====== Programmieren Teil 5 – Die for-Schleife ======
  * Dieses Seite ist die Fortsetzung von [[gf_informatik:programmieren_iv_gra|]].

++++ Vorausgesetzte Kompetenzen:|
  - Ich beherrsche die in Teil 1 und 2 gelernten Grundlagen in python (Turtlegraphics, Variablen, while-Schleife, Verzweigungen, Vergleichsoperatoren, mathematische Operatoren, f-Strings, Funktionen ''print'' und ''input'', nie repeat verwenden, clever und kompakt programmieren).
  - Ich beherrsche den Umgang mit Listen, wie in Teil 3 gelernt:
    * Listen korrekt erstellen – leer oder mit Zahlen oder mit Texten drin.
    * Mit einer while-Schleife alle Elemente einer Liste durchgehen, sie auslesen/ausgeben oder mit einer if-Verzweigung abfragen und evtl. verändern oder entfernen.
    * Die Listen-Funktionen ''pop'' und ''append'' richtig verwenden.
    * Mit ''in'' fragen, ob ein bestimmtes Element in einer Liste vorkommt.
    * Listen analysieren (z.B. Mittelwert ermitteln) oder verändern (z.B. bestimmte Elemente ersetzen etc.).
  - Ich kann in Pyhton //Funktionen// (mit und ohne //Argumente//, mit und ohne //Rückgabewerte//) korrekt //definieren// und //aufrufen//, wie in Teil 4 gelernt.
  - Ich kann jeden //Begriff// des vorhergehenden Satzes erklären.
++++
++++Lernziele:|
  - Ich kann die for-Schleife verwenden, um durch Elemente einer Sequenz (Liste oder String) durchzugehen (über eine Sequenz iterieren). 
  - Ich kann die direkte for-Schleife von der indirekten for-Schleife (mit range-Funktion) unterscheiden und weiss, in welchen Fällen ich besser die indirekte for-Schleife verwende.
  - Ich kann die **range**-Funktion verwenden, um auf- und absteigende Zahlenfolgen in beliebigen Bereichen mit beliebigen Schritten zu erstellen.
  - Ich kann mit for-Schleifen...
    - ...Code-Abschnitte beliebig oft wiederholen,
    - ...Elemente von Sequenzen schrittweise bearbeiten oder ausgeben,
    - ...Positionen von Elementen in einer Sequenz ermitteln,
    - ...aus bestehenden Sequenzen neue, modifizierte Sequenzen erstellen,
    - ...mehrere Sequenzen zu einer Sequenz zusammenführen,
    - ...komplexe Muster mit Turtle-Graphics erstellen.
++++

===== - Einführung =====

Du kennst die **while-Schleife** – damit kannst du:
  - Codeabschnitte wiederholt ausführen lassen – bis die Bedingung erfüllt ist oder endlos.
  - Alle Elemente einer Liste oder eines Strings durchgehen.

Speziell für die zweite Anwendung gibt es die **for-Schleife**. Eine **for-Schleife** wird verwendet, um **alle Elemente einer Sequenz** (z.B. eine Liste, ein String usw.) durchzugehen. Man nennt dies auch *über eine Sequenz iterieren*.

===== - Theorie =====

For-Schleifen haben die Form:
<code python>
for element in sequence:
    # Aktion, die für jedes Element ausgeführt wird
</code>

Um zum Beispiel alle **Elemente einer Liste** auszugeben, schreibt man einfach:
<code python>
fruits = ["Apfel", "Banane", "Kirsche"]
for fruit in fruits:
    print(fruit)
</code>

++++Äquivalente while-Schleife|
<code python>
fruits = ["Apfel", "Banane", "Kirsche"]
i = 0
while i < len(fruits):
    print(fruits[i])
    i = i + 1
</code>
++++

Ganz ähnlich kann man alle **Zeichen eines Strings** durchgehen:
<code python>
word = "Python"
for letter in word:
    print(letter)
