• Articles
  • Tutorials
  • Interview Questions

Introduction to Pygame in Python: A Game Development Library

Introduction to Pygame in Python: A Game Development Library
Tutorial Playlist

Pygame, a game development library for the Python programming language, provides a gateway to creating captivating interactive experiences. Before diving in, there are a few prerequisites to this. Familiarity with Python programming basics, including variables, data types, control structures, and functions, is essential. Additionally, a grasp of object-oriented programming concepts will be advantageous. With these foundations, developers can embark on an exciting journey of unleashing their creativity, and crafting immersive games using Pygame.

Appendix:

Watch this video to learn the basics of Pygame and start coding your own games today!

What is Pygame in Python?

Pygame is a Python library specifically designed to develop 2D video games and multimedia applications. It provides extensive tools and functions that allow programmers to create interactive and visually appealing games easily. Pygame has become popular among developers because of its simplicity, versatility, and active community support as an open-source framework.

What is Pygame in Python?
  • Pygame uses the Simple DirectMedia Layer (SDL), a cross-platform development library, to grant developers direct access to computer hardware components like graphics, sound, and input devices. 
  • This functionality empowers developers to build games that operate seamlessly on various platforms such as Windows, Mac, Linux, and even mobile devices.
  • Pygame empowers developers to manage different elements of game development effortlessly, such as graphics rendering, event handling, collision detection, animation, sound effects, and music playback. 
  • This library offers many functions and classes specifically designed to simplify these tasks, freeing up programmers to concentrate on game logic and design rather than being burdened by intricate low-level intricacies.
  • Pygame’s simplicity lies in its intuitive and straightforward API, which makes it accessible to both beginners and experienced developers. 
  • Its extensive documentation and numerous online resources provide a supportive learning environment where developers can quickly grasp and implement the concepts in their projects.
  • Pygame’s versatility extends beyond game development. Its multimedia capabilities enable the creation of applications involving image and video processing, simulations, educational tools, and more. 
  • It makes Pygame a valuable asset for programmers exploring various domains beyond gaming.

Start coding today with our beginner-friendly Python course!

How to Install Pygame?

Follow the steps below to install Pygame on your system, empowering you to effortlessly develop captivating games.

How to install Pygame

Step 1: Install Python: Before installing Pygame, ensure that Python is installed on your system. Visit the official Python website (python.org) and download the latest stable version compatible with your operating system. Follow the installation instructions provided and verify that Python is properly installed by running “python –version” in your terminal or command prompt.

Step 2: Install Pygame: To install Pygame, you need to use a package manager such as pip, which is commonly bundled with Python installations. Run your terminal or command prompt and execute the following command: “pip install pygame“. The command will download and install the latest stable version of Pygame from the Python Package Index (PyPI).

Step 3: Verify the Installation: Run a simple test script to confirm that Pygame is installed correctly. Create a new file in Python and import the Pygame module by adding the line “import pygame”. Save the file with a “.py” extension and execute it. If no errors occur, Pygame is successfully installed. Hello World for pygame:

import pygame, sys
from pygame.locals import *
pygame.init()
DISPLAYSURF = pygame.display.set_mode((400, 300))
pygame.display.set_caption('Hello World!')
while True: # main game loop
    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
    pygame.display.update()

Learn how to use Machine Learning in Python with this Machine Learning Tutorial!

Get 100% Hike!

Master Most in Demand Skills Now !

What are the Components of Pygame?

Understanding the key components of Pygame is vital for successfully leveraging its capabilities in game development. By familiarizing yourself with the Pygame module, display surface, sprites, surfaces, event handling, sound and music, and collision detection, you gain the necessary tools to create engaging and immersive games. 

Continuously exploring and experimenting with these components will allow you to unlock the full potential of Pygame in bringing your game ideas to life.

