One place for hosting & domains

      So indexieren und trennen Sie Zeichenfolgen in Python 3


      Einführung

      Der Python-Zeichenfolgen-Datentyp ist eine Sequenz, die aus einem oder mehreren einzelnen Zeichen besteht, die aus Buchstaben, Zahlen, Leerzeichen oder Symbolen bestehen können. Da es sich bei einer Zeichenfolge um eine Sequenz handelt, kann durch Indizieren und Schneiden auf dieselbe Weise wie bei anderen sequenzbasierten Datentypen auf sie zugegriffen werden.

      Dieses Tutorial führt Sie durch den Zugriff auf Zeichenfolgen durch Indizieren, sie durch ihre Zeichenfolgen schneiden und einige Zähl- und Zeichenortungsmethoden durchgehen.

      Wie Zeichenfolgen indiziert sind

      Wie der Listendatentyp mit Elementen, die einer Indexnummer entsprechen, entspricht auch jedes Zeichen einer Zeichenfolge einer Indexnummer, beginnend mit der Indexnummer 0.

      Für die Zeichenfolge Sammy Shark! die Indexaufschlüsselung sieht folgendermaßen aus:

      S a m m y S h a r k !
      0 1 2 3 4 5 6 7 8 9 10 11

      Wie Sie sehen können, beginnt das erste S bei Index 0 und die Zeichenfolge endet bei Index 11 mit dem ! -Symbol.

      Wir bemerken auch, dass das Leerzeichen zwischen Sammy und Shark auch seiner eigenen Indexnummer entspricht. In diesem Fall beträgt die dem Leerzeichen zugeordnete Indexnummer 5.

      Das Ausrufezeichen (!) hat auch eine Indexnummer zugeordnet. Alle anderen Symbole oder Satzzeichen wie *#$&. ;?, ist ebenfalls ein Zeichen und würde mit einer eigenen Indexnummer verknüpft.

      Die Tatsache, dass jedes Zeichen in einer Python-Zeichenfolge eine entsprechende Indexnummer hat, ermöglicht es uns, auf Zeichenfolgen auf dieselbe Weise wie bei anderen sequentiellen Datentypen zuzugreifen und diese zu bearbeiten.

      Zugriff auf Zeichen nach positiver Indexnummer

      Durch Verweisen von Indexnummern können wir eins der Zeichen in einer Zeichenfolge isolieren. Wir tun dies durch Einfügen der Indexnummern in quadratische Klammern. Lassen Sie uns eine Zeichenfolge deklarieren, drucken und die Indexnummer in quadratischen Klammern aufrufen:

      ss = "Sammy Shark!"
      print(ss[4])
      

      Output

      y

      Wenn wir auf eine bestimmte Indexnummer einer Zeichenfolge verweisen, gibt Python das Zeichen zurück, das sich in dieser Position befindet. Da sich der Buchstabe y an der Indexnummer 4 der Zeichenfolge ss = „Sammy Shark!“ befindet, erhalten wir beim Drucken von ss [4] y als Ausgabe.

      Indexnummern ermöglichen es uns, auf bestimmte Zeichen innerhalb einer Zeichenfolge zuzugreifen.

      Zugriff auf Zeichen nach negativer Indexnummer

      Wenn wir eine lange Zeichenfolge haben und ein Element am Ende anlegen möchten, können wir auch am Ende der Zeichenfolge rückwärts zählen, beginnend mit der Indexnummer -1.

      Für die gleiche Zeichenfolge Sammy Shark! sieht die negative Indexaufschlüsselung folgendermaßen aus:

      S a m m y S h a r k !
      -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

      Durch die Verwendung negativer Indexzahlen können wir das Zeichen r ausdrucken, indem wir uns wie folgt auf seine Position am -3-Index beziehen:

      print(ss[-3])
      

      Output

      r

      Die Verwendung negativer Indexnummern kann nützlich sein, um ein einzelnes Zeichen am Ende einer langen Zeichenfolge zu isolieren.

      Schneiden von Zeichenfolgen

      Wir können auch eine Reihe von Zeichen aus der Zeichenfolge aufrufen. Angenommen, wir möchten nur das Wort Shark drucken. Wir können dies tun, indem wir eine Scheibeerstellen, die eine Folge von Zeichen innerhalb einer ursprünglichen Zeichenfolge ist. Mit Scheiben können wir mehrere Zeichenwerte aufrufen, indem wir einen Bereich von Indexnummern erstellen, die durch einen Doppelpunkt [x:y] getrennt sind:

      print(ss[6:11])
      

      Output

      Shark

      Beim Erstellen einer Scheibe wie in [6:11] beginnt bei der ersten Indexnummer die Scheibe (einschließlich), und bei der zweiten Indexnummer endet die Scheibe (exklusiv), weshalb in unserem obigen Beispiel der Bereich der Indexnummer gilt, der unmittelbar nach dem Ende der Zeichenfolge auftreten würde.

      Beim Schneiden von Zeichenfolgen erstellen wir eine Teilzeichenfolge, bei der es sich im Wesentlichen um eine Zeichenfolge handelt, die in einer anderen Zeichenfolge vorhanden ist. Wenn wir ss[6:11] aufrufen, rufen wir den Teilstring Shark auf, der in der Zeichenfolge Sammy Shark! vorhanden ist.

      Wenn wir eines der Enden einer Zeichenfolge einschließen möchten, können wir eine der Zahlen in der ZeichenfolgenSyntax [n:n] auslassen. Wenn wir beispielsweise das erste Wort der Zeichenfolge ss – „Sammy“ – drucken möchten, können Sie dies tun, indem Sie Folgendes eingeben:

      print(ss[:5])
      

      Output

      Sammy

      Dazu haben wir die Indexnummer vor dem Doppelpunkt in der Scheiben-Syntax weggelassen und nur die Indexnummer nach dem Doppelpunkt eingefügt, die sich auf das Ende der Teilzeichenfolge bezieht.

      Um eine Teilzeichenfolge zu drucken, die in der Mitte einer Zeichenfolge beginnt und bis zum Ende druckt, können Sie dazu nur die Indexnummer vor dem Doppelpunkt einfügen:

      print(ss[7:])
      

      Output

      hark!

      Indem nur die Indexnummer vor dem Doppelpunkt eingefügt und die zweite Indexnummer aus der Syntax herausgelassen wird, wechselt die Teilzeichenfolge vom Zeichen der aufgerufenen Indexnummer zum Ende der Zeichenfolge.

      Sie können auch negative Indexnummern verwenden, um eine Zeichenfolge zu trennen. Wie bereits erwähnt, beginnen negative Indexzahlen einer Zeichenfolge bei -1 und zählen von dort herunter, bis wir den Anfang der Zeichenfolge erreichen. Wenn man negative Indexzahlen verwendet, beginnen wir zuerst mit der niedrigeren Zahl, wie sie früher in der Zeichenfolge vorkommt.

      Verwenden wir zwei negative Indexzahlen, um die Zeichenfolge ss zu schneiden:

      print(ss[-4:-1])
      

      Output

      ark

      Die Teilzeichenfolge „Arche“ ist aus der Zeichenfolge „Sammy Shark!“ , weil das Zeichen „a“ an der Position der Indexnummer -4 auftritt und das Zeichen „k“ unmittelbar vor der Position der Indexnummer -1 auftritt.

      Festlegen des Schrittes beim Schneiden von Zeichenfolgen

      Das Schneiden von Zeichenfolgen kann zusätzlich zu zwei Indexnummern einen dritten Parameter akzeptieren. Der dritte Parameter gibt den Schritt an, der angibt, wie viele Zeichen vorwärts bewegt werden sollen, nachdem das erste Zeichen aus der Zeichenfolge abgerufen wurde. Bisher haben wir den Schrittparameter weggelassen, und Python verwendet standardmäßig den Schritt 1, sodass jedes Zeichen zwischen zwei Indexnummern abgerufen wird.

      Schauen wir uns noch einmal das obige Beispiel an, in dem die Teilzeichenfolge „Shark“ ausgedruckt wird:

      print(ss[6:11])
      

      Output

      Shark

      Wir können die gleichen Ergebnisse erzielen, indem wir einen dritten Parameter mit einem Schritt von 1 einfügen:

      print(ss[6:11:1])
      

      Output

      Shark

      Ein Schritt von 1 nimmt also jedes Zeichen zwischen zwei Indexnummern eines Schrittes auf. Wenn wir den Schrittparameter weglassen, wird Python standardmäßig mit 1 angegeben.

      Wenn wir stattdessen den Schritt erhöhen, sehen wir, dass Zeichen übersprungen werden:

      print(ss[0:12:2])
      

      Output

      SmySak

      Die Angabe des Schrittes 2 als letzter Parameter in der Python-Syntax ss[0:12:2] überspringt jedes zweite Zeichen. Schauen wir uns die Zeichen an, die in rot ausgedruckt werden:

      Sammy Shark!

      Beachten Sie, dass das Leerzeichen bei der Indexnummer 5 auch mit einem angegebenen Schritt von 2 übersprungen wird.

      Wenn wir eine größere Zahl für unseren Schrittparameter verwenden, haben wir eine deutlich kleinere Teilzeichenfolge:

      print(ss[0:12:4])
      

      Output

      Sya

      Die Angabe des Schrittes 4 als letzter Parameter in der Python-Syntax ss[0:12:4] druckt nur jedes vierte Zeichen. Schauen wir uns nochmals die Zeichen an, die in rot ausgedruckt werden:

      Sammy Shark!

      In diesem Beispiel wird auch das Leerzeichen übersprungen.

      Da wir die gesamte Zeichenfolge drucken, können wir die beiden Indexnummern weglassen und die beiden Doppelpunkte in der Syntax behalten, um das gleiche Ergebnis zu erzielen:

      print(ss[::4])
      

      Output

      Sya

      Durch Weglassen der beiden Indexnummern und Beibehalten von Doppelpunkten bleibt die gesamte Zeichenfolge im Bereich, während durch Hinzufügen eines letzten Parameters für den Schritt die Anzahl der zu überspringenden Zeichen angegeben wird.

      Zusätzlich können Sie einen negativen numerischen Wert für den Schritt angeben, mit dem wir die ursprüngliche Zeichenfolge in umgekehrter Reihenfolge drucken können, wenn wir den Schritt auf -1 setzen:

      print(ss[::-1])
      

      Output

      !krahS ymmaS

      Die beiden Doppelpunkte ohne angegebenen Parameter enthalten alle Zeichen aus der ursprünglichen Zeichenfolge. Ein Schritt von 1 enthält alle Zeichen ohne Überspringen. Wenn Sie diesen Schritt negieren, wird die Reihenfolge der Zeichen umgekehrt.

      Lassen Sie uns dies erneut tun, aber mit einem Schritt von -2:

      print(ss[::-2])
      

      Output

      !rh ma

      In diesem Beispiel, ss[::-2], handelt es sich um die Gesamtheit der ursprünglichen Zeichenfolge, da in den Parametern keine Indexnummern enthalten sind, und die Umkehrung der Zeichenfolge durch den negativen Schritt. Außerdem überspringen wir mit einem Schritt von -2 jeden zweiten Buchstaben der umgekehrten Zeichenfolge:

      ! krahS[Leerzeichen]ymmaS

      Das Leerzeichen wird in diesem Beispiel ausgedruckt.

      Indem Sie den dritten Parameter der Python-Scheiben-Syntax angeben, geben Sie den Schritt der Teilzeichenfolge an, den Sie aus der ursprünglichen Zeichenfolge ziehen.

      Zählmethoden

      Während wir über die relevanten Indexnummern nachdenken, die Zeichen in Zeichenfolgen entsprechen, lohnt es sich, einige der Methoden durchzugehen, die Zeichenfolgen zählen oder Indexnummern zurückgeben. Dies kann nützlich sein, um die Anzahl der Zeichen zu begrenzen, die wir in einem Benutzereingabeformular akzeptieren möchten, oder um Zeichenfolgen zu vergleichen. Wie bei anderen sequentiellen Datentypen können Zeichenfolgen mit verschiedenen Methoden gezählt werden.

      Wir werden uns zunächst die len() -Methode ansehen, mit der die Länge jedes Datentyps ermittelt werden kann, der eine geordnete oder ungeordnete Sequenz ist, einschließlich Zeichenfolgen, Listen, Tupeln und Wörterbüchern.

      Drucken wir die Länge der Zeichenfolge ss:

      print(len(ss))
      

      Output

      12

      Die Länge der Zeichenfolge „Sammy Shark!“ ist 12 Zeichen lang, einschließlich des Leerzeichens und des Ausrufezeichens.

      Anstatt eine Variable zu verwenden, können wir auch eine Zeichenfolge direkt an die len() -Methode übergeben:

      print(len("Let's print the length of this string."))
      

      Output

      38

      Die len() -Methode zählt die Gesamtzahl der Zeichen innerhalb einer Zeichenfolge.

      Wenn wir zählen möchten, wie oft entweder ein bestimmtes Zeichen oder eine Folge von Zeichen in einer Zeichenfolge angezeigt wird, können wir dies mit der str.count()-Methode tun. Arbeiten wir mit unserer Zeichenfolge ss = „Sammy Shark!“ und zählen die Anzahl der erscheinenden Zeichen „a“:

      print(ss.count("a"))
      

      Output

      2

      Wir können nach einem anderen Zeichen suchen:

      print(ss.count("s"))
      

      Output

      0

      Obwohl sich der Buchstabe „S“ in der Zeichenfolge befindet, ist es wichtig zu beachten, dass bei jedem Zeichen zwischen Groß- und Kleinschreibung unterschieden wird. Wenn wir unabhängig von der Groß- und Kleinschreibung nach allen Buchstaben in einer Zeichenfolge suchen möchten, können wir die Zeichenfolge mit der str.lower() -Methode zuerst in Kleinbuchstaben konvertieren. Weitere Informationen zu dieser Methode finden Sie unter „Eine Einführung in Zeichenfolgenmethoden in Python 3“.

      Versuchen wir str.count() mit einer Sequenz von Zeichen:

      likes = "Sammy likes to swim in the ocean, likes to spin up servers, and likes to smile."
      print(likes.count("likes"))
      

      Output

      3

      In den Zeichenfolgen likes kommt die Zeichenfolge, die „likes“ entspricht, in der ursprünglichen Zeichenfolge dreimal vor.

      Wir können auch herausfinden, an welcher Position ein Zeichen oder eine Zeichenfolge in einer Zeichenfolge vorkommt. Wir können dies mit der str.find()-Methode tun, die die Position des Zeichens basierend auf der Indexnummer zurückgibt.

      Wir können überprüfen, wo das erste „m“ in der Zeichenfolge ss vorkommt:

      print(ss.find("m"))
      

      Ouput

      2

      Das erste Zeichen „m“ tritt an der Indexposition 2 in der Zeichenfolge „Sammy Shark!“ auf. Wir können die Indexnummerpositionen der oben beschriebenen Zeichenfolge ss überprüfen.

      Überprüfen wir, wo die erste Zeichenfolge „likes“ in der Zeichenfolge likes vorkommt:

      print(likes.find("likes"))
      

      Ouput

      6

      Die erste Instanz der Zeichenfolge „likes“ beginnt an der Indexnummernposition 6, an der sich das Zeichen l der Sequenz likes befindet.

      Was, wenn wir sehen möchten, wo die zweite Sequenz von „likes“ beginnt? Wir können dazu einen zweiten Parameter an die str.find()-Methode übergeben, die mit einer bestimmten Indexnummer beginnt. Anstatt also am Anfang der Zeichenfolge zu beginnen, beginnen wir nach der Indexnummer 9:

      print(likes.find("likes", 9))
      

      Output

      34

      In diesem zweiten Beispiel, das an der Indexnummer 9 beginnt, beginnt das erste Ereignis der Zeichenfolge „likes“ bei der Indexnummer 34.

      Zusätzlich können wir ein Ende für den Bereich als dritten Parameter angeben. Wie beim Schneiden können wir dies tun, indem wir mit einer negativen Indexzahl rückwärts zählen:

      print(likes.find("likes", 40, -6))
      

      Output

      64

      Dieses letzte Beispiel sucht nach der Position der Sequenz „likes“ zwischen den Indexnummern 40 und -6. Da der letzte eingegebene Parameter eine negative Zahl ist, zählt er vom Ende der ursprünglichen Zeichenfolge.

      Die Zeichenfolgemethoden len(), str.count() und str.find() können verwendet werden, um die Länge, die Zählungen von Zeichen oder Zeichenfolgen sowie Indexpositionen von Zeichen oder Zeichenfolgen in Zeichenfolgen zu bestimmen.

      Zusammenfassung

      Die Möglichkeit, bestimmte Indexnummern von Zeichenfolgen oder eine bestimmte Scheibe einer Zeichenfolge aufzurufen, bietet uns eine größere Flexibilität bei der Arbeit mit diesem Datentyp. Da Zeichenfolgen wie Listen und Tupel ein sequenzbasierter Datentyp sind, kann durch Indizieren und Schneiden auf sie zugegriffen werden.

      Sie können mehr über das Formatieren von Zeichenfolgen und Zeichenfolgenmethoden lesen, um weitere Informationen zu Zeichenfolgen zu erhalten.



      Source link