Alle Sidepanels auf-/zuklappen

Zeichnen in Python

Anforderungen an Inspirer

Um Python zu erklären, solltest du selbst Erfahrung mit Python haben. Wenn du einen Python-Kurs geben willst, check Folgendes für dich ab:

Du bist in der Lage funktionsfähige Pythonskripte zu erstellen und Fehler zu debuggen.
Du weißt, wie Repl funktioniert und kannst eine verständliche und hilfreiche Einführung dazu halten.
Du kannst mit 9.- 11.-Klässler:innen so kommunizieren, dass sie sich ernst genommen fühlen.
Du kannst eine Balance zwischen Verständnis, Echtheit der Programmiererfahrung und Interessenförderung für jeden Teilnehmenden finden. Das kann bei einer abstrakteren Sprache wie Python schwierig werden - aber wenn du dir dessen bewusst bist, machst du das bestimmt auch gut.

Genereller Ablauf

Der Kurs beginnt mit der Begrüßung im Plenum. Ein erfahrener Inspirer übernimmt die Einführung in das Thema und versucht sicherzustellen, dass die Technik bei den Meisten funktioniert. Danach werden die Teilnehmenden in kleine Teams eingeteilt. Jeder Inspirer ist während dem Kurs für etwa 4 bis 6 Teilnehmende verantwortlich.
Die eingeteilten Teams werden in Breakout-Rooms (bei Zoom) eingeteilt. Wenn ihr in den Breakout Rooms Fragen habt, ruft gerne über Zoom um Hilfe. Der Haupt-Inspirer wird dann zu euch in den Breakout-Room kommen.
Vorstellungsrunde in den Gruppen. Stellt euch einmal vor und erklärt gerne, wie ihr zu der IT gekommen seid. Lasst die Teilnehmenden sich vorstellen, inklusive Programmiererfahrung, Erwartungen und Motivation.
Jetzt geht es ans Eingemachte: Programmieren! Mehr Informationen zu den Einheiten findet ihr unten.
Versucht nach etwa der Halbzeit eine Pause von 30 Minuten einzulegen.
Der Abschluss findet wieder im Plenum mit der gesamten Klasse statt. Hier stellt sich jeder Inspirer einmal kurz vor und erklärt, warum er*sie für IT brennt.

P.S.: Vergesst nicht, eure Pausen zu machen 🙂

Hinweise zum Konzept

Lernziele

Es geht darum, die Teilnehmenden zu begeistern. Unser Ziel ist es, dass sie nach den 3 Stunden Kurs Interesse haben, noch weiter zu recherchieren und zu programmieren. Wie das bei euch konkret aussieht, ist euch überlassen. Ihr merkt, die Teilnehmenden haben voll Lust mit euch eine halbe Stunde über Roboter zu reden? Macht das gerne.
Versucht eher, den Teilnehmenden grundlegende Konzepte beizubringen (“Wie debugge ich ein Programm?”), als Ihnen diese eine Eigenheit von Python lang und breit zu erklären. Zeigt/erklärt ihnen auch gerne, wo das, was sie gerade lernen, im echten Leben zum Einsatz kommt.
Lasst die Teilnehmenden so viele Schritte wie möglich selbst gehen. Sie werden so am meisten lernen, und sind hoffentlich auch in der Lage, an das Gelernte nach Ende des Kurses anknüpfen zu können.
Lasst sie dabei auch scheitern. Im Optimalfall versucht ihr dann mit ihnen gemeinsam zu ergründen, wieso ihr Ansatz nicht funktioniert hat – dadurch müssen sie ihre Gedanken kommunizieren und lernen so mehr.
Dieses Konzept ist unser Vorschlag, wie man Kinder und Jugendliche begeistern könnte. Seht es also mehr als groben Leitfaden und weniger als festen Lehrplan.

Feedback und Fragen an kurskonzepte@hacker-school.de.

Technologie

