Handbuch zur Python-String-Manipulation – Erfahren Sie, wie Sie Python-Strings für Anfänger manipulieren

String-Manipulation ist eine dieser Aktivitäten in der Programmierung, die wir als Programmierer ständig durchführen.

In vielen Programmiersprachen müssen Sie einen Großteil der schweren Arbeit selbst erledigen.

In Python hingegen stehen Ihnen in der Standardbibliothek mehrere integrierte Funktionen zur Verfügung, mit denen Sie Zeichenfolgen auf vielfältige Weise manipulieren können.

In diesem Artikel zeige ich Ihnen, wie Sie speziell mit Zeichenfolgen arbeiten ein paar nette Tricks.

Kurzinfo: Sie können hier eine PDF-Version dieses Python-String-Manipulationshandbuchs herunterladen.

Bereit zum Eintauchen?

Inhaltsverzeichnis

Python-String-Grundlagen
So teilen Sie einen String in Python
So entfernen Sie alle Leerzeichen in einer Zeichenfolge in Python
Umgang mit mehrzeiligen Zeichenfolgen in Python
lstrip(): So entfernen Sie Leerzeichen und Zeichen vom Anfang einer Zeichenfolge in Python
rstrip(): So entfernen Sie Leerzeichen und Zeichen vom Ende einer Zeichenfolge in Python
strip(): So entfernen Sie Leerzeichen und Zeichen vom Anfang und Ende eines Strings in Python
So erstellen Sie in Python eine ganze Zeichenfolge in Kleinbuchstaben
So erstellen Sie in Python einen ganzen String in Großbuchstaben
So verwenden Sie die Groß- und Kleinschreibung von Titeln in Python
So verwenden Sie Swap Case in Python
So überprüfen Sie in Python, ob ein String leer ist
rjust(): Wie man einen String in Python rechtsbündig ausrichtet
ljust(): Wie man einen String in Python linksbündig ausrichtet
isalnum(): So prüfen Sie in Python nur, ob eine Zeichenfolge alphanumerische Zeichen enthält
isprintable(): So prüfen Sie in Python, ob ein String druckbare Zeichen enthält
isspace(): So prüfen Sie in Python nur, ob in einem String Leerzeichen vorhanden sind
Startswith(): So überprüfen Sie in Python, ob ein String mit einem bestimmten Wert beginnt
Capitalize(): So setzen Sie das erste Zeichen in einer Zeichenfolge in Python nur auf Großbuchstaben
isupper(): So prüfen Sie in Python nur, ob in einem String Großbuchstaben vorhanden sind
join(): So fügen Sie Elemente einer Iterable in Python zu einem String zusammen
splitlines(): So teilen Sie einen String an Zeilenumbrüchen in Python
islower(): So prüfen Sie in Python nur, ob in einem String Kleinbuchstaben vorhanden sind
isnumeric(): So prüfen Sie in Python nur auf Zahlen in einem String
isdigit(): So prüfen Sie in Python nur, ob Ziffern in einer Zeichenfolge vorhanden sind
isdecimal(): So prüfen Sie in Python nur auf Dezimalstellen in einem String
isalpha(): So prüfen Sie in Python nur, ob in einer Zeichenfolge Buchstaben vorhanden sind
istitle(): So prüfen Sie, ob jedes Wort in einem String in Python mit einem Großbuchstaben beginnt
expandtabs(): So legen Sie die Anzahl der Leerzeichen für einen Tabulator in einer Zeichenfolge in Python fest
center(): So zentrieren Sie einen String in Python
zfill(): So fügen Sie Nullen zu einem String in Python hinzu
find(): So überprüfen Sie in Python, ob ein String einen bestimmten Teilstring hat
So entfernen Sie ein Präfix oder Suffix in einer Zeichenfolge in Python
lstrip() vs. Removeprefix() und rstrip() vs. Removesuffix()
So funktioniert Slicing in Python
So kehren Sie einen String in Python um
Abschluss

Python-String-Grundlagen

Der Typ text ist einer der am häufigsten vorkommenden Typen und wird oft string oder in Python einfach str genannt.

my_city = "New York"
print(type(my_city))

#Single quotes have exactly
#the same use as double quotes
my_city = 'New York'
print(type(my_city))

#Setting the variable type explicitly
my_city = str("New York")
print(type(my_city))

<class 'str'>
<class 'str'>
<class 'str'>

So verketten Sie Zeichenfolgen

Sie können den Operator + verwenden, um Zeichenfolgen zu verketten.

Von einer Verkettung spricht man, wenn Sie zwei oder mehr Zeichenfolgen haben und diese zu einer einzigen verbinden möchten.

word1 = 'New '
word2 = 'York'

print(word1 + word2)

New York

So wählen Sie ein Zeichen aus

Um ein Zeichen auszuwählen, verwenden Sie [] und geben Sie die Position des Zeichens an.

Position 0 bezieht sich auf die erste Position.

>>> word = "Rio de Janeiro"
>>> char=word[0]
>>> print(char)
R

So ermitteln Sie die Größe einer Zeichenfolge

Die Funktion len() gibt die Länge einer Zeichenfolge zurück.

>>> len('Rio')
3
>>> len('Rio de Janeiro')
14

So ersetzen Sie einen Teil einer Zeichenfolge

Die Methode replace() ersetzt einen Teil der Zeichenfolge durch einen anderen. Als Beispiel ersetzen wir „Rio“ durch „Mar“.

>>> 'Rio de Janeiro'.replace('Rio', 'Mar')
'Mar de Janeiro'

Rio bedeutet auf Portugiesisch Fluss und Mar bedeutet Meer – nur damit Sie wissen, dass ich diesen Ersatz nicht so zufällig ausgewählt habe.

