NB02_Strings_Tupel_und_Sequenzen

(c) 2020/2021 Hochschule Augsburg - Fakultät für Informatik - Prof.Dr.Nik Klever

Strings (Zeichenketten)

Allgemeines

Analog wie bei Listen sind String-Methoden Methoden die auf Objekte des Typs String (Zeichenketten) angewendet werden. In der folgenden Aufzählung ist eine Auswahl der wichtigsten String-Methoden aufgeführt. In dieser Auflistung ist wieder str der Methode als Platzhalter für einen String vorangestellt. In den weiteren Literaturhinweisen ist die komplette Aufzählung aller String-Methoden zu finden.

String-Methoden

  • str.capitalize()

    Gibt eine Kopie der Zeichenkette zurück, wobei der erste Buchstabe groß geschrieben wird und die restlichen Buchstaben klein.

  • str.count(sub[, start[, end]])

    Gibt die Anzahl der nicht-überlappenden Vorkommen des Teilstrings sub in dem Bereich [start, end]. Return the number of non-overlapping occurrences of substring sub in the range [start, end]. Die optionalen Argumente start und end werden wie in der slice-Schreibweise verwendet.

  • str.endswith(suffix[, start[, end]])

    Gibt True zurück, falls der String mit dem angebenen Teilstring suffix endet, andernfalls False. suffix kann ebenso ein Tuple von Suffixen sein, nach denen überprüft wird. Mit dem optionalen Argument start, wird erst an dieser Position angefangen zu überprüfen. Mit dem optionalen Argument end wird die Überprüfung bereits an dieser Position beendet.

  • str.find(sub[, start[, end]])

    Gibt den kleinsten Index zurück an dem der Teilstring sub in dem string innerhalb des Slice [start:end] gefunden wird. Return the lowest index in the string where substring sub is found within the slice s[start:end]. Die optionalen Argumente start und end werden wie in der slice-Schreibweise verwendet. Gibt -1 zurück, wenn der Teilstring sub nicht gefunden wird.

    Beachte:

    Die find() Methode sollte nur benutzt werden, wenn wirklich die Position des Teilstrings sub benötigt wird. Um zu überprüfen, ob ein Teilstring in einem String enthalten ist oder nicht, sollte der in-Operator benutzt werden:

    >>> 'Py' in 'Python'
    True
  • str.index(sub[, start[, end]])

    Wie find(), aber wirft einen ValueError wenn der Teilstring nicht gefunden wird.

  • str.isalnum()

    Gibt True zurück, falls alle Zeichen in dem String alphanumerisch sind und letztendlich mindestens ein Zeichen überhaupt vorhanden ist, andernfalls wird False zurückgegeben. Ein Zeichen c is alphanumerisch falls eine der folgenden Methoden True zurückliefert: c.isalpha(), c.isdecimal(), c.isdigit(), oder c.isnumeric().

  • str.isalpha()

    Gibt True zurück, falls alle Zeichen in dem String alphabetisch sind und letztendlich mindestens ein Zeichen überhaupt vorhanden ist, andernfalls wird False zurückgegeben. Alphabetische Zeichen sind solche Zeichen die in der Datenbank aller Unicode Zeichen als “Letter” bezeichnet werden.

  • str.isdecimal()

    Gibt True zurück, falls alle Zeichen in dem String dezimal sind und letztendlich mindestens ein Zeichen überhaupt vorhanden ist, andernfalls wird False zurückgegeben. Dezimale Zeichen sind solche mit denen dezimale Zahlen gebildet werden können.

  • str.isdigit()

    Gibt True zurück, falls alle Zeichen in dem String Ziffern sind und letztendlich mindestens ein Zeichen überhaupt vorhanden ist, andernfalls wird False zurückgegeben. Ziffern umfassen sowohl die dezimalen Zeichen als auch Ziffern, die ein spezielles Verhalten erfordern, wie z.B. hochgestellte Ziffern.

  • str.islower()

    Gibt True zurück, falls alle alphabetischen Zeichen in dem String kleingeschrieben sind und letztendlich mindestens ein Zeichen überhaupt vorhanden ist, andernfalls wird False zurückgegeben.

  • str.isnumeric()

    Gibt True zurück, falls alle Zeichen in dem String numerisch sind und letztendlich mindestens ein Zeichen überhaupt vorhanden ist, andernfalls wird False zurückgegeben. Numerische Zeichen umfassen sowohl Ziffern als auch andere numerische Zeichen, die in der Unicode Datenbank das Attribut "numerisch" besitzen.

  • str.isspace()

    Gibt True zurück, falls alle Zeichen in dem String Leerzeichen, Tabulatoren oder Zeilenumbrüche (Whitespace Zeichen) sind und letztendlich mindestens ein Zeichen überhaupt vorhanden ist, andernfalls wird False zurückgegeben.

  • str.isupper()

    Gibt True zurück, falls alle alphabetischen Zeichen in dem String großgeschrieben sind und letztendlich mindestens ein Zeichen überhaupt vorhanden ist, andernfalls wird False zurückgegeben.

  • str.join(iterable)

    Gibt einen String zurück, der die Zeichenketten in dem Argument iterable jeweils mit dem string als Trenn-String verknüpft, auf den diese Methode angewendet wird. Ein TypeError wird geworfen, falls irgendein Wert in iterables kein String ist.

  • str.lower()

    Gibt eine Kopie der Zeichenkette zurück, in dem alle alphabetischen Zeichen in kleingeschriebene Zeichen umgewandelt wurden.

  • str.partition(sep)

    Teilt dem String an dem ersten Auftauchen der Trennzeichenkette sep auf und gibt einen 3-er Tuple zurück, mit dem Teil vor der Trennzeichenkette, der Trennzeichenkette selbst und dem Teil nach der Trennzeichenkette. Falls die Trennzeichenkette nicht gefunden wird, wird ebenfalls ein 3-er Tuple zurückgegeben mit dem String selbst als erstem Teil und zwei leeren Zeichenketten anschliessend.

  • str.replace(old, new[, count])

    Gibt eine Kopie der Zeichenkette zurück, in dem alle Vorkommen des Teilstrings old durch den Teilstring nwe ausgetauscht werden. Falls das optionale Argument count angegeben wurde, werden nur die ersten count Vorkommen ersetzt.

  • str.split(sep=None, maxsplit=-1)

    Gibt eine Liste aller Wörter aus dem String zurück, wobei als Trennzeichenkette sep verwendet wird. Falls maxsplit angegeben wird, werden höchstens maxsplit Trennungen durchgeführt (dies bedeutet, dass die resultierende Liste höchstens maxsplit+1 Elemente besitzt). Falls maxsplit nicht spezifiziert ist oder -1 ist, dann gibt es keine Grenze für die Anzahl der Trennungen (alle möglichen Trennungen werden durchgeführt).

    Falls sep angegeben wird, werden zusammenhängende Trennzeichenketten nicht zusammengefasst sondern getrennt erfasst und somit leere Zeichenketten in der Ergebnisliste erzeugt (z.B. '1,,2'.split(',') ergibt ['1', '', '2']). Das Argument sep kann auch aus mehreren Zeichen bestehen (z.B. '1<>2<>3'.split('<>') ergibt ['1', '2', '3']). Einen leeren String mit einer spezifierten Trennzeichenketten liefert [''] als Ergebnis.

    Beispiele:

    >>> '1,2,3'.split(',')
    ['1', '2', '3']
    >>> '1,2,3'.split(',', maxsplit=1)
    ['1', '2,3']
    >>> '1,2,,3,'.split(',')
    ['1', '2', '', '3', '']
    
    

    Falls sep nicht spezifiziert ist oder None ist, wird ein anderer Trennalgorithmus angewendet: mehrere zusammenhängende Whitespace Zeichen (Leerzeichen, Tabulatoren, Zeilenumbrüche) werden als ein einziges Trennzeichen betrachtet und das Ergebnis enthält keine leeren Zeichenketten am Anfang und Ende, falls die Zeichenkette führende oder nachfolgende Whitespace Zeichen besitzt. Konsequenterweise ergibt die Trennung einer leeren Zeichenkette oder einer Zeichenkette mit ausschliesslich Whitespace Zeichen mit keinem Trennzeichen (sep=None) als Ergebnis eine leere Liste ([]).

    Beispiele:

    >>> '1 2 3'.split()
    ['1', '2', '3']
    >>> '1 2 3'.split(maxsplit=1)
    ['1', '2 3']
    >>> '   1   2   3   '.split()
    ['1', '2', '3']
  • str.startswith(prefix[, start[, end]])

    Gibt True zurück, falls der String mit dem angebenen Teilstring prefix beginnt, andernfalls False. prefix kann ebenso ein Tuple von Präfixen sein, nach denen überprüft wird. Mit dem optionalen Argument start, wird erst an dieser Position angefangen zu überprüfen. Mit dem optionalen Argument end wird die Überprüfung bereits an dieser Position beendet.

  • str.strip([chars])

    Gibt eine Kopie der Zeichenkette zurück, in der die führenden und nachfolgenden Zeichen des Arguments chars entfernt werden. Das Argument chars ist eine Zeichenkette, welche die Zeichen beinhaltet, die entfernt werden sollen. Falls dieses Argument fehlt oder None ist, werden alle Whitespace Zeichen (Leerzeichen, Tabulatoren, Zeilenumbrüche) vorgegeben und daher entfernt. Das Argument chars ist kein Präfix oder Suffix; im Gegenteil, alle Kombinationen von seinem Wert werden entfernt:

    >>> '   spacious   '.strip()
    'spacious'
    >>> 'www.example.com'.strip('cmowz.')
    'example'
    
    

    Die äußersten führenden und nachfolgenden Zeichen aus dem Arguments chars werden von der Zeichenkette entfernt. Zeichen werden vom Anfang der Zeichenkette solange entfernt, bis ein Zeichen der Zeichenkette nicht mehr in der Menge der Zeichen in dem Argument chars enthalten ist. Analog geschieht dieses Verfahren am Ende der Zeichenkette.

    Beispiel:

    >>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
    >>> comment_string.strip('.#! ')
    'Section 3.2.1 Issue #32'
  • str.swapcase()

    Gibt eine Kopie der Zeichenkette zurück, in dem alle großgeschriebenen Zeichen in kleingeschriebene Zeichen umgewandelt werden und umgekehrt. Beachte, dass der Ausdruck s.swapcase().swapcase() == s nicht notwendigerweise wahr sein muss.

  • str.upper()

    Gibt eine Kopie der Zeichenkette zurück, in dem alle alphabetischen Zeichen in großgeschriebene Zeichen umgewandelt wurden.