</code>
Der Output wird dann sein:
<code bash>
P
y
t
h
o
n
</code>

++++Äquivalente while-Schleife|
<code python>
word = "Python"
i = 0
while i < len(word):
    print(word[i])
    i = i + 1
</code>
++++

==== Direkte und indirekte for-Schleife ====
Du hast soeben die **direkte for-Schleife** kennengelernt: Du greifst dabei //direkt// auf die Elemente der Liste oder des Strings zu. Die Variable, die vor ''in'' steht, enthält das jeweilige Element.

Bei der **indirekten for-Schleife** verwendest du die Funktion ''range'' und greifst //über den Index// auf das Element zu – wie bei der while-Schleife. Hier eine Übersicht:

<WRAP group>
<WRAP column half>
== Direkte for-Schleife ==
<code python>
colors = ['red','green','blue']
for c in colors:
    print(c)
</code>
Output:
<code>
red
green
blue
</code>
</WRAP>
<WRAP column half>
== Indirekte for-Schleife ==
<code python>
colors = ['red','green','blue']
for i in range(len(colors)):
    print(colors[i])
</code>
Output:
<code>
red
green
blue
</code>
</WRAP>
</WRAP>

Die beiden Codes oben tun dasselbe. Aber der rechte ist etwas komplexer. So fragst du dich vieleicht: <color #ff00ff>Wieso sollte ich die indirekte for-Schleife verwenden?</color> Die Antwort findest du unten. Zuerst musst du die range-Funktion in der indirekten for-Schleife verstehen:

=== Die Range-Funktion ===
Mit der **range-**Funktion kannst du einfach eine Zahlenfolge erstellen. Sie hat 1 bis 3 Argumente: `range(<start>,<stop>,<step>)`, wobei:

   * `<start>` der Startwert ist.
   * `<stop>` der Schlusswert ist (Achtung: nicht inklusive!)
   * `<step>` die Schrittweite zwischen zwei Zahlen ist.

<WRAP group>
<WRAP column third>
Beispiel 1: Nur ein Argument:
<code python>
for i in range(5):
    print(i) # Output: 0,1,2,3,4
</code>
</WRAP>
<WRAP column third>
Beispiel 2: Zwei Argumente:
<code python>
for i in range(5,10):
    print(i) # Output: 5,6,7,8,9
</code>
</WRAP>
<WRAP column third>
Beispiel 3: Alle drei Argumente:
<code python>
for i in range(3,11,2):
    print(i) # Output: 3,5,7,9.
</code>
</WRAP>
</WRAP>

Die range-Funktion kann auch *rückwärts* iterieren: `range(10,3,-1) # [10,9,8,7,6,5,4]`

=== Wann brauche ich die indirekte for-Schleife? ===

<WRAP group>
<WRAP column third>
**Wenn du nicht durch eine bestehende Sequenz (Liste/String) iterieren willst.**

Zum Beispiel soll die Schleife nur dazu dienen, bestimmte Befehle mehrfach auszufürhen:
<code python>
from gturtle import *
q = Turtle()

for i in range(4): # Zeichne Quadrat
    q.forward(50)
    q.right(90)
</code>
</WRAP>

<WRAP column third>
**Wenn du nicht (nur) die Elemente, sondern (auch) die Positionen dieser Elemente benötigst.**

Zum Beispiel willst du die Position eines gesuchten Elements ausgeben:
<code python>
numbers = [7,42,13,70,42,37,42]
 
for i in range(len(numbers)):
    if numbers[i] == 42:
        print(f"Found 42 at index {i}")
</code>
</WRAP>

<WRAP column third>
**Wenn du durch zwei oder mehr Sequenzen (Listen/Strings) __gleichzeitig__ iterieren willst.**

Zum Beispiel möchtest du die Elemente aus zwei Listen zusammenführen:
<code python>
laender = ["Italien","Polen","Ungarn"]
staedte = ["Rom","Warschau","Budapest"]
 
for i in range(len(laender)):
    print(f"{laender[i]}: {staedte[i]}")