Wie man zählt

Geben Sie an, was als Argument gezählt werden soll.

In diesem Fall zählen wir, wie viele Plätze es in „Rio de Janeiro“ gibt, nämlich 2.

>>> word = "Rio de Janeiro"
>>> print(word.count(' '))
2

So wiederholen Sie eine Zeichenfolge

Sie können das Symbol * verwenden, um eine Zeichenfolge zu wiederholen.

Hier multiplizieren wir das Wort „Tokio“ mit 3.

>>> words = "Tokyo" * 3 
>>> print(words)
TokyoTokyoTokyo

So teilen Sie einen String in Python

Das Aufteilen einer Zeichenfolge in kleinere Teile ist eine sehr häufige Aufgabe. Dazu verwenden wir die Methode split() in Python.

Sehen wir uns einige Beispiele an, wie das geht.

Beispiel 1: Leerzeichen als Trennzeichen verwenden

In diesem Beispiel teilen wir die Phrase durch Leerzeichen auf und erstellen eine Liste mit dem Namen my_words mit fünf Elementen, die jedem Wort in der Phrase entsprechen.

my_phrase = "let's go to the beach"
my_words = my_phrase.split(" ")

for word in my_words:
    print(word)
#output:
#let's
#go
#to
#the
#beach

print(my_words)
#output:
#["let's", 'go', 'to', 'the', 'beach']

Beachten Sie, dass die Methode split() standardmäßig eine beliebige aufeinanderfolgende Anzahl von Leerzeichen als Trennzeichen verwendet. Wir können den obigen Code wie folgt ändern:

my_phrase = "let's go to the beach"
my_words = my_phrase.split()

for word in my_words:
    print(word)

#output:
#let's
#go
#to
#the
#beach

Die Ausgabe ist dieselbe, da zwischen jedem Wort nur ein Leerzeichen steht.

Beispiel 2: Übergeben Sie verschiedene Argumente als Trennzeichen

Bei der Arbeit mit Daten ist es üblich, einige CSV-Dateien zu lesen, um Informationen daraus zu extrahieren.

Daher müssen Sie möglicherweise bestimmte Daten aus einer bestimmten Spalte speichern.

CSV-Dateien haben normalerweise Felder, die durch ein Semikolon „;“ getrennt sind. oder ein Komma ",".

In diesem Beispiel verwenden wir die Methode split() und übergeben als Argument ein bestimmtes Trennzeichen, „;“ in diesem Fall.

my_csv = "mary;32;australia;mary@email.com"
my_data = my_csv.split(";")

for data in my_data:
    print(data)

#output:
#mary
#32
#australia
#mary@email.com

print(my_data[3])
#output:
# mary@email.com

So entfernen Sie alle Leerzeichen in einer Zeichenfolge in Python

Wenn Sie wirklich alle Leerzeichen in einer Zeichenfolge entfernen und nur die Zeichen übrig lassen möchten, ist die Verwendung eines regulären Ausdrucks die beste Lösung.

Sie müssen das Modul re importieren, das reguläre Ausdrucksoperationen bereitstellt.

Beachten Sie, dass \s nicht nur Leerzeichen ' ' darstellt, sondern auch Formularvorschub \f und Zeilenvorschub \n, Wagenrücklauf \r, Tab \t und vertikaler Tab \v.

Zusammenfassend gilt: \s=[ \f\n\r\t\v].

Das Symbol + wird als Quantor bezeichnet und als „eins oder mehrere“ gelesen. Dies bedeutet, dass in diesem Fall ein oder mehrere Leerzeichen berücksichtigt werden, da es direkt nach dem \s positioniert ist.

import re

phrase = ' Do   or do    not   there    is  no try   '

phrase_no_space = re.sub(r'\s+', '', phrase)

print(phrase)
# Do   or do    not   there    is  no try   

print(phrase_no_space)
#Doordonotthereisnotry

Die ursprüngliche Variable phrase bleibt gleich. Sie müssen die neue bereinigte Zeichenfolge einer neuen Variablen zuweisen, in diesem Fall phrase_no_space.

Umgang mit mehrzeiligen Zeichenfolgen in Python

Dreifache Zitate

Um mehrzeilige Zeichenfolgen in Python zu verarbeiten, verwenden Sie dreifache Anführungszeichen, entweder einfache oder doppelte.

In diesem ersten Beispiel werden doppelte Anführungszeichen verwendet.

long_text = """This is a multiline,

a long string with lots of text,

I'm wrapping it in triple quotes to make it work."""

print(long_text)
#output:
#This is a multiline,
#
#a long string with lots of text,
#
#I'm wrapping it in triple quotes to make it work.

Jetzt das Gleiche wie zuvor, aber mit einfachen Anführungszeichen:

long_text = '''This is a multiline,

a long string with lots of text,

I'm wrapping it in triple quotes to make it work.'''

print(long_text)
#output:
#This is a multiline,
#
#a long string with lots of text,
#
#I'm wrapping it in triple quotes to make it work.

Beachten Sie, dass beide Ausgaben gleich sind.

Klammern

Sehen wir uns ein Beispiel mit Klammern an.

long_text = ("This is a multiline, "
"a long string with lots of text "
"I'm wrapping it in brackets to make it work.")
print(long_text)
#This is a multiline, a long string with lots of text I'm wrapping it in triple quotes to make it work.

Wie Sie sehen, ist das Ergebnis nicht dasselbe. Um neue Zeilen zu erhalten, muss ich \n hinzufügen, etwa so:

long_text = ("This is a multiline, \n\n"
"a long string with lots of text \n\n"
"I'm wrapping it in brackets to make it work.")
print(long_text)
#This is a multiline, 
#
#a long string with lots of text 
#
#I'm wrapping it in triple quotes to make it work.

