Isolamento de Ambientes no Python: Venv vs. Conda Qual escolher?

Se você já passou pela clássica frustração do "na minha máquina funciona, mas no servidor quebrou" ou acabou corrompendo as dependências globais do seu sistema operacional ao instalar uma biblioteca externa, parabéns: você descobriu a necessidade vital dos ambientes virtuais.

No ecossistema Python, duas ferramentas dominam essa arena de isolamento de dependências: o venv (nativo do Python) e o conda (proveniente da distribuição Anaconda/Miniconda). Embora ambos resolvam com primor o problema de isolar bibliotecas, eles operam de maneiras fundamentalmente diferentes sob o capô.

O que é o venv?

O venv é o gerenciador de ambientes virtuais padrão e nativo do Python, disponível nativamente a partir da versão 3.3. Ele foi desenhado com um propósito simples e focado: criar ambientes isolados para projetos Python, utilizando como base a instalação do interpretador Python que já existe de forma global no seu sistema operacional.

Como ele funciona?

Ao inicializar um ambiente usando o comando python -m venv meu_ambiente, ele gera um diretório local que contém cópias e links simbólicos que apontam para o executável do Python do seu sistema. Ao ativar esse ambiente e executar o pip install, os pacotes e suas respectivas versões são instalados isoladamente nesta pasta, sem qualquer interferência com dependências globais ou outros projetos.

O que é o conda?

O conda é um gerenciador de ambientes e também de pacotes multiplataforma de código aberto. Ao contrário do venv (que gerencia estritamente pacotes Python), o conda é agnóstico de linguagem de programação. Ele foi originalmente idealizado pela comunidade de Ciência de Dados, onde os projetos frequentemente demandam dependências complexas e binários de baixo nível written em C, C++, Fortran ou integrações com drivers de GPU.

Criando ambiente virtual no Conda

Exemplo para criar um ambiente virtual no Conda no Python 3.13

conda create --name meu_ambiente python=3.13

Pode instalar as libs junto com a criação do ambiente (Opcional)

conda create --name meu_ambiente python=3.13 numpy pandas scikit-learn

Vantagem: O gerenciador do Conda analisa a compatibilidade de todas as bibliotecas de uma vez só antes de baixar. Ele também instala binários pré-compilados e otimizados para o seu sistema operacional (como otimizações de performance da Intel para o NumPy, por exemplo).

Mas também pode instalar as libs dentro do ambiente virtual com pip

Regra de Ouro (Apenas um cuidado)

Se você optar por instalar depois com o pip, certifique-se sempre de ativar o ambiente primeiro (conda activate meu_ambiente). Se esquecer de ativar, o pip vai instalar Se você optar por instalar depois com o pip, certifique-se sempre de ativar o ambiente primeiro (conda activate meu_ambiente). Se esquecer de ativar, o pip vai instalar

conda activate meu_ambiente

pip install numpy pandas scikit-learn

Desativar o ambiente virtual conda deactivate

Como ele funciona?

Diferente do seu concorrente nativo, o conda não depende de um interpretador Python pré-instalado no sistema. Ele é capaz de baixar e instalar diferentes versões do próprio Python diretamente em cada ambiente de forma totalmente isolada. Ele gerencia binários pré-compilados diretamente de canais de distribuição (como o conda-forge), resolvendo conflitos a nível de sistema operacional.

Tabela Comparativa: Venv x Conda

Característica	venv (nativo)	conda (gerenciador global)
Instalação	Já vem pré-instalado por padrão junto ao Python.	Requer a instalação prévia do Anaconda ou do Miniconda.
Escopo de Pacotes	Gerencia exclusivamente pacotes Python via indexador PyPI.	Gerencia pacotes de qualquer linguagem (Python, C, R, CUDA, etc).
Versão do Python	Usa obrigatoriamente a versão do sistema operacional base.	Permite instalar e isolar qualquer versão do Python por ambiente.
Velocidade de Instalação	Rápida, mas pode gerar conflitos silenciosos de pacotes.	Mais lenta devido à rigorosa análise de resolução de dependências.
Armazenamento (Disco)	Extremamente leve e enxuto.	Moderado a pesado devido ao cache e compilação de binários.

Vantagens e Desvantagens

O clássico venv

Vantagens:
- Sem fricção de configuração: Não necessita de instaladores adicionais. Se você possui o Python na máquina, você já possui o venv pronto para uso.
- Alta eficiência de armazenamento: Os ambientes ocupam pouquíssimo espaço antes da instalação de novas bibliotecas.
- Padrão consolidado no desenvolvimento Web: Excelente para microsserviços, APIs (FastAPI, Flask) e deploys simplificados em containers Docker.

