Python Datenstrukturen Tutorial

Datenstrukturen sind eine Möglichkeit, Daten so zu organisieren und zu speichern, dass auf sie zugegriffen und effizient mit ihnen gearbeitet werden kann. Sie definieren die Beziehung zwischen den Daten und die Operationen, die mit den Daten durchgeführt werden können. Es gibt viele verschiedene Arten von Datenstrukturen, die es Datenwissenschaftlern und Computeringenieuren erleichtern, sich auf die Lösung größerer Probleme zu konzentrieren, anstatt sich in den Details der Datenbeschreibung und des Datenzugriffs zu verlieren.

In diesem Lernprogramm lernst du die verschiedenen Python-Datenstrukturen kennen und siehst, wie sie implementiert werden:

• Abstrakte Datentypen und Datenstrukturen
• Primitive Datenstrukturen
  • Ganze Zahlen
  • Schwimmer
  • Strings
  • Boolesche
• Nicht-primitive Datenstrukturen
  • Arrays
  • Listen
  • Tupel
  • Wörterbuch
  • Sets
  • Dateien

Im kostenlosen Kurs "Einführung in Python für Data Science " von DataCamp erfährst du mehr über die Verwendung von Python speziell im Kontext von Data Science. Der Kurs gibt eine Einführung in die grundlegenden Konzepte von Python. Mit ihm lernst du Methoden, Funktionen und das NumPy-Paket kennen.

Abstrakte Datentypen und Datenstrukturen

Wie du in der Einleitung gelesen hast, helfen dir Datenstrukturen dabei, dich auf das große Ganze zu konzentrieren, anstatt dich in den Details zu verlieren. Dies wird als Datenabstraktion bezeichnet.

Datenstrukturen sind eigentlich eine Implementierung von abstrakten Datentypen oder ADT. Diese Implementierung erfordert eine physische Sicht auf die Daten unter Verwendung einer Sammlung von Programmierkonstrukten und grundlegenden Datentypen.

Generell lassen sich Datenstrukturen in der Informatik in zwei Kategorien einteilen: primitive und nicht-primitive Datenstrukturen. Erstere sind die einfachsten Formen der Datendarstellung, während letztere fortschrittlicher sind: Sie enthalten primitive Datenstrukturen innerhalb komplexerer Datenstrukturen für spezielle Zwecke.

Primitive Datenstrukturen

Dies sind die primitivsten oder grundlegendsten Datenstrukturen. Sie sind die Bausteine für die Datenmanipulation und enthalten reine, einfache Werte von Daten. Python hat vier primitive Variablentypen:

• Ganze Zahlen
• Schwimmer
• Strings
• Boolesche

In den nächsten Abschnitten erfährst du mehr über sie!

Ganze Zahlen

Du kannst eine ganze Zahl verwenden, um numerische Daten darzustellen, genauer gesagt, ganze Zahlen von negativ unendlich bis unendlich, wie 4, 5 oder -1.

Schwimmer

"Float" steht für "Gleitkommazahl". Du kannst sie für rationale Zahlen verwenden, die normalerweise mit einer Dezimalzahl enden, wie z.B. 1,11 oder 3,14.

Sieh dir das folgende DataCamp Light Chunk an und probiere einige der Ganzzahl- und Fließkommaoperationen aus!

Beachte, dass du in Python den Typ der Variablen oder deiner Daten nicht explizit angeben musst. Das liegt daran, dass sie eine dynamisch typisierte Sprache ist. Dynamisch typisierte Sprachen sind Sprachen, in denen der Typ der Daten, die ein Objekt speichern kann, veränderbar ist.

String

Strings sind Sammlungen von Alphabeten, Wörtern oder anderen Zeichen. In Python kannst du Zeichenketten erstellen, indem du eine Folge von Zeichen in ein Paar einfacher oder doppelter Anführungszeichen einschließt. Zum Beispiel: 'cake', "cookie", etc.

Du kannst auch die + Operationen auf zwei oder mehr Strings anwenden, um sie zu verketten, so wie im folgenden Beispiel:

x = 'Cake'
y = 'Cookie'
x + ' & ' + y

'Cake & Cookie'

