ALGORITMOS E PROGRAMAÇÃO

EM PYTHON PARA O ENSINO

TÉCNICO INTEGRADO
 Elanne Cristina Oliveira dos Santos

ALGORITMOS E PROGRAMAÇÃO
EM PYTHON PARA O ENSINO
TÉCNICO INTEGRADO

1ª Edição
Teresina
2022
 Ministério da Educação
Secretaria de Educação Profissional e Tecnológica
Instituto Federal de Educação, Ciência e Tecnologia do Piauí

Ministério da Educação
Secretaria de Educação Profissional e Tecnológica
Instituto Federal de Educação, Ciência e Tecnologia do Piauí

Reitor Paulo Borges da Cunha

Pró-Reitora de Administração Larissa Santiago de Amorim
Pró-Reitor de Ensino Odiomogenes Soares Lopes
Pró-Reitor de Pesquisa, Pós-Graduação e Inovação José Luís de Oliveira e Silva
Pró-Reitora de Extensão Divamélia de Oliveira Bezerra Gomes
Pró-Reitor de Desenvolvimento Institucional Paulo Henrique Gomes de Lima

Conselho Editorial
Prof. Dr. Ricardo Martins Ramos – Presidente
Prof. Me. Alan Elias Silva – Secretário-Geral
Prof. Dr. José Carlos Raulino Lopes – Membro
Profa. Ma. Inara Erice de Souza Alves Raulino Lopes – Membro
Prof. Me. Israel Alves Correa Noleto – Membro
Bibliotecária Me. Sindya Santos Melo – Membro
Bibliotecária Me. Sônia Oliveira Matos Moutinho – Membro

Diagramação: Danilo Silva Araujo

Capa: Ângela Rêgo
Ilustração da capa: Elanne Cristina Oliveira dos Santos
Revisão de Texto: Maira Danuse Santos de Oliveira

Dados Internacionais de Catalogação na Publicação (CIP) de acordo com ISBD

Santos, Elanne Cristina Oliveira dos
S237a
Algoritmos e programação em Python para o ensino técnico integrado
[recurso eletrônico] / Elanne Cristina Oliveira dos Santos. – Teresina: IFPI,
2022.
148 p. ; il. color.

ISBN versão impressa: 978-65-86592-46-7

ISBN versão digital: 978-65-86592-47-4
DOI: 10.51361/978-65-86592-47-4

1. Algoritmos. 2. Programação (Computadores). 3. Python (Linguagem de

programação de computador). I. Título.
CDD 005.1
Elaborado por Sindya Santos Melo CRB 3/1085

Esta obra é uma publicação do Instituto Federal de Educação, Ciência e Tecnologia do Piauí. Os textos assinados são
de responsabilidade exclusiva dos autores e não expressam a opinião do Conselho Editorial.

Esta obra está licenciada sob uma Licença Creative Commons. Os usuários têm permissão para
copiar e redistribuir os trabalhos por qualquer meio ou formato, e para, tendo como base o seu
conteúdo, reutilizar, transformar ou criar, com propósitos legais, até comerciais, desde que citada
a fonte.

Instituto Federal do Piauí

Avenida Presidente Jânio Quadros, 330 – Bairro: Santa Isabel
E-mail: [email protected]
www.ifpi.edu.br
 Para meu pai,
que partiu e deixou essa saudade imensa no coração
de toda a família. Que me deu a oportunidade de
estudar e de amar ensinar o que eu aprendo. Para
seguir em frente, como ele sempre me ensinou,
comecei a escrever este livro.
Saudades do brilho dos seus olhos, verdinhos
brilhando cheios de esperança como duas estrelinhas
no céu, saudades do seu sorriso, todo feliz preparando
o jantar, saudades do seu cabelo branquinho feito
nuvem... Saudades do meu pai.

“Dentro da vastidão do tempo e da imensidão do

universo, é um imenso prazer pra mim dividir um
planeta e uma época com você.”

Carl Sagan
 SUMÁRIO
LISTA DE FIGURAS..........................................................................
FIGURAS..........................................................................11
11
INTRODUÇÃO.................................................................................... 17
INTRODUÇÃO
1 - O QUE É PROGRAMAÇÃO?.
PROGRAMAÇÃO?....................................................19
.................................................. 19
1.1 Programação e o raciocínio lógico.........................................19

1.2 A linguagem de programação de Python.............................21

1.3 O que nós vimos neste capítulo?............................................ 25

2 - A LINGUAGEM PYTHON.......................................................
PYTHON.......................................................27
27
2.1 Por que usar a linguagem Python?.........................................27

2.2 Características de linguagens de programação..................27

2.2.1 O interpretador Python.........................................................27

2.2.2 Python é uma linguagem interpretada.............................31

2.2.3 Variáveis e tipos de variáveis............................................... 34

2.2.4 Verificando tipos com a função “type()”............................ 36

2.2.5 Python usa tipagem dinâmica.............................................37

2.2.6 Blocos de código e indentação em Python..................... 38

Exercícios............................................................................................ 43

3 - PYTHON BÁSICO: VARIÁVEIS, OPERADORES E

ENTRADA E SAÍDA DE DADOS.
DADOS............................................... 45
3.1 O que é uma variável?............................................................... 45

3.2 Regras para nomear variáveis.................................................47

3.3 Python é dinamicamente tipada............................................47

3.4 Manipulando strings (tipo “str” do Python)......................... 50

3.5 Operadores.................................................................................. 52
3.6 A função de entrada “input()” e a função de saída
“print()”...................................................................................................54

Exercícios............................................................................................ 58

4 - ESTRUTURA DE DECISÃO IF..............................................

IF..............................................61
61
4.1 O comando IF...............................................................................61

4.2 O comando IF...ELSE................................................................61

4.3 O comando IF... ELIF................................................................ 63

4.4 Sintaxe do comando de decisão IF....................................... 64

Exercícios............................................................................................ 65

5 - ESTRUTURA DE REPETIÇÃO.
REPETIÇÃO.............................................69
........................................... 69
5.1 O comando WHILE.................................................................. 69

Exercícios.............................................................................................79

5.2 O comando FOR........................................................................ 83

5.2.1 O uso da iteração com “range”............................................. 85

5.2.2 O uso de outros “iteratores”.................................................87

Exercícios usando comando de repetição FOR........................87

Exercícios usando comando de repetição WHILE e FOR.... 93

6 - LISTA..............................................................................................
LISTA.............................................................................................. 95
6.1 Criando uma lista........................................................................97

6.2 O tamanho da lista.................................................................... 98

6.3 Adicionando elementos à lista............................................... 98

6.4 Modificando elementos na lista............................................. 99

6.5 Apagando elementos na lista.................................................101

Exercícios.......................................................................................... 102
7 - DICIONÁRIOS.
DICIONÁRIOS............................................................................107
..........................................................................107
7.1 Criando um dicionário.............................................................107

7.2 Adicionando e modificando elementos em um

dicionário.......................................................................................... 109

7.3 Buscando as chaves de um dicionário................................110

7.4 Buscando os valores de um dicionário................................111

7.5 Verificando se uma chave pertence ao dicionário........... 112

7.6 Usando um “For Loop” para percorrer o dicionário........ 115

7.7 Apagando elementos de um dicionário...............................117

Exercícios........................................................................................... 118

8 - FUNÇÕES....................................................................................
FUNÇÕES....................................................................................125
125
8.1 Criando uma função................................................................ 126

8.2 Módulos.......................................................................................128

8.3 A variável __name__............................................................... 133

8.4 Passagem de parâmetros........................................................138

8.5 O comando “return”................................................................. 139

Exercícios........................................................................................... 141

REFERÊNCIAS..................................................................................147
REFERÊNCIAS ............................................................................... 147
SOBRE A AUTORA........................................................................
AUTORA........................................................................ 148
 Lista de figuras
11

LISTA DE FIGURAS

Figura 1 – Sequência de passos de um raciocínio lógico......20

Figura 2 – Download da linguagem Python no site

oficial.................................................................................................... 22

Figura 3 – Programa escrito em Python com o objetivo de calcular

a operação (+5)x(-3-4) usando a propriedade distributiva.... 23

Figura 4 – Ao executar o passo “print(resultado)”, o

valor da variável “resultado” é apresentado na tela do
computador........................................................................................ 24

Figura 5 – Sequência de comandos e sua execução em

Python ................................................................................................ 25

Figura 6 – Janela inicial do IDLE................................................. 28

Figura 7 – Executando comandos na linha de comando do

interpretador IDLE.......................................................................... 28

Figura 8 – Usando o editor de textos do IDLE........................ 29

Figura 9 – Salvando o programa como o nome de

“alomundo”........................................................................................30

Figura 10– Opção de menu RUN usada para executar um

programa Python.............................................................................30

Figura 11 – Execução do programa “alomundo.py” na janela

do interpretador IDLE.....................................................................31

Figura 12 – Exemplo de um processo de tradução na vida

real........................................................................................................ 32

Figura 13 – Processo de compilação........................................... 32

Figura 14 – Processo de interpretação........................................ 33

Figura 15 – Declarando variáveis do tipo “int” no interpretador

do IDLE............................................................................................... 34
 Algoritmos e programação em Python para o Ensino Técnico Integrado
12

Figura 16 – Declarando variáveis do tipo “float” no interpretador

do IDLE............................................................................................... 35

Figura 17 – Declarando variáveis do tipo “str” no interpretador

do IDLE............................................................................................... 35

Figura 18 – Declarando variáveis do tipo “bool“ no interpretador

do IDLE............................................................................................... 36

Figura 19 – Checando o tipo de variáveis e valores com a função

“type()”................................................................................................. 36

Figura 20 – O Python informa que a operação não

pode ser realizada, pois as variáveis “x” e “y” são de tipos
diferentes.............................................................................................37

Figura 21 – Fluxo de execução de comandos usando a

condição “se”...................................................................................... 39

Figura 22– Fluxo de execução de comandos usando o laço de

repetição “enquanto”....................................................................... 40

Figura 23 – Exemplo de indentação em Python..................... 41

Figura 24 – Inserindo comentários em uma linha................. 42

Figura 25 – Inserindo um comentário de mais de uma

linha...................................................................................................... 43

Figura 26 – Variáveis “a”, “b” e “c” definidas na janela do

interpretador IDLE.......................................................................... 46

Figura 27 – Variáveis “a”, “b” e “c” definidas no editor de textos

do IDLE............................................................................................... 46

Figura 28 – Comando de atribuição declara explicitamente a

variável “x”.......................................................................................... 48

Figura 29 – Usando a função “type()” para verificar o tipo da

variável “x”.......................................................................................... 48

Figura 30 – Mudando o valor e o tipo da variável “x”.......... 49

 Lista de figuras
13

Figura 31 – Declarando a variável “x” com diferentes

tipos...................................................................................................... 49

Figura 32 – Executando o programa da Figura 31.................. 50

Figura 33 – Acessando elementos da “string”........................... 51

Figura 34 – Tentando modificar um caractere na “string”.... 51

Figura 35 – Verificando o tamanho da “string”......................... 51

Figura 36 – Usando a função “input()”........................................55

Figura 37 – Usando a função “input()” para ler um valor do tipo

“int”........................................................................................................ 56

Figura 38 – Usando a função “input()” para ler um valor do

tipo “float”........................................................................................... 56

Figura 39– Bloco de repetição no exemplo “a soma dos números

inteiros de 1 a 10”.............................................................................. 69

Figura 40 – O comando de repetição “while” no exemplo de

“a soma dos números inteiros de 1 a 10”.................................... 70

Figura 41 – Exemplo de um programa em “loop infinito”... 70

Figura 42 – Execução do programa em “loop infinito”.......... 71

Figura 43 – Código em Python com o exemplo 1...................72

Figura 44 – Execução do exemplo 1.............................................72

Figura 45 – Código em Python com o exemplo 2...................73

Figura 46 – Execução do exemplo 2............................................73

Figura 47– E rro de exceção após modificação no

exemplo 2............................................................................................74

Figura 48 – Código em Python com o exemplo 3...................75

Figura 49– Código em Python com o exemplo 4....................76

Figura 50 – Execução do exemplo 4............................................76

 Algoritmos e programação em Python para o Ensino Técnico Integrado
14

Figura 51 – Código em Python com o exemplo 5................... 77

Figura 52 – Código em Python com o exemplo 6...................78

Figura 53 – Código em Python com o exemplo 7...................78

Figura 54 – Mostrando os números pares de 0 a 20 (usando

repetição “while”).............................................................................. 84

Figura 55 – Mostrando os números pares de 0 a 20 (primeira

solução usando repetição “for”)................................................... 86

Figura 56 – Mostrando os números pares de 0 a 20 (segunda

solução usando repetição “for”).................................................... 86

Figura 57 – Acessando os caracteres da variável “binário” (do

tipo “str”) por meio de índices...................................................... 96

Figura 58 – Verificando o tipo dos caracteres da variável “binário”

(do tipo “str”) por meio do comando “type” do Python........97

Figura 59 – Verificando o tipo dos caracteres da variável “binário”

(do tipo “str”) por meio do comando “type” do Python........97

Figura 60 – Verificando o tamanho da lista com o comando

“len()”..................................................................................................... 98

Figura 61 – Modificando um elemento da lista.....................100

Figura 62 – Erro indica que o usuário tentou acessar um índice

não existente na lista......................................................................100

Figura 63 – Erro ao tentar apagar um elemento que não existe

na lista.................................................................................................101

Figura 64 – Criando um dicionário em Python com o uso de

chaves (“{}”)........................................................................................107

Figura 65– Criando um dicionário em Python com o uso da

palavra-reservada “dict”................................................................ 108

Figura 66 – Verificando as chaves de um dicionário usando o

comando “keys”................................................................................110
 Lista de figuras
15

Figura 67 – Verificando os valores de um dicionário usando o

comando “values”.............................................................................111

Figura 68 – Verificando os valores de um dicionário usando o

comando “values”............................................................................ 112

Figura 69 – O programa tenta imprimir o valor contido na

chave “c”............................................................................................. 113

Figura 70 – Mensagem de erro emitida pelo Python após o

programa tentar acessar uma chave que não existe.............. 114

Figura 71 – O programa verifica se a chave existe no

dicionário e, somente se ela existir, imprime o valor associado
a ela...................................................................................................... 114

Figura 72 – O programa verifica se a chave existe no dicionário,

e se ela não existe, ele imprime a mensagem “a chave não existe
no dicionário”................................................................................... 115

Figura 73 – Resultado da execução do programa escrito na

Figura 71............................................................................................. 115

Figura 74 – Resultado da execução do programa escrito na

Figura 71............................................................................................. 116

Figura 75 – Resultado da execução do programa escrito na

Figura 73............................................................................................. 116

Figura 76 – Erro ao tentar apagar um elemento associado a

uma chave não presente no dicionário..................................... 118

Figura 77 – Listagem de funções embutidas no Python......125

Figura 78 – Exemplo de código que efetua as operações de

soma, subtração, multiplicação e divisão................................ 126

Figura 79 – Código definindo quatro funções (soma, subtração,

multiplicação e divisão), em que cada uma delas executa uma
operação matemática específica.................................................. 127

Figura 80 – Código realizando a chamada das funções (soma,

subtração, multiplicação e divisão)............................................128
 Algoritmos e programação em Python para o Ensino Técnico Integrado
16

Figura 81 – Módulo “saudacao.py”................................................129

Figura 82 – Importando o módulo “saudacao.py” no interpretador

IDLE................................................................................................... 130

Figura 83 – Importando o módulo “saudacao.py” no interpretador

IDLE.................................................................................................... 131

Figura 84 – Verificando o valor da variável __name__ do

módulo “saudacao”............................................................................ 131

Figura 85 – Importando o módulo “saudacao” usando

“from.. import..”...................................................................................132

Figura 86 – Módulo “calculadora”..............................................134

Figura 87 – Resultado da impressão do valor da variável

__name__.........................................................................................134

Figura 88 – Módulo é executado somente se o valor da variável

__name__for igual a “__main__”............................................135

Figura 89 – Módulo “calculadora.py” contendo somente as

definições de funções.................................................................... 136

Figura 90 – Uso de “import” para importar as funções definidas

em “calculadora.py”....................................................................... 136

Figura 91 – Uso de “from..import” para importar as funções

definidas em “calculadora.py”...................................................... 137

Figura 92 – Função “soma” definida com dois parâmetros.138

Figura 93 – Função “soma” recebendo as variáveis “x” e “y”

como argumentos.......................................................................... 139

Figura 94 – Função “soma” retornando o resultado da

operação............................................................................................ 140

Figura 95 – Função “compara” verificando se os valores “x” e

“y” são iguais.................................................................................... 140

Figura 96 – Resultado da execução da função “compara”

passando os valores 3 e 3............................................................... 141
 Introdução
17

INTRODUÇÃO

Esta obra surgiu da necessidade de preparar um guia

de referência e/ou um livro didático sobre algoritmos de
programação para alunos do ensino técnico médio integrado
de informática do Instituto Federal do Piauí (IFPI). A disciplina
Algoritmos de programação é ministrada no 1º ano do ensino
médio, e propõe apresentar aos alunos o conceito de algoritmos
e programação, e como desenvolvê-los na resolução de
problemas.
Neste livro, para o desenvolvimento de algoritmos,
trabalharemos com a linguagem Python, versão 3.x (versão
3 ou superior). O objetivo aqui não é constituir um guia
aprofundado, mas um material didático que possa ser utilizado
como roteiro de estudo e em sala de aula, com atividades
comuns a serem executadas por professores e alunos. Para ter
acesso à documentação da linguagem, o leitor pode visitar o
endereço: https://www.python.org/doc/.
Os capítulos foram organizados com o intuito de apresentar
os conceitos básicos de algoritmos e programação, os quais são
desenvolvidos utilizando recursos da linguagem Python. Ao
término de cada capítulo (exceto o capítulo 1), estão dispostas
atividades complementares, a fim de que o leitor teste seus
conhecimentos e seu domínio sobre o conteúdo oportunizado.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
18
 Capítulo 1 - O que é programação?
19

