Sequenzielle Datentypen

• str, unicode, list und tuple
• list ist ein mutable (änderbar), tuple ein immutable (nicht änderbar) Datentyp

• x in s: Prüfung, ob x in s, gibt bool zurück
• x not in s: Prüfung, ob x nicht in s ist, gibt bool zurück
• s + t: Verkettung, s und t müssen vom gleichen Typ sein
• s += t: s wird s+t zugewiesen
• s * t oder t * s: Inhalt ver-s-fachen
• s *= t: dto.
• s[i]: i-tes Element von s (von 0 beginnend, auch negativ, wenn sinnvoll)
• s[i:j]: Sequenz von i bis j (Achtung: von/bis nicht Anzahl), s[4:]: bis Ende
  Achtung, Achtung: inklusive i, exklusive j
• s[i:j:k]: Sequenz von i bis j, nur jedes k-te Element
• len(s): Länge von s (Achtung: Anzahl von Zeichen, nicht Index!)
  letztes Element: s[len(s)-1]
• min(s)/max(s): Kleinstes/größtes Element, wenn Ordnung vorhanden

Link

• list
• beliebige Instanzen
• l = [1, 0.5, „String“, 2]
• Inhalt kann veränder werden!!!

>>> s = [1, 2, 3, 4, 5, 6, 7] 
>>> s[3] = 1337 
>>> s 
[1, 2, 3, 1337, 5, 6, 7]
>>> for x in s:
    print(x)
1
2
3
...

• s[i] = x: i-test Element der Liste x zuweisen
• s[i:j] = t: i bis j wird durch t ersetzt, t muss iterierbar sein, inklusive i, exklusive j
  Anzahl muss übereinstimmen!
• s[i:j:k] = t: dto.
  Anzahl muss übereinstimmen!
• del[…]: dto.

Die Methoden verändern die jeweilige Liste!

• s.append(t)
• s.extend(t):

# append
x = [1, 2, 3]
x.append([4, 5])
print (x)
 
>>> [1, 2, 3, [4, 5]]
 
# extend
x = [1, 2, 3]
x.extend([4, 5])
print (x)
 
>>> [1, 2, 3, 4, 5]

• s.count(t): Anzahl des Elements t in s
• s.index(x[, i[, j]]): Gibt den Index k des ersten Vorkommens von x im Bereich i ⇐ k < j zurück.
• s.insert(i, x): Fügt x an der Stelle i in s ein. Anschließend hat s[i] den Wert von x, wobei alle folgenden Elemente um eine Stelle nach hinten aufrücken.
  Nur ein Element kann eingefügt werden.
• s.pop([i]): Gibt das i-te Element von s zurück und entfernt es aus s. Ist i nicht angegeben, wird das letzte Element genommen. Es wird das entfernte Element zurückgegeben.
• s.remove(x): Entfernt das erste Vorkommen von x aus der Sequenz s und gibt es zurück.
• s.reverse(): Kehrt die Reihenfolge der Elemente in s um.
• s.sort(…): siehe https://wiki.python.org/moin/HowTo/Sorting

Unveränderbare Listen

>>> a = (1, 2, 3, 4, 5) 
>>> a[3] 
4

• Umschließende Klammern kann man weglassen: schnack = 1, 2, 3

Entpacken:

schnack = (1, 2, 3)
(eins, zwei, drei) = schnack
eins
>>> 1
zwei
>>> 2
drei
>>>3

Zuweisungen mehrerer Variablen:

a, b = 10, 20
a
>>> 10
b
>>> 20

Link

• Datentypen str und unicode
• alle Operationen für sequentielle Datentypen sind einsetzbar

Mehrere Zeilen

>>> string3 = """Erste Zeile! 
Ui, noch eine Zeile"""

Trennen:

• s.split([sep[, maxsplit]]): Teilt bei sep von vorn, maxsplit: Größe der Liste
• s.rsplit([sep[, maxsplit]]): Teilt bei sep con hinten, dto.
• s.splitlines([keepends]): Klar, oder? → Beispiel
• s.partition(sep): partition zerteilt einen String an der ersten Stelle, an der der übergebene Trennstring sep auftritt, und gibt ein Tupel zurück, das aus dem Teil vor dem Trennstring, dem Trennstring selbst und dem Teil danach besteht
• s.rpartition(sep): dto.. von hinten

# mehrere Trennzeichen:
>>> s = "1---2-3" 
>>> s.split("-") 
['1', '', '', '2', '3']
 
# splitlines:
text = '''Hallo
Ballo
Schnick
Schnack
Schnuck
'''
print text.splitlines(1)
>>> ['Hallo\n', 'Ballo\n', 'Schnick\n', 'Schnack\n', 'Schnuck\n']

Suchen:

Zur Erinnerung: Beim Slicing eines Strings s mit s[start:end] wird ein Teilstring erzeugt, der das Element s[end] nicht mehr enthält.

• s.find(sub[, start[, end]]): sucht und gibt Position zurück, -1 wenn nicht
  • besser: if „Py“ in „Python“
• s.rfind(sub[, start[, end]]): dto. von hinten
• s.index(sub[, start[, end]]): dto. s.find()
• s.rindex(sub[, start[, end]]): dto. s.rfind()
• s.count(sub[, start[, end]]): zählt das Vorkommen von sub in s

Ersetzen:

• s.replace(old, new[, count])
• s.lower()
• s.upper()
• s.swapcase()
• s.capitalize()
• s.title(): Anfangsbuchstabe jedes Wortes groß
• s.expandtabs([tabsize])

Entfernen bestimmter Zeichen am Anfang oder am Ende von Strings:

• s.strip([chars])
• s.lstrip([chars])
• s.rstrip([chars])
• alle Whitespaces werden entfernt (alle, von links, von rechts)

Verketten:

• s.join(seq)
• „, “.join(kontakt_liste)

Link