Unidade 1 · o recado

Recado e crachá

Primeiro você fala. Depois guarda o que a pessoa disse. print, arquivo .py, input, f-string, números. A receita que você inventa (def) espera a unidade 4 — quando a fila já cansou a mão.

Um arquivo que termina em .py

Crie uma pasta qualquer. Dentro dela, um arquivo chamado recado.py. A extensão .py é um recado para você e para as ferramentas: “isto é Python”, não um e-mail.

Escreva código num editor de texto puro. Word, Google Docs e Excel guardam formatação escondida; o interpretador quer caracteres, não negrito. VS Code, Cursor, Vim ou o Bloco de Notas servem.

1. Abra o editor. Arquivo novo. Salve como recado.py.
2. Escreva uma linha de Python (vamos chegar no print já já).
3. Abra o terminal nessa pasta e chame o interpretador, passando o nome do arquivo.

$ python recado.py

O $ (ou > no Windows) só marca “pode escrever”. Não é dinheiro. Você não “abre o recado”. Você chama o interpretador e passa o nome do arquivo.

O que o computador realmente executa

O processador não entende print. Ele entende instruções bem mais baixas — na prática, padrões de zeros e uns. Você não escreve isso na mão. O interpretador (o programa chamado python) lê o seu arquivo, traduz, e manda a máquina trabalhar.

Por isso o comando tem duas partes: à esquerda, quem traduz; à direita, o texto a traduzir. Sem o Python instalado, o comando nem existe. Com ele instalado, o arquivo continua sendo só texto — até alguém pedir para lê-lo.

Editores sérios pintam o código (palavra-chave numa cor, texto noutra). Isso se chama syntax highlighting. É maquiagem útil: ajuda o olho humano. O interpretador ignora cor; ele só lê caracteres.

Duas portas: terminal e janela

CLI (interface de linha de comando) é o terminal: você digita, o programa responde em texto. GUI (interface gráfica) é janela, botão, ícone — o WhatsApp no celular, o navegador.

Os dois existem. Programas prontos quase sempre usam GUI. Para aprender o fluxo linha a linha, o terminal ganha: cada comando é visível, cada erro aparece escrito, não há clique mágico escondendo o que aconteceu.

Neste curso, o fluxo padrão é: editor + terminal. Mais tarde você pode colocar uma janela na frente. A lógica por baixo continua a mesma.

A primeira ferramenta: print

Função é uma ferramenta com nome. print escreve na tela. Entre parênteses vai o argumento — o ingrediente da vez. Aspas marcam um pedaço de texto (string).

print("Café na máquina.")

$ python recado.py
Café na máquina.

O que aparece no terminal é um efeito: algo visível. Mais adiante você vai conhecer funções que, além disso (ou em vez disso), devolvem um valor para guardar.

Aspas simples ou duplas valem, desde que abram e fechem iguais. Muita gente escolhe duplas e fica nisso o curso inteiro — consistência ajuda a ler.

Se o texto precisa de aspas por dentro, você troca o tipo por fora: print('ele disse "oi"'). Ou escapa: print("ele disse \"oi\""). A barra invertida avisa: o próximo caractere não fecha a string; faz parte dela.

Quando o computador recusa

Esqueça o ) no fim. Para um humano é typo. Para o Python é frase pela metade. Ele responde com SyntaxError e não executa. Mensagens às vezes são claras (“nunca fechou o parêntese”); às vezes chutam errado. Com prática você lê o que importa: a linha apontada e o tipo do erro.