What are the Components of Pygame?
  • Pygame Module: The Pygame module acts as the building block for game development, encompassing a range of capabilities. It facilitates tasks such as game window management, event handling (including keyboard and mouse input), and screen graphics rendering. By incorporating the Pygame module into your code, you unlock the potential to leverage these fundamental features.
  • Display Surface: The display surface holds great significance in Pygame as it represents the window or screen where your game is showcased. It serves as a canvas for rendering objects, images, and animations, creating a graphical environment for your game. Pygame offers functions to create and handle the display surface, granting you control over its dimensions, title, and additional properties.
  • Sprites: Sprites are essential elements in game development, representing characters, objects, or entities within the game world. Pygame simplifies sprite management by offering the Sprite class, which provides a convenient way to create, update, and render sprites on the screen. Sprites can have attributes such as position, size, and image representation, and Pygame provides collision detection functionality to handle interactions between sprites.
  • Surface: Surfaces in Pygame serve the purpose of displaying graphics, such as images, shapes, and text. They represent rectangular pixel areas that can be manipulated to generate visual elements within your game. Pygame offers the flexibility to load images from diverse file formats and convert them into surfaces that can be shown on the screen. Surfaces have the ability to draw shapes, apply transformations, and render text with a variety of fonts.
  • Event Handling: Event handling in Pygame simplifies the process of detecting and responding to user interactions, including keyboard and mouse inputs. By utilizing the event module provided by Pygame, you can capture events such as key presses, mouse clicks, and window resizing. This functionality empowers you to create interactive games that dynamically respond to user actions, facilitating the implementation of gameplay mechanics and user interfaces.
  • Sound and Music: Audio is integral to many games, and Pygame offers functionalities for playing and manipulating sounds and music. The mixer module in Pygame allows you to load and play sound effects and background music, control their volume, and apply effects like fading. This feature enables you to enhance the immersive experience of your games through rich audio elements.
  • Collision Detection: Collision detection is a critical aspect of game development, and Pygame provides built-in mechanisms to detect collisions between sprites and other game objects. Using collision detection functions, you can detect and respond to collisions, implement gameplay mechanics like scoring, and create realistic interactions between objects in your game world.

Intellipaat is providing free Python Interview Questions and Answers, which will help you excel in your career!

Snake Game using Pygame

We have already covered the installation of Pygame in a Windows system. Now it’s time to create a demo game from scratch using Pygame in Python. 

Snake Game using Pygame
  • Pygame Installations

The initial step in creating games with Pygame entails the installation of the framework on your systems. This can be accomplished by executing the subsequent command:

pip install pygame
  • Screen creation of the Pygame

Using Pygame, first, you should use the display.set_mode() function to build the screen. Additionally, you must use the init() and stop() methods to initialize and un-initialize everything at the beginning and end of the code, respectively. Any changes made to the screen are updated using the update() function. Another method, flip(), performs operations equivalent to update(). The update() function updates only the changes that have been made, whereas the flip() method redoes the entire screen. If no arguments are supplied, the complete screen is updated.

import pygame
pygame.init()
dis=pygame.display.set_mode((400,300))
pygame.display.update()
pygame.display.set_caption('Snake game by Intellipaat')
game_over=False
while not game_over:
    for event in pygame.event.get():
        print(event)   #prints out all the actions that take place on the screen
 
pygame.quit()
quit()
  • Code to create the snake

In order to color the snake, food, screen, etc., before actually making the snake, you must first establish a few color variables. Pygame uses the RGB color scheme, which stands for “Red, Green, and Blue.” The color will be black, and all 255 values will be white if you set them all to 0. So, in reality, our snake will be a rectangle. When drawing rectangles in Pygame, you may use the draw.rect() method, which will let you specify the color and size of the rectangle.

pygame.display.set_caption('Snake game by Intellipaat')
 
blue=(0,0,255)
red=(255,0,0)
 
game_over=False
while not game_over:
    for event in pygame.event.get():
        if event.type==pygame.QUIT:
            game_over=True
    pygame.draw.rect(dis,blue,[200,150,10,10])
    pygame.display.update()
pygame.quit()
quit()
  • Code for snake movement

You must take advantage of the Pygame KEYDOWN class’s key events in order to move the snake. Here, the events K_UP, K_DOWN, K_LEFT, and K_RIGHT are employed to cause the snake to move up, down, left, and right, respectively. The fill() technique also alters the display screen’s default black to white.
To store the updated values of the x and y coordinates, you have to declare two new variables, x1_change and y1_change.