O QUE É PROGRAMAÇÃO?

1.1 PROGRAMAÇÃO E O RACIOCÍNIO LÓGICO

Quando nos deparamos com o desafio de programar,

imaginamos que essa é uma atividade complexa e nunca,
antes, executada por nós. No entanto, para começar a falar
em programação, podemos mencionar uma atividade que
executamos todos os dias, a todo momento em nossas vidas,
que é o raciocínio lógico.
O raciocínio lógico é executado constantemente em
nossas vidas, pois em simples ações, como tarefas do dia a
dia, utilizamos o raciocínio. Um exemplo prático disso seria
o raciocínio que você desenvolve todos os dias para realizar
a tarefa de ir à escola; ou, ainda, o que você desenvolve para
realizar a soma total de suas compras no supermercado, e/ou
do valor máximo que você tem disponível para gastar nessa
compra.
Portanto, o raciocínio lógico está na tarefa de fazer um
bolo, como misturar os ingredientes, definir em quanto tempo
se deve colocá-lo no fogo, e assim por diante.
Então, com o objetivo de executar uma tarefa específica,
você pensa em pequenos passos sequenciados que o levarão
ao objetivo final. É assim que você trabalha mentalmente na
resolução de pequenos problemas do dia a dia. É dessa forma
também que você trabalha mentalmente para solucionar um
problema de matemática, por exemplo.
Como fazemos isso? Imagine o seguinte problema de
matemática:
Utilizando a propriedade distributiva, efetue a operação
sem o auxílio da calculadora: (+5) x (-3-4).
 Algoritmos e programação em Python para o Ensino Técnico Integrado
20

Lembrando que a propriedade distributiva é utilizada

quando um número está multiplicando uma adição ou subtração,
basta multiplicar em separado cada termo, e somar ou subtrair
o resultado.
Então, tente descrever o seu raciocínio em pequenos passos na
hora de realizar essa tarefa.
Vamos lá! Esse foi um raciocínio lógico utilizado para a
execução do problema:
Passo 1) (+5)x(-3) = -15
Passo 2) (+5)x(-4) = -20
Passo 3) -15-20= -35
Acima, observamos que para solucionar o problema,
devemos decompô-lo em três passos diferentes. Na Figura 1,
abaixo, você vê um esquema com a sequência de passos do
Formatado: Fonte: (P
raciocínio lógico, o objetivo desse raciocínio e o resultado
esperado.

Figura 1 – Sequência de passos de um raciocínio lógico

Fonte: elaborada pela autora (2021).

Na Figura 1, você consegue visualizar o raciocínio lógico

decomposto em passos, com o propósito de calcular o valor
da operação (+5) x (-3-4) usando a propriedade distributiva.
Verifique que após todos os passos serem executados, obtém-
se o resultado do raciocínio. No exemplo dado, o valor -35.
 Capítulo 1 - O que é programação?
21

Assim como o problema de matemática apresentado

acima, que foi decomposto em três pequenos passos para ser
solucionado, você está o tempo todo resolvendo tarefas no seu
dia a dia, pensando sobre a melhor maneira de solucioná-las
e, possivelmente, decompondo essas tarefas em passos. Isso é
raciocínio lógico. E você utiliza-o o tempo todo.
Então, agora que falamos um pouco sobre raciocínio
lógico, podemos concluir que a atividade de programação
é uma atividade essencialmente de raciocínio lógico. Olha
que legal, você já está acostumado a usar o raciocínio lógico
automaticamente em quase todas as tarefas do seu dia a dia!

1.2 A LINGUAGEM DE PROGRAMAÇÃO DE PYTHON

Imagine agora que você pedirá para o computador executar

a mesma sequência de passos realizada no exemplo da Figura
1. Então, como explicar isso para o computador? Agora, o
problema é de comunicação. Você consegue traduzir para o seu
cérebro o problema e efetuar essa tarefa sozinho, mas como
explicar isso para que o computador execute essa tarefa? Para
realizar essa comunicação, você precisa de uma LINGUAGEM
DE PROGRAMAÇÃO, que determinará a forma como você
deve descrever os passos que o computador executará, bem
como o resultado que será apresentado.
Existem muitas linguagens de programação no mercado,
cada uma com suas características específicas e regras para
determinar essa comunicação. É como definir se você falará
português, inglês ou espanhol – depende muito de seu objetivo,
da mesma maneira, para cada uma das linguagens, existem
formas diferentes de definir os passos a serem executados.
Essa “forma” de definir os passos nós chamamos também
de SINTAXE, que é a maneira como se escreve. Por exemplo:
em português, você diz Bom dia; em inglês, Good morning, e
 Algoritmos e programação em Python para o Ensino Técnico Integrado
22

assim por diante. Dessa forma, como a língua que você fala
possui uma sintaxe específica, a linguagem de computador que
você usa também possui sua própria sintaxe.
Logo, para que você faça um PROGRAMA DE
COMPUTADOR, você precisará usar uma LINGUAGEM DE
PROGRAMAÇÃO, e para usar essa linguagem de programação,
será necessário conhecer a sintaxe dessa linguagem.
A linguagem que utilizaremos neste livro é a linguagem de
programação Python versão 3.7. Você pode baixar gratuitamente
a linguagem Python no endereço https://www.python.org/
downloads/. No momento de criação desse material, a última
versão disponível no site era a 3.9.5, como visto na Figura 2.
Você pode baixar esta versão sem problemas. Qualquer versão
acima da 3 será compatível com as atividades realizadas neste
livro.

Figura 2 – Download da linguagem Python no site oficial

Fonte: (PYTHON, 2021).

 Capítulo 1 - O que é programação?
23

Então, agora sabendo de que precisamos de uma

LINGUAGEM DE PROGRAMAÇÃO, que usaremos a
linguagem PYTHON e que o Python possui uma SINTAXE
específica, como fazer um programa em Python que peça
para o computador executar a operação (+5)x(-3-4), usando a
propriedade distributiva?
A Figura 3 ilustra os três passos para realizar a operação,
traduzidos para a sintaxe Python.

Figura 3 – Programa escrito em Python com o objetivo de calcular a

operação (+5)x(-3-4) usando a propriedade distributiva

Fonte: elaborada pela autora (2021).

Você não conseguiu entender totalmente os passos

realizados na Figura 3, acima? Tudo bem! Provavelmente, você
não está entendendo porque ainda não conhece a SINTAXE
da linguagem Python. Tentaremos agora traduzir cada um dos
passos realizados no programa:
Passo 1) valor1 = (+5)*(-3)
O cálculo será realizado e o resultado (o valor -15) será
guardado dentro de “valor1”.
Considere “valor1” como uma caixa onde você pode
armazenar valores. Na linguagem, chamamos esse recurso
de VARIÁVEL. Uma variável pode receber diferentes valores
durante a execução de um programa.
Passo 2) valor2 = (+5)*(-4)
O cálculo será realizado e o resultado (o valor -20) será
guardado dentro da VARIÁVEL “valor2”.
Passo 3) resultado = valor1+valor2
 Algoritmos e programação em Python para o Ensino Técnico Integrado
24

A soma dos valores guardados em “valor1” e “valor2” é

realizada, e o resultado é guardado na VARIÁVEL “resultado”.
Passo 4) print(resultado)
Reparou que o passo 4 não existia na primeira solução? Os
passos anteriores realizaram as operações e usaram VARIÁVEIS
(“valor1”, ”valor2” e “resultado”) para guardar os resultados.
Mas em nenhum momento, esse resultado foi apresentado
na tela do computador. A FUNÇÃO “print()” é usada, em
Python, para imprimir um valor, este valor (chamado de
argumento) é definido entre os parênteses que acompanham
o nome da função. Logo, no exemplo, quando o programa for
executado, print(resultado) mostrará na tela do computador
o valor guardado na variável “resultado”, conforme mostra a
Figura 4.

Figura 4 – Ao executar o passo “print(resultado)”, o valor da variável

“resultado” é apresentado na tela do computador

Fonte: elaborada pela autora (2021).

Além da FUNÇÃO “print()”, existem várias outras funções

definidas na linguagem Python. Ainda sobre o exemplo da
Figura 4, até agora, vimos que para realizar a operação (+5)x(-
3-4) usando a linguagem Python, usamos VARIÁVEIS (“valor1”,
“valor2” e “resultado”) e uma FUNÇÃO (“print()”) . Além disso,
no Python, percorremos quatro passos para alcançar o objetivo
desejado.
 Capítulo 1 - O que é programação?
25

A esses passos realizados você pode chamar de

COMANDOS. Os COMANDOS são executados, no exemplo
dado, linha a linha, um após o outro, ou seja, sequencialmente.
Para que os COMANDOS sejam executados corretamente,
vimos que é preciso conhecer a SINTAXE da linguagem Python,
isto é, a forma correta de escrever tais comandos.
Na linha de comando “print(resultado)”, é impresso o valor
da variável “resultado” na tela do computador. Logo, podemos
dizer que esse é um COMANDO DE SAÍDA DE DADOS.
Veja, na Figura 5, o novo esquema (agora usando a linguagem
Python), similar ao da Figura 1.

Figura 5 – Sequência de comandos e sua execução em Python

Fonte: elaborada pela autora (2021).

1.3 O QUE NÓS VIMOS NESTE CAPÍTULO?

Conversamos aqui sobre como programar tem muito

a ver com uma atividade básica do seu dia a dia: o uso do
raciocínio lógico. Falamos que para programar, precisamos usar
 Algoritmos e programação em Python para o Ensino Técnico Integrado
26

o raciocínio lógico na resolução de problemas, assim como de

uma linguagem de programação. A linguagem de programação
que utilizaremos neste livro é a linguagem Python.
Falamos rapidamente também sobre alguns conceitos
usados em programação, tais como sintaxe, variáveis, a
função “print()” do Python, comandos e comandos de saída
de dados. Muita coisa? Não precisa ficar preocupado! Todos
esses conceitos serão discutidos de forma mais detalhada nos
próximos capítulos. Vamos continuar?
 Capítulo 2 - A linguagem python
27

A LINGUAGEM PYTHON

2.1 POR QUE USAR A LINGUAGEM PYTHON?

Python é uma linguagem muito fácil de aprender: sua

sintaxe é muito simples e permite ao programador concentrar-
se mais na solução do problema e menos com regras de sintaxe
de linguagem. Esse é um dos principais motivos para Python ser
uma linguagem tão adequada ao uso no estudo de algoritmos
e linguagem de programação, tendo em vista que estamos
começando o desafio de aprender a programar.
Por sinal, Python é um software livre, ou seja, pode ser
usado gratuitamente. Além disso, pode ser usado em qualquer
arquitetura de computadores ou sistema operacional como,
por exemplo, Windows, Linux ou Mac.

2.2 CARACTERÍSTICAS DE LINGUAGENS DE

PROGRAMAÇÃO

2.2.1 O interpretador Python

Para começarmos a desenvolver programas utilizando a

linguagem Python, precisamos instalar o interpretador Python
no computador, que é o programa que permite executar todos
os comandos da linguagem. Para desenvolver os exemplos
apresentados neste livro, você pode instalar a versão 3.8 ou
superior. Você pode baixar o interpretador Python no site
oficial https://www.python.org/downloads/.
Quando você abrir o programa interpretador, verá a janela
inicial do IDLE. A sigla IDLE significa Integrated Developmentand
Learning Environment (Ambiente Integrado de Desenvolvimento
e Aprendizagem). O IDLE é uma interface gráfica utilizada
 Algoritmos e programação em Python para o Ensino Técnico Integrado
28

pelo interpretador como um ambiente de desenvolvimento

integrado para a execução de programas e comandos escritos
em Python. A aplicação vem junto com a maioria das instalações
do Python e está presente na distribuição oficial, desde a versão
2.3. Veja a Figura 6.

Figura 6 – Janela inicial do IDLE

Fonte: elaborada pela autora (2021).

A janela inicial, na Figura 6, é a janela do interpretador.

Observe, ainda, que o cursor está posicionado dentro da janela,
e a linha de comando é iniciada pela sequência “>>> (também
chamada de prompt de comando). Você pode executar os
comandos Python linha a linha na janela do interpretador,
conforme mostra a Figura 7.

Figura 7 – Executando comandos na linha de comando do interpretador

IDLE

Fonte: elaborada pela autora (2021).

 Capítulo 2 - A linguagem python
29

Na Figura 7, o interpretador está sendo usado para realizar

as operações matemáticas “3+3” e, logo em seguida, “3*2”.
Em Python, você pode utilizar qualquer editor de textos
disponível, mas o IDLE também possui um editor de textos
próprio. Com a janela do IDLE aberta, clique no menu FILE,
selecione a opção NEW FILE. Uma nova janela será aberta.
Nela, você pode escrever seu programa Python. Veja a Figura 8.

Figura 8 – Usando o editor de textos do IDLE

Fonte: elaborada pela autora (2021).

Na Figura 8, podemos visualizar duas janelas: uma é a do

interpretador (a mesma da Figura 6); a outra é a do editor de
textos. Para salvar seu programa escrito no editor, você pode
clicar no menu FILE, selecionar a opção SAVE ou SAVE AS
(salvar e modificar o nome do arquivo). O programa escrito
em Python será salvo com a extensão “.py” automaticamente.
Veja na Figura 9.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
30

Figura 9 – Salvando o programa como o nome de “alomundo”

Fonte: elaborada pela autora (2021).

Verifique, na Figura 9, que na parte inferior da janela

SALVAR COMO, existe a definição do nome do arquivo e, logo
em seguida, o tipo do arquivo. No exemplo dado, o nome do
arquivo foi definido como “alomundo”.
Ainda na Figura 9, observe que o tipo de arquivo é definido
automaticamente como um arquivo do tipo Python (na janela
descrito como “Python files”). Assim, o programa escrito em
Python será salvo com a extensão “.py”. No exemplo visto,
o nome do arquivo, juntamente com a sua extensão, será
“alomundo.py”. Para executar o programa “alomundo.py” no
IDLE, você pode clicar em menu RUN, opção RUN MODULE.
Veja a Figura 10. A execução do programa será apresentada
na janela inicial ( janela do interpretador), conforme mostra
a Figura 11.

Figura 10– Opção de menu RUN usada para executar um programa

Python

Fonte: elaborada pela autora (2021).

 Capítulo 2 - A linguagem python
31

Figura 11 – Execução do programa “alomundo.py” na janela do

interpretador IDLE

Fonte: elaborada pela autora (2021).

2.2.2 Python é uma linguagem interpretada

Quando a sintaxe da linguagem é facilmente entendida

por nós, dizemos que ela é de alto nível. Isso posto, a linguagem
de programação simplifica o nosso trabalho, possibilitando que
nós, usuários programadores, possamos escrever um código-
fonte próximo da nossa própria linguagem e/ou entendimento.
Ocorre que o computador não consegue entender
diretamente o código-fonte escrito na linguagem de alto nível,
daí porque é necessária a tradução desse código para que o
computador possa executá-lo. Nesse processo, o código deve
ser transformado em um código mais próximo da linguagem
de máquina (imagine que o computador só entende sequências
de “0” e “1”, chamadas de código binário), ou seja, um código
que realmente o computador seja capaz de entender e executar.
Para realizar essa tradução, as linguagens de programação usam
diferentes estratégias.
O programa que você escreve (linguagem de alto nível),
segundo a sintaxe da linguagem, será lido e executado pelo
computador. Para que esse programa seja compreendido pela
máquina, antes, ele deve ser traduzido para uma forma que o
computador consiga entender.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
32

Você pode imaginar esse processo como algo semelhante

ao que acontece na vida real: imagine que você precisa se
comunicar com um nativo americano que acabou de chegar à
sua escola, mas você não entende uma única palavra em inglês
e ele, por sua vez, não entende nada em português. Você pedirá
ajuda a um amigo que domina o inglês e é capaz de traduzir
sua mensagem. Assim, seu amigo será seu tradutor, e o colega
americano conseguirá entender sua mensagem depois de
traduzida. Veja a Figura 12.

Figura 12 – Exemplo de um processo de tradução na vida real

Fonte: elaborada pela autora (2021).

Cada linguagem de programação usa um processo de

tradução. De acordo com o processo de tradução que uma
linguagem usa, ela pode ser classificada como compilada ou
interpretada.
Em uma linguagem compilada, o texto que você escreve
(chamado também de código-fonte do programa) é lido por
um tradutor, nomeado de compilador, ou seja, um programa
que lê o código-fonte e, a partir dele, cria outro arquivo, um
arquivo binário (igualmente chamado de arquivo executável).
Esse arquivo é a tradução do que foi escrito no código-fonte,
e uma vez realizada a tradução para o arquivo executável, ele
pode ser executado diretamente pelo seu computador. Veja a
Figura 13.

Figura 13 – Processo de compilação

Fonte: elaborada pela autora (2021).

 Capítulo 2 - A linguagem python
33

No processo de compilação da Figura 13, para criar o

arquivo com o código executável, o programa compilador
executa os seguintes passos:
Cria um código-objeto: converte o código-fonte em
linguagem de máquina (linguagem entendida pelo hardware
do computador). Esse código só é criado quando não há erros
no código-fonte. A extensão do arquivo que contém o código-
fonte é .OBJ.
Logo em seguida, um ligador ou linkeditor “junta” o
código-fonte com outros arquivos necessários presentes na
linguagem (chamados de “bibliotecas”). As extensões dos
arquivos de bibliotecas, geralmente, são .DLL ou .LIB. Dessa
união, é criado o arquivo executável. O código executável pode
ser, então, executado pelo sistema operacional do computador.
Contudo, em uma linguagem interpretada, não é criado
um arquivo executável. Nesse caso, o arquivo de código-fonte
é executado por meio do uso de outro programa, chamado
de interpretador. Assim, toda vez que o programa for usado,
o interpretador entrará em ação e o traduzirá diretamente,
durante a sua execução. Veja a Figura 14.

Figura 14 – Processo de interpretação

Fonte: elaborada pela autora (2021).

O interpretador lê o programa escrito em código-fonte

