APOSTILA DE PYTHON — DO BÁSICO À AUTONOMIA

Módulo 1
Ambiente e primeira execução

🧭 Visão do módulo — leia antes de começar

O que você vai aprender: o que Python é de verdade (e como difere do C que você conhece),
como instalar tudo no seu computador, como executar programas de duas formas diferentes e
como este curso vai funcionar na prática.
Para que isso serve: sem ambiente funcionando, não existe curso — só leitura. Este módulo
garante que, a partir do Módulo 2, cada conceito novo possa ser digitado, executado, quebrado
e consertado por você em menos de um minuto. Ele também instala os hábitos que sustentam
todo o resto: o ciclo de estudo e o caderno de erros.
Quantas sessões curtas: 4 sessões de 20 a 45 minutos. Se a instalação der trabalho (acontece),
a Sessão 2 pode virar duas — isso é normal e não é atraso.
Conquista prática ao terminar: você terá escrito, salvo e executado seus primeiros programas
em Python, terá um “laboratório de experimentos” a um clique de distância e saberá
exatamente o que fazer quando algo der errado.

Sessão 1 — O que é Python (e o que muda em relação ao

C)
O problema que justifica esta sessão
Você já programou em C. Então sabe que entre “escrever código” e “ver o resultado” existe uma
etapa chamada compilação. Em Python, essa etapa não existe — e entender por que não existe
muda a forma como você vai trabalhar todos os dias.

Explicação intuitiva
Pense em dois modos de se comunicar com alguém que fala outro idioma:

• C funciona como traduzir um livro inteiro antes de entregá-lo. Você escreve o texto todo, um
tradutor (o compilador) converte tudo para o idioma da máquina de uma vez, e só então o
leitor (o processador) lê. Se houver um erro de tradução na página 200, você fica sabendo antes
de entregar o livro.
• Python funciona como um intérprete simultâneo. Você fala uma frase, o intérprete traduz na
hora, o ouvinte reage na hora. A conversa flui — mas se você disser algo sem sentido na frase
200, só descobre quando chegar nela.
Explicação técnica
Em C, o ciclo é escrever → compilar → executar. O compilador (como o gcc) transforma seu código-
fonte em um arquivo executável em linguagem de máquina. Erros de sintaxe aparecem na
compilação, antes de qualquer execução.

Em Python, o ciclo é escrever → executar. Um programa chamado interpretador lê seu arquivo .py
e executa as instruções linha a linha, na hora. Não existe arquivo executável intermediário que você
precise gerenciar.

Consequências práticas que você vai sentir desde hoje:

Aspecto C Python

Ciclo de trabalho escrever → compilar → executar escrever → executar

Velocidade de mais lenta (cada teste exige quase instantânea

experimentação recompilar)

Quando os erros aparecem muitos na compilação quase todos na execução

Declaração de tipos obrigatória (int x = 5;) não existe (x = 5)

Ponto e vírgula obrigatório não se usa

Chaves { } para blocos obrigatórias não existem — a indentação define

os blocos

Velocidade do programa muito rápido mais lento (e quase nunca importa

— Módulo 26)

⚠️ Cuidado, vindo do C
A diferença mais traiçoeira da tabela é a linha “quando os erros aparecem”. Em C, se compilou,
a sintaxe está inteira. Em Python, um erro pode estar dormindo numa linha que ainda não foi
executada. Por isso, testar cedo e testar sempre é ainda mais importante em Python do que
era em C. O curso inteiro vai reforçar esse hábito.

Por que Python, afinal?

Três razões objetivas, sem propaganda:

• Legibilidade. Python foi desenhado para que código pareça pseudocódigo. Você vai comprovar
isso na Sessão 3.
• Ecossistema. Praticamente qualquer área — planilhas, estatística, gráficos, APIs, automação —
tem bibliotecas maduras e gratuitas.
• É a língua franca da IA. Praticamente toda a pesquisa e a prática em inteligência artificial
acontecem em Python (TensorFlow, PyTorch e scikit-learn são bibliotecas Python). Para o seu
doutorado, isso significa algo concreto: os fundamentos que você vai construir aqui são
exatamente os pré-requisitos para, um dia, ler e escrever os códigos que aparecem em artigos e
 experimentos com IA. Não vamos antecipar nada disso agora — mas cada módulo deste curso
