0Pricing
Pandas & NumPy Academy · Lektion

Der .str-Accessor

Greifen Sie in einer Series mit .str auf String-Methoden zu und wenden Sie lower(), upper(), strip() und len() auf alle Werte an.

Der .str-Accessor ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Einführung in den .str-Accessor

Python-Zeichenfolgen verfügen über viele nützliche Methoden wie .lower(), .strip() und .replace(). Sie können diese jedoch nicht direkt auf einer Pandas-Series aus Zeichenfolgen aufrufen – dafür wäre eine Schleife erforderlich. Der .str-Accessor löst dieses Problem, indem er vektorisierte Varianten der integrierten Zeichenfolgenmethoden von Python für eine Series bereitstellt. Die Operation wird auf jedes Element gleichzeitig angewendet, ohne dass Sie eine Schleife schreiben müssen, und fehlende Werte werden korrekt behandelt (für sie wird NaN zurückgegeben).

import pandas as pd

names = pd.Series(['  Alice ', 'BOB', '  carol  '])

# .strip() removes leading/trailing whitespace from every element
print(names.str.strip())
# 0    Alice
# 1      BOB
# 2    carol

# .lower() lowercases every element
print(names.str.strip().str.lower())
# 0    alice
# 1      bob
# 2    carol

Methoden zur Groß- und Kleinschreibung

Eine uneinheitliche Groß- und Kleinschreibung gehört zu den häufigsten Problemen bei der Datenqualität. Der .str-Accessor stellt .lower(), .upper(), .title() (erster Buchstabe jedes Wortes großgeschrieben) und .capitalize() (nur der erste Buchstabe der Zeichenfolge großgeschrieben) bereit. Verwenden Sie .lower() vor Vergleichen und groupby-Operationen, damit 'NYC' und 'nyc' nicht als unterschiedliche Gruppen behandelt werden.

import pandas as pd

df = pd.DataFrame({'city': ['new york', 'LOS ANGELES', 'Chicago', 'HOUSTON']})

df['city_lower'] = df['city'].str.lower()
df['city_title'] = df['city'].str.title()
df['city_upper'] = df['city'].str.upper()

print(df[['city_lower', 'city_title']])
#    city_lower   city_title
# 0   new york     New York
# 1  los angeles  Los Angeles
# 2    chicago      Chicago
# 3    houston      Houston

Leerraum entfernen

Führender und abschließender Leerraum ist in Anzeigen unsichtbar, führt aber dazu, dass Vergleiche auf exakte Übereinstimmung unbemerkt fehlschlagen. .str.strip() entfernt Leerraum an beiden Enden, .str.lstrip() nur am linken und .str.rstrip() nur am rechten Ende. Sie können auch ein bestimmtes Zeichen zum Entfernen übergeben (z. B. entfernt .str.strip('$') Dollarzeichen).

import pandas as pd

df = pd.DataFrame({'code': ['  A001  ', '$B002$', '  C003']})

print(df['code'].str.strip())     # 'A001', '$B002$', 'C003'
print(df['code'].str.strip('$ ')) # 'A001', 'B002', 'C003'

Länge mit .str.len() prüfen

.str.len() gibt die Anzahl der Zeichen in jedem Zeichenfolgenelement als ganzzahlige Series zurück. Das ist nützlich für Validierungen – etwa um zu prüfen, ob ein Produktcode immer fünf Zeichen lang ist, eine Telefonnummer die richtige Anzahl an Ziffern besitzt oder ein Textfeld nicht verdächtig kurz ist (z. B. nur ein Zeichen enthält, was auf einen Platzhalter hindeuten kann).

import pandas as pd

df = pd.DataFrame({'sku': ['A001', 'BB02', 'CCC', 'D0005', 'E1']})

df['sku_len'] = df['sku'].str.len()
print(df)

# Rows with unexpected SKU length
bad_skus = df[df['sku_len'] != 4]
print(bad_skus)
#     sku  sku_len
# 2   CCC        3
# 3  D0005        5
# 4    E1        2

