Pythons integrierte String-Methodenanalyse

In diesem Artikel werden hauptsächlich einige der in Python integrierten String-Methoden vorgestellt, darunter Übersicht, String-Groß-/Kleinschreibung, Ausgabe des String-Formats, String-Suche, Positionierung und Ersetzung, String-Vereinigung und -Division sowie String-Bedingungen.

String-Verarbeitung ist eine sehr verbreitete Fähigkeit, aber Python verfügt über zu viele integrierte String-Methoden, die oft vergessen werden. Zum schnellen Nachschlagen ist jede integrierte Methode speziell auf der Grundlage von Python 3.5.1 geschrieben. Beispiele sind zur Vereinfachung kategorisiert Indizierung.

PS: Sie können auf den grünen Titel in der Übersicht klicken, um zur entsprechenden Kategorie zu gelangen, oder die entsprechende Methode schnell über das Artikelverzeichnis in der rechten Seitenleiste indizieren.

Groß-/Kleinschreibung umwandeln

str.capitalize()

Konvertieren Sie den ersten Buchstaben in einen Großbuchstaben. Es ist zu beachten, dass die ursprüngliche Zeichenfolge zurückgegeben wird, wenn das erste Wort nicht in Großbuchstaben geschrieben ist.

'adi dog'.capitalize()
# 'Adi dog'

'abcd Xu'.capitalize()
# 'Abcd Xu'

'Xu abcd'.capitalize()
# 'Xu abcd'

'ß'.capitalize()
# 'SS'

str. Lower()

Konvertieren Sie die Zeichenfolge in Kleinbuchstaben, was nur für ASCII-codierte Buchstaben gültig ist.

'DOBI'.lower()
# 'dobi'

'ß'.lower() # 'ß' ist ein deutscher Kleinbuchstabe, der einen weiteren Kleinbuchstaben 'ss' hat , untere Methode kann
# 'ß'

'Xu ABCD'.lower()
# 'Xu abcd'

str.casefold ( )

Konvertieren Sie die Zeichenfolge in Kleinbuchstaben. Alle entsprechenden Kleinbuchstaben in der Unicode-Kodierung werden konvertiert.

'DOBI'.casefold()
# 'dobi'

'ß'.casefold() #Der Kleinbuchstabe ß im Deutschen entspricht dem Kleinbuchstaben ss und dessen Großbuchstabe ist SS
# 'ss'

str.swapcase()

Kehren Sie die Groß- und Kleinschreibung von Zeichenfolgen um.

'Xu Dobi a123 ß'.swapcase()
#: 'Xu dOBI A123 SS' Das ß wird hier in SS umgewandelt, was ein Großbuchstabe ist
Aber es sollte beachtet werden, dass s. swapcase( ).swapcase() == s ist nicht unbedingt wahr:

u'xb5'
# 'µ'

u'xb5'.swapcase()
# 'Μ '

u'xb5'.swapcase().swapcase()
# 'μ'

hex(ord(u'xb5'.swapcase().swapcase() ))
Out[154]: '0x3bc'

Die Kleinschreibung von 'Μ' (das ist mu, nicht M) ist genau die gleiche wie die Schreibweise von 'μ'.

str.title()

Großschreiben Sie den ersten Buchstaben jedes „Worts“ in der Zeichenfolge. Die Grundlage für die Beurteilung von „Wörtern“ sind Leerzeichen und Satzzeichen. Daher treten Fehler auf, wenn englische Possessivformen oder einige englische Abkürzungen großgeschrieben werden.

'Hello world'.title()
# 'Hello World'

'Chinese abc def 12gh'.title()
# 'Chinese Abc Def 12Gh'

# Aber diese Methode ist nicht perfekt:
"they're Bill's Friends from the UK".title()
# "They're Bill's Friends From The Uk"

str.upper()

Wandelt alle Buchstaben in der Zeichenfolge in Großbuchstaben um und ignoriert automatisch Zeichen, die nicht in Großbuchstaben umgewandelt werden können.

