Vill du skriva ditt första spel men vet inte var du ska börja med spelutveckling? Pygame river den barriären. Du skriver i ren Python och ser omedelbart resultatet på skärmen: en sprite som rör sig, tangentbordsinput som svarar, levande mekanik. Inga tunga motorer, inga tusentals rader boilerplate-kod.

Problemet med de flesta tutorials är att de antingen begraver dig i 40 sidor teori eller lämnar dig med "gör klart det själv". Här tar vi en medelväg: förklarar precis tillräckligt så att du förstår varje rad, och bygger direkt ett fungerande spel med en karaktär som rör sig över skärmen med WASD. Hela koden ryms på 60 rader.

💡 Snabb översikt:

• Installera Pygame via pip och skapa en spelfil, det tar ett par minuter
• Förstå spelloopen: händelser, beräkningar, rendering, tre faser som lever i en oändlig while True
• Skriv en spelarklass och väck den till liv: WASD-tangenterna flyttar spriten, skärmen ritas om 60 gånger per sekund
• Förstå koordinatsystemet och färghantering, två hörnstenar som bär upp all 2D-grafik

Vad är Pygame och varför välja det

Pygame är ett bibliotek för Python som slår in multimediabiblioteket SDL (Simple DirectMedia Layer) i ett bekvämt Python-API. SDL hanterar grafik på låg nivå, ljud och inmatningsenheter, medan Pygame ger åtkomst via välbekanta klasser och metoder. Den aktuella versionen, 2.6.0, underhålls aktivt och fungerar på Windows, macOS och Linux.

För nybörjare har Pygame tre obestridliga fördelar. För det första, låg tröskel: du använder vanlig Python-kod, inget nytt språk eller visuell editor. För det andra, omedelbar feedback: du skriver pygame.draw.rect(...) och en rektangel dyker upp på skärmen, ingen magi. För det tredje, förstå grunden: Pygame döljer inte spelloopen och händelsekön för dig, du ser hur vilket spel som helst fungerar inuti. Efter Pygame blir det lättare att gå över till Godot eller Unity eftersom du redan vet vad delta time och event polling är.

Biblioteket försöker inte vara en spelmotor. Det har inget scensystem, ingen fysik och ingen inbyggd leveleditor, och det är ett medvetet beslut. Du kontrollerar varje pixel och varje tick, vilket innebär att du lär dig tänka som en spelutvecklare, inte som en operatör av någon annans verktyg.

Installera Pygame på två minuter

Har du redan Python 3.9 eller nyare? Öppna då en terminal och kör ett kommando:

1
pip install pygame

För projektisolering är det bättre att skapa en virtuell miljö:

1
python -m venv game_env
2
game_env\Scripts\activate     # Windows
3
source game_env/bin/activate  # macOS / Linux
4
pip install pygame

Kontrollera att biblioteket är installerat:

1
import pygame
2
print(pygame.version.ver)

Om du får 2.6.0 som svar (eller nyare, du kan kolla aktuell version på pygame.org), är du redo. Skapa en projektmapp, lägg en valfri sprite-bild på 80×80 pixlar med namnet player.png i den, och en textfil game.py, vi börjar med det.

Hur spelloopen fungerar: händelser, beräkningar, rendering

Hjärtat i varje spel är huvudloopen. Medan spelet körs, inuti en oändlig while True, avlöser tre faser varandra:

• Händelsehantering, vad hände sedan förra bildrutan? Tangent nedtryckt? Musen rörd? Fönster stängt? Pygame samlar alla händelser i en kö, och vi itererar genom den med for event in pygame.event.get().

• Logikberäkning, hur förändrades världen som svar på händelser? Spelaren tryckte W, öka Y-koordinaten. Kula kolliderade med asteroid, markera båda för borttagning.

• Rendering, rita allt som ska vara på skärmen. Fyll bakgrunden, placera sprites på nya koordinater, anropa pygame.display.update(), och spelaren ser en bildruta.

Dessa tre steg upprepas 60 gånger per sekund, exakt den bildfrekvens (FPS) vi ställer in på timern. Illusionen av rörelse bygger på att spriten förflyttas ett par pixlar mellan bildrutorna, medan ögat uppfattar detta som kontinuerlig animation.

Skriva första koden: flytta en sprite över skärmen

Här är den kompletta spelkoden. Spara den som game.py och placera player.png i samma mapp:

1
#!/usr/bin/env python3
2
 
3
import pygame
4
import sys
5
 
6
WIDTH, HEIGHT = 360, 480
7
WHITE = (255, 255, 255)
8
 
9
class Player(pygame.sprite.Sprite):
10
 
11
    def __init__(self, image_path):
12
        super().__init__()
13
        self.image = pygame.image.load(image_path)
