Zeichenfolgen und Zeichendaten in Python
Im Tutorial unter Basic Data Types in Python haben Sie gelernt, wie Sie Strings: Objekte definieren, die Sequenzen von Zeichendaten enthalten. Die Verarbeitung von Zeichendaten ist ein wesentlicher Bestandteil der Programmierung. Es ist eine seltene Anwendung, bei der Zeichenfolgen zumindest teilweise nicht bearbeitet werden müssen.
*In diesem Tutorial erfahren Sie Folgendes:* Python bietet eine Vielzahl von Operatoren, Funktionen und Methoden für die Arbeit mit Zeichenfolgen. Wenn Sie mit diesem Lernprogramm fertig sind, wissen Sie, wie Sie auf Teile von Zeichenfolgen zugreifen und diese extrahieren können, und sind mit den Methoden vertraut, die zum Bearbeiten und Ändern von Zeichenfolgendaten verfügbar sind.
Sie werden auch mit zwei anderen Python-Objekten vertraut gemacht, die zur Darstellung von Rohbyte-Daten verwendet werden, den Typen "+ Bytes " und " Bytearray +".
*__ Nehmen Sie am Quiz teil:* Testen Sie Ihr Wissen mit unserem interaktiven Quiz „Python-Zeichenfolgen und Zeichendaten“. Nach Abschluss erhalten Sie eine Punktzahl, mit der Sie Ihren Lernfortschritt im Laufe der Zeit verfolgen können:
String-Manipulation
In den folgenden Abschnitten werden die Operatoren, Methoden und Funktionen hervorgehoben, die für die Arbeit mit Zeichenfolgen verfügbar sind.
String-Operatoren
Sie haben bereits die Operatoren "+" und "+ *+" gesehen, die auf numerische Operanden im Lernprogramm unter https://realpython.com/python-operators-expressions/[Operators and Expressions in Python angewendet wurden. Diese beiden Operatoren können auch auf Zeichenfolgen angewendet werden.
Der + Operator
Der Operator + verkettet Zeichenfolgen. Es wird eine Zeichenfolge zurückgegeben, die aus den miteinander verbundenen Operanden besteht, wie hier gezeigt:
>>>
>>> s = 'foo'
>>> t = 'bar'
>>> u = 'baz'
>>> s + t
'foobar'
>>> s + t + u
'foobarbaz'
>>> print('Go team' + '!!!')
Go team!!!Der +* + Operator
Der Operator + *+ erstellt mehrere Kopien einer Zeichenfolge. Wenn "+ s " eine Zeichenfolge und " n " eine Ganzzahl ist, gibt einer der folgenden Ausdrücke eine Zeichenfolge zurück, die aus " n " verketteten Kopien von " s +" besteht:
_
+ s* n + + + n *s +
_
Hier sind Beispiele für beide Formen:
>>>
>>> s = 'foo.'
>>> s* 4
'foo.foo.foo.foo.'
>>> 4 *s
'foo.foo.foo.foo.'Der Multiplikatoroperand "+ n +" muss eine ganze Zahl sein. Man könnte meinen, es müsste eine positive Ganzzahl sein, aber amüsanterweise kann sie Null oder negativ sein. In diesem Fall ist das Ergebnis eine leere Zeichenfolge:
>>>
>>> 'foo'* -8Wenn Sie eine Zeichenfolgenvariable erstellen und sie mit der leeren Zeichenfolge initialisieren, indem Sie ihr den Wert "+" foo "* -8 +" zuweisen, würde jeder zu Recht denken, dass Sie ein bisschen dumm sind. Aber es würde funktionieren.
Der Operator "+ in +"
Python bietet auch einen Mitgliedschaftsoperator, der mit Zeichenfolgen verwendet werden kann. Der Operator "+ in " gibt " True " zurück, wenn der erste Operand im zweiten enthalten ist, und " False +" ansonsten:
>>>
>>> s = 'foo'
>>> s in 'That\'s food for thought.'
True
>>> s in 'That\'s good for now.'
FalseEs gibt auch einen Operator "+ nicht in +", der das Gegenteil bewirkt:
>>>
>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
FalseIntegrierte String-Funktionen
Wie Sie im Tutorial unter Basic Data Types in Python gesehen haben, bietet Python viele Funktionen, die in den Interpreter integriert und immer verfügbar sind. Hier sind einige, die mit Zeichenfolgen arbeiten:
| Function | Description |
|---|---|
|
Converts an integer to a character |
|
Converts a character to an integer |
|
Returns the length of a string |
|
Returns a string representation of an object |
Diese werden im Folgenden näher erläutert.
+ ord (c) +
_ Gibt einen ganzzahligen Wert für das angegebene Zeichen zurück. _
Auf der einfachsten Ebene speichern Computer alle Informationen als Zahlen. Zur Darstellung von Zeichendaten wird ein Übersetzungsschema verwendet, das jedes Zeichen seiner repräsentativen Nummer zuordnet.
Das einfachste gebräuchliche Schema heißt ASCII. Es behandelt die gebräuchlichen lateinischen Zeichen, mit denen Sie wahrscheinlich am meisten vertraut sind. Für diese Zeichen gibt + ord (c) + den ASCII-Wert für das Zeichen` + c + `zurück:
>>>
>>> ord('a')
97
>>> ord('#')
35ASCII ist soweit in Ordnung. Aber es gibt viele verschiedene Sprachen auf der Welt und unzählige Symbole und Glyphen, die in digitalen Medien erscheinen. Der vollständige Zeichensatz, der möglicherweise im Computercode dargestellt werden muss, übertrifft die üblichen lateinischen Buchstaben, Zahlen und Symbole, die Sie normalerweise sehen, bei weitem.
Unicode ist ein ehrgeiziger Standard, der versucht, auf jeder möglichen Plattform einen numerischen Code für jedes mögliche Zeichen in jeder möglichen Sprache bereitzustellen. Python 3 unterstützt Unicode umfassend, einschließlich des Zulassens von Unicode-Zeichen in Zeichenfolgen.
*Weitere Informationen:* Siehe https://docs.python.org/3/howto/unicode.html#python-s-unicode-support[Python's Unicode Support] in der Python-Dokumentation.
Solange Sie im Bereich der allgemeinen Zeichen bleiben, gibt es kaum einen praktischen Unterschied zwischen ASCII und Unicode. Die Funktion + ord () + gibt aber auch numerische Werte für Unicode-Zeichen zurück:
>>>
>>> ord('€')
8364
>>> ord('∑')
8721+ chr (n) +
_ Gibt einen Zeichenwert für die angegebene Ganzzahl zurück. _
+ chr () + macht die Umkehrung von + ord () +. Bei einem numerischen Wert "+ n " gibt " chr (n) " eine Zeichenfolge zurück, die das Zeichen darstellt, das " n +" entspricht:
>>>
>>> chr(97)
'a'
>>> chr(35)
'#'+ chr () + behandelt auch Unicode-Zeichen:
>>>
>>> chr(8364)
'€'
>>> chr(8721)
'∑'+ len (s) +
_ Gibt die Länge einer Zeichenfolge zurück. _
Mit + len () + können Sie die Länge der Python-Zeichenfolge überprüfen. + len (s) + gibt die Anzahl der Zeichen in + s + zurück:
>>>
>>> s = 'I am a string.'
>>> len(s)
14+ str (obj) +
_ Gibt eine Zeichenfolgendarstellung eines Objekts zurück. _
Praktisch jedes Objekt in Python kann als Zeichenfolge gerendert werden. + str (obj) + gibt die String-Darstellung des Objekts + obj + zurück:
>>>
>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('foo')
'foo'String-Indizierung
In Programmiersprachen kann häufig direkt auf einzelne Elemente in einem geordneten Datensatz zugegriffen werden, indem ein numerischer Index oder ein Schlüsselwert verwendet wird. Dieser Vorgang wird als Indizierung bezeichnet.
In Python sind Zeichenfolgen geordnete Sequenzen von Zeichendaten und können daher auf diese Weise indiziert werden. Auf einzelne Zeichen in einer Zeichenfolge kann zugegriffen werden, indem der Zeichenfolgenname gefolgt von einer Zahl in eckigen Klammern (+ [] +) angegeben wird.
Die Indizierung von Zeichenfolgen in Python basiert auf Null: Das erste Zeichen in der Zeichenfolge hat den Index "+ 0 ", das nächste den Index " 1 +" usw. Der Index des letzten Zeichens ist die Länge der Zeichenfolge minus eins.
Ein schematisches Diagramm der Indizes der Zeichenfolge "" foobar "" würde beispielsweise folgendermaßen aussehen:
Auf die einzelnen Zeichen kann per Index wie folgt zugegriffen werden:
>>>
>>> s = 'foobar'
>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> len(s)
6
>>> s[len(s)-1]
'r'Der Versuch, über das Ende der Zeichenfolge hinaus zu indizieren, führt zu einem Fehler:
>>>
>>> s[6]
Traceback (most recent call last):
File "<pyshell#17>", line 1, in <module>
s[6]
IndexError: string index out of rangeZeichenfolgenindizes können auch mit negativen Zahlen angegeben werden. In diesem Fall erfolgt die Indizierung ab dem Ende der Zeichenfolge rückwärts: "+ -1 " bezieht sich auf das letzte Zeichen, " -2 " auf das vorletzte Zeichen und bald. Hier ist das gleiche Diagramm, das sowohl den positiven als auch den negativen Index in der Zeichenfolge "" foobar "+" zeigt:
Hier einige Beispiele für eine negative Indizierung:
>>>
>>> s = 'foobar'
>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s)
6
>>> s[-len(s)]
'f'Der Versuch, mit negativen Zahlen über den Anfang der Zeichenfolge hinaus zu indizieren, führt zu einem Fehler:
>>>
>>> s[-7]
Traceback (most recent call last):
File "<pyshell#26>", line 1, in <module>
s[-7]
IndexError: string index out of rangeFür jede nicht leere Zeichenfolge + s + geben + s [len (s) -1] + und + s [-1] + beide das letzte Zeichen zurück. Es gibt keinen Index, der für eine leere Zeichenfolge sinnvoll ist.
Schnurschneiden
Python ermöglicht auch eine Form der Indizierungssyntax, mit der Teilzeichenfolgen aus einem String extrahiert werden. Dies wird als String-Slicing bezeichnet. Wenn "+ s " eine Zeichenfolge ist, gibt ein Ausdruck der Form " s [m: n] " den Teil von " s " zurück, beginnend mit Position " m " und bis zur Position " n +", jedoch ohne diese `:
>>>
>>> s = 'foobar'
>>> s[2:5]
'oba'*Denken Sie daran:* String-Indizes basieren auf Null. Das erste Zeichen in einer Zeichenfolge hat den Index "+ 0 +". Dies gilt sowohl für die Standardindizierung als auch für das Slicing.
Wiederum gibt der zweite Index das erste Zeichen an, das nicht im Ergebnis enthalten ist - das Zeichen "" r "" ("+ s [5] ") im obigen Beispiel. Das mag etwas unintuitiv erscheinen, aber es erzeugt dieses Ergebnis, das Sinn macht: Der Ausdruck ` s [m: n] ` gibt einen Teilstring zurück, der ` n - m +` Zeichen lang ist, in diesem Fall `+5 - 2 = 3 + `.
Wenn Sie den ersten Index weglassen, beginnt das Slice am Anfang der Zeichenfolge. Somit sind "+ s [: m] " und " s [0: m] +" äquivalent:
>>>
>>> s = 'foobar'
>>> s[:4]
'foob'
>>> s[0:4]
'foob'Wenn Sie den zweiten Index wie in + s [n:] + weglassen, erstreckt sich das Slice vom ersten Index bis zum Ende der Zeichenfolge. Dies ist eine schöne, prägnante Alternative zu den umständlicheren + s [n: len (s)] +:
>>>
>>> s = 'foobar'
>>> s[2:]
'obar'
>>> s[2:len(s)]
'obar'Für jede Zeichenfolge + s + und jede ganze Zahl` + n + ( +0 ≤ n ≤ len (s) + ) ist + s [: n] + s [n:] + gleich + s + `:
>>>
>>> s = 'foobar'
>>> s[:4] + s[4:]
'foobar'
>>> s[:4] + s[4:] == s
TrueWenn Sie beide Indizes weglassen, wird die ursprüngliche Zeichenfolge in ihrer Gesamtheit zurückgegeben. Buchstäblich. Es ist keine Kopie, sondern ein Verweis auf die ursprüngliche Zeichenfolge:
>>>
>>> s = 'foobar'
>>> t = s[:]
>>> id(s)
59598496
>>> id(t)
59598496
>>> s is t
TrueWenn der erste Index in einem Slice größer oder gleich dem zweiten Index ist, gibt Python eine leere Zeichenfolge zurück. Dies ist eine weitere verschleierte Methode, um eine leere Zeichenfolge zu generieren, falls Sie nach einer suchen:
>>>
>>> s[2:2]
>>> s[4:2]Negative Indizes können auch beim Schneiden verwendet werden. + -1 + bezieht sich auf das letzte Zeichen, + -2 + auf das vorletzte und so weiter, genau wie bei der einfachen Indizierung. Das folgende Diagramm zeigt, wie der Teilstring "" oob "" aus der Zeichenfolge "" foobar "" unter Verwendung sowohl positiver als auch negativer Indizes geschnitten wird:
Hier ist der entsprechende Python-Code:
>>>
>>> s = 'foobar'
>>> s[-5:-2]
'oob'
>>> s[1:4]
'oob'
>>> s[-5:-2] == s[1:4]
TrueAngeben eines Schrittes in einem String-Slice
Es gibt noch eine weitere Variante der Slicing-Syntax. Das Hinzufügen eines zusätzlichen +: + und eines dritten Index kennzeichnet einen Schritt (auch als Schritt bezeichnet), der angibt, wie viele Zeichen nach dem Abrufen jedes Zeichens im Slice gesprungen werden sollen.
Beispielsweise beginnt für die Zeichenfolge "" foobar "" das Slice "+0: 6: 2 +" mit dem ersten Zeichen und endet mit dem letzten Zeichen (der gesamten Zeichenfolge), und jedes zweite Zeichen wird übersprungen. Dies ist in der folgenden Abbildung dargestellt:
In ähnlicher Weise gibt "1: 6: 2 +" ein Slice an, das mit dem zweiten Zeichen (Index " 1 ") beginnt und mit dem letzten Zeichen endet, und wiederum bewirkt der Schrittwert " 2 +", dass jedes andere Zeichen ist übersprungen:
Der veranschaulichende REPL-Code wird hier gezeigt:
>>>
>>> s = 'foobar'
>>> s[0:6:2]
'foa'
>>> s[1:6:2]
'obr'Wie bei jedem Slicing können der erste und der zweite Index weggelassen werden und standardmäßig das erste bzw. das letzte Zeichen verwendet werden:
>>>
>>> s = '12345' *5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'Sie können auch einen negativen Schrittwert angeben. In diesem Fall geht Python die Zeichenfolge rückwärts durch. In diesem Fall sollte der Start-/Erstindex größer sein als der End-/Zweitindex:
>>>
>>> s = 'foobar'
>>> s[5:0:-2]
'rbo'Im obigen Beispiel bedeutet "+5: 0: -2 +" "Beginnen Sie mit dem letzten Zeichen und gehen Sie mit" + 2 + "zurück, bis zum ersten Zeichen, aber ohne es einzuschließen."
Wenn Sie einen Schritt zurücktreten und der erste und der zweite Index weggelassen werden, werden die Standardeinstellungen auf intuitive Weise umgekehrt: Der erste Index wird standardmäßig an das Ende der Zeichenfolge und der zweite Index an den Anfang gesetzt. Hier ist ein Beispiel:
>>>
>>> s = '12345'* 5
>>> s
'1234512345123451234512345'
>>> s[::-5]
'55555'Dies ist ein gängiges Paradigma für die Umkehrung einer Zeichenfolge:
>>>
>>> s = 'If Comrade Napoleon says it, it must be right.'
>>> s[::-1]
'.thgir eb tsum ti ,ti syas noelopaN edarmoC fI'Variablen in einen String interpolieren
In Python Version 3.6 wurde ein neuer Mechanismus zur Formatierung von Zeichenfolgen eingeführt. Diese Funktion wird formal als formatiertes String-Literal bezeichnet, wird jedoch üblicherweise mit dem Spitznamen f-string bezeichnet.
Die Formatierungsfunktionen von F-Strings sind umfangreich und werden hier nicht im Detail behandelt. Wenn Sie mehr erfahren möchten, lesen Sie den Real Python-Artikel Python 3’s f-Strings: Eine verbesserte String-Formatierungssyntax (Anleitung). Es gibt auch ein Tutorial zu formatierter Ausgabe, das später in dieser Reihe veröffentlicht wird und sich eingehender mit F-Strings befasst.
Eine einfache Funktion von F-Strings, die Sie sofort verwenden können, ist die variable Interpolation. Sie können einen Variablennamen direkt in einem F-String-Literal angeben, und Python ersetzt den Namen durch den entsprechenden Wert.
Angenommen, Sie möchten das Ergebnis einer arithmetischen Berechnung anzeigen. Sie können dies mit einer einfachen Anweisung + print () + tun, bei der numerische Werte und Zeichenfolgenliterale durch Kommas getrennt werden:
>>>
>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('The product of', n, 'and', m, 'is', prod)
The product of 20 and 25 is 500Das ist aber umständlich. So erreichen Sie dasselbe mit einem F-String:
-
Geben Sie entweder ein Kleinbuchstaben "+ f " oder ein Großbuchstaben " F " direkt vor dem Eröffnungszitat des String-Literal an. Dies teilt Python mit, dass es sich um eine F-Zeichenfolge anstelle einer Standardzeichenfolge handelt. *Geben Sie alle Variablen an, die in geschweiften Klammern interpoliert werden sollen (` {} +`).
Das obige Beispiel sieht mit einem F-String neu aus und sieht viel sauberer aus:
>>>
>>> n = 20
>>> m = 25
>>> prod = n* m
>>> print(f'The product of {n} and {m} is {prod}')
The product of 20 and 25 is 500Jeder der drei Anführungszeichen von Python kann zum Definieren eines F-Strings verwendet werden:
>>>
>>> var = 'Bark'
>>> print(f'A dog says {var}!')
A dog says Bark!
>>> print(f"A dog says {var}!")
A dog says Bark!
>>> print(f'''A dog says {var}!''')
A dog says Bark!Strings ändern
Kurz gesagt, Sie können nicht. Zeichenfolgen sind einer der Datentypen, die Python als unveränderlich betrachtet, dh sie können nicht geändert werden. Tatsächlich sind alle Datentypen, die Sie bisher gesehen haben, unveränderlich. (Python bietet Datentypen, die veränderbar sind, wie Sie gleich sehen werden.)
Eine solche Anweisung führt zu einem Fehler:
>>>
>>> s = 'foobar'
>>> s[3] = 'x'
Traceback (most recent call last):
File "<pyshell#40>", line 1, in <module>
s[3] = 'x'
TypeError: 'str' object does not support item assignmentIn Wahrheit müssen die Zeichenfolgen nicht viel geändert werden. In der Regel können Sie problemlos das erreichen, was Sie möchten, indem Sie eine Kopie der Originalzeichenfolge mit der gewünschten Änderung erstellen. In Python gibt es dafür sehr viele Möglichkeiten. Hier ist eine Möglichkeit:
>>>
>>> s = s[:3] + 'x' + s[4:]
>>> s
'fooxar'Es gibt auch eine integrierte String-Methode, um dies zu erreichen:
>>>
>>> s = 'foobar'
>>> s = s.replace('b', 'x')
>>> s
'fooxar'Lesen Sie weiter, um weitere Informationen zu integrierten Zeichenfolgenmethoden zu erhalten!
Integrierte String-Methoden
Sie haben im Tutorial unter Variables in Python erfahren, dass Python eine stark objektorientierte Sprache ist. Jedes Datenelement in einem Python-Programm ist ein Objekt.
Sie kennen auch Funktionen: aufrufbare Prozeduren, die Sie aufrufen können, um bestimmte Aufgaben auszuführen.
Methoden ähneln Funktionen. Eine Methode ist eine spezielle Art von aufrufbarer Prozedur, die eng mit einem Objekt verbunden ist. Wie eine Funktion wird eine Methode aufgerufen, um eine bestimmte Aufgabe auszuführen. Sie wird jedoch für ein bestimmtes Objekt aufgerufen und kennt das Zielobjekt während der Ausführung.
Die Syntax zum Aufrufen einer Methode für ein Objekt lautet wie folgt:
obj.foo(<args>)Dies ruft die Methode + .foo () + für das Objekt` + obj + auf. `+ <args> + gibt die an die Methode übergebenen Argumente an (falls vorhanden).
Sie werden später in der Diskussion der objektorientierten Programmierung viel mehr über das Definieren und Aufrufen von Methoden erfahren. Derzeit besteht das Ziel darin, einige der am häufigsten verwendeten integrierten Methoden vorzustellen, die Python für die Bearbeitung von Zeichenfolgenobjekten unterstützt.
In den folgenden Methodendefinitionen sind Argumente in eckigen Klammern (+ [] +) optional.
Fallkonvertierung
Methoden in dieser Gruppe führen eine Fallkonvertierung für die Zielzeichenfolge durch.
+ s.capitalize () +
_ Großschreibt die Zielzeichenfolge. _
+ s.capitalize () + gibt eine Kopie von + s + zurück, wobei das erste Zeichen in Großbuchstaben und alle anderen Zeichen in Kleinbuchstaben konvertiert werden:
>>>
>>> s = 'foO BaR BAZ quX'
>>> s.capitalize()
'Foo bar baz qux'Nicht alphabetische Zeichen bleiben unverändert:
>>>
>>> s = 'foo123#BAR#.'
>>> s.capitalize()
'Foo123#bar#.'+ s.lower () +
_ Konvertiert alphabetische Zeichen in Kleinbuchstaben. _
+ s.lower () + gibt eine Kopie von + s + zurück, wobei alle alphabetischen Zeichen in Kleinbuchstaben umgewandelt werden:
>>>
>>> 'FOO Bar 123 baz qUX'.lower()
'foo bar 123 baz qux'+ s.swapcase () +
_ Tauscht alphabetische Zeichen aus. _
+ s.swapcase () + gibt eine Kopie von + s + mit in Kleinbuchstaben konvertierten Großbuchstaben zurück und umgekehrt:
>>>
>>> 'FOO Bar 123 baz qUX'.swapcase()
'foo bAR 123 BAZ Qux'+ s.title () +
_ Konvertiert die Zielzeichenfolge in "Groß- und Kleinschreibung". _
+ s.title () + gibt eine Kopie von + s + zurück, in der der erste Buchstabe jedes Wortes in Großbuchstaben umgewandelt wird und die verbleibenden Buchstaben in Kleinbuchstaben geschrieben sind:
>>>
>>> 'the sun also rises'.title()
'The Sun Also Rises'Diese Methode verwendet einen ziemlich einfachen Algorithmus. Es versucht nicht, zwischen wichtigen und unwichtigen Wörtern zu unterscheiden, und es behandelt Apostrophe, Possessive oder Akronyme nicht anmutig:
>>>
>>> "what's happened to ted's IBM stock?".title()
"What'S Happened To Ted'S Ibm Stock?"+ s.upper () +
_ Konvertiert alphabetische Zeichen in Großbuchstaben. _
+ s.upper () + gibt eine Kopie von + s + mit allen in Großbuchstaben konvertierten alphabetischen Zeichen zurück:
>>>
>>> 'FOO Bar 123 baz qUX'.upper()
'FOO BAR 123 BAZ QUX'Suchen und Ersetzen
Diese Methoden bieten verschiedene Möglichkeiten zum Durchsuchen der Zielzeichenfolge nach einem bestimmten Teilstring.
Jede Methode in dieser Gruppe unterstützt optionale Argumente "+ <start> " und " <end> ". Diese werden wie beim Schneiden von Zeichenfolgen interpretiert: Die Aktion der Methode ist auf den Teil der Zielzeichenfolge beschränkt, der an der Zeichenposition ` <start> ` beginnt und bis zur Zeichenposition ` <end> ` reicht, diese jedoch nicht einschließt. Wenn " <start> " angegeben wird, " <end> " jedoch nicht, gilt die Methode für den Teil der Zielzeichenfolge von " <start> +" bis zum Ende der Zeichenfolge.
+ s.count (<sub> [, <start> [, <end>]]) +
_ Zählt das Auftreten eines Teilstrings in der Zielzeichenfolge. _
+ s.count (<sub>) + gibt die Anzahl der nicht überlappenden Vorkommen von Teilzeichenfolgen + <sub> + in + s + zurück:
>>>
>>> 'foo goo moo'.count('oo')
3Die Anzahl ist auf die Anzahl der Vorkommen innerhalb der Teilzeichenfolge beschränkt, die durch "+ <start> " und " <end> +" angegeben sind, sofern angegeben:
>>>
>>> 'foo goo moo'.count('oo', 0, 8)
2+ s.endswith (<suffix> [, <start> [, <end>]]) +
_ Legt fest, ob die Zielzeichenfolge mit einem bestimmten Teilstring endet. _
+ s.endswith (<suffix>) + gibt + True + zurück, wenn` + s + mit dem angegebenen + <suffix> + und + False + `endet, andernfalls:
>>>
>>> 'foobar'.endswith('bar')
True
>>> 'foobar'.endswith('baz')
FalseDer Vergleich ist auf den Teilstring beschränkt, der durch "+ <start> " und " <end> +" angegeben ist, wenn sie angegeben sind:
>>>
>>> 'foobar'.endswith('oob', 0, 4)
True
>>> 'foobar'.endswith('oob', 2, 4)
False+ s.find (<sub> [, <start> [, <end>]]) +
_ Durchsucht die Zielzeichenfolge nach einem bestimmten Teilstring. _
Sie können + .find () + verwenden, um festzustellen, ob eine Python-Zeichenfolge eine bestimmte Teilzeichenfolge enthält. + s.find (<sub>) + gibt den niedrigsten Index in + s + zurück, wobei Teilzeichenfolge + <sub> + gefunden wird:
>>>
>>> 'foo bar foo baz foo qux'.find('foo')
0Diese Methode gibt + -1 + zurück, wenn der angegebene Teilstring nicht gefunden wird:
>>>
>>> 'foo bar foo baz foo qux'.find('grault')
-1Die Suche ist auf die Teilzeichenfolge beschränkt, die durch "+ <start> " und " <end> +" angegeben wird, sofern angegeben:
>>>
>>> 'foo bar foo baz foo qux'.find('foo', 4)
8
>>> 'foo bar foo baz foo qux'.find('foo', 4, 7)
-1+ s.index (<sub> [, <start> [, <end>]]) +
_ Durchsucht die Zielzeichenfolge nach einem bestimmten Teilstring. _
Diese Methode ist identisch mit "+ .find () ", außer dass sie eine Ausnahme auslöst, wenn " <sub> " nicht gefunden wird, anstatt " -1 +" zurückzugeben:
>>>
>>> 'foo bar foo baz foo qux'.index('grault')
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
'foo bar foo baz foo qux'.index('grault')
ValueError: substring not found+ s.rfind (<sub> [, <start> [, <end>]]) +
_ Durchsucht die Zielzeichenfolge ab dem Ende nach einem bestimmten Teilstring. _
+ s.rfind (<sub>) + gibt den höchsten Index in + s + zurück, wobei Teilzeichenfolge + <sub> + gefunden wird:
>>>
>>> 'foo bar foo baz foo qux'.rfind('foo')
16Wie bei + .find () + wird + -1 + zurückgegeben, wenn der Teilstring nicht gefunden wird:
>>>
>>> 'foo bar foo baz foo qux'.rfind('grault')
-1Die Suche ist auf die Teilzeichenfolge beschränkt, die durch "+ <start> " und " <end> +" angegeben wird, sofern angegeben:
>>>
>>> 'foo bar foo baz foo qux'.rfind('foo', 0, 14)
8
>>> 'foo bar foo baz foo qux'.rfind('foo', 10, 14)
-1+ s.rindex (<sub> [, <start> [, <end>]]) +
_ Durchsucht die Zielzeichenfolge ab dem Ende nach einem bestimmten Teilstring. _
Diese Methode ist identisch mit "+ .rfind () ", außer dass sie eine Ausnahme auslöst, wenn " <sub> " nicht gefunden wird, anstatt " -1 +" zurückzugeben:
>>>
>>> 'foo bar foo baz foo qux'.rindex('grault')
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
'foo bar foo baz foo qux'.rindex('grault')
ValueError: substring not found+ s.startswith (<Präfix> [, <Start> [, <Ende>]]) +
_ Legt fest, ob die Zielzeichenfolge mit einem bestimmten Teilstring beginnt. _
Wenn Sie die Python-Methode + .startswith () + verwenden, gibt + s.startswith (<suffix>) + + True + zurück, wenn` + s + mit dem angegebenen + <suffix> + und beginnt + Falsch + `sonst:
>>>
>>> 'foobar'.startswith('foo')
True
>>> 'foobar'.startswith('bar')
FalseDer Vergleich ist auf den Teilstring beschränkt, der durch "+ <start> " und " <end> +" angegeben ist, wenn sie angegeben sind:
>>>
>>> 'foobar'.startswith('bar', 3)
True
>>> 'foobar'.startswith('bar', 3, 2)
FalseZeichenklassifizierung
Methoden in dieser Gruppe klassifizieren eine Zeichenfolge basierend auf den darin enthaltenen Zeichen.
+ s.isalnum () +
_ Legt fest, ob die Zielzeichenfolge aus alphanumerischen Zeichen besteht. _
+ s.isalnum () + gibt + True + zurück, wenn + s + nicht leer ist und alle seine Zeichen alphanumerisch sind (entweder ein Buchstabe oder eine Zahl), und + False + andernfalls:
>>>
>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False+ s.isalpha () +
_ Legt fest, ob die Zielzeichenfolge aus alphabetischen Zeichen besteht. _
+ s.isalpha () + gibt + True + zurück, wenn` + s + nicht leer ist und alle Zeichen alphabetisch sind, und + False + `ansonsten:
>>>
>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False+ s.isdigit () +
_ Legt fest, ob die Zielzeichenfolge aus Ziffern besteht. _
Mit der Python-Methode + .isdigit () + können Sie überprüfen, ob Ihre Zeichenfolge nur aus Ziffern besteht. + s.digit () + gibt + True + zurück, wenn` + s + nicht leer ist und alle seine Zeichen numerische Ziffern sind, und + False + `ansonsten:
>>>
>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False+ s.isidentifier () +
_ Bestimmt, ob die Zielzeichenfolge eine gültige Python-Kennung ist. _
+ s.isidentifier () + gibt + True + zurück, wenn` + s + ein gültiger Python-Bezeichner gemäß der Sprachdefinition ist, und + False + `ansonsten:
>>>
>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False*Hinweis:* `+ .isidentifier () +` gibt `+ True +` für eine Zeichenfolge zurück, die einem Python-Schlüsselwort entspricht, obwohl dies eigentlich kein gültiger Bezeichner wäre:
>>>
>>> 'and'.isidentifier()
TrueSie können testen, ob eine Zeichenfolge mit einem Python-Schlüsselwort übereinstimmt, indem Sie eine Funktion namens "+ iskeyword () " verwenden, die in einem Modul namens " keyword +" enthalten ist. Ein möglicher Weg, dies zu tun, ist unten gezeigt:
>>>
>>> from keyword import iskeyword
>>> iskeyword('and')
TrueWenn Sie wirklich sicherstellen möchten, dass eine Zeichenfolge als gültiger Python-Bezeichner dient, sollten Sie überprüfen, ob + .isidentifier () + + True + und + iskeyword () + + False + ist.
Weitere Informationen zu Python-Modulen finden Sie unter Python Modules and Packages - Eine Einführung.
+ s.islower () +
_ Legt fest, ob die alphabetischen Zeichen der Zielzeichenfolge in Kleinbuchstaben geschrieben sind. _
+ s.islower () + gibt + True + zurück, wenn` + s + nicht leer ist und alle darin enthaltenen alphabetischen Zeichen in Kleinbuchstaben geschrieben sind, andernfalls + False + `. Nicht alphabetische Zeichen werden ignoriert:
>>>
>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False+ s.isprintable () +
_ Legt fest, ob die Zielzeichenfolge vollständig aus druckbaren Zeichen besteht. _
+ s.isprintable () + gibt + True + zurück, wenn + s + leer ist oder alle darin enthaltenen alphabetischen Zeichen druckbar sind. Es gibt "+ False " zurück, wenn " s +" mindestens ein nicht druckbares Zeichen enthält. Nicht alphabetische Zeichen werden ignoriert:
>>>
>>> 'a\tb'.isprintable()
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'a\nb'.isprintable()
False*Hinweis:* Dies ist die einzige Methode "+ .isxxxx () +", die "+ True +" zurückgibt, wenn "+ s +" eine leere Zeichenfolge ist. Alle anderen geben "+ False +" für eine leere Zeichenfolge zurück.
+ s.isspace () +
_ Legt fest, ob die Zielzeichenfolge aus Leerzeichen besteht. _
+ s.isspace () + gibt + True + zurück, wenn + s + nicht leer ist und alle Zeichen Leerzeichen sind, andernfalls + False +.
Die am häufigsten vorkommenden Leerzeichen sind Leerzeichen "+" + ", Tab" + "\ t" + "und Zeilenumbruch" + "\ n" + ":
>>>
>>> ' \t \n '.isspace()
True
>>> ' a '.isspace()
FalseEs gibt jedoch einige andere ASCII-Zeichen, die als Leerzeichen gelten, und wenn Sie Unicode-Zeichen berücksichtigen, gibt es darüber hinaus einige:
>>>
>>> '\f\u2005\r'.isspace()
True(+ '\ f' + und + '\ r' + sind die Escape-Sequenzen für die ASCII-Form Feed- und Carriage Return-Zeichen; + '\ u2005' + ist die Escape-Sequenz für den Unicode Four-Per -Em Raum.)
+ s.istitle () +
_ Legt fest, ob die Zielzeichenfolge mit einem Titel versehen ist. _
+ s.istitle () + gibt + True + zurück, wenn + s + nicht leer ist, das erste alphabetische Zeichen jedes Wortes in Großbuchstaben geschrieben ist und alle anderen alphabetischen Zeichen in jedem Wort in Kleinbuchstaben geschrieben sind. Es gibt "+ False +" zurück, andernfalls:
>>>
>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True*Hinweis:* In der Python-Dokumentation wird "+ .istitle () +" folgendermaßen beschrieben, falls Sie dies intuitiver finden: "Großbuchstaben dürfen nur nicht in Großbuchstaben und Kleinbuchstaben nur in Großbuchstaben geschrieben werden."
+ s.isupper () +
_ Legt fest, ob die alphabetischen Zeichen der Zielzeichenfolge in Großbuchstaben geschrieben sind. _
+ s.isupper () + gibt + True + zurück, wenn` + s + nicht leer ist und alle darin enthaltenen alphabetischen Zeichen in Großbuchstaben und ansonsten + False + sind. Nicht alphabetische Zeichen werden ignoriert:
>>>
>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
FalseString-Formatierung
Methoden in dieser Gruppe ändern oder verbessern das Format einer Zeichenfolge.
+ s.center (<width> [, <fill>]) +
_ Zentriert eine Zeichenfolge in einem Feld. _
+ s.center (<width>) + gibt eine Zeichenfolge zurück, die aus + s + besteht und in einem Feld mit der Breite + <width> + zentriert ist. Standardmäßig besteht das Auffüllen aus dem ASCII-Leerzeichen:
>>>
>>> 'foo'.center(10)
' foo 'Wenn das optionale Argument "+ <Fill> +" angegeben ist, wird es als Füllzeichen verwendet:
>>>
>>> 'bar'.center(10, '-')
'---bar----'Wenn + s + bereits mindestens so lang ist wie + <width> +, wird es unverändert zurückgegeben:
>>>
>>> 'foo'.center(2)
'foo'+ s.expandtabs (tabsize = 8) +
_ Erweitert Registerkarten in einer Zeichenfolge. _
+ s.expandtabs () + ersetzt jedes Tabulatorzeichen (+ '\ t' +) durch Leerzeichen. Standardmäßig werden Leerzeichen unter der Annahme eines Tabulators in jeder achten Spalte ausgefüllt:
>>>
>>> 'a\tb\tc'.expandtabs()
'a b c'
>>> 'aaa\tbbb\tc'.expandtabs()
'aaa bbb c'+ tabsize + ist ein optionaler Schlüsselwortparameter, der alternative Tabstoppspalten angibt:
>>>
>>> 'a\tb\tc'.expandtabs(4)
'a b c'
>>> 'aaa\tbbb\tc'.expandtabs(tabsize=4)
'aaa bbb c'+ s.ljust (<Breite> [, <Füllung>]) +
_ Linksbündig eine Zeichenfolge im Feld. _
+ s.ljust (<width>) + gibt eine Zeichenfolge zurück, die aus + s + linksbündig in einem Feld mit der Breite + <width> + besteht. Standardmäßig besteht das Auffüllen aus dem ASCII-Leerzeichen:
>>>
>>> 'foo'.ljust(10)
'foo 'Wenn das optionale Argument "+ <Fill> +" angegeben ist, wird es als Füllzeichen verwendet:
>>>
>>> 'foo'.ljust(10, '-')
'foo-------'Wenn + s + bereits mindestens so lang ist wie + <width> +, wird es unverändert zurückgegeben:
>>>
>>> 'foo'.ljust(2)
'foo'+ s.lstrip ([<chars>]) +
_ Schneidet führende Zeichen von einer Zeichenfolge ab. _
+ s.lstrip () + gibt eine Kopie von + s + zurück, wobei alle Leerzeichen am linken Ende entfernt werden:
>>>
>>> ' foo bar baz '.lstrip()
'foo bar baz '
>>> '\t\nfoo\t\nbar\t\nbaz'.lstrip()
'foo\t\nbar\t\nbaz'Wenn das optionale Argument + <chars> + angegeben ist, ist es eine Zeichenfolge, die den zu entfernenden Zeichensatz angibt:
>>>
>>> 'http://www.realpython.com'.lstrip('/:pth')
'www.realpython.com'+ s.replace (<old>, <new> [, <count>]) +
_ Ersetzt das Auftreten eines Teilstrings innerhalb eines Strings. _
In Python können Sie zum Entfernen eines Zeichens aus einer Zeichenfolge die Python-Zeichenfolge + .replace () + verwenden. + s.replace (<old>, <new>) + gibt eine Kopie von + s + zurück, wobei alle Vorkommen von Teilzeichenfolgen + <old> + durch + <new> + ersetzt werden:
>>>
>>> 'foo bar foo baz foo qux'.replace('foo', 'grault')
'grault bar grault baz grault qux'Wenn das optionale Argument "+ <count> " angegeben ist, werden maximal " <count> " ersetzt, beginnend am linken Ende von " s +":
>>>
>>> 'foo bar foo baz foo qux'.replace('foo', 'grault', 2)
'grault bar grault baz foo qux'+ s.rjust (<width> [, <fill>]) +
_ Richtet eine Zeichenfolge in einem Feld rechtsbündig aus. _
+ s.rjust (<width>) + gibt eine Zeichenfolge zurück, die aus + s + rechtsbündig in einem Feld mit der Breite + <width> + besteht. Standardmäßig besteht das Auffüllen aus dem ASCII-Leerzeichen:
>>>
>>> 'foo'.rjust(10)
' foo'Wenn das optionale Argument "+ <Fill> +" angegeben ist, wird es als Füllzeichen verwendet:
>>>
>>> 'foo'.rjust(10, '-')
'-------foo'Wenn + s + bereits mindestens so lang ist wie + <width> +, wird es unverändert zurückgegeben:
>>>
>>> 'foo'.rjust(2)
'foo'+ s.rstrip ([<chars>]) +
_ Schneidet nachfolgende Zeichen aus einer Zeichenfolge ab. _
+ s.rstrip () + gibt eine Kopie von + s + zurück, wobei alle Leerzeichen am rechten Ende entfernt werden:
>>>
>>> ' foo bar baz '.rstrip()
' foo bar baz'
>>> 'foo\t\nbar\t\nbaz\t\n'.rstrip()
'foo\t\nbar\t\nbaz'Wenn das optionale Argument + <chars> + angegeben ist, ist es eine Zeichenfolge, die den zu entfernenden Zeichensatz angibt:
>>>
>>> 'foo.$$$;'.rstrip(';$.')
'foo'+ s.strip ([<chars>]) +
_ Entfernt Zeichen vom linken und rechten Ende einer Zeichenfolge. _
+ s.strip () + entspricht im Wesentlichen dem Aufrufen von + s.lstrip () + und + s.rstrip () + nacheinander. Ohne das Argument + <chars> + werden führende und nachfolgende Leerzeichen entfernt:
>>>
>>> s = ' foo bar baz\t\t\t'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'Wie bei + .lstrip () + und + .rstrip () + gibt das optionale Argument + <chars> + den zu entfernenden Zeichensatz an:
>>>
>>> 'www.realpython.com'.strip('w.moc')
'realpython'*Hinweis:* Wenn der Rückgabewert einer Zeichenfolgenmethode eine andere Zeichenfolge ist, wie dies häufig der Fall ist, können Methoden nacheinander aufgerufen werden, indem die Aufrufe verkettet werden:
>>>
>>> ' foo bar baz\t\t\t'.lstrip().rstrip()
'foo bar baz'
>>> ' foo bar baz\t\t\t'.strip()
'foo bar baz'
>>> 'www.realpython.com'.lstrip('w.moc').rstrip('w.moc')
'realpython'
>>> 'www.realpython.com'.strip('w.moc')
'realpython'+ s.zfill (<Breite>) +
_ Fügt links eine Zeichenfolge mit Nullen auf. _
+ s.zfill (<width>) + gibt eine Kopie von + s + links aufgefüllt mit + '0' + Zeichen auf das angegebene + <width> + zurück:
>>>
>>> '42'.zfill(5)
'00042'Wenn + s + ein führendes Vorzeichen enthält, bleibt es nach dem Einfügen von Nullen am linken Rand der Ergebniszeichenfolge:
>>>
>>> '+42'.zfill(8)
'+0000042'
>>> '-42'.zfill(8)
'-0000042'Wenn + s + bereits mindestens so lang ist wie + <width> +, wird es unverändert zurückgegeben:
>>>
>>> '-42'.zfill(3)
'-42'+ .zfill () + ist am nützlichsten für Zeichenfolgendarstellungen von Zahlen, aber Python füllt eine Zeichenfolge, die nicht:
>>>
>>> 'foo'.zfill(6)
'000foo'Konvertieren zwischen Zeichenfolgen und Listen
Methoden in dieser Gruppe konvertieren zwischen einer Zeichenfolge und einem zusammengesetzten Datentyp, indem sie entweder Objekte zu einer Zeichenfolge zusammenfügen oder eine Zeichenfolge in Teile zerlegen.
Diese Methoden arbeiten mit iterables , dem allgemeinen Python-Begriff für eine sequentielle Sammlung von Objekten. Sie werden das Innenleben von Iterables im kommenden Tutorial zur definitiven Iteration ausführlicher untersuchen.
Viele dieser Methoden geben entweder eine Liste oder ein Tupel zurück. Dies sind zwei ähnliche zusammengesetzte Datentypen, die prototypische Beispiele für Iterables in Python sind. Sie werden im nächsten Tutorial behandelt, sodass Sie sie bald kennenlernen werden! Stellen Sie sie sich bis dahin einfach als Folgen von Werten vor. Eine Liste steht in eckigen Klammern (+ [] +) und ein Tupel in Klammern (+ () +).
Schauen wir uns mit dieser Einführung diese letzte Gruppe von Zeichenfolgenmethoden an.
+ s.join (<iterable>) +
_ Verkettet Zeichenfolgen aus einer iterierbaren Zeichenfolge. _
+ s.join (<iterable>) + gibt die Zeichenfolge zurück, die sich aus der Verkettung der Objekte in + <iterable> + ergibt, getrennt durch + s +.
Beachten Sie, dass "+ .join () " für " s ", die Trennzeichenfolge, aufgerufen wird. ` <iterable> +` muss auch eine Folge von String-Objekten sein.
Einige Beispielcodes sollten zur Verdeutlichung beitragen. Im folgenden Beispiel ist das Trennzeichen "+ s " die Zeichenfolge "", "" und " <iterable> +" eine Liste von Zeichenfolgenwerten:
>>>
>>> ', '.join(['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'Das Ergebnis ist eine einzelne Zeichenfolge, die aus durch Kommas getrennten Listenobjekten besteht.
Im nächsten Beispiel wird "+ <iterable> +" als einzelner Zeichenfolgenwert angegeben. Wenn ein Zeichenfolgenwert als Iterable verwendet wird, wird er als Liste der einzelnen Zeichen der Zeichenfolge interpretiert:
>>>
>>> list('corge')
['c', 'o', 'r', 'g', 'e']
>>> ':'.join('corge')
'c:o:r:g:e'Somit ist das Ergebnis von "": ". Join (" corge ") +" eine Zeichenfolge, die aus jedem Zeichen in "" corge "" besteht, getrennt durch "": "+".
Dieses Beispiel schlägt fehl, weil eines der Objekte in + <iterable> + keine Zeichenfolge ist:
>>>
>>> '---'.join(['foo', 23, 'bar'])
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
'---'.join(['foo', 23, 'bar'])
TypeError: sequence item 1: expected str instance, int foundDies kann jedoch behoben werden:
>>>
>>> '---'.join(['foo', str(23), 'bar'])
'foo---23---bar'Wie Sie gleich sehen werden, können viele zusammengesetzte Objekte in Python als iterable Objekte ausgelegt werden, und + .join () + ist besonders nützlich, um daraus Zeichenfolgen zu erstellen.
+ s.partition (<sep>) +
_ Teilt eine Zeichenfolge basierend auf einem Trennzeichen. _
+ s.partition (<sep>) + teilt` + s + beim ersten Auftreten der Zeichenfolge + <sep> + `. Der Rückgabewert ist ein dreiteiliges Tupel, bestehend aus:
-
Der Teil von
+ s +vor` + <sep> + ` -
+ <sep> +selbst -
Der Teil von
+ s +nach+ <sep> +
Hier sind einige Beispiele für + .partition () + in Aktion:
>>>
>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')Wenn "+ <sep> " in " s " nicht gefunden wird, enthält das zurückgegebene Tupel " s +", gefolgt von zwei leeren Zeichenfolgen:
>>>
>>> 'foo.bar'.partition('@@')
('foo.bar', '', '')*Denken Sie daran:* Listen und Tupel werden im nächsten Tutorial behandelt.
+ s.rpartition (<sep>) +
_ Teilt eine Zeichenfolge basierend auf einem Trennzeichen. _
+ s.rpartition (<sep>) + funktioniert genau wie + s.partition (<sep>) +, außer dass + s + beim letzten Auftreten von + <sep> + statt geteilt wird das erste Vorkommen:
>>>
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')
>>> 'foo@@bar@@baz'.rpartition('@@')
('foo@@bar', '@@', 'baz')+ s.rsplit (sep = Keine, maxsplit = -1) +
_ Teilt eine Zeichenfolge in eine Liste von Teilzeichenfolgen auf. _
Ohne Argumente teilt + s.rsplit () + + s + in Teilzeichenfolgen auf, die durch eine beliebige Folge von Leerzeichen begrenzt sind, und gibt die Teilzeichenfolgen als Liste zurück:
>>>
>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foo\n\tbar baz\r\fqux'.rsplit()
['foo', 'bar', 'baz', 'qux']Wenn + <sep> + angegeben ist, wird es als Trennzeichen für die Aufteilung verwendet:
>>>
>>> 'foo.bar.baz.qux'.rsplit(sep='.')
['foo', 'bar', 'baz', 'qux'](Wenn "+ <sep> " mit dem Wert " None " angegeben wird, wird die Zeichenfolge durch Leerzeichen getrennt geteilt, als wäre " <sep> +" überhaupt nicht angegeben worden.)
Wenn "+ <sep> " explizit als Trennzeichen angegeben wird, wird angenommen, dass aufeinanderfolgende Trennzeichen in " s +" leere Zeichenfolgen begrenzen, die zurückgegeben werden:
>>>
>>> 'foo...bar'.rsplit(sep='.')
['foo', '', '', 'bar']Dies ist jedoch nicht der Fall, wenn + <sep> + weggelassen wird. In diesem Fall werden aufeinanderfolgende Leerzeichen zu einem einzigen Trennzeichen zusammengefasst, und die resultierende Liste enthält niemals leere Zeichenfolgen:
>>>
>>> 'foo\t\t\tbar'.rsplit()
['foo', 'bar']Wenn der optionale Schlüsselwortparameter "+ <maxsplit> " angegeben wird, werden maximal so viele Teilungen ausgeführt, beginnend am rechten Ende von " s +":
>>>
>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=1)
['www.realpython', 'com']Der Standardwert für "+ <maxsplit> " ist " -1 ", was bedeutet, dass alle möglichen Teilungen durchgeführt werden sollten - genauso, als ob " <maxsplit> +" vollständig weggelassen wird:
>>>
>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=-1)
['www', 'realpython', 'com']
>>> 'www.realpython.com'.rsplit(sep='.')
['www', 'realpython', 'com']+ s.split (sep = Keine, maxsplit = -1) +
_ Teilt eine Zeichenfolge in eine Liste von Teilzeichenfolgen auf. _
+ s.split () + verhält sich genau wie + s.rsplit () +, außer dass, wenn + <maxsplit> + angegeben wird, Teilungen vom linken Ende von + s + anstatt vom gezählt werden rechtes Ende:
>>>
>>> 'www.realpython.com'.split('.', maxsplit=1)
['www', 'realpython.com']
>>> 'www.realpython.com'.rsplit('.', maxsplit=1)
['www.realpython', 'com']Wenn "+ <maxsplit> " nicht angegeben ist, sind " .split () " und " .rsplit () +" nicht zu unterscheiden.
+ s.splitlines ([<keepends>]) +
_ Bricht eine Zeichenfolge an den Liniengrenzen. _
+ s.splitlines () + teilt` + s + `in Zeilen auf und gibt sie in einer Liste zurück. Jedes der folgenden Zeichen oder Zeichenfolgen wird als Liniengrenze betrachtet:
| Escape Sequence | Character |
|---|---|
|
Newline |
|
Carriage Return |
|
Carriage Return + Line Feed |
|
Line Tabulation |
|
Form Feed |
|
File Separator |
|
Group Separator |
|
Record Separator |
|
Next Line (C1 Control Code) |
|
Unicode Line Separator |
|
Unicode Paragraph Separator |
Hier ist ein Beispiel mit mehreren verschiedenen Zeilentrennzeichen:
>>>
>>> 'foo\nbar\r\nbaz\fqux\u2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']Wenn aufeinanderfolgende Zeilenbegrenzungszeichen in der Zeichenfolge vorhanden sind, wird davon ausgegangen, dass sie Leerzeilen begrenzen, die in der Ergebnisliste angezeigt werden:
>>>
>>> 'foo\f\f\fbar'.splitlines()
['foo', '', '', 'bar']Wenn das optionale Argument "+ <hält> +" angegeben und wahr ist, werden die Zeilengrenzen in den Ergebniszeichenfolgen beibehalten:
>>>
>>> 'foo\nbar\nbaz\nqux'.splitlines(True)
['foo\n', 'bar\n', 'baz\n', 'qux']
>>> 'foo\nbar\nbaz\nqux'.splitlines(1)
['foo\n', 'bar\n', 'baz\n', 'qux']+ Bytes + Objekte
Das Objekt "+ Bytes " ist einer der integrierten Kerntypen zum Bearbeiten von Binärdaten. Ein ` Bytes +` Objekt ist eine unveränderliche Folge einzelner byte Werte. Jedes Element in einem + Bytes + -Objekt ist eine kleine Ganzzahl im Bereich von + 0 + bis + 255 +.
Definieren eines Literal + Bytes + Objekts
Ein + Bytes + Literal wird auf die gleiche Weise wie ein String-Literal definiert, wobei ein + 'b' + Präfix hinzugefügt wird:
>>>
>>> b = b'foo bar baz'
>>> b
b'foo bar baz'
>>> type(b)
<class 'bytes'>Wie bei Zeichenfolgen können Sie einen der einfachen, doppelten oder dreifachen Anführungszeichen verwenden:
>>>
>>> b'Contains embedded "double" quotes'
b'Contains embedded "double" quotes'
>>> b"Contains embedded 'single' quotes"
b"Contains embedded 'single' quotes"
>>> b'''Contains embedded "double" and 'single' quotes'''
b'Contains embedded "double" and \'single\' quotes'
>>> b"""Contains embedded "double" and 'single' quotes"""
b'Contains embedded "double" and \'single\' quotes'In einem + Bytes + Literal sind nur ASCII-Zeichen zulässig. Jeder Zeichenwert größer als "+ 127 +" muss mit einer geeigneten Escape-Sequenz angegeben werden:
>>>
>>> b = b'foo\xddbar'
>>> b
b'foo\xddbar'
>>> b[3]
221
>>> int(0xdd)
221Das Präfix "" r "" kann für ein "+ Bytes +" - Literal verwendet werden, um die Verarbeitung von Escape-Sequenzen zu deaktivieren, wie bei Zeichenfolgen:
>>>
>>> b = rb'foo\xddbar'
>>> b
b'foo\\xddbar'
>>> b[3]
92
>>> chr(92)
'\\'Definieren eines + Bytes + Objekts mit der eingebauten Funktion` + Bytes () + `
Die Funktion + bytes () + erstellt auch ein + bytes + Objekt. Welche Art von + Bytes + Objekt zurückgegeben wird, hängt von den an die Funktion übergebenen Argumenten ab. Die möglichen Formen sind unten gezeigt.
+ Bytes (<s>, <Kodierung>) +
_ Erstellt ein + Bytes + Objekt aus einer Zeichenfolge. _
+ bytes (<s>, <encoding>) + konvertiert den String + <s> + in ein + bytes + Objekt, wobei + str.encode () + gemäß der angegebenen `+ <encoding> verwendet wird + `:
>>>
>>> b = bytes('foo.bar', 'utf8')
>>> b
b'foo.bar'
>>> type(b)
<class 'bytes'>*Technischer Hinweis:* In dieser Form der Funktion "+ bytes () +" ist das Argument "+ <Kodierung> +" erforderlich. "Codierung" bezieht sich auf die Art und Weise, wie Zeichen in ganzzahlige Werte übersetzt werden. Ein Wert von "+" utf8 "+" gibt das Unicode-Transformationsformat *UTF-8* an, eine Codierung, die jedes mögliche Unicode-Zeichen verarbeiten kann. UTF-8 kann auch durch Angabe von "+" UTF8 "+", "+" utf-8 "+" oder "+" UTF-8 "+" für "+ <Codierung> +" angegeben werden.
Weitere Informationen finden Sie in der Unicode-Dokumentation. Solange Sie mit gängigen lateinischen Zeichen arbeiten, wird UTF-8 Ihnen gute Dienste leisten.
+ Bytes (<Größe>) +
_
Erstellt ein + Bytes + Objekt, das aus null (+ 0x00 +) Bytes besteht.
_
+ bytes (<size>) + definiert ein + bytes + Objekt des angegebenen + <size> +, das eine positive ganze Zahl sein muss. Das resultierende + Bytes + Objekt wird mit null (+ 0x00 +) Bytes initialisiert:
>>>
>>> b = bytes(8)
>>> b
b'\x00\x00\x00\x00\x00\x00\x00\x00'
>>> type(b)
<class 'bytes'>+ Bytes (<iterable>) +
_
Erstellt ein + Bytes + Objekt aus einem iterablen Objekt.
_
+ bytes (<iterable>) + definiert ein + bytes + Objekt aus der Folge von Ganzzahlen, die von + <iterable> + generiert werden. + <iterable> + muss eine Iterable sein, die eine Folge von ganzen Zahlen + n + im Bereich +0 ≤ n ≤ 255 + erzeugt:
>>>
>>> b = bytes([100, 102, 104, 106, 108])
>>> b
b'dfhjl'
>>> type(b)
<class 'bytes'>
>>> b[2]
104Operationen an + Bytes + Objekten
Wie Zeichenfolgen unterstützen + Bytes + Objekte die allgemeinen Sequenzoperationen:
-
Die Operatoren "+ in " und " nicht in +":
>>>
>>> b = b'abcde'
>>> b'cd' in b
True
>>> b'foo' not in b
True*Die Operatoren Verkettung (`+++`) und Replikation (`+* +`):
>>>
>>> b = b'abcde'
>>> b + b'fghi'
b'abcdefghi'
>>> b * 3
b'abcdeabcdeabcde'-
Indizieren und Schneiden:
>>>
>>> b = b'abcde'
>>> b[2]
99
>>> b[1:3]
b'bc'-
Eingebaute Funktionen:
>>>
>>> len(b)
5
>>> min(b)
97
>>> max(b)
101Viele der für String-Objekte definierten Methoden gelten auch für + Bytes + Objekte:
>>>
>>> b = b'foo,bar,foo,baz,foo,qux'
>>> b.count(b'foo')
3
>>> b.endswith(b'qux')
True
>>> b.find(b'baz')
12
>>> b.split(sep=b',')
[b'foo', b'bar', b'foo', b'baz', b'foo', b'qux']
>>> b.center(30, b'-')
b'---foo,bar,foo,baz,foo,qux----'Beachten Sie jedoch, dass beim Aufrufen dieser Operatoren und Methoden für ein Objekt "+ Bytes " der Operand und die Argumente ebenfalls " Bytes +" Objekte sein müssen:
>>>
>>> b = b'foo.bar'
>>> b + '.baz'
Traceback (most recent call last):
File "<pyshell#72>", line 1, in <module>
b + '.baz'
TypeError: can't concat bytes to str
>>> b + b'.baz'
b'foo.bar.baz'
>>> b.split(sep='.')
Traceback (most recent call last):
File "<pyshell#74>", line 1, in <module>
b.split(sep='.')
TypeError: a bytes-like object is required, not 'str'
>>> b.split(sep=b'.')
[b'foo', b'bar']Obwohl eine Objektdefinition und -darstellung von + + Bytes + auf ASCII-Text basiert, verhält sie sich tatsächlich wie eine unveränderliche Folge kleiner Ganzzahlen im Bereich von + 0 + bis einschließlich + 255 . Aus diesem Grund wird ein einzelnes Element aus einem " Bytes +" - Objekt als Ganzzahl angezeigt:
>>>
>>> b = b'foo\xddbar'
>>> b[3]
221
>>> hex(b[3])
'0xdd'
>>> min(b)
97
>>> max(b)
221Ein Slice wird jedoch als + Bytes + Objekt angezeigt, auch wenn es nur ein Byte lang ist:
>>>
>>> b[2:3]
b'c'Sie können ein + Bytes + -Objekt mit der integrierten Funktion + list () + `in eine Liste von Ganzzahlen konvertieren:
>>>
>>> list(b)
[97, 98, 99, 100, 101]Hexadezimalzahlen werden häufig verwendet, um Binärdaten anzugeben, da zwei Hexadezimalzahlen direkt einem einzelnen Byte entsprechen. Die Klasse "+ Bytes +" unterstützt zwei zusätzliche Methoden, die die Konvertierung in und aus einer Folge von hexadezimalen Ziffern erleichtern.
+ bytes.fromhex (<s>) +
_
Gibt ein + Bytes + Objekt zurück, das aus einer Folge von Hexadezimalwerten erstellt wurde.
_
+ bytes.fromhex (<s>) + gibt das Objekt + bytes + zurück, das sich aus der Konvertierung jedes hexadezimalen Ziffernpaars in + <s> + in den entsprechenden Bytewert ergibt. Die hexadezimalen Ziffernpaare in + <s> + können optional durch Leerzeichen getrennt werden, was ignoriert wird:
>>>
>>> b = bytes.fromhex(' aa 68 4682cc ')
>>> b
b'\xaahF\x82\xcc'
>>> list(b)
[170, 104, 70, 130, 204]*Hinweis:* Diese Methode ist eine Klassenmethode, keine Objektmethode. Es ist an die Klasse "+ Bytes +" gebunden, nicht an ein Objekt "+ Bytes +". In den kommenden Tutorials unter https://realpython.com/python3-object-oriented-programming/[object-oriented programming] werden Sie sich eingehender mit der Unterscheidung zwischen Klassen, Objekten und ihren jeweiligen Methoden befassen. Beachten Sie vorerst nur, dass diese Methode für die Klasse `+ bytes +` aufgerufen wird, nicht für das Objekt `+ b +`.
+ b.hex () +
_
Gibt eine Zeichenfolge mit hexadezimalem Wert von einem + Bytes + Objekt zurück.
_
+ b.hex () + gibt das Ergebnis der Konvertierung von + Bytes + Objekt` + b + in eine Folge von hexadezimalen Ziffernpaaren zurück. Das heißt, es macht das Gegenteil von `+ .fromhex () +:
>>>
>>> b = bytes.fromhex(' aa 68 4682cc ')
>>> b
b'\xaahF\x82\xcc'
>>> b.hex()
'aa684682cc'
>>> type(b.hex())
<class 'str'>*Hinweis:* Im Gegensatz zu "+ .fromhex () +" ist "+ .hex () +" eine Objektmethode, keine Klassenmethode. Daher wird es für ein Objekt der Klasse "+ Bytes +" aufgerufen, nicht für die Klasse selbst.
+ bytearray + Objekte
Python unterstützt einen anderen binären Sequenztyp namens "+ bytearray ". ` bytearray ` Objekte sind trotz einiger Unterschiede sehr ähnlich wie ` bytes +` Objekte:
-
In Python ist keine dedizierte Syntax zum Definieren eines "+ bytearray " - Literals integriert, wie das Präfix "" b "", das zum Definieren eines " bytes " - Objekts verwendet werden kann. Ein ` bytearray ` Objekt wird immer mit der eingebauten Funktion ` bytearray () +` erstellt:
>>>
>>> ba = bytearray('foo.bar.baz', 'UTF-8')
>>> ba
bytearray(b'foo.bar.baz')
>>> bytearray(6)
bytearray(b'\x00\x00\x00\x00\x00\x00')
>>> bytearray([100, 102, 104, 106, 108])
bytearray(b'dfhjl')*`+ bytearray +` Objekte sind veränderlich. Sie können den Inhalt eines `+ bytearray +` Objekts durch Indizieren und Schneiden ändern:
>>>
>>> ba = bytearray('foo.bar.baz', 'UTF-8')
>>> ba
bytearray(b'foo.bar.baz')
>>> ba[5] = 0xee
>>> ba
bytearray(b'foo.b\xeer.baz')
>>> ba[8:11] = b'qux'
>>> ba
bytearray(b'foo.b\xeer.qux')Ein + Bytearray + Objekt kann auch direkt aus einem + Bytes + Objekt erstellt werden:
>>>
>>> ba = bytearray(b'foo')
>>> ba
bytearray(b'foo')Fazit
Dieses Tutorial bot einen detaillierten Einblick in die vielen verschiedenen Mechanismen, die Python für die* String *-Handhabung bereitstellt, einschließlich String-Operatoren, integrierten Funktionen, Indizierung, Slicing und integrierten Methoden. Sie wurden auch in die Typen "+ Bytes " und " Bytearray +" eingeführt.
Diese Typen sind die ersten Typen, die Sie untersucht haben und die aus einer Sammlung kleinerer Teile zusammengesetzt sind. Python bietet mehrere integrierte Composite-Typen. Im nächsten Tutorial werden Sie zwei der am häufigsten verwendeten kennenlernen:* Listen und Tupel *.
*__ Nehmen Sie am Quiz teil:* Testen Sie Ihr Wissen mit unserem interaktiven Quiz „Python-Zeichenfolgen und Zeichendaten“. Nach Abschluss erhalten Sie eine Punktzahl, mit der Sie Ihren Lernfortschritt im Laufe der Zeit verfolgen können: