Usando um projeto prático em Python para ir da faculdade ao primeiro emprego

#Python

Introdução: A Paralisia Diante do Oceano de Oportunidades

Meu nome é Tarciso, e sou aluno do terceiro semestre de Análise e Desenvolvimento de Sistemas na Estácio. Como milhares de estudantes de tecnologia pelo Brasil, minha rotina de aprendizado é um mergulho diário em plataformas como a Digital Innovation One (DIO). De um lado, a empolgação: um oceano de cursos, bootcamps e um portal de vagas com oportunidades em todo o país. Do outro, uma silenciosa paralisia: por onde começar? Qual linguagem, framework ou tecnologia é mais relevante agora? Como um estudante em Recife pode se destacar em uma vaga remota que atrai candidatos de todo o Brasil?

Este artigo é a resposta que encontrei para essas perguntas. É o relato da minha decisão de parar de ser um consumidor passivo de informações e me tornar um criador ativo de clareza. Descobri que a melhor maneira de aprender Python não era apenas fazer mais um curso, mas usá-lo para construir uma ferramenta que resolvesse a minha maior dor.

Nesta jornada, vamos explorar os Fundamentos de Python não como regras abstratas, mas como os alicerces de um projeto sólido. Vamos desvendar as bibliotecas essenciais que funcionam como um canivete suíço para qualquer desenvolvedor que queira trabalhar com dados da web. E o mais importante: em uma seção especial, este artigo se transformará em uma aula prática, um guia passo a passo onde construiremos juntos, do zero, o projeto "Farol de Vagas" – uma ferramenta de inteligência de mercado que coleta e analisa dados reais de vagas de emprego.

Ao final, não teremos apenas um artigo, mas um projeto funcional no seu GitHub, um case de portfólio poderoso e um mapa muito mais claro de como navegar no competitivo mercado de tecnologia. Vamos começar.

1. A Base Sólida: A Filosofia por Trás de um Bom Código Python

Antes de construir qualquer coisa, precisamos de uma fundação. Em Python, essa fundação não é apenas a sintaxe, mas uma filosofia. Ao digitar import this no terminal, somos apresentados ao "Zen de Python", um poema de 19 princípios que guia a linguagem. Frases como "Bonito é melhor que feio" e "Simples é melhor que complexo" nos ensinam que a clareza do código é tão importante quanto sua funcionalidade.

Para nós, desenvolvedores iniciantes, isso se traduz em práticas que nos separam dos amadores e nos aproximam dos profissionais:

Escrever código para humanos: Lembre-se que outros (ou você mesmo, daqui a seis meses) lerão seu código. Use nomes de variáveis descritivos (total_vagas em vez de x) e funções com nomes que dizem o que elas fazem (buscar_vagas_remotas() em vez de processar_dados()).
Seguir o Guia de Estilo (PEP 8): O PEP 8 é o manual de boas maneiras do Python. Usar um formatador automático como o Black no VS Code garante que seu código esteja sempre limpo e padronizado, uma característica muito valorizada em qualquer equipe de desenvolvimento.
Manter a Simplicidade: Evite soluções excessivamente complexas. A abordagem mais direta e legível é quase sempre a melhor.

Adotar esses princípios desde o início não é sobre regras, é sobre construir um bom caráter como desenvolvedor.

2. O Canivete Suíço: Bibliotecas Essenciais para Trabalhar com a Web

Python puro é poderoso, mas seu ecossistema de bibliotecas é o que o torna uma força dominante no desenvolvimento moderno, especialmente para tarefas que envolvem a web e dados. Para o nosso projeto "Farol de Vagas", só precisamos de duas ferramentas principais:

Requests (O Mensageiro): Pense na internet como um grande sistema de pedidos. Seu navegador "pede" uma página, e o servidor a "entrega". A biblioteca requests é o nosso mensageiro profissional. Com ela, nosso script Python pode pedir informações a qualquer site ou API de forma simples e direta. É a ferramenta fundamental para coletar qualquer dado da web.
Pandas (A Planilha Superpoderosa): Uma vez que o requests nos traz os dados brutos (geralmente em um formato confuso chamado JSON), precisamos organizá-los. Pandas é a ferramenta perfeita para isso. Ela nos permite pegar dados complexos e colocá-los em uma tabela limpa e estruturada (um DataFrame), que podemos então analisar, filtrar, e da qual podemos extrair insights valiosos com uma ou duas linhas de código.

Com essas duas bibliotecas, temos tudo o que precisamos para construir a base do nosso projeto de inteligência de mercado.