14
        self.x = WIDTH / 2
15
        self.y = HEIGHT / 2
16
        self.speed = 5
17
 
18
    def move(self, dx, dy):
19
        self.x += dx
20
        self.y += dy
21
 
22
def main():
23
    pygame.init()
24
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
25
    pygame.display.set_caption("First Game on Pygame")
26
 
27
    clock = pygame.time.Clock()
28
    fps = 60
29
 
30
    player = Player("player.png")
31
    dx, dy = 0, 0
32
 
33
    running = True
34
    while running:
35
        for event in pygame.event.get():
36
            if event.type == pygame.QUIT:
37
                running = False
38
 
39
            elif event.type == pygame.KEYDOWN:
40
                if event.key == pygame.K_d:
41
                    dx = player.speed
42
                elif event.key == pygame.K_a:
43
                    dx = -player.speed
44
                elif event.key == pygame.K_w:
45
                    dy = -player.speed
46
                elif event.key == pygame.K_s:
47
                    dy = player.speed
48
 
49
            elif event.type == pygame.KEYUP:
50
                if event.key in (pygame.K_d, pygame.K_a):
51
                    dx = 0
52
                elif event.key in (pygame.K_w, pygame.K_s):
53
                    dy = 0
54
 
55
        player.move(dx, dy)
56
        screen.fill(WHITE)
57
        screen.blit(player.image, (player.x, player.y))
58
        pygame.display.update()
59
        clock.tick(fps)
60
 
61
    pygame.quit()
62
    sys.exit()
63
 
64
if __name__ == "__main__":
65
    main()

Kör python game.py, ett fönster med vit bakgrund och din sprite i mitten öppnas. Håll ned W, A, S eller D, karaktären rör sig. Släpp tangenten, den stannar. Detta är redan ett riktigt spel, om än minimalt.

Vad som är förbättrat jämfört med klassiska tutorials: KEYUP-hanterare är tillagd för tangentuppsläpp. Utan den skulle spriten försvinna från skärmen för alltid efter första nedtryckningen. Och koden är inlindad i konstruktionen if __name__ == "__main__", en god praxis som tillåter import av filen som en modul utan att starta spelet.

Koordinatsystem och färghantering

I Pygame räknas koordinater från övre vänstra hörnet: (0, 0), allra längst upp till vänster. Att röra sig åt höger ökar X, att röra sig nedåt ökar Y. Detta skiljer sig från skolans koordinatsystem där Y växer uppåt, kom bara ihåg det och kontrollera dig själv under de första två körningarna: tryckte S, sprite flyttades ned, tryckte W, upp.

Färg anges av en tupel med tre tal (R, G, B), vardera från 0 till 255. Vitt motsvarar (255, 255, 255), svart motsvarar (0, 0, 0), rött motsvarar (255, 0, 0). Metoden screen.fill(WHITE) fyller hela skärmen med den valda färgen före rendering av varje bildruta. Om du inte gör detta kommer spriten att lämna ett spår av tidigare positioner.

Vad som händer under huven: rad för rad-genomgång

Klassen Player ärver från pygame.sprite.Sprite, Pygames inbyggda klass för spelobjekt. I konstruktorn laddar vi bilden via pygame.image.load() och sätter startpositionen i skärmens mitt: WIDTH / 2 och HEIGHT / 2. Metoden move(dx, dy) tar emot förskjutning och adderar den till aktuella koordinater, ren aritmetik, ingen magi.

Funktionen main() sammanför allt. pygame.init() startar interna delsystem. pygame.display.set_mode() skapar ett fönster, och screen är en Surface vi ritar på. pygame.time.Clock() skapar en timer: dess tick(fps)-metod i slutet av loopen säger till Pygame "vänta tills 1/60 sekund har gått sedan förra bildrutan", så här fixerar vi bildfrekvensen och slösar inte CPU.

Huvudloopen while running snurrar tills flaggan running blir False. Inuti, de tre faserna vi pratade om ovan:

I loopen for event in pygame.event.get() avläser vi händelsekön. pygame.QUIT är signalen "användaren klickade på stäng-knappen i fönstret": sätt running = False, och vid nästa iteration avslutas loopen. pygame.KEYDOWN utlöses när en tangent trycks ned, och KEYUP när den släpps. För D och A ändrar vi dx, för W och S ändrar vi dy. När tangenten släpps nollställer vi motsvarande hastighetskomponent, spriten stannar.

screen.blit(player.image, (player.x, player.y)), metoden som "lägger över" en bild på en annan. I vårt fall, spelarspriten på huvudskärmytan vid aktuella koordinater. pygame.display.update() uppdaterar fönstret, och spelaren ser den färdiga bildrutan.

