Als erstes brauchen wir natürlich die Möglichkeit, Zahlen und Wörter (Strings, Zeichenketten) in entsprechenden Variablen zu speichern. Dann erweitern wir diese zu Kombinationen, also Listen, Tupel und Mengen von Variablen sowie sogenannten Dictionaries (Lexika), welche man sich tatsächlich wie ein Lexikon oder Index vorstellen kann.

Die wichtigsten Datentypen in Python

• Zahlen / numerische Datentypen
• Strings / Zeichenketten
• Listen
• Tupel
• Mengen
• Dictionary

Benennung von Variablen

Ok, man kann seine Python-Variablen ziemlich beliebig benennen, es gibt aber ein paar Regeln. Die wichtigste Regel ist natürlich, eure Variablen sinnvoll zu benennen, so dass ihr euch noch zurecht findet, wenn ihr den Code in einem Jahr nochmal anschaut.

Ansonsten gelten folgende Einschränkungen:

• Es sind nur Buchstaben (a-z, A-Z), Zahlen (0-9) und der Unterstrich _ erlaubt
• Variablen dürfen nicht mit einer Zahl anfangen, also 9a ist verboten
• Python beachtet Groß- und Kleinschreibung, d.h. Abc und abc sind zwei unterschiedliche Variablen
• Es gibt ein paar reservierte Schlüsselwörter, die nicht verwendet werden dürfen, da sie schon für andere Zwecke reserviert sind:

Datenanalyse mit Python - 5 Tage Minikurs

Variablendeklaration in Python

Man muss Variablen in Python nicht deklarieren, also den Datentyp mit angeben, wie das in anderen Programmiersprachen wie C der Fall ist.

In Python schreibt man also einfach a=3. Python erkennt automatisch, dass es sich um eine ganze Zahl handelt und weist a den Variablentyp int zu. In C müsste man den Typ mit angeben also int a = 3;

Die automatische Typendeklaration macht es für den Programmierer einfacher, weil er sich nicht darum kümmern muss. Es hat aber auch Nachteile, denn die explizite Angabe gibt uns mehr Kontrolle. So können in Python zum Beispiel keine Konstanten (also nicht änderbare Variablen) definiert werden. Der Programmierer muss selber darauf achten, den Wert nicht zu verändern.

Numerische Datentypen in Python

Es gibt drei Arten von Zahlen in Python

• int ist für ganze Zahlen, also z.B. 2, 3, 10, 100, 10000000, -5, -10000
• float ist für Dezimalzahlen (Kommazahlen), also z.B. 3.14, 1.9999, -0.96424, 10.23. Beachte, dass als Dezimaltrennzeichen der Punkt statt des Kommas verwendet wird (englische Konvention)
• complex ist für komplexe Zahlen, welche aus Real- und Imaginärteil bestehen. Wenn Du nicht weißt, was das ist, macht das nichts. Dann benötigst Du diesen Datentyp vermutlich auch nicht.

Die zulässige Größe ist im Gegensatz zu vielen anderen Programmiersprachen nicht beschränkt, sondern hängt nur vom Speicherplatz ab.

Wie im vorherigen Abschnitt geschrieben, müsst ihr euch in Python nicht explizit um den Typ kümmern, d.h. wenn ihr a = 3 eingebt, dann wird a eine Variable vom Typ int. Wenn ihr a = 3.0 eingebt, dann wird a eine Variable vom Typ float.

############################################
# Zahlen
############################################
 
# Integer-Variablen (ganze Zahlen) definieren
a = 3
b = -10
c = 100000000000000000000000000000000000000000000000000
d = a
a = -2
 
# Float-Variablen (Kommazahlen) definieren
fa = 3.14
fb = -0.9999999999999
# Exponentialschreibweise -5e-5 = -5 * 10^3 = -5 * 1000 = -5000
fc = -5e3
 
# complex-Variablen (komplexe Zahlen) definieren
w = 3 + 2j
z = 1j
 
# gleichzeitige Zuweisung mehrerer Variablen
i, j, k = 10, 20, 3.14

Strings / Zeichenketten

Jede Programmiersprache kann Zeichenketten in Variablen speichern, so auch Python. Und das ist genau simpel wie bei Zahlen, nämlich einfach die Zeichenkette, die ihr speichern wollt in Anführungsstriche, egal ob einfache oder doppelte, verpacken. Also s = „Hallo“ bzw.  s= ‚Hallo‘.