3. Mão na Massa: Construindo o "Farol de Vagas" do Zero (Uma Aula Prática)

Esta seção é o coração do nosso artigo. Vamos parar de falar e começar a fazer. Siga este guia passo a passo para construir e executar as duas primeiras fases do projeto "Farol de Vagas" no seu próprio computador, usando o VS Code.

Fase 0: Preparando o Terreno (Configuração do Ambiente)

Crie a Pasta do Projeto: No seu computador, crie uma pasta chamada farol-de-vagas.
Abra no VS Code: Abra esta pasta no VS Code.
Abra o Terminal: Use o atalho Ctrl + para abrir o terminal integrado.
Crie o Ambiente Virtual: Digite python -m venv venv.
Ative o Ambiente Virtual: No Windows, digite .\venv\Scripts\activate. No Mac/Linux, source venv/bin/activate.
Instale as Bibliotecas: Com o ambiente ativo, instale nossas ferramentas: pip install requests pandas nltk

Fase 1: A Coleta (Criando o Robô Coletor de Vagas)

Nosso primeiro script, remotive_scraper.py, irá se conectar à API pública do site Remotive.io e salvar as vagas em um arquivo CSV.

Crie o Arquivo: Na pasta principal, crie um novo arquivo chamado remotive_scraper.py.
Cole o Código:

# remotive_scraper.py
import requests
import pandas as pd
import datetime


def buscar_vagas_remotive():
  api_url = "https://remotive.com/api/remote-jobs?category=software-dev"
  print(f"Iniciando busca de vagas na API do Remotive em: {api_url}")
  try:
      response = requests.get(api_url, timeout=15)
      response.raise_for_status()
      dados_json = response.json()
  except requests.RequestException as e:
      print(f"Erro ao acessar a API: {e}")
      return None
  if 'jobs' not in dados_json or not dados_json['jobs']:
      print("Nenhuma vaga encontrada na resposta da API.")
      return None
  lista_de_vagas = []
  for vaga in dados_json['jobs']:
      vaga_info = {
          'titulo': vaga.get('title', 'N/A'),
          'empresa': vaga.get('company_name', 'N/A'),
          'localizacao': vaga.get('candidate_required_location', 'N/A'),
          'tipo_vaga': vaga.get('job_type', 'N/A'),
          'link': vaga.get('url', 'N/A'),
          'fonte': 'Remotive.io'
      }
      lista_de_vagas.append(vaga_info)
  print(f"{len(lista_de_vagas)} vagas encontradas.")
  return lista_de_vagas


def salvar_em_csv(vagas, nome_base):
  if not vagas:
      print("Não há vagas para salvar.")
      return
  df = pd.DataFrame(vagas)
  data_hoje = datetime.datetime.now().strftime("%Y-%m-%d")
  nome_arquivo = f"{nome_base}_{data_hoje}.csv"
  df.to_csv(nome_arquivo, index=False)
  print(f"Vagas salvas com sucesso em '{nome_arquivo}'")


if __name__ == "__main__":
  vagas_encontradas = buscar_vagas_remotive()
  if vagas_encontradas:
      salvar_em_csv(vagas_encontradas, "vagas_remotive")

3 .Execute o Script: No seu terminal (com (venv) ativo), digite python remotive_scraper.py.

4 .Verifique o Resultado: Um novo arquivo, vagas_remotive_DATA.csv, aparecerá na sua pasta.

Fase 2: A Inteligência (Analisando as Vagas Coletadas)

Nosso segundo script, skill_analyzer.py, lerá o arquivo CSV e descobrirá as tecnologias mais pedidas.

Crie o Arquivo: Na pasta principal, crie um novo arquivo chamado skill_analyzer.py.
Cole o Código:

# skill_analyzer.py
import pandas as pd
import nltk
import re
import datetime


try:
  nltk.data.find('tokenizers/punkt')
except nltk.downloader.DownloadError:
  print("Baixando pacote 'punkt' do NLTK (necessário na primeira execução)...")
  nltk.download('punkt')


SKILLS_DICIONARIO = [
  'python', 'django', 'flask', 'javascript', 'react', 'angular', 'vue', 'next.js',
  'typescript', 'html', 'css', 'sql', 'mysql', 'postgresql', 'nosql', 'api',
  'mongodb', 'docker', 'kubernetes', 'aws', 'azure', 'gcp', 'git', 'rest',
  'graphql', 'testes', 'tdd', 'automação', 'qa', 'scrum', 'agile', 'devops',
  'data science', 'machine learning', 'ml', 'ai', 'java', 'c#', '.net', 'php',
  'laravel', 'node.js', 'nodejs', 'ruby', 'rails', 'go', 'golang', 'kotlin',
  'swift', 'flutter', 'react native', 'backend', 'frontend', 'fullstack'
]


