Skip to content

Extrahieren einer Teilzeichenkette aus einer Zeichenkette in Python (Position, regex)

Python

Dieser Artikel genau, wie SIE in Python einen Teilstring aus einem String extrahieren. Sie können eine Teilzeichenfolge extrahieren, indem Sie die Position und die Anzahl der Zeichen angeben, oder mit regulären Ausdrucksmustern.

  • Extrahieren Sie eine Teilzeichenfolge, indem Sie die Position und die Anzahl der Zeichen angeben
    • Extrahieren Sie ein Zeichen nach Index
    • Extrahieren Sie eine Teilzeichenfolge durch Aufteilen
    • Extrahieren Sie basierend auf der Anzahl der Zeichen
  • Extrahieren Sie eine Teilzeichenfolge mit regulären Ausdrücken:re.search(), re.findall()
  • Musterbeispiele für regelmäßige Ausdrücke
    • Wildcard-ähnliches Muster
    • Gierig und nicht gierig
    • Extrahieren Sie einen Teil des Musters mit Klammern
    • Übereinstimmung mit einem einzelnen Zeichen
    • Passen Sie den Anfang/das Ende der Zeichenfolge an
    • Extrahieren Sie nach mehreren Mustern
    • Groß- und Kleinschreibung beachten

Wenn Sie eine Teilzeichenfolge durch eine andere Zeichenfolge ersetzen möchten, lesen Sie den following Artikel.

Extrahieren Sie eine Teilzeichenfolge, indem Sie die Position und die Anzahl der Zeichen angeben

Sie können ein Zeichen an der gewünschten Position erhalten, ohne dass Sie einen Index in [] angeben. Indizes beginnen mit 0 (nullbasierte Indizierung).

s = 'abcde'

print(s[0])
# a

print(s[4])
# e

Sie können eine Rückwärtsposition mit negativen Werten angeben. -1 steht für das letzte Zeichen.

print(s[-1])
# e

print(s[-5])
# a

Ein Fehler WIRD ausgelöst, WENN DER NICHT VORHANDENE INDEX ANGEGEBEN WIRD.

# print(s[5])
# IndexError: string index out of range

# print(s[-6])
# IndexError: string index out of range

Sie können einen Teilstring im Bereich start <= x < stop mit [start:step] extrahieren. Wenn Start weggelassen WIRD, erstreckt sich der Bereich vom Anfang, und wenn Ende weggelassen WIRD, reicht der Bereich bis zum Ende.

s = 'abcde'

print(s[1:3])
# bc

print(s[:3])
# abc

print(s[1:])
# bcde

Sie können auch negative Werte verwenden.

print(s[-4:-2])
# bc

print(s[:-2])
# abc

print(s[-4:])
# bcde

Wenn Start > Ende, wird kein Fehler ausgelöst und ein leeres Zeichen “ extrahiert.

print(s[3:1])
# 

print(s[3:1] == '')
# True

Außerhalb des Bereichs wird ignoriert.

print(s[-100:100])
# abcde

Zusätzlich zur Startposition Start und Endposition Stop können Sie einen Inkrementschritt wie [Start:Stopp:Schritt] angeben. Wenn der Schritt negativ ist, wird er von hinten gezogen.

print(s[1:4:2])
# bd

print(s[::2])
# ace

print(s[::3])
# ad

print(s[::-1])
# edcba

print(s[::-2])
# eca

Weitere Informationen zum Slicing finden Sie im following Artikel.

Die eingebaute Funktion len() gibt die Anzahl der Zeichen zurück. SIE can stirbt beispielsweise verwenden, um das zentrale Zeichen zu erhalten oder sterben erste oder zweite Hälfte der Zeichenfolge mit Slicing zu extrahieren.

Beachten Sie, dass SIE nur ganzzahlige int-Werte für index [] und Slice [:] angeben können. Die Division durch / löst einen Fehler aus, da das Ergebnis eine Gleitkommazahl Float ist.

Das Beispiel verwendet eine ganzzahlige Division //. Der Dezimalpunkt wird abgeschnitten.

s = 'abcdefghi'

print(len(s))
# 9

# print(s[len(s) / 2])
# TypeError: string indices must be integers

