In [ ]:
type(1)
In [ ]:
type('Hello world')
Da Python im Kern eine objektorientierte Sprache ist (alles ist ein Objekt im Sinne der objektorientierten Programmierung) gibt es potentiell beliebig viele Typen, weil selbstgeschriebene Klassen eigene Typen darstellen.
Die für den Einstieg wichtigsten Typen sind: int, float, bool und str.
int und floatDer Datentyp int (Integer) repräsentiert eine Ganzzahl, der Datentyp float eine Kommazahl (Float).
Beiden Typen können im Prinzip beliebig groß werden, ihre Größe ist nur durch den vorhanden Hauptspeicher begrenzt.
In [ ]:
type(12345), type(3.14)
In [ ]:
43 + 99 / 5 * 3
Versuchen Sie, durch Multiplikation oder Potenzierung eine richtig große Zahl zu erzeugen.
In [ ]:
Wieviel bleibt Rest, wenn man 481 durch 17 dividiert?
In [ ]:
Was passiert, wenn man einen Floatwert zu einem Integerwert addiert. Welchen Datentyp hat das Ergebnis?
In [ ]:
In [ ]:
type(True), type(False)
In [ ]:
type('abc'), type("abc")
In [ ]:
'"Das ist praktisch", sagte er, "weil man im String das jeweils andere Anführungszeichen verwenden kann."'
Manchmal muss man lange Strings erzeugen, die auch über mehrere Zeilen reichen können. Python bietet hier zwei elegante Möglchkeiten. Entwedert man verwendet als Stringbegrenzer drei Anführungszeichen (egal ob doppelte oder einfache)
In [ ]:
"""Das ist ein ziemlicher langer String, der
über mehrere Zeilen reicht."""
oder man klammert mehrere einzelne Strings:
In [ ]:
('Das ist eine ziemlich langer String, der '
'über mehrere Zeilen reicht.')
In Strings dient der Backslash (\) als Escape-Zeichen, das die Bedeutung des unmittelbar darauf folgenden Zeichens verändert. Es gibt eine Reihe solcher Escape-Sequenzen, hier nur ein paar Beispiele:
\' und \" können dazu verwendet werden, in einen String Anführungszeichen einzufügen, wenn das jeweilige Zeichen bereits zur Begrenzung des Strings verwendet wurde:
In [ ]:
'Sie sagte: \'Escape-Sequenzen sind manchmal recht nützlich\''
\n fügt eine Zeilenumbruch (Linefeed) ein. Das ist ein normales, in der Regel nicht sichtbares Zeichen (Codepoint 10)
In [ ]:
print("Zeile 1\nZeile2")
\t fügt ein Tabulatorzeichen ein
In [ ]:
print('abd\tefg')
In [ ]:
print('Die Escape-Sequenz \\t steht für einen Tabulator')
In [ ]:
print('Ein Sigma sieht so aus: \u03A3')
Der Datentyp legt fest, wie ein Wert intern repräsentiert wird.
Aus Programmiererersicht am wichtigsten ist, was man mit bestimmten Datentypen machen kann und was nicht.
Die Methode upper() des String-Typs wandelt alle Zeichen in Großbuchstaben um.
In [ ]:
'abc'.upper()
upper() in Zusammenhang mit Integern macht dagegen keinen Sinn und führt zu einem Error:
In [ ]:
123.upper()
Auch Operatoren bewirken für unterschiedliche Datentypen Unterschiedliches:
In [ ]:
1 + 1
In [ ]:
'1' + '1'
In [ ]:
'1' + 1 # führt zu TypeError
In [ ]:
'1' + str(1)
In [ ]:
int('1') + 1
Natürlich kann aber auch diese Typumwandlung scheitern:
In [ ]:
int('abc')
Vergleichsoperatoren werden dazu verwendet, zwei Werte miteinander zu vergleichen.
Man kann z.B. testen, ob zwei Wert gleich sind. Der entsprechende Operator ist == (zwei Istgleich-Zeichen!). Jeder Vergleich liefert einen Wahrheitswert (also True oder False).
123 == 123
True
'Graz' == 'Wien'
FalseNatürlich kann man auch berechnete Werte miteinander vergleichen:
100 / 4 == 75 / 3
In [ ]:
# Übung: Lässt sich 3459 durch 7 teilen?
# Hinweis: eine Zahl ist durch eine andere Zahl teilbar, wenn bei der Division Rest 0 bleibt
Python kennt eine Reihe von Vergleichsoperatoren:
== liefert True, wenn beide Werte gleich sind!= liefert True, wenn beide Werte ungleich sind< liefert True, wenn der linke Wert kleiner als der rechte Wert ist <= liefert True, wenn der linke Wert kleiner gleich dem rechten Wert ist > liefert True, wenn der linke Wert größer als der rechte Wert ist >= liefert True, wenn der linke Wert größer gleich dem rechten Wert ist
In [ ]:
'abc' != 'def'
In [ ]:
5 > 4
In [ ]:
7 <= 7
In [ ]:
'a' < 'b'
Zusätzlich kann man auf Objektidentität testen. Die entsprechenden Operatoren sind is und is not.
Sie liefern nur True wenn beide Werte dasselbe Objekt darstellen. In der Praxis sollten diese beide Operatoren nur für diese Datentypen verwendet werden: bool und None (kommt später noch).
In [ ]:
True is True
In [ ]:
True is False
In [ ]:
5 is None
Variablen sind Namen für Werte. (Unter Informatikern hört man öfter, dass Python keine echten Variablen hat, sondern dass man besser den Begriff Name dafür verwenden sollte, wir bleiben aber bei Variable, weil das ein in fast allen Programmiersprachen verwendeter Begriff ist.)
Eine Variable ist also ein Name (den wir selbst festlegen müssen), der auf einen bestimmten Wert zeigt:
In [ ]:
vorname = 'Gunter'
print(vorname)
Dabei können beliebig viele Variablen auf ein und denselben Wert zeigen:
In [ ]:
vorname = 'Wolfgang Amadeus'
firstname = vorname
vorname, firstname
Wir können überprüfen, ob die beiden Variablen wirklich auf denselben Wert zeigen, indem wir die Funktion id() verwenden. Jedes Objekt hat eine eindeutige Id, die mit der Funktion id() ausgelesen werden kann:
In [ ]:
id(vorname), id(firstname)
Weisen wir hingegen zweimal einen (und zwar denselben) Wert zu, zeigen die beiden Variablen auf unterschiedliche Objekte:
In [ ]:
vorname = 'Wolfgang Amadeus'
firstname = 'Wolfgang Amadeus'
id(vorname), id(firstname)
In [ ]:
vorname = 'Wolfgang Amadeus'
vorname
In [ ]:
print(vorname)
vorname = 'Ludwig'
print(vorname)
Python kennt einen speziellen Datentyp NoneType, der genau einen Wert annehmen kann: None.
In [ ]:
type(None)
None ist ein Nicht-Wert, der überall dort verwendet wird, wo kein Wert vorhanden ist. Beispielsweise kann eine Variable zunächst mit dem Wert None initialisert werden und erst später im Programmablauf einen anderen Wert bekommen.
Will man testen, ob der Wert einer Variable auf None steht, sollte man den is-Operator verwenden:
In [ ]:
firstname = None
firstname is None
Weil Variablen (Namen) auf Werte mit bestimmten Datentypen zeigen, sagt man, dass eine Variable einen bestimmten Typ hat. vorname im Beispiel oben ist vom Typ str.
In [ ]:
vorname = 'Gunter'
type(vorname)
Anders als bei statisch typisierten Sprache wie C oder Java, wo man den Typ einer Variable beim Initialisieren angeben muss, und diese Variablen den Datentyp während der gesamten Laufzeit beibehält, ist Python eine dynamische Sprache. Das bedeutet, dass einer Variable zur Laufzeit ein neuer Wert mit einem anderen Datentyp zugewiesen werden kann.
In [ ]:
alter = 29
print(alter, type(alter))
alter = 'alt'
print(alter, type(alter))
In [ ]:
alter = 29
isinstance(alter, int)
In [ ]:
isinstance(alter, str)
Ich empfehle ausdrücklich, mindestens eine der folgenden Ressourcen zur Vertiefung zu lesen!