Programmieren mit Python

• Konsole, Variablen, Schleifen und Entscheidungen
• Zeichnen, Tasten, LEDs, Töne und Texte
• eigene Funktionen mit Rückgabewerten, Listen und Dateien
• Turtle, Canvas und Sprites – bis zum eigenen Spiel mit Kollisionen und Beschleunigungssensor
• Zusatzkapitel für Neugierige: Objekte und Klassen

Das Buch setzt keine Vorkenntnisse voraus, auch keine Blockprogrammierung. Es richtet sich an alle ab 14 Jahren und arbeitet mit vielen kurzen Programmen. Du brauchst nur einen Browser – den PicoBoy Color Plus selbst kannst du dazunehmen, wenn du einen hast.

So sieht ein Programm aus

import pbc

pbc.clear()
pbc.text24("Hallo!", 80, 120, pbc.YELLOW)

while True:
    if pbc.was_pressed_a():
        pbc.led_green(True)
        pbc.tone(880, 100)
    if pbc.was_pressed_b():
        pbc.led_green(False)

Das Modul pbc nimmt die Kleinarbeit ab: Bildschirm, Tasten, LEDs, Ton und Beschleunigungssensor sind jeweils ein Befehl. Auf dem Gerät läuft MicroPython, eine Variante von Python für kleine Computer. Fast alles, was du hier lernst, gilt genauso für Python auf dem PC.

Erste Schritte im Textmodus

Programmiert wird im Browser mit PBC+ Studio, am besten in Chrome oder Edge. Nur diese Browser können sich über USB mit dem Gerät verbinden. Installieren musst du nichts.

PBC+ Studio zeigt ein Programm entweder als Blöcke oder als Text. Beim allerersten Öffnen siehst du die Blockansicht mit einem kleinen Startprogramm. Für Python wechselst du einmal in den Textmodus:

1. Oben auf Zu Text wechseln klicken.
2. Das Startprogramm steht jetzt als Python-Text da, zunächst schreibgeschützt. Rechts auf Bearbeitung aktivieren klicken und mit OK bestätigen.
3. Fertig. PBC+ Studio merkt sich den Textmodus und dein letztes Programm, auch wenn du die Seite neu lädst.

Nr.	Bereich	Wofür?
1	Dateien	Programme speichern und öffnen, Bilder hochladen
2	Hilfe-Leiste	Erklärungen und Beispiele zu Python und zu allen PBC+-Befehlen, nach Themen sortiert. In den Editor einfügen übernimmt ein Beispiel.
3	Editor	Hier schreibst du dein Programm, links stehen die Zeilennummern.
4 / 5	▶ Testen / ■ Stop	Programm starten und anhalten
6	Ziel	Läuft das Programm im Emulator oder auf dem echten Gerät (PBC+)?
7	Verbinden / Trennen	verbindet PBC+ Studio mit dem Gerät oder dem Emulator
8	Emulator	ein PicoBoy auf dem Bildschirm, der sich wie das echte Gerät verhält
9	Terminal	Ausgaben deines Programms und Fehlermeldungen (die Konsole)

Das erste Programm

Lösche alles im Editor (Strg + A, dann Entf) und tippe ab:

import pbc

pbc.clear()
pbc.text24("Bereit?", 70, 120, pbc.WHITE)

import pbc holt die Befehle für den PicoBoy. Ohne diese Zeile kennt Python weder Bildschirm noch Tasten. pbc.clear() löscht den Bildschirm, pbc.text24 schreibt Text in 24 Pixel hoher Schrift. Die beiden Zahlen sind die Koordinaten: Der Bildschirm ist 240 Pixel breit und 280 Pixel hoch, (0, 0) ist die linke obere Ecke.

• Im Emulator: Als Ziel Emulator wählen und auf ▶ Testen klicken. Im Emulator erscheint „Bereit?“, im Terminal steht -- Testlauf -- und am Ende -- fertig --.
• Auf dem Gerät: PBC+ per USB anschließen und einschalten, als Ziel PBC+ wählen, Verbinden klicken und den PicoBoy in der Liste des Browsers auswählen. Dann ▶ Testen.
• Ein Programm, das nicht von selbst aufhört, hältst du mit ■ Stop an.

Am Gerät	Im Emulator
Joystick hoch, runter, links, rechts	Pfeiltasten
Joystick drücken (MITTE)	Leertaste
Taste A / Taste B	Taste A / Taste B (oder mit der Maus)

Zum Sichern speicherst du dein Programm mit Dateien → Auf den Computer… als .py-Datei und öffnest es später mit Dateien → Vom Computer… wieder. Eine .py-Datei ist eine ganz normale Textdatei.

Die wichtigsten Befehle