import pygame
 
pygame.init()
 
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
 
dis = pygame.display.set_mode((800, 600))
pygame.display.set_caption('Snake Game by Intellipaat')
 
game_over = False
 
x1 = 300
y1 = 300
 
x1_change = 0       
y1_change = 0
 
clock = pygame.time.Clock()
 
while not game_over:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game_over = True
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                x1_change = -10
                y1_change = 0
            elif event.key == pygame.K_RIGHT:
                x1_change = 10
                y1_change = 0
            elif event.key == pygame.K_UP:
                y1_change = -10
                x1_change = 0
            elif event.key == pygame.K_DOWN:
                y1_change = 10
                x1_change = 0
 
    x1 += x1_change
    y1 += y1_change
    dis.fill(white)
    pygame.draw.rect(dis, black, [x1, y1, 10, 10])
 
    pygame.display.update()
 
    clock.tick(30)
 
pygame.quit()
quit()
  • Conditions for game over

The player loses in this snake game if he reaches the screen’s edges. You have to use a ‘if’ statement to establish the boundaries for the snake’s x and y coordinates to be less than or equal to the screen’s coordinates in order to express that. 

import pygame
import time
pygame.init()
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
dis_width = 800
dis_height  = 600
dis = pygame.display.set_mode((dis_width, dis_width))
pygame.display.set_caption('Snake Game by Intellipaat')
game_over = False
x1 = dis_width/2
y1 = dis_height/2
snake_block=10
x1_change = 0
y1_change = 0
clock = pygame.time.Clock()
snake_speed=30
font_style = pygame.font.SysFont(None, 50)
 def message(msg,color):
    mesg = font_style.render(msg, True, color)
    dis.blit(mesg, [dis_width/2, dis_height/2])
 while not game_over:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game_over = True
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                x1_change = -snake_block
                y1_change = 0
            elif event.key == pygame.K_RIGHT:
                x1_change = snake_block
                y1_change = 0
            elif event.key == pygame.K_UP:
                y1_change = -snake_block
                x1_change = 0
            elif event.key == pygame.K_DOWN:
                y1_change = snake_block
                x1_change = 0
    if x1 >= dis_width or x1 < 0 or y1 >= dis_height or y1 < 0:
        game_over = True
    x1 += x1_change
    y1 += y1_change
    dis.fill(white)
    pygame.draw.rect(dis, black, [x1, y1, snake_block, snake_block])
     pygame.display.update()
    clock.tick(snake_speed)
 message("You lost",red)
pygame.display.update()
time.sleep(2)
pygame.quit()
quit()
  • Code to add food for the snake
import pygame
import time
import random
 pygame.init()
 white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
blue = (0, 0, 255)
 dis_width = 800
dis_height = 600
 dis = pygame.display.set_mode((dis_width, dis_height))
pygame.display.set_caption('Snake Game by Edureka')
 clock = pygame.time.Clock()
snake_block = 10
snake_speed = 30
 font_style = pygame.font.SysFont(None, 30)
def message(msg, color):
    mesg = font_style.render(msg, True, color)
    dis.blit(mesg, [dis_width/3, dis_height/3])
def gameLoop():  # creating a function
    game_over = False
    game_close = False
     x1 = dis_width / 2
    y1 = dis_height / 2
     x1_change = 0
    y1_change = 0
     foodx = round(random.randrange(0, dis_width - snake_block) / 10.0) * 10.0
    foody = round(random.randrange(0, dis_width - snake_block) / 10.0) * 10.0
     while not game_over:
        while game_close == True:
            dis.fill(white)
            message("You Lost! Press Q-Quit or C-Play Again", red)
            pygame.display.update()
             for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_q:
                        game_over = True
                        game_close = False
                    if event.key == pygame.K_c:
                        gameLoop()
         for event in pygame.event.get():
            if event.type == pygame.QUIT:
                game_over = True
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    x1_change = -snake_block
                    y1_change = 0
                elif event.key == pygame.K_RIGHT:
                    x1_change = snake_block
                    y1_change = 0
                elif event.key == pygame.K_UP:
                    y1_change = -snake_block
                    x1_change = 0
                elif event.key == pygame.K_DOWN:
                    y1_change = snake_block
                    x1_change = 0
         if x1 >= dis_width or x1 < 0 or y1 >= dis_height or y1 < 0:
            game_close = True
         x1 += x1_change
        y1 += y1_change
        dis.fill(white)
        pygame.draw.rect(dis, blue, [foodx, foody, snake_block, snake_block])
        pygame.draw.rect(dis, black, [x1, y1, snake_block, snake_block])
        pygame.display.update()
         if x1 == foodx and y1 == foody:
            print("Yummy!!")
        clock.tick(snake_speed)
     pygame.quit()
    quit()
 gameLoop()
  • Code to increase the length of the snake