</code>
</WRAP>

</WRAP>
===== - Aufgaben P – for-Schleife =====
==== Aufgaben PA – Mit for-Schleife, ohne Funktionen ====
In folgenden Aufgaben benötigst du die direkte oder indirekte for-Schleife. **Überlege jeweils zuerst, welche der beiden du benötigst.** Schau bei Bedarf in der Theorie oben nach.
=== PA1 – Notenschnitt ===
Die Noten der letzten Franz-Prüfung einer Klasse sind:
`noten = [6, 3.0, 5.5, 6, 5.25, 3.5, 3, 4.75, 5, 3.5, 5.25, 5.5, 4.75, 6, 3.75, 4.25, 3.25, 4.5, 3.5, 5]`

   1. Berechne den Klassendurchschnitt selbst mithilfe einer while-Schleife.
   1. Berechne den Klassendurchschnitt nun nochmals, aber mithilfe einer for-Schleife. Verwende in der Schleife eine sinnvoll benannte Variable.

=== PA2 – Maximum in Liste ===
Finde mithilfe einer for-Schleife in der folgenden Liste die grösste Zahl und gib diese aus: `numbers = [3, 6, 2, 8, 4, 10, 1]`. Der Code soll auch für alle anderen Listen mit Zahlen funktionieren.

Wende deinen Code nun auf diese längere Liste an: `numbers = [14, 41, 136, 38, 120, 24, 8, 129, 115, 117, 122, 1, 147, 39, 24, 94, 61, 26, 2, 26, 4, 73, 44, 78, 35, 156, 85, 116, 121, 106, 49, 131, 145, 32, 118, 118, 148, 19, 156, 25, 11, 3, 32, 102, 129, 129, 7, 20, 92, 35]` (Resultat: 156)

=== PA3 – Sechseck ===
<WRAP group>
<WRAP column half>
Zeichne mithilfe einer for-Schleife ein Sechseck wie im Bild.
</WRAP>
<WRAP column half>
{{.:programmieren_v_gra:pasted:20250730-065438.png?200}}
</WRAP>
</WRAP>

=== PA4 – Zehn Vielfache ===
Die Benutzer:in kann eine Zahl von eingben (verwende die Funktion ''input''). Dein Programm gibt dann die ersten 10 Vielfachen dieser Zahl nacheinander aus. Beispiel: Wird 3 eingegeben, so gibt dein Programm nacheinander 3, 6, 9, 12, 15, 18, 21, 24, 27, 20 aus. Tipp: Verwende in deiner for-Schleife die range-Funktion mit drei Argumenten.

=== PA5 – So viele S ===
Schreibe einen Code, der mithilfe einer for-Schleife ermittelt, wie oft der Buchstabe 'S' in einem Wort (gespeichert in Variable ''word'') vorkommt. Teste deinen Code für folgende Wörter:
  * ''word = "MISSISSIPPI"''
  * ''word = "SAMICHLAUS"''

=== PA6 – String in Liste wandeln ===
Wandle mithilfe einer for-Schleife einen String in eine Liste um, die die Buchstaben des Wortes beinhaltet. Aus `word = "Python"` soll dann also `letters = ['P','y','t','h','o','n']` werden. Am Ende gibtst du die Liste aus.

Starte wie folgt:
<code python>
word = "Python"
letters = [] # starte mit leerer Liste. Füge in for-Schleife nacheinander Buchstaben hinzu.

for ...

</code>

=== PA7 – Zahlenreihen ===
Schreibe Codes mit for-Schleifen, die folgende Zahlenreihen ausgeben:

   1. Zähle auf $100$: Gib alle ganzen Zahlen von $1$ bis und mit $100$ aus.
   1. Zähle von $10$ in $5$er-Schritten auf $100$, also $10,15,20,25,\ldots,95,100$.
   1. Zähle von $99$ in $3$er-Schritten bis auf $0 herunter.

