Datentypen und Datenstrukturen

Einführung

In diesem Abschnitt werden Datenstrukturen in Form von Tupeln und Wörterbüchern vorgestellt.

Primitive Datentypen

Python hat einige primitive Datentypen:

• Ganzzahlen
• Gleitkommazahlen
• Zeichenketten (Text)

Wir haben uns in der Einführung mit diesen beschäftigt.

None-Typ

email_address = None

None wird oft als Platzhalter für optionale oder fehlende Werte verwendet. Es wertet sich in bedingten Anweisungen als False aus.

if email_address:
    send_email(email_address, msg)

Datenstrukturen

Echte Programme haben komplexere Daten. Beispielsweise Informationen über einen Aktienbesitz:

100 Anteile von GOOG zu einem Preis von 490,10 USD

Dies ist ein "Objekt" mit drei Teilen:

• Name oder Symbol der Aktie ("GOOG", eine Zeichenkette)
• Anzahl der Anteile (100, eine Ganzzahl)
• Preis (490,10, eine Gleitkommazahl)

Tupel

Ein Tupel ist eine Sammlung von Werten, die zusammen gruppiert sind.

Beispiel:

s = ('GOOG', 100, 490.1)

Manchmal werden die () in der Syntax weggelassen.

s = 'GOOG', 100, 490.1

Spezielle Fälle (0-Tupel, 1-Tupel).

t = ()            ## Ein leeres Tupel
w = ('GOOG', )    ## Ein 1-Element-Tupel

Tupel werden oft verwendet, um einfache Datensätze oder Strukturen zu repräsentieren. Typischerweise ist es ein einzelnes Objekt mit mehreren Teilen. Ein gutes Analogie: Ein Tupel ist wie eine einzelne Zeile in einer Datenbanktabelle.

Die Inhalte eines Tupels sind geordnet (wie ein Array).

s = ('GOOG', 100, 490.1)
name = s[0]                 ## 'GOOG'
shares = s[1]               ## 100
price = s[2]                ## 490.1

Die Inhalte können jedoch nicht geändert werden.

>>> s[1] = 75
TypeError: object does not support item assignment

Man kann jedoch ein neues Tupel basierend auf einem bestehenden Tupel erstellen.

s = (s[0], 75, s[2])

Tupel-Packing

Tupel handeln sich eher darum, verwandte Elemente in eine einzelne Entität zu packen.

s = ('GOOG', 100, 490.1)

Das Tupel kann dann als einzelnes Objekt leicht an andere Teile eines Programms weitergegeben werden.

Tupel-Aufpacken

Um das Tupel an einem anderen Ort zu verwenden, können Sie seine Teile in Variablen aufpacken.

name, shares, price = s
print('Cost', shares * price)

Die Anzahl der Variablen auf der linken Seite muss der Tupelstruktur entsprechen.

name, shares = s     ## FEHLER
Traceback (most recent call last):
...
ValueError: too many values to unpack

Tupel vs. Listen

Tupel sehen wie schreibgeschützte Listen aus. Tupel werden jedoch am häufigsten für einen einzelnen Datensatz verwendet, der aus mehreren Teilen besteht. Listen sind normalerweise eine Sammlung von verschiedenen Elementen, die in der Regel vom gleichen Typ sind.

record = ('GOOG', 100, 490.1)       ## Ein Tupel, das einen Datensatz im Portfolio repräsentiert

symbols = [ 'GOOG', 'AAPL', 'IBM' ]  ## Eine Liste, die drei Aktiensymbole repräsentiert

Dictionaries

Ein Dictionary ist eine Zuordnung von Schlüsseln zu Werten. Manchmal wird es auch als Hashtabelle oder assoziatives Array bezeichnet. Die Schlüssel dienen als Indizes zum Zugriff auf die Werte.

s = {
    'name': 'GOOG',
    'shares': 100,
    'price': 490.1
}

Allgemeine Operationen

Um Werte aus einem Dictionary zu erhalten, verwenden Sie die Schlüsselnamen.

