Lettura da URL e StringIO
Carichi file CSV remoti direttamente da un URL e analizzi stringhe CSV in memoria usando io.StringIO per i test.
Lettura da URL e StringIO è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 4 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.
Lettura dei dati senza scaricare file
Non è sempre necessario salvare un file su disco prima di caricarlo in Pandas. pd.read_csv(url) accetta direttamente un URL HTTP o HTTPS e scarica il file in un DataFrame in un solo passaggio. È ideale per i dataset pubblici ospitati su GitHub, data.gov o qualsiasi server web e rende i notebook riproducibili: chiunque può eseguirli senza scaricare prima le risorse.
import pandas as pd
url = 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv'
df = pd.read_csv(url)
print(df.shape) # (244, 7)
print(df.head(2))Come funziona internamente la lettura degli URL
Quando si passa un URL a read_csv(), Pandas utilizza internamente la libreria Python urllib o requests per scaricare i byte grezzi, quindi li analizza esattamente come se provenissero da un file locale. La maggior parte delle funzioni di lettura (read_excel, read_json, read_parquet) supporta gli URL. I file compressi come .gz o .bz2 vengono decompressi automaticamente.
import pandas as pd
# Compressed CSV from URL -- auto-decompressed
url = 'https://example.com/data.csv.gz'
df = pd.read_csv(url, compression='infer')
print(df.shape)Aggiunta di intestazioni delle richieste per l'autenticazione
Alcune API richiedono intestazioni di autenticazione, come token Bearer e chiavi API. La lettura degli URL in Pandas non supporta direttamente le intestazioni personalizzate. In questi casi, utilizzi requests per scaricare prima il contenuto, quindi lo racchiuda in io.StringIO prima di passarlo a Pandas. Questo schema in due passaggi separa la gestione HTTP dall'analisi dei dati.
import pandas as pd
import requests
import io
headers = {'Authorization': 'Bearer mytoken123'}
response = requests.get('https://api.example.com/export.csv',
headers=headers)
df = pd.read_csv(io.StringIO(response.text))
print(df.shape)Che cos'è io.StringIO?
io.StringIO è una classe della libreria standard di Python che crea un oggetto simile a un file in memoria a partire da una stringa. Poiché le funzioni di lettura di Pandas si aspettano un percorso di file o un oggetto simile a un file, è possibile racchiudere qualsiasi stringa CSV in StringIO e passarla direttamente. È prezioso per i test, per elaborare le risposte delle API e per analizzare dati CSV generati dinamicamente dal codice Python.
import pandas as pd
import io
csv_text = 'name,score\nAlice,90\nBob,75\nCarol,88'
df = pd.read_csv(io.StringIO(csv_text))
print(df)
# name score
# 0 Alice 90
# 1 Bob 75
# 2 Carol 88io.BytesIO per i dati binari
Per i formati binari come Excel, Parquet o CSV compressi, utilizzi io.BytesIO (un buffer in memoria basato su bytes) anziché io.StringIO. Racchiuda i byte grezzi provenienti da una risposta di rete o da un campo BLOB di un database in BytesIO e li passi al lettore appropriato. In questo modo evita di scrivere file temporanei su disco.
import pandas as pd
import requests
import io
# Download an Excel file without saving to disk
response = requests.get('https://example.com/report.xlsx')
buffer = io.BytesIO(response.content)
df = pd.read_excel(buffer, sheet_name='Data')
print(df.shape)Test con StringIO
Un uso importante di StringIO è nei test unitari: incorpori piccole stringhe CSV direttamente nella funzione di test invece di fornire file di fixture. In questo modo i test sono autonomi, portabili e veloci. I dati di test vengono sottoposti al controllo versione insieme al codice e non possono divergere da un file esterno.
import pandas as pd
import io
def test_clean_names():
raw = 'name,age\n Alice ,30\nBob ,25'
df = pd.read_csv(io.StringIO(raw))
df['name'] = df['name'].str.strip()
assert df['name'].tolist() == ['Alice', 'Bob']
print('Test passed')
test_clean_names()Scrittura in StringIO per CSV in memoria
È possibile scrivere un DataFrame in un buffer StringIO con df.to_csv(buffer) per produrre una stringa CSV in memoria senza creare un file. Chiami buffer.getvalue() per recuperare la stringa. È utile per incorporare CSV nel corpo di un'email, inviarli in una risposta HTTP o confrontare l'output CSV previsto con quello effettivo nei test.
import pandas as pd
import io
df = pd.DataFrame({'x': [1, 2], 'y': [3, 4]})
buffer = io.StringIO()
df.to_csv(buffer, index=False)
csv_string = buffer.getvalue()
print(repr(csv_string))
# 'x,y\n1,3\n2,4\n'Memorizzazione nella cache dei dati remoti con Requests-Cache
Scaricare ripetutamente lo stesso URL durante lo sviluppo è lento e spreca banda. Utilizzi requests-cache oppure salvi il primo download in un file locale. Uno schema comune consiste nel verificare se esiste un file di cache locale e usare l'URL solo quando il file non è presente. In questo modo lo sviluppo è rapido, mantenendo al contempo i notebook eseguibili da zero.
import pandas as pd
import os
LOCAL = 'data/tips_cache.csv'
URL = 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv'
if os.path.exists(LOCAL):
df = pd.read_csv(LOCAL)
else:
df = pd.read_csv(URL)
df.to_csv(LOCAL, index=False)
print('Loaded:', df.shape)Streaming di file remoti di grandi dimensioni
Per i file CSV remoti di grandi dimensioni che superano la memoria disponibile, combini lo streaming di requests con chunksize. Trasmetta il contenuto della risposta riga per riga in un buffer StringIO, legga i chunk ed elabori i dati progressivamente. In alternativa, scarichi direttamente i dati con requests in un file locale a blocchi, quindi utilizzi la lettura a blocchi di Pandas sulla copia locale.
import requests
import io
import pandas as pd
def stream_csv(url, chunksize=10000):
with requests.get(url, stream=True) as r:
content = r.content.decode('utf-8')
for chunk in pd.read_csv(io.StringIO(content), chunksize=chunksize):
yield chunkLettura parallela di più URL
Quando è necessario combinare dataset provenienti da più URL, leggerli in sequenza è lento. Utilizzi concurrent.futures.ThreadPoolExecutor di Python per scaricare e analizzare più URL contemporaneamente, quindi combini i risultati con pd.concat(). Per l'analisi vincolata dalla CPU di molti file di grandi dimensioni, ProcessPoolExecutor può essere più veloce.
import pandas as pd
from concurrent.futures import ThreadPoolExecutor
urls = [
'https://example.com/data_jan.csv',
'https://example.com/data_feb.csv',
]
with ThreadPoolExecutor(max_workers=4) as ex:
dfs = list(ex.map(pd.read_csv, urls))
combined = pd.concat(dfs, ignore_index=True)
print(combined.shape)Considerazioni sulla sicurezza degli URL remoti
La lettura da URL non attendibili comporta dei rischi: un server malevolo potrebbe reindirizzare a un formato imprevisto, fornire un file estremamente grande esaurendo la memoria o iniettare contenuti che confondono l'analizzatore. Convalidi sempre lo schema dell'URL (deve essere HTTPS per i dati sensibili), imposti un timeout per il download e limiti il numero di righe con nrows= quando esplora per la prima volta un URL sconosciuto.
import pandas as pd
import requests
import io
url = 'https://trusted-source.example.com/data.csv'
response = requests.get(url, timeout=30) # 30-second timeout
response.raise_for_status() # raise on HTTP error
df = pd.read_csv(io.StringIO(response.text), nrows=1000)
print(df.shape)Verifica rapida
Verifichi la comprensione della lettura da URL e di StringIO illustrata in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: pd.read_csv() accetta direttamente URL HTTP/HTTPS senza dover prima scaricare i file, io.StringIO racchiude una stringa CSV in un oggetto simile a un file, consentendo a Pandas di analizzarla in memoria e io.BytesIO svolge la stessa funzione per i formati binari come Excel e Parquet. Con questa lezione si conclude il corso Lettura e scrittura dei dati; prossimamente filtreremo i DataFrame con precisione usando l'indicizzazione booleana e il metodo query().
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 «Lettura da URL e StringIO» è gratuita?
Sì — il testo completo di «Lettura da URL e StringIO» è 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 «Lettura da URL e StringIO»?
Carichi file CSV remoti direttamente da un URL e analizzi stringhe CSV in memoria usando io.StringIO per i test. 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 4 di 4.
Quanto tempo richiede la lezione «Lettura da URL e StringIO»?
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
- Lettura di file CSV
- Lettura di file Excel e JSON
- Scrittura dei DataFrame su file
- Lettura da URL e StringIO