Sprites
The Building Blocks of Every Game Object

What Are Sprites, and the Sprite Class

A sprite is just Pygame's name for any visual game object — the player, an enemy, a bullet, a coin. Rather than juggling a separate image variable and Rect for every object by hand, Pygame provides pygame.sprite.Sprite, a base class you inherit from. Every sprite subclass needs exactly two attributes: self.image (a Surface — what gets drawn) and self.rect (a Rect — where it's drawn and where collisions are tested).

By convention, all your setup logic goes in __init__, and any per-frame behavior — movement, animation, state changes — goes in an update() method that Pygame's Group system will call automatically every frame.

import pygame

class Player(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.image = pygame.Surface((40, 60))
        self.image.fill((52, 211, 153))
        self.rect = self.image.get_rect(center=(x, y))
        self.speed = 5

    def update(self):
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            self.rect.x -= self.speed
        if keys[pygame.K_RIGHT]:
            self.rect.x += self.speed

Sprite Groups: Updating and Drawing at Scale

A pygame.sprite.Group is a container that holds any number of sprites and gives you two extremely powerful one-line operations: group.update() calls update() on every sprite inside it, and group.draw(screen) blits every sprite's .image at its .rect position onto the screen. This replaces dozens of individual update/draw calls with two lines, no matter how many objects the group holds.

import pygame

pygame.init()
screen = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()

all_sprites = pygame.sprite.Group()
player = Player(400, 300)
all_sprites.add(player)

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    all_sprites.update()          # calls update() on every sprite

    screen.fill((15, 20, 35))
    all_sprites.draw(screen)      # blits every sprite's image at its rect
    pygame.display.flip()
    clock.tick(60)

pygame.quit()

You can add a sprite to multiple groups at once — a common pattern is one all_sprites group for drawing everything, plus smaller category groups like enemies or bullets used only for collision checks. Removing a sprite from every group it belongs to is as simple as calling sprite.kill().

Sprite Layers: Controlling Draw Order

A regular Group draws sprites in the order they were added, which is fine until you need the background drawn behind the player and the UI drawn in front of everything. pygame.sprite.LayeredUpdates solves this by letting each sprite carry a _layer attribute (or an explicit layer argument on add()) that controls draw order regardless of insertion order.

all_sprites = pygame.sprite.LayeredUpdates()

all_sprites.add(background_sprite, layer=0)
all_sprites.add(player, layer=1)
all_sprites.add(hud_sprite, layer=2)

# Drawing respects layer order regardless of add() order
all_sprites.draw(screen)

Sprite Sheets: Slicing One Image Into Many Frames

Loading a separate PNG for every animation frame is wasteful. Instead, artists typically pack all frames into one sprite sheet — a single image laid out in a grid — and you slice individual frames out at load time using Surface.subsurface() or blit with a source rect. Once sliced, each frame becomes a normal Surface you can store in a list.

def load_frames(sheet_path, frame_w, frame_h, frame_count):
    sheet = pygame.image.load(sheet_path).convert_alpha()
    frames = []
    for i in range(frame_count):
        rect = pygame.Rect(i * frame_w, 0, frame_w, frame_h)
        frame = sheet.subsurface(rect).copy()
        frames.append(frame)
    return frames

# A sheet with 6 frames, each 64x64 pixels, laid out left-to-right
walk_frames = load_frames("player_walk.png", 64, 64, 6)

Slicing at load time (once) rather than every frame keeps performance high — you pay the cost of cutting the sheet apart a single time, then just swap which pre-sliced Surface is assigned to self.image during animation.

Animated Sprites and Character States

An animated sprite stores a list of frames per state (idle, walking, jumping), tracks the current frame index and a timer, and swaps self.image as time passes inside its own update() method. The character's current state — a simple string like "idle" or "walk" — determines which frame list is active, so switching states automatically switches animations.

class Enemy(pygame.sprite.Sprite):
    def __init__(self, frames_by_state, x, y):
        super().__init__()
        self.frames_by_state = frames_by_state
        self.state = "idle"
        self.frame_index = 0
        self.anim_timer = 0
        self.image = self.frames_by_state[self.state][0]
        self.rect = self.image.get_rect(center=(x, y))

    def update(self):
        self.anim_timer += 1
        if self.anim_timer >= 8:  # advance frame every 8 game ticks
            self.anim_timer = 0
            frames = self.frames_by_state[self.state]
            self.frame_index = (self.frame_index + 1) % len(frames)
            self.image = frames[self.frame_index]

Sprite Project: Put It All Together

Build one small scene combining every concept from this module: a Player sprite class with idle/walk states loaded from a sliced sprite sheet, added to an all_sprites LayeredUpdates group alongside a background sprite (layer 0) and a few enemy sprites (layer 1). Call all_sprites.update() and all_sprites.draw(screen) once per frame and confirm draw order and animation both behave correctly.

Sprite Sheet Frame Indexing

The load_frames() slicer from Section 4 walks a sprite sheet in reading order — left to right, then down a row — assigning each slice a numeric index starting at 0. An animation timer then just swaps self.image to frames[frame_index], so knowing exactly which square holds which index is the key to debugging animation glitches.