Eine Auswahl aus dem Modul pbc und dem Modul turtle. Die vollständige Übersicht steht in Anhang A des Buchs und in der Hilfe-Leiste von PBC+ Studio.

Thema	Befehle
Bildschirm	pbc.clear(), pbc.clear(farbe), pbc.WIDTH, pbc.HEIGHT
Text	pbc.text(s, x, y, farbe), pbc.text12 / text18 / text24(s, x, y, farbe)
Zeichnen	pbc.pixel(x, y, farbe), pbc.line(x1, y1, x2, y2, farbe), pbc.rect(x, y, b, h, farbe), pbc.fill_rect(…), pbc.ellipse(mx, my, rx, ry, farbe, fill=True)
Farben	pbc.WHITE, pbc.RED, pbc.YELLOW … und eigene Farben mit pbc.rgb(r, g, b)
Tasten	pbc.pressed_a() (solange gedrückt), pbc.was_pressed_a() (genau einmal pro Druck), ebenso für b, up, down, left, right, center; pbc.wait_for_button()
LEDs	pbc.led_red(True), pbc.led_yellow, pbc.led_green, pbc.leds_off(), pbc.rgb_led(r, g, b)
Ton	pbc.tone(frequenz, ms), pbc.tone_off()
Beschleunigungssensor	pbc.accel_x(), pbc.accel_y(), pbc.accel_z() in m/s²
Canvas	pbc.Canvas(240, 280) – ein Bild im Speicher, pbc.show(canvas) zeigt es flimmerfrei an; pbc.load_image("datei.png")
Sprites	s = pbc.sprite("datei.png"), s.show(), s.set_to(x, y), s.set_by(dx, dy), s.glide_to(x, y, ms), s.touches(anderes), s.touches_edge()
Turtle	t = turtle.Turtle(), t.forward(d), t.left(w), t.right(w), t.penUp(), t.setPenColor("green")

Dazu kommt das übliche Python: print und input, time.sleep_ms und time.ticks_ms, random.randint, Listen, Strings, f-Strings und Dateien mit open.

Beispiele aus dem Buch

Vier Programme aus verschiedenen Teilen des Buchs, genau so, wie sie dort stehen. Du kannst sie in PBC+ Studio abtippen und im Emulator starten.

Ein Haus mit Sonne (Kapitel 5)

Linien, Rechtecke, eine gefüllte Ellipse und drei eigene Farben. Alle Teile des Hauses werden von einem Punkt aus berechnet: haus_x und haus_y sind die linke obere Ecke der Wand. Ändert man diese zwei Zahlen, wandert das ganze Haus mit.

import pbc

himmel = pbc.rgb(110, 170, 250)
wiese = pbc.rgb(40, 160, 60)
wand = pbc.rgb(240, 220, 180)
haus_x = 50
haus_y = 150

# Hintergrund: Himmel und Wiese
pbc.clear(himmel)
pbc.fill_rect(0, 220, pbc.WIDTH, pbc.HEIGHT - 220, wiese)
# Sonne: erst die Strahlen, dann die Scheibe darueber
pbc.line(190, 10, 190, 90, pbc.YELLOW)
pbc.line(150, 50, 230, 50, pbc.YELLOW)
pbc.line(162, 22, 218, 78, pbc.YELLOW)
pbc.line(162, 78, 218, 22, pbc.YELLOW)
pbc.ellipse(190, 50, 25, 25, pbc.YELLOW, fill=True)
# Haus: Wand, Dach, Tuer, Fenster
pbc.fill_rect(haus_x, haus_y, 100, 70, wand)
pbc.line(haus_x - 10, haus_y, haus_x + 50, haus_y - 50, pbc.RED)
pbc.line(haus_x + 50, haus_y - 50, haus_x + 110, haus_y, pbc.RED)
pbc.hline(haus_x - 10, haus_y, 121, pbc.RED)
pbc.fill_rect(haus_x + 40, haus_y + 30, 20, 40, pbc.rgb(120, 70, 20))
pbc.fill_rect(haus_x + 12, haus_y + 15, 20, 20, pbc.CYAN)
pbc.rect(haus_x + 12, haus_y + 15, 20, 20, pbc.WHITE)
pbc.fill_rect(haus_x + 68, haus_y + 15, 20, 20, pbc.CYAN)
pbc.rect(haus_x + 68, haus_y + 15, 20, 20, pbc.WHITE)

Die Zaubertafel (Kapitel 8)

Mit dem Joystick malst du Linien. x und y merken sich, wo der Stift gerade ist. Der alte Punkt wird nie gelöscht, so entsteht eine Spur. Taste B wischt die Tafel leer. Die Endlosschleife while True ist das Grundgerüst jeder Spielschleife: lesen – rechnen – zeichnen – warten.

import pbc
import time

x = 120
y = 140