Desvantagens:
- Acoplado ao sistema: Dificulta o teste simultâneo de múltiplos interpretadores de Python sem o auxílio de ferramentas acessórias como o pyenv.
- Dependências não-Python: Falha em resolver dependências que exijam compilações complexas de bibliotecas de sistema C/C++ diretamente na máquina do usuário final.

O canivete suíço conda

Vantagens:
- Isolamento de baixo nível: Perfeito para gerenciar bibliotecas científicas complexas (NumPy, SciPy, TensorFlow) que dependem de otimizações de hardware.
- Portabilidade total: Garante que os pacotes binários de sistema funcionarão de forma idêntica em Windows, Linux ou macOS.
- Flexibilidade de interpretador: Criar um ambiente com Python 3.8 e outro com 3.12 é simples como executar conda create -n env python=3.12.

Desvantagens:
- Overhead de disco: Os binários ocupam consideravelmente mais armazenamento em disco.
- Complexidade extra: Para desenvolvimento de aplicações web convencionais e scripts leves de automação, seu ecossistema pode ser desnecessariamente robusto.

Dica Prática de Engenharia de Software:

Utilize o venv sempre que o deploy final do seu software for baseado em containers Docker enxutos e focados em microserviços Web tradicionais. Reserve o uso do conda para fluxos de trabalho que exijam engenharia de dados, machine learning ou computação científica de alto desempenho.

Referências

https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html

Feito!

Manipulando arquivos gigantes com Python

Quando trabalhamos com Python no dia a dia, é comum lidarmos com arquivos CSV ou Excel relativamente pequenos. Porém, em cenários de Data Science e Big Data, não é raro recebermos um arquivo que ultrapassa a casa dos gigabytes. E aí surge o problema: carregar tudo na memória de uma só vez pode simplesmente derrubar a sua máquina.

A boa notícia é que o Python tem ferramentas que permitem processar esses arquivos de forma inteligente e incremental. Hoje, vamos falar sobre o conceito de chunks.

O que são chunks?

De forma simples, um chunk é um pedaço do arquivo.

Ao invés de ler um CSV inteiro com pandas.read_csv(), podemos instruir o Pandas a carregar n linhas por vez, processar, salvar o resultado parcial e liberar memória. Assim, conseguimos trabalhar com arquivos gigantes sem precisar de um supercomputador.

Exemplo prático

Imagine que temos um arquivo transacoes.csv com 100 milhões de linhas. Queremos somar o valor total de uma coluna chamada valor.

Solução tradicional (não funciona bem em arquivos grandes):

import pandas as pd
# Isso pode travar o computador!
df = pd.read_csv("transacoes.csv")
print("Total:", df["valor"].sum())

Se o arquivo for grande demais, sua memória RAM não vai aguentar.

Solução com chunks:

import pandas as pd
total = 0
# Lendo o arquivo em blocos de 1 milhão de linhas
for chunk in pd.read_csv("transacoes.csv", chunksize=10**6):
    total += chunk["valor"].sum()

print("Total:", total)

Nesse caso:

chunksize=10**6 significa que o Pandas vai ler 1 milhão de linhas por vez.

Cada pedaço é processado, somado e descartado da memória.

Ao final, temos o total consolidado sem sobrecarregar o sistema.

Vantagens do processamento em chunks

• Trabalhar com arquivos enormes sem precisar expandir a RAM.
• Possibilidade de processamento incremental (ex: salvar resultados parciais).
• Aplicável a diversas operações: filtros, agregações, limpeza de dados, exportação em lotes.

Onde isso aparece na prática?

• Relatórios financeiros de grandes empresas.
• Logs de servidores com milhões de registros.
• Bases públicas gigantes, como dados do IBGE ou Kaggle.

Considerações finais

Trabalhar com chunks é quase um rito de passagem para quem está saindo do Python intermediário e entrando em projetos de nível avançado, onde eficiência importa tanto quanto clareza do código.

Feito!

Automação de tarefas com Python e Pandas

Imagine o seguinte cenário: toda semana você recebe relatórios de vendas em formato CSV e precisa consolidá-los em uma única planilha para gerar um resumo.

Fazer isso manualmente pode levar horas. Mas com o Pandas, é questão de segundos.

O Pandas é uma das bibliotecas mais poderosas do ecossistema Python para análise, transformação e automação de dados.

Se você já lidou com planilhas no Excel, vai se sentir em casa, mas aqui, com muito mais poder e automação.

Preparando o ambiente

Como sempre, vamos manter nosso projeto isolado em um ambiente virtual.

python3 -m venv .venv

No Linux/macOS source .venv/bin/activate

No Windows source .venv\Scripts\activate

Instalando o Pandas

Abre o terminal:

pip install pandas openpyxl

pandas: biblioteca principal para análise de dados.