In [2]:
%%Mooc StringAssessment
Out[2]:

Stringmethode find

Gegeben sei der folgende Code


a = "Dies ist eine kurze Zeichenkette"
b = a.find("kurze")
print(b)

Geben sie das Ergebnis des Print-Befehls aus.



In [3]:
%%Mooc StringAssessment
Out[3]:

Stringmethode join

Gegeben sei der folgende Code


a = ['Vorname','Nachname','Plz','Ort','Strasse']
b = ";".join(a)
print(b)

Geben sie das Ergebnis des Print-Befehls aus.



In [4]:
%%Mooc StringAssessment
Out[4]:

Stringmethode split

Gegeben sei der folgende Code


a = "Vorname,Nachname,Plz,Ort,Strasse"
b = a.split(",")
print(b)

Geben sie das Ergebnis des Print-Befehls aus.



In [5]:
a = "<svg><circle r='100'/></svg>"
b = a.replace("100","150")
print(b)
<svg><circle r='150'/></svg>
In [6]:
%%Mooc StringAssessment
Out[6]:

Stringmethode replace

Gegeben sei der folgende Code


a = "<svg><circle r='100'/></svg>"
b = a.replace("100","150")
print(b)

Geben sie das Ergebnis des Print-Befehls aus.



Tupel und Sequenzen

