2.Datentypen und Datenstrukturen

Datentypen

In Python unterscheidet man vier verschiedene Datentypen (Klassen):

Datentyp	Abkürzung	Bedeutung	Beispiel
String	str	Zeichenkette	"abc"
Integer	int	Ganze Zahl	1
Float	float	Dezimalzahl	1.0
Boolean	bool	Wahrheitsgehalt	True, False

Der Datentyp kann durch den type-Befehl abgefragt werden.
Beispiel:

‎

sequence = "ACGT"
result = type(sequence)
print(result)
# Output: <class 'str'>
‎

Datenstrukturen

Man unterscheidet zwischen drei verscheiden Datenstrukturen: Listen, Dictionary und Tupel. Alle diese Datenstrukturen stellen Organisationsformen von Daten in Python dar. Das heißt sie erleichtern vor allem die Handhabung größerer Datenmengen, indem sie diese in geeigneter Form darstellen und speichern. Sie unterscheiden sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

Listen

‎

#Befehl:
liste = ['string', variable, 1, 2.0, True]

# Beispiel_1:

hund = ['Hund', 100, 399, 99, True]
katze = ['Katze', 60, 249, 99, True]
fisch = ['Fisch', 3, 1, 50, False]
 
print(hund)
print(katze)
print(fisch)

# output
# ['Hund', 100, 399, 99, True]
# ['Katze', 60, 249, 99, True]
# ['Fisch', 3, 1, 50, False]
‎

Funktion

• haben dieselbe Funktion wie Listen im echten Leben
• mit Listen können mehrere Werte unter einem Namen abgespeichert werden
• macht das Programm übersichtlicher und erleichtert die Arbeit, weil nicht jeder einzelne Wert mit einem eigenen Variablennamen gespeichert werden muss

Syntax

• die Liste erhält einen Namen, welcher wie eine Variable durch ein Gleichheitszeichen den Elementen der Liste zugeordnet wird
• die Elemente der Liste werden in eckige Klammern gesetzt und müssen mit einem Komma voneinander getrennt werden
• in einer Liste können verschiedene Datentypen auf einmal vorkommen

Liste ausgeben lassen

• die ganze Liste lässt sich durch einen print-Befehl ausgeben (s. Beispiel_1)

einzelne Elemente der Liste ausgeben lassen

• auch einzelne Elemente der Liste können ausgegeben werden (s. Beispiel_2)
• dabei wird die Position des auszugebenden Elements durch eine Indexzahl in eckigen Klammern nach dem Listennamen angegeben
• Achtung: grundsätzlich zählt man von 0 ausgehend, d.h. das erste Element in der Liste besitzt die Position 0, das zweite die Position 1 etc.
• es kann auch von hinten gezählt werden, dabei besitzt das erste Element (welches von vorne gezählt das letzte wäre) die Position -1 usw.

Bereich der Liste ausgeben lassen

• es lässt sich auch ein bestimmter Bereich der Liste ausgeben, wobei die Positionen der Elemente durch einen Doppelpunkt getrennt werden (s.Beispiel_2)
• die erste Indexzahl schließt die Position des Elements ein, welche ausgegeben wird (engl. inclusive)
• die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird (engl. exclusive)
• um die Syntax des Befehls zu verstehen, ist es sinnvoll, die verschiedenen Möglichkeiten einmal selbst auszuprobieren und die Aufgaben 4 und 5 auf dem Aufgabenblatt zu bearbeiten

‎

 # Befehl:
 print(liste[Position])
 
 # Beispiel_2:
 tier_1 = ["Hund", 100, 399, 99, True]
 
 print(tier_1[0])
 print(tier_1[1])
 print(tier_1[-1])
 print(tier_1[0:4])

# output
# Hund
# 100
# True
# ['Hund', 100, 399, 99]
‎‎

Liste verändern

• wie Variablen sind auch Listen veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

Element in Liste verändern

• Elemente der Liste lassen sich verändern, genau wie auch der Wert von Variablen neu definiert werden kann
• dafür schreibt man den Namen der Liste, dahinter eine Indexzahl in eckigen Klammern, wobei die Indexzahl die Position des zu verändernden Elements angibt
• die Zuweisung des neuen Werts erfolgt durch ein Gleichheitszeichen und den neuen Wert, den das Element der Liste annehmen soll (s. Beispiel_3)

‎

 # Befehl:
 liste[Position]= neuer_Wert
 
 # Beispiel_3:
 tier_1 = ['Hund', 100, 399, 99, True]
 print(tier_1)
 tier_1[0] = "Tiger"
 tier_1[1] = 500
 print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Tiger', 500, 399, 99, True]