openpyxl: permite exportar para Excel (.xlsx).

Lendo um arquivo CSV

Vamos começar simples: carregar um relatório em CSV e inspecionar os dados.

relatorio-vendas.py

import pandas as pd

# Carregar o arquivo CSV
df = pd.read_csv("vendas.csv")

# Exibir as primeiras linhas
print(df.head())

Se o arquivo vendas.csv contiver algo como:

data,produto,quantidade,valor
01/08/2025,Notebook,3,3500
01/08/2025,Mouse,10,80
01/08/2025,Teclado,5,150

A saída será uma tabela organizada, semelhante a uma planilha.

python3 relatorio-vendas.py

         data   produto  quantidade  valor
0  01/08/2025  Notebook           3   3500
1  01/08/2025     Mouse          10     80
2  01/08/2025   Teclado           5    150

Filtrando e transformando dados

Agora vamos selecionar apenas vendas acima de R$ 1000.

filtro = df[df["valor"] > 1000]
print(filtro)

Resultado:

         data        produto   quantidade  valor
0        01/08/2025  Notebook     3        3500

Exportando para Excel

filtro = df
filtro.to_excel("vendas_filtradas.xlsx", index=False)
print("Relatório exportado para vendas_filtradas.xlsx")

Com isso, temos um arquivo pronto para ser compartilhado, sem precisar abrir o Excel manualmente.

Mini-projeto: Consolidando múltiplos relatórios

Imagine que você recebe vários arquivos CSV (vendas_jan.csv, vendas_fev.csv, etc.).

Podemos juntá-los em um único relatório com poucas linhas de código:

import pandas as pd
import glob

# Carregar todos os arquivos CSV
arquivos = glob.glob("vendas_*.csv")

# Concatenar em um único DataFrame
dfs = [pd.read_csv(arq) for arq in arquivos]
df_final = pd.concat(dfs, ignore_index=True)

# Salvar no Excel
df_final.to_excel("vendas_consolidadas.xlsx", index=False)
print("Relatório consolidado gerado com sucesso!")

Agora, em vez de copiar e colar manualmente dezenas de planilhas, você automatiza tudo em segundos.

Quando usar Pandas para automação

O Pandas é ideal para:

• Processar grandes volumes de dados de forma rápida.
• Automatizar tarefas repetitivas de ETL (Extract, Transform, Load).
• Transformar relatórios em insights prontos para análise.

Considerações finais

Com o Pandas, você elimina horas de trabalho repetitivo e ganha produtividade, transformando relatórios manuais em processos automáticos e confiáveis.

Feito!

Criando APIs REST com Python

Imagine que você precisa criar um serviço que permita que outros sistemas ou aplicações acessem seus dados de forma segura e padronizada. É aí que entram as APIs REST, uma das formas mais comuns de comunicação entre aplicações na web.

E, quando falamos de Python,um dos frameworks leve e eficientes para construir APIs é o FastAPI.

O que é o FastAPI?

O FastAPI é um framework web para Python, projetado para criar APIs de forma:

• Rápida:

otimizado para alta performance usando programação assíncrona.

• Segura:

valida automaticamente os dados recebidos.

• Produtiva:

gera documentação interativa automaticamente.

Ele é tão eficiente que já é usado em produção por empresas como Microsoft e Uber.

Por que usar o FastAPI?

Velocidade de desenvolvimento: você escreve menos código para fazer mais.

Validação automática: parâmetros e dados recebidos são verificados automaticamente.

Documentação integrada: acesso imediato à documentação interativa via Swagger UI e ReDoc.

Desempenho: comparável a frameworks rápidos como Node.js e Go.

Preparando o ambiente

Como nas postagens anteriores, vamos criar um ambiente virtual para manter as dependências isoladas.

python3 -m venv .venv

No Linux/macOS source .venv/bin/activate

No Windows source .venv\Scripts\activate

Instalando o FastAPI e o servidor Uvicorn

pip install fastapi uvicorn

fastapi: framework para criar a API.

uvicorn: servidor leve e rápido para rodar a aplicação.

Criando sua primeira API

Crie um arquivo chamado main.py

Executando a aplicação

No terminal:

uvicorn main:app --reload

main:app main é o nome do arquivo, app é a instância do FastAPI.

--reload reinicia automaticamente o servidor ao modificar o código.

Acesse no browser:

http://127.0.0.1:8000/api

Rota inicial.

http://127.0.0.1:8000/docs Documentação interativa (Swagger UI).

http://127.0.0.1:8000/redoc Documentação alternativa (ReDoc).

Desafio: API de To-Do List

Você pode ampliar este exemplo para criar um CRUD (Create, Read, Update, Delete) de tarefas:

POST /tarefas cria tarefa.