Für die Länge eines Strings s gibt es die Funktion len(s). Einzelne Zeichen eines Strings könnt ihr mit eckigen Klammern ansprechen, so gibt z.B. s[0] das erste Zeichen zurück oder s[0:2] die ersten zwei Zeichen. Achtung: In Python beginnt die Zählweise mit 0 und bei einer Folge wie 0:2 ist das rechte Element nicht mehr dabei, d.h. 0:2 entspricht den Werten 0 und 1, also das 1. und das 2. Zeichen des Strings

############################################
# Strings
############################################
 
s1 = "Hello"
s2 = "databraineo!"
s2 = s1
s1 = "Ola"
s3 = 'auch ein String'
 
s2[0]
s2[1:]
len(s2)
 
#Sonderzeichen
# \ wird als Start für Escape-Sequenz erkannt, \t als Tab
print('C:\temp')
# für den Backslash benötigen wir also \\
print('C:\\temp')
#raw string
s4 = r'C:\\temp'
#
#mehrzeiliger String
s5 = """abc
def
ghi"""
print(s5)
 
# einen String als Unicode definieren
s6 = u"Das hier ist Unicode"

Datenanalyse mit Python – 5 Tage Minikurs

Listen, Tupel, Mengen

Ihr wollt mehrere Elemente abspeichern, dann braucht ihr Listen, Tupel oder Mengen. Zusammengefasst sind Listen eben eine (geordnete) Liste von Elementen. Die einzelnen Elemente lassen sich über einen Index ansprechen. Tupel sind fast das gleiche wie eine Liste, nur lassen sich die einzelnen Elemente nicht mehr verändern. Mengen sind nicht geordnet und haben keine doppelten Elemente.

Listen in Python

Dabei sind Listen sicherlich die wichtigste Struktur. Eine Liste wird mit eckigen Klammern definiert und besteht aus einer Folge von Elementen, die sogar von unterschiedlichen Typen sein können. Also zum Beispiel l1 = [1, 2, 3] oder l2 = [„grün“, 3.14, 2].

Die Elemente der Liste lassen sich über die Indizes ansprechen. Im Prinzip genauso wie die einzelnen Zeichen eines Strings. Und wieder gilt, dass wir bei 0 mit dem Zählen anfangen. Also l1[0] gibt das 1. Element zurück, in dem Fall 1. l2[0] würde „grün“ zurückgeben.

Listen können beliebige Datentypen enthalten, auch wieder Listen. l3 = [[1,2], „grün“, [3.0,3.1,3.2]]

Vorsicht beim Kopieren von Listen: Wenn man mit l2 = l1 eine Liste „kopiert“, wird keine echte Kopie gemacht, sondern nur der sogenannte Zeiger auf die Liste kopiert. Verändere ich die ursprüngliche Liste l1, dann verändert sich damit auch l2. Um eine echte Kopie zu machen, verwendet man l2 = l1.copy().

Tupel in Python

Tupel sind im Gegensatz zu Listen nicht mehr veränderbar, d.h. im Nachhinein können keine Elemente eines Tupels geändert werden. Ansonsten verhalten sie sich genauso wie Listen. Tupel werden mit runden Klammern initialisiert, also z.B. t1 = (1, 2, 3).

Mit t1[1] greift ihr auf das 2. Element zurück, hier also 2. Nicht erlaubt ist t1[1] = 9, da wie eben geschrieben, Tupel nicht veränderbar sind.

Mengen in Python

Vermutlich eher ein selten genutztes Konstrukt. Mengen enthalten eindeutige Elemente, also keine doppelten Einträge, und sind nicht geordnet. D.h. im Gegensatz zu Listen oder Tupel können wir die Elemente nicht mit einem Index abrufen. Mengen werden in Python mit geschweiften Klammern gebildet. also z.B. m1 = { „grün“, „rot“, „blau“}

############################################
# Listen, Tupel, Mengen
############################################
alist = [1,2,3,4]
alist
atuple = (1,2,3,3)
atuple
aset = {'grün','gelb','rot','rot'}
aset
 
# Elemente einer Liste können geändert werden
alist[2] = 9.34
alist[3] = 'grün'
alist[0] = ['gelb',-2e-2,5]
len(alist)
 
# Elemente eines Tuples können nicht geändert werden
atuple[0] = 9
btuple = atuple + ('grün',2.1,[-3,-2,0])
btuple[6]
btuple[6][2] = 9
len(btuple)
 
# Mengen sind nicht geordnet
aset[0]
'grün' in aset
aset.add('lila')
aset.remove('grün')
 
