Manipulation von Zeichenketten¶

pandas bietet die Möglichkeit, String-Methoden und reguläre Ausdrücke von Python prägnant auf ganze Arrays von Daten anzuwenden.

See also:

Vektorisierte String-Funktionen in pandas¶

Das Aufräumen eines unübersichtlichen Datensatzes für die Analyse erfordert oft eine Menge an String-Manipulationen. Erschwerend kommt hinzu, dass eine Spalte, die Strings enthält, manchmal fehlende Daten enthält:

[1]:

import numpy as np
import pandas as pd


addresses = {
    "Veit": np.nan,
    "Veit Schiele": "veit.schiele@cusy.io",
    "cusy GmbH": "info@cusy.io",
}
addresses = pd.Series(addresses)

addresses

[1]:

Veit                             NaN
Veit Schiele    veit.schiele@cusy.io
cusy GmbH               info@cusy.io
dtype: object

[2]:

addresses.isna()

[2]:

Veit             True
Veit Schiele    False
cusy GmbH       False
dtype: bool

Ihr könnt Methoden für Zeichenketten und reguläre Ausdrücke auf jeden Wert anwenden (durch Übergabe eines Lambdas oder einer anderen Funktion), indem ihr data.map verwendet, aber dies schlägt bei NA-Werten fehl. Um dies zu bewältigen, verfügt Series über array-orientierte Methoden für String-Operationen, die NA-Werte überspringen und weiterleiten. Auf diese wird über das str-Attribut von Series zugegriffen; zum Beispiel könnten wir mit str.contains prüfen, ob jede E-Mail-Adresse veit enthält:

[3]:

addresses.str.contains("veit")

[3]:

Veit              NaN
Veit Schiele     True
cusy GmbH       False
dtype: object

Reguläre Ausdrücke können ebenfalls verwendet werden, zusammen mit Optionen wie IGNORECASE:

[4]:

import re

pattern = r"([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})"

addresses.str.findall(pattern, flags=re.IGNORECASE)

[4]:

Veit                                   NaN
Veit Schiele    [(veit.schiele, cusy, io)]
cusy GmbH               [(info, cusy, io)]
dtype: object

Es gibt mehrere Möglichkeiten, ein vektorisiertes Element abzurufen. Entweder verwendet ihr str.get oder den Index von str:

[5]:

matches = addresses.str.findall(pattern, flags=re.IGNORECASE).str[0]

matches

[5]:

Veit                                 NaN
Veit Schiele    (veit.schiele, cusy, io)
cusy GmbH               (info, cusy, io)
dtype: object

[6]:

matches.str.get(1)

[6]:

Veit             NaN
Veit Schiele    cusy
cusy GmbH       cusy
dtype: object

In ähnlicher Weise könnt ihr mit dieser Syntax auch Zeichenketten zerschneiden:

[7]:

addresses.str[:5]

[7]:

Veit              NaN
Veit Schiele    veit.
cusy GmbH       info@
dtype: object

Die pandas.Series.str.extract-Methode gibt die erfassten Gruppen eines regulären Ausdrucks als DataFrame zurück:

[8]:

addresses.str.extract(pattern, flags=re.IGNORECASE)

[8]:

	0	1	2
Veit	NaN	NaN	NaN
Veit Schiele	veit.schiele	cusy	io
cusy GmbH	info	cusy	io

Weitere vektorisierten Pandas-String-Methoden:

Methode	Beschreibung
`cat`	verknüpft Zeichenketten elementweise mit optionalem Trennzeichen
`contains`	gibt ein boolesches Array zurück, wenn jede Zeichenkette ein Muster/Regex enthält
`count`	zählt Vorkommen des Musters
`extract`	verwendet einen regulären Ausdruck mit Gruppen, um eine oder mehrere Zeichenketten aus einer Reihe von Zeichenketten zu extrahieren; das Ergebnis ist ein DataFrame mit einer Spalte pro Gruppe
`endswith`	Äquivalent zu `x.endswith(pattern)` für jedes Element
`startswith`	Äquivalent zu `x.startswith(pattern)` für jedes Element
`findall`	berechnet Liste aller Vorkommen von Muster/Regex für jede Zeichenkette
`get`	Index in jedem Element (`i`-tes Element abrufen)
`isalnum`	Äquivalent zu eingebautem `str.alnum`
`isalpha`	Entspricht dem eingebauten `str.isalpha`
`isdecimal`	Äquivalent zu eingebautem `str.isdecimal`
`isdigit`	Gleichwertig zu eingebautem `str.isdigit`
`islower`	Gleichwertig zu eingebautem `str.islower`
`isnumeric`	Gleichwertig zu eingebautem `str.isnumeric`
`isupper`	Äquivalent zur eingebauten `str.isupper`
`join`	verbindet Zeichenketten in jedem Element der Serie mit dem übergebenen Trennzeichen
`len`	berechnet die Länge jeder Zeichenkette
`lower`, `upper`	konvertiert Groß- und Kleinschreibung; entspricht `x.lower()` oder `x.upper()` für jedes Element
`match`	verwendet `re.match` mit dem übergebenen regulären Ausdruck für jedes Element, wobei `True` oder `False` zurückgegeben wird, wenn es übereinstimmt.
`extract`	erfasst Gruppenelemente (falls vorhanden) nach Index aus jeder Zeichenkette
`pad`	fügt Leerzeichen auf der linken, rechten oder beiden Seiten von Zeichenketten ein
`center`	Äquivalent zu `pad(side='both')`
`repeat`	Doppelte Werte (z.B. `s.str.repeat(3)` entspricht `x * 3` für jede Zeichenkette)
`replace`	ersetzt Muster/Regex durch eine andere Zeichenfolge
`slice`	schneidet jede Zeichenkette in der Serie auf
`split`	teilt Zeichenketten anhand von Begrenzungszeichen oder regulären Ausdrücken
`strip`	schneidet Leerzeichen auf beiden Seiten ab, einschließlich Zeilenumbrüchen
`rstrip`	schneidet Leerzeichen auf der rechten Seite ab
`lstrip`	schneidet Leerzeichen auf der linken Seite ab