Apostila Python para Iniciantes

Índice
1. Variáveis
2. Tipos de dados (primitivos)
3. Operadores
4. Condicionais (if, elif, else)
5. Laços (repetições)
6. Funções (def)
7. Coleções (estruturas de dados)
8. Strings (trabalhar com texto)
9. Entrada e saída
10. Importações e módulos
11. Tratamento de erros (try/except)

1. Variáveis
Variáveis são como caixinhas mágicas onde guardamos valores para usá-los depois. Em programação,
uma variável é um nome que referencia um espaço na memória do computador onde um dado é
armazenado. Você pode imaginar uma variável como um apelido para um valor: em vez de lembrar o
número 42, você pode criar uma variável chamada idade que guarda esse número. Assim, sempre
que usar idade , o Python sabe que você quer dizer 42 (ou qualquer valor que esteja lá dentro).
Variáveis facilitam a vida porque podemos dar nomes significativos aos dados e reutilizá-los sem
reescrever valores. Além disso, o conteúdo de uma variável pode mudar enquanto o programa roda –
por isso o nome variável! Você pode guardar um texto numa variável agora e depois guardar um
número na mesma variável sem problemas, já que Python é bem flexível (tipagem dinâmica). Não se
assuste: criar e usar variáveis em Python é bem simples e útil no dia a dia do código.

Regras e boas práticas: Ao definir nomes de variáveis, siga algumas regrinhas para evitar erros e
manter um código bonito:
- Nomes válidos: Use letras, números e underscore ( _ ). O nome deve começar com uma letra (ou
underscore), nunca com número – por exemplo, 2aluno é inválido, mas aluno2 é ok 1 . Evite
caracteres especiais ou acentos no nome.
- Minúsculas e snake_case: Por convenção, utilize letras minúsculas nos nomes. Se o nome tiver várias
palavras, separe-as com underscore, por exemplo periodo_corrente (esse estilo é chamado
snake_case 2 ). Isso deixa o código mais legível.
- Palavras reservadas: Não use palavras reservadas do Python (como while , for , True , etc.)
como nomes de variáveis 1 . Python não vai deixar, pois elas já têm significado especial na linguagem.
- Nomes significativos: Escolha nomes que reflitam o dado armazenado ou seu propósito. Por
exemplo, use temperatura em vez de t ou valor1 . Isso ajuda qualquer pessoa (inclusive você no
futuro) a entender o código 3 . Evite abreviações confusas.
- Atualização de valor: Você pode alterar o valor de uma variável quantas vezes quiser no programa.
Apenas lembre que a variável sempre guardará o valor mais recente atribuído a ela.
- Case-sensitive: Python diferencia maiúsculas de minúsculas (case sensitive). Ou seja, valor e

1
Valor são variáveis diferentes. Mantenha consistência no uso das letras maiúsculas/minúsculas para
não se confundir.

Exemplo em Python:

mensagem = "Olá, mundo!" # Atribuímos a string "Olá, mundo!" à variável

mensagem
idade = 25 # Atribuímos o número inteiro 25 à variável idade
pi = 3.14159 # Atribuímos o número de ponto flutuante 3.14159 à
variável pi
print(mensagem) # Imprime o conteúdo da variável mensagem (saída:
Olá, mundo!)
idade = idade + 1 # Atualiza o valor de idade: soma 1 ao valor atual
(25 passa a ser 26)
print(idade) # Imprime o novo valor de idade (saída: 26)

Pseudocódigo:

mensagem <- "Olá, mundo!"

idade <- 25
pi <- 3.14159
escreva mensagem // Saída: Olá, mundo!
idade <- idade + 1 // idade passa a valer 26
escreva idade // Saída: 26

2. Tipos de dados (primitivos)

Quando guardamos valores em variáveis, esses valores têm tipos diferentes. O tipo de dado nos diz
que tipo de coisa estamos armazenando – por exemplo, número, texto ou valor lógico. Python lida com
tipos de forma bem tranquila: você não precisa declarar o tipo da variável, ele é determinado
automaticamente pelo valor que você atribui. Isso significa que você pode fazer contador = 1
(contador é um número inteiro agora) e depois contador = "um" (agora é uma string) sem erro
algum – Python é uma linguagem de tipagem dinâmica. Mas é importante entender os tipos básicos
para saber como as operações se comportam e como formatar dados corretamente. Os principais tipos
de dados primitivos em Python são bem intuitivos e correspondem a conceitos do mundo real, como
números e texto. Vamos conhecê-los:

Principais tipos primitivos:

- int (inteiro): Representa números inteiros (…-3, -2, -1, 0, 1, 2, 3… etc.), sem parte decimal 4 . Use
int para quantidades contáveis, idades, contagens, etc.
- float (ponto flutuante): Representa números reais com parte decimal, usando o ponto . como
separador decimal (por exemplo, 3.14). Em Python (como em muitas linguagens), usa-se ponto e não
vírgula para decimais 5 – então escreva 5.0 e não 5,0 . Valores como 2.5, -0.001 ou 100.0 são
floats.
- bool (booleano): Representa valores lógicos Verdadeiro ou Falso (True ou False em Python). É o tipo
usado em comparações e condições lógicas. Por exemplo, ativo = True ou 5 > 3 resulta em
False / True .
- str (string): Representa texto, ou seja, uma sequência de caracteres (letras, dígitos, símbolos). Strings

2
devem estar entre aspas simples ou duplas 6 . Por exemplo: "Python" , 'Olá, mundo' . Você pode
usar aspas simples ou duplas conforme conveniente (mas sempre feche com o mesmo tipo que abriu).
Para strings de várias linhas ou textos grandes, pode-se usar aspas triplas """assim""" .

Python tem ainda outros tipos nativos, como complex (números complexos) ou NoneType (valor nulo
representado por None ), mas os quatro acima são os primitivos mais usados no começo. Como Python
atribui automaticamente o tipo conforme o valor, é fácil trabalhar: só lembre de converter o tipo
quando necessário (por exemplo, se ler um número como texto, converta para int/float para fazer
cálculos).

Regras e boas práticas:

- Uso correto de aspas: Para definir uma string, coloque o texto entre aspas simples ( 'texto' ) ou
duplas ( "texto" ). Python não distingue diferença de significado entre elas 6 , então escolha um
padrão e seja consistente no código. Se o texto em si contém aspas, use o outro tipo para definir a
string (ex: "Ele disse 'oi'" ou 'Ela respondeu "olá"' ). Também é possível usar a barra
invertida \ para escapar aspas dentro da string, se necessário (ex: "Aspas duplas: \" " ).
- Conversão de tipos: Esteja atento ao tipo dos dados principalmente em operações. Strings não
podem ser somadas com números sem conversão. Por exemplo, para concatenar um número em uma
mensagem, converta o número para string com str(numero) ou use f-string (ver seção de Strings).
Para entrada do usuário (que vem como str ), use int() ou float() se precisar de um número.
- Precisão de floats: Lembre que números de ponto flutuante podem apresentar pequenas
imprecisões binárias. Por exemplo, 0.1 + 0.2 pode resultar em 0.30000000000000004 . Isso é
normal em computação; para a maioria dos casos iniciais não será um problema, mas é bom saber que
ocorre.
- Verificando tipo: Se precisar conferir o tipo de um valor/variável, use a função embutida type() .
Por exemplo, type(42) retorna <class 'int'> . Útil para depuração e aprendizado, mas em geral
o Python cuida dos tipos pra você automaticamente.

Exemplo em Python:

a = 10 # int (inteiro)
b = 3.14 # float (número de ponto flutuante)
c = "Python" # str (string de texto)
d = True # bool (booleano True/False)

print(type(a)) # Mostra <class 'int'>

print(type(b)) # Mostra <class 'float'>
print(type(c)) # Mostra <class 'str'>
print(type(d)) # Mostra <class 'bool'>

Comentário: No exemplo acima, type(a) vai retornar o tipo do valor armazenado em a . Assim,
vemos que a é int, b é float, c é str, e d é bool. Repare que para o Python, tanto "Texto"
quanto 'Texto' são strings (desde que as aspas casem certinho). Os booleanos True/False começam
com letra maiúscula em Python.

Pseudocódigo:

3
 a <- 10 // inteiro
b <- 3.14 // real (ponto flutuante)
c <- "Python" // string (texto)
d <- Verdadeiro // booleano (True)

escreva a, b, c, d // Possível saída: 10 3.14 Python Verdadeiro

(No pseudocódigo acima, assumimos que Verdadeiro representa um valor lógico verdadeiro. A saída
exata pode variar conforme a notação, mas a ideia é mostrar os valores.)

3. Operadores
Operadores são símbolos ou palavras especiais que realizam operações sobre os dados, como por
exemplo somar dois números, comparar valores ou ligar condições lógicas. Pense nos operadores
como os verbos das expressões: eles dizem ao Python o que fazer com os valores ou variáveis. Existem
vários tipos de operadores em Python, mas vamos começar pelos mais básicos e úteis:

• Operadores aritméticos: servem para realizar cálculos matemáticos: + (adição), -

