Streamlit DataFrame: Exibindo, Estilizando e Otimizando Pandas DataFrames (Atualizado para 2025)

No universo da ciência de dados, a capacidade de visualizar e interagir com seus dados é primordial. Streamlit, uma biblioteca Python, revolucionou a forma como criamos aplicações web ricas em dados com apenas algumas linhas de código. Uma das funcionalidades mais poderosas do Streamlit é sua integração fluida com Pandas DataFrames. Neste artigo, vamos explorar o mundo dos Streamlit DataFrames, mostrando como exibir, estilizar e otimizar seus Pandas DataFrames em uma app Streamlit moderna. Manteremos um estilo de tutorial fácil de seguir — do uso básico a dicas avançadas — atualizado para refletir as capacidades mais recentes do Streamlit em 2025.

O que é um Streamlit DataFrame?

Um Streamlit DataFrame refere-se à exibição de um Pandas DataFrame (ou dados tabulares similares) dentro de uma app Streamlit. É como pegar uma tabela estática de um notebook Jupyter e trazê-la à vida como um elemento interativo em uma aplicação web. Por baixo dos panos, o Streamlit usa Pandas (e outras estruturas de dados como PyArrow ou Polars) para gerenciar os dados, mas envolve essas estruturas em uma interface amigável para a web. Pandas DataFrames são estruturas de dados bidimensionais e rotuladas, onipresentes na ciência de dados. O Streamlit constrói sobre o Pandas oferecendo uma plataforma onde DataFrames podem ser exibidos e manipulados interativamente pelos usuários em tempo real. Em vez de apenas visualizar tabelas estáticas, você pode ordenar colunas, filtrar dados, destacar valores importantes e até permitir que usuários editem dados — tudo através dos componentes intuitivos do Streamlit.

Tutorial de Streamlit DataFrame

Você já ouviu falar desta incrível ferramenta de Análise e Visualização de Dados, que pode facilmente transformar sua Streamlit App em algo parecido com o Tableau?

PyGWalker (opens in a new tab) é uma biblioteca Python que ajuda você a incorporar uma UI alternativa ao Tableau dentro da sua própria Streamlit app de forma descomplicada. Confira este vídeo incrível how to explore data with pygwalker (opens in a new tab) demonstrando os passos detalhados para capacitar sua Streamlit app com essa poderosa Data Visualization Python Library!

Começando com Streamlit DataFrames

Primeiro, certifique-se de que o Streamlit está instalado. Você pode instalá-lo via pip:

pip install streamlit

Importe o Streamlit no seu script Python, juntamente com o Pandas para manipulação de dados:

import streamlit as st
import pandas as pd

Em seguida, crie um DataFrame simples para exibir. Por exemplo, vamos usar um pequeno conjunto de dados de frutas:

data = {
    "Fruit": ["Apple", "Banana", "Cherry", "Date", "Elderberry"],
    "Quantity": [10, 15, 20, 25, 30],
    "Price": [0.5, 0.25, 0.75, 1.0, 2.0]
}
df = pd.DataFrame(data)

Agora, para exibir este DataFrame em uma app Streamlit, use a função st.dataframe():

st.dataframe(df)

Quando você executar sua app Streamlit (streamlit run your_script.py), verá seu DataFrame renderizado como uma tabela interativa. Você pode ordenar a tabela clicando nos cabeçalhos das colunas e redimensionar a tabela arrastando o canto inferior direito. Em versões modernas do Streamlit, a tabela vem com uma barra de ferramentas que permite pesquisar nos dados, copiar dados para a área de transferência e até baixar os dados como CSV. Por padrão, st.dataframe ajusta sua altura para mostrar até 10 linhas e permite rolagem dentro da tabela se houver mais. Este exemplo básico mostra como é fácil começar. A seguir, exploraremos como personalizar a exibição e lidar com conjuntos de dados maiores.

Exibindo DataFrames no Streamlit

