<jupyter_start><jupyter_text>3 - Bedingungen, Funktionen und Schleifen  Bedingungen  `if``if` prüft eine Bedingung und führt nachfolgende Operationen aus, wenn die Bedingung erfüllt ist.`else` muss nach `if` stehen. Führt Operation aus, wenn das vorangegangene `if` nicht erfüllt wurde.`elif` muss nach `if` und vor `else` (optional) stehen. Prüft eine weitere `if`-Bedingung.<jupyter_code>if 7 != 7:
    print('Wahr!')
else:
    print('Falsch!')
if 1 < 2:
    print('Wahr!')
else: 
    print('Falsch!')
zahl = input('Ganze Zahl eingeben:')

if not zahl.isdigit():
    print('Keine ganze Zahl!')
elif int(zahl) % 2 != 0: #  % = Rest-Operator , int() konvertiert String zu Zahl
    print('Ungerade!')
else: 
    print('Gerade!')<jupyter_output><empty_output><jupyter_text>Boolsche Ausdrücke* `True` und `False`* `1` und `0`*  `None` ist immer `False`* Leere Objekte (`[]`, `()`, `{}`, etc.) evaluieren immer als `False`Siehe auch [Python Docs](https://docs.python.org/3/library/stdtypes.htmltruth-value-testing)<jupyter_code>L = []
if L: # Boolsche Abfrage
    print(L[0])
else: 
    print('Leere Liste')
    L.append(3)
print(L)<jupyter_output><empty_output><jupyter_text>Übungsaufgabe 1Schreibt ein Programm, dass überprüft ob ein Input String "spam" beinhaltet oder nicht. Falls "spam" gefunden wurde, soll die Anzahl der "spam" Substrings ausgeben. Wird kein "spam" gefunden soll ein entsprechender Hinweis ausgedruckt werden.<jupyter_code># Code für Übungsaufgabe 1<jupyter_output><empty_output><jupyter_text>Übungsaufgabe 2 Schreibt ein Programm, dass die Teilbarkeit einer Zahl überprüft. Wenn die Zahl durch 5 und durch 3 teilbar ist, soll das Programm einen entsprechenden Hinweis drucken. Weiterhin soll unterschieden und gedruckt werden, ob die Zahl nur durch 5, nur durch 3, oder weder durch 5 noch 3 teilbar ist.*Input/Output Beispiele*: ```    5   --> "durch 5 teilbar"15  --> "durch 5 und durch 3 teilbar"2   --> "weder durch 3 noch durch 5 teilbar"```<jupyter_code># Code Übungsaufgabe 2<jupyter_output><empty_output><jupyter_text>Funktionen definieren Funktionen in Python erhalten Input(s) und erzeugen in der Regel nach deren Verarbeitung Output(s). Wenn funktionen einmal im Arbeitsspeicher abgelegt werden, können diese anschließend beliebig häufig wieder verwendet werden:<jupyter_code>def largest_number(input_liste): # name und input
    max_number = max(input_liste)
    print(len(input_liste))
    return max_number

test = largest_number([9, 4, 9, 23, 9, 4000])
print(test)<jupyter_output><empty_output><jupyter_text>Selbstdefinierte Funktionen sind besonders dann nützlich, wenn bestimmte Abläufe mehrmals wiederholt werden - [DRY - Don't repeat yourself!](https://de.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself)Als Faustregel gilt:  Wenn ein bestimmter Prozess >= 3 mal verwendet werden muss, lohnt es sich dafür eine Funktion zu schreiben.  Übungaufgabe 3Schreibe eine Funktion, die für eine Liste mit beliebig vielen Zahlen (Input) das arithmetische Mittel der Zahlen ausgibt (Output). *Hinweis: Funktion* ``sum()`` *Bonusaufgabe: Erstellt eine weitere Funktion für den [Median](https://de.wikipedia.org/wiki/Median).*<jupyter_code># Code Übungsaufgabe 3<jupyter_output><empty_output><jupyter_text>SchleifenAnweisung eine Operation entsprechend bestimmter Regeln zu wiederholen. Die Objekte auf die sich die Operation bezieht, können sich dabei verändern.Kommt in zwei Varianten* `while`-Schleife* `for`-SchleifeSiehe auch [Python Docs](https://docs.python.org/3/tutorial/controlflow.html)  `while` - Schleifen1. Prüfe Bedingung.2. Wenn (IF) Bedingung wahr:    2. Führe Operation aus.    2. Gehe zu 1.3. Wenn Bedingung nicht erfüllt:    3. Beende Schleife  Beispiel: Die  [Fibonacci-Serie](https://de.wikipedia.org/wiki/Fibonacci-Folge)$$  f_n =\begin{cases}f_n = n,  & \text{if $n \le 2$} \\f_{n-1} + f_{n-2}, & \text{if $n \gt 2$}\end{cases} $$$f = 0, 1, 1, 2, 3, 5, 8, 13, \dots$<jupyter_code>def fibonacci(stop):  #  Input: Stopkriterium
    L = []
    a, b = 0, 1 
    while a < stop:
        L.append(a)
        a, b = b, a + b
    return L # Output: Liste der Fibonacci-Serie

sequenz = fibonacci(2000000)
print(sequenz)<jupyter_output><empty_output><jupyter_text>**Achtung**: `while` Schleifen können *unendlich* lange laufen, wenn die zu überprüfende Eingangsbedingung nie als `False` evaluiert wird:<jupyter_code>i = 5
while i > 0:
    print(i)
    print("Zwei mal 'i' drücken um das Programm abzubrechen!")<jupyter_output><empty_output><jupyter_text>Falls ein Notebook abstürzen sollte oder die Ausführung einer Zelle zu lange dauert, können Berechnungen über die Menüführung mit **Kernel -> Interrupt** unterbrochen werden bzw. über **Kernel -> Restart** das Notebook neugestartet werden. Bei einem Neustart müssen  sämtliche Berechnungen neu durchgeführt werden.  `for` - Schleifen`for` Schleifen zählen zu den nützlichsten Tools für die Verarbeitung von Daten. Das Grundprinzip:Für jedes Element einer Sequenz:    1. Führe Operation aus    2. Rufe nächstes Element    3. Wenn kein weiteres Element:           Beende Schleife.    4. Sonst:           Gehe zu 1.<jupyter_code>for element in [1, 2, 3]:
    print(element)<jupyter_output><empty_output><jupyter_text>Über eine `for` Schleife durch eine Liste mit Wörtern gehen und die Häufigkeit jedes Wortes zurück geben:<jupyter_code>spamskit = '''Well, there's egg and bacon; egg sausage and bacon;
egg and spam; egg bacon and spam; egg bacon sausage and spam; spam bacon sausage and spam;
spam egg spam spam bacon and spam; spam sausage spam spam bacon spam tomato and spam;'''
print(spamskit)
# Strings die über ''' geöffnet und geschlossen werden, dürfen Zeilenumbrüche beinhalten
tokens = spamskit.split()
print(tokens)
print(len(tokens))
print(len(set(tokens))) # Sets sind Mengen und eliminieren Dopplungen in Objekten
## Häufigkeit der Wörter ausgeben:
for token in set(tokens):
    print(token, tokens.count(token))<jupyter_output><empty_output><jupyter_text>Übungsaufgabe 4Schreibt ein Programm, dass für eine Liste, die ganze Zahlen beinhaltet, für jede gerade Zahl das Quadrat der Zahl und jede ungerade Zahl unverändert ausgibt. 4 -> quadrat(4)    5 -> 5<jupyter_code># Code für Übungsaufgabe 4<jupyter_output><empty_output><jupyter_text>Übungsaufgabe 5Schreibt eine Funktion, welcher als Input ein String übergeben wird. Als Output soll die Funktion eine Liste mit allen Wörtern (in lowercase) des Strings ohne Sonderzeichen enthalten. *Hinweis: Methode .isalpha() prüft, ob ein String ausschließlich alphabetische Zeichen enthält.* *Input/Output Beispiel*: ```    Input: "Only 10 kinds of people €xist in th3 world: Th0se wh0 underst@nd binary and th0se wh0 d0 not!" Output: ["only", "kinds", "of", "people", "in", "binary", "and"]```<jupyter_code># Code für Übungsaufgabe 5<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10463751100675081, 'fraction_numerical': 0.015409451130026416, 'mean_word_length': 5.218065693430657, 'pattern_counts': {'":': 0, '<': 51, '<?xml version=': 0, '>': 58, 'https://': 5, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '471287', 'license': 'CC0-1.0', 'n_tokens_mistral': 2552, 'n_tokens_neox': 2491, 'n_words': 746, 'path': 'notebooks/03_Bedingungen_Funktionen_Schleifen.ipynb', 'repo_name': 'cschwem2er/python_data_scraping', 'size': '6814'}