recap.ipynb

 
 Python Grundlagen

Dynamisch typisierte Sprache
Statt geschweifter Klammern für Codeblöcke (Funktionen, Schleifen) wird Code mit vier Leerzeichen (pro Hierarchieebene) eingerückt
Die meisten Editoren ersetzen Tab automatisch durch vier Leerzeichen
Kommentare beginnen mit Raute #
 Krasse neue Bibliothek
Formatiert euren Code nach jeder Ausführung

für "normale" python scripte: black
für jupyter notebooks: nb_black
Installation: pip install nb_black
Ausführung: Einfach %load_ext nb_black in einem Codeblock einmalig ausführen
 %load_ext nb_black
 
 Grundlegende Datentypen
Zahlentypen (int/float) sind größtenteils äquivalent zu Java. Strings können mit doppelten oder einfachen Anführungszeichen deklariert werden.
 a = 2 * 2.0
b = 5

print(a + b)
print(type(a))
 
 a += 1
# ist kurz für
a = a + 1
# a++ existiert nicht

print(a)
 
 2 ** 4  # Potenzen
 
 2 / 4  # Brüche
 
 text1 = "Hallo "
text2 = "Welt"

print(text1 + text2)

# Andere Datentypen müssen explizit in Strings konvertiert werden,
# wenn sie an einen String angehängt werden sollen.
print(text1 + str(1))
# ansonsten muss per Komma getrennt werden
print(text1, 1)
 
 float("1")
 
 float(1)
 
 None entspricht null in Java.
 myvar = None
 
 print(myvar)
 
 if myvar is None:
    print("x ist nicht definiert")
 
 Listen
Listen werden mit eckigen Klammern oder list() initialisiert.
 l1 = []
l = [1, 2, 3, 3]
l.append(4)

print(l1)
print(l)
 
 Vorsicht bei der Kombination von Listen. append hängt die übergebene Variable als einzelnen Listeneintrag an die Liste an.
 l.append([5, 6])

print(l)
 
 Zur Kombination von zwei Listen wird der +-Operator verwendet.
 l2 = l + [5, 6]

print(l2)
 
 Mengen
Mengen können mit geschweiften Klammern oder set() initialisiert werden.
 s = {1, 2, 3, 3}
s2 = set([2, 3, 4, 5])

print(s)
print(s.intersection(s2))
 
 s.add(9)
s.remove(2)
s
 
 Mit list() und set() können die Typen auch ineinander konvertiert werden.
 list(s)
 
 set([1, 2, 3])
 
 Ranges
Auflistung von Zahlen, werden z.Bsp. für for-Schleifen mit Index verwendet.
 for i in range(5):
    print(i)
 
 Tupel
Für sortierete Werte mit fester Komponentenanzahl und fester Bedeutung für jeden Eintrag.
 essen = "Chili"
preis = 2.51
boneintrag = (essen, preis)

print(boneintrag)
print(boneintrag[0])
print(boneintrag[1])
 
 (essen2, preis2) = boneintrag

print(essen2)
print(preis2)
 
 Klammern können oft weggelassen werden
 boneintrag = essen, preis
essen2, preis2 = boneintrag

print(boneintrag)
print(essen2)
print(preis2)
 
 Dictionaries
Äquivalent zu Maps.
 d = {"Chili": 1.90, "Penne": 2.50}
 
 d.keys()
 
 d.values()
 
 for key, val in d.items():
    print("{}: {}".format(key, val))
 
 d["Chili"]
 
 d["Burger"] = 4.90
d
 
 del d["Burger"]
d
 
 If-Anweisungen
 if 2 > 1 or 1 > 2:
    print("Bedingung erfüllt.")
 
 y = 10
x = 5 if y > 10 else 4

print(x)
 
 Schleifen
 x = 5
while x > 0:
    x -= 1
x
 
 for x in ["a", "b", "c"]:
    print(x)
 
 Funktionen
 def sum_upto(n):
    return n * (n + 1) / 2


sum_upto(4)
 
 Zur besseren Übersicht (insbesondere bei vielen Parametern) können diese auch namentlich zugewiesen werden.
 sum_upto(n=4)
 
 Funktionen können Default-Parameter haben, d.h. Werte, die von der Funktion als Standardwert verwendet werden (wenn kein anderer Wert übergeben wird). Default-Parameter müssen am Ende der Funktion stehen und übergeben werden.
 def fun_with_default(x=3):
    print("Parameter is {}".format(x))
 
 fun_with_default()
 
 fun_with_default(x=4)
 
 Funktionen können wie Variablen referenziert werden (Pointer auf die Funktion) und zum Beispiel als Parameter übergeben werden.
 def calc_and_print(calc_function, n):
    calc_result = calc_function(n)
    print(calc_result)
 
 calc_and_print(sum_upto, 4)
 
 Lambda-Funktionen
I.d.R. für Inline-Funktionen. Können zum Beispiel an Funktionen als Parameter übergeben oder als Variable deklariert werden. Lambdas enthalten ein einzelnes Statement, dessen Wert automatisch der Rückgabewert ist.
 calc_square = lambda x: x ** 2
calc_square(3)
 
 calc_and_print(calc_square, 4)
 
 calc_and_print(lambda x: x ** 3, 4)
 
 List Comprehensions
 y = [x ** 2 for x in range(10)]
y
 
 xy = [(x, x ** 2) for x in range(10) if x % 2 == 0]
xy
 
 Klassen
Objekte einer Klasse bekommen bei Methodenaufrufen als ersten Parameter automatisch das "self"-Objekt übergeben (vgl. this in Java). Dieser Parameter muss also immer auch als erster Parameter einer Klassenmethode übergeben werden. 
 class Vehicle:
    # Constructor
    def __init__(self, n_wheels=4, noise="beep"):
        self.n_wheels = n_wheels
        self.noise = noise

    def make_noise(self):
        print(self.noise)
 
 basicVehicle = Vehicle()
basicVehicle.make_noise()
 
 Properties sind immer von außen sichtbar und lassen sich verändern. Properties, die nicht zur Veränderung gedacht sind, werden nach Konvention durch zwei Unterstriche im Namen gekennzeichnet.
 basicVehicle.n_wheels
 
 Vererbung ist in Python möglich. In der Regel wird aber Duck-Typing verwendet. 
“When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.”
 bike = Vehicle(n_wheels=2, noise="ring")
bike.make_noise()
 
 class Bike(Vehicle):
    def __init__(self):
        self.n_wheels = 2
        self.noise = "ring"
 
 Bike().make_noise()
 
 Jupyter Notebook Grundlagen

Notebook besteht aus Zellen
Unter der Zelle wird der Rückgabewert des letzten Statements ausgegeben
Quellcode kann auf mehrere Zellen aufgeteilt werden (Variablen behalten ihre Gültigkeit/Sichtbarkeit)
Variablen sind auch nach dem Löschen von Zellen weiter sichtbar. Um den Speicher zu bereinigen Kernel -> Restart
 Shortcuts
Übersicht: Help -> Keyboard Shortcuts

Enter: Editiermodus für selektierte Zelle (grün)
Esc: Editiermodus verlassen/Kommandomodus (blau)
Shift+Strg: Selektierte Zelle ausführen
Shift+Enter: Selektierte Zelle ausführen und in nächste Zelle springen
Im Editiermodus:

Tab: Autocomplete oder Einrücken
Im Kommandomodus:

B: Zelle darunter einfügen
A: Zelle darüber einfügen
DD: Zelle löschen
M: Zelltyp Markdown (für formatierte beschreibende Texte)
Y: Zelltyp Code (Default)