está nesse caminho.

💭 Pergunta para levar (responda mentalmente antes da próxima sessão)

Se Python executa linha a linha, o que acontece quando a linha 1 do arquivo está correta e a
linha 2 tem um erro de digitação? O programa executa a linha 1 ou não executa nada? Você vai
testar isso na prática na Sessão 3 — e a resposta tem uma pegadinha.
Sessão 2 — Instalação e o primeiro programa
Esta sessão é um passo a passo. Siga na ordem, sem pular etapas. Se algo der errado, a caixa “Erros
comuns” no final da sessão cobre os problemas mais frequentes.

Passo 1 — Instalar o Python (Windows)

1. Acesse [Link]/downloads e baixe a versão mais recente (3.12 ou superior).

2. Execute o instalador e, antes de clicar em “Install Now”, marque a caixa:

[x] Add [Link] to PATH

💡 Por que essa caixinha importa

Ela é responsável por 80% dos problemas de iniciantes no Windows. Marcá-la permite que o
comando python funcione em qualquer pasta do computador. Se esquecer, a correção está
em “Erros comuns”, logo adiante.

3. Clique em Install Now e aguarde.

Passo 2 — Verificar a instalação

1. Abra o terminal: pressione Win + R, digite cmd e pressione Enter. (Você também pode usar o
PowerShell; os comandos deste curso funcionam nos dois.)

2. Digite:

python --version

3. A resposta deve ser algo como:

Python 3.12.4

Se apareceu a versão: instalação concluída. Se apareceu erro, vá direto para “Erros comuns” no fim
desta sessão.

Passo 3 — Instalar o VS Code

O VS Code é o editor que usaremos: gratuito, leve e o mais usado do mundo para Python.

1. Baixe em [Link] e instale com as opções padrão.

2. Abra o VS Code, clique no ícone de Extensões na barra lateral esquerda (quatro quadradinhos) e
pesquise por Python.
3. Instale a extensão chamada Python, publicada pela Microsoft.

Passo 4 — Criar sua pasta de curso

Organização desde o dia 1. No terminal (ou pelo Explorador de Arquivos, se preferir):

mkdir C:\curso-python

Todos os seus programas viverão em subpastas desta pasta:

C:\curso-python\
modulo-01\
modulo-02\
...

💡 Dica compatível com sua rotina

Se quiser sincronizar com o Google Drive para acessar de outros computadores, pode criar a
pasta dentro do Drive. Só evite espaços e acentos no nome das pastas (curso-python, não
Curso de Python): caminhos com espaços causam dores de cabeça no terminal.

Passo 5 — Agora no seu computador: o primeiro programa

1. No VS Code: File → Open Folder → selecione C:\curso-python.

2. Crie a pasta modulo-01 e, dentro dela, um arquivo chamado [Link] (File → New File, salve
com esse nome).

3. Digite (não copie e cole — digitar constrói memória motora):

[Link]
print("Olá, Python!")
print("Meu primeiro programa rodou.")

4. Execute de duas formas (é importante conhecer as duas):

Forma A — pelo VS Code: clique no botão ▶ (Run) no canto superior direito.

Forma B — pelo terminal: abra o terminal dentro do próprio VS Code (Terminal → New Terminal) e
digite:

python modulo-01\[Link]

A saída, nas duas formas, deve ser:

 Olá, Python!
Meu primeiro programa rodou.

O que acabou de acontecer (linha por linha)

• print é uma função — um comando pronto que o Python oferece. Sua tarefa: exibir algo na
tela. Equivale ao printf do C, mas sem #include, sem \n obrigatório no final e sem
especificadores como %d — cada print já pula para a próxima linha automaticamente.
• Os parênteses entregam à função aquilo que ela deve exibir.
• O texto entre aspas é uma string — aspas duplas ou simples, tanto faz em Python, desde que
abram e fechem iguais.
• Repare no que não existe: nenhum #include, nenhum int main(), nenhum ponto e vírgula,
nenhuma chave. O arquivo com duas linhas é o programa completo.

Quebre de propósito (parte essencial, não pule)

