sudo apt-get install ipython-notebook
, ansonsten: http://ipython.org/install.html2 + 3
5
2 * 3
6
2 ** 3
8
int
vs. float
!2 / 3
0
2.0 / 3
0.6666666666666666
Verwende die Funktion float()
, wenn eine Ganzzahl (oder einen String, der eine Ganzzahl repräsentiert) in eine Gleitkommazahl umgewandelt werden soll:
float(3)
3.0
float("3")
3.0
Einen mehrzeiligen String können wir so allerdings nicht eingeben. Nach Eingabe der Enter/Return-Taste erscheint eine Fehlermeldung:
"Hallo Siggi,
File "<ipython-input-8-008aff03b796>", line 1 "Hallo Siggi, ^ SyntaxError: EOL while scanning string literal
Mehrzeilige Strings (können beliebig viele Zeilenumbrüche und Leerzeichen enthalten) werden in dreifache Anführungszeichen (' oder ") gesetzt:
"""Hallo Siggi,
ich hab mein Passwort vergessen.
Kannst du meins bitte zurücksetzen?"""
'Er sagte, 'So geht es nicht'.'
File "<ipython-input-9-de935d445a7e>", line 1 'Er sagte, 'So geht es nicht'.' ^ SyntaxError: invalid syntax
'Er sagte, \'So geht es nicht\'.'
"Er sagte, 'So geht es nicht'."
"Er sagte, 'So geht es nicht'."
"Er sagte, 'So geht es nicht'."
'Er sagte, "So geht es nicht".'
'Er sagte, "So geht es nicht".'
lotto = (6, 9, 12, 24, 36, 41)
print lotto[1] # gibt das 2. Element des lotto-Tupels auf dem Bildschirm aus
9
lotto[1] = 42 # Wir können einem Element des Tupels nicht nachträglich einen neuen Wert zuweisen (_immutable_)
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-14-19315ec4fa0a> in <module>() ----> 1 lotto[1] = 42 # Wir können einem Element des Tupels nicht nachträglich einen neuen Wert zuweisen (_immutable_) TypeError: 'tuple' object does not support item assignment
print lotto # unverändert
gemischte_liste = ([1,2,3], 3.14, 'Chomsky')
print gemischte_liste[0]
einkauf = ['brot', 'butter']
einkauf.append('milch')
print len(einkauf), einkauf
einkauf[2] = 'käse' # Wert des 3. Elements der einkauf-Liste wird verändert
print len(einkauf), einkauf
print einkauf[2]
einkauf.pop(0) # nulltes Element entfernen
print len(einkauf), einkauf
einkauf[2] = 'kwas' # mit der Index-Notation können wir nur bestehende Elemente verändern, aber keine Neuen hinzufügen
einkauf.append('kwas')
print einkauf
Wir basteln uns eine kleine Datenbank der aktuellen Bundesregierung. Die Tätigkeitsbeschreibung speichern wir als Attribute (Keys) und die zugehörigen Personen als Werte (Values):
jobs = {'chef': 'angie',
'aussen': 'frank-walter',
'innen': 'thomas',
'krieg': 'zensursula',
'gedöns': 'manuela'}
Wir können unsere Datenbank (das jobs Dictionary) jetzt abfragen:
print jobs['krieg'] # einen Key abfragen
print jobs['entwicklung'] # Key existiert nicht
Wir haben vergessen, den "Entwicklungshilfe"-Minister einzutragen (das jobs Dictionary enthält kein Attribut "entwicklung") und bekommen daher eine Fehlermeldung. Alternativ können wir das Dictionary auch so abfragen, dass kein Fehler entsteht:
'entwicklung' in jobs
Statt eines Wahrheitswerts können wir auch einen selbstgewählten Wert (default value) zurückgeben, wenn ein Key nicht im Dictionary vorhanden ist:
print jobs.get('aussen', 'Stelle frei!1!!') # Attribut vorhanden, Wert wird zurückgegeben
print jobs.get('entwicklung', 'Stelle frei!1!!') # Attribut nicht vorhanden, Default-Wert wird zurückgegeben
jobs['entwicklung'] = 'gerd' # Attribut-Wert-Paar hinzufügen
print jobs # gibt das komplette Dictionary aus
print jobs.items() # Ausgabe als Liste von (Attribut, Wert)-Tupeln
leere_menge = set()
print leere_menge
foo = set([0.2,7,2,1,1,1,3,3,6])
print foo # Mengen sind unsortiert!
Mithilfe der Funktion sorted()
können Mengen, Listen, Tupel usw. sortiert werden (numerisch, lexikographisch)
sorted(foo)
zahlen = set([1,2,3])
mehr_zahlen = {3,4,5} # Alternativschreibweise, nicht mit Dictionary verwechseln!
print zahlen, mehr_zahlen
3 in zahlen # Mitgliedschaft testen
zahlen.intersection(mehr_zahlen) # Schnittmenge beider Mengen
zahlen.add("Buchstaben sind auch ok.")
print zahlen
a = {1,2,3}
b = {3,4,5}
c = {3,7,9}
a.intersection(b,c) # Schnittmenge der Mengen A, B und C
heute = "Donnerstag"
print heute
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-15-bf5e3e1a80aa> in <module>() ----> 1 print heute NameError: name 'heute' is not defined
heute = "Freitag"
print heute
Freitag
3erlei = 123
File "<ipython-input-17-a148c24a0314>", line 1 3erlei = 123 ^ SyntaxError: invalid token
leer zeichen = 'Angela Merkel'
File "<ipython-input-18-be468ab04bf4>", line 1 leer zeichen = 'Angela Merkel' ^ SyntaxError: invalid syntax
name = "Ronny" # immutable
print "Mein Name beginnt mit", name[0]
name[0] = "C"
Mein Name beginnt mit R
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-19-5aabc0f736f1> in <module>() 1 name = "Ronny" # immutable 2 print "Mein Name beginnt mit", name[0] ----> 3 name[0] = "C" TypeError: 'str' object does not support item assignment
Wir können das erste Element des Strings name zwar abfragen, aber nicht nachträglich ändern. Tupel verhalten sich genauso:
name = ('R', 'o', 'n', 'n', 'y') # immutable
print "Mein Name beginnt mit", name[0]
name[0] = "C"
Mein Name beginnt mit R
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-20-0a4cde2f20a8> in <module>() 1 name = ('R', 'o', 'n', 'n', 'y') # immutable 2 print "Mein Name beginnt mit", name[0] ----> 3 name[0] = "C" TypeError: 'tuple' object does not support item assignment
Im Gegensatz zu Strings und Tuoeln sind Listen mutable, wir können daher nicht nur das erste Element abfragen, sondern es auch nachträglich verändern:
name = ['R', 'o', 'n', 'n', 'y'] # mutable
name[0] = "C"
print name
['C', 'o', 'n', 'n', 'y']
bradley_manning = "89289"
chelsea_manning = bradley_manning # beide Variablen referenzieren jetzt den gleichen String
print "Werte: ", bradley_manning, chelsea_manning
print "Speicheradresse: ", id(bradley_manning), id(chelsea_manning)
Werte: 89289 89289 Speicheradresse: 46327008 46327008
Die Variable bradley_manning bekommt einen neuen Wert zugewiesen (mit neuer Speicheradresse), chelsea_manning behält hingegen den alten Wert:
bradley_manning = "007" # Der Variable wird ein neuer Wert zugewiesen.
print "Werte: ", bradley_manning, chelsea_manning
print "Speicheradresse: ", id(bradley_manning), id(chelsea_manning)
Werte: 007 89289 Speicheradresse: 46360616 46327008
einkauf = ['brot', 'butter']
zweikauf = einkauf
print einkauf, zweikauf
print id(einkauf), id(zweikauf)
['brot', 'butter'] ['brot', 'butter'] 44845536 44845536
Die Liste, die der Variable einkauf zugewiesen wurde, wird durch Anhängung eines Elements verändert. Die Variablen einkauf und zweikauf referenzieren immernoch das gleiche (aber veränderte) Objekt:
einkauf.append('wasser')
print einkauf, zweikauf
print id(einkauf), id(zweikauf)
['brot', 'butter', 'wasser'] ['brot', 'butter', 'wasser'] 44845536 44845536
zehner = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
zehner[3:] # vom vierten Element bis einschliesslich des letzten Elements
[30, 40, 50, 60, 70, 80, 90, 100]
print zehner [0:5] # vom ersten Element bis einschliesslich des fünften Elements
print zehner[:5] # Kurzschreibweise
[0, 10, 20, 30, 40] [0, 10, 20, 30, 40]
zehner[2:5] # vom 3. bis einschliesslich des 5. Elements
[20, 30, 40]
zehner[4:-1] # vom 5. Element bis einschliesslich des vorletzten Elements
[40, 50, 60, 70, 80, 90]
Die Funktion range(n)
gibt eine Liste der Ganzzahlen 0 bis n-1 zurück:
range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Die Funktion range(i, n)
gibt eine Liste der Ganzzahlen i bis n-1 zurück:
range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Die Funktion range(i, n, increment)
gibt eine Liste aller Ganzzahlen i, i+increment, i+increment*2 ... < n
print range(0, 101, 10) # von 1 bis einschliesslich 100 mit Schrittweite 10
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
2 + 3
5
'2' + '3'
'23'
2 * 6
12
'2' * 6
'222222'
'2' * '6' # Der Operator * kann nicht auf zwei Strings angewendet werden
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-38-733cce7bc2a5> in <module>() ----> 1 '2' * '6' # Der Operator * kann nicht auf zwei Strings angewendet werden TypeError: can't multiply sequence by non-int of type 'str'
4 < 2
False
'elefant' < 'mouse' # lexikographischer Vergleich
True
2<=2
True
a = 23
b = 42
a == b
False
a != b
True
'aaa' == 'aaa'
True
1 < 2 and 'b' > 'a'
True
1 < 2 or 1 > 2
True
'apple' in ['apple', 'banana', 'cherry']
True
'pizza' not in ['apple', 'banana', 'cherry']
True
print type(1), type(1.0), type("1"), type([1])
<type 'int'> <type 'float'> <type 'str'> <type 'list'>
print isinstance(1, str) # gibt Wahrheitswert zurück
False
Vorsicht: Interpretation kann auch "schiefgehen"!
Python interpretiert Ganzzahlen mit führender Null als Zahlen im Oktalsystem und rechnet diese automatisch in das Dezimalsystem um:
print 033
27
type(033)
int
oct(27) # Umrechnung der Ganzzahl 27 (Dezimalsystem) in das Oktalsystem
'033'
print int(3.14) ## Umwandlung float --> int
print type(int("2")), type(str(2)) ## Umwandlung str --> int sowie int --> str
3 <type 'int'> <type 'str'>
kontostand = -100
if kontostand > 0:
print "Auszahlung läuft"
else:
print "Geht nicht, weil iss nicht!"
Geht nicht, weil iss nicht!
fruits = ['apple', 'banana', 'cherry']
veggies = ['avocado', 'tomato', 'beetroot']
food_item = 'pizza'
if food_item in fruits:
print "It's sweet!"
elif food_item in veggies:
print "It's healty!"
else:
print "Oh noes!"
Oh noes!
for dingsbums in fruits:
print dingsbums
apple banana cherry
for zaehler, gemuese in enumerate(veggies):
print "veggie number", zaehler, "is a", gemuese
veggie number 0 is a avocado veggie number 1 is a tomato veggie number 2 is a beetroot
Wie funktioniert dieser Zähler?
Wir wenden die Funktion enumerate()
auf ein iterierbares ("durchzählbares") Objekt an, also z.B. Listen, Tupel, Strings oder Dictionaries. Als Ergebnis bekommen wir eine Liste von 2-Tupeln (bestehend aus dem Index des Elements und dem Element selbst).
gemuesezaehler = enumerate(veggies)
Intern sieht der "Gemüsezähler" jetzt so aus: [(0, 'avocado'), (1, 'tomato'), (2, 'beetroot')]
Irrelevantes Detail für Fortgeschrittene: aus Effizienzgründen liefert enumerate keine Liste zurück, sondern ein Objekt mit der Funktion next()
, welches uns das jeweils nächste 2-Tupel der Gemüsezählerliste zurückgibt:
gemuesezaehler = enumerate(veggies)
print gemuesezaehler.next()
print gemuesezaehler.next()
print gemuesezaehler.next()
print gemuesezaehler.next()
(0, 'avocado') (1, 'tomato') (2, 'beetroot')
--------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-59-161e782347db> in <module>() 3 print gemuesezaehler.next() 4 print gemuesezaehler.next() ----> 5 print gemuesezaehler.next() StopIteration:
Die for-Schleife braucht also gar nicht zu wissen, wieviele Elemente unsere Liste enthält. enumerate
liefert sowohl den Zähler des aktuellen Schleifendurchlaufs als auch die Information, wann die Schleife abgebrochen werden kann (StopIteration
).
for i in range(1,10):
print 'a' * i
a aa aaa aaaa aaaaa aaaaaa aaaaaaa aaaaaaaa aaaaaaaaa
name = "Horst"
print "Hallo {}! Wie geht's?".format(name)
Hallo Horst! Wie geht's?
Der Wert der Variable name
wurde in den String an die Stelle {}
eingefügt.
Wenn man mehrere Werte in einen String einfügen möchte, muss man die {}
numerieren:
name1 = "Horst"
name2 = "Ulla"
print "Hallo {0}! Kennst du {1} schon?".format(name1, name2)
Hallo Horst! Kennst du Ulla schon?
Die format()
-Methode kann man auch direkt mit Werten füttern,
es müssen auch keine Strings sein (solange sie sich in einen String umwandeln lassen):
print "pi ist {0} und nicht {1} oder gar {2}!".format(3.141592653589793, 23, 'Kuchen')
pi ist 3.14159265359 und nicht 23 oder gar Kuchen!
def greeting(name):
return "Hallo, {}. Wie geht's?".format(name)
print greeting('Horst')
Hallo, Horst. Wie geht's?
Welchen Typ der Parameter name
hat ist der Funktion prinzipiell egal.
Irrelevantes Detail für Fortgeschrittene: die format()
-Methode kann jedes Objekt in einen String einfügen, das eine __str__()
-Methode hat.
print greeting(12)
Hallo, 12. Wie geht's?
def greeting2(name, formality):
hello = "Hallo, %s!" % name
if formality == 'formell':
return hello + " Wie geht es Ihnen?"
elif formality == 'informell':
return hello + " Wie geht es dir?"
else:
return hello
print greeting2('Ulla', 'formell') # if ...
Hallo, Ulla! Wie geht es Ihnen?
print greeting2('Ulla', 'informell') # else if ...
Hallo, Ulla! Wie geht es dir?
print greeting2('Ulla', 'ksdlfksdlfskdlfsd') # else
Hallo, Ulla!
print greeting2('Ulla') # ein Parameter zu wenig übergeben
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-71-20b661b36ca9> in <module>() ----> 1 print greeting2('Ulla') # ein Parameter zu wenig übergeben TypeError: greeting2() takes exactly 2 arguments (1 given)
def greeting3(name, formality=None):
hello = "Hallo, %s!" % name
if formality is None: # geht auch: if formality == None
return hello
elif formality == 'formell':
return hello + " Wie geht es Ihnen?"
else:
return hello + " Wie geht es dir?"
print greeting3('Maik') # ohne optionalen Parameter
Hallo, Maik!
print greeting3('Maik', 'formell') # else if ...
Hallo, Maik! Wie geht es Ihnen?
print greeting3('Maik', 'informell') # else ...
Hallo, Maik! Wie geht es dir?
print greeting3('Maik', 'Knäckebrot') # ebenfalls else ...
Hallo, Maik! Wie geht es dir?
Funktionen ohne return
-Anweisung haben immer den Rückgabewert None
.
def plus2(zahl):
print zahl+2
Die Funktion plus2(zahl)
addiert 2 zur gegebene Zahl und gibt das Ergebnis nur auf dem Bildschirm aus.
plus2(10)
12
Beim Versuch das Ergebnis der Funktion plus2()
in einer Variable zu speichern, kommt es zu unerwarteten Effekten:
ergebnis = plus2(10)
12
print ergebnis
None
print ergebnis + -100
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-81-f541f392f570> in <module>() ----> 1 print ergebnis + -100 TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
class Gruessaugust:
"""
Ein Grüßaugust hat nur eine Aufgabe: Grüßen.
Jede Instanz der Klasse Gruessaugust hat genau eine Methode:
print_greeting(name).
"""
def print_greeting(self, name):
print "Hallo {}".format(name)
wulff = Gruessaugust() # wulff ist eine Instanz der Klasse Gruessaugust
wulff.print_greeting("Angie") # wulff kann alle Methoden nutzen, die für die Klasse Gruessaugust definiert sind
Hallo Angie
print_greeting("Angie") # die Methoden einer Klasse können nur auf einer Instanz derselben aufgerufen werden
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-85-e76f9e3e23fd> in <module>() ----> 1 print_greeting("Angie") # die Methoden einer Klasse können nur auf einer Instanz derselben aufgerufen werden NameError: name 'print_greeting' is not defined
class Gruesser:
def __init__(self, gruesser_name):
self.name = gruesser_name
def print_greeting(self, gast):
print "Der Grüssaugust {0} begrüßt den Gast {1}".format(self.name, gast)
wulff = Gruesser("Christian")
wulff.name
'Christian'
wulff.print_greeting("Putin")
Der Grüssaugust Christian begrüßt den Gast Putin
koehler = Gruesser('Horst')
koehler.name
'Horst'
koehler.print_greeting("Juncker")
Der Grüssaugust Horst begrüßt den Gast Juncker