Fingerübungen 2024-03
Contents
Fingerübungen 2024-03#
Lösen Sie mit einem Einzeiler#
l1: Eine Liste l1 mit allen Zahlen von 0 bis n, hier mit n=5
n = 5
... #
assert l1 == [0, 1, 2, 3, 4, 5]
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [1], line 3
1 n = 5
2 #
----> 3 assert l1 == [0, 1, 2, 3, 4, 5]
NameError: name 'l1' is not defined
l2: Eine Liste l2, die alle Quadratzahlen von l1 enthält
... #
assert l2 == [0, 1, 4, 9, 16, 25]
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [2], line 2
1 ... #
----> 2 assert l2 == [0, 1, 4, 9, 16, 25]
NameError: name 'l2' is not defined
Plausibilitätskontrolle: l1 und l2 haben (bei n = 5) die Zahlen 0, 1 und 4 gemeinsam.
l3: Eine Liste l3, die alle Kubikzahlen (“hoch drei”) enthält, das man aus l1 erzeugen kann
... #
assert l3 == [0, 1, 8, 27, 64, 125]
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [3], line 2
1 ... #
----> 2 assert l3 == [0, 1, 8, 27, 64, 125]
NameError: name 'l3' is not defined
Plausibilitätskontrolle: l2 und l3 haben (bei n = 5) nur die Zahlen 0 und 1 gemeinsam.
s23: Ein Set s23, das alle Quadrat- und alle Kubikzahlen enthält, das man aus l1 erzeugen kann
einfach: mit Benutzung von
l2undl3anspruchsvoller: als Einzeiler nur mit Benutzung von
l1
# einfach
... #
#anspruchsvoller
... #
assert s23 == {0, 1, 4, 8, 9, 16, 25, 27, 64, 125}
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [4], line 5
1 # einfach
2 #
3 #anspruchsvoller
4 #
----> 5 assert s23 == {0, 1, 4, 8, 9, 16, 25, 27, 64, 125}
NameError: name 's23' is not defined
l2_minus_l3: Eine Liste l2_minus_l3, in der alle Elemente aus l2 enthalten sind, die nicht in l3 enthalten sind.
Reihenfolge relevant? Lösung mit List Comprehension!
Wenn die Reihenfolge egal ist: Lösung mit Hilfe von Sets!
# Lösung mit List Comprehension
... #
assert l2_minus_l3 == [4, 9, 16, 25]
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [5], line 3
1 # Lösung mit List Comprehension
2 #
----> 3 assert l2_minus_l3 == [4, 9, 16, 25]
NameError: name 'l2_minus_l3' is not defined
# Lösung mit Hilfe von Sets
... #
assert set(l2_minus_l3) == { 4, 9, 16, 25 }
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [6], line 3
1 # Lösung mit Hilfe von Sets
2 #
----> 3 assert set(l2_minus_l3) == { 4, 9, 16, 25 }
NameError: name 'l2_minus_l3' is not defined
Lösen Sie mit Set-Operatoren#
s1 = { 3, 2, 1, "a"}
s2 = { 3, "a", "c", "b" }
s3: Schnittmenge von s1 und s2
... #
assert s3 == {3, 'a'}
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [8], line 2
1 ... #
----> 2 assert s3 == {3, 'a'}
NameError: name 's3' is not defined
s4: Vereinigungsmenge von s1 und s2
... #
assert s4 == {1, 2, 3, 'a', 'b', 'c'}
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [9], line 2
1 ... #
----> 2 assert s4 == {1, 2, 3, 'a', 'b', 'c'}
NameError: name 's4' is not defined
s5: Differenzmenge: Alle Elemente aus s1, die nicht in s2 enthalten sind
... #
assert s5 == {1, 2}
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [10], line 2
1 ... #
----> 2 assert s5 == {1, 2}
NameError: name 's5' is not defined
s6 symmetrische Differenz: Alle Elemente aus s1, die nicht in s2 enthalten sind, sowie alle Elemente aus s2, die nicht in s1 enthalten sind
... #
assert s6 == {1, 2, 'b', 'c'}
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [11], line 2
1 ... #
----> 2 assert s6 == {1, 2, 'b', 'c'}
NameError: name 's6' is not defined
Übertragung Set-Operatoren auf Listen#
Aufgabe hier: Übertragung obiger grundlegenden Mengen-Operatoren auf Listen. Wesentlicher Unterschied
Die Reihenfoge ist relevant.
Mehrfach vorkommende ELemente sind erlaubt (und dürfen auch nicht weggeworfen werden), Zwischenschritte mit Set-Operatoren scheiden also aus.
Terminologie: Statt Schnittmenge reden wir informell von einer Schnittliste etc., die Bedeutung ist offensichtlich.
Und klar: Lösen Sie die Aufgabe mit einem Einzeiler ;-)
l_11 = [3, 2, 1, "a"]
l_12 = [3, "a", "c", "b"]
l_13: Schnitt-Liste von l_11 und l_12: Elemente aus l_11 (mit Reihenfolge), die auch in l_12 enthalten sind
... #
l_13
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [13], line 2
1 ... #
----> 2 l_13
NameError: name 'l_13' is not defined
l_14: Vereinigungs-Liste von l_11 und l_12: Alle Elemente aus l_11, dann alle Elemente aus l_12.
... #
l_14
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [14], line 2
1 ... #
----> 2 l_14
NameError: name 'l_14' is not defined
l_15: Differenz-Liste: alle Elemente aus l_11, die nicht in l_12 enthalten sind
l_15 = [ i for i in l_11 if i not in l_12 ]
l_15
[2, 1]
In eine Funktion packen#
Bereits oben gelöst: Schnittliste, Differenzliste.
Hier zu lösen: Definition entsprechender Funktionen.
Funktion schnittliste(x, y): gibt als Liste alle Elemente zurück, die sowohl in der Liste x wie auch in der Liste y enthalten sind.
def schnittliste(x, y):
"""gibt als Liste alle Elemente zurück,
die sowohl in der Liste x wie auch in der Liste y enthalten sind."""
... #
return ergebnis
assert schnittliste(l_11, l_12) == [3, 'a']
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [17], line 1
----> 1 assert schnittliste(l_11, l_12) == [3, 'a']
Cell In [16], line 5, in schnittliste(x, y)
2 """gibt als Liste alle Elemente zurück,
3 die sowohl in der Liste x wie auch in der Liste y enthalten sind."""
4 ... #
----> 5 return ergebnis
NameError: name 'ergebnis' is not defined
Funktion differenz_poly(x, y): gibt alle Elemente aus x zurück, nicht in y enthalten sind.
Wenn x ein Set ist, wird auch y wie eine Set behandelt, dann Mengen-Operation
Wenn x eine Liste ist, wird auch y wie eine Liste behandelt, dann Listen-Operation
Tip: Es gilt type([1,2,3]) == list; type({1,2,3}) == set
def differenz_poly(x, y):
if type(x) == set:
ergebnis = { i for i in x if i not in y }
elif type(x) == list:
ergebnis = [ i for i in x if i not in y ]
else:
print(f"ERROR: differenz_poly({type(x)}, {type(y)}) is undefinded")
ergebnis = None
return ergebnis
assert differenz_poly(l_11, l_12) == [2, 1]
assert differenz_poly(s1, s2) == {1, 2}
differenz_poly(3, 4)
ERROR: differenz_poly(<class 'int'>, <class 'int'>) is undefinded
Das ist mies!#
Mit den folgenden Ausdrücken versuchen wir Sie zu verwirren. Das ist mies – einerseits. Andererseits müssen Sie gerade mit solchen Ausdrücken zurechtkommen, wenn Sie Denkfehler in Fremdcode und – schwieriger – eigenem Code entdecken wollen.
Sei gegeben string = "abcba".
string = "abcba"
Auswertung bei dieser Aufgabe:
1 Punkt für jede richtige Antwort
1 Punkt Abzug (!) für jede falsche Antwort
+-0 Punkte für jede nicht abgegebene Antwort.
Es ist also eine gute Strategie, nur dort eine Antwort zu geben, wo Sie sicher sind.
Was wird bei den folgenden Ausdrücken ausgegeben?
#[ i for i in string]
... #
#set(string)
... #
#{ string }
... #
#str(set(string))
... #
#string[2]
... #
#string[2:3]
... #
#string[::]
... #
#str()
... #
#str
... #