=== PA8 – Wo sind die i? ===
  - Schreibe Code, der mithilfe einer for-Schleife **die Positionen** aller Buchstaben 'i' (nur Kleinbuchstaben) in einem Wort ausgibt. Teste mit den Wörtern unten.
  - Erweitere deinen Code, sodass auch die Positionen der Grossbuchstaben 'I' ausgegeben werden. Nutze [[programmieren_iv_gra#nb4_minimalwert_aus_drei_zahlen|logische Verknüpfungen]] oder das Schlüsselwort ''in''.
<code python>
wort = "Familienzeit-Initiative" # Positionen: 3, 5, 10, (13), 15, 17, 20
wort = "Igel-Illustration" # Positionen: (0), (5), 14
</code>

=== PA9 – Doppelte ===
Gegeben sei eine Liste mit Zahle `numbers = [5,3,7,1,2]`. Erstelle mithilfe einer for-Schleife eine neue Liste `doubles`, die von den Zahlen aus `numbers` jeweils das Doppelte beinhalten soll. `doubles` soll dann also `[10,6,14,2,4]` sein.

=== PA10 – Reissverschluss ===
Kombiniere die folgenden beiden String `s1 = "IFRAI"` und `s2 = "nomtk"` mithilfe einer for-Schleife zu einem einzigen String `"InFoRmAtIk`. Wie bei einem Reissverschluss soll abwechslungsweise ein Element von der einen, dann von der anderen Seite hinzukommen.

=== PA11 – Gerade aus Liste ===
Gegeben ist die Liste `numbers = [24, 40, 16, 10, 7, 26, 15, 7, 25, 23, 25, 41, 38, 13, 21, 33, 10, 42, 13, 9, 20, 35, 5, 39, 15, 36, 35, 1, 27, 42]`. Erstelle eine neue, leere Liste `even = []`. Füge dieser Liste in einer for-Schleife alle *geraden* Zahlen aus numbers hinzu.

=== PA12 – Ohne E ===
Der König im Buch 'Die wilde Sophie' hat panische Angst vor dem Buchstaben 'E'. Er verlangt von seinen Untertanen, dass sie in ihrer Sprach den Buchstaben 'E' einfach auslassen. Anstelle "ESEL ESSEN GERNE ERDBEEREN, BESONDERS BEI EINEM ELEGANTEN ELEFANTENESSEN." sollen sie sagen und schreiben: "SL SSN GRN RDBRN, BSONDRS BI INM LGANTN LFANTNSSN."

Schreibe einen Code mit einer for-Schleife, der von einem gegebenen String eine neue Version *ohne* E's erstellt:
<code python>
text = "ESEL ESSEN GERNE ERDBEEREN, BESONDERS BEI EINEM ELEGANTEN ELEFANTENESSEN."
text_ohne_E = "" 

for ...
</code>

==== Aufgaben PB – Mit for-Schleife, mit Funktionen ====
Du hast die for-Schleife in beiden Varianten (direkt und indirekt) schon einige Male verwendet. In den folgenden Aufgaben kombinierst du for-Schleifem mit Funktionen.

=== PB1 – Sternenmuster ===
<WRAP group>
<WRAP column half>
Schreibe eine Funktion sternchen(n), die ein Muster aus n Zeilen Sternchen ausgibt. Die erste Zeile hat jeweils ein Sternchen, die zweite eins mehr etc. 

Beispiel: Beim Aufruf ''sternchen(5)'' soll nebenstehendes Muster entstehen.
</WRAP>
<WRAP column half>
<code>
*
**
***
****
*****
</code>
</WRAP>
</WRAP>

=== PB2 – Vokale zählen ===
Schreibe eine Funktion ''anzahl_vokale(text)'', die die Anzahl Vokale (nur die Kleinbuchstaben 'a', 'e', 'i', 'o', 'u') in ''text'' zählt und zurückgibt. Teste die Funktion.

++++Tipp:|
Mit ''in'' kannst abfragen, ob ein Wert in einer Liste oder in einem String vorkommt:
<code python>
if wert in "abcdefghijklmnopqrstuvwxyz": # fragt, ob Wert im kleinen Alphabet vorkommt.

if wert in ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag"]: # fragt, ob Wert ein Wochentag ist.

</code>
++++
=== PB3 – Anzahl r ===
Schreibe eine Funktion ''anzahl_r(liste)'', die alle Wörter in ''liste'' zählt, die ein 'r' enthalten und die Anzahl zurückgibt. Teste deine Funktion mit folgender Liste:

<code python>
monate = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "December"]
</code>

=== PB4 – Positionen r ===
Schreibe eine Funktion ''positionen_r(liste)'', die die Positionen aller Wörter mit r ermittelt und diese Positionen **aus**gibt (die Funktion muss nichts zurückgeben, sie gibt schon was aus). Teste deine Funktion mit der Monats-Liste aus obiger Aufgabe.

++++ Korrekte Ausgabe:|
<code>
0
1
2
3
8
9
10
11
</code>
++++
=== PB5 – Positionen r als Liste ===
Schreibe eine Funktion ''positionen_r(liste)'', die die Positionen aller Wörter mit r ermittelt, diese in eine Liste füllt und diese Liste **zurück**gibt (die Funktion muss nichts ausgeben, sie gibt ja was zurück). Teste deine Funktion mit der Monats-Liste aus obiger Aufgabe.
++++ Korrekte Ausgabe:|
<code>
[0, 1, 2, 3, 8, 9, 10, 11]
</code>
++++
=== PB6 – Anzahl x ===
Schreibe eine Funktion ''anzahl\_x(liste, x)'', die die Positionen aller Wörter mit Buchstabe x ermittelt und die Anzahl **zurück**gibt. 

Zum Beispiel soll der Aufruf ''anzahl_x(monate, 'u')'' (mit obiger Liste monate) die Zahl 5 zurückgeben.

=== BP7 – Summe aller Listenelemente ===
Schreibe eine Funktion ''liste_summieren(liste)'', die alle Zahlen in einer Liste aufsummiert und die Summe zurückgibt.

Teste mit folgenden Listen:
<code python>
zahlen1 = [31, 98, 93, 74, 15, 83, 14, 99, 84, 32, 37, 86] # Summe = 746 
zahlen2 = [49, 24, -33, -4, -38, 40, 3, 23, -13, 39, 26, -2] # Summe = 114
</code>

=== BP8 – Rückwärts ausgeben ===
Schreibe eine Funktion ''rueckwaerts_ausgeben(text)'', die jedes Zeichen des Texts rückwärts in einer neuen Zeile ausgibt. Verwende eine indirekte for-Schleife.

=== BP9 – Punkte-Linie ===
<WRAP group>
<WRAP column twothirds>
Schreibe eine Funktion ''dot\_line(n)'', die mithilfe einer for-Schleife ''n'' Punkte auf einer Linie zeichnet:
  * Die Grösse des ersten Punktes ist 10, die des nächsten 20, dann 30 etc.
  * Fahre jeweils zuerst vorwärts (um die Grösse des Punktes) und zeichne dann einen Punkt.
  * Der Aufruf ''dot\_line(7)'' sollte nebenstehendes Muster zeichnen.
</WRAP>
<WRAP column third>
{{.:programmieren_v_gra:pasted:20250730-135758.png?300}}
</WRAP>
</WRAP>

=== BP10 – Punkte-Kreis === 
<WRAP group>
<WRAP column twothirds>
Schreibe eine Funktion ''dot\_arc(list)'', die mithilfe einer for-Schleife für jede Zahl in ''list'' einen Punkt in entsprechender Grösse auf einem Kreis zeichnet:
  * Verwende die Funktion ''rightArc(radius, winkel)''.
    * Setze ''radius'' auf 100.
    * Du kannst davon ausgehen, dass ''list'' 12 Elemente hat: Wie gross muss ''winkel'' sein, damit der Kreis am Ende geschlossen ist.
  * Der Aufruf ''dot\_arc(dot_sizes)'' sollte nebenstehendes Muster ergeben.

<code python>
diameters = [10, 20, 30, 15, 50, 40, 30, 15, 10, 20, 60, 20]
</code>
</WRAP>
<WRAP column third>
{{.:programmieren_v_gra:pasted:20250730-142809.png?250}}
</WRAP>
</WRAP>

=== BP11 – Punkte-Kreis Plus === 
<WRAP group>
<WRAP column half>
Erweitere deine Funktion ''dot\_arc(list)'', sodass sie mit beliebig langen Listen((ausser leere Listen)) immer einen ganzen Kreis zeichnet. Teste deine Funktion mit untenstehenden Listen. Es sollten nebenstehende Muster entstehen.

<code python>
diameters1 = [10, 20, 30, 15, 50, 40]
diameters2 = [30, 60, 50, 20, 30, 20, 50, 40, 30]
</code>
</WRAP>

<WRAP column half>
{{.:programmieren_v_gra:pasted:20250730-143828.png?250}} {{.:programmieren_v_gra:pasted:20250730-143915.png?250}}
</WRAP>

</WRAP>

=== BP12 – Punkte-Kreis Bunt === 

<WRAP group>
<WRAP column twothirds>
Erweitere deine Funktion um ein Argument für eine Farbliste: ''dot\_arc(l\_dia, l\_col)''. Die Funktion zeichnet mit beliebig langen Listen((ausser leere Listen)) einen ganzen Kreis **in verschiedenen Farben**:
  * Du kannst davon ausgehen, dass die beiden Listen (für die Punkte-Durchmesser und für die Farben) gleich lang sind.
Teste deine Funktion mit untenstehenden Listen. Es sollte nebenstehendes Muster entstehen.

<code python>
diameters = [30, 40, 30, 40, 60, 40, 30, 50, 30]
colors = ["6495ED", "4169E1", "0000FF", 
          "1E90FF", "008B8B", "66CDAA", 
          "20B2AA", "006400", "2E8B57"]
</code>
</WRAP>

<WRAP column third>
{{.:programmieren_v_gra:pasted:20250731-065005.png?300}}</WRAP>

</WRAP>

===== - Aufgaben Q – For-Schleife für Fortgeschrittene =====

=== Q1 – Fakultät ===
Schreibe eine Funktion ''falultaet(zahl)'', das mithilfe einer for-Schleife die [[https://de.wikipedia.org/wiki/Fakult%C3%A4t_(Mathematik)|Fakultät]] zu ''zahl'' berechnet und **aus**gibt.
Beispiele: 
  * Die Fakultät zur Zahl 1 ist 1 = 1
  * Die Fakultät zur Zahl 2 ist 1 * 2 = 2
  * Die Fakultät zur Zahl 3 ist 1 * 2 * 3 =  6 

=== Q2 – Punkte-Kreis Pro ===
Siehe Aufgabe PB12. Erweitere die Funktion ''dot\_arc(l\_dia, l\_col)'', sodass beide Listen beliebig lang sein können. Die Durchmeser-Liste ist massgebend, das heisst:
  * Wenn die Durchmesser-Liste leer ist, wird nur ein Kreis gezeichnet, ohne einen Punkt drauf.
  * Wenn die Farben-Liste leer ist, werden die Punkte schwarz gezeichnet.
  * Wenn die Farben-Liste kürzer ist als die Durchmesser-Liste, wird die Farben-Liste wiederholt: Nach der letzten Farbe in der Liste wird wieder die erste gewählt. Tipp: Modulo-Operator (%).
  * Wenn die Durchmesser-Liste kürzer ist als die Farben-Liste, werden die übrigen Farben ignoriert.
===== - Lösungen =====

**Achtung:** Meist gibt es mehrere Lösungen. Nur weil deine Lösung anders ist als diejenige in den Musterlösungen unten, bedeutet dies nicht, dass deine nicht richtig/gut ist. Sende oder zeige im Zweifelsfall deine Lösung der Lehrperson.

<nodisp 2>
++++Lösungen zu Aufgaben PA:|
=== PA1 ===
<WRAP group>
<WRAP column half>
Mit while:
<code python>
noten = [6, 3.0, 5.5, 6, 5.25, 3.5, 3, 4.75, 5, 3.5, 5.25, 5.5, 4.75, 6, 3.75, 4.25, 3.25, 4.5, 3.5, 5]
summe = 0

i = 0
while i < len(noten):
    summe = summe + noten[i]
    i = i + 1

schnitt = summe/len(noten)
print(schnitt)
</code>
</WRAP>
<WRAP column half>
Mit for:
<code python>
noten = [6, 3.0, 5.5, 6, 5.25, 3.5, 3, 4.75, 5, 3.5, 5.25, 5.5, 4.75, 6, 3.75, 4.25, 3.25, 4.5, 3.5, 5]
summe = 0
    
for note in noten:
    summe = summe + note

schnitt = summe/len(noten)
print(schnitt)
</code>
</WRAP>
</WRAP>


=== PA2 ===
<code python>
numbers = [14, 41, 136, 38, 120, 24, 8, 129, 115, 117, 122, 1, 147, 39, 24, 94, 61, 26, 2, 26, 4, 73, 44, 78, 35, 156, 85, 116, 121, 106, 49, 131, 145, 32, 118, 118, 148, 19, 156, 25, 11, 3, 32, 102, 129, 129, 7, 20, 92, 35]
max = numbers[0]

for n in numbers:
    if n>max:
        max = n

print(max)
</code>

=== PA3 ===
<code python>
from gturtle import *
raphael = Turtle()

for i in range(6):
    raphael.forward(60)
    raphael.right(60)
</code>

=== PA4 ===
<code python>
zahl = input("Bitte Zahl eingeben")
for i in range(zahl, zahl * 11, zahl):
    print(i)
</code>

=== PA5 ===
<code python>
#word = "MISSISSIPPI"
word = "SAMICHLAUS"
count = 0
for letter in word:
    if letter == 'S':
        count+= 1

print(count)
</code>

=== PA6 ===
<code python>
word = "Python"
letters = [] # starte mit leerer Liste. Füge in for-Schleife nacheinander Buchstaben hinzu.

for letter in word:
    letters.append(letter)

print(letters)
</code>

=== PA7 ===
<code python>
for i in range(1,101):
    print(i)

for i in range(10,101,5):
    print(i)

for i in range(99,-1,-3):
    print(i)
</code>

=== PA8 ===
<code python>
#wort = "Familienzeit-Initiative" # Positionen: 
wort = "Igel-Illustration"

# Variante mit logischer Verknüpfung
for i in range(len(wort)):
    if wort[i] == 'i' or wort[i] == 'I':
        print(i)

# Variante mit in
for i in range(len(wort)):
    if wort[i] in ['i','I']:
        print(i)
</code>

=== PA9 ===
<code python>
numbers = [5,3,7,1,2]
doubles = []

for n in numbers:
    doubles.append(2*n)

print(doubles)
</code>

=== PA10 ===
<code python>
s1 = "IFRAI"
s2 = "nomtk"
word = ""

for i in range(len(s1)):
    word = word + s1[i] + s2[i]

print(word)
</code>

=== PA11 ===
<code python>
numbers = [24, 40, 16, 10, 7, 26, 15, 7, 25, 23, 25, 41, 38, 13, 21, 33, 10, 42, 13, 9, 20, 35, 5, 39, 15, 36, 35, 1, 27, 42]
even = []

for n in numbers:
    if n % 2 == 0:
        even.append(n)

print(even)
</code>

=== PA12 ===
<code python>
text = "ESEL ESSEN GERNE ERDBEEREN, BESONDERS BEI EINEM ELEGANTEN ELEFANTENESSEN."
text_ohne_E = ""

for letter in text:
    if letter != "E":
        text_ohne_E = text_ohne_E + letter

print(text_ohne_E)
</code>
++++
</nodisp>

<nodisp 2>
++++Lösungen zu Aufgaben PB:|
=== PB1 ===
<code python>
def sternchen(n):
    for i in range(1,n+1):
        text = i * '*'
        print(text)

sternchen(5)
</code>

=== PB2 ===
<code python>
def anzahl_vokale(text):
    count = 0
    for letter in text:
        if letter in "aeiou":
            count += 1
    return (count)

print(anzahl_vokale("Qualabaer"))
</code>

=== PB3 ===
<code python>
def anzahl_r(liste):
    count = 0
    for word in liste:
        if 'r' in word:
            count += 1
    return count

monate = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "December"]

print(anzahl_r(monate))
</code>

=== PB4 ===
<code python>
def positionen_r(liste):
    count = 0
    for i in range(len(liste)):
        if 'r' in liste[i]:
            print(i)

monate = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "December"]

positionen_r(monate)
</code>

=== PB5 ===
<code python>
def positionen_r(liste):
    pos_r = []
    count = 0
    for i in range(len(liste)):
        if 'r' in liste[i]:
            pos_r.append(i)
    return pos_r

monate = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "December"]