Notera: player.move() anropas före screen.fill(). Om du byter plats på dem raderas spriten samma millisekund den dyker upp, du ser den helt enkelt inte på skärmen. Ordningen på operationer i spelloopen är kritisk.

Klicka på stäng-knappen, pygame.quit() avlastar Pygames delsystem korrekt, och sys.exit() avslutar Python-processen. Utan pygame.quit() kan fönstret frysa vid stängning, en liten detalj, men kod ska vara ren.

Kort video om ämnet

Om textinstruktionen inte riktigt klickar, här är en utmärkt videokurs på engelska där de bygger Space Invaders i Pygame steg för steg. Alla koncept från artikeln visas live:

⁉️🤔 Vanliga frågor

Behöver jag kunna OOP för Pygame?

Ja, på grundläggande nivå. Klasser, metoder, arv och self behöver du från dag ett: spelare, fiender, kulor och bonusar passar naturligt in i en objektmodell. Om du har gått någon introduktionskurs i Python som förklarade class och __init__, räcker det. Resten lär du dig efter hand: Pygame kräver inga designmönster, vanligt arv från Sprite räcker för dussintals prototyper. Ett spelobjekt i Pygame är en klass som ärver från pygame.sprite.Sprite. I konstruktorn laddar du spriten via pygame.image.load(), sätter initiala koordinater och hastighet. Metoden update() (eller din egen, som move()) ändrar position varje bildruta. Huvudloopen anropar update() på alla objekt, renderar dem sedan via screen.blit(). Ingen magi, bara metodanrop i rätt ordning 60 gånger per sekund.

Blir Pygame långsamt med komplex 2D-grafik?

Med ett rimligt antal sprites, nej. Surfaces i Pygame lever i RAM, och blit är snabb pixelkopiering, inte mjukvarurendering. Med tusen samtidigt rörliga objekt kan du nå Pythons prestandagräns, men för ett plattformsspel, top-down shooter eller tower defense finns marginal. Om du behöver pressa ut maximal prestanda, använd pygame.sprite.Group med automatisk rendering och dirty rectangles för partiella skärmuppdateringar.

Kan jag lägga till ljud och musik i Pygame?

Ja, direkt ur lådan. Modulen pygame.mixer kan spela WAV och MP3. Ett pistolskottsljud startas via pygame.mixer.Sound("shoot.wav").play(), och bakgrundsmusik laddas via pygame.mixer.music.load("theme.mp3") och pygame.mixer.music.play(-1) (flaggan -1 loopar den). Enda haken: pygame.mixer.init() måste anropas innan ljud laddas, och för MP3 på Linux kan du behöva biblioteket libmpg123.

Är det någon mening att lära sig Pygame 2026 när Godot och Unity finns?

Absolut. Pygame är inte en Godot-konkurrent, det är ett pedagogiskt verktyg och ett lättviktslager för 2D-prototyper. Du lär dig inte C# bara för att flytta en kvadrat, och du klurar inte ut nodsystemet för Pong. Pygame ger dig en förståelse för hur spel fungerar på en lägre nivå: spelloop, frame-buffring, kollisioner. Programmerare som började med Pygame har lättare för Unity och Godot eftersom de ser den levande mekaniken bakom motorns abstraktioner. Riktiga indieprojekt skrivs i Pygame, inklusive kommersiella, ett litet plattformsspel eller pussel kan släppas på Steam utan att röra C++.

Vad gör jag om spriten åker utanför skärmen?

Lägg till gränskontroll i move()-metoden: om self.x < 0, sätt den till 0; om self.x + sprite_width > WIDTH, sätt den till WIDTH - sprite_width. Samma för Y. Detta kallas clamping, och utan det kommer karaktären så småningom att försvinna till ett osynligt område. I mer avancerade spel är gränser nivåväggar definierade via ett tile-rutnät eller en kollisionsarray.

Redo att starta ditt första spel?

Kopiera koden från avsnittet "Skriva första koden", spara den som game.py, placera en valfri sprite-bild bredvid, och inom några sekunder ser du ett fönster med en rörlig karaktär. Detta är ingångspunkten till spelutveckling: inte att läsa, utan att starta och börja justera parametrar.

Ändra WIDTH och HEIGHT, fönstret blir större. Sätt player.speed = 10, karaktären blir snabbare. Byt ut WHITE mot (35, 35, 35), du får en mörk bakgrund. Experimentera, så förstår du att ett spelprogram inte är magi, utan en sekvens av steg du kontrollerar.

När du har bemästrat rörelse, ta itu med kollisioner (pygame.sprite.collide_rect()), animation (byte av rutor i sprite sheet) och procedurell nivågenerering. För att börja räcker en game.py-fil och viljan att förstå hur det fungerar.