Python Language
String-Methoden

Syntax

• str.capitalize () -> str
• str.casefold () -> str [nur für Python> 3.3]
• str.center (width [, fillchar]) -> str
• str.count (sub [, start [, end]]) -> int
• str.decode (coding = "utf-8" [, Fehler]) -> Unicode [nur in Python 2.x]
• str.encode (Kodierung = "utf-8", Fehler = "streng") -> Bytes
• str.endswith (Suffix [, Anfang [, Ende]]) -> bool
• str.expandtabs (tabsize = 8) -> str
• str.find (sub [, start [, end]]) -> int
• str.format (* args, ** kwargs) -> str
• str.format_map (Mapping) -> str
• str.index (sub [, start [, end]]) -> int
• str.isalnum () -> bool
• str.isalpha () -> bool
• str.isdecimal () -> bool
• str.isdigit () -> bool
• str.isidentifier () -> bool
• str.islower () -> bool
• str.isnumeric () -> bool
• str.isprintable () -> bool
• str.isspace () -> bool
• str.istitle () -> bool
• str.isupper () -> bool
• str.join (iterable) -> str
• str.ljust (width [, fillchar]) -> str
• str.lower () -> str
• str.lstrip ([Zeichen]) -> str
• statische Str.maketrans (x [, y [, z]])
• str.partition (sep) -> (kopf, sep, schwanz)
• str.replace (alt, neu [, Anzahl]) -> str
• str.rfind (sub [, start [, end]]) -> int
• str.rindex (sub [, start [, end]]) -> int
• str.just (width [, fillchar]) -> str
• str.rpartition (sep) -> (kopf, sep, schwanz)
• str.rsplit (sep = None, maxsplit = -1) -> Liste der Strings
• str.rstrip ([Zeichen]) -> str
• str.split (sep = None, maxsplit = -1) -> Liste der Strings
• str.splitlines ([keepends]) -> Liste der Strings
• str.startswith (Präfix [, Start [, Ende]]) -> book
• str.strip ([Zeichen]) -> str
• str.swapcase () -> str
• str.title () -> str
• str.translate (table) -> str
• str.upper () -> str
• str.zfill (width) -> str

Bemerkungen

Ändern der Großschreibung einer Zeichenfolge

Der String-Typ von Python bietet viele Funktionen, die sich auf die Großschreibung einer Zeichenfolge beziehen. Diese schließen ein :

• str.casefold
• str.upper
• str.lower
• str.capitalize
• str.title
• str.swapcase

Bei Unicode-Zeichenfolgen (der Standardeinstellung in Python 3) sind diese Vorgänge nicht 1: 1-Zuordnungen oder umkehrbar. Die meisten dieser Operationen sind eher zur Anzeige als zur Normalisierung gedacht.

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

str.upper()

str.upper nimmt jedes Zeichen in einer Zeichenfolge und konvertiert es in seine entsprechenden Großbuchstaben. Beispiel:

"This is a 'string'.".upper()
# "THIS IS A 'STRING'."

str.lower()

str.lower macht das Gegenteil; Es nimmt jedes Zeichen in einer Zeichenfolge und konvertiert es in sein Kleinbuchstaben:

"This IS a 'string'.".lower()
# "this is a 'string'."

str.capitalize()

str.capitalize gibt eine str.capitalize Version der Zeichenfolge zurück, str.capitalize , das erste Zeichen wird in Großbuchstaben geschrieben, der Rest darunter:

"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."

str.title()

str.title gibt die Titelversion des Strings zurück, d. h. jeder Buchstabe am Anfang eines Wortes wird in Großbuchstaben und alle anderen in Kleinbuchstaben geschrieben:

"this Is a 'String'".title()
# "This Is A 'String'"

str.swapcase()

str.swapcase gibt ein neues String-Objekt zurück, in dem alle Kleinbuchstaben in Großbuchstaben und alle Großbuchstaben in Kleinbuchstaben umgewandelt werden:

"this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"

Verwendung als str Klassenmethoden