Allgemeines

Wir haben gesehen, dass Listen und Zeichenketten (Strings) viele gemeinsame Eigenschaften besitzen, wie z.B. die Indizes oder die Slice Operation. Dies sind zwei Beispiele des Datentyps Sequenzen (siehe Weitere Literatur). Da Python eine sich ständig weiterentwickelnde Programmiersprache ist, können weitere Sequenzdatentypen hinzukommen.

Tupel

Es gibt einen weiteren Standard Sequenzdatentyp namens Tupel. Ein Tupel besteht aus einer Reihe von Werten, die durch Kommata getrennt werden.

In [7]:
t = 12345, 54321, 'hello!'
print(t[0])
print(t)
12345
(12345, 54321, 'hello!')

Tupel können verschachtelt sein

In [8]:
u = t, (1, 2, 3, 4, 5)
print(u)
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

Tupel sind unveränderbar:

In [9]:
t[0] = 88888
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-9-edd9bcaa2212> in <module>()
----> 1 t[0] = 88888

TypeError: 'tuple' object does not support item assignment

Tupel können aber veränderbare Objekte enthalten

In [10]:
v = ([1, 2, 3], [3, 2, 1])
print(v)
([1, 2, 3], [3, 2, 1])

Wenn man sich die Print-Ausgaben ansieht, dann erkennt man, dass Tupel immer in runden Klammern eingeschlossen sind und somit auch verschachtelte Tupel korrekt interpretiert werden können. Für die Erstellung eines Tupel können umschliessende runde Klammern verwendet werden, müssen aber nicht. Obwohl oftmals Klammern auch notwendig sind, wenn z.B. das Tupel Teil eines größeren Ausdrucks ist. Einzelne Elemente eines Tupels können nicht verändert werden, dennoch ist es möglich, Tupel zu erzeugen die veränderbare Objekte, wie zum Beispiel Listen, enthalten.

