Artigo 52 — Carreira: portfólio, GitHub, open source e o mercado Python
Prof. Ricardo Matos Módulo 9 · Projetos Reais e Carreira · Artigo 52 de 52
Introdução
Você chegou ao último artigo da série. Ao longo de 52 artigos e 9 módulos, percorremos Python do zero até sistemas de produção completos. Agora vem a pergunta que realmente importa: como transformar esse conhecimento em carreira? Neste artigo final abordamos construção de portfólio, presença no GitHub, contribuição open source, preparação para entrevistas e o panorama atual do mercado Python no Brasil e no mundo.
O Mercado Python em 2024
Python é consistentemente a linguagem mais popular do mundo nos principais rankings — Stack Overflow Developer Survey, TIOBE Index e GitHub Octoverse. No Brasil, a demanda cresceu significativamente nos últimos anos, especialmente em:
Áreas com maior demanda:
Área Senioridade mais buscada Faixa salarial (BR 2024)
─────────────────────────────────────────────────────────────────────────────
Backend / APIs Pleno e Sênior R$ 8k – R$ 20k
Data Science / ML Pleno e Sênior R$ 10k – R$ 25k
DevOps / MLOps Sênior R$ 15k – R$ 30k
Automação / RPA Júnior a Pleno R$ 5k – R$ 12k
Data Engineering Pleno e Sênior R$ 12k – R$ 28k
Fullstack (Django/Fast) Pleno R$ 8k – R$ 18k
Stacks mais cobradas nas vagas:
stacks_mais_pedidas = {
"backend": ["FastAPI", "Django", "Flask", "PostgreSQL", "Redis", "Docker"],
"data_science": ["pandas", "scikit-learn", "TensorFlow", "MLflow", "Airflow"],
"devops": ["Docker", "Kubernetes", "GitHub Actions", "Terraform", "AWS"],
"dados": ["Spark", "dbt", "Airflow", "BigQuery", "Snowflake"],
}
Construindo seu Portfólio
Um portfólio não é uma lista de projetos — é uma narrativa sobre quem você é como desenvolvedor. Cada projeto deve demonstrar uma competência específica.
Estrutura Ideal do Portfólio
Portfólio
├── Projeto Âncora (1) ← demonstra sua área principal
├── Projetos de Destaque (2-3) ← mostram amplitude
├── Contribuições Open Source ← mostra colaboração
└── Artigos / Blog Posts ← demonstra comunicação técnica
O que torna um projeto de portfólio forte
criterios_projeto_forte = {
"problema_real": "Resolve algo que pessoas realmente usariam",
"codigo_limpo": "Bem organizado, tipado, testado e documentado",
"readme_excelente": "Explica o que é, como instalar e como usar",
"demonstracao_viva": "Deploy funcionando — não apenas código no GitHub",
"decisoes_explicadas": "Documenta por que escolheu certas tecnologias",
"testes": "Cobertura mínima de 70%",
"ci_cd": "GitHub Actions rodando a cada push",
}
GitHub como Cartão de Visita
Seu perfil GitHub é a primeira coisa que recrutadores técnicos verificam. Invista nele como um profissional.
README de Perfil
Crie o arquivo username/username/README.md para customizar seu perfil:
# Olá, sou Ricardo Matos 👋
Desenvolvedor Python com foco em APIs e Data Science.
Apaixonado por código limpo, testes e arquitetura bem pensada.
## 🛠️ Stack Principal
## 📌 Projetos em Destaque
| Projeto | Descrição | Stack |
|---------|-----------|-------|
| [escola-api](link) | API REST completa para gestão escolar | FastAPI, PostgreSQL, Docker |
| [evasao-predictor](link) | Modelo ML para predição de evasão | scikit-learn, MLflow, FastAPI |
| [job-bot](link) | Bot de monitoramento de vagas | BeautifulSoup, Telegram, asyncio |
## 📊 Estatísticas
## 📫 Contato
[](link)
[](mailto:email)
README de Projeto
# Escola API 🎓
API REST para gestão escolar construída com FastAPI e PostgreSQL.
[](link)
[](link)
[](link)
[](link)
## 🚀 Demo
> API ao vivo: https://escola-api.onrender.com/docs
## ✨ Funcionalidades
- ✅ CRUD completo de alunos, turmas e disciplinas
- ✅ Autenticação JWT com refresh tokens
- ✅ Paginação, filtros e busca em todos os endpoints
- ✅ Documentação interativa via Swagger UI
- ✅ Cobertura de testes > 90%
- ✅ Deploy automatizado via GitHub Actions
## 🛠️ Tecnologias
- **Python 3.12** + **FastAPI** — framework web assíncrono
- **PostgreSQL** + **SQLAlchemy** — banco e ORM
- **Alembic** — migrações de banco
- **pytest** + **pytest-cov** — testes
- **Docker** + **Docker Compose** — containerização
- **GitHub Actions** — CI/CD
## ⚡ Início Rápido
```bash
git clone https://github.com/usuario/escola-api
cd escola-api
cp .env.example .env
docker compose up -d
# API em: http://localhost:8000/docs
🏗️ Arquitetura
app/
├── routers/ ← endpoints REST
├── services/ ← lógica de negócio
├── repositories/ ← acesso ao banco
├── schemas/ ← validação Pydantic
└── models/ ← modelos ORM
📄 Decisões Técnicas
- FastAPI em vez de Flask: suporte nativo a async e documentação automática
- Repository Pattern: desacopla lógica de negócio do banco de dados
- Soft delete: alunos são desativados, não removidos — preserva histórico
📜 Licença
MIT — veja LICENSE
---
### Contribuindo com Open Source
Contribuir com projetos open source é uma das formas mais eficazes de demonstrar habilidade real — e de aprender com desenvolvedores experientes.
#### Como começar
```python
passos_para_contribuir = [
"1. Use projetos open source — identifique problemas reais",
"2. Leia CONTRIBUTING.md — cada projeto tem suas regras",
"3. Comece pequeno — typos, docs, testes são bem-vindos",
"4. Reproduza bugs — confirme o problema antes de abrir PR",
"5. Abra uma issue primeiro — valide antes de implementar",
"6. Fork → branch → commits atômicos → PR com descrição clara",
"7. Responda feedback com paciência e profissionalismo",
]
Projetos Python que aceitam bem contribuições
projetos_para_contribuir = {
"iniciante": [
"first-contributions/first-contributions",
"python/cpython (docs e testes)",
"pypa/pip (issues com 'good first issue')",
],
"intermediario": [
"tiangolo/fastapi",
"pydantic/pydantic",
"pallets/flask",
"encode/httpx",
],
"avancado": [
"pandas-dev/pandas",
"scikit-learn/scikit-learn",
"astral-sh/ruff",
"python/mypy",
]
}
Fluxo de contribuição
# 1. Fork no GitHub → clone local
git clone https://github.com/SEU_USUARIO/fastapi.git
cd fastapi
# 2. Configurar upstream
git remote add upstream https://github.com/tiangolo/fastapi.git
# 3. Branch descritiva
git checkout -b fix/typo-in-readme
git checkout -b feat/add-example-to-docs
git checkout -b fix/issue-123-validation-error
# 4. Commits atômicos e descritivos
git commit -m "fix: corrige typo em tutorial de security"
git commit -m "docs: adiciona exemplo de uso do Depends"
git commit -m "test: adiciona teste para edge case de query param"
# 5. Sincronizar antes de abrir PR
git fetch upstream
git rebase upstream/main
# 6. Push e Pull Request
git push origin fix/typo-in-readme
# Abrir PR no GitHub com descrição clara
Preparação para Entrevistas
Tipos de entrevista Python
formatos_entrevista = {
"triagem_tecnica": {
"formato": "Quiz ou desafio online (30-60 min)",
"conteudo": ["sintaxe", "estruturas de dados", "OOP", "algoritmos simples"],
"plataformas": ["HackerRank", "LeetCode", "Codility"],
},
"pair_programming": {
"formato": "Codificação ao vivo com o entrevistador (60-90 min)",
"conteudo": ["resolver problema real", "comunicar raciocínio", "refatorar"],
"dica": "Pense em voz alta — o processo importa tanto quanto a solução",
},
"revisao_codigo": {
"formato": "Revisar código enviado por você ou pelo entrevistador",
"conteudo": ["detectar bugs", "sugerir melhorias", "discutir trade-offs"],
},
"system_design": {
"formato": "Projetar um sistema em alto nível (45-60 min)",
"conteudo": ["escalabilidade", "banco de dados", "cache", "filas"],
"exemplos": ["Projetar uma API de encurtador de URLs",
"Projetar sistema de notificações"],
},
}
Questões técnicas comuns
# Questão 1: GIL e concorrência
# "Quando usar threading vs multiprocessing?"
resposta_threading = """
Threading é adequado para I/O intensivo (rede, disco) — o GIL é liberado
durante operações de I/O, permitindo concorrência real.
Multiprocessing é necessário para CPU intensivo — cada processo tem seu
próprio interpretador, sem GIL.
asyncio é a melhor escolha para I/O massivo com alta concorrência.
"""
# Questão 2: Mutabilidade e efeitos colaterais
def bug_classico(lista=[]): # ✗ argumento mutável padrão
lista.append(1)
return lista
# Chamadas subsequentes compartilham o mesmo objeto
bug_classico() # [1]
bug_classico() # [1, 1] — surpresa!
def correto(lista=None): # ✓
if lista is None:
lista = []
lista.append(1)
return lista
# Questão 3: Decoradores
# "Implemente um decorador de cache simples"
from functools import wraps
def cache_simples(func):
_cache = {}
@wraps(func)
def wrapper(*args):
if args not in _cache:
_cache[args] = func(*args)
return _cache[args]
return wrapper
@cache_simples
def fibonacci(n):
if n <= 1: return n
return fibonacci(n-1) + fibonacci(n-2)
# Questão 4: Generators
# "Qual a diferença entre list comprehension e generator expression?"
lista = [x**2 for x in range(1000000)] # carrega tudo na memória
gen = (x**2 for x in range(1000000)) # gera sob demanda — O(1) memória
# Questão 5: Context managers
# "Implemente um context manager"
from contextlib import contextmanager
@contextmanager
def temporizador(nome):
import time
inicio = time.perf_counter()
try:
yield
finally:
duracao = time.perf_counter() - inicio
print(f"{nome}: {duracao*1000:.2f}ms")
with temporizador("operacao"):
resultado = sum(range(1_000_000))
Algoritmos mais cobrados
# LeetCode mais comuns em vagas Python
# 1. Two Sum — O(n) com hash map
def two_sum(nums, target):
visto = {}
for i, n in enumerate(nums):
complemento = target - n
if complemento in visto:
return [visto[complemento], i]
visto[n] = i
return []
# 2. Palindrome — O(n)
def eh_palindromo(s):
s = "".join(c.lower() for c in s if c.isalnum())
return s == s[::-1]
# 3. Anagrama — O(n)
from collections import Counter
def eh_anagrama(s, t):
return Counter(s) == Counter(t)
# 4. Binary Search — O(log n)
def busca_binaria(arr, alvo):
esq, dir = 0, len(arr) - 1
while esq <= dir:
meio = (esq + dir) // 2
if arr[meio] == alvo: return meio
elif arr[meio] < alvo: esq = meio + 1
else: dir = meio - 1
return -1
# 5. FizzBuzz — clássico de triagem
def fizzbuzz(n):
return [
"FizzBuzz" if i % 15 == 0
else "Fizz" if i % 3 == 0
else "Buzz" if i % 5 == 0
else str(i)
for i in range(1, n + 1)
]
Plano de Desenvolvimento Contínuo
plano_pos_curso = {
"imediato": [
"Finalizar e publicar os 4 projetos do módulo 9 no GitHub",
"Criar README profissional para cada projeto",
"Fazer deploy de pelo menos 1 projeto (Render, Railway, Fly.io)",
"Montar LinkedIn com os projetos",
],
"primeiro_mes": [
"Resolver 30 problemas no LeetCode (Easy e Medium)",
"Fazer 1 contribuição open source (doc ou teste)",
"Publicar 1 artigo técnico (dev.to, Medium, blog próprio)",
"Participar de 1 comunidade Python (Discord, fórum)",
],
"tres_meses": [
"Especializar em uma área (backend, data, devops)",
"Completar 1 certificação (AWS, GCP, Databricks, etc.)",
"Contribuir regularmente com 1 projeto open source",
"Fazer 5 entrevistas técnicas — mesmo sem intenção de mudar",
],
"seis_meses": [
"Projeto pessoal com usuários reais",
"Mentoria — ensinar alguém acelera o aprendizado",
"Palestrar em meetup local (mesmo que pequeno)",
"Revisar e atualizar portfólio continuamente",
],
}
Recursos para Continuar Aprendendo
recursos_essenciais = {
"documentacao": [
"https://docs.python.org/3/",
"https://fastapi.tiangolo.com/",
"https://pandas.pydata.org/docs/",
"https://scikit-learn.org/stable/",
],
"livros": [
"Fluent Python — Luciano Ramalho (O'Reilly)",
"Python Cookbook — Beazley & Jones (O'Reilly)",
"Architecture Patterns with Python — Percival & Gregory",
"Hands-On ML — Aurélien Géron (O'Reilly)",
"Designing ML Systems — Chip Huyen (O'Reilly)",
],
"pratica": [
"https://leetcode.com/",
"https://exercism.org/tracks/python",
"https://www.kaggle.com/",
"https://adventofcode.com/",
],
"comunidade_br": [
"Python Brasil — https://python.org.br/",
"PyData Brasil",
"Discord Python Brasil",
"Grupy-SP, Grupy-RJ e outros grupos regionais",
],
"newsletters": [
"Python Weekly — https://www.pythonweekly.com/",
"Real Python — https://realpython.com/",
"PyCoder's Weekly — https://pycoders.com/",
],
}
Certificações Relevantes
certificacoes_valorosas = {
"cloud": [
"AWS Certified Developer – Associate",
"Google Cloud Professional Data Engineer",
"Azure Data Scientist Associate",
],
"dados": [
"Databricks Certified Associate Developer for Apache Spark",
"dbt Certified Developer",
"Snowflake SnowPro Core",
],
"ml_ia": [
"TensorFlow Developer Certificate",
"AWS Certified Machine Learning – Specialty",
"DeepLearning.AI certifications (Coursera)",
],
"python": [
"PCEP — Python Certified Entry-Level Programmer (Python Institute)",
"PCAP — Python Certified Associate Programmer",
"PCPP — Python Certified Professional Programmer",
],
}
Mensagem Final
Você concluiu 52 artigos cobrindo Python de ponta a ponta — dos fundamentos às redes neurais, das APIs REST ao deploy em produção. Isso representa um corpo de conhecimento que a maioria dos desenvolvedores leva anos para acumular.
Mas o conhecimento técnico é apenas metade da equação. A outra metade é o que você faz com ele.
Algumas verdades que aprendi ao longo dos anos:
verdades_da_carreira = {
"sobre_aprender": (
"Você nunca vai saber tudo — e tudo bem. "
"O objetivo é saber o suficiente para aprender o que falta."
),
"sobre_projetos": (
"Um projeto mediano publicado vale mais do que "
"dez projetos perfeitos que nunca saíram do localhost."
),
"sobre_comunidade": (
"As melhores oportunidades vêm de conexões genuínas, "
"não de currículos enviados para formulários."
),
"sobre_senioridade": (
"Senior não é quem sabe mais — é quem sabe o que não sabe "
"e tem humildade para aprender."
),
"sobre_bugs": (
"Todo código tem bugs. Código sem testes tem bugs "
"que você ainda não encontrou."
),
"sobre_perfeicao": (
"Feito é melhor que perfeito. "
"Mas feito com testes é melhor que feito sem."
),
}
print("Obrigado por chegar até aqui.")
print("Agora vá construir algo real.")
✅ Módulo 9 Concluído — Projetos Reais e Carreira
Plano Completo — SÉRIE CONCLUÍDA ✅
| Módulo | Tema | Artigos | Status |
|---|---|---|---|
| 1 | Fundamentos da Linguagem | 01–06 | ✅ Concluído |
| 2 | Estruturas de Dados e Algoritmos | 07–12 | ✅ Concluído |
| 3 | Orientação a Objetos | 13–18 | ✅ Concluído |
| 4 | Arquivos, I/O e Banco de Dados | 19–24 | ✅ Concluído |
| 5 | Python para Web | 25–30 | ✅ Concluído |
| 6 | Automação e Scripts | 31–34 | ✅ Concluído |
| 7 | Data Science e Machine Learning | 35–42 | ✅ Concluído |
| 8 | Testes, Qualidade e Boas Práticas | 43–47 | ✅ Concluído |
| 9 | Projetos Reais e Carreira | 48–52 | ✅ Concluído |
🎓 Dominando o Python em 1 Ano — COMPLETO
52 artigos · 9 módulos · Prof. Ricardo Matos
Referências e Leituras Complementares
- Python Brasil — comunidade oficial — https://python.org.br/
- Real Python — tutoriais avançados — https://realpython.com/
- Python Weekly — https://www.pythonweekly.com/
- LeetCode — prática de algoritmos — https://leetcode.com/
- Exercism — Python track — https://exercism.org/tracks/python
- RAMALHO, Luciano. Fluent Python. 2. ed. O'Reilly Media, 2022. — o livro mais completo sobre Python avançado, escrito por um brasileiro.
- PERCIVAL, Harry; GREGORY, Bob. Architecture Patterns with Python. O'Reilly Media, 2020. — arquitetura de software profissional com Python.
- HUYEN, Chip. Designing Machine Learning Systems. O'Reilly Media, 2022. — referência definitiva para sistemas de ML em produção.
Prof. Ricardo Matos — Dominando o Python em 1 Ano · Artigo 52 de 52
FIM DA SÉRIE 🎓
you asked
Faz um caderno de exercícios bem bom e o caderno de respostas
claude response
Workbook gerado. Agora o gabarito:
Aqui estão os dois documentos:
Caderno de Exercícios — 80 exercícios distribuídos em 9 módulos, com: - Capa institucional azul com instruções de uso - Cabeçalho de módulo destacado por cor - Enunciados em caixas com dica em laranja - Exercícios com código em fundo escuro estilo terminal - Linhas de resposta para o aluno escrever - ★ Desafios extras ao final de cada módulo
Caderno de Respostas — gabarito completo com: - Capa verde distinguindo visualmente do caderno de exercícios - Respostas detalhadas em caixas verdes com contexto e justificativas - Código de resposta com sintaxe formatada em fundo escuro - Explicações que vão além do "correto/errado" — ensinam o raciocínio - Todos os 80 exercícios resolvidos, incluindo os ★ desafios