‎

Element zu einer Liste hinzufügen

• Listen können erweitert werden
• dazu schreibt man den Namen der Liste ein Gleichheitszeichen, erneut den Namen der Liste, ein „+“ und das Element das hinzugefügt werden soll in eckigen Klammern (s. Beispiel_4)

‎

 # Befehl:
 liste = liste + [neues_Element]
 
 # Beispiel_4:
 tier_1 = ['Hund', 100, 399, 99, True]
 print(tier_1)
 tier_1 = tier_1 + ["Elefant"]
 print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Hund', 100, 399, 99, True, 'Elefant']
‎

Element aus Liste löschen

• Elemente lassen sich mit dem del-Befehl aus der Liste entfernen (s. Beispiel_5)
• nach „del“ folgt der Listenname und die Position des zu löschenden Elements in eckigen Klammern

# Befehl:
del liste[Position]
 
# Beispiel_5:
tier_1 = ['Hund', 100, 399, 99, True]
del tier_1[1]
print(tier_1)

# Output: ['Hund', 399, 99, True]

Addition und Multiplikation von Listen

• Listen können miteinander addiert oder mit Zahlen multipliziert werden

(s. Beispiel_6)

• werden zwei Listen addiert, wird der Inhalt der Listen hintereinander ausgegeben
• wird eine Liste mit einer Zahl multipliziert, wird der Inhalt der Liste entsprechend oft hintereinander ausgegeben

‎

# Beispiel_6:
tier_1 = ['Hund', 100, 399, 99, True]
tier_2 = ['Katze', 60, 249, 99, True]
tier_3 = ['Fisch', 3, 1, 50, False]
 
print(tier_1 + tier_2)
print(tier_1 * 2)
‎

output

‎

 ['Hund', 100, 399, 99, True, 'Katze', 60, 249, 99, True]
 ['Hund', 100, 399, 99, True, 'Hund', 100, 399, 99, True]
‎

Listen in Listen

• Elemente einer Liste können selbst eine Liste sein, so erhält man Listen in einer Liste (s. Beispiel_7, engl. nested lists)
• es entsteht eine zweidimensionale Liste mit einer übergeordneten Liste (im Beispiel: alle_tiere) und den untergeordneten Listen (tier_1, tier_2, tier_3)
• auf die Elemente der übergeordneten Liste lässt sich wie oben gezeigt zugreifen
• möchte man nur auf ein Element der untergeordneten Liste zugreifen, sind zwei Indexzahlen notwendig
• die erste Indexzahl gibt die Position des Elements in der übergeordneten Liste an
• die zweite Indexzahl gibt die Position des Elements in der untergeordneten Liste an (s. Beispiel_7)

‎

# Befehl
print(liste[Position][Position])

# Beispiel_7:

tier_1 = ['Hund', 100, 399, 99, True]
tier_2 = ['Katze', 60, 249, 99, True]
tier_3 = ['Fisch', 3, 1, 50, False]

alle_tiere = [tier_1, tier_2, tier_3]
print(alle_tiere)
print(alle_tiere[0])
print(alle_tiere[0][0])

# output
# [['Hund', 100, 399, 99, True], ['Katze', 60, 249, 99, True], ['Fisch', 3, 1, 50, False]]
# ['Hund', 100, 399, 99, True]
# Hund
‎

Dictionaries

‎

# Befehl
dictionary = {'key_1': Element_1, 'key_2': Element_2}

# Beispiel_1:

buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
 
print(buch_1) 
print(buch_1["Buch"])
print(buch_1["Autor"])
print(buch_1["Preis"])

# output
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
# Der Herr der Ringe
# Tolkien
# 45
‎

Funktion

Listen sind zwar geeignet, um größere Mengen an Daten in übersichtlicher und gut manipulierbarer Weise abzuspeichern, haben aber einen entscheidenden Nachteil: Um auf ein Element in einer Liste zugreifen zu können, ist es notwendig die Position des Elements in der Liste zu kennen. Bei kürzeren Listen lässt sich vielleicht noch der Überblick behalten. Sobald Listen aber eine gewisse Zahl an Elementen überschreiten, in einem Programm mehrere Listen verwendet werden oder sogar Listen in Listen gespeichert sind, ist jeglicher Versuch sich die Positionen der Elemente zu merken vergebens. Hier bringen die sogenannten Dictionaries den entscheidenden Vorteil. Dictionaries funktionieren wie Listen, wenn es darum geht, Informationen abzuspeichern. Doch der Zugriff auf die Elemente erfolgt nicht durch eine Indexnummer, sondern über ein sogenannten key oder Schlüsselbegriff. Um auf die Elemente über einen key zugreifen zu können, wird den Elementen im Dictionary jeweils ein Schlüsselbegriff zugeordnet.