Backslashes

Schließlich sind auch Backslashes möglich.

Beachten Sie, dass nach dem Zeichen \ kein Leerzeichen steht, da dies einen Fehler auslösen würde.

long_text = "This is a multiline, \n\n" \
"a long string with lots of text \n\n" \
"I'm using backlashes to make it work."
print(long_text)
#This is a multiline, 
#
#a long string with lots of text 
#
#I'm wrapping it in triple quotes to make it work.

lstrip(): So entfernen Sie Leerzeichen und Zeichen vom Anfang einer Zeichenfolge in Python

Verwenden Sie die Methode lstrip(), um Leerzeichen am Anfang einer Zeichenfolge zu entfernen.

regular_text = "   This is a regular text."

no_space_begin_text = regular_text.lstrip()

print(regular_text)
#'   This is a regular text.'

print(no_space_begin_text)
#'This is a regular text.'

Beachten Sie, dass die ursprüngliche Variable regular_text unverändert bleibt. Daher müssen Sie die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall no_space_begin_text.

So entfernen Sie Zeichen

Die Methode lstrip() akzeptiert auch bestimmte Zeichen zum Entfernen als Parameter.

regular_text = "$@G#This is a regular text."

clean_begin_text = regular_text.lstrip("#$@G")

print(regular_text)
#$@G#This is a regular text.

print(clean_begin_text)
#This is a regular text.

rstrip(): So entfernen Sie Leerzeichen und Zeichen vom Ende einer Zeichenfolge in Python

Verwenden Sie die Methode rstrip(), um Leerzeichen am Ende einer Zeichenfolge zu entfernen.

regular_text = "This is a regular text.   "

no_space_end_text = regular_text.rstrip()

print(regular_text)
#'This is a regular text.   '

print(no_space_end_text)
#'This is a regular text.'

Beachten Sie, dass die ursprüngliche Variable regular_text unverändert bleibt, daher müssen Sie die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall no_space_end_text.

Die Methode rstrip() akzeptiert auch bestimmte Zeichen zum Entfernen als Parameter.

regular_text = "This is a regular text.$@G#"

clean_end_text = regular_text.rstrip("#$@G")

print(regular_text)
#This is a regular text.$@G#

print(clean_end_text)
#This is a regular text.

strip(): So entfernen Sie Leerzeichen und Zeichen vom Anfang und Ende eines Strings in Python

Verwenden Sie die Methode strip(), um Leerzeichen am Anfang und Ende einer Zeichenfolge zu entfernen.

regular_text = "  This is a regular text.   "

no_space_text = regular_text.strip()

print(regular_text)
#'  This is a regular text.   '

print(no_space_text)
#'This is a regular text.'

Beachten Sie, dass die ursprüngliche Variable regular_text unverändert bleibt, daher müssen Sie die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall no_space_text.

Die Methode strip() akzeptiert auch bestimmte zu entfernende Zeichen als Parameter.

regular_text = "AbC#This is a regular text.$@G#"

clean_text = regular_text.strip("AbC#$@G")

print(regular_text)
#AbC#This is a regular text.$@G#

print(clean_text)
#This is a regular text.

So erstellen Sie in Python eine ganze Zeichenfolge in Kleinbuchstaben

Verwenden Sie die Methode lower(), um eine ganze Zeichenfolge in Kleinbuchstaben umzuwandeln.

regular_text = "This is a Regular TEXT."

lower_case_text = regular_text.lower()

print(regular_text)
#This is a Regular TEXT.

print(lower_case_text)
#this is a regular text.

Beachten Sie, dass die ursprüngliche Variable regular_text unverändert bleibt. Daher müssen Sie die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall lower_case_text.

So erstellen Sie in Python einen ganzen String in Großbuchstaben

Verwenden Sie die Methode upper(), um eine ganze Zeichenfolge in Großbuchstaben umzuwandeln.

regular_text = "This is a regular text."

upper_case_text = regular_text.upper()

print(regular_text)
#This is a regular text.

print(upper_case_text)
#THIS IS A REGULAR TEXT.

Beachten Sie, dass die ursprüngliche Variable regular_text unverändert bleibt. Daher müssen Sie die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall upper_case_text.

So verwenden Sie die Groß- und Kleinschreibung von Titeln in Python

Verwenden Sie die Methode title(), um den ersten Buchstaben jedes Wortes in Großbuchstaben und die restlichen Zeichen in Kleinbuchstaben umzuwandeln.

regular_text = "This is a regular text."

title_case_text = regular_text.title()

print(regular_text)
#This is a regular text.

print(title_case_text)
#This Is A Regular Text.

Beachten Sie, dass die ursprüngliche Variable regular_text unverändert bleibt, daher müssen Sie die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall title_case_text.

So verwenden Sie Swap Case in Python

Verwenden Sie die Methode swapcase(), um die Großbuchstaben in Kleinbuchstaben umzuwandeln und umgekehrt.

regular_text = "This IS a reguLar text."

swapped_case_text = regular_text.swapcase()

print(regular_text)
#This IS a reguLar text.

print(swapped_case_text)
#tHIS is A REGUlAR TEXT.

Beachten Sie, dass die ursprüngliche Variable regular_text unverändert bleibt, daher müssen Sie die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall swapped_case_text.

So überprüfen Sie in Python, ob ein String leer ist

Die pythonische Methode, um zu überprüfen, ob ein string leer ist, ist die Verwendung des not-Operators.

my_string = ''
if not my_string:
  print("My string is empty!!!")

Um das Gegenteil zu überprüfen und festzustellen, ob die Zeichenfolge nicht leer ist, gehen Sie wie folgt vor:

my_string = 'amazon, microsoft'
if my_string:
  print("My string is NOT empty!!!")

rjust(): Wie man einen String in Python rechtsbündig ausrichtet

Verwenden Sie rjust(), um eine Zeichenfolge rechtsbündig auszurichten.

word = 'beach'
number_spaces = 32

word_justified = word.rjust(number_spaces)

print(word)
#'beach'

print(word_justified)
#'                           beach'

Beachten Sie die Leerzeichen in der zweiten Zeichenfolge. Das Wort „Strand“ hat 5 Zeichen, was uns 27 Leerzeichen gibt, die wir mit Leerzeichen füllen können.

Die ursprüngliche Variable word bleibt unverändert, daher müssen wir die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall word_justified.

Der rjust() akzeptiert auch ein bestimmtes Zeichen als Parameter, um den verbleibenden Platz zu füllen.

word = 'beach'
number_chars = 32
char = '$'

word_justified = word.rjust(number_chars, char)

print(word)
#beach

print(word_justified)
#$$$$$$$$$$$$$$$$$$$$$$$$$$$beach

Ähnlich wie in der ersten Situation habe ich 27 $-Zeichen, sodass ich insgesamt 32 habe, wenn ich die 5 Zeichen zähle, die im Wort „Strand“ enthalten sind.

ljust(): Wie man einen String in Python linksbündig ausrichtet

Verwenden Sie ljust(), um eine Zeichenfolge linksbündig auszurichten.

word = 'beach'
number_spaces = 32

word_justified = word.ljust(number_spaces)

print(word)
#'beach'

print(word_justified)
#'beach                           '

Beachten Sie die Leerzeichen in der zweiten Zeichenfolge. Das Wort „Strand“ hat 5 Zeichen, was uns 27 Leerzeichen gibt, die wir mit Leerzeichen füllen können.

Die ursprüngliche Variable word bleibt unverändert, daher müssen wir die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall word_justified.

Der ljust() akzeptiert auch ein bestimmtes Zeichen als Parameter, um den verbleibenden Platz zu füllen.

word = 'beach'
number_chars = 32
char = '$'

word_justified = word.ljust(number_chars, char)

print(word)
#beach

print(word_justified)
#beach$$$$$$$$$$$$$$$$$$$$$$$$$$$

Ähnlich wie in der ersten Situation habe ich 27 $-Zeichen, sodass ich insgesamt 32 habe, wenn ich die 5 Zeichen zähle, die im Wort „Strand“ enthalten sind.

isalnum(): So prüfen Sie in Python nur, ob eine Zeichenfolge alphanumerische Zeichen enthält

Verwenden Sie die Methode isalnum(), um zu prüfen, ob eine Zeichenfolge nur alphanumerische Zeichen enthält.

word = 'beach'
print(word.isalnum())
#output: True

word = '32'
print(word.isalnum())
#output: True

word = 'number32' #notice there is no space
print(word.isalnum())
#output: True

word = 'Favorite number is 32' #notice the space between words
print(word.isalnum())
#output: False

word = '@number32$' #notice the special chars '@' and '$'
print(word.isalnum())
#output: False

isprintable(): So prüfen Sie in Python, ob in einem String druckbare Zeichen vorhanden sind

Verwenden Sie die Methode isprintable(), um zu prüfen, ob die Zeichen in einer Zeichenfolge druckbar sind.

text = '' # notice this is an empty string, there is no white space here
print(text.isprintable())
#output: True

text = 'This is a regular text'
print(text.isprintable())
#output: True

text = ' ' #one space
print(text.isprintable())
#output: True

text = '                        '  #many spaces
print(text.isprintable())
#output: True

text = '\f\n\r\t\v'
print(text.isprintable())
#output: False

Beachten Sie, dass in den ersten vier Beispielen jedes Zeichen etwas Platz einnimmt, auch wenn es ein Leerzeichen ist, wie Sie im ersten Beispiel sehen können.

Das letzte Beispiel gibt False zurück und zeigt fünf Arten von Zeichen an, die nicht druckbare sind: Seitenvorschub \f, Zeilenvorschub \n, Wagenrücklauf \r, Tab \t und vertikaler Tab \v.

Einige dieser „unsichtbaren“ Zeichen können Ihren Ausdruck stören und zu einer unerwarteten Ausgabe führen, selbst wenn alles „in Ordnung“ aussieht.

isspace(): So prüfen Sie in Python nur, ob in einem String Leerzeichen vorhanden sind

Verwenden Sie die Methode isspace(), um zu überprüfen, ob die Zeichen in einer Zeichenfolge alle Leerzeichen sind.

text = ' '
print(text.isspace())
#output: True

text = ' \f\n\r\t\v'
print(text.isspace())
#output: True

text = '                        '
print(text.isspace())
#output: True

text = '' # notice this is an empty string, there is no white space here
print(text.isspace())
#output: False

text = 'This is a regular text'
print(text.isspace())
#output: False

Beachten Sie im zweiten Beispiel, dass Leerzeichen nicht nur ' ' sind, sondern auch Formularvorschub \f, Zeilenvorschub \n, Wagenrücklauf \r, Tab \t und vertikaler Tab \v.

Startswith(): So überprüfen Sie in Python, ob ein String mit einem bestimmten Wert beginnt

Verwenden Sie die Methode startswith(), um zu prüfen, ob eine Zeichenfolge mit einem bestimmten Wert beginnt.

phrase = "This is a regular text"

print(phrase.startswith('This is'))
#output: True

print(phrase.startswith('text'))
#output: False

Sie können auch festlegen, ob der Match an einer bestimmten Position beginnen und an einer anderen bestimmten Position der Zeichenfolge enden soll.

phrase = "This is a regular text"