pbc.clear()
pbc.text12("B = alles loeschen", 60, 10, pbc.WHITE)

while True:
    if pbc.pressed_left():
        x -= 2
    if pbc.pressed_right():
        x += 2
    if pbc.pressed_up():
        y -= 2
    if pbc.pressed_down():
        y += 2
    if pbc.pressed_b():
        pbc.clear()
    pbc.fill_rect(x, y, 3, 3, pbc.CYAN)
    time.sleep_ms(10)

Ein Baum mit der Turtle (Kapitel 16)

Die Turtle ist eine Schildkröte mit Stift. Ein Baum ist selbstähnlich: Ein Ast teilt sich in zwei kleinere Äste, die sich wieder teilen. Deshalb ruft die Funktion ast sich selbst auf – jedes Mal mit 70 % der Länge und einer Stufe weniger. Bei Stufe 0 hört sie auf.

import turtle

WINKEL = 25


def ast(t, laenge, stufe):
    if stufe == 0:
        return
    t.forward(laenge)
    t.left(WINKEL)
    ast(t, laenge * 0.7, stufe - 1)     # linker Teilbaum
    t.right(2 * WINKEL)
    ast(t, laenge * 0.7, stufe - 1)     # rechter Teilbaum
    t.left(WINKEL)
    t.penUp()
    t.back(laenge)                      # zurück zum Anfang des Asts
    t.penDown()


t = turtle.Turtle()
t.setPenColor("green")
t.speed(10)
t.penUp()
t.back(125)
t.penDown()
ast(t, 70, 7)
t.hide()

Springende Bälle als Objekte (Zusatzkapitel)

Jeder Ball ist ein Objekt mit Position, Richtung, Größe und Farbe. Die Klasse Ball beschreibt, was jeder Ball kann: sich bewegen und sich zeichnen. Mit Taste A kommt ein Ball dazu, Taste B nimmt einen weg. Gezeichnet wird auf einen Canvas, damit nichts flackert.

import pbc
import random
import time

class Ball:
    def __init__(self, farbe):
        self.r = random.randint(6, 14)
        self.x = random.randint(self.r, pbc.WIDTH - self.r)
        self.y = random.randint(self.r, pbc.HEIGHT - self.r)
        self.dx = random.choice([-3, -2, 2, 3])
        self.dy = random.choice([-3, -2, 2, 3])
        self.farbe = farbe

    def bewege(self):
        self.x = self.x + self.dx
        self.y = self.y + self.dy
        # an einer Wand die Richtung umdrehen
        if self.x < self.r or self.x > pbc.WIDTH - self.r:
            self.dx = -self.dx
        if self.y < self.r or self.y > pbc.HEIGHT - self.r:
            self.dy = -self.dy

    def zeichne(self, bild):
        bild.ellipse(self.x, self.y, self.r, self.r, self.farbe, True)

FARBEN = [pbc.RED, pbc.GREEN, pbc.BLUE, pbc.YELLOW, pbc.CYAN, pbc.MAGENTA]
bild = pbc.Canvas(pbc.WIDTH, pbc.HEIGHT)
baelle = [Ball(f) for f in FARBEN]

while True:
    if pbc.was_pressed_a():
        baelle.append(Ball(random.choice(FARBEN)))
    if pbc.was_pressed_b() and len(baelle) > 0:
        baelle.pop()
    bild.fill(pbc.BLACK)
    for ball in baelle:
        ball.bewege()
        ball.zeichne(bild)
    bild.text12(f"Baelle: {len(baelle)}", 10, 10, pbc.WHITE)
    pbc.show(bild)
    time.sleep_ms(20)

Ein Blick ins Buch

Jedes Kapitel hat denselben Aufbau: Worum geht’s?, Erklärung mit Programmbeispielen, ein größeres Ausprobieren-Programm, Übungsaufgaben in drei Schwierigkeitsstufen (⭐ / ⭐⭐ / ⭐⭐⭐) und Das Wichtigste in Kürze. Die Lösungen zu allen Aufgaben stehen im Anhang. Alle Beispielprogramme laufen im Emulator.

Im Anhang: eine Befehlsübersicht, die häufigsten Fehlermeldungen mit Beispielen, die Lösungen und ein Teil für Fortgeschrittene über Bilder, Dateien auf dem Gerät und das Aufspielen der Firmware.

Das Projekt: Apfelfang

In Kapitel 21 setzt du fast alles zusammen, was du gelernt hast: Funktionen, Listen, Canvas, Sprites, Kollisionen und Dateien. Unten steht ein Korb, den du mit dem Joystick bewegst, von oben fallen Äpfel. Das Spiel entsteht in vier Stufen, von denen jede für sich läuft – bis zum Highscore, der in einer Datei auf dem Gerät gespeichert bleibt.

Programme auf dem Gerät

