Teach kids Python by building an interactive game

Open source tools can help anyone get started learning Python in an easy and fun way—making games.
186 readers like this.
Family learning and reading together at night in a room


Python has earned a reputation as a wonderful beginner programming language. But where does one begin?

One of my favorite ways to get people interested in programming is by writing games.

PursuedPyBear (ppb) is a game programming library optimized for teaching, and I recently used it to teach my children more about my favorite programming language.

The Jupyter project is a browser-based Python console, initially designed for data scientists to play with data.

I have a Jupyter Notebook designed to teach you how to make a simple interactive game, which you can download from here. In order to open the file, you will need to install the latest Jupyter project, JupyterLab.


  • Running a recent version of Python (instructions for LinuxMac, and Windows)
  • Running a recent version of Git (instructions here)

We will briefly configure a virtual environment to create a separate space for the needed libraries. (You can learn more about how virtual environments work here.)

$ git clone https://github.com/moshez/penguin-bit-by-bit.git
$ cd penguin-bit-by-bit
$ python -m venv venv
$ source ./venv/bin/activate
$ pip install -r requirements.txt
$ jupyter lab .

The last command should open JupyterLab in your default browser at the address http://localhost:8888/lab. Choose the dynamic_penguin.ipynb file in the left-hand column, and we can get started!

Jupyter screenshot

The event loop that will run the game

Jupyter runs an event loop internally, which is a process that manages the running of further asynchronous operations. The event loop used in Jupyter is asyncio, and PursuedPyBear runs its own event loop.

We can integrate the two using another library, Twisted, like glue. This sounds complicated, but thankfully, the complexity is hidden behind libraries, which will do all the hard work for us.

The following cell in Jupyter takes care of the first half—integrating Twisted with the asyncio event loop.

The__file__ = None is needed to integrate PursuedPyBear with Jupyter.

from twisted.internet import asyncioreactor
__file__ = None

Next, we need a "setup" function. A setup function is a common term for the configuration of key game elements. However, our function will only put the game "scene" in a global variable. Think of it like us defining the table on which we will play our game.

The following cell in Jupyter Notebook will do the trick.

def setup(scene):
    global SCENE
    SCENE = scene

Now we need to integrate PursuedPyBear's event loop with Twisted. We use the txppb module for that:

import txppb
d = txppb.run(setup)

The print at the end helps us if the game crashes because of a bug—it will print out a traceback to the Jupyter output.

This will show an empty window, ready for the game elements.

This is where we start taking advantage of Jupyter—traditionally, the whole game needs to be written before we start playing. We buck convention, however, and start playing the game immediately!

Making the game interesting with interaction

It is not a very interesting game, though. It has nothing and just sits there. If we want something, we better add it.

In video game programming, the things moving on the screen are called "sprites." In PursuedPyBear, sprites are represented by classes. A sprite will automatically use an image named the same as the class. I got a little penguin image from Kenney, a collection of free and open source video game assets.

import ppb

class Penguin(ppb.Sprite):

Now let's put the penguin riiiiiight in the middle.


It carefully sits there in the middle. This is marginally more interesting than having nothing. That's good—this is exactly what we want. In incremental game development, every step should be only marginally more interesting.

Adding movement to our penguin game with ppb

But penguins are not meant to sit still! The penguin should move around. We will have the player control the penguin with the arrow keys. First, let's map the keys to vectors:

from ppb import keycodes

DIRECTIONS = {keycodes.Left: ppb.Vector(-1,0), keycodes.Right: ppb.Vector(1,0),
              keycodes.Up: ppb.Vector(0, 1), keycodes.Down: ppb.Vector(0, -1)}

Now we will use a utility library. The set_in_class function sets the method in the class. Python's ability to add functions to classes retroactively is really coming in handy!

from mzutil import set_in_class

Penguin.direction = ppb.Vector(0, 0)

def on_update(self, update_event, signal):
    self.position += update_event.time_delta * self.direction