Wir arbeiten während dem Kurs mit dem Online-Editor Repl.it -> https://repl.it
Wie genau die Kids sich einloggen und mit welchen Accounts sie arbeiten, erklärt der Team-Inspirer am Anfang im Plenum. Das ist also nicht eure Aufgabe, darum kümmern wir uns.

Konzept

Begrüßung und generelle Motivation

Wer sind wir und was wünschen wir uns? (an die Kinder gerichtet)

Hacker School: Wir wollen, dass ihr alle etwas mitnehmen könnt. Uns ist es lieber, dass ihr Zusammenhänge verstanden habt, aber dafür insgesamt weniger Stoff. (Wird trotzdem vorkommen, dass euch Dinge überfordern, aber das ist normal. Behaltet das trotzdem im Hinterkopf)
Vordergründig bringen wir euch heute Programmieren bei, aber eigentlich geht es uns auch darum, euch mit Menschen zusammenzubringen, die das richtige Mindset haben. Damit ihr von Ihnen lernen könnt. Wenn ihr inhaltlich überhaupt nichts verstehen solltet, aber dafür die Fehlerkultur mitnehmt, sind wir happy.
A propos Fehlerkultur: Wenn ihr etwas nicht versteht – fragt nach. Das hier soll alles werden, bloß kein Frontalunterricht, in dem ihr Dinge schlucken, verdauen und nachher wieder auskotzen sollt. Uns geht es darum, dass ihr Spaß habt, und vor allem: etwas für euch lernt und mitnehmt. Und gerade dem stehen so ein paar Dinge im Weg, wie: Schon beim ersten kleinen Fitzelchen Syntax zu scheitern. Also: Wenn ihr jetzt gleich bei euren Inspirern seid und euer Programm nicht funktioniert, was macht ihr dann? Richtig. Fragt nach.

grober inhaltlicher Überblick
zeitlicher Überblick
Einmal kurz die Technologie durchgehen

Vorstellungsrunde

Stellt euch selber vor. (2-3 Sätze)

Was habt ihr gemacht, als ihr so alt wart wie die Teilnehmenden?

Lasst die Teilnehmenden sich vorstellen.

Wie heißt du?
Hast du schonmal programmiert?
Was erhoffst du dir von diesem Kurs?

Wichtig: achtet darauf, dass die Kinder sich nur mit Vornamen vorstellen – Datenschutz.

Hallo!

Teaser fürs Plenum

Ein*e (Team-)Inspirer*ess kopiert den Code in eine Repl und lässt die Teilnehmenden staunen :)

from turtle import *
def draw_line(x1, y1, x2, y2):
    penup()
    goto(x1, y1)
    pendown()
    goto(x2, y2)
def draw_circle(xs, ys, radius, farbe="black"):
    penup()
    goto(xs, ys)
    pendown()
    color(farbe)
    circle(radius)
    color("black")
def char_h(x):
    draw_line(x, 0, x, 50)
    draw_line(x, 25, x+20, 25)
    draw_line(x+20, 0, x+20, 50)
def char_e(x):
    penup()
    goto(x, 0)
    pendown()
    seth(180)
    circle(-10, 270)
    seth(0)
    back(20)
def char_a(x):
    draw_circle(x, 0, 10)
    draw_line(x+10, 0, x+10, 20)
def char_ex(x):
    draw_line(x, 15, x-5, 50)
    draw_line(x-5, 50, x+5, 50)
    draw_line(x+5, 50, x, 15)
    draw_circle(x, 0, 4)
def hello():
    char_h(-110)
    char_e(-70)
    draw_line(-50, 0,-50 , 50)
    draw_line(-30, 0, -30, 50)
    draw_circle(-10, 0, 10)
    char_ex(20)
hello()

Linien

Kopiert (oder schreibt) untenstehendes Programm in eure Repl, und führt es aus.
Was scheint es zu tun? (Was sagt der Name der Funktion aus?)

Lasst die Teilnehmenden den Code in ihre eigenen Repl übernehmen (abgetippt oder kopiert, je nach Überforderungsgrad :))
Schaffen die Teilnehmenden es, Dinge so zu verändern, dass die Linie da hinkommt, wo sie wollen? Zum Beispiel horizontal, oder vertikal?