Präfixe und Suffixe prüfen

.str.startswith() und .str.endswith() geben boolesche Series zurück. Sie sind die übersichtlichste Möglichkeit, Zeilen danach zu filtern, wie ein Zeichenfolgenwert beginnt oder endet – beispielsweise, um alle Bestell-IDs auszuwählen, die mit 'ORD' beginnen, oder alle Dateinamen, die mit '.csv' enden. Beide Methoden akzeptieren außerdem Tupel von Zeichenfolgen, um mehrere Präfixe oder Suffixe gleichzeitig zu prüfen.

import pandas as pd

df = pd.DataFrame({'file': ['data.csv', 'report.xlsx', 'backup.csv', 'config.json']})

# Filter CSV files
csv_files = df[df['file'].str.endswith('.csv')]
print(csv_files)
#         file
# 0   data.csv
# 2  backup.csv

# Multiple suffixes
spreadsheets = df[df['file'].str.endswith(('.csv', '.xlsx'))]
print(spreadsheets.shape)  # (3, 1)

.str.contains() für die Suche nach Teilzeichenfolgen

.str.contains(pattern) gibt eine boolesche Series zurück, die angibt, ob jedes Element das angegebene Muster enthält. Standardmäßig wird das Muster als regulärer Ausdruck behandelt. Für die Suche nach einer literalen Teilzeichenfolge können Sie jedoch regex=False übergeben. Das Argument na=False behandelt NaN als nicht übereinstimmend, statt NaN an das Ergebnis weiterzugeben.

import pandas as pd

df = pd.DataFrame({
    'description': ['Red apple', 'Green banana', 'Red cherry', None, 'Blue grape']
})

# Find rows containing 'Red' (case-sensitive)
mask = df['description'].str.contains('Red', na=False)
print(df[mask])
#    description
# 0   Red apple
# 2  Red cherry

Verhalten von NaN bei .str-Methoden

Wenn eine Series NaN-Werte enthält, geben die meisten .str-Methoden NaN standardmäßig weiter – an den fehlenden Positionen der Ausgabe-Series wird NaN zurückgegeben. Methoden, die boolesche Werte liefern (etwa .str.contains()), geben an fehlenden Positionen standardmäßig NaN zurück. Das kann zu Problemen bei der booleschen Indizierung führen. Verwenden Sie na=False, um NaN als nicht übereinstimmend zu behandeln, oder na=True, um NaN als übereinstimmend zu behandeln.

import pandas as pd
import numpy as np

s = pd.Series(['hello', None, 'world', np.nan])

# Default: NaN propagates
print(s.str.upper())
# 0    HELLO
# 1     None
# 2    WORLD
# 3      NaN

# contains with na=False: NaN treated as non-matching
print(s.str.contains('o', na=False))
# 0     True
# 1    False
# 2     True
# 3    False

.str.count() zum Zählen von Mustervorkommen

.str.count(pattern) zählt, wie oft ein Muster in jedem Zeichenfolgenelement vorkommt. Das ist nützlich für Feature Engineering in der Verarbeitung natürlicher Sprache – beispielsweise, um zu zählen, wie oft ein Wort vorkommt, wie viele Ziffern eine Zeichenfolge enthält oder wie viele Kommas die Werte in einem durch Trennzeichen gegliederten Feld voneinander trennen.

import pandas as pd

df = pd.DataFrame({'text': ['hello world', 'foo bar baz', 'a b c d e']})

# Count number of words (spaces + 1)
df['word_count'] = df['text'].str.count(' ') + 1
print(df)
#           text  word_count
# 0  hello world           2
# 1  foo bar baz           3
# 2    a b c d e           5

.str-Methoden verketten