The code for set_in_class is not long, but it does use some non-trivial Python tricks. We will put the full utility library at the end of the article for review, and for the sake of flow, we will skip it for now.

Back to the penguin!

Oh, um, well.

The penguin is diligently moving…at zero speed, precisely nowhere. Let's manually set the direction to see what happens.

Penguin.direction = DIRECTIONS[keycodes.Up]/4

The direction is up, but a little slow. This gives enough time to set the penguin's direction back to zero manually. Let's do that now!

Penguin.direction = ppb.Vector(0, 0)

Adding interactivity to our penguin game

Phew, that was exciting—but not what we wanted. We want the penguin to respond to keypresses. Controlling it from the code is what gamers refer to as "cheating."

Let's set it to set the direction to the keypress, and back to zero when the key is released.

def on_key_pressed(self, key_event, signal):
    self.direction = DIRECTIONS.get(key_event.key, ppb.Vector(0, 0))    

def on_key_released(self, key_event, signal):
    if key_event.key in DIRECTIONS:
        self.direction = ppb.Vector(0, 0)

The Penguin is a bit bored, isn't it? Maybe we should give it an orange ball to play with.

class OrangeBall(ppb.Sprite):

Again, I made sure to have an image called orangeball.png. Now let's put the ball on the left side of the screen.

SCENE.add(OrangeBall(pos=(-4, 0)))

Try as it might, the penguin cannot kick the ball. Let's have the ball move away from the penguin when it approaches.

First, let's define what it means to "kick" the ball. Kicking the ball means deciding where it is going to be in one second, and then setting its state to "moving."

At first, we will just move it by having the first update move it to the target position.

OrangeBall.is_moving = False

def kick(self, direction):
    self.target_position = self.position + direction
    self.original_position = self.position
    self.time_passed = 0
    self.is_moving = True

def on_update(self, update_event, signal):
    if self.is_moving:
        self.position = self.target_position
        self.is_moving = False

Now, let's kick it!

ball, = SCENE.get(kind=OrangeBall)
ball.kick(ppb.Vector(1, 1))

But this just teleports the ball; it immediately changes the position. In real life, the ball goes between the intermediate points. When it's moving, it will interpolate between where it is and where it needs to go.

Naively, we would use linear interpolation. But a cool video game trick is to use an "easing" function. Here, we use the common "smooth step."

from mzutil import smooth_step

def maybe_move(self, update_event, signal):
    if not self.is_moving:
        return False
    self.time_passed += update_event.time_delta
    if self.time_passed >= 1:
        self.position = self.target_position
        self.is_moving = False
        return False
    t = smooth_step(self.time_passed)
    self.position = (1-t) * self.original_position + t * self.target_position
    return True

OrangeBall.on_update = OrangeBall.maybe_move

Now, let's try kicking it again.

ball, = SCENE.get(kind=OrangeBall)
ball.kick(ppb.Vector(1, -1))

But really, the penguin should be kicking the ball. When the ball sees that it is colliding with the penguin, it will kick itself in the opposite direction. If the penguin has gotten right on top of it, the ball will choose a random direction.

The update function now calls maybe_move and will only check collision if we are not moving right now.

from mzutil import collide
import random

OrangeBall.x_offset = OrangeBall.y_offset = 0.25

def on_update(self, update_event,signal):
    if self.maybe_move(update_event, signal):
    penguin, = update_event.scene.get(kind=Penguin)
    if not collide(penguin, self):
        direction = (self.position - penguin.position).normalize()
    except ZeroDivisionError:
        direction = ppb.Vector(random.uniform(-1, 1), random.uniform(-1, 1)).normalize()

But just kicking a ball around is not that much fun. Let's add a target.

class Target(ppb.Sprite):

Let's put the target at the right of the screen.

SCENE.add(Target(pos=(4, 0)))

Rewarding our penguin

Now, we will want a reward for the penguin when it kicks the ball into the target. How about a fish?

class Fish(ppb.Sprite):

When the target gets the ball, it should remove it and create a new ball at the other end of the screen. Then, it will cause a fish to appear.