import pygame
import time
import random
 pygame.init()
 white = (255, 255, 255)
yellow = (255, 255, 102)
black = (0, 0, 0)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
 dis_width = 600
dis_height = 400
 dis = pygame.display.set_mode((dis_width, dis_height))
pygame.display.set_caption('Snake Game by Intellipaat')
 clock = pygame.time.Clock()
 snake_block = 10
snake_speed = 15
 font_style = pygame.font.SysFont("bahnschrift", 25)
score_font = pygame.font.SysFont("comicsansms", 35)
 def our_snake(snake_block, snake_list):
    for x in snake_list:
        pygame.draw.rect(dis, black, [x[0], x[1], snake_block, snake_block])
 def message(msg, color):
    mesg = font_style.render(msg, True, color)
    dis.blit(mesg, [dis_width / 6, dis_height / 3])
  def gameLoop():
    game_over = False
    game_close = False
     x1 = dis_width / 2
    y1 = dis_height / 2
     x1_change = 0
    y1_change = 0
     snake_List = []
    Length_of_snake = 1
     foodx = round(random.randrange(0, dis_width - snake_block) / 10.0) * 10.0
    foody = round(random.randrange(0, dis_height - snake_block) / 10.0) * 10.0
     while not game_over:
         while game_close == True:
            dis.fill(blue)
            message("You Lost! Press C-Play Again or Q-Quit", red)
            pygame.display.update()
             for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_q:
                        game_over = True
                        game_close = False
                    if event.key == pygame.K_c:
                        gameLoop()
         for event in pygame.event.get():
            if event.type == pygame.QUIT:
                game_over = True
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    x1_change = -snake_block
                    y1_change = 0
                elif event.key == pygame.K_RIGHT:
                    x1_change = snake_block
                    y1_change = 0
                elif event.key == pygame.K_UP:
                    y1_change = -snake_block
                    x1_change = 0
                elif event.key == pygame.K_DOWN:
                    y1_change = snake_block
                    x1_change = 0
         if x1 >= dis_width or x1 < 0 or y1 >= dis_height or y1 < 0:
            game_close = True
        x1 += x1_change
        y1 += y1_change
        dis.fill(blue)
        pygame.draw.rect(dis, green, [foodx, foody, snake_block, snake_block])
        snake_Head = []
        snake_Head.append(x1)
        snake_Head.append(y1)
        snake_List.append(snake_Head)
        if len(snake_List) > Length_of_snake:
            del snake_List[0]
         for x in snake_List[:-1]:
            if x == snake_Head:
                game_close = True
         our_snake(snake_block, snake_List)
          pygame.display.update()
         if x1 == foodx and y1 == foody:
            foodx = round(random.randrange(0, dis_width - snake_block) / 10.0) * 10.0
            foody = round(random.randrange(0, dis_height - snake_block) / 10.0) * 10.0
            Length_of_snake += 1
        clock.tick(snake_speed)
     pygame.quit()
    quit()
 gameLoop()
  • Displaying the score

It is the last component of the snake game by Intellipaat. Here, you will need to display the score of the player. To do this, you have to create a new function as ‚ÄúYour_score‚ÄĚ. This function will display the snake’s length subtracted by 1 because that is the initial size of the snake.

import pygame
import time
import random
 pygame.init()
 white = (255, 255, 255)