print(phrase.startswith('regular', 10)) #the word regular starts at position 10 of the phrase
#output: True

print(phrase.startswith('regular', 10, 22)) #look for in 'regular text'
#output: True

print(phrase.startswith('regular', 10, 15)) ##look for in 'regul'
#output: False

Schließlich möchten Sie möglicherweise gleichzeitig nach mehreren Zeichenfolgen suchen. Anstatt eine Art Schleife zu verwenden, können Sie ein Tupel als Argument mit allen Zeichenfolgen verwenden, mit denen Sie vergleichen möchten.

phrase = "This is a regular text"

print(phrase.startswith(('regular', 'This')))
#output: True

print(phrase.startswith(('regular', 'text')))
#output: False

print(phrase.startswith(('regular', 'text'), 10, 22)) #look for in 'regular text'
#output: True

Capitalize(): So setzen Sie das erste Zeichen in einer Zeichenfolge in Python nur auf Großbuchstaben

Verwenden Sie die Methode capitalize(), um nur das erste Zeichen in einer Zeichenfolge in Großbuchstaben umzuwandeln.

Der Rest der Zeichenfolge wird in Kleinbuchstaben umgewandelt.

text = 'this is a regular text'
print(text.capitalize())
#This is a regular text

text = 'THIS IS A REGULAR TEXT'
print(text.capitalize())
#This is a regular text

text = 'THIS $ 1S @ A R3GULAR TEXT!'
print(text.capitalize())
#This $ 1s @ a r3gular text!

text = '3THIS $ 1S @ A R3GULAR TEXT!'
print(text.capitalize())
#3this $ 1s @ a r3gular text!

Beachten Sie, dass jedes Zeichen zählt, beispielsweise eine Zahl oder ein Sonderzeichen. Im letzten Beispiel ist 3 also das erste Zeichen und erfährt keine Änderungen, während der Rest der Zeichenfolge in Kleinbuchstaben umgewandelt wird.

isupper(): So prüfen Sie in Python nur, ob in einem String Großbuchstaben vorhanden sind

Verwenden Sie die Methode isupper(), um zu überprüfen, ob die Zeichen in einer Zeichenfolge alle in Großbuchstaben geschrieben sind.

text = 'This is a regular text'
print(text.isupper())
#output: False

text = 'THIS IS A REGULAR TEXT'
print(text.isupper())
#output: True

text = 'THIS $ 1S @ A R3GULAR TEXT!'
print(text.isupper())
#output: True

Wenn Sie das letzte Beispiel bemerken, machen die Zahlen und Sonderzeichen wie @ und $ in der Zeichenfolge keinen Unterschied und isupper() gibt immer noch < zurückTrue, da die Methode nur die alphabetischen Zeichen überprüft.

join(): So fügen Sie Elemente einer Iterable in Python zu einem String zusammen

Verwenden Sie die Methode join(), um alle iterierbaren Elemente zu einem String zu verknüpfen.

Die grundlegende Syntax lautet: string.join(iterable)

Gemäß der obigen Syntax ist eine Zeichenfolge als Trennzeichen erforderlich.

Die Methode gibt einen neuen String zurück, was bedeutet, dass der ursprüngliche Iterator unverändert bleibt.

Da die Methode join() nur Zeichenfolgen akzeptiert, wird ein Fehler ausgegeben, wenn ein Element im Iterable von einem anderen Typ ist.

Sehen wir uns einige Beispiele mit String, Liste, Tupel, Menge und Wörterbuch an

join(): Strings

Die Methode join() setzt das Zeichen $ als Trennzeichen für jedes Zeichen in der Zeichenfolge.

my_string = 'beach'

print('$'.join(my_string))
#output: b$e$a$c$h

join(): Listen

Ich habe eine einfache Liste mit drei Elementen, die Automarken repräsentieren.

Die Methode join() verwendet das Zeichen $ als Trennzeichen.

Es verkettet alle Elemente in der Liste und fügt dazwischen das Zeichen $ ein.

my_list = ['bmw', 'ferrari', 'mclaren']

print('$'.join(my_list))
#output: bmw$ferrari$mclaren

Dieses Beispiel erinnert Sie daran, dass join() nicht mit Nicht-String-Elementen funktioniert.

Beim Versuch, die int-Elemente zu verketten, wird ein Fehler ausgelöst.

my_list = [1, 2, 3]

print('$'.join(my_list))
#output:
#Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
#TypeError: sequence item 0: expected str instance, int found

join(): Tupel

Das Tupel folgt dem gleichen Grundprinzip wie das zuvor erläuterte Listenbeispiel.

Auch hier verwende ich das Zeichen $ als Trennzeichen.

my_tuple = ('bmw', 'ferrari', 'mclaren')

print('$'.join(my_tuple))
#output: bmw$ferrari$mclaren

join(): Setzt

Da die Menge auch mit dem Tupel und der Liste übereinstimmt, habe ich in diesem Beispiel ein anderes Trennzeichen verwendet.

my_set = {'bmw', 'ferrari', 'mclaren'}
print('|'.join(my_set))
#output: ferrari|bmw|mclaren

join(): Wörterbücher

Das Wörterbuch hat einen Haken, wenn Sie die Methode join() verwenden: Es verknüpft die Schlüssel, nicht die Werte.

Dieses Beispiel zeigt die Verkettung der Schlüssel.

my_dict = {'bmw': 'BMW I8', 'ferrari': 'Ferrari F8', 'mclaren': 'McLaren 720S'}

print(','.join(my_dict))
#output: bmw,ferrari,mclaren

splitlines(): So teilen Sie einen String an Zeilenumbrüchen in Python

Verwenden Sie die Methode splitlines(), um eine Zeichenfolge an Zeilenumbrüchen zu teilen.

