1  Arrumando as coisas para começar a trabalhar com Python

1.1 O que você saberá se você ler todo este capítulo?

  1. 🏆 Você irá testar logo de cara o seu primeiro algoritmo!
  2. Python é legal, mas não é perfeito. Não seja fanboy/fangirl de linguagem de programação!
  3. Muita gente em universidades e empresas usam Python porque é simples, rápido e tem uma comunidade grande.
  4. Como configurar o seu computador para começar a trabalhar com Python (mais especificamente, com o PyCharm), e o que é o PyCharm e uma IDE.
  5. Você irá testar diferentes funções/comandos em Python dentro do PyCharm.

📚 Sobre este capítulo: Este é um capítulo de configuração e preparação do ambiente. Você verá um código de exemplo (Counter-Strike), mas não precisa entendê-lo completamente agora. O objetivo é fazer você executar seu primeiro programa e sentir o que é trabalhar com Python. A programação de verdade (variáveis, loops, condicionais) começa no Capítulo 2!

1.2 Por que Python?

Olha, se você está aqui é porque provavelmente já ouviu falar que Python é “a linguagem do momento”. E sabe o que? Não é exagero!

Python é uma das linguagens mais usadas pelas empresas hoje em dia, e não é à toa. É simples de aprender (principalmente se você nunca programou), tem uma comunidade gigante que está sempre criando coisas novas, e funciona para quase tudo: desde calcular quanto você gastou no mês até criar inteligência artificial que reconhece gatos em fotos.

1.2.1 O que torna Python especial?

É uma linguagem de alto nível - isso significa que você escreve código quase como se estivesse falando com o computador em português. Em vez de ter que explicar para o computador onde cada bit vai na memória (como acontece com linguagens mais “baixas”), você pode simplesmente dizer “pega essa lista e me mostra o maior número”.

Tem bibliotecas para tudo - imagina que você quer fazer um gráfico. Em vez de ter que programar do zero como desenhar uma linha, você usa uma biblioteca que já faz isso para você. É como ter uma caixa de ferramentas gigante onde alguém já fez todas as ferramentas que você pode precisar.

1.2.2 Python no mundo real

A primeira imagem de um buraco negro que a humanidade conseguiu gerar? Python. O algoritmo que recomenda vídeos no YouTube? Python. Os sistemas que processam milhões de transações por segundo no PayPal? Python.

E olha só essa imagem histórica:

Buraco negro M87

1.2.3 Empresas que usam Python (e você nem sabia!)

Google - A gigante das buscas usa Python para praticamente tudo: desde analisar quando algo dá errado até criar inteligência artificial. E olha só: o YouTube (que é da Google) também roda em Python! Então toda vez que você assiste um vídeo de gato, pode agradecer ao Python.

NASA - Sim, a NASA! Eles usam Python para processar imagens do espaço, analisar dados de missões e até controlar algumas partes das naves espaciais. Se Python é bom o suficiente para explorar o espaço, deve ser bom o suficiente para você também, né?

Instagram - Aquela rede social onde todo mundo posta foto da comida? Python. O Spotify que você usa para escutar música? Python. O Dropbox onde você guarda seus arquivos? Python. O Reddit onde você perde horas lendo discussões aleatórias? Python também!

1.2.4 Mas Python não é só para web…

Inteligência Artificial - Empresas como Amazon, Netflix e Airbnb usam Python com bibliotecas como NumPy, Pandas e Scikit-learn para criar sistemas que aprendem sozinhos. É assim que a Netflix sabe que você vai gostar daquela série que você nem sabia que existia.

Automação - Python é ótimo para automatizar tarefas chatas. Desde fazer backup dos seus arquivos até analisar milhares de logs de sistema. É como ter um assistente virtual que nunca reclama e trabalha 24 horas por dia.

1.2.5 O que isso significa para você?

Se você aprender Python, estará aprendendo a mesma linguagem que essas empresas gigantes usam. Não é garantia de emprego (infelizmente), mas é um bom começo!

1.2.6 Nas universidades (onde tudo começou)

Se você está na faculdade, provavelmente já ouviu falar de Python nas aulas. E não é à toa! As universidades adoram Python porque:

É fácil de ensinar - Os professores não precisam passar 3 meses explicando conceitos complicados antes de você conseguir fazer algo útil. Em Python, você consegue fazer um programa que realmente funciona nas primeiras aulas.

É usado em pesquisa - Ciência de dados, inteligência artificial, análise de dados… praticamente toda pesquisa moderna usa Python em algum momento. Se você quer seguir carreira acadêmica, Python é quase obrigatório.

Prepara para o mercado - Diferente de algumas linguagens que você aprende na faculdade e nunca mais usa, Python é exatamente o que as empresas estão procurando.

1.2.7 Python também é usado em…

Finanças - Bancos e corretoras usam Python para analisar riscos, detectar fraudes e fazer trading automatizado.

Marketing - Empresas usam Python para analisar comportamento de clientes, otimizar campanhas e personalizar ofertas.

Automação - Desde fazer backup de arquivos até processar planilhas gigantes, Python é perfeito para automatizar tarefas chatas.

1.2.8 Mas calma lá, não é perfeito!

Olha, eu gosto de Python, mas não sou fanboy. Python tem seus problemas:

  • É mais lento que linguagens como C ou C++. Para aplicações que precisam de performance extrema, Python pode não ser a melhor escolha.
  • Pode dar dor de cabeça quando você atualiza de uma versão para outra. Às vezes coisas que funcionavam param de funcionar.
  • Não é ideal para jogos - a maioria dos jogos comerciais é feita em outras linguagens.

Mas para aprender programação e para a maioria dos projetos reais? Python é uma excelente escolha!

💡 Dica: Se quiser ver o ranking das linguagens mais populares, dá uma olhada aqui. Spoiler: Python está bem no topo!

1.3 Qual versão do Python usar? (A saga das versões)

Antes de começarmos, preciso te avisar sobre uma coisa: Python tem duas “famílias” principais, e escolher a errada pode dar dor de cabeça.

1.3.1 Python 2 vs Python 3: A grande divisão

Python 2.x - A versão antiga, que parou de ser atualizada em 2020. É como usar um iPhone 4 em 2024: tecnicamente funciona, mas ninguém mais faz apps para ele.

Python 3.x - A versão moderna e atual. É a que você quer usar. É como usar um iPhone atual: tem tudo que você precisa e vai continuar sendo atualizado.

⚠️ Importante: Se você encontrar algum tutorial na internet que usa Python 2, ignore. Python 2 está morto e enterrado. Use Python 3!

1.3.2 Qual versão do Python 3 escolher?

Dentro do Python 3, existem várias versões: 3.8, 3.9, 3.10, 3.11, 3.12… É como escolher qual modelo de carro você quer.

Para este material, recomendo Python 3.10 ou superior. Essas versões são:

  • Estáveis (não quebram do nada)
  • Têm suporte de longo prazo
  • São compatíveis com todas as bibliotecas modernas

💡 Dica: Se você já tem Python instalado, não se preocupe! Dificilmente você terá problemas seguindo este material. Só evite Python 2.x.

1.3.3 Como descobrir qual versão você tem?

Abra o terminal/prompt de comando e digite:

No Windows:

python --version

ou

py --version

No Mac/Linux:

python3 --version

Você deverá ver algo como Python 3.10.5 ou Python 3.11.2. Se aparecer um número começando com 3, está tudo certo!

🤔 Por que às vezes é py no Windows? No Windows, você pode usar tanto python quanto py. O comando py é o Python Launcher for Windows, uma ferramenta que a Microsoft criou para facilitar o gerenciamento de múltiplas versões do Python no mesmo sistema. Ele automaticamente encontra e executa a versão mais recente do Python instalada, evitando problemas de PATH. Use py quando não souber qual versão usar, ou python quando quiser usar uma versão específica que está no seu PATH.

1.4 Instalando (ou não) o Python

Você pode usar o Word para escrever textos, o PowerPoint para fazer apresentações, a Steam para comprar jogos para o computador e o Chrome para navegar na internet. Mas, o que você usaria para trabalhar com algoritmos? Para isso usamos as IDEs.

1.4.1 Mas o que é uma IDE?

Uma IDE (Integrated Development Environment) é como um “Word para programadores”. Assim como você usa o Word para escrever documentos, a IDE é onde você escreve código. Mas não é só isso!

Uma IDE boa faz muito mais:

  • Escreve o código: óbvio, né?
  • Detecta erros: “Ô, você digitou errado aqui!”
  • Executa o código: roda seu programa
  • Organiza arquivos: mantém tudo no lugar certo
  • Mostra resultados: exibe o que seu código faz

É tipo ter um assistente que te ajuda a programar sem precisar lembrar de mil comandos diferentes.

1.4.2 Por que Python precisa de uma IDE?

Python é uma linguagem “interpretada” - isso significa que ele lê seu código linha por linha e executa na hora. É diferente de linguagens como C++, que precisam ser “compiladas” (transformadas) antes de funcionar.