Es sei darauf hingewiesen, dass diese Methoden entweder für String-Objekte (wie oben gezeigt) oder als Klassenmethode der Klasse str (mit einem expliziten Aufruf von str.upper usw.) str.upper können.

str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

Dies ist besonders nützlich, wenn eine dieser Methoden auf viele Zeichenfolgen gleichzeitig angewendet wird, beispielsweise in einer map Funktion.

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

Teilen Sie eine Zeichenfolge basierend auf einem Trennzeichen in eine Liste von Zeichenfolgen

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

str.split einen String und gibt eine Liste der Teilstrings des ursprünglichen Strings zurück. Das Verhalten hängt davon ab, ob das sep Argument angegeben oder weggelassen wird.

Wenn " sep nicht angegeben ist oder " None , erfolgt die Aufteilung überall dort, wo Leerzeichen vorhanden sind. Führende und nachgestellte Leerzeichen werden jedoch ignoriert, und mehrere aufeinanderfolgende Leerzeichen werden wie ein einzelnes Leerzeichen behandelt:

>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

Mit dem Parameter sep kann eine Trennzeichenfolge definiert werden. Die ursprüngliche Zeichenfolge wird dort aufgeteilt, wo die Trennzeichenfolge auftritt, und das Trennzeichen selbst wird verworfen. Mehrere aufeinanderfolgende Trennzeichen werden nicht wie ein einzelnes Vorkommen behandelt, sondern es werden leere Zeichenfolgen erstellt.

>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

Standardmäßig wird bei jedem Vorkommen des Trennzeichens eine maxsplit Parameter maxsplit begrenzt jedoch die Anzahl der auftretenden Aufteilungen. Der Standardwert von -1 bedeutet kein Limit:

>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

str.rsplit(sep=None, maxsplit=-1)

str.rsplit ("right split") unterscheidet sich von str.split ("left split"), wenn maxsplit angegeben wird. Die Aufteilung beginnt am Ende der Zeichenfolge und nicht am Anfang:

>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

Hinweis : Python gibt die maximale Anzahl der durchgeführten Splits an , während die meisten anderen Programmiersprachen die maximale Anzahl der erstellten Teilzeichenfolgen angeben. Dies kann zu Verwirrung beim Portieren oder Vergleichen von Code führen.

Ersetzen Sie alle Vorkommen einer Teilzeichenfolge durch eine andere Teilzeichenfolge

Der str Typ von Python verfügt auch über eine Methode, um Vorkommen einer Unterzeichenfolge durch eine andere Unterzeichenfolge in einer gegebenen Zeichenfolge zu ersetzen. Für anspruchsvollere Fälle kann re.sub .

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

str.replace zwei old und new Argumente, die die old Teilzeichenfolge enthalten, die durch die new Teilzeichenfolge ersetzt werden soll. Das optionale Argument count gibt die Anzahl der durchzuführenden Ersetzungen an:

Um beispielsweise 'foo' durch 'spam' in der folgenden Zeichenfolge zu ersetzen, können wir str.replace mit old = 'foo' und new = 'spam' aufrufen:

>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

Wenn die angegebene Zeichenfolge mehrere Beispiele enthält, die dem old Argument entsprechen, werden alle Vorkommen durch den in new Wert ersetzt:

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

es sei denn, wir liefern natürlich einen Wert für die count . In diesem Fall count gehen Vorkommen ersetzt werden:

>>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'

str.format und f-strings: Formatiert Werte in einen String

Python bietet String-Interpolations- und Formatierungsfunktionen über die in Version 2.6 eingeführte Funktion str.format und in Version 3.6 eingeführte F-Strings.

Angesichts der folgenden Variablen:

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

Die folgenden Aussagen sind alle gleichwertig

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

Als Referenz unterstützt Python auch C-Stil-Qualifizierer für die Formatierung von Zeichenfolgen. Die folgenden Beispiele entsprechen den oben genannten, die str.format Versionen werden jedoch aufgrund der Vorteile str.format Flexibilität, Konsistenz der Notation und Erweiterbarkeit bevorzugt:

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

Die für die Interpolation in str.format verwendeten str.format können auch durchnummeriert werden, um die Duplizierung beim Formatieren von Strings zu reduzieren. Zum Beispiel sind die folgenden gleichwertig:

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