'Chinese abc def 12gh'.upper()
# 'Chinese ABC DEF 12GH'
Es ist zu beachten, dass s.upper().isupper() nicht unbedingt wahr ist.

String-Format-Ausgabe

str.center(width[, fillchar])
Zentrieren Sie den String entsprechend der angegebenen Breite, Sie können ihn auffüllen Überschüssige Länge bei einer angegebenen Anzahl von Zeichen oder gibt die ursprüngliche Zeichenfolge zurück, wenn die angegebene Länge kleiner als die Zeichenfolgenlänge ist.

'12345'.center(10, '*')
# '**12345***'

'12345'.center(10)
# ' 12345 '
str.ljust(width[, fillchar]); str.rjust(width[, fillchar])

Gibt eine Zeichenfolge der angegebenen Länge zurück, mit dem Inhalt der Zeichenfolge auf der linken Seite (rechts) Wenn die Länge kleiner als die Länge der Zeichenfolge ist, wird die ursprüngliche Zeichenfolge zurückgegeben. Die Standardauffüllung besteht aus ASCII-Leerzeichen, und die aufgefüllte Zeichenfolge kann angegeben werden.

'dobi'.ljust(10)
# 'dobi'

'dobi'.ljust(10, '~')
# 'dobi~~~~~ ~'

'dobi'.ljust(3, '~')
# 'dobi'

'dobi'.ljust(3)
# 'dobi'
str.zfill(width)

Füllt die Zeichenfolge mit „0“ und gibt eine Zeichenfolge mit der angegebenen Breite zurück.

"42".zfill(5)
# '00042'
"-42".zfill(5)
# '-0042'

'dd' .zfill(5)
# '000dd'

'--'.zfill(5)
# '-000-'

' '.zfill(5)
# '0000 '

''.zfill(5)
# '00000'

'dddddddd'.zfill(5)
# 'dddddddd'
str.expandtabs(tabsize=8)
Ersetzt horizontale Tabulatorzeichen durch angegebene Leerzeichen, sodass der Abstand zwischen benachbarten Zeichenfolgen innerhalb der angegebenen Anzahl von Leerzeichen bleibt.

tab = '1t23t456t7890t1112131415t161718192021'

tab.expandtabs()
# '1 23 456 7890 1112131415 161718192021'
# '123456781234567812345678123456 781234567812345678' Achten Sie darauf die Beziehung zwischen der Anzahl der Leerzeichen und der Ausgabeposition oben

Tab .expandtabs(4)
# '1 23 456 7890 1112131415 161718192021'
# '12341234123412341234123412341234'
str.format(^args,^^kwargs)

Es gibt viele Syntax für die Formatierung von Zeichenfolgen. Die offiziellen Dokumente enthalten bereits relativ detaillierte Beispiele, daher werde ich hier keine Beispiele schreiben. Wer mehr über Kinderschuhe erfahren möchte, kann hier direkt klicken. Formatierungsbeispiele.

str.format_map(mapping )

Ähnlich wie str .format(*args, **kwargs), der Unterschied besteht darin, dass Mapping ein Wörterbuchobjekt ist.

People = {'name':'john', 'age':56}

'Mein Name ist {Name}, ich bin {Alter} alt'.format_map(People)
# 'Mein Name ist John, ich bin 56 alt'

Suche, Positionierung und Ersetzung von Zeichenfolgen

str.count(sub[, start[, end] ])
text = 'äußere Schutzhülle'

text.count('e')
# 4

text.count('e', 5, 11)
# 1

text.count('e', 5, 10)
# 0
str.find(sub[, start[, end]]); str.rfind(sub [, start[, end]])
text = 'äußere Schutzhülle'

text.find('er')
# 3

text.find('to ')
# -1

text.find('er', 3)
Out[121]: 3

text.find('er', 4)
Out[122]: 20

text.find('er', 4, 21)
Out[123]: -1

text.find('er', 4, 22)
Out[124]: 20

text.rfind('er')
Out[125]: 20

