<jupyter_start><jupyter_text>Aufgabenblatt 1<jupyter_code>!pip install --user nose
from nose.tools import assert_equal<jupyter_output><empty_output><jupyter_text>Aufgabe 1: FormatierungWarum benötigt z. B. eine for-Schleife der Form```pythonfor i in range (1, 10):    print (i)    print (i, "mal 2 ist", i*2)```keine geschweiften Klammern, Schlüsselwörter `begin` und `end` oder andere syntaktische Hilfsmittel, um zu erkennen, welche Befehle innerhalb der Schleife ausgeführt werden sollen?  Aufgabe 2: Bash-Skript in Python Skript umwandelnWandeln Sie das folgende Shell-Skript, das die Fakultät $i!$ für die Werte $𝑖 \in \{1, 2, \dots, 20\}$ berechnet, in ein Python-Skript um:```bashfor i in $( seq 1 20 ); do  count=$i; ergebnis=1  while [ $count -gt 1 ]; do    ergebnis=$((ergebnis * count))    count=$((count-1))  done  echo "fakultaet" $i "=" $ergebnisdone```<jupyter_code>for i in range(1, 21):
    count=i
    ergebnis=1
    while count > 1:
        ergebnis=ergebnis * count
        count=count-1
    print("fakultaet %2d = %20d" % (i, ergebnis))
if '%(' not in _i.replace(' ',''):
    print('Pass your variables in a tuple to print statement')
assert i == 20, 'range function does not include the upper limit'
assert ergebnis == 243290200817664e4, 'factorial of 20 is incorrect'
assert count == 1, 'count should reduce to 1'<jupyter_output><empty_output><jupyter_text>Aufgabe 3: Gleichheit und Identität1. Testen Sie die beiden Vergleichsoperatoren `==` (Gleichheit) und `is` (Identität) mit folgenden Befehlen:```pythona = 3b = 3a == b  Test auf Gleichheit, True oder False?a is b  Test auf Identität, True oder False?c = [3,4]d = [3,4]e = dc == dd == ec is dd is e```<jupyter_code>a = 3
b = 3
assert type(a) == int
assert type(a) == int
assert a is b, 'Try smaller integers'<jupyter_output><empty_output><jupyter_text>2. Sie haben das Ergebnis von `a is b` für den Fall `a=3` und `b=3` gesehen. Wiederholen Sie den Test für größere Werte von `a` und `b`. Fällt das Ergebnis von `a is b` immer gleich aus?<jupyter_code># YOUR CODE HERE
raise NotImplementedError()
assert a == b, 'assign the same integer'
assert a > 256, 'choose larger number'<jupyter_output><empty_output><jupyter_text>Aufgabe 4: DivisionsoperatorWie unterscheiden sich die beiden Operatoren `/` und `//`?Rechnen Sie dazu mit Integern `5/3` und `5//3` sowie mit Float-Zahlen `5.0/3.0` und `5.0//3.0` aus. **Achtung:** Der Divisionsoperator `/` hat eine unterschiedliche Bedeutung in Python2.Dort ergibt `5/3 = 1`.Manchmal sehen Sie zu Begin eines Python Codes folgendes:```pythonfrom __future__ import division```Damit kann man für einzelne Aspekte (z.B. die Division) in Python2 das gleiche Verhalten erreichen wie in Python3.  Aufgabe 5: ZahlensystemeFür die häufig benötigten Zahlensysteme mit Basis 2, 8 und 16 können Sie in Python Zahlen mit den Präfixen `0b` (binär, Basis 2), `0o` (oktal, Basis 8) und `0x` (hexadezimal, Basis 16) darstellen (z. B. `0xa = 0o12 = 0b1010 = 10`). Alternativ verwenden Sie die int-Funktion, die einen String und die gewünschte Zahlenbasis als Parameter akzeptiert (z. B. `int("a",16)` oder `int("1010",2)` für hexadezimale und binäre Zahlen).Lassen Sie sich mit beiden Methoden (Präfix bzw. int-Funktion) die Dezimaldarstellungen der folgenden Zahlen ausgeben:- `10010101` (binär)- `7777` (oktal)- `c000` (hexadezimal)<jupyter_code># YOUR CODE HERE
raise NotImplementedError()
assert ('0b' or '0o' or '0x') in _i, 'Use one of three prefix'
assert type(_) is int, 'cell output should be integer'
# YOUR CODE HERE
raise NotImplementedError()
assert 'int(' in _i, 'use int function'
assert type(_) is int, 'cell output should be integer'<jupyter_output><empty_output><jupyter_text>Umgekehrt können Sie über Format-Strings mit `%o` und `%x` Zahlen im Oktal- und Hexadezimalformat ausgeben. Testen Sie z. B.die folgenden Befehle:- `"%x" % 49152`- `"%o" % 18056` Der Einsatz des Operators `%` gilt in Python 3 allerdings als veraltet – stattdessen wird hier die auf Strings anwendbare Methode `format()` verwendet, z. B. wie folgt:```formatstring = "dezimal: {}, hex.: {:x}, oktal: {:o}, binär: {:b}"w = 99formatstring.format (w,w,w,w)``` Rufen Sie mit `help('FORMATTING')` die eingebaute Hilfe zur Formatierung auf und schauen Sie sich die Syntax und die am Endegezeigten Beispiele an.  Aufgabe 6: SchleifenProgrammieren Sie eine geschachtelte Schleife, die unten stehende Tabelle erzeugt.|   x   |   y   |   z   | x and y or ((y and z) and not x) || ----- | ----- | ----- | -------------------- || True  | True  | True  | True| | False  | True  | True  | True| | True  | False  | True  | False| | False  | False  | True  | False| | True  | True  | False  | True| | False  | True  | False  | False| | True  | False  | False  | False| | False  | False  | False  | False |<jupyter_code>print("x", "\t", "y", "\t", "z", "\t", "x and y or ((y and z) and not x)")
print('---------------------------------------------------------')
# YOUR CODE HERE
raise NotImplementedError()
assert _i.count('for')>2, 'Use nested loops'<jupyter_output><empty_output><jupyter_text>Aufgabe 7: DateienSchreiben Sie mehrere Strings als Zeilen in eine Datei und schließen Sie die Datei.<jupyter_code>file_name = "ausgabe.txt"