Während die offizielle Python-Dokumentation wie immer gründlich genug ist, bietet pyformat.info eine Reihe von Beispielen mit detaillierten Erklärungen.

Darüber hinaus können die Zeichen { und } mit doppelten Klammern geschützt werden:

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

Weitere Informationen finden Sie unter String-Formatierung . str.format() wurde in PEP 3101 und f-strings in PEP 498 vorgeschlagen .

Zählt, wie oft ein Teilstring in einem String erscheint

Es gibt eine Methode, um die Anzahl der Vorkommen einer Unterzeichenfolge in einer anderen Zeichenfolge, str.count , zu str.count .

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

str.count gibt ein int , das die Anzahl der nicht überlappenden Vorkommen des Sub-String- sub in einem anderen String angibt. Die optionalen Argumente start und end geben den Anfang und das Ende der Suche an. Standardmäßig sind start = 0 und end = len(str) dh der gesamte String wird durchsucht:

>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

Durch die Angabe eines anderen Werts für start , end wir eine lokalisierte Suche und Zählung erhalten. Wenn start gleich 13 der Aufruf an:

>>> s.count("sea", start)
1

ist äquivalent zu:

>>> t = s[start:]
>>> t.count("sea")
1

Testen Sie die Start- und Endzeichen einer Zeichenfolge

Um den Anfang und das Ende eines bestimmten Strings in Python zu testen, können die Methoden str.startswith() und str.endswith() .

str.startswith(prefix[, start[, end]])

Wie der Name schon sagt, wird mit str.startswith getestet, ob eine angegebene Zeichenfolge mit den angegebenen Zeichen im prefix beginnt.

>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

Die optionalen Argumente start und end geben die Start- und Endpunkte an, von denen aus der Test gestartet und beendet wird. Im folgenden Beispiel wird durch Angabe eines Startwerts von 2 unsere Zeichenfolge ab Position 2 und danach gesucht:

>>> s.startswith("is", 2)
True

Dies ergibt True da s[2] == 'i' und s[3] == 's' .

Sie können ein tuple auch verwenden, um zu überprüfen, ob es mit einer Reihe von Zeichenfolgen beginnt

>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

str.endswith(prefix[, start[, end]])

str.endswith ähnelt str.endswith genau, mit dem einzigen Unterschied, dass nach Endzeichen und nicht nach str.startswith str.endswith wird. Um beispielsweise zu testen, ob eine Zeichenfolge in einem Punkt endet, kann man schreiben:

>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

wie bei startswith mehr als ein Zeichen als Endsequenz verwendet werden:

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

Sie können ein tuple auch verwenden, um zu überprüfen, ob es mit einem String-Satz endet

>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False

Testen, woraus eine Zeichenfolge besteht

Der str Typ von Python bietet auch eine Reihe von Methoden, mit denen der Inhalt eines Strings ausgewertet werden kann. Dies sind str.isalpha , str.isdigit , str.isalnum , str.isspace . Die Kapitalisierung kann mit str.isupper , str.islower und str.istitle .

str.isalpha

str.isalpha keine Argumente und gibt " True wenn alle Zeichen in einer angegebenen Zeichenfolge alphabetisch sind. Beispiel:

>>> "Hello World".isalpha()  # contains a space
False
>>> "Hello2World".isalpha()  # contains a number
False
>>> "HelloWorld!".isalpha()  # contains punctuation
False
>>> "HelloWorld".isalpha()
True

Als "".isalpha() wird der leere String bei Verwendung von "".isalpha() als "".isalpha() False "".isalpha() .

str.isupper , str.islower , str.istitle

Diese Methoden testen die Großschreibung in einer bestimmten Zeichenfolge.

str.isupper ist eine Methode, die True zurückgibt, wenn alle Zeichen in einer angegebenen Zeichenfolge Großbuchstaben sind, andernfalls False .

>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

Umgekehrt ist str.islower eine Methode, die True zurückgibt, wenn alle Zeichen in einer angegebenen Zeichenfolge Kleinbuchstaben und andernfalls False sind.

