Pixels are small pixies with paint brushes, which read the values in the memory and paint them using pixie magic.

More likely: it uses a digital to analogue convertor to change binary values to voltages which are then sent to the LCD R, G and B channels (or the raster beam in a CRT monitor) which corresponds to a brightness value for the channel. Alpha doesn't exist on the actual display, it's just used by the GPU to blend colour values.

Not sure i understand the question perfectly, but take a look at this. This is the visual representation of a single RGBA pixel. Nowadays, computer (and programmers) love working with byte, which is a group of 8 bits, because let's face it, you can't do much with only 0 and 1. So, each color, red, green and blue take 1 byte, or 8 bits, which mean it can have any value between 0 and 255. But computer language also define integers, which are typically 4 bytes long, or 32 bits, thus giving a possible value between 0 and 4294967295 (or -2147483648 to 2147483647) depending if the value is signed or not. That way we can use value bigger than 255, like the x and y coordinate you where talking about.

Now, let say you're screensize is 1360x768 with 32 bit colors, that mean it take 1360x768x4 bytes to store that information, that's 4177920 bytes. All that information is generally stored in a linear array, one byte after the other. Let say you want to allocate a buffer for a 24 bits image that is 1000x1000 pixels large, in c++, you would do something like that:

// create a structure to hold 1 pixel data
struct RGB {
    BYTE r, g, b;
};

// some usefull constants
int Width = 1000;
int Height = 1000;
int NumPixels = Width * Height;

// Allocate a buffer large enough to store pixels into
RGB *pBuffer = new RGB[NumPixels];

// Fill them with random values
for(int i = 0; i < NumPixels; i++){
    pBuffer[i].r = rand() % 256;     // this assign a value between 0 and 255 to each byte in the image
    pBuffer[i].g = rand() % 256;     // that's 16777216 possible colors per pixels (256*256*256)
    pBuffer[i].b = rand() % 256;
}

// now, let say we want to access the pixel 100,50 (x=100, y=50) and set it completly red ...
int x = 50;
int y = 100;
int Indx = (x * Width) + y; // basic formula for transforming a 2d coordinate point into a 1d coordinate (linear)

pBuffer[Indx].r = 255;
pBuffer[Indx].g = 0;
pBuffer[Indx].b = 0;

Hope that help!

EDIT: other good read: link, link, link

First, the pixel itself, contains 8 bytes (lets ignore alpha), each with 8 bits.

Each bit is like a digit in our base 10 number system, addition and all work the same (eg. if you increment a digit by 1 and it goes over the "limit", you set it to 0 and increment the next digit)

eg.

binary:

001: + 001

decimal:

001 + 009

VVVVVVVVV

binary:

010

decimal:

010

So basically you have a structure like (0-255,0-255,0-255), each value telling the amount of that color. Using combinations of these colors the monitor can create any color for the single pixel.

Now, next the position.

On the GPU, we have as a result of all the processing a huge array of the above mentioned RGB colors, next to each other in memory. The size of the array is width*height of the screen, to have the correct amount of pixels.

You could imagine the drawing process as going through the pixels one by one, and writing it to the corresponding pixel on the screen.

For example, you could imagine that the screen also contains a width*height array of pixels, each of which is hard wired to the physical pixel on the screen. Then it would just be a matter of copying the pixel array from the GPU to the screens memory. Probably not how it actually works but it could be one way.

If you want to know how, on the transistor level, it is possible to index some byte in the memory given another byte representing the position, it could be implemented as a hierarchy.

If you have a tree where each node splits to 2 subnodes, and have 8 levels, this gives you 256 units of memory (bottommost nodes). To access this using a byte (8 bits) you would take the first bit to decide which subnode to go to from the root node, then use the second bit to decide where to turn next etc. until you reach the bottom level.