Die Rückgabe der Methode ist eine Liste der Zeilen.

my_string = 'world \n cup'

print(my_string.splitlines())
#output: ['world ', ' cup']

Wenn Sie den Zeilenumbruch beibehalten möchten, akzeptiert splitlines() einen Parameter, der auf True gesetzt werden kann, der Standardwert ist False.

my_string = 'world \n cup'

print(my_string.splitlines(True))
#output: ['world \n', ' cup']

islower(): So prüfen Sie in Python nur, ob in einem String Kleinbuchstaben vorhanden sind

Verwenden Sie die Methode islower(), um zu überprüfen, ob die Zeichen in einer Zeichenfolge alle in Kleinbuchstaben geschrieben sind.

text = 'This is a regular text'
print(text.islower())
#output: False

text = 'this is a regular text'
print(text.islower())
#output: True

text = 'this $ 1s @ a r3gular text!'
print(text.islower())
#output: True

Wie Sie im letzten Beispiel bemerken, machen die Zahlen und Sonderzeichen wie @ und $ in der Zeichenfolge keinen Unterschied und islower() wird trotzdem zurückgegeben True, da die Methode nur die alphabetischen Zeichen überprüft.

isnumeric(): So prüfen Sie in Python nur auf Zahlen in einem String

Verwenden Sie die Methode isnumeric(), um zu prüfen, ob eine Zeichenfolge nur numerische Zeichen enthält.

Zu den Zahlen gehören Zahlen von 0 bis 9 und Kombinationen daraus, römische Ziffern, hochgestellte, tiefgestellte Ziffern, Brüche und andere Variationen.

word = '32'
print(word.isnumeric())
#output: True

print("\u2083".isnumeric()) #unicode for subscript 3
#output: True

print("\u2169".isnumeric()) #unicode for roman numeral X
#output: True

word = 'beach'
print(word.isnumeric())
#output: False

word = 'number32'
print(word.isnumeric())
#output: False

word = '1 2 3' #notice the space between chars
print(word.isnumeric())
#output: False

word = '@32$' #notice the special chars '@' and '$'
print(word.isnumeric())
#output: False

isdecimal() ist strenger als isdigit(), das wiederum strenger ist als isnumeric().

isdigit(): So prüfen Sie in Python nur, ob Ziffern in einer Zeichenfolge vorhanden sind

Verwenden Sie die Methode isdigit(), um zu prüfen, ob eine Zeichenfolge nur Ziffern enthält.

Zu den Ziffern gehören Zahlen von 0 bis 9 sowie hoch- und tiefgestellte Ziffern.

word = '32'
print(word.isdigit())
#output: True

print("\u2083".isdigit()) #unicode for subscript 3
#output: True

word = 'beach'
print(word.isdigit())
#output: False

word = 'number32'
print(word.isdigit())
#output: False

word = '1 2 3' #notice the space between chars
print(word.isdigit())
#output: False

word = '@32$' #notice the special chars '@' and '$'
print(word.isdigit())
#output: False

isdecimal() ist strenger als isdigit(), das wiederum strenger ist als isnumeric().

isdecimal(): So prüfen Sie in Python nur auf Dezimalstellen in einem String

Verwenden Sie die Methode isdecimal(), um zu prüfen, ob eine Zeichenfolge nur Dezimalzahlen enthält, also nur Zahlen von 0 bis 9 und Kombinationen dieser Zahlen.

Tiefgestellte, hochgestellte, römische Ziffern und andere Variationen werden als False zurückgegeben.

word = '32'
print(word.isdecimal())
#output: True

word = '954'
print(word.isdecimal())
#output: True

print("\u2083".isdecimal()) #unicode for subscript 3
#output: False

word = 'beach'
print(word.isdecimal())
#output: False

word = 'number32'
print(word.isdecimal())
#output: False

word = '1 2 3' #notice the space between chars
print(word.isdecimal())
#output: False

word = '@32$' #notice the special chars '@' and '$'
print(word.isdecimal())
#output: False

isdecimal() ist strenger als isdigit(), das wiederum strenger ist als isnumeric().

isalpha(): So prüfen Sie nur Buchstaben in einem String in Python

Verwenden Sie die Methode isalpha(), um zu prüfen, ob eine Zeichenfolge nur Buchstaben enthält.

word = 'beach'
print(word.isalpha())
#output: True

word = '32'
print(word.isalpha())
#output: False

word = 'number32'
print(word.isalpha())
#output: False

word = 'Favorite number is blue' #notice the space between words
print(word.isalpha())
#output: False

word = '@beach$' #notice the special chars '@' and '$'
print(word.isalpha())
#output: False

istitle(): So prüfen Sie, ob jedes Wort in einem String in Python mit einem Großbuchstaben beginnt

Verwenden Sie die Methode istitle(), um zu prüfen, ob das erste Zeichen in jedem Wort in einer Zeichenfolge Großbuchstaben und die anderen Zeichen Kleinbuchstaben sind.

text = 'This is a regular text'
print(text.istitle())
#output: False

text = 'This Is A Regular Text'
print(text.istitle())
#output: True

text = 'This $ Is @ A Regular 3 Text!'
print(text.istitle())
#output: True

Wie Sie im letzten Beispiel bemerken, machen die Zahlen und Sonderzeichen wie @ und $ in der Zeichenfolge keinen Unterschied und istitle() wird trotzdem zurückgegeben True, da die Methode nur die alphabetischen Zeichen überprüft.

expandtabs(): So legen Sie die Anzahl der Leerzeichen für einen Tabulator in einer Zeichenfolge in Python fest

Verwenden Sie die Methode expandtabs(), um die Anzahl der Leerzeichen für einen Tabulator festzulegen.

