From 3664595076095e51879214cad51264527bed6032 Mon Sep 17 00:00:00 2001 From: Robert Jeutter Date: Tue, 11 Jan 2022 15:17:19 +0100 Subject: [PATCH] remove unnecessary html --- Python-Syntax.html | 17017 ------------------------------------------- Web Crawling.html | 13305 --------------------------------- 2 files changed, 30322 deletions(-) delete mode 100644 Python-Syntax.html delete mode 100644 Web Crawling.html diff --git a/Python-Syntax.html b/Python-Syntax.html deleted file mode 100644 index d5844c8..0000000 --- a/Python-Syntax.html +++ /dev/null @@ -1,17017 +0,0 @@ - - - - -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
-
-
-
- -
-
- -
-
-
-
-

Datentypen

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. 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
    • -
- -
-
-
-
-
-
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
-
-
-
- -
-
- -
-
-
-
-

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
    • -
- -
-
-
-
-
-
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")
-print(a)
-
- -
-
-
- -
-
- - -
- -
- - -
-
5
-
-
-
- -
-
- -
-
-
-
-

Einen String in eine Kommazahl umwandeln

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

- -
-
-
-
-
-
In [39]:
-
-
-
a = float("5.5")
-print(a)
-
- -
-
-
- -
-
- - -
- -
- - -
-
5.5
-
-
-
- -
-
- -
-
-
-
-

Eine Zahl in einen String umwandeln

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

- -
-
-
-
-
-
In [40]:
-
-
-
age = str(21)
-print(age)
-
- -
-
-
- -
-
- - -
- -
- - -
-
21
-
-
-
- -
-
- -
-
-
-
-

Einen String in eine Liste aufspalten

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

- -
-
-
-
-
-
In [41]:
-
-
-
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 & Gatter

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 [42]:
-
-
-
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 [43]:
-
-
-
# 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 [44]:
-
-
-
# 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 [45]:
-
-
-
# '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 [46]:
-
-
-
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 [47]:
-
-
-
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 [48]:
-
-
-
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 [49]:
-
-
-
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 [50]:
-
-
-
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 [51]:
-
-
-
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 [52]:
-
-
-
# 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 [53]:
-
-
-
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 [54]:
-
-
-
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 [55]:
-
-
-
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 [56]:
-
-
-
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 [57]:
-
-
-
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 [58]:
-
-
-
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 [59]:
-
-
-
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 [60]:
-
-
-
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 [61]:
-
-
-
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 [62]:
-
-
-
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 [63]:
-
-
-
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. 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 [64]:
-
-
-
# Das 'hallo.py' Programm:
-def welt():
-    print("Hallo Welt")
-welt()
-
- -
-
-
- -
-
- - -
- -
- - -
-
Hallo Welt
-
-
-
- -
-
- -
-
-
-
In [65]:
-
-
-
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 [66]:
-
-
-
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 [67]:
-
-
-
from hallo import * # mit dem '*' werden alle Funktionen aus 'hallo.py' in das aktuelle Programm geladen
-welt() 
-
- -
-
-
- -
-
- - -
- -
- - -
-
Hallo Welt
-
-
-
- -
-
- -
-
-
-
In [68]:
-
-
-
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 [69]:
-
-
-
# Modul-Datei: __init__.py
-__all__ = ["datei"] # all Beschreibt alle Module, "datei" ist ein Programm namens 'datei.py' im Modulordner
-
- -
-
-
- -
-
-
-
In [70]:
-
-
-
# hier wird der Vorteil der Modul-Datei gezeigt
-from ordner import * # alle Funktionen aus dem Ordner 'ordner' werden geladen
-datei.f()
-
- -
-
-
- -
-
- - -
- -
- - -
-
datei.py - Funktion 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 [71]:
-
-
-
%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 [72]:
-
-
-
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 [73]:
-
-
-
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 [74]:
-
-
-
import requests
-r = requests.get("http://www.google.de")
-
-print(r.status_code)
-
- -
-
-
- -
-
- - -
- -
- - -
-
200
-
-
-
- -
-
- -
-
-
-
-

Elemente in HTML finden

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

- -
-
-
-
-
-
In [75]:
-
-
-
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 [76]:
-
-
-
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
-
-
-
- -
-
- -
-
-
-
-

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 [77]:
-
-
-
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 [78]:
-
-
-
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 [79]:
-
-
-
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 [80]:
-
-
-
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 [81]:
-
-
-
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 [82]:
-
-
-
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 [83]:
-
-
-
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 [84]:
-
-
-
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 [85]:
-
-
-
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 [86]:
-
-
-
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
-
-
-
- -
-
- -
-
-
-
-

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/Web Crawling.html b/Web Crawling.html deleted file mode 100644 index 9f0e6ab..0000000 --- a/Web Crawling.html +++ /dev/null @@ -1,13305 +0,0 @@ - - - - -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
-
-
-
-
- -
-
- -
-
-
- - - - - -