298 lines
5.0 KiB
Python
298 lines
5.0 KiB
Python
# %% [markdown]
|
|
# # Erweiterte Datentypen: Container
|
|
|
|
# %% [markdown]
|
|
# ## Listen und Tupel
|
|
|
|
# %%
|
|
# Listenliterale
|
|
|
|
values = [5, 10, 20, 30, 50]
|
|
print(values)
|
|
fractions = [0.5, 0.6, 0.8, 1.0, 1.2]
|
|
print(fractions)
|
|
names = ["Joe", "Alice", "Bob", "Charly"]
|
|
print(names)
|
|
heap = [1, "Joe", 1.4, "Alice", 100]
|
|
print(heap)
|
|
single = ["one"]
|
|
leer = []
|
|
auch_leer = list()
|
|
print(single, leer, auch_leer)
|
|
|
|
# %%
|
|
# Tuplelliterale
|
|
values = (5, 10, 20, 30, 50)
|
|
print(values)
|
|
fractions = (0.5, 0.6, 0.8, 1.0, 1.2)
|
|
print(fractions)
|
|
names = ("Joe", "Alice", "Bob", "Charly")
|
|
print(names)
|
|
heap = (1, "Joe", 1.4, "Alice", 100)
|
|
print(heap)
|
|
t_single = ("one",)
|
|
t_auch_single = "one",
|
|
t_leer = ()
|
|
t_auch_leer = tuple()
|
|
print(t_single, t_auch_single, t_leer, t_auch_leer)
|
|
|
|
|
|
# %%
|
|
# Umwandlung
|
|
|
|
l = [1, 2, 3, 4, 5]
|
|
t = tuple(l)
|
|
print(l, t)
|
|
l = [10, 20, 30, 40, 50]
|
|
print(l, t)
|
|
l2 = list(t)
|
|
print(l2)
|
|
|
|
# %%
|
|
s = "hallo"
|
|
print(list(s))
|
|
print(tuple(s))
|
|
|
|
# %% [markdown]
|
|
# ### Indizierung
|
|
|
|
# %%
|
|
seasons = ["Frühling", "Sommer", "Herbst", "Winter"]
|
|
print(seasons[0]) # Erstes Element hat Index 0!
|
|
print(seasons[2])
|
|
print(seasons[-1]) # Negative Indices zählen vom letzten Element rückwärts
|
|
print(seasons[-3])
|
|
|
|
# %%
|
|
# Ungültige Indizes führen zu einem Fehler (IndexError Exception)
|
|
print(seasons[4]) # 4 Elemente => gültige Indizes 0..3
|
|
|
|
# %%
|
|
# Ebenso
|
|
print(seasons[-5])
|
|
|
|
# %%
|
|
# Zuweisung an einzelne Listenelemente
|
|
|
|
l = [1, 2, 3, 4, 5]
|
|
l[1] = -1
|
|
print(l)
|
|
l[3] = "vier"
|
|
print(l)
|
|
l[-1] = 5.0
|
|
print(l)
|
|
|
|
# %%
|
|
# Indizierung funktioniert auch mit Tupeln mit der selben Syntax
|
|
t = (1, 2, 3, 4, 5)
|
|
print(t[0], t[-2])
|
|
|
|
# %%
|
|
# Aber Tuple sind nicht-veränderbar (immutable)
|
|
|
|
t[2] = "drei"
|
|
|
|
# %% [markdown]
|
|
# ### Slicing
|
|
|
|
# %%
|
|
l = list(range(10)) # l = [0, 1, ..., 9]
|
|
print(l)
|
|
print(l[2:4]) # Start ist inklusiv, Ende nicht!
|
|
|
|
# %%
|
|
# Auch wenn kein oder nur ein Element "übrig bleibt", ist das Ergebnis eine Liste
|
|
|
|
print(l[2:3])
|
|
print(l[9:-1])
|
|
|
|
# %%
|
|
# Start und End können leer, also "offen", sein
|
|
|
|
print(l[5:])
|
|
print(l[:3]) # auch hier ist der Ende-Index nicht-inklusiv!
|
|
|
|
# %%
|
|
# Sind Start und Ende leer, ist das Ergebnis eine Kopie der Liste / des Tuples
|
|
|
|
l1 = [1, 2, 3]
|
|
l2 = l1[:]
|
|
l3 = l1
|
|
l1[0] = 999
|
|
print(l1)
|
|
print(l2)
|
|
print(l3)
|
|
|
|
# %%
|
|
# Zuweisung an Listenslices ist möglich!
|
|
|
|
seasons = ["Winter", "Frühling", "Sommer", "Herbst"]
|
|
seasons[1:1] = ["Karneval"]
|
|
print(seasons)
|
|
|
|
# %%
|
|
# Listen oder Tuples können mit + zu einer/m neuen Liste / Tupel zusamengefügt werden
|
|
|
|
items = [1, 2, 3]
|
|
more_items = items + ["one", "two", "three"]
|
|
print(more_items)
|
|
items[1:2] = []
|
|
print(items)
|
|
print(more_items)
|
|
more_items += [4, 6, 6]
|
|
print(more_items)
|
|
|
|
|
|
# %%
|
|
t = (1, 2, 3)
|
|
t2 = t + (4, 5, 6)
|
|
print(t)
|
|
print(t2)
|
|
|
|
# %%
|
|
# Achtung:
|
|
|
|
t = (1, 2, 3)
|
|
t2 = t
|
|
print(t)
|
|
print(t2)
|
|
print(t is t2)
|
|
t += (1, 2, 3) # Tuples sind immutable, t ist eine neue Kopie!
|
|
print(t)
|
|
print(t2)
|
|
print(t is t2)
|
|
s = "ein string"
|
|
s += " und noch mehr"
|
|
i = 0
|
|
i += 1
|
|
|
|
|
|
# %%
|
|
l = list(range(10))
|
|
import sys
|
|
sys.getsizeof(l)
|
|
|
|
# %% [markdown]
|
|
# ## Dictionaries
|
|
|
|
# %%
|
|
# Auch Hashtables, Lookup Tables usw. genannt
|
|
# Tabellen mit Zurdnung von Schlüsseln zu werten (Key-value pairs)
|
|
|
|
d = {}
|
|
# oder:
|
|
d = dict()
|
|
print(d)
|
|
|
|
# %%
|
|
scores = {
|
|
"blue team": 40,
|
|
"green team": 45,
|
|
"red team": 30,
|
|
"black team": 60
|
|
}
|
|
print(scores)
|
|
|
|
# %%
|
|
# Look up
|
|
|
|
print("The red team scored:", scores["red team"])
|
|
|
|
# %%
|
|
# Neue Key/Value Paare hinzufügen (Dictionaries sind veränderbar!)
|
|
|
|
scores["white team"] = 45
|
|
scores["rainbow team"] = 50
|
|
print(scores)
|
|
del scores["blue team"]
|
|
|
|
# %%
|
|
# Umwandlung
|
|
|
|
print(tuple(scores)) # Tupel der Keys
|
|
|
|
print(list(scores)) # Liste der Keys
|
|
|
|
print(tuple(scores.keys()))
|
|
|
|
# %%
|
|
# Iteration
|
|
|
|
for key in scores:
|
|
print("Das", key, "hat", scores[key], "Punkte.")
|
|
|
|
# %%
|
|
# Iteration über Key/Value Paare
|
|
|
|
print(scores.items())
|
|
|
|
for key, value in scores.items():
|
|
print("Das", key, "hat", value, "Punkte.")
|
|
|
|
# %%
|
|
# Keys müssen keine Strings, aber immutable sein
|
|
# => Integers, Floats, Tuples sind ok
|
|
|
|
numbers = {1: "one", 2: "two", 3: "three"}
|
|
print(numbers[2]) # Achtung: nicht mit Listenindex verwechseln!
|
|
|
|
pixels = {
|
|
(0, 5): 'r',
|
|
(2, 7): 'b',
|
|
(3, 10): 'r',
|
|
(5, 2): 'g',
|
|
(5, 5): 'b',
|
|
}
|
|
|
|
for row in range(6):
|
|
for col in range(10):
|
|
value = pixels.get((row, col), ".")
|
|
print(value, end="")
|
|
print()
|
|
|
|
|
|
# %% [markdown]
|
|
# ## Sets (Mengen)
|
|
#
|
|
# Mengen sind wie unsortierte Tupel, in denen jedes Element nur einmal vorkommen kann.
|
|
|
|
# %%
|
|
s = set([])
|
|
print(s) # leeres Set wird repräsentiert mit 'set()', nicht '{}' (leeres Dictionary!)
|
|
|
|
s2 = set([2,3,5])
|
|
s2.add(4)
|
|
s2.add(5) # Schon im Set enthalten
|
|
print(s2)
|
|
|
|
for i in s2:
|
|
print(i)
|
|
|
|
print()
|
|
|
|
s2.add(1)
|
|
s2.remove(4)
|
|
|
|
for i in s2:
|
|
print(i) # Reihenfolge nach Änderung nicht garantiert gleich!
|
|
|
|
# %%
|
|
# Kombination
|
|
|
|
s1 = set([1, 2, 3, 5])
|
|
s2 = set([4, 5, 6, 7])
|
|
|
|
# Union (alle Elemente aus beiden Sets)
|
|
print(s1 | s2)
|
|
|
|
# Intersection (alle Elemente, die sowohl in s1 als auch s2 sind)
|
|
print(s1 & s2)
|
|
|
|
# Difference (alle Elemente in s1, die nicht auch in s2 sin)
|
|
print(s1 - s2)
|
|
|
|
# %% [markdown]
|
|
# Siehe: https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset
|
|
|
|
|