(linguagem de alto nível) e executa-o. Assim, o interpretador
processa o programa um pouco de cada vez, alternadamente,
lendo as linhas de comando e realizando as operações, linha
a linha.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
34

2.2.3 Variáveis e tipos de variáveis

Você lembra que no capítulo anterior falamos sobre

variáveis? Que elas são como caixas onde você pode armazenar
valores? Pois bem, esses valores podem ser de vários tipos.
Abaixo seguem alguns tipos básicos usados em Python:
- Inteiro (“int”): armazena valores do tipo inteiro. Exemplo: 2,
10, 20 etc. A Figura 15 mostra os comandos sendo escritos no
prompt (“>>>”) do interpretador. Na primeira linha, a variável
“a” recebe o valor 2. Logo em seguida, “b” recebe o valor 10, e
x, o valor “20”. Em seguida, os valores armazenados em cada
um deles é impresso na tela.

Figura 15 – Declarando variáveis do tipo “int” no interpretador do IDLE

Fonte: elaborada pela autora (2021).

- Ponto flutuante ou decimal (“float”): armazena valores com

casas decimais. Exemplo: 2.3, 4.35, 6.5 etc. Veja a Figura 16.
- String (“str”): armazena strings, ou seja, uma cadeia de
caracteres. Os valores, nesse caso, são armazenados entre
aspas simples (‘ ’) ou aspas duplas (“ ”). Exemplo: “casa”, “1234”,
“Maria de Fatima” etc. Veja a Figura 17.
 Capítulo 2 - A linguagem python
35

Figura 16 – Declarando variáveis do tipo “float” no interpretador do IDLE

Fonte: elaborada pela autora (2021).

Figura 17 – Declarando variáveis do tipo “str” no interpretador do IDLE

Fonte: elaborada pela autora (2021).

- Boolean (“bool”): armazenas valores booleanos, ou seja, valores

lógicos, os quais são representados por True (verdadeiro) ou
False (falso). Veja a Figura 18.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
36

Figura 18 – Declarando variáveis do tipo “bool“ no interpretador do IDLE

Fonte: elaborada pela autora (2021).

2.2.4 Verificando tipos com a função “type()”

No Python, para verificar o tipo de determinada variável

ou valor, você pode usar a função “type()”, conforme mostra o
exemplo na Figura 19.

Figura 19 – Checando o tipo de variáveis e valores com a função “type()”

Fonte: elaborada pela autora (2021).

 Capítulo 2 - A linguagem python
37

2.2.5 Python usa tipagem dinâmica

Em algumas linguagens, antes de armazenarmos um valor

na variável, devemos declarar o tipo da variável. Por exemplo,
o código abaixo mostra a sintaxe na linguagem Java:

Na primeira linha, ele declara “x” do tipo “int”. Logo em

seguida, armazena o valor 2 (dois) em “x”. Na segunda linha,
ele declara “y” do tipo “float”, e nessa mesma linha, armazena o
valor 2.3 em “y”. Como antes de armazenar o valor na variável,
é necessário declarar explicitamente qual o tipo da variável,
dizemos que a linguagem Java usa tipagem estática.
Na linguagem Python, não precisamos declarar as variáveis
nem seus tipos, ou seja, dizemos que Python possui tipagem
dinâmica.
No Python, o tipo ao qual a variável está associada pode
variar durante a execução do programa. Mesmo não declarando
explicitamente as variáveis, elas sempre assumem um único tipo
em determinado momento (tipagem forte). Veja na Figura 20.

Figura 20 – O Python informa que a operação não pode ser realizada,

pois as variáveis “x” e “y” são de tipos diferentes

Fonte: elaborada pela autora (2021).

 Algoritmos e programação em Python para o Ensino Técnico Integrado
38

Quando o tipo de dado não é bem definido, a linguagem

pode alterá-lo por alguma ação, sem intervenção direta do
programador. Nesse caso, dizemos que a linguagem possui
tipagem fraca. Veja o exemplo abaixo, feito na linguagem
Javascript:

2.2.6 Blocos de código e indentação em Python

Quando estamos construindo um programa, precisamos

organizar nosso código em blocos (subgrupos de códigos).
Blocos de código são pequenos trechos do programa que, para
serem executados, estão associados a alguma condição.
Na vida real, podemos verificar alguns exemplos de ações
que executamos durante o dia e que dependem das condições
da situação atual. No exemplo abaixo, descrevemos os passos
que devem ser executados na ação de ir para a escola:

Verifique, na Figura 21, as setas indicando o fluxo de

execução dos comandos.
 Capítulo 2 - A linguagem python
39

Figura 21 – Fluxo de execução de comandos usando a condição “se”

Fonte: elaborada pela autora (2021).

Veja que os passos 1, 2 e 3 devem ser executados

independentemente de qualquer condição. No entanto, o passo
4.1 só acontecerá se o passo 4 for uma condição verdadeira (se
estiver chovendo). Dizemos que o passo 4.1 depende de um
comando condicional “se” (passo 4). Podemos usar essa analogia
para dizer que o passo 4.1 é um trecho de código (ou bloco de
código) que depende do passo 4 para acontecer. Nesse caso,
o trecho de código possui um único comando (comando 4.1).
Logo em seguida, o passo 5 é executado.
Vamos agora modificar um pouco mais o nosso exemplo:
 Algoritmos e programação em Python para o Ensino Técnico Integrado
40

Agora, no passo 4, você deve ficar checando se ainda

está chovendo, pois enquanto estiver chovendo, você não
pode sair de casa. O passo 4.1 continua sendo o trecho de
código dependente do passo 4, só que agora você tem de ficar
verificando repetidas vezes se a chuva já passou ou não. Se a
chuva não passar, você não consegue continuar os demais passos,
ou seja, se a chuva não passar, você nunca executará o passo 5.
Dizemos que o passo 4.1 é um trecho de código (ou bloco
de código) que está dependendo de um comando de laço de
repetição “enquanto” (passo 4). Verifique na Figura 22 as setas
indicando o fluxo de execução dos comandos.

Figura 22– Fluxo de execução de comandos usando o laço de repetição

“enquanto”

Fonte: elaborada pela autora (2021).

Observe que tanto na Figura 21 (exemplo com o uso do

comando condicional “se”) quanto na Figura 22 (exemplo
com o uso do comando de repetição “enquanto”), o passo 4.1
é apresentado no código com um espaçamento a mais para
 Capítulo 2 - A linguagem python
41

a direita. Dizemos que o passo 4.1 está indentado à direita,

indicando que ele depende de a condição do passo 4 ser
verdadeira.
O Python usa a indentação como uma forma de arrumar o
código, fazendo com que algumas linhas fiquem mais à direita
que outras, à medida que adicionamos espaços em seu início.
Veja, na Figura 23, a indentação em destaque.

Figura 23 – Exemplo de indentação em Python

Fonte: elaborada pela autora (2021).

Assim, em Python, os blocos são demarcados apenas

por espaços de indentação. Essa característica da linguagem
faz com que o código fique muito mais enxuto, uma vez que
contém menos instruções e símbolos, além de se tornar um
código mais claro e legível.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
42

2.2.7 Comentários em Python

Comentários são informações que podem ser adicionadas

ao programa, como o autor do programa, objetivo do programa
etc. O interpretador deve ser avisado de que essas linhas não
devem ser processadas, e para isso, o Python usa caracteres
especiais.
Existem dois tipos de comentários em Python, por
exemplo, para definir um comentário por linha o Python usa
o caractere “#”. Veja na Figura 24.

Figura 24 – Inserindo comentários em uma linha

Fonte: elaborada pela autora (2021).

No exemplo acima, existem três linhas de comentários,

cada uma das quais é definida como um comentário, por meio
do uso do caractere #.
Para definir um comentário de mais de uma linha, são
utilizadas três aspas duplas (“““) ou três aspas simples (‘‘‘) no
início do comentário e ao término dele. Veja no exemplo da
Figura 25.
 Capítulo 2 - A linguagem python
43

Figura 25 – Inserindo um comentário de mais de uma linha

Fonte: elaborada pela autora (2021).

EXERCÍCIOS

1 . Defina o que você entende por programa de computador.

2 . Com base no que você leu até agora, o que você entende
por variáveis?

3 . Como você define o tipo de uma variável? Como você pode

verificar o tipo de uma variável no Python?

4 .A partir da versão 3.x da linguagem Python, o IDLE

é instalado juntamente com a linguagem Python no
computador. Marque V (Verdadeiro) ou F (Falso):

( ) A janela inicial do IDLE é conhecida como interpretador,

e pode ser usada para executar linhas de comando, tais como
comandos Python ou operações matemáticas.

( ) Na janela do interpretador, o comando deve ser digitado

logo após a sequência “>>>”, também conhecida como “prompt”
de comando do interpretador.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
44

( ) Para escrever um programa Python no IDLE, você deve,

inicialmente, acessar a opção de menu FILE/NEW FILE na
janela inicial e abrir uma nova janela, onde será escrito o
programa.

( ) Programas em Python podem ser salvos com qualquer

extensão.

( ) Programas em Python são salvos, automaticamente, com

a extensão “.py” no editor de texto do IDLE.

5 . Defina linguagem de alto nível.

6 . Define tipagem estática e tipagem dinâmica. Qual das duas

Python utiliza?

7 . Defina tipagem forte e tipagem fraca. Qual das duas Python

utiliza?

8 . Sobre a sequência de comandos abaixo:

Modifique a sequência e acrescente que se estiver frio, você

deve levar um casaco.

9 . Explique o que você entendeu por blocos de códigos e

indentação em Python.

10 . Pesquise na internet uma receita de bolo de chocolate.

Tente descrever em uma sequência de comandos a receita
que você encontrou.

11 . Tente descrever em uma sequência de comandos os passos

que devem ser realizados para trocar o pneu de um carro.
 Capítulo 3 - Python básico: variáveis, operadores e entrada e saída de dados
45

PYTHON BÁSICO: VARIÁVEIS,

OPERADORES E ENTRADA E
SAÍDA DE DADOS

3.1 O QUE É UMA VARIÁVEL?

No Capítulo 2, falamos que variáveis são como caixas

onde você pode armazenar valores, lembra? Então, ao escrever
programas, você deparar-se-á com a necessidade de armazenar
e manipular valores de dados. Para armazenar e manipular
esses valores de dados, você precisará usar o que chamamos
de variáveis.
Uma variável é simplesmente um nome que faz referência
a algum local (chamamos de “endereço”) na memória do
computador, onde é guardado um determinado valor. Para
criar uma variável no Python, precisamos associá-la a um valor
(ou a outra variável) usando o comando de atribuição que
corresponde ao símbolo “=”, como no trecho abaixo:
Variável = valor
Os valores nas variáveis são guardados temporariamente,
e só existem enquanto o programa é executado. Durante a
execução de um programa, uma variável pode ter seu valor
modificado várias vezes. Quando a execução do programa
acaba, os valores armazenados nas variáveis são perdidos
automaticamente.
Veja, na Figura 26, a soma de dois valores sendo realizada
no interpretador e o resultado sendo apresentado logo em
seguida. Para realizar a operação, foram criadas três variáveis.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
46

Figura 26 – Variáveis “a”, “b” e “c” definidas na janela do interpretador

IDLE

Fonte: elaborada pela autora (2021).

No exemplo da Figura 26, três variáveis foram criadas

(“a”, “b” e “c”). Você lembra que ainda falamos no Capítulo 2
sobre os tipos de variáveis? No exemplo dado, as três variáveis
são do tipo “int” no Python, ou seja, guardam valores do tipo
inteiro. Revise, no Capítulo 2, os tipos básicos “int”, “float”, “str”
e “bool” (seção 2.2.3 Variáveis e tipos de variáveis).
O exemplo da Figura 26 foi realizado na janela do
interpretador. Vamos agora escrever um programa que realize
a soma entre dois valores no editor de textos do IDLE. Veja a
Figura 27.

Figura 27 – Variáveis “a”, “b” e “c” definidas no editor de textos do IDLE

Fonte: elaborada pela autora (2021).

Você notou alguma diferença entre a sequência de

comandos escrita na Figura 26 e na Figura 27? Qual?
 Capítulo 3 - Python básico: variáveis, operadores e entrada e saída de dados
47

Verifique que no interpretador (Figura 26), a quarta linha

de comando está escrita apenas usando o nome da variável “c”.
Logo em seguida, o interpretador apresenta o resultado, “10”.
No interpretador, basta você escrever o nome da variável e o
valor dela será apresentado na tela. Quando você escreve o
programa no editor de textos, não é possível escrever somente
o nome da variável para obter o seu valor.
Para mostrar o valor guardado na variável, você deve usar
a função “print()”. Assim, na Figura 27, para mostrar o valor
armazenado na variável “c”, na quarta linha do programa, está
escrito “print(c)”. Falaremos mais sobre o função “print()” do
Python nas próximas seções.

3.2 REGRAS PARA NOMEAR VARIÁVEIS

Existem regras nas linguagens de programação na hora

de definir nomes de variáveis. No caso do Python:
- Nomes de variáveis devem começar com uma letra (maiúscula
ou minúscula) ou o caractere underline (_ ); o restante do nome
da variável pode ter letras, números e underline.
Exemplo de nomes de variáveis válidos: x, y , _valor , soma1,
Numero1 ....
Exemplo de nomes de variáveis inválidos: 2x, 4valor....
- Python é case-sensitive, ou seja, a linguagem faz diferença
entre letras maiúsculas e minúscula.
Exemplo: “Valor” e “valor” são considerados pelo Python coisas
diferentes, por causa da diferença maiúscula (na primeira
palavra) e minúscula (na segunda palavra) na letra “v”.

3.3 PYTHON É DINAMICAMENTE TIPADA

Em Pyton, você não precisa declarar as variáveis (dizer

explicitamente de que tipo a variável é) antes de usá-las. Veja
a Figura 28.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
48

Figura 28 – Comando de atribuição declara explicitamente a variável “x”

Fonte: elaborada pela autora (2021).

No exemplo da Figura 28, uma variável “x” recebe o valor

10. Com esse comando de atribuição de valor, automaticamente,
a variável “x” é criada no Python, e o valor do tipo inteiro 10 é
atribuído. O Python verifica o valor atribuído, 10, identifica que
ele é um inteiro, e dinamicamente, atribui o tipo int a variável
“x”. Logo, você não precisa explicitar que a variável “x” é do
tipo int, pois a linguagem Python é dinamicamente tipada e
resolve isso automaticamente para o programador.
Na Figura 29, usamos o função “type()” para checar o tipo
da variável “x”. Verifique que “x” é definida pela linguagem
como do tipo “int”.

Figura 29 – Usando a função “type()” para verificar o tipo da variável “x”

Fonte: elaborada pela autora (2021).

O tipo definido dinamicamente pode mudar, dependendo

dos valores que são atribuídos à variável. Na Figura 30, após
receber o valor inteiro 10, a variável “x” recebeu o valor “olá”
(Relembrando: os valores definidos entre aspas simples (‘ ‘) ou
 Capítulo 3 - Python básico: variáveis, operadores e entrada e saída de dados
49

duplas (“ “) são considerados cadeias de caracteres e definidos

como do tipo “str”). Então, “x” passa a ser uma variável do tipo
“str”.

Figura 30 – Mudando o valor e o tipo da variável “x”

Fonte: elaborada pela autora (2021).

Agora veja, na Figura 31, o exemplo escrito no editor IDLE.

Nele, inicialmente, o comando de atribuição “x=2” atribui o valor
2 à variável “x”. Logo em seguida, usa-se a função “print(x)” para
imprimir o valor de x e “print(type(x))” para imprimir o tipo da
variável “x”. Verifique a execução do programa na Figura 32.

Figura 31 – Declarando a variável “x” com diferentes tipos

Fonte: elaborada pela autora (2021).

 Algoritmos e programação em Python para o Ensino Técnico Integrado
50

Figura 32 – Executando o programa da Figura 31

Fonte: elaborada pela autora (2021).

3.4 MANIPULANDO STRINGS (TIPO “STR” DO PYTHON)

Uma string – tipo definido “str” no Python –, como já

vimos, pode ser definida como uma cadeia de caracteres, e
é possível acessar individualmente cada um dos elementos
dessa cadeia, os quais contém uma posição, por meio da qual
é possível acessar um elemento particular.
Exemplo: nome = “maria”
A primeira posição da cadeia começa com 0 (zero), logo:

nome[0] ‘m’

nome[1] ‘a’

nome[2] ‘r’

nome[3] ‘i’

nome[4] ‘a’

Assim, você também pode verificar um intervalo qualquer

dentro da cadeia de caracteres. Por exemplo, ao solicitar [2:4],
é retornado o intervalo “ri” dentro da cadeia. Isso acontece
porque o primeiro valor indica o início da cadeia e o segundo,
o fim dela – sendo que o valor nessa posição não é incluído na
seleção. Veja na Figura 33.
 Capítulo 3 - Python básico: variáveis, operadores e entrada e saída de dados
51

Figura 33 – Acessando elementos da “string”

Fonte: elaborada pela autora (2021).

Outra característica do tipo string é que se trata de uma

sequência imutável, ou seja, não pode ter seu valor modificado.
Veja na Figura 34 a mensagem de erro apresentada ao usuário,
ao tentar modificar um caractere da string. A mensagem
apresentada em vermelho diz que o tipo “str” não suporta
atribuição de valores.

Figura 34 – Tentando modificar um caractere na “string”

Fonte: elaborada pela autora (2021).

O tamanho de uma variável “str” no Python pode ser

verificado a partir do comando “len()”. Veja na Figura 35.

Figura 35 – Verificando o tamanho da “string”

Fonte: elaborada pela autora (2021).

 Algoritmos e programação em Python para o Ensino Técnico Integrado
52

3.5 Operadores

Quadro 1 – Operadores no Python

OPERAÇÃO OPERADOR (ES) EXEMPLO

UTILIZADO (S)
Adição + >> 2+2
>> 4
>> x = “teste”
>> y = “segundo teste”
>>x+y
>> “testesegundo teste”
Subtração - >> 10 – 5
>>5

Multiplicação * >>10*5
>>50
Divisão / >>10/5
>>2

