string

Die meisten der Python-String-Methoden sind im str-Typ integriert, so dass alle str-Objekte automatisch über sie verfügen:

>>> welcome = "hello pythonistas!\n"
>>> welcome.isupper()
False
>>> welcome.isalpha()
False
>>> welcome[0:5].isalpha()
True
>>> welcome.capitalize()
'Hello pythonistas!\n'
>>> welcome.title()
'Hello Pythonistas!\n'
>>> welcome.strip()
'Hello pythonistas!'
>>> welcome.split(" ")
['hello', 'pythonistas!\n']
>>> chunks = [snippet.strip() for snippet in welcome.split(" ")]
>>> chunks
['hello', 'pythonistas!']
>>> " ".join(chunks)
'hello pythonistas!'
>>> welcome.replace("\n", "")
'hello pythonistas!'

Im Folgenden findet ihr einen Überblick über die häufigsten String-Methoden:

Methode

Beschreibung

str.count()

gibt die Anzahl der sich nicht überschneidenden Vorkommen der Zeichenkette zurück.

str.endswith()

gibt True zurück, wenn die Zeichenkette mit dem Suffix endet.

str.startswith()

gibt True zurück, wenn die Zeichenkette mit dem Präfix beginnt.

str.join()

verwendet die Zeichenkette als Begrenzer für die Verkettung einer Folge anderer Zeichenketten.

str.index()

gibt die Position des ersten Zeichens in der Zeichenkette zurück, wenn es in der Zeichenkette gefunden wurde; löst einen ValueError aus, wenn es nicht gefunden wurde.

str.find()

gibt die Position des ersten Zeichens des ersten Vorkommens der Teil-Zeichenkette in der Zeichenkette zurück; wie index, gibt aber -1 zurück, wenn nichts gefunden wurde.

str.rfind()

Rückgabe der Position des ersten Zeichens des letzten Vorkommens der Teil-Zeichenkette in der Zeichenkette; gibt -1 zurück, wenn nichts gefunden wurde.

str.replace()

ersetzt Vorkommen einer Zeichenkette durch eine andere Zeichenkette.

str.strip(), str.rstrip(), str.lstrip()

schneiden Leerzeichen ab, einschließlich Zeilenumbrüchen.

str.split()

zerlegt eine Zeichenkette in eine Liste von Teil-Zeichenketten unter Verwendung des übergebenen Trennzeichens.

str.lower()

konvertiert alphabetische Zeichen in Kleinbuchstaben.

str.upper()

konvertiert alphabetische Zeichen in Großbuchstaben.

str.casefold()

konvertiert Zeichen in Kleinbuchstaben und konvertiert alle regionsspezifischen variablen Zeichenkombinationen in eine gemeinsame vergleichbare Form.

str.ljust(), str.rjust()

linksbündig bzw. rechtsbündig; füllt die gegenüberliegende Seite der Zeichenkette mit Leerzeichen (oder einem anderen Füllzeichen) auf, um eine Zeichenkette mit einer Mindestbreite zu erhalten.

str.split und str.join

Während str.split() eine Liste von Zeichenfolgen zurückgibt, nimmt str.join() eine Liste von Zeichenketten und fügt sie zu einer einzigen Zeichenkette zusammen. Normalerweise verwendet str.split() Leerraum als Begrenzungszeichen für die aufzuteilenden Zeichenketten, aber ihr könnt dieses Verhalten mit einem optionalen Parameter ändern.

Warnung

Die Verkettung von Zeichenketten mit + ist zwar nützlich, aber nicht effizient, wenn es darum geht, eine große Anzahl von Zeichenketten zu einer einzigen Zeichenkette zusammenzufügen, da jedes Mal, wenn + angewendet wird, ein neues Zeichenketten-Objekt erstellt wird. "Hello" + "Pythonistas!" erzeugt zwei Objekte, von denen eines sofort wieder verworfen wird.

Wenn ihr mit str.join() Zeichenfolgen zusammenführt, könnt ihr zwischen die Zeichenfolgen beliebige Zeichen einfügen:

>>> " :: ".join(["License", "OSI Approved"])
'License :: OSI Approved'

Ihr könnt auch eine leere Zeichenkette, "", verwenden, z.B. für die CamelCase-Schreibweise von Python-Klassen:

>>> "".join(["My", "Class"])
'MyClass'

str.split() wird meist verwendet um Zeichenketten an Leerräumen zu trennen. Ihr könnt eine Zeichenkette jedoch auch an einer bestimmten anderen Zeichenfolge trennen, indem ihr einen optionalen Parameter übergebt:

>>> example = "1. You can have\n\twhitespaces, newlines\n   and tabs mixed in\n\tthe string."
>>> example.split()
['1.', 'You', 'can', 'have', 'whitespaces,', 'newlines', 'and', 'tabs', 'mixed', 'in', 'the', 'string.']
>>> license = "License :: OSI Approved"
>>> license.split(" :: ")
['License', 'OSI Approved']

Manchmal ist es nützlich, dem letzten Feld in einer Zeichenkette zu erlauben, beliebigen Text zu enthalten. Ihr könnt dies tun, indem ihr einen optionalen zweiten Parameter angebt, wie viele Teilungen durchgeführt werden sollen:

>>> example.split(" ", 1)
['1.', 'You can have\n\twhitespaces, newlines\n   and tabs mixed in\n\tthe string.']

Wenn ihr str.split() mit dem optionalen zweiten Argument verwenden wollt, müsst ihr zunächst ein erstes Argument angeben. Um zu erreichen, dass bei allen Leerzeichen geteilt wird, verwendet None als erstes Argument:

>>> example.split(None, 8)
['1.', 'You', 'can', 'have', 'whitespaces,', 'newlines', 'and', 'tabs', 'mixed in\n\tthe string.']

Tipp

Ich verwende str.split() und str.join() ausgiebig, meist für Textdateien, die von anderen Programmen erzeugt wurden. Zum Schreiben von CSV- oder JSON-Dateien verwende ich jedoch meist die zugehörigen Python-Bibliotheken.

Leerraum entfernen

str.strip() gibt eine neue Zeichenkette zurück, die sich von der ursprünglichen Zeichenkette nur dadurch unterscheidet, dass alle Leerzeichen am Anfang oder Ende der Zeichenkette entfernt wurden. str.lstrip() und str.rstrip() arbeiten ähnlich, entfernen jedoch nur die Leerzeichen am linken bzw. rechten Ende der ursprünglichen Zeichenkette:

>>> example = "    whitespaces, newlines \n\tand tabs. \n"
>>> example.strip()
'whitespaces, newlines \n\tand tabs.'
>>> example.lstrip()
'whitespaces, newlines \n\tand tabs. \n'
>>> example.rstrip()
'    whitespaces, newlines \n\tand tabs.'

In diesem Beispiel werden die Newlines \n als Leerzeichen betrachtet. Die genaue Zuordnung kann sich von Betriebssystem zu Betriebssystem unterscheiden. Ihr könnt herausfinden, was Python als Leerzeichen betrachtet, indem ihr auf die Variable string.whitespace zugreift. Bei mir wird das folgende zurückgegeben:

>>> import string
>>> string.whitespace
' \t\n\r\x0b\x0c'

Die im Hexadezimalformat (\x0b, \x0c) angegebenen Zeichen stellen die vertikalen Tabulator- und Vorschubzeichen dar.

Tipp

Ändert nicht den Wert dieser Variablen um die Funktionsweise von str.strip() usw. zu beeinflussen. Welche Zeichen diese Methoden entfernen, könnt ihr Zeichen als zusätzlichen Parameter übergeben:

>>> url = "https://www.cusy.io/"
>>> url.strip("htps:/w.")
'cusy.io'

Suche in Zeichenketten

