Pandas & NumPy Academy · Aula

Lendo de URLs e StringIO

Carregue arquivos CSV remotos diretamente de uma URL e analise strings CSV em memória usando io.StringIO para testes.

Lendo de URLs e StringIO é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

Lendo dados sem baixar arquivos

Nem sempre é necessário salvar um arquivo no disco antes de carregá-lo no Pandas. pd.read_csv(url) aceita diretamente uma URL HTTP ou HTTPS e baixa o arquivo para um DataFrame em uma única etapa. Isso é ideal para conjuntos de dados públicos hospedados no GitHub, em data.gov ou em qualquer servidor web, além de tornar os notebooks reproduzíveis — qualquer pessoa pode executá-los sem baixar os recursos previamente.

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

Como a leitura de URLs funciona internamente

Quando você passa uma URL para read_csv(), o Pandas usa internamente a biblioteca urllib ou requests do Python para baixar os bytes brutos e, em seguida, os analisa exatamente como se viessem de um arquivo local. A maioria das funções de leitura (read_excel, read_json, read_parquet) oferece suporte a URLs. Os arquivos compactados como .gz ou .bz2 são descompactados 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)

Adicionando cabeçalhos de solicitação para autenticação

Algumas APIs exigem cabeçalhos de autenticação (tokens Bearer, chaves de API). A leitura de URLs pelo Pandas não oferece suporte direto a cabeçalhos personalizados. Nesses casos, use requests para baixar primeiro o conteúdo e, em seguida, envolva-o em io.StringIO antes de passá-lo ao Pandas. Esse padrão em duas etapas separa as questões de HTTP da análise dos dados.

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)

O que é io.StringIO?

io.StringIO é uma classe da biblioteca padrão do Python que cria um objeto semelhante a um arquivo na memória a partir de uma string. Como as funções de leitura do Pandas esperam um caminho de arquivo ou um objeto semelhante a um arquivo, você pode envolver qualquer string CSV em StringIO e passá-la diretamente. Isso é extremamente útil para testes, para processar respostas de APIs e para analisar dados CSV gerados dinamicamente por código 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     88

io.BytesIO para dados binários

Para formatos binários como Excel, Parquet ou CSV compactado, use io.BytesIO (um buffer na memória baseado em bytes) em vez de io.StringIO. Envolva os bytes brutos de uma resposta de rede ou de um campo BLOB de um banco de dados em BytesIO e passe-o ao leitor apropriado. Assim, você evita gravar arquivos temporários no 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)

Testando com StringIO

Um uso importante de StringIO é em testes unitários: incorpore pequenas strings CSV diretamente na função de teste, em vez de fornecer arquivos de dados de teste. Isso torna os testes autocontidos, portáteis e rápidos. Os dados de teste ficam sob controle de versão junto com o código e não podem ficar dessincronizados em relação a um arquivo externo.

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()

Gravando em StringIO para CSV na memória

Você pode gravar um DataFrame em um buffer StringIO com df.to_csv(buffer) para produzir uma string CSV na memória sem criar um arquivo. Chame buffer.getvalue() para recuperar a string. Isso é útil para incorporar CSV ao corpo de um e-mail, enviá-lo em uma resposta HTTP ou comparar a saída CSV esperada com a real nos testes.

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'

Armazenando dados remotos em cache com Requests-Cache

Baixar repetidamente a mesma URL durante o desenvolvimento é lento e desperdiça largura de banda. Use requests-cache ou salve o primeiro download em um arquivo local. Um padrão comum é verificar se existe um arquivo de cache local e usar a URL como alternativa somente quando ele estiver ausente. Assim, o desenvolvimento fica rápido e os notebooks continuam executáveis desde o início.

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)

Transmitindo arquivos remotos grandes em fluxo

Para arquivos CSV remotos grandes demais para a memória, combine a transmissão em fluxo de requests com chunksize. Transmita o conteúdo da resposta linha a linha para um buffer StringIO, leia blocos e processe-os incrementalmente. Como alternativa, baixe diretamente com requests para um arquivo local em blocos e use a leitura em blocos do Pandas na cópia local.

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 chunk

Lendo várias URLs em paralelo

Quando você precisa combinar conjuntos de dados de várias URLs, lê-los sequencialmente é lento. Use concurrent.futures.ThreadPoolExecutor do Python para baixar e analisar várias URLs simultaneamente e, em seguida, aplique pd.concat() aos resultados. Para a análise limitada pela CPU de muitos arquivos grandes, ProcessPoolExecutor pode ser mais rápido.

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)

Considerações de segurança para URLs remotas

A leitura de URLs não confiáveis envolve riscos: um servidor mal-intencionado pode redirecionar para um formato inesperado, disponibilizar um arquivo extremamente grande que esgote a memória ou injetar conteúdo que confunda o analisador. Sempre valide o esquema da URL (deve ser HTTPS para dados sensíveis), defina um tempo limite para o download e limite o número de linhas com nrows= ao explorar uma URL desconhecida pela primeira vez.

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ção rápida

Teste sua compreensão sobre a leitura de URLs e StringIO com base nesta lição.

Recapitulação da lição

Nesta lição, você aprendeu que: pd.read_csv() aceita URLs HTTP/HTTPS diretamente, sem que seja necessário baixar os arquivos primeiro, io.StringIO envolve uma string CSV em um objeto semelhante a um arquivo para que o Pandas possa analisá-la na memória e io.BytesIO faz o mesmo para formatos binários como Excel e Parquet. Isso conclui o curso Leitura e gravação de dados — em seguida, filtraremos DataFrames com precisão usando indexação booleana e o método query().

Perguntas Frequentes

A aula “Lendo de URLs e StringIO” é grátis?

Sim — o texto completo de “Lendo de URLs e StringIO” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

O que vou aprender em “Lendo de URLs e StringIO”?

Carregue arquivos CSV remotos diretamente de uma URL e analise strings CSV em memória usando io.StringIO para testes. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Pandas & NumPy Academy?

Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Lendo de URLs e StringIO”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Pandas & NumPy Academy?

Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Pandas & NumPy Academy