(subtração), * (multiplicação), / (divisão normal, resultado float), // (divisão inteira,
descartando decimais), % (módulo, resto da divisão) e ** (exponenciação, potência) 7 8 .
Por exemplo, 5 + 2 resulta em 7, 5 - 2 em 3, 5 * 2 em 10, 5 / 2 em 2.5, 5 // 2 em
2, 5 % 2 em 1, e 5 ** 2 em 25.
• Operadores de comparação (relacionais): servem para comparar valores e produzir um
resultado booleano (True/False). Os principais são: == (igual a), != (diferente de), > (maior
que), < (menor que), >= (maior ou igual) e <= (menor ou igual). Por exemplo, 10 == 10 é
True, 5 != 3 é True, 7 < 0 é False. Essas comparações são muito usadas em condicionais.
Atenção: use == para comparar igualdade, pois um sinal = sozinho faz atribuição (guarda
valor na variável) e não comparação!
• Operadores lógicos: usados para combinar expressões booleanas: and (e), or (ou), not
(não). Por exemplo, (5 > 2) and (3 > 1) é True (porque ambas as comparações são True),
já (5 > 2) and (3 < 1) seria False (a segunda parte é False). O or retorna True se pelo
menos uma condição for True. O not inverte o valor booleano (transforma True em False e
vice-versa).
• Operador de atribuição: = (igual) é usado para atribuir um valor a uma variável, como vimos
em variáveis. Há também atribuições incrementais, como += , -= , *= , etc., que combinam
operação e atribuição. Por exemplo, x += 5 é o mesmo que x = x + 5 .

Regras e boas práticas:

- Precedência de operadores: Assim como na matemática, Python segue uma ordem de precedência.
Por exemplo, multiplicação e divisão são realizadas antes de adição e subtração. Você pode usar
parênteses () para deixar claro a ordem desejada e tornar a expressão mais legível. Por exemplo,
2 + 3 * 4 dá 14, mas (2 + 3) * 4 dá 20.
- Espaços em torno de operadores: Para melhorar a legibilidade, coloque espaços ao redor de
operadores binários (como = , + , == , etc.). Exemplo: escreva x = 1 + 2 em vez de x=1+2 . Isso
está inclusive na PEP 8 (guia de estilo do Python) 9 . A única exceção são operadores de alta prioridade
numa expressão complexa – aí você pode omitir espaços para indicar ligação mais forte, mas na dúvida,
use parênteses e mantenha espaços em geral 9 .
- Não dividir por zero: Lembre-se das regras matemáticas: dividir por zero não é permitido (gerará
uma exceção ZeroDivisionError ). Se houver chance do divisor ser zero, trate isso (por exemplo,

4
com um if ou tratamento de erro).
- Concatenação e repetição: O operador + também funciona para concatenar strings (juntar textos),
e o * com um número inteiro pode repetir uma string. Ex: "Py" + "thon" resulta em "Python" ,
e "Ha" * 3 resulta em "HaHaHa" . Porém, não use + para juntar números em texto sem conversão;
use f-strings ou str() para evitar erro (ver seção de Strings).
- Comparações encadeadas: Python permite escrever comparações encadeadas de forma matemática.
Por exemplo, 5 < x < 10 verifica se x está entre 5 e 10. Isso pode tornar condições mais claras. Mas
tome cuidado: a == b == c verifica se a é igual a b e b é igual a c. Se você queria comparar todos três
independentes, talvez precise usar and .

Exemplo em Python:

x = 10
y = 3

soma = x + y # 10 + 3 = 13
subtracao = x - y # 10 - 3 = 7
produto = x * y # 10 * 3 = 30
divisao = x / y # 10 / 3 = 3.333... (divisão com resultado float)
divisao_int = x // y # 10 // 3 = 3 (divisão inteira, parte inteira do
resultado)
resto = x % y # 10 % 3 = 1 (resto da divisão de 10 por 3)
potencia = x ** y # 10 ** 3 = 1000 (10 elevado à 3)

print(soma, subtracao, produto, divisao, divisao_int, resto, potencia)

# Saída: 13 7 30 3.3333333333333335 3 1 1000

No código acima, calculamos resultados usando vários operadores e os armazenamos em variáveis.

Colocamos comentários mostrando o cálculo e o resultado esperado de cada operação. Por fim,
imprimimos todos os resultados. Observação: a divisão normal x / y resultou em um número de
ponto flutuante. Já x // y deu apenas a parte inteira da divisão (desprezando a fração). Operações
matemáticas seguem o padrão esperado.

Para completar, aqui vai um pequeno exemplo com operadores de comparação e lógicos:

a = 5
b = 8
comparacao = a < b # True, pois 5 é menor que 8
teste_logico = (a > 0) and (b < 0) # False, pois b < 0 é False (8 não é
menor que 0)
print(comparacao, teste_logico) # Saída: True False

Pseudocódigo:

x <- 10
y <- 3

5
 soma <- x + y // 13
subtracao <- x - y // 7
produto <- x * y // 30
divisao <- x / y // 3.333...
divisao_inteira <- x div y // 3 (divisão inteira)
resto <- x mod y // 1 (resto da divisão)
potencia <- x ^ y // 1000 (10 elevado a 3)

escreva soma, subtracao, produto, divisao, divisao_inteira, resto, potencia

// Saída esperada: 13 7 30 3.333... 3 1 1000

(Observação: Em pseudocódigo, usamos div para divisão inteira e mod para resto, notações comuns em
algoritmos. Usamos ^ para representar exponenciação. A saída mostrada é ilustrativa de cada resultado.)

4. Condicionais (if, elif, else)

Com condicionais, nosso programa pode tomar decisões e seguir por caminhos diferentes de acordo
com as circunstâncias. Em outras palavras, podemos fazer o código “pensar”: "Se determinada
condição for verdadeira, execute isto; caso contrário, faça aquilo." A estrutura condicional básica em
Python usa as palavras-chave if (se), elif (abreviação de else if, ou "senão se") e else (senão). É
como uma bifurcação: o if é a primeira verificação, os elif são verificações adicionais caso as
anteriores não sejam verdadeiras, e o else é o caminho final se nenhuma das condições anteriores
for satisfeita.

Um exemplo cotidiano: se estiver chovendo, pegue um guarda-chuva; senão se estiver nevando, pegue
um casaco pesado; senão (qualquer outra condição, ou seja, não está chovendo nem nevando), apenas
saia de casa normalmente. Da mesma forma, no programa podemos verificar valores e tomar ações.
Isso torna o programa interativo e inteligente, reagindo a diferentes entradas ou estados.

Em Python, a sintaxe de um bloco condicional é fácil de ler: usamos if condição: seguido por um
bloco indentado de código a executar se a condição for True. Podemos adicionar opcionalmente elif
outra_condicao: (quantos elif forem necessários, inclusive nenhum ou vários) e por fim um else:
para cobrir todos os outros casos não contemplados. Importante: não existe elif sem antes um
if , e só pode haver um else no final de uma cadeia de ifs.

Regras e boas práticas:

- Indentação do bloco: Em Python, indentação é obrigatória para definir os blocos de código. Após
um if , elif ou else , coloque os comandos que fazem parte daquela condição identados (4
espaços é o padrão recomendado 10 ). Nunca misture tabulações e espaços – use espaços sempre,
para evitar erros de indentação 10 . Por exemplo:

if condição:
# quatro espaços antes desta linha mostram que ela está dentro do if
faz_algo()
else:
# também indentado
faz_outra_coisa()
# aqui saímos do bloco if/else, sem indentação

6
O uso correto da indentação é crucial: é assim que o Python sabe quais comandos pertencem a cada
ramo do if 11 . Se você esquecer de indentar ou indentar errado, o Python vai reclamar (SyntaxError ou
IndentationError).
- Dois pontos : : Não esqueça de colocar : ao final da linha do if , do elif e do else . Esse
dois-pontos indicam o início de um bloco indentado. Esquecer : é um erro de sintaxe comum para
iniciantes.
- Condições booleanas: O if avalia uma expressão booleana (True/False). Você pode usar
comparações ou variáveis booleanas diretamente. Por exemplo, if x > 0: ou if esta_logado: .
Em Python, alguns valores “vazios” ou zero também são tratados como False em um if (ex.: 0, ""
string vazia, listas vazias, None ), mas é melhor explicitamente comparar para clareza quando iniciante.
- Elif e else opcionais: O elif só deve ser usado se há uma nova condição a verificar caso o if
anterior falhe. O else captura “qualquer outro caso”. Você não é obrigado a usar elif ou else ;
pode ter apenas um if sozinho. Use elif quando precisar testar múltiplas condições mutuamente
exclusivas. Use else para tratar “todo o resto” de casos.
- Múltiplos elif: Você pode encadear vários elif para cobrir várias faixas de casos. O Python vai
avaliar de cima para baixo: quando encontrar uma condição True, executa aquele bloco e sai da cadeia
de if (ignorando os demais). Portanto, ordene as condições do caso mais específico para o mais
genérico, se aplicável.
- Evite condicional desnecessária: Às vezes, checagens simples podem ser escritas de forma mais
direta. Por exemplo, em vez de:

if condicao:
return True
else:
return False

Você pode simplesmente usar return condicao , já que condicao em si é True/False. Mas isso é
uma otimização de código; como iniciante, foque primeiro na clareza do fluxo lógico.

Exemplo em Python:

numero = 7 # Podemos mudar este valor para testar diferentes casos

if numero > 0: # se numero for maior que 0...
print("Positivo") # ...imprime "Positivo"
elif numero < 0: # senão, se numero for menor que 0...
print("Negativo") # ...imprime "Negativo"
else: # caso contrário (numero não é >0 nem <0,
então só pode ser == 0)
print("Zero") # imprime "Zero"

