Python-String-Tutorial

String-Slicing in Python

Da Strings Zeichenfolgen sind, kannst du sie über Slicing und Indexing ansprechen – ganz wie bei Python-Listen oder -Tupeln. Strings werden pro Zeichen indiziert, beginnend bei 0:

Im obigen String ist das erste Zeichen C und hat den Index 0. Das letzte Zeichen ist der Punkt . und ist das 16. Zeichen im String. Du kannst Zeichen auch rückwärts ab -1 ansprechen; so greifst du mit -1 ebenfalls auf den . zu. Zwischen Chocolate und cookie steht ein Leerzeichen; es gehört zum String und hat in diesem Fall den Index 9. Das kannst du per Slicing prüfen.

Weil jedes Zeichen in einem Python-String eine Indexnummer hat, kannst du Strings genauso adressieren und bearbeiten wie andere Sequenztypen. Slicing ist eine Technik, mit der du über Indexwerte ein bestimmtes Element oder eine Teilfolge aus einem Containerobjekt holst. So sparst du dir Schleifen über die Indizes, um Teilstrings zu finden oder zu extrahieren.

snack = "Chocolate cookie."
print(snack[0])
print(snack[9])
print(snack[-1])

C

.

Angenommen, du willst den Teilstring "cookie" aus dem folgenden String extrahieren. Wie machst du das?

In solchen Fällen verwendest du Bereichs-Slicing.

Die Syntax für Bereichs-Slicing lautet: [Startindex (inklusive): Stoppindex (exklusive)]

snack = "Chocolate cookie."
print(snack[10:16])

cookie

Das geht auch mit einem negativen Stoppindex:

print(snack[10:-1]) # -1: Der Stoppindex ist beim Slicing ausgeschlossen.

cookie

Lässt du den Stoppindex weg, werden vom Startindex bis zum letzten Zeichen alle Zeichen übernommen. Lässt du den Startindex weg, beginnt das Slicing beim ersten Zeichen bis zum Stoppindex:

# Kein Stoppwert angegeben
print(snack[0:]) 

# Kein Startwert angegeben (Stoppwert laut Syntax exklusive)
print(snack[:-1])

# Das ist ebenfalls erlaubt
print(snack[:])

Chocolate cookie.
Chocolate cookie
Chocolate cookie.

Beim String-Slicing kannst du auch einen dritten Parameter angeben: den stride. Er gibt an, um wie viele Zeichen du nach dem ersten entnommenen Zeichen weiterspringst. Standard ist 1.

Schauen wir uns stride in Aktion an:

number_string = "1020304050"
print(number_string[0:-1:2])

12345

Tipp: Mit Striding kannst du sehr elegant einen String umkehren:

print(number_string[::-1]) #

0504030201

Der Wert -1 für den Stride startet beim letzten Zeichen und geht dann schrittweise rückwärts.

Gibst du stattdessen -2 an, startest du ebenfalls am Ende, springst aber jeweils zwei Zeichen zurück:

print(number_string[::-2]) #

00000

Häufige String-Operationen

Slicing und Bereichs-Slicing gehören zu den Standardoperationen auf Strings. Auch die Konkatenation ist simpel wie eine Addition:

string1 = 'Chocolate'
string2 = 'cookie'

snack = string1 + " " + string2
print(snack)

Chocolate cookie

Allerdings funktioniert das nicht, wenn du einen String mit einem anderen Datentyp verketten willst.

cost = 15
string1 = "The total in Euro is: "

bill = string1 + cost
print(bill)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-218-7d5c5248b927> in <module>()
      2 string1 = "The total in Euro is: "
      3 
----> 4 bill = string1 + cost
      5 print(bill)


TypeError: Can't convert 'int' object to str implicitly

Hier hast du versucht, einen String mit einem Integer zu verketten – das ist nicht erlaubt. Der Interpreter kann nicht automatisch erkennen, ob du eine ganze Zahl addieren oder Strings verketten willst. So klappt es:

bill = string1 + str(cost)
print(bill)

The total in Euro is: 15

Du hast den Integer explizit in einen String umgewandelt und dann konkateniert. Mehr zu Typkonvertierungen findest du in diesem Tutorial.

Zum Wiederholen eines Strings verwendest du den Operator *.

single_word = 'hip '
line1 = single_word * 2 + 'hurray! '
print(line1 * 3)

hip hip hurray! hip hip hurray! hip hip hurray! 

Mit in und not in prüfst du die Teilmengen-Eigenschaft in Strings:

sub_string1 = 'ice'
sub_string2 = 'glue'
string1 = 'ice cream'
if sub_string in string1:
    print("There is " + sub_string + " in " + string1)
if sub_string2 not in string1:
    print("Phew! No " + sub_string2 + " in " + string1)

There is ice in ice cream
Phew! No glue in ice cream

Python bringt viele eingebaute Methoden für die String-Manipulation mit. Du kannst Teilstrings ersetzen, Wörter kapitalisieren oder die Position eines Substrings in einem anderen String finden – und vieles mehr.

Hier ein paar Beispiele im Detail:

• str.capitalize(): Gibt eine Kopie des Strings mit großgeschriebenem Anfangsbuchstaben zurück.

str.capitalize('cookie')

'Cookie'

• str.islower(): Liefert True, wenn alle Zeichen im String klein sind, sonst False.

snack = 'cookie'
snack.islower()

True

• str.find(substring): Liefert den kleinsten Index, an dem der Substring gefunden wird. Optional kannst du Start- und Endindex angeben. Gibt -1 zurück, wenn nicht gefunden.

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

• str.count(substring): Zählt, wie oft ein Substring im String vorkommt. Optional mit Start- und Stoppindex.

str1 = 'I got you a cookie, do you like cookies?'
str2 = 'cookie'
str1.count(str2)

2

• str.isspace(): Liefert True, wenn nur Leerraumzeichen enthalten sind, sonst False. Leerraum sind z. B. Space, Tab, Zeilenumbruch usw.

Das ist nützlich bei echten Datensätzen, die beim Konvertieren zwischen Formaten nicht immer saubere Abstände behalten.

str_space = '   '
str_space.isspace()

True

str_tab = '\t'
str_tab.isspace()

True

str_nextline = '''\n'''
str_nextline.isspace()

True

Hinweis: Ist dir das \t und \n oben aufgefallen? Das sind Escape-Sequenzen. Sie beginnen mit einem Backslash \. Intern werden sie nicht als normale Zeichenketten interpretiert, sondern stehen für etwas Besonderes. Zum Beispiel repräsentiert \t einen Tab. Weitere Escape-Zeichen findest du in unserem Python-Regex-Tutorial.

• str.lstrip(): Entfernt führende Leerzeichen im String. Ebenfalls praktisch bei echten Datensätzen.

str1 = " I can't hear you. Are you alright? "
str2 = " Yes, all is good."
str3 = str1.lstrip() + str2.lstrip()
print(str3)

I can't hear you. Are you alright? Yes, all is good.

• str.isdigit(): Liefert True, wenn der String nur Ziffern enthält, sonst False.

number_string = "1020304050"
number_string.isdigit()

True

• str.replace(substring, new): Ersetzt alle Vorkommen des Substrings durch new. Optional kannst du mit dem dritten Argument max die Anzahl der Ersetzungen begrenzen. Beachte: Das ist keine In-place-Operation – wegen der Unveränderlichkeit entsteht ein neuer String.

string1 = 'hip hip hurray! hip hip hurray! hip hip hurray!'
string2 = string1.replace('hip', 'Hip')
print(string1)
print(string2)

hip hip hurray! hip hip hurray! hip hip hurray!
Hip Hip hurray! Hip Hip hurray! Hip Hip hurray!