>>> print(s['name'], s['shares'])
GOOG 100
>>> s['price']
490.10
>>>

Um Werte hinzuzufügen oder zu ändern, weisen Sie die Werte über die Schlüsselnamen zu.

>>> s['shares'] = 75
>>> s['date'] = '6/6/2007'
>>>

Um einen Wert zu löschen, verwenden Sie den del-Befehl.

>>> del s['date']
>>>

Warum Dictionaries?

Dictionaries sind nützlich, wenn es viele verschiedene Werte gibt und diese Werte verändert oder manipuliert werden können. Dictionaries machen Ihren Code lesbarer.

s['price']
## vs
s[2]

In den letzten Übungen haben Sie ein Programm geschrieben, das eine Datendatei portfolio.csv ausliest. Mit dem csv-Modul ist es einfach, die Datei Zeile für Zeile zu lesen.

>>> import csv
>>> f = open('portfolio.csv')
>>> rows = csv.reader(f)
>>> next(rows)
['name','shares', 'price']
>>> row = next(rows)
>>> row
['AA', '100', '32.20']
>>>

Obwohl das Lesen der Datei einfach ist, möchten Sie oft mehr mit den Daten machen als nur lesen. Beispielsweise möchten Sie sie vielleicht speichern und einige Berechnungen damit durchführen. Leider gibt Ihnen eine einfache "Zeile" von Daten nicht genug, um damit zu arbeiten. Beispielsweise funktioniert auch eine einfache mathematische Berechnung nicht:

>>> row = ['AA', '100', '32.20']
>>> cost = row[1] * row[2]
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type'str'
>>>

Um mehr zu tun, möchten Sie die Rohdaten typischerweise auf eine bestimmte Weise interpretieren und in ein nützlicheres Objekt umwandeln, damit Sie später damit arbeiten können. Zwei einfache Optionen sind Tupel oder Dictionaries.

Übung 2.1: Tupel

Am interaktiven Prompt erstellen Sie das folgende Tupel, das die obige Zeile repräsentiert, wobei die numerischen Spalten in richtige Zahlen umgewandelt sind:

>>> t = (row[0], int(row[1]), float(row[2]))
>>> t
('AA', 100, 32.2)
>>>

Mit diesem können Sie jetzt die Gesamtkosten berechnen, indem Sie die Anzahl der Anteile und den Preis multiplizieren:

>>> cost = t[1] * t[2]
>>> cost
3220.0000000000005
>>>

Ist die Mathematik in Python kaputt? Was ist mit der Antwort 3220.0000000000005 los?

Dies ist ein Artefakt der Gleitkomma-Hardware Ihres Computers, die nur in der Lage ist, Dezimalzahlen in Basis-2, nicht in Basis-10, genau darzustellen. Bei sogar einfachen Berechnungen mit Basis-10 Dezimalzahlen werden kleine Fehler eingeführt. Dies ist normal, obwohl es vielleicht etwas überraschend sein kann, wenn Sie es noch nie gesehen haben.

Dies passiert in allen Programmiersprachen, die Gleitkomma-Zahlen verwenden, wird aber oft bei der Ausgabe versteckt. Beispielsweise:

>>> print(f'{cost:0.2f}')
3220.00
>>>

Tupel sind schreibgeschützt. Verifizieren Sie dies, indem Sie versuchen, die Anzahl der Anteile auf 75 zu ändern.

>>> t[1] = 75
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

Obwohl Sie die Tupel-Inhalte nicht ändern können, können Sie immer ein ganz neues Tupel erstellen, das das alte ersetzt.

>>> t = (t[0], 75, t[2])
>>> t
('AA', 75, 32.2)
>>>

Wenn Sie eine vorhandene Variablennamen wie oben neu zuweisen, wird der alte Wert verworfen. Obwohl die obige Zuweisung so aussieht, als würden Sie das Tupel ändern, erstellen Sie tatsächlich ein neues Tupel und werfen das alte weg.

Tupel werden oft verwendet, um Werte in Variablen zu packen und wieder auszupacken. Versuchen Sie Folgendes:

>>> name, shares, price = t
>>> name
'AA'
>>> shares
75
>>> price
32.2
>>>

Nehmen Sie die obigen Variablen und packen Sie sie wieder in ein Tupel

>>> t = (name, 2*shares, price)
>>> t
('AA', 150, 32.2)
>>>

Übung 2.2: Dictionaries als Datenstruktur

Eine Alternative zu einem Tupel ist die Erstellung eines Dictionaries.

>>> d = {
        'name' : row[0],
      'shares' : int(row[1]),
        'price'  : float(row[2])
    }
>>> d
{'name': 'AA','shares': 100, 'price': 32.2 }
>>>

Berechnen Sie die Gesamtkosten dieses Portfolios:

>>> cost = d['shares'] * d['price']
>>> cost
3220.0000000000005
>>>

Vergleichen Sie dieses Beispiel mit der gleichen Berechnung mit Tupeln oben. Ändern Sie die Anzahl der Anteile auf 75.

>>> d['shares'] = 75
>>> d
{'name': 'AA','shares': 75, 'price': 32.2 }
>>>

Im Gegensatz zu Tupeln können Dictionaries frei geändert werden. Fügen Sie einige Attribute hinzu:

>>> d['date'] = (6, 11, 2007)
>>> d['account'] = 12345
>>> d
{'name': 'AA','shares': 75, 'price':32.2, 'date': (6, 11, 2007), 'account': 12345}
>>>

Übung 2.3: Weitere Dictionary-Operationen

Wenn Sie ein Dictionary in eine Liste umwandeln, erhalten Sie alle seine Schlüssel:

>>> list(d)
['name','shares', 'price', 'date', 'account']
>>>

Ähnlich können Sie die for-Anweisung verwenden, um über ein Dictionary zu iterieren, und erhalten Sie dann die Schlüssel:

>>> for k in d:
        print('k =', k)

k = name
k = shares
k = price
k = date
k = account
>>>

Versuchen Sie diese Variante, die gleichzeitig eine Suche ausführt:

>>> for k in d:
        print(k, '=', d[k])

name = AA
shares = 75
price = 32.2
date = (6, 11, 2007)
account = 12345
>>>

Sie können auch alle Schlüssel mit der keys()-Methode erhalten:

>>> keys = d.keys()
>>> keys
dict_keys(['name','shares', 'price', 'date', 'account'])
>>>

keys() ist etwas ungewöhnlich, da sie ein spezielles dict_keys-Objekt zurückgibt.

Dies ist eine Überlagerung des ursprünglichen Dictionaries, die Ihnen immer die aktuellen Schlüssel gibt - auch wenn das Dictionary sich ändert. Beispielsweise versuchen Sie dies:

>>> del d['account']
>>> keys
dict_keys(['name','shares', 'price', 'date'])
>>>

Befinden Sie sich aufmerksam darauf, dass das 'account' aus keys verschwunden ist, obwohl Sie d.keys() nicht erneut aufgerufen haben.

Eine elegantere Möglichkeit, um Schlüssel und Werte zusammen zu verwenden, ist die items()-Methode. Dies gibt Ihnen (Schlüssel, Wert)-Tupel:

>>> items = d.items()
>>> items
dict_items([('name', 'AA'), ('shares', 75), ('price', 32.2), ('date', (6, 11, 2007))])
>>> for k, v in d.items():
        print(k, '=', v)

name = AA
shares = 75
price = 32.2
date = (6, 11, 2007)
>>>

Wenn Sie Tupel wie items haben, können Sie ein Dictionary mit der dict()-Funktion erstellen. Versuchen Sie es:

>>> items
dict_items([('name', 'AA'), ('shares', 75), ('price', 32.2), ('date', (6, 11, 2007))])
>>> d = dict(items)
>>> d
{'name': 'AA','shares': 75, 'price':32.2, 'date': (6, 11, 2007)}
>>>

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Lab zu Datentypen und Datenstrukturen abgeschlossen. Sie können in LabEx weitere Labs ausprobieren, um Ihre Fähigkeiten zu verbessern.