Se executarmos o código acima com numero = 7 , a saída será Positivo . Se ajustarmos

numero = -3 , a primeira condição falha, a segunda ( elif ) é verdadeira, e obteremos Negativo .
Se numero = 0 , nenhuma das condições if/elif é verdadeira, então o bloco do else será executado,
exibindo Zero . Note como apenas um dos blocos é executado de acordo com o valor de numero .

Outro exemplo rápido: imagine que um aluno fez 75 pontos de 100 em uma prova. Podemos avaliar se
ele passou, ficou de recuperação ou foi reprovado, usando múltiplos elif:

7
 nota = 75
if nota >= 60:
print("Aprovado!") # 60 ou mais -> aprovado
elif nota >= 40:
print("Recuperação.") # 40 a 59 -> recuperação
else:
print("Reprovado.") # abaixo de 40 -> reprovado
# Saída aqui seria "Aprovado!"

Pseudocódigo:

numero <- 7

se numero > 0 então

escreva "Positivo"
senão se numero < 0 então
escreva "Negativo"
senão
escreva "Zero"
fim se

No pseudocódigo acima, ilustramos a estrutura condicional em português: "se (condição) então ...
senão se ... senão ... fim se". A lógica é equivalente ao código Python. Apenas lembre que no Python real
usamos elif e else com indentação e : conforme mostrado no exemplo em Python.

(Dica: Sempre verifique se suas condições cobrem todos os casos possíveis. O bloco else é útil como
"seguro" para qualquer situação não prevista nos if/elif anteriores.)

5. Laços (repetições)
Laços de repetição permitem executar um conjunto de instruções várias vezes, de forma automática.
Em vez de repetir código manualmente, você faz o computador repetir para você! Existem dois tipos
principais de laços em Python: o while , que repete enquanto uma condição for verdadeira, e o for ,
que itera sobre uma sequência de elementos (por exemplo, cada item de uma lista, ou uma faixa de
números). Usando laços, você pode, por exemplo, imprimir os números de 1 a 100 sem escrever cem
linhas – bastam poucas linhas num loop.

• Laço while : funciona como um loop condicional. Ele verifica uma condição no início e, se for
True, executa o bloco de código; então volta ao início, verifica de novo, e assim por diante, até
que a condição se torne False. A palavra while significa "enquanto". Exemplo: while
tem_comida_no_prato: comer() . O loop continuará "enquanto" houver comida no prato. Se
a condição já começar False, o bloco nem chega a executar nenhuma vez.
• Laço for : em Python, o for é na verdade um loop para cada item em uma sequência. Ou
seja, ele pega um item por vez de um conjunto (por exemplo, cada caractere de uma string, cada
elemento de uma lista, ou cada número em um range) e executa o bloco para aquele item,
depois passa para o próximo automaticamente. A sintaxe é for variavel in sequencia: .
Por exemplo: for x in [1,2,3]: print(x) vai imprimir 1, depois 2, depois 3. Muito útil
para iterar sobre listas, ranges numéricos, etc.

8
Regras e boas práticas:
- Indentação novamente: Assim como nas condicionais, os blocos dentro de while e for precisam
ser indentados. Tudo que estiver indentado sob o while ou for será repetido no laço. Mantenha os
4 espaços padrão para cada nível 10 .
- Cuidado com loops infinitos: Um erro comum com while é esquecer de modificar a condição
dentro do loop, fazendo com que ela nunca fique False. Isso resulta em um loop infinito – o programa
fica repetindo "até o fim dos tempos" e pode travar (a não ser que você o interrompa) 12 . Para evitar
isso, certifique-se de que algo dentro do while eventualmente torne a condição False. Por exemplo,
se while contador < 10: , lembre de incrementar contador dentro do loop. Se, por algum
motivo, você quer deliberadamente um loop infinito, pode usar while True: e controlar saídas com
break (veja abaixo), mas use com cautela.
- Instruções break e continue : Dentro de um laço, você pode usar break para parar totalmente
a repetição (sai do loop imediatamente) e continue para pular para a próxima iteração (interrompe a
iteração atual e volta para o início do loop verificando a condição novamente, no caso do while, ou
pegando o próximo item, no caso do for). Essas instruções podem ajudar em certas lógicas (por
exemplo, sair de um loop quando uma condição é atendida, ou ignorar certos elementos). Mas não
abuse: loops bem estruturados muitas vezes não precisam delas.
- Loop for com range: Para repetir um número fixo de vezes, use a função range() . Por exemplo,
range(5) gera a sequência 0,1,2,3,4. E range(1,6) gera 1,2,3,4,5. Então fazer for i in
range(1,6): repete o loop para i=1 até i=5. O range pode ter um passo: range(inicio, fim,
passo) . Ex: range(0, 10, 2) gera 0,2,4,6,8. Lembre-se que o range vai até o segundo
argumento sem incluí-lo. Então range(1,6) vai até 5 13 .
- Iterando coleções: Você pode usar for diretamente em outras coleções. Por exemplo,
for letra in "python": vai iterar em cada caractere da string, e for fruta in
lista_de_frutas: itera item a item. Isso é mais simples e legível do que usar índices para percorrer
estruturas.
- Não modificar coleção durante iteração: Evite adicionar ou remover itens de uma lista enquanto
você a percorre com for , pois isso pode causar comportamento inesperado (o tamanho muda
durante o loop). Se precisar modificar, uma estratégia é iterar sobre uma cópia ou usar compreensão de
listas. Isso é um detalhe mais avançado, mas fica a dica.
- Saindo de loops aninhados: Se você tem loops dentro de loops (aninhados), um break apenas sai
do loop interno onde ele está. Para sair de loops externos, será necessário lógica adicional (como flags)
ou exceções, já que não existe um break “rotulado” nativo em Python. Mas para 99% dos casos
iniciais, loops simples resolvem.

Exemplo (While) em Python:

contador = 1
while contador <= 5: # enquanto contador for menor ou igual
a 5...
print(contador) # ...imprime o valor atual de contador
contador += 1 # incrementa o contador em 1 a cada
iteração

Explicação: Inicializamos contador com 1. O while vai continuar executando enquanto contador
<= 5 for True. Dentro do loop, exibimos o valor de contador e depois aumentamos ele em 1
( contador += 1 ). Assim, o loop imprime 1, 2, 3, 4, 5 e então, quando contador se torna 6, a
condição do while passa a False e o laço termina. Se não atualizássemos contador , ele ficaria sempre
1 e o loop seria infinito – por isso é importante modificar algo que afete a condição dentro do while.

9
Exemplo (For) em Python:

for i in range(1, 6): # para cada valor i de 1 até 5

(range(1,6) vai 1,2,3,4,5)...
print(i) # ...imprime i

Explicação: O for acima vai iterar i nos valores 1, 2, 3, 4, 5 (note que o 6 não entra). A cada iteração,
ele executa o bloco indentado (no caso, apenas um print do valor de i ). O resultado será imprimir os
números de 1 a 5, um por linha. Não precisamos nós mesmos incrementar i – o loop for faz isso
automaticamente ao passar para o próximo elemento da sequência. Esse exemplo faz exatamente a
mesma coisa que o while anterior, mas de forma mais compacta.

Pseudocódigo (While):

contador <- 1
enquanto contador <= 5 faça
escreva contador
contador <- contador + 1
fim enquanto

Esse pseudocódigo ilustra um loop enquanto. Ele vai escrever os números de 1 a 5, semelhante ao
exemplo em Python. Note o incremento contador <- contador + 1 para evitar loop infinito.

Pseudocódigo (For):

para i de 1 até 5 faça

escreva i
fim para

Aqui mostramos um loop para (for) em pseudocódigo, que itera i de 1 a 5. É análogo ao for i in
range(1,6) do Python. Cada iteração escreve o valor de i. Quando i passar de 5, o laço termina.

(Com laços, conseguimos fazer tarefas repetitivas de forma elegante. Por exemplo, podemos somar todos os
números de uma lista facilmente com um for, ou repetir uma pergunta até o usuário dar uma resposta válida
com um while. Aproveite esse "poder de repetição" para evitar código redundante!)

6. Funções (def)
Funções são como subprogramas dentro do seu programa: pequenos blocos de código que realizam
uma tarefa específica e que podem ser reutilizados em diferentes momentos. Elas nos ajudam a evitar
repetição de código e a organizar melhor o programa, dividindo-o em partes lógicas. Pense em uma
função como uma receita: você define os ingredientes (parâmetros) e os passos (código da função)
uma vez, e depois pode “chamar” essa receita pelo nome sempre que quiser, sem precisar reescrever
todo o procedimento. Em Python, definimos uma função usando a palavra-chave def seguida do
nome da função e parênteses com eventuais parâmetros.

10
Por exemplo, imagine que você precise calcular a área de um círculo em vários lugares do programa.
Em vez de repetir a fórmula πr² toda hora, você pode escrever uma função
calcula_area_circulo(raio) que retorna o resultado. Daí, sempre que precisar, basta chamar
calcula_area_circulo(5) ou outro valor, tornando o código mais limpo e de fácil manutenção.

Conceito básico: Uma função em Python tem a sintaxe:

def nome_da_funcao(param1, param2, ...):

# bloco de código
return resultado