GET /tarefas lista tarefas.

PUT /tarefas/{id} atualiza tarefa.

DELETE /tarefas/{id} remove tarefa.

Essa base será extremamente útil para aplicações reais.

Considerações finais

O FastAPI combina velocidade, praticidade e robustez, sendo ideal para desenvolvedores que querem criar APIs modernas sem complicação.

Referências

https://fastapi.tiangolo.com

Feito!

Programação assíncrona no Python

No mundo real, um restaurante com apenas um cozinheiro pode atender vários clientes ao mesmo tempo: enquanto um prato assa no forno, o cozinheiro prepara outro. Isso é trabalho assíncrono.

No Python, a programação assíncrona nos permite executar múltiplas tarefas em paralelo (ou melhor, quase paralelo) sem precisar esperar que cada uma termine para começar a próxima — ideal para chamadas de API, consultas a banco de dados e processamento de arquivos.

O que é programação assíncrona?

Em um programa tradicional (síncrono), cada instrução só começa depois que a anterior termina.

Na programação assíncrona:

Algumas operações podem “esperar” (ex.: aguardar resposta de uma API).

Enquanto esperam, o Python pode executar outras tarefas.

Isso reduz tempo ocioso e aumenta a eficiência, principalmente em aplicações que fazem muitas operações de I/O.

O módulo asyncio

O asyncio é a biblioteca nativa do Python para lidar com programação assíncrona.

Com ele, você:

Declara funções assíncronas usando async def.

Aguarda resultados com await.

Executa múltiplas funções com asyncio.gather().

Criando um projeto prático

Neste exemplo, vamos simular o download de páginas web usando aiohttp para trabalhar de forma assíncrona.

Criar e ativar o ambiente virtual

python3 -m venv .venv

No Linux/macOS: source .venv/bin/activate

No Windows: .venv\Scripts\activate

Instalar dependências

pip install aiohttp

Código exemplo: Download assíncrono

Entendendo o código

async def : cria uma função assíncrona.

await : pausa a função até que o resultado esteja pronto, sem travar o resto do programa.

asyncio.gather() : executa várias tarefas ao mesmo tempo.

aiohttp : biblioteca otimizada para requisições HTTP assíncronas.

Comparando com o código síncrono

Se fizéssemos as requisições uma de cada vez, o tempo total seria a soma de todos os tempos individuais.

No modo assíncrono, todas começam juntas, reduzindo drasticamente o tempo de espera.

Quando usar programação assíncrona?

A programação assíncrona é especialmente útil quando seu código precisa:

• Fazer várias requisições HTTP.
• Ler ou gravar muitos arquivos.
• Processar grandes volumes de dados que dependem de I/O.

Para cálculos pesados (CPU-bound), a programação assíncrona não é a melhor opção — nesse caso, usar múltiplos processos (multiprocessing) ou threads pode ser mais eficiente.

Considerações finais

Com o asyncio, conseguimos transformar tarefas demoradas em operações rápidas e eficientes, aproveitando melhor o tempo de execução do programa.

Feito!

Criando e gerenciando ambientes virtuais com venv e pip-tools no Python

Imagine que você está desenvolvendo dois projetos diferentes em Python:

Um utiliza a biblioteca Django na versão 3.2.

Outro exige Django na versão 5.0.

Se você instalar ambas as versões diretamente no seu sistema, haverá conflitos e um dos projetos inevitavelmente deixará de funcionar. É aqui que entra o conceito de ambiente virtual.

O que é um ambiente virtual e por que usá-lo?

Um ambiente virtual no Python é como um “espaço isolado” onde você instala bibliotecas apenas para um determinado projeto, sem interferir no restante do sistema ou em outros projetos.

Essa prática traz benefícios claros:

• Isolamento:

cada projeto tem suas próprias dependências e versões.

• Reprodutibilidade:

você consegue recriar exatamente o mesmo ambiente em outra máquina.

• Organização:

evita instalar bibliotecas desnecessárias no Python global.

Em poucas palavras: o venv protege seu projeto de conflitos e garante consistência no desenvolvimento.

Criando um ambiente virtual com venv

O Python já vem com o módulo venv embutido, então você não precisa instalar nada para começar.

1. Abra o terminal no diretório do seu projeto.

2. Execute: python3 -m venv .venv

Aqui:

python3 -m venv Cria o ambiente virtual.

.venv é o nome da pasta que conterá o ambiente (você pode escolher outro nome).

Ativando o ambiente virtual

A ativação muda o terminal para usar o Python e as bibliotecas daquele ambiente.

Linux / macOS:

source .venv/bin/activate

Windows:

.venv\Scripts\activate

Ao ativar, você verá algo assim no terminal:

(.venv) $

Isso indica que o ambiente virtual está ativo.