def extrair_skills(texto):
  if not isinstance(texto, str): return []
  texto = texto.lower()
  skills_encontradas = set()
  for skill in SKILLS_DICIONARIO:
      if re.search(r'\b' + re.escape(skill) + r'\b', texto):
          skills_encontradas.add(skill)
  return list(skills_encontradas)


def analisar_vagas(caminho_do_arquivo):
  try:
      df = pd.read_csv(caminho_do_arquivo)
  except FileNotFoundError:
      print(f"ERRO: O arquivo de entrada '{caminho_do_arquivo}' não foi encontrado.")
      print("Por favor, execute o script 'remotive_scraper.py' primeiro.")
      return
  print(f"Iniciando análise de skills do arquivo: {caminho_do_arquivo}")
  df['skills'] = df['titulo'].apply(extrair_skills)
  data_hoje = datetime.datetime.now().strftime("%Y-%m-%d")
  nome_arquivo_saida = f"vagas_remotive_analisadas_{data_hoje}.csv"
  df.to_csv(nome_arquivo_saida, index=False)
  print(f"Arquivo enriquecido salvo como '{nome_arquivo_saida}'")
  todas_as_skills = [skill for lista in df['skills'] for skill in lista]
  contagem_skills = pd.Series(todas_as_skills).value_counts()
  print("\n--- Top 15 Skills Mais Encontradas ---")
  print(contagem_skills.head(15))
  print("-" * 40)


if __name__ == "__main__":
  data_hoje = datetime.datetime.now().strftime("%Y-%m-%d")
  nome_arquivo_entrada = f"vagas_remotive_{data_hoje}.csv"
  analisar_vagas(nome_arquivo_entrada)

3 .Execute o Script: No seu terminal, digite python skill_analyzer.py.

2 .Verifique o Resultado: O terminal exibirá um ranking das skills mais pedidas e um novo arquivo, vagas_remotive_analisadas_DATA.csv, será criado.

Com estes passos, você construiu um pipeline de dados funcional: da coleta à análise. Este é um projeto de portfólio completo e impressionante.

4. Levando o Projeto para a Web: Flask e Django como Próximos Passos

Até agora, nosso projeto "Farol de Vagas" é um poderoso motor que roda localmente. Mas como o transformamos em um serviço acessível a todos? A resposta está no desenvolvimento web, e em Python, dois nomes reinam: Flask e Django.

O Primeiro Passo Online: Criando uma API com Flask

O caminho mais rápido para colocar nossos dados online é através de uma API. Flask é a ferramenta perfeita para isso. Por ser um microframework, ele é leve e nos permite criar uma API simples em poucas linhas de código para servir nossos dados analisados.

Exemplo de Código (api.py):

# api.py
from flask import Flask, jsonify
import pandas as pd


app = Flask(__name__)


@app.route("/api/vagas", methods=['GET'])
def obter_vagas_analisadas():
  try:
      # Nota: Em uma aplicação real, o nome do arquivo seria dinâmico.
      df = pd.read_csv("vagas_remotive_analisadas_2025-09-16.csv")
      resultado_json = df.to_dict(orient='records')
      return jsonify(resultado_json)
  except FileNotFoundError:
      return jsonify({"erro": "Arquivo de dados não encontrado."}), 404


if __name__ == '__main__':
  app.run(debug=True)

Com este script, criamos um "endereço" na web que entrega nossos dados em formato JSON, pronto para ser consumido por um painel visual (dashboard).

A Evolução: Construindo uma Plataforma Completa com Django

Se o "Farol de Vagas" crescesse, precisando de contas de usuário, alertas por e-mail e um painel administrativo, Django seria a escolha ideal. Por ser um framework com "baterias inclusas", ele já vem com soluções prontas para Models (banco de dados), Views (lógica), Templates (visual) e um sistema de usuários completo, acelerando imensamente o desenvolvimento de uma plataforma robusta.

Em resumo, Flask é perfeito para o primeiro passo, e Django para a evolução.

5. O Impacto na Carreira: De Estudante a Engenheiro de Dados Júnior

O que acabamos de construir é mais do que um "trabalho de faculdade". É uma demonstração prática de habilidades valorizadas pelo mercado:

Interagir com APIs web para coletar dados.
Estruturar e limpar dados com a biblioteca Pandas.
Realizar análises básicas para extrair informações.
Organizar um projeto com ambiente virtual e gerenciamento de dependências.

Essas são competências de um Analista ou Engenheiro de Dados Júnior. Com um projeto como este em mãos, a conversa em uma entrevista de emprego muda de "o que você aprendeu?" para "me explique como você construiu isso".

6. Um Foco Crítico: Recife, a Cidade dos Ilhados e a Tecnologia como Resposta

Para finalizar, quero que o nosso projeto transcenda. Quero que ele se torne uma resposta, ainda que pequena, a uma das feridas mais abertas da nossa cidade. Todo recifense conhece o sentimento de apreensão quando a chuva engrossa. O medo do caos, das ruas que se tornam rios, das perdas.

É uma indignação silenciosa que carregamos. Vivemos em um polo tecnológico, mas ficamos à mercê da sorte. E se a nossa frustração se transformasse em código? E se usássemos as mesmas ferramentas (requests para ouvir os alertas do clima e os relatos das pessoas, pandas para cruzar dados e prever riscos, Flask para exibir um mapa em tempo real) para construir um escudo digital para a nossa cidade?

É aqui que o projeto "Recife Resiliente" ganha vida, não como uma "ideia inovadora", mas como uma necessidade urgente. Um mapa que não mostra o caminho mais curto, mas o caminho seguro. Isso não é sobre tecnologia, é sobre devolver às pessoas o poder de decisão em dias de crise. O "Farol de Vagas" é como aprendemos a construir o barco e a navegar. O "Recife Resiliente" é a nossa primeira grande missão no oceano de problemas reais que nos cercam.

7. O Lançamento: Um Convite à Comunidade

O "Farol de Vagas" nasceu de uma necessidade pessoal, mas seu potencial é comunitário. Por isso, este projeto é open-source. O código que construímos é o MVP (Mínimo Produto Viável) e está pronto para ser publicado no GitHub. O convite está aberto para qualquer um que queira contribuir, seja adicionando novas fontes de vagas, melhorando o algoritmo de extração de skills, ou construindo o dashboard de visualização.

Conclusão: Do Código à Cidadania

A jornada que começamos com uma simples pergunta "o que devo estudar?" nos levou muito além da tecnologia. Ela nos mostrou que o verdadeiro poder do Python não está na sintaxe ou nas bibliotecas, mas na capacidade que ele nos dá de transformar angústia em análise, caos em clareza, e indignação em ação. Para o estudante de tecnologia, a linha de comando pode ser a mais poderosa ferramenta de cidadania. O desafio está lançado. O que você vai construir?

Referências

Fundamentos e Boas Práticas (Seção 1)

The Zen of Python (PEP 20). Acessível em: https://peps.python.org/pep-0020/
PEP 8 -- Style Guide for Python Code. Acessível em: https://peps.python.org/pep-0008/
Python Software Foundation. Documentação Oficial do Python 3. Acessível em: https://docs.python.org/3/

Bibliotecas e Aula Prática (Seções 2 e 3)

Requests: HTTP for Humans. Documentação Oficial. Acessível em: https://requests.readthedocs.io/
pandas: Python Data Analysis Library. Documentação Oficial. Acessível em: https://pandas.pydata.org/docs/
Natural Language Toolkit (NLTK). Documentação Oficial. Acessível em: https://www.nltk.org/
Remotive Developer API. Fonte de dados para o projeto "Farol de Vagas". Acessível em: https://remotive.com/api-documentation

Desenvolvimento Web (Seção 4)

Flask Documentation. Acessível em: https://flask.palletsprojects.com/
Django Documentation. Acessível em: https://www.djangoproject.com/

Impacto na Carreira e Mercado (Seção 5)

GeekHunter. "Relatório de Salários de Desenvolvedores no Brasil 2025". (Nota: Esta é uma referência representativa para dados salariais).

Foco Crítico em Recife (Seção 6)

APAC - Agência Pernambucana de Águas e Clima. Fonte de dados meteorológicos e de marés para o projeto "Recife Resiliente". Acessível em: http://www.apac.pe.gov.br/

Imagens

https://www.leiaja.com/noticias/2025/02/05/confira-os-pontos-mais-criticos-de-alagamento-no-recife/
https://surubimnews.com.br/chuva-causa-alagamentos-e-transtornos-no-recife/