String-Abfangen
Das Abfangen von Zeichenfolgen ist eine in praktischen Anwendungen häufig verwendete Technik, und der abgefangene Teil wird als „Teilzeichenfolge“ bezeichnet. In Java wird die Funktion substr() verwendet, um eine Teilzeichenfolge abzurufen, und in C# wird die Funktion substring() verwendet, um eine Teilzeichenfolge abzurufen. Da Python über integrierte Sequenzen verfügt, können Sie Teilzeichenfolgen durch die zuvor eingeführte Indizierung und Slicing erhalten oder sie mit der Funktion split() abrufen. Strings sind ebenfalls Sequenzen.
Der folgende Code verwendet den Index der Sequenz, um einen Teilstring abzurufen:
# Verwenden Sie den Index, um Teilzeichenfolgen abzufangen
print('----------# Index verwenden, um Teilzeichenfolge abzufangen---------')
Wort = 'Welt'
print(word[4])
[Codebeschreibung] Die vierte Codezeile greift auf den Wert des fünften Zeichens der Zeichenfolge zu. Die Ausgabe ist „d“.
【Operationsergebnis】
Durch Slicing kann ein regelmäßiges Abfangen von Strings erreicht werden. Das Syntaxformat von Slices ist wie folgt.
string[Anfang: Ende: Schritt]
[Codebeschreibung] wobei string die Quell-String-Variable darstellt, die in einen Teilstring unterteilt werden muss. [start:end:step] gibt an, dass die Teilzeichenfolge von der Startindexposition bis zum Endindex der Zeichenfolge abgefangen wird. Der Abfangschritt ist Schritt. Das heißt, die Zeichenfolge [Start + Schritt] wird jedes Mal bis zum Endindex abgefangen. Der Index beginnt bei 0 zu zählen.
Der folgende Code demonstriert die Funktion der Verwendung von Slicing zum Abfangen von Teilzeichenfolgen:
#Spezielles Slice zum Abfangen von Teilzeichenfolgen
print('---------# Spezielles Slice zum Abfangen von Teilzeichenfolgen----------')
str1 = 'Hallo Welt'
print(str1[0:3])
print(str1[::2])
print(str1[1::2])
str2 = 'ABCDEFG'
print(str2[:3])
print(str2[3:])
print(str2[::2])
drucken('-----------------------------------')
[Codebeschreibung]
Die 10. Codezeile fängt den Teil zwischen dem ersten und dem dritten Zeichen in der Zeichenfolge ab.
In Zeile 11 des Codes werden im Slice [::2] die Start- und Endzeichen weggelassen. Beginnen Sie mit dem ersten Zeichen der Zeichenfolge und fangen Sie die Zeichen nacheinander in 2er-Schritten ab.
In der 12. Codezeile bedeutet die Zahl 1 im Slice, dass Zeichen beginnend mit dem zweiten Zeichen der Zeichenfolge genommen werden, und die Zahl 2 bedeutet, dass Zeichen einzeln in Zweierschritten abgefangen werden.
【Operationsergebnis】
Wenn Sie mehrere Teilzeichenfolgen gleichzeitig abfangen möchten, können Sie dies mit der Funktion split() erreichen. Die Deklaration der Funktion split() lautet wie folgt. 
split([char] [,num])
[Codebeschreibung]
Der Parameter char stellt das zur Trennung verwendete Zeichen dar. Das Standardtrennzeichen ist ein Leerzeichen.
Der Parameter num gibt die Anzahl der Unterteilungen an. Wenn num gleich 2 ist, wird die Quellzeichenfolge in 3 Teilzeichenfolgen aufgeteilt. Standardmäßig werden Teilzeichenfolgen basierend auf der Anzahl der Vorkommen des Zeichens char in der Zeichenfolge aufgeteilt.
Der Rückgabewert der Funktion ist eine Liste von Teilzeichenfolgen.
Code wie folgt anzeigen:
# Verwenden Sie split(), um Teilzeichenfolgen abzurufen
print('-----------# Verwenden Sie split(), um den Teilstring abzurufen-----')
Satz = „Tom sagte: a,b,c,d.“
print('Verwenden Sie Leerzeichen, um Teilzeichenfolgen abzurufen:', Satz.split())
print('Verwenden Sie Kommas, um Teilzeichenfolgen abzurufen:', Satz.split(','))
print('Verwenden Sie Kommas, um 3 Teilzeichenfolgen zu erhalten:', Satz.split(',', 2))
Satz1 = 'Uzi sagt uns: Er ist König und sagt: A, B, C, D.'
print('Verwenden Sie Leerzeichen, um Teilzeichenfolgen abzurufen:', Satz1.split())
print('Verwenden Sie Kommas, um Teilzeichenfolgen abzurufen:', Satz1.split(','))
print('Verwenden Sie Leerzeichen, um 4 Teilzeichenfolgen zu erhalten:', Satz1.split(' ',3))
drucken('-----------------------------------')
[Codebeschreibung]
Zeile 22 des Codes ruft Teilzeichenfolgen basierend auf Leerzeichen ab. Wenn der Zeichenfolgensatz 5 Leerzeichen enthält, wird eine Liste mit 6 Teilzeichenfolgen zurückgegeben.
Zeile 23 des Codes ruft die Teilzeichenfolge basierend auf dem Komma ab. Wenn der Zeichenfolgensatz drei Leerzeichen enthält, wird eine Liste mit vier Teilzeichenfolgen zurückgegeben.
Die 24. Codezeile teilt die Zeichenfolge anhand von Kommas auf und teilt den Zeichenfolgensatz in drei Teilzeichenfolgen auf.
【Operationsergebnis】
Nach der Zeichenfolgenverkettung weist Python der verketteten Zeichenfolge neuen Speicherplatz zu und die Quellzeichenfolge bleibt unverändert.

# Nach der Zeichenfolgenverkettung weist Python der verketteten Zeichenfolge neuen Speicherplatz zu und die Quellzeichenfolge bleibt unverändert.
print('Nach der String-Verkettung weist Python dem verketteten String neuen Platz zu und der Quell-String bleibt unverändert.')
str3 = "a"
print(id(str3))
print(id(str3 + "b"))
drucken('-------------------------------------')

[Codebeschreibung]
Zeile 2 des Codes gibt den internen Bezeichner von str1 aus. Das Ausgabeergebnis ist „4337916312“.
Zeile 3 des Codes führt eine Zeichenfolgenverkettung durch und die neue Zeichenfolge erhält eine neue Identität. Das Ausgabeergebnis ist „4337800168“.
【Operationsergebnis】
ALLE:
Laufergebnisse ALLE:
-------------------Ende--------------------