>>5/2
>>2.5

Se desejar só resultado inteiro da divisão:

>>int(5/2)
>>2

O “int” captura somente a parte inteira da

divisão, ou seja, o valor sem casas
decimais.

Importante: Não é possível divisão por 0

(zero), a execução dessa operação causará
um erro no programa:

>>> 5/0
Traceback (mostrecentcalllast):
File "<pyshell#2>", line 1, in <module>
5/0
ZeroDivisionError: division by zero

Atribuição = >> x = 10
(assign men t) >> x = 20

Condicional de == >> x=10

Igualdade >> y=20
Usado em uma >> x==y
expressão booleana >>False
aonde:
>>x=10
Se os elementos forem >>y=10
iguais retorna >>x==y
verdadeiro (Tru e). >>True
 Capítulo 3 - Python básico: variáveis, operadores e entrada e saída de dados
53

Se os elementos forem >>5==5

diferentes retorna falso >>True
(F alse).
Condicional de != >>x=10
diferença >>y=14
Usado em uma >>x!=y
expressão booleana >>True
aonde:
>>x=10
Se os elementos forem >>y=10
Compara
diferentestodas as
retorna OBS:
>>x!=y(4==4) é True e (4<5) é True, logo o
expressões (Tru e).
verdadeiro booleanas de resultado
>>False é True.
uma sentença:
Se os elementos forem >>5!=5 and (4<5)
>>(4!=4)
-iguais retorna
Se todas falso
as expressões >>False
(F alse).verdadeiras,
forem
Comparação retorna
< (menor) verdadeiro OBS:
>> 4 <(4!=4)
5 é False e (4<5) é True, logo o
(True).
> (maior) resultado
>>True é False.
<= (menor ou igual)
-Se pelo menos
>= (maior uma das
ou igual) >>(4==4)
>> 4 <= 5 and (4<5) and (2!=2)
expressões for falsa, >>False
>>True
retorna falso (False).
>> 4 >(4==4)
OBS: 5 é True, (4<5) é True e (2!=2) é
Fazendo a tabela de False,
>>Falselogo o resultado é False.
Usados em uma
combinações possíveis
podemos
expressãover:
booleana, >> 4 >= 5
retornando verdadeiro >> False
(True)and
True ou True=
Falso (False),
True
de acordo com o >> 4>=4
resultado
True da
and False = False >>True
comparação.
False and True= False >> 4<=4
>>False
False and False= False
Lógico (or) or >>(4==4) or (4>5)
Lógica(not) not
Compara todas as >>not(True)
>>True
expressões booleanas de >>False
modifica
uma um valor
sentença: OBS: (4==4) é True e (4>5) é False, logo o
booleano >>not(False)
resultado é True.
- Se pelo menos uma >>True
das expressões for >>(4!=4) or (4>5)
verdadeira, retorna >>x=True
>>False
verdadeiro (True). >>not(x)
>>False
OBS: (4!=4) é False e (4>5) é False, logo o
-Se todas as expressões resultado é False.
Lógico (and) and
forem falsas, retorna >>(4==4) and (4<5)
falso (False). >>True or (4<5) or (2!=2)
>>(4==4)
>>True
Compara todas as OBS: (4==4) é True e (4<5) é True, logo o
Fazendo a tabela de
expressões booleanas de resultado é True.
combinações possíveis OBS: (4==4) é True, (4<5) é True e (2!=2) é
uma sentença:
podemos ver: False, logo o resultado é True.
>>(4!=4) and (4<5)
- Se todas as expressões >>False
True or True = True
forem verdadeiras,
True or False = True
retorna verdadeiro OBS: (4!=4) é False e (4<5) é True, logo o
False or True = True
(True). resultado é False.
False or False = False
-Se pelo menos uma das >>(4==4) and (4<5) and (2!=2)
expressões for falsa, >>False
retorna falso (False).
OBS: (4==4) é True, (4<5) é True e (2!=2) é
Fazendo a tabela de False, logo o resultado é False.
combinações possíveis
podemos ver:
 Fazendo a tabela de
expressões booleanas
combinações possíveisde resultado
OBS: é True.
(4==4) é True, (4<5) é True e (2!=2) é
uma sentença:
podemos ver: False, logo o resultado é True.
>>(4!=4) and (4<5)
Algoritmos e programação em Python para o Ensino Técnico Integrado
54 - Se todas
True or Trueas expressões
= True
foremorverdadeiras,
>>False
True False = True
retorna
False or verdadeiro
True = True OBS: (4!=4) é False e (4<5) é True, logo o
(True).
False or False = False resultado é False.

-Se pelo menos uma das >>(4==4) and (4<5) and (2!=2)
expressões for falsa, >>False
retorna falso (False).
OBS: (4==4) é True, (4<5) é True e (2!=2) é
Fazendo a tabela de False, logo o resultado é False.
combinações possíveis
podemos ver:

True and True= True

True and False = False

False and True= False

False and False= False

Lógico (or) or >>(4==4) or (4>5)
Compara todas as >>True
expressões booleanas de
uma sentença: OBS: (4==4) é True e (4>5) é False, logo o
resultado é True.
- Se pelo menos uma
das expressões for >>(4!=4) or (4>5)
verdadeira, retorna >>False
verdadeiro (True).
OBS: (4!=4) é False e (4>5) é False, logo o
-Se todas as expressões resultado é False.
forem falsas, retorna
falso (False). >>(4==4) or (4<5) or (2!=2)
>>True
Fazendo a tabela de
combinações possíveis OBS: (4==4) é True, (4<5) é True e (2!=2) é
podemos ver: False, logo o resultado é True.

True or True = True

True or False = True
False or True = True
False or False = False

Fonte: elaborada pela autora (2021).

3.6 A FUNÇÃO DE ENTRADA “INPUT()” E A FUNÇÃO DE

SAÍDA “PRINT()”

Já citamos aqui algumas funções existentes na linguagem

Python. Mas, afinal, o que é uma função? Podemos dizer que
uma função é uma sequência de comandos com determinado
nome que tem o objetivo de executar certa tarefa.
 Capítulo 3 - Python básico: variáveis, operadores e entrada e saída de dados
55

Nesse sentido, Python possui várias funções definidas na

linguagem que o programador pode utilizar. Além disso, você
pode definir suas próprias funções. Nas seções anteriores, nós
usamos as funções “type()” e “print()” do Python. Nesta seção,
falaremos, especificamente, de duas funções de entrada e saída,
respectivamente: a função “input()” e a função “print()”.
A função “input()” é utilizada para ler valores a partir do
teclado do computador. Como você está recebendo valores a
partir do teclado, dizemos que essa é uma função de entrada
de dados. Veja no exemplo abaixo:

No exemplo, a função “input()“ escreve na tela do

computador a mensagem “digite o valor de x:” e aguarda o valor
ser digitado por meio do teclado. Esse valor, por sua vez, será
atribuído à variável “x”. Veja o exemplo na Figura 36, em que o
usuário digita o valor 10. Logo, 10 será atribuído à variável “x”.

Figura 36 – Usando a função “input()”

Fonte: elaborada pela autora (2021).

A função “input()” , a partir do Python 3.x, considera por

padrão que o valor lido é do tipo “str”. Assim, no exemplo da
Figura 31, “x” recebe o valor “10”, sendo tipada como sendo
uma variável do tipo “str”.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
56

Nas versões 2.x do Python, a função usada para fazer a

leitura de um valor do tipo “str” era chamada de raw_input(). A
partir das versões 3.x, a função raw_input() foi simplesmente
renomeada para input(). Portanto, a partir das versões 3.x do
Python, a função raw_input() não existe mais.
Então, como ler valores de tipos diferentes usando somente
a função input() no Python 3.x? Você pode usar conversão de
tipos para resolver esse problema. Por exemplo, para ler um
valor do tipo “int”, converta o valor “str” retornado pela função
input() para “int”. Veja na Figura 37.

Figura 37 – Usando a função “input()” para ler um valor do tipo “int”

Fonte: elaborada pela autora (2021).

Para ler um valor do tipo “float”, converta o valor “str”

retornado pela função input() para “float”. Veja na Figura 38,
abaixo.

Figura 38 – Usando a função “input()” para ler um valor do tipo “float”

Fonte: elaborada pela autora (2021).

 Capítulo 3 - Python básico: variáveis, operadores e entrada e saída de dados
57

A função “print()”, por sua vez, é utilizada para apresentar

informações (cadeia de caracteres) e/ou valores na tela do
computador. Como você está apresentando dados a partir do
teclado, dizemos que essa é uma função de saída de dados.
Veja no exemplo abaixo:

Nesse exemplo, a mensagem “testando a saída de dados”

será impressa na tela. Observe que para apresentar uma
mensagem na forma de uma cadeia de caracteres (string), é
necessário colocar essa mensagem entre aspas (“ “ ou ‘ ‘) . No
caso da impressão de um valor de dados, as aspas não são
necessárias. Veja no exemplo:

Nesse exemplo, será apresentada a mensagem:

10

Ainda é possível combinar mensagem e valor em uma

mesma chamada da função “print()”. Veja no exemplo:

Nesse exemplo, será apresentada a mensagem:

No caso de existir mais de um valor a ser apresentado, é

possível separar a cadeia de caracteres utilizando vírgulas (,).
Veja no exemplo:
 Algoritmos e programação em Python para o Ensino Técnico Integrado
58

Outra forma de combinar uma cadeia de caracteres com

valores é a utilização da função “format()”, que em Python, serve,
basicamente, para criar uma string que contém campos entre
chaves que são substituídos pelos argumentos de “format()”.
Portanto, repare que os campos de substituição na string que
estão entre chaves ‘{}’ estão associadas aos parâmetros do
método “format()”.
Vamos reconstruir o último exemplo, agora, usando
“format()”:

No caso de existir mais de um argumento, é possível

indicar a sequência do que será apresentado na cadeia. Veja
no exemplo:

EXERCÍCIOS

1 . Qual o valor final das variáveis A e B, após a execução das

instruções abaixo?

A = 2
B = A*5
A = B+2
B = A-5
Valor A: ___________
Valor B:____________
 Capítulo 3 - Python básico: variáveis, operadores e entrada e saída de dados
59

2 . Mostre o que será impresso pelo seguinte algoritmo:

B=28
A= (B*2)
C=A-B
print(A)
print(C)
print(“C”)
Resposta: ___________________________________

3 . Faça um programa que receba dois números e, ao término,

mostre a soma, subtração, multiplicação e divisão dos
números lidos.

4 . Uma loja está vendendo seus produtos em cinco prestações

sem juros. Faça um programa que leia o valor de uma compra
e mostre o valor das prestações.

5 . Faça um programa que receba o preço de custo de um

produto e mostre o valor de venda. Sabe-se que o preço de
custo recebe um acréscimo de acordo com o percentual
informado pelo usuário.

6 . Leia uma velocidade em m/s, calcule-a e escreva-a em

km/h. (Vkm/h = Vm/s * 3.6).

7 . Leia um valor em horas e um valor em minutos, calcule e

escreva o equivalente em minutos.

8 . Leia o valor do dólar e um valor em dólar, calcule e escreva

o equivalente em real (R$).

9 . Leia um número inteiro (três dígitos), calcule e escreva a

soma de seus elementos (C + D + U).

10 . Leia uma velocidade em km/h, calcule-a e escreva-a em

m/s. (Vm/s = Vkm/h / 3.6)
 Algoritmos e programação em Python para o Ensino Técnico Integrado
60
 Capítulo 4 - Estrutura de decisão if
61

ESTRUTURA DE DECISÃO IF

4.1 O COMANDO IF

O comando “if” (“se”) serve para selecionar uma parte de

um código que deverá ser executada. Por exemplo, o programa
a seguir informa que um aluno está aprovado por média se a
nota dele for maior ou igual a 7.0.
Exemplo: Teste o programa com valores diversos entre
0 e 10, e veja o resultado.

No exemplo acima, no primeiro “if”, a expressão “nota>=7.0”

é testada. Seu resultado deve retornar verdadeiro (True) ou falso
(False). Somente se a expressão for verdadeira, o programa
executará a linha de código “print(“Você está aprovado por média.”)”.
No segundo “if”, a expressão “nota<7.0” é testada. Somente
se o resultado da expressão for verdadeiro (True), o programa
executará a linha de código “print(“Você não está aprovado por
média.”)”.

4.2 O COMANDO IF...ELSE

Outra forma de escrever o exemplo anterior é utilizar

o “if” combinado com o comando “else” (“então”). O “else” é
executado se a expressão dentro do “if” for falsa (False). Veja
a seguir:
 Algoritmos e programação em Python para o Ensino Técnico Integrado
62

Observe que ao utilizar o “else”, não foi mais preciso utilizar

o segundo “if” do exemplo anterior.
Imagine agora que você precisa verificar, ainda, duas
situações:
• se a nota é menor (<) do que 4 (quatro), deve ser
informado que o aluno está reprovado;
• se a nota é maior ou igual (>=) a 4 (quatro), deve ser
informado que o aluno fará prova final.
Observe que as duas situações podem acontecer quando
o programa entrar no bloco “else” do programa. Então, é lá que
você pode realizar essa modificação. Veja como ficou agora:

Agora, dentro do bloco “else”, temos 2 (dois) “ifs” seguidos.

Podemos, novamente, usar o “else” e retirar o segundo “if” do
código. Veja:
 Capítulo 4 - Estrutura de decisão if
63

Repare que você tem, agora, um bloco “if-else” mais

interno dentro de um bloco “else”, ou seja, para que o bloco
“if-else” mais interno seja executado, o resultado na expressão
“nota >=7” precisa ser falso (False).

4.3 O COMANDO IF... ELIF

Ainda existe outra estrutura do Python, além do “else”, que

pode ser utilizada combinada com o “if”. Seu nome é “elif”, e
nela combinam-se um comando “else” e um comando “if”, ou
seja, ao executar o comando “else”, efetua-se, igualmente, um
teste para uma nova expressão. Vamos modificar novamente o
exemplo anterior e usar essa estrutura. Veja abaixo como ficou:

Verifique que agora, não existe mais um bloco interno

“if” dentro do “else”. Seu programa, agora, contém uma única
estrutura “if” e associada a ela, existem os blocos “elif” e “else”.
Se a expressão “nota>=7” for falsa (False) o programa desvia
 Algoritmos e programação em Python para o Ensino Técnico Integrado
64

a execução para a linha do “elif”, se a expressão “nota<4” for

verdadeira (True), o programa executa a linha “print(“Você
está reprovado!!”)” e depois encerra a execução. Se a expressão
“nota<4” for falsa (False), o programa executa a linha “print(“
Você ainda vai fazer prova final!!! ” )” e depois encerra a execução.
Ainda é possível usar o “elif” sem que, necessariamente,
ele seja seguido de “else”. A opção “elif” é interessante quando
existe mais de uma situação a ser testadas pelo programa. Veja
no exemplo abaixo:

4.4 SINTAXE DO COMANDO DE DECISÃO IF

Assim, a sintaxe do comando de decisão “if” é a seguinte:

 Capítulo 4 - Estrutura de decisão if
65

As regras básicas são:

- a estrutura deve começar sempre com um IF;
- só é possível ter um ELSE na estrutura, isto é, o ELSE não
é obrigatório, mas se ele for usado, só pode estar uma única
vez na estrutura;
- depois do IF, é possível colocar quantos ELIFs forem desejados,
bem como terminar a estrutura com um ELIF.
- observe, também, que a indentação é necessária para cada
bloco de código contido dentro da estrutura.

EXERCÍCIOS

1 . O que será impresso após a execução das instruções abaixo?

A = 2
B = A*5
B = A-5
if A>2:
print(“o valor é “,A)
else:
print(“A é menor que 2!“)

Reposta: ________________________________

2 . O que será impresso após a execução das instruções abaixo?

A = 10
B = A*5
B = A-5
if A>=2:
print(“o valor é ”,A)
elif B<0:
print(“B é menor que 0!“)
 Algoritmos e programação em Python para o Ensino Técnico Integrado
66

Reposta: ________________________________

3 . O que será impresso após a execução das instruções abaixo?

A = 0
B = A*5
B = A-5
if A>=2:
print(“o valor é “,A)
elif B<0:
print(“B é menor que 0!“)
else:
print(“Nenhuma das alternativas anteriores!“)

Reposta: ________________________________

4 . Leia dois números e em seguida, verifique e escreva o

menor e o maior dentre os números lidos.

5 . Leia duas notas de um aluno e escreva na tela a palavra

“Aprovado” se a média das duas notas for maior ou igual a 7,0.
Caso a média seja inferior a 7,0, escreva “O aluno deve fazer
a prova final!”, logo em seguida, o programa deve ler a nota
da prova final e calcular a média final. Se a média final for
maior ou igual a 6,0, o programa deve escrever “Aprovado!”;
caso contrário, deve escrever “Reprovado!”.

6 . Leia dois valores e a operação matemática que deve ser

executada entre eles. Para definir a operação matemática
use as seguintes opções: “ Digite: 1 (Adição) / 2 (Subtração) / 3
(Multiplicação) / 4 (Divisão)”. Em seguida, calcule e escreva o
resultado dessa operação sobre os dois valores lidos.

7 . Leia um número e mostre na tela se ele é positivo ou

negativo.
 Capítulo 4 - Estrutura de decisão if
67

8 . Leia uma letra e verifique se ela é igual a “F”, se for escreva

“F – Feminino”; se ela for igual a “M” e escreva “M– Masculino”.
Se ela não for igual a nenhuma das duas opções escreva “O
valor digitado é inválido!!”.

9 . Leia o preço de três produtos e informe qual deles deve ser

comprado, sabendo que a decisão é sempre pelo mais barato.

10 . Leia o turno em que um aluno estuda, sendo “M” para

matutino, “V” para Vespertino e “N” para Noturno, e escreva
a mensagem “Bom Dia!”, “Boa Tarde!” ou “Boa Noite!”, ou “Valor
Inválido!”, conforme o caso.

11 . Leia um número inteiro e imprima se ele é par e divisível

por 3.