fobj = None #Use this variable for your file
# YOUR CODE HERE
raise NotImplementedError()
assert fobj.closed, 'File is not closed'
try:
    file = open(file_name, "r")
    assert file.read().count('\n')>2, '"ausgabe.txt" does not contain at least three lines'
    file.close()
except FileNotFoundError:
    print('"ausgabe.txt" has not been created')
    raise<jupyter_output><empty_output><jupyter_text>Öffnen Sie die Datei zum Lesen und geben Sie den Inhalt aus.<jupyter_code># YOUR CODE HERE
raise NotImplementedError()
assert fobj.closed, 'File is not closed'<jupyter_output><empty_output><jupyter_text>Aufgabe 8: FunktionenGeben Sie die folgende Funktion mit unendlicher Rekursion in ipython ein und testen Sie sie durch Aufruf von `unendlich(0)`.```pythondef unendlich(n):    return unendlich(n+1)```<jupyter_code>count = 0;
def unendlich(n):
    global count
    count += 1
    return unendlich(n+1)

try:
    unendlich(0)
except RecursionError:
    print(count)<jupyter_output><empty_output><jupyter_text>Wie Sie sehen, ist die maximale anzahl der Aufrufe begrenzt; der Aufruf `unendelich(0)` bricht nach einer Reihe von rekursiven Aufrufen mit einem Fehler ab.Damit an dieser Stelle der auftretende Fehler nicht zum Abbruch der Programmzelle führt, haben wir den Aufruf in einen `try`-`except` Block egstellt.Um mitzuzählen, wie viele Aufrufe erfolgen, verwenden wir eine globale Variable. Widmen wir uns nun *dem* klassischen Beispiel, wenn es um Rekursion geht:Die **Fibonacci-Funktion** ist durch$\largefib(n) = \begin{cases}    0,& \text{if } n = 0\\    1,& \text{if } n = 1\\    fib (n–1) + fib (n–2), & \text{if } n \geq 2\end{cases}$definiert. Betrachten Sie die folgenden zwei Implementierungen von `fib`:```pythondef fib_a(n):    if n == 0:        return 0    elif n == 1:        return 1    else:        return fib_a(n-1) + fib_a(n-2)``````pythondef fib_b(n):    (a,b) = (0,1)    for i in range(n):        (a,b) = (b,a+b)    return a```1. Welche der beiden Funktionen ist rekursiv?2. Geben Sie beide Funktionen in eine Code-Zelle ein und rufen Sie sie mit den Argumenten 20, 30 und 35 auf. Sie werden sehr unterschiedliche Laufzeiten beobachten. Haben Sie dafür eine Erklärung?<jupyter_code>def fib_a(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib_a(n-1) + fib_a(n-2)
    
def test_fib_a():
    # YOUR CODE HERE
    raise NotImplementedError()

from unittest.mock import patch, call
with patch('__main__.fib_a') as mock_f:
     test_fib_a()
calls = [call(20),call(30),call(35)]
mock_f.assert_has_calls(calls, any_order=True)
def fib_b(n):
    (a,b) = (0,1)
    for i in range(n):
        (a,b) = (b,a+b)
    return a

def test_fib_b():
    # YOUR CODE HERE
    raise NotImplementedError()
from unittest.mock import patch, call
with patch('__main__.fib_b') as mock_f:
     test_fib_b()
calls = [call(20),call(30),call(35)]
mock_f.assert_has_calls(calls, any_order=True)<jupyter_output><empty_output><jupyter_text>3. Schreiben Sie eine bessere rekursive Implementierung von fib, die ein Dictionary verwendet,welches als```pythonfib_dict = {}fib_dict[0] = 0fib_dict[1] = 1```initialisiert wird. Die neue Funktion fib_c() soll prüfen, ob der gesuchte Wert bereits im Dictionary enthalten ist – wenn ja, kann sie ihn einfach zurückgeben. (Zur Erinnerung: Ob ein Schlüssel / Key im Dictionary enthalten ist, testen Sie mit `key in dict`.) Wenn nicht, soll sie ihn rekursiv, also durch Aufruf von fib_c(), berechnen.4. Das Dictionary fib_dict deklarieren Sie außerhalb der Funktion. Warum ist dasvorteilhaft?<jupyter_code>fib_dict = {}
fib_dict[0] = 0
fib_dict[1] = 1

def fib_c(n):
    # YOUR CODE HERE
    raise NotImplementedError()
from nose.tools import assert_equal

try:
    fib_c(0)
    fib_c(1)
except:
    print('add cases of 0 and 1')
    raise


assert_equal(fib_c(0), 0)
assert_equal(fib_c(1), 1)
assert_equal(fib_c(10), 55)
assert_equal(fib_c(20), 6765)
assert_equal(fib_c(30), 832040)<jupyter_output><empty_output><jupyter_text>Aufgabe 9: Strings und KonvertierungImplementieren Sie eine Funktion `sternchen()`, die als Argument einen String oder eine Zahl akzeptiert. Sie soll als Rückgabewert einen String liefern, der vorne und hinten je drei Sternchen und dazwischen, durch Leerzeichen abgetrennt, den Parameter enthält. Also z. B.:```pythonsternchen("Hallo")  soll "*** Hallo ***" zurückgebensternchen(42)       soll "*** 42 ***"    zurückgebensternchen(4.123)    soll "*** 4.123 ***" zurückgeben```Sie können für die Umwandlung von Zahlen in Strings die Funktion `str()` verwenden, sollen diese aber nur aufrufen, wenn der Parameter kein String ist. Bei der Implementierung wird Ihnen die Funktion `type()` helfen.<jupyter_code>def sternchen(x):
    # YOUR CODE HERE
    raise NotImplementedError()
assert not [a for a in [15, 'Yes'] if sternchen(a) != f'*** {a} ***'], 'consider converting integers'
sternchen("HAllo")<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12593614505321246, 'fraction_numerical': 0.024733937721718564, 'mean_word_length': 4.384084880636605, 'pattern_counts': {'":': 0, '<': 49, '<?xml version=': 0, '>': 53, 'https://': 0, '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': '152318', 'license': 'MIT', 'n_tokens_mistral': 3829, 'n_tokens_neox': 3691, 'n_words': 1196, 'path': 'u1/ex01.ipynb', 'repo_name': 'fh-swf-hgi/skriptsprachen-ex', 'size': '10148'}