Mit ▶ Testen läuft ein Programm nur, bis du den PBC+ ausschaltest oder ein anderes Programm testest. Soll es bleiben, speicherst du es auf dem Gerät:

1. Gerät verbinden (Ziel PBC+, Verbinden).
2. Dateien → Auf den PBC+…, einen Dateinamen eingeben, z. B. bereit.py, und speichern.
3. Einmalig: Dateien → Startmenü installieren…

Danach zeigt der PBC+ beim Einschalten ein Menü mit allen gespeicherten Programmen; mit dem Joystick wählst du eins aus. Hinter dem Startmenü steckt eine main.py mit nur zwei Zeilen. Eine vorhandene main.py wird vorher in main(2).py umbenannt.

import pbc
pbc.menu()

• Dateien → Vom PBC+… holt ein Programm vom Gerät zurück in den Editor.
• Dateien → Dateien verwalten… zeigt alles im Speicher des Geräts: Programme, Bilder und Dateien, die deine Programme mit open() geschrieben haben. Du kannst Dateien herunterladen, löschen und hochladen.
• Dateien → Bilder verwalten… lädt PNG-Bilder für Sprites und Hintergründe hoch, Dateien → Bild zeichnen… öffnet einen kleinen Pixel-Editor.
• Ist das Gerät verbunden und läuft kein Programm, erreichst du im Terminal die REPL (>>>): Du tippst eine Anweisung, drückst Enter, und MicroPython führt sie sofort aus. Strg + C hält ein laufendes Programm an.

Im Emulator gibt es keine REPL. Dateien, die ein Programm dort mit open() schreibt, bleiben nur bis zum Neuladen der Seite erhalten; hochgeladene Bilder bleiben im Browser gespeichert.

Wenn etwas schiefgeht

Fehlermeldungen gehören dazu. Eine Meldung (ein Traceback) liest du am besten von unten nach oben: Die letzte Zeile nennt die Fehlerart und eine kurze Beschreibung auf Englisch, darüber steht die Zeilennummer.

punkte = 0
for runde in range(3):
    punkte = punkte + 10
print("Ergebnis:", punkt)

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
NameError: name 'punkt' isn't defined

Die Variable heißt punkte, in Zeile 4 steht aber punkt. Python unterscheidet jeden Buchstaben und auch Groß- und Kleinschreibung. Zusätzlich öffnet PBC+ Studio ein Hinweisfenster mit einer Erklärung auf Deutsch.

Fehlerart	Hinweisfenster	Häufige Ursache
SyntaxError	Schreibfehler im Code	Doppelpunkt nach if, for, def … fehlt, Klammer oder Anführungszeichen fehlt. Das Programm startet gar nicht.
IndentationError	Einrückung stimmt nicht	Zeilen, die zusammengehören, sind nicht gleich weit eingerückt.
NameError	Unbekannter Name	Tippfehler im Namen, import pbc vergessen
AttributeError	Unbekannte Funktion oder Eigenschaft	pbc.white statt pbc.WHITE, add statt append
TypeError	Falscher Typ	Text und Zahl mit + verbunden, eine Zahl direkt an pbc.text24 gegeben, return vergessen
ValueError	Eingabe ist keine Zahl	Text, der sich nicht in eine Zahl umwandeln lässt, z. B. int("3.5") oder float("3,5") mit Komma
IndexError	Listen-Position außerhalb	Index zu groß – der größte ist len(liste) - 1
OSError	Datei nicht gefunden	Datei lesen, die es noch nicht gibt, z. B. beim ersten Start mit Highscore
MemoryError	Nicht genug Speicher	sehr lange Listen, viele Bilder oder mehrere große Canvas

Zwei Stolpersteine kommen besonders oft vor: input liefert immer einen String, auch wenn eine Zahl eingetippt wird – dann hilft int(input(…)). Und die pbc.text-Befehle erwarten Text: pbc.text24(str(punkte), 20, 20, pbc.WHITE) oder mit f-String f"Punkte: {punkte}".

Läuft ein Programm ohne Meldung, macht aber etwas anderes als gedacht, lässt du dir mit print die Werte der Variablen ausgeben. Oft endet ein range eine Zahl zu früh oder eine Zeile ist falsch eingerückt.

Für den Unterricht

Das Buch eignet sich für den Informatikunterricht ab Klasse 8: viele kurze Programme, Aufgaben in drei Stufen und Lösungen. Ohne Geräte geht es mit dem Emulator, mit Geräten kommen Sensor, Ton und Dateien dazu. Stundenverläufe und mehr stehen im Lehrerhandbuch, weiteres zum Einsatz im Unterricht auf der Seite für Schulen.

Quellcode

• pbc-micropython – die MicroPython-Firmware mit dem Board PBC_PLUS und dem Modul pbc