Newer
Older
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
"- Bitte tragt euch in **beide Moodle Kurse** ein. Ankündigungen werden dort veröffentlicht! Wer sich nicht anmeldet und nicht regelmäßig ins Forum schaut, hat Pech gehabt.\n",
" - Man kann einstellen, dass man Emails bei neuen Forumbeiträgen bekommt, um keine Neuigkeiten zu verpassen."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **Pair-Programming** bitte einhalten: **\"nicht gleichzeitig\"** programmieren, sondern **abwechselnd aktiv** sein. Das ist für alle Beteiligten ein Vorteil!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **Latex**: Tutorium oder Übung. Im Seminar benutzen wir nur Jupyter-Notebooks"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **WICHTIG** bei Ankündigungen am Ende der Stunde: Bitte Jupyter Notebooks durcharbeiten oder versuchen. Ich verstehe, dass man nicht immer alle Übungen alleine schafft, aber zumindest die Theorie kann man mit seinem Partner durcharbeiten. \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **HILFE** bei Aufgaben: \n",
" - Email \n",
" - Tutorium\n",
" - vorbeikommen (Raum 12)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Alternativer Python-Kurs für Interessierte: https://automatetheboringstuff.com/"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Python Tutor\n",
"Eine gute Hilfe ist die Webseite: http://www.pythontutor.com.\n",
"Dort könnt ihr euren Python Code hochladen und Schritt für Schritt durchführen. \n",
"Probiert es aus *(Achtung: Sie müssen die Funktion auch dort aufrufen)*. \n",
"- Kurze Anleitung:\n",
" - Nehmt einen Browser eurer Wahl und ruft http://www.pythontutor.com auf.\n",
" - Klickt auf *Visualize your code and get live help now*\n",
" - Copy-Paste euren Code in das Textfenster\n",
" - Drückt auf Visualize Execution (jetzt solltet ihr auf eine neue Seite gelangt sein)\n",
" - Mit den Buttons (First,Back,Forward,Last) könnt ihr jetzt jeden Schritt nachvollziehen, den python macht, wenn ihr den Code im Jupyter-Notebook aufruft. \n",
"\n",
"\n",
"- Der Vorteil ist natürlich, dass ihr nun Schritt für Schritt nachvollziehen könnt, was euer Code macht. \n",
" - Es gibt eine print box, wo alles ausgegeben wird, was durch print() auf eurem Display auch ausgegeben werden würde\n",
" - Darunter werden Variablen, Funktionen und Methoden angezeigt. \n",
"\n",
"Besonders hilfreich beim Thema **REKURSION**."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h1><center> Zu den Jupyter-Notebooks </center></h1>\n",
"\n",
"### was mir an python gefällt:\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Im Exkurs **\"was mir an python gefällt\"** muss der Code nicht geändert werden. Es reicht, den Code auszuführen mit **\"Strg+Enter\"** und das Ergebnis zu verstehen. Schaut euch den Code an und versucht zu verstehen, was gemacht wird. Einige Anweisungen kennt ihr bereits, andere widerum sind neu. \n",
"\n",
" - Dieser Exkurs soll zeigen, zu was python alles fähig ist und für was ihr Python in Zukunft benutzen könnt :)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **Markdownblöcke** (das sind normalerweise die Textblöcke) kann man mit **\"Strg + enter\"** wieder in den Lesemodus bringen\n",
"- **Codeblöcke** (das sind normalerweise die Blöcke, indem der Pythoncode steht) kann man mit **\"Strg + enter\"** ausführen"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- **Download**: Linksklick auf das Notebook (z.B. seminar03.ipynb) -> Rechtsklick auf Feld \"Open Raw\" -> Ziel speichern unter \n",
"- Download von Notebooks mit Firefox!\n",
"- Öffnen von Jupyter-Notebook geht auch mit Internet-Explorer"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Falls ihr einen Codeblock ausführt und **ein Stern erscheint: \"In [ * ]\" **, bedeutet das, dass der Code gerade ausgeführt wird. \n",
"- Manchmal bleibt das Notebook aber auch einfach hängen, dann benutzt folgende Möglichkeit: **Menüleiste-> Kernel-> restart and clear output**. Damit wird das Notebook komplett neu geladen, allerdings müsst ihr die vorherigen Codeblöcke auch neu ausführen."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Einrücken durch die **\"Tabulatortaste\" (tab)**, um die richtige Formatierung einfach zu bekommen (bei Definitionen von Funktionen, for- oder while-Schleifen, if-Bedingungen, etc.)\n",
"- Falsches Einrücken ergibt häufig den Fehler: **IndentationError**\n",
"- Beispiel:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def example():\n",
" i=0\n",
" while i <= 5:\n",
" if i<1:\n",
" print(\"Mit der tab-Taste kann man immer 'eins weiter' einrücken.\")\n",
" elif i==5:\n",
" print(\"Mit 'tab' und 'shift' gleichzeitig rückt man 'eins' wieder nach hinten.\")\n",
" i=i+1\n",
" \n",
"example()"
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Jupyter-Notebook wird immer in dem Browser geöffnet, der auf dem Computer als Standardbrowser festgelegt ist.\n",
"Im PC-Pool ist das zur Zeit der Internet-Explorer und wir können das leider nicht ändern.\n",
"Dadurch funktionieren manche Shortcuts leider nicht.\n",
"\n",
"Auf euren PC's zu Hause könnt ihr es aber einfach ändern: \n",
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
"(Wir empfehlen Firefox als Standardbrowser)\n",
"\n",
"macOS:\n",
"\n",
" 1. Öffnen sie die Systemeinstellungen.\n",
" 2. Klicken Sie auf „Allgemein“.\n",
" 3. Wählen Sie unter „Standard-Webbrowser“ den gewünschten Browser aus.\n",
"\n",
"Ubuntu Linux:\n",
"\n",
" 1. Öffnen Sie die System Settings.\n",
" 2. Klicken Sie auf „Applications“.\n",
" 3. Wählen Sie in der linken Spalte „Default Applications“ aus.\n",
" 4. Klicken Sie in der Spalte rechts davon auf „Web Browser“.\n",
" 5. Wählen Sie „in the following browser:“ aus.\n",
" 6. Wählen Sie den gewünschten Browser aus.\n",
"\n",
"Windows:\n",
"\n",
" 1. Öffnen Sie die Systemsteuerung.\n",
" 2. Klicken Sie auf „Standardprogramme“.\n",
" 3. Klicken Sie auf „Standardprogramme festlegen“.\n",
" 4. Klicken Sie in der Liste auf den gewünschten Browser.\n",
" 5. Klicken Sie dann auf „Dieses Programm als Standard festlegen“.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h1><center> Beispielcode</center></h1>"
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Kommentare\n",
"\n",
"- Kommentare in Codeblöcken kann man mit Hilfe von # schreiben"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# We are inside a Code block. \n",
"# But with the help of # we can still write whatever we want to document our code. This is really helpful.\n",
"# Shortcut: Str+/ (comment and uncomment)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Zusätzlich gibt es Docstrings (kurz für Documentation strings). Die Syntax sind drei Gänsefüßchen am Anfang und am Ende der Zeichenkette. Damit könnt ihr eure Funktionen und Methoden gut beschreiben, Zeilenumbrüche funktionieren."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def function(): \n",
" \"\"\"\n",
" Do nothing, but document it.\n",
" No, really, it doesn't do anything. \n",
" \"\"\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Zahlen - float"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Gleitkommazahlen (floats) immer mit **Punkt** statt **Komma* angeben -> 29.99 statt 29,99"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"preis=29.99\n",
"print(preis)\n",
"print(type(preis))\n",
"# python erkennt die Zahl und gibt die Zahl wieder. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"preis=29,99\n",
"print(preis)\n",
"type(preis)\n",
"# Python erkennt zwei Zahlen, die es in einem Tupel speichert."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Print - Funktion\n",
"- Die Print-Funktion \"print()\" kann mehrere Argumente entgegennehmen. Das können ganz verschiedene Datentypen sein. Die verschiedenen Argumente müssen jeweils durch Kommata getrennt werden.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Beispiele:\n",
"\n",
"# Der print-Befehl ist eine überaus nützliche Funktion in python. \n",
"# Wir können uns damit an jeder Stelle unseres Codes Zwischenergebnisse,\n",
"# Ergebnisse, Variablen, etc. ausgeben lassen.\n",
"\n",
"#Zeichenketten:\n",
"print(\"\\n \\n Jetzt kommen wir zu den Zeichenketten \\n\")\n",
"print(\"Hallo! Schön, dass du es hierher geschafft hast :)\")\n",
"\n",
"#Zahlen:\n",
"print(\"\\n \\n Jetzt kommen wir zu den Zahlen \\n\")\n",
"print(10)\n",
"print(10,20,30)\n",
"\n",
"#Variablen:\n",
"print(\"\\n \\n Jetzt kommen wir zu den Variablen \\n\")\n",
"a=10\n",
"print(a)\n",
"\n",
"#Verkapselungen:\n",
"print(\"\\n \\n Jetzt kommen wir zu den Verkapselungen \\n\")\n",
"print(\"Die Lösung lautet:\", 100, \"Hier kann noch mehr Text stehen\")\n",
"\n",
"print(\"Zeichenketten kann man auch mit dem + Operator verbinden:\"+\" Das kann man hier sehen.\")\n",
"print(\"Zahlen dagegen werden dadurch addiert und die Summe wird ausgegeben: \", 5+4)\n",
"\n",
"\n",
"a=10\n",
"b=20\n",
"c=\"Hier könnte alles stehen.\"\n",
"print(\"Wir können auch Variablen dazunehmen:\",a,b,c)\n",
"\n",
"# Jetzt kommen komplizierte Beispiele:\n",
"print(\"\\n \\n Jetzt kommen wir zu komplizierte Beispiele \\n\")\n",
"print(\"Durch verschiedene Zeichen kann man den Output der Print-Funktion 'verschönern'. \\n\")\n",
"\n",
"print('\"\\\\n\" : erzeugt einen Zeilenabsatz \\n' )\n",
"print(\"Beispiel: \\n\", \"Hello \\n , \\n World \\n ! \")\n",
"\n",
"print('\"\\\\t\" : rückt den anschließenden Abstand um einen festen Abstand vor \\n' )\n",
"print(\"Beispiel: \\t\", \"Hello \\t , \\t World \\t ! \")\n",
"print(\"\\n\")\n",
"\n",
"\n",
"print('Bis jetzt konnten wir diese Anweisung in einer Zeichenkette ausühren.Man kann der print Funktion auch einen zusätzlichen Befehl übergeben: \"sep=\\\\n\" oder \"sep=\\\\t\"')\n",
"print(\"Dieser Befehl definiert den Abstand zwischen verschiedenen Anweisungen innerhalb der print-Funktion\")\n",
"print(\"BeispieL: \",\"Jetzt\", \"werden\", \"wir\", \"zwischen\", \"jeder\", \"Anweisung\", \"einen\", \"Abstand\", \"definieren\", sep=\"\\t\")\n",
"print(\"BeispieL: \",\"Jetzt\", \"werden\", \"wir\", \"zwischen\", \"jeder\", \"Anweisung\", \"einen\", \"Abstand\", \"definieren\", sep=\"\\n\")\n",
"\n",
"\n",
"#Macht euch den Unterschied zwischen \\t und \\n innerhalb einer Zeichenkette und sep=\"\\n\" bzw. sep=\"\\t\" klar.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"40/1.61 \n",
"#Hier rechnen wir 40km in Meilen um. Das Ergebnis, welches Python ausgibt, bitte nicht für weitere Rechnungen verwenden.\n",
"# Stattdessen können wir einfach den Term in Klammern benutzen (40/1.61) oder die Rechnung in einer Variable speichern (z.B. Meilen= 40/1.61)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#example\n",
"#Ein Mann hat eine 40km Fahrradtour in 2h absolivert. \n",
"#1. Wieviele Sekunden pro Meter ist er im Durchschnitt gefahren?\n",
"#2. Mit wieviel Meter pro Minute war er im Durchschnitt unterwegs?\n",
"#3. Mit wieviel Meilen pro Stunde war er im Durchschnitt unterwegs?\n",
"#solution:\n",
"#Zeit in verschiedenen Einheiten\n",
"Stunden=2\n",
"Minuten=Stunde*60\n",
"Sekunden=Minute*60\n",
"#Strecken in verschiedenen Einheiten\n",
"Kilometer=10\n",
"Meter=40*1000\n",
"Meilen=40/1.61\n",
"print(\"In einer print()-Funktion kann man\",\"mehrere Zeichenketten und Variablen\", \" durch Kommata trennen und zusammen ausgeben\")\n",
"print(\"Sekunden pro Meter :\", Sekunden/Meter)\n",
"print(\"Meter pro Mintue :\", Meter/Minuten)\n",
"print(\"Meilen pro Stunde :\", Meilen/Stunden, \"Perfekt\")\n",
"print(\"Meilen pro Stunde :\", (40/1.61)/Stunden, \"Okay\")\n",
"print(\"Meilen pro Stunde :\", 24.844720496894407/Stunden, \"Bitte nicht gerundete Zahlen übernehmen\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"Division von integers \\n\")\n",
"#Teilen von Ganzzahlen (integers oder int) mit \"/\" (gibt den genauen Wert zurück, typ=float)\n",
"print(\"Hier dividieren wir mit Hilfe von /: \",2/60,3/2,8/3, sep='\\t')\n",
"\n",
"#Teilen von Ganzzahlen (integers oder int) mit \"//\" (gibt den abgerundeten Wert wieder, typ=int)\n",
"print(\"Hier dividieren wir mit Hilfe von //: \",2//60,3//2,8//3, sep='\\t')\n",
"#Teilen von Float und Ganzzahlen (integers oder int) mit \"/\" (gibt den genauen Wert zurück, typ=float)\n",
"print(\"Hier dividieren wir mit Hilfe von /: \",2/60.0,3.0/2,8.4/3,sep='\\t')\n",
"#Teilen von Float und Ganzzahlen (integers oder int) mit \"//\" (gibt den abgerundeten Wert wieder, typ=float)\n",
"print(\"Hier dividieren wir mit Hilfe von //: \",2//60.0,3.0//2,8.4//3,sep='\\t')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Importieren von Modulen und Bibliotheken"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Stellen Datentypen oder Funktionen für alle Python-Programme bereit\n",
"- Syntax: `import module` \n",
"- Konvention: Steht **immer am Anfang des Codes**\n",
"- Beispiel:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import math\n",
"import turtle\n",
"import csv\n",
"\n",
"#hier steht Code"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Funktionen\n",
"\n",
"Funktion funktionieren in Python wie mathematische Funktionen aus der Schule: \n",
"\n",
"Stellt euch die Funktion f(x,y)=x*y vor. In Python definieren wir sie wie folgt:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Jetzt haben wir die Funktion zwar definiert, aber sie gibt noch kein Ergebnis zurück. Das passiert nur, wenn wir die Funktion aufrufen. \n",
"\n",
"Um die Funktion aufzurufen, müssen wir die Parameter x und y explizit angeben, z.B. x=5 und y=3. \n",
"\n",
"In der Schule haben wir früher Folgendes geschrieben: f(5,3)=5*3=15. \n",
"\n",
"In Python machen wir nichts anderes, nur das Berechnen überlassen wir python:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"Wenn eine Funktion einen return-Rückgabewert hat, muss man die Funktion durch print() aufrufen, um das Ergebnis angezeigt zu bekommen. \\n\")\n",
"f(5,3)\n",
"print(\"Wie man sieht, wird nichts auf das Display ausgegeben. Also verschachteln wir unser Funktionsaufruf f(5,3) in einen print()-Aufruf. \\n\")\n",
"\n",
"print(\"Es gibt verschiedene Wege:\")\n",
"print(f(5,3)) \n",
"\n",
"print(\"\\nAlternative 1:\")\n",
"print(f(x=5,y=3)) \n",
"\n",
"print(\"\\nAlternative 2:\")\n",
"variable_x=5 \n",
"variable_y=3\n",
"print(f(variable_x, variable_y)) "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def beispiel(x):\n",
" print(x)\n",
" \n",
"print(\"Falls die Funktion kein return hat, sondern nur print-Anweisungen, dann reicht es, die Funktion aufzufen.\") \n",
"print(\"print() innerhalb der Funktion gibt x aus. \\n\")\n",
"\n",
"beispiel(\"Das ist ein Funktionsaufruf und diese Zeichenkette ist unser Parameter x\")\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Fazit**: Um eine Funktion aufzurufen und ein Ergebnis herauszubekommen, reicht es nicht, die Funktion zu definieren. Sie muss anschließend **aufgerufen** werden. Die **Parameter müssen explizit** angegeben werden."
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Turtle Modul\n",
"\n",
"- Dokumentation mit allen turtle-Methoden: https://docs.python.org/3/library/turtle.html\n",
"- Im Idealfall sollte in jedem Codeblock die folgenden Anweisungen stehen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Zuerst wird das Modul turtle importiert\n",
"import turtle\n",
"\n",
"\n",
"#hier steht euer Code\n",
"\n",
"\n",
"\n",
"# Um ein Arbeiten mit turtle und Jupyter-Notebook zu ermöglichen, müssen wir diese beiden Befehle am Ende des Blocks schreiben\n",
"\n",
"turtle.mainloop()\n",
"turtle.bye()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Zuerst wird das Modul turtle importiert\n",
"import turtle\n",
"\n",
"#Hier lernen wir die Funktionen up(), down() und fd() kennen\n",
"\n",
"otto=turtle.Turtle()\n",
"\n",
"def line(t):\n",
" t.fd(50)\n",
" t.up()\n",
" t.fd(50)\n",
" t.down()\n",
" t.fd(50)\n",
" t.fd(50)\n",
" t.up()\n",
" t.fd(50)\n",
" t.fd(50)\n",
" t.down()\n",
" t.fd(50)\n",
"# Um ein Arbeiten mit turtle und Jupyter-Notebook zu ermöglichen, müssen wir diese beiden Befehle am Ende des Blocks schreiben\n",
"line(otto)\n",
"turtle.mainloop()\n",
"turtle.bye()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Kommentare -> commit -> nicht zu bdeuten"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import turtle\n",
"\n",
"otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
"anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
"telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
"\n",
"#Hier lernen wir die Funktionen shape(), color(), fd() und lt() kennen\n",
"\n",
"def square(t): \n",
" t.shape('turtle') #wir geben der turtle t die Form einer Schildkröte\n",
" t.color(\"purple\",\"red\") #wir färben den zurückgelegten Weg lila (erstes Argument), die Schildkröte rot (zweites Argument)\n",
" for k in range(4): #schleife (4 Aufrufe): unsere turtle läuft in jedem Aufruf zuerst gerade aus und wendet sich dann um 90° nach links.\n",
" t.fd(100)\n",
" t.lt(90) \n",
"\n",
"square(otto) #wir rufen square mit der turtle namens otto auf. Wir könnten aber genauso anna oder telmo nehmen\n",
"\n",
"turtle.mainloop()\n",
"turtle.bye()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import turtle\n",
"\n",
"otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
"anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
"telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
"\n",
"#Hier lernen wir die Funktionen color(),begin_fill(), end_fill(), fd() und lt() kennen\n",
"\n",
"def square(t): \n",
" t.color(\"purple\") #Falls nur ein Argument in color()--> Schildkröte und Weg haben dieselbe Farbe. Wir färben die Schildkröte und die Fläche, die wir einfärben wollen, lila\n",
" \n",
" t.begin_fill() # wir beginnen die Fläche, die unsere turtle läuft, zu färben\n",
" for k in range(4): #schleife (4 Aufrufe): unsere turtle läuft in jedem Aufruf zuerst gerade aus und wendet sich dann um 90° nach links.\n",
" t.fd(100)\n",
" t.lt(90) \n",
" t.end_fill() # wir beenden das Einfärben der Fläche\n",
" \n",
"square(anna) #wir rufen square mit der turtle namens anna auf. Wir könnten aber genauso otto oder telmo nehmen\n",
"\n",
"turtle.mainloop()\n",
"turtle.bye()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Diese Funktion können wir nutzen, um unsere Schildkröte mit zufälligen Farben zu färben. \n",
"# Wir können die Funktion nutzen, indem wir sie in unseren Codeblock einfügen und dann an passender Stelle aufrufen.\n",
"# Im nächsten Codeblock ist ein Beispiel gegeben. \n",
"# Varianten: setcolor(t,1) : Schildkröte und Zeichnung in derselben zufälligen Farbe\n",
"# Varianten: setcolor(t,2) : Schildkröte und Zeichnung in zwei unterschiedlichen zufälligen Farben\n",
"def setcolor(t,n):\n",
" turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren\n",
" if n==1: \n",
" t.color(randint(0,255),randint(0,255),randint(0,255)) #generiert eine zufällige Farbe für die turtle\n",
" if n==2: \n",
" t.color((randint(0,255),randint(0,255),randint(0,255)),(randint(0,255),randint(0,255),randint(0,255))) #generiert eine zufällige Farbe für die turtle\n",
" \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import turtle\n",
"\n",
"otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
"anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
"telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
"\n",
"#Hier lernen wir die Funktionen shape(), stamp(), color(), colormode() und fd() kennen\n",
"\n",
"# Fkt setcolor wurde hier eingefügt\n",
"def setcolor(t,n):\n",
" turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren\n",
" if n==1: \n",
" t.color(randint(0,255),randint(0,255),randint(0,255)) #generiert eine zufällige Farbe für die turtle\n",
" if n==2: \n",
" t.color((randint(0,255),randint(0,255),randint(0,255)),(randint(0,255),randint(0,255),randint(0,255))) #generiert eine zufällige Farbe für die turtle\n",
"\n",
" \n",
"def line(t): #Diese Funktion malt eine einfache Linie (in verschiedenen Farben und mit Stempeln jede 100 Einheiten)\n",
" setcolor(t,1) #Hier rufen wir setcolor mit unserer turtle auf und setzen n=1, um die Linie und die Schildkröte in derselben Farbe zu färben\n",
" t.shape('turtle')\n",
" t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
" t.fd(100)\n",
" setcolor(t,1) #nächster Aufruf von setcolor\n",
" setcolor(t,1) # wir können setcolor beliebig oft und an beliebiger Stelle aufrufen\n",
" t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
" t.fd(100)\n",
" t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
" t.fd(100)\n",
" t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
" t.fd(100)\n",
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
"\n",
" \n",
"line(telmo) #wir rufen line mit der turtle namens telmo auf. Wir könnten aber genauso anna oder otto nehmen\n",
"\n",
"turtle.mainloop()\n",
"turtle.bye()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import turtle\n",
"\n",
"otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
"anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
"telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
"\n",
"#Hier lernen wir die Funktionen circle() und shapesize() kennen\n",
"\n",
"def circle(t,r): \n",
" t.shape('turtle') \n",
" t.shapesize(10) # wir ändern die Größe unserer turtle\n",
" t.circle(r) #wir malen einen Kreis mit Radius r\n",
" \n",
"circle(telmo,100) #wir rufen line mit der turtle namens telmo auf. Wir könnten aber genauso anna oder otto nehmen\n",
"\n",
"turtle.mainloop()\n",
"turtle.bye()"
]
}
],
"metadata": {
"language_info": {
"name": "python",
"pygments_lexer": "ipython3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}