Como exibir um DataFrame como tabela interativa

Como mostrado acima, exibir um DataFrame no Streamlit é tão simples quanto chamar st.dataframe(df). No entanto, há mais do que apenas mostrar a tabela — o Streamlit permite personalizar a aparência e a interatividade do DataFrame. Customizando o tamanho: você pode definir o tamanho do componente DataFrame para se adequar ao layout da sua app. Por exemplo, para limitar a altura (em pixels) da exibição da tabela:

st.dataframe(df, height=300)

No código acima, o DataFrame ocupará um espaço vertical de 300 pixels (aproximadamente mostrando ~10 linhas por vez). Se o DataFrame tiver mais linhas, uma barra de rolagem aparece dentro da tabela para que o usuário possa navegar. Similarmente, você pode controlar a largura. Em versões recentes, st.dataframe aceita um parâmetro width (ou você pode usar width="stretch" para fazê-lo expandir até a largura do contêiner). Por exemplo:

st.dataframe(df, width="stretch", height=300)

Isso esticará a tabela para a largura completa da coluna/contêiner da app enquanto fixa a altura. (Observação: o parâmetro antigo use_container_width=True agora está obsoleto em favor de width="stretch" na API mais recente do Streamlit.) Recursos interativos: a exibição do DataFrame no Streamlit não é estática; ela é alimentada por um grid de dados interativo. Usuários podem realizar as seguintes ações diretamente na UI da tabela:

• Ordenar colunas: clicar no cabeçalho da coluna para ordenar crescente/decrescente.
• Redimensionar e reordenar colunas: arrastar as bordas das colunas para redimensionar, ou arrastar os cabeçalhos para reordenar ou fixar colunas.
• Ocultar colunas: usar o menu da coluna (normalmente um menu "⋮" no cabeçalho) para ocultar/exibir colunas específicas.
• Buscar: usar a caixa de busca na barra de ferramentas da tabela (ou pressionar Ctrl+F/Cmd+F) para localizar entradas em todo o DataFrame.
• Copiar e baixar: selecionar células e pressionar Ctrl+C/Cmd+C para copiar, ou usar o botão de download na barra de ferramentas para baixar os dados como CSV.

Todos esses recursos estão disponíveis por padrão ao usar st.dataframe, tornando-o uma ferramenta poderosa para exploração de dados.

Destacando Dados e Formatação Condicional

Frequentemente você pode querer chamar atenção para certos valores no DataFrame. Uma maneira conveniente de fazer isso é usando o Pandas Styler para aplicar formatação condicional antes de exibir o DataFrame. O Streamlit suporta a renderização de objetos Pandas Styler, o que significa que você pode usar métodos como highlight_max, highlight_min, background_gradient, etc., e então passar o DataFrame estilizado para o Streamlit. Por exemplo, para destacar o valor máximo em cada coluna:

st.dataframe(df.style.highlight_max(axis=0))

Neste exemplo, o maior valor em cada coluna será destacado (com um estilo de destaque padrão). Você pode personalizar a estilização mais profundamente ou usar métodos diferentes do Styler. Outro exemplo: aplicar um gradiente de cor baseado nos valores de cada coluna:

st.dataframe(df.style.background_gradient(cmap="Blues"))

Isso colorirá o fundo das células de claro a escuro em azul dependendo da magnitude, o que ajuda a visualizar a distribuição rapidamente. O Streamlit exibirá esses DataFrames estilizados, embora algumas funcionalidades avançadas do Pandas Styler (como barras ou tooltips dentro das células) possam não ser totalmente suportadas na tabela do Streamlit. A estilização mais comum para cores, texto e formatação básica, no entanto, funciona.

Lidando com DataFrames Grandes no Streamlit

Trabalhar com DataFrames grandes (milhares ou até milhões de linhas) pode ser desafiador para qualquer app web. O componente de tabela do Streamlit é projetado para performance e pode lidar com datasets muito grandes usando virtualização eficiente (desenhando apenas o que está visível) e um canvas HTML por baixo. No entanto, ainda existem considerações práticas e limites ao lidar com volumes enormes de dados:

• Limites do navegador e da rede: tipicamente os dados precisam ser enviados do servidor Streamlit para o navegador. Datasets extremamente grandes podem atingir limites de tamanho de mensagens via WebSocket ou esgotar a memória do navegador. Por exemplo, ao tentar enviar um DataFrame de um milhão de linhas, a app pode lidar, mas pode ser lenta para transmitir e renderizar no cliente.
• Otimizações automáticas: o Streamlit desabilitará automaticamente certos recursos para tabelas grandes a fim de manter a responsividade. Por exemplo, se seu dataset tiver mais de ~150.000 linhas, o Streamlit desativa a ordenação de colunas para acelerar a renderização. Tabelas muito grandes podem não suportar todas as funcionalidades interativas para evitar problemas de performance.
• Boas práticas para dados grandes:
  • Mostrar subconjuntos de dados: em vez de despejar um DataFrame enorme em st.dataframe de uma vez, considere mostrar um subconjunto filtrado ou amostrado. Por exemplo, você pode permitir que o usuário escolha um subconjunto de colunas ou um intervalo de datas para visualizar, ou simplesmente exibir as primeiras N linhas com uma opção para paginar pelos dados.
  • Implementar paginação simples: você pode criar um mecanismo de paginação manual. Uma abordagem é usar um slider ou number_input para o índice da página e fatiar o DataFrame conforme:

page_size = 100  # rows per page
total_rows = len(df)
total_pages = (total_rows - 1) // page_size + 1
 
page = st.number_input("Page", min_value=1, max_value=total_pages, value=1)
start_idx = (page - 1) * page_size
end_idx = start_idx + page_size
st.write(f"Showing rows {start_idx} to {min(end_idx, total_rows)}")
st.dataframe(df.iloc[start_idx:end_idx])

Neste exemplo, o usuário pode selecionar um número de página para ver um bloco de 100 linhas por vez. Isso impede que a app tente renderizar o DataFrame inteiro de uma vez, melhorando a responsividade.

• Aproveitar dataframes lazy: o Streamlit pode exibir dados de fontes como PySpark ou Snowflake (Snowpark) DataFrames. Essas estruturas de dados puxam dados conforme necessário, o que significa que, se você aplicar filtros ou limites, o processamento pode ocorrer no backend (por exemplo, em um banco de dados ou motor Spark) e apenas os resultados limitados são enviados ao Streamlit. Se seu dataset for extremamente grande e residir em um banco de dados ou plataforma de big data, considere consultá-lo em blocos ou usar métodos de avaliação tardia em vez de carregar tudo em um Pandas DataFrame na memória.
• Usar cache para carregamento de dados: (Cobraremos caching em detalhe em uma seção posterior, mas em resumo: faça cache da etapa de recuperação de dados para não ler repetidamente um dataset grande a cada rerun da app.)

Ao ter atenção a essas estratégias, você pode lidar com datasets grandes de forma mais suave no Streamlit. A chave é evitar sobrecarregar o frontend com dados demais de uma só vez e aproveitar os recursos de performance do Streamlit.

Estilizando DataFrames no Streamlit

Exibir dados é uma coisa — fazê-los parecer claros e legíveis é outra. O Streamlit oferece várias formas de estilizar seu DataFrame, desde opções de formatação embutidas até CSS customizado (com algumas ressalvas). Vamos explorar como melhorar a aparência das suas tabelas.

Posso estilizar um DataFrame usando CSS no Streamlit?

Você pode se perguntar se é possível aplicar estilos CSS customizados (como em uma página web) ao DataFrame no Streamlit. A resposta curta é sim, mas com cuidado. O Streamlit permite injetar HTML/CSS na sua app usando st.markdown com a flag unsafe_allow_html=True. Isso significa que você pode tentar direcionar os elementos da tabela com CSS. Por exemplo, para alterar a cor de fundo da tabela:

st.markdown(
    """
    <style>
    table { background-color: #f0f0f0; }
    </style>
    """,
    unsafe_allow_html=True
)
st.dataframe(df)

Neste snippet, inserimos um bloco <style> que define o fundo de todas as tags HTML <table> para um cinza claro antes de chamar st.dataframe(df). Isso pode afetar a estilização do DataFrame se a renderização subjacente usar elementos HTML de tabela padrão. Contudo, tenha em mente:

• Essa abordagem não é oficialmente suportada e pode quebrar se a implementação interna do Streamlit mudar. De fato, o st.dataframe moderno é construído sobre um canvas HTML e não usa uma simples tabela HTML para as células de dados, então alguns seletores CSS podem não ter efeito.
• Usar unsafe_allow_html=True é geralmente desaconselhado, exceto para gambiarras rápidas, pois pode introduzir problemas de segurança ou estabilidade (por exemplo, se você estilizar algo globalmente por acidente).

Em resumo, embora você possa usar CSS para ajustes menores (como definir cor de fundo ou fonte), é melhor usar os recursos de estilização embutidos do Streamlit quando possível.

Estilização de DataFrame no Streamlit com Pandas e Column Config

Uma forma mais robusta de estilizar DataFrames no Streamlit é usar o Pandas Styler (como mostrado na seção anterior com highlight_max e background_gradient) ou as opções de configuração de coluna do Streamlit para formatação. Pandas Styler: você pode aplicar muitas funções de estilização fornecidas pelo Pandas. Por exemplo:

• df.style.format(format_dict) – para formatar números ou datas em cada coluna (ex.: exibir um float como porcentagem ou moeda).
• df.style.applymap(func) – para aplicar uma função de estilização elemento a elemento (ex.: colorir números negativos de vermelho).
• df.style.set_properties(**props) – para definir propriedades CSS em certas células (embora nem todas carreguem para o Streamlit).
• df.style.hide(axis="index") – para ocultar o índice se ele não for relevante para a exibição.

Depois de estilizar o DataFrame com Pandas, passe o objeto Styler para st.dataframe() assim como fizemos com highlight_max. Configuração de colunas: o Streamlit (a partir de v1.22+) introduziu o parâmetro column_config para st.dataframe e st.data_editor que permite customizar como as colunas são exibidas. Esta é uma forma "pythônica" de especificar coisas como:

• Rótulos das colunas (renomear colunas para exibição sem alterar o DataFrame em si).
• Ocultar colunas específicas.
• Definir o tipo de exibição de dados (ex.: marcar uma coluna como Image, Link, Checkbox, Datetime, etc., o que pode alterar como os valores são renderizados).
• Formatar números ou datas (semelhante ao Styler, mas feito via API do Streamlit).

Por exemplo, suponha que seu DataFrame tenha uma coluna de preços e você queira mostrá-los como moeda USD e talvez renomear o cabeçalho:

import streamlit as st
import pandas as pd
 
df = pd.DataFrame({
    "item": ["A", "B", "C"],
    "price": [1.5, 2.0, 3.25]
})
 
st.dataframe(
    df,
    column_config={
        "price": st.column_config.NumberColumn(
            "Price (USD)",
            format="$%.2f"
        )
    }
)

Neste snippet:

• Renomeamos a coluna price para Price (USD) apenas para exibição.
• Formatamos os números nessa coluna para ter símbolo de dólar e duas casas decimais.

Essa abordagem gera uma tabela bem formatada sem precisar de CSS customizado, e funciona com o grid interativo do Streamlit. Também podemos ocultar colunas definindo a configuração de coluna para None, ou usar outros tipos de configuração para diferentes dados (como imagens ou booleanos). Em resumo, use Pandas Styler ou as configurações de coluna do Streamlit para estilizar quando possível — eles são mais estáveis e expressivos para tarefas comuns do que injetar CSS bruto.