string1.replace('hip', 'Hip', 2)

'Hip Hip hurray! hip hip hurray! hip hip hurray!'

• str.split(delimiter=""): Teilt den String am Delimiter (Standard: Leerzeichen) und gibt eine Liste von Teilstrings zurück.

dessert = 'Cake, Cookie, Icecream'
list_dessert = string1.split(',')

Eine vollständige Liste aller String-Methoden in Python findest du hier.

String-Formatierung

Python unterstützt mehrere Wege, einen String zu formatieren. In diesem Abschnitt lernst du die wichtigsten Optionen kennen.

%-Formatierung

Das Modulo-Zeichen % ist eine eingebaute Operation in Python und heißt Interpolationsoperator. Du gibst % gefolgt vom Datentyp an, der formatiert bzw. konvertiert werden soll. Die %-Operation ersetzt dann das Platzhalter-Muster '%datatype' durch die angegebenen Werte:

print("I bought %d Euro worth of %s!" %(200, 'cookies'))

I bought 200 Euro worth of cookies!

Du hast %d für Integer und %s für Strings gesehen. Weitere Typen sind z. B.: o für Oktalzahlen, x für Hexadezimal, f für Gleitkommazahlen, c für ein einzelnes Zeichen (Integer oder einzeichenlanger String).

Die Formatter-Klasse

Die formatter-Klasse ist Teil der eingebauten String-Funktionalität. Sie ermöglicht komplexe Variablensubstitutionen und Wertformatierungen über die Methode format(). Du kannst eigenes Formatierverhalten erstellen, indem du die öffentlichen Methoden format() und vformat() überschreibst. Außerdem gibt es Methoden, die für Subklassen gedacht sind: parse(), get_field(), get_value(), check_unused_args(), format_field() und convert_field(). Der Einfachheit halber schauen wir uns hier die am häufigsten genutzte Funktion format() an...

print("I bought {0} Euro worth of {1}!".format(200,'cookies')) # Zugriff per Positionsindex

I bought 200 Euro worth of cookies!

print("I bought {total} Euro worth of {item}!".format(total = 200, item = 'cookies')) # Zugriff per Namen

I bought 200 Euro worth of cookies!

'{:#<10}'.format('Cake') # Linksbündig, Lücken mit '#'

'Cake######'

'{:#^10}'.format('Cake') # Zentriert, Lücken mit '#'

'###Cake###'

'{:#>10}'.format('Cake') # Rechtsbündig, Lücken mit '#'

'######Cake'

for num in range(1,10): 
        print('{0:{width}}'.format(num, width=5), end=' ')

    1     2     3     4     5     6     7     8     9 

Template-Strings

Statt der üblichen %-Substitutionen unterstützen Templates $-Substitutionen. Der Grund für die Einführung in Python 2.4: Die %-Formatierung ist zwar mächtig, aber fehleranfällig und recht strikt, was die Formate nach dem '%' angeht. Ein häufiger Fehler ist das Vergessen des abschließenden Formatzeichens, z. B. des e in %(variabl)e.

Templates bieten Methoden wie substitute() und safe_substitute(). So verwendest du sie:

from string import Template # Zuerst die Klasse 'Template' importieren

money = dict(who = 'You', to_whom = 'baker')
Template('$who owe the $to_whom a total of $$100').substitute(money)

'You owe the baker a total of $100'

Ist dir das $$ im Beispiel aufgefallen?

Bei Templates ist $$ eine Escape-Sequenz und wird zu einem einzelnen $. Das ist eine der Template-Regeln. Eine weitere betrifft die Bezeichner in deinem Template: Neben $identifier gibt es ${identifier}.

Das heißt, ${identifier} entspricht $identifier, ist aber in Fällen wie diesem praktisch:

word = dict(noun = 'feed')
Template('Please don\'t stop ${noun}ing me').substitute(word)

"Please don't stop feeding me"