>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitle gibt True wenn die angegebene Zeichenfolge mit einem Titel versehen ist. Das heißt, jedes Wort beginnt mit einem Großbuchstaben gefolgt von Kleinbuchstaben.

>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal zurück, ob es sich bei der Zeichenfolge um eine Folge von Dezimalstellen handelt, die zur Darstellung einer Dezimalzahl geeignet ist.

str.isdigit enthält Ziffern, die sich nicht in einer für die Darstellung einer Dezimalzahl geeigneten Form befinden, wie z. B. hochgestellte Ziffern.

str.isnumeric enthält beliebige Zahlenwerte, auch wenn es sich nicht um Ziffern handelt, z. B. Werte außerhalb des Bereichs 0-9.

            isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³🄅₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

Bytestrings ( bytes in Python 3, str in Python 2) unterstützen nur isdigit , wobei nur ASCII- isdigit .

Wie bei str.isalpha wird der leere String zu False ausgewertet.

str.isalnum

Dies ist eine Kombination von str.isalpha und str.isnumeric , speziell es wertet True , wenn alle Zeichen in der angegebenen String - alphanumerische sind, das heißt, sie bestehen aus alphabetischen oder numerischen Zeichen:

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # contains whitespace
False

str.isspace

Wird als " True ausgewertet, wenn die Zeichenfolge nur Leerzeichen enthält.

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

Manchmal sieht eine Zeichenfolge „leer“ aus, aber wir wissen nicht, ob sie nur Leerzeichen oder überhaupt keine Zeichen enthält

>>> "".isspace()
False

Um diesen Fall abzudecken, benötigen wir einen zusätzlichen Test

>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

Der kürzeste Weg, um zu testen, ob eine Zeichenfolge leer ist oder nur Leerzeichen enthält, ist strip (ohne Argumente werden alle führenden und nachgestellten Leerzeichen entfernt).

>>> not my_str.strip()
True

str.translate: Zeichen in einer Zeichenfolge übersetzen

Python unterstützt eine translate für den str Typ, mit der Sie die (für die Ersetzung verwendete) Übersetzungstabelle sowie alle Zeichen angeben können, die im Prozess gelöscht werden sollen.

str.translate(table[, deletechars])

Mit der Methode maketrans ( str.maketrans in Python 3 und string.maketrans in Python 2) können Sie eine Übersetzungstabelle string.maketrans .

>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

Die translate gibt einen String zurück, der eine übersetzte Kopie des Originalstrings ist.

Sie können das table auf None wenn Sie nur Zeichen löschen müssen.

>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'

Entfernen Sie unerwünschte führende / nachgestellte Zeichen aus einer Zeichenfolge

Es stehen drei Methoden zur Verfügung, mit denen führende und nachgestellte Zeichen aus einem String entfernt werden können: str.strip , str.rstrip und str.lstrip . Alle drei Methoden haben dieselbe Signatur und alle drei geben ein neues String-Objekt zurück, wobei unerwünschte Zeichen entfernt werden.

str.strip([chars])

str.strip wirkt auf eine gegebene Zeichenkette und entfernt (Streifen) irgendwelche führenden oder nachfolgenden im Argument enthaltenen Zeichen chars ; Wenn chars nicht angegeben sind oder None , werden standardmäßig alle Leerzeichen entfernt. Zum Beispiel:

>>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

Wenn chars , werden alle darin enthaltenen Zeichen aus der zurückgegebenen Zeichenfolge entfernt. Zum Beispiel:

>>> ">>> a Python prompt".strip('> ')  # strips '>' character and space character 
'a Python prompt'

str.rstrip([chars]) und str.lstrip([chars])

Diese Methoden haben mit str.strip() ähnliche Semantiken und Argumente. Ihr Unterschied liegt in der Richtung, aus der sie beginnen. str.rstrip() beginnt am Ende des Strings, während str.lstrip() vom Anfang des Strings getrennt wird.

Verwenden Sie beispielsweise str.rstrip :

>>> "     spacious string      ".rstrip()
'     spacious string'

Während mit str.lstrip :