Otimizando DataFrames no Streamlit

À medida que você constrói apps mais complexas ou trabalha com datasets maiores, a performance se torna importante. Esta seção cobre como otimizar o uso de DataFrames no Streamlit para velocidade e eficiência, focando em caching e outras boas práticas.

Como otimizar um Pandas DataFrame no Streamlit

Otimização aqui significa tanto otimizar a performance da sua app (tempos de carregamento, responsividade) quanto otimizar o uso de recursos (como memória). Aqui estão algumas estratégias-chave:

Use o cache do Streamlit para carregamento e computação de dados: uma das formas mais simples de acelerar sua app é evitar repetir operações caras. Se você tem um dataset grande em CSV ou em um banco de dados, carregá-lo do zero a cada execução pode ser lento. O Streamlit fornece um mecanismo de cache para ajudar nisso. Em versões mais antigas você poderia usar @st.cache. No Streamlit atual, você deve usar @st.cache_data para cachear funções que retornam dados (como DataFrames). Por exemplo:

import pandas as pd
import streamlit as st
 
@st.cache_data
def load_data():
    # Imagine que isto é uma operação cara, ex.: ler um CSV grande
    df = pd.read_csv("large_dataset.csv")
    # (Você pode fazer processamento adicional aqui, se necessário)
    return df
 
# Use a função cacheada para carregar dados
df_large = load_data()
st.dataframe(df_large.head(100))  # Exibe apenas as primeiras 100 linhas como exemplo

Ao usar @st.cache_data, a primeira execução vai ler o CSV e armazenar o DataFrame em cache. Em execuções subsequentes (ou quando os usuários rerodarem a app), desde que os argumentos da função não tenham mudado, o Streamlit pulirá a execução de load_data() e recuperará o DataFrame do cache. Isso pode acelerar significativamente apps que precisam dos mesmos dados repetidamente.

Otimize tamanhos e tipos do DataFrame: DataFrames grandes podem ser otimizados usando tipos de dados apropriados. Por exemplo, se você tem dados textuais categóricos, convertê-los para Categorical do Pandas pode economizar memória. Se tem colunas que só precisam de 0/1 ou True/False, use boolean em vez de inteiros. Números de ponto flutuante que não precisam de alta precisão podem ser downcast para float32. Essas otimizações do pandas reduzem uso de memória, o que pode melhorar indiretamente a performance no Streamlit (especialmente em servidores com recursos limitados).

Use formatos de dados eficientes: se você controla a origem dos dados, formatos binários como Parquet ou Arrow podem tornar a leitura mais rápida do que CSV. O Streamlit pode ler tabelas Arrow diretamente e lidar com elas eficientemente. Isso também se integra ao cache — por exemplo, você pode cachear o resultado de ler um arquivo Parquet que já é mais rápido de carregar.

Agora vamos olhar mais de perto o caching e dicas de performance, já que caching é uma parte crucial da otimização.

Caching de DataFrames no Streamlit e dicas de performance

Caching é uma ferramenta poderosa no Streamlit, mas é importante usá-la corretamente. Aqui estão algumas dicas e boas práticas:

Escolha o decorador de cache correto: use @st.cache_data para cachear computações de dados ou queries (funções que retornam dados como DataFrames, listas, dicionários, etc.). Use @st.cache_resource para cachear recursos singleton (como uma conexão de banco de dados, modelo de ML, ou outro objeto que deve ser inicializado uma vez e reutilizado). Substituir @st.cache pelo decorador novo apropriado evitará avisos de depreciação e oferecerá melhor performance conforme o caso de uso.

Os inputs da função importam: funções cacheadas são invalidadas com base em seus argumentos. Sempre que você chamar uma função cacheada com um novo valor de argumento, ela executará novamente e irá cachear o novo resultado. Isso é útil para atualizações de dados. Por exemplo:

@st.cache_data
def load_data(filename):
    return pd.read_csv(filename)
 
file_choice = st.selectbox("Choose a data file", ["data1.csv", "data2.csv"])
df = load_data(file_choice)
st.dataframe(df.head())

Nesse cenário, se o usuário alternar de "data1.csv" para "data2.csv", load_data será executada novamente para o novo filename e o resultado será cacheado separadamente. Voltar para "data1.csv" recuperará do cache. Esse comportamento garante que sua app lide eficientemente com múltiplos datasets sem recalcular desnecessariamente.

Evite mutar dados cacheados: uma armadilha comum é alterar um objeto que está em cache. Por exemplo, se você cachear um DataFrame e então modificá-lo in-place, essas mudanças podem persistir no objeto cacheado entre execuções, levando a resultados inesperados. Com st.cache_data, o Streamlit ajuda a evitar isso retornando uma cópia dos dados a partir do cache em cada chamada, prevenindo problemas de mutação. Geralmente você não precisará usar o antigo allow_output_mutation=True (opção em st.cache) porque o novo sistema lida com isso de forma diferente. Se você realmente precisa cachear um objeto que será mutado, considere st.cache_resource, mas faça isso com cautela e documente o comportamento.

Limpe o cache quando necessário: se seus dados são atualizados externamente e você precisa forçar a atualização do cache, você pode adicionar um botão para os usuários limparam o cache manualmente (st.cache_data.clear() por exemplo) ou incorporar um ttl (time-to-live) no cache ou um hash de versão externa dos dados. Por exemplo, se você sabe que os dados são atualizados diariamente, pode incluir a data atual como parte da chave do cache ou definir @st.cache_data(ttl=86400) para expirar após um dia. Isso garante que os usuários não fiquem com dados obsoletos.

Limite a quantidade de DataFrame renderizada: mesmo com caching, renderizar um DataFrame enorme pode ser lento no navegador. Muitas vezes é sensato limitar quanto do DataFrame é exibido de uma vez. Discutimos usar o parâmetro height ou paginação manual acima. Outra tática simples é exibir apenas sumários ou amostras do dataset grande e oferecer links para download ou a visualização completa somente sob demanda. A app deve focar no que é relevante para a análise do usuário no momento, em vez de sobrecarregá-lo (e o navegador) com uma tabela massiva. Se for necessário mostrar muitos dados, os usuários podem sempre usar as funções de busca e rolagem, mas certifique-se de que a app permaneça responsiva.

Seguindo essas práticas de caching e performance, você assegura que sua app Streamlit se mantenha ágil e eficiente, mesmo à medida que seus dados crescem.

Streamlit DataFrame: Casos de Uso Avançados

Nesta seção, vamos explorar alguns cenários avançados (mas comuns) onde Streamlit DataFrames desempenham um papel crucial: filtragem interativa de dados e integração de DataFrames em um fluxo de trabalho de machine learning.

Filtragem de DataFrame no Streamlit

Filtrar dados é parte central da exploração de dados. Os widgets do Streamlit tornam fácil adicionar filtros interativos à exibição do DataFrame. Em vez de pré-definir subconjuntos estáticos, você pode permitir que o usuário escolha como filtrar o DataFrame. Por exemplo, suponha que você queira permitir que o usuário filtre o DataFrame df selecionando um intervalo de valores em uma das colunas numéricas. Você pode usar um slider para intervalo e um selectbox para escolher a coluna a filtrar:

# Assume df is already loaded
column = st.selectbox("Select column to filter", df.columns)
if pd.api.types.is_numeric_dtype(df[column]):
    min_val, max_val = int(df[column].min()), int(df[column].max())
    # Slider to pick a range within [min, max]
    range_values = st.slider(f"Filter {column} between:", min_val, max_val, (min_val, max_val))
    # Filter the dataframe based on slider
    filtered_df = df[(df[column] >= range_values[0]) & (df[column] <= range_values[1])]