yellow = (255, 255, 102)
black = (0, 0, 0)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
 dis_width = 600
dis_height = 400
 dis = pygame.display.set_mode((dis_width, dis_height))
pygame.display.set_caption('Snake Game by Intellipaat')
 clock = pygame.time.Clock()
snake_block = 10
snake_speed = 15
 font_style = pygame.font.SysFont("bahnschrift", 25)
score_font = pygame.font.SysFont("comicsansms", 35)
 def Your_score(score):
    value = score_font.render("Your Score: " + str(score), True, yellow)
    dis.blit(value, [0, 0])
 def our_snake(snake_block, snake_list):
    for x in snake_list:
        pygame.draw.rect(dis, black, [x[0], x[1], snake_block, snake_block])
def message(msg, color):
    mesg = font_style.render(msg, True, color)
    dis.blit(mesg, [dis_width / 6, dis_height / 3])
 def gameLoop():
    game_over = False
    game_close = False
     x1 = dis_width / 2
    y1 = dis_height / 2
     x1_change = 0
    y1_change = 0
     snake_List = []
    Length_of_snake = 1
     foodx = round(random.randrange(0, dis_width - snake_block) / 10.0) * 10.0
    foody = round(random.randrange(0, dis_height - snake_block) / 10.0) * 10.0
    while not game_over:
         while game_close == True:
            dis.fill(blue)
            message("You Lost! Press C-Play Again or Q-Quit", red)
            Your_score(Length_of_snake - 1)
            pygame.display.update()
             for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_q:
                        game_over = True
                        game_close = False
                    if event.key == pygame.K_c:
                        gameLoop()
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                game_over = True
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    x1_change = -snake_block
                    y1_change = 0
                elif event.key == pygame.K_RIGHT:
                    x1_change = snake_block
                    y1_change = 0
                elif event.key == pygame.K_UP:
                    y1_change = -snake_block
                    x1_change = 0
                elif event.key == pygame.K_DOWN:
                    y1_change = snake_block
                    x1_change = 0
         if x1 >= dis_width or x1 < 0 or y1 >= dis_height or y1 < 0:
            game_close = True
        x1 += x1_change
        y1 += y1_change
        dis.fill(blue)
        pygame.draw.rect(dis, green, [foodx, foody, snake_block, snake_block])
        snake_Head = []
        snake_Head.append(x1)
        snake_Head.append(y1)
        snake_List.append(snake_Head)
        if len(snake_List) > Length_of_snake:
            del snake_List[0]
         for x in snake_List[:-1]:
            if x == snake_Head:
                game_close = True
         our_snake(snake_block, snake_List)
        Your_score(Length_of_snake - 1)
        pygame.display.update()
         if x1 == foodx and y1 == foody:
            foodx = round(random.randrange(0, dis_width - snake_block) / 10.0) * 10.0
            foody = round(random.randrange(0, dis_height - snake_block) / 10.0) * 10.0
            Length_of_snake += 1
         clock.tick(snake_speed)
     pygame.quit()
    quit()
 gameLoop()

Conclusion

As we reach the end of this adventure into Pygame, we stand at the threshold of infinite possibilities in game development. Armed with the knowledge of Python fundamentals and a grasp of object-oriented programming, you are now equipped to unlock your creative potential. Pygame offers a medium to a world where imagination comes to life and interactive experiences captivate players. So, step into this realm of game development and let your ideas soar as Pygame awaits to transform your visions into reality. Let the games begin!

Course Schedule

Name Date Details
Python Course 25 May 2024(Sat-Sun) Weekend Batch
View Details
Python Course 01 Jun 2024(Sat-Sun) Weekend Batch
View Details
Python Course 08 Jun 2024(Sat-Sun) Weekend Batch
View Details

About the Author

Senior Consultant Analytics & Data Science

Presenting Sahil Mattoo, a Senior Consultant Analytics & Data Science at Eli Lilly and Company is an accomplished professional with 14 years of experience across data science, analytics, and technical leadership domains, demonstrates a remarkable ability to drive business insights. Sahil holds a Post Graduate Program in Business Analytics and Business Intelligence from Great Lakes Institute of Management.