Hier sind einige andere grundlegende Operationen, die du mit Zeichenketten durchführen kannst. Zum Beispiel kannst du * verwenden, um eine Zeichenkette eine bestimmte Anzahl von Malen zu wiederholen:

# Repeat
x * 2

'CakeCake'

Du kannst auch Strings zerschneiden, das heißt, du wählst Teile von Strings aus:

# Range Slicing
z1 = x[2:] 

print(z1)

# Slicing
z2 = y[0] + y[1] 

print(z2)

ke
Co

Beachte, dass Zeichenketten auch aus alphanumerischen Zeichen bestehen können, aber dass die Operation + immer noch zum Verketten von Zeichenketten verwendet wird.

x = '4'
y = '2'

x + y

'42'

Python hat viele eingebaute Methoden oder Hilfsfunktionen, um Zeichenketten zu manipulieren. Das Ersetzen einer Teilzeichenkette, das Großschreiben bestimmter Wörter in einem Absatz, das Finden der Position einer Zeichenkette innerhalb einer anderen Zeichenkette sind einige gängige Manipulationen von Zeichenketten. Schau dir einige von ihnen an:

• Zeichenketten groß schreiben

str.capitalize('cookie')

'Cookie'

• Ermittelt die Länge einer Zeichenkette in Zeichen. Beachte, dass auch die Leerzeichen zum Endergebnis zählen:

str1 = "Cake 4 U"
str2 = "404"
len(str1)

8

• Prüfen, ob eine Zeichenkette nur aus Ziffern besteht

str1.isdigit()

False

str2.isdigit()

True

• Ersetze Teile von Strings durch andere Strings

str1.replace('4 U', str2)

'Cake 404'

• Teilzeichenketten in anderen Zeichenketten finden; Gibt den niedrigsten Index oder die niedrigste Position innerhalb der Zeichenkette zurück, an der die Teilzeichenkette gefunden wird:

str1 = 'cookie'
str2 = 'cook'
str1.find(str2)

0

Die Teilzeichenkette

'cook'

befindet sich am Anfang von

'cookie'

. Infolgedessen verweist du auf die Position innerhalb

'cookie'

an dem du diese Teilzeichenkette findest. In diesem Fall,

0

wird zurückgegeben, weil du mit dem Zählen der Positionen bei 0 beginnst!

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

Ähnlich ist es mit der Teilzeichenkette

'cook'

befindet sich an Position 12 innerhalb

'I got you a cookie'

. Denke daran, dass du bei 0 beginnst und dass Leerzeichen zu den Positionen zählen!

Eine ausführliche Liste der String-Methoden in Python findest du hier.

Boolesche

Dieser eingebaute Datentyp kann die Werte True und False annehmen, was sie oft austauschbar mit den ganzen Zahlen 1 und 0 macht. Boolesche Ausdrücke sind nützlich in bedingten und vergleichenden Ausdrücken, wie in den folgenden Beispielen:

x = 4
y = 2
x == y

False

x > y

True

x = 4
y = 2
z = (x==y) # Comparison expression (Evaluates to false)
if z: # Conditional on truth/false value of 'z'
    print("Cookie")
else: print("No Cookie")

No Cookie

Datentyp-Konvertierung

Manchmal kommt es vor, dass du an dem Code eines anderen arbeitest und zum Beispiel eine Ganzzahl in eine Fließkommazahl oder umgekehrt umwandeln musst. Oder du stellst fest, dass du eine ganze Zahl verwendet hast, obwohl du eigentlich eine Fließkommazahl brauchst. In solchen Fällen kannst du den Datentyp von Variablen umwandeln!

Um den Typ eines Objekts in Python zu prüfen, verwendest du die eingebaute Funktion type(), so wie in den folgenden Codezeilen:

i = 4.0
type(i)

float

Wenn du den Typ einer Entität von einem Datentyp in einen anderen änderst, nennt man das "Typecasting". Es sind zwei Arten von Datenkonvertierungen möglich: implizite, die als Coercion bezeichnet werden, und explizite, die oft als Casting bezeichnet werden.

Implizite Datentypkonvertierung

Dies ist eine automatische Datenkonvertierung, die der Compiler für dich übernimmt. Sieh dir die folgenden Beispiele an:

# A float
x = 4.0 

# An integer
y = 2 

# Divide `x` by `y`
z = x/y

# Check the type of `z`
type(z)

float

Im obigen Beispiel musstest du den Datentyp von y nicht explizit ändern, um eine Division von Float-Werten durchzuführen. Der Compiler hat das implizit für dich getan.

Das ist ganz einfach!

Explizite Datentypkonvertierung

Diese Art der Datentypumwandlung ist benutzerdefiniert, d.h. du musst dem Compiler explizit mitteilen, dass du den Datentyp bestimmter Entitäten ändern möchtest. Schau dir den folgenden Code an, um dies zu verstehen:

x = 2
y = "The Godfather: Part "
fav_movie = y + x

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in ()
      1 x = 2
      2 y = "The Godfather: Part "
----> 3 fav_movie = y + x


TypeError: Can't convert 'int' object to str implicitly

Im obigen Beispiel hast du eine Fehlermeldung erhalten, weil der Compiler aufgrund der gemischten Datentypen nicht versteht, dass du versuchst, eine Verkettung oder Addition durchzuführen. Du hast eine ganze Zahl und eine Zeichenkette, die du zusammenzählen willst.

Es gibt eine offensichtliche Diskrepanz.

Um dieses Problem zu lösen, musst du zuerst int in string umwandeln, um dann eine Verkettung durchführen zu können.

Beachte, dass es nicht immer möglich ist, einen Datentyp in einen anderen zu konvertieren. Einige integrierte Datenkonvertierungsfunktionen, die du hier verwenden kannst, sind: int(), float(), und str().

x = 2
y = "The Godfather: Part "
fav_movie = (y) + str(x)
print(fav_movie)

The Godfather: Part 2

Nicht-primitive Datenstrukturen

Nicht-primitive Typen sind die anspruchsvollen Mitglieder der Datenstrukturfamilie. Sie speichern nicht nur einen Wert, sondern eine Sammlung von Werten in verschiedenen Formaten.

In der traditionellen Informatik werden die nicht-primitiven Datenstrukturen unterteilt in:

• Arrays
• Listen
• Dateien

Array

Zunächst einmal sind Arrays in Python eine kompakte Methode, um grundlegende Datentypen zu sammeln: Alle Einträge in einem Array müssen denselben Datentyp haben. Allerdings sind Arrays in Python im Gegensatz zu anderen Programmiersprachen wie C++ oder Java nicht sehr beliebt.

Wenn man in Python von Arrays spricht, meint man in der Regel eigentlich Listen. Es gibt jedoch einen grundlegenden Unterschied zwischen ihnen, und den wirst du gleich sehen. Für Python sind Arrays eine effizientere Möglichkeit, eine bestimmte Art von Liste zu speichern. Diese Art von Liste hat jedoch Elemente desselben Datentyps.

In Python werden Arrays durch das Modul array unterstützt und müssen importiert werden, bevor du sie initialisieren und verwenden kannst. Die in einem Array gespeicherten Elemente sind an ihren Datentyp gebunden. Der Datentyp wird bei der Erstellung des Arrays angegeben und durch einen Typcode spezifiziert, der aus einem einzelnen Zeichen besteht, wie das I im Beispiel unten:

import array as arr
a = arr.array("I",[3,6,9])
type(a)

array.array

Auf der Python Array-Dokumentationsseite findest du weitere Informationen über die verschiedenen verfügbaren Codetypen und die Funktionen des Moduls array.

Liste

Listen werden in Python verwendet, um Sammlungen von heterogenen Elementen zu speichern. Sie sind veränderbar, das heißt, du kannst ihren Inhalt ändern, ohne ihre Identität zu verändern. Du erkennst Listen an den eckigen Klammern [ und ], die durch ein Komma getrennte Elemente enthalten ,. Listen sind in Python integriert: Du musst sie nicht extra aufrufen.

x = [] # Empty list
type(x)

list

x1 = [1,2,3]
type(x1)

list

x2 = list([1,'apple',3])
type(x2)

list

print(x2[1])

apple

x2[1] = 'orange'
print(x2)

[1, 'orange', 3]