print(s[len(s) // 2])
# e

print(s[:len(s) // 2])
# abcd

print(s[len(s) // 2:])
# efghi

Sie können regelmäßig Ausdrücke mit dem re-Modul der Standardbibliothek verwenden.

Use you re.search(), um Eine Teilzeichenfolge zu extrahieren, sterben Einem regulären Ausdrucksmuster entspricht. Geben SIE das Muster des regulären Ausdrucks als erster Parameter und die Zielzeichenfolge als zweiter Parameter an.

import re

s = '012-3456-7890'

print(re.search(r'd+', s))
# 

d entspricht einem Ziffernzeichen und entspricht einer Wiederholung des Musters. Somit stimmt d+ mit einer oder mehreren aufeinanderfolgenden Ziffern überein.

Da der umgekehrte Schrägstrich in speziellen Sequenzen regulärer Ausdrücke wie d used WIRD, IST ES PRAKTISCH, Eine rohe Zeichenfolge zu verwenden, Indem r vor “ oder „“ hinzugefügt WIRD.

Wenn ein String mit dem Muster gefunden wird, gibt re.search() ein Match-Objekt zurück. Sie können den übereinstimmenden Teil als String str mit der group()-Methode des match-Objekts erhalten.

m = re.search(r'd+', s)

print(m.group())
# 012

print(type(m.group()))
# <class 'str'>

Wie im obigen Beispiel gibt re.search() nur das Match-Objekt des ersten Teils zurück, selbst wenn es mehrere übereinstimmende Teile gibt.

re.findall() gibt alle übereinstimmenden Teile als Liste von Strings zurück.

print(re.findall(r'd+', s))
# ['012', '3456', '7890']

Musterbeispiele für regelmäßige Ausdrücke

In diesem Abschnitt werden einige Beispiele für reguläre Ausdrucksmuster mit Metazeichen/Sondersequenzen vorgestellt.

Wildcard-ähnliches Muster

. entspricht jedem einzelnen Zeichen außer einem Zeilenumbruch und * entspricht null oder mehr Wiederholungen des vorhergehenden Musters.

Beispiel entspricht a.*b der Zeichenfolge, die mit a beginnt und mit b endet. Da * auf null Wiederholungen passt, passt es auch auf ab.

print(re.findall('a.*b', 'axyzb'))
# ['axyzb']

print(re.findall('a.*b', 'a---b'))
# ['a---b']

print(re.findall('a.*b', 'aあいうえおb'))
# ['aあいうえおb']

print(re.findall('a.*b', 'ab'))
# ['ab']

+ stimmt mit einer oder mehreren Wiederholungen des wiederholten Musters überein. a.+b passt nicht zu ab.

print(re.findall('a.+b', 'ab'))
# []

print(re.findall('a.+b', 'axb'))
# ['axb']

print(re.findall('a.+b', 'axxxxxxb'))
# ['axxxxxxb']

? stimmt mit null oder einem vorangehenden Muster überein. Im Fall von a.?b stimmt es mit ab und der Zeichenfolge mit nur einem Zeichen zwischen a und b überein.

print(re.findall('a.?b', 'ab'))
# ['ab']

print(re.findall('a.?b', 'axb'))
# ['axb']

print(re.findall('a.?b', 'axxb'))
# []

Gierig und nicht gierig

*, + und ? sind alles gierige Übereinstimmungen, die so viel Text wie möglich finden. *?, +? und ?? sind nicht gierig, minimale Übereinstimmungen, die so wenige Zeichen wie möglich finden.

s = 'axb-axxxxxxb'

print(re.findall('a.*b', s))
# ['axb-axxxxxxb']

print(re.findall('a.*?b', s))
# ['axb', 'axxxxxxb']

Wenn Sie einen Teil eines regulären Ausdrucksmusters in Klammern () einschließen, können Sie einen Teilstring in diesem Teil extrahieren.

print(re.findall('a(.*)b', 'axyzb'))
# ['xyz']

Wenn Sie Klammern () als Zeichen abgleichen möchten, maskieren Sie Sie mit einem Backslash .

print(re.findall(r'(.+)', 'abc(def)ghi'))
# ['(def)']

print(re.findall(r'((.+))', 'abc(def)ghi'))
# ['def']

Übereinstimmung mit einem einzelnen Zeichen

Das Einschließen einer Zeichenfolge in [] stimmt mit einem der Zeichen in der Zeichenfolge überein.

Wenn Sie auf einander zugewandte Unicode-Codepunkte mit – verbinden, z. B. [az], werden alle Zeichen dazwischen abgedeckt. Beispiel entspricht [az] einem beliebigen Zeichen des Kleinbuchstabenalphabets.

print(re.findall('[abc]x', 'ax-bx-cx'))
# ['ax', 'bx', 'cx']

print(re.findall('[abc]+', 'abc-aaa-cba'))
# ['abc', 'aaa', 'cba']

print(re.findall('[a-z]+', 'abc-xyz'))
# ['abc', 'xyz']

Passen Sie den Anfang/das Ende der Zeichenfolge an

^ entspricht dem Anfang der Zeichenfolge und $ entspricht dem Ende der Zeichenfolge.

s = 'abc-def-ghi'

print(re.findall('[a-z]+', s))
# ['abc', 'def', 'ghi']

print(re.findall('^[a-z]+', s))
# ['abc']

print(re.findall('[a-z]+$', s))
# ['ghi']

Verwenden Sie Sie | um eine Teilzeichenfolge zu extrahieren, sterben mit einem der mehreren Muster zu treffen. Zum Beispiel können Sie für reguläre Ausdrucksmuster A und BA|B schreiben.

s = 'axxxb-012'

print(re.findall('a.*b', s))
# ['axxxb']

print(re.findall(r'd+', s))
# ['012']

print(re.findall(r'a.*b|d+', s))
# ['axxxb', '012']

Groß- und Kleinschreibung beachten

Das re-Modul unterscheidet standardmäßig zwischen Groß- und Kleinschreibung. Setzen Sie das Flags-Argument auf re.IGNORECASE, um die Groß-/Kleinschreibung zu ignorieren.

s = 'abc-Abc-ABC'

print(re.findall('[a-z]+', s))
# ['abc', 'bc']

print(re.findall('[A-Z]+', s))
# ['A', 'ABC']

print(re.findall('[a-z]+', s, flags=re.IGNORECASE))
# ['abc', 'Abc', 'ABC']