Pandas & NumPy Academy · Lezione

L'accessor .str

Acceda ai metodi per le stringhe di una Series usando .str e applichi lower(), upper(), strip() e len() a tutti i valori.

Lezione 1 di 413 passaggi

L'accessor .str è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Introduzione all’accessor .str

Le stringhe Python dispongono di molti metodi utili, come .lower(), .strip() e .replace(), ma non è possibile chiamarli direttamente su una Series Pandas di stringhe: sarebbe necessario usare un ciclo. L’accessor .str risolve il problema mettendo a disposizione su una Series versioni vettorializzate dei metodi per stringhe integrati in Python. L’operazione viene applicata contemporaneamente a ogni elemento, senza scrivere un ciclo, e i valori NaN vengono gestiti correttamente (per i valori mancanti restituisce NaN).

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

Metodi di conversione delle maiuscole e minuscole

L’uso incoerente delle maiuscole e delle minuscole è uno dei problemi più comuni di qualità dei dati. L’accessor .str mette a disposizione .lower(), .upper(), .title() (prima lettera di ogni parola maiuscola) e .capitalize() (solo la prima lettera della stringa maiuscola). Usi .lower() prima dei confronti e delle operazioni di groupby per evitare di trattare 'NYC' e 'nyc' come gruppi diversi.

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

Rimozione degli spazi bianchi

Gli spazi bianchi iniziali e finali sono invisibili nella visualizzazione, ma causano il fallimento silenzioso dei confronti per corrispondenza esatta. .str.strip() rimuove gli spazi da entrambe le estremità, .str.lstrip() li rimuove solo da sinistra e .str.rstrip() solo da destra. È anche possibile passare un carattere specifico da rimuovere (ad esempio, .str.strip('$') elimina i simboli del dollaro).

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'

Controllo della lunghezza con .str.len()

.str.len() restituisce il numero di caratteri di ogni elemento stringa come Series di interi. È utile per la convalida: per verificare che un codice prodotto abbia sempre 5 caratteri, che un numero di telefono contenga il numero corretto di cifre o che un campo di testo non sia sospettosamente breve (ad esempio, un singolo carattere che suggerisce un segnaposto).

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

Controllo dei prefissi e dei suffissi

.str.startswith() e .str.endswith() restituiscono Series booleane. Sono il modo più semplice per filtrare le righe in base a come inizia o termina un valore stringa, ad esempio selezionando tutti gli ID degli ordini che iniziano con 'ORD' o tutti i nomi di file che terminano con '.csv'. Accettano anche tuple di stringhe per controllare contemporaneamente più prefissi o suffissi.

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

.str.contains(pattern) restituisce una Series booleana che indica se ogni elemento contiene il modello specificato. Per impostazione predefinita accetta un’espressione regolare, ma può passare regex=False per cercare una sottostringa letterale. L’argomento na=False considera NaN come non corrispondente, invece di propagare NaN nel risultato.

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

Comportamento di NaN nei metodi .str

Quando una Series contiene valori NaN, la maggior parte dei metodi .str propaga NaN per impostazione predefinita: per le posizioni mancanti della Series di output restituisce NaN. I metodi che restituiscono valori booleani (come .str.contains()) per impostazione predefinita restituiscono NaN nelle posizioni mancanti, causando possibili problemi nell’indicizzazione booleana. Usi na=False per trattare NaN come non corrispondente oppure na=True per trattarlo come corrispondente.

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() per la frequenza dei modelli

.str.count(pattern) conta il numero di volte in cui un modello compare in ogni elemento stringa. È utile per la feature engineering nell’elaborazione del linguaggio naturale, ad esempio per contare quante volte compare una parola, quante cifre contiene una stringa o quante virgole separano i valori in un campo delimitato.

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

Concatenazione dei metodi .str

Poiché ogni metodo .str restituisce una nuova Series, è possibile concatenare più operazioni sulle stringhe in un'unica espressione. Questo è il modo più chiaro per applicare diversi passaggi di pulizia a una colonna di testo: rimuovere gli spazi, convertire in minuscolo ed eliminare i caratteri speciali, tutto in un'unica riga leggibile. La catena viene valutata da sinistra a destra e ogni passaggio fornisce il risultato a quello successivo.

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

Indicizzare i caratteri con .str[]

La notazione .str[n] estrae il carattere nella posizione n da ogni stringa, mentre .str[start:end] estrae una porzione della stringa. Si tratta di un'indicizzazione vettorializzata delle stringhe, utile per estrarre codici a larghezza fissa, come i prefissi dei codici postali, le cifre dell'anno da stringhe di date o la prima lettera di un nome.

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

Pulizia pratica con .str

Ecco una pipeline realistica di pulizia del testo per una colonna contenente nomi di prodotti acquisiti da una pagina web. Combina la rimozione degli spazi iniziali e finali, la normalizzazione delle maiuscole e minuscole, la rimozione della punteggiatura e la compressione degli spazi, una sequenza standard di pre-elaborazione in qualsiasi attività di NLP o pulizia dei dati.

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

Verifica rapida

Verifichi la Sua comprensione dell'accessor .str.

Riepilogo della lezione

In questa lezione ha imparato che l'accessor .str espone metodi vettorializzati per le stringhe su una Pandas Series, tra cui lower/upper/strip per la normalizzazione, startswith/endswith/contains per il filtraggio e len/count per la misurazione. Può concatenare più chiamate .str per creare pipeline di pulizia leggibili. Utilizzi na=False quando sono presenti valori NaN. Prossimamente vedremo come dividere e sostituire le stringhe per realizzare trasformazioni più avanzate.

Gratis per iniziare

Impara Python con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi
30
Lezioni
120

Domande Frequenti

La lezione «L'accessor .str» è gratuita?

Sì — il testo completo di «L'accessor .str» è 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 «L'accessor .str»?

Acceda ai metodi per le stringhe di una Series usando .str e applichi lower(), upper(), strip() e len() a tutti i valori. 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 1 di 4.

Quanto tempo richiede la lezione «L'accessor .str»?

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