12 . Faça um algoritmo no Python que leia o nome e a idade

de uma pessoa e em seguida:

- Imprima o nome da pessoa;

- Se a pessoa tem 18 anos, imprima “A pessoa tem 18 anos!!”;

- Se a pessoa tem mais de 18 anos, imprima “A pessoa tem mais

de 18 anos!!!”;

- Se a pessoa tem menos de 18 anos, imprima “A pessoa tem

menos de 18 anos!!!”.

13 . A loja “Computadores e Cia” está vendendo seus produtos

em cinco prestações, sem juros. Na compra à vista, a loja dá
um desconto de 10%. Faça um algoritmo que receba o valor
de uma compra, mostre ao usuário como ficaria o valor das
prestações (para o caso de compra à prazo) e como ficaria o
valor à vista. Em seguida, o usuário deve escolher entre as
opções:
 Algoritmos e programação em Python para o Ensino Técnico Integrado
68

Opção <1> - Realizar compra a prazo

Opção <2> - Realizar compra à vista
Opção <3> - Cancelar
Após a escolha:

- Se o usuário escolheu opção <1> ou <2>, mostre na tela do

computador o valor da compra (no caso da compra a prazo,
mostre o valor total, o valor e quantidade de cada parcela).

- Se o usuário escolheu opção <3>, mostre na tela do computador

a mensagem: “Você não realizou a compra!!”
 Capítulo 5 - Estrutura de repetição
69

ESTRUTURA DE REPETIÇÃO
As estruturas de repetição, normalmente, são usadas
quando é necessário repetir determinada parte do código de
um número N de vezes. Um exemplo bem simples seria a soma
de todos os números inteiros de 1 a 10. Nesse problema, temos
uma soma que deve ser realizada dez vezes. Veja a Figura 39.

Figura 39– Bloco de repetição no exemplo “a soma dos números inteiros

de 1 a 10”

Fonte: elaborada pela autora (2021).

No exemplo acima, as linhas 3 e 4 irão se repetir (chamamos

também de “loop” de repetição ou laço de repetição) enquanto
o valor de “num” for menor ou igual a 10.
Neste capítulo, estudaremos as duas estruturas de repetição
existentes na linguagem Python, a saber:
• while
• for

5.1 O COMANDO WHILE

A estrutura “while” (“enquanto”) tem como objetivo repetir

a execução de um bloco de código enquanto determinada
condição é válida, ou seja, enquanto uma condição for verdadeira
 Algoritmos e programação em Python para o Ensino Técnico Integrado
70

(True), um bloco de código será executado repetidas vezes. No

momento em que a condição for falsa (False), o processamento
da rotina será desviado para fora do laço de repetição.
Assim, refazendo o exemplo da Figura 39, podemos
reescrever esse código em Python, utilizando a estrutura “while”.
Veja na Figura 40.

Figura 40 – O comando de repetição “while” no exemplo de “a soma dos

números inteiros de 1 a 10”

Fonte: elaborada pela autora (2021).

No exemplo da Figura 40, o comando de repetição “while”

verifica a condição “num<=10”. E enquanto ela for verdadeira
(True), um bloco de código (contendo as linhas de comando
“soma = soma + num” e “num = num + 1”) será executado repetidas
vezes (dez vezes).
É importante observar que ao utilizar um comando de
repetição em um programa, a condição, em algum momento,
precisa ser false (False) para que o bloco de repetição possa ter
um “ponto de parada”. Se a condição sempre for verdadeira
(True), o laço de repetição repetir-se-á indefinidamente no
programa. Chamamos essa situação de “loop infinito”, e ela
causa um erro de semântica no programa. Veja na Figura 41.

Figura 41 – Exemplo de um programa em “loop infinito”

 Capítulo 5 - Estrutura de repetição
71

Fonte: elaborada pela autora (2021).

Na Figura 41, a condição do comando “while” é sempre

verdadeira (True), o que faz com que o programa entre em loop
infinito. Veja a execução do programa na Figura 42.

Figura 42 – Execução do programa em “loop infinito”

Fonte: elaborada pela autora (2021).

Logo, para que a repetição pare de ser executada, em

algum momento, a condição envolvida deve passar a ser falsa
(False). Com isso, é possível garantir que existirá um ponto de
parada para a repetição.
A sintaxe do comando de repetição “while” é a seguinte:

A seguir, mostraremos mais alguns exemplos usando o

comando de repetição “while”:
IMPORTANTE: nos exemplos 1, 2, 3 e 4, a seguir, observe que
não é possível saber, antes da execução do programa, quantas
vezes o bloco de código irá se repetir, pois a quantidade de
repetições depende do valor digitado pelo usuário.
EXEMPLO 1: enquanto o usuário digitar a opção 1 o programa
executará o bloco de repetição. Se um valor diferente de 1 for
digitado, o programa encerrará a execução. Veja na Figura 43.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
72

Figura 43 – Código em Python com o exemplo 1

Fonte: elaborada pela autora (2021).

Veja na Figura 44 a execução do exemplo 1.

Figura 44 – Execução do exemplo 1

Fonte: elaborada pela autora (2021).

Veja, na Figura 44, que enquanto o usuário digita 1 (um), o

bloco de código associado ao “while” continua a ser executado.
O “ponto de parada”, nesse caso, é quando o valor de “op” for
diferente de 1 (nesse momento, o resultado da condição (op==1)
retornará falso (False), e o programa desvia, então, a execução
para o próximo comando (após o bloco de repetição “while”).

EXEMPLO 2: enquanto o usuário digitar “S” ou “s” (indica

“SIM”, sinalizando que o usuário quer continuar no programa),
este executará o bloco de repetição. Se um valor diferente de
“s” ou “S” for digitado, o programa encerrará a execução. Veja
na Figura 45.
 Capítulo 5 - Estrutura de repetição
73

Figura 45 – Código em Python com o exemplo 2

Fonte: elaborada pela autora (2021).

No exemplo 2, a condição (op.upper()==”S”) será falsa

(False) quando op for diferente de “s” ou “S”. Observe que o
uso da função “upper()” faz com que o valor contido na variável
“op” seja colocado em caixa alta (maiúscula). Para transformar
caracteres em maiúsculo, no Python, você pode usar a função
“upper()”. Da mesma forma, para transformar caracteres em
minúsculo, você pode usar a função “lower()”.
Veja na Figura 46 a execução do exemplo 2.

Figura 46 – Execução do exemplo 2

Fonte: elaborada pela autora (2021).

Observe que tanto no exemplo 1 quanto no exemplo 2,

foi necessário, antes de executar o laço de repetição, inicializar
o valor da variável “op”. No primeiro caso, “op” é inicializado
com 1, e no segundo, “op”, com “S”. A inicialização de valor é
 Algoritmos e programação em Python para o Ensino Técnico Integrado
74

necessária para que a condição associada ao comando “while”

seja verdadeira (True) e, pelo menos uma vez, o laço de repetição
seja executado.
Suponha a retirada do valor inicial de “op” tanto no
exemplo 1 quanto no exemplo 2.
No exemplo 1, modifique para:

No exemplo 2, modifique para:

O que aconteceria na execução dos programas? Ambos

apresentariam um erro na execução, indicando que é impossível
verificar as condições porque a variável “op” (em ambos os
exemplos) não foi definida.
Veja o resultado da execução do exemplo 2, após a
modificação, na Figura 47.

Figura 47– Erro de exceção após modificação no exemplo 2

Fonte: elaborada pela autora (2021).

Verifique que em ambos os casos (exemplo 1 e exemplo 2),

é necessário um valor prévio para a variável “op”, caso contrário,
o programa sofrerá um erro de exceção (um erro de exceção
em Python força a saída automática do programa).
 Capítulo 5 - Estrutura de repetição
75

Veja, na Figura 47, a informação, em vermelho, na linha

de exceção (“NameError: name ‘op’ is not defined”), indicando
que a variável “op” não foi definida previamente, e por isso,
foi impossível verificar o valor da condição (op.upper()== “S”).

EXEMPLO 3: usando um loop infinito para definir que enquanto

o usuário digitar a “S” (indica “SIM”, sinalizando que ele quer
continuar no programa), o programa executará o bloco de
repetição. Se um valor diferente de “s” ou “S” for digitado, o
programa encerrará a execução. Veja na Figura 48.

Figura 48 – Código em Python com o exemplo 3

Fonte: elaborada pela autora (2021).

No exemplo 3, realiza-se um comando “if” dentro do laço

de repetição. A função da condicional “if”, nesse caso, é “forçar”
um ponto de parada, ou seja, quando a condição (op.upper()!=
“S”) for verdadeira (True), indica que o usuário digitou um
valor diferente de “S” ou “s”, e o programa executará a linha
de código com o comando “break”. O comando “break” força a
saída do laço de repetição, e então, o programa é encerrado.
Antes de conferir o próximo exemplo, tente modificar
o exemplo 1 e defina agora nele um loop infinito. O ponto de
parada deve ser quando o valor de “op” for diferente de 1.
EXEMPLO 4: no exemplo 3 anterior, verifique que o usuário
pode digitar quaisquer valores diferentes de “S” ou “s”. Vamos
modificar o programa do exemplo 3 de maneira que agora, o
programa só aceite ler valores contidos no conjunto [“S”, “s”, “N”,
 Algoritmos e programação em Python para o Ensino Técnico Integrado
76

“n”]. Para quaisquer valores diferentes que forem digitados, o

programa deve informar que o valor informado pelo usuário
é inválido. Veja na Figura 49.

Figura 49– Código em Python com o exemplo 4

Fonte: elaborada pela autora (2021).

Veja o resultado da execução do exemplo 4 na Figura 50.

Figura 50 – Execução do exemplo 4

Fonte: elaborada pela autora (2021).

IMPORTANTE: observe agora que nos exemplos 5, 6 e 7, a

seguir, é possível saber, antes da execução do programa, quantas
vezes o bloco de repetição se repetirá, pois a quantidade de
repetições é definida previamente.
 Capítulo 5 - Estrutura de repetição
77

EXEMPLO 5: o programa deve mostrar todos os números

pares entre 1 e 20. Veja na Figura 51.

Figura 51 – Código em Python com o exemplo 5

Fonte: elaborada pela autora (2021).

No exemplo 5, acima, temos um bloco de 20 (vinte)

repetições. Dentro do “while”, temos o seguinte bloco de
comandos:

Na expressão “num%2==0”, ele verifica se o resto da divisão

de “num” por 2 é igual a 0. Se for, então, o número é par, o
programa entra no bloco de código associado ao “if” e imprime
o valor na tela do computador (print(num)).
Na linha “num+=1”, o valor de “num” é incrementado de 1.
Na linha “cont+=1”, o valor de “cont” é incrementado de 1.
A variável “cont” é usada na linha “while cont<=20:” como
um “contador”, ou seja, ela controla a quantidade de vezes que
o laço de repetição acontece. Note que é preciso, no caso do
comando “while”, que o contador seja inicializado antes dele
para que a expressão possa ser avaliada pela primeira vez.
Além disso, é necessária a atualização do valor de “cont” a
cada repetição do laço. Nessa solução, o laço de repetição é
executado 20 (vinte) vezes.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
78

EXEMPLO 6: usando outra solução para um programa que

mostra todos os números pares entre 1 e 20. Veja na Figura 52.

Figura 52 – Código em Python com o exemplo 6

Fonte: elaborada pela autora (2021).

Note que agora, usamos uma única variável (“num”),

que é usada como contador e controla a quantidade de vezes
que o laço se repete. Ela é inicializada antes do “while”, com
o valor 0 (zero) (“num = 0”), e dentro do laço de repetição,
é incrementada de 2 (“num +=2”). Nessa solução, o laço de
repetição é executado dez vezes.
EXEMPLO 7: faça um programa que mostre a soma dos 30
(trinta) primeiros números inteiros divisíveis por 5. Veja na
Figura 53.

Figura 53 – Código em Python com o exemplo 7

Fonte: elaborada pela autora (2021).

Observe que a variável “num” (usada como contador) é

inicializada com 0 (zero) na linha “num = 0”, e dentro do laço
de repetição, é incrementada de 5 (cinco). A variável “soma”, a
cada repetição do laço, atualiza o valor da soma dos números
(“soma = soma + num”).
 Capítulo 5 - Estrutura de repetição
79

Perceba o comando “print” será executado somente uma

vez, pois está fora do laço de repetição do comando “while”.
Nessa solução, o laço de repetição é executado 6 (seis) vezes.

EXERCÍCIOS

1 . De acordo com o código abaixo, responda às questões:

a) Qual a condição?

b) Quantas vezes o laço de repetição “while” se repete?

c) Por que esse laço de repetição é também chamado de “loop

infinito”?

2 . De acordo com o código abaixo, responda às questões:

a) Qual a condição?

b) A condição é verdadeira ou falsa (True or False)?

c) O que será impresso?

d) Quantas vezes o laço de repetição “while” é executado?

3 . De acordo com o código abaixo, responda às questões:

 Algoritmos e programação em Python para o Ensino Técnico Integrado
80

a) Qual o último valor impresso ao término do programa?

b) Qual o último valor de “cont”, ao término do programa?

c) Preencha a tabela:

Observação: a quantidade de LINHAS na tabela NÃO SIGNIFICA

A QUANTIDADE DE REPETIÇÕES. Você PODE INCLUIR
LINHAS, SE NECESSÁRIO, ou ignorar LINHAS A MAIS.

4 . De acordo com o código abaixo, responda às questões:

a) Qual a condição?

b) A condição é verdadeira ou falsa (True or False)?

c) O que será impresso?

d) Quantas vezes o laço de repetição “while” é executado?

e) Qual o valor de “x” no fim do programa?

 Capítulo 5 - Estrutura de repetição
81

5 . De acordo com o código abaixo, responda às questões:

a) Qual a condição?

b) A condição é verdadeira ou falsa (True or False)?

c) O que será impresso?

d) Quantas vezes o laço de repetição “while” é executado?

e) Qual o valor de “x” no fim do programa?

6 . De acordo com o código abaixo, responda às questões:

a) Qual a condição?

b) A condição é verdadeira ou falsa (True or False)?

c) O que será impresso?

d) Quantas vezes o laço de repetição “while” é executado?

e) Qual o valor de “x” no fim do programa?

f) Existe algum erro no programa acima? Se sim, explique

qual o erro?

7 . De acordo com o código a seguir, responda às questões:

 Algoritmos e programação em Python para o Ensino Técnico Integrado
82

a) Qual a condição?

b) Quantas vezes o laço de repetição “while” é executado?

c) Preencha a tabela a seguir:

Observação: a quantidade de LINHAS na tabela NÃO SIGNIFICA

A QUANTIDADE DE REPETIÇÕES. Você PODE INCLUIR
LINHAS, SE NECESSÁRIO, ou ignorar LINHAS A MAIS.

8. De acordo com o código abaixo, responda às questões:

a) Qual a condição?
 Capítulo 5 - Estrutura de repetição
83

b) Quantas vezes o laço de repetição “while” é executado?

c) Preencha a tabela a seguir:

Observação: a quantidade de LINHAS na tabela NÃO SIGNIFICA

A QUANTIDADE DE REPETIÇÕES. Você PODE INCLUIR
LINHAS, SE NECESSÁRIO, ou ignorar LINHAS A MAIS.

5.2 O COMANDO FOR

O comando “for” também é utilizado para criar uma

estrutura de repetição, no entanto existem algumas diferenças
em relação ao comando “while” visto anteriormente. Ao usar
o “for”:
- não existe a necessidade de inicializar uma variável (contador)
antes do início do laço de repetição;
- não existe a necessidade de, dentro do laço de repetição,
existir o incremento do valor da variável (contador).
A sintaxe do comando de repetição “for” é a seguinte:
 Algoritmos e programação em Python para o Ensino Técnico Integrado
84

Onde <var> é o nome de uma variável, e <iteração> é a

iteração que será executada. A <iteração> pode ser considerada
como um conjunto de valores. A cada volta do comando de
repetição, <var> assume um dos valores do conjunto.
É comum surgir dúvidas tais como: Qual dos 2 (dois)
comandos utilizar: “while” ou “for”? Quando usar um ou o
outro?
Normalmente, é possível usar qualquer dos 2 (dois) laços
de repetição, mas podemos dizer que o uso do comando de
repetição “for” pode ser mais apropriado para os casos em
que o programador conhece, antes da execução do laço de
repetição, quantas vezes a repetição deve acontecer.
Por exemplo, se o problema é mostrar todos os números
pares de 0 (zero) a 20 (vinte), já é possível supor, antes da
execução do programa, que a repetição acontecerá em um
intervalo de 0 (zero) a 20 (vinte). O problema pode ser resolvido
usando um laço de repetição “while”, mas empregar o laço de
repetição “for”, nesse caso, pode tornar o problema menor e
mais legível. Veja, na Figura 54, a solução usando um laço de
repetição “while”.

Figura 54 – Mostrando os números pares de 0 a 20

(usando repetição “while”)

Fonte: elaborada pela autora (2021).

Para escrever o programa da Figura 54 usando a repetição

“for”, inicialmente, precisamos entender outro conceito muito
ligado à construção do comando “for” na linguagem Python:
o uso da iteração com o comando “range”.
 Capítulo 5 - Estrutura de repetição
85

5.2.1 O uso da iteração com “range”

O comando “range” é usado para iterar um intervalo de

valores, gerando listas contendo progressões aritméticas. Veja
nos exemplos:
• range(4)
Abrange o intervalo [0,1,2,3]
• range(1,8)
Abrange o intervalo [1,2,3,4,5,6,7]
• range(0,10,2)
Abrange o intervalo [0,2,4,6,8]
Existem várias maneiras possíveis de usar o comando
“range”:
• range(<fim_do_intervalo>)
Nesse caso, o Python supõe, como padrão, que o início
do intervalo é o valor 0 (zero) e que o incremento de valor (a
cada repetição efetuada) é igual a 1.
O <fim_do_intervalo> não participa do intervalo. A
repetição acontece sempre até o <fim_do_intervalo> - 1.
Ex.: range(6) é referente ao intervalo [0,1,2,3,4,5]