print(positionen_r(monate))
</code>

=== PB6 ===
<code python>
def anzahl_x(liste, x):
    count = 0
    for word in liste:
        if x in word:
            count += 1
    return count

monate = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "December"]

print(anzahl_x(monate, 'u'))
</code>

=== PB7 ===
<code python>
def liste_summieren(liste):
    summe = 0
    for zahl in liste:
        summe += zahl
    return summe

zahlen1 = [31, 98, 93, 74, 15, 83, 14, 99, 84, 32, 37, 86] # Summe = 746 
zahlen2 = [49, 24, -33, -4, -38, 40, 3, 23, -13, 39, 26, -2] # Summe = 114

print(liste_summieren(zahlen1))
print(liste_summieren(zahlen2))
</code>

=== PB8 ===
<code python>
def rueckwaerts_ausgeben(text):
    for i in range(len(text)-1, -1, -1):
        print(text[i])

rueckwaerts_ausgeben("Halli Hallo")
</code>

=== PB9 ===
<code python>
from gturtle import *
raffael = Turtle()

def dot_line(n):
    for i in range(10, 10*n+1, 10):
        raffael.forward(i)
        raffael.dot(i)  

raffael.right(90)
dot_line(7)
</code>

=== PB10 ===
<code python>
from gturtle import *
raffael = Turtle()