Sie können eine beliebige Anzahl von Leerzeichen festlegen. Wenn jedoch kein Argument angegeben wird, ist der Standardwert 8.

Grundlegende Verwendung

my_string = 'B\tR'

print(my_string.expandtabs())
#output: B       R

Beachten Sie die 7 Leerzeichen zwischen den Buchstaben B und R.

Der \t befindet sich an Position zwei nach einem Zeichen und wird daher durch 7 Leerzeichen ersetzt.

Schauen wir uns ein anderes Beispiel an.

my_string = 'WORL\tD'

print(my_string.expandtabs())
#output: WORL    D

Da WORL vier Zeichen hat, wird \t durch 4 Leerzeichen ersetzt, sodass insgesamt 8, die Standard-Tabulatorgröße, erreicht werden.

Der folgende Code gibt uns 4 Leerzeichen für den ersten Tabulator nach vier Zeichen „WORL“ und 7 Leerzeichen für den zweiten Tabulator nach einem Zeichen „D“.

my_string = 'WORL\tD\tCUP'

print(my_string.expandtabs())
#output: WORL    D       CUP

Benutzerdefinierte Tabgröße

Es ist möglich, die Tabgröße nach Bedarf festzulegen.

In diesem Beispiel ist die Tab-Größe 4, was uns 3 Leerzeichen nach dem Zeichen „B“ gibt.

my_string = 'B\tR'

print(my_string.expandtabs(4))
#output: B   R

In diesem Code ist die Tab-Größe auf 6 eingestellt, was uns 5 Leerzeichen nach dem Zeichen „B“ gibt.

my_string = 'B\tR'

print(my_string.expandtabs(6))
#output: B     R

center(): So zentrieren Sie einen String in Python

Verwenden Sie die Methode center(), um eine Zeichenfolge zu zentrieren.

word = 'beach'
number_spaces = 32

word_centered = word.center(number_spaces)

print(word)
#'beach'

print(word_centered)
##output: '              beach              '

Beachten Sie die Leerzeichen in der zweiten Zeichenfolge. Das Wort „Strand“ hat 5 Zeichen, was uns 28 Leerzeichen zum Füllen mit Leerzeichen gibt, 14 Leerzeichen davor und 14 danach, um das Wort zu zentrieren.

Die ursprüngliche Variable word bleibt unverändert, daher müssen wir die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall word_centered.

Der center() akzeptiert auch ein bestimmtes Zeichen als Parameter, um den verbleibenden Platz zu füllen.

word = 'beach'
number_chars = 33
char = '$'

word_centered = word.center(number_chars, char)

print(word)
#beach

print(word_centered)
#output: $$$$$$$$$$$$$$beach$$$$$$$$$$$$$$

Ähnlich wie in der ersten Situation habe ich 14 $ auf jeder Seite, sodass ich insgesamt 33 habe, wenn ich die 5 Zeichen zähle, die im Wort „Beach“ enthalten sind.

zfill(): So fügen Sie Nullen zu einem String in Python hinzu

Verwenden Sie zfill(), um Nullen 0 am Anfang einer Zeichenfolge einzufügen.

Die Anzahl der Nullen ergibt sich aus der als Argument übergebenen Zahl minus der Anzahl der Zeichen in der Zeichenfolge.

Das Wort „Beach“ hat 5 Zeichen, was uns 27 Leerzeichen gibt, die wir mit Nullen füllen können, um insgesamt 32 zu erhalten, wie in der Variablen size_string angegeben

word = 'beach'
size_string = 32

word_zeros = word.zfill(size_string)

print(word)
#beach

print(word_zeros)
#000000000000000000000000000beach

Die ursprüngliche Variable word bleibt unverändert, daher müssen wir die Rückgabe der Methode einer neuen Variablen zuweisen, in diesem Fall word_zeros.

Beachten Sie außerdem, dass sich nichts ändert, wenn das Argument kleiner als die Anzahl der Zeichen in der Zeichenfolge ist.

Im Beispiel unten hat „Beach“ 5 Zeichen und wir möchten Nullen hinzufügen, bis der size_string von 4 erreicht ist, was bedeutet, dass nichts getan werden muss.

word = 'beach'
size_string = 4

word_zeros = word.zfill(size_string)

print(word)
#beach

print(word_zeros)
#'beach'

find(): So überprüfen Sie in Python, ob ein String einen bestimmten Teilstring hat

Verwenden Sie die Methode find(), um zu überprüfen, ob eine Zeichenfolge eine bestimmte Teilzeichenfolge enthält.

Die Methode gibt den Index des ersten Vorkommens des angegebenen Werts zurück.

Denken Sie daran, dass die Indexzählung bei 0 beginnt.

phrase = "This is a regular text"

print(phrase.find('This'))

print(phrase.find('regular'))

print(phrase.find('text'))

0
10
18

Wenn der Wert nicht gefunden wird, wird -1 zurückgegeben.

phrase = "This is a regular text"

print(phrase.find('train'))

-1

Sie können die Suche auch an einer bestimmten Position beginnen und an einer anderen bestimmten Position der Zeichenfolge beenden.

phrase = "This is a regular text"

#look for in 'This is', the rest of the phrase is not included
print(phrase.find('This', 0, 7))

#look for in 'This is a regular'
print(phrase.find('regular', 0, 17))

#look for in 'This is a regul'
print(phrase.find('a', 0, 15))

0
10
8

So entfernen Sie ein Präfix oder Suffix in einer Zeichenfolge in Python

Ab Python 3.9 verfügt der String-Typ über zwei neue Methoden.

Sie können ein Präfix gezielt aus einer Zeichenfolge entfernen, indem Sie die Methode removeprefix() verwenden:

>>> 'Rio de Janeiro'.removeprefix("Rio")
' de Janeiro'

Oder entfernen Sie ein Suffix mit der Methode removesuffix():

>>> 'Rio de Janeiro'.removesuffix("eiro")
'Rio de Jan'

Übergeben Sie einfach als Argument den Text, der als zu entfernendes Präfix oder Suffix betrachtet werden soll, und die Methode gibt als Ergebnis eine neue Zeichenfolge zurück.

Wenn Sie neugierig sind, wie diese Funktionen zur Sprache hinzugefügt werden, empfehle ich Ihnen, den PEP 616 in der offiziellen Dokumentation zu lesen.

Dies ist eine ziemlich einfache Änderung und für Anfänger sehr hilfreich, damit sie sich an das Lesen der offiziellen Dokumentation gewöhnen können.

lstrip() vs. Removeprefix() und rstrip() vs. Removesuffix()

Das sorgt bei vielen Menschen für Verwirrung.

Es ist leicht, sich lstrip() und removeprefix() anzuschauen und sich zu fragen, was der wahre Unterschied zwischen den beiden ist.

Bei Verwendung von lstrip() besteht das Argument aus einer Reihe von führenden Zeichen, die so oft entfernt werden, wie sie vorkommen:

>>> word = 'hubbubbubboo'
>>> word.lstrip('hub')
'oo'

Während removeprefix() nur die genaue Übereinstimmung entfernt:

>>> word = 'hubbubbubboo'
>>> word.removeprefix('hub')
'bubbubboo'

Sie können die gleiche Begründung verwenden, um zwischen rstrip() und removesuffix() zu unterscheiden.

>>> word = 'peekeeneenee'
>>> word.rstrip('nee')
'peek'

>>> word = 'peekeeneenee'
>>> word.removesuffix('nee')
'peekeenee'

Und als Bonus – nur für den Fall, dass Sie noch nie mit regulären Ausdrücken gearbeitet haben: Seien Sie dankbar, dass Sie über strip() verfügen, um Zeichensätze aus einer Zeichenfolge anstelle eines regulären Ausdrucks zu entfernen:

>>> import re
>>> word = 'amazonia'
>>> word.strip('ami')
'zon'
>>> re.search('^[ami]*(.*?)[ami]*$', word).group(1)
'zon'

So funktioniert Slicing in Python

Slicing ist eines der nützlichsten Werkzeuge in der Python-Sprache.

Daher ist es wichtig, ein gutes Verständnis dafür zu haben, wie es funktioniert.

Grundlegende Slicing-Notation

Nehmen wir an, wir haben ein Array namens „list“.

list[start:stop:step]

start: wo das Schneiden beginnen soll
stop: bis dorthin, wo das Schneiden erfolgen soll, aber denken Sie daran, dass der Wert von stop nicht enthalten ist
Schritt: Wenn Sie ein Element überspringen möchten, ist der Standardwert 1, sodass Sie alle Elemente im Array durchgehen

Indizes

Beim Slicing sind die Indizes Punkte zwischen den Zeichen, nicht auf den Zeichen.

Für das Wort „Film“:

 +---+---+---+---+---+
 | m | o | v | i | e |
 +---+---+---+---+---+
 0   1   2   3   4   5 
-5  -4  -3  -2  -1

Wenn ich von 0 bis 2 schneide, erhalte ich im obigen Beispiel „mo“ und nicht „mov“.

Da es sich bei einem String nur um eine Liste von Zeichen handelt, gilt das Gleiche auch für eine Liste:

my_list = [1, 2 , 3, 4, 5]

Wird :

 +---+---+---+---+---+
 | 1 | 2 | 3 | 4 | 5 |
 +---+---+---+---+---+
 0   1   2   3   4   5 
-5  -4  -3  -2  -1

Beispiele für Slicing in Python

Wir haben eine Variable, die die Zeichenfolge „Film“ enthält, etwa so:

word = 'movie'

Alle folgenden Beispiele werden auf dieses Wort angewendet.

Beispiel 1

So erhalten Sie die ersten beiden Zeichen:

sliced = word[:2]
print(sliced)
mo

Beachten Sie, dass wir 0 hätten verwenden können, um den Anfang zu kennzeichnen, aber das ist nicht notwendig.

Beispiel 2

Der letzte Punkt:

sliced = word[-1]
print(sliced)
e

Beispiel 3

Überspringen von Buchstaben im 2er-Schritt:

sliced = word[::2]
print(sliced)
mve

So kehren Sie einen String in Python um

Um eine Zeichenfolge umzukehren, verwenden Sie die Slice-Syntax:

my_string = "ferrari"

my_string_reversed = my_string[::-1]

print(my_string)

print(my_string_reversed)

ferrari

irarref

Mit der Slice-Syntax können Sie einen Schritt festlegen, der im Beispiel -1 ist.

Der Standardschritt ist 1, d. h. es wird jeweils ein Zeichen der Zeichenfolge vorwärts gesprungen.

Wenn Sie den Schritt auf -1 setzen, ist das Gegenteil der Fall: Gehen Sie jeweils um ein Zeichen zurück.

Sie beginnen also an der Position des letzten Zeichens und bewegen sich rückwärts zum ersten Zeichen an Position 0.

Das ist es!

Herzlichen Glückwunsch zum Erreichen des Endes.

Ich möchte Ihnen dafür danken, dass Sie diesen Artikel gelesen haben.

Wenn Sie mehr erfahren möchten, schauen Sie sich meinen Blog renanmf.com an.

Denken Sie daran, eine PDF-Version dieses Python-String-Manipulationshandbuchs herunterzuladen.

Sie können mich auch auf Twitter finden: @renanmouraf.