• range(<inicio_do_intervalo>,<fim_do_intervalo>)
Nesse caso, o Python assume <inicio_do_intervalo> como
valor inicial do intervalo. Como padrão, o incremento de valor
(a cada repetição efetuada) é igual a 1.
O <fim_do_intervalo> não participa do intervalo. A
repetição acontece sempre até o <fim_do_intervalo> - 1.
Ex.: range(1,8) é referente ao intervalo [1,2,3,4,5,6,7]

• range(<inicio_do_intervalo>,<fim_do_
intervalo>,<incremento>)
Nesse caso, além do <inicio_do_intervalo> e <fim_do_
intervalo>, o Python assume também o valor <incremento>
como sendo o valor que será incrementado a cada repetição
do laço.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
86

O <fim_do_intervalo> não participa do intervalo. A

repetição acontece sempre até o <fim_do_intervalo> - 1.
Ex.: range(1,8,2) é referente ao intervalor [1,3,5,7]
Agora, conhecendo o comando “range”, podemos escrever
o programa da Figura 55 usando a repetição “for” combinada
com o intervalo definido pelo “range”. Veja na Figura a seguir.

Figura 55 – Mostrando os números pares de 0 a 20 (primeira solução

usando repetição “for”)

Fonte: elaborada pela autora (2021).

Na solução da Figura 55, o laço de repetição repete-se

21 (vinte e uma) vezes. Vamos ver na Figura 56 outra solução,
também usando o “for”.

Figura 56 – Mostrando os números pares de 0 a 20 (segunda solução

usando repetição “for”)

Fonte: elaborada pela autora (2021).

Na solução da Figura 56, o laço de repetição repete-se 11

(onze) vezes. Verifique que nessa solução, o valor do incremento
é de 2 (dois), e que, assim, não existe mais a necessidade de
usar o comando “if” para testar se o valor é par ou ímpar, pois
somente os números pares entrarão no intervalo.
 Capítulo 5 - Estrutura de repetição
87

5.2.2 O uso de outros “iteratores”

Podemos observar, ainda, sobre o comando “for”, que ele

não precisa de uma condição (como no caso do “while”). Ele
precisa, simplesmente, de um argumento iterável e de uma
variável para repassar o item de cada iteração.
O comando “for”, além de iterar sobre progressões
aritméticas (como no caso do uso do “range”) em Python, pode
iterar sobre os itens de uma sequência (ex.: uma lista ou uma
cadeia de caracteres), na ordem em que aparecem na sequência.
Veja os exemplos abaixo:
• iteração em uma cadeia de caracteres:

• iteração em uma lista:

EXERCÍCIOS

USANDO COMANDO DE REPETIÇÃO FOR

1 . De acordo com os códigos abaixo, verifique o que será

impresso e preencha na tabela ao lado:

Obs. 1: todos os exemplos dessa questão estão relacionados ao

comando de repetição FOR.

Obs.2: a quantidade de LINHAS na tabela NÃO SIGNIFICA

A QUANTIDADE DE REPETIÇÕES, você PODE INCLUIR
LINHAS SE NECESSÁRIO ou ignorar LINHAS A MAIS.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
88

a)

for x in range(5):
print(x**2)

b)

for x in range(4):
print(x)
 Capítulo 5 - Estrutura de repetição
89

c)

for b in range(1,9):
print(b+1)

d)

for b in range(3):
print(x)
 Algoritmos e programação em Python para o Ensino Técnico Integrado
90

e)

for x in range(2,7):
print(“x“)
print(x)

f)

for x in range(0,12,2):
print(x)
 Capítulo 5 - Estrutura de repetição
91

g)

for y in range(0,12,3):
print(“o valor é “,y)

h)

for x in range(1,12,2):
print(“x é “,x)
 Algoritmos e programação em Python para o Ensino Técnico Integrado
92

i)

for x in range(20,10,-2):
print(x)

j)

for x in range(10,1,-1):
print(“x é “,x)
 Capítulo 5 - Estrutura de repetição
93

2 . De acordo com o código abaixo:

Obs: nessa questão, observe o uso do “end” dentro do comando

“print” e verifique o que ele faz.

for x in range(5):
print(x*2,end= “ “)

2.1 Ao término da execução do código, quais valores serão

impressos?

a. ( ) 0 1 4 9 16

b. ( ) 0 1 4 9 16 25

c. ( ) 0 2 4 6 8

d. ( ) 0 2 4 6 8 16

2.2 Você entendeu qual a finalidade do uso do “end” neste

código? Explique.

EXERCÍCIOS
USANDO COMANDO DE REPETIÇÃO WHILE E FOR

Leia atentamente o enunciado das questões e construa o

programa em Python. Você pode usar o comando de repetição
WHILE e/ou usar o comando de repetição FOR para solucionar
as questões.

1 . Faça um algoritmo que leia diversos números positivos e

escreva, para cada um, o dobro de seu valor. O programa
deve ser executado até que o usuário informe que não deseja
mais continuar.

2 . Faça um algoritmo que leia um número binário e

transforme-o em decimal.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
94

3 . Escreva um programa que leia o valor da série de Fibonacci

que o usuário deseja imprimir. Imprima o valor da série
de Fibonacci solicitada pelo usuário. O programa deve ser
executado até que o usuário informe que não deseja mais
continuar.

OBS: na série de Fibonacci, começando de 1, essa sequência é

formada somando cada numeral com o numeral que o antecede:
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
Por exemplo, na sequência acima, o 4º termo da série é 3.

4 . Escreva um algoritmo para ler as notas de uma prova de

matemática de cinco alunos. Calcule a média da turma. O
programa deve imprimir o valor da média e o valor da maior
nota do aluno.

5 . Escreva um algoritmo para ler as notas de uma prova de

matemática de um grupo de alunos. O programa deve ser
executado até que o usuário informe que não deseja mais
continuar (todos as notas foram lidas). Calcule a média da
turma. O programa deve imprimir o valor da média e o valor
da menor nota do aluno.

6 . Faça um algoritmo no Python que mostre os dez primeiros

números ímpares.

7 . Leia dez números e exiba a soma dos números pares.

8 . Leia dez números e exiba qual o maior e qual o menor.

9 . Faça um algoritmo que leia diversos números. O programa

deve ser executado até que o usuário informe que não deseja
mais continuar. Ao término, exiba qual o maior e qual o
menor número lido.

10 . Faça um algoritmo que leia dez números e informe, para

cada um deles, se ele é positivo ou negativo.
 Capítulo 6 - Lista
95

LISTA
Uma “lista” é uma das estruturas de dados disponíveis em
Python. Por meio dela, você pode armazenar um conjunto de
valores. Imagine uma lista no mundo real:
• uma lista de supermercado informa o conjunto de
itens que você deseja comprar;
• uma lista de alunos informa os dados dos alunos de
uma turma;
• uma lista de tarefas para serem executadas informa
a quantidade de tarefas que você deseja realizar durante
um dia, por exemplo.
As listas são sequências mutáveis. É possível, em uma lista no
Python, armazenar dados heterogêneos, mas ela é normalmente
usada para armazenar coleções de itens homogêneos (o grau
preciso de similaridade variará de acordo com a aplicação).
As listas em Python têm o mesmo significado das listas
no mundo real. Então, por que usar listas? Sempre que for
necessário representar um conjunto de valores, uma opção é
você usar uma lista para representar isso em Python.
Exemplos de conjuntos de valores:
Conjunto finito das vogais = {a,e,i,o,u}
Conjunto infinito dos números pares ={2,4,6,8,10,12....}
Conjunto finito A = {1,2,3,4}
Conjunto finito B = {3,4,5,6,7}
Conjunto finito A ∩ B = {3,4}
Uma lista é um conjunto ordenado de valores. Ela tem
características semelhantes a um tipo “str”. Você lembra como
se identifica, individualmente, os elementos de uma variável
do tipo “str”? Exemplo: cada elemento da “str” é reconhecido
com um índice que vai de 0 (zero) até o seu tamanho – 1.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
96

Na Figura 57, a variável de nome “binário” do tipo “str”

possui tamanho 5 (cinco) e os índices 0, 1, 2, 3 e 4 para cada
um dos caracteres envolvidos.

Figura 57 – Acessando os caracteres da variável “binário” (do tipo “str”) por

meio de índices

Fonte: elaborada pela autora (2021).

As listas são similares as strings “str” do Pyton, que são

conjuntos ordenados de caracteres, com a diferença de que
os elementos de uma lista podem possuir QUALQUER TIPO.
Em um “str”, cada um de seus caracteres também é um “str”.
Na Figura 58, é usado o comando “type“ do Python para
verificar o tipo dos caracteres da variável “binário“ do tipo “str“.
Veja que todos os caracteres de “binário“ também são do tipo
“str“.
 Capítulo 6 - Lista
97

Figura 58 – Verificando o tipo dos caracteres da variável “binário” (do tipo

“str”) por meio do comando “type” do Python

Fonte: elaborada pela autora (2021).

Já sabemos, então, que ao contrário de um “str“, os

elementos de uma lista podem possuir QUALQUER TIPO.
A lista pode conter elementos de tipos diferentes, incluindo
até outras listas. Dessa forma, veremos agora como criar uma
lista no Python.

6.1 CRIANDO UMA LISTA

Para criar uma lista no Python, utilize os sinais [] ou a
palavra reservada list(). Veja a Figura 59.

Figura 59 – Verificando o tipo dos caracteres da variável “binário” (do tipo

“str”) por meio do comando “type” do Python

Fonte: elaborada pela autora (2021).

 Algoritmos e programação em Python para o Ensino Técnico Integrado
98

Verifique na Figura 58 a lista “b” criada. Quais os elementos

encontrados? Quem são os elementos b[0], b[1], b[2] e b[3]? De
que tipo cada um deles são? Quem são os elementos lista[0] e
lista[1]? De que tipo são eles?

6.2 O TAMANHO DA LISTA

Você pode observar o tamanho de uma lista no Python da

mesma maneira como se verifica o tamanho de um “str”: por
meio da função “len()” do Python. Veja na Figura 60.

Figura 60 – Verificando o tamanho da lista com o comando “len()”

Fonte: elaborada pela autora (2021).

Na Figura 60, o comando “len()” é usado para verificar o

tamanho da variável “binário” (do tipo “str“) e para verificar o
tamanho da variável “lista” (do tipo “list“).
Ainda sobre a Figura 60, responda:
- Quais os elementos binario[0], binário[1], binario[2] e
binario[3]? De que tipo são cada um desses elementos?
- Quais os elementos lista[0], lista[1], lista[2] e lista[3]? De que
tipo são cada um desses elementos?

6.3 ADICIONANDO ELEMENTOS À LISTA

Para adicionar elementos a uma lista, existe mais de uma

opção. Vamos citar essas opções usando uma lista chamada de
“c“ nos exemplos a seguir:
1º) No momento de criação da lista:
 Capítulo 6 - Lista
99

A lista “c” já é criada com três elementos. São eles: “maria”,

“joao” e “carlos”. Veja abaixo:
Ex.:

2º) APPEND: o comando “append()” adiciona elementos ao

fim da lista. Veja abaixo:
Ex.:

O resultado da lista “c” agora será:

3º) EXTEND: adiciona vários elementos, de uma só vez, ao

fim da lista. Veja abaixo:
Ex.:

O resultado da lista “c” da agora será:

4º) INSERT: com ele, você só insere um elemento por vez. E

é necessário indicar a posição do elemento na lista.
Ex.:

O resultado da lista “c” da agora será:

OBSERVAÇÃO IMPORTANTE: ao usar o comando “insert()”,

se você indicar um índice que NÃO EXISTE, o elemento será
adicionado ao fim da lista.

6.4 MODIFICANDO ELEMENTOS NA LISTA

Para modificar um elemento na lista, basta atribuir ao

índice o novo valor. Veja a Figura 61.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
100

Figura 61 – Modificando um elemento da lista

Fonte: elaborada pela autora (2021).

Observação importante: cuidado na hora de indicar o índice!

Qualquer referência a um índice NÃO EXISTENTE na lista
ocasionará um ERRO ao seu programa. Veja na Figura 62.

Figura 62 – Erro indica que o usuário tentou acessar um índice não

existente na lista

Fonte: elaborada pela autora (2021).

 Capítulo 6 - Lista
101

6.5 APAGANDO ELEMENTOS NA LISTA

• del
Apaga um elemento específico na lista.
Ex.:

• pop()
Apaga um elemento específico na lista e retorna o valor
removido.
Ex.:

Observe que ao tentar apagar um elemento associado

não existente na lista, um erro será emitido pelo Python. Veja
na Figura 63.

Figura 63 – Erro ao tentar apagar um elemento que não existe na lista

Fonte: elaborada pela autora (2021).

 Algoritmos e programação em Python para o Ensino Técnico Integrado
102

EXERCÍCIOS

1 . De acordo com o código abaixo:

Ao término da execução do código, quais valores serão impressos?

a) ( ) [0, 2, 4, 6]

b) ( ) [0, 1, 2, 3,4]

c) ( ) [0, 1, 4, 9]

d) ( ) [0, 2, 4, 6,8]

2 . De acordo com o código abaixo:

Ao término da execução do código, quais valores serão impressos?

a) ( ) [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

b) ( ) [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

c) ( ) [2, 3, 4, 5, 6, 7, 8, 9, 10]

d) ( ) [2, 3, 4, 5, 6, 7, 8, 9, 10]
 Capítulo 6 - Lista
103

3 . De acordo com o código abaixo:

Ao término da execução do código, quais valores serão impressos?

a) ( ) [0, 1, 2, 3]

b) ( ) [0, 1, 2, 3,4]

c) ( ) [0, 1, 2, 3,4,5]

d) ( ) NDA

4 . Sobre o código abaixo, marque as alternativas verdadeiras:

l=[]
for i in range(3):
l.append([i,i+1,i+2])
print(l)

a) ( ) Todos os elementos da lista “l” é do tipo “list”.

b) ( ) Ao término da execução do código, será impresso [[0, 1,

2], [1, 2, 3], [2, 3, 4]].

c) ( ) Alguns elementos da lista “l” são tipo “list” e alguns são

do tipo “int”.

d) ( ) Ao término da execução do código será impresso [[0, 1,

2], [3, 4, 5], [6, 7, 8]].
 Algoritmos e programação em Python para o Ensino Técnico Integrado
104

5 . De acordo com o código abaixo:

Ao término da execução do código, quais valores serão impressos?

a) ( ) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

b) ( ) [0, 1, 2, ‘ana maria’, 3, 4, 5, 6, 7, 8, 9]

c) ( ) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10]

d) ( ) [0, 1, ‘ana maria’, 2, 3, 4, 5, 6, 7, 8, 9,10]

6 . Sobre o código abaixo, marque as alternativas verdadeiras:

a) ( ) Ao término da execução do programa, será impresso

[0, 1, 2, 3, ‘ana maria’]

b) ( ) Ao término da execução do programa, será impresso

[0, 1, 2, 3]
 Capítulo 6 - Lista
105

c) ( ) Um erro acontecerá durante a execução do programa,

pois o índice 5 não existe na lista.

d) ( ) Um erro acontecerá durante a execução do programa,

pois o valor “ana maria” é do tipo “str”, e a lista “l” só armazena
valores do tipo “int”.

7 . Faça um programa que leia os nomes dos alunos da turma

e os inclua em uma lista. O programa deve ser executado até
que o usuário informe que não deseja mais continuar.

8 . O algoritmo abaixo armazena em “turma” os dados

[nome,nota] dos meninos e das meninas de uma turma. Se
o aluno for do sexo feminino, ele armazena [nome,nota]
no índice 0 da lista de “turma”; se for do sexo masculino,
armazena [nome,nota] no índice 1 da lista de “turma”:
 Algoritmos e programação em Python para o Ensino Técnico Integrado
106

a) Baseado no algoritmo acima, complete o algoritmo de

maneira que ele mostre os dados [nome,nota] somente dos
meninos da turma.

b) Baseado no algoritmo acima, complete o algoritmo de

maneira que ele mostre os dados [nome,nota] somente das
meninas aprovadas da turma (QUE OBTIVERAM NOTA
ACIMA OU IGUAL A 7).
 Capítulo 7 - Dicionários
107

DICIONÁRIOS
Outra estrutura de dados disponível em Python é
chamada de “dicionário”. Com um dicionário, você também
pode armazenar um conjunto de valores, tal como vimos
anteriormente, usando listas. No entanto, o dicionário tem uma
característica particular: ele relaciona a cada valor específico
uma chave de acesso.
Diferentemente das listas, em que o índice é um número
(o índice, em listas, é usado para acessar determinado valor),
dicionários utilizam suas chaves para acessar os valores. Assim,
podemos dizer que o dicionário é um tipo de mapeamento, ou
seja, ele mapeia valores (chaves) para outros valores arbitrários
(conteúdos). Mapeamentos são mutáveis. Em Python, existe, no
momento, apenas um tipo de mapeamento padrão, o dicionário.

7.1 CRIANDO UM DICIONÁRIO

Um exemplo no mundo real que pode ser adaptado para

a estrutura de dicionários seria o nome do aluno, usado como
valor, e sua matrícula, utilizada como chave de acesso. Veja na
Figura 64.

Figura 64 – Criando um dicionário em Python com o uso de chaves (“{}”)

Fonte: elaborada pela autora (2021).

 Algoritmos e programação em Python para o Ensino Técnico Integrado
108

Na Figura 64, o dicionário de nome “alunos” é definido por

meio do uso das chaves “{}”. O uso desses caracteres define um
dicionário vazio. Ainda na Figura 64, em seguida, adiciona-se
ao dicionário a aluna de nome “maria dos santos silva”, com
matrícula igual a 123. Observe que não é necessário o uso do
comando “append” para incluir elementos, como fazíamos com
o uso das listas. Para incluir um novo elemento ao dicionário,
basta definir a chave relacionada entre colchetes e associá-la
(por meio do caractere “=”) ao valor correspondente. Assim,
no exemplo acima, a chave é 123 (matrícula), e o valor é “maria
dos santos silva” (nome).
Outra forma de você definir um dicionário vazio é usando
a palavra reservada “dict”. No exemplo abaixo, obtemos o
mesmo resultado que na Figura 63.