Instalando pacotes

Com o ambiente ativo, instale pacotes normalmente:

pip install requests

Esses pacotes ficam armazenados dentro da pasta .venv, sem afetar o restante do sistema.

Gerenciando dependências com pip-tools

O pip-tools ajuda a manter um controle organizado das bibliotecas que seu projeto usa. Ele separa:

O que você pediu para instalar.

As dependências que foram instaladas automaticamente.

1. Instale o pip-tools:

pip install pip-tools

2. Crie um arquivo requirements.in:

requests
pandas

3. Compile para requirem ents.txt:

pip-compile

O requirements.txt gerado terá as versões exatas:

pandas==2.1.0
requests==2.31.0

4. Instale exatamente essas versões:

pip install -r requirements.txt

Para sair do ambiente virtual venv, execute: deactivate

Exportando dependências

Se quiser compartilhar seu projeto, basta enviar:

O código-fonte e o arquivo requirements.txt ou melhor o link do repositório do projeto de alguma das plataformas GitHub, Bitbucket, GitLab ou Azure DevOps

Em outra máquina, basta:

python3 -m venv .venv source .venv/bin/activate

OU no Windows

.venv\Scripts\activate

pip install -r requirements.txt

Pronto: ambiente recriado exatamente como no seu computador.

Considerações finais:

O uso de ambientes virtuais não é apenas uma boa prática: é fundamental para qualquer desenvolvedor Python que queira evitar problemas e manter seus projetos organizados.

O venv garante isolamento e o pip-tools ajuda a manter suas dependências claras e previsíveis.

Feito!

Por que Python está dominando o mercado de dados?

Você já se perguntou por que alguém escolheria analisar dados em Python, uma linguagem de programação, em vez de ferramentas familiares como Excel ou Power BI? É uma dúvida comum, especialmente quando se pensa na rapidez para criar um dashboard no Power BI. Muitos comentários que refletem essa incredulidade: É mais trabalhoso construir dashboards em Python do que no Power BI ou Excel? Sim, definitivamente.

No entanto, a questão vai muito além dos dashboards. Eles são apenas a ponta de um iceberg gigantesco no processo de análise de dados. Ferramentas gráficas podem te limitar mais cedo ou mais tarde, especialmente se você leva a análise de dados a sério.

O mercado já decidiu: Python lidera

A ideia de que o mundo dos dados está migrando em massa para Python não é apenas uma teoria. Um projeto sólido de Luke Barrow, um renomado analista de dados nos EUA, analisou mais de 3 milhões de vagas preenchidas no mundo dos dados (engenheiros, cientistas, analistas de dados, etc.). O resultado é claro:

Python aparece em primeiro lugar como a ferramenta mais usada globalmente, presente em mais de 55% das vagas. Enquanto isso, Excel e Power BI ficam abaixo de 17%. Essa migração massiva já aconteceu, e os números de vagas confirmam isso.

Os 7 Pilares Que Tornam Python Indispensável

A dominância do Python se baseia em sete elementos cruciais que uma ferramenta de análise de dados "perfeita" deve ter:

1. Ampla variedade de formatos de dados aceitos:

Ferramentas gráficas te limitam aos tipos de dados que seus desenvolvedores predefiniram. Embora lidem bem com planilhas, bancos de dados SQL e JSON, elas falham com APIs mais complexas e, crucialmente, com dados não estruturados, que representam 99% dos dados do mundo (textos, imagens, vídeos, áudios). Python oferece a flexibilidade necessária para trabalhar com qualquer tipo de dado, estruturado ou não.

2. Capacidade de automatizar a captura de dados:

Você precisa de uma ferramenta que possa criar processos de atualização automática de dados. Python permite desenvolver scripts que contornam bloqueios de API e mantêm seus dados sempre atualizados, algo que as ferramentas gráficas não oferecem com a mesma robustez.

3. Performance com Big Data:

Ferramentas como Excel e Power BI travam e sofrem com grandes conjuntos de dados. Python, com bibliotecas como Pandas, Dask e Spark, consegue carregar e manipular milhões de linhas (como um arquivo de 1GB com 10 milhões de linhas de dados de aviação) em segundos, com uma velocidade impressionante.

4. Versatilidade nas Análises:

Em Excel e Power BI, você está restrito às funcionalidades e "botões" que os desenvolvedores da ferramenta forneceram. Python, por outro lado, oferece total liberdade para realizar qualquer tipo de análise, desde Machine Learning (regressões logísticas, modelos de clusterização), testes estatísticos robustos, análises de séries temporais, até a criação de modelos de previsão de vendas e análises personalizadas com Visão Computacional.

5. Controle dos recursos computacionais:

Em ferramentas gráficas, o processamento de dados é uma "caixa preta", você não sabe como os cálculos são feitos ou se estão sendo eficientes. Com Python, você tem controle total. É possível paralelizar cálculos usando bibliotecas como Dask e Joblib, distribuindo o processamento por múltiplos núcleos do processador, ou até mesmo descarregar cálculos para a GPU com QPI e Rapids. Isso pode resultar em ganhos de performance de 10.000 vezes, transformando análises de horas em segundos.

6. Personalização ilimitada na apresentação de dados:

Além de dashboards, Python permite gerar relatórios PDF totalmente personalizados, enviar informações automaticamente por e-mail, WhatsApp ou Telegram, e até criar APIs para que outros sistemas consumam seus dados. A liberdade de saída é ilimitada, permitindo que você construa suas próprias ferramentas e gráficos que ainda não existem.

7. Custo e propriedade:

Excel e Power BI são produtos da Microsoft, pagos e sujeitos às decisões da empresa (preços, descontinuação, remoção de funcionalidades) . Python é uma linguagem gratuita e de código aberto, desenvolvida por uma comunidade global. Isso significa que a ferramenta é sua, o poder é seu, e você não está refém de uma única empresa ou de suas atualizações.

A Curva de aprendizagem e o futuro com a IA

É verdade que aprender Python exige mais dedicação do que simplesmente "arrastar e soltar" em ferramentas gráficas. Um iniciante pode levar cerca de 3 meses para começar a produzir bons resultados. No entanto, o domínio de Python abre portas para posições que pagam muito mais, com diferenças salariais que podem ser de duas a três vezes maiores, inclusive em vagas internacionais de engenharia e ciência de dados.

Além disso, a ascensão da programação assistida por IA (como ChatGPT, Gemini, Copilot, Claude.AI, etc) está revolucionando o aprendizado. A IA pode programar para você, e sua função será supervisionar e corrigir. Isso gera um enorme ganho de produtividade. O mais curioso é que, para aproveitar ao máximo essas ferramentas, é fundamental saber programar, pois você precisa saber o que pedir e como corrigir os erros da IA.

Roteiro para dominar Python na análise de dados

Para aqueles que desejam trilhar o caminho da análise de dados com Python, aqui está um roteiro básico para começar:

• Fundamentos da Programação em Python:

Comece com a lógica de programação, manipulação de dados básicos, estruturas de controle de fluxo, loops, funções e programação orientada a objetos.

• Análise de dados básica e visualização:

Domine bibliotecas como Pandas (considerado um "Excel com esteroides" em Python), Matplotlib e Seaborn para transformar e visualizar dados.

• Trabalho com APIs e Bancos de Dados:

Aprenda a consumir informações de APIs e bancos de dados e a inseri-las em suas análises.

• Construção de Dashboards:

Utilize bibliotecas poderosas como Plotly e Seaborn para transformar suas análises em algo visualizável para sua equipe.

• Automação de Processos:

Entenda como automatizar todo o processo para garantir atualizações em tempo real dos dashboards e a estabilidade do sistema, permitindo que novos usuários acessem os dados sem quebrar o fluxo.

Este é um roteiro fundamental para um analista de dados, que pode ser seguido de forma autônoma, embora o processo possa ser mais desafiador sem uma estrutura clara e mentoria.

Considerações finais

A migração do mercado de dados para Python não é uma moda passageira, mas uma resposta às crescentes demandas por flexibilidade, performance e controle. As ferramentas gráficas, por mais acessíveis que sejam, impõem limitações que se tornam barreiras para quem busca levar a análise de dados a um nível profissional.

Você está pronto para dominar a ferramenta que o mercado exige e desbloquear todo o seu potencial na análise de dados?

Feito!

Como armazenar senhas com segurança em um banco de dados

A segurança das senhas dos usuários é uma das preocupações mais importantes para qualquer aplicação ou serviço online. A forma como as senhas são armazenadas pode determinar a resistência do sistema a ataques e violações de segurança. Neste artigo, vamos discutir práticas recomendadas e abordagens a serem evitadas ao armazenar senhas em um banco de dados.

O que não deve ser feito?

• Armazenamento em Texto Puro: Armazenar senhas em texto simples é uma das práticas mais inseguras. Isso significa que as senhas estão disponíveis em seu formato legível para qualquer pessoa que tenha acesso ao banco de dados. Isso expõe os usuários a riscos significativos, especialmente em caso de violação de dados.
• Hash MD5 e SHA: O uso de algoritmos de hash como MD5 ou SHA para armazenar senhas também não é mais recomendado. Esses algoritmos são rápidos e podem ser facilmente quebrados usando técnicas de força bruta ou ataques de dicionário. Além disso, eles não oferecem proteção adequada contra ataques de hash conhecidos, como ataques de tabela arco-íris.
• Encrypt e Decrypt: O uso de criptografia simétrica para armazenar senhas também não é uma prática recomendada. Isso envolve a criptografia das senhas usando uma chave e, em seguida, descriptografá-las quando necessário. No entanto, se a chave for comprometida, todas as senhas armazenadas estarão em risco.