Os parâmetros (também chamados argumentos) são opcionais – pode haver função sem parâmetros.
O return também é opcional – se a função não retornar nada explicitamente, ela retorna None por
padrão. Funções podem tanto retornar um valor (por exemplo, um cálculo que você quer usar depois)
quanto simplesmente executar ações (por exemplo, imprimir algo na tela) sem retorno explícito.

Regras e boas práticas:

- Nomes de funções: Assim como variáveis, siga convenções snake_case em letras minúsculas 14 . O
nome deve indicar o que a função faz, de preferência um verbo ou ação (ex: calcula_media ,
imprime_boas_vindas ). Isso torna o código autoexplicativo.
- Definição vs chamada: Usar def cria (define) a função, mas não a executa naquele momento. A
execução ocorre quando você “chama” a função pelo nome, com parênteses e os argumentos
necessários. Certifique-se de definir a função antes de chamá-la (no fluxo do código). Em um script
linear, defina as funções no topo e depois use-as.
- Parâmetros e argumentos: Parâmetros são variáveis locais na função que recebem os valores
(argumentos) passados durante a chamada. Você pode definir funções com múltiplos parâmetros, ou
nenhum. Na chamada, forneça argumentos na ordem correta ou use argumentos nomeados. Ex.:
def saudacao(nome, idioma) , chamada: saudacao("João", "pt") ou usando nome:
saudacao(idioma="pt", nome="João") .
- Escopo: Variáveis definidas dentro de uma função (parâmetros ou quaisquer criadas ali) só existem
dentro dela (escopo local). Elas não interferem em variáveis de mesmo nome fora da função (escopo
global), e vice-versa. Isso evita conflitos e é bom para organizar o código. Se precisar usar uma variável
global dentro da função, você deve declará-la global (não recomendado a menos que necessário). Em
geral, passe o que precisa via parâmetros e retorne resultados em vez de usar globais.
- Retorno de valores: Use return para devolver um resultado da função para quem a chamou.
Quando o Python encontra um return , ele sai da função imediatamente (não executa mais nada
abaixo dele naquela função). Se sua função deve retornar algo, garanta que todas as vias de execução
retornem valor (ou pelo menos um return sem valor para terminar). Se a função é mais um
procedimento (apenas executa ações e não calcula nada específico para retornar), você pode omitir o
return ou usar return None .
- Funções pequenas e coesas: É boa prática fazer funções que realizam uma única tarefa ou lógica
bem definida. Isso facilita testes e reutilização. Se sua função estiver fazendo muitas coisas diferentes,
considere dividir em funções menores.
- Docstring: Embora não seja obrigatório para funcionamento, é recomendado documentar a função.
Logo abaixo da linha def ...: você pode colocar uma string (entre """ """ ) descrevendo o que a
função faz, seus parâmetros e retorno. Essa docstring pode ser acessada via help(funcao) ou
funcao.__doc__ . Para uma apostila iniciante, basta saber que existe essa possibilidade de
documentar.

11
Exemplo em Python:

def soma(a, b): # define a função 'soma' com

parâmetros a e b
resultado = a + b # calcula a soma de a e b
return resultado # devolve o resultado da soma

x = 10
y = 7
total = soma(x, y) # chama a função soma com x e y;
armazena o retorno em 'total'
print(f"A soma de {x} e {y} é {total}") # imprime: A soma de 10 e 7 é 17

No exemplo acima, criamos uma função soma que recebe dois números ( a e b ) e retorna a soma
deles. Depois definimos x e y , e usamos soma(x, y) para obter a soma desses valores,
guardando em total . A função facilita somar quaisquer dois números que fornecermos, sem repetir
código de soma e print toda vez. Note que poderíamos simplesmente fazer print(soma(x, y))
diretamente também. Separar o cálculo do uso é útil porque talvez queiramos reutilizar soma em um
contexto diferente, não apenas imprimir.

Outro exemplo: função sem retorno explícito, apenas realizando ação:

def imprime_linha():
print("-" * 30)

imprime_linha() # Chama a função; ela imprime 30 hífens.

imprime_linha() # Podemos chamar de novo quantas vezes precisarmos.

Aqui imprime_linha não tem parâmetros e não retorna nada; toda vez que é chamada, ela
simplesmente imprime uma linha tracejada. Útil para separar visualmente saída, por exemplo. Essa
função retorna None implicitamente.

Pseudocódigo:

função soma(a, b):

resultado <- a + b
retorne resultado
fim função

x <- 10
y <- 7
saida <- soma(x, y)
escreva "A soma de ", x, " e ", y, " é ", saida

No pseudocódigo, definimos a função soma que retorna a soma de dois parâmetros. Depois
chamamos essa função passando x e y e usamos o valor retornado (armazenado em saida ) para
mostrar uma mensagem. O fluxo é análogo ao código Python, apenas adaptado à sintaxe de algoritmo.

12
(Dica: pensar em funções como "caixinhas" que recebem entrada (parâmetros) e produzem saída (retorno)
ajuda bastante. Quando seu programa estiver ficando grande, identifique tarefas repetitivas ou bem
definidas e transforme-as em funções. Isso deixa o código mais modular e legível.)

7. Coleções (estruturas de dados)

Chegamos aos tipos de dados estruturados, ou coleções, que permitem agrupar múltiplos valores em
uma única variável. Em vez de ter 5 variáveis para 5 números, você pode colocar todos em uma lista,
por exemplo. Python fornece algumas estruturas de dados embutidas muito poderosas e práticas:
listas, tuplas, conjuntos (sets) e dicionários (dict), entre outras. Vamos apresentar as principais:

• Listas ( list ): São coleções ordenadas e mutáveis de elementos. Itens em uma lista são
numerados por índices (a posição, começando em 0) e você pode modificar a lista após criá-la
(adicionar, remover, alterar elementos). Listas são definidas usando colchetes [] , com os
elementos separados por vírgulas. Exemplo: numeros = [1, 2, 3, 4] . Listas podem
misturar tipos (ex: mistura = [1, "Oi", True] é válido), mas geralmente usamos
elementos relacionados de mesmo tipo. Você acessa elementos por índice: numeros[0] é 1
(primeiro elemento). Lembre: o primeiro índice é 0, depois 1, 2, ... Isso vale para quase todas
estruturas ordenadas em Python.
• Tuplas ( tuple ): Parecidas com listas, mas são imutáveis – uma vez criada, você não consegue
alterar os elementos (não pode adicionar, remover ou mudar valores). Tuplas são definidas
usando parênteses () ou simplesmente separando por vírgulas. Exemplo: ponto = (10,
20) ou cores = "red", "green", "blue" . Por serem imutáveis, tuplas são usadas
quando você quer garantir que os dados não mudem ou para usar como chaves em dicionários
(que exigem objetos imutáveis). Acesso também por índices, começando em 0.
• Conjuntos ( set ): Coleções não ordenadas de elementos únicos (sem repetições). Útil quando
você quer armazenar itens sem ordem específica e evitar duplicatas (por exemplo, um conjunto
de tags, ou letras únicas de uma palavra). Definidos usando chaves {} ou a função set() .
Exemplo: vogais = {"a", "e", "i", "o", "u"} . Se você adicionar um elemento já
existente, o conjunto simplesmente não muda (pois não pode ter duplicata). Como não é
ordenado, você não acessa por índice, mas pode verificar presença ( if x in conjunto: ) ou
iterar sobre o set (a ordem de iteração é arbitrária).
• Dicionários ( dict ): São estruturas que mapeiam chaves a valores (também chamados de
arrays associativos ou mapas). Imagine um dicionário físico: você tem palavras (chaves) e
definições (valores). Em Python, dicionários usam chaves únicas (podem ser strings, números ou
até tuplas imutáveis) para associar a algum valor (que pode ser qualquer tipo). São definidos
com {chave: valor, chave2: valor2, ...} . Exemplo: aluno = {"nome": "Ana",
"idade": 22} . Para acessar um valor, você usa a chave: aluno["nome"] retorna "Ana" .
Você pode adicionar novas pares fazendo dict[chave_nova] = valor . A ordem dos
dicionários em Python 3.7+ acompanha a inserção (OrderedDict behavior by default), mas
logicamente não contamos com ordenação para lógica do programa, usamos as chaves para
acessar diretamente.

Essas coleções tornam fácil manipular grupos de dados. Por exemplo, iterar sobre uma lista de nomes,
verificar se um elemento pertence a um conjunto, ou buscar um valor pelo nome da chave no
dicionário.

Regras e boas práticas:

- Índices começam em 0: Reforçando, em listas e tuplas o primeiro elemento está no índice 0.
Portanto, o enésimo elemento está no índice n-1 . Isso é fonte comum de confusão para iniciantes,