Da jede .str-Methode eine neue Series zurückgibt, können Sie mehrere String-Operationen in einem Ausdruck verketten. Dies ist die übersichtlichste Methode, mehrere Bereinigungsschritte auf eine Textspalte anzuwenden: Leerzeichen entfernen, in Kleinbuchstaben umwandeln und Sonderzeichen entfernen – alles in einer einzigen gut lesbaren Zeile. Die Verkettung wird von links nach rechts ausgewertet, wobei jeder Schritt sein Ergebnis an den nächsten weitergibt.

import pandas as pd

df = pd.DataFrame({'tag': ['  Python  ', ' DATA-SCIENCE ', ' Machine_Learning !']})

df['tag_clean'] = (
    df['tag']
    .str.strip()
    .str.lower()
    .str.replace('[-_!]', ' ', regex=True)
    .str.strip()
)
print(df)
#                      tag           tag_clean
# 0            Python       python
# 1       DATA-SCIENCE     data science
# 2  Machine_Learning !  machine learning

Zeichen mit .str[] indizieren

Die Schreibweise .str[n] extrahiert aus jedem String das Zeichen an der Position n, während .str[start:end] einen Teilstring als Slice extrahiert. Dabei handelt es sich um vektorisierte Indizierung von Strings, die sich beispielsweise zum Extrahieren von Codes mit fester Länge eignet – etwa Postleitzahlpräfixen, Jahresziffern aus Datumsstrings oder dem ersten Buchstaben eines Namens.

import pandas as pd

df = pd.DataFrame({'code': ['NYC-001', 'LAX-042', 'ORD-018']})

# Extract city code (first 3 chars)
df['city'] = df['code'].str[:3]

# Extract numeric part (chars 4 onwards)
df['num'] = df['code'].str[4:]

print(df)
#       code city num
# 0  NYC-001  NYC 001
# 1  LAX-042  LAX 042
# 2  ORD-018  ORD 018

Praktische Datenbereinigung mit .str

Hier sehen Sie eine realistische Pipeline zur Textbereinigung einer Produktnamenspalte, die von einer Webseite extrahiert wurde. Sie kombiniert das Entfernen von Leerzeichen am Anfang und Ende, die Normalisierung der Groß- und Kleinschreibung, das Entfernen von Satzzeichen und das Zusammenfassen von Leerraum – eine typische Vorverarbeitungssequenz für NLP- und Datenbereinigungsaufgaben.

import pandas as pd

df = pd.DataFrame({
    'product': ['  Apple iPhone 15!!', 'samsung GALAXY s24 ', '  Google Pixel 8  Pro  ']
})

df['product_clean'] = (
    df['product']
    .str.strip()
    .str.title()
    .str.replace('[^A-Za-z0-9 ]', '', regex=True)  # remove punctuation
    .str.replace(r'\s+', ' ', regex=True)            # collapse extra spaces
    .str.strip()
)
print(df['product_clean'].tolist())
# ['Apple Iphone 15', 'Samsung Galaxy S24', 'Google Pixel 8 Pro']

Kurze Überprüfung

Testen Sie Ihr Verständnis des .str-Accessors.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: Der .str-Accessor stellt vektorisierte String-Methoden für eine Pandas Series bereit, darunter lower/upper/strip zur Normalisierung, startswith/endswith/contains zum Filtern sowie len/count zum Messen. Verketten Sie mehrere .str-Aufrufe zu übersichtlichen Bereinigungspipelines. Verwenden Sie na=False, wenn NaN-Werte vorhanden sind. Als Nächstes teilen und ersetzen wir Strings für fortgeschrittenere Transformationen.

Häufig gestellte Fragen

Ist die Lektion „Der .str-Accessor“ kostenlos?

Ja — der vollständige Text von „Der .str-Accessor“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Der .str-Accessor“?

Greifen Sie in einer Series mit .str auf String-Methoden zu und wenden Sie lower(), upper(), strip() und len() auf alle Werte an. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?

Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Der .str-Accessor“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?

Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Der .str-Accessor
  2. Strings aufteilen und ersetzen
  3. Musterabgleich mit regulären Ausdrücken
  4. Textspalten kombinieren und bereinigen
← Zurück zu Pandas & NumPy Academy