def dot_arc(list):
    for size in list:
        raffael.rightArc(100,30)
        raffael.dot(size)  

diameters = [10, 20, 30, 15, 50, 40, 30, 15, 10, 20, 60, 20]

dot_arc(diameters)
</code>

=== PB11 ===
<code python>
from gturtle import *
raffael = Turtle()

def dot_arc(list):
    angle = 360/len(list)
    for size in list:
        raffael.rightArc(100,angle)
        raffael.dot(size)  

diameters1 = [10, 20, 30, 15, 50, 40]
diameters2 = [30, 60, 50, 20, 30, 20, 50, 40, 30]

dot_arc(diameters2)
</code>

=== PB12 ===
<code python>
from gturtle import *
raffael = Turtle()

def dot_arc(l_dia, l_col):
    i = 0
    angle = 360/len(l_dia)
    for i in range(len(l_dia)):
        raffael.setPenColor(l_col[i])
        raffael.rightArc(100,angle)
        raffael.dot(l_dia[i])  

diameters = [30, 40, 30, 40, 60, 40, 30, 50, 30]
colors = ["6495ED", "4169E1", "0000FF", 
          "1E90FF", "008B8B", "66CDAA", 
          "20B2AA", "006400", "2E8B57"]
    
dot_arc(diameters, colors)
</code>
++++
</nodisp>