What Natter can do

01 · Basics

The language

Natter compiles Python 3 to bytecode and runs it in time slices. The table shows what works, with an example, and what does not, with the message Natter then shows. Every row ran while this page was built.

for i in range(3):
    if i == 1:
        continue
    print(i, 2 ** 70)

x = 3
match x:
    case 3:
        print("drei")

if (n := 5) > 3:
    print(n)

print(round(2.5), -7 // 2, -7 % 3, 2 ** 100, 0.1 + 0.2)

print(1 + 2j)

n = "Ada"
print(f"{n:>5}|{3.14159:.2f}|{1234567:,}", "%d%%" % 5, "{} {}".format(1, 2))

print(b"abc")

print(format(255, "x"))

a, *rest = [3, 1, 2]
print(a, rest, [x * x for x in rest], {x % 2 for x in rest}, {k: len(k) for k in ["ab", "c"]})

print({"a": 1} | {"b": 2})

def gruss(name, *, laut=False, **extra):
    t = "Hallo " + name
    return t.upper() if laut else t
print(gruss("Ada", laut=True), (lambda x: x * 2)(21))

def f(a, /, b):
    return a + b

class Tier:
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return "Tier " + self.name
class Hund(Tier):
    def __init__(self, name):
        super().__init__(name)
print(Hund("Bello"))

class L(list):
    pass

class M(type):
    pass
class A(metaclass=M):
    pass

class ZuKlein(Exception):
    pass
try:
    raise ZuKlein("unter 0")
except ZuKlein as e:
    print("Fehler:", e)
finally:
    print("fertig")

try:
    pass
except* ValueError:
    pass

def zaehle(n):
    yield from range(n)
print(sum(x * x for x in zaehle(4)))

async def f():
    pass

name = input("Wie heißt du? ")
print("Hallo", name, sep=", ", end="!\n")

import math as m
from os import path
print(m.floor(2.7), path.join("a", "b"))

import tkinter

def doppelt(x: int) -> int:
    return 2 * x
zahlen: list = [1, 2]
print(doppelt(4), zahlen)

from typing import List

print(eval("1 + 2"))

print(dir())

02 · Basics

Built-in functions

Every program knows these names without an import. Parameters are shown as Natter checks them; x=… means it may be left out.

zahlen = [5, 3, 8, 1]
print(len(zahlen), sum(zahlen), min(zahlen), max(zahlen))
print(sorted(zahlen, reverse=True))
for i, z in enumerate(zahlen, start=1):
    print(i, z, end="; ")
print()
print(list(zip("abc", range(3))), round(3.14159, 2), abs(-4), divmod(17, 5))

4 17 1 8
[8, 5, 3, 1]
1 5; 2 3; 3 8; 4 1; 
[('a', 0), ('b', 1), ('c', 2)] 3.14 4 (3, 2)

Funktionen

• callable(obj)
• classmethod(function)
• delattr(object, name)
• frozenset(iterable=…)
• hash(obj)
• id(obj)
• issubclass(class, classinfo)
• oct(x)
• property(fget=…, fset=…, fdel=…)
• repr(obj)
• staticmethod(function)

Exceptions

BaseException SystemExit KeyboardInterrupt GeneratorExit Exception ArithmeticError FloatingPointError OverflowError ZeroDivisionError AssertionError AttributeError EOFError ImportError ModuleNotFoundError LookupError IndexError KeyError NameError UnboundLocalError OSError FileNotFoundError PermissionError FileExistsError IsADirectoryError NotADirectoryError TimeoutError ConnectionError RuntimeError NotImplementedError RecursionError StopIteration SyntaxError IndentationError TabError TypeError ValueError IOError EnvironmentError

Missing compared with CPython

aiter anext ascii breakpoint bytearray bytes compile complex dir eval exec format globals help locals memoryview __import__

03 · Basics

Methods of the built-in types

Methods of strings, lists, tuples, dicts and sets. They all behave as in CPython. int and float have no methods (e.g. bit_length and is_integer are missing).

satz = "  Natter ist eine kleine Schlange  "
woerter = satz.strip().split()
print(woerter, "-".join(woerter).upper())
print(satz.count("e"), satz.find("klein"), satz.replace("klein", "groß").strip())
zahlen = [3, 1, 2]
zahlen.append(5)
zahlen.sort()
print(zahlen, zahlen.index(5), zahlen.pop())
alter = {"Ada": 36}
alter.setdefault("Linus", 21)
for name, jahre in alter.items():
    print(name, alter.get(name), jahre)

['Natter', 'ist', 'eine', 'kleine', 'Schlange'] NATTER-IST-EINE-KLEINE-SCHLANGE
6 18 Natter ist eine große Schlange
[1, 2, 3] 3 5
Ada 36 36
Linus 21 21

str

• capitalize(…)
• center(width, fillchar=…)
• endswith(suffix)
• expandtabs(tabsize=…)
• index(…)
• isalnum(…)
• isalpha(…)
• islower(…)
• isnumeric(…)
• isspace(…)
• isupper(…)
• ljust(width, fillchar=…)
• lstrip(chars=…)
• rfind(…)
• rindex(…)
• rjust(width, fillchar=…)
• rstrip(chars=…)
• splitlines(keepends=…)
• swapcase(…)
• title(…)
• zfill(width)

list

• clear(…)
• copy(…)
• count(value)
• extend(iterable)
• reverse(…)

tuple

• count(value)
• index(value)

dict

• clear(…)
• copy(…)

set

• clear(…)
• copy(…)
• difference_update(…)
• intersection_update(…)
• isdisjoint(other)
• issubset(other)
• issuperset(other)
• pop(…)
• remove(elem)
• symmetric_difference(other)
• symmetric_difference_update(other)
• update(…)

frozenset

• copy(…)
• difference(…)
• intersection(…)
• isdisjoint(other)
• issubset(other)
• issuperset(other)
• symmetric_difference(other)
• union(…)

04 · Basics

Files, os and os.path

A program sees the files of its project as a folder. open() reads and writes text files; os and os.path list, check, rename and delete. Paths are relative to the project folder (/ is the project folder).

The files live in memory. Where they are kept permanently (folder, ZIP, browser storage) is up to the page that embeds Natter: it is told about every change (onFileChange).

with open("noten.txt", "w") as f:
    f.write("Ada,1\nLinus,2\n")

with open("noten.txt") as f:
    for zeile in f:
        name, note = zeile.strip().split(",")
        print(name, "hat eine", note)

import os
print(os.listdir("."), os.path.getsize("noten.txt"))

Ada hat eine 1
Linus hat eine 2
['noten.txt'] 14

Ada,1
Linus,2

open() and file objects

Functions

Classes

• TextFile(path, mode, encoding=None)

TextFile

os

Functions

• getcwd()
• unlink(p)
• rmdir(p)
• getenv(key, default=None)
• walk(top)

Constants

• sep= '/'
• linesep= '\n'
• name= 'posix'
• curdir= '.'
• pardir= '..'
• environ= {}

os.path

Functions

• split(p)
• dirname(p)
• normpath(p)
• abspath(p)
• isabs(p)
• getsize(p)

Constants

• sep= '/'
• curdir= '.'
• pardir= '..'

05 · Standard modules

math

All functions of math used in school. They compute the same on every device: sin, exp, log … are implemented in Natter itself (after fdlibm, hypot and dist correctly rounded) instead of using the browser's functions, which differ in the last digit from device to device.

import math
print(math.sqrt(2), math.pi)
print(math.sin(math.radians(30)), math.floor(-2.5), math.ceil(2.1))
print(math.gcd(12, 18), math.factorial(10), math.comb(49, 6))
print(math.hypot(3, 4), math.log(8, 2), math.isclose(0.1 + 0.2, 0.3))

1.4142135623730951 3.141592653589793
0.49999999999999994 -3 3
6 3628800 13983816
5.0 3.0 True

Functions

• sinh(…)
• cosh(…)
• tanh(…)
• asinh(…)
• acosh(…)
• atanh(…)
• expm1(…)
• exp2(…)
• log1p(…)
• cbrt(…)
• perm(n, k=…)
• prod(iterable, start=…)
• fsum(iterable)
• isfinite(x)
• isinf(x)
• isnan(x)
• copysign(x, y)
• fmod(x, y)
• modf(x)
• ldexp(x, i)

Constants

• tau= 6.283185307179586
• nan= nan

06 · Standard modules

random

Random numbers from the VM's own generator. Without a seed it starts from the browser's secure randomness, so every run differs; with random.seed(…) or a fixed seed from the page, every run is the same.

import random
random.seed(7)
print(random.randint(1, 6), random.choice(["Stein", "Schere", "Papier"]))
karten = list(range(1, 11))
random.shuffle(karten)
print(karten, random.sample(karten, 3))
print(round(random.random(), 3), round(random.uniform(1, 2), 3))

1 Papier
[3, 5, 6, 1, 10, 9, 2, 7, 4, 8] [1, 2, 3]
0.901 1.919

Functions

• triangular(low=…, high=…, mode=…)
• expovariate(lambd)
• getrandbits(k)
• normalvariate(mu=…, sigma=…)

07 · Standard modules

time

Clock and waiting. time.sleep() only pauses the program, never the page. In the page the clock is real; in test runs without a page a virtual clock runs and sleep takes no time.

import time
start = time.perf_counter()
for i in range(3, 0, -1):
    print(i)
    time.sleep(0.5)
print("Los!", round(time.perf_counter() - start, 1), "Sekunden")

3
2
1
Los! 1.5 Sekunden

Functions

• time_ns(…)
• monotonic(…)
• process_time(…)
• gmtime(secs=None)
• mktime(t)
• asctime(t=None)
• ctime(secs=None)

Constants

• timezone= 0
• altzone= 0
• daylight= 0
• tzname= ('UTC', 'UTC')

08 · Standard modules

datetime

Dates, times, time spans and fixed time zones, computed in the Gregorian calendar like CPython.

from datetime import date, datetime, timedelta
ferien = date(2025, 7, 24)
heute = date(2025, 6, 2)
print((ferien - heute).days, "Tage bis zu den Ferien")
print(ferien.strftime("%d.%m.%Y"), ferien.weekday(), ferien + timedelta(weeks=6))
print(datetime(2025, 6, 2, 8, 15).isoformat())

52 Tage bis zu den Ferien
24.07.2025 3 2025-09-04
2025-06-02T08:15:00

Classes

• tzinfo()

timedelta

date

time

datetime

Constants

• MINYEAR= 1
• MAXYEAR= 9999

09 · Standard modules

json

Reading and writing JSON, formatted exactly like CPython (indent, sort_keys, ensure_ascii, separators).

import json
daten = {"name": "Ada", "noten": [1, 2.5], "aktiv": True, "lehrer": None}
text = json.dumps(daten, indent=2, ensure_ascii=False)
print(text)
print(json.loads(text)["noten"][1])

{
  "name": "Ada",
  "noten": [
    1,
    2.5
  ],
  "aktiv": true,
  "lehrer": null
}
2.5

Functions

Exceptions

• JSONDecodeError(msg, doc, pos)

10 · Standard modules

statistics

Mean, median, mode, variance and standard deviation.

import statistics as st
noten = [2, 3, 1, 2, 4, 2]
print(st.mean(noten), st.median(noten), st.mode(noten))
print(round(st.stdev(noten), 3), st.multimode([1, 1, 2, 2]))

2.3333333333333335 2.0 2
1.033 [1, 2]

Functions

• fmean(data, weights=None)
• median_low(data)
• median_high(data)
• multimode(data)
• pvariance(data, mu=None)

Exceptions

• StatisticsError()

11 · Standard modules

collections

Counter, defaultdict, deque, OrderedDict and namedtuple.

from collections import Counter, defaultdict, deque, namedtuple
print(Counter("abrakadabra").most_common(2))
gruppen = defaultdict(list)
for w in ["Apfel", "Birne", "Ananas"]:
    gruppen[w[0]].append(w)
print(dict(gruppen))
schlange = deque([1, 2, 3], maxlen=3)
schlange.append(4)
print(schlange)
Punkt = namedtuple("Punkt", "x y")
print(Punkt(2, 3).x)

[('a', 5), ('b', 2)]
{'A': ['Apfel', 'Ananas'], 'B': ['Birne']}
deque([2, 3, 4], maxlen=3)
2

Functions

Classes

defaultdict

OrderedDict

Counter

deque

12 · Standard modules

itertools

Building blocks for loops: combinatorics, endless sequences, grouping.

import itertools
print(list(itertools.permutations("abc", 2)))
print(list(itertools.combinations(range(4), 2)))
for k, g in itertools.groupby("aaabbc"):
    print(k, len(list(g)), end=" ")
print()
print(list(itertools.islice(itertools.count(10, 5), 4)))

[('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'c'), ('c', 'a'), ('c', 'b')]
[(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
a 3 b 2 c 1 
[10, 15, 20, 25]

Functions

• repeat(obj, times=None)
• takewhile(predicate, iterable)
• dropwhile(predicate, iterable)
• filterfalse(predicate, iterable)
• starmap(function, iterable)
• compress(data, selectors)
• zip_longest(*iterables, fillvalue=None)
• pairwise(iterable)
• combinations_with_replacement(iterable, r)
• tee(iterable, n=2)

Classes

13 · Standard modules

functools

reduce, partial, lru_cache/cache, wraps, cmp_to_key, total_ordering.

from functools import lru_cache, reduce, partial

@lru_cache
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)

print(fib(90))
print(reduce(lambda a, b: a * b, range(1, 6)))
zweier = partial(int, base=2)
print(zweier("1011"))

2880067194370816120
120
11

Functions

• wraps(wrapped)
• cmp_to_key(mycmp)
• total_ordering(cls)

Classes

14 · Standard modules

string

Character classes as strings, and capwords.

import string
print(string.ascii_uppercase)
print(string.capwords("hallo schöne welt"))
print(sum(1 for c in "Python 3.12!" if c in string.digits))

ABCDEFGHIJKLMNOPQRSTUVWXYZ
Hallo Schöne Welt
3

Functions

• capwords(s, sep=None)

Constants

• ascii_lowercase= 'abcdefghijklmnopqrstuvwxyz'
• ascii_uppercase= 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
• ascii_letters= 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJK…
• digits= '0123456789'
• hexdigits= '0123456789abcdefABCDEF'
• octdigits= '01234567'
• punctuation= '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
• whitespace= ' \t\n\r\x0b\x0c'
• printable= '0123456789abcdefghijklmnopqrstuvwxyzA…

15 · Standard modules

copy

Shallow and deep copies of lists, dicts, sets and your own objects (respects __copy__/__deepcopy__).

import copy
feld = [[0, 0], [0, 0]]
flach = copy.copy(feld)
tief = copy.deepcopy(feld)
feld[0][0] = 9
print(flach[0][0], tief[0][0])

9 0

Functions

16 · Standard modules

sys

The parts of sys that school programs need: exit, stdout/stderr/stdin, argv, version information.

import sys
print(sys.version_info[:2], sys.platform)
sys.stdout.write("ohne Zeilenumbruch")
print()
if len(sys.argv) < 2:
    print("Keine Argumente, Ende.")
    sys.exit()
print("nie erreicht")

(3, 12) browser
ohne Zeilenumbruch
Keine Argumente, Ende.

Functions

• getrecursionlimit()
• setrecursionlimit(n)
• getsizeof(obj)

Objects

Constants

• argv= ['']
• maxsize= 9223372036854775807
• version= '3.12.0 (Natter)'
• version_info= (3, 12, 0, 'final', 0)
• platform= 'browser'
• byteorder= 'little'
• path= []
• modules= {}

17 · Standard modules

re

Regular expressions with Python's syntax (named groups (?P<name>…), \A, \Z, lookbehind, flags, verbose mode). Positions count characters as in Python.

import re
text = "Ada: 0171-555 12, Linus: 030 1234"
print(re.findall(r"\d+", text))
m = re.search(r"(?P<name>\w+): (?P<nr>[\d -]+)", text)
print(m.group("name"), m.span())
print(re.sub(r"\s+", " ", "viel    zu   viel Platz"))
print(re.split(r"[,:]\s*", text))

['0171', '555', '12', '030', '1234']
Ada (0, 16)
viel zu viel Platz
['Ada', '0171-555 12', 'Linus', '030 1234']

Functions

• subn(pattern, repl, string, count=0, flags=0)
• escape(pattern)
• purge()

Classes

• Match(pattern, string, spans, pos, endpos)
• Pattern(pattern, flags)

Match

Pattern

Exceptions

• PatternError(msg, pattern=None, pos=None)
• error(msg, pattern=None, pos=None)

Constants

• I= 2
• IGNORECASE= 2
• L= 4
• LOCALE= 4
• M= 8
• MULTILINE= 8
• S= 16
• DOTALL= 16
• U= 32
• UNICODE= 32
• X= 64
• VERBOSE= 64
• A= 256
• ASCII= 256
• NOFLAG= 0

18 · Standard modules

pprint

Prints nested data readably, with the same line-breaking rules as CPython.

from pprint import pprint
schule = {"klassen": {"7a": ["Ada", "Linus", "Grace"], "7b": ["Alan", "Barbara"]}, "raeume": list(range(101, 112))}
pprint(schule, width=50)

{'klassen': {'7a': ['Ada', 'Linus', 'Grace'],
             '7b': ['Alan', 'Barbara']},
 'raeume': [101,
            102,
            103,
            104,
            105,
            106,
            107,
            108,
            109,
            110,
            111]}

Functions

• pformat(obj, indent=1, width=80, depth=None, *, compact=False, sort_dicts=True, underscore_numbers=False)
• pprint(obj, stream=None, indent=1, width=80, depth=None, *, compact=False, sort_dicts=True, underscore_numbers=False)
• pp(obj, *args, sort_dicts=False, **kw)
• saferepr(obj)
• isreadable(obj)
• isrecursive(obj)

Classes

• PrettyPrinter(indent=1, width=80, depth=None, stream=None, *, compact=False, sort_dicts=True, underscore_numbers=False)

19 · Standard modules

textwrap

Wrapping, shortening and indenting text.

import textwrap
satz = "Natter ist ein kleiner Python-Interpreter für den Unterricht im Browser."
print(textwrap.fill(satz, width=30))
print(textwrap.shorten(satz, width=30))
print(textwrap.indent("a\nb", "> "))

Natter ist ein kleiner Python-
Interpreter für den Unterricht
im Browser.
Natter ist ein kleiner [...]
> a
> b

Functions

• wrap(text, width=70, initial_indent='', subsequent_indent='', expand_tabs=True, replace_whitespace=True, fix_sentence_endings=False, break_long_words=True, drop_whitespace=True, break_on_hyphens=True, tabsize=8, max_lines=None, placeholder=' [...]')
• fill(text, width=70, **kw)
• shorten(text, width, **kw)
• dedent(text)
• indent(text, prefix, predicate=None)

Classes

• TextWrapper(width=70, **kw)

20 · Drawing and games

turtle

Turtle graphics as in CPython: the same formulas, so the same positions and headings. The page draws (origin in the middle, y up), animates according to speed() and sends keys, clicks and timers to mainloop().

import turtle
t = turtle.Turtle()
t.speed(0)
t.color("darkgreen", "lightgreen")
t.begin_fill()
for i in range(5):
    t.forward(150)
    t.right(144)
t.end_fill()
t.penup()
t.goto(0, -60)
t.write("Stern", align="center", font=("Arial", 16, "bold"))
print(t.position(), t.heading())
turtle.done()

(0.00,-60.00) 0.0

Functions

• getscreen()
• getturtle()
• getpen()
• delay(delay=None)
• screensize(*args)
• onclick(fun, btn=1, add=None)
• turtles()
• clearscreen()
• resetscreen()
• fd(distance)
• bk(distance)
• backward(distance)
• rt(angle)
• lt(angle)
• setpos(x, y=None)
• setposition(x, y=None)
• setx(x)
• sety(y)
• seth(to_angle)
• clearstamp(stampid)
• clearstamps(n=None)
• pos()
• position()
• xcor()
• ycor()
• heading()
• towards(x, y=None)
• distance(x, y=None)
• degrees(fullcircle=360.0)
• radians()
• pu()
• up()
• pd()
• down()
• isdown()
• width(width=None)
• pen(pen=None, **pendict)
• pencolor(*args)
• fillcolor(*args)
• filling()
• showturtle()
• st()
• ht()
• isvisible()
• shapesize(stretch_wid=None, stretch_len=None, outline=None)
• turtlesize(stretch_wid=None, stretch_len=None, outline=None)
• resizemode(rmode=None)
• clone()
• undo()
• setundobuffer(size)
• undobufferentries()
• onrelease(fun, btn=1, add=None)
• ondrag(fun, btn=1, add=None)
• begin_poly()
• end_poly()
• get_poly()
• teleport(x=None, y=None, fill_gap=False)
• shearfactor(shear=None)
• tilt(angle)
• settiltangle(angle)
• tiltangle(angle=None)
• bgpic(picname=None)
• title(titlestring)
• window_width()
• window_height()
• update()
• exitonclick()
• bye()
• mode(mode=None)
• colormode(cmode=None)
• listen(xdummy=None, ydummy=None)
• onkeypress(fun, key=None)
• onkeyrelease(fun, key)
• register_shape(name, shape=None)
• addshape(name, shape=None)
• getshapes()

Classes

• RawTurtle(shape='classic', undobuffersize=1000, visible=True)

Turtle

Screen

Exceptions

• TurtleGraphicsError()
• Terminator()

21 · Drawing and games

Kara the ladybug

Kara walks on a meadow of cells, collects blueberries, avoids trees and pushes mushrooms. The commands are named as in the book (move, turnLeft, treeFront …) and work with import kara (kara.move()), with from kara import * or without any import: when a program starts with world("""…"""), the commands are already there.

The meadow is a picture made of characters, one line of text per row. Kara faces right at the start. Lines may differ in length (missing cells are empty).

world("""
########
#@ . ..#
########
""")

while not treeFront():
    if onBerry():
        removeBerry()
    move()
if onBerry():
    removeBerry()

########
#     @#
########

Commands

World characters

Error messages

• tree Kara bumped her head on a tree.
• edge Kara reached the edge of the meadow and cannot go further.
• mushroom The mushroom cannot be pushed: behind it is a tree, a mushroom or the edge.
• berryThere There is already a blueberry here.
• noBerry There is no blueberry here to pick up.
• noWorld There is no meadow yet. Call world("""...""") first.
• noKara The meadow has no Kara (the character @ or +).
• twoKaras The meadow has more than one Kara.
• badChar The character “{char}” does not exist in the meadow (line {y}, column {x}).

22 · Drawing and games

Pygame Zero

Games with the API of Pygame Zero 1.2: write draw() and update(), move Actors, read keys, play sounds. The game logic computes like the real Pygame Zero (compared with pgzero 1.2.1 and pygame 2), plus the popular extensions from pgzhelper (scale, flip_x, images/animate, move_towards …).

A game starts like pgzrun game.py: if the program has def draw() or def update() (or WIDTH/HEIGHT and Actor/screen), it knows all the names below without an import. With import pgzrun and pgzrun.go() at the end it works the same; code after go() runs when the window is closed.

Window: WIDTH, HEIGHT (default 800 × 600) and TITLE as global variables. Images are found by their name without extension: first in the project folder images/ (sounds sounds/, music music/, fonts fonts/), then in the asset library.

import random

WIDTH = 480
HEIGHT = 320
TITLE = "Münzjagd"

heldin = Actor("heroine_idle_1", (240, 260))
muenze = Actor("pf_coin_1", (100, 80))
punkte = 0

def draw():
    screen.fill("skyblue")
    heldin.draw()
    muenze.draw()
    screen.draw.text("Punkte: " + str(punkte), (10, 10), fontsize=32, color="white")

def update():
    global punkte
    if keyboard.left:
        heldin.x -= 5
    if keyboard.right:
        heldin.x += 5
    muenze.y += 2
    if heldin.colliderect(muenze):
        punkte += 1
        sounds.coin.play()
        neu()
    elif muenze.top > HEIGHT:
        neu()

def neu():
    muenze.pos = (random.randint(20, WIDTH - 20), -20)

def on_mouse_down(pos):
    heldin.x = pos[0]

Hooks (functions you write)

Predefined names

Actor

Rect

ZRect

clock

keys

• keys.AC_BACK
• keys.UNKNOWN
• keys.BACKSPACE
• keys.TAB
• keys.CLEAR
• keys.RETURN
• keys.PAUSE
• keys.ESCAPE
• keys.SPACE
• keys.QUOTE
• keys.COMMA
• keys.MINUS
• keys.PERIOD
• keys.SLASH
• keys.K_0
• keys.K_1
• keys.K_2
• keys.K_3
• keys.K_4
• keys.K_5
• keys.K_6
• keys.K_7
• keys.K_8
• keys.K_9
• keys.SEMICOLON
• keys.EQUALS
• keys.LEFTBRACKET
• keys.BACKSLASH
• keys.RIGHTBRACKET
• keys.BACKQUOTE
• keys.A
• keys.B
• keys.C
• keys.D
• keys.E
• keys.F
• keys.G
• keys.H
• keys.I
• keys.J
• keys.K
• keys.L
• keys.M
• keys.N
• keys.O
• keys.P
• keys.Q
• keys.R
• keys.S
• keys.T
• keys.U
• keys.V
• keys.W
• keys.X
• keys.Y
• keys.Z
• keys.DELETE
• keys.KP_0
• keys.KP_1
• keys.KP_2
• keys.KP_3
• keys.KP_4
• keys.KP_5
• keys.KP_6
• keys.KP_7
• keys.KP_8
• keys.KP_9
• keys.KP0
• keys.KP1
• keys.KP2
• keys.KP3
• keys.KP4
• keys.KP5
• keys.KP6
• keys.KP7
• keys.KP8
• keys.KP9
• keys.KP_PERIOD
• keys.KP_DIVIDE
• keys.KP_MULTIPLY
• keys.KP_MINUS
• keys.KP_PLUS
• keys.KP_ENTER
• keys.KP_EQUALS
• keys.UP
• keys.DOWN
• keys.RIGHT
• keys.LEFT
• keys.INSERT
• keys.HOME
• keys.END
• keys.PAGEUP
• keys.PAGEDOWN
• keys.F1
• keys.F2
• keys.F3
• keys.F4
• keys.F5
• keys.F6
• keys.F7
• keys.F8
• keys.F9
• keys.F10
• keys.F11
• keys.F12
• keys.F13
• keys.F14
• keys.F15
• keys.NUMLOCKCLEAR
• keys.NUMLOCK
• keys.CAPSLOCK
• keys.SCROLLLOCK
• keys.SCROLLOCK
• keys.RSHIFT
• keys.LSHIFT
• keys.RCTRL
• keys.LCTRL
• keys.RALT
• keys.LALT
• keys.RGUI
• keys.RMETA
• keys.LGUI
• keys.LMETA
• keys.LSUPER
• keys.RSUPER
• keys.MODE
• keys.HELP
• keys.PRINTSCREEN
• keys.PRINT
• keys.SYSREQ
• keys.BREAK
• keys.MENU
• keys.POWER
• keys.CURRENCYUNIT
• keys.CURRENCYSUBUNIT
• keys.EURO
• keys.EXCLAIM
• keys.QUOTEDBL
• keys.HASH
• keys.DOLLAR
• keys.AMPERSAND
• keys.PERCENT
• keys.LEFTPAREN
• keys.RIGHTPAREN
• keys.ASTERISK
• keys.PLUS
• keys.COLON
• keys.LESS
• keys.GREATER
• keys.QUESTION
• keys.AT
• keys.CARET
• keys.UNDERSCORE

keymods

• keymods.NONE
• keymods.LSHIFT
• keymods.RSHIFT
• keymods.LCTRL
• keymods.RCTRL
• keymods.LALT
• keymods.RALT
• keymods.LGUI
• keymods.RGUI
• keymods.NUM
• keymods.CAPS
• keymods.MODE
• keymods.CTRL
• keymods.SHIFT
• keymods.ALT
• keymods.GUI
• keymods.LMETA
• keymods.RMETA
• keymods.META

mouse

• mouse.LEFT
• mouse.MIDDLE
• mouse.RIGHT
• mouse.WHEEL_UP
• mouse.WHEEL_DOWN

music

sounds

images

tone

screen

screen.draw

Sound

23 · Drawing and games

Asset library

About 900 images in one consistent style plus short sounds, free to use (CC0). A program only names them, without uploading files: Actor("heroine_run_1"), screen.blit("pf_grass_mid", (0, 416)), sounds.coin.play(). Kara and the turtle shape use the same library.

Only what the program mentions is loaded. A string like "heroine_run_" + str(i) loads all images whose name starts that way. Your own file with the same name in the project folder images/ wins. The sprite gallery shows all images and sounds with previews, sorted by game type; the packs live in packages/assets (gametypes.json, catalog.json).

Game types with starter sets

Browse all images and sounds in the sprite gallery

Packs

• adventure Adventure
• animals Animals
• arcade Arcade
• book Pond game of the book
• characters Characters
• flyer Flyers and falling things
• grid_action Grid action
• grid_chars Grid characters (top-down)
• grid_puzzle Grid puzzles and board games
• grid_tiles Grid tiles
• kara Kara the ladybug
• nature Nature and weather
• platformer Platformer
• sea Sea
• space Space
• turtle Turtle
• ui Game interface
• sounds Sounds

Sounds

• sounds.platsch Water splash
• sounds.coin Collect a coin
• sounds.jump Jump
• sounds.hit Hit
• sounds.explosion Explosion
• sounds.laser Laser shot
• sounds.powerup Power up
• sounds.click Click
• sounds.blip Blip
• sounds.win You win
• sounds.lose You lose
• sounds.bounce Bounce
• sounds.step Footstep
• sounds.quack Quack

24 · Forms, data, network

Forms with guizero

Windows with buttons, text boxes and lists through the API of guizero 1.6. Programs run as the guizero documentation shows them; defaults, warnings and error messages match the real guizero.

The page draws the widgets as real HTML elements. Layout auto works like Tk pack, layout grid is a grid that grows with its content (grid=[column, row], also [column, row, width, height]).

from guizero import App, Text, PushButton, Box

app = App(title="Zähler", width=240, height=160)
anzeige = Text(app, text="0", size=40)
knoepfe = Box(app, layout="grid")

def plus():
    anzeige.value = int(anzeige.value) + 1

def null():
    anzeige.value = 0

PushButton(knoepfe, text="+1", command=plus, grid=[0, 0])
PushButton(knoepfe, text="Null", command=null, grid=[1, 0])
app.display()

Functions

• warn(title, text, master=None)
• error(title, text, master=None)
• select_folder(title='Select folder', folder='.', master=None)

Classes

App

Window

Box

TitleBox

Text

TextBox

PushButton

CheckBox

ButtonGroup

Combo

ListBox

Slider

Picture

Waffle

Drawing

Exceptions

• GUIZeroException()

All widgets also have

25 · Forms, data, network

numpy

An honest subset of numpy 2: arrays with broadcasting, arithmetic, statistics, sorting, random numbers, some linear algebra. What exists prints the same digits as numpy (compared with numpy 2.5): output format, statistics and numpy.random with the same seed.

dtypes: int64, float64, bool and strings. Slices and .T are views as in numpy (changing them changes the original); mask and list indexes return copies.

import numpy as np
a = np.arange(1, 7).reshape(2, 3)
print(a)
print(a.sum(axis=0), a.mean(), a[a > 2])
x = np.linspace(0, 1, 5)
print(x ** 2, np.round(np.sin(x), 3))
rng = np.random.default_rng(42)
print(rng.integers(1, 7, size=5))

[[1 2 3]
 [4 5 6]]
[5 7 9] 3.5 [3 4 5 6]
[0.     0.0625 0.25   0.5625 1.    ] [0.    0.247 0.479 0.682 0.841]
[1 5 4 3 3]

numpy

Functions

• asarray(a, dtype=…, order=…)
• copy(a)
• empty(shape, dtype=…)
• full(shape, fill_value, dtype=…)
• zeros_like(a, dtype=…)
• ones_like(a, dtype=…)
• empty_like(a, dtype=…)
• full_like(a, fill_value, dtype=…)
• eye(N, M=…, k=…, dtype=…)
• identity(n, dtype=…)
• meshgrid(x, y)
• ravel(a)
• transpose(a, axes=…)
• shape(a)
• size(a)
• ndim(a)
• squeeze(a, axis=…)
• expand_dims(a, axis)
• concatenate(arrays, axis=…)
• vstack(tup)
• hstack(tup)
• column_stack(tup)
• stack(arrays, axis=…)
• append(arr, values, axis=…)
• flip(m, axis=…)
• repeat(a, repeats, axis=…)
• tile(A, reps)
• nonzero(a)
• argwhere(a)
• clip(a, a_min, a_max, out=…)
• maximum(x1, x2)
• minimum(x1, x2)
• arctan2(x1, x2)
• hypot(x1, x2)
• logical_and(x1, x2)
• logical_or(x1, x2)
• logical_xor(x1, x2)
• isclose(a, b, rtol=…, atol=…, equal_nan=…)
• allclose(a, b, rtol=…, atol=…, equal_nan=…)
• array_equal(a1, a2, equal_nan=…)
• round(a, decimals=…, out=…)
• power(x1, x2)
• add(x1, x2)
• subtract(x1, x2)
• multiply(x1, x2)
• divide(x1, x2)
• floor_divide(x1, x2)
• mod(x1, x2)
• prod(…)
• min(…)
• max(…)
• any(…)
• all(…)
• ptp(…)
• count_nonzero(…)
• amin(…)
• amax(…)
• argmin(…)
• argmax(…)
• var(…)
• cumsum(…)
• cumprod(…)
• nansum(a, axis=…, dtype=…, out=…, keepdims=…)
• nanmean(a, axis=…, dtype=…, out=…, keepdims=…)
• nanvar(a, axis=…, dtype=…, out=…, ddof=…, keepdims=…)
• nanstd(a, axis=…, dtype=…, out=…, ddof=…, keepdims=…)
• nanmax(a, axis=…, out=…, keepdims=…)
• nanmin(a, axis=…, out=…, keepdims=…)
• nanmedian(a, axis=…)
• median(a, axis=…)
• percentile(a, q, axis=…)
• quantile(a, q, axis=…)
• average(a, axis=…, weights=…)
• diff(a, n=…, axis=…)
• argsort(a, axis=…, kind=…)
• bincount(x, weights=…, minlength=…)
• matmul(x1, x2)
• outer(a, b)
• trace(a)
• diag(v, k=…)
• polyval(p, x)
• corrcoef(x, y=…)
• cov(m, y=…)
• interp(x, xp, fp)
• isscalar(…)
• set_printoptions(precision=…, threshold=…, edgeitems=…, linewidth=…, suppress=…, nanstr=…, infstr=…, formatter=…, sign=…, floatmode=…, legacy=…)
• get_printoptions(…)
• exp(…)
• exp2(…)
• expm1(…)
• log(…)
• log2(…)
• log10(…)
• log1p(…)
• cos(…)
• tan(…)
• arcsin(…)
• arccos(…)
• arctan(…)
• sinh(…)
• cosh(…)
• tanh(…)
• arcsinh(…)
• arccosh(…)
• arctanh(…)
• degrees(…)
• radians(…)
• rad2deg(…)
• deg2rad(…)
• absolute(…)
• fabs(…)
• negative(…)
• positive(…)
• floor(…)
• ceil(…)
• trunc(…)
• rint(…)
• fix(…)
• sign(…)
• square(…)
• reciprocal(…)
• cbrt(…)
• isnan(…)
• isinf(…)
• isfinite(…)
• logical_not(…)
• signbit(…)
• abs(…)
• around(a, decimals=…, out=…)
• vectorize(pyfunc, otypes=None)
• apply_along_axis(func1d, axis, arr)
• fromfunction(function, shape, dtype=…)

Classes

• ndarray(shape, dtype=…)

ndarray

Constants

• pi= 3.141592653589793
• e= 2.718281828459045
• euler_gamma= 0.5772156649015329
• inf= inf
• nan= nan
• newaxis= None

numpy.random

Functions

• randn(…)
• random_sample(…)
• ranf(…)
• sample(…)
• random_integers(…)
• uniform(…)
• standard_normal(…)
• exponential(…)
• poisson(…)
• binomial(…)
• choice(…)
• shuffle(…)
• permutation(…)

Classes

• RandomState()
• Generator()

numpy.linalg

Functions

• norm(x, ord=None, axis=None)

Exceptions

• LinAlgError()

26 · Forms, data, network

Plots with matplotlib.pyplot

Function graphs, scatter plots, bars, histograms and pie charts like matplotlib 3: the same axes, ticks, colours, legends and positions. plt.show() shows the plot as SVG in the page and the program goes on at once; plt.savefig("plot.svg") offers it for download.

The object-oriented style works too: fig, ax = plt.subplots(), ax.plot(…), axs[0, 1], ax.set(title=…).

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2 * np.pi, 100)
plt.plot(x, np.sin(x), label="sin")
plt.plot(x, np.cos(x), "r--", label="cos")
plt.title("Sinus und Kosinus")
plt.xlabel("x")
plt.legend()
plt.grid(True)
plt.show()

Functions

• gcf(…)
• gca(…)
• sca(…)
• close(…)
• clf(…)
• subplot(*args, **kwargs)
• errorbar(*args, **kwargs)
• fill_between(*args, **kwargs)
• suptitle(t, **kwargs)
• xticks(ticks=None, labels=None, **kwargs)
• yticks(ticks=None, labels=None, **kwargs)
• axis(*args, **kwargs)
• tight_layout(**kwargs)
• subplots_adjust(**kwargs)
• cla()
• get_fignums()
• ion()
• ioff()
• pause(interval)

Classes

• Figure()
• Axes()

Figure

Axes

Placeholders only (raise NotImplementedError)

• xscale(*args, **kwargs)
• yscale(*args, **kwargs)
• semilogx(*args, **kwargs)
• semilogy(*args, **kwargs)
• loglog(*args, **kwargs)
• imshow(*args, **kwargs)
• contour(*args, **kwargs)
• contourf(*args, **kwargs)
• colorbar(*args, **kwargs)
• boxplot(*args, **kwargs)
• violinplot(*args, **kwargs)
• stem(*args, **kwargs)
• step(*args, **kwargs)
• quiver(*args, **kwargs)
• polar(*args, **kwargs)
• stackplot(*args, **kwargs)
• twinx(*args, **kwargs)

27 · Forms, data, network

requests and CORS

Fetching data from the web as with the requests package: requests.get(url).json(). The page performs the request with fetch; the program waits meanwhile.

Why some addresses fail (CORS): a browser only lets a web page read answers from servers that explicitly allow it (header Access-Control-Allow-Origin). Open data APIs such as Open-Meteo, Wikipedia and many JSON APIs allow it; ordinary web pages usually do not. When the browser blocks a request, Natter raises ConnectionError with exactly this explanation. Remedies: use a source that allows CORS, put the data into the project as a file, or run the program on your own computer with CPython.

import requests

antwort = requests.get("https://api.open-meteo.com/v1/forecast", params={
    "latitude": 52.52, "longitude": 13.41, "current_weather": "true"})
antwort.raise_for_status()
wetter = antwort.json()["current_weather"]
print("Berlin:", wetter["temperature"], "°C, Wind", wetter["windspeed"], "km/h")

Functions

• put(url, data=None, **kw)
• patch(url, data=None, **kw)
• delete(url, **kw)
• head(url, **kw)

Classes

Response

Session

Exceptions

• RequestException(*args, **kwargs)
• ConnectTimeout(*args, **kwargs)
• ReadTimeout(*args, **kwargs)
• InvalidURL(*args, **kwargs)
• MissingSchema(*args, **kwargs)
• JSONDecodeError(msg, doc, pos)