print("Café na máquina."
SyntaxError: '(' was never closed

Isso não é fracasso pessoal. É o contrato da linguagem: ou a gramática fecha, ou não roda. Conserte, rode de novo. No terminal, seta para cima recupera o último comando; Tab completa nomes de arquivo.

Há outra família de problema: o arquivo roda, mas faz a coisa errada. Isso é bug de lógica, não de sintaxe. O interpretador não reclama — porque a gramática está ok. Quem reclama é você, olhando a tela. Os dois consertos são diferentes: um é pontuação; o outro é o pensamento.

Notas para humano, não para a tela

Linha que começa com # é comentário. O interpretador ignora. Serve para você daqui a uma semana, não para “explicar o óbvio” em programa de duas linhas.

# recado da manhã — aparece só no arquivo, não no terminal
print("Café na máquina.")

Bloco maior: três aspas seguidas (""" ou ''') abrem e fecham um texto de várias linhas. Usado como docstring no topo de função (módulo 04) ou, à moda antiga, como comentário comprido. Não é print: não vai para o terminal sozinho.

Rascunho em português (às vezes chamado de pseudocódigo) vale antes de digitar Python: “perguntar o nome; limpar espaços; imprimir o crachá”. Depois você troca cada frase por uma linha de verdade. Não precisa de formato oficial. Precisa de clareza.

print com vários argumentos

print aceita zero, um ou muitos valores, separados por vírgula fora das aspas. Por padrão, coloca um espaço entre eles e, no fim, pula de linha. Isso está documentado assim: argumentos posicionais (a ordem importa) e parâmetros nomeados (você chama pelo nome).

sep troca o separador. end troca o que vem no fim (o padrão é \n, “nova linha”).

print("SP", "Brasil", sep="-")
# SP-Brasil
print("item", end="")
print("seguido")
# itemseguido   — o segundo print continua na mesma linha

end="" é string vazia: não pula linha. Útil quando você monta a linha em pedaços (volta no módulo 06). print() sem argumento só emite o \n padrão — uma linha em branco.

Posicional: print("a", "b") — a ordem é a da vírgula. Nomeado: sep="-" — o nome sep, um =, o valor. Você não escreve o traço “solto” e espera que o Python adivinhe.

Onde está escrito o contrato do print

A linguagem tem dono da especificação: a documentação em docs.python.org — print. Lá aparece a assinatura completa: vários objetos, sep, end, e outros detalhes que ainda não precisamos.

Vale o hábito de abrir, mesmo quando a página parecer densa. Este curso traduz o essencial; a docs é a fonte se um dia o material e o interpretador discordarem.

Oficina · cartão no terminal

print("Nícolas")
print("engenharia de software")
print("n@empresa.exemplo")

Perguntar e receber

input mostra um convite e espera Enter. O que a pessoa digitou volta para o programa — um valor de retorno. Funções de print só faziam efeito na tela; esta entrega um objeto para você usar.

input("Apelido: ")

Se você não guardar o retorno, ele some. É como alguém falar o nome no balcão e ninguém anotar no crachá.

Perguntar, receber, etiquetar

Variável é uma gaveta com etiqueta. O = não pergunta se os dois lados são iguais. Ele copia da direita para a esquerda: o retorno de input entra na gaveta apelido.

apelido = input("Apelido: ")

Nomes descritivos batem nomes de uma letra: o teclado está aí para isso. Letras, números e _; não começa com número; não use palavra reservada (if, print como nome de variável atrapalha).

Depois de guardar, print(apelido) — sem aspas — mostra o conteúdo. Com aspas, mostra a palavra.

Notas no arquivo de texto

Linha que começa com #: o interpretador ignora. Serve para você daqui a uma semana. Várias linhas? Vários #.

# ficha da recepção
apelido = input("Apelido: ")

Três aspas ("""...""") viram um bloco de texto. No topo de uma função isso vira documentação (docstring). Solto no meio do arquivo, o Python cria a string e descarta — não imprime. Quem imprime é o print.

f-string: o jeito padrão daqui

Um f colado antes das aspas liga a substituição. Chaves no meio do texto puxam o valor da gaveta:

apelido = input("Apelido: ")
print(f"Crachá: {apelido}")

Há outros jeitos (concatenar com +, vários argumentos no print). Eles existem e às vezes são úteis. Neste curso, se a frase mistura texto fixo e variável, comece pela f-string. Menos vírgula no lugar errado, menos espaço duplicado.

Colar texto sem f-string

+ entre duas strings cola. "Bem-vindo, " + apelido exige você lembrar do espaço na mão. print("Bem-vindo,", apelido) ganha um espaço automático — e um espaço a mais se você já pôs um nas aspas.

Misturar número com + e string dá TypeError. Aí ou você usa f-string, ou str(n). No módulo 03 o número entra de verdade; aqui o recado é: o + de string não é o + da calculadora.

A pessoa não digita “bonito”

Espaço no começo, tudo minúsculo, enter nervoso. String traz ferramentas chamadas métodos: nome da gaveta, ponto, nome da ferramenta, parênteses.

apelido = apelido.strip().title()

strip tira espaços das pontas (não do meio). title põe maiúscula em cada palavra — melhor para “ana souza” do que capitalize, que só mexe na primeira letra da string inteira. O resultado precisa voltar para a gaveta com =; senão você limpou e jogou fora.

Dá para encadear no input:

apelido = input("Apelido: ").strip().title()

Linha longa demais? Quebre em duas atribuições. Legível ganha de “cabe numa linha”.

Só a esquerda, só a direita, contar

lstrip limpa a esquerda; rstrip a direita; strip os dois. Nenhum deles apaga espaço no meio da frase. Para isso entra replace ou, mais tarde, outras ferramentas.

fila = "  12  "
print(fila.lstrip())  # "12  "
print(fila.rstrip())  # "  12"

count conta quantas vezes um trecho aparece. "banana".count("na") vale 2: o par na no meio e no fim — não é a letra a sozinha (essa aparece três vezes).

Outras ferramentas de texto

len é função: vai na frente, entre parênteses. Os outros são métodos: vão depois do ponto. Espaço conta. len("Ana ") com dois espaços no fim é 5.

Quebrar um nome composto

split fatia a string num separador. Com um espaço, “Ana Souza” vira dois pedaços. Python deixa desempacotar:

primeiro, ultimo = "Ana Souza".split(" ")
print(f"Na lista: {primeiro}")

Se a pessoa digitar três nomes, essa linha quebra: há mais pedaços do que gavetas. A oficina pede só nome e sobrenome simples. Mais tarde você trata o resto.

Oficina · crachá da portaria

nome = input("Nome completo: ").strip().title()
print(f"Crachá: {nome}")

O teclado não manda int

Arquivo cafe.py: preço do café vezes a quantidade. Ingênuo:

preco = input("Preço unitário: ")
qtd = input("Quantos: ")
print(preco * qtd)  # TypeError: não multiplica str assim

Troque * por + e o clássico aparece: "12" + "3" vira 123. Concatenação, não soma. int e float são tipos e também funções conversoras.

Converter de verdade

Centavos pedem float. Quantidade inteira pede int. Aninhar é válido: o de dentro roda primeiro.

preco = float(input("Preço unitário: "))
qtd = int(input("Quantos: "))
total = preco * qtd
print(f"Total: {total:.2f}")

Se a pessoa digitar bolo, float explode — isso se resolve com decisão no unidade 1. Hoje assumimos cooperação, mas você já sabe onde o programa é frágil.

str(n) faz o caminho inverso quando você precisa colar número no meio de texto sem f-string.

Conversar com o interpretador

No terminal, python sem nome de arquivo abre o prompt >>>. Cada linha executa na hora. Útil para testar type(x), uma conta, um round. Não substitui o arquivo: feche com exit() ou Ctrl+Z no Windows (Ctrl+D no Unix) e volte ao .py quando o trecho prestar para guardar.

>>> type(3)
<class 'int'>
>>> type(3.14)
<class 'float'>
>>> type("12")
<class 'str'>

Contas que o Python já sabe

abs(-8) tira o sinal. min(4, 9, 1) e max(...) escolhem extremos. Inteiros em Python 3 não têm teto prático; float tem precisão finita — 0,1 + 0,2 às vezes não é o 0,3 da caderneta. Para dinheiro, arredonde na hora de mostrar.

Duas casas na tela e na gaveta

round(total, 2) arredonda o valor. A f-string {total:.2f} só controla a aparência na tela — o número na gaveta pode continuar com mais casas. Escolha: arredondar de verdade (round) ou só formatar (f-string). Em recibo, os dois juntos são comuns.

por_pessoa = total / pessoas
print(f"{round(por_pessoa, 2):.2f}")

O resto % volta no unidade 1 para fila par/ímpar. Aqui ele já existe: 10 % 3 == 1.

Números grandes na f-string

Na f-string, {n:,} pede separador de milhar no estilo da documentação da linguagem (vírgula: 1,000). No Brasil o olho espera ponto: 1.000. Dá para trocar o locale depois; a sintaxe nativa é essa vírgula dentro das chaves. Não é o sep do print — é formatação do próprio número.

vendas = 12500
print(f"Hoje: {vendas:,}")
# Hoje: 12,500

Oficina · a mesa paga

conta = float(input("Conta: "))
pessoas = int(input("Pessoas: "))
cada = (conta * 1.10) / pessoas
print(f"Cada um: {cada:.2f}")