Recomendação: Usando Bcrypt

O Bcrypt é um algoritmo de hashing projetado especificamente para armazenar senhas de forma segura. Ele incorpora um fator de trabalho ajustável, tornando-o mais resistente a ataques de força bruta e dicionário, mesmo com o aumento da capacidade de computação.

O Bcrypt é amplamente recomendado pela comunidade de segurança e é suportado por muitas linguagens de programação, incluindo Python.

Para armazenar senhas com hash Bcrypt em um banco de dados MySQL em um ambiente Docker, primeiro você precisa configurar um contêiner Docker MySQL e, em seguida, adaptar o script Python para se conectar a esse banco de dados e armazenar as senhas com segurança.

Configurando o contâiner MySQL

Certifique-se de ter o Docker instalado em sua máquina, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10 .

Em seguida, você pode executar o seguinte comando para configurar um contêiner Docker MySQL:

docker run --name meu-mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=secret -e MYSQL_DATABASE=safe_password -d mysql:latest

Isso criará um contêiner MySQL com uma senha de root especificada como "secret".

docker start meu-mysql

Script create_table_usuarios.sql

CREATE TABLE usuarios(
  id INTEGER PRIMARY KEY AUTO_INCREMENT,
 nome VARCHAR(200),
email VARCHAR(200),
 senha VARCHAR(200)
);

docker cp create_table_usuarios.sql meu-mysql:/create_table_usuarios.sql

docker exec -it meu-mysql bash

mysql -u root -p safe_password < create_users.sql

Script Python para armazenar senhas com Bcrypt no MySQL

O Bcrypt não é uma biblioteca nativa do Python, então você precisa instalá-la usando pip. Para instalar o bcrypt, você pode executar o seguinte comando no terminal:

pip install bcrypt mysql-connector-python

Aqui está um exemplo simples de como você pode usar o bcrypt para armazenar senhas de forma segura em um banco de dados em Python:

safe_password.py

Teste do script Python safe_password.py

python3 safe_password.py

Considerações finais:

A segurança das senhas dos usuários é uma responsabilidade crucial para qualquer desenvolvedor de software. Armazenar senhas de forma segura utilizando algoritmos robustos como bcrypt é essencial para proteger os dados dos usuários contra acessos não autorizados. Evitar práticas inseguras, como armazenamento em texto simples ou o uso de algoritmos de hash fracos, é fundamental para garantir a integridade e a confidencialidade das informações dos usuários.

Feito!

Conhecendo o PyScript

O que é PyScript?

PyScript é um projeto que executa scripts em Python diretamente na página web.

Sabemos que Python é uma das linguagens de programação mais populares pela sua facilidade de aprendizado e também ser considerada a caligrafia do programador, dos que não tem costume de indentar códigos.

Também o uso do Python cresceu bastante em Data Sciense (Ciência de Dados), incluindo Machine Learning e Deep Learning.

Assim surgiu o projeto PyScript, como uma biblioteca JavaScript que permite executar scripts Python na página web, inicialmente para quem conhece PHP, irá pensar que é parecido, pois mistura Python e HTML na página web.

O objetivo do projeto PyScript é permitir o público de desenvolvedores Frontend conheçam o poder do Python e as diversas bibliotecas de estatísticas, Machine Learning, Deep Learning, etc.

Se caso você é um Cientista de Dados, pode compartilhar os arquivos HTML, dashboards e modelos para pessoas interessadas poderem executar diretamente no browser a sua aplicação, de forma simples, sem precisar uma configuração complicada.

Como o PyScript funciona?

PyScript foi construído em cima do Pyodide, que é uma biblioteca que transforma código Python em WebAssembly.

WebAssembly é uma tecnologia que possibilita escrever sites em Python. Utiliza uma linguagem no formato .wat legível por humanos, então convertida para o formato .wasm binário para que os browser poder executar. Por meio disso, podemos escrever código em qualquer linguagem, compilá-lo para WebAssembly e executá-lo em um browser.

Por enquanto, o PyScript tem suporte escrever e executar apenas código Python no browser. O objetivo para o futuro é que também ofereça suporte para outras linguagens de programação.

Vamos na prática

Agora vamos executar o primeiro código Python no browser com o PyScript

O famoso Hello World com PyScript

helloword.html