Hinweis: Wie du im obigen Beispiel mit x1 gesehen hast, können Listen auch homogene Elemente enthalten und erfüllen damit die Speicherfunktion eines Arrays. Das ist in Ordnung, es sei denn, du möchtest einige spezielle Operationen auf diese Sammlung anwenden.

Python bietet viele Methoden, um Listen zu manipulieren und mit ihnen zu arbeiten. Das Hinzufügen neuer Elemente zu einer Liste, das Entfernen einiger Elemente aus einer Liste und das Sortieren oder Umkehren einer Liste sind gängige Listenmanipulationen. Lass uns einige von ihnen in Aktion sehen:

• Füge 11 der Liste list_num mit append() hinzu. Standardmäßig wird diese Nummer an das Ende der Liste angehängt.

list_num = [1,2,45,6,7,2,90,23,435]
list_char = ['c','o','o','k','i','e']

list_num.append(11) # Add 11 to the list, by default adds to the last position
print(list_num)

[1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Benutze insert(), um 11 an Index oder Position 0 in die Liste list_num einzufügen.

list_num.insert(0, 11)
print(list_num)

[11, 1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Entferne das erste Vorkommen von 'o' aus list_char mit Hilfe von remove()

list_char.remove('o') 
print(list_char)

['c', 'o', 'k', 'i', 'e']

• Entferne das Element mit dem Index -2 aus list_char

list_char.pop(-2) # Removes the item at the specified position
print(list_char)

['c', 'o', 'k', 'e']

list_num.sort() # In-place sorting
print(list_num)

[1, 2, 2, 6, 7, 11, 11, 23, 45, 90, 435]

list.reverse(list_num)
print(list_num)

[435, 90, 45, 23, 11, 11, 7, 6, 2, 2, 1]

Wenn du mehr über Python-Listen wissen willst, kannst du einfach durch das Tutorial 18 Most Common Python List Questions gehen!

Arrays versus Listen

Jetzt, wo du Listen in Python gesehen hast, fragst du dich vielleicht, warum du überhaupt Arrays brauchst. Der Grund dafür ist, dass sie sich in Bezug auf die Operationen, die man mit ihnen durchführen kann, grundlegend unterscheiden. Bei Arrays kannst du alle Elemente einzeln bearbeiten, was bei Listen nicht immer der Fall ist. Hier ist eine Illustration:

array_char = array.array("u",["c","a","t","s"])
array_char.tostring()
print(array_char)

array('u', 'cats')

Du konntest die Funktion tostring() der array_char anwenden, weil Python weiß, dass alle Elemente in einem Array vom gleichen Datentyp sind und sich die Operation daher bei jedem Element gleich verhält. Arrays können also sehr nützlich sein, wenn du mit einer großen Sammlung homogener Datentypen arbeitest. Da Python sich nicht die Datentypdetails jedes einzelnen Elements merken muss, sind Arrays in manchen Fällen schneller und benötigen weniger Speicherplatz als Listen.

Es lohnt sich auch, das NumPy-Array zu erwähnen, wenn wir schon beim Thema Arrays sind. NumPy-Arrays werden in der Welt der Datenwissenschaft sehr häufig verwendet, um mit mehrdimensionalen Arrays zu arbeiten. Sie sind effizienter als das Array-Modul und Python-Listen im Allgemeinen. Das Lesen und Schreiben von Elementen in einem NumPy-Array ist schneller, und sie unterstützen "vektorisierte" Operationen wie die elementweise Addition. Außerdem arbeiten NumPy-Arrays effizient mit großen spärlichen Datensätzen. Mehr dazu erfährst du im Python Numpy Array Tutorial von DataCamp.

Hier ist etwas Code, der dir den Einstieg in NumPy Array erleichtert:

import numpy as np

arr_a = np.array([3, 6, 9])
arr_b = arr_a/3 # Performing vectorized (element-wise) operations 
print(arr_b)

[ 1.  2.  3.]

arr_ones = np.ones(4)
print(arr_ones)

[ 1.  1.  1.  1.]

multi_arr_ones = np.ones((3,4)) # Creating 2D array with 3 rows and 4 columns
print(multi_arr_ones)

[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

Traditionell können Listendatenstrukturen in lineare und nichtlineare Datenstrukturen unterteilt werden. Stacks und Queues werden als "lineare Datenstrukturen" bezeichnet, während Graphs und Trees "nicht-lineare Datenstrukturen" sind. Diese Strukturen und ihre Konzepte können relativ komplex sein, werden aber aufgrund ihrer Ähnlichkeit mit Modellen aus der realen Welt häufig verwendet. In diesem Lernprogramm erhältst du einen Einblick in diese Themen.

Hinweis: In einer linearen Datenstruktur sind die Datenelemente sequentiell oder, anders gesagt, linear organisiert. Die Datenelemente werden seriell nacheinander durchlaufen und alle Datenelemente in einer linearen Datenstruktur können in einem einzigen Durchlauf durchlaufen werden. In nicht-linearen Datenstrukturen sind die Datenelemente jedoch nicht sequentiell angeordnet. Das bedeutet, dass die Elemente mit mehr als einem Element verbunden sein können, um eine besondere Beziehung zwischen diesen Elementen darzustellen. Es kann sein, dass nicht alle Daten in einer nichtlinearen Datenstruktur in einem einzigen Durchlauf durchlaufen werden.

Stapel

Ein Stapel ist ein Behälter mit Objekten, die nach dem Last-In-First-Out (LIFO)-Konzept eingefügt und entfernt werden. Stell dir ein Szenario vor, bei dem auf einer Dinnerparty ein Stapel von Tellern steht und immer wieder Teller hinzukommen oder weggenommen werden. In der Informatik wird dieses Konzept für die Auswertung von Ausdrücken und Syntaxparsing, die Planung von Algorithmen/Routinen usw. verwendet.

Stapel können in Python mit Listen implementiert werden. Wenn du einem Stapel Elemente hinzufügst, nennt man das eine Push-Operation, wenn du ein Element entfernst oder löschst, nennt man das eine Pop-Operation. Wenn du in Python mit Stapeln arbeitest, steht dir die Methode pop() zur Verfügung:

# Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack = [1,2,3,4,5] 
stack.append(6) # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 (Top)
print(stack)

[1, 2, 3, 4, 5, 6]

stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 (Top)
print(stack)

[1, 2, 3, 4]

Warteschlange

Eine Warteschlange ist ein Behälter mit Objekten, die nach dem First-In-First-Out (FIFO)-Prinzip eingefügt und entfernt werden. Ein hervorragendes Beispiel für eine Warteschlange in der realen Welt ist die Schlange an einem Fahrkartenschalter, an dem die Menschen in der Reihenfolge ihres Eintreffens bedient werden, so dass die Person, die als Erste ankommt, auch als Erste geht. Es gibt viele verschiedene Arten von Warteschlangen.

Listen sind für die Implementierung einer Warteschlange nicht effizient, da append() und pop() vom Ende einer Liste aus nicht schnell sind und Kosten für Speicherbewegungen verursachen. Auch das Einfügen am Ende und Löschen am Anfang einer Liste ist nicht so schnell, da es eine Verschiebung der Elementpositionen erfordert.

Diagramme

Ein Graph in der Mathematik und Informatik ist ein Netzwerk, das aus Knoten besteht, die miteinander verbunden sein können oder auch nicht. Die Linien oder der Weg, der zwei Knoten miteinander verbindet, wird Kante genannt. Wenn die Kante eine bestimmte Flussrichtung hat, handelt es sich um einen gerichteten Graphen, wobei die Richtungskante als Bogen bezeichnet wird. Wenn keine Richtungen angegeben werden, wird der Graph als ungerichteter Graph bezeichnet.

Das mag alles sehr theoretisch klingen und kann ziemlich komplex werden, wenn du tiefer gehst. Graphen sind jedoch ein wichtiges Konzept, vor allem in der Datenwissenschaft, und werden oft zur Modellierung realer Probleme verwendet. Soziale Netzwerke, molekulare Studien in der Chemie und Biologie, Landkarten und Empfehlungssysteme basieren alle auf den Prinzipien der Graphen- und Graphentheorie.

Hier findest du eine einfache Graphen-Implementierung mit einem Python Dictionary, die dir den Einstieg erleichtert:

graph = { "a" : ["c", "d"],
          "b" : ["d", "e"],
          "c" : ["a", "e"],
          "d" : ["a", "b"],
          "e" : ["b", "c"]
        }

def define_edges(graph):
    edges = []
    for vertices in graph:
        for neighbour in graph[vertices]:
            edges.append((vertices, neighbour))
    return edges

print(define_edges(graph))

[('a', 'c'), ('a', 'd'), ('b', 'd'), ('b', 'e'), ('c', 'a'), ('c', 'e'), ('e', 'b'), ('e', 'c'), ('d', 'a'), ('d', 'b')]

Du kannst einige coole Sachen mit Graphen machen, wie z.B. herausfinden, ob es einen Pfad zwischen zwei Knoten gibt, den kürzesten Weg zwischen zwei Knoten finden oder Zyklen im Graphen bestimmen.

Bei dem berühmten "Handlungsreisenden-Problem" geht es darum, die kürzestmögliche Route zu finden, die jeden Knotenpunkt genau einmal besucht und zum Ausgangspunkt zurückkehrt. Manchmal wurden den Knoten oder Bögen eines Graphen Gewichte oder Kosten zugewiesen. Du kannst dir das als Zuweisung eines Schwierigkeitsgrads für den Weg vorstellen, und du bist daran interessiert, den billigsten oder einfachsten Weg zu finden.

Bäume

Ein Baum in der realen Welt ist ein Lebewesen, dessen Wurzeln im Boden stecken und dessen Äste, die die Blätter und Früchte tragen, im Freien stehen. Die Äste des Baumes breiten sich einigermaßen geordnet aus. In der Informatik werden Bäume verwendet, um zu beschreiben, wie Daten manchmal organisiert sind, mit dem Unterschied, dass die Wurzel oben ist und die Äste, Blätter folgen, die sich nach unten ausbreiten und der Baum im Vergleich zum realen Baum umgedreht gezeichnet wird.

Die Wurzel befindet sich immer an der Spitze des Baumes, um die Notation etwas zu vereinfachen. Um bei der Baum-Metapher zu bleiben, werden die folgenden Knoten als Zweige bezeichnet und der letzte Knoten in jedem Zweig wird als Blatt bezeichnet. Du kannst dir vorstellen, dass jeder Zweig ein kleinerer Baum für sich ist. Die Wurzel wird oft als Elternteil bezeichnet und die Knoten, auf die sie verweist, als ihre Kinder. Die Knoten mit demselben Elternteil werden als Geschwister bezeichnet. Verstehst du, warum man das auch einen Stammbaum nennt?

Bäume helfen bei der Definition von Szenarien in der realen Welt und werden überall eingesetzt, von der Spielewelt bis hin zur Entwicklung von XML-Parsern und auch das PDF-Designprinzip basiert auf Bäumen. In der Datenwissenschaft ist das "Entscheidungsbaum-basierte Lernen" ein großer Forschungsbereich. Es gibt zahlreiche bekannte Methoden wie Bagging und Boosting, die das Baummodell verwenden, um ein Vorhersagemodell zu erstellen. Spiele wie Schach bauen einen riesigen Baum mit allen möglichen Zügen auf, um sie zu analysieren und Heuristiken anzuwenden, um einen optimalen Zug zu wählen.

Du kannst eine Baumstruktur implementieren, indem du die verschiedenen Datenstrukturen, die du bisher in diesem Lernprogramm gesehen hast, verwendest und kombinierst. Der Einfachheit halber wird dieses Thema jedoch in einem anderen Beitrag behandelt.

class Tree:
    def __init__(self, info, left=None, right=None):
        self.info = info
        self.left  = left
        self.right = right

    def __str__(self):
        return (str(self.info) + ', Left child: ' + str(self.left) + ', Right child: ' + str(self.right))

tree = Tree(1, Tree(2, 2.1, 2.2), Tree(3, 3.1))
print(tree)

1, Left child: 2, Left child: 2.1, Right child: 2.2, Right child: 3, Left child: 3.1, Right child: None

Du hast etwas über Arrays gelernt und auch die Listendatenstruktur gesehen. Python bietet jedoch viele verschiedene Arten von Datenerfassungsmechanismen, und obwohl sie vielleicht nicht zu den traditionellen Datenstruktur-Themen in der Informatik gehören, sind sie besonders im Hinblick auf die Programmiersprache Python wissenswert:

• Tupel
• Wörterbuch
• Sets

Tupel

Tupel sind ein weiterer Standard-Sequenz-Datentyp. Der Unterschied zwischen Tupeln und Listen besteht darin, dass Tupeln unveränderlich sind, d. h., wenn sie einmal definiert sind, kannst du keine Werte darin löschen, hinzufügen oder bearbeiten. Dies kann in Situationen nützlich sein, in denen du die Kontrolle an eine andere Person weitergeben möchtest, die aber nicht die Daten in deiner Sammlung manipulieren soll, sondern sie nur sehen oder separate Operationen in einer Kopie der Daten durchführen soll.

Schauen wir uns an, wie Tupel implementiert werden:

x_tuple = 1,2,3,4,5
y_tuple = ('c','a','k','e')
x_tuple[0]

1

y_tuple[3]
x_tuple[0] = 0 # Cannot change values inside a tuple

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in ()
      1 y_tuple[3]
----> 2 x_tuple[0] = 0 # Cannot change values inside a tuple


TypeError: 'tuple' object does not support item assignment

Wörterbuch

Wörterbücher sind genau das, was du brauchst, wenn du etwas Ähnliches wie ein Telefonbuch implementieren willst. Keine der Datenstrukturen, die du bisher gesehen hast, ist für ein Telefonbuch geeignet.

In diesem Fall kann ein Wörterbuch sehr hilfreich sein. Wörterbücher bestehen aus Schlüssel-Wert-Paaren. key wird verwendet, um das Objekt zu identifizieren und value enthält, wie der Name schon sagt, den Wert des Objekts.

x_dict = {'Edward':1, 'Jorge':2, 'Prem':3, 'Joe':4}
del x_dict['Joe']
x_dict

{'Edward': 1, 'Jorge': 2, 'Prem': 3}

x_dict['Edward'] # Prints the value stored with the key 'Edward'.

1

Du kannst viele andere integrierte Funktionen auf Wörterbücher anwenden:

len(x_dict)

3

x_dict.keys()

dict_keys(['Prem', 'Edward', 'Jorge'])

x_dict.values()

dict_values([3, 1, 2])

Dieser Code zeigt ein Beispiel für die Verwendung eines Python-Wörterbuchs, um Schlüssel-Wert-Paare zu speichern und darauf zuzugreifen.

Zuerst ruft der Code die Funktion len() mit x_dict als Argument auf. Dies gibt die Anzahl der Schlüssel-Wert-Paare im Wörterbuch zurück, die 3 beträgt.

Als nächstes ruft der Code die Methode keys() auf x_dict auf. Dies gibt ein View-Objekt zurück, das die Schlüssel des Wörterbuchs enthält. In diesem Fall sind die Schlüssel "Prem", "Edward" und "Jorge", wie die Ausgabe zeigt.

Dann ruft der Code die Methode values() auf x_dict auf. Dies gibt ein View-Objekt zurück, das die Werte im Wörterbuch enthält. In diesem Fall sind die Werte 3, 1 bzw. 2, wie die Ausgabe zeigt.

Sets

Mengen sind eine Sammlung von eindeutigen (einzigartigen) Objekten. Diese sind nützlich, um Listen zu erstellen, die nur eindeutige Werte im Datensatz enthalten. Sie ist eine ungeordnete, aber veränderbare Sammlung, was sehr hilfreich ist, wenn du einen großen Datensatz durchgehst.

x_set = set('CAKE&COKE')
y_set = set('COOKIE')

print(x_set)

{'A', '&', 'O', 'E', 'C', 'K'}

print(y_set) # Single unique 'o'

{'I', 'O', 'E', 'C', 'K'}

print(x - y) # All the elements in x_set but not in y_set

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

 in ()
----> 1 print(x - y) # All the elements in x_set but not in y_set


NameError: name 'x' is not defined

print(x_set|y_set) # Unique elements in x_set or y_set or both

{'C', '&', 'E', 'A', 'O', 'K', 'I'}

print(x_set & y_set) # Elements in both x_set and y_set

{'O', 'E', 'K', 'C'}

Der Code erstellt zwei Sets: x_set und y_set. Jedes Set wird erstellt, indem eine Zeichenkette als Argument an die Funktion set() übergeben wird. In diesem Fall wird x_set aus der Zeichenfolge "CAKE&COKE" erstellt, während y_set aus der Zeichenfolge "COOKIE" erstellt wird.

Als Nächstes druckt der Code jeden Satz mit der Funktion print() aus. Die erste Anweisung print() gibt x_set aus, die die eindeutigen Zeichen der Zeichenfolge "CAKE&COKE" enthält. Die Ausgabe zeigt, dass x_set die Zeichen 'A', '&', 'O', 'E', 'C' und 'K' enthält. In ähnlicher Weise gibt die zweite Anweisung print() y_set aus, die die eindeutigen Zeichen der Zeichenfolge "COOKIE" enthält. Die Ausgabe zeigt, dass y_set die Zeichen 'I', 'O', 'E', 'C' und 'K' enthält.

Die dritte Anweisung print() versucht, die Menge aller Elemente in x_set zu drucken, die nicht in y_set enthalten sind. Diese Codezeile führt jedoch zu einer NameError, weil die Variable x nicht definiert wurde. Vermutlich sollte diese Zeile stattdessen print(x_set - y_set) lauten.

Die vierte Anweisung print() gibt die Menge der eindeutigen Elemente in x_set oder y_set oder in beiden aus. Die Ausgabe zeigt, dass die resultierende Menge alle eindeutigen Zeichen sowohl von x_set als auch von y_set enthält.

Die fünfte Anweisung print() schließlich gibt die Menge der Elemente aus, die sowohl in x_set als auch in y_set enthalten sind. Die Ausgabe zeigt, dass diese Menge die Zeichen "O", "E", "K" und "C" enthält.

Dateien

Dateien sind traditionell ein Teil von Datenstrukturen. Und obwohl Big Data in der Data Science-Branche gang und gäbe ist, wäre eine Programmiersprache ohne die Möglichkeit, bereits gespeicherte Informationen zu speichern und abzurufen, kaum nützlich. Du musst immer noch alle Daten nutzen, die sich in Dateien über Datenbanken hinweg befinden, und du wirst lernen, wie man das macht.

Die Syntax zum Lesen und Schreiben von Dateien ist in Python ähnlich wie in anderen Programmiersprachen, aber viel einfacher zu handhaben. Hier sind einige der grundlegenden Funktionen, die dir bei der Arbeit mit Dateien in Python helfen werden:

• open() um Dateien in deinem System zu öffnen, ist der Dateiname der Name der zu öffnenden Datei;
• read() um ganze Dateien zu lesen;
• readline() um eine Zeile nach der anderen zu lesen;
• write() um eine Zeichenkette in eine Datei zu schreiben und die Anzahl der geschriebenen Zeichen zurückzugeben; und
• close() um die Datei zu schließen.

# File modes (2nd argument): 'r'(read), 'w'(write), 'a'(appending), 'r+'(both reading and writing)
f = open('file_name', 'w')

# Reads entire file
f.read() 

# Reads one line at a time
f.readline() 

# Writes the string to the file, returning the number of char written
f.write('Add this line.') 

f.close()

Das zweite Argument in der Funktion open() ist der Dateimodus. Hier kannst du angeben, ob du lesen (r), schreiben (w), anhängen (a) oder sowohl lesen als auch schreiben (r+) möchtest.

Wenn du mehr über den Umgang mit Dateien in Python erfahren möchtest, solltest du diese Seite besuchen.

Du hast es geschafft!

Hurray! Du hast das Ende des Tutorials erreicht! Das bringt dich deinem Traum, die Welt der Datenwissenschaft zu erobern, ein Thema näher.

Wenn du Interesse hast, kannst du in der zweiteiligen Python Data Science Toolbox von DataCamp tiefer in Funktionen, Iteratoren, Listen usw. eintauchen.

Mach eine Pause und wenn du bereit bist, gehst du zu einem der empfohlenen Tutorials, um deine Reise fortzusetzen!