Lernziele

korrekte Benutzung von draw_line()

Code

from turtle import *
def draw_line(x1, y1, x2, y2):
    penup()
    goto(x1, y1)
    pendown()
    goto(x2, y2)
draw_line(0, 0, 10, 0)

Ein Dreieck!

Teilt euren Bildschirm und wagt euch zu dem Code weiter unten vor.
Es kann gut sein, dass das Konzept eines Koordinatensystems noch nicht vollkommen gefestigt ist. Vergesst nicht, das zu überprüfen und gegebenenfalls darauf einzugehen.

Lernziele

Zusammensetzung kleinerer Teile zu etwas Größerem - zum Beispiel einem Dreieck :)
Koordinatensysteme verstanden haben (und mit ihnen umgehen können.)

Code

draw_line(0, 0, 50, 0)
draw_line(50, 0, 25, 42)
draw_line(25, 42, 0, 0)

Funktionen

Eine kleine Motivation für Funktionen: Was ist eigentlich eine Funktion, wofür kann man sie benutzen? -> in unserem Fall ist das relativ naheliegend: Wir wollen den Code für das Dreieck einfach wiederverwenden können.
Die Funktion dreieck(x1, y1, x2, y2, x3, y3) wird in der Gruppe live gecodet.
Lasst die Teilnehmenden zunächst dreieck nachcoden - so können wir das Grundverständinis überprüfen, bevor sie selbst Hand anlegen. Zusätzlich wiederholen sie damit das Gesehene, was ihnen hilft, gleich selbst weiterzumachen. Vorschläge für weiterführende Funktionen:
- viereck(x1, y1, x2, y2, x3, y3, x4, y4)
- rechteck(x, y, breite, laenge)
- quadrat(x, y, groesse)
- stern(x, y, groesse)
Wichtig: Diese Funktionen müssen weder alle gecodet werden, noch müssen es zwangsläufig genau diese Funktionen sein. Die Teilnehmenden haben ganz bestimmt eigene Ideen. Nutzt sie ;)

Lernziele

Wie man Funktionen definiert:
1
def <name>(*params): <body>
Was Funktionen sind (mehr als diese Graphen in Mathe): eine Zusammenführung von Dingen (z.B. Abläufen) unter einen gemeinsamen Namen.
Wie Funktionen einem Arbeit abnehmen können – das sollte hier ziemlich gut ersichtlich sein.

Code

#Diese Funktion wird live gecodet
def dreieck(x1, y1, x2, y2, x3, y3):
    draw_line(x1, y1, x2, y2)
    draw_line(x2, y2, x3, y3)
    draw_line(x3, y3, x1, y1)

Schleifen

Eine kleine Motivation für Schleifen: Was können wir machen, wenn wir ganz viele Dreiecke auf einmal zeichnen wollen?
Codet eine for-Schleife in der Gruppe live.
Stellt wieder sicher, dass es keine Syntax- oder Verständnisprobleme gibt, bevor sie alleine loslegen. Lasst sie also selbst eure for-Schleife nachcoden, bevor sie mit etwas Eigenem loslegen.
Und dafür sollte range() auf jeden Fall genutzt werden können.

Lernziele

Wie man Schleifen erstellt – for <var> in <iterator>: <body>
Wie man range() mit ein, zwei und drei Aufrufargumenten benutzt
einige Beispiele gesehen (und verstanden) haben – es sollte reichen, wenn sie ein bisschen mit dem Code dieses Abschnittes herumspielen.

Code

for size in range(0, 100, 10):
    dreieck(0, 0, 0, size, size, 0)
for size in range(0, 100, 10):
    draw_line(0, 0, size, 0)

Wenn ihr hier bei in etwa der Hälfte der Zeit seid (und noch keine gemacht habt), würde sich hier eine längere Pause von 30 Minuten anbieten. Dadurch entsteht eine klare Einteilung zwischen fachlichem Input und Projektarbeit.