In [11]:
%%Mooc StringAssessment
Out[11]:

Tupel

Gegeben sei der folgende Code


a = 1,2,3,(4,5,6,(7,8,9)),(10,11,12)
print(len(a))

Wie viele Elemente enthält der Tupel a ?

Geben sie das Ergebnis des Print-Befehls aus.



Unterschied Tupel - Listen

Obwohl Tupel den Listen sehr ähnlich sind, werden sie oft in unterschiedlichen Situationen und auch unterschiedlichen Zwecken benutzt.

  • Tupel sind unveränderbar, und enthalten normalerweise eine heterogene Sequenz von Elementen die über das Auspacken (siehe unten) oder über die Indizes angesprochen werden.

  • Listen dagegen sind veränderbar und deren Elemente sind normalerweise homogen und werden normalerweise durch das Iterieren über die Liste angesprochen.

Tupel mit keinem oder nur einem Element

Ein spezielles Problem ist die Erzeugung eines Tupels mit keinem oder nur einem Element: Die Syntax hat hierfür einige Eigenheiten parat, um sich diesem Problem Rechnung zu tragen. Leere Tupel werden durch ein leeres Paar von runden Klammern erzeugt; ein Tupel mit einem Element wird durch das Element selbst mit einem nachfolgenden Komma erzeugt, wobei es nicht notwendig ist, ein einzelnes Element in Klammern zu setzen.

Beispiel:

In [12]:
empty = ()
print(len(empty))
0
In [13]:
singleton = 'hello',    # <-- note trailing comma
print(len(singleton))
print(singleton)
1
('hello',)

Tupel Einpacken und Sequenz Auspacken

Der Ausdruck

In [14]:
t = 12345, 54321, 'hello!'
print(t)
(12345, 54321, 'hello!')

ist ein Beispiel von Tupel Einpacken (tuple packing): die Werte 12345, 54321 und 'hello!' werden zusammen in ein Tupel gepackt. Die umgekehrte Operation Auspacken (unpacking) ist ebenfalls möglich:

In [15]:
x, y, z = t
print(x)
print(y)
print(z)
12345
54321
hello!

Der obige Prozess wird Auspacken einer Sequenz (sequence unpacking) genannt und kann für jede Sequenz auf der rechten Seite verwendet werden. Für das Auspacken einer Sequenz (sequence unpacking) ist erforderlich, dass genauso viele Variablen auf der linken Seite des Gleichheitszeichens stehen, wie Elemente in der Sequenz enthalten sind. Man beachte, dass eine mehrfache Zuweisung nichts anderes als eine Kombination von Tupel Ein- und Sequenz Auspacken ist.

In [16]:
a = 1,2,3,(4,5,6,(7,8,9)),(10,11,12)
a1, a2, a3, a4, a5 = a
print(a4)
(4, 5, 6, (7, 8, 9))
In [17]:
%%Mooc StringAssessment
Out[17]:

Tupel Auspacken

Gegeben sei der folgende Code


a = 1,2,3,(4,5,6,(7,8,9)),(10,11,12)
a1, a2, a3, a4, a5 = a
print(a4)

Geben sie das Ergebnis des Print-Befehls aus.



In [18]:
%%Mooc Video
Out[18]:

Weitere Literatur

In [19]:
%%Mooc WebReference

String Methoden

https://docs.python.org/3/library/stdtypes.html#string-methods

Hinweis: Auflistung und Beschreibung aller String Methoden

In [20]:
%%Mooc WebReference

Datentyp Sequenzen - Listen, Tuple, Range

https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range

Hinweis: Beschreibung des Datentyps Sequenzen mit Listen, Tupeln, Range