tds-lp

Apostila de Python

Disciplina: Lógica de Programação – Prof. Mauro Borges França

Curso: Técnico em Desenvolvimento de Sistemas Integrado ao Ensino Médio - TDS

Material: apostila de Python organizada na mesma sequência das aulas de lógica em Portugol (VisuAlg).

Sumário

Como encontrar um assunto: use este sumário para navegar pelos capítulos ou consulte o Índice por assunto no final da apostila. Nos arquivos digitais, os itens são clicáveis. No material impresso, procure pelo número da seção (ex.: 5.15), que aparece no título de cada seção.

• Capítulo 0 – Preparando o ambiente
• Capítulo 1 – Introdução: do algoritmo ao programa em Python
  • 1.1 – Conceitos iniciais
  • 1.2 – Método para a construção de algoritmos (vale também para Python)
  • 1.3 – Do Portugol para Python: o primeiro exemplo
  • 1.4 – Estrutura do programa em Python
  • 1.5 – Tipos básicos de dados (primitivos)
  • 1.6 – Constantes
  • 1.7 – Variáveis e formação de identificadores
  • 1.8 – Declaração e atribuição
  • 1.9 – Operadores aritméticos
  • 1.10 – Operadores relacionais
  • 1.11 – Operadores lógicos
  • 1.12 – Comandos de entrada e saída
  • 1.13 – Blocos de comandos e indentação
  • 1.14 – Prática
• Capítulo 2 – Estrutura Condicional (Parte 1)
  • 2.1 – Operadores relacionais
  • 2.2 – Operadores lógicos
  • 2.3 – Estruturas condicionais (estruturas de controle)
  • 2.4 – Vamos para a prática
• Capítulo 3 – Estrutura Condicional (Parte 2): match/case
  • 3.1 – Estrutura de seleção match/case
  • 3.2 – Comparação com o if/else
• Capítulo 4 – Estruturas de Repetição
  • 4.1 – Repetição baseada em contagem: for (estrutura PARA)
  • 4.2 – Repetição com teste no início: while (estrutura ENQUANTO)
  • 4.3 – Repetição com teste no final (estrutura REPITA)
  • 4.4 – Qual estrutura escolher?
• Capítulo 5 – Estrutura de Dados: Vetores (listas)
  • 5.1 – O que é um vetor?
  • 5.2 – A grande diferença: em Python, o índice começa em 0
  • 5.3 – Diferença entre variável simples e vetor
  • 5.4 – Criação de um vetor
  • 5.5 – Índices e posições
  • 5.6 – Limites do vetor
  • 5.7 – Atribuição direta de valores
  • 5.8 – Leitura de valores em um vetor
  • 5.9 – Exibição dos valores
  • 5.10 – Percurso em ordem normal e inversa
  • 5.11 – Soma dos valores de um vetor
  • 5.12 – Cálculo da média
  • 5.13 – Contagem de valores
  • 5.14 – Exibição de valores que atendem a uma condição
  • 5.15 – Maior valor do vetor
  • 5.16 – Menor valor do vetor
  • 5.17 – Maior e menor valor no mesmo programa
  • 5.18 – Localização da posição do maior valor
  • 5.19 – Busca de um valor no vetor
  • 5.20 – Alteração de uma posição
  • 5.21 – Capacidade e quantidade preenchida
  • 5.22 – Vetores paralelos
  • 5.23 – Exemplo completo: análise de notas
  • 5.24 – Erros comuns no uso de vetores em Python
  • 5.25 – Resumo
  • 5.26 – Atividades de fixação
• Capítulo 6 – Estrutura de Dados: Matriz
  • 6.1 – O que é uma matriz
  • 6.2 – Criação de uma matriz
  • 6.3 – Acesso aos elementos
  • 6.4 – Leitura e escrita em matrizes
  • 6.5 – Exibindo a matriz em formato de tabela
  • 6.6 – Média de cada aluno (cálculo por linha)
• Capítulo 7 – Procedimentos (funções sem retorno)
  • 7.1 – O que são funções e procedimentos?
  • 7.2 – Procedimentos em Python
  • 7.3 – Organizando as listas de exercícios com menu
  • 7.4 – Como escrever um procedimento em Python
  • 7.5 – Onde colocar e como chamar o procedimento
  • 7.6 – Exemplo completo: uma lista com menu
  • 7.7 – Como adaptar um exercício que você já resolveu
  • 7.8 – Cuidados importantes
• Capítulo 8 – Funções
  • 8.1 – O que são funções?
  • 8.2 – Estrutura básica de uma função em Python
  • 8.3 – Tipos de funções quanto aos parâmetros
  • 8.4 – Como chamar uma função
  • 8.5 – Parâmetros e argumentos
  • 8.6 – Tipos de retorno das funções
  • 8.7 – Compare os exemplos
  • 8.8 – Retornar não é o mesmo que exibir
  • 8.9 – Programa completo com todas as funções da aula
  • 8.10 – Como planejar uma função simples
  • 8.11 – Dicas importantes
• Apêndice – Tabela de equivalência Portugol × Python
• Índice por assunto

Apresentação

Durante as aulas de Lógica de Programação, construímos algoritmos em Portugol usando o VisuAlg. Agora vamos escrever os mesmos algoritmos em Python.

A ideia central desta apostila é simples: a lógica vem antes da linguagem. Todos os exemplos seguem a mesma sequência das aulas, com os mesmos nomes de variáveis e o mesmo raciocínio. O que muda é a forma de escrever.

ENTRADA → receber os dados
   ↓
PROCESSAMENTO → realizar cálculos e decisões
   ↓
SAÍDA → apresentar os resultados

Sequência da apostila

Observação: em cada capítulo há uma tabela Portugol → Python com a tradução dos comandos estudados. Consulte-a sempre que estiver convertendo um algoritmo seu para Python.

Capítulo 0 – Preparando o ambiente

Ano: 1991
Criador/origem: Guido van Rossum
Responsável atual: Python Software Foundation (PSF)
Tipagem: Dinâmica
Forma de execução: Interpretada/bytecode em VM
IDE/editor indicado: PyCharm

No VisuAlg, escrevíamos e executávamos o algoritmo no mesmo programa. Em Python acontece algo parecido: o interpretador lê o arquivo .py e executa as instruções, sem uma etapa separada de compilação feita pelo aluno.

main.py → interpretador Python → execução

Links

• Python
• PyCharm

Passo a passo

1. Baixe o Python pelo site oficial e execute o instalador para Windows.
2. Na instalação, habilite a opção que permite usar Python pelo terminal (normalmente indicada como adicionar Python ao PATH).
3. Abra um novo PowerShell e execute python --version. Em algumas instalações do Windows, também é possível usar py --version.
4. Baixe e instale o PyCharm.
5. Abra o PyCharm e escolha New Project. Selecione um interpretador Python instalado; o PyCharm também pode criar um ambiente virtual para o projeto.
6. Crie o arquivo main.py e cole o código.
7. Clique com o botão direito no arquivo e escolha Run main, ou execute no terminal com python main.py.

Versão do Python: o Capítulo 3 usa o comando match/case, disponível a partir do Python 3.10. Instale sempre uma versão atual.

Capítulo 1 – Introdução: do algoritmo ao programa em Python

1.1 – Conceitos iniciais

• Programação: ato de escrever instruções para que máquinas executem uma determinada função ou várias funções encadeadas.
• Lógica de programação: metodologia para resolver problemas, criando uma sequência organizada de passos.
• Algoritmo: sequência finita e ordenada de passos para atingir um objetivo.
• Linguagem de programação: conjunto de regras usado para escrever o algoritmo de forma que o computador consiga executá-lo. Em nosso caso, Python.

1.2 – Método para a construção de algoritmos (vale também para Python)

1. Compreender completamente o problema a ser resolvido;
2. Definir os dados de entrada;
3. Definir o processamento (cálculos e restrições);
4. Definir os dados de saída;
5. Construir o algoritmo (agora, o programa em Python);
6. Testar realizando simulações (teste de mesa e execução).

1.3 – Do Portugol para Python: o primeiro exemplo

Na aula de introdução, fizemos um algoritmo que multiplica dois números:

Algoritmo "semnome"
Var
   n1, n2, m: inteiro
Inicio
   escreva("Digite dois números")
   leia(n1)
   leia(n2)
   m:= n1 * n2
   escreva("O resultado é =",m)
Fimalgoritmo

O mesmo algoritmo em Python:

# Disciplina  : Lógica de Programação
# Professor   : Mauro Borges França
# Descrição   : Multiplicar dois números inteiros
# Autor(a)    : Nome do(a) aluno(a)
# Data atual  : 05/10/2026

print("Digite dois números")
n1 = int(input())
n2 = int(input())

m = n1 * n2

print("O resultado é =", m)

Repare como o programa ficou menor: em Python não é preciso declarar as variáveis antes nem escrever Inicio e Fimalgoritmo.

1.4 – Estrutura do programa em Python

No Portugol, a estrutura era: INÍCIO → DECLARAÇÃO DE VARIÁVEIS → SEÇÃO DE COMANDOS → FIM. Em Python, o programa começa na primeira linha e termina na última:

# Seção 1 - Identificação: título, descrição, autor e data (comentários)

# Seção 2 - Variáveis: são criadas no momento da primeira atribuição

# Seção 3 - Comandos de entrada, processamento e saída

Atenção: Python diferencia letras maiúsculas de minúsculas: soma, Soma e SOMA são três nomes diferentes. Não é necessário usar ; no final das instruções.

1.5 – Tipos básicos de dados (primitivos)

Observações importantes:

• Em Python, o número real usa ponto: 1.73, e não 1,73.
• Textos podem ser escritos entre aspas duplas ("Olá") ou simples ('Olá').
• Os valores lógicos são True (verdadeiro) e False (falso), com a primeira letra maiúscula.
• Python tem tipagem dinâmica: o tipo é definido pelo valor guardado. A função type() mostra o tipo: print(type(altura)) exibe <class 'float'>.

1.6 – Constantes

Python não possui um comando específico para constantes. Por convenção, nomes escritos em letras maiúsculas indicam valores que não devem ser alterados:

PI = 3.14159
ANO_ATUAL = 2026

1.7 – Variáveis e formação de identificadores

As regras são as mesmas do Portugol, com alguns cuidados:

• Devem começar por uma letra (ou _);
• Podem ser seguidos por letras, números ou _;
• Não podem ter espaços ou caracteres especiais;
• Não podem ser palavras reservadas (if, for, while, def, return, True…).

Boa prática: embora o Python aceite acentos em nomes de variáveis (média), evite-os. Use media, ano_nascimento, qtd_pares.

1.8 – Declaração e atribuição

No Portugol, declarávamos nome: tipo e atribuíamos com <-. Em Python, basta atribuir com =; a variável é criada nesse momento:

nome = "Vagner"
idade = 18
nota = 93.5
peso = 71.63

1.9 – Operadores aritméticos

1.10 – Operadores relacionais

Cuidado: em Python, = é atribuição e == é comparação.

1.11 – Operadores lógicos

As tabelas-verdade são exatamente as mesmas estudadas nas aulas:

1.12 – Comandos de entrada e saída

Ponto de atenção: input() sempre retorna texto (str). Para fazer cálculos, é preciso converter: int() para inteiros e float() para reais. Se esquecer a conversão, "5" + "3" resulta em "53" (junção de textos), e não em 8!

O input() pode exibir a mensagem e ler o valor na mesma linha:

nome = input("Digite seu nome: ")
idade = int(input("Digite sua idade: "))

print("Mauro Borges França")
print("Nome:", nome)

Formatando a saída com f-strings

Uma f-string é um texto com a letra f antes das aspas. Dentro dele, colocamos variáveis entre chaves { }:

media = 7.456
print(f"Média: {media:.2f}")    # Média: 7.46  (equivale a media:4:2)
print(f"Nome: {nome}, idade: {idade}")

1.13 – Blocos de comandos e indentação

Muito importante: no VisuAlg, a indentação era uma boa prática. Em Python, a indentação é obrigatória: é ela que define quais comandos pertencem a um bloco. Use sempre 4 espaços (o PyCharm faz isso automaticamente ao pressionar Tab). Uma indentação errada causa IndentationError ou muda a lógica do programa.

Algoritmo calcula_idade em Python:

# Disciplina  : Lógica de Programação
# Professor   : Mauro Borges França
# Descrição   : Calcular a idade dos clientes do cinema
# Data atual  : 05/10/2026

print("Favor forneça o nome do cliente:")
nome = input()

print("Entre com seu ano de nascimento:")
ano_nascimento = int(input())

ano_atual = 2026
idade = ano_atual - ano_nascimento

print("A idade do cliente é:", idade)

Como este programa não possui estruturas de controle, todas as linhas ficam encostadas à esquerda. Nos próximos capítulos, os comandos dentro de if, for e while serão recuados.

1.14 – Prática

Dicas básicas:

• Coloque o cabeçalho com nome do programa, autor, descrição e data (em comentários #);
• Use nomes de variáveis claros;
• Converta as entradas numéricas com int() ou float();
• Pense logicamente no desenvolvimento do problema e faça as operações;
• Calcule e mostre o que se pede;
• Execute e teste com valores cujo resultado você conhece;
• Salve o arquivo .py no pendrive ou na nuvem.

Exercício 1 – Acesso ao cinema

O dono de uma rede de cinemas deseja fazer a indicação de filmes de acordo com a faixa etária de seus clientes. Para automatizar o processo, crie um programa em Python que receba o nome e o ano de nascimento do cliente e mostre quantos anos ele fez (ou fará) neste ano.

Exercício 2 – As quatro operações

Uma professora de matemática deseja fazer um experimento com seus alunos. Ela precisa de um programa em Python em que seja possível informar dois números inteiros e visualizar o resultado das quatro operações (adição, subtração, multiplicação e divisão) realizadas entre eles.

Capítulo 2 – Estrutura Condicional (Parte 1)

2.1 – Operadores relacionais

Permitem comparar dois valores do mesmo tipo básico. O resultado sempre será um valor lógico: True (verdadeiro) ou False (falso).

Exemplo: print(5 > 10) exibe False.

Exemplos de expressões comparativas

Suponha x igual a 10:

2.2 – Operadores lógicos

2.2.1 – Assimilando o operador and (“e”)

Suponha x igual a 10:

Observação: todas as condições devem ser verdadeiras para o resultado da expressão ser verdadeiro.

Exemplo – João quer jogar futebol. Ele precisa terminar a lição de casa e o tempo precisa estar ensolarado.

licao_de_casa = input("João terminou a lição de casa? (S/N): ")
tempo_ensolarado = input("O tempo está ensolarado?.......(S/N): ")

if (licao_de_casa == "S") and (tempo_ensolarado == "S"):
    print("João pode sair de casa")
else:
    print("João não pode sair de casa")

Atenção à sintaxe do if em Python:

• não existe entao: no lugar dele, usamos dois-pontos (:);
• não existe fimse: o bloco termina quando a indentação volta para a esquerda;
• os parênteses em volta das condições são opcionais, mas ajudam na leitura.

2.2.2 – Assimilando o operador or (“ou”)

Suponha x igual a 10:

Observação: pelo menos uma das condições deve ser verdadeira para o resultado ser verdadeiro.

Exemplo – Mariana quer assistir TV. Basta terminar a lição de casa ou ser final de semana.

licao_de_casa = input("Mariana terminou a lição de casa? (S/N): ")
final_de_semana = input("É final de semana?.................(S/N): ")

if (licao_de_casa == "S") or (final_de_semana == "S"):
    print("Mariana pode assistir TV")
else:
    print("Mariana não pode assistir TV")

2.2.3 – Assimilando o operador not (“não”)

Suponha x igual a 10:

Observação: o operador not sempre inverte o resultado da expressão lógica, de F para V ou de V para F.

Exemplo – Carlos quer jogar videogame. Ele só pode jogar se não houver tarefas pendentes.

tarefas_pendentes = input("Carlos tem tarefas pendentes? (S/N): ")

if not (tarefas_pendentes == "S"):
    print("Carlos pode jogar videogame")
else:
    print("Carlos não pode jogar videogame")

Dica: se o usuário digitar s minúsculo, a comparação com "S" será falsa. Para aceitar as duas formas, use input(...).upper(), que converte o texto digitado para maiúsculas.

2.3 – Estruturas condicionais (estruturas de controle)

Conceito: uma estrutura condicional permite que um bloco de comandos seja executado somente quando uma condição específica for satisfeita, alterando o fluxo de execução do programa.

2.3.1 – Estrutura condicional simples

if condicao:
    comando1
    comando2
    comandoN

• Verdadeiro: executa o bloco de comandos;
• Falso: pula o bloco de comandos.

# Descrição   : Exemplo de estrutura condicional simples
# Autor(a)    : Mauro Borges França

# Entrada de dados
idade = int(input("Digite a sua idade: "))

# Estrutura condicional simples
if idade >= 18:
    print("Você é maior de idade!")

2.3.2 – Estrutura condicional composta

if condicao:
    comando1
    comandoN
else:
    comando3
    comandoN

• Verdadeiro: executa somente o bloco do if;
• Falso: executa somente o bloco do else.

# Descrição   : Exemplo de estrutura condicional composta
# Autor(a)    : Mauro Borges França

# Entrada de dados
idade = int(input("Digite a sua idade: "))

# Estrutura condicional composta
if idade >= 18:
    print("Você é maior de idade!")
else:
    print("Você é menor de idade!")

2.3.3 – E se eu tiver mais de duas possibilidades?

Tradicionalmente, uma população é dividida em três faixas etárias:

• Jovens: até 19 anos;
• Adultos: de 20 até 59 anos;
• Idosos: 60 anos em diante.

No Portugol, colocávamos um se dentro do senao. Em Python, podemos fazer o mesmo:

if condicao1:
    comando1
else:
    if condicao2:
        comando2
    else:
        comando3

Porém, Python oferece o elif (abreviação de else if), que deixa o encadeamento mais limpo. As duas formas têm a mesma lógica:

if condicao1:
    comando1
elif condicao2:
    comando2
else:
    comando3

# Descrição   : Estrutura condicional composta com mais de duas possibilidades
# Autor(a)    : Mauro Borges França

# Entrada de dados
idade = int(input("Digite a sua idade: "))

# Estrutura condicional com mais de duas possibilidades
if idade <= 19:
    print("Você é uma pessoa jovem!")
elif (idade >= 20) and (idade <= 59):
    print("Você é uma pessoa adulta!")
else:
    print("Você é uma pessoa idosa!")

Curiosidade: em Python, a condição (idade >= 20) and (idade <= 59) também pode ser escrita como 20 <= idade <= 59.

2.4 – Vamos para a prática

Dicas básicas para um melhor desempenho:

• Coloque o cabeçalho do programa (nome, autor, descrição e data);
• Converta as entradas numéricas com int() ou float();
• Pense logicamente no desenvolvimento do problema;
• Utilize as estruturas condicionais, calcule e mostre o que se pede;
• Confira os dois-pontos no final de cada if, elif e else;
• Confira a indentação de cada bloco;
• Faça o teste de mesa e teste com valores que caiam em todas as condições.

Atividades de fixação

1. Leia um número inteiro e informe se ele é positivo, negativo ou zero.
2. Leia duas notas, calcule a média e informe “Aprovado” (média maior ou igual a 6), “Recuperação” (média entre 4 e 5.9) ou “Reprovado” (média menor que 4).
3. Leia um número inteiro e informe se ele é par ou ímpar (use o operador %).
4. Leia a idade e informe se a pessoa pode votar de forma obrigatória (18 a 70 anos), facultativa (16, 17 ou acima de 70) ou se não pode votar (menos de 16).

Capítulo 3 – Estrutura Condicional (Parte 2): match/case

3.1 – Estrutura de seleção match/case

Conceito: a estrutura escolha-caso do Portugol corresponde ao match/case em Python (disponível a partir do Python 3.10). Ela é utilizada quando temos vários if/else aninhados que testam o valor de uma mesma variável, permitindo ir direto ao bloco desejado.

match variavel:
    case 1:
        comando1
        comandoN
    case 2:
        comando1
        comandoN
    case 3:
        comando1
        comandoN
    case _:
        comando1
        comandoN

Observações:

• O case _: (sublinhado) equivale ao outrocaso: é executado quando nenhum caso anterior foi atendido.
• Diferente do C, não é necessário break: apenas o bloco do caso correspondente é executado, como no VisuAlg.
• O match funciona com números e também com textos: case "S":.
• Cuidado: depois do case escreva valores (como 1, 2 ou "S"), e não nomes de variáveis. Em case opcao_valida:, o Python não compara com a variável: ele entende o nome como um “coringa” que aceita qualquer valor.

3.2 – Comparação com o if/else

Versão com if/else aninhados (exatamente como no Portugol):

# Descrição   : Exercício - Dia da semana - com if/else
# Autor(a)    : Professor Mauro Borges França

dia = int(input("Digite um número de 1 a 7: "))

if dia == 1:
    print("Domingo")
else:
    if dia == 2:
        print("Segunda-feira")
    else:
        if dia == 3:
            print("Terça-feira")
        else:
            if dia == 4:
                print("Quarta-feira")
            else:
                if dia == 5:
                    print("Quinta-feira")
                else:
                    if dia == 6:
                        print("Sexta-feira")
                    else:
                        if dia == 7:
                            print("Sábado")
                        else:
                            print("Número inválido")

Observação: veja como os if/else aninhados deixam o código mais complexo e “empurrado” para a direita. Veja o mesmo programa com match:

# Descrição   : Exercício - Dia da semana - estrutura match/case
# Autor(a)    : Professor Mauro Borges França

dia = int(input("Digite um número de 1 a 7: "))

print("Dia da semana: ", end="")
match dia:
    case 1:
        print("Domingo")
    case 2:
        print("Segunda-feira")
    case 3:
        print("Terça-feira")
    case 4:
        print("Quarta-feira")
    case 5:
        print("Quinta-feira")
    case 6:
        print("Sexta-feira")
    case 7:
        print("Sábado")
    case _:
        print("Número inválido")

Observação: bem mais organizado. A lógica dos dois programas é a mesma; para algumas soluções, o match é mais adequado.

Outra observação: o case _ é opcional, assim como o outrocaso, mas é muito útil e será utilizado na maioria das aplicações.

3.2.1 – A mesma solução com elif

Também é muito comum, em Python, resolver esse problema com elif. É uma alternativa válida para quem usa versões anteriores ao Python 3.10:

dia = int(input("Digite um número de 1 a 7: "))

if dia == 1:
    print("Domingo")
elif dia == 2:
    print("Segunda-feira")
elif dia == 3:
    print("Terça-feira")
elif dia == 4:
    print("Quarta-feira")
elif dia == 5:
    print("Quinta-feira")
elif dia == 6:
    print("Sexta-feira")
elif dia == 7:
    print("Sábado")
else:
    print("Número inválido")

3.2.2 – Vários valores para o mesmo bloco

Usamos a barra vertical | (lê-se “ou”) para agrupar valores:

match dia:
    case 1 | 7:
        print("Fim de semana")
    case 2 | 3 | 4 | 5 | 6:
        print("Dia útil")
    case _:
        print("Número inválido")

Atividades de fixação

1. Leia um número de 1 a 12 e mostre o nome do mês correspondente.
2. Leia dois números reais e um símbolo de operação (+, -, * ou /) e mostre o resultado da operação escolhida (use match com texto).
3. Reescreva com match/case um dos seus exercícios de if/else da Lista de Estrutura Condicional.

Capítulo 4 – Estruturas de Repetição

Conceito: uma estrutura de repetição (também conhecida como laço ou loop) repete um bloco de comandos várias vezes, enquanto uma condição for verdadeira ou durante um número determinado de vezes.

Contexto: lembra do algoritmo que calcula a média de um aluno? Se forem 50 alunos, não faz sentido escrever o mesmo código 50 vezes. Escrevemos uma vez e usamos uma estrutura de repetição.

4.1 – Repetição baseada em contagem: for (estrutura PARA)

Utilizada quando se sabe o número de vezes que um trecho deve ser repetido.

Para <variavel> de <valor-inicial> ate <valor-final> [passo <incremento>] faca
   <comandos>
fimpara

Em Python, o for percorre uma sequência de números gerada pela função range():

for variavel in range(inicio, fim, passo):
    comandos

Atenção – o valor final NÃO entra! range(1, 11) gera os números de 1 até 10. Por isso, para repetir “de 1 até 10”, escrevemos range(1, 11).

Exemplo 1 – Estrutura for:

# Descrição   : Exemplo para demonstrar a estrutura for (PARA)

for i in range(1, 11):
    print("Número ->", i)

Explicação:

• i é a variável que funciona como contador;
• range(1, 11) define que o laço começa em 1 e termina em 10;
• a cada repetição, o print mostra o valor atual de i.

Número -> 1
Número -> 2
Número -> 3
...
Número -> 10

Exemplo 2 – Soma de 1 a 100:

# Descrição   : Somar os 100 primeiros números com for

soma = 0
for i in range(1, 101):
    soma = soma + i

print("A soma dos números de 1 até 100 é:", soma)

Explicação:

• A variável soma começa com 0 (acumulador inicializado);
• O laço percorre todos os números de 1 até 100;
• A cada repetição, o valor de i é adicionado à soma;
• No final, o programa exibe o total acumulado: 5050.

Dica: soma = soma + i também pode ser escrito como soma += i.

4.2 – Repetição com teste no início: while (estrutura ENQUANTO)

Utilizada quando não se sabe o número de vezes que um trecho deverá ser repetido. O bloco é executado enquanto a condição for verdadeira. Se a condição já começar falsa, o bloco não é executado nenhuma vez.

Exemplo 1 – Contar com while:

# Descrição   : Exemplo para demonstrar a estrutura while (ENQUANTO)

contador = 1

while contador <= 5:
    print("Número:", contador)
    contador = contador + 1

print("Saiu do laço")

Explicação:

• O laço começa com contador = 1 e vai até 5;
• A cada volta, mostra o número e soma 1;
• Quando contador passa a valer 6, a condição fica falsa, o programa sai do laço e executa o primeiro comando após a estrutura (a linha sem recuo).

Cuidado – laço infinito: se esquecer a linha contador = contador + 1, a condição nunca ficará falsa. Para interromper, use o botão Stop do PyCharm ou Ctrl + C no terminal.

Exemplo 2 – Ler números até digitar zero:

# Descrição   : Ler números até o usuário digitar zero (while)

numero = int(input("Digite um número (0 para sair): "))

while numero != 0:
    print("Você digitou:", numero)
    numero = int(input("Digite outro número (0 para sair): "))

print("Programa encerrado.")

Explicação:

• O laço continua pedindo números enquanto o valor digitado for diferente de 0 (!=);
• Quando o usuário digita 0, o laço termina;
• Se o usuário digitar 0 logo no início, o laço nem começa.

4.3 – Repetição com teste no final (estrutura REPITA)

Python não possui um comando repita (nem do/while). Para garantir que o bloco seja executado pelo menos uma vez e testar a condição no final, usamos um padrão muito comum:

while True:          # repita
    comandos
    if condicao:     # ate (condicao)
        break

• while True cria um laço que, sozinho, não terminaria;
• O if condicao: break no final do bloco faz o papel do ate: quando a condição for verdadeira, o break interrompe o laço.

Vantagem: a condição do if é a mesma do ate no Portugol. Não é preciso invertê-la.

Exemplo 1 – Contar com repita:

# Descrição   : Simulando a estrutura REPITA em Python

contador = 1
while True:
    print("Número:", contador)
    contador = contador + 1
    if contador > 5:        # Portugol: ate (contador > 5)
        break

print("Saiu do laço")

Exemplo 2 – Ler números com repita:

# Descrição   : Ler números até o usuário digitar zero (repita)

while True:
    numero = int(input("Digite um número (0 para sair): "))
    if numero == 0:         # Portugol: ate (numero = 0)
        break

print("Programa encerrado.")

Explicação:

• O laço garante que o número será lido pelo menos uma vez;
• O processo se repete até o usuário digitar 0.

4.4 – Qual estrutura escolher?

Atividades de fixação

1. Mostre a tabuada de um número informado pelo usuário (de 1 a 10) usando for.
2. Mostre os números pares de 0 a 50 usando range com passo 2.
3. Leia as notas de uma turma até que seja digitada uma nota negativa. Ao final, mostre a quantidade de notas e a média (use while).
4. Leia uma senha numérica até que o usuário digite 1234 (use while True + break).
5. Calcule o fatorial de um número inteiro informado pelo usuário.

Capítulo 5 – Estrutura de Dados: Vetores (listas)

Objetivos

Ao final deste capítulo, o estudante deverá ser capaz de:

• compreender o conceito de vetor e como ele é representado em Python;
• diferenciar uma variável simples de uma variável composta;
• criar vetores (listas) em Python;
• acessar, preencher e alterar posições de um vetor;
• percorrer vetores em ordem normal e inversa;
• realizar cálculos utilizando os valores armazenados;
• localizar elementos em um vetor;
• identificar erros comuns no uso de índices.

5.1 – O que é um vetor?

Um vetor, também chamado de array, é uma variável composta homogênea de uma dimensão. Ele:

• armazena vários valores;
• armazena valores do mesmo tipo;
• utiliza um único nome;
• organiza os valores em posições;
• identifica cada posição por meio de um índice.

Em Python, usamos a lista (list) para representar um vetor. Considere cinco idades: 18, 20, 17, 22, 19. Em vez de criar cinco variáveis:

idade1 = 18
idade2 = 20
idade3 = 17
idade4 = 22
idade5 = 19

podemos criar apenas uma lista:

idades = [18, 20, 17, 22, 19]

Observação: a lista do Python é mais flexível que o vetor do VisuAlg: pode mudar de tamanho e até guardar tipos diferentes. Nesta disciplina, vamos usá-la como um vetor: tamanho definido e valores do mesmo tipo.

5.2 – A grande diferença: em Python, o índice começa em 0

No VisuAlg, declarávamos vetor[1..5] e as posições iam de 1 a 5. Em Python, o primeiro índice é sempre 0. Uma lista de 5 posições tem os índices 0, 1, 2, 3 e 4.

Assim, idades[0] representa o valor 18 e idades[3] representa o valor 22.

Dica: para mostrar ao usuário “1º número”, “2º número”…, usamos i + 1 na mensagem, mas guardamos o valor em numeros[i].

Características de um vetor

• É uma estrutura de dados simples;
• Possui uma quantidade definida de posições;
• Armazena dados do mesmo tipo;
• Permite acesso direto a qualquer posição;
• Utiliza índices para identificar os elementos;
• Serve de base para estruturas mais complexas, como matrizes, listas, filas e pilhas.

5.3 – Diferença entre variável simples e vetor

5.4 – Criação de um vetor

Para criar um vetor com uma quantidade definida de posições, multiplicamos uma lista de um elemento pela quantidade desejada:

notas = [0.0] * 10        # 10 notas reais, todas começando em 0.0
idades = [0] * 20         # 20 inteiros, todos começando em 0
nomes = [""] * 5          # 5 textos vazios
respostas = [False] * 10  # 10 valores lógicos

No exemplo notas = [0.0] * 10 temos: nome notas; 10 posições; índices de 0 a 9; valores do tipo float.

Também é possível criar o vetor já com os valores:

idades = [18, 20, 17, 22, 19]

A função len() informa a quantidade de posições: len(idades) resulta em 5.

5.5 – Índices e posições

notas = [0.0] * 3

notas[0] = 8.5
notas[1] = 7.0
notas[2] = 9.5

Atenção: o índice não é o valor armazenado. Em notas[1] = 7.0, 1 é o índice e 7.0 é o valor.

5.6 – Limites do vetor

Com numeros = [0] * 5, as posições válidas são 0, 1, 2, 3 e 4. Acessar numeros[5] provoca o erro:

IndexError: list index out of range

Cuidado com índices negativos: em Python, numeros[-1] não gera erro: ele representa a última posição. Isso pode esconder erros de lógica. Nesta disciplina, use apenas índices de 0 até o tamanho menos 1.

5.7 – Atribuição direta de valores

numeros = [0] * 3

numeros[0] = 10
numeros[1] = 25
numeros[2] = 8

numeros[1] = 30   # substitui o valor anterior (25)

5.8 – Leitura de valores em um vetor

numeros = [0] * 5

# Percorre todas as posições do vetor
for i in range(5):
    numeros[i] = int(input(f"Digite o {i + 1}º número: "))

O comando numeros[i] = int(input(...)) utiliza o valor de i para indicar a posição que será preenchida:

i = 0 → numeros[0]   (1º número)
i = 1 → numeros[1]   (2º número)
i = 2 → numeros[2]   (3º número)
i = 3 → numeros[3]   (4º número)
i = 4 → numeros[4]   (5º número)

5.9 – Exibição dos valores

numeros = [0] * 5

# Leitura dos valores
for i in range(5):
    numeros[i] = int(input(f"Digite o {i + 1}º número: "))

print()
print("Valores armazenados:")

# Exibição dos valores
for i in range(5):
    print(f"Posição {i + 1}: {numeros[i]}")

Curiosidade: print(numeros) mostra a lista inteira de uma vez, por exemplo [8, -2, 12, 4, 10]. Porém, para treinar a lógica, vamos percorrer o vetor com o for.

5.10 – Percurso em ordem normal e inversa

Atenção: em range(4, -1, -1), o laço começa em 4 e para antes de -1, ou seja, vai até 0.

numeros = [0] * 5

# Preenchimento do vetor
for i in range(5):
    numeros[i] = int(input(f"Digite o {i + 1}º número: "))

# Exibição em ordem normal
print()
print("===== ORDEM NORMAL =====")
for i in range(5):
    print(f"Posição {i + 1}: {numeros[i]}")

# Exibição em ordem inversa
print()
print("===== ORDEM INVERSA =====")
for i in range(4, -1, -1):
    print(f"Posição {i + 1}: {numeros[i]}")

5.11 – Soma dos valores de um vetor

numeros = [0] * 5
soma = 0

# Leitura dos valores
for i in range(5):
    numeros[i] = int(input(f"Digite o {i + 1}º número: "))

# Soma dos valores
for i in range(5):
    soma = soma + numeros[i]

print("Soma dos valores:", soma)

Curiosidade: Python possui a função pronta sum(numeros), que faz a mesma soma. Use-a depois de entender a lógica do acumulador.

5.12 – Cálculo da média

notas = [0.0] * 5
soma = 0

# Leitura das notas
for i in range(5):
    notas[i] = float(input(f"Digite a {i + 1}ª nota: "))
    soma = soma + notas[i]

# Cálculo da média
media = soma / 5

print(f"Média das notas: {media:.2f}")

5.13 – Contagem de valores

Exemplo – Contar números pares:

numeros = [0] * 5
qtd_pares = 0

# Leitura dos valores
for i in range(5):
    numeros[i] = int(input(f"Digite o {i + 1}º número: "))

# Contagem dos números pares
for i in range(5):
    if numeros[i] % 2 == 0:
        qtd_pares = qtd_pares + 1

print("Quantidade de números pares:", qtd_pares)

5.14 – Exibição de valores que atendem a uma condição

print("Números maiores que 10:")

for i in range(5):
    if numeros[i] > 10:
        print(numeros[i])

5.15 – Maior valor do vetor

Para encontrar o maior valor, utilizamos inicialmente o primeiro elemento (numeros[0]) e comparamos com os demais.

numeros = [0] * 5

# Leitura dos valores
for i in range(5):
    numeros[i] = int(input(f"Digite o {i + 1}º número: "))

# O primeiro elemento é inicialmente considerado o maior
maior = numeros[0]

# Comparação com os demais elementos
for i in range(1, 5):
    if numeros[i] > maior:
        maior = numeros[i]

print("Maior valor:", maior)

Por que não iniciar o maior com zero? Considere o vetor -5, -2, -10, -4, -8. Com maior = 0, o programa informaria que o maior valor é zero, mesmo que zero não esteja armazenado. Por isso, use maior = numeros[0].

Curiosidade: Python possui as funções prontas max(numeros) e min(numeros). Use-as depois de entender a lógica da comparação.

5.16 – Menor valor do vetor

numeros = [0] * 5

# Leitura dos valores
for i in range(5):
    numeros[i] = int(input(f"Digite o {i + 1}º número: "))

menor = numeros[0]

# Procura pelo menor valor
for i in range(1, 5):
    if numeros[i] < menor:
        menor = numeros[i]

print("Menor valor:", menor)

5.17 – Maior e menor valor no mesmo programa

numeros = [0] * 5

# Preenchimento do vetor
for i in range(5):
    numeros[i] = int(input(f"Digite o {i + 1}º número: "))

# Inicialização com o primeiro valor
maior = numeros[0]
menor = numeros[0]

# Comparação com os demais valores
for i in range(1, 5):
    if numeros[i] > maior:
        maior = numeros[i]
    if numeros[i] < menor:
        menor = numeros[i]

print("Maior valor:", maior)
print("Menor valor:", menor)

5.18 – Localização da posição do maior valor

numeros = [0] * 5

for i in range(5):
    numeros[i] = int(input(f"Digite o {i + 1}º número: "))

maior = numeros[0]
pos_maior = 0

for i in range(1, 5):
    if numeros[i] > maior:
        maior = numeros[i]
        pos_maior = i

print("Maior valor:", maior)
print("Posição do maior valor:", pos_maior + 1)

Observação: guardamos o índice real (pos_maior = i) e somamos 1 apenas na hora de mostrar ao usuário.

5.19 – Busca de um valor no vetor

numeros = [0] * 5

# Preenchimento do vetor
for i in range(5):
    numeros[i] = int(input(f"Digite o {i + 1}º número: "))

# Número que será procurado
procurado = int(input("Digite o número que deseja procurar: "))

encontrou = False

# Busca pelo número
for i in range(5):
    if numeros[i] == procurado:
        print("Número encontrado na posição", i + 1)
        encontrou = True

# Mensagem apresentada quando não houver ocorrência
if encontrou == False:
    print("Número não encontrado.")

Observação: se o mesmo número aparecer mais de uma vez, o programa mostrará todas as posições em que ele foi encontrado. A condição encontrou == False também pode ser escrita como not encontrou.

5.20 – Alteração de uma posição

numeros = [0] * 5

# Preenchimento do vetor
for i in range(5):
    numeros[i] = int(input(f"Digite o valor da posição {i + 1}: "))

posicao = int(input("Informe a posição que deseja alterar (1 a 5): "))

# Validação da posição
if posicao >= 1 and posicao <= 5:
    novo_valor = int(input("Informe o novo valor: "))
    numeros[posicao - 1] = novo_valor    # posição 1 do usuário = índice 0
    print("Valor alterado com sucesso.")
else:
    print("Posição inválida.")

# Exibição do vetor atualizado
print()
print("Vetor atualizado:")
for i in range(5):
    print(f"Posição {i + 1}: {numeros[i]}")

5.21 – Capacidade e quantidade preenchida

Um vetor pode possuir mais posições do que a quantidade de dados realmente utilizada.

nomes = [""] * 10

qtd = int(input("Quantos nomes deseja cadastrar? "))

for i in range(qtd):
    nomes[i] = input(f"Digite o {i + 1}º nome: ")

Nesse caso: capacidade do vetor: 10; quantidade utilizada: valor de qtd.

Cuidado: valide qtd para que ele não seja maior que a capacidade (10).

Curiosidade: como as listas do Python podem crescer, também é possível começar com uma lista vazia (nomes = []) e acrescentar elementos com nomes.append(nome). Você verá essa forma em muitos materiais de Python.

5.22 – Vetores paralelos

Vetores paralelos são vetores diferentes cujas posições representam informações relacionadas.

nomes[2] e notas[2] representam os dados do mesmo aluno.

nomes = [""] * 5
notas = [0.0] * 5

# Cadastro dos alunos
for i in range(5):
    nomes[i] = input(f"Digite o nome do {i + 1}º aluno: ")
    notas[i] = float(input(f"Digite a nota de {nomes[i]}: "))

# Apresentação dos dados
print()
print("===== ALUNOS E NOTAS =====")
for i in range(5):
    print("Aluno:", nomes[i])
    print("Nota:", notas[i])
    print("--------------------------")

5.23 – Exemplo completo: análise de notas

O programa deverá: ler cinco notas; mostrar todas as notas; calcular a média; informar a maior e a menor nota; contar quantas notas estão acima da média; mostrar as notas em ordem inversa.

notas = [0.0] * 5
soma = 0
qtd_acima = 0

# Leitura das notas
for i in range(5):
    notas[i] = float(input(f"Digite a {i + 1}ª nota: "))
    soma = soma + notas[i]

# Cálculo da média
media = soma / 5

# Inicialização do maior e do menor valor
maior = notas[0]
menor = notas[0]

# Procura pelo maior e pelo menor valor
for i in range(1, 5):
    if notas[i] > maior:
        maior = notas[i]
    if notas[i] < menor:
        menor = notas[i]

# Contagem das notas acima da média
for i in range(5):
    if notas[i] > media:
        qtd_acima = qtd_acima + 1

# Apresentação das notas
print()
print("===== NOTAS INFORMADAS =====")
for i in range(5):
    print(f"Nota {i + 1}: {notas[i]:.2f}")

# Apresentação dos resultados
print()
print("===== RESULTADOS =====")
print(f"Média: {media:.2f}")
print(f"Maior nota: {maior:.2f}")
print(f"Menor nota: {menor:.2f}")
print("Notas acima da média:", qtd_acima)

# Apresentação em ordem inversa
print()
print("===== ORDEM INVERSA =====")
for i in range(4, -1, -1):
    print(f"{notas[i]:.2f}")

5.24 – Erros comuns no uso de vetores em Python

1. Não utilizar o índice

numeros = int(input())       # Incorreto: substitui a lista inteira por um número
numeros[i] = int(input())    # Correto

2. Acessar uma posição inexistente

numeros = [0] * 5
numeros[5] = 10   # Incorreto: IndexError - os índices vão de 0 a 4

3. Usar o range errado

# Incorreto: ignora numeros[0] e tenta acessar numeros[5]
for i in range(1, 6):
    numeros[i] = int(input())

# Correto: i assume 0, 1, 2, 3, 4
for i in range(5):
    numeros[i] = int(input())

4. Atribuir a uma lista vazia

numeros = []
numeros[0] = 10   # Incorreto: IndexError - a lista não tem posições
numeros = [0] * 5 # Correto: crie as posições antes

5. Confundir posição com valor – em numeros[3] = 20, 3 é o índice e 20 é o valor.

6. Não inicializar um acumulador – sem soma = 0 antes do laço, ocorre NameError: name 'soma' is not defined.

7. Inicializar o maior valor com zero – prefira maior = numeros[0].

8. Usar nomes diferentes – se a lista foi criada como numeros, use numeros[i], e não numero[i].

9. Esquecer a conversão do input – sem int() ou float(), os valores serão textos e a soma juntará os caracteres.

5.25 – Resumo

5.26 – Atividades de fixação

Exercício 1 – Leitura e apresentação. Faça um programa que leia oito números inteiros, armazene-os em um vetor e apresente todos os valores na ordem em que foram informados.

Exercício 2 – Ordem inversa. Faça um programa que leia dez números inteiros e apresente-os na ordem inversa à ordem de entrada.

Exercício 3 – Números pares. Faça um programa que leia dez números inteiros e apresente: todos os números informados; somente os números pares; a quantidade de números pares.

Exercício 4 – Soma e média. Faça um programa que leia seis números reais e apresente: a soma dos valores; a média; os valores maiores que a média.

Exercício 5 – Maior e menor. Faça um programa que leia oito números inteiros e apresente: o maior número e sua posição; o menor número e sua posição.

Exercício 6 – Busca de valor. Faça um programa que leia dez números inteiros. Em seguida, solicite um número ao usuário e informe se ele está armazenado no vetor. Caso esteja, mostre também sua posição.

Exercício 7 – Alteração de valor. Faça um programa que leia cinco números inteiros. Depois, solicite uma posição e um novo valor. O programa deverá verificar se a posição é válida, substituir o valor e apresentar o vetor atualizado.

Exercício 8 – Notas dos alunos. Faça um programa que leia o nome e a nota de dez alunos utilizando dois vetores. Apresente: o nome e a nota de todos os alunos; a média da turma; os alunos com nota maior ou igual a 60; a quantidade de alunos abaixo da média.

Exercício 9 – Temperaturas. Faça um programa que armazene a temperatura registrada durante sete dias. Apresente: a média; a maior temperatura; a menor temperatura; quantos dias tiveram temperatura acima da média.

Exercício 10 – Cadastro de produtos. Faça um programa que leia o nome e o preço de cinco produtos utilizando vetores paralelos. Apresente: todos os produtos cadastrados; o produto mais caro; o produto mais barato; a média dos preços; os produtos com preço abaixo da média.

Capítulo 6 – Estrutura de Dados: Matriz

6.1 – O que é uma matriz

Uma matriz é uma variável composta homogênea e multidimensional. Todos os elementos são do mesmo tipo e possuem o mesmo nome; o que distingue cada elemento são os índices. O mais comum são duas dimensões — linhas e colunas —, como em uma planilha eletrônica.

Características:

• é uma estrutura de dados composta multidimensional;
• cada valor ocupa uma posição identificada por um índice para cada dimensão;
• permite acesso direto a qualquer elemento usando [linha][coluna];
• representa naturalmente dados tabulares (tabelas, planilhas) e serve de base para aplicações como imagens, gráficos e cálculos matemáticos.

Em Python, uma matriz é representada por uma lista de listas: cada linha da matriz é uma lista.

Diferença entre variável simples, vetor e matriz

6.2 – Criação de uma matriz

Para criar uma matriz de 3 linhas e 4 colunas, criamos 3 listas de 4 posições:

notas = [[0.0] * 4 for i in range(3)]   # 3 linhas (alunos) e 4 colunas (notas)

Lê-se: “para cada i de 0 a 2, crie uma lista com 4 posições valendo 0.0”.

Observação: no VisuAlg não existe posição zero. Em Python, linhas e colunas começam em 0: em uma matriz 3×4, as linhas vão de 0 a 2 e as colunas de 0 a 3.

Cuidado – armadilha comum: não crie a matriz com [[0.0] * 4] * 3. Essa forma cria três referências para a mesma linha: ao alterar notas[0][0], as três linhas mudam juntas! Use sempre [[0.0] * 4 for i in range(3)].

6.3 – Acesso aos elementos

notas[0][0] = 7.5
notas[0][1] = 8.0
notas[0][2] = 9.0
notas[0][3] = 6.0

notas[1][0] = 6.0
notas[1][1] = 9.5
notas[1][2] = 7.0
notas[1][3] = 4.0

notas[2][0] = 5.0
notas[2][1] = 3.0
notas[2][2] = 3.0
notas[2][3] = 9.0

notas[1][0] acessa o segundo aluno em sua primeira nota: o valor 6.0.

Também é possível criar a matriz já com os valores:

notas = [
    [7.5, 8.0, 9.0, 6.0],
    [6.0, 9.5, 7.0, 4.0],
    [5.0, 3.0, 3.0, 9.0]
]

6.4 – Leitura e escrita em matrizes

Para preencher ou exibir uma matriz, usamos dois laços: o laço externo (i) controla as linhas e o laço interno (j) controla as colunas.

Exemplo – Ler 4 notas de 3 alunos e apresentar na tela:

# Descrição   : Programa para apresentar os conceitos de matriz

notas = [[0.0] * 4 for i in range(3)]

# Seção de entrada de dados
for i in range(3):
    print(f"Forneça as notas do {i + 1}º aluno")
    for j in range(4):
        notas[i][j] = float(input(f"Digite a {j + 1}ª nota: "))

# Seção para apresentar os dados
for i in range(3):
    print(f"O {i + 1}º aluno tirou as notas")
    for j in range(4):
        print(f"{j + 1}ª nota: {notas[i][j]}")

Observação: a necessidade de dois laços se dá porque a matriz possui duas dimensões. O laço externo (i) percorre as linhas; o interno (j) percorre as colunas. Essa combinação permite visitar cada célula [i][j]. Repare que o for j está recuado dentro do for i.

Área de visualização (tela):

Forneça as notas do 1º aluno
Digite a 1ª nota: 10
Digite a 2ª nota: 9
Digite a 3ª nota: 8
Digite a 4ª nota: 7
Forneça as notas do 2º aluno
...
O 1º aluno tirou as notas
1ª nota: 10.0
2ª nota: 9.0
3ª nota: 8.0
4ª nota: 7.0
...

Memória após a leitura:

notas[0][0] = 10   notas[0][1] = 9   notas[0][2] = 8   notas[0][3] = 7
notas[1][0] = 7    notas[1][1] = 9   notas[1][2] = 8   notas[1][3] = 7
notas[2][0] = 10   notas[2][1] = 8   notas[2][2] = 9   notas[2][3] = 7

6.5 – Exibindo a matriz em formato de tabela

for i in range(3):
    for j in range(4):
        print(f"{notas[i][j]:6.1f}", end="")   # 6 posições, 1 casa, sem pular linha
    print()                                     # pula linha ao final de cada linha da matriz

6.6 – Média de cada aluno (cálculo por linha)

notas = [[0.0] * 4 for i in range(3)]

for i in range(3):
    print(f"Forneça as notas do {i + 1}º aluno")
    for j in range(4):
        notas[i][j] = float(input(f"Digite a {j + 1}ª nota: "))

for i in range(3):
    soma = 0                          # reinicia o acumulador para cada aluno
    for j in range(4):
        soma = soma + notas[i][j]
    media = soma / 4
    print(f"Média do {i + 1}º aluno: {media:.2f}")

Atenção: o acumulador soma é zerado dentro do laço das linhas, para que a soma de um aluno não se misture com a do próximo.

Atividades de fixação

1. Leia uma matriz 3×3 de inteiros e mostre-a em formato de tabela.
2. Leia uma matriz 4×4 de inteiros e mostre a soma de todos os elementos.
3. Leia uma matriz 3×3 e mostre os elementos da diagonal principal (onde i == j).
4. Leia as 4 notas de 5 alunos e mostre a média de cada aluno e a média de cada avaliação (coluna).
5. Leia uma matriz 3×4 e mostre o maior valor e a sua posição (linha e coluna).

Capítulo 7 – Procedimentos (funções sem retorno)

7.1 – O que são funções e procedimentos?

Imagine que você está escrevendo um livro. Se precisar repetir a mesma frase várias vezes, seria mais fácil dar um nome a ela e “chamar” esse nome sempre que precisar.

Funções e procedimentos são blocos de código com uma tarefa específica e um nome. Você escreve o código uma vez e pode usá-lo quantas vezes quiser.

Por que usar?

• Organização: o código fica mais limpo e fácil de entender;
• Reaproveitamento: não é preciso repetir o mesmo código;
• Manutenção: se a lógica mudar, altera-se em um único lugar.

Curiosidade: você já usa funções desde o primeiro programa: print(), input(), int() e len() são funções prontas do Python.

7.2 – Procedimentos em Python

Um procedimento executa uma ação e não retorna valor. Em Python, não existe a palavra procedimento: usamos def para definir uma função e simplesmente não usamos return com valor.

def nome_do_procedimento():
    # Variáveis locais, se houver
    # Código do procedimento
    ...

# Para chamar o procedimento: nome_do_procedimento()

Exemplo prático – mensagem de boas-vindas:

# Descrição   : Exemplo de procedimento simples

# Seção de procedimentos e funções
def saudacao():
    print("Olá! Seja bem-vindo(a) ao meu programa.")
    print("Este é um procedimento simples.")


# Corpo do programa principal
print("--- Início do Programa Principal ---")
print()
saudacao()   # Chamando o procedimento
print()
print("--- Fim do Programa Principal ---")

7.3 – Organizando as listas de exercícios com menu

Imagine uma lista com três exercícios:

O menu permite escolher o exercício. O procedimento contém a resolução: leitura dos dados, processamento e apresentação do resultado.

Criar um procedimento não faz com que ele seja executado automaticamente. É preciso chamá-lo pelo nome.

7.4 – Como escrever um procedimento em Python

def exercicio01():
    numero1 = float(input("Digite o primeiro número: "))
    numero2 = float(input("Digite o segundo número: "))

    soma = numero1 + numero2

    print(f"Soma: {soma:.2f}")

As variáveis criadas dentro do procedimento são locais: pertencem àquele procedimento.

Nesta atividade usaremos procedimentos sem parâmetros: os parênteses ficam vazios e os dados são lidos com input dentro de cada procedimento. Quando dizemos que o procedimento não retorna valor, significa que ele não entrega um valor para uma atribuição: chamamos com exercicio01(), e não escrevemos resultado = exercicio01().

7.5 – Onde colocar e como chamar o procedimento

Em Python, assim como no VisuAlg, os procedimentos ficam antes do programa principal. O Python lê o arquivo de cima para baixo: se a chamada aparecer antes do def, ocorre NameError.

def exercicio01():
    numero1 = float(input("Digite o primeiro número: "))
    numero2 = float(input("Digite o segundo número: "))

    soma = numero1 + numero2

    print(f"Soma: {soma:.2f}")


# Início do programa principal
print("Vamos executar o exercício 01!")
exercicio01()
print("O exercício terminou.")

A execução acontece nesta ordem:

1. O Python lê o def e “guarda” o procedimento, sem executá-lo;
2. Começa o programa principal e exibe a primeira mensagem;
3. Encontra exercicio01() e executa os comandos desse procedimento;
4. Ao terminar o bloco do procedimento, volta para o comando seguinte à chamada;
5. Exibe “O exercício terminou.” e encerra.

Atenção: o programa principal fica sem recuo, encostado à esquerda. Se ele ficar recuado, o Python entenderá que faz parte do procedimento.

7.6 – Exemplo completo: uma lista com menu

Agora vamos reunir dois exercícios no arquivo lista01.py:

• Exercício 01: somar dois números;
• Exercício 02: calcular a área de um retângulo.

# Arquivo     : lista01.py
# Descrição   : Lista de exercícios organizada com menu e procedimentos

# Exercicio 01 - Somar dois numeros
def exercicio01():
    print("--- EXERCÍCIO 01: SOMA ---")
    numero1 = float(input("Digite o primeiro número: "))
    numero2 = float(input("Digite o segundo número: "))

    soma = numero1 + numero2

    print(f"Soma: {soma:.2f}")


# Exercicio 02 - Calcular a area de um retangulo
def exercicio02():
    print("--- EXERCÍCIO 02: ÁREA ---")
    base = float(input("Digite a base em metros: "))
    altura = float(input("Digite a altura em metros: "))

    area = base * altura

    print(f"Área: {area:.2f} m2")


# Programa principal: menu e chamadas
while True:
    print()
    print("==============================")
    print("           LISTA 01")
    print("==============================")
    print("1 - Somar dois números")
    print("2 - Calcular a área do retângulo")
    print("0 - Sair")
    opcao = int(input("Escolha uma opção: "))
    print()

    match opcao:
        case 1:
            exercicio01()
        case 2:
            exercicio02()
        case 0:
            print("Programa encerrado.")
        case _:
            print("Opção inválida! Tente novamente.")

    if opcao == 0:
        break

Entendendo o menu

A variável opcao fica no programa principal, pois é usada pelo menu. As variáveis de cálculo ficam dentro dos respectivos procedimentos.

Vamos acompanhar uma execução?

1. O usuário digita 1 no menu;
2. O case 1 chama exercicio01();
3. O usuário informa os números 5 e 3;
4. O procedimento mostra a soma 8.00 e termina;
5. A execução volta ao menu. Como a opção é diferente de 0, a repetição continua;
6. O usuário pode executar outro exercício, repetir o mesmo ou digitar 0 para sair.

7.7 – Como adaptar um exercício que você já resolveu

1. Crie um procedimento com def e o número do exercício, antes do programa principal;
2. Coloque a resolução recuada dentro do procedimento;
3. Acrescente a opção correspondente nas mensagens do menu;
4. Acrescente um case que chame o procedimento.

Para incluir o exercício 03, por exemplo:

# Junto das mensagens com as opcoes:
print("3 - Descrição do exercício 03")

# Dentro do match, antes do case _:
case 3:
    exercicio03()

Esse trecho mostra apenas o que acrescentar; ele não é um programa completo.

Não copie um programa inteiro para dentro do procedimento. Cada arquivo terá um único programa principal, depois de todos os def.

7.8 – Cuidados importantes

• Use o mesmo nome na definição e na chamada (Python diferencia maiúsculas de minúsculas);
• Coloque os procedimentos antes do programa principal;
• Não esqueça os dois-pontos no def e os parênteses na chamada: exercicio01();
• Confira a indentação: tudo que pertence ao procedimento fica recuado;
• Deixe uma linha em branco (ou duas) entre os procedimentos para facilitar a leitura;
• Inicialize acumuladores e contadores dentro do procedimento, antes de usá-los.

Capítulo 8 – Funções

8.1 – O que são funções?

Funções são partes de um programa que recebem um nome, realizam uma tarefa e devolvem um resultado para o trecho que as chamou. Elas podem receber dados para realizar essa tarefa.

Imagine uma calculadora com uma tecla chamada dobro: ao receber 5, devolve 10; ao receber 8, devolve 16.

8.2 – Estrutura básica de uma função em Python

def nome(parametros):
    # variáveis locais, quando necessárias
    # comandos da função
    return resultado

Indicando os tipos (anotações de tipo)

No VisuAlg, informávamos o tipo dos parâmetros e do retorno. Em Python isso não é obrigatório, mas podemos documentar os tipos com anotações, deixando a função muito parecida com a do Portugol:

def nome(parametro: tipo) -> tipo_do_retorno:
    return resultado

Observação: as anotações (: int e -> int) servem para documentar e ajudam o PyCharm a apontar possíveis erros, mas o Python não as verifica durante a execução. Nesta apostila, vamos usá-las para manter a mesma ideia de “tipo do parâmetro” e “tipo do retorno” estudada no Portugol.

8.3 – Tipos de funções quanto aos parâmetros

8.3.1 – Função sem parâmetros e com retorno

def fornecer_pi() -> float:
    return 3.14159

Recebe: nenhum parâmetro. Retorna: um valor do tipo float.

valor = fornecer_pi()
print(valor)

Diferença para o VisuAlg: em Python, os parênteses são obrigatórios na definição e na chamada, mesmo sem parâmetros: fornecer_pi().

Sobre os nomes: em Python, a convenção é escrever nomes de funções com letras minúsculas e _ separando as palavras (fornecer_pi, calcular_media). O nome fornecerPi também funciona, mas não é o estilo recomendado.

8.3.2 – Função com parâmetros e com retorno

def dobro(valor: int) -> int:
    return valor * 2

Definir uma função não a executa. Para utilizá-la, precisamos fazer uma chamada.

8.4 – Como chamar uma função

Escreva a função antes do programa principal:

def dobro(valor: int) -> int:
    return valor * 2


numero = 5
resultado = dobro(numero)
print("Dobro:", resultado)

O programa exibe Dobro: 10.

Acompanhe a execução

1. O programa principal começa, e numero recebe 5;
2. A chamada dobro(numero) envia o valor 5 para a função;
3. O parâmetro valor recebe 5, e a função calcula 5 * 2;
4. A função devolve 10, e esse valor é guardado em resultado;
5. O print mostra o resultado na tela.

Na atribuição resultado = dobro(numero), o lado direito é resolvido primeiro; depois, o valor devolvido é guardado na variável à esquerda.

Reutilize a mesma função

resultado = dobro(3)
print(resultado)

resultado = dobro(8)
print(resultado)

Esse trecho exibe 6 e depois 16. A função foi escrita uma vez e utilizada duas vezes.

Pense: se a chamada fosse dobro(9), qual valor seria devolvido?

8.5 – Parâmetros e argumentos

Parâmetro é a variável indicada na definição da função. Argumento é o valor ou a expressão enviada na chamada.

• Na definição def dobro(valor: int), valor é o parâmetro;
• Na chamada dobro(5), o argumento é 5;
• Na chamada dobro(numero), enviamos o valor guardado em numero.

Uma função com dois parâmetros

def somar(a: int, b: int) -> int:
    return a + b

primeiro = 4
segundo = 6
total = somar(primeiro, segundo)
print("Soma:", total)

Os nomes das variáveis enviadas não precisam ser iguais aos nomes dos parâmetros. O que importa é respeitar a quantidade, a ordem e os tipos esperados. O parâmetro valor de dobro pertence somente à função.

8.6 – Tipos de retorno das funções

8.6.1 – Função com retorno inteiro

As funções dobro e somar retornam valores do tipo int.

8.6.2 – Função com retorno real e variável local

def calcular_media(n1: float, n2: float) -> float:
    m = (n1 + n2) / 2
    return m

n1 e n2 são parâmetros, e m é uma variável local. A chamada calcular_media(7, 8) devolve 7.5.

Exemplo completo com entrada de dados:

def calcular_media(n1: float, n2: float) -> float:
    m = (n1 + n2) / 2
    return m


nota1 = float(input("Digite a primeira nota: "))
nota2 = float(input("Digite a segunda nota: "))

media = calcular_media(nota1, nota2)
print(f"Média: {media:.2f}")

Observe a divisão das tarefas: o programa principal lê os dados e exibe o resultado; a função calcula e devolve a média. A variável local m não é utilizada diretamente pelo programa principal.

8.6.3 – Função com retorno lógico

def eh_positivo(numero: int) -> bool:
    return numero > 0

Recebe: um número inteiro. Retorna: um valor lógico.

resultado_logico = eh_positivo(4)
print(resultado_logico)    # True

As chamadas eh_positivo(0) e eh_positivo(-3) devolvem False.

8.6.4 – Função com retorno de texto

def obter_mensagem() -> str:
    return "Bem-vindo ao sistema!"

Recebe: nenhum parâmetro. Retorna: um texto do tipo str.

mensagem = obter_mensagem()
print(mensagem)

O tipo do parâmetro pode ser diferente do tipo do retorno

Em eh_positivo, o parâmetro é int, mas o retorno é bool. O primeiro tipo descreve o dado que entra; o segundo descreve o resultado que volta.

8.7 – Compare os exemplos

8.8 – Retornar não é o mesmo que exibir

O return entrega um resultado ao trecho que fez a chamada. O print mostra uma informação na tela.

resultado = dobro(5)    # guarda 10, mas não mostra nada
print(resultado)        # agora sim, exibe 10

Erro comum: escrever print(valor * 2) dentro da função no lugar de return valor * 2. Nesse caso, a função mostra o valor, mas devolve None, e a variável que recebe a chamada fica sem o resultado.

8.9 – Programa completo com todas as funções da aula

def fornecer_pi() -> float:
    return 3.14159


def dobro(valor: int) -> int:
    return valor * 2


def somar(a: int, b: int) -> int:
    return a + b


def calcular_media(n1: float, n2: float) -> float:
    m = (n1 + n2) / 2
    return m


def eh_positivo(numero: int) -> bool:
    return numero > 0


def obter_mensagem() -> str:
    return "Bem-vindo ao sistema!"


print(obter_mensagem())
print(f"Pi: {fornecer_pi():.5f}")
print("Dobro de 9:", dobro(9))
print("Soma de 4 e 6:", somar(4, 6))
print(f"Média de 7 e 8: {calcular_media(7, 8):.2f}")
print("-3 é positivo?", eh_positivo(-3))

Observação: o valor retornado por uma função pode ser usado diretamente dentro de outro comando, como em print(dobro(9)).

8.10 – Como planejar uma função simples

1. Escolha uma tarefa pequena, como calcular o dobro ou somar dois números;
2. Decida se a função precisa receber dados na chamada;
3. Se precisar, defina os nomes e os tipos dos parâmetros;
4. Defina o tipo do resultado que será devolvido;
5. Escolha um nome que explique a tarefa;
6. Escreva os comandos e utilize return para devolver o resultado;
7. Faça a chamada e teste com valores cujo resultado você já conhece.

Antes de escrever, responda: quais dados entram, o que será feito com eles e qual resultado deve voltar?

8.11 – Dicas importantes

• Escreva as funções antes do programa principal;
• Identifique se a função precisa receber parâmetros;
• Defina se o retorno será int, float, bool ou str;
• Lembre-se de chamar a função; apenas defini-la não executa seus comandos;
• Use nomes descritivos, como calcular_media e area_retangulo;
• Mantenha uma tarefa clara por função;
• Crie as variáveis auxiliares dentro da função quando forem usadas apenas nela;
• Use return para devolver o resultado — não confunda com print;
• Confira o resultado com um cálculo feito à mão.

Atividades de fixação

1. Crie a função preco_com_desconto(valor: float, taxa: float) -> float que devolve o preço com o desconto percentual aplicado.
2. Crie a função eh_par(numero: int) -> bool e use-a para informar se um número digitado é par ou ímpar.
3. Crie a função situacao_aluno(media: float) -> str que devolve "Aprovado" (média maior ou igual a 60) ou "Reprovado".
4. Crie a função area_retangulo(base: float, altura: float) -> float.
5. Crie a função maior_de_tres(a: int, b: int, c: int) -> int.

Apêndice – Tabela de equivalência Portugol × Python

Conclusão

Python é uma linguagem com sintaxe enxuta: não exige declaração de variáveis, ponto e vírgula ou chaves. Em compensação, exige atenção à indentação, à conversão das entradas com int() e float() e aos índices começando em zero. Porém, a lógica é exatamente a mesma. Se o algoritmo está correto em Portugol, a tradução para Python é uma questão de conhecer a “gramática” da nova linguagem.

Links e telas de instalação podem mudar ao longo do tempo. Em caso de diferença visual, utilize sempre a página oficial indicada e procure a opção equivalente para o sistema operacional utilizado.

Índice por assunto

Os números indicam a seção da apostila (ex.: 5.15 = Capítulo 5, seção 15). Nos arquivos digitais, clique no número para ir direto ao conteúdo.

Assuntos de lógica de programação

A

• Acumulador (somar valores em uma variável) — 4.1, 5.11, 6.6
• Algoritmo – conceito — 1.1
• Alterar um valor do vetor — 5.20
• Ambiente de programação (instalação) — Cap. 0
• Argumento — 8.5
• Atividades de fixação / exercícios — 1.14, 2.4, 4.4, 5.26, 6.6, 8.11
• Atribuição — 1.8

B

• Blocos de comandos — 1.13
• Busca de um valor no vetor — 5.19

C

• Capacidade do vetor — 5.21
• Chamada de função — 8.4
• Chamada de procedimento — 7.5
• Comentários — 1.4
• Condicional composta (se/senão) — 2.3.2
• Condicional encadeada (mais de duas possibilidades) — 2.3.3
• Condicional simples (se) — 2.3.1
• Constantes — 1.6
• Contador / contagem de valores — 4.2, 5.13

D

• Declaração de variáveis — 1.8
• Divisão inteira — 1.9

E

• Enquanto (estrutura) — 4.2
• Entrada de dados — 1.12
• Erros comuns com vetores — 5.24
• Escolha-caso (estrutura) — 3.1, 3.2
• Estrutura do programa — 1.4
• Execução de uma função passo a passo — 8.4
• Exibir os valores de um vetor — 5.9
• Exibir somente valores que atendem a uma condição — 5.14
• Exponenciação / potência — 1.9

F

• Função com parâmetros e com retorno — 8.3.2
• Função sem parâmetros e com retorno — 8.3.1
• Função – como planejar — 8.10
• Função – conceito — 8.1
• Função – estrutura básica — 8.2

I

• Identificadores (nomes de variáveis) — 1.7
• Indentação — 1.13
• Índice do vetor (começa em 0) — 5.2, 5.5

L

• Laço infinito — 4.2
• Leitura de valores em um vetor — 5.8
• Limites do vetor — 5.6

M

• Maior e menor valor no mesmo programa — 5.17
• Maior valor do vetor — 5.15
• Matriz – acesso aos elementos — 6.3
• Matriz – conceito — 6.1
• Matriz – criação — 6.2
• Matriz – exibir em formato de tabela — 6.5
• Matriz – leitura e escrita (dois laços) — 6.4
• Média — 5.12, 5.23, 6.6, 8.6.2
• Menor valor do vetor — 5.16
• Menu de exercícios — 7.3, 7.6, 7.7
• Método para construção de algoritmos — 1.2

O

• Operador E — 2.2.1
• Operador NÃO — 2.2.3
• Operador OU — 2.2.2
• Operadores aritméticos — 1.9
• Operadores lógicos — 1.11, 2.2
• Operadores relacionais (comparação) — 1.10, 2.1
• Ordem inversa (percorrer o vetor de trás para frente) — 5.10

P

• Par ou ímpar — 5.13
• Para (estrutura) — 4.1
• Parâmetro — 8.5
• Passo / incremento do laço — 4.1
• Portugol × linguagem (tabela de equivalência) — Apêndice
• Posição do maior valor — 5.18
• Primeiro programa (Portugol → linguagem) — 1.3
• Procedimento – como escrever — 7.4
• Procedimento – conceito — 7.1, 7.2
• Procedimento – cuidados — 7.8

Q

• Qual estrutura de repetição escolher — 4.4

R

• Repetição – conceito e tipos — Cap. 4
• Repita (estrutura) — 4.3
• Resto da divisão — 1.9
• Retornar × exibir — 8.8
• Retorno de texto — 8.6.4
• Retorno inteiro — 8.6.1
• Retorno lógico — 8.6.3
• Retorno real — 8.6.2

S

• Saída de dados — 1.12
• Soma de 1 a 100 — 4.1
• Soma dos valores de um vetor — 5.11

T

• Tabela-verdade — 1.11
• Tipos de dados (primitivos) — 1.5
• Tipos de retorno das funções — 8.6, 8.7

V

• Variável local — 7.4, 8.6.2
• Variável simples × vetor × matriz — 5.3, 6.1
• Vetor – análise completa de notas — 5.23
• Vetor – conceito — 5.1
• Vetor – criação — 5.4
• Vetor – resumo dos comandos — 5.25
• Vetores paralelos — 5.22

Comandos e recursos da linguagem Python

Símbolos

• != (diferente) — 1.10, 2.1
• // (divisão inteira) — 1.9
• ** (potência) — 1.9
• % (resto) — 1.9
• [[0.0] * 4 for i in range(3)] (criar matriz) — 6.2
• [0] * 5 (criar vetor) — 5.4

A

• and — 2.2.1
• Anotações de tipo (-> int) — 8.2
• append() — 5.21

B

• break — 4.3

C

• case _ (outro caso) — 3.1

D

• def — 7.2, 8.2

E

• elif — 2.3.3, 3.2.1
• else — 2.3.2
• end="" no print — 1.12, 6.5

F

• f-string (f"...") — 1.12
• float() — 1.12
• for — 4.1, 5.10

I

• if — 2.3.1
• IndentationError — 1.13
• IndexError — 5.6, 5.24
• Índice negativo ([-1]) — 5.6
• input() — 1.12
• int() — 1.12

L

• len() — 5.4
• Lista (vetor em Python) — 5.1, 5.4
• Lista de listas (matriz) — 6.1, 6.2

M

• match/case — 3.1, 3.2
• Matriz com [[0]*4]*3 (armadilha) — 6.2
• max() / min() — 5.15

N

• NameError — 5.24, 7.5
• None — 8.8
• not — 2.2.3

O

• or — 2.2.2

P

• print() — 1.12

R

• range() — 4.1, 5.10
• return — 8.2

S

• sum() — 5.11

T

• True / False — 1.5
• type() — 1.5

U

• upper() — 2.2.3

W

• while — 4.2
• while True + break (repita) — 4.3

Símbolos

• = × == — 1.10

Copyleft 🄯 2026 - Professor Mauro Borges França.