>>> "     spacious string      ".rstrip()
'spacious string      '

String-Vergleiche ohne Berücksichtigung von Groß- und Kleinschreibung

Ein Vergleich der Zeichenfolge ohne Berücksichtigung der Groß- und Kleinschreibung scheint etwas Triviales zu sein, ist es aber nicht. Dieser Abschnitt berücksichtigt nur Unicode-Zeichenfolgen (die Standardeinstellung in Python 3). Beachten Sie, dass Python 2 im Vergleich zu Python 3 subtile Schwächen aufweisen kann - die spätere Unicode-Verarbeitung ist viel vollständiger.

Das erste, was zu beachten ist, dass Konvertierungen, bei denen die Groß- / Kleinschreibung entfernt wird, nicht trivial sind. Es gibt Text, für den text.lower() != text.upper().lower() , beispielsweise "ß" :

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

Aber sagen wir mal, Sie wollten "BUSSE" und "Buße" . Heck, du willst wahrscheinlich auch "BUSSE" und "BUẞE" gleich vergleichen - das ist die neuere Kapitalform. Die empfohlene Methode ist die Verwendung von casefold :

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str
    
     Return a version of S suitable for caseless comparisons.
"""

Verwenden Sie nicht einfach lower . Wenn die casefold nicht verfügbar ist, hilft das Ausführen von .upper().lower() (jedoch nur etwas).

Dann sollten Sie Akzente berücksichtigen. Wenn Ihr Font-Renderer gut ist, denken Sie wahrscheinlich "ê" == "ê" - aber es funktioniert nicht:

>>> "ê" == "ê"
False

Das ist, weil sie tatsächlich sind

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

Der einfachste Weg, um damit umzugehen, ist unicodedata.normalize . Sie möchten möglicherweise die NFKD- Normalisierung verwenden, können jedoch die Dokumentation überprüfen. Dann tut man es

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

Zum Abschluss wird dies hier in Funktionen ausgedrückt:

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

Verknüpfen Sie eine Liste von Zeichenfolgen in einer Zeichenfolge

Eine Zeichenfolge kann als Trennzeichen verwendet werden, um eine Liste von Zeichenfolgen mithilfe der join() Methode zu einer einzelnen Zeichenfolge zusammenzufügen. Sie können beispielsweise eine Zeichenfolge erstellen, bei der jedes Element in einer Liste durch ein Leerzeichen getrennt ist.

>>> " ".join(["once","upon","a","time"])
"once upon a time"

Im folgenden Beispiel werden die Zeichenfolgenelemente durch drei Bindestriche getrennt.

>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"

Nützliche Konstanten des String-Moduls

Das string Modul von Python stellt Konstanten für string-bezogene Operationen bereit. Um sie zu verwenden, importieren Sie das string Modul:

>>> import string

string.ascii_letters :

Verkettung von ascii_lowercase und ascii_uppercase :

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase :

Enthält alle ASCII-Kleinbuchstaben:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase :

Enthält alle ASCII-Großbuchstaben:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits :

Enthält alle Dezimalziffern:

>>> string.digits
'0123456789'

string.hexdigits :

Enthält alle hexadezimalen Zeichen:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits :

Enthält alle Oktalzeichen:

>>> string.octaldigits
'01234567'

string.punctuation :

Enthält alle Zeichen, die im C Gebietsschema als Interpunktion gelten:

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace :

Enthält alle ASCII-Zeichen, die als Leerzeichen gelten:

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

Im Skriptmodus werden mit print(string.whitespace) die tatsächlichen Zeichen gedruckt. Verwenden Sie str , um den oben angegebenen String print(string.whitespace) .

string.printable :

Enthält alle Zeichen, die als druckbar gelten. eine Kombination aus string.digits , string.ascii_letters , string.punctuation und string.whitespace .

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

Einen String umkehren

Eine Zeichenfolge kann mit der integrierten Funktion reversed() umgekehrt werden. Diese Funktion nimmt eine Zeichenfolge und gibt einen Iterator in umgekehrter Reihenfolge zurück.

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed() kann in einen Aufruf von ''.join() , um aus dem Iterator eine Zeichenfolge zu ''.join() .

>>> ''.join(reversed('hello'))
'olleh'

Während reversed() für ungeübte Python-Benutzer möglicherweise lesbarer ist, ist die Verwendung von erweitertem Slicing mit einem Schritt von -1 schneller und übersichtlicher. Versuchen Sie es hier als Funktion zu implementieren:

>>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

Zeichenfolgen rechtfertigen

Python bietet Funktionen zum Ausrichten von Zeichenfolgen, wodurch das Auffüllen mit Text die Ausrichtung verschiedener Zeichenfolgen erheblich vereinfacht.

Unten ist ein Beispiel für str.ljust und str.rjust :

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))

  40 -> 2555 mi. (4112 km.)
  19 -> 63   mi. (102  km.)
   5 -> 1381 mi. (2222 km.)
  93 -> 189  mi. (305  km.)

ljust und rjust sind sehr ähnlich. Beide haben einen width Parameter und einen optionalen fillchar Parameter. Jeder von diesen Funktionen erstellte String ist mindestens so lang wie der width Parameter, der an die Funktion übergeben wurde. Wenn die Zeichenfolge länger als die width ist, wird sie nicht abgeschnitten. Das Argument fillchar , das standardmäßig auf das Leerzeichen ' ' muss ein einzelnes Zeichen und keine Zeichenfolge mit fillchar Zeichen sein.

Die ljust Funktion ljust das Ende des aufgerufenen Strings mit dem fillchar bis es width Zeichen lang ist. Die rjust Funktion rjust den Anfang der Saite auf ähnliche Weise auf. Daher beziehen sich l und r in den Namen dieser Funktionen auf die Seite, auf der die Originalzeichenfolge und nicht die fillchar in der Ausgabezeichenfolge positioniert ist.

Konvertierung zwischen Str. Oder Byte-Daten und Unicode-Zeichen

Der Inhalt von Dateien und Netzwerknachrichten kann verschlüsselte Zeichen darstellen. Sie müssen häufig in Unicode konvertiert werden, um eine korrekte Anzeige zu ermöglichen.

In Python 2 müssen Sie möglicherweise str-Daten in Unicode-Zeichen konvertieren. Der Standardwert ( '' , "" usw.) ist eine ASCII-Zeichenfolge, wobei alle Werte außerhalb des ASCII-Bereichs als Escape-Werte angezeigt werden. Unicode-Zeichenfolgen sind u'' (oder u"" usw.).

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc'  # s is a byte array, not a string of characters
                    # Doesn't know the original was UTF-8
                    # Default form of string literals in Python 2
s[0]                # '\xc2' - meaningless byte (without context such as an encoding)
type(s)             # str - even though it's not a useful one w/o having a known encoding

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Now we have a Unicode string, which can be read as UTF-8 and printed properly
                       # In Python 2, Unicode string literals need a leading u
                       # str.decode converts a string which may contain escaped bytes to a Unicode string
u[0]                # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode produces a string with escaped bytes for non-ASCII characters

In Python 3 müssen Sie möglicherweise Byte-Arrays (als Byte-Literal bezeichnet) in Zeichenfolgen aus Unicode-Zeichen konvertieren. Der Standardwert ist jetzt eine Unicode-Zeichenfolge, und Bytestring-Literale müssen jetzt als b'' , b"" usw. eingegeben werden. Ein Byte-Literal gibt True an isinstance(some_val, byte) , wobei some_val , dass some_val eine möglicherweise codierte Zeichenfolge ist als Bytes.

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters
                    # In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0]                # b'\xc2' - meaningless byte (without context such as an encoding)
type(s)             # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8')  # '© abc' on a Unicode terminal
                       # bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0]                # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # str
                    # The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.

String enthält

Python macht es extrem intuitiv zu überprüfen, ob eine Zeichenfolge eine gegebene Teilzeichenfolge enthält. Verwenden Sie einfach den in Operator:

>>> "foo" in "foo.baz.bar"
True

Hinweis: Das Testen einer leeren Zeichenfolge führt immer zu " True :

>>> "" in "test"
True