Programar é conviver com erros. Vamos provocar o primeiro em ambiente controlado. No seu
[Link], remova a aspa final da primeira linha:

print("Olá, Python!)

Execute. Você verá algo como:

File "C:\curso-python\modulo-01\[Link]", line 1

print("Olá, Python!)
^
SyntaxError: unterminated string literal (detected at line 1)

Leia com calma, porque essa mensagem é mais amigável do que parece:

• line 1 — o Python diz em que linha está o problema;

• ^ — aponta a região do problema;
• SyntaxError: unterminated string literal — “string não terminada”: você abriu
aspas e não fechou.
Conserte a aspa e execute de novo. Esse ciclo — quebrar, ler a mensagem, consertar — é o músculo
mais importante que este curso vai desenvolver. No Módulo 2, vamos dissecar a anatomia
completa dessas mensagens.

Erros comuns desta sessão

1. “'python' não é reconhecido como um comando interno ou externo” — Causa: a caixinha
“Add [Link] to PATH” não foi marcada. Solução: execute o instalador de novo → Modify →
avance → em Advanced Options, marque “Add Python to environment variables” → Install.
 Feche e reabra o terminal e teste python --version novamente.
2. O comando python abre a Microsoft Store — Causa: um atalho do Windows interceptando o
comando. Solução: Iniciar → “Gerenciar aliases de execução de aplicativo” → desative os itens
“[Link]” e “[Link]”. Feche e reabra o terminal.
3. O botão ▶ não aparece no VS Code — Causa: extensão Python não instalada ou arquivo sem
a extensão .py. Solução: confira os dois; o nome do arquivo precisa terminar em .py.
4. Acentos estranhos na saída (ex.: Olá) — Causa: codificação do terminal do Windows.
Solução rápida: digite chcp 65001 no terminal e execute de novo. Pelo botão ▶ do VS Code, o
problema normalmente não ocorre.

Exercícios da Sessão 2
Exercício simples: crie um arquivo [Link] que exiba três linhas: seu nome, sua cidade e
uma das suas profissões. Execute pelas duas formas (botão ▶ e terminal).

Exercício intermediário: faça o programa exibir uma “tabela” simples usando apenas print, algo
como:

=== FICHA ===

Nome: Murilo
Área: Matemática
=============

Descubra sozinho como exibir os sinais de igual (dica: eles são texto como qualquer outro).

Desafio: consiga exibir uma frase que contenha aspas duplas dentro dela, por exemplo: O aluno
disse: "entendi!".

🔎 Pistas graduadas do desafio (tente antes de ler!)

Pista 1: releia o trecho da análise linha por linha sobre aspas simples e duplas.
Pista 2: se as aspas de fora forem de um tipo, as de dentro podem ser do outro.
Solução comentada no fim do módulo.
Sessão 3 — O REPL: seu laboratório de experimentos
O problema que justifica esta sessão
Imagine que você só quer testar uma coisinha: “será que em Python 7 / 2 dá 3, como em C, ou dá
3.5?” Criar um arquivo, salvar e executar só para isso é burocracia demais. Deve existir um jeito de
conversar com o Python — e existe.

Explicação intuitiva
O REPL é o Python em modo conversa: você digita uma linha, ele responde na hora. É a
materialização do “intérprete simultâneo” da Sessão 1. Pense nele como a calculadora científica do
programador: não serve para escrever programas, serve para tirar dúvidas em segundos.

Explicação técnica
REPL significa Read–Eval–Print Loop: o interpretador lê o que você digitou, avalia (executa),
imprime o resultado e volta ao início, esperando a próxima linha.

Agora no seu computador

1. Abra o terminal e digite apenas:

python

2. Aparecerá algo assim — os três sinais de maior (>>>) são o convite do REPL:

Python 3.12.4 (tags/v3.12.4:8e8a4ba, ...) on win32

Type "help", "copyright", "credits" or "license" for more information.
>>>

3. Converse com ele. Digite cada linha e observe a resposta antes de digitar a próxima:

>>> 2 + 3
5
>>> 7 / 2
3.5
>>> 7 // 2
3
>>> "bom" + " dia"
'bom dia'
>>> nota = 8.5
>>> nota * 2
17.0

Observações do experimento:
 • 7 / 2 deu 3.5 — diferente do C, onde divisão entre inteiros trunca. Em Python, / sempre
produz resultado com casas decimais; quem trunca é // (detalhes no Módulo 4).
• "bom" + " dia" — o + também junta textos. Em C isso não existe; aqui é natural.
• nota = 8.5 não imprimiu nada: atribuições não têm “resultado” para mostrar. Mas o valor
ficou guardado, como a linha seguinte prova.
• No REPL você não precisou de print para ver resultados — o REPL mostra o valor de qualquer
expressão automaticamente. Dentro de arquivos .py, o print continua necessário. Essa
diferença confunde muita gente no início; agora você já sabe.
4. Para sair do REPL, digite:

>>> exit()

Respondendo à pergunta da Sessão 1

Crie um arquivo teste_erro.py com este conteúdo:

teste_erro.py
print("linha um executou")
print("linha dois vai quebrar)
print("linha três nunca chega")

Antes de executar, escreva num papel sua previsão: o que vai aparecer na tela?

Agora execute. Resultado: nem a linha 1 executa. Surpreso? A explicação: antes de começar a
executar, o interpretador faz uma leitura prévia do arquivo procurando erros de sintaxe (estrutura).
Aspas não fechadas são erro de sintaxe, então o programa é barrado inteiro, antes da primeira linha.

Isso parece contradizer a Sessão 1, mas não contradiz: o que o Python só descobre durante a
execução são os erros de lógica e de tipo (por exemplo, somar um número com um texto — você
verá no Módulo 2). A regra prática:

📌 Regra prática
Erro de sintaxe (estrutura quebrada): barra o programa inteiro, nada executa.
Erro de execução (a linha é válida, mas a operação é impossível): o programa roda até a linha
problemática e para nela.
Você acabou de aprender isso executando um experimento e comparando com sua previsão
— grave esse método, porque é o método do curso inteiro.

Exercícios da Sessão 3 (todos no REPL)

Exercício simples: use o REPL como calculadora para responder: quanto rende, em juros simples, um
capital de R$ 10.000 a 1,2% ao mês durante 8 meses? (Fórmula: 10000 * 0.012 * 8.)
Exercício intermediário: descubra experimentalmente o que cada expressão produz, prevendo
antes de digitar:

>>> 2 ** 10
>>> "ab" * 3
>>> 10 % 3
>>> "2" + "3"

A última é uma pegadinha instrutiva. Anote no seu caderno de erros (Sessão 4) o que ela ensinou.

Desafio: sem criar arquivo nenhum, calcule no REPL o montante de R$ 5.000 aplicados a 0,9% ao
mês por 12 meses em juros compostos.

🔎 Pistas graduadas do desafio (tente antes de ler!)

Pista 1: a fórmula é M = C · (1 + i)ⁿ.
Pista 2: potência em Python é **, não ^.
Solução comentada no fim do módulo.
Sessão 4 — Como este curso funciona (o contrato de
estudo)
Esta sessão é curta e não tem código novo. Ela instala os hábitos que sustentam os módulos
seguintes. Não pule: 15 minutos aqui economizam horas depois.

O ciclo de estudo de cada sessão

Toda sessão do curso, daqui em diante, segue este ciclo:

1. Ler o conceito (problema → intuição → técnica);

2. Digitar e executar os exemplos (“Agora no seu computador”) — digitar, não colar;

3. Quebrar de propósito pelo menos uma coisa e ler a mensagem de erro;

4. Resolver os exercícios antes de olhar pistas ou soluções;

5. Registrar no caderno de erros o que travou você.

🌱 Sem cronograma rígido

Uma sessão por dia, três por semana, uma semana parado — tudo cabe. O único compromisso
inegociável é com o ciclo, não com o calendário.
Se ficar duas semanas sem estudar, a regra de retomada é simples: refaça o mini-teste do
último módulo concluído antes de avançar. Se passar, siga em frente sem culpa.

O caderno de erros
Crie (no Obsidian, que você já usa, ou num arquivo [Link] na pasta do curso) uma
nota simples. Toda vez que um erro travar você por mais de 10 minutos, registre uma linha:

[data] SyntaxError: unterminated string literal → esqueci de fechar

aspas → conferir aspas antes de executar

Formato: erro → causa → lição em uma linha. Nada além disso — se der trabalho, você abandona, e
o valor está na constância. Em três meses, esse caderno será o retrato exato das suas dificuldades, e
as revisões do curso vão pedir que você o consulte.

Usando IA sem criar dependência — orientação nº 1

🤖 Regra deste módulo

Quando um erro aparecer, cole o traceback completo na IA e peça: “explique o que este erro
significa — não me dê a correção.”
Entender a mensagem vale mais do que consertar o código. A correção você tenta primeiro
 sozinho, com a explicação em mãos. A cada módulo, esta trilha ganha uma orientação nova.

Solução comentada dos desafios

Desafio da Sessão 2 (aspas dentro de aspas):

print('O aluno disse: "entendi!"')

Usando aspas simples por fora, as aspas duplas internas viram texto comum. O inverso também
funciona. Existe uma terceira via, a contrabarra (print("O aluno disse: \"entendi!\"")) —
igual ao escape do C — mas a troca de tipo de aspas é mais legível, e legibilidade sempre vence em
Python.

Desafio da Sessão 3 (juros compostos no REPL):

>>> 5000 * (1 + 0.009) ** 12

5565.681727...

Três pontos de atenção: a taxa entra na forma decimal (0.009, não 0,9 — Python usa ponto, não
vírgula, nos números); a potência é ** (o ^ existe em Python, mas faz outra coisa — se você digitou
^, o resultado estranho vai para o caderno de erros); e os parênteses garantem que a soma aconteça
antes da potência, exatamente como na fórmula matemática.
Encerramento do Módulo 1
O que você deve ser capaz de fazer agora
1. Explicar, em uma frase, a diferença entre compilar (C) e interpretar (Python);

2. Criar um arquivo .py no VS Code e executá-lo pelo botão ▶ e pelo terminal;

3. Abrir o REPL, testar uma expressão e sair dele;

4. Provocar um SyntaxError de propósito e localizar, na mensagem, a linha do problema;

5. Dizer qual é a regra do seu caderno de erros.

Checklist de domínio
☐ python --version responde com a versão no meu terminal
☐ Executei [Link] pelas duas formas
☐ Quebrei o programa de propósito e li o traceback
☐ Usei o REPL como calculadora, incluindo **
☐ Sei explicar por que "2" + "3" não dá 5
☐ Criei meu caderno de erros com pelo menos 1 registro
☐ Fiz o desafio dos juros compostos sem olhar a solução (ou olhei, entendi e refiz sozinho)

Mini-teste dos 10 minutos (sem consultar nada)

1. Crie um arquivo [Link] que exiba seu nome e o resultado de 15 % 4 em linhas
separadas;
2. Execute-o pelo terminal;
3. No REPL, calcule quanto é 1.05 ** 10 (fator de 10 meses a 5% a.m.);
4. Provoque um erro de sintaxe qualquer no arquivo e aponte, na mensagem, onde o Python
indica a linha do problema.

🟢 Sinal verde / 🟡 Sinal amarelo

Sinal verde: fez os 4 itens sem consulta → avance para o Módulo 2.
Sinal amarelo: travou em algum item → refaça apenas a sessão correspondente (itens 1–2:
Sessão 2; item 3: Sessão 3; item 4: Sessões 2 e 3) e repita o mini-teste amanhã. Isso não é
retrocesso; é o curso funcionando como planejado.
O que vem a seguir
Módulo 2 — Variáveis, tipos e o primeiro contato sério com erros. Você vai entender por que
Python não exige declarar tipos (e que preço se paga por isso), conhecer os quatro tipos
fundamentais e aprender a ler um traceback completo de cima a baixo — a habilidade que separa
quem depende de tutorial de quem se vira sozinho.

Estimativa: 4 a 5 sessões curtas. Conquista prática: um programa que conversa com o usuário sem
quebrar com qualquer erro básico de digitação.

Fim do Módulo 1. Estude, execute, quebre, conserte — e quando o mini-teste der sinal verde, peça o
Módulo 2.