Syntax

• nach dem Namen des Dictionary und dem Gleichheitszeichen folgt eine geschweifte Klammer {}
• danach folgt der Key, dabei kann es sich um ein integer, float, bool oder string handeln
• darauf folgt das Listenelement, getrennt durch einen Doppelpunkt vom Key und durch ein Komma vom nächsten Key-Element Paar

Dictionary ausgeben lassen

• das ganze Dictionary lässt sich durch einen print-Befehl ausgeben (s. Beispiel_1)

einzelne Elemente des Dictionaries ausgeben

• der Zugriff erfolgt durch den key
• die Syntax ist analog zum Abruf der Elemente einer Liste, nur das statt der Indexzahl der key in die eckige Klammer geschrieben wird (s.Beispiel_1)

Dictionary verändern

• wie Listen sind auch Dictionaries veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

Element in Dictionary verändern

• die Syntax ist analog zur Veränderung eines Elements in Listen, nur hier wird der key, statt der Position in die eckigen Klammern hinter dem Namen des Dictionaries gesetzt (s. Beispiel_2)

‎

# Befehl: 
dictionary[(bestehender)key] = "neuer Wert"
# Beispiel_2:
buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
buch_1["Preis"] = 23
print(buch_1)

# output
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 23}
‎

Element zum Dictionary hinzufügen

• um Elemente zum Dictionary hinzuzufügen, ist es notwendig auch gleichzeitig einen key für das Element zu definieren
• nach dem Listennamen und dem Key in eckigen Klammern folgt ein Gleichheitszeichen und der Wert des neuen Elements (s. Beispiel_3)

‎

# Befehl:
dictionary["(neuer) key"] = "neues Element"
 
# Beispiel_3:
buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
 
buch_1["Erscheinungsjahr"] = 1954
buch_1["Bewertung"] = "sehr gut"
print(buch_1)

# output 
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45, 'Erscheinungsjahr': 1954, 'Bewertung':   'sehr gut'}
‎

Element aus Dictionary löschen

• analoger Aufbau zum del-Befehl bei Listen
• hier wird wieder anstatt der Indexzahl der key in die eckigen Klammern gesetzt (s. Besipiel_4)

‎

# Befehl:
del dictionary[key] 
 
# Beispiel_4:
buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
 
del buch_1["Preis"]
print(buch_1)

# output 
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien'}
‎

Tupel

‎

# Befehl:
tupel = (element_1, element_2)

# Beispiel_1:
tier_1 = ("Hund", 100, 399, 99, True)
print(tier_1)
print(tier_1[0])

# output
# ('Hund', 100, 399, 99, True)
# Hund
‎

Funktion

• Tupel sind eine unveränderliche Datenstruktur d.h. die Elemente eines Tupels sind im Gegensatz zu Listen und Dictionaries nicht veränderbar oder löschbar
• sie können jedoch ergänzt werden
• Tupel werden genutzt, um Daten zu speichern, die nicht geändert werden sollen (z. B. Konstanten)
• man könnte diese natürlich auch in Dictionaries und Listen speichern, so geht man aber sicher, dass die Daten nicht ausversehen geändert werden

Syntax

• die Erstellung von Tupeln ist analog zur Erstellung von Listen, nur werden hier runde Klammern benötigt (s. Beispiel_1)
• der Zugriff auf die Elemente des Tupels ist analog zur Syntax bei Listen (s. Beispiel_1)

Tupel ausgeben lassen

• sowohl das Ausgeben des ganzen Tupels, als auch der einzelnen Elemente, folgt der selben Syntax der Listen

Erweiterung eines Tupels

• auch hier ist die Syntax analog zur Erweiterung von Listen
• das neue Element muss selbst ein Tupel sein, um es zum Tupel hinzufügen zu können
• dazu muss das neue Element erst als Tupel abgespeichert werden
• um ein neues Element als Tupel zu speichern, wird ein Tupel mit nur einem Element erstellt
• nun kann dieser Tupel dem alten hinzugefügt werden (s. Beispiel_2)

‎

# Beispiel_2:
tier_1 = ("Hund", 100, 399, 99, True)
farbe = ("braun",)
tier_1 = tier_1 + farbe
print(tier_1)

# output
# ('Hund', 100, 399, 99, True, 'braun')
‎

Literatur

Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2