else:
    # If non-numeric, maybe use multiselect for categories
    options = st.multiselect(f"Filter values for {column}:", df[column].unique(), default=list(df[column].unique()))
    filtered_df = df[df[column].isin(options)]
 
st.dataframe(filtered_df)

Neste exemplo:

• Primeiro deixamos o usuário escolher qual coluna filtrar.
• Se a coluna selecionada for numérica, exibimos um slider de intervalo entre o mínimo e o máximo da coluna, e a seleção do usuário fornece uma tupla (min_val, max_val). Em seguida filtramos df por esse intervalo.
• Se a coluna for não numérica (por exemplo strings/categorias), usamos multiselect para que o usuário escolha quais valores incluir, e então filtramos de acordo.
• Por fim, exibimos o filtered_df.

Esse padrão pode ser adaptado para muitos cenários: você pode ter múltiplos filtros simultâneos (basta adicionar mais widgets e condições), ou diferentes tipos de widgets para diferentes colunas (date pickers para colunas de data, text inputs para buscas por substring, etc.). O resultado é uma app onde usuários podem fatiar e manipular o DataFrame em tempo real e ver a tabela atualizar para mostrar apenas os dados que atendem aos critérios.

DataFrames no Streamlit para aplicações de Machine Learning

Streamlit não serve apenas para exibição estática — é excelente para construir demos interativos de machine learning e dashboards. DataFrames costumam aparecer em apps de ML: por exemplo, para mostrar uma pré-visualização dos dados de treino, exibir scores de importância de features ou permitir que o usuário faça upload de novos dados para previsão. Vamos considerar um exemplo simples: você tem um dataset e quer permitir que o usuário treine um modelo (por exemplo um classificador) com o clique de um botão, e então exibir os resultados. Você pode usar um DataFrame para mostrar os dados e widgets do Streamlit para gerenciar a interação:

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
 
# Display the DataFrame (e.g., training dataset preview)
st.dataframe(df)
 
# Let user trigger model training
if st.button("Train Model"):
    # Assume 'target' is the label column in df
    if 'target' not in df.columns:
        st.error("No target column found in data!")
    else:
        # Split the data
        X = df.drop('target', axis=1)
        y = df['target']
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
        
        # Train a simple RandomForest model
        model = RandomForestClassifier(n_estimators=100, random_state=42)
        model.fit(X_train, y_train)
        
        # Evaluate the model
        preds = model.predict(X_test)
        accuracy = accuracy_score(y_test, preds)
        
        # Display accuracy result
        st.write(f"**Model Accuracy:** {accuracy*100:.2f}%")

O que acontece neste snippet:

• Exibimos o DataFrame df para que o usuário inspecione os dados brutos.
• Incluímos um botão "Train Model". Quando o usuário clica, o código dentro do bloco if st.button é executado.
• Fazemos uma verificação rápida para garantir que existe uma coluna target para predizer (o label).
• Separamos o DataFrame em features (X) e target (y), depois em conjuntos de treino e teste.
• Inicializamos um RandomForestClassifier (do scikit-learn) e treinamos com os dados de treino.
• Realizamos previsões no conjunto de teste e calculamos a acurácia.
• Por fim, usamos st.write para exibir a acurácia na app.

Esse exemplo simples ilustra como integrar a exibição do DataFrame com controles interativos para criar um pequeno pipeline de machine learning na Streamlit. O usuário poderia ajustar hiperparâmetros (por exemplo número de árvores, proporção do teste via sliders), escolher modelos diferentes e ver os resultados rapidamente. O DataFrame é central aqui como forma de apresentar os dados usados para o treino ou os resultados (você também poderia exibir um DataFrame com previsões ou exemplos mal classificados, etc.). Com o DataFrame interativo e widgets do Streamlit, você transforma um script em uma app onde usuários podem experimentar em tempo real.

