From bfef87ad2d2907ea5540952a4f1369826f436d7f Mon Sep 17 00:00:00 2001 From: Robert Jeutter <48153869+wieerwill@users.noreply.github.com> Date: Sun, 10 Mar 2019 18:09:29 +0100 Subject: [PATCH] Add files via upload --- Python-Syntax.html | 1086 +++++++++++++++++++++++++++++-------------- Python-Syntax.ipynb | 780 +++++++++++++++++++++---------- 2 files changed, 1262 insertions(+), 604 deletions(-) diff --git a/Python-Syntax.html b/Python-Syntax.html index 80d75f6..d5844c8 100644 --- a/Python-Syntax.html +++ b/Python-Syntax.html @@ -13185,7 +13185,7 @@ div#notebook {
-

Daten Typen

Zahlen

Bei Zahlen wird zwischen Integers (ganzen Zahlen) und Floating-pint Numbers (Kommazahlen) oder kurz Floats unterschieden.

+

Datentypen

Zahlen

Bei Zahlen wird zwischen Integers (ganzen Zahlen) und Floating-pint Numbers (Kommazahlen) oder kurz Floats unterschieden.

@@ -13268,7 +13268,7 @@ Alex
-

Strings zusammenführen

Mehrere Strings können durch + oder Leerzeichen zusammengefügt werden

+

Strings zusammenführen

Mehrere Strings können durch + oder Leerzeichen zusammengefügt werden

@@ -13309,7 +13309,7 @@ Mein Name ist Alex. Wie ist dein Name?
-

Strings replizieren

Strings können einfach repliziert werden.

+

Strings replizieren

Strings können einfach repliziert werden.

@@ -13348,7 +13348,7 @@ Mein Name ist Alex. Wie ist dein Name?
-

Strings kürzen

Strings können über [Zahl:Zahl] gekürzt werden. Wobei die Zahlen die zu überspringenden Zeichen angeben.

+

Strings kürzen

Strings können über [Zahl:Zahl] gekürzt werden. Wobei die Zahlen die zu überspringenden Zeichen angeben.

@@ -13387,7 +13387,7 @@ Mein Name ist Alex. Wie ist dein Name?
-

Bestimmte Zeichen eines Strings ausgeben

Einzelne String-Zeichen können mittel [Zahl] ausgegeben werden, wobei Zahl die gesuchte Position ist

+

Bestimmte Zeichen eines Strings ausgeben

Einzelne String-Zeichen können mittel [Zahl] ausgegeben werden, wobei Zahl die gesuchte Position ist

@@ -13726,8 +13726,21 @@ Hallo Alex
-

2. Listen

Listen können mehrere Elemente enthalten und sind veränderliche Datenstruktur.
+

2. Datenstrukturen

    +
  • Listen: Geordnete Auflistung von Elementen. Bsp: liste = ["Hallo", "Welt"]
    • +
  • Dictionaries: Zuordnung von Schlüssel zu Wert. Bsp: d = {"Hallo": 5, "Welt": 4}
    • +
  • Tupel: Geordnete Auflistung von Elementen, jedoch unveränderlich
    • +
  • Set: Ungeordnete Sammlung von Elementen, deren Elemente innerhalb nur einmal vorkommen dürfen
    • +
  • Queue: Ähnlich wie Liste, sind Elemente sortiert und werden in Reihenfolge der Eingabe ausgegeben
    • +
  • PriorityQueue (Prioritätswarteschlange): Automatische Sortierung der Elemente
    • +
+

Listen

