2.Datentypen und Datenstrukturen: Difference between revisions
(→Listen) |
m (→Tupel) |
||
(25 intermediate revisions by 3 users not shown) | |||
Line 1: | Line 1: | ||
__TOC__ | __TOC__ | ||
== Datentypen == | |||
In Python unterscheidet man vier verschiedene Datentypen (Klassen): | In Python unterscheidet man vier verschiedene Datentypen (Klassen): | ||
Line 19: | Line 19: | ||
Der Datentyp kann durch den ''type''-Befehl abgefragt werden. | Der Datentyp kann durch den ''type''-Befehl abgefragt werden. | ||
<br> Beispiel: | |||
<syntaxhighlight lang="python"> | |||
sequence = "ACGT" | |||
result = type(sequence) | |||
print(result) | |||
# Output: <class 'str'> | |||
</syntaxhighlight> | |||
== Datenstrukturen == | |||
Man unterscheidet zwischen drei verscheiden Datenstrukturen: | Man unterscheidet zwischen drei verscheiden Datenstrukturen: | ||
Listen, Dictionary und Tupel. Alle diese Datenstrukturen stellen Organisationsformen | Listen, Dictionary und Tupel. Alle diese Datenstrukturen stellen Organisationsformen | ||
von Daten in Python dar. Das heißt sie | 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. | indem sie diese in geeigneter Form darstellen und speichern. | ||
Sie | Sie unterscheiden sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen. | ||
=== Listen === | |||
<syntaxhighlight lang="python"> | |||
#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] | |||
</syntaxhighlight> | |||
==== 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 | |||
<syntaxhighlight lang="python"> | |||
# 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] | |||
</syntaxhighlight> | |||
===== Liste verändern ===== | |||
* wie Variablen sind auch Listen veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden | |||
#Befehl: | ====== 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) | |||
<syntaxhighlight lang="python"> | |||
# Befehl: | |||
liste[Position]= neuer_Wert | |||
# | # Beispiel_3: | ||
tier_1=[ | 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] | |||
</syntaxhighlight> | |||
====== 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) | |||
<syntaxhighlight lang="python"> | |||
# Befehl: | |||
liste = liste + [neues_Element] | |||
# Beispiel_4: | |||
tier_1 = ['Hund', 100, 399, 99, True] | |||
print(tier_1) | print(tier_1) | ||
print( | tier_1 = tier_1 + ["Elefant"] | ||
print( | print(tier_1) | ||
# output | |||
# ['Hund', 100, 399, 99, True] | |||
# ['Hund', 100, 399, 99, True, 'Elefant'] | |||
</syntaxhighlight> | |||
====== 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 | |||
<syntaxhighlight lang="python"> | |||
# 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] | |||
</syntaxhighlight> | |||
===== 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 | |||
<syntaxhighlight lang="python"> | |||
# 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) | |||
</syntaxhighlight> | |||
output | output | ||
['Hund', 100, 399, 99, True | <syntaxhighlight lang="python"> | ||
['Hund', 100, 399, 99, True, 'Katze', 60, 249, 99, True] | |||
[' | ['Hund', 100, 399, 99, True, 'Hund', 100, 399, 99, True] | ||
</syntaxhighlight> | |||
===== | ===== Listen in Listen ===== | ||
* haben | * 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) | |||
<syntaxhighlight lang="python"> | |||
# 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 | |||
</syntaxhighlight> | |||
=== Dictionaries === | |||
<syntaxhighlight lang="python"> | |||
# 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 | |||
</syntaxhighlight> | |||
==== 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) | |||
<syntaxhighlight lang="python"> | |||
# 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} | |||
</syntaxhighlight> | |||
====== 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) | |||
<syntaxhighlight lang="python"> | |||
# 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'} | |||
</syntaxhighlight> | |||
====== 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) | |||
<syntaxhighlight lang="python"> | |||
# 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'} | |||
</syntaxhighlight> | |||
=== Tupel === | |||
<syntaxhighlight lang="python"> | |||
# 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 | |||
</syntaxhighlight> | |||
==== 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) | |||
<syntaxhighlight lang="python"> | |||
# 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') | |||
</syntaxhighlight> | |||
== | == Literatur == | ||
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2 | |||
Latest revision as of 14:57, 28 May 2023
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