str-Objekte bieten mehrere Methoden für die einfache Suche nach Zeichenketten: Die vier grundlegenden Methoden für die Suche nach Zeichenketten sind str.find(), str.rfind(), str.index() und str.rindex(). Eine verwandte Methode, str.count(), zählt, wie oft eine Zeichenfolge in einer anderen Zeichenfolge gefunden werden kann.

str.find() benötigt einen einzigen Parameter: die gesuchte Teil-Zeichenkette; zurückgegeben wird dann die Position des ersten Vorkommens oder -1, wenn es kein Vorkommen gibt:

>>> hipy = "Hello Pythonistas!\n"
>>> hipy.find("\n")
18

str.find() kann auch ein oder zwei zusätzliche Parameter annehmen:

start

Zahl, der Zeichen am Anfang der zu durchsuchenden Zeichenkette, die ignoriert werden soll.

end

Zahl, der Zeichen am Ende der zu durchsuchenden Zeichenkette, die ignoriert werden soll.

Im Gegensatz zu find() beginnt rfind() die Suche am Ende der Zeichenkette und gibt daher die Position des letzten Vorkommens zurück.

index() und rindex() unterscheiden sich von find() und rfind() dadurch, dass statt dem Rückgabewert -1 eine ValueError-Ausnahme ausgelöst wird.

Ihr könnt zwei weitere String-Methoden verwenden, um Strings zu suchen: str.startswith() und str.endswith(). Diese Methoden geben True- oder False als Ergebnis zurück, je nachdem, ob die Zeichenkette, auf die sie angewendet werden, mit einer der als Parameter angegebenen Zeichenketten beginnt oder endet:

>>> hipy.endswith("\n")
True
>>> hipy.endswith(("\n", "\r"))
True

Darüber hinaus gibt es einige Methoden, mit denen die Eigenschaft einer Zeichenkette überprüft werden kann:

Methode

[!#$%…]

[a-zA-Z]

[¼½¾]

[¹²³]

[0-9]

str.isprintable()

str.isalnum()

str.isnumeric()

str.isdigit()

str.isdecimal()

str.isspace() prüft auf Leerzeichen.

Zeichenketten ändern

str-Objekte sind unveränderlich, aber sie verfügen über mehrere Methoden, die eine modifizierte Version der ursprünglichen Zeichenkette zurückgeben können.

str.replace() könnt ihr verwenden, um Vorkommen des ersten Parameter durch den zweiten zu ersetzen, z.B.:

>>> hipy.replace("\n", "\n\r")
'Hello Pythonistas!\n\r'

str.maketrans() und str.translate() können zusammen verwendet werden, um Zeichen in Zeichenketten in andere Zeichen zu übersetzen, z.B.:

1>>> hipy = "Hello Pythonistas!\n"
2>>> trans_map = hipy.maketrans(" ", "-", "!\n")
3>>> hipy.translate(trans_map)
4'Hello-Pythonistas'
Zeile 2

str.maketrans() wird verwendet, um eine Übersetzungstabelle aus den beiden Zeichenketten-Argumenten zu erstellen. Die beiden Argumente müssen jeweils die gleiche Anzahl von Zeichen enthalten. Als drittes Argument werden Zeichen übergeben, die nicht zurückgegeben werden sollen.

Zeile 3

Die von str.maketrans() erzeugte Tabelle wird an str.translate() übergeben.

Checks

  • Wie könnt ihr eine Überschrift wie variables and expressions so abändern, dass sie keine Leerzeichen mehr enthält und besser als Dateinamen verwendet werden kann?

  • Wenn ihr überprüfen wollt, ob eine Zeile mit .. note:: beginnt, welche Methode würdet ihr verwenden? Gibt es auch noch andere Möglichkeiten?

  • Angenommen, ihr habt eine Zeichenkette mit Ausrufezeichen, Anführungszeichen und Zeilenumbruch. Wie können diese aus der Zeichenkette entfernt werden?

  • Wie könnt ihr alle Leerräume und Satzzeichen aus einer Zeichenfolge in einen Bindestrich (-) ändern?