So nutzt du substitute() und safe_substitute():

fact = Template('$alter_ego is weak but wait till he transforms to $superhero!')
fact.substitute(alter_ego='Bruce Banner', superhero='Hulk')

'Bruce Banner is weak but wait till he transforms to Hulk!'

hero = dict(alter_ego='Peter Parker')
fact.substitute(hero)

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-244-c82f6a2ebc02> in <module>()
      1 hero = dict(alter_ego='Peter Parker')
----> 2 fact.substitute(hero)


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in substitute(*args, **kws)
    127             raise ValueError('Unrecognized named group in pattern',
    128                              self.pattern)
--> 129         return self.pattern.sub(convert, self.template)
    130 
    131     def safe_substitute(*args, **kws):


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in convert(mo)
    117             named = mo.group('named') or mo.group('braced')
    118             if named is not None:
--> 119                 val = mapping[named]
    120                 # We use this idiom instead of str() because the latter will
    121                 # fail if val is a Unicode containing non-ASCII characters.


KeyError: 'superhero'

Das Beispiel wirft einen Fehler, weil superhero nicht definiert ist. So klappt es ohne Fehler:

fact.safe_substitute(hero)

'Peter Parker is weak but wait till he transforms to $superhero!'

safe_substitute() ist ein großer Vorteil von Templates.

Warum so viele Optionen zur String-Formatierung?

Oft ist es eine Frage der Syntax-Präferenz – ein Trade-off zwischen Einfachheit und Ausführlichkeit, und davon, womit du vertraut bist. Wer aus C kommt, findet %-Formatierung oft naheliegend. Templates sind leicht zu schreiben, format() ist ausführlicher, bietet aber mehr Features.

Formatted String Literal (F-String)

Das ist eine weitere Formatiermethode seit Python 3.6. Ein Formatted String Literal oder F-String ist ein String-Literal mit Präfix 'f' oder 'F'. Platzhalter schreibst du in geschweifte Klammern { }.

Warum noch eine Formatierungsoption? Weil sie praktisch und einfach ist – genau deshalb!

Sieh dir die Beispiele an und du merkst schnell, warum F-Strings oft der einfachste und pragmatischste Weg sind, Strings in Python zu formatieren.

alter_ego = 'Peter Parker' superhero = 'spiderman' f'{alter_ego} is weak but wait till he transforms to {superhero}!'

Hinweis: Der obige Code funktioniert nur mit Python 3.6 oder höher. Prüfe deine Python-Version mit python -V im Terminal. Alternativ kannst du in Python das Modul sys verwenden:

import sys
sys.version

Formatierte Strings sind Ausdrücke, die zur Laufzeit ausgewertet werden. Du kannst also beliebige Python-Ausdrücke in die geschweiften Klammern eines F-Strings setzen – ein weiterer großer Vorteil.

f'{alter_ego} is weak but wait till he transforms to {superhero.capitalize()}!'

Klingt F-String nicht jetzt schon großartig? Es wird noch besser: F-Strings sind oft auch schneller als die drei zuvor gezeigten Methoden, da sie vorgeparst und als effizientes Bytecode-Objekt gespeichert werden.

Zieh an den richtigen Strings!

Geschafft – du bist am Ende des Tutorials angekommen! Du weißt jetzt, was Strings sind, wie String-Slicing funktioniert und welche Operationen du auf Strings anwenden kannst. Außerdem hast du mehrere Wege zur String-Formatierung kennengelernt. Wie immer gilt: Übung macht den Meister.

Strings sind nur einer von mehreren Datentypen in Python. Schau dir den DataCamp-Kurs Data Types for Data Science an, um mehr über Listen, Dictionaries, Tupel und Sets zu lernen. In diesem Kurs nutzt du dein Wissen über Datentypen praktisch – mit Transitzahlen aus der Metropolregion Chicago für Data-Science-Zwecke. Schau gleich mal rein...