- 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 #
%% Cell type:markdown id: tags:
## 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
%% Cell type:code id: tags:
```
%load_ext nb_black
```
%% Cell type:markdown id: tags:
## Grundlegende Datentypen
Zahlentypen (int/float) sind größtenteils äquivalent zu Java. Strings können mit doppelten oder einfachen Anführungszeichen deklariert werden.
%% Cell type:code id: tags:
```
a = 2*2.0
a = 2 * 2.0
b = 5
print(a + b)
print(type(a))
```
%% Cell type:code id: tags:
```
a += 1
# ist kurz für
a = a + 1
# a++ existiert nicht
print(a)
```
%% Cell type:code id: tags:
```
2**4
2** 4 # Potenzen
```
%% Cell type:code id: tags:
```
2/4
2 / 4 # Brüche
```
%% Cell type:code id: tags:
```
text1 = 'Hallo '
text1 = "Hallo "
text2 = "Welt"
print(text1 + text2)
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)
```
%% Cell type:code id: tags:
```
float('1')
float("1")
```
%% Cell type:code id: tags:
```
float(1)
```
%% Cell type:markdown id: tags:
*None* entspricht *null* in Java.
%% Cell type:code id: tags:
```
myvar = None
```
%% Cell type:code id: tags:
```
print(myvar)
```
%% Cell type:code id: tags:
```
if myvar is None:
print('x ist nicht definiert')
print("x ist nicht definiert")
```
%% Cell type:markdown id: tags:
## Listen
Listen werden mit eckigen Klammern oder list() initialisiert.
%% Cell type:code id: tags:
```
l = [1,2,3,3]
l1 = []
l = [1, 2, 3, 3]
l.append(4)
print(l1)
print(l)
```
%% Cell type:markdown id: tags:
Vorsicht bei der Kombination von Listen. append hängt die übergebene Variable als einzelnen Listeneintrag an die Liste an.
%% Cell type:code id: tags:
```
l.append([5, 6])
print(l)
```
%% Cell type:markdown id: tags:
Zur Kombination von zwei Listen wird der +-Operator verwendet.
%% Cell type:code id: tags:
```
l2 = l + [5,6]
l2 = l + [5,6]
print(l2)
```
%% Cell type:markdown id: tags:
## Mengen
Mengen können mit geschweiften Klammern oder set() initialisiert werden.
%% Cell type:code id: tags:
```
s = {1,2,3,3}
s2 = set([2,3,4,5])
s = {1,2,3,3}
s2 = set([2,3,4,5])
print(s)
print(s.intersection(s2))
```
%% Cell type:code id: tags:
```
s.add(9)
s.remove(2)
s
```
%% Cell type:markdown id: tags:
Mit list() und set() können die Typen auch ineinander konvertiert werden.
%% Cell type:code id: tags:
```
list(s)
```
%% Cell type:code id: tags:
```
set([1,2,3])
set([1,2,3])
```
%% Cell type:markdown id: tags:
## Ranges
Auflistung von Zahlen, werden z.Bsp. für for-Schleifen mit Index verwendet.
%% Cell type:code id: tags:
```
for i in range(5):
print(i)
```
%% Cell type:markdown id: tags:
## Tupel
Für sortierete Werte mit fester Komponentenanzahl und fester Bedeutung für jeden Eintrag.
%% Cell type:code id: tags:
```
essen = 'Chili'
essen = "Chili"
preis = 2.51
boneintrag = (essen, preis)
print(boneintrag)
print(boneintrag[0])
print(boneintrag[1])
```
%% Cell type:code id: tags:
```
(essen2, preis2) = boneintrag
print(essen2)
print(preis2)
```
%% Cell type:markdown id: tags:
Klammern können oft weggelassen werden
%% Cell type:code id: tags:
```
boneintrag = essen, preis
essen2, preis2 = boneintrag
print(boneintrag)
print(essen2)
print(preis2)
```
%% Cell type:markdown id: tags:
## Dictionaries
Äquivalent zu Maps.
%% Cell type:code id: tags:
```
d = {'Chili': 1.90, 'Penne': 2.50}
d = {"Chili": 1.90, "Penne": 2.50}
```
%% Cell type:code id: tags:
```
d.keys()
```
%% Cell type:code id: tags:
```
d.values()
```
%% Cell type:code id: tags:
```
for key, val in d.items():
print('{}: {}'.format(key, val))
print("{}: {}".format(key, val))
```
%% Cell type:code id: tags:
```
d['Chili']
d["Chili"]
```
%% Cell type:code id: tags:
```
d['Burger'] = 4.90
d["Burger"] = 4.90
d
```
%% Cell type:code id: tags:
```
del d['Burger']
del d["Burger"]
d
```
%% Cell type:markdown id: tags:
## If-Anweisungen
%% Cell type:code id: tags:
```
if 2>1 or 1>2:
print ('Bedingung erfüllt.')
if 2 > 1 or 1 > 2:
print("Bedingung erfüllt.")
```
%% Cell type:code id: tags:
```
y = 10
x = 5 if y > 10 else 4
print(x)
```
%% Cell type:markdown id: tags:
## Schleifen
%% Cell type:code id: tags:
```
x = 5
while x > 0:
x -= 1
x
```
%% Cell type:code id: tags:
```
for x in ['a', 'b', 'c']:
for x in ["a", "b", "c"]:
print(x)
```
%% Cell type:markdown id: tags:
## Funktionen
%% Cell type:code id: tags:
```
def sum_upto(n):
return n*(n+1)/2
return n * (n + 1) / 2
sum_upto(4)
```
%% Cell type:markdown id: tags:
Zur besseren Übersicht (insbesondere bei vielen Parametern) können diese auch namentlich zugewiesen werden.
%% Cell type:code id: tags:
```
sum_upto(n=4)
```
%% Cell type:markdown id: tags:
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.
%% Cell type:code id: tags:
```
def fun_with_default(x=3):
print('Parameter is {}'.format(x))
print("Parameter is {}".format(x))
```
%% Cell type:code id: tags:
```
fun_with_default()
```
%% Cell type:code id: tags:
```
fun_with_default(x=4)
```
%% Cell type:markdown id: tags:
Funktionen können wie Variablen referenziert werden (Pointer auf die Funktion) und zum Beispiel als Parameter übergeben werden.
%% Cell type:code id: tags:
```
def calc_and_print(calc_function, n):
calc_result = calc_function(n)
print(calc_result)
```
%% Cell type:code id: tags:
```
calc_and_print(sum_upto, 4)
```
%% Cell type:markdown id: tags:
## 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.
%% Cell type:code id: tags:
```
calc_square = lambda x: x**2
calc_square = lambda x: x**2
calc_square(3)
```
%% Cell type:code id: tags:
```
calc_and_print(calc_square, 4)
```
%% Cell type:code id: tags:
```
calc_and_print(lambda x: x**3, 4)
calc_and_print(lambda x: x**3, 4)
```
%% Cell type:markdown id: tags:
## List Comprehensions
%% Cell type:code id: tags:
```
y = [x**2 for x in range(10)]
y = [x**2 for x in range(10)]
y
```
%% Cell type:code id: tags:
```
xy = [(x, x**2) for x in range(10) if x%2 == 0]
xy = [(x, x**2) for x in range(10) if x % 2 == 0]
xy
```
%% Cell type:markdown id: tags:
## 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.
%% Cell type:code id: tags:
```
class Vehicle():
class Vehicle:
# Constructor
def __init__(self, n_wheels=4, noise='beep'):
def __init__(self, n_wheels=4, noise="beep"):
self.n_wheels = n_wheels
self.noise = noise
def make_noise(self):
print(self.noise)
```
%% Cell type:code id: tags:
```
basicVehicle = Vehicle()
basicVehicle.make_noise()
```
%% Cell type:markdown id: tags:
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.
%% Cell type:code id: tags:
```
basicVehicle.n_wheels
```
%% Cell type:markdown id: tags:
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.”
%% Cell type:code id: tags:
```
bike = Vehicle(n_wheels=2, noise='ring')
bike = Vehicle(n_wheels=2, noise="ring")
bike.make_noise()
```
%% Cell type:code id: tags:
```
class Bike(Vehicle):
def __init__(self):
self.n_wheels = 2
self.noise = 'ring'
self.noise = "ring"
```
%% Cell type:code id: tags:
```
Bike().make_noise()
```
%% Cell type:markdown id: tags:
# 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*
%% Cell type:markdown id: tags:
# Shortcuts
Übersicht: *Help -> Keyboard Shortcuts*
-*Enter*: Editiermodus für selektierte Zelle (grün)