Mas mesmo sendo simples, programar só com um bloco de notas é como tentar fazer uma cirurgia com um canivete suíço: dá para fazer, mas não é a melhor ideia. A IDE te dá as ferramentas certas para o trabalho.

1.4.3 Quais IDEs usar?

O Python possui várias IDEs disponíveis como, por exemplo, o PyCharm, Visual Studio Code, e Spyder. Para desenvolver algoritmos em Python também é possível desenvolver códigos direto do navegador com soluções como o repl.it e Google Colab.

A recomendação é a de que você instale o PyCharm para fazer os seus algoritmos. Se você está interessado em seguir em frente com o PyCharm e gostaria de saber como instalá-lo, recomendo acessar este passo-a-passo que eu criei especificamente para isso.

A partir de agora eu assumirei que você já está com o PyCharm (ou alguma outra alternativa) já instalada no seu computador. Se tudo deu certo, você terá uma janela com essa carinha:

Tela inicial do PyCharm

1.5 O que são Ambientes Virtuais e por que usá-los?

📌 Quando ler esta seção: Esta é uma informação importante para trabalhar em projetos reais, mas não é necessária para seguir os primeiros capítulos deste livro. Você pode pular esta seção por agora e voltar quando começar a trabalhar em projetos próprios ou quando for instalar bibliotecas externas.

1.5.1 O problema que você ainda não sabe que tem

Imagine que você está trabalhando em dois projetos diferentes:

  • Projeto A: usa a biblioteca X na versão 1.0
  • Projeto B: usa a biblioteca X na versão 2.0

Se você instalar tudo no mesmo lugar, um projeto vai “quebrar” o outro! É aí que entram os ambientes virtuais (virtual environments, ou “venv”).

1.5.2 O que é um ambiente virtual?

Um ambiente virtual é como criar uma “caixinha isolada” para cada projeto, onde cada um tem suas próprias bibliotecas e versões, sem interferir nos outros projetos ou no sistema.

💡 Analogia: Pense em um ambiente virtual como ter um armário separado para roupas de cada estação do ano. As roupas de inverno não se misturam com as de verão, e você pode organizar cada armário do jeito que quiser!

1.5.3 Por que isso é importante?

Sem ambientes virtuais, você pode ter problemas como:

  • “Funcionava na minha máquina!”: seu código funciona, mas não no computador do colega
  • Conflitos de versão: uma biblioteca atualizada quebra um projeto antigo
  • Bagunça geral: não saber qual biblioteca está sendo usada onde

1.5.4 Como criar um ambiente virtual?

1. Crie uma pasta para o seu projeto:

mkdir meu_projeto
cd meu_projeto

2. Crie o ambiente virtual:

No Windows:

python -m venv venv

No Mac/Linux:

python3 -m venv venv

Isso cria uma pasta chamada venv dentro do seu projeto com tudo que é necessário.

3. Ative o ambiente virtual:

No Windows (PowerShell):

.\venv\Scripts\Activate.ps1

No Windows (CMD):

.\venv\Scripts\activate.bat

No Mac/Linux:

source venv/bin/activate

Quando ativado, você verá (venv) no início da linha do seu terminal, indicando que está dentro do ambiente virtual.

4. Para desativar:

deactivate

⚠️ Importante: Sempre ative o ambiente virtual antes de trabalhar no seu projeto! Isso garante que você está usando as bibliotecas corretas.

1.5.5 Por que isso é importante?

  • Isolamento: Cada projeto tem suas próprias dependências
  • Reprodutibilidade: Outros desenvolvedores podem recriar o mesmo ambiente
  • Sem conflitos: Versões diferentes de bibliotecas não interferem entre si
  • Organização: Seu sistema operacional fica limpo e organizado

💡 Dica profissional: Sempre crie um arquivo requirements.txt com as bibliotecas do seu projeto. Isso facilita compartilhar o projeto com outras pessoas!

TipQuer praticar seus primeiros passos no Python?

Agora que você configurou seu ambiente, criei o batel.tech, um site gratuito com exercícios práticos de Python para complementar seus estudos. Lá você encontra:

  • Exercícios progressivos sobre configuração de ambiente e primeiros passos
  • Feedback imediato para suas soluções
  • Acompanhamento por IA para te ajudar quando travar
  • 💬 Comunidade no Discord para trocar ideias

É um projeto pessoal meu (Prof. Wellington) para te dar mais insumos e ajudar na jornada Python! 🐍

