[PyGame] I found a way to generate sprites without .blit. Is it effecient?

[xBlackHeartx]

I lost interest in coding with pygame for a while after I realized that I would need some type of pixel art program for future projects. Planning it out, I quickly realized that such a program would be far more complex than anything I had made before. I would literally have to figure out how to do dozens of things just to make this one program, which was excessive.

However, while watching a video by the 8-bit guy (a youtuber that talks about 80s computers), I was inspired and realized that I could write an algorithm that could generate sprites WITHOUT having to use image files!

Here is the code I came up with:

import pygame
pygame.init()

mainWindow=pygame.display.set_mode((500,500))

#position of sprite
x=200
y=250
#size of pixels in screen pixels
pixel=10

#binary data used to generate sprite
row1=[0,0,0,1,1,0,0,0]
row2=[0,0,1,1,1,1,0,0]
row3=[0,1,1,1,1,1,1,0]
row4=[1,1,0,1,1,0,1,1]
row5=[1,1,1,1,1,1,1,1]
row6=[0,0,1,0,0,1,0,0]
row7=[0,1,0,1,1,0,1,0]
row8=[1,0,1,0,0,1,0,1]

sprite=row1+row2+row3+row4+row5+row6+row7+row8

#function that renders sprite based on binary sequence
def makeSprite():
    pixelx=x
    pixely=y

    for a in sprite:
        if a==1:
            pygame.draw.rect(mainWindow, (white),(pixelx,pixely,pixel,pixel))
        pixelx=pixelx+pixel
        if (pixelx-x)%80==0:
            pixelx=x
            pixely=pixely+pixel

#main loop so that sprite can be moved using arrow keys
def main():
    global x
    global y
    while True:
        pygame.time.delay(100)

        for event in pygame.event.get():
            if event.type==pygame.QUIT:
                pygame.quit()
                quit()
        key=pygame.key.get_pressed()
        if key[pygame.K_UP]:
            y=y-pixel
        if key[pygame.K_DOWN]:
            y=y+pixel
        if key[pygame.K_RIGHT]:
            x=x+pixel
        if key[pygame.K_LEFT]:
            x=x-pixel

        mainWindow.fill((0,0,0))
        makeSprite()
        pygame.display.update()

main()

What this program is supposed to do is generate a sprite that looks like one of the aliens from space invaders. You can move the sprite around the screen using the arrow keys.

Besides not needing a way to actually make proper image files, I see a number of advantages to this. For one, it would be really easy to make other algorithms that can flip or rotate the sprite, thus giving me more control over them. I also don't need to have a bunch of loose image files laying around (note that I have yet to figure out how to compile my programs). Also, it makes achieving transparency easier. Instead of telling the program to just ignore certain colors, with my algorithm it just skips over to the next pixel as it draws the sprite pixel by pixel, completely removing the need to have code in there to create transparency.

The only downside I can see to making sprites this way is that its kinda hard to figure out the binary sequence you need to type in to make a sprite. You'll notice that I implemented each row of the sprite as a separate list and had the program just combine them into a single list. I tried to type it out as one long list, but I quickly got lost and decided to do it this way hoping it would give me an idea of what the resulting sprite would look like, which it didn't sadly, but it still made it easier for me to keep track of which row I was typing in. Obviously, doing a larger sprite (such as a 16x16) would require a lot of typing, but for that I could just map out the thing on graph paper to make it easier for me to figure out the binary sequence I need to type in. Another small issue is that the color palette would have to be limited if I wanted to keep each entry in the list one digit (if I use both numbers and letters, I could in theory have 35 colors). Honestly, I don't mind this much. I find the number of colors available to me overwhelming and unnecessary. Also, I want to make retro-style games, so the limited color palette doesn't exactly bother me at all.

Of course, I don't know what effect this would have on how much processing power my games would require. I've noticed that my snake clone takes up an insane amount of my RAM, but that may just be because its having to interpret my code on the fly since I haven't figured out a way to actually compile anything.

Is there any other fundamental difference to generating sprites this way rather than through the .blit command? Either way, I'll probably be relying on it for a while until I get advanced enough where I can make my own ideal pixel art program.