diff --git a/Python-Syntax.html b/Python-Syntax.html new file mode 100644 index 0000000..80d75f6 --- /dev/null +++ b/Python-Syntax.html @@ -0,0 +1,16629 @@ + + + + +Python-Syntax + + + + + + + + + + + + + + + + + + + + + + + +
+
+ +
+
+
+

Python Syntax

Hinweise zum Lesen:

+ +
- Nach dem Code-Block ist jeweils die Konsolen-Ausgabe sichtbar
+ +
+
+
+
+
+
+

1. Grundlagen

+
+
+
+
+
+
+

Grundrechenarten und Regeln

+
+
+
+
+
+
In [1]:
+
+
+
print(5 + 4) # Addition
+print(5 - 4) # Subtraktion
+print(5 * 4) # Multiplikation
+print(5 / 4) # Division
+print(5 ** 4)# Exponent
+print(5 % 4) # Modulus/Remaider
+print(5 // 4)# Integer division
+print((5 + 4) *3) #Punkt vor Strich
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
9
+1
+20
+1.25
+625
+1
+1
+27
+
+
+
+ +
+
+ +
+
+
+
+

Daten Typen

Zahlen

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

+ +
+
+
+
+
+
In [2]:
+
+
+
print(1) # Zahlen können ohne Markup eingefügt werden
+print(1.5) # Kommata werden anstatt mit ',' mit einem '.' geschrieben
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
1
+1.5
+
+
+
+ +
+
+ +
+
+
+
+

Strings (Zeichenketten)

Zeichen die zwischen Anführungszeichen stehen

+ +
+
+
+
+
+
In [3]:
+
+
+
print("Hallo Welt") #Einfacher String in Anführungszeichen
+name ="Alex"  # Strings können in Variablen gespeichert werden
+print(name)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hallo Welt
+Alex
+
+
+
+ +
+
+ +
+
+
+
+

Strings zusammenführen

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

+ +
+
+
+
+
+
In [4]:
+
+
+
print("Mein Name ist Alex. " + "Wie ist dein Name?")
+print("Mein Name ist Alex. "  "Wie ist dein Name?")
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Mein Name ist Alex. Wie ist dein Name?
+Mein Name ist Alex. Wie ist dein Name?
+
+
+
+ +
+
+ +
+
+
+
+

Strings replizieren

Strings können einfach repliziert werden.

+ +
+
+
+
+
+
In [5]:
+
+
+
print("Alex" * 5)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
AlexAlexAlexAlexAlex
+
+
+
+ +
+
+ +
+
+
+
+

Strings kürzen

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

+ +
+
+
+
+
+
In [6]:
+
+
+
print("Hallo Welt!"[6:-1]) #Die ersten 0-6 Zeichen werden übersprungen
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Welt
+
+
+
+ +
+
+ +
+
+
+
+

Bestimmte Zeichen eines Strings ausgeben

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

+ +
+
+
+
+
+
In [7]:
+
+
+
print("Hallo Welt"[6]) # das 7. Zeichen wird ausgegeben
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
W
+
+
+
+ +
+
+ +
+
+
+
+

Boolean

Für Wahr oder Falsch werden die Booleans True und False ausgegeben

+ +
+
+
+
+
+
In [8]:
+
+
+
b = False
+print(b)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
False
+
+
+
+ +
+
+ +
+
+
+
+

Variablen

Variablen können benutzt werden, um Werte zuzuweisen und später einfach aufzurufen.
+Für Variablen gelten drei Regeln:

+
    +
  • nur ein Wort
    • +
  • nur Buchstaben, Zahlen und der Underscore (_)
    • +
  • darf nicht mit einer Zahl beginnen
    • +
+ +
+
+
+
+
+
In [9]:
+
+
+
a = 5         # Einfache Variable
+print(a)
+b = 5 + 6     # Zahlen können in Variablen verrechnet werden
+print(b)
+print(a + b)  # Variablen können verrechnet werden
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
5
+11
+16
+
+
+
+ +
+
+ +
+
+
+
+

Kommentare

Kommentare im Code erleichtern die Lesbarkeit und werden nicht ausgeführt. Dafür nutzt man #

+ +
+
+
+
+
+
In [10]:
+
+
+
# Dies ist ein Kommentar
+# print("Hallo Welt")  Diese Zeile wird nicht ausgeführt
+print("Hello Welt")  # Diese Zeile wird ausgeführt
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hello Welt
+
+
+
+ +
+
+ +
+
+
+
+

Grundfunktionen

Python liefert einige Grundfunktionen.

+

Print() - Funktion

Mit der print()-Funktion können Ausgaben über die Konsole getätigt werden. Die erforderliche Ausgabe wird in den Klammern () getätigt. Für Funktionen die in dieser Klammer ausgeführt werden, wird nur das Ergebnis ausgegeben.

+ +
+
+
+
+
+
In [11]:
+
+
+
print("dies ist ein String")
+print(1) # eine Zahl
+print(1 + 2) # eine Rechnung in der Print()-Funktion
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
dies ist ein String
+1
+3
+
+
+
+ +
+
+ +
+
+
+
+

input Function

Mithilfe der input() Funktion können Eingaben über die Konsole an das Programm übergeben werden. Die Eingabe kann in einer Variable gespeichert werden.

+ +
+
+
+
+
+
In [12]:
+
+
+
print('Wie ist dein Name?')   # ask for their name
+myName = input() # eine Zeile mit Eingabe wird geöffnet
+print('Hallo {}'.format(myName))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Wie ist dein Name?
+Alex
+Hallo Alex
+
+
+
+ +
+
+ +
+
+
+
+

len Function

Berechnet die Länge eines Strings als Integer

+ +
+
+
+
+
+
In [13]:
+
+
+
len('hello')
+
+ +
+
+
+ +
+
+ + +
+ +
Out[13]:
+ + + + +
+
5
+
+ +
+ +
+
+ +
+
+
+
+

Strings aus einer Liste zu einem String zusammenfügen

join()-Befehl auf einen String: string.join(liste)

+ +
+
+
+
+
+
In [14]:
+
+
+
students = ["Alex", "Bob", "Cedric", "Erika"]
+print(", ".join(students))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Alex, Bob, Cedric, Erika
+
+
+
+ +
+
+ +
+
+
+
+

2. Listen

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

+ +
+
+
+
+
+
In [15]:
+
+
+
students = ["Alex", "Bob", "Cedric", "Erika"]
+print(students)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
['Alex', 'Bob', 'Cedric', 'Erika']
+
+
+
+ +
+
+ +
+
+
+
+

Element aus Liste auswählen

Elemente einer Liste sind aufsteigend von 0 an nummeriert.
+Per Index kann ein einzelnes Element über seine Listenposition angewählt werden: Listenname[Position]

+ +
+
+
+
+
+
In [16]:
+
+
+
print(students[0])
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Alex
+
+
+
+ +
+
+ +
+
+
+
+

Über eine negative Positionsnummer kann die Liste vom Ende zum Anfang ausgelesen werden. +Die Ausgabe ist wieder in Reihenfolge der orginalen Liste

+ +
+
+
+
+
+
In [17]:
+
+
+
print(students[-1])
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Erika
+
+
+
+ +
+
+ +
+
+
+
+

Liste Trennen

Eine Liste kann auch aufgeteilt (gesliced) werden. Hierfür wird Zahl:Zahl. Wobei die Zahlen die zu überspringenden Indexe angeben.

+ +
+
+
+
+
+
In [18]:
+
+
+
print(students[2:4])
+print(students[1:-1]) #auch hier können negative Positionen benutzt werden
+print(students[1:]) # mit auslassen einer Zahl wird die Liste bis zum Ende ausgeführt
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
['Cedric', 'Erika']
+['Bob', 'Cedric']
+['Bob', 'Cedric', 'Erika']
+
+
+
+ +
+
+ +
+
+
+
+

Element einer Liste anhängen

über append() kann ein Element an das Ende einer Liste hinzugefügt werden

+ +
+
+
+
+
+
In [19]:
+
+
+
students.append("Franz")
+print(students)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
['Alex', 'Bob', 'Cedric', 'Erika', 'Franz']
+
+
+
+ +
+
+ +
+
+
+
+

ebenso mit + können weitere Elemente hinzugefügt werden

+ +
+
+
+
+
+
In [20]:
+
+
+
students = ["Alex", "Bob", "Cedric", "Erika"] + ["Ferdinand"]
+print(students)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
['Alex', 'Bob', 'Cedric', 'Erika', 'Ferdinand']
+
+
+
+ +
+
+ +
+
+
+
+

Elemente aus Liste entfernen

mit del kann ein bestimmtes Element anhand der Position aus einer Liste entfernt werden

+ +
+
+
+
+
+
In [21]:
+
+
+
del students[3]
+print(students)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
['Alex', 'Bob', 'Cedric', 'Ferdinand']
+
+
+
+ +
+
+ +
+
+
+
+

mit remove kann ein bestimmtes Element anhand des Strings aus einer Liste entfernt werden

+ +
+
+
+
+
+
In [22]:
+
+
+
students.remove("Alex")
+print(students)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
['Bob', 'Cedric', 'Ferdinand']
+
+
+
+ +
+
+ +
+
+
+
+

über .pop() kann das letzte Element aus der Liste entfernt werden

+ +
+
+
+
+
+
In [23]:
+
+
+
x = students.pop() #aus Students wird das letzte Element entfernt
+print(students) #restliche Liste
+print(x)  #entferntes Element
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
['Bob', 'Cedric']
+Ferdinand
+
+
+
+ +
+
+ +
+
+
+
+

List Comprehension

Einfache Umwandlung bzw Neuerstellung einer Liste. Beachte, dass die Variablen ungleich der Listennamen vergeben werden müssen!

+ +
+
+
+
+
+
In [24]:
+
+
+
xs = [1,2,3,4]
+ys = [x * x for x in xs] # für jeden Wert in xs wird das Quadrat in ys gespeichert
+print(xs)
+print(ys)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
[1, 2, 3, 4]
+[1, 4, 9, 16]
+
+
+
+ +
+
+ +
+
+
+
In [25]:
+
+
+
students = ["Alex", "Bob", "Cedric", "Erika", "Ferdinand"]
+lengths = [len(student) for student in students] 
+#für jede Länge eines Studentennames wird das Ergebnis in "lenghts" gespeichert
+print(lengths)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
[4, 3, 6, 5, 9]
+
+
+
+ +
+
+ +
+
+
+
In [26]:
+
+
+
#Zu viele Zeilen!
+xs = []
+for x in range(0,10):
+    xs.append(x/10)
+print(xs)
+
+#einfacher:
+xs = [x/10 for x in range(0,10)]
+print(xs)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
+[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
+
+
+
+ +
+
+ +
+
+
+
+

Listen verschachteln

Listen können ineinander verschachtelt werden um z.B. eine Matrix zu modellieren.
+[[Liste1],[Liste2]]
+Beachte, dass verschachtelte Listen mit einem Kommata getrennt werden.

+ +
+
+
+
+
+
In [27]:
+
+
+
liste = [
+    ["Element1", "Element2", "Element3"],
+    ["Element4", "Element5", "Element6"]
+]
+print(liste[0][2])
+print(liste[1][1])
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Element3
+Element5
+
+
+
+ +
+
+ +
+
+
+
+

3. Daten umwandeln

+
+
+
+
+
+
+

Einen String in eine Ganzzahl umwandeln

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

+ +
+
+
+
+
+
In [28]:
+
+
+
a = int("5")
+print(a)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
5
+
+
+
+ +
+
+ +
+
+
+
+

Einen String in eine Kommazahl umwandeln

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

+ +
+
+
+
+
+
In [29]:
+
+
+
a = float("5.5")
+print(a)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
5.5
+
+
+
+ +
+
+ +
+
+
+
+

Eine Zahl in einen String umwandeln

str()-Befehl auf eine Ganzzahl oder Kommazahl: str(zahl)

+ +
+
+
+
+
+
In [30]:
+
+
+
age = str(21)
+print(age)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
21
+
+
+
+ +
+
+ +
+
+
+
+

Einen String in eine Liste aufspalten

split()-Befehl auf einen String: string.split()

+ +
+
+
+
+
+
In [31]:
+
+
+
students = "Alex, Bob, Cedric, Erika"
+print(students.split()) # Kommata werden übernommen
+print(students.split(", ")) # Kommata werden ausgelassen
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
['Alex,', 'Bob,', 'Cedric,', 'Erika']
+['Alex', 'Bob', 'Cedric', 'Erika']
+
+
+
+ +
+
+ +
+
+
+
+

4. Operatoren

Vergleichoperatoren

Verschiedene Operatoren zum Vergleichen von Variablen/Zahlen

+
    +
  • a == b Werte sind gleich
    • +
  • a != b Werte sind ungleich
    • +
  • a < b Wert b ist größer als Wert a
    • +
  • a > b Wert a ist größer als Wert b
    • +
  • a <= b Wert b ist größer-gleich Wert a
    • +
  • a >= b Wert a ist größer-gleich Wert a +Die Ausgabe über print() gibt die Booleans True(Wahr) oder False(Falsch) aus
    • +
+ +
+
+
+
+
+
In [32]:
+
+
+
a = 5
+b = 6
+print(a == b)  # Gleichheit
+print(a != b)  # Ungleichheit
+print(a < b)   # kleiner als
+print(a > b)   # größer als
+print(a <= b)  # kleiner-gleich als
+print(a >= b)  # größer-gleich als
+print( "Hallo" == "World") # auch Strings können verglichen werden
+print(True is True) # für Boolean Werte keine '='-Zeichen benutzen!
+print(True is not True) # Boolean werden mit 'is' und 'is not' abgefragt
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
False
+True
+True
+False
+True
+False
+False
+True
+False
+
+
+
+ +
+
+ +
+
+
+
+

Gatter

+
+
+
+
+
+
In [33]:
+
+
+
# Für and müssen beide Variablen den gleichen Wert annehmen
+print(True and True)
+print(True and False)
+print(False and True)
+print(False and False)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
True
+False
+False
+False
+
+
+
+ +
+
+ +
+
+
+
In [34]:
+
+
+
# Für or muss eine der Variablen True annehmen
+print(True or True)
+print(True or False)
+print(False or True)
+print(False or False)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
True
+True
+True
+False
+
+
+
+ +
+
+ +
+
+
+
In [35]:
+
+
+
# 'not' Gatter negieren Ihr Ergebnis
+print(not True)
+print(not False)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
False
+True
+
+
+
+ +
+
+ +
+
+
+
+

Der in-Operator

mit in-Operatoren kann man überprüfen, ob ein Element in einem anderen Element enthalten ist

+

der in-Operator mit Listen:

+ +
+
+
+
+
+
In [36]:
+
+
+
students = ["Alex", "Bob", "Cedric", "Erika"]
+print("Monika" in students) # Monika ist nicht in der Liste
+print("Bob" in students) # Bob ist in der Liste
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
False
+True
+
+
+
+ +
+
+ +
+
+
+
+

der in-Operator mit Strings

+ +
+
+
+
+
+
In [37]:
+
+
+
satz ="Ja dieser Text ist ein String!"
+print("Ja" in satz) # "Ja" ist in dem String enthalten 
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
True
+
+
+
+ +
+
+ +
+
+
+
+

Der not-Operator

Der not-Operator negiert das Ergebnis bzw. die Abfrage.

+

Beachte, dass der not-Operator vor und nach der Variable kommen kann

+ +
+
+
+
+
+
In [38]:
+
+
+
print( not 5 == 5) # Das Erbgenis von "5 == 5" ist wahr, "not" negiert das Ergebnis
+
+# Es können auch Listen abgefragt werden:
+names = ["Andreas", "Bertold"]
+print("Alex" not in names)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
False
+True
+
+
+
+ +
+
+ +
+
+
+
+

Mehr Operatoren

+
+
+
+
+
+
In [39]:
+
+
+
i = 5
+print(i)
+i += 1  # Mit += kann die Variable mit den nachstehenden Wert addiert und in i gespeichert werden
+print(i)
+i -= 1  # Mit -= kann die Variable mit den nachstehenden Wert subtrahiert und in i gespeichert werden
+print(i)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
5
+6
+5
+
+
+
+ +
+
+ +
+
+
+
+

5. Schleifen

+
+
+
+
+
+
+

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!

+

if Bedingung:
+      Auszuführender_Code
+else:
+      Sonst-Auszuführender_Code

+ +
+
+
+
+
+
In [40]:
+
+
+
x = 5
+if x < 10:
+    print("x ist kleiner als 10")
+else:
+    print("x ist größer als 9")
+print("Ich bin nicht mehr Eingerückt")
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
x ist kleiner als 10
+Ich bin nicht mehr Eingerückt
+
+
+
+ +
+
+ +
+
+
+
+

Müssen mehr als zwei if-else Fälle abgefragt werden, nutzt man elif nächste_Bedinung: als Kurzfassung.

+ +
+
+
+
+
+
In [41]:
+
+
+
x = 5
+if x == 8:
+    print("x ist 8")
+elif x==7:
+    print("x ist 7")
+elif x==6:
+    print("x ist 6")
+elif x==5:
+    print("x ist 5")
+else:
+    print("x ist nicht zwischen 4 und 9")
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
x ist 5
+
+
+
+ +
+
+ +
+
+
+
+

for-Schleife

Die for-Schleife durchläuft eine anzugebende Sequenz

+ +
+
+
+
+
+
In [42]:
+
+
+
# Das Funktioniert sowohl mit Zahlen als auch Strings
+liste = [1, 2, 5]
+for i in liste:
+    print(i)
+    
+liste = ["Max", "Mustermann", "Michael"]
+for i in liste:
+    print(i)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
1
+2
+5
+Max
+Mustermann
+Michael
+
+
+
+ +
+
+ +
+
+
+
+

Das range-Objekt wird dazu genutzt, die Sequenzlänge vorzugeben. D.h. wie oft die Schleife durchlaufen werden soll.

+ +
+
+
+
+
+
In [43]:
+
+
+
for i in range(0, 5): # von 0 bis 4 werden alle Zahlen ausgegeben
+    print(i)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
0
+1
+2
+3
+4
+
+
+
+ +
+
+ +
+
+
+
+

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!

+ +
+
+
+
+
+
In [44]:
+
+
+
zähler = 0
+while zähler < 3:
+    print(zähler)
+    zähler += 1
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
0
+1
+2
+
+
+
+ +
+
+ +
+
+
+
+

Continue & Break

Während eines Schleifendurchlaufs kann der man vorzeitig abbrechen und mit dem nächsten Schleifendurchlauf fortfahren (continue) oder die gesamte Schleife abbrechen (break).

+ +
+
+
+
+
+
In [45]:
+
+
+
for i in range(0, 4):
+    if i == 2:
+        continue  # anstatt print(2) auszuführen wird 2 übersprungen und mit dem nächsten Durchlauf fortgesetzt
+    print(i)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
0
+1
+3
+
+
+
+ +
+
+ +
+
+
+
In [46]:
+
+
+
for i in range(0, 4):
+    if i == 2:
+        break  # an dieser Stelle wird die Schleife abgebrochen und nicht weiter ausgeführt 
+    print(i)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
0
+1
+
+
+
+ +
+
+ +
+
+
+
+

6. Funktionen

Funktionen sind t´zusammengefasste Codeblöcke. Mittels Funktionen vermeidet man mehrmals verwendete Codeblöcke. Eine Funktion kann merhmals im Programm aufgerufen werden, nachdem sie definiert wurde.
+Beachte, der Funktion oder ihren Variablen keine Dopplungen aus deinem Code zu geben!

+

Funktionen definieren und Aufrufen

def Funktionname():
+      Code

+ +
+
+
+
+
+
In [47]:
+
+
+
def print_more():    # Das Definieren der Funktion
+    print("hi")
+    print("there")
+    
+print_more()    # Das Aufrufen der Funktion mit ihrem Funktionsnamen()
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
hi
+there
+
+
+
+ +
+
+ +
+
+
+
+

Funktionen können auch mit einem oder mehreren Argumenten arbeiten

def Funktionname(Argument):
+      Code

+ +
+
+
+
+
+
In [48]:
+
+
+
def print_name(name): # hier wird in Klammern ein Argument übergeben, ein Argument kann frei definiert werden
+    print("Hallo mein Name ist " + name + ".") #das Argument wird mit Argument-Namen übernommen und kann verwendet werden
+
+print_name("Hans")
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hallo mein Name ist Hans.
+
+
+
+ +
+
+ +
+
+
+
In [49]:
+
+
+
def print_more(name, count):
+    for i in range(0, count):
+        print(name)
+        
+print_more("Hallo!", 3)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hallo!
+Hallo!
+Hallo!
+
+
+
+ +
+
+ +
+
+
+
+

Ineinander verschachtelte Funktionen sind auch möglich

+
+
+
+
+
+
In [50]:
+
+
+
def print_name(name):
+    print("Hallo mein Name ist " + name + ".")
+def print_alter(alter):
+    print("Ich bin " + str(alter) + " Jahre alt.")
+
+def NameUndAlter(name, alter):
+    print_name(name)
+    print_alter(alter)
+
+NameUndAlter("Hans", 23)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hallo mein Name ist Hans.
+Ich bin 23 Jahre alt.
+
+
+
+ +
+
+ +
+
+
+
+

Werte zurückgeben mit 'return'

Mit dem Befehl return können Werte aus einer Funktion zurückgegeben werden. Funktionen mit return können wie Variablen behandelt werden.

+ +
+
+
+
+
+
In [51]:
+
+
+
def return_element(name):
+    return name
+
+print(return_element("Hi"))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hi
+
+
+
+ +
+
+ +
+
+
+
+

Mehr Funktionen

Neben selbst erstellten Funktionen bietet Python selbst vordefinierte Funktionen, diese findet man hier.

+ +
+
+
+
+
+
+

7. Dateien

Einfaches öffnen und schließen von Dateien kann mit open() und close() realisiert werden.
+Mit dem with-Konstruktor müssen geöffnete Dateien danach nicht mit der close() -Methode geschlossen werden.

+

open("dateiname", "operator")
+       write.CodeMitDatei
+close()

+

with open("dateiname.dateiendung", "operator") as dateiname_in_funktion:
+       Code

+

Mögliche Dateien sind .txt, .csv (comma seperated values), ...

+

Textdateien schreiben

Zum schreiben einer neuen Datei nutzt man den Operator w (write)
+Soll nichts überschrieben werden oder Text angehängt werden nutzt man den Operator a (append)

+ +
+
+
+
+
+
In [52]:
+
+
+
file = open("test.txt", "w")
+file.write("Diese Datei wurde mit Phyton geschrieben. \n")
+file.close()
+
+ +
+
+
+ +
+
+
+
+

Textdateien lesen und Inhalt ausgeben

Zum lesen einer Datei nutzen wir den Operator "r" (read)

+ +
+
+
+
+
+
In [53]:
+
+
+
file = open("test.txt", "r")
+for line in file:  # Alle Zeilen nacheinander auslesen
+    print(line.strip()) #eine Zeile ohne Zeilenumbruch ausgeben
+file.close()
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Diese Datei wurde mit Phyton geschrieben.
+
+
+
+ +
+
+ +
+
+
+
+

Zeichen aus Datei entfernen

das Entfernen bestimmter Zeichen ist mit Python einfach realisierbar. Es wurde schon im oberen Beispiel gezeigt:
+.strip entfernt Sonderzeichen wie z.B. \n (Zeilenumbruch)

+ +
+
+
+
+
+
+

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.
+Dafür erstellt man erst ein Python-Programm (Datei mit .py-Endung). Diese wird über den import-Befehl geladen.

+ +
+
+
+
+
+
In [3]:
+
+
+
# Das 'hallo.py' Programm:
+def welt():
+    print("Hallo Welt")
+welt()
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hallo Welt
+
+
+
+ +
+
+ +
+
+
+
In [4]:
+
+
+
import hallo # die Datei hallo.py wird in das aktuelle Programm eingebunden
+hallo.welt() # die Funktion welt() im hallo.py-Programm wird in unserem aktuellen Skript ausgeführt
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hallo Welt
+
+
+
+ +
+
+ +
+
+
+
In [5]:
+
+
+
from hallo import welt # damit wird explizit nur die Funktion 'welt()' in das aktuelle Programm geladen, jede weitere mit ',' getrennt
+welt() # die Funktion kann damit direkt benutzt werden
+# Achte auf Dopplungen von Funktionsnamen in unterschiedlichen Programmen!
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hallo Welt
+
+
+
+ +
+
+ +
+
+
+
In [6]:
+
+
+
from hallo import * # mit dem '*' werden alle Funktionen aus 'hallo.py' in das aktuelle Programm geladen
+welt() 
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hallo Welt
+
+
+
+ +
+
+ +
+
+
+
In [7]:
+
+
+
import hallo as h # mit der 'as'-Methode wird zum Aufrufen eines Programms im Skript ein 'Ersatzname' genutzt
+h.welt() # diese Variante kann lange Programmnamen abkürzen
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Hallo Welt
+
+
+
+ +
+
+ +
+
+
+
+

Modulordner definieren und strukturieren

Um viele Programme und Module strukturiert zu halten ist es oft praktisch diese in einem extra Ordner zu speichern. Hierbei ist es vorteilhaft eine Modul-Datei mit der Auflistung aller möglichen Programme zu führen.

+ +
+
+
+
+
+
In [ ]:
+
+
+
# Modul-Datei: __init__.py
+__all__ = ["datei"] # all Beschreibt alle Module, "datei" ist ein Programm namens 'datei.py' im Modulordner
+
+ +
+
+
+ +
+
+
+
In [ ]:
+
+
+
# hier wird der Vorteil der Modul-Datei gezeigt
+from ordner import * # alle Funktionen aus dem Ordner 'ordner' werden geladen
+datei.f()
+
+ +
+
+
+ +
+
+
+
+

Module importieren

für zusätzliche Funktionen können externe bzw. fertige Module in Python importiert werden.
+Den Python-Modul-Indes findet man hier: https://docs.python.org/3/py-modindex.html
+Einige der wichtigsten Module werden folgend vorgestellt

+

Mathe plotten

mit der Bibliothek für Matheplotter (mathplotlib.pyplot) können Funktionen und Zahlen Grafisch visualisiert werden.

+ +
+
+
+
+
+
In [8]:
+
+
+
%matplotlib inline 
+import matplotlib.pyplot as plt # hier wird das Matplolib-Modul importiert und mit der Variable plt verknüpft
+plt.scatter([1, 2 , 3], [4, 3, 2])  # plt. kann dann für das Modul benutzt werden
+plt.show()
+
+ +
+
+
+ +
+
+ + +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
+

Programm Beenden/Abbrechen

Mit sys.exit (muss importiert werden) kann ein laufendes Programm vorzeitig abgebrochen werden.

+ +
+
+
+
+
+
In [61]:
+
+
+
import sys
+#sys.exit() (Bei Anwendung hier kann der weitere Verlauf nicht umgesetzt werden)
+
+ +
+
+
+ +
+
+
+
+

Programm pausieren

Manchmal ist es notwenig das Programm pausieren zu lassen (Bsp Crawler auf Webseite). Dafür nutzt man das Modul time

+ +
+
+
+
+
+
In [19]:
+
+
+
import time     # Time-Modul importieren
+time.sleep(1)   # '1'-Sekunde Programmpause
+
+ +
+
+
+ +
+
+
+
+

Webseiten runterladen

Mit einem request kann eine bestimmte Webseite heruntergeladen und der HTML-Code ausgegeben werden (http://docs.python-requests.org/en/master/).

+ +
+
+
+
+
+
In [5]:
+
+
+
import requests
+r = requests.get("http://www.google.de")
+
+print(r.status_code)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
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'}
+
+
+
+ +
+
+ +
+
+
+
+

Elemente in HTML finden

Aus html-Dateien kann man mit BeautifulSoup (https://www.crummy.com/software/BeautifulSoup/bs4/doc/) Informationen zerlegen und extrahieren.

+ +
+
+
+
+
+
In [12]:
+
+
+
from bs4 import BeautifulSoup      # BeautifulSoup importieren
+
+# Beispiel HTML-Datei 
+htmlDatei = """ 
+    <html>
+        <body>
+            <p class="something">Ich bin ein Absatz!</p>
+            <p>Ich bin noch ein Absatz</p>
+        </body>
+    </html>
+"""
+
+doc = BeautifulSoup(htmlDatei, "html.parser") # HTML-Datei mit BeautifulSoup Parsen/Einlesen
+
+for p in doc.find_all("p"):   # im Dokument alle <p>-Konstruktoren finden
+    print(p.attrs)            # für alle <p> dessen Attribute ausgeben
+    print(p.text)             # für alle <p> dessen Text ausgeben
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
{'class': ['something']}
+Ich bin ein Absatz!
+{}
+Ich bin noch ein Absatz
+
+
+
+ +
+
+ +
+
+
+
+

relative URLs

Einige Elemente (z.B. Bilder) sind auf Webseiten nur relativ zu Ihrer Webseite verlinkt. Beim Crawlen kann der gesamte Bildpfad mit urljoin hergestellt werden.

+ +
+
+
+
+
+
In [18]:
+
+
+
from urllib.parse import urljoin   # urljoin importieren
+from bs4 import BeautifulSoup      # BeautifulSoup importieren
+
+url = "http://python.beispiel.programmierenlernen.io/index.php" #Webseiten-URL die durchsucht wurde
+
+r = requests.get(url)
+doc = BeautifulSoup(r.text, "html.parser") # HTML-Datei mit BeautifulSoup Parsen/Einlesen
+    
+for card in doc.select(".card"):
+    image = card.select_one("img").attrs["src"]
+    imageURL = urljoin(url, image)
+    print("relative URL: " + image + " gesamte URL: " + imageURL)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
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
+
+
+
+ +
+
+ +
+
+
+
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.

+ +
+
+
+
+
+
In [8]:
+
+
+
def gen_generator():
+    for i in range(0, 3):
+        print("gen: " + str(i))
+        yield i
+
+for element in gen_generator():      # Alle Elemente der Liste ausgeben
+    print("for: " + str(element))
+
+print("####")
+
+for element in gen_generator():      # die ersten 2 Elemente ausgeben
+    if element == 1:
+        break
+    print("for: " + str(element))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
gen: 0
+for: 0
+gen: 1
+for: 1
+gen: 2
+for: 2
+####
+gen: 0
+for: 0
+gen: 1
+
+
+
+ +
+
+ +
+
+
+
+

10. Objektorientierung

Klassen sind Baupläne für Objekte. Die erzeugten Objekte nennt man Instanzen dieser Klasse.

+ +
+
+
+
+
+
In [62]:
+
+
+
class Student():               # Klasse Student erstellen, Klassennamen beginnen gemäß Konvention mit Großbuchstaben
+    pass                       # Leere Klasse zulassen
+
+erik = Student()               # Instanz erzeugen
+erik.firstname = "Erik"        # zwei Variablen für das Objekt,
+erik.lastname = "Mustermann"   # auf díe über das Objekt per Punktschreibweise zugegriffen werden kann
+
+print(erik.firstname)          
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Erik
+
+
+
+ +
+
+ +
+
+
+
In [63]:
+
+
+
class Student():                      
+    def __init__(self, firstname, lastname): # durch Definition der Variablen mittel einer Methode
+        self.firstname = firstname           # können Instanzen einfach hinzugefügt werden
+        self.lastname = lastname
+
+monika = Student("Monika", "Mueller") # Kurzschreibweise für Instanz
+
+print(monika.lastname)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Mueller
+
+
+
+ +
+
+ +
+
+
+
+

Methoden und Definitionen können innerhalb von Objekten gebildet werden um Namensübertretungen zu verhindern bzw. +innerhalb eines Objekts alle Namenskonventionen festzuhalten.
+self ist ein Schlüsselwort, es fungiert gewissermassen als Platzhalter für die jeweilige Instanz

+ +
+
+
+
+
+
In [64]:
+
+
+
class Student():
+    def name(self): # ein Konstruktor, der eine Funktion für das Objekt definiert
+        print(self.firstname + " " + self.lastname)
+
+erik = Student()              
+erik.firstname = "Erik"       
+erik.lastname = "Mustermann"
+erik.name()     
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Erik Mustermann
+
+
+
+ +
+
+ +
+
+
+
In [65]:
+
+
+
class Student():
+    def __init__(self, firstname, lastname):
+        self.firstname = firstname
+        self.lastname = lastname
+        self.term = 1 # Hier initialisiert die neue Variable term (Eigenschaft)
+        
+    def increase_term(self): # Mit dieser Methode erhöht die Variable term um 1
+        self.term = self.term + 1
+    
+    def name(self): # name() gibt Name und Anzahl der Semester aus
+        print(self.firstname + " " + self.lastname + 
+              " (Semester: " + str(self.term) + ")")
+        
+erik = Student("Erik", "Mustermann")
+erik.name()
+erik.increase_term() #Semester erhöhen
+erik.name()
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Erik Mustermann (Semester: 1)
+Erik Mustermann (Semester: 2)
+
+
+
+ +
+
+ +
+
+
+
+

Private Eigenschaften und Methoden

Private Eigenschaften erlauben sauberes Kapseln von Eigenschaften und Methoden. Dadurch können Variablen und Methoden vor außerhalb geschützt werden. Wichtig wenn diese Variablen / Methoden noch angeüasst werden.
+Mit zwei Unterstrichen vor der Variable wird diese privat. Methoden könne auf dieselbe Weise eingeschränkt werden.

+ +
+
+
+
+
+
In [66]:
+
+
+
class Student():
+    def increase_term(self):
+        self.__term = self.__term + 1
+        
+    def get_term(self): # um von außen noch auf die Variable term zugreifen zu können
+        return self.__term
+    
+    def __do_something(self):
+        print("doSomething")
+
+ +
+
+
+ +
+
+
+
+

Vererbung

Durch Vererbung können Daten aufgeteilt und besser modelliert werden.
+Als Parameter wird die Klasse übergeben, von der neue Eigenschaften und Methoden vererbt werden sollen (Mutterklasse).

+ +
+
+
+
+
+
In [67]:
+
+
+
class WorkingStudent(Student):
+    
+    def __init__(self, firstname, surname, company):        
+        # mit super() wird Python gezeigt, dass die init()-Methode der Mutterklasse angewendet werden soll
+        super().__init__(firstname, surname)
+        self.company = company
+    
+    def name(self):
+        return super().name() + " (" + self.company + ")"
+
+ +
+
+
+ +
+
+
+
+

Die type() und isinstance() Funktionen

Mit der type()-Funktion kann der Typ eines Objektes festgestellt werden.
+Die Funktion isinstance() erhält zwei Parameter: die Variable und die Klasse bezüglich derer auf Zugehörigkeit der Variable geprüft werden soll. isinstance() liefert einen Bool zurück.

+ +
+
+
+
+
+
In [68]:
+
+
+
print(type(student))
+print(isinstance(student, Student))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
<class 'tuple'>
+False
+
+
+
+ +
+
+ +
+
+
+
+

Statische Variablen

Anstatt Instanzen können auch Variablen an Klassen gebunden werden. Diese heißen statisch, weil sie nicht an einer einzelnen Instanz hängen. Werden die Variablen geändert, werden sie für alle Objekte geändert.

+ +
+
+
+
+
+
In [69]:
+
+
+
class Car:
+    price = "expensive" # der Preis wird auf jedes Objekt übertragen das mit der Klasse 'Car' erstellt wurde
+
+c = Car
+print(c.price)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
expensive
+
+
+
+ +
+
+ +
+
+
+
+

Styleguide für Klassen und Variablen

In Python verwendet man dazu nach Konvention:

+
    +
  • PascalCase (IchBesteheAusMehrerenWoertern)
    • +
  • sneak_case (ich_bestehe_aus_mehreren_woertern)
    • +
+

Anders als in anderen Programmiersprachen benutzt man nicht:

+
    +
  • camelCase (ichBesteheAusMehrerenWoertern)
    • +
+ +
+
+
+
+
+
+

Besondere Methoden

Die str-Funktion gibt für print(objekt) eine Definierte Form aus.
+Die repr-Methode gibt für Objekt eine Definierte Form aus.
+Die len-Methode gibt für print(len(Objekt)) die Länge aus.

+ +
+
+
+
+
+
In [70]:
+
+
+
class PhoneBook():
+    def __init__(self):
+        self.__entries = {}
+    def add(self, name, phone_number):
+        self.__entries[name] = phone_number
+    def get(self, name):
+        if name in self.__entries:
+            return self.__entries[name]
+        else:
+            return None
+    def __str__(self):
+        return "PhoneBook(" + str(self.__entries) + ")"
+    def __repr__(self):
+        return "PhoneBook(" + str(self.__entries) + ")"
+    def __len__(self):
+        return len(self.__entries)
+
+book = PhoneBook()
+book.add("Mustermann", "1234")
+book.add("Mueller", "9876")
+
+print(book)      #für str-Funktion
+book             #für repr-Funktion
+print(len(book)) # für len-Funktion
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
PhoneBook({'Mustermann': '1234', 'Mueller': '9876'})
+2
+
+
+
+ +
+
+ +
+
+
+
+ +
+
+
+
+
+ + + + + + diff --git a/Python-Syntax.ipynb b/Python-Syntax.ipynb index 9faf657..65d61dd 100644 --- a/Python-Syntax.ipynb +++ b/Python-Syntax.ipynb @@ -1757,18 +1757,154 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# 10. Importieren mit %\n", - "für zusätzliche Funktionen können Module in Python importiert werden" + "# 10. 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": 60, + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hallo Welt\n" + ] + } + ], + "source": [ + "# Das 'hallo.py' Programm:\n", + "def welt():\n", + " print(\"Hallo Welt\")\n", + "welt()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hallo Welt\n" + ] + } + ], + "source": [ + "import hallo # die Datei hallo.py wird in das aktuelle Programm eingebunden\n", + "hallo.welt() # die Funktion welt() im hallo.py-Programm wird in unserem aktuellen Skript ausgeführt" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hallo Welt\n" + ] + } + ], + "source": [ + "from hallo import welt # damit wird explizit nur die Funktion 'welt()' in das aktuelle Programm geladen, jede weitere mit ',' getrennt\n", + "welt() # die Funktion kann damit direkt benutzt werden\n", + "# Achte auf Dopplungen von Funktionsnamen in unterschiedlichen Programmen!" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hallo Welt\n" + ] + } + ], + "source": [ + "from hallo import * # mit dem '*' werden alle Funktionen aus 'hallo.py' in das aktuelle Programm geladen\n", + "welt() " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hallo Welt\n" + ] + } + ], + "source": [ + "import hallo as h # mit der 'as'-Methode wird zum Aufrufen eines Programms im Skript ein 'Ersatzname' genutzt\n", + "h.welt() # diese Variante kann lange Programmnamen abkürzen" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Modulordner definieren und strukturieren\n", + "Um viele Programme und Module strukturiert zu halten ist es oft praktisch diese in einem extra Ordner zu speichern. Hierbei ist es vorteilhaft eine Modul-Datei mit der Auflistung aller möglichen Programme zu führen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Modul-Datei: __init__.py\n", + "__all__ = [\"datei\"] # all Beschreibt alle Module, \"datei\" ist ein Programm namens 'datei.py' im Modulordner" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# hier wird der Vorteil der Modul-Datei gezeigt\n", + "from ordner import * # alle Funktionen aus dem Ordner 'ordner' werden geladen\n", + "datei.f()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Module importieren\n", + "für zusätzliche Funktionen können externe bzw. fertige Module in Python importiert werden.
\n", + "Den Python-Modul-Indes findet man hier: https://docs.python.org/3/py-modindex.html
\n", + "Einige der wichtigsten Module werden folgend vorgestellt\n", + "\n", + "### Mathe plotten\n", + "mit der Bibliothek für Matheplotter (**mathplotlib.pyplot**) können Funktionen und Zahlen Grafisch visualisiert werden." + ] + }, + { + "cell_type": "code", + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1782,7 +1918,7 @@ "source": [ "%matplotlib inline \n", "import matplotlib.pyplot as plt # hier wird das Matplolib-Modul importiert und mit der Variable plt verknüpft\n", - "plt.scatter([1, 2], [4, 3]) # plt. kann dann für das Modul benutzt werden\n", + "plt.scatter([1, 2 , 3], [4, 3, 2]) # plt. kann dann für das Modul benutzt werden\n", "plt.show()" ] }, @@ -1808,7 +1944,194 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# 11. Objektorientierung\n", + "### Programm pausieren\n", + "Manchmal ist es notwenig das Programm pausieren zu lassen (Bsp Crawler auf Webseite). Dafür nutzt man das Modul **time**" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import time # Time-Modul importieren\n", + "time.sleep(1) # '1'-Sekunde Programmpause" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Webseiten runterladen\n", + "Mit einem **request** kann eine bestimmte Webseite heruntergeladen und der HTML-Code ausgegeben werden (http://docs.python-requests.org/en/master/)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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" + ] + } + ], + "source": [ + "import requests\n", + "r = requests.get(\"http://www.google.de\")\n", + "\n", + "print(r.status_code)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Elemente in HTML finden\n", + "Aus html-Dateien kann man mit **BeautifulSoup** (https://www.crummy.com/software/BeautifulSoup/bs4/doc/) Informationen zerlegen und extrahieren." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'class': ['something']}\n", + "Ich bin ein Absatz!\n", + "{}\n", + "Ich bin noch ein Absatz\n" + ] + } + ], + "source": [ + "from bs4 import BeautifulSoup # BeautifulSoup importieren\n", + "\n", + "# Beispiel HTML-Datei \n", + "htmlDatei = \"\"\" \n", + " \n", + " \n", + "

Ich bin ein Absatz!

\n", + "

Ich bin noch ein Absatz

\n", + " \n", + " \n", + "\"\"\"\n", + "\n", + "doc = BeautifulSoup(htmlDatei, \"html.parser\") # HTML-Datei mit BeautifulSoup Parsen/Einlesen\n", + "\n", + "for p in doc.find_all(\"p\"): # im Dokument alle

-Konstruktoren finden\n", + " print(p.attrs) # für alle

dessen Attribute ausgeben\n", + " print(p.text) # für alle

dessen Text ausgeben" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### relative URLs\n", + "Einige Elemente (z.B. Bilder) sind auf Webseiten nur relativ zu Ihrer Webseite verlinkt. Beim Crawlen kann der gesamte Bildpfad mit **urljoin** hergestellt werden." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "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" + ] + } + ], + "source": [ + "from urllib.parse import urljoin # urljoin importieren\n", + "from bs4 import BeautifulSoup # BeautifulSoup importieren\n", + "\n", + "url = \"http://python.beispiel.programmierenlernen.io/index.php\" #Webseiten-URL die durchsucht wurde\n", + "\n", + "r = requests.get(url)\n", + "doc = BeautifulSoup(r.text, \"html.parser\") # HTML-Datei mit BeautifulSoup Parsen/Einlesen\n", + " \n", + "for card in doc.select(\".card\"):\n", + " image = card.select_one(\"img\").attrs[\"src\"]\n", + " imageURL = urljoin(url, image)\n", + " print(\"relative URL: \" + image + \" gesamte URL: \" + imageURL)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 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, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "gen: 0\n", + "for: 0\n", + "gen: 1\n", + "for: 1\n", + "gen: 2\n", + "for: 2\n", + "####\n", + "gen: 0\n", + "for: 0\n", + "gen: 1\n" + ] + } + ], + "source": [ + "def gen_generator():\n", + " for i in range(0, 3):\n", + " print(\"gen: \" + str(i))\n", + " yield i\n", + "\n", + "for element in gen_generator(): # Alle Elemente der Liste ausgeben\n", + " print(\"for: \" + str(element))\n", + "\n", + "print(\"####\")\n", + "\n", + "for element in gen_generator(): # die ersten 2 Elemente ausgeben\n", + " if element == 1:\n", + " break\n", + " print(\"for: \" + str(element))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 10. Objektorientierung\n", "Klassen sind Baupläne für Objekte. Die erzeugten Objekte nennt man Instanzen dieser Klasse." ] }, @@ -2103,10 +2426,8 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [] } ], diff --git a/Web Crawling.html b/Web Crawling.html new file mode 100644 index 0000000..9f0e6ab --- /dev/null +++ b/Web Crawling.html @@ -0,0 +1,13305 @@ + + + + +Web Crawling + + + + + + + + + + + + + + + + + + + + + + + +

+
+ +
+
+
+

Webcrawling

Crawlen beschreibt den Prozess, bei dem Daten aus einer Webseite extrahiert werden. Das Vorgehen ist meist wie folgt:

+
    +
  1. Seite als HTML-Code herunterladen
    2. +
  2. HTML-Code einlesen und Elemente suchen
    3. +
  3. Aus gefundenen Element(en) werden Informationen extrahiert.
    4. +
+

1.: HTML-Code herunterladen

mit requests-Paket

+ +
+
+
+
+
+
In [12]:
+
+
+
import requests        # requests importieren
+url = "http://www.beispiel.de""
+r = requests.get(url)  # das 'r' steht für 'Response', kann aber durch jedes beliebiges Zeichen ersetzt werden
+
+ +
+
+
+ +
+
+
+
+

Die Anfrage wurde an den Server gestellt. Der Statuscode der Webseite kann genauer betrachtet werden. Wichtige HTTP Status-Codes sind:

+
    +
  • 500: Internal Server Error
    • +
  • 404: Seite nicht gefunden
    • +
  • 200: Alles Okay
    • +
+ +
+
+
+
+
+
In [13]:
+
+
+
print(r.status_code)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
200
+
+
+
+ +
+
+ +
+
+
+
+

2. HTML-Code einlesen und Elemente suchen

+
+
+
+
+
+
In [25]:
+
+
+
from bs4 import BeautifulSoup      # BeautifulSoup importieren
+doc = BeautifulSoup(r.text, "html.parser") # HTML-Datei mit BeautifulSoup Einlesen
+
+ +
+
+
+ +
+
+
+
+

Mit dem heruntergeladenen und eingelesenen HTML-Code können Elemente extrahiert werden. Dafür bieten sich CSS-Selektroen an. +Beispiel:

+
    +
  • <div class="test">Hallo</div>: mit Hilfe von .test finden, der Punkt steht hierbei für eine Klasse
    • +
  • <div id="test">Hallo</div>: mit Hilfe von #test finden, die Raute steht hierbei für einID-Attribut
    • +
+ +
+
+
+
+
+
In [32]:
+
+
+
print(doc.find_all("p"))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
[<p>Diese Domain ist für illustrative Beispiele in Dokumenten eingerichtet. <br/>Sie können diese Domain ohne Erlaubnis als Beispiel verwenden und verlinken.</p>, <p><a href="/mehr.html">Mehr Infos</a>
+</p>]
+
+
+
+ +
+
+ +
+
+
+
+

3. Aus gefundenen Element(en) werden Informationen extrahiert.

+
+
+
+
+
+
In [31]:
+
+
+
i = 0
+for p in doc.find_all("p"):   # im Dokument alle <p>-Konstruktoren finden
+    print(str(i) + ". " + p.text)             # für alle <p> dessen Text ausgeben
+    i = i + 1
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
0. Diese Domain ist für illustrative Beispiele in Dokumenten eingerichtet. Sie können diese Domain ohne Erlaubnis als Beispiel verwenden und verlinken.
+1. Mehr Infos
+
+
+
+
+ +
+
+ +
+
+
+ + + + + + diff --git a/Web Crawling.ipynb b/Web Crawling.ipynb new file mode 100644 index 0000000..a759167 --- /dev/null +++ b/Web Crawling.ipynb @@ -0,0 +1,154 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Webcrawling\n", + "Crawlen beschreibt den Prozess, bei dem Daten aus einer Webseite extrahiert werden. Das Vorgehen ist meist wie folgt:
\n", + "\n", + "1. Seite als HTML-Code herunterladen\n", + "2. HTML-Code einlesen und Elemente suchen\n", + "3. Aus gefundenen Element(en) werden Informationen extrahiert.\n", + "\n", + "\n", + "## 1.: HTML-Code herunterladen \n", + "mit **requests**-Paket" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import requests # requests importieren\n", + "url = \"http://www.beispiel.de\"\"\n", + "r = requests.get(url) # das 'r' steht für 'Response', kann aber durch jedes beliebiges Zeichen ersetzt werden" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Die Anfrage wurde an den Server gestellt. Der Statuscode der Webseite kann genauer betrachtet werden. Wichtige HTTP Status-Codes sind:\n", + "- 500: Internal Server Error\n", + "- 404: Seite nicht gefunden\n", + "- 200: Alles Okay" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200\n" + ] + } + ], + "source": [ + "print(r.status_code)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. HTML-Code einlesen und Elemente suchen" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "from bs4 import BeautifulSoup # BeautifulSoup importieren\n", + "doc = BeautifulSoup(r.text, \"html.parser\") # HTML-Datei mit BeautifulSoup Einlesen" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mit dem heruntergeladenen und eingelesenen HTML-Code können Elemente extrahiert werden. Dafür bieten sich CSS-Selektroen an.\n", + "Beispiel:\n", + "\n", + "- `
Hallo
`: mit Hilfe von `.test` finden, der Punkt steht hierbei für eine Klasse\n", + "- `
Hallo
`: mit Hilfe von `#test` finden, die Raute steht hierbei für einID-Attribut" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[

Diese Domain ist für illustrative Beispiele in Dokumenten eingerichtet.
Sie können diese Domain ohne Erlaubnis als Beispiel verwenden und verlinken.

,

Mehr Infos\n", + "

]\n" + ] + } + ], + "source": [ + "print(doc.find_all(\"p\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Aus gefundenen Element(en) werden Informationen extrahiert." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0. Diese Domain ist für illustrative Beispiele in Dokumenten eingerichtet. Sie können diese Domain ohne Erlaubnis als Beispiel verwenden und verlinken.\n", + "1. Mehr Infos\n", + "\n" + ] + } + ], + "source": [ + "i = 0\n", + "for p in doc.find_all(\"p\"): # im Dokument alle

-Konstruktoren finden\n", + " print(str(i) + \". \" + p.text) # für alle

dessen Text ausgeben\n", + " i = i + 1" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}