{#environment:sourcecodefile}

1.6 Começando com código: colocando a mão na massa

Sejamos sinceros: o legal mesmo é colocar a mão na massa logo de cara, não é mesmo? O que acha de um algoritmo em Python que gera uma tabela de um campeonato de Counter-Strike?

1.6.1 O que você vai ver aqui?

Este código vai fazer algo bem legal: calcular automaticamente a tabela de classificação de um campeonato de Counter-Strike. Ele vai:

  • Pegar os resultados dos jogos
  • Calcular pontos (3 para vitória, 1 para empate)
  • Ordenar os times por pontuação
  • Mostrar uma tabela bonita

1.6.2 Por que mostrar código “difícil” logo de cara?

Boa pergunta! A ideia é você ver que Python pode fazer coisas legais desde o começo. É como mostrar para alguém que nunca dirigiu um carro como é uma corrida de Fórmula 1 - não vai aprender a dirigir, mas vai ver o que é possível!

⚠️ Importante: Você ainda NÃO precisa entender todo este código linha por linha! Este exemplo serve para você: 1. Ver como é um programa Python “de verdade” 2. Executar seu primeiro código e ver funcionando 3. Se familiarizar com a aparência do código Python 4. Perder o medo de código “grande”

Os conceitos usados aqui (listas, dicionários, loops, condicionais) serão explicados nos próximos capítulos. Por enquanto, apenas execute e observe o resultado!

1.6.3 Como ler código Python (dica rápida)

Antes de ver o código, uma dica: em Python, tudo que vem depois de # é um comentário - uma explicação que o Python ignora. É como uma nota que você deixa para si mesmo (ou para outros programadores) explicando o que o código faz.

💡 Dica importante: Este código pode parecer complexo agora, mas não se preocupe! Você não precisa entender cada linha neste momento. O objetivo é ver como Python funciona e perder o medo de código “grande”. Os conceitos usados aqui (listas, dicionários, loops, condicionais) serão explicados nos próximos capítulos.

Agora vamos ver o código do campeonato de Counter-Strike:

Streamer da Twitch.tv ‘Gaules’
Code
# ====================================================================
# CAMPEONATO DE COUNTER-STRIKE - TABELA DE CLASSIFICAÇÃO
# ====================================================================

# Lista com os nomes de todos os times participantes do campeonato
times = ['Astralis', 'Na`Vi', 'G2', 'Vitality', 'Liquid', 'FURIA']

# Lista contendo todos os resultados dos jogos
# Formato: [time1, time2, placar_time1, placar_time2]
# Exemplo: ['Astralis', 'G2', 16, 10] significa que Astralis venceu G2 por 16 a 10
resultados = [
    ['Astralis', 'G2', 16, 10],
    ['Na`Vi', 'Vitality', 16, 8],
    ['Liquid', 'FURIA', 16, 14],
    ['Astralis', 'Liquid', 16, 13],
    ['G2', 'FURIA', 16, 12],
    ['Vitality', 'Astralis', 16, 14],
    ['Na`Vi', 'Liquid', 16, 11],
    ['FURIA', 'Vitality', 16, 13],
    ['Astralis', 'Na`Vi', 16, 12],
    ['G2', 'Vitality', 16, 14],
    ['Liquid', 'Astralis', 16, 12],
    ['FURIA', 'Na`Vi', 16, 14],
]

# Criamos um dicionário para guardar as estatísticas de cada time
# Para cada time, guardamos: pontos, número de jogos e número de vitórias
# Começamos tudo zerado
pontuacao = {time: {'pontos': 0, 'jogos': 0, 'vitorias': 0} for time in times}

# Agora vamos processar cada jogo e atualizar a pontuação
for jogo in resultados:
    # Separamos as informações do jogo em variáveis
    time1, time2, resultado1, resultado2 = jogo
    
    # Verificamos quem ganhou e atribuímos os pontos
    if resultado1 > resultado2:
        # Time 1 venceu: ganha 3 pontos e conta como vitória
        pontuacao[time1]['pontos'] += 3
        pontuacao[time1]['vitorias'] += 1
    elif resultado1 < resultado2:
        # Time 2 venceu: ganha 3 pontos e conta como vitória
        pontuacao[time2]['pontos'] += 3
        pontuacao[time2]['vitorias'] += 1
    else:
        # Empate: cada time ganha 1 ponto
        pontuacao[time1]['pontos'] += 1
        pontuacao[time2]['pontos'] += 1
    
    # Independente do resultado, ambos os times jogaram mais uma partida
    pontuacao[time1]['jogos'] += 1
    pontuacao[time2]['jogos'] += 1

# Ordenamos os times por pontos (maior primeiro) e depois por vitórias
# O "-" antes significa ordem decrescente (do maior para o menor)
classificacao = sorted(
    pontuacao.items(), 
    key=lambda x: (-x[1]['pontos'], -x[1]['vitorias'])
)

# Agora vamos exibir a tabela de forma bonita e organizada
print('Tabela de classificação:')
print(f"{'Time':<15} {'Pontos':<10} {'Vitórias':<10} {'Jogos':<10}")
print('-' * 45)  # Linha separadora

# Percorremos cada time da classificação e mostramos suas estatísticas
for time, estatisticas in classificacao:
    print(f"{time:<15} {estatisticas['pontos']:<10} "
          f"{estatisticas['vitorias']:<10} {estatisticas['jogos']:<10}")
Tabela de classificação:
Time            Pontos     Vitórias   Jogos     
---------------------------------------------
Astralis        9          3          5         
Na`Vi           6          2          4         
G2              6          2          3         
Liquid          6          2          4         
FURIA           6          2          4         
Vitality        3          1          4         

1.6.4 Comparando IDEs e Editores: Qual escolher?

Existem várias opções para desenvolver em Python. Cada uma tem suas vantagens e é melhor para situações diferentes. Vamos conhecer as principais:

1.6.4.1 PyCharm (Recomendado para iniciantes)

Vantagens:

  • ✅ Tudo em um só lugar (depurador, terminal, Git, etc.)
  • ✅ Detecção automática de erros muito boa
  • ✅ Ótimo para projetos grandes
  • ✅ Versão Community gratuita e completa

Desvantagens:

  • ❌ Mais pesado (usa mais memória RAM)
  • ❌ Pode ser confuso no início (muitos botões e opções)

Quando usar: Projetos completos, aplicações web, quando você quer tudo configurado automaticamente.


1.6.4.2 Visual Studio Code (VS Code)

Vantagens:

  • ✅ Muito leve e rápido
  • ✅ Altamente customizável com extensões
  • ✅ Ótimo para trabalhar com várias linguagens
  • ✅ Grande comunidade e muitos tutoriais

Desvantagens:

  • ❌ Precisa instalar extensões manualmente
  • ❌ Configuração inicial pode levar tempo

Quando usar: Se você já programa em outras linguagens, quer algo rápido, ou tem um computador mais simples.


1.6.4.3 Jupyter Notebook / JupyterLab

Vantagens:

  • ✅ Perfeito para análise de dados e ciência de dados
  • ✅ Executa código em células (testa pequenos trechos)
  • ✅ Mistura código, texto e gráficos no mesmo lugar
  • ✅ Funciona no navegador

Desvantagens:

  • ❌ Não é ideal para projetos grandes
  • ❌ Não tem algumas ferramentas de depuração avançadas

Quando usar: Análise de dados, machine learning, experimentos, relatórios com código.

💡 Nota: Este material que você está lendo foi feito em Jupyter Notebook!


1.6.4.4 Google Colab

Vantagens:

  • ✅ Não precisa instalar nada (100% online)
  • ✅ Acesso gratuito a GPUs para machine learning
  • ✅ Fácil compartilhamento
  • ✅ Baseado em Jupyter Notebook

Desvantagens:

  • ❌ Precisa de internet
  • ❌ Sessão expira após inatividade
  • ❌ Não serve para projetos complexos

Quando usar: Estudar de qualquer lugar, testar códigos rapidamente, aprender sem instalar nada.


1.6.4.5 IDLE (Vem com Python)

Vantagens:

  • ✅ Já vem instalado com Python
  • ✅ Muito simples e leve
  • ✅ Bom para iniciantes absolutos

Desvantagens:

  • ❌ Muito básico, faltam recursos modernos
  • ❌ Interface desatualizada

Quando usar: Primeiros passos, testes rápidos, computadores muito simples.


1.6.5 E então, qual eu uso?

Minha recomendação por perfil:

Perfil IDE Recomendada
Iniciante total em programação PyCharm Community
Já programa em outras linguagens VS Code
Foco em ciência de dados / análise Jupyter Lab ou Google Colab
Computador com pouca memória RAM VS Code ou IDLE
Quer testar sem instalar nada Google Colab

💡 Dica: Você pode (e deve!) experimentar várias opções. Muitos profissionais usam PyCharm para projetos e Jupyter para análises!

Viu o resultado acima? Ele gerou uma tabela toda bonita contendo os times já ordenados pela pontuação. Isso poderia servir para qualquer outro campeonato: futebol, sinuca ou qualquer outra coisa que poderia entrar neste formato.

Quer testar isso? Volte lá no PyCharm e apague todo o conteúdo que está naquela aba main.py. Este arquivo main.py possui o seu código-fonte, e é isso que iremos substituir.

Código-fonte: É o arquivo que contém o código na sua forma original, antes de ser compilado ou interpretado, e é através dele que os desenvolvedores podem criar, editar e aprimorar os programas.

Você deverá ficar com algo assim:

Tela inicial do PyCharm com o código-fonte de exemplo removido

Agora, vamos copiar e colar o código acima dentro desta tela. Você deve ficar com algo assim:

Tela inicial do PyCharm com o nosso código-fonte adicionado

Agora é hora de rodar (executar) o código. Você pode fazer isso de algumas formas:

  1. Apertar Shift e F10 no seu teclado;
  2. Clicando no botão de Run (triângulo verde no canto superior direito da tela, destacado abaixo);
  3. No menu superior, clicando em Run > Run '$ARQUIVO' (neste caso, seria Run > Run 'main').

Botão para rodar o código

Com isso, o seu código deve executar e os resultados aparecerão na parte inferior do PyCharm. Veja a imagem abaixo:

Resultado da execução do algoritmo mostrando a tabela de classificação com 6 equipes e as colunas pontos, vitórias e jogos.

Você também deve ter notado a mensagem final Process finished with exit code 0. Isto significa que o código rodou sem problemas. Agora, o que aconteceria se você digitasse qualquer outra coisa no meio do arquivo? Por exemplo: na linha 24, troque o texto resultados por abc. Deve ficar assim:

Linha 24 do algoritmo editada. O texto ‘resultados’ foi substituído pelo texto ‘abc’. Há um realce em vermelho sob o texto ‘abc’.

Notou uma linha em ziguezague (ou uma “cobrinha”) embaixo do abc? O PyCharm ajuda a detectar erros para te mostrar com antecedência. Se você passar o mouse em cima do abc verá que aparecerá um texto com a mensagem Unresolved reference 'abc'.

Isto, traduzindo para o português, significa Referência 'abc' não-resolvida. Reescrevendo de forma mais clara: Você tá querendo usar um negócio chamado 'abc' que não existe em nenhum outro lugar no código. Tá certo isso?. O PyCharm está avisando que vai dar erro isso aí. O que acontece se ignorarmos este erro e tentarmos rodar o código mesmo assim (seja clicando no triângulo verde, indo no menu Run ou apertando Shift + F10)? Olha só:

Mensagem de erro com o texto ‘NameError: name abc is not defined’.

Parece confuso, mas não é. O Python é bem amigável quanto às mensagens de erro. Vamos traduzir por partes:

  1. Traceback (most recent call last): “Viu, esse aqui foi o último erro que achei e que fez o código parar de funcionar, ó:”
  2. File "$ARQUIVO", line $LINHA, in <module>: “O erro aconteceu aqui ó, nesse $ARQUIVO (no nosso caso, no main.py) e nessa $LINHA (no nosso caso, na linha 24), entendeu?”
  3. for jogo in abc:: “Tá com preguiça de abrir aquela linha 24 para ver o que tem lá? Não tem problema: a linha 24 tinha isso aqui ó.”
  4. NameError: name 'abc' is not defined: “O erro que teve aqui foi um erro de nome. No caso, não achei em lugar nenhum alguém com o nome de ‘abc’. O que é isso? O que eu deveria fazer com isso? Me ajuda aí.”

Diferentes erros terão diferentes tratamentos. Ou seja, não será sempre que aparecerá um NameError, mas as explicações farão sentido para você ao longo do caminho. Para te ajudar, também criei uma seção com os tratamentos mais comuns aos erros de código para você.

1.6.6 Arquivos do Python (.py) e o Python Console

Agora que você já viu como executar um arquivo Python completo, vamos falar sobre uma ferramenta muito útil: o Python Console.

1.6.7 O que é o Python Console?

O console do Python é como uma “calculadora de código”. Você digita um comando, aperta Enter, e ele executa na hora, mostrando o resultado imediatamente. É perfeito para testar coisas rapidamente.

1.6.8 Arquivo .py vs Console: qual usar quando?

Arquivo .py (como o main.py):

  • ✅ Salva seu código permanentemente
  • ✅ Pode executar várias vezes
  • ✅ Melhor para programas completos
  • ✅ Pode ter milhares de linhas
  • ❌ Precisa salvar e executar todo o código

Console Python:

  • ✅ Execução imediata
  • ✅ Perfeito para testar ideias
  • ✅ Ótimo para aprender e experimentar
  • ✅ Mostra resultado na hora
  • ❌ Perde tudo quando fechar
  • ❌ Não serve para programas grandes

1.6.9 Analogia culinária

Fazendo uma comparação com o mundo real:

  • Arquivo .py = receita de bolo escrita em um caderno. Você pode salvar, consultar depois, e fazer o bolo quantas vezes quiser
  • Console Python = estar na cozinha experimentando temperos. Você testa um pouquinho de sal, vê se está bom, testa um pouquinho de pimenta… mas não vai escrever a receita completa ali

1.6.10 Quando usar cada um?

  • Use o arquivo .py para programas sérios, exercícios, projetos
  • Use o console para testar comandos, experimentar, aprender, tirar dúvidas rápidas

Botão ‘Python Console’ realçado dentro do PyCharm

Quer testar o Python Console? Digite o comando abaixo dentro do console e logo após os >>>:

print("Alô alô, testando.")

Depois de digitar, aperte Enter. Deverá aparecer a mensagem Alô alô, testando. logo abaixo no console. Deve aparecer algo desse jeito:

Comando print(‘Alô alô, testando.’) aparecendo no Python Console.

Resultado da função print(‘Alô alô, testando.’) no Python Console. A frase ‘Alô alô, testando.’ apareceu na tela.

A função print é responsável por mostrar uma mensagem na tela. A forma de escrever é sempre a mesma: o texto print, seguido pela abertura de parênteses e, dentro dos parênteses e circundados por aspas simples ou duplas, o texto que você quer mostrar. Os exemplos abaixo são permitidos:

print("Alô alô, testando.")
print('Alô alô, testando.')

Assim não seria uma boa prática de formatação/organização:

print ("Alô alô, testando.")  # veja o espaço entre `print` e `(`
print( "Alô alô, testando." ) # veja o espaço antes e depois do fechamento das aspas

E isso aqui daria um erro, já que você começaria de um jeito (aspas simples) e terminaria de outro (aspas duplas):

print('Alô alô, testando.")   

1.7 Problemas Comuns e Como Resolver (Troubleshooting)

🔧 Sobre esta seção: Esta é uma seção de referência. Você não precisa ler tudo agora! Volte aqui quando encontrar algum problema durante a instalação ou configuração. Use o índice abaixo para encontrar rapidamente seu problema.

Toda pessoa que programa já enfrentou problemas de instalação e configuração. Aqui estão os problemas mais comuns e suas soluções:

Índice rápido:

  • Problema 1: Python não reconhecido
  • Problema 2: Erro ao criar ambiente virtual
  • Problema 3: Permission Denied (Windows)
  • Problema 4: pip não funciona
  • Problema 5: PyCharm não encontra Python
  • Problema 6: Antivírus bloqueando
  • Problema 7: Jupyter não abre
  • Problema 8: Python 2 vs Python 3
  • Problema 9: Pacote não encontrado
  • Problema 10: PyCharm lento

1.7.1 Problema 1: “Python não é reconhecido como comando”

Sintoma:

'python' não é reconhecido como um comando interno
ou externo, um programa operável ou um arquivo em lotes.

Soluções:

No Windows:

  1. Verifique se o Python está no PATH:
    • Abra o Prompt de Comando
    • Tente py --version ao invés de python --version
    • Se py funcionar, use sempre py ao invés de python
  2. Adicionar Python ao PATH manualmente:
    • Abra o “Painel de Controle” → “Sistema” → “Configurações avançadas do sistema”
    • Clique em “Variáveis de Ambiente”
    • Em “Variáveis do sistema”, encontre “Path” e clique em “Editar”
    • Adicione o caminho da instalação do Python (geralmente C:\Users\SeuUsuario\AppData\Local\Programs\Python\Python311\)
    • Adicione também a pasta Scripts: C:\Users\SeuUsuario\AppData\Local\Programs\Python\Python311\Scripts\
    • Clique em “OK” e reinicie o terminal
  3. Reinstale o Python:
    • Baixe novamente do python.org
    • MARQUE a opção “Add Python to PATH” durante a instalação

No Mac/Linux:

  • Use python3 ao invés de python
  • Se não funcionar, instale via gerenciador de pacotes:
    • Mac: brew install python3
    • Linux (Ubuntu/Debian): sudo apt-get install python3

1.7.2 Problema 2: Erro ao criar ambiente virtual

Sintoma:

No module named 'venv'

Solução:

No Ubuntu/Debian:

sudo apt-get install python3-venv

No Windows:

  • Reinstale o Python garantindo que todos os componentes estão marcados

1.7.3 Problema 3: “Permission Denied” ao ativar ambiente virtual (Windows)

Sintoma:

... cannot be loaded because running scripts is disabled on this system.

Solução:

  1. Abra o PowerShell como Administrador

  2. Execute:

    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
  3. Digite S (Sim) para confirmar

  4. Tente ativar o ambiente virtual novamente

Alternativa: Use o Command Prompt (CMD) ao invés do PowerShell:

venv\Scripts\activate.bat

1.7.4 Problema 4: pip não funciona

Sintoma:

'pip' não é reconhecido como um comando

Soluções:

  1. Use python -m pip:

    python -m pip install nome-do-pacote
    # ou no Windows:
    py -m pip install nome-do-pacote
  2. Verifique se o pip está instalado:

    python -m ensurepip --upgrade
  3. Atualize o pip:

    python -m pip install --upgrade pip

1.7.5 Problema 5: PyCharm não encontra o Python

Sintoma: Ao criar projeto, aparece erro “No Python interpreter selected”

Solução:

  1. No PyCharm, vá em File → Settings (ou PyCharm → Preferences no Mac)
  2. Navegue até Project → Python Interpreter
  3. Clique no ícone de engrenagem → Add
  4. Selecione a instalação do Python no seu sistema

1.7.6 Problema 6: Antivírus bloqueando Python/PyCharm

Sintoma:

  • Instalação muito lenta
  • Arquivos não são criados
  • Erro ao executar código

Solução:

  1. Adicione exceções no seu antivírus para:
    • Pasta de instalação do Python
    • Pasta de instalação do PyCharm
    • Pastas dos seus projetos
  2. Temporariamente desabilite o antivírus durante a instalação

1.7.7 Problema 7: Jupyter Notebook não abre no navegador

Sintoma: Comando jupyter notebook executa mas navegador não abre

Solução:

  1. Copie a URL que aparece no terminal (algo como http://localhost:8888/?token=...)

  2. Cole manualmente no navegador

  3. Ou force abrir:

    jupyter notebook --no-browser

    E copie a URL gerada


1.7.8 Problema 8: Diferença entre Python 2 e Python 3

Sintoma: Código não funciona ou sintaxe estranha

Solução:

  • SEMPRE use Python 3.x
  • Se python --version mostrar 2.x, use python3 ao invés de python
  • Python 2 não é mais mantido desde 2020

1.7.9 Problema 9: Pacote instalado mas não é encontrado

Sintoma:

ModuleNotFoundError: No module named 'nome_pacote'

Soluções:

  1. Verifique se o ambiente virtual está ativado:

    • Deve aparecer (venv) no início da linha do terminal
    • Se não aparecer, ative: .\venv\Scripts\activate (Windows) ou source venv/bin/activate (Mac/Linux)
  2. Instale no ambiente correto:

    # Ative o venv primeiro, depois:
    pip install nome_pacote
  3. Verifique qual Python está sendo usado:

    python -c "import sys; print(sys.executable)"

1.7.10 Problema 10: Computador lento ao usar PyCharm

Sintoma: PyCharm trava, muito lento, consome muita RAM

Soluções:

  1. Use VS Code ao invés do PyCharm (mais leve)
  2. Aumente a memória do PyCharm:
    • Help → Change Memory Settings
    • Aumente para 2GB ou mais (se tiver RAM disponível)
  3. Desabilite plugins desnecessários:
    • File → Settings → Plugins
    • Desabilite o que não usar
  4. Use a versão Community (mais leve que a Professional)

1.7.11 Recursos para buscar ajuda

Quando nenhuma das soluções acima funcionar:

  1. Stack Overflow em Português: https://pt.stackoverflow.com/
  2. Python Brasil no Telegram: https://t.me/pythonbr
  3. Documentação oficial do Python: https://docs.python.org/pt-br/3/
  4. Google com termos em inglês: geralmente tem mais resultados

💡 Dica de ouro: Ao buscar erro no Google, copie a mensagem de erro exata (sem caminhos específicos do seu computador) e coloque entre aspas na busca!

Quer testar mais exemplos? Digite os comandos abaixo, sempre apertando Enter no final de cada comando. Fique tranquilo se alguns desses conceitos não estiverem muito claros: veremos com mais calma adiante.

  • print("Olá de novo!"): exibe uma outra mensagem na tela. No caso, “Olá de novo!”.
  • 5 + 1: soma cinco mais um e mostra o resultado (6) na tela.
  • "Olá" + " " + "de novo!": concatena os textos (strings) “Olá” e “de novo!” com um espaço entre eles e exibe o resultado na tela.
  • len("Python"): retorna o comprimento (length, ou total de caracteres) da string “Python”.
  • type(5): retorna o tipo de dado do número 5. Como 5 é um número inteiro (integer), aparecerá int na tela.
  • type("Python"): retorna o tipo de dado do valor “Python”. Como ele é um texto (string), aparecerá str na tela.
  • max([1, 7, 2, 3]): retorna o maior número da lista [1, 7, 2, 3]. No caso, 7.
  • min([1, 7, 2, 3]): retorna o menor número da lista [1, 7, 2, 3]. No caso, 1.
  • sum([1, 7, 2, 3]): retorna a soma dos números da lista [1, 7, 2, 3]. No caso, 13.
  • round(3.14159265359, 2): arredonda o número pi para 2 casas decimais. No caso, 3.14.
  • bool(1): retorna True, pois 1 representa o valor verdadeiro em Python quando estamos tratando de operações binárias (isto é, verdadeiro/falso, ligado/desligado).
  • bool(0): retorna False, pois 0 representa o valor falso em Python.
  • str(123): converte o número 123 para uma string. No caso, resultará em "123" (observe as aspas que explicitam que trata-se de um texto, e não de um número).
  • 'Olá de novo!'.split(): divide a string em uma lista de palavras toda vez que um espaço for encontrado. No caso, retornará ['Olá', 'de', 'novo!'].
  • "wellington".capitalize(): retorna a string "Wellington". Observe que a primeira letra está em maiúscula.
  • abs(-5): retorna o valor absoluto de -5. No caso, 5.
  • " São José dos Pinhais ".strip(): remove os espaços em branco no início e no fim da string, mas vai ignorar os espaços entre as palavras. No caso, retornará São José dos Pinhais.
  • "Olá de novo!".replace("novo", "volta"): substitui a palavra "novo" por "volta" na string.
  • list(range(10)): cria uma lista de números inteiros de 0 até 10, mas sem considerar o 10. Ou seja: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].

1.8 Exercícios Práticos

Agora é hora de praticar! Estes exercícios são organizados por nível de dificuldade, desde o básico até o avançado. Cada exercício tem gabarito completo com explicações linha-a-linha.

1.8.1 Nível 1: Muito Fácil (Aplicação direta de conceitos básicos)

1.8.1.1 Exercício 1.1: Seu primeiro “Hello World”

Objetivo: Executar sua primeira mensagem no Python Console

Instruções:

  1. Abra o Python Console no PyCharm
  2. Digite: print("Olá, mundo!")
  3. Aperte Enter

Gabarito:

print("Olá, mundo!")

Explicação linha-a-linha:

  • print(): função que exibe texto na tela
  • "Olá, mundo!": texto que será exibido (entre aspas duplas)

1.8.1.2 Exercício 1.2: Testando operações matemáticas básicas

Objetivo: Verificar se o Python consegue fazer cálculos simples

Instruções: Execute cada linha separadamente no console:

2 + 3
10 - 4
6 * 7
15 / 3

Gabarito:

2 + 3    # Resultado: 5
10 - 4   # Resultado: 6
6 * 7    # Resultado: 42
15 / 3   # Resultado: 5.0

Explicação linha-a-linha:

  • 2 + 3: soma 2 mais 3, resultado 5
  • 10 - 4: subtrai 4 de 10, resultado 6
  • 6 * 7: multiplica 6 por 7, resultado 42
  • 15 / 3: divide 15 por 3, resultado 5.0 (note o .0 - divisão sempre retorna float)

1.8.1.3 Exercício 1.3: Explorando strings simples

Objetivo: Trabalhar com texto básico

Instruções: Execute no console:

"Python"
"Python" + " é legal"
"Python" * 3
len("Python")

Gabarito:

"Python"              # Resultado: 'Python'
"Python" + " é legal" # Resultado: 'Python é legal'
"Python" * 3          # Resultado: 'PythonPythonPython'
len("Python")         # Resultado: 6

Explicação linha-a-linha:

  • "Python": simplesmente exibe a string Python
  • "Python" + " é legal": concatena (junta) duas strings
  • "Python" * 3: repete a string 3 vezes
  • len("Python"): conta quantos caracteres tem na string (6 caracteres)

1.8.1.4 Exercício 1.4: Verificando tipos de dados

Objetivo: Entender que Python tem diferentes tipos de dados

Instruções: Execute no console:

type(42)
type("Python")
type(3.14)
type(True)

Gabarito:

type(42)       # Resultado: <class 'int'>
type("Python") # Resultado: <class 'str'>
type(3.14)     # Resultado: <class 'float'>
type(True)     # Resultado: <class 'bool'>

Explicação linha-a-linha:

  • type(42): verifica o tipo do número 42 (int = inteiro)
  • type("Python"): verifica o tipo da string “Python” (str = string/texto)
  • type(3.14): verifica o tipo do número 3.14 (float = decimal)
  • type(True): verifica o tipo do valor True (bool = booleano/verdadeiro-falso)

1.8.2 Nível 2: Fácil (Combina 2-3 conceitos básicos)

1.8.2.1 Exercício 2.1: Calculadora pessoal

Objetivo: Criar um programa que faz cálculos e mostra resultados formatados

Instruções:

  1. Crie um arquivo chamado calculadora.py
  2. Escreva o código que calcula e exibe:
    • A soma de 25 + 17
    • A subtração de 100 - 43
    • A multiplicação de 12 * 8
    • A divisão de 144 / 12

Gabarito:

# Calculadora pessoal
print("=== MINHA CALCULADORA ===")
print("25 + 17 =", 25 + 17)
print("100 - 43 =", 100 - 43)
print("12 * 8 =", 12 * 8)
print("144 / 12 =", 144 / 12)
print("========================")

Explicação linha-a-linha:

  • # Calculadora pessoal: comentário explicativo
  • print("=== MINHA CALCULADORA ==="): exibe um cabeçalho bonito
  • print("25 + 17 =", 25 + 17): exibe texto + resultado da operação
  • print("100 - 43 =", 100 - 43): mesmo padrão para subtração
  • print("12 * 8 =", 12 * 8): mesmo padrão para multiplicação
  • print("144 / 12 =", 144 / 12): mesmo padrão para divisão
  • print("========================"): rodapé para fechar bonito

1.8.2.2 Exercício 2.2: Manipulando strings

Objetivo: Aprender operações básicas com texto

Instruções: Execute no console Python:

nome = "Maria"
sobrenome = "Silva"
nome_completo = nome + " " + sobrenome
print("Nome:", nome)
print("Sobrenome:", sobrenome)
print("Nome completo:", nome_completo)
print("Total de caracteres:", len(nome_completo))

Gabarito:

nome = "Maria"                    # Cria variável nome com valor "Maria"
sobrenome = "Silva"               # Cria variável sobrenome com valor "Silva"
nome_completo = nome + " " + sobrenome  # Junta nome + espaço + sobrenome
print("Nome:", nome)              # Exibe: Nome: Maria
print("Sobrenome:", sobrenome)    # Exibe: Sobrenome: Silva
print("Nome completo:", nome_completo)  # Exibe: Nome completo: Maria Silva
print("Total de caracteres:", len(nome_completo))  # Exibe: Total de caracteres: 11

Explicação linha-a-linha:

  • nome = "Maria": cria uma variável chamada “nome” com valor “Maria”
  • sobrenome = "Silva": cria variável “sobrenome” com valor “Silva”
  • nome_completo = nome + " " + sobrenome: concatena as variáveis com um espaço no meio
  • Os prints mostram cada informação de forma organizada
  • len(nome_completo): conta caracteres no nome completo (incluindo o espaço)

1.8.2.3 Exercício 2.3: Explorando funções built-in

Objetivo: Conhecer funções que já vêm com Python

Instruções: Teste cada função no console:

# Trabalhando com números
abs(-15)
round(3.14159, 2)
max(10, 25, 5, 30)
min(10, 25, 5, 30)
sum([1, 2, 3, 4, 5])

# Trabalhando com strings
"python".upper()
"PYTHON".lower()
"  espaços  ".strip()
"Olá mundo".replace("mundo", "Python")

Gabarito:

# Trabalhando com números
abs(-15)                    # Resultado: 15 (valor absoluto)
round(3.14159, 2)          # Resultado: 3.14 (arredonda para 2 casas)
max(10, 25, 5, 30)         # Resultado: 30 (maior número)
min(10, 25, 5, 30)         # Resultado: 5 (menor número)
sum([1, 2, 3, 4, 5])       # Resultado: 15 (soma da lista)

# Trabalhando com strings
"python".upper()           # Resultado: 'PYTHON' (maiúsculas)
"PYTHON".lower()           # Resultado: 'python' (minúsculas)
"  espaços  ".strip()      # Resultado: 'espaços' (remove espaços das bordas)
"Olá mundo".replace("mundo", "Python")  # Resultado: 'Olá Python' (substitui texto)

Explicação linha-a-linha:

  • abs(-15): retorna o valor absoluto (sempre positivo)
  • round(3.14159, 2): arredonda para 2 casas decimais
  • max() e min(): encontram o maior e menor valor
  • sum([1, 2, 3, 4, 5]): soma todos os números da lista
  • .upper() e .lower(): transformam texto em maiúsculas/minúsculas
  • .strip(): remove espaços em branco do início e fim
  • .replace(): substitui uma parte do texto por outra

1.8.3 Nível 3: Médio (Requer raciocínio e combina múltiplos conceitos)

1.8.3.1 Exercício 3.1: Calculadora de IMC

Objetivo: Criar um programa que calcula o Índice de Massa Corporal

Instruções:

  1. Crie um arquivo imc_calculator.py
  2. O programa deve:
    • Calcular IMC = peso / (altura)²
    • Mostrar o resultado formatado
    • Usar valores: peso = 70kg, altura = 1.75m

Gabarito:

# Calculadora de IMC (Índice de Massa Corporal)
peso = 70          # peso em kg
altura = 1.75      # altura em metros
imc = peso / (altura ** 2)  # fórmula do IMC

print("=== CALCULADORA DE IMC ===")
print(f"Peso: {peso} kg")
print(f"Altura: {altura} m")
print(f"IMC: {imc:.2f}")  # :.2f formata para 2 casas decimais
print("========================")

Explicação linha-a-linha:

  • peso = 70: define variável peso com valor 70
  • altura = 1.75: define variável altura com valor 1.75
  • imc = peso / (altura ** 2): calcula IMC usando a fórmula (altura ao quadrado)
  • **: operador de potência (altura²)
  • f"Peso: {peso} kg": f-string que insere variável no texto
  • {imc:.2f}: formata o resultado para 2 casas decimais

1.8.3.2 Exercício 3.2: Analisador de texto

Objetivo: Criar um programa que analisa uma frase

Instruções: Crie um arquivo analisador_texto.py que:

  1. Recebe uma frase: “Python é uma linguagem incrível”
  2. Mostra:
    • A frase original
    • A frase em maiúsculas
    • A frase em minúsculas
    • Quantas palavras tem
    • Quantos caracteres tem (sem espaços)

Gabarito:

# Analisador de texto
frase = "Python é uma linguagem incrível"

print("=== ANÁLISE DE TEXTO ===")
print(f"Frase original: {frase}")
print(f"Em maiúsculas: {frase.upper()}")
print(f"Em minúsculas: {frase.lower()}")
print(f"Número de palavras: {len(frase.split())}")
print(f"Caracteres (sem espaços): {len(frase.replace(' ', ''))}")
print("========================")

Explicação linha-a-linha:

  • frase = "Python é uma linguagem incrível": define a frase a ser analisada
  • frase.upper(): converte toda a frase para maiúsculas
  • frase.lower(): converte toda a frase para minúsculas
  • frase.split(): divide a frase em palavras (retorna lista)
  • len(frase.split()): conta quantas palavras tem na lista
  • frase.replace(' ', ''): remove todos os espaços da frase
  • len(frase.replace(' ', '')): conta caracteres sem espaços

1.8.3.3 Exercício 3.3: Conversor de unidades

Objetivo: Converter entre diferentes unidades de medida

Instruções: Crie um arquivo conversor.py que converte:

  • 100 quilômetros para metros
  • 50 metros para centímetros
  • 2000 gramas para quilogramas
  • 3.5 horas para minutos

Gabarito:

# Conversor de unidades
print("=== CONVERSOR DE UNIDADES ===")

# Conversões
km_para_m = 100 * 1000           # 1 km = 1000 m
m_para_cm = 50 * 100             # 1 m = 100 cm
g_para_kg = 2000 / 1000          # 1 kg = 1000 g
h_para_min = 3.5 * 60            # 1 h = 60 min

# Exibindo resultados
print(f"100 km = {km_para_m} metros")
print(f"50 metros = {m_para_cm} centímetros")
print(f"2000 gramas = {g_para_kg} quilogramas")
print(f"3.5 horas = {h_para_min} minutos")
print("=============================")

Explicação linha-a-linha:

  • km_para_m = 100 * 1000: multiplica 100 por 1000 (fator de conversão km→m)
  • m_para_cm = 50 * 100: multiplica 50 por 100 (fator de conversão m→cm)
  • g_para_kg = 2000 / 1000: divide 2000 por 1000 (fator de conversão g→kg)
  • h_para_min = 3.5 * 60: multiplica 3.5 por 60 (fator de conversão h→min)
  • Cada print exibe o resultado formatado com f-strings

1.8.4 Nível 4: Difícil (Integra conceitos e requer planejamento)

1.8.4.1 Exercício 4.1: Sistema de cadastro simples

Objetivo: Criar um programa que simula um cadastro básico

Instruções: Crie um arquivo cadastro.py que:

  1. Pede nome, idade, cidade e email
  2. Valida se a idade é um número válido
  3. Mostra um resumo formatado
  4. Calcula quantos anos a pessoa terá em 2030

Gabarito:

# Sistema de cadastro simples
print("=== SISTEMA DE CADASTRO ===")

# Coleta de dados (simulando entrada do usuário)
nome = "João Silva"
idade = 25
cidade = "São Paulo"
email = "joao@email.com"

# Validação básica
idade_valida = isinstance(idade, int) and idade > 0

# Cálculos
anos_ate_2030 = 2030 - 2024  # assumindo que estamos em 2024
idade_em_2030 = idade + anos_ate_2030

# Exibição dos resultados
print(f"Nome: {nome}")
print(f"Idade: {idade} anos")
print(f"Cidade: {cidade}")
print(f"Email: {email}")
print(f"Idade válida: {'Sim' if idade_valida else 'Não'}")
print(f"Em 2030 você terá: {idade_em_2030} anos")
print("==========================")

Explicação linha-a-linha:

  • isinstance(idade, int): verifica se idade é um número inteiro
  • and idade > 0: também verifica se idade é positiva
  • 2030 - 2024: calcula quantos anos faltam até 2030
  • idade + anos_ate_2030: soma a idade atual com os anos que faltam
  • 'Sim' if idade_valida else 'Não': operador ternário (if/else em uma linha)

1.8.4.2 Exercício 4.2: Calculadora de estatísticas

Objetivo: Analisar uma lista de notas e calcular estatísticas

Instruções: Crie um arquivo estatisticas.py que analisa as notas: [8.5, 7.0, 9.5, 6.0, 8.0, 7.5, 9.0] Calcule e mostre:

  • Maior nota
  • Menor nota
  • Média das notas
  • Quantas notas são maiores que 8.0

Gabarito:

# Calculadora de estatísticas
notas = [8.5, 7.0, 9.5, 6.0, 8.0, 7.5, 9.0]

print("=== ANÁLISE DE NOTAS ===")
print(f"Notas: {notas}")
print(f"Maior nota: {max(notas)}")
print(f"Menor nota: {min(notas)}")
print(f"Média: {sum(notas) / len(notas):.2f}")

# Contando notas maiores que 8.0
notas_altas = [nota for nota in notas if nota > 8.0]
quantidade_altas = len(notas_altas)

print(f"Notas maiores que 8.0: {notas_altas}")
print(f"Quantidade de notas altas: {quantidade_altas}")
print("=========================")

Explicação linha-a-linha:

  • notas = [8.5, 7.0, 9.5, 6.0, 8.0, 7.5, 9.0]: cria lista com as notas
  • max(notas): encontra a maior nota da lista
  • min(notas): encontra a menor nota da lista
  • sum(notas) / len(notas): calcula média (soma dividida por quantidade)
  • [nota for nota in notas if nota > 8.0]: list comprehension que filtra notas > 8.0
  • len(notas_altas): conta quantas notas são maiores que 8.0

1.8.4.3 Exercício 4.3: Gerador de senha simples

Objetivo: Criar um programa que gera senhas baseadas em informações do usuário

Instruções: Crie um arquivo gerador_senha.py que:

  1. Recebe nome, ano de nascimento e cidade
  2. Gera uma senha usando partes dessas informações
  3. Mostra a senha gerada e seu tamanho

Gabarito:

# Gerador de senha simples
print("=== GERADOR DE SENHA ===")

# Dados do usuário
nome = "Maria"
ano_nascimento = 1995
cidade = "Rio de Janeiro"

# Gerando senha
primeira_letra = nome[0].upper()           # primeira letra do nome em maiúscula
ultimas_digitos = str(ano_nascimento)[-2:]  # últimos 2 dígitos do ano
primeira_cidade = cidade.split()[0][:3]     # primeiras 3 letras da primeira palavra da cidade
numero_especial = len(nome) * len(cidade)   # multiplicação do tamanho do nome e cidade

senha = primeira_letra + ultimas_digitos + primeira_cidade + str(numero_especial)

# Exibindo resultado
print(f"Nome: {nome}")
print(f"Ano: {ano_nascimento}")
print(f"Cidade: {cidade}")
print(f"Senha gerada: {senha}")
print(f"Tamanho da senha: {len(senha)} caracteres")
print("========================")

Explicação linha-a-linha:

  • nome[0].upper(): pega primeira letra do nome e converte para maiúscula
  • str(ano_nascimento)[-2:]: converte ano para string e pega últimos 2 caracteres
  • cidade.split()[0][:3]: divide cidade em palavras, pega primeira palavra, pega primeiras 3 letras
  • len(nome) * len(cidade): multiplica tamanho do nome pelo tamanho da cidade
  • str(numero_especial): converte o número para string para concatenar
  • A senha é formada concatenando todas essas partes

1.8.5 Nível 5: Muito Difícil (Desafio criativo e síntese avançada)

1.8.5.1 Exercício 5.1: Simulador de conta bancária básica

Objetivo: Criar um sistema simples de conta bancária

Instruções: Crie um arquivo conta_bancaria.py que simula:

  1. Uma conta com saldo inicial de R$ 1000
  2. Operações de depósito, saque e consulta de saldo
  3. Validação para não permitir saldo negativo
  4. Histórico das últimas 3 operações

Gabarito:

# Simulador de conta bancária básica
print("=== BANCO PYTHON ===")

# Estado inicial da conta
saldo = 1000.0
historico = []

# Simulando operações
print(f"Saldo inicial: R$ {saldo:.2f}")

# Operação 1: Depósito
deposito = 500.0
saldo += deposito
historico.append(f"Depósito: +R$ {deposito:.2f}")
print(f"Depósito de R$ {deposito:.2f} realizado")

# Operação 2: Saque
saque = 200.0
if saque <= saldo:
    saldo -= saque
    historico.append(f"Saque: -R$ {saque:.2f}")
    print(f"Saque de R$ {saque:.2f} realizado")
else:
    print("Saldo insuficiente para saque!")

# Operação 3: Consulta
historico.append(f"Consulta: Saldo R$ {saldo:.2f}")
print(f"Saldo atual: R$ {saldo:.2f}")

# Mostrando histórico
print("\n=== HISTÓRICO (últimas 3 operações) ===")
for i, operacao in enumerate(historico[-3:], 1):
    print(f"{i}. {operacao}")
print("======================================")

Explicação linha-a-linha:

  • saldo = 1000.0: inicializa saldo com valor decimal
  • historico = []: lista vazia para armazenar operações
  • saldo += deposito: adiciona valor ao saldo
  • historico.append(): adiciona operação ao histórico
  • if saque <= saldo: verifica se há saldo suficiente
  • historico[-3:]: pega as últimas 3 operações do histórico
  • enumerate(historico[-3:], 1): numera as operações começando em 1

1.8.5.2 Exercício 5.2: Sistema de gerenciamento de livros

Objetivo: Criar um sistema para gerenciar uma pequena biblioteca

Instruções: Crie um arquivo biblioteca.py que:

  1. Mantém uma lista de livros com título, autor e ano
  2. Permite adicionar novos livros
  3. Busca livros por autor
  4. Calcula estatísticas da biblioteca

Gabarito:

# Sistema de gerenciamento de livros
print("=== BIBLIOTECA PYTHON ===")

# Base de dados inicial
biblioteca = [
    {"titulo": "1984", "autor": "George Orwell", "ano": 1949},
    {"titulo": "Dom Casmurro", "autor": "Machado de Assis", "ano": 1899},
    {"titulo": "O Senhor dos Anéis", "autor": "J.R.R. Tolkien", "ano": 1954}
]

# Adicionando novos livros
novos_livros = [
    {"titulo": "Python para Iniciantes", "autor": "João Silva", "ano": 2023},
    {"titulo": "A Revolução dos Bichos", "autor": "George Orwell", "ano": 1945}
]

biblioteca.extend(novos_livros)

# Exibindo todos os livros
print("=== TODOS OS LIVROS ===")
for i, livro in enumerate(biblioteca, 1):
    print(f"{i}. {livro['titulo']} - {livro['autor']} ({livro['ano']})")

# Buscando livros por autor
autor_busca = "George Orwell"
livros_autor = [livro for livro in biblioteca if autor_busca.lower() in livro['autor'].lower()]

print(f"\n=== LIVROS DE {autor_busca.upper()} ===")
for livro in livros_autor:
    print(f"- {livro['titulo']} ({livro['ano']})")

# Estatísticas
anos = [livro['ano'] for livro in biblioteca]
autores = [livro['autor'] for livro in biblioteca]
autores_unicos = list(set(autores))

print(f"\n=== ESTATÍSTICAS ===")
print(f"Total de livros: {len(biblioteca)}")
print(f"Número de autores únicos: {len(autores_unicos)}")
print(f"Livro mais antigo: {min(anos)}")
print(f"Livro mais recente: {max(anos)}")
print(f"Período coberto: {max(anos) - min(anos)} anos")
print("====================")

Explicação linha-a-linha:

  • biblioteca = [...]: lista inicial com dicionários representando livros
  • biblioteca.extend(novos_livros): adiciona novos livros à biblioteca
  • enumerate(biblioteca, 1): numera os livros começando em 1
  • [livro for livro in biblioteca if ...]: list comprehension para filtrar livros
  • autor_busca.lower() in livro['autor'].lower(): busca case-insensitive
  • list(set(autores)): remove duplicatas de autores
  • min(anos) e max(anos): encontram ano mais antigo e recente

1.8.5.3 Exercício 5.3: Calculadora de investimentos

Objetivo: Simular crescimento de investimentos ao longo do tempo

Instruções: Crie um arquivo investimentos.py que:

  1. Simula investimento inicial de R$ 10.000
  2. Taxa de juros de 0.8% ao mês
  3. Mostra crescimento mês a mês por 12 meses
  4. Calcula total ganho e percentual de crescimento

Gabarito:

# Calculadora de investimentos
print("=== SIMULADOR DE INVESTIMENTOS ===")

# Parâmetros do investimento
valor_inicial = 10000.0
taxa_juros = 0.008  # 0.8% ao mês
periodo_meses = 12

# Simulação
valor_atual = valor_inicial
historico = []

print(f"Investimento inicial: R$ {valor_inicial:,.2f}")
print(f"Taxa de juros: {taxa_juros * 100:.1f}% ao mês")
print(f"Período: {periodo_meses} meses")
print("\n=== CRONOGRAMA DE CRESCIMENTO ===")

for mes in range(1, periodo_meses + 1):
    juros_mes = valor_atual * taxa_juros
    valor_atual += juros_mes
    historico.append(valor_atual)
    
    print(f"Mês {mes:2d}: R$ {valor_atual:,.2f} (+R$ {juros_mes:,.2f})")

# Resultados finais
valor_final = valor_atual
total_ganho = valor_final - valor_inicial
percentual_crescimento = (total_ganho / valor_inicial) * 100

print(f"\n=== RESULTADOS FINAIS ===")
print(f"Valor inicial: R$ {valor_inicial:,.2f}")
print(f"Valor final: R$ {valor_final:,.2f}")
print(f"Total ganho: R$ {total_ganho:,.2f}")
print(f"Crescimento: {percentual_crescimento:.2f}%")
print("=========================")

Explicação linha-a-linha:

  • taxa_juros = 0.008: define taxa como decimal (0.8% = 0.008)
  • for mes in range(1, periodo_meses + 1): loop de 1 a 12 meses
  • juros_mes = valor_atual * taxa_juros: calcula juros do mês
  • valor_atual += juros_mes: adiciona juros ao valor atual
  • historico.append(valor_atual): guarda valor para análise
  • {valor_atual:,.2f}: formata número com vírgulas e 2 casas decimais
  • {mes:2d}: formata mês com 2 dígitos, alinhado à direita
  • percentual_crescimento = (total_ganho / valor_inicial) * 100: calcula percentual

1.8.6 Dicas para Resolver os Exercícios

  1. Comece pelos mais fáceis: Não tente pular direto para o nível 5!
  2. Leia o código linha por linha: Entenda cada parte antes de continuar
  3. Experimente no console: Teste comandos pequenos antes de fazer programas grandes
  4. Use comentários: Explique seu raciocínio no código
  5. Teste diferentes valores: Mude os números para ver como o resultado varia
  6. Não desista: Se travar, volte ao básico e construa passo a passo

💡 Lembre-se: A programação é como aprender a tocar um instrumento - precisa de prática constante. Cada exercício que você fizer te deixa um pouco melhor!

1.9 Formatação Avançada de Strings - F-strings Poderosas

📌 Quando ler esta seção: Esta seção é essencial para resolver exercícios de níveis 2-5. F-strings podem fazer muito mais que simples substituição de variáveis.

1.9.1 F-strings Básicas (Recapitulação)

Você já viu f-strings básicas:

nome = "João"
idade = 25
print(f"Meu nome é {nome} e tenho {idade} anos")
# Resultado: Meu nome é João e tenho 25 anos

1.9.2 Formatação de Números

F-strings podem formatar números de várias formas:

1.9.2.1 1. Controle de casas decimais

numero = 3.14159265359

# 2 casas decimais
print(f"{numero:.2f}")  # 3.14

# 4 casas decimais
print(f"{numero:.4f}")  # 3.1416

1.9.2.2 2. Separador de milhares

numero = 1234567.89

# Com vírgula como separador de milhares
print(f"{numero:,.2f}")  # 1,234,567.89

# Sem casas decimais
numero_inteiro = 1234567
print(f"{numero_inteiro:,}")  # 1,234,567

1.9.2.3 3. Alinhamento e preenchimento

# Alinhar à direita com 10 espaços
numero = 42
print(f"{numero:>10}")  # "        42"

# Alinhar à esquerda com 10 espaços
print(f"{numero:<10}")  # "42        "

# Centralizar com 10 espaços
print(f"{numero:^10}")  # "    42    "

# Preencher com zeros
print(f"{numero:04d}")  # "0042"

1.9.3 Formatação de Strings

1.9.3.1 1. Alinhamento de texto

nome = "Python"

# Centralizar em 20 caracteres
print(f"'{nome:^20}'")  # '      Python       '

# Alinhar à direita em 15 caracteres
print(f"'{nome:>15}'")  # '         Python'

# Alinhar à esquerda em 15 caracteres
print(f"'{nome:<15}'")  # 'Python         '

1.9.3.2 2. Preenchimento com caracteres

# Preencher com asteriscos
texto = "Python"
print(f"{texto:*^20}")  # *******Python*******

# Preencher com pontos
print(f"{texto:.>15}")  # .........Python

1.9.4 Formatação de Datas e Horas

from datetime import datetime

agora = datetime.now()

# Formatação personalizada
print(f"Hoje é {agora:%d/%m/%Y}")  # Hoje é 15/01/2024
print(f"São {agora:%H:%M:%S}")     # São 14:30:25

1.9.5 Exemplos dos Exercícios

Muitos exercícios usam formatação avançada. Aqui estão exemplos:

# Exemplo do exercício de IMC
peso = 70
altura = 1.75
imc = peso / (altura ** 2)
print(f"IMC: {imc:.2f}")  # IMC: 22.86

# Exemplo do exercício de investimentos
valor_inicial = 10000
valor_final = 12345.67
print(f"Investimento: R$ {valor_inicial:,.2f}")  # Investimento: R$ 10,000.00
print(f"Resultado: R$ {valor_final:,.2f}")       # Resultado: R$ 12,345.67

# Exemplo do exercício de estatísticas
notas = [8.5, 7.0, 9.5, 6.0, 8.0]
media = sum(notas) / len(notas)
print(f"Média: {media:.2f}")  # Média: 7.80

1.9.6 Sintaxe Completa

A sintaxe completa de formatação é:

f"{valor:preenchimento_alinhamento_largura.precisao_tipo}"

Componentes: - valor: A variável a ser formatada - preenchimento: Caractere para preencher espaços (opcional) - alinhamento: < (esquerda), > (direita), ^ (centro) - largura: Número mínimo de caracteres - precisao: Número de casas decimais (para números) - tipo: f (float), d (inteiro), s (string)

1.9.7 Exemplos Avançados

# Tabela formatada
produtos = [("Notebook", 2500.00), ("Mouse", 50.00), ("Teclado", 120.00)]

print("PRODUTOS")
print("-" * 30)
for nome, preco in produtos:
    print(f"{nome:<15} R$ {preco:>8,.2f}")

# Resultado:
# PRODUTOS
# ------------------------------
# Notebook       R$ 2,500.00
# Mouse          R$    50.00
# Teclado        R$   120.00

1.9.8 Dicas Importantes

  1. Use :,.2f para valores monetários com separador de milhares
  2. Use :>10 para alinhar números à direita em tabelas
  3. Use :^20 para centralizar títulos
  4. Use :04d para preencher números com zeros à esquerda

💡 Dica: A formatação avançada de f-strings é essencial para criar saídas profissionais e legíveis nos seus programas!

1.10 Recursos Adicionais para Continuar Aprendendo

Agora que você deu os primeiros passos, aqui estão recursos valiosos para continuar sua jornada com Python:

1.10.1 Documentação e Tutoriais

  • Documentação Oficial do Python (PT-BR): https://docs.python.org/pt-br/3/
  • Tutorial Oficial do Python: https://docs.python.org/pt-br/3/tutorial/
  • Real Python: https://realpython.com/ (em inglês, muito bom)

1.10.2 Livros Recomendados (Internacionais)

Para Iniciantes:

  • “Python Crash Course” - Eric Matthes: Abordagem prática e hands-on, perfeito para quem está começando. Começa do zero e vai até projetos reais.
  • “Automate the Boring Stuff with Python” - Al Sweigart: Focado em automatização de tarefas práticas. Disponível gratuitamente online em https://automatetheboringstuff.com/
  • “Learning Python” - Mark Lutz: Guia completo e detalhado, cobre tudo que você precisa saber sobre Python.

Intermediário/Avançado:

  • “Fluent Python” - Luciano Ramalho: Para quem já sabe o básico e quer dominar Python de verdade. Explica conceitos avançados de forma clara.
  • “Effective Python” - Brett Slatkin: 90 dicas específicas para escrever código Python melhor. Ótimo para aprimorar suas habilidades.
  • “Python Cookbook” - David Beazley & Brian K. Jones: Receitas práticas para problemas comuns. Excelente referência.

Especializados:

  • “Python for Data Analysis” - Wes McKinney: Criado pelo autor do Pandas. Essencial para ciência de dados.
  • “Clean Code in Python” - Mariano Anaya: Práticas de código limpo aplicadas ao Python.
  • “Test-Driven Development with Python” - Harry Percival: Aprenda TDD enquanto constrói uma aplicação web.

1.10.3 Livros em Português

  • “Python Fluente” - Luciano Ramalho: Tradução oficial de “Fluent Python”, escrito por um brasileiro. Um dos melhores livros de Python em qualquer idioma.
  • “Introdução à Programação com Python” - Nilo Ney Coutinho Menezes: Livro brasileiro focado em iniciantes, com exercícios práticos.
  • “Pense em Python” - Allen B. Downey (traduzido): Abordagem focada em resolução de problemas e pensamento computacional.
  • “Use a Cabeça! Python” - Paul Barry: Estilo visual e descontraído, bom para quem prefere aprender de forma menos tradicional.

1.10.4 Bibliotecas Essenciais

  • NumPy: Computação numérica e arrays
  • Pandas: Análise de dados e tabelas
  • Matplotlib: Visualização e gráficos
  • Requests: Requisições HTTP e APIs
  • Flask/Django: Desenvolvimento web
  • Scikit-learn: Machine Learning

1.10.5 Prática e Desafios

  • HackerRank Python: https://www.hackerrank.com/domains/python
  • LeetCode: https://leetcode.com/
  • Exercism Python: https://exercism.org/tracks/python
  • Project Euler: https://projecteuler.net/
  • Batel Tech (desafios em português): https://batel.tech/

1.10.6 Dicas Finais

  1. Pratique todo dia, mesmo que seja 15 minutos
  2. Construa projetos pessoais - teoria sem prática não funciona
  3. Leia código de outros - aprenda com projetos open source
  4. Participe de comunidades - não aprenda sozinho
  5. Ensine o que aprendeu - melhor forma de consolidar conhecimento

🎯 Próximos passos: Termine este livro, faça todos os exercícios, e então escolha um projeto pessoal para construir!


1.10.7 Próximos Passos

Parabéns por completar o capítulo 1! Você:

  • ✅ Entendeu por que Python é importante
  • ✅ Instalou e configurou seu ambiente
  • ✅ Conheceu diferentes IDEs
  • ✅ Executou seu primeiro código Python
  • ✅ Criou um ambiente virtual
  • ✅ Instalou uma biblioteca

No próximo capítulo, você aprenderá sobre algoritmos e começará a programar de verdade!

💡 Dica: Se você travou em algum exercício, não se preocupe! Volte ao capítulo, releia as seções relevantes e consulte o Troubleshooting. A prática leva à perfeição!

1.11 Referências bibliográficas

  • MARTIN, R. C. Clean Code: A Handbook of Agile Software Craftsmanship. Prentice Hall, 2009.
  • MCKINNEY, W. Python for data analysis: Data wrangling with Pandas, NumPy, and IPython. O’Reilly Media, 2012.
  • REITZ, K. et al. Requests: HTTP for Humans™. 2021. Disponível em: https://docs.python-requests.org/en/latest/. Acesso em: 01 mar. 2023.
  • REYNOLDS, J. 8 World-Class Software Companies That Use Python?. Disponível em: https://realpython.com/world-class-companies-using-python/. Acesso em: 03 mar. 2023.
  • RICHARDSON, L. et al. Beautiful Soup Documentation. 2021. Disponível em: https://www.crummy.com/software/BeautifulSoup/bs4/doc/. Acesso em: 01 mar. 2023.
  • RAYOME, A. Why Python is so popular with developers: 3 reasons the language has exploded. TechRepublic, 2015. Disponível em: https://www.techrepublic.com/article/why-python-is-so-popular-with-developers-3-reasons-the-language-has-exploded/. Acesso em: 03 mar. 2023.
  • THOMAS, D.; HUNT, A. The pragmatic programmer. Addison-Wesley Professional, 2019.
  • VAN ROSSUM, G. Computer Programming for Everybody. Disponível em: https://www.python.org/doc/essays/cp4e. Acesso em: 02 mar. 2023.