Pandas & NumPy Academy · Lektion

Attributet .str

Åtkom strängmetoder på en Series med .str och använd lower(), upper(), strip() och len() på alla värden.

Lektion 1 av 413 steg

Attributet .str är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Pandas & NumPy Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Introduktion till accessorn .str

Python-strängar har många användbara metoder som .lower(), .strip() och .replace(), men du kan inte anropa dem direkt på en Pandas-Series med strängar – då skulle du behöva en loop. Accessorn .str löser detta genom att tillhandahålla vektoriserade versioner av Pythons inbyggda strängmetoder för en Series. Operationen tillämpas på alla element samtidigt utan att du behöver skriva en loop, och NaN hanteras korrekt (NaN returneras för saknade värden).

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

Metoder för konvertering av skiftläge

Inkonsekvent användning av versaler och gemener är ett av de vanligaste problemen med datakvalitet. Accessorn .str tillhandahåller .lower(), .upper(), .title() (första bokstaven i varje ord skrivs med versal) och .capitalize() (endast strängens första bokstav skrivs med versal). Använd .lower() före jämförelser och groupby-operationer för att undvika att 'NYC' och 'nyc' behandlas som olika grupper.

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

Ta bort blanksteg

Inledande och avslutande blanksteg är osynliga i visningar, men gör att jämförelser av exakta matchningar misslyckas utan tydlig felindikering. .str.strip() tar bort blanksteg från båda ändarna, .str.lstrip() tar endast bort dem från vänster sida och .str.rstrip() tar endast bort dem från höger sida. Du kan också ange ett specifikt tecken som ska tas bort, till exempel tar .str.strip('$') bort dollartecken.

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'

Kontrollera längden med .str.len()

.str.len() returnerar antalet tecken i varje strängelement som en heltals-Series. Detta är användbart för validering – till exempel för att kontrollera att en produktkod alltid består av 5 tecken, att ett telefonnummer har rätt antal siffror eller att ett textfält inte är misstänkt kort, exempelvis ett enda tecken som kan tyda på en platshållare.

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

Kontrollera prefix och suffix

.str.startswith() och .str.endswith() returnerar booleska Series. De är det tydligaste sättet att filtrera rader utifrån hur ett strängvärde börjar eller slutar – till exempel för att välja alla order-ID:n som börjar med 'ORD' eller alla filnamn som slutar med '.csv'. De accepterar också tupler av strängar för att kontrollera flera prefix eller suffix samtidigt.

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 sökning efter delsträngar

.str.contains(pattern) returnerar en boolesk Series som anger om varje element innehåller det angivna mönstret. Som standard accepterar den ett reguljärt uttryck, men du kan skicka med regex=False för en sökning efter en bokstavlig delsträng. Argumentet na=False behandlar NaN som en icke-matchning i stället för att låta NaN spridas till resultatet.

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

NaN-beteende i .str-metoder

När en Series innehåller NaN-värden sprider de flesta .str-metoder NaN som standard – de returnerar NaN för de saknade positionerna i resultatet. Metoder som returnerar booleska värden, till exempel .str.contains(), returnerar som standard NaN för saknade positioner, vilket kan orsaka problem vid boolesk indexering. Använd na=False för att behandla NaN som en icke-matchning eller na=True för att behandla det som en matchning.

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() för mönsterfrekvens

.str.count(pattern) räknar hur många gånger ett mönster förekommer i varje strängelement. Detta är användbart för funktionsskapande inom bearbetning av naturligt språk – till exempel för att räkna hur många gånger ett ord förekommer, hur många siffror en sträng innehåller eller hur många kommatecken som avgränsar värden i ett fält med avgränsare.

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

Kedja .str-metoder

Eftersom varje .str-metod returnerar en ny Series kan Ni kedja flera strängoperationer i samma uttryck. Det här är det tydligaste sättet att utföra flera rensningssteg på en textkolumn: ta bort blanksteg, konvertera till gemener och ta bort specialtecken – allt på en enda läsbar rad. Kedjan utvärderas från vänster till höger, där varje steg skickar sitt resultat vidare till nästa.

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

Indexera tecken med .str[]

Notation med .str[n] hämtar tecknet på position n från varje sträng, och .str[start:end] hämtar ett delsträngsintervall. Det här är vektoriserad indexering av strängarna och är användbart för att hämta koder med fast bredd, till exempel postnummerprefix, årtalssiffror från datumsträngar eller den första bokstaven i ett namn.

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

Praktisk rensning med .str

Här är en realistisk pipeline för textrensning av en kolumn med produktnamn som har hämtats från en webbsida. Den kombinerar borttagning av blanksteg, normalisering av skiftläge, borttagning av interpunktion och komprimering av blanksteg – en standardsekvens för förbehandling i alla NLP- eller datarensningsuppgifter.

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']

Snabb kontroll

Testa Er förståelse av åtkomstobjektet .str.

Lektionssammanfattning

I den här lektionen lärde Ni Er att .str accessor tillhandahåller vektoriserade strängmetoder för en Pandas Series, bland annat lower/upper/strip för normalisering, startswith/endswith/contains för filtrering samt len/count för mätning. Kedja flera .str-anrop för att skapa läsbara rensningspipelines. Använd na=False när NaN-värden förekommer. Härnäst delar vi upp och ersätter strängar för mer avancerade transformationer.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
30
Lektioner
120

Vanliga frågor

Är lektionen ”Attributet .str” gratis?

Ja – hela texten till ”Attributet .str” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Pandas & NumPy Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Attributet .str”?

Åtkom strängmetoder på en Series med .str och använd lower(), upper(), strip() och len() på alla värden. Ni övar på Pandas & NumPy Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Pandas & NumPy Academy?

Du behöver inga förkunskaper. Utbildningen i Pandas & NumPy Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Attributet .str”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Pandas & NumPy Academy-lektionen?

Ja. Varje Pandas & NumPy Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Attributet .str
  2. Dela upp och ersätta strängar
  3. Mönstermatchning med regex
  4. Kombinera och rensa textkolumner
← Tillbaka till Pandas & NumPy Academy