Conclusão

Streamlit tornou mais fácil do que nunca construir apps de dados interativos, e sua integração com Pandas DataFrames coloca muito poder nas suas mãos. Neste artigo cobrimos como exibir DataFrames no Streamlit, desde o uso básico até personalizações avançadas. Vimos como estilizar os dados para melhor legibilidade, como lidar com datasets grandes de forma eficiente e até como DataFrames se integram a casos de uso interativos de filtragem e machine learning. Com as atualizações mais recentes do Streamlit (em 2025), st.dataframe está mais capaz e performante — oferecendo ordenação embutida, busca, download e uma renderização em grid ágil que pode lidar com volumes substanciais de dados. Também mencionamos st.data_editor para cenários onde você precisa que usuários editem ou contribuam com dados via app. Seja você um cientista de dados experiente ou um iniciante, o Streamlit fornece uma plataforma amigável e poderosa para compartilhar insights. Um DataFrame que seria estático em um notebook pode se tornar uma ferramenta de exploração interativa em uma app Streamlit. Ao seguir em frente, lembre-se de usar caching para performance, pensar na experiência do usuário (mostre a fatia de dados mais relevante, não tudo de uma vez) e aproveitar as opções de estilização para tornar os dados claros. Vá em frente — experimente essas técnicas na sua própria Streamlit app. Transforme seus DataFrames em tabelas interativas, construa um dashboard ao redor deles ou crie a próxima ótima aplicação de ciência de dados. As possibilidades são infinitas quando se combina Pandas e Streamlit!

Você já ouviu falar desta incrível ferramenta de Análise e Visualização de Dados, que transforma sua Streamlit App em algo parecido com o Tableau?

PyGWalker (opens in a new tab) é uma biblioteca Python que ajuda você a incorporar uma UI alternativa ao Tableau dentro da sua própria Streamlit app de forma descomplicada.

(opens in a new tab)

Perguntas Frequentes

Como posso estilizar um DataFrame no Streamlit? – Você pode estilizar um DataFrame usando tanto a estilização do Pandas quanto as opções de exibição do Streamlit. Por exemplo, use métodos do Pandas Styler como highlight_max ou background_gradient para adicionar realces de cor. Também é possível aplicar CSS customizado via st.markdown (com unsafe_allow_html=True) para ajustes simples (embora seja avançado e limitado). Além disso, aproveite o column_config em st.dataframe para formatar colunas (por exemplo, formatação numérica, ocultar índice) de forma direta.

Como posso filtrar um DataFrame no Streamlit? – O Streamlit fornece widgets interativos que facilitam a filtragem. Você pode usar dropdowns (st.selectbox ou st.multiselect) para filtros categóricos, sliders (st.slider) para intervalos numéricos, entradas de texto para busca por texto, etc. No seu código, use os valores desses widgets para subsetar o DataFrame (por exemplo, df[df[column] == value] ou usando indexação booleana do pandas para intervalos). A app atualizará em tempo real quando o usuário ajustar os widgets, mostrando os dados filtrados.

Posso exibir imagens dentro de um DataFrame no Streamlit? – O Streamlit pode exibir imagens, mas não diretamente dentro das células de st.dataframe no momento. Uma abordagem comum é ter uma coluna no DataFrame com URLs de imagem ou caminhos de arquivo. Em vez de tentar colocar as imagens na tabela, você faria um loop pelo DataFrame e usaria st.image() para cada imagem (ou use st.columns para dispor em uma grade). Alternativamente, se você tiver pequenas URLs de thumbnails, pode usar a configuração de coluna para marcar essa coluna como Image (quando essa feature estiver habilitada), o que pode exibir imagens diretamente. Mas, de forma geral, você vai lidar com imagens por chamadas separadas do Streamlit em vez de embuti-las em st.dataframe. Lembre-se que qualquer dado de imagem precisa ser acessível (como URL ou arquivo enviado) para que st.image o exiba.