# Listen werden nicht kopiert, sondern zeigen auf das gleiche Objekt
blist = [1,2,3]
clist = blist
clist[0]
blist[0] = 9
clist[0]
# echte Kopien erstellen
dlist = blist.copy()
dlist = list(blist)

Python Dictionaries

Ein Dictionary kann man sich, wie der Name sagt, als Lexikon vorstellen, d.h. es gibt einen Schlüsselbegriff (key), dem etwas zugeordnet wird. Beim normalen Lexikon wäre es eine Erklärung des Schlüsselbegriffs, beim dictionary können es aber beliebige Datentypen sein. Wie schon bei Listen, Tupeln oder Mengen können auch dictionaries verschachtelt sein.

Ein Dictionary wird wie eine Menge per geschweiften Klammern definiert, allerdings bestehen die Einträge aus dem Schlüssel, gefolgt von Doppelpunkt und dann dem Wert.

Die einzelnen Einträge werden dann anstatt über einen Index über den Schlüssel angesprochen. So können die Einträge auch geändert werden. Wenn man alle Werte des Dictionaries dic als Liste bekommen will, benutzt man die Funktion values, also list(dic.values()). Beachtet, dass wir noch list davor schreiben müssen, um auch wirklich eine Liste zu bekommen. Genauso funktioniert es mit den Schlüsseln, also list(dic.keys()).

Sehr praktisch sind dictionaries, wenn mehrere Eigenschaften eines Objekts gespeichert werden sollen. Zum Beispiel soll für einen Kunden Name, Vorname und Alter gespeichert werden.

############################################
# Dictionaries
############################################
dic = { 'E1':'Sofa','E2':'Stuhl','E3':'Tisch' }
print(dic)
dic['E1']
dic[0]
dic.values()
dic.keys()
 
dic = { 1:'Sofa',2:'Stuhl',3:'Tisch' }
dic[1]
 
 
Kunde = {'Vorname':'Kevin', 'Name': 'Chalupke', 'Alter': 32}
print(Kunde['Name'])
print(Kunde['Alter'])
Kunde['Alter'] = 33

Den Datentyp einer Variable abfragen

Um zu prüfen, welchen Datentyp eine Variable x hat, gibt es den Befehl type(x). Mit isinstance(x,typ) wird geprüft, ob x vom angegebenen Typ ist. Es wird also True oder False zurückgegeben

Python Datentypen umwandeln

Das Umwandeln von Datentypen in Python ist ziemlich intuitiv. Man benutzt einfach den Datentyp als Funktion und als Parameter kommt die umzuwandelnde Variable.

• int zu float: float(3)
• float zu int: int(3.14)
• int zu string: str(3)
• string zu int: int("3")
• float zu string: str(3.14)
• string zu float: float("3.14")

Auch die drei zusammengesetzten Typen List, Tuple und Set lassen sich so ineinander überführen

• list zu tuple: tuple(l)
• tuple zu list: list(t)
• list zu set: set(l)
• set zu list: list(s)
• tuple zu set: set(t)
• set zu tuple: tuple(s)

Nur das Dictionary fällt aus der Reihe, denn Python kann ja nicht wissen, wie es z.B. eine Liste in ein Dictionary umwandeln soll, denn es fehlen die Schlüssel. Andersherum funktioniert es: aus einem Dictionary kann man eine Liste/Tupel/Menge machen, allerdings werden nur die Schlüssel verwendet.

############################################
# Datentypen umwandeln 
############################################
 
# int schneidet die Dezimalstellen ab
x = 3.14
int(x)
int(3.6)
int(-0.9)
 
 
float(3)
float("3.14")
 
int("3")
# ein String einer Dezimalzahl kann nicht in einen int umgewandelt werden
int("3.14")
int(float("3.14"))
 
str(10)
str(10.34)
 
# Listen, Tupel und Mengen lassen sich ineinander überführen
tuple(alist)
list(atuple)
set(alist)
set(atuple)
list(aset)
tuple(aset)
 
 
# Wenn man ein Dictionary in eine Liste/Tupel/Menge umwandelt, wird
# der Schlüssel (Key) in das entsprechende Objekt umgewandelt
list(dic)
tuple(dic)
set(dic)
list(Kunde)

So, das war es mit den wichtigsten Datentypen in Python. Eigentlich nicht so schwierig, oder?

Hat Euch der Beitrag gefallen? Dann schreibt mir einen Kommentar oder teilt den Artikel, damit andere auch etwas davon haben.

Happy coding,

Euer Holger

Datenanalyse mit Python - 5 Tage Minikurs