13
mas acostume-se: meu_lista[0] é o primeiro item. Se tentar acessar um índice igual ou maior que o
tamanho da lista, você terá um erro IndexError .
- Listas são mutáveis: Você pode fazer minha_lista[2] = 99 para alterar o valor na posição 2, ou
usar métodos como append , remove , etc. Mutabilidade é útil, mas também requer cuidado se você
tem várias referências para a mesma lista (todas verão a modificação). Se não quiser que mude, use
tupla.
- Principais métodos de lista: append(x) adiciona um elemento ao final; pop(i) remove e retorna
o elemento no índice i (ou o último se i não for passado); remove(x) remove a primeira ocorrência do
valor x; len(lista) dá o tamanho; lista.sort() ordena a lista in-place; sorted(lista)
retorna uma nova lista ordenada (sem modificar a original).
- Slicing: Tanto strings, listas e tuplas permitem fatiamento (slicing): por exemplo lista[1:4] pega
uma sublista do índice 1 até 3 (4 não incluso). lista[:3] do início até 2, lista[4:] do índice 4 até
o final. lista[-1] é o último elemento (índices negativos contam do fim). Isso é bem útil para extrair
pedaços, mas cuidado para não sair do intervalo.
- Conjuntos para operações matemáticas: Sets suportam operações de conjunto: união ( set1 |
set2 ), interseção ( set1 & set2 ), diferença ( set1 - set2 ), diferença simétrica ( set1 ^ set2 ).
Podem ajudar a eliminar duplicatas de uma lista facilmente: set(minha_lista) resulta em um
conjunto com elementos únicos.
- Dicionários e chaves: As chaves de dicionário devem ser objetos imutáveis (int, float, string, tuple,
etc). Não pode usar lista como chave, por exemplo. Ao acessar ou definir um valor, use colchetes com a
chave: meu_dict[chave] . Para evitar erro ao acessar chave que pode não existir, ou ver se existe, use
o operador in (ex: if "nome" in aluno: ) ou o método get : aluno.get("nome") retorna o
valor ou None se não existir (pode passar um valor default: aluno.get("nome",
"desconhecido") ).
- Iterando em dicionários: Você pode iterar diretamente: for chave in meu_dict: percorre as
chaves. Ou usar meu_dict.items() para pegar par chave-valor, meu_dict.keys() para só chaves,
meu_dict.values() para só valores.
- Escolha da estrutura certa: Use lista quando precisa de ordem e possivelmente valores repetidos.
Use tupla para um conjunto fixo de valores que pertencem juntos e não mudam (ex: coordenadas x,y).
Use set para coleções de membros únicos e para testar rapidamente pertencimento. Use dicionário
quando tiver pares nome-valor para busca rápida por chave.

Exemplo (Lista) em Python:

frutas = ["maçã", "banana", "laranja"] # cria uma lista de frutas

print(frutas[0]) # acessa o primeiro elemento (índice 0): "maçã"
frutas.append("uva") # adiciona "uva" ao final da lista
print(frutas) # exibe ['maçã', 'banana', 'laranja', 'uva']
frutas.remove("banana") # remove o elemento "banana" da lista
print(frutas) # exibe ['maçã', 'laranja', 'uva']

No código acima, começamos com uma lista de 3 frutas. Usamos frutas[0] para obter "maçã".
Depois append para incluir "uva" no fim. Em seguida, removemos "banana" com remove . A lista vai
mudando após cada operação. Poderíamos também acessar frutas[-1] para ver o último item, ou
usar len(frutas) para ver o tamanho da lista. Note que após remover "banana", a lista agora tem 3
elementos e "laranja" passou a ocupar o índice 1.

Exemplo (Dicionário) em Python:

14
 precos = {"maçã": 3.5, "banana": 2.0, "laranja": 4.2}
# dicionário de preços de frutas
print(precos["banana"]) # acessa o valor associado à chave "banana": 2.0
precos["uva"] = 5.0 # adiciona um novo par chave:valor (uva: 5.0)
print(precos) # exibe {'maçã': 3.5, 'banana': 2.0, 'laranja':
4.2, 'uva': 5.0}

No exemplo do dicionário, criamos um dict onde as chaves são nomes de frutas e os valores são preços.
Ao fazer precos["banana"] obtemos 2.0. Depois adicionamos a chave "uva" com valor 5.0
simplesmente atribuindo a precos["uva"] . Impressa, vemos que o dicionário agora contém quatro
pares. Se tentarmos acessar uma chave que não existe, por exemplo precos["melancia"] ,
obteríamos um KeyError . Para evitar, poderíamos usar precos.get("melancia") que retornaria
None (ou um default se fornecêssemos).

Pseudocódigo (Lista):

frutas <- ["maçã", "banana", "laranja"]

escreva frutas[0] // Saída: maçã
adicione(frutas, "uva") // adiciona "uva" na lista frutas (função
hipotética adicione)
escreva frutas // Saída: [maçã, banana, laranja, uva]
remova(frutas, "banana") // remove "banana" da lista
escreva frutas // Saída: [maçã, laranja, uva]

Aqui, usamos pseudocódigo para demonstrar operações equivalentes: adicionando e removendo

elementos na lista de frutas. Não existe sintaxe padrão exata, então usamos adicione e remova
para ilustrar as ações.

Pseudocódigo (Dicionário):

precos <- {"maçã": 3.5, "banana": 2.0, "laranja": 4.2}

escreva precos["banana"] // Saída: 2.0
precos["uva"] <- 5.0 // adiciona chave "uva" com valor 5.0
escreva precos // Saída: {"maçã": 3.5, "banana": 2.0,
"laranja": 4.2, "uva": 5.0}

No pseudocódigo, mostramos o acesso a uma chave do dicionário (banana) e a adição de uma nova
chave (uva). Assim como em Python, usamos a sintaxe de colchetes para representar chave/valor.

(Resumo: as coleções permitem manipular conjuntos de dados de forma eficiente. Você pode iterar listas
facilmente, buscar rapidamente valores por chave em dicionários, garantir unicidade com sets, etc. Aprender
a usar essas estruturas é fundamental para escrever programas mais complexos e idiomáticos em Python.)

8. Strings (trabalhar com texto)

Strings são sequências de caracteres usadas para representar texto. Já vimos um pouco sobre elas nos
tipos primitivos, mas agora vamos nos aprofundar em como trabalhar com texto em Python de forma

15
efetiva. Como texto está em toda parte (mensagens, nomes, arquivos, etc.), manipular strings é uma
habilidade importante.

Em Python, uma string (tipo str ) é delimitada por aspas simples ou duplas. Por exemplo: "Hello"
ou 'Olá' são strings. Strings em Python são imutáveis, o que significa que você não pode alterar um
caractere específico de uma string existente (não dá para fazer minha_string[0] = 'A' ). Em vez
disso, se você quiser uma string modificada, você cria uma nova string a partir da original (por exemplo,
usando concatenação ou métodos). Mas não se preocupe: Python oferece muitos métodos úteis para
criar versões modificadas de strings sem esforço.

Algumas operações úteis com strings:

- Concatenação: usar + para juntar strings: "Bom " + "dia" resulta em "Bom dia" . Lembre-se
de converter outros tipos em str se quiser concatenar com strings, ou usar outra abordagem (ver
formatação).
- Repetição: usar * com inteiro: "ha" * 3 resulta em "hahaha" .
- Indexação e fatiamento: assim como listas, você pode acessar caracteres individuais por índice
(lembrando: índice 0 é o primeiro caractere). Ex: nome = "Python"; nome[1] é "y" . Também
pode fatiar: nome[:3] dá "Pyt" , nome[-1] dá "n" (último char).
- Comprimento: len(minha_string) retorna o número de caracteres na string.
- Métodos de string: Python tem vários métodos de string embutidos:
- s.lower() – retorna a string s em letras minúsculas.
- s.upper() – retorna s em maiúsculas.
- s.strip() – remove espaços em branco do início e fim da string (útil para limpar entradas).
- s.replace("antigo", "novo") – substitui todas ocorrências de "antigo" por "novo" em
s .
- s.split(delimitador) – divide a string em uma lista, usando um delimitador (por padrão
espaço). Ex: "a,b,c".split(",") produz ["a", "b", "c"] .
- s.find("sub") – retorna o índice da primeira ocorrência da substring "sub" em s (ou -1 se não
achar).
- Entre outros: isdigit() , startswith() , join() , etc. Você pode explorar a documentação ou
usar dir(str) para ver todos.
- Formatação de strings: Em vez de fazer muitas concatenações com + , Python oferece formas mais
elegantes para montar strings com variáveis. Atualmente, a mais recomendada é usar f-strings (f de
formatted strings). Basta colocar um f antes da string de aspas e dentro dela usar {} para inserir
expressões Python. Exemplo:

nome = "Carlos"
idade = 30
print(f"Meu nome é {nome} e eu tenho {idade} anos.")

Isso automaticamente formata a string inserindo os valores de nome e idade nos lugares das
chaves. F-strings são simples e poderosas – você pode até fazer cálculos dentro das chaves. Elas foram
introduzidas no Python 3.6 como forma melhorada de formatar strings 15 .
Outra opção mais antiga é usar str.format() , por exemplo: "Meu nome é {} e tenho {}
anos".format(nome, idade) , mas f-string é geralmente preferida por ser mais concisa e legível.
Também existe o operador % de formatação (estilo printf do C), mas hoje em dia f-string cobre bem as
necessidades.