<html>
  <head>
    <link rel="stylesheet" href="https://pyscript.net/alpha/pyscript.css" />
    <script defer src="https://pyscript.net/alpha/pyscript.js"></script>
  </head>
  <body> 
    <py-script> print('Hello, World!') </py-script> 
  </body>
</html>

Execute o arquivo HTML no browser que utiliza como default e irá mostrar "Hello, World!" na página. Agora vamos para o segundo exemplo mais elaborado que executa o Histograma de uma Distribuição Padrão, como em Estatística.

histograma-dist.html

<html>
    <head>
      <link rel="stylesheet" href="https://pyscript.net/alpha/pyscript.css" />
      <script defer src="https://pyscript.net/alpha/pyscript.js"></script>
      <py-env>
        - numpy
        - matplotlib
      </py-env>
    </head>

  <body>
    <h1>Histograma de uma Distribuição Padrão</h1>
    <div id="grafico"></div>
    <py-script output="grafico">
import matplotlib.pyplot as plt
import numpy as np

np.random.seed(42)

rv = np.random.standard_normal(1000)

fig, ax = plt.subplots()
ax.hist(rv, bins=30)
fig
    </py-script>
  </body>
</html>

Você deve perguntar, se teria como executar o script Python separado do HTML, a resposta é sim, deixando mais limpo.

Adicione o script Python entre a tag

<py-script src="script.py"> </py-script>

<html>
  <head>
    <link rel="stylesheet" href="https://pyscript.net/alpha/pyscript.css" />
    <script defer src="https://pyscript.net/alpha/pyscript.js"></script>
  </head>
  <body> 
    <py-script src="/script.py"> </py-script>
  </body>
</html>

Referências

https://anaconda.cloud/pyscript-python-in-the-browser

https://pyscript.com/

https://github.com/pyodide/pyodide/tree/main/packages

Feito!

Configurando servidor de arquivos com Python

O que é HTTP Server?

HTTP HypertText Transfer Protocol. Vamos pensar em um protocolo como um idioma qualquer de lingua nativa do seu país de origem ou secundário. Cada idioma tem um conjunto de regras e vocabulário. Portanto, se duas ou mais pessoas entender as regras e o vocabulário de um idioma, pode-se comunicar no idioma de maneira eficaz.

Assim como os seres humanos, os dispositivos eletrônicos tambémm se comunicam entre si. Eles, portanto, precisam de um "conjunto de regras e vocabulário" para transmitir e receber ativamente informações uns dos outros.

Um protocolo é um conjunto padrão de regras que facilita a comunicação bem-sucessida entre dispositivos eletrônicos. Esses conjuntos de regras mutuamente aceitas e implementas incluem os comandos usados para iniciar o envio e a recepção de dados, os tipos de dados a serem transmitidos entre os dispositivos, como detectar erros nos cabos, como as transferências de dados bem-sucessidas são confirmadas e muito mais.

Por exemplo, quando você executa uma pesquisa simples usando um navegador, há dois sisemas essenciais envolvidos. O cliente HTTP e o servidor HTTP.

O cliente, comumente referido como navegador, como Google Chrome ou Firefox, mas também pode ser tão simples quanto um aplicativo CLI. O cliente envia sua solicitação ao servidor, que processa as solicitações HTTP e fornece uma resposta ao cliente. No caso de navegadores, a resposta normalmente é uma página HTML.

Módulo SimpleHTTPServer do Python

Quando você precisa de um servidor web rápido em execução, configurar um servidor de nível de produção é uum exagero.

O módulo SimpleHTTPServer do Python é uma ferramenta de economia de trabalho que você pode aproveitar para transformar qualquer diretório em seu sistema em um servidor web descomplicado. Ele vem com uum servidor HTTP simples que oferece manipuladores de solicitação GET e HEAD padrão.

Com um servidor HTTP embutido, você não precisa instalar ou configurar nada para ter seu servidor web instalado e funcionando.

OBS: O módulo Python SimpleHTTPServer foi incorporado ao módulo http.server em Python 3, mas se você estiver usando Python 2, pode trocar http.server por SimpleHTTPServer e funciona de ambos os casos.

Inicializar o HTTPServer no Python

A maneira mais simples de iniciar um servidor web que atende ao diretório no qual o comando é executado, simplesmente acesse até o diretório onde tem os arquivos e execute no terminal:

Python 2
$ python -m SimpleHTTPServer 8000

Python 3
$ python3 -m http.server 8000

No browser na máquina local acesse http://localhost:8000

Para acessar de outra máquina da rede interna http://IPSERVIDOR:8000

Conclusão

A linguagem Python nos fornece o módulo SimpleHTTPServer que pode ser usado para servir arquivos de forma rápida e fácil de um diretório local via HTTP. Isso pode ser usado para tarefas internas, mas não recomendado utilizar em ambiente de produção.

Feito!