Was sind die gängigen Methoden für das Python-String-Slicing?

1. Slicing:

bezieht sich auf den Vorgang des Abfangens eines Teils des Operationsobjekts. Strings, Listen und Tupel unterstützen alle Slicing-Vorgänge.

Syntax:

Sequenz [Startpositionsindex: Endpositionsindex: Schritt Größe], ​​enthält nicht die Indexdaten der Endposition, die Schrittgröße ist das Auswahlintervall, entweder positiv oder negativ, der Standardwert ist 1

Zum Beispiel:

str = 'abcdefg_a'
print(str[1:6:2], str[2:6], str[:3], str[3:], str[:])
print(str[::2], str[:-2], str[-6:-2], str[::-2], str[::-1])
print(str[-2:], str[2:-2], str[-2::-2], str[:-2:2], str[2:-2:2])
 
输出：
bdf cdef abc defg_a abcdefg_a
acega abcdefg defg ageca a_gfedcba
_a cdefg _fdb aceg ceg

2. Gängige Methoden

2.1 Suche

Zeichenfolge suchen:

Das heißt, die Position oder die Anzahl des Vorkommens der Teilzeichenfolge in der Zeichenfolge ermitteln

find():
• Erkennen Sie, ob eine bestimmte Zeichenfolge in einer bestimmten Zeichenfolge enthalten ist, und geben Sie diese zurück, wenn sie vorhanden ist Startposition des Substring-Index, andernfalls gibt

  -1 zurück

Syntax:
• String sequence.find (Substring, Startposition-Index, Endposition-Index)

index():
• Erkennen Sie, ob eine bestimmte Teilzeichenfolge In einer bestimmten Zeichenfolge enthalten. Wenn vorhanden, wird der Anfangspositionsindex der Teilzeichenfolge zurückgegeben. Andernfalls wird eine Ausnahme gemeldet. Syntax: String sequence.index (Teilzeichenfolge, Anfangspositionsindex, Endpositionsindex)
  rfind():
hat die gleiche Funktion wie find(), aber die Suchrichtung beginnt von rechts, d. h. die letzte Vorkommensposition des Teilstrings wird zurückgegeben

• rindex():

  und index() Die Funktion ist dieselbe, aber die Suchrichtung beginnt von rechts, d erscheint in der Zeichenfolge

• Zum Beispiel:

  str = 'abcdefg_a'
  print('-------------------查找-------------------')
  print(str.find('c'), str.find('fg', 2, ), str.find('a', 2), str.find('h'))
  print(str.index('c'), str.index('fg', 2, ), str.index('a', 2))
  print(str.find('a'), str.rfind('a'), str.index('a'), str.rindex('a'), str.count('a'))
  print(str.index('h'))
   
  输出：
  -------------------查找-------------------
  2 5 8 -1
  2 5 8
  0 8 0 8 2
  ValueError: substring not found

2.2 Ändern

• Zeichenfolge ändern: Ändern Sie die Daten in der Zeichenfolge über die Funktionsform

• replace(): Ersetzen

Syntax: String sequence.replace(alter Teilstring, neuer Teilstring, Maximale Anzahl an Ersetzungen)

split(): Teilt den String entsprechend den angegebenen Zeichen

Syntax: string sequence.split (geteilte Zeichen, Anzahl der Teilungen) #Die Anzahl der zurückgegebenen Daten ist die Anzahl der Teilungen + 1

join(): Zeichenfolgen mit einem Zeichen oder Teilzeichenfolge kombinieren, d. h. mehrere Zeichenfolgen zu einer neuen Zeichenfolge zusammenführen

Syntax: Zeichen oder substring.join (Sequenz bestehend aus mehreren Zeichenfolgen)
capitalize(): Konvertieren Sie das erste Zeichen der Zeichenfolge in Großbuchstaben. Nach der Konvertierung ist nur das erste Zeichen ein Großbuchstabe und der Rest ein Kleinbuchstabe

Syntax : String sequence.capitalize()
title (): Wandelt den ersten Buchstaben jedes Wortes in der Zeichenfolge in Großbuchstaben um

• lower(): Wandelt den Großbuchstaben in der Zeichenfolge in Kleinbuchstaben um

• upper( ): Wandeln Sie den Kleinbuchstaben in der Zeichenfolge in Großbuchstaben um linker Teilstring, Trennzeichen und rechter Teilstring

• min(str): Gibt den kleinsten Buchstaben im String zurück str