text.rfind('er', 20)
Out[126]: 20

text.rfind('er', 20, 21)
Out[129]: -1
str.index(sub[, start [, end]]); str.rindex(sub[, start[, end]])
Ähnlich wie find() rfind(), mit dem Unterschied, dass ein ValueError ausgelöst wird, wenn es nicht gefunden wird.

str.replace(old, new[, count])
'dog wow wow jiao'.replace('wow', 'wang')
# 'dog wang wang jiao'

'dog wow wow jiao'.replace('wow', 'wang', 1)
# 'dog wang wow jiao'

'dog wow wow jiao'.replace('wow ', 'wang', 0)
# 'dog wow wow jiao'

'dog wow wow jiao'.replace('wow', 'wang', 2)
# 'dog wang wang jiao'

'dog wow wow jiao'.replace('wow', 'wang', 3)
# 'dog wang wang jiao'
str.lstrip([chars]); str.rstrip([chars]); str.strip([chars])
' dobi'.lstrip()
# 'dobi'
'db.kun.ac.cn'.lstrip(' dbk')
# '.kun.ac.cn'

' dobi '.rstrip()
# ' dobi'
'db.kun.ac.cn'.rstrip( 'acn')
# 'db.kun.ac.'

' dobi '.strip()
# 'dobi'
'db.kun.ac.cn'.strip ('db.c')
# 'kun.ac.cn'
'db.kun.ac.cn'.strip('cbd.un')
# 'kun.a'
static str.maketrans(x[, y[, z]]); str.translate(table)
maktrans ist eine statische Methode, die zum Generieren einer Vergleichstabelle zur Verwendung durch Translate verwendet wird.
Wenn maktrans nur einen Parameter hat, muss der Parameter ein Wörterbuch sein. Der Schlüssel des Wörterbuchs ist entweder eine Unicode-Kodierung (eine Ganzzahl) oder eine Zeichenfolge der Länge 1. Der Wert des Wörterbuchs kann eine beliebige Zeichenfolge sein Unicode-Kodierung.

a = 'dobi'
ord('o')
# 111

ord('a')
# 97

hex( ord('dog'))
# '0x72d7'

b = {'d':'dobi', 111:' is ', 'b':97, 'i':'u72d7u72d7' }
table = str.maketrans(b)

a.translate(table)
# 'dobi is a dog'

Wenn maktrans zwei Parameter hat, dann Die beiden Parameter bilden eine Zuordnung, und die beiden Zeichenfolgen müssen gleich lang sein. Wenn es einen dritten Parameter gibt, muss der dritte Parameter ebenfalls eine Zeichenfolge sein, und die Zeichenfolge wird automatisch auf „Keine“ abgebildet:

a = 'dobi ist ein Hund'

table = str.maketrans('dobi', 'alph')

a.translate(table)
# 'alph hs a alg '

table = str.maketrans('dobi', 'alph', 'o')

a.translate(table)
# 'aph hs a ag'

Vereinigung und Aufteilung von Strings

str.join(iterable)

String angeben, der verkettet wird Elemente sind iterierbare Objekte von Strings.

'-'.join(['2012', '3', '12'])
# '2012-3-12'

'-'.join([ 2012, 3, 12])
# TypeError: Sequenzelement 0: erwartete Str-Instanz, int gefunden

'-'.join(['2012', '3', b'12']) #bytes ist kein String
# TypeError: Sequenzelement 2: erwartete Str-Instanz, Bytes gefunden

'-'.join(['2012'])
# '2012'

'-'.join([])
# ''

' -'.join([None])
# TypeError: Sequenzelement 0: erwartete Str-Instanz, NoneType gefunden

'-'.join([''])
# ''

','.join({'dobi':'dog', 'polly':'bird'})
# 'dobi,polly'

','.join({ 'dobi':'dog', 'polly':'bird'}.values())
# 'dog,bird'
str.partition(sep); str.rpartition(sep)
'dog wow wow jiao'.partition('wow')
# ('dog ', 'wow', ' wow jiao')