def on_update(self, update_event, signal):
    for ball in update_event.scene.get(kind=OrangeBall):
        if not collide(ball, self):
        update_event.scene.add(OrangeBall(pos=(-4, random.uniform(-3, 3))))
        update_event.scene.add(Fish(pos=(random.uniform(-4, -3),
                                         random.uniform(-3, 3))))


We want to have the penguin eat the fish. When the fish sees the penguin, it should vanish.

Fish.x_offset = 0.05
Fish.y_offset = 0.2
def on_update(self, update_event,signal):
    penguin, = update_event.scene.get(kind=Penguin)
    if collide(penguin, self):

It works!

Iterative game design is fun for penguins and people alike!

This has all the makings of a game: the player-controlled penguin kicks the ball into the target, gets a fish, eats the fish, and kicks a new ball. This would work as a "grinding level" part of a game, or we could add obstacles to make the penguin's life harder.

Whether you are an experienced programmer, or just getting started, programming video games is fun. PursuedPyBear with Jupyter brings all the joy of classic 2D games with the interactive programming capabilities of the classic environments like Logo and Smalltalk. Time to enjoy a little retro 80s!


Here is the full source code of our utility library. It provides some interesting concepts to make the game board work. For more on how it does that, read about collision detection, setattr. and the __name__ attribute.

def set_in_class(klass):
    def retval(func):
        setattr(klass, func.__name__, func)
        return func
    return retval

def smooth_step(t):
    return t * t * (3 - 2 * t)


_WHICH_SIGN = dict(top=1, bottom=-1, left=-1, right=1)

def _effective_side(sprite, direction):
    return (getattr(sprite, direction) -
            _WHICH_SIGN[direction] *
           getattr(sprite, _WHICH_OFFSET[direction], 0))

def _extreme_side(sprite1, sprite2, direction):
    sign = -_WHICH_SIGN[direction]
    return sign * max(sign * _effective_side(sprite1, direction),
                      sign * _effective_side(sprite2, direction))
def collide(sprite1, sprite2):
    return (_extreme_side(sprite1, sprite2, 'bottom') <
            _extreme_side(sprite1, sprite2, 'top')
            _extreme_side(sprite1, sprite2, 'left') <
            _extreme_side(sprite1, sprite2, 'right'))
What to read next
Moshe sitting down, head slightly to the side. His t-shirt has Guardians of the Galaxy silhoutes against a background of sound visualization bars.
Moshe has been involved in the Linux community since 1998, helping in Linux "installation parties". He has been programming Python since 1999, and has contributed to the core Python interpreter. Moshe has been a DevOps/SRE since before those terms existed, caring deeply about software reliability, build reproducibility and other such things.


This is such a great article! Thanks for writing it

Yep I am agree with you. Making game is the best and fun way to learn programming.

This is a great idea! I've always thought that introductions to programming should be cantered around the thing that makes most people want to learn: game design. This certainly isn't the first platform to take this approach, but it's one of the first ones I've seen do it right. Too many "introductory" coding tools and courses fall flat due to excessively hand-holding gimics that alienate experienced coders and form a barrier to learning more "real" languages. This doesn't seem to do any of that; it just smooths over some of coding's more complicated or tedious aspects and leads directly into a very popular, mainstream language.

That's basically how I learned programming: After learning the basic fundamentals (thanks to Khan Academy), I started making simple games. My projects grew more complex as I refined my skills and researched the specific commands I needed.

After building a (very) rudimentary and limited 3D engine, I realized that i had outgrown Khan Academy's editor and decided to move on to more advanced languages like Java and C++. It wasn't until my freshman year of college (after years of coding) that I started to branch out and try things other than game development.

Thanks for writing this.

My child 10 years old already goes to IT school, I think this is a promising education in our country


My friends told me about Qweetly.com. I’ve gone there to read various templates of A-winning academic papers. They were absolutely free.

Very useful information!

Very Useful info

Creative Commons LicenseThis work is licensed under a Creative Commons Attribution-Share Alike 4.0 International License.