0Pricing
Pandas & NumPy Academy · Lezione

Dividere e sostituire le stringhe

Divida le stringhe in più colonne con .str.split(expand=True) e sostituisca le sottostringhe con .str.replace().

Dividere e sostituire le stringhe è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Dividere le stringhe in una lista

.str.split(sep) divide ogni stringa di una Series in corrispondenza di ogni occorrenza del separatore e restituisce una Series di liste. Senza expand=True, ogni elemento è una lista Python, utile per contare i token o per eseguire ulteriori elaborazioni a livello di lista. Il separatore può essere una stringa letterale o un pattern regex.

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 per dividere in colonne

Passando expand=True a .str.split() si ottiene un DataFrame invece di una Series di liste; ogni token risultante dalla divisione diventa una colonna distinta (colonna 0, 1, 2, …). Questo è il modo standard per ampliare una colonna delimitata, ad esempio dividendo un nome completo 'first last' in colonne separate per nome e cognome.

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     White

Limitare il numero di divisioni con n=

Il parametro n limita il numero massimo di divisioni. .str.split(sep, n=1) divide al massimo una volta, creando al massimo due parti. È utile quando serve soltanto il primo componente di una stringa e si desidera lasciare il resto unito, ad esempio per estrarre il dominio da un indirizzo e-mail dividendo in corrispondenza di '@'.

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.net

rsplit() per dividere dal lato destro

.str.rsplit(sep, n=1) divide la stringa partendo dal lato destro. È utile quando si desidera l'ultimo componente, ad esempio per estrarre l'estensione di un file da un percorso dividendo in corrispondenza dell'ultimo punto. In combinazione con expand=True, crea due colonne: tutto ciò che precede l'ultimo separatore e tutto ciò che lo segue.

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() per sostituire sottostringhe

.str.replace(pat, repl) sostituisce le occorrenze di un pattern in ogni stringa. Per impostazione predefinita, pat viene trattato come un'espressione regolare; passi quindi regex=False per sostituire una stringa letterale. La sostituzione può essere una stringa fissa o un riferimento all'indietro regex. Utilizzi sempre questo metodo per le sostituzioni vettorializzate invece di un ciclo Python.

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.75

Sostituire usando pattern regex

Quando si passa regex=True (il valore predefinito), il pattern è un'espressione regolare e la sostituzione può includere riferimenti all'indietro come r'\1' per fare riferimento ai gruppi acquisiti. Questo consente trasformazioni avanzate del testo, come riformattare le date, normalizzare i numeri di telefono o estrarre dati strutturati da testo libero.

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-04

Contare le sostituzioni effettuate

A volte è necessario verificare quanti valori siano stati effettivamente modificati da una sostituzione. Confronti la Series originale con quella sostituita per contare le righe in cui si è verificata una modifica. Questo passaggio di convalida conferma che il pattern di sostituzione ha trovato le corrispondenze previste e aiuta a individuare tempestivamente gli errori nelle regex.

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

Sostituire più pattern con un ciclo

Quando è necessario applicare molte sostituzioni (ad esempio, standardizzare decine di abbreviazioni), iteri su un dizionario di mapping e applichi ogni sostituzione in sequenza. Questo è più facile da mantenere rispetto a un'unica alternanza regex complessa. Crei il mapping a partire dalle regole aziendali o da una tabella di ricerca.

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

Riunire le parti divise

Dopo aver diviso una stringa, potrebbe essere necessario ricombinare le parti. Per una Series di liste, utilizzi .str.join(separator) per concatenare gli elementi della lista in un'unica stringa per ogni riga. Per unire valori tra colonne, utilizzi la normale concatenazione di stringhe con + e .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-baz

Normalizzare gli spazi

Un'attività comune di pulizia del testo consiste nel comprimere più spazi consecutivi in un singolo spazio. Questo accade spesso nel testo acquisito dal web, quando la spaziatura dell'HTML o il copia-incolla aggiungono spazi bianchi in eccesso. Il pattern regex r'\s+' corrisponde a uno o più caratteri di spaziatura e li sostituisce tutti con un singolo spazio; successivamente, .str.strip() rimuove gli spazi iniziali o finali.

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

Pratica: analizzare una colonna di stringhe strutturate

Ecco un esempio realistico in cui una singola colonna contiene dati strutturati come 'Alice:25:Engineer'. Dividiamo i valori in corrispondenza del delimitatore, assegniamo un nome alle colonne risultanti e convertiamo ciascuna al tipo appropriato: una pipeline completa di analisi e conversione dei tipi usando soltanto .str.split() e 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   Analyst

Verifica rapida

Verifichi la Sua comprensione della divisione e della sostituzione delle stringhe.

Riepilogo della lezione

In questa lezione ha imparato che str.split(sep, expand=True) amplia una colonna delimitata trasformandola in più colonne, n= limita il numero di divisioni, str.rsplit() divide partendo da destra e str.replace() sostituisce i pattern (con supporto per le regex). Concateni le operazioni di divisione e sostituzione con strip e lower per creare pipeline complete di normalizzazione del testo. Prossimamente utilizzeremo i pattern regex per estrarre e trovare corrispondenze nelle sottostringhe.

Domande Frequenti

La lezione «Dividere e sostituire le stringhe» è gratuita?

Sì — il testo completo di «Dividere e sostituire le stringhe» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Cosa imparerò in «Dividere e sostituire le stringhe»?

Divida le stringhe in più colonne con .str.split(expand=True) e sostituisca le sottostringhe con .str.replace(). Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?

Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Dividere e sostituire le stringhe»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?

Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. L'accessor .str
  2. Dividere e sostituire le stringhe
  3. Confrontare pattern con le espressioni regolari
  4. Combinare e ripulire le colonne di testo
← Torna a Pandas & NumPy Academy