'dog wow wow jiao'.partition('dog')
# ('', 'dog', ' wow wow jiao')

'dog wow wow jiao'.partition('jiao')
# ('dog wow wow ', 'jiao', '')

'dog wow wow jiao'.partition('ww')
# ('dog wow wow jiao', '', '' )

'dog wow wow jiao'.rpartition('wow')
Out[131]: ('dog wow ', 'wow', ' jiao' )

'dog wow wow jiao'.rpartition('dog')
Out[132]: ('', 'dog', ' wow wow jiao')

'dog wow wow jiao'.rpartition('jiao')
Out[133]: ('dog wow wow ', 'jiao', '')

'dog wow wow jiao'.rpartition('ww ')
Out[135]: ('', '', 'dog wow wow jiao')
str.split(sep=None, maxsplit=-1); str.rsplit(sep=None, maxsplit=-1)
'1,2,3'.split(','), '1, 2, 3'.rsplit()
# (['1 ', '2', '3'], ['1,', '2,', '3'])

'1,2,3'.split(',', maxsplit=1 ),  '1,2,3'.rsplit(',', maxsplit=1)
# (['1', '2,3'], ['1,2', '3'])

'1 2 3'.split(), '1 2 3'.rsplit()
# (['1', '2', '3'], ['1', '2 ', '3'])

'1 2 3'.split(maxsplit=1), '1 2 3'.rsplit(maxsplit=1)
# (['1', '2 3'], ['1 2', '3'])

'   1   2   3   '.split()
# ['1', '2', '3']

'1,2,,3,'.split(','), '1,2,,3,'.rsplit(',')
# (['1', '2', '', '3', ''], ['1', '2', '', '3', ''])

''.split()
# []
''.split('a')
# ['']
'bcd'.split('a')
# ['bcd']
'bcd'.split( Keine)
# ['bcd']
str.splitlines([keepends])

字符串以行界符为分隔符拆分为列表；当 keepends 为True，拆分后保留行界符，能被识别的行界符见官方文档.

'ab cnnde fgrklrn'.splitlines()
# ['ab c', '', 'de fg ', 'kl']
'ab cnnde fgrklrn'.splitlines(keepends=True)
# ['ab cn', 'n', 'de fgr', 'klrn']

"".splitlines()， ''.split('n')      #注意两者的区别
# ([], [''])
"One line".splitlines()
# (['Eine Zeile'], ['Zwei Zeilen', ''])

字符串条件判断

str.endswith( Suffix[, Start[, Ende]]); str.startswith(prefix[, start[, end]])
text = 'äußere Schutzhülle'

text.endswith('ing')
# True

text .endswith(('gin', 'ing'))
# True
text.endswith('ter', 2, 5)
# True

text.endswith('ter ', 2, 4)
# False

str.isalnum()

字符串和数字的任意组合，即为真, 简而言之:

Die folgenden Funktionen umfassen c.isalpha(), c.isdecimal(), c.isdigit(), c.isnumeric() und c.isalnum()真。

'dobi'.isalnum()
# True

'dobi123'.isalnum()
# True

'123'.isalnum( )
# True

'徐'.isalnum()
# True

'dobi_123'.isalnum()
# False

'dobi 123'.isalnum()
# False

'%'.isalnum()
# False
str.isalpha()
Unicode 字符数据库中作为 „Letter“（这些字符一般具有 „Lm“, „Lt“, „Lu“, „Ll“ oder „Lo“. 🎜># True

'do bi'.isalpha()
# False

'dobi123'.isalpha()
# False

'徐' .isalpha()
# True

str.isdecimal(); str.isdigit(); str.isnumeric()

三个方法的区别在于对 Unicode 通用标识的真值判断范围不同:

isdecimal: Nd,
isdigit: No, Nd,

isnumeric: Nein , Nd, Nl

Der Unterschied zwischen Ziffer und Dezimalzahl besteht darin, dass einige numerische Zeichenfolgen Ziffern, aber keine Dezimalzahlen sind. Für Details klicken Sie hier

num = 'u2155'
print(num)
# ⅕
num .isdecimal(), num.isdigit(), num.isnumeric()
# (False, False, True)

num = 'u00B2'
print(num)
# ²
num.isdecimal(), num.isdigit(), num.isnumeric()
# (False, True, True)

num = "1" #unicode
num .isdecimal (), num.isdigit(), num.isnumeric()
# (Ture, True, True)

num = "'Ⅶ'"
num.isdecimal(), num .isdigit (), num.isnumeric()
# (False, False, True)

num = "十"
num.isdecimal(), num.isdigit(), num.isnumeric ()
# (Falsch, Falsch, Wahr)

num = b"1" # byte
num.isdigit() # True
num.isdecimal() # AttributeError 'bytes' Objekt hat kein Attribut 'isdecimal'
num.isnumeric() # AttributeError 'bytes' Objekt hat kein Attribut 'isnumeric'
str.isidentifier()

Bestimmen Sie, ob das string is valid ist eine gültige Kennung.

'def'.isidentifier()
# True

'with'.isidentifier()
# True

'false'.isidentifier ()
# True

'dobi_123'.isidentifier()
# True

'dobi 123'.isidentifier()
# False

'123'.isidentifier()
# False
str.islower()
'Xu'.islower()
# False

'ß'.islower() #Deutsch Großbuchstaben
# Falsch

'a Xu'.islower()
# Wahr

'ss'.islower()
# Wahr

'23'.islower()
# False

'Ab'.islower()
# False

str.isprintable()

Beurteilen Sie, ob alle Zeichen der Zeichenfolge druckbare Zeichen sind oder die Zeichenfolge leer ist. Zeichen in den Kategorien „Andere“ und „Trennzeichen“ des Unicode-Zeichensatzes sind nicht druckbare Zeichen (enthalten jedoch keine ASCII-Leerzeichen (0x20)).

'dobi123'.isprintable()
# True

'dobi123n'.isprintable()
Out[24]: False

'dobi 123' .isprintable()
# True

'dobi.123'.isprintable()
# True

''.isprintable()
# True

str.isspace()

Bestimmt, ob mindestens ein Zeichen in der Zeichenfolge vorhanden ist und alle Zeichen Leerzeichen sind.

In [29]: 'rnt'.isspace()
Out[29]: True

In [30]: ''.isspace()
Out[30 ]: False

In [31]: ' '.isspace()
Out[31]: True

str.istitle()

Bestimmen Sie, ob die Zeichen in der Zeichenfolge großgeschrieben werden und nicht alphabetische Zeichen ignoriert werden.

'So funktioniert Python'.istitle()
# True

'How Python FUNKTIONIERT'.istitle()
# False

'wie Python funktioniert '.istitle()
# False

'So funktioniert Python'.istitle()
# True

' '.istitle()
# False

''.istitle()
# Falsch

'A'.istitle()
# Wahr

'a'.istitle()
# Falsch

'Diaoshui Abc Def 123'.istitle()
# True
str.isupper()
'Xu'.isupper()
# False

'DOBI'.isupper()
Out[41]: True

'Dobi'.isupper()
# False

'DOBI123'.isupper()
# True

'DOBI 123'.isupper()
# True

'DOBIt 123'.isupper()
# True

'DOBI_123' . isupper()
# True

'_123'.isupper()
# False

String-Kodierung

str.encode(encoding="utf-8",errors="strict")

fname = 'Xu'

fname.encode('ascii')
# UnicodeEncodeError: Der Codec „ascii“ kann das Zeichen „u5f90“ nicht kodieren...

fname.encode('ascii', 'replace')
# b'?'

fname.encode('ascii', 'ignore')
# b''

fname.encode('ascii', 'xmlcharrefreplace')
# b'Xu'

fname.encode('ascii', 'backslashreplace')
# b'\u5f90'

Weitere Artikel zur integrierten String-Methodenanalyse von Python finden Sie auf der chinesischen PHP-Website !