Datenstrukturen

Strings werden zwischen “ oder ' geschrieben. Sie können addiert (aneinandergehängt) und mit natürlichen Zahlen multipliziert werden (hier ein Auszug aus der Python-Konsole):

>>> a = "Hello "
>>> b = 'world!'
>>> a+b
'Hello world!'
>>> a*5
'Hello Hello Hello Hello Hello '
>>> b="backslash n ist Zeilenumbruch\n"*5
>>> print(b)
backslash n ist Zeilenumbruch
backslash n ist Zeilenumbruch
backslash n ist Zeilenumbruch
backslash n ist Zeilenumbruch
backslash n ist Zeilenumbruch

Umwandlung in einen String: str( irgendwas ).

Auch wichtig ist die Umwandlung von Strings in Zahlen (int() und float()):

>>> int(" 123  ")
123
>>> int(" 15.9  ")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: ' 15.9  '
>>> float(" 15.9  ")
15.9

>>> a = "ABCDEFGH"
>>> a[2:4]    # Startindex (inklusive) Endindex (exklusive)
'CD'
>>> a[4:]     # Bis zum Ende
'EFGH'
>>> a[:2]     # Von Anfang an
'AB'

split: Einen String in eine Liste zerlegen:

>>> "3 4 55 11   3 5".split()   # Alle whitespaces (Space, Tab und Newline), auch mehrere hintereinander
['3', '4', '55', '11', '3', '5']
>>> "234;1;123;;;4;3;".split(";")   # Genau ein ; (beachten Sie die leeren Einträge)
['234', '1', '123', '', '', '4', '3', '']

join: Ein Array von Strings zu einem String zusammenhängen:

>>> " und ".join(['3', '4', '55', '11', '3', '5'])
'3 und 4 und 55 und 11 und 3 und 5'

Sind die Einträge im Array keine Strings, müssen diese zuerst umgewandelt werden, z.B. so:

>>> l = [i*i for i in range(5)]
>>> l
[0, 1, 4, 9, 16]
>>> " plus ".join(l)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found
>>> " plus ".join([str(e) for e in l])          # Umwandlung aller Elemente der Liste
'0 plus 1 plus 4 plus 9 plus 16'

In Python gibt es zwei Arten von Arrays: Listen (veränderbar) und Tuples (unveränderbar).

• Listen: zwischen eckigen Klammern: a=[1,2,3].
• Tuples: zwischen runden Klammern: b = (1,2,3), oder c=(1,) für ein Tuple der Länge 1.

Tuples (unveränderbare Arrays) haben den Vorteil, dass damit effizienter und “sicherer” gearbeitet werden kann. Insbesondere wenn ein Tuple einer Funktion übergeben wird, kann man sicher sein, dass die Funktion den Tuple nicht verändern kann.

In folgenden Beispielen enthält a eine Liste, z.B. a=[2,3,4].

• .append(element): Einer Liste hinten ein neues Element hinzufügen.
• .pop(): Entfernt das letzte Element der Liste und liefert es als Resultat. (.pop(index) entfernt ein Element an dieser der Stelle index.
• .insert(position, element)
• [ausdruck mit x for x in range, liste oder tuple]. Z.B. [i*i for i in range(2,10,2)] liefert [4, 16, 36, 64].

>>> a = [i*i for i in range(2,10,2)]
>>> a
[4, 16, 36, 64]
>>> b = [x/2 for x in a]
>>> b
[2.0, 8.0, 18.0, 32.0]
>>> c = [str(x) for x in b]
>>> c
['2.0', '8.0', '18.0', '32.0']
>>> d = [x*2 for x in c]
>>> d
['2.02.0', '8.08.0', '18.018.0', '32.032.0']

Über Listen und Tuples kann eine for-Schleife gemacht werden:

a = [2,3,5,7,11,13]
for p in a:
  print(p*p)

Dictionaries (auch Hashtables genannt) sind wie ungeordnete Listen, die anstatt Indizies Schlüssel (keys) haben. Normalerweise sind die keys einfach Strings, es können aber beliebige Python-Objekte verwendet werden.

Dictionaries werden zwischen geschweiften Klammern {} geschrieben. Schlüssel und Werte werden durch : getrennt. Schlüssel/Wert-Paare werden durch Kommas getrennt:

>>> h = {"ruby":10, "python":7, "java":[1,2,3]}
>>> h
{'ruby': 10, 'python': 7, 'java': [1, 2, 3]}
>>> h["ruby"]
10
>>> h["java"]
[1, 2, 3]
>>> h["java"][0]
1
>>> "python" in h    # Gibt es den key "python"?
True
>>> "c++" in h       # Gibt es den key "c++"?
False
>>> h["c++"]=8       # Neues key/value Paar einfügen.
>>> h
{'ruby': 10, 'python': 7, 'java': [1, 2, 3], 'c++': 8}
>>> "c++" in h
True
>>> h["java"]+=[6,5,4]    # Wert eines Eintrags verändern
>>> h
{'ruby': 10, 'python': 7, 'java': [1, 2, 3, 6, 5, 4], 'c++': 8}

Über die keys kann iteriert werden:

h = {"ruby":10, "python":7, "java":[1,2,3]}
for key in h:
  print("In %s steht %s" % (key, str(h[key])))
for key,value in h.items():
  print(key+" -> "+str(value))

liefert den Output

In ruby steht 10
In python steht 7
In java steht [1, 2, 3]
ruby -> 10
python -> 7
java -> [1, 2, 3]

Wir eine Datei zum Lesen oder Schreiben geöffnet, muss diese auch wieder geschlossen werden. Das Konstrukt with macht dies automatisch (auch wenn etwas schief gehen sollte) und sollte deshalb wenn möglich immer verwendet werden.

# Datei lesen
with open(pfad_und_dateiname) as datei:
  while True:
    line = datei.readline()  # Eine zeile lesen
    if not line:   # Testen, ob die Datei nicht schon fertig ist
       break
    # Tu was mit der Zeile (enthält noch das '\n' am Schluss!)
    line = line.rstrip()   # Zeilenumbruch am Ende entfernen

Oder alles in eine Liste einlesen:

lines = []   # In Python nicht nötig, in den meisten anderen Programmiersprachen schon
with open(pfad_und_dateiname) as datei:
  lines = datei.readlines()  # Alle Zeilen in eine Liste lesen
 
# Tu was mit den Zeilen, die Datei ist hier bereits wieder geschlossen
print(lines[0])

with open(pfad_und_dateiname, "w") as datei:
  datei.write("Hello ")
  datei.write("World\n")  # Zeilenumbrüche sind selbst einzufügen.
  datei.write(str(6*7))   # datei.write(42) produziert einen Fehler, weil 42 kein String ist!

liste_mit_strings = [str(i*i)+"\n" for i in range(10)]
with open(pfad_und_dateiname, "w") as datei:
  datei.writelines(liste_mit_strings)  # Achtung: Zeilenumbrüche müssen bereits in den einzelnen Einträgen stehen!