No exemplo da Figura 65, são criados dois dicionários,

“a” e “b” (como uso de “{}” e “dict()”, respectivamente). Ao usar
o comando “type”, podemos constatar que ambas as variáveis,
“a” e “b”, são do mesmo tipo, “dict”:

Figura 65– Criando um dicionário em Python com o uso da palavra-

reservada “dict”

Fonte: elaborada pela autora (2021).

 Capítulo 7 - Dicionários
109

7.2 ADICIONANDO E MODIFICANDO ELEMENTOS EM

UM DICIONÁRIO

Vimos que para incluir novos elementos em um dicionário,

basta definir a chave entre colchetes e associá-la (por meio do
caractere “=”) ao valor correspondente. Se essa chave já existir,
o valor será modificado. Veja no exemplo abaixo:

>>> letra={}
>>> letra[‘a’]=’abrigo’
>>> letra[‘b’]=’bola’
>>> letra[‘c’]=’carro’
>>> letra
{‘a’: ‘abrigo’, ‘b’: ‘bola’, ‘c’: ‘carro’}
>>> letra[‘c’]=’casa’
>>> letra
{‘a’: ‘abrigo’, ‘b’: ‘bola’, ‘c’: ‘casa’}

Vimos o dicionário “letra” ser criado, e incluídos três

elementos ao dicionário ({‘a’: ‘abrigo’, ‘b’: ‘bola’, ‘c’: ‘carro’}).
Logo em seguida, realiza-se uma modificação no conteúdo
da chave ‘c’ (letra[‘c’]= ‘casa’). Para verificar um valor dentro
do dicionário, a pesquisa deve ser feita utilizando a chave
procurada. Exemplo:

>>> letra[‘a’]

‘abrigo’

Se a chave procurada não existir, o Python imprimirá uma

mensagem de erro. Ainda considerando o dicionário “letra”,
criado anteriormente, veja abaixo:
 Algoritmos e programação em Python para o Ensino Técnico Integrado
110

7.3 BUSCANDO AS CHAVES DE UM DICIONÁRIO

Para verificar somente quais são as chaves de um dicionário,

use o comando “keys”. Veja o exemplo na Figura 66.

Figura 66 – Verificando as chaves de um dicionário usando o comando

“keys”

Fonte: elaborada pela autora (2021).

Na Figura 66, o dicionário “d” é criado e, logo em seguida,

dois elementos são inseridos no dicionário. Na sequência, para
verificar todos os elementos do dicionário “d”, usamos somente
o nome do dicionário:

Ainda na Figura 66, para verificar somente as chaves do

dicionário “d”, usamos o comando “keys”:
 Capítulo 7 - Dicionários
111

7.4 BUSCANDO OS VALORES DE UM DICIONÁRIO

Para verificar somente quais são os valores de um dicionário,

use o comando “values”. Veja o exemplo na Figura 67.

Figura 67 – Verificando os valores de um dicionário usando o comando

“values”

Fonte: elaborada pela autora (2021).

Na Figura 67, o dicionário “d” é criado e, logo em seguida,

dois elementos são inseridos no dicionário. A seguir, para
verificar todos os elementos do dicionário “d”, usamos somente
o nome do dicionário:

Ainda, na Figura 67, para verificar somente os valores do

dicionário “d”, usamos o comando “values”:

>>> d.values()
dict_values([‘alfa‘, ‘beta‘])
 Algoritmos e programação em Python para o Ensino Técnico Integrado
112

7.5 VERIFICANDO SE UMA CHAVE PERTENCE AO

DICIONÁRIO

Para verificar se uma chave está presente em um dicionário,

usamos o comando “in”.
A sintaxe utilizada é:
<chave> in <dict>
O resultado dessa operação retorna verdadeiro (True) se
a chave estiver presente no dicionário, ou retorna falso (False)
se ela não estiver presente. Veja na Figura 68.

Figura 68 – Verificando os valores de um dicionário usando o comando

“values”

Fonte: elaborada pela autora (2021).

No exemplo da Figura 68, o dicionário “d” é criado e,

logo em seguida, dois elementos são inseridos nele. Após isso,
é verificada a existência das chaves no dicionário, usando o
comando “in”,
a. Verifica-se se a chave “a” existe em “d”. Como a chave
existe no dicionário, a expressão retorna verdadeiro
(True):

>>> ‘a‘ in d
True
 Capítulo 7 - Dicionários
113

b. Verifica-se se a chave “b” existe em “d”. Como a chave

existe no dicionário, a expressão retorna verdadeiro
(True):
>>> ‘b‘ in d
True

c. Verifica-se se a chave “c” existe em “d”. Como a

chave não existe no dicionário, a expressão retorna falso
(False):
>>> ‘c‘ in d
False

Uma boa estratégia é antes de tentar acessar determinada

chave no dicionário, utilizar o comando “in” para verificar
se ela realmente existe – isso evita que o Python envie uma
mensagem de erro e encerre a execução do programa, caso a
chave não exista. Veja na Figura 69.

Figura 69 – O programa tenta imprimir o valor contido na chave “c”

Fonte: elaborada pela autora (2021).

Na última linha do programa, na Figura 69, o programa

tenta imprimir o valor contido na chave “c” (print(d[‘c’])).
Como a chave “c” não existe no dicionário, o Python emite
uma mensagem de erro e sai da execução do programa. Veja
na Figura 70.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
114

Figura 70 – Mensagem de erro emitida pelo Python após o programa

tentar acessar uma chave que não existe

Fonte: elaborada pela autora (2021).

Para evitar o problema apresentado acima, podemos

modificar o programa e incluir o comando “in” para verificar
se a chave realmente existe, antes de tentar acessá-la. Veja na
Figura 71.

Figura 71 – O programa verifica se a chave existe no dicionário e, somente

se ela existir, imprime o valor associado a ela

Fonte: elaborada pela autora (2021).

Agora, na Figura 71, na penúltima linha, o programa

verifica se a chave “c” existe no dicionário “d”. Em caso positivo,
ele imprime o valor associado à chave. Se ela não existir, o
programa não executa mais nenhum comando. Em uma segunda
modificação, podemos emitir uma mensagem informando que
a chave não existe no dicionário. Veja na Figura 72.
 Capítulo 7 - Dicionários
115

Figura 72 – O programa verifica se a chave existe no dicionário, e se ela

não existe, ele imprime a mensagem “a chave não existe no dicionário”

Fonte: elaborada pela autora (2021).

Verifique, agora, na Figura 73, o resultado da execução

do programa.

Figura 73 – Resultado da execução do programa escrito na Figura 71

Fonte: elaborada pela autora (2021).

7.6 USANDO UM “FOR LOOP” PARA PERCORRER O

DICIONÁRIO

Um “for loop” em Python pode ser utilizado para realizar

uma iteração por meio de uma sequência (lista, dicionário
etc.). Nesta seção, usaremos o “for loop” para iterar os valores
contidos em um dicionário.
A sintaxe usada é:
for <i> in <dict>
em que <i> representa cada uma das chaves do dicionário
percorridas durante a iteração, e <dict> representa o dicionário.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
116

Na Figura 74, usamos o “for” para percorrer os elementos

do dicionário “d”. O valor de “i”, a cada volta do laço de repetição
“for”, armazena uma chave contida no dicionário.

Figura 74 – Resultado da execução do programa escrito na Figura 71

Fonte: elaborada pela autora (2021).

Na Figura 74, o resultado da execução do programa

será a impressão das chaves existentes no dicionário “d”. Na
primeira volta do “for loop”, o valor de i será igual a “a”. Assim,
ao executar o comando “print(i)”, será impresso o valor “a”.
Logo depois, o laço voltará a ser executado. Na segunda volta
do “for loop”, o valor de i será igual a “b”. Assim, ao executar o
comando “print(i)”, será impresso agora o valor “b”. Nessa fase,
todos os elementos do dicionário já foram percorridos. Logo,
o “for loop” é encerrado.
Veja o resultado da execução do programa na Figura 75.

Figura 75 – Resultado da execução do programa escrito na Figura 73

Fonte: elaborada pela autora (2021).

 Capítulo 7 - Dicionários
117

No programa anterior, o “for loop” foi usado para iterar o

dicionário “d”, e a cada volta do laço “for”, os valores da chaves
do dicionário foram impressos. Para imprimir agora os valores
associados a cada uma das chaves, podemos modificar o trecho
“for loop” do programa da seguinte maneira:

for i in d:
print(d[i])

Assim, os valores impressos ao executar o programa agora

seriam:

alfa
beta

7.7 APAGANDO ELEMENTOS DE UM DICIONÁRIO

Para apagar um elemento do dicionário, você pode usar

duas diferentes abordagens. São elas:
• del
Apaga um elemento específico no dicionário.
Ex.:

• pop()
Apaga um elemento específico no dicionário e retorna o
valor removido.
Ex.:
 Algoritmos e programação em Python para o Ensino Técnico Integrado
118

Observe que ao tentar apagar um elemento associado a

uma chave não existente no dicionário, um erro será emitido
pelo Python. Veja na Figura 76.

Figura 76 – Erro ao tentar apagar um elemento associado a uma chave

não presente no dicionário

Fonte: elaborada pela autora (2021).

EXERCÍCIOS

1 . De acordo com o código abaixo:

Ao término da execução do código, quais valores serão impressos?

a) ( ) {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10}

b) ( ) {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}

c) ( ) [0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10]

d) ( ) [0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9]
 Capítulo 7 - Dicionários
119

2 . Sobre a execução do código abaixo, é verdadeiro afirmar:

a) ( ) Um erro ocorrerá durante a execução do programa,

pois o dicionário “letras” não existe.

b) ( ) Um erro ocorrerá durante a execução do programa,

pois a chave “c” no dicionário “letras” não existe.

c) ( ) O programa executará corretamente, e nada será

impresso, pois a chave “c” não existe no dicionário “letras”.

d) ( ) O programa executará corretamente e será impresso

o valor associado à chave “c” no dicionário “letras”.

3 . De acordo com o código abaixo:

Ao término da execução do código, quais valores serão impressos?

a) ( )1
ana maria
2
joao batista
3
fabio

b) ( ) ana maria
joao batista
fabio
 Algoritmos e programação em Python para o Ensino Técnico Integrado
120

c) ( )1
2
3

d) ( ) ana maria
1
joao batista
2
fabio 3

4 . Sobre o código abaixo:

Considerando que o usuário digitou os seguintes valores de

entrada:
 Capítulo 7 - Dicionários
121

Ao término da execução do código, quais valores serão impressos?

a) ( ) [1: ‘azul’, 2: ‘amarelo’, 3: ‘vermelho’]

b) ( ) {1: ‘azul’, 2: ‘amarelo’, 3: ‘vermelho’}

c) ( ) [‘azul’, ‘amarelo’, ‘vermelho’]

d) ( ) {‘azul’, ‘amarelo’, ‘vermelho’}

5 . Sobre o código abaixo:

Considerando que o usuário digitou os seguintes valores de

entrada:
 Algoritmos e programação em Python para o Ensino Técnico Integrado
122

Ao término da execução do código, quais valores serão impressos?

a) ( )ABC

b) ( ) A ANA CLAUDIA B BETHANIA SANTOS C CARLOS

ALBERTO

c) ( ) ANA CLAUDIA BETHANIA SANTOS CARLOS ALBERTO

d) ( ) NDA

6 . Sobre o código abaixo:

Considerando que o usuário digitou os seguintes valores de

entrada:
 Capítulo 7 - Dicionários
123

Ao término da execução do código, quais valores serão

impressos?

a) ( ) {‘MARIA’, ‘CARLOS’, ‘JOAO’, ‘MARCOS’}

b) ( ) {‘MARIA’: ‘32322020’, ‘CARLOS’: ‘99875544’, ‘JOAO’:

‘94562323’, ‘MARCOS’: ‘49241212’}

c) ( ) [‘MARIA’, ‘CARLOS’, ‘JOAO’, ‘MARCOS’]

d) ( ) NDA

7 . Sobre o código abaixo:

Marque a(s) alternativa(s) verdadeira(s):

a) ( ) Um erro de execução ocorrerá se o programa tentar

acessar um valor não existente no dicionário “agenda” .
 Algoritmos e programação em Python para o Ensino Técnico Integrado
124

b) ( ) O programa executará normalmente se acessar um valor

existente no dicionário “agenda”.

c) ( ) Por meio da linha de comando “print(agenda[chave])”, o

programa tenta acessar o valor associado a uma chave específica
do dicionário e imprimir esse valor.

d) ( ) O programa executará normalmente se tentar acessar

um valor não existente no dicionário “agenda” .

8 . Ainda sobre o código de programa da questão 7, você

identificou algum erro no programa? Se SIM, reescreva o
programa de forma a corrigir esse erro.
 Capítulo 8 - Funções
125

FUNÇÕES
Uma função é um bloco de código contendo início e
fim, sendo que esse bloco de código só é executado quando é
chamado.
Existem, na verdade, duas possibilidades de objetos função:
funções embutidas e funções definidas pelo usuário. Uma
função embutida é aquela pré-definida pela linguagem.
A propósito, o Python apresenta várias funções embutidas,
algumas das quais já vimos no decorrer deste livro, tais como:
type(), len(), range() etc. Uma função embutida é executada
quando é chamada pelo seu nome. Assim, se a função já existe
na linguagem, basta ao programador fazer a chamada dessa
função para executá-la.
O interpretador do Python possui várias funções e
múltiplos tipos embutidos que sempre estão disponíveis. Na
Figura 77, estão todas as funções, em ordem alfabética.

Figura 77 – Listagem de funções embutidas no Python

Fonte: Disponível em: https://docs.python.org/pt-br/3/library/functions.

html. Acesso em: 20 out. 2021.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
126

8.1 CRIANDO UMA FUNÇÃO

Uma função definida pelo usuário é aquela criada pelo

próprio usuário. Nesse caso, ele deve, primeiro, criar a função
para depois executá-la. Uma função definida pelo usuário
também é executada quando é chamada pelo seu nome.
Veja o exemplo no código da Figura 78 abaixo, em que
todas as operações (soma, subtração, multiplicação e divisão)
estão sendo executadas no mesmo programa.

Figura 78 – Exemplo de código que efetua as operações de soma,

subtração, multiplicação e divisão

Fonte: elaborada pela autora (2021).

O exemplo da Figura 78 pode ser modificado de maneira

que cada uma das operações será definida em diferentes
módulos/blocos de programas (funções). Para criar uma função
no Python, usa-se a palavra-reservada “def”. Veja no exemplo
da Figura 79.
 Capítulo 8 - Funções
127

Figura 79 – Código definindo quatro funções (soma, subtração,

multiplicação e divisão), em que cada uma delas executa uma operação
matemática específica

Fonte: elaborada pela autora (2021).

As funções expostas na Figura 79 foram declaradas, mas

não foram chamadas. Vimos que para que as funções sejam
executadas, elas precisam ser chamadas. Para chamar uma
função, usamos o nome dela seguido por parênteses. Veja, na
Figura 80, a modificação do programa, agora chamando as
funções na seguinte ordem: soma(), subtração(), multiplicação()
e divisao() .
 Algoritmos e programação em Python para o Ensino Técnico Integrado
128

Figura 80 – Código realizando a chamada das funções (soma, subtração,

multiplicação e divisão)

Fonte: elaborada pela autora (2021).

Observe que na Figura 80, a indentação utilizada nas quatro

últimas linhas onde as funções são chamadas faz um recuo no
texto até o início da margem do editor. Indicamos, com essa
indentação, que as chamadas das funções não dependem de
nenhum outro comando anterior para serem executadas, e estão
no que comumente chamamos de programa principal (main),
que é a parte do programa que será executada quando você
o chamar. Podemos dizer, então, que na Figura 80, quando o
programa for chamado, ele começará a executar a partir do
programa principal.
No exemplo da Figura 80, somente as funções chamadas
no programa principal serão executadas, na sequência em que
forem chamadas. Assim, ele executa as funções na seguinte
ordem: soma(), subtração(), multiplicação() e por fim, divisão().

8.2 MÓDULOS

É uma boa prática de programação, quando o programa se

torna grande e/ou se propõe a resolver mais de um problema
(por exemplo, uma calculadora deve resolver problemas como
 Capítulo 8 - Funções
129

adição, subtração, multiplicação, divisão, entre outros), dividi-lo

em arquivos menores (de modo que cada um realize uma tarefa
específica) para torná-lo mais legível e facilitar a manutenção.
Da mesma forma, é preferível usar um arquivo separado
para funções que você escreveria em vários programas diferentes
para não copiar a definição de função em cada um deles.
Para permitir isso, o Python tem uma maneira de colocar as
definições em um arquivo e, então, usá-las em um script1 ou
em uma execução interativa do interpretador. Tal arquivo
é chamado de módulo. Um módulo é um arquivo contendo
definições e comandos (instruções) Python. O nome do arquivo
é o nome do módulo acrescido do sufixo .py.
Definições de um módulo podem ser importadas para
outros módulos ou para o módulo principal (a coleção de
variáveis acessadas em um script executado como um programa
ou acessadas diretamente no interpretador IDE do Python),
ou seja, o módulo principal (vamos chamá-lo neste capítulo
também de programa principal) é o responsável por executar
um conjunto de comandos (instruções) e/ou um conjunto
de funções (que podem ter sido definidas nele ou em outros
módulos), como mostra o exemplo da Figura 81.

Figura 81 – Módulo “saudacao.py”

Fonte: elaborada pela autora (2021).

1 Os scripts provêm de sequências de códigos de uma linguagem de

programação. O instalador Python associa automaticamente os arquivos .py
com o python.exe, de forma que um clique duplo em um arquivo Python o
executará como um script.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
130

Existem duas maneiras de importar um módulo: “import”