16
Regras e boas práticas:
- Escolha das aspas: Você pode usar aspas simples ou duplas para definir strings, apenas seja
consistente. Um critério comum: use o tipo oposto do que aparece dentro da string para evitar escapes.
Ex: para string que contém uma citação "Ele disse 'olá'" , é mais fácil cercar com aspas duplas.
Se precisar literalmente de aspas do mesmo tipo, use \" ou \' para escapar.
- Strings multilinha: Para texto em múltiplas linhas, use aspas triplas """ ou ''' . Tudo que estiver
entre elas, incluindo quebras de linha, fará parte da string. Útil para mensagens longas ou preservar
formatação. Ex:

texto = """Linha1
Linha2
Linha3"""

Isso inclui as quebras de linha na string. Cuidado apenas com a indentação dessas aspas triplas no
código, pois o espaço em branco também será capturado.
- Imutabilidade: Lembre que métodos de string retornam novas strings. Se você faz s.upper() , o
retorno é a versão em maiúsculas, mas s original permanece igual se você não reatribuir. Então, faça
s = s.upper() se quiser atualizar a variável s . Isso é intencional; strings imutáveis evitam efeitos
colaterais inesperados.
- Eficiência na concatenação: Em Python, concatenar muitas strings com + em loop pode ser
ineficiente, porque strings são imutáveis e cada concatenação cria uma nova string. Em situações de
juntar pedaços repetidamente, prefira acumular em uma lista e usar "".join(lista_de_partes)
no final, ou usar io.StringIO . Mas para poucos concatenamentos não há problema. Em geral, para
formatações use f-string como dito.
- Caracteres especiais: Fique atento a caracteres especiais dentro de strings. \n representa nova
linha (newline), \t tabulação, etc. Se você quer colocar uma barra invertida real, escreva \\ . Python
também permite strings raw (cruas) prefixadas com r , que tratam backslashes como caracteres
normais (útil para caminhos de arquivo no Windows, regex, etc.). Ex: r"C:\novo\teste.txt" .
- Unicode: Python 3 lida com Unicode internamente, então você pode ter acentos e emojis em strings
normalmente. Só certifique que o encoding do seu script é UTF-8 (padrão). Ao ler entrada ou arquivos,
os caracteres especiais geralmente funcionam, mas se encontrar problemas, pode ser questão de
encoding da fonte de dados.

Exemplo em Python:

nome = "Maria"
saudacao = "Olá, " + nome + "!" # concatena strings (resulta em
"Olá, Maria!")
saudacao2 = f"Olá, {nome}!"
# usa f-string para formatar (mesmo resultado: "Olá, Maria!")
grito = nome.upper() # .upper() devolve "MARIA"
quantidade_letras = len(nome) # len("Maria") devolve 5 (número de
caracteres)
print(saudacao) # Saída: Olá, Maria!
print(saudacao2) # Saída: Olá, Maria!
print(grito) # Saída: MARIA
print(quantidade_letras) # Saída: 5

17
Nesse código, demonstramos várias operações: concatenação tradicional vs f-string (ambas produzem
"Olá, Maria!"), uso de método .upper() para obter "MARIA", e len para obter o comprimento da
string. Notamos que tanto saudacao quanto saudacao2 têm o mesmo valor final, mas a f-string
torna o código mais limpo. Se quiséssemos tudo em minúsculas, poderíamos usar nome.lower() . Se
quiséssemos substituir "Maria" por outro nome, .replace("Maria", "João") aplicado em uma
string maior funcionaria. Há muita flexibilidade com os métodos.

Outro exemplo, trabalhando com partes da string:

frase = "Python é divertido"

palavras = frase.split(" ") # divide a frase em lista de palavras
print(palavras) # Saída: ['Python', 'é', 'divertido']
print(frase[0:6]) # Saída: Python (caracteres do índice 0 ao
5)
ultima_palavra = palavras[-1] # pega a última palavra da lista
if ultima_palavra.endswith("do"):
print("A frase termina com 'do'.") # Este seria o caso aqui, pois
'divertido' termina com 'do'

Aqui usamos .split para quebrar a frase em palavras usando espaço como separador, mostramos
um fatiamento frase[0:6] que retorna "Python", e usamos .endswith para checar sufixo da
última palavra.

Pseudocódigo:

nome <- "Maria"

saudacao <- "Olá, " + nome + "!"
saudacao2 <- "Olá, " + nome + "!" // (pseudocódigo não tem f-string, então
usamos concat igualmente)
grito <- MAIUSCULO(nome) // supondo uma função que converta para
maiúsculas: "MARIA"
quantidade_letras <- comprimento(nome) // supondo função que dá o tamanho:
5
escreva saudacao // Saída: Olá, Maria!
escreva saudacao2 // Saída: Olá, Maria!
escreva grito // Saída: MARIA
escreva quantidade_letras // Saída: 5

No pseudocódigo, não temos f-string, então tratamos saudacao2 da mesma forma que saudacao .
Também presumimos funções genéricas MAIUSCULO() e comprimento() para ilustrar o
.upper() e len() respectivamente. A lógica é similar ao código Python.

(Strings são muito versáteis. Conforme avançar, você aprenderá sobre expressões regulares para buscas
complexas, ou formatação avançada. Mas por ora, dominar concatenação, métodos básicos e f-strings já
permite fazer praticamente tudo que um iniciante precisa em termos de manipulação de texto.)

18
9. Entrada e saída
Entrada e saída (I/O - Input/Output) são as formas de comunicar o programa com o "mundo externo":
ler dados do usuário (entrada) e mostrar resultados (saída). Em Python, as funções básicas para isso são
input() para entrada via teclado e print() para saída no console. Vamos ver como usá-las
efetivamente.

Entrada com input() :

A função input(prompt) pausa o programa e espera o usuário digitar algo no console, terminando
quando o usuário aperta Enter. Ela então retorna o texto digitado como string. O parâmetro prompt
é opcional – se fornecido, é uma mensagem exibida para o usuário antes da entrada (sem pular linha
automaticamente, você geralmente coloca um espaço no final do prompt). Exemplo: nome =
input("Qual é o seu nome? ") vai exibir a pergunta e aguardar o usuário digitar algo,
armazenando o texto em nome . Lembre-se que o resultado é sempre string, então se você espera um
número, precisa converter (ex: idade = int(input("Idade: ")) para obter um int).

Saída com print() :

A função print() exibe o que você passar para ela no console (por padrão) seguido de uma nova
linha. Você pode passar múltiplos argumentos separados por vírgula que serão impressos separados
por espaço. Por exemplo, print("Olá", nome) imprimirá "Olá <nome>" com espaço automático.
Alguns detalhes: - Por padrão, print adiciona end="\n" (quebra de linha) no final. Se não quiser
pular linha, você pode especificar end="" ou outro sufixo. Ex: print("Sem quebra", end="")
continua na mesma linha. - Você pode mudar o separador entre múltiplos argumentos usando sep .
Ex: print("a", "b", "c", sep="-") imprime a-b-c . - print converte tudo para string
automaticamente (chamando str() nos argumentos). Então você pode passar números, booleanos
etc., ele imprime direitinho. - Para imprimir sem espaço entre argumentos, defina sep="" .

Conversão de entrada:
É importantíssimo lembrar que input() retorna string. Então, se o usuário digita 25 e você espera
usar isso como número, faça a conversão: idade = int(input("Idade: ")) . Se o texto digitado
não puder virar int, o Python vai lançar um ValueError. Você pode tratar isso (ver seção de erros) ou
garantir via mensagem que o usuário insira corretamente. Existem funções de conversão built-in:
int(str) para inteiro, float(str) para float, bool(str) (cuidado, "False" retorna True porque
string não vazia é True; melhor comparar string explicitamente para booleans), etc.

Formatando saída:
Já mencionamos f-strings e format que ajudam a imprimir valores dentro de texto de forma elegante.
Por exemplo:

nome = "João"
idade = 20
print(f"{nome} tem {idade} anos.")

Isso escreve "João tem 20 anos." sem precisar fazer conversões ou concatenações manualmente. Use
esses recursos para que a saída fique amigável e clara.

Regras e boas práticas:

- Prompt claro: Sempre informe ao usuário o que ele deve digitar. input() sem prompt não mostra

19
nada e o programa parece travado esperando input. Então use mensagens como
input("Digite sua idade: ") . Torne as instruções claras (unidades, formato esperado, etc., se
necessário).
- Remover newline do input: O input() não inclui o newline final na string retornada (ele para
antes), então normalmente não precisa fazer .strip() . Mas se o usuário digitar espaços antes/
depois, esses farão parte da string. Pode ser bom usar .strip() para limpar espaços extras
dependendo do contexto.
- Validação de entrada: Nunca confie cegamente que o usuário digitou o que você esperava. Para
programas reais, é bom validar. Ex: usar .isdigit() para conferir que o input é numérico antes de
converter, ou tentar converter dentro de um bloco try/except (veja Tratamento de Erros). Em nosso
exemplo, vamos ilustrar um tratamento básico.
- Múltiplos inputs: Cada chamada de input() lê até o Enter. Se quiser ler vários valores em uma
linha, pode usar um input e depois .split() na string. Ex: valores = input("Digite dois
números separados por espaço: ").split() vai dar uma lista de strings. Então você faz a =
int(valores[0]); b = int(valores[1]) .
- Print não formatado vs formatado: Para debugging às vezes se faz print(repr(obj)) ou usar
logging, mas para o usuário final, formate de forma amigável. Não jogue estruturas brutas do Python
sem contexto. Prefira mensagens descritivas, por exemplo: em vez de print(lista) , se for
relevante, explique: print("Itens:", lista) . Em geral, planeje as saídas para serem fáceis de
entender.
- Arquivos e outros I/O: Fora do escopo imediato, mas Python pode ler/escrever arquivos com funções
open/read/write, e interagir com outros canais. Mas inicialmente, teclado e console são o foco.

Exemplo em Python:

nome = input("Qual é o seu nome? ") # pede ao usuário para

digitar o nome
print(f"Olá, {nome}!")
# exibe uma saudação usando o nome

idade_str = input("Quantos anos você tem? ") # lê a idade como string

try:
idade = int(idade_str) # tenta converter para int
print(f"Ano que vem você terá {idade + 1} anos.") # utiliza a idade em
cálculo e mostra resultado
except ValueError:
print("Ops, isso não parecia um número válido.") # trata caso não seja
possível converter para inteiro

Vamos supor uma interação possível no console:

Qual é o seu nome? João

Olá, João!
Quantos anos você tem? 30
Ano que vem você terá 31 anos.

Aqui o programa pediu o nome, cumprimentou o usuário pelo nome fornecido, depois pediu a idade,
converteu para número e calculou a idade no ano seguinte. Incluímos um try/except simples para

20
capturar o caso de a conversão falhar (por exemplo, se a pessoa digitar "trinta" em vez de 30),
imprimindo uma mensagem de erro amigável. (Veremos tratamento de erros com mais detalhes na
próxima seção, mas já demonstramos um uso.)

Note que ao usar input() , o cursor fica esperando o usuário digitar. Durante esse tempo, o
programa está "pausado". Após apertar Enter, a execução continua. Também note que não houve \n
explícito nos prints, mas cada print começa em nova linha automaticamente. Usamos f-string para
inserir a variável dentro da mensagem facilmente.

Pseudocódigo:

escreva "Qual é o seu nome? "

leia nome
escreva "Olá, ", nome, "!"
escreva "Quantos anos você tem? "
leia idade_texto
se (idade_texto for numérico) então
idade <- converteParaInteiro(idade_texto)
escreva "Ano que vem você terá ", idade + 1, " anos."
senão
escreva "Entrada inválida para idade."
fim se

No pseudocódigo acima, ilustramos a lógica da interação. Usamos leia para simbolizar o input do
usuário, e fazemos uma verificação simples se o texto lido é numérico antes de converter (não
especificamos exato como, mas supõe-se uma função ou condição que detecte isso). Em seguida,
mostramos a saída adequada.

(Dica: Teste seu programa interativamente para ver se as mensagens estão claras e as conversões corretas.
Uma boa experiência de usuário desde o terminal é importante – ninguém gosta de programas que não
dizem o que querem ou falham silenciosamente.)

10. Importações e módulos

Uma das forças do Python é sua vasta quantidade de módulos e bibliotecas reutilizáveis. Módulos são
arquivos Python com definições (variáveis, funções, classes) que podemos importar em outro script
para usar seus recursos. A palavra-chave para isso é import . Usar módulos evita reinventar a roda –
você pode aproveitar funcionalidades prontas da biblioteca padrão do Python ou instalar pacotes
externos conforme necessário.

Importando módulos:
- Importar inteiro: import nome_modulo – Isso carrega o módulo inteiro. Para usar as funções/
variáveis, você precisa prefixar com o nome do módulo. Exemplo: import math e depois
math.sqrt(16) para usar a função sqrt do módulo math.
- Importar específico: from nome_modulo import algo – Isso carrega apenas o item especificado
do módulo, permitindo usá-lo diretamente sem prefixo. Exemplo: from math import pi permite
usar pi diretamente. Você pode importar múltiplos itens separando por vírgulas:
from math import sin, cos, tan .
- Importar com alias: Às vezes módulos têm nomes longos, então você pode usar as para dar um

21
apelido. Exemplo: import numpy as np (np vira referência ao módulo numpy). Ou from math
import sqrt as raiz . Isso é útil para abreviar ou evitar conflito de nomes.
- Importar tudo (não recomendado): from nome_modulo import * importa todos os nomes
públicos do módulo para seu namespace. Evite isso, especialmente em códigos maiores, porque polui o
namespace e pode causar conflitos de nome difíceis de rastrear, além de prejudicar a legibilidade (não
se sabe de onde veio cada nome). É melhor importar explicitamente o que precisa ou o módulo todo.
- Módulos vs Pacotes: Um pacote é um diretório contendo módulos (geralmente identificado por um
arquivo __init__.py ). Você importa pacotes parecido com módulos. Ex: import
pacote.submodulo . A biblioteca padrão tem pacotes (como os , collections , etc.) e você
também instala pacotes externos via pip (ex: import numpy ).

A biblioteca padrão do Python inclui muitos módulos úteis: math (matemática básica), datetime
(datas e horas), random (geração de números aleatórios), os (interação com sistema operacional),
sys , json , etc. Consulte a documentação para ver a lista – vale a pena ter ideia do que já vem
pronto. Além disso, a comunidade Python oferece milhares de pacotes externos (por exemplo, requests
para requisições web, numpy/pandas para computação científica, etc.), mas esses precisam ser
instalados separadamente.

Regras e boas práticas:

- Importações no topo: Convenciona-se colocar todas as importações no início do arquivo/script 16 ,
em ordem (primeiro imports da stdlib, depois de terceiros, depois locais). Isso facilita ver as
dependências e evita import cíclico inadvertido.
- Uma por linha: Faça um import por linha para clareza 16 . Em vez de import sys, os , prefira:

import sys
import os

(Exceção é from module import x, y, z em uma linha, isso é ok porque são todos do mesmo
módulo).
- Alias significativos: Ao usar as , escolha abreviações padrão (por exemplo, np para numpy, plt
para matplotlib.pyplot, pd para pandas) ou algo claro. Não faça import math as m a menos que
muito repetitivo, pois math.sqrt já é curto o bastante. Aliases são mais para conveniência em
pacotes conhecidos ou muito longos.
- Não reinventar: Antes de codar algo complexo, veja se há um módulo que ajuda. Por exemplo, para
matemática avançada use math ou statistics , para manipulação de CSV use csv módulo, etc.
Saber buscar na docs ou internet "Python módulo para X" é valioso.
- Módulos próprios: Você pode criar seus próprios módulos. Se você salvar funções úteis em
util.py , por exemplo, pode usar import util e depois util.minha_func() . Se estiver
desenvolvendo um projeto multi-arquivos, esta é a forma de organizar. Lembre-se de que o diretório do
arquivo principal ou o PYTHONPATH devem estar configurados para encontrar esses módulos.
- Cuidado com nomes duplicados: Se você fizer from math import sqrt e também tiver sua
própria função chamada sqrt, haverá conflito. O último import vai prevalecer. Por isso, outra razão para
evitar from module import * . Em geral, tente evitar dar nomes a variáveis que colidam com
módulos comuns (por exemplo, não faça random = 5 se importou random módulo).
- Consultar documentação: A sintaxe geral vimos, mas cada módulo tem seu conteúdo. Use a
documentação ou funções de introspecção: help(math) ou dir(math) para listar coisas. Isso
ajuda a descobrir funções disponíveis.

Exemplo em Python:

22
 import math # importa o módulo math inteiro
raiz = math.sqrt(16) # usa a função sqrt do módulo math (deve
prefixar com math.)
print(raiz) # Saída: 4.0

from math import pi

# importa apenas a constante pi do módulo math
print(pi) # Saída: 3.141592653589793

Nesse exemplo, primeiro importamos math e usamos math.sqrt() . Depois importamos

especificamente pi de math, e podemos imprimir pi diretamente. Note que após from math
import pi , podemos usar pi sem escrever math. . Se tentássemos chamar sqrt sem o prefixo
após apenas esse import, daria erro, porque não fizemos from math import sqrt .

Outro exemplo, usando alias:

import datetime as dt
hoje = dt.date.today()
print("Data de hoje:", hoje)

Aqui importamos o módulo datetime como dt . Então usamos dt.date.today() para pegar a
data atual. A saída será algo como "Data de hoje: 2025-06-13" (ou a data do dia atual). Poderíamos
importar apenas date de datetime ( from datetime import date ), mas quisemos ilustrar alias.

Pseudocódigo:

// Em pseudocódigo, não há um padrão universal para importações.

// Podemos apenas comentar ou indicar que vamos usar uma biblioteca:
# usar biblioteca matemática
x <- raiz_quadrada(16) // supondo que sqrt vem da biblioteca matemática
escreva x // Saída: 4

# usar constante pi da biblioteca matemática

escreva PI // Saída: 3.14159...

No pseudocódigo acima, inserimos comentários para indicar import hipotético de uma biblioteca
matemática. Em seguida usamos uma função raiz_quadrada e a constante PI como se estivessem
disponíveis, similar ao exemplo Python. Pseudocódigos geralmente não detalham o mecanismo de
import, apenas assumem que certas funções estão disponíveis.

(Resumo: import é como chamar reforços – se seu programa precisa de algo que não vem "de fábrica" no
núcleo da linguagem, provavelmente há um módulo para isso. Aprender a navegar e utilizar módulos padrão
e externos expande muito o que você pode fazer com Python. E tudo começa com import .)

23
11. Tratamento de erros (try/except)
Por fim, vamos falar sobre tornar seu programa mais robusto contra erros e exceções. Em Python (e
outras linguagens), quando ocorre algo inesperado durante a execução – como tentar dividir por zero,
acessar um índice que não existe, converter um texto inválido em número, etc. – o Python lança uma
exceção. Se essa exceção não for tratada, o programa para e exibe uma mensagem de erro (traceback).
Entretanto, podemos tratar (capturar) exceções usando blocos try/except , de forma a lidar com o
problema de forma controlada, evitando o crash do programa e possivelmente informando o usuário
de maneira amigável.

Um bloco básico de tratamento de erros tem esta estrutura:

try:
# código que pode gerar uma exceção
except TipoDoErro:
# o que fazer se ocorrer esse tipo de erro

Você pode ter múltiplos excepts para tratar diferentes tipos de erro separadamente, e também um
except Exception: genérico para pegar qualquer outro erro não específico. Além disso, existe
finally: (opcional) para executar código que deve rodar independentemente de ter dado erro ou
não (por exemplo, fechar um arquivo), e else: (opcional) que executa se nenhuma exceção ocorreu
no try.

Funcionamento: Quando o Python executa o bloco try: , se nenhuma exceção ocorrer, ele ignora
todos os except e segue em frente (pode executar um else: se houver). Se ocorrer uma exceção
em algum ponto dentro do try, ele imediatamente pula o restante do bloco try e procura um except
cujo tipo de exceção corresponda. Ao encontrar, ele executa o bloco daquele except e depois sai do try/
except (não retorna ao try, ele termina ali). Se nenhuma cláusula except corresponder, a exceção "sobe"
para fora (como se o try não estivesse lá) e pode ser capturada mais acima ou resultar em término do
programa com traceback.

Exemplo de exceções comuns:

- ValueError : quando uma função recebe um valor do tipo certo mas com conteúdo inválido. Ex:
int("abc") lança ValueError (não pode converter "abc" em inteiro).
- ZeroDivisionError : dividir por zero, como 10/0 .
- IndexError : ao acessar índice fora do intervalo numa lista/tupla/str.
- KeyError : ao acessar uma chave inexistente em um dicionário.
- TypeError : quando tipo de dado não suporta certa operação. Ex: tentar somar string com número
sem conversão, ou chamar len(5) (int não tem len).
- FileNotFoundError : ao tentar abrir um arquivo que não existe.
- NameError : usar uma variável que não foi definida.
- SyntaxError : erro de sintaxe no código (mas esse acontece antes de rodar, então não entra em try/
except – é erro em tempo de compilação do script).

Ao tratar erros, você deve pensar: é esperado que esse erro possa acontecer? Por exemplo, se você
está convertendo entrada do usuário para int, sim, é bem possível que o usuário digite algo inválido.
Então use try/except ValueError para, por exemplo, pedir de novo ou mostrar mensagem. Se é um erro
realmente inesperado (um bug de lógica), às vezes é melhor deixar ele acontecer para você consertar o

24
código. Não tente engolir toda e qualquer exceção com except genérico sem pelo menos registrar ou
reemitir – isso pode mascarar bugs. Trate especificamente o que você espera e sabe como lidar.

Também é possível lançar exceções manualmente usando raise . Por exemplo, raise
ValueError("idade não pode ser negativa") se detectarmos uma condição inválida no nosso
programa. Isso interrompe normal fluxo e pode ser capturado por um try/except circundante. Você
pode criar exceções customizadas (classes) também, mas isso é avançado.

Regras e boas práticas:

- Especifique exceções sempre que possível: Use except NomeDaExcecao: em vez de um
except: genérico, a não ser que você realmente queira pegar qualquer erro. Isso evita capturar
exceções que você não pretendia e que seriam bugs lógicos. Por exemplo, no input de idade, pegar
ValueError faz sentido; não queremos capturar um KeyboardInterrupt ou MemoryError acidentalmente
com um except genérico.
- Mínimo de código dentro do try: Abrace no bloco try apenas o código que pode dar aquela exceção e
que você quer tratar. Evite envolver blocos enormes onde pode acontecer vários tipos de erros
diferentes que não são relacionados. Assim você lida caso a caso e evita pegar exceções que não
tinham a ver. Por exemplo, no nosso código de input, colocamos só a conversão e print no try, de forma
que o except ValueError se refere claramente à conversão falhada.
- Informe ou recupere-se graciosamente: Dentro de um except, faça algo útil – pode ser exibir uma
mensagem de erro amigável, usar um valor padrão, ou re-pedir entrada. Simplesmente fazer pass
dentro do except (ignorando silenciosamente) não é ideal, pois o programa continua mas algo deu
errado e o usuário nem sabe.
- finally para limpeza: Se seu código abre recursos externos (arquivos, conexões), use finally para
garantir fechamento/liberação. Ex:

file = open('dados.txt')
try:
# ler arquivo
finally:
file.close()

O bloco finally executa com ou sem erro, então o arquivo será fechado mesmo se ocorrer exceção
durante a leitura. (Observação: hoje usamos with open(...) as file: para gerenciar
automaticamente, mas entenda o conceito de finally).
- else em try/except: O bloco else (logo após as clausulas except) é executado se nenhum erro
ocorreu no try. É útil para colocar código que depende do sucesso do try, mas que não deve rodar se
ocorreu erro. Poderia ser usado, por exemplo, para só processar dados se a leitura de arquivo deu
certo. Não é extremamente comum, mas é bom saber que existe.
- Não abuse do except genérico: Um except Exception as e: no topo do seu código que envolve
tudo e só imprime "deu erro" para qualquer problema é péssimo para depuração. Se for usar except
genérico, pelo menos logue e ou mostre o erro real. Em programas de usuário final, talvez capture
genericamente para não explodir, mas internamente você ainda quer saber o que deu errado.

Exemplo em Python:

try:
num = int(input("Digite um número: "))
print(f"O dobro de {num} é {num * 2}.")

25
 except ValueError:
print("Você não digitou um número válido!")

Este exemplo é semelhante ao que mostramos na seção de I/O, mas reforça a ideia: se o usuário digitar
algo que int() não consegue converter (gerando ValueError), cairemos no except e avisaremos o
usuário. Caso contrário (input válido), o except é ignorado e tudo segue normal. Poderíamos adicionar
um else: após o except para imprimir "Conversão bem-sucedida!" só para ilustrar, mas não é
necessário aqui.

Outro exemplo com múltiplos except:

dividendo = input("Dividendo: ")

divisor = input("Divisor: ")
try:
a = float(dividendo)
b = float(divisor)
resultado = a / b
print("Resultado da divisão =", resultado)
except ValueError:
print("Por favor, digite apenas números.")
except ZeroDivisionError:
print("Não é possível dividir por zero!")

Aqui tratamos dois cenários: se a conversão para float falhar (ValueError) e se a divisão por zero ocorrer
(b=0 então a/b lança ZeroDivisionError). Note que a ordem dos except importa – Python vai tentar casar
a exceção na ordem escrita. Se tivéssemos um except genérico antes do específico, o específico nunca
seria alcançado. Portanto, escreva do mais específico para o mais genérico.

Se nenhuma exceção ocorre (ou seja, ambos inputs são números válidos e divisor não zero), o resultado
é calculado e exibido, e nenhum except roda.

Pseudocódigo:

tente:
leia num_texto
num <- converteParaInteiro(num_texto)
escreva "O dobro de ", num, " é ", num * 2
capture (ValorInvalido):
escreva "Você não digitou um número válido!"
fim tente

No pseudocódigo, usamos "tente/capture" para ilustrar try/except. Especificamos um tipo de erro

hipotético "ValorInvalido" análogo ao ValueError. A lógica segue o exemplo Python: tentar converter e,
em caso de problema, avisar o usuário.

(Tratamento de erros é como colocar airbags no seu programa. Você espera não precisar deles, mas se algo
der errado, eles estão lá para amortecer o impacto e permitir que o programa siga ou termine

26
graciosamente, em vez de simplesmente "quebrar". Use try/except nos pontos necessários, e seu programa
será muito mais confiável e amigável.) 17

Conclusão: Ufa! Com isso, cobrimos uma jornada completa pelos fundamentos do Python: variáveis,
tipos, operadores, estrutura de controle, loops, funções, estruturas de dados, strings, I/O e tratamento
de erros. Cada tópico desses é um alicerce para escrever programas úteis e robustos. Agora é praticar
bastante – experimente criar pequenos programas que utilizem esses conceitos. Divirta-se
programando em Python, e quando algo não sair como esperado, lembre-se: pesquise, debuge, e
aprenda com os erros (afinal, você sabe como tratá-los!). Boas codificações! 2 9

1 2 3 5 6 7 8 11 12 13 15 memoria.ifrn.edu.br
https://memoria.ifrn.edu.br/bitstream/handle/1044/2090/EBOOK%20-
%20INTRODU%C3%87%C3%83O%20A%20PYTHON%20%28EDITORA%20IFRN%29.pdf?sequence=1&isAllowed=y

4 Tipos Primitivos em Python

https://www.devponto.com/posts/tipos-primitivos-em-python/

9 14 Guia de Estilo Python - PEP 8 - DEV Community

https://dev.to/immurderer/guia-de-estilo-python-pep-8-lm8

10 16 Você sabe o que é PEP 8? - Guia para um Código Limpo e Eficiente | Paloma Falchi | Python |
DIO
https://www.dio.me/articles/voce-sabe-o-que-e-pep-8-guia-para-um-codigo-limpo-e-eficiente

17 Try e Except em Python - Entenda como lidar com erros | Asimov Academy
https://hub.asimov.academy/blog/try-except-python/

27