draw_line() erweitern

Was macht eigentlich diese Funktion, die wir bisher immer genutzt haben?

def draw_line(x1, y1, x2, y2):
    penup()
    goto(x1, y1)
    pendown()
    goto(x2, y2)

Sie:

Setzt den Stift ab.
Geht zu den ersten Koordinaten.
Nimmt den Stift wieder auf.
Und geht zu den zweiten Koordinaten.

Schön und gut, aber es wäre hilfreich, auch noch andere Farben außer Schwarz zeichnen zu können. Das geht (zum Beispiel) so:

def draw_line(x1, y1, x2, y2, farbe="black"):
    penup()
    goto(x1, y1)
    pendown()
    color("green")
    goto(x2, y2)
    color("black")

Anmerkungen:

farbe ist hier ein sogenanntes keyword-Argument (mit Standardwert)
Am Ende setzen wir die Farbe wieder auf Schwarz, damit nicht alle Linien ab da in der neuen Farbe gemalt werden.

Lernziele

Wie man eine Funktion mit Keyword-Argument aufruft (und schreibt) – also:

man schreibt sie als eine "ganz normale" Funktion, aber
kann sie aufrufen mit keyword=value

Das neue draw_line benutzen können

Code

def draw_line(x1, y1, x2, y2, farbe="black"):
    penup()
    goto(x1, y1)
    pendown()
    color(farbe)
    goto(x2, y2)
    color("black")
draw_line(0, 0, 0, 100, farbe="green")

Projektarbeit

Von hier an ist alles offen. Die Teilnehmenden dürfen gerne ihre eigenen Formen coden und eigene Ideen umsetzen.
Das unten sollte im Normalfall reichen, falls ihr allerdings mehr wollt/braucht, lohnt es sich sicherlich auch, mal einen Blick in die Dokumentation zu werfen.
Einige Ideen als Inspiration: Man kann ...

... die Größe der Striche verändern: pensize(groesse), wobei der Standard groesse = 1 ist.
... die Zeichengeschwindigkeit verändern: speed(v), Standard: v = 1
... Kreise zeichnen: circle() aus Turtle tut genau das – aber hier lohnt es sich wahrscheinlich, auch wieder eine kleine Hilfsfunktion zu schreiben: draw_circle

def draw_circle(xs, ys, radius, farbe="black"):
    penup()
    goto(xs, ys)
    pendown()
    color(farbe)
    circle(radius)
    color("black")

Beispielprojekt + Ideen

Sollte gar nichts kommen, hier einmal eine ausgearbeitete Idee, wohin es gehen könnte:

def draw_starship(xs, ys, size):
    for i in range(0, size * 11, size):
        draw_line(xs + (size * 10) - i,
                  ys + 3 * (-(size * 10) + i),
                  xs + -i,
                  ys + (-3*i))
def draw_fleet():
    for j in range(-9, 11, 2):
        draw_starship(25 * j, 25 * -abs(j), 2)
draw_fleet()

Na, was passiert? :)

Abschluss

In eurer Gruppe:

~5 min

Wenn ihr eurer Gruppe am Ende noch Feedback geben wollt, dann nehmt euch gerne jetzt Zeit dafür.
Fragt nach, ob jemand (in der Abschlussrunde im großen Plenum) vorstellen möchte, was ihr so gemacht habt.

Im Plenum:

~20 min

Die Teilnehmenden stellen ihre Projekte vor (eine*r pro Gruppe), und erzählen ein bisschen, was sie so gemacht haben.
Die Inspirer reden über sich, wie sie zur IT gekommen sind, was ihnen daran Spaß macht, wieso sie es weiterhin machen wollen, und was sie den Jugendlichen gerne mitgeben möchten.
(Wenn erwünscht, bekommt der*die Lehrer*in kurz das Wort)
Feedbacklink geht raus

← Hacker School @yourschool

Grundlagen des Programmierens in Python →