Dele opp og erstatte strenger
Del strenger i flere kolonner med .str.split(expand=True), og erstatt delstrenger med .str.replace().
Dele opp og erstatte strenger er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Dele strenger opp i en liste
.str.split(sep) deler hver streng i en Series ved hver forekomst av skilletegnet og returnerer en Series med lister. Uten expand=True er hvert element en Python-liste, noe som er nyttig for å telle tokens eller utføre videre behandling på listenivå. Skilletegnet kan være en bokstavelig streng eller et regex-mønster.
import pandas as pd
df = pd.DataFrame({'tags': ['python,data,pandas', 'ml,ai', 'sql,db,query']})
# Split into a list of strings
df['tag_list'] = df['tags'].str.split(',')
print(df['tag_list'])
# 0 [python, data, pandas]
# 1 [ml, ai]
# 2 [sql, db, query]
# Count tags per row
df['tag_count'] = df['tag_list'].str.len()
print(df['tag_count'].tolist()) # [3, 2, 3]expand=True for å dele opp i kolonner
Når De sender expand=True til .str.split(), returneres en DataFrame i stedet for en Series med lister. Hvert oppdelte token blir sin egen kolonne (kolonne 0, 1, 2, …). Dette er standardmåten å utvide en kolonne med skilletegn på – for eksempel ved å dele et fullt navn som «first last» opp i separate kolonner for fornavn og etternavn.
import pandas as pd
df = pd.DataFrame({'full_name': ['Alice Smith', 'Bob Jones', 'Carol White']})
# Split into two columns
name_parts = df['full_name'].str.split(' ', expand=True)
name_parts.columns = ['first_name', 'last_name']
df = pd.concat([df, name_parts], axis=1)
print(df)
# full_name first_name last_name
# 0 Alice Smith Alice Smith
# 1 Bob Jones Bob Jones
# 2 Carol White Carol WhiteBegrense antall oppdelinger med n=
Parameteren n begrenser det maksimale antallet oppdelinger. .str.split(sep, n=1) deler opp høyst én gang, slik at det opprettes maksimalt to deler. Dette er nyttig når De bare trenger den første delen av en streng, mens resten kan forbli samlet – for eksempel når De henter domenet fra en e-postadresse ved å dele ved '@'.
import pandas as pd
df = pd.DataFrame({'email': ['alice@example.com', 'bob@work.org', 'carol@test.net']})
# Split at '@', keep only the first split
parts = df['email'].str.split('@', n=1, expand=True)
df['username'] = parts[0]
df['domain'] = parts[1]
print(df[['username', 'domain']])
# username domain
# 0 alice example.com
# 1 bob work.org
# 2 carol test.netrsplit() for oppdeling fra høyre
.str.rsplit(sep, n=1) deler strengen fra høyre side. Dette er nyttig når De vil hente den siste delen – for eksempel filendelsen fra en bane ved å dele ved det siste punktumet. Kombinert med expand=True opprettes to kolonner: alt før det siste skilletegnet og alt etter.
import pandas as pd
df = pd.DataFrame({'filepath': ['data/raw/sales.csv', 'data/clean/orders.xlsx', 'reports/q1.pdf']})
# Split on the last '/' to separate directory from filename
parts = df['filepath'].str.rsplit('/', n=1, expand=True)
df['directory'] = parts[0]
df['filename'] = parts[1]
print(df[['directory', 'filename']])
# directory filename
# 0 data/raw sales.csv
# 1 data/clean orders.xlsx
# 2 reports q1.pdf.str.replace() for erstatning av delstrenger
.str.replace(pat, repl) erstatter forekomster av et mønster i hver streng. Som standard behandles pat som et regulært uttrykk, så De må angi regex=False for bokstavelig strengutskifting. Erstatningen kan være en fast streng eller en backreferanse i et regex. Bruk alltid denne metoden for vektorisert utskifting i stedet for en Python-løkke.
import pandas as pd
df = pd.DataFrame({'price': ['$1,200.50', '$800.00', '$3,450.75']})
# Remove dollar sign and commas
df['price_clean'] = (
df['price']
.str.replace('$', '', regex=False) # literal $
.str.replace(',', '', regex=False) # literal comma
)
df['price_float'] = df['price_clean'].astype(float)
print(df)
# price price_clean price_float
# 0 $1,200.50 1200.50 1200.5
# 1 $800.00 800.00 800.0
# 2 $3,450.75 3450.75 3450.75Erstatte med regex-mønstre
Når De sender regex=True (standardverdien), er mønsteret et regulært uttrykk, og erstatningen kan inneholde backreferanser som r'\1' for å referere til grupper som er fanget opp. Dette muliggjør kraftige teksttransformasjoner, som omformatering av datoer, normalisering av telefonnumre eller uthenting av strukturerte data fra fritekst.
import pandas as pd
df = pd.DataFrame({'date': ['01-15-2024', '03-20-2024', '07-04-2024']})
# Reformat from MM-DD-YYYY to YYYY-MM-DD using groups
df['date_iso'] = df['date'].str.replace(
r'(\d{2})-(\d{2})-(\d{4})',
r'\3-\1-\2',
regex=True
)
print(df)
# date date_iso
# 0 01-15-2024 2024-01-15
# 1 03-20-2024 2024-03-20
# 2 07-04-2024 2024-07-04Telle utførte erstatninger
Noen ganger ønsker De å kontrollere hvor mange verdier som faktisk ble endret av en erstatning. Sammenlign den opprinnelige og den erstattede Series-en for å telle rader der det skjedde en endring. Dette valideringstrinnet bekrefter at erstatningsmønsteret traff som forventet, og gjør det enklere å oppdage regex-feil tidlig.
import pandas as pd
df = pd.DataFrame({'text': ['foo bar', 'hello foo', 'world', 'foo foo']})
original = df['text'].copy()
df['text'] = df['text'].str.replace('foo', 'baz', regex=False)
changed = (df['text'] != original).sum()
print(f'{changed} rows were modified') # 3
print(df['text'].tolist())
# ['baz bar', 'hello baz', 'world', 'baz baz']Erstatte flere mønstre med en løkke
Når De må utføre mange erstatninger (for eksempel standardisere dusinvis av forkortelser), kan De gå gjennom en mapping-ordbok og bruke hver erstatning etter tur. Dette er enklere å vedlikeholde enn ett komplekst regex-uttrykk med alternativer. Bygg mappingen fra forretningsregler eller en oppslagstabell.
import pandas as pd
df = pd.DataFrame({'dept': ['Eng', 'Engg', 'HR', 'Human Resources', 'Mktg', 'Marketing']})
# Standardisation map
substitutions = {
'Engg': 'Engineering',
'Eng': 'Engineering',
'Human Resources': 'HR',
'Mktg': 'Marketing'
}
for old, new in substitutions.items():
df['dept'] = df['dept'].str.replace(old, new, regex=False)
print(df['dept'].tolist())
# ['Engineering', 'Engineering', 'HR', 'HR', 'Marketing', 'Marketing']Sette sammen oppdelte deler igjen
Etter oppdeling kan De ha behov for å sette delene sammen igjen. For en Series med lister bruker De .str.join(separator) til å sette listeelementene sammen til én streng per rad. Når De skal sette sammen verdier på tvers av kolonner, bruker De standard strengsammenslåing med + og .astype(str).
import pandas as pd
df = pd.DataFrame({'parts': [['alpha', 'beta'], ['foo', 'bar', 'baz']]})
# Join list elements with a hyphen
df['joined'] = df['parts'].str.join('-')
print(df['joined'])
# 0 alpha-beta
# 1 foo-bar-bazNormalisere mellomrom
En vanlig oppgave innen tekstrensing er å slå sammen flere påfølgende mellomrom til ett enkelt mellomrom. Dette skjer ofte i tekst som er hentet fra nettsider, der mellomrom i HTML eller kopiering og innliming legger til ekstra mellomrom. Regex-mønsteret r'\s+' finner ett eller flere mellomromstegn og erstatter dem alle med ett enkelt mellomrom. Deretter fjerner .str.strip() eventuelle mellomrom i begynnelsen eller slutten.
import pandas as pd
df = pd.DataFrame({'address': ['123 Main St', ' 456 Oak Ave ', '789 Pine St']})
df['address_clean'] = (
df['address']
.str.replace(r'\s+', ' ', regex=True)
.str.strip()
)
print(df['address_clean'].tolist())
# ['123 Main St', '456 Oak Ave', '789 Pine St']Praktisk: Tolke en strukturert strengkolonne
Her er et realistisk eksempel der én kolonne inneholder strukturerte data som 'Alice:25:Engineer'. Vi deler opp ved skilletegnet, gir de resulterende kolonnene navn og konverterer hver av dem til riktig type – en komplett pipeline for parsing og typekonvertering som bare bruker .str.split() og astype().
import pandas as pd
df = pd.DataFrame({'record': ['Alice:25:Engineer', 'Bob:34:Manager', 'Carol:28:Analyst']})
parts = df['record'].str.split(':', expand=True)
parts.columns = ['name', 'age', 'role']
parts['age'] = parts['age'].astype(int)
result = pd.concat([df, parts], axis=1)
print(result)
# record name age role
# 0 Alice:25:Engineer Alice 25 Engineer
# 1 Bob:34:Manager Bob 34 Manager
# 2 Carol:28:Analyst Carol 28 AnalystHurtigsjekk
Test forståelsen Deres av å dele opp og erstatte strenger.
Oppsummering av leksjonen
I denne leksjonen har De lært at str.split(sep, expand=True) utvider en kolonne med skilletegn til flere kolonner, at n= begrenser antallet oppdelinger, at str.rsplit() deler opp fra høyre, og at str.replace() erstatter mønstre (med støtte for regex). Kjed split- og replace-operasjoner med strip og lower for å bygge komplette pipelines for tekstnormalisering. Neste del handler om å bruke regex-mønstre til å hente ut og finne delstrenger.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Dele opp og erstatte strenger» gratis?
Ja – hele teksten i «Dele opp og erstatte strenger» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Dele opp og erstatte strenger»?
Del strenger i flere kolonner med .str.split(expand=True), og erstatt delstrenger med .str.replace(). Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?
Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.
Hvor lang tid tar leksjonen «Dele opp og erstatte strenger»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?
Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Accessoren .str
- Dele opp og erstatte strenger
- Mønstergjenkjenning med regex
- Kombinere og rense tekstkolonner