e “from..import”. O “import” importa todas as funções do módulo,
enquanto o “from...import” pode importar todas as funções ou
somente aquelas desejadas pelo programador.
O exemplo da Figura 82 mostra o módulo sendo importado
com o comando “import”. Observe a importação do módulo
“saudacao.py” (“import saudacao”) e, logo em seguida, a chamada,
no interpretador IDLE, da função “alo”, presente no módulo.

Figura 82 – Importando o módulo “saudacao.py” no interpretador IDLE

Fonte: elaborada pela autora (2021).

Na Figura 82, observe que para chamar a função “alo“,

antes foi necessário indicar o nome do módulo ao qual ela
pertencia, seguido do caractere ponto (.):

saudacao.alo()

Quando usamos o “import“, devemos fazer a chamada das

funções sempre com o nome do módulo seguido do nome da
função. Assim, a sintaxe para a importação do módulo e da
chamada da função, respectivamente, é:

import <nome do módulo>

<nome do módulo>.<nome da função>
 Capítulo 8 - Funções
131

Caso você queira saber quais funções estão presentes em

um módulo, pode usar o comando “dir“. A Figura 83 apresenta
a utilização da função “dir()“ e mostra como resultado uma lista
de “str“ com o nome de todas as funções definidas dentro do
módulo “saudacao”.

Figura 83 – Importando o módulo “saudacao.py” no interpretador IDLE

Fonte: elaborada pela autora (2021).

Observe, na Figura 83, que além da função “alo“, definida

no módulo, o resultado do comando “dir” apresenta outros
componentes do módulo. Todos estão precedidos dos caracteres
“__” e sucedidos dos caracteres “___”. O Python geralmente
usa esses caracteres para definir variáveis ou funções especiais.
Falaremos agora de um desses componentes apresentados
na lista: a variável __name__. A variável __name__ (variável
do tipo “str”) é responsável por guardar o nome do módulo.
Veja na Figura 84.

Figura 84 – Verificando o valor da variável __name__ do módulo

“saudacao”

Fonte: elaborada pela autora (2021).

 Algoritmos e programação em Python para o Ensino Técnico Integrado
132

Vamos agora importar o módulo “saudacao”, usando o

comando “from..import“. Veja na Figura 85.

Figura 85 – Importando o módulo “saudacao” usando “from.. import..”

Fonte: elaborada pela autora (2021).

Na Figura 85, o módulo “saudacao” é importado da seguinte

maneira:

from saudacao import *

O uso do caractere asterisco (*) está informando que você

deseja importar todas as funções do módulo.
Suponha que você só desejasse importar a função “alo“ do
módulo. Você poderia definir o comando da seguinte maneira:

from saudacao import alo

Ainda no exemplo da Figura 85, observe que para chamar

a função “alo”, agora, é possível chamar somente o nome da
função, sem que seja necessário esse nome ser precedido do
nome do módulo:

alo()

A sintaxe para importar todas as funções do módulo e da

chamada da função, respectivamente, é:

from <nome do módulo> import *

<nome da função>()
 Capítulo 8 - Funções
133

A sintaxe para importar funções específicas do módulo e

da chamada da função, respectivamente, é:

from <nome do módulo> import <nome da função>

<nome da função>()

Ainda, se você quiser importar mais de uma função:

from <nome do módulo> import <nome da função 1>,<nome

da função 2>... <nome da função n>

8.3 A VARIÁVEL __NAME__

Ainda sobre o programa principal (main()), no Python,

vimos que cada arquivo com extensão .py é chamado de módulo.
Cada módulo pode ser executado diretamente, como um
programa em si, ou o módulo pode ser importado por outro
módulo (nesse caso, o programa é chamado por outro módulo).
No caso de um programa contendo mais de um módulo,
é necessário identificar o módulo principal (programa que é
executado) e quais módulos são importados por outros módulos.
No exemplo anterior, da Figura 84, vimos o módulo “saudacao”
ser importado, e logo em seguida, vimos que o valor da variável
__name__ era o nome do próprio módulo (“saudacao”). Assim,
quando o módulo é importado, o valor da variável __name__ é
igual ao nome do módulo. Por outro lado, quando o programa
é executado por si só, __name__ é definida com o valor igual a
“__main__”. A Figura 86 ilustra esta situação. Com o objetivo
de verificar o valor da variável __name__, incluímos a linha
“print(__name__)”.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
134

Figura 86 – Módulo “calculadora”

Fonte: elaborada pela autora (2021).

Veja o resultado da execução do programa na Figura 87.

Figura 87 – Resultado da impressão do valor da variável __name__

Fonte: elaborada pela autora (2021).

Na Figura 87, notamos que o resultado da impressão da

variável __name__ foi o valor “__main__”, indicando que o
módulo é executado por si só como um programa. É possível,
assim, identificar se um módulo deve ser executado ou não. Se
 Capítulo 8 - Funções
135

o módulo estiver sendo importado, ele não deve ser executado

diretamente, e suas funções só devem ser executadas se forem
chamadas pelo programa que importou o módulo.
Veja a modificação no módulo “calculadora” realizada na
Figura 88.

Figura 88 – Módulo é executado somente se o valor da variável __

name__for igual a “__main__”

Fonte: elaborada pela autora (2021).

O código mostrado na Figura 88, antes de executar o

programa principal, verifica se o valor da variável __name__
é igual a “main”. Se a afirmação for verdadeira, o código
chama as funções soma(), subtração(), multiplicacao() e divisao(),
respectivamente nessa ordem. Caso contrário, nenhuma das
funções será chamada. Essa é uma estratégia possível de ser
utilizada quando o seu programa tem mais de um módulo de
programa. Dessa forma, você pode identificar qual é o módulo
principal.
Inicialmente, podemos imaginar que todas as vezes que
tivermos mais de um módulo no programa, podemos utilizar
essa estratégia para verificar qual programa principal deve ser
realmente executado. Porém, o recomendado para programas
que contenham mais de um módulo é que exista um nível
maior de organização, de maneira que em alguns módulos
 Algoritmos e programação em Python para o Ensino Técnico Integrado
136

compreendam somente as definições de funções, e em seguida,

esses módulos de funções sejam importados para aqueles que
as executarão.
Veja nas Figuras 89 e 90.

Figura 89 – Módulo “calculadora.py” contendo somente as definições de

funções

Fonte: elaborada pela autora (2021).

Figura 90 – Uso de “import” para importar as funções definidas em

“calculadora.py”

Fonte: elaborada pela autora (2021).

 Capítulo 8 - Funções
137

Na Figura 90, o módulo “calculadora.py” é importado

por intermédio do comando:

import calculadora

Escrito no início do módulo “principal.py”. Assim, é

possível ao módulo “principal.py” fazer a chamada de todas
as funções do módulo “calculadora.py”. Verifique que antes do
nome das funções, adiciona-se o nome do módulo “calculadora”,
seguido do caractere “.” – isso indica em que módulo estão
definidas as funções chamadas. Outra maneira de importar o
módulo “calculadora.py” é apresentada na Figura 91.

Figura 91 – Uso de “from..import” para importar as funções definidas em

“calculadora.py”

Fonte: elaborada pela autora (2021).

Na Figura 91, o módulo “calculadora.py” é importado por

meio do comando:

from calculadora import *

Escrito no início do módulo “principal.py”. O caractere “*”

indica que estamos importando todas as funções do módulo.
Supondo que só fosse necessário importar a função “soma”,
você poderia definir o comando da seguinte maneira:

from calculadora import soma

 Algoritmos e programação em Python para o Ensino Técnico Integrado
138

8.4 PASSAGEM DE PARÂMETROS

Os exemplos de funções apresentados até agora não

possuem passagem de parâmetros. A passagem de parâmetro
significa que variáveis devem ser incluídas entre os parênteses
utilizados na chamada da função. Ver sintaxe:

<nome_da_função>()

Na sintaxe acima, a função possui o parâmetro “x”. Se

a função possuir mais de um parâmetro, eles devem ser
separados pelo caractere vírgula (,). Agora, veja a função com
dois parâmetros, “x” e “y”:

<nome_da_função>(x,y)

Os parâmetros são uma maneira de a função receber

valores e/ou variáveis de entrada que serão utilizadas no
processamento do bloco de função. Por exemplo, a soma de
dois números necessita, obrigatoriamente, de dois valores
de entrada, que serão somados. Esses dois valores podem ser
passados diretamente, por meio de parâmetros. Veja na Figura
92.

Figura 92 – Função “soma” definida com dois parâmetros

Fonte: elaborada pela autora (2021).

 Capítulo 8 - Funções
139

Na Figura 92, a função “soma” recebe dois parâmetros,

“a” e “b”, os quais são usados como valores de entrada para a
realização da operação de soma. Na chamada da função, na
linha:

soma(2,3)

Os valores inteiros 2 e 3 são passados como valores para os

parâmetros “a” e “b”. Os valores passados para os parâmetros no
momento da chamada da função são chamados de argumentos.
No exemplo, o parâmetro “a“ recebe o valor 2, enquanto o
parâmetro “b“, o valor 3.
Veja na Figura 92 que estamos passando valores fixos (2,3)
como parâmetros para a função. É possível, também, passar
valores de variáveis para os parâmetros. Veja na Figura 93.

Figura 93 – Função “soma” recebendo as variáveis “x” e “y” como

argumentos

Fonte: elaborada pela autora (2021).

8.5 O COMANDO “RETURN”

O comando “return” no Python é uma instrução especial

que pode ser usada dentro de uma função para enviar o resultado
da função de volta ao programa chamador. A maneira de utilizar
o “return” é colocar o nome do comando seguido do valor que
se deseja retornar. Veja a sintaxe:

return <valor>
 Algoritmos e programação em Python para o Ensino Técnico Integrado
140

O valor de retorno de uma função Python pode ser de

qualquer tipo. Podem ser retornados, por exemplo, números
(int, float etc.), valores booleanos (True ou False), sequências
(list, dict etc.). Veja o exemplo na Figura 94.

Figura 94 – Função “soma” retornando o resultado da operação

Fonte: elaborada pela autora (2021).

Na Figura 94, a função “soma” retorna o valor da soma dos

argumentos recebidos 3 e 2. O retorno do valor é impresso
pelo comando “print”. Logo, no exemplo, o valor impresso na
tela será 5.
É importante verificar que o comando “return” provoca
a saída imediata do bloco de função. Então, a sua localização
dentro do bloco da função deve ser cuidadosamente escolhida.
Normalmente, por esse motivo, o “return” é colocado como
última instrução da função, ou dentro de blocos “if.. elif” que
proponham mais de uma opção de execução de instruções
dentro do bloco de função.
Veja o exemplo na Figura 95.

Figura 95 – Função “compara” verificando se os valores “x” e “y” são iguais

Fonte: elaborada pela autora (2021).

 Capítulo 8 - Funções
141

Na Figura 95, se os valores forem iguais, a função retorna

“True”. Caso contrário, a função retorna “False”. Observe que o
valor retornado da função é recebido pela variável “resultado”
e, logo em seguida, o valor dessa variável é impressa pelo
comando “print“.
Na Figura 96, veja o resultado da execução do programa.

Figura 96 – Resultado da execução da função “compara” passando os

valores 3 e 3

Fonte: elaborada pela autora (2021).

EXERCÍCIOS

1 . Sobre o código abaixo:

def c(x,y):
if x==y:
return True
else:
return False

resultado=c(4,3)
print(resultado)
 Algoritmos e programação em Python para o Ensino Técnico Integrado
142

Marque a (s) alternativa (s) correta (s):

a. ( ) Ao término de sua execução, a função “c” retorna “True”

se os valores “x” e “y” forem iguais e “False” se os valores “x” e
“y” forem diferentes.

b. ( ) O valor impresso ao término da execução do programa

será “4” e “3”.

c. ( ) O valor impresso ao término da execução do programa

será “False”.

d. ( ) O valor impresso ao término da execução do programa

será “True”.

2 . Sobre o código abaixo, responda:

def w(x):
if x%2==0:
return True
else:
return False

print(w(4))
print(w(3))
print(w(2))
w(1)

Os valores impressos ao término da execução do programa são:

a. ( ) False False True

b. ( ) True False True

c. ( ) True False True False

d. ( ) True False True True

 Capítulo 8 - Funções
143

3 . O objetivo do código a seguir é realizar o somatório dos

cinco primeiros números pares e, em seguida, imprimir
esse valor. Verifique se o código está correto e marque a(s)
alternativa(s) verdadeira(s):

def s():
soma=0
for i in range(0,10,2):
soma += i
print(s())

a. ( ) A função “s” realiza a soma dos cinco primeiros números

pares, mas no programa principal, a saída impressa será igual
a “None”, indicando que a função não retorna valor algum que
possa ser impresso.

b. ( ) A função “s” realiza a soma dos cinco primeiros números

pares, e no programa principal, a saída impressa será igual a
20, indicando que a função retorna um valor do tipo inteiro,
obtido na operação de adição realizada.

c. ( ) A função “s” não possui passagem de parâmetros.

d. ( ) A função “s” não retorna nenhum valor ao término de

sua execução.

4 . Verifique agora a modificação realizada no programa da

questão anterior e responda:

def s():
soma=0
for i in range(0,10,2):
soma += i
print(s())
 Algoritmos e programação em Python para o Ensino Técnico Integrado
144

a. ( ) A função “s” realiza a soma dos cinco primeiros números

pares, e no programa principal, a saída impressa será igual a 20.

b. ( ) A função “s” realiza a soma dos cinco primeiros números

pares, mas no programa principal, a saída impressa será igual
a “None”, indicando que a função não retorna valor algum que
possa ser impresso.

c. ( ) A função “s” não possui passagem de parâmetros e não

retorna nenhum valor ao término de sua execução.

d. ( ) A função “s” não possui passagem de parâmetros e retorna

um valor do tipo inteiro ao término de sua execução.

5 . Faça um programa que leia dois números quaisquer,

chame uma função que os compare lidos e retorne se eles são
iguais ou diferentes. Se forem iguais, a função deve retornar
verdadeiro (True); se forem diferentes, a função deve retornar
falso (False). Ao final, o programa deve mostrar a mensagem
“Os números são iguais” se os números forem iguais; senão,
deve mostrar a mensagem “Os números são diferentes”.

6 . Faça um programa que leia dois números quaisquer, chame

uma função que os compare e mostre o maior número, o
menor ou se os números são iguais.

7 . Faça um programa que leia um número inteiro N, chame

uma função que mostre se ele é ímpar ou par. Se for par,
mostre a mensagem “O número N é par!”; se não, mostre a
mensagem “O número N é ímpar!”. Considere N o valor do
número lido.

8 . Faça um programa para ler um número N qualquer e

chamar uma função que mostra se ele é positivo, negativo ou
zero. Se N for positivo, mostre a mensagem “O número N é
 Capítulo 8 - Funções
145

positivo!”; se for negativo, mostre a mensagem “O número

N é negativo!”; se N for igual a zero, mostre a mensagem “O
número é igual a zero!”. Considere N o valor do número lido.
9 . Faça um programa que leia um número inteiro N e chame
uma função que retorne o resultado da sequência:
1/2+1/4+....+1/2N

10 . Faça um programa que leia um número inteiro N e

chame uma função que retorne a sequência de Fibonacci
até o enésimo termo. A série de Fibonacci é formada pela
sequência: 1,1,3,5,8,13,21,34,..etc. Por exemplo, o quarto termo
da sequência é 5, o sétimo termo é 21, e assim por diante.
Observe que as sequência de Fibonacci é uma sucessão de
números que obedece a um padrão em que cada elemento
subsequente é o resultado da soma dos dois elementos
anteriores.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
146
 Referências
147

REFERÊNCIAS

ALVES, Fábio Junior. Introdução à Linguagem de

Programação Python. Rio de Janeiro: Ed. Ciência Moderna
Ltda., 2013.

ORESTES, Yan. Python: O que significa if __name__ ==

‘__main__’? Alura. 2018. Disponível em: https://www.alura.
com.br/artigos/o-que-significa-if-name-main-no-python.
Acesso em: 10 out. 2021.

PYTHON. Download Python. Disponível em: https://www.

python.org/downloads/. Acesso em: 10 dez. 2021.

PYTHON Foundation. Tutorial Python 3.10.2. Disponível

em: https://docs.python.org/. Acesso em: 10 dez. 2021

W3SCHOOLS. Tutorial Python. Disponível em: https://www.

w3schools.com/python. Acesso em: 24 jan. 2022.
 Algoritmos e programação em Python para o Ensino Técnico Integrado
148

SOBRE A AUTORA

Elanne Cristina Oliveira dos Santos

Possui graduação em Bacharelado em Ciências da

Computação pela Universidade Federal do Piauí (1998),
Doutorado em Ciências da Computação pela UFF (Universidade
Federal Fluminense), Mestrado em Ciências da Computação pela
Universidade Federal de Pernambuco, mestrado em Políticas
Públicas para a Educação (UNB) ,especialização em Educação
a Distância pela SENAC-MA. Professora no IFPI (Instituto
Federal de Educação, Ciência e Tecnologia do Piauí), atua nos
cursos Superior de ADS (Administração e Desenvolvimento de
Sistemas) e Ensino Médio Integrado de Informática. Membro
do Programa de Pós-Graduação ProfEPT/IFPI (Mestrado
Profissional em Educação Profissional e Tecnológica). Seus
interesses incluem: aprendizagem de programação, educação
profissional, tecnologias para educação e jogos digitais em
contextos educacionais.
 Esta obra surgiu da necessidade de preparar
um guia de referência e/ou um livro didático
sobre algoritmos de programação para alunos do
ensino técnico médio integrado de informática
do Instituto Federal do Piauí (IFPI). A disciplina
Algoritmos de programação é ministrada no 1º
ano do ensino médio, e propõe apresentar aos
alunos o conceito de algoritmos e programação, e
como desenvolvê-los na resolução de problemas.
Neste livro, para o desenvolvimento de
algoritmos, trabalharemos com a linguagem
Python, versão 3.x (versão 3 ou superior).
O objetivo aqui não é constituir um guia
aprofundado, mas um material didático que
possa ser utilizado como roteiro de estudo e em
sala de aula, com atividades comuns a serem
executadas por professores e alunos.