Listen können mehrere Elemente enthalten und sind veränderliche Datenstruktur.
Listenname = ["Element1", Element2", ... ]

+
    +
  • Kann nachträglich erweitert werden
    • +
  • Reihenfolge wird beibehalten
    • +
  • Elemente dürfen mehrfach vorkommen
    • +
@@ -14256,14 +14269,13 @@ Element5
-

3. Daten umwandeln

-
-
-
-
-
-
-

Einen String in eine Ganzzahl umwandeln

int()-Befehl auf einen String: int(string)

+

Dictionaries

Die Verknüpfung verschiedener Strings und Listen wird mit Dictionaries erfolgen.

+
    +
  • Speichert eine Zuordnung von einem Schlüssel (key) zu einem Wert (value)
    • +
  • Reihenfolge wird nicht beibehalten
    • +
  • Werte dürfen mehrfach vorkommen
    • +
  • Jeder Schlüssel darf aber nur 1x existieren
    • +
@@ -14271,6 +14283,480 @@ Element5
In [28]:
+
+
+
d = {"Berlin":"BER", "Helsinki":"Hel", "Barcelona":"BAC"} # Aufbau eines Dictionaries
+print(d) # Ausgabe des gesamten Dictionaries
+print(d["Helsinki"]) # Ausgabe der Wertzuweisung für den Schlüssel "Helsinki"
+print(d.get("Helsinki")) # vermeidet Fehler falls Schlüssel nicht im Dictionarie enthalten
+print(d.get("Budapest")) # Beispiel für nicht-existenz
+print(d.items())  # Ausgabe des Dictionaries als Liste mit Tupel
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
{'Berlin': 'BER', 'Helsinki': 'Hel', 'Barcelona': 'BAC'}
+Hel
+Hel
+None
+dict_items([('Berlin', 'BER'), ('Helsinki', 'Hel'), ('Barcelona', 'BAC')])
+
+
+
+ +
+
+ +
+
+
+
+

Dictionaries kann jedem Element/Schlüssel auch eine Definition zugewiesen werden

+ +
+
+
+
+
+
In [29]:
+
+
+
for key, wert in d.items():
+
+    print(key + " : " + wert)  
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Berlin : BER
+Helsinki : Hel
+Barcelona : BAC
+
+
+
+ +
+
+ +
+
+
+
+

Listen in Dictionaries

+ +
+
+
+
+
+
In [30]:
+
+
+
staedte = {
+    "München": ["MUC", "Bayern"],
+    "Berlin": ["BER", "Berlin"]
+}
+
+print(staedte["Berlin"])
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
['BER', 'Berlin']
+
+
+
+ +
+
+ +
+
+
+
+

Tupel

Ähnlich zu Listen, jedoch unveränderliche Datenstruktur (nicht erweiterbar).

+ +
+
+
+
+
+
In [31]:
+
+
+
t = (1, 2, 3) # ein Tupel wird mit runden Klammern gebildet
+
+print(t)      # abrufen des gesamten Tupel
+
+print(t[1])   # abrufen eines bestimmten Tupel-Elements
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
(1, 2, 3)
+2
+
+
+
+ +
+
+ +
+
+
+
+

Tupel definieren

Der Inhalt eines Tupels kann durch Variablen definiert und zugewiesen werden. Erleichtert den Zugriff und das Entpacken

+ +
+
+
+
+
+
In [32]:
+
+
+
student = ("Max Mustermann", 20, "Maschinenbau") # Tupel bilden
+name, alter, fach = student # Tupel entpacken und Definition zuweisen
+print(fach)   # Information aus Tupel anhand der Definition entpacken
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Maschinenbau
+
+
+
+ +
+
+ +
+
+
+
+

Eine Liste mit Tupel

+
+
+
+
+
+
In [33]:
+
+
+
students = [
+    ("Max", 20), # Komma zwischen Tupel nicht vergessen!
+    ("Alex", 30)
+]
+
+for name, alter in students: # Definitionen zuweisen 
+    print(name)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Max
+Alex
+
+
+
+ +
+
+ +
+
+
+
+

Set

Ungeordnete Sammlung von Elementen, deren Elemente innerhalb nur einmal vorkommen dürfen.

+ +
- Kann nachträglich erweitert werden
+- Reihenfolge wird nicht beibehalten
+- Index - Schreibweise s[15] wird nicht unterstützt
+- Jedes Element kommt nur 1x vor
+ +
+
+
+
+
+
In [34]:
+
+
+
s = ["Hallo", "Welt"]
+print(s)
+s.append("Mars")
+print(s)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
['Hallo', 'Welt']
+['Hallo', 'Welt', 'Mars']
+
+
+
+ +
+
+ +
+
+
+
In [35]:
+
+
+
if "Mars" in s:
+    print("Mars ist im Set")
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Mars ist im Set
+
+
+
+ +
+
+ +
+
+
+
+

Queue

Ähnlich wie Liste, sind Elemente sortiert und werden in Reihenfolge der Eingabe ausgegeben

+ +
+
+
+
+
+
In [36]:
+
+
+
import queue
+q = queue.Queue()     # Queue erstellen
+
+q.put("Hallo")        # Elemente einfügen
+q.put("Welt")
+
+print(q)
+print(q.get())        # Element ausgeben
+print(q.get())
+
+q.empty()             # überprüfen ob Queue leer ist
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
<queue.Queue object at 0x0000025AEDBD8780>
+Hallo
+Welt
+
+
+
+ +
+ +
Out[36]:
+ + + + +
+
True
+
+ +
+ +
+
+ +
+
+
+
+

PriorityQueue

Ähnlich wie Queue. Elemente werden mit unterschiedlicher "Dringlichkeit" eingegeben und nach "Dringlichkeit" ausgegeben. Automatische Sortierung der Elemente nach "Dringlichkeit".

+ +
- Optimierte Datenstruktur, um Elemente nach einer Priorität zu sortieren
+- Elemente werden quasi automatisch nach ihrer Priorität sortiert
+- Direkter Zugriff auf die Elemente nicht möglich
+- Man kann nur auf das erste Element zugreifen, bzw. das erste Element entfernen
+ +
+
+
+
+
+
In [37]:
+
+
+
import queue
+q = queue.PriorityQueue()    #PriotityQueue erstellen
+
+q.put((10, "Hallo Welt"))    # Elemente mit Priorität einfügen
+q.put((5, "Wichtig"))
+q.put((15, "Mars"))
+
+print(q.get())                      # Element von kleinster nach größter Priorität ausgeben
+q.get()
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
(5, 'Wichtig')
+
+
+
+ +
+ +
Out[37]:
+ + + + +
+
(10, 'Hallo Welt')
+
+ +
+ +
+
+ +
+
+
+
+

3. Daten(-strukturen umwandeln

Einen String in eine Ganzzahl umwandeln

int()-Befehl auf einen String: int(string)

+ +
+
+
+
+
+
In [38]:
a = int("5")
@@ -14310,7 +14796,7 @@ Element5
-
In [29]:
+
In [39]:
a = float("5.5")
@@ -14350,7 +14836,7 @@ Element5
-
In [30]:
+
In [40]:
age = str(21)
@@ -14390,7 +14876,7 @@ Element5
-
In [31]:
+
In [41]:
students = "Alex, Bob, Cedric, Erika"
@@ -14425,7 +14911,7 @@ Element5
 

 

 

-
4. Operatoren
Vergleichoperatoren
Verschiedene Operatoren zum Vergleichen von Variablen/Zahlen

+
4. Operatoren & Gatter
Vergleichoperatoren
Verschiedene Operatoren zum Vergleichen von Variablen/Zahlen

 
    
 
  • a == b Werte sind gleich
    • 
 
  • a != b Werte sind ungleich
    • 
@@ -14441,7 +14927,7 @@ Die Ausgabe über print() gibt die Booleans True
 
    
 
    
-
    In [32]:
    
+
    In [42]:
    
 
    
     
    
 
    a = 5
@@ -14497,7 +14983,7 @@ False
 
    
 
    
 
    
-
    In [33]:
    
+
    In [43]:
    
 
    
     
    
 
    # Für and müssen beide Variablen den gleichen Wert annehmen
@@ -14535,7 +15021,7 @@ False
 
    
 
    
 
    
-
    In [34]:
    
+
    In [44]:
    
 
    
     
    
 
    # Für or muss eine der Variablen True annehmen
@@ -14573,7 +15059,7 @@ False
 
    
 
    
 
    
-
    In [35]:
    
+
    In [45]:
    
 
    
     
    
 
    # 'not' Gatter negieren Ihr Ergebnis
@@ -14616,7 +15102,7 @@ True
 
    
 
    
 
    
-
    In [36]:
    
+
    In [46]:
    
 
    
     
    
 
    students = ["Alex", "Bob", "Cedric", "Erika"]
@@ -14658,7 +15144,7 @@ True
 
    
 
    
 
    
-
    In [37]:
    
+
    In [47]:
    
 
    
     
    
 
    satz ="Ja dieser Text ist ein String!"
@@ -14699,7 +15185,7 @@ True
 
    
 
    
 
    
-
    In [38]:
    
+
    In [48]:
    
 
    
     
    
 
    print( not 5 == 5) # Das Erbgenis von "5 == 5" ist wahr, "not" negiert das Ergebnis
@@ -14742,7 +15228,7 @@ True
 
    
 
    
 
    
-
    In [39]:
    
+
    In [49]:
    
 
    
     
    
 
    i = 5
@@ -14788,7 +15274,7 @@ True
 
    
 
    
 
    
-
    if-else-Struktur
    Ausführen bestimmter Abschnitte nur bei bestimmter Bedingung in if-else-Struktur.
+
    if-else-Struktur
    Ausführen bestimmter Abschnitte nur bei bestimmter Bedingung in if-else-Struktur.
 if fordert eine Bedingung, wird diese Bedingung erfüllt wird der eingrückte nachstehende Code ausgeführt.
 else wird ausgeführt, wenn die Bedingung nicht erfüllt wird
    
 
    Jeder Codeblock wird nur einmal ausgeführt. Beachte die Einrückung für den Codeabschnitt!
    
@@ -14802,7 +15288,7 @@ else:
    
 
    
 
    
 
    
-
    In [40]:
    
+
    In [50]:
    
 
    
     
    
 
    x = 5
@@ -14847,7 +15333,7 @@ Ich bin nicht mehr Eingerückt
 
    
 
    
 
    
-
    In [41]:
    
+
    In [51]:
    
 
    
     
    
 
    x = 5
@@ -14889,14 +15375,14 @@ Ich bin nicht mehr Eingerückt
 
    
 
    
 
    
-
    for-Schleife
    Die for-Schleife durchläuft eine anzugebende Sequenz
    
+
    for-Schleife
    Die for-Schleife durchläuft eine anzugebende Sequenz
    
 
 
    
 
    
 
    
 
    
 
    
-
    In [42]:
    
+
    In [52]:
    
 
    
     
    
 
    # Das Funktioniert sowohl mit Zahlen als auch Strings
@@ -14947,7 +15433,7 @@ Michael
 
    
 
    
 
    
-
    In [43]:
    
+
    In [53]:
    
 
    
     
    
 
    for i in range(0, 5): # von 0 bis 4 werden alle Zahlen ausgegeben
@@ -14984,7 +15470,7 @@ Michael
 
    
 
    
 
    
-
    while-Schleife
    while-Schleifen führen einen Code-Block mehrmals hintereinander aus, bis eine Abbruchbedingung erfüllt ist.
+
    while-Schleife
    while-Schleifen führen einen Code-Block mehrmals hintereinander aus, bis eine Abbruchbedingung erfüllt ist.
 Innerhalb einer while-Schleife muss ein Zustand verändert werden, damit das Programm die Schleife auch wieder verlassen kann!
    
 
 
    
@@ -14992,7 +15478,7 @@ Innerhalb einer while-Schleife muss ein Zustand verändert werden, damit das Pro
 
    
 
    
 
    
-
    In [44]:
    
+
    In [54]:
    
 
    
     
    
 
    zähler = 0
@@ -15036,7 +15522,7 @@ Innerhalb einer while-Schleife muss ein Zustand verändert werden, damit das Pro
 
    
 
    
 
    
-
    In [45]:
    
+
    In [55]:
    
 
    
     
    
 
    for i in range(0, 4):
@@ -15072,7 +15558,7 @@ Innerhalb einer while-Schleife muss ein Zustand verändert werden, damit das Pro
 
    
 
    
 
    
-
    In [46]:
    
+
    In [56]:
    
 
    
     
    
 
    for i in range(0, 4):
@@ -15118,7 +15604,7 @@ Beachte, der Funktion oder ihren Variablen keine Dopplungen aus deinem Code zu g
 
    
 
    
 
    
-
    In [47]:
    
+
    In [57]:
    
 
    
     
    
 
    def print_more():    # Das Definieren der Funktion
@@ -15163,7 +15649,7 @@ there
 
    
 
    
 
    
-
    In [48]:
    
+
    In [58]:
    
 
    
     
    
 
    def print_name(name): # hier wird in Klammern ein Argument übergeben, ein Argument kann frei definiert werden
@@ -15197,7 +15683,7 @@ there
 
    
 
    
 
    
-
    In [49]:
    
+
    In [59]:
    
 
    
     
    
 
    def print_more(name, count):
@@ -15241,7 +15727,7 @@ Hallo!
 
    
 
    
 
    
-
    In [50]:
    
+
    In [60]:
    
 
    
     
    
 
    def print_name(name):
@@ -15290,7 +15776,7 @@ Ich bin 23 Jahre alt.
 
    
 
    
 
    
-
    In [51]:
    
+
    In [61]:
    
 
    
     
    
 
    def return_element(name):
@@ -15349,7 +15835,7 @@ Soll nichts überschrieben werden oder Text angehängt werden nutzt man den Oper
 
    
 
    
 
    
-
    In [52]:
    
+
    In [62]:
    
 
    
     
    
 
    file = open("test.txt", "w")
@@ -15372,7 +15858,7 @@ Soll nichts überschrieben werden oder Text angehängt werden nutzt man den Oper
 
    
 
    
 
    
-
    In [53]:
    
+
    In [63]:
    
 
    
     
    
 
    file = open("test.txt", "r")
@@ -15416,267 +15902,7 @@ Soll nichts überschrieben werden oder Text angehängt werden nutzt man den Oper
 
    
 
    
 
    
-
    8. Dictionaries
    Die Verknüpfung verschiedener Strings und Listen wird mit Dictionaries erfolgen. Dictionaries werden mit {"Schlüssel:Zuweisung} aufgebaut
    
-
-
    
-
    
-
    
-
    
-
    
-
    In [54]:
    
-
    
-    
    
-
    d = {"Berlin":"BER", "Helsinki":"Hel", "Barcelona":"BAC"} # Aufbau eines Dictionaries
-print(d) # Ausgabe des gesamten Dictionaries
-print(d["Helsinki"]) # Ausgabe der Wertzuweisung für den Schlüssel "Helsinki"
-print(d.get("Helsinki")) # vermeidet Fehler falls Schlüssel nicht im Dictionarie enthalten
-print(d.get("Budapest")) # Beispiel für nicht-existenz
-print(d.items())  # Ausgabe des Dictionaries als Liste mit Tupel
-
    
-
-    
    
-
    
-
    
-
-
    
-
    
-
-
-
    
-
-    
    
-
-
-
    
-
    {'Berlin': 'BER', 'Helsinki': 'Hel', 'Barcelona': 'BAC'}
-Hel
-Hel
-None
-dict_items([('Berlin', 'BER'), ('Helsinki', 'Hel'), ('Barcelona', 'BAC')])
-
    
-
    
-
    
-
-
    
-
    
-
-
    
-
    
-
    
-
    
-
    Dictionaries kann jedem Element/Schlüssel auch eine Definition zugewiesen werden
    
-
-
    
-
    
-
    
-
    
-
    
-
    In [55]:
    
-
    
-    
    
-
    for key, wert in d.items():
-    print(key + " : " + wert)    
-
    
-
-    
    
-
    
-
    
-
-
    
-
    
-
-
-
    
-
-    
    
-
-
-
    
-
    Berlin : BER
-Helsinki : Hel
-Barcelona : BAC
-
    
-
    
-
    
-
-
    
-
    
-
-
    
-
    
-
    
-
    
-
    Listen in Dictionaries
    
-
    
-
    
-
    
-
    
-
    
-
    In [56]:
    
-
    
-    
    
-
    staedte = {
-    "München": ["MUC", "Bayern"],
-    "Berlin": ["BER", "Berlin"]
-}
-print(staedte["Berlin"])
-
    
-
-    
    
-
    
-
    
-
-
    
-
    
-
-
-
    
-
-    
    
-
-
-
    
-
    ['BER', 'Berlin']
-
    
-
    
-
    
-
-
    
-
    
-
-
    
-
    
-
    
-
    
-
    9. Tupel
    Ähnlich zu Listen, jedoch unveränderliche Datenstruktur.
    
-
-
    
-
    
-
    
-
    
-
    
-
    In [57]:
    
-
    
-    
    
-
    t = (1, 2, 3) # ein Tupel wird mit runden Klammern gebildet
-print(t)      # abrufen des gesamten Tupel
-print(t[1])   # abrufen eines bestimmten Tupel-Elements
-
    
-
-    
    
-
    
-
    
-
-
    
-
    
-
-
-
    
-
-    
    
-
-
-
    
-
    (1, 2, 3)
-2
-
    
-
    
-
    
-
-
    
-
    
-
-
    
-
    
-
    
-
    
-
    Tupel definieren
    Der Inhalt eines Tupels kann durch Variablen definiert und zugewiesen werden. Erleichtert den Zugriff und das Entpacken
    
-
-
    
-
    
-
    
-
    
-
    
-
    In [58]:
    
-
    
-    
    
-
    student = ("Max Mustermann", 20, "Maschinenbau") # Tupel bilden
-name, alter, fach = student # Tupel entpacken und Definition zuweisen
-print(fach)   # Information aus Tupel anhand der Definition entpacken
-
    
-
-    
    
-
    
-
    
-
-
    
-
    
-
-
-
    
-
-    
    
-
-
-
    
-
    Maschinenbau
-
    
-
    
-
    
-
-
    
-
    
-
-
    
-
    
-
    
-
    
-
    Eine Liste mit Tupel
    
-
    
-
    
-
    
-
    
-
    
-
    In [59]:
    
-
    
-    
    
-
    students = [
-    ("Max", 20), # Komma zwischen Tupel nicht vergessen!
-    ("Alex", 30)
-]
-
-for name, alter in students: # Definitionen zuweisen 
-    print(name)
-
    
-
-    
    
-
    
-
    
-
-
    
-
    
-
-
-
    
-
-    
    
-
-
-
    
-
    Max
-Alex
-
    
-
    
-
    
-
-
    
-
    
-
-
    
-
    
-
    
-
    
-
    10. Module
    Mit Modulen können Funktionen und Rechnungen aus anderen Python-Programmen in einem anderen Wiederbenutzt werden.
    
+
    8. Module
    Mit Modulen können Funktionen und Rechnungen aus anderen Python-Programmen in einem anderen Wiederbenutzt werden.
    
 Dafür erstellt man erst ein Python-Programm (Datei mit .py-Endung). Diese wird über den import-Befehl geladen.
    
 
 
    
@@ -15684,7 +15910,7 @@ Dafür erstellt man erst ein Python-Programm (Datei mit .py-End
 
    
 
    
 
    
-
    In [3]:
    
+
    In [64]:
    
 
    
     
    
 
    # Das 'hallo.py' Programm:
@@ -15718,7 +15944,7 @@ Dafür erstellt man erst ein Python-Programm (Datei mit .py-End
 
    
 
    
 
    
-
    In [4]:
    
+
    In [65]:
    
 
    
     
    
 
    import hallo # die Datei hallo.py wird in das aktuelle Programm eingebunden
@@ -15750,7 +15976,7 @@ Dafür erstellt man erst ein Python-Programm (Datei mit .py-End
 
    
 
    
 
    
-
    In [5]:
    
+
    In [66]:
    
 
    
     
    
 
    from hallo import welt # damit wird explizit nur die Funktion 'welt()' in das aktuelle Programm geladen, jede weitere mit ',' getrennt
@@ -15783,7 +16009,7 @@ Dafür erstellt man erst ein Python-Programm (Datei mit .py-End
 
    
 
    
 
    
-
    In [6]:
    
+
    In [67]:
    
 
    
     
    
 
    from hallo import * # mit dem '*' werden alle Funktionen aus 'hallo.py' in das aktuelle Programm geladen
@@ -15815,7 +16041,7 @@ Dafür erstellt man erst ein Python-Programm (Datei mit .py-End
 
    
 
    
 
    
-
    In [7]:
    
+
    In [68]:
    
 
    
     
    
 
    import hallo as h # mit der 'as'-Methode wird zum Aufrufen eines Programms im Skript ein 'Ersatzname' genutzt
@@ -15855,7 +16081,7 @@ Dafür erstellt man erst ein Python-Programm (Datei mit .py-End
 
    
 
    
 
    
-
    In [ ]:
    
+
    In [69]:
    
 
    
     
    
 
    # Modul-Datei: __init__.py
@@ -15869,7 +16095,7 @@ Dafür erstellt man erst ein Python-Programm (Datei mit .py-End
 
    
 
    
 
    
-
    In [ ]:
    
+
    In [70]:
    
 
    
     
    
 
    # hier wird der Vorteil der Modul-Datei gezeigt
@@ -15881,6 +16107,24 @@ Dafür erstellt man erst ein Python-Programm (Datei mit .py-End
 
    
 
    
 
+
    
+
    
+
+
+
    
+
+    
    
+
+
+
    
+
    datei.py - Funktion f()
+
    
+
    
+
    
+
+
    
+
    
+
 
    
 
    
 
    
@@ -15895,7 +16139,7 @@ Einige der wichtigsten Module werden folgend vorgestellt
    
 
    
 
    
 
    
-
    In [8]:
    
+
    In [71]:
    
 
    
     
    
 
    %matplotlib inline 
@@ -15941,7 +16185,7 @@ Einige der wichtigsten Module werden folgend vorgestellt
    
 
    
 
    
 
    
-
    In [61]:
    
+
    In [72]:
    
 
    
     
    
 
    import sys
@@ -15963,7 +16207,7 @@ Einige der wichtigsten Module werden folgend vorgestellt
    
 
    
 
    
 
    
-
    In [19]:
    
+
    In [73]:
    
 
    
     
    
 
    import time     # Time-Modul importieren
@@ -15985,7 +16229,7 @@ Einige der wichtigsten Module werden folgend vorgestellt
    
 
    
 
    
 
    
-
    In [5]:
    
+
    In [74]:
    
 
    
     
    
 
    import requests
@@ -16009,7 +16253,6 @@ Einige der wichtigsten Module werden folgend vorgestellt
    
 
 
    
 
    200
-{'Date': 'Sun, 10 Mar 2019 10:06:34 GMT', 'Expires': '-1', 'Cache-Control': 'private, max-age=0', 'Content-Type': 'text/html; charset=ISO-8859-1', 'P3P': 'CP="This is not a P3P policy! See g.co/p3phelp for more info."', 'Content-Encoding': 'gzip', 'Server': 'gws', 'Content-Length': '5434', 'X-XSS-Protection': '1; mode=block', 'X-Frame-Options': 'SAMEORIGIN', 'Set-Cookie': '1P_JAR=2019-03-10-10; expires=Tue, 09-Apr-2019 10:06:34 GMT; path=/; domain=.google.de, NID=162=hj9rxv-Nn8TIZUhSheNrRj0Jdo-Z_UkDlz9QadH8cnTTxQo-doOCClFPhDQfJe2phQCuVLI2qgDasKfuuXwxZ1COXvS8iE7moTbTI2AHnKVJrrfyhsuz9_hKOkoiZ1bkG1-15qe1lt_Vi3vktyz8R4dpVdOUGTOlsy43lpLvuhY; expires=Mon, 09-Sep-2019 10:06:34 GMT; path=/; domain=.google.de; HttpOnly'}
 
    
 
    
 
    
@@ -16028,7 +16271,7 @@ Einige der wichtigsten Module werden folgend vorgestellt
    
 
    
 
    
 
    
-
    In [12]:
    
+
    In [75]:
    
 
    
     
    
 
    from bs4 import BeautifulSoup      # BeautifulSoup importieren
@@ -16086,7 +16329,7 @@ Ich bin noch ein Absatz
 
    
 
    
 
    
-
    In [18]:
    
+
    In [76]:
    
 
    
     
    
 
    from urllib.parse import urljoin   # urljoin importieren
@@ -16117,13 +16360,13 @@ Ich bin noch ein Absatz
 
 
 
    
-
    relative URL: ./img/1.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/1.jpg
-relative URL: ./img/2.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/2.jpg
-relative URL: ./img/3.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/3.jpg
-relative URL: ./img/4.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/4.jpg
-relative URL: ./img/5.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/5.jpg
-relative URL: ./img/6.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/6.jpg
-relative URL: ./img/7.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/7.jpg
+
    relative URL: ./img/1.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/1.jpg
+relative URL: ./img/2.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/2.jpg
+relative URL: ./img/3.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/3.jpg
+relative URL: ./img/4.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/4.jpg
+relative URL: ./img/5.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/5.jpg
+relative URL: ./img/6.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/6.jpg
+relative URL: ./img/7.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/7.jpg
 
    
 
    
 
    
@@ -16131,31 +16374,18 @@ relative URL: ./img/7.jpg ; gesamte URL: http://python.beispiel.programmierenler
 
    
 
    
 
-
    
-
    
-
    
-
    In [ ]:
    
-
    
-    
    
-
     
-
    
-
-    
    
-
    
-
    
-
 
    
 
    
 
    
 
    
-
    Generatoren
    Generatoren erzeugen Listen (meist aus Crawlern) die viele Einträge enthält. Aus dieser Liste können eine bestimmte Anzahl an Einträgen ausgegeben werden. Die .fetch()-Methode erkennt dies dadurch automatisch.
    
+
    9. Generatoren
    Generatoren erzeugen Listen (meist aus Crawlern) die viele Einträge enthält. Aus dieser Liste können eine bestimmte Anzahl an Einträgen ausgegeben werden. Die .fetch()-Methode erkennt dies dadurch automatisch.
    
 
 
    
 
    
 
    
 
    
 
    
-
    In [8]:
    
+
    In [77]:
    
 
    
     
    
 
    def gen_generator():
@@ -16216,7 +16446,7 @@ gen: 1
 
    
 
    
 
    
-
    In [62]:
    
+
    In [78]:
    
 
    
     
    
 
    class Student():               # Klasse Student erstellen, Klassennamen beginnen gemäß Konvention mit Großbuchstaben
@@ -16254,7 +16484,7 @@ gen: 1
 
    
 
    
 
    
-
    In [63]:
    
+
    In [79]:
    
 
    
     
    
 
    class Student():                      
@@ -16302,7 +16532,7 @@ innerhalb eines Objekts alle Namenskonventionen festzuhalten.
    
 
    
 
    
 
    
-
    In [64]:
    
+
    In [80]:
    
 
    
     
    
 
    class Student():
@@ -16340,7 +16570,7 @@ innerhalb eines Objekts alle Namenskonventionen festzuhalten.
    
 
    
 
    
 
    
-
    In [65]:
    
+
    In [81]:
    
 
    
     
    
 
    class Student():
@@ -16397,7 +16627,7 @@ Mit zwei Unterstrichen vor der Variable wird diese priv
 
    
 
    
 
    
-
    In [66]:
    
+
    In [82]:
    
 
    
     
    
 
    class Student():
@@ -16427,7 +16657,7 @@ Als Parameter wird die Klasse übergeben, von der neue Eigenschaften und Methode
 
    
 
    
 
    
-
    In [67]:
    
+
    In [83]:
    
 
    
     
    
 
    class WorkingStudent(Student):
@@ -16457,7 +16687,7 @@ Die Funktion isinstance() erhält zwei Parameter: die V
 
    
 
    
 
    
-
    In [68]:
    
+
    In [84]:
    
 
    
     
    
 
    print(type(student))
@@ -16498,7 +16728,7 @@ False
 
    
 
    
 
    
-
    In [69]:
    
+
    In [85]:
    
 
    
     
    
 
    class Car:
@@ -16559,7 +16789,7 @@ Die len-Methode gibt für print(len(Objekt)) die Länge aus.
    
 
    
 
    
-
    In [70]:
    
+
    In [86]:
    
 
    
     
    
 
    class PhoneBook():
@@ -16615,9 +16845,167 @@ Die len-Methode gibt für print(len(Objekt)) die Länge aus.
    
 
    
 
    
+
    11. Exceptions
    Während der Laufzeit eines Programms können Fehler auftreten. Damit das Programm dadurch nicht abgebrochen wird, kann man mit Exceptions (try: und except: Blöcke) arbeiten. Ein Code kann mehrere except-Blöcke enthalten. Es können auch eigene Fehlercodes programmiert werden.
    
+Fehlercodes sollten nur in den seltensten Fällen benutzt werden!
    
 
 
    
 
    
+
    
+
    
+
    
+
    In [87]:
    
+
    
+    
    
+
    try:
+    print(5 / 0)                       # durch Null teilen ist nicht definiert -> Fehler
+    print(4)                           # alles nach dem Fehler wird nicht ausgeführt
+except ZeroDivisionError:              # tritt ein bestimmter Fehler auf wird der except-Block asugeführt
+    print("Durch null teilen ist nicht erlaubt!")
+print(5)                               # alles nach dem except Block wird wieder ausgeführt
+
    
+
+    
    
+
    
+
    
+
+
    
+
    
+
+
+
    
+
+    
    
+
+
+
    
+
    Durch null teilen ist nicht erlaubt!
+5
+
    
+
    
+
    
+
+
    
+
    
+
+
    
+
    
+
    
+
    
+
    Eigene Fehler auslösen
    Über den raise-Befehl können eigene Fehler ausgelöst werden.
    
+
+
    
+
    
+
    
+
    
+
    
+
    In [88]:
    
+
    
+    
    
+
    class InvalidEmailError(Exception):
+    pass
+
+def send_mail(email, subject, content):
+    if not "@" in email:
+        raise InvalidEmailError("email does not contain an @")
+try:     
+    send_mail("hallo", "Betreff", "Inhalt")
+except InvalidEmailError:
+    print("Bitte gebe eine gültige E-Mail ein")
+
    
+
+    
    
+
    
+
    
+
+
    
+
    
+
+
+
    
+
+    
    
+
+
+
    
+
    Bitte gebe eine gültige E-Mail ein
+
    
+
    
+
    
+
+
    
+
    
+
+
    
+
    
+
    
+
    
+
    Code abschließen
    Der finally-Befehl wird bei jedem Programmdurchlauf ausgeführt, auch wenn zuvor Fehler aufgetreten sind.
    
+
+
    
+
    
+
    
+
    
+
    
+
    In [89]:
    
+
    
+    
    
+
    try:
+    print(5 / 0)
+except ZeroDivisionError:
+    print("Durch null teilen ist nicht erlaubt!")
+finally:
+    print("Schluss")
+
    
+
+    
    
+
    
+
    
+
+
    
+
    
+
+
+
    
+
+    
    
+
+
+
    
+
    Durch null teilen ist nicht erlaubt!
+Schluss
+
    
+
    
+
    
+
+
    
+
    
+
+
    
+
    
+
    
+
    
+
    12. Datenstrukturen
      
+
    • Listen: Geordnete Auflistung von Elementen. Bsp: liste = ["Hallo", "Welt"]
      • 
+
    • Dictionaries: Zuordnung von Schlüssel zu Wert. Bsp: d = {"Hallo": 5, "Welt": 4}
      • 
+
    • Set: Ungeordnete Sammlung von Elementen, deren Elemente innerhalb nur einmal vorkommen dürfen
      • 
+
    • PriorityQueue (Prioritätswarteschlange): Automatische Sortierung der Elemente
      • 
+
    
+
+
    
+
    
+
    
+
    
+
    
+
    In [ ]:
    
+
    
+    
    
+
     
+
    
+
+    
    
+
    
+
    
+
 
    
     
    
   
    
diff --git a/Python-Syntax.ipynb b/Python-Syntax.ipynb
index 65d61dd..d18716d 100644
--- a/Python-Syntax.ipynb
+++ b/Python-Syntax.ipynb
@@ -58,7 +58,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Daten Typen\n",
+    "## Datentypen\n",
     "### Zahlen\n",
     "Bei Zahlen wird zwischen Integers (ganzen Zahlen) und Floating-pint Numbers (Kommazahlen) oder kurz Floats unterschieden."
    ]
@@ -114,7 +114,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Strings zusammenführen\n",
+    "#### Strings zusammenführen\n",
     "Mehrere Strings können durch **+** oder **Leerzeichen** zusammengefügt werden"
    ]
   },
@@ -143,7 +143,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Strings replizieren\n",
+    "#### Strings replizieren\n",
     "Strings können einfach repliziert werden."
    ]
   },
@@ -168,7 +168,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Strings kürzen\n",
+    "#### Strings kürzen\n",
     "Strings können über **[Zahl:Zahl]** gekürzt werden. Wobei die Zahlen die zu überspringenden Zeichen angeben."
    ]
   },
@@ -193,7 +193,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Bestimmte Zeichen eines Strings ausgeben\n",
+    "#### Bestimmte Zeichen eines Strings ausgeben\n",
     "Einzelne String-Zeichen können mittel **[Zahl]** ausgegeben werden, wobei Zahl die gesuchte Position ist"
    ]
   },
@@ -420,9 +420,21 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 2. Listen\n",
+    "# 2. Datenstrukturen\n",
+    "\n",
+    "- Listen: Geordnete Auflistung von Elementen. Bsp: `liste = [\"Hallo\", \"Welt\"]`\n",
+    "- Dictionaries: Zuordnung von Schlüssel zu Wert. Bsp: `d = {\"Hallo\": 5, \"Welt\": 4}`\n",
+    "- Tupel: Geordnete Auflistung von Elementen, jedoch unveränderlich\n",
+    "- Set: Ungeordnete Sammlung von Elementen, deren Elemente innerhalb nur einmal vorkommen dürfen\n",
+    "- Queue: Ähnlich wie Liste, sind Elemente sortiert und werden in Reihenfolge der Eingabe ausgegeben\n",
+    "- PriorityQueue (Prioritätswarteschlange): Automatische Sortierung der Elemente\n",
+    "\n",
+    "## Listen\n",
     "Listen können mehrere Elemente enthalten und sind veränderliche Datenstruktur.
    \n",
-    "**Listenname = [\"Element1\", Element2\", ... ]**"
+    "**Listenname = [\"Element1\", Element2\", ... ]**\n",
+    "- Kann nachträglich erweitert werden\n",
+    "- Reihenfolge wird beibehalten\n",
+    "- Elemente dürfen mehrfach vorkommen"
    ]
   },
   {
@@ -764,20 +776,342 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 3. Daten umwandeln\n"
+    "## Dictionaries\n",
+    "Die Verknüpfung verschiedener Strings und Listen wird mit Dictionaries erfolgen.\n",
+    " - Speichert eine Zuordnung von einem Schlüssel (key) zu einem Wert (value)\n",
+    " - Reihenfolge wird nicht beibehalten\n",
+    " - Werte dürfen mehrfach vorkommen\n",
+    " - Jeder Schlüssel darf aber nur 1x existieren"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Berlin': 'BER', 'Helsinki': 'Hel', 'Barcelona': 'BAC'}\n",
+      "Hel\n",
+      "Hel\n",
+      "None\n",
+      "dict_items([('Berlin', 'BER'), ('Helsinki', 'Hel'), ('Barcelona', 'BAC')])\n"
+     ]
+    }
+   ],
+   "source": [
+    "d = {\"Berlin\":\"BER\", \"Helsinki\":\"Hel\", \"Barcelona\":\"BAC\"} # Aufbau eines Dictionaries\n",
+    "print(d) # Ausgabe des gesamten Dictionaries\n",
+    "print(d[\"Helsinki\"]) # Ausgabe der Wertzuweisung für den Schlüssel \"Helsinki\"\n",
+    "print(d.get(\"Helsinki\")) # vermeidet Fehler falls Schlüssel nicht im Dictionarie enthalten\n",
+    "print(d.get(\"Budapest\")) # Beispiel für nicht-existenz\n",
+    "print(d.items())  # Ausgabe des Dictionaries als Liste mit Tupel"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "Dictionaries kann jedem Element/Schlüssel auch eine Definition zugewiesen werden"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Berlin : BER\n",
+      "Helsinki : Hel\n",
+      "Barcelona : BAC\n"
+     ]
+    }
+   ],
+   "source": [
+    "for key, wert in d.items():\n",
+    "\n",
+    "    print(key + \" : \" + wert)  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Listen in Dictionaries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['BER', 'Berlin']\n"
+     ]
+    }
+   ],
+   "source": [
+    "staedte = {\n",
+    "    \"München\": [\"MUC\", \"Bayern\"],\n",
+    "    \"Berlin\": [\"BER\", \"Berlin\"]\n",
+    "}\n",
+    "\n",
+    "print(staedte[\"Berlin\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Tupel\n",
+    "Ähnlich zu Listen, jedoch unveränderliche Datenstruktur (nicht erweiterbar)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1, 2, 3)\n",
+      "2\n"
+     ]
+    }
+   ],
+   "source": [
+    "t = (1, 2, 3) # ein Tupel wird mit runden Klammern gebildet\n",
+    "\n",
+    "print(t)      # abrufen des gesamten Tupel\n",
+    "\n",
+    "print(t[1])   # abrufen eines bestimmten Tupel-Elements"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Tupel definieren\n",
+    "Der Inhalt eines Tupels kann durch Variablen definiert und zugewiesen werden. Erleichtert den Zugriff und das Entpacken"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Maschinenbau\n"
+     ]
+    }
+   ],
+   "source": [
+    "student = (\"Max Mustermann\", 20, \"Maschinenbau\") # Tupel bilden\n",
+    "name, alter, fach = student # Tupel entpacken und Definition zuweisen\n",
+    "print(fach)   # Information aus Tupel anhand der Definition entpacken"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Eine Liste mit Tupel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Max\n",
+      "Alex\n"
+     ]
+    }
+   ],
+   "source": [
+    "students = [\n",
+    "    (\"Max\", 20), # Komma zwischen Tupel nicht vergessen!\n",
+    "    (\"Alex\", 30)\n",
+    "]\n",
+    "\n",
+    "for name, alter in students: # Definitionen zuweisen \n",
+    "    print(name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set\n",
+    "Ungeordnete Sammlung von Elementen, deren Elemente innerhalb nur einmal vorkommen dürfen.\n",
+    "    - Kann nachträglich erweitert werden\n",
+    "    - Reihenfolge wird nicht beibehalten\n",
+    "    - Index - Schreibweise s[15] wird nicht unterstützt\n",
+    "    - Jedes Element kommt nur 1x vor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Hallo', 'Welt']\n",
+      "['Hallo', 'Welt', 'Mars']\n"
+     ]
+    }
+   ],
+   "source": [
+    "s = [\"Hallo\", \"Welt\"]\n",
+    "print(s)\n",
+    "s.append(\"Mars\")\n",
+    "print(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mars ist im Set\n"
+     ]
+    }
+   ],
+   "source": [
+    "if \"Mars\" in s:\n",
+    "    print(\"Mars ist im Set\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Queue\n",
+    "Ähnlich wie Liste, sind Elemente sortiert und werden in Reihenfolge der Eingabe ausgegeben"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Hallo\n",
+      "Welt\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import queue\n",
+    "q = queue.Queue()     # Queue erstellen\n",
+    "\n",
+    "q.put(\"Hallo\")        # Elemente einfügen\n",
+    "q.put(\"Welt\")\n",
+    "\n",
+    "print(q)\n",
+    "print(q.get())        # Element ausgeben\n",
+    "print(q.get())\n",
+    "\n",
+    "q.empty()             # überprüfen ob Queue leer ist"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## PriorityQueue\n",
+    "Ähnlich wie Queue. Elemente werden mit unterschiedlicher \"Dringlichkeit\" eingegeben und nach \"Dringlichkeit\" ausgegeben. Automatische Sortierung der Elemente nach \"Dringlichkeit\".\n",
+    "    - Optimierte Datenstruktur, um Elemente nach einer Priorität zu sortieren\n",
+    "    - Elemente werden quasi automatisch nach ihrer Priorität sortiert\n",
+    "    - Direkter Zugriff auf die Elemente nicht möglich\n",
+    "    - Man kann nur auf das erste Element zugreifen, bzw. das erste Element entfernen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(5, 'Wichtig')\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(10, 'Hallo Welt')"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import queue\n",
+    "q = queue.PriorityQueue()    #PriotityQueue erstellen\n",
+    "\n",
+    "q.put((10, \"Hallo Welt\"))    # Elemente mit Priorität einfügen\n",
+    "q.put((5, \"Wichtig\"))\n",
+    "q.put((15, \"Mars\"))\n",
+    "\n",
+    "print(q.get())                      # Element von kleinster nach größter Priorität ausgeben\n",
+    "q.get()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 3. Daten(-strukturen umwandeln\n",
     "### Einen String in eine Ganzzahl umwandeln\n",
     "**int()**-Befehl auf einen String: **int(string)**"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [
     {
@@ -803,7 +1137,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 39,
    "metadata": {
     "scrolled": true
    },
@@ -831,7 +1165,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [
     {
@@ -857,7 +1191,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [
     {
@@ -879,7 +1213,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 4. Operatoren\n",
+    "# 4. Operatoren & Gatter\n",
     "### Vergleichoperatoren\n",
     "Verschiedene Operatoren zum Vergleichen von Variablen/Zahlen\n",
     " - **a == b** Werte sind gleich\n",
@@ -893,7 +1227,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
     {
@@ -935,7 +1269,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [
     {
@@ -959,7 +1293,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
@@ -983,7 +1317,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [
     {
@@ -1013,7 +1347,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
@@ -1040,7 +1374,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [
     {
@@ -1068,7 +1402,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [
     {
@@ -1097,7 +1431,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [
     {
@@ -1130,7 +1464,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### if-else-Struktur\n",
+    "## if-else-Struktur\n",
     "Ausführen bestimmter Abschnitte nur bei bestimmter Bedingung in **if-else-Struktur**.\n",
     "**if** fordert eine Bedingung, wird diese Bedingung erfüllt wird der eingrückte nachstehende Code ausgeführt.\n",
     "**else** wird ausgeführt, wenn die Bedingung nicht erfüllt wird\n",
@@ -1145,7 +1479,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 50,
    "metadata": {},
    "outputs": [
     {
@@ -1175,7 +1509,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 51,
    "metadata": {},
    "outputs": [
     {
@@ -1204,13 +1538,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### for-Schleife\n",
+    "## for-Schleife\n",
     "Die **for**-Schleife durchläuft eine anzugebende Sequenz"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 52,
    "metadata": {},
    "outputs": [
     {
@@ -1246,7 +1580,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 53,
    "metadata": {},
    "outputs": [
     {
@@ -1270,14 +1604,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### while-Schleife\n",
+    "## while-Schleife\n",
     "**while**-Schleifen führen einen Code-Block mehrmals hintereinander aus, bis eine Abbruchbedingung erfüllt ist.\n",
     "Innerhalb einer while-Schleife muss ein Zustand verändert werden, damit das Programm die Schleife auch wieder verlassen kann!"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 54,
    "metadata": {
     "scrolled": true
    },
@@ -1309,7 +1643,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 55,
    "metadata": {},
    "outputs": [
     {
@@ -1331,7 +1665,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 56,
    "metadata": {},
    "outputs": [
     {
@@ -1366,7 +1700,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 57,
    "metadata": {},
    "outputs": [
     {
@@ -1397,7 +1731,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 58,
    "metadata": {},
    "outputs": [
     {
@@ -1417,7 +1751,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 59,
    "metadata": {},
    "outputs": [
     {
@@ -1447,7 +1781,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 60,
    "metadata": {},
    "outputs": [
     {
@@ -1482,7 +1816,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
+   "execution_count": 61,
    "metadata": {},
    "outputs": [
     {
@@ -1532,7 +1866,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": 62,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1551,7 +1885,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 63,
    "metadata": {},
    "outputs": [
     {
@@ -1582,189 +1916,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 8. Dictionaries\n",
-    "Die Verknüpfung verschiedener Strings und Listen wird mit Dictionaries erfolgen. Dictionaries werden mit **{\"Schlüssel:Zuweisung}** aufgebaut"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'Berlin': 'BER', 'Helsinki': 'Hel', 'Barcelona': 'BAC'}\n",
-      "Hel\n",
-      "Hel\n",
-      "None\n",
-      "dict_items([('Berlin', 'BER'), ('Helsinki', 'Hel'), ('Barcelona', 'BAC')])\n"
-     ]
-    }
-   ],
-   "source": [
-    "d = {\"Berlin\":\"BER\", \"Helsinki\":\"Hel\", \"Barcelona\":\"BAC\"} # Aufbau eines Dictionaries\n",
-    "print(d) # Ausgabe des gesamten Dictionaries\n",
-    "print(d[\"Helsinki\"]) # Ausgabe der Wertzuweisung für den Schlüssel \"Helsinki\"\n",
-    "print(d.get(\"Helsinki\")) # vermeidet Fehler falls Schlüssel nicht im Dictionarie enthalten\n",
-    "print(d.get(\"Budapest\")) # Beispiel für nicht-existenz\n",
-    "print(d.items())  # Ausgabe des Dictionaries als Liste mit Tupel"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Dictionaries kann jedem Element/Schlüssel auch eine Definition zugewiesen werden"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Berlin : BER\n",
-      "Helsinki : Hel\n",
-      "Barcelona : BAC\n"
-     ]
-    }
-   ],
-   "source": [
-    "for key, wert in d.items():\n",
-    "    print(key + \" : \" + wert)    "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Listen in Dictionaries"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['BER', 'Berlin']\n"
-     ]
-    }
-   ],
-   "source": [
-    "staedte = {\n",
-    "    \"München\": [\"MUC\", \"Bayern\"],\n",
-    "    \"Berlin\": [\"BER\", \"Berlin\"]\n",
-    "}\n",
-    "print(staedte[\"Berlin\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 9. Tupel\n",
-    "Ähnlich zu Listen, jedoch unveränderliche Datenstruktur."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(1, 2, 3)\n",
-      "2\n"
-     ]
-    }
-   ],
-   "source": [
-    "t = (1, 2, 3) # ein Tupel wird mit runden Klammern gebildet\n",
-    "print(t)      # abrufen des gesamten Tupel\n",
-    "print(t[1])   # abrufen eines bestimmten Tupel-Elements"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Tupel definieren\n",
-    "Der Inhalt eines Tupels kann durch Variablen definiert und zugewiesen werden. Erleichtert den Zugriff und das Entpacken"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Maschinenbau\n"
-     ]
-    }
-   ],
-   "source": [
-    "student = (\"Max Mustermann\", 20, \"Maschinenbau\") # Tupel bilden\n",
-    "name, alter, fach = student # Tupel entpacken und Definition zuweisen\n",
-    "print(fach)   # Information aus Tupel anhand der Definition entpacken"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Eine Liste mit Tupel"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 59,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Max\n",
-      "Alex\n"
-     ]
-    }
-   ],
-   "source": [
-    "students = [\n",
-    "    (\"Max\", 20), # Komma zwischen Tupel nicht vergessen!\n",
-    "    (\"Alex\", 30)\n",
-    "]\n",
-    "\n",
-    "for name, alter in students: # Definitionen zuweisen \n",
-    "    print(name)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 10. Module\n",
+    "# 8. Module\n",
     "Mit Modulen können Funktionen und Rechnungen aus anderen Python-Programmen in einem anderen Wiederbenutzt werden.
    \n",
     "Dafür erstellt man erst ein Python-Programm (Datei mit **.py**-Endung). Diese wird über den **import**-Befehl geladen."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 64,
    "metadata": {},
    "outputs": [
     {
@@ -1784,7 +1943,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 65,
    "metadata": {},
    "outputs": [
     {
@@ -1802,7 +1961,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 66,
    "metadata": {},
    "outputs": [
     {
@@ -1821,7 +1980,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 67,
    "metadata": {},
    "outputs": [
     {
@@ -1839,7 +1998,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 68,
    "metadata": {},
    "outputs": [
     {
@@ -1865,7 +2024,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 69,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1875,9 +2034,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 70,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "datei.py - Funktion f()\n"
+     ]
+    }
+   ],
    "source": [
     "# hier wird der Vorteil der Modul-Datei gezeigt\n",
     "from ordner import * # alle Funktionen aus dem Ordner 'ordner' werden geladen\n",
@@ -1899,7 +2066,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 71,
    "metadata": {},
    "outputs": [
     {
@@ -1932,7 +2099,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 61,
+   "execution_count": 72,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1950,7 +2117,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 73,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1968,15 +2135,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 74,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "200\n",
-      "{'Date': 'Sun, 10 Mar 2019 10:06:34 GMT', 'Expires': '-1', 'Cache-Control': 'private, max-age=0', 'Content-Type': 'text/html; charset=ISO-8859-1', 'P3P': 'CP=\"This is not a P3P policy! See g.co/p3phelp for more info.\"', 'Content-Encoding': 'gzip', 'Server': 'gws', 'Content-Length': '5434', 'X-XSS-Protection': '1; mode=block', 'X-Frame-Options': 'SAMEORIGIN', 'Set-Cookie': '1P_JAR=2019-03-10-10; expires=Tue, 09-Apr-2019 10:06:34 GMT; path=/; domain=.google.de, NID=162=hj9rxv-Nn8TIZUhSheNrRj0Jdo-Z_UkDlz9QadH8cnTTxQo-doOCClFPhDQfJe2phQCuVLI2qgDasKfuuXwxZ1COXvS8iE7moTbTI2AHnKVJrrfyhsuz9_hKOkoiZ1bkG1-15qe1lt_Vi3vktyz8R4dpVdOUGTOlsy43lpLvuhY; expires=Mon, 09-Sep-2019 10:06:34 GMT; path=/; domain=.google.de; HttpOnly'}\n"
+      "200\n"
      ]
     }
    ],
@@ -1997,7 +2163,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 75,
    "metadata": {},
    "outputs": [
     {
@@ -2041,20 +2207,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 76,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "relative URL: ./img/1.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/1.jpg\n",
-      "relative URL: ./img/2.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/2.jpg\n",
-      "relative URL: ./img/3.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/3.jpg\n",
-      "relative URL: ./img/4.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/4.jpg\n",
-      "relative URL: ./img/5.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/5.jpg\n",
-      "relative URL: ./img/6.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/6.jpg\n",
-      "relative URL: ./img/7.jpg ; gesamte URL: http://python.beispiel.programmierenlernen.io/img/7.jpg\n"
+      "relative URL: ./img/1.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/1.jpg\n",
+      "relative URL: ./img/2.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/2.jpg\n",
+      "relative URL: ./img/3.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/3.jpg\n",
+      "relative URL: ./img/4.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/4.jpg\n",
+      "relative URL: ./img/5.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/5.jpg\n",
+      "relative URL: ./img/6.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/6.jpg\n",
+      "relative URL: ./img/7.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/7.jpg\n"
      ]
     }
    ],
@@ -2073,24 +2239,17 @@
     "    print(\"relative URL: \" + image + \" gesamte URL: \" + imageURL)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Generatoren\n",
+    "# 9. Generatoren\n",
     "Generatoren erzeugen Listen (meist aus Crawlern) die viele Einträge enthält. Aus dieser Liste können eine bestimmte Anzahl an Einträgen ausgegeben werden. Die **.fetch()**-Methode erkennt dies dadurch automatisch."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 77,
    "metadata": {},
    "outputs": [
     {
@@ -2137,7 +2296,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 62,
+   "execution_count": 78,
    "metadata": {},
    "outputs": [
     {
@@ -2161,7 +2320,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": 79,
    "metadata": {},
    "outputs": [
     {
@@ -2194,7 +2353,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 64,
+   "execution_count": 80,
    "metadata": {},
    "outputs": [
     {
@@ -2218,7 +2377,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 65,
+   "execution_count": 81,
    "metadata": {},
    "outputs": [
     {
@@ -2261,7 +2420,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 82,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2287,7 +2446,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 83,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -2313,7 +2472,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": 84,
    "metadata": {},
    "outputs": [
     {
@@ -2340,7 +2499,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 69,
+   "execution_count": 85,
    "metadata": {},
    "outputs": [
     {
@@ -2386,7 +2545,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 86,
    "metadata": {},
    "outputs": [
     {
@@ -2428,6 +2587,117 @@
   {
    "cell_type": "markdown",
    "metadata": {},
+   "source": [
+    "# 11. Exceptions\n",
+    "Während der Laufzeit eines Programms können Fehler auftreten. Damit das Programm dadurch nicht abgebrochen wird, kann man mit Exceptions (**try:** und **except:** Blöcke) arbeiten. Ein Code kann mehrere **except**-Blöcke enthalten. Es können auch eigene Fehlercodes programmiert werden.
    \n",
+    "Fehlercodes sollten nur in den seltensten Fällen benutzt werden!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 87,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Durch null teilen ist nicht erlaubt!\n",
+      "5\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    print(5 / 0)                       # durch Null teilen ist nicht definiert -> Fehler\n",
+    "    print(4)                           # alles nach dem Fehler wird nicht ausgeführt\n",
+    "except ZeroDivisionError:              # tritt ein bestimmter Fehler auf wird der except-Block asugeführt\n",
+    "    print(\"Durch null teilen ist nicht erlaubt!\")\n",
+    "print(5)                               # alles nach dem except Block wird wieder ausgeführt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Eigene Fehler auslösen\n",
+    "Über den **raise**-Befehl können eigene Fehler ausgelöst werden."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 88,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Bitte gebe eine gültige E-Mail ein\n"
+     ]
+    }
+   ],
+   "source": [
+    "class InvalidEmailError(Exception):\n",
+    "    pass\n",
+    "\n",
+    "def send_mail(email, subject, content):\n",
+    "    if not \"@\" in email:\n",
+    "        raise InvalidEmailError(\"email does not contain an @\")\n",
+    "try:     \n",
+    "    send_mail(\"hallo\", \"Betreff\", \"Inhalt\")\n",
+    "except InvalidEmailError:\n",
+    "    print(\"Bitte gebe eine gültige E-Mail ein\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Code abschließen\n",
+    "Der **finally**-Befehl wird bei jedem Programmdurchlauf ausgeführt, auch wenn zuvor Fehler aufgetreten sind."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Durch null teilen ist nicht erlaubt!\n",
+      "Schluss\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    print(5 / 0)\n",
+    "except ZeroDivisionError:\n",
+    "    print(\"Durch null teilen ist nicht erlaubt!\")\n",
+    "finally:\n",
+    "    print(\"Schluss\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 12. Datenstrukturen\n",
+    "\n",
+    "- Listen: Geordnete Auflistung von Elementen. Bsp: `liste = [\"Hallo\", \"Welt\"]`\n",
+    "- Dictionaries: Zuordnung von Schlüssel zu Wert. Bsp: `d = {\"Hallo\": 5, \"Welt\": 4}`\n",
+    "- Set: Ungeordnete Sammlung von Elementen, deren Elemente innerhalb nur einmal vorkommen dürfen\n",
+    "- PriorityQueue (Prioritätswarteschlange): Automatische Sortierung der Elemente"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": []
   }
  ],