max(str): Gibt den größten Buchstaben im String zurück str
zfill(width) : Gibt eine Zeichenfolge mit der angegebenen Länge und Breite rechtsbündig aus. Wenn sie kleiner als die angegebene Länge ist, wird 0 an der Vorderseite hinzugefügt. Wenn sie die angegebene Länge überschreitet, wird sie unverändert ausgegeben
lstrip(): Löschen Sie die Leerzeichen auf der linken Seite der Zeichenfolge.
rstrip(): Löschen Sie die Leerzeichen auf der rechten Seite der Zeichenfolge.
strip(): Löschen Sie Leerzeichen auf beiden Seiten von die Zeichenfolge
ljust(): Die Zeichenfolge wird linksbündig ausgerichtet und mit angegebenen Zeichen (Standard-Leerzeichen) auf die entsprechende Länge aufgefüllt
• Syntax: Zeichenfolgenfolge.ljust(Länge, Füllzeichen)

• rjust(): Der String wird rechtsbündig ausgerichtet und mit angegebenen Zeichen (Standard-Leerzeichen) auf die entsprechende Länge aufgefüllt

• Syntax: string sequence.rjust (Länge, Füllzeichen)
center(): Ausrichten in der Mitte und füllen Sie es mit den angegebenen Zeichen (Standard-Leerzeichen) auf die entsprechende Länge
• Syntax: string sequence.center(length, padding Character)

• Zum Beispiel:

print('--------------修改--------------')
str1 = 'hello python and hello IT and hello world and hello YX !'
print(str1.replace('and','&&'))
print(str1.split('and'), str1.split('and', 2))
l = ['Hello', 'world', '!']
t = ('Hello', 'python', '!')
print('_'.join(l), ' '.join(t))  # 用下划线_和空格连接
print(str1.capitalize())  # 首字符转为大写，其余均小写
print(str1.title())  # 每个单词首字母转为大写
str2 = '   Hello World !   '
print(str2.lower(), str2.upper(), str2.swapcase())  # 大写转小写，小写转大写，翻转大小写
print(str2.partition('rl'), str2.partition('o'))  # 根据指定分隔符将字符串分割，返回三元元组
print(min(str2), max(str2), ord(min(str2)), ord(max(str2)))  # str2中最小为空格对应十进制32，最大为r对应114
print(str2.zfill(21))  # 输出指定长度为21的字符串，右对齐，不足前面补0，超出指定长度则原样输出
print(str2.lstrip(), str2.rstrip(), str2.strip())  # 清除字符串左、右、两边空格字符
str3 = 'hello!'
print(str3.ljust(13, '*'), str3.rjust(13, '*'), str3.center(14, '*'))
 
输出：
--------------修改--------------
hello python && hello IT && hello world && hello YX !
['hello python ', ' hello IT ', ' hello world ', ' hello YX !'] ['hello python ', ' hello IT ', ' hello world and hello YX !']
Hello_world_! Hello python !
Hello python and hello it and hello world and hello yx !
Hello Python And Hello It And Hello World And Hello Yx !
   hello world !       HELLO WORLD !       hELLO wORLD !   
('   Hello Wo', 'rl', 'd !   ') ('   Hell', 'o', ' World !   ')
  r 32 114
00   Hello World !  
Hello World !       Hello World ! Hello World !
hello!******* *******hello! ****hello!****

2.3 Urteil
startswith(): Überprüfen Sie, ob die Zeichenfolge mit der angegebenen Teilzeichenfolge beginnt. Wenn ja, geben Sie True zurück, andernfalls geben Sie False zurück, legen Sie die Start- und Endpositionsindizes fest und prüfen Sie, ob sie innerhalb des angegebenen Bereichs liegen.

Syntax: Zeichenfolgensequenz. startet mit (Teilzeichenfolge, Startpositionsindex, Endpositionsindex)
endswith(): Überprüfen Sie, ob die Zeichenfolge mit der angegebenen Teilzeichenfolge endet, geben Sie True zurück, andernfalls geben Sie False zurück, legen Sie die Start- und Endpositionsindizes fest und prüfen Sie dann innerhalb der angegebener Bereich

Syntax: string sequence.endswith (substring, start position subscript, end position subscript)

isalpha(): Wenn die Zeichenfolge mindestens ein Zeichen enthält und alle Zeichen alle Buchstaben sind, es gibt True zurück, andernfalls gibt es False zurück

isdigit(): Wenn die Zeichenfolge nur Zahlen enthält, gibt es True zurück, andernfalls gibt es False zurück

• isalnum()：若字符串至少有一个字符且所有字符都是字母或数字则返回True，否则返回False

• isspace()：若字符串只包含空格，则返回True，否则返回False

举例如下：

print('---------------判断----------------')
str3 = 'hello!'
print(str3.startswith('he'), str3.startswith('she'), str3.startswith('he',2,))
print(str3.endswith('!'), str3.endswith('。'), str3.endswith('!', 2, 5))
print(str3.isalpha(),str3.isalnum(), str3.isdigit(), str3.isspace())
 
输出：
---------------判断----------------
True False False
True False False
False False False False

Das obige ist der detaillierte Inhalt vonWas sind die gängigen Methoden für das Python-String-Slicing?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!