24.1 Conteudo Teorico Livro Texto

P ROGRAMAÇÃO DE C OMPUTADORES I – BCC701
C ONTEÚDO T EÓRICO EM L INGUAGEM P YTHON
2024/1 ( VERSÃO 1.2)
E LABORADO PELA C OMISSÃO DE U NIFICAÇÃO DA D ISCIPLINA BCC701,

COM A COLABORAÇÃO DE PROFESSORES E ESTAGIÁRIOS DOCENTES
http://www.decom.ufop.br/bcc701/
DECOM – D EPARTAMENTO DE C OMPUTAÇÃO

ICEB – I NSTITUTO DE C IÊNCIAS E XATAS E B IOLÓGICAS
UFOP – U NIVERSIDADE F EDERAL DE O URO P RETO
Sumário
1 Introdução 4
1.1 Programas de Computadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Linguagem de programação Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Programação Estruturada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4.1 Exemplo 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4.2 Exemplo 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4.3 Exemplo 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.5 Dicas para um bom aproveitamento na disciplina . . . . . . . . . . . . . . . . . . . . . 9
1.6 Organização deste documento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2 Variáveis e Expressões 12
2.1 Para que serve uma variável? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2 Atribuição de Valores para uma Variável . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Regras para o nome de uma variável . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4 Exemplos de utilização de variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.5 Tipos de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.5.1 Numéricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.5.2 String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.6 Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.6.1 Precedência e associatividade de operadores . . . . . . . . . . . . . . . . . . . . 21
2.7 Funções elementares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.7.1 Resumo das funções elementares . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.8 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.9 Outra forma de importação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.10 Exercícios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3 Entrada e Saída 30
3.1 Saída: função print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.1.1 Strings de formatação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.1.2 Especificando a formatação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.1.3 Inserção de caracteres especiais em uma string . . . . . . . . . . . . . . . . . . 34
3.2 Entrada: função input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2.1 Conversão de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.2.2 Conversão para inteiro: função int . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.2.3 Conversão para real: função float . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.2.4 Conversão para string: função str . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.2.5 Cuidados especiais com conversão de tipos . . . . . . . . . . . . . . . . . . . . . 37
3.2.6 Conversão de dados fornecidos pelo usuário . . . . . . . . . . . . . . . . . . . . 37
3.3 Entrada e Saída: Exemplos Práticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1
4 Estrutura de Decisão 46
4.1 O comando if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.2 Operadores Relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.3 A cláusula else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.4 Operadores Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.5 Estruturas de decisão aninhadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5 Estrutura de Repetição 63
5.1 Repetição controlada logicamente: comando while . . . . . . . . . . . . . . . . . . . . 63
5.2 Repetição controlada por contador: comando for . . . . . . . . . . . . . . . . . . . . . 69
5.2.1 A função range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.3 Estruturas de repetição aninhadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
6 Implementação de Funções 86
6.1 Definição de Função . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.2 Chamada de Função . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
6.3 Escopo de variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.4 Função sem argumento de entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
6.5 Função sem retorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6.6 Retornando vários valores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
7 Estruturas Homogêneas 96
7.1 Vetores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.1.1 Criando um vetor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.1.2 Acessando ou modificando elementos de um vetor . . . . . . . . . . . . . . . . 98
7.1.3 Inserindo elementos em um vetor . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.1.4 Removendo elementos de um vetor . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.1.5 Descobrindo a dimensão de um vetor . . . . . . . . . . . . . . . . . . . . . . . . 99
7.1.6 Percorrendo os elementos de um vetor . . . . . . . . . . . . . . . . . . . . . . . 99
7.1.7 Exercícios propostos – Vetores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
7.2 Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.2.1 Criando uma matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.2.2 Acessando e modificando elementos em uma matriz . . . . . . . . . . . . . . . 105
7.2.3 Descobrir as dimensões da matriz . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.2.4 Exercícios propostos – Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.3 Construindo uma biblioteca de funções úteis . . . . . . . . . . . . . . . . . . . . . . . . 109
7.3.1 Criando um vetor com valor padrão . . . . . . . . . . . . . . . . . . . . . . . . 109
7.3.2 Criando uma matriz com valor padrão . . . . . . . . . . . . . . . . . . . . . . . 109
7.3.3 Criando um vetor com valores de uma string . . . . . . . . . . . . . . . . . . . 110
7.3.4 Criando uma matriz com valores de uma string . . . . . . . . . . . . . . . . . . 111
2
7.3.5 Dimensões de uma matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
7.3.6 Criando e usando a biblioteca . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
7.4 Exercícios propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8 Estruturas Heterogêneas 116

8.1 Sintaxe básica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
8.2 Vetores e matrizes de registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.3 Registros como argumento ou retorno de função . . . . . . . . . . . . . . . . . . . . . 120
8.4 Exercícios propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
9 Soluções dos Exercícios Propostos 128

9.1 Exercícios do Capítulo 2: Variáveis e Expressões . . . . . . . . . . . . . . . . . . . . . . 128
9.2 Exercícios do Capítulo 3: Entrada e Saída . . . . . . . . . . . . . . . . . . . . . . . . . 133
9.3 Exercícios do Capítulo 4: Estrutura de Decisão . . . . . . . . . . . . . . . . . . . . . . . 137
9.4 Exercícios do Capítulo 5: Estrutura de Repetição . . . . . . . . . . . . . . . . . . . . . 144
9.5 Exercícios do Capítulo 6: Função . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
9.6 Exercícios do Capítulo 7: Estruturas Homogêneas . . . . . . . . . . . . . . . . . . . . . 158
9.7 Exercícios do Capítulo 8: Estruturas Heterogêneas . . . . . . . . . . . . . . . . . . . . 169
3
1 Introdução
CAPÍTULO
Este material foi elaborado pela Comissão de Unificação da disciplina de Programação de Com-
putadores I (BCC701) com a colaboração de professores e estagiários docentes do DECOM durante
o semestre letivo 2019/02 e revisado nos semestres posteriores. Nele, apresentamos os conceitos e
recursos mínimos a serem abordados no conteúdo programático da disciplina. Professores podem
abordar os assuntos à sua maneira, expandindo determinado conteúdo quando considerar necessário,
assim como alterando a ordem de apresentação dos mesmos.
Neste capítulo introduzimos alguns conceitos importantes sobre programação de computadores,

linguagem de programação, programação estruturada e algoritmos. Além disso, fornecemos dicas
valiosas para um bom aproveitamento na disciplina.
1.1 Programas de Computadores

Um programa de computador é uma sequência de instruções que um computador deve executar
para realizar uma tarefa. Diversas tarefas do nosso dia-a-dia também são assim, sendo definidas
como uma sequência de “passos” a serem executados: receitas culinárias; instruções de um manual;
execução de uma peça de música; etc.
De maneira similar a um músico que executa uma peça a partir de uma partitura, um computador
precisa de um conjunto de instruções para executar alguma tarefa. Essas instruções estão contidas
em um arquivo de texto denominado código-fonte, que deve ser escrito conforme as regras de uma
linguagem de programação.
Existem diversas linguagens de programação, listamos alguns exemplos: C; Java; Javascript; e

Python. Utilizaremos a linguagem Python devido à sua simplicidade, flexibilidade e popularidade.
4
1.2 Linguagem de programação Python
A linguagem Python é uma das linguagens mais populares e utilizadas do mundo atualmente.
Além disso, ela é simples de entender e mais ainda de usar. Abaixo, ensinaremos um jeito fácil de
começar a usar a linguagem.
Python é uma linguagem muito ampla e flexível, utilizaremos neste curso um conjunto limitado de
seus recursos, com o intuito de aplicar e fixar o conhecimento de estruturas e conceitos de programa-
ção de computadores ao nível introdutório, compreendendo o conteúdo programático da disciplina.
Escrever um código em Python é semelhante a escrever qualquer sequência de instruções. Con-

tudo, um computador não consegue executar qualquer tipo de instrução. A linguagem de programação
define as regras para a construção das instruções, muitas delas serão ensinadas ao longo desta disci-
plina. A seguir vemos um exemplo de programa em Python, feito para elevar um número definido
pelo usuário ao quadrado:
1 # Entrada
2 x = float(input('Digite um número para elevar ao quadrado: '))
3 # Processamento
4 y = x * x
5 # Saída
6 print(f'O resultado do processamento é {y}')
No código acima, as linhas indicadas por # são comentários. Isso indica ao computador que tudo
que estiver escrito nessas linhas, a partir de #, não deve ser interpretado como instruções a serem
executadas. As demais linhas são maneiras de passar instruções ao computador usando a linguagem
Python. Agora, a intenção é apenas mostrar um exemplo de programa em Python, durante o decorrer
da disciplina, aprenderemos cada uma das instruções deste exemplo, e muito mais.
É importante praticar e aprimorar os seus conhecimentos na ferramenta de programação esco-

lhida. Utilizaremos o Thonny, uma plataforma simples de aprendizado, disponível para Windows,
Linux e MacOS, e super simples de instalar. Basta baixar no link https://thonny.org/ e executar.
No Linux, é só seguir a instrução para instalação via linha de comando do terminal.
1.3 Programação Estruturada

Conhecendo o conceito de programas de computador e linguagem de programação, agora é im-
portante saber também o que significa Programação Estruturada. Conforme dito, um programa de
computador executa uma sequência de instruções para realizar uma tarefa. Na programação estrutu-
rada, as instruções podem ser classificadas em três tipos de estrutura:
1. Sequência: essa estrutura é composta por uma sequência ordenada de instruções executadas
uma após a outra, como exemplificado na Figura 1.
2. Decisão: estruturas de decisão são utilizadas para realizar um controle e efetuar ações de
acordo com uma determinada condição, como exemplificado na Figura 2.
3. Iteração: estruturas de repetição (ou laço) são utilizadas para realizar uma tarefa repetitiva,
até que uma determinada condição seja satisfeita, como exemplificado na Figura 3.
Apenas estes três tipos de estruturas são suficientes para resolver todos os problemas da disciplina.
5
As Figuras 1, 2 e 3 apresentam estas três estruturas em fluxogramas. Os fluxogramas são uma
forma de representar um programa em mais “alto nível” para entendermos melhor o raciocínio para
solução do problema. Eles representam cada um dos passos realizados por um algoritmo por meio de
“caixas” e o caminho tomado pelo algoritmo é representado por setas interligando as caixas. Existem
indicações de onde o algoritmo começa (caixa “Início”) e onde ele termina (caixa “Fim”). Esse tipo de
representação permite criar visualizações amigáveis e fáceis de entender.
Início
Instrução 1
Instrução 2
...
Instrução n
Fim
Figura 1: Estrutura do tipo sequência.
Verdadeira Falsa
Condição
Instrução 1
Instrução 2
...
Instrução n
Figura 2: Estrutura do tipo Decisão.
Verdadeira Falsa
Condição
Instrução 1
Instrução 2
...
Instrução n
Figura 3: Estrutura do tipo Iteração.
6
1.4 Algoritmos
Para criar um programa de computador, precisamos de uma sequência de instruções claras e sem
ambiguidade. O conjunto dessas instruções e como elas são definidas é o que chamamos de Algoritmo.
Utilizamos algoritmos para resolver os mais diversos problemas do dia-a-dia, da nossa vida acadêmica
ou profissional.
Para representar um algoritmo, uma ferramenta interessante são os fluxogramas, como vistos
anteriormente. Outra forma de representação de algoritmos é por meio de um texto que descreva
passo a passo, de forma enumerada, as instruções. Obviamente, um programa de computador escrito
em uma linguagem de programação também é uma representação de um algoritmo. Vejamos alguns
exemplos a seguir.
1.4.1 Exemplo 1
Suponha que na aula de física você aprendeu a converter uma temperatura de Celsius para Fahre-
nheit. A fórmula usada é:
9
F = (C. ) + 32
5
Em uma sequência sistemática de passos (um algoritmo), o raciocínio pode ser o seguinte:
1. Ler um valor de temperatura em Celsius;
2. Multiplicar o valor por 9 e dividir por 5;
3. Somar 32 ao valor encontrado no passo anterior;
4. Imprimir o valor resultante.
Vejamos agora esse algoritmo em um fluxograma, para visualizá-lo graficamente. Observe na Fi-
gura 4, que o fluxograma apenas organiza os passos antes representados por uma lista textual, adici-
onando alguns detalhamentos, como, por exemplo, a atribuição de nomes para alguns valores mani-
pulados (C para a temperatura em Celsius lida e F para a temperatura convertida para Fahrenheit) e
a representação algébrica dos cálculos.
Início
Ler o valor de C
F=C*9/5
F = F + 32
Imprimir F
Fim
Figura 4: Fluxograma para o Exemplo 1.
7
1.4.2 Exemplo 2
A velocidade média é definida através da razão entre a distância percorrida (S) e o tempo decorrido
para percorrê-la (T ):
S
v=
T
Considere agora o problema de determinar a velocidade média a partir da leitura dos valores de S
e T . Porém, caso pelo menos um destes valores seja menor ou igual a zero, uma mensagem de erro
deve ser impressa no terminal.
1. Ler o valor de S e de T;
2. Se S é menor ou igual a zero OU T é menor ou igual a zero:
2.1. Imprimir mensagem de erro;
3. Caso contrário:
3.1. Calcular v;
3.2. Imprimir o valor de v.
Aqui explorou-se uma variação da estrutura de decisão mostrada da Figura 2, onde a decisão
determina a “escolha” entre dois blocos de instruções, um quando a condição é “Verdadeira”, e outro
quando a condição é “Falsa”. Esta utilização fica mais clara no fluxograma da Figura 5.
Início
Ler S e T
Verdadeira Falsa
Se S <= 0 ou T <= 0
Imprimir mensagem
v=S/T
de erro
Imprimir v
Fim
1.4.3 Exemplo 3
Frequência e período são duas grandezas escalares relacionadas à rotação de um objeto em movi-
mento circular. A frequência (f ) pode ser determinada pelo inverso do período (T ):
1
f=
T
8
Considere agora o problema de determinar a frequência a partir da leitura de valores de T . Para
cada valor de T lido, calcula-se f e imprime-se este resultado no terminal. O programa para de realizar
a entrada e o cálculo quando um valor menor ou igual a zero é fornecido na leitura de T .
1. Ler o valor de T;
2. Enquanto T é maior do que zero:
2.1. Calcular f;
2.2. Imprimir o valor de f;
2.3. Ler o valor de T;
Observe que agora precisaremos da estrutura de iteração exemplificada na Figura 3. A Figura 6

apresenta um fluxograma que representa o algoritmo para este exemplo.
Início
Ler T
Verdadeira Falsa
Enquanto T > 0
f=1/T
Imprimir f Fim
Ler T
1.5 Dicas para um bom aproveitamento na disciplina

• Acompanhe e participe de todas as aulas. Em caso de ausência, verifique o conteúdo dado pelo
professor e estude na mesma semana da aula perdida. Não deixe acumular conteúdo para a
semana seguinte, os assuntos são acumulativos;
• Participe ativamente das aulas práticas, procurando fazer os exercícios sozinho durante a
aula e solicitando ajuda sempre que necessário;
• Mesmo participando das aulas, estude o conteúdo apresentado nas aulas da semana através
deste livro texto.
• Observe sempre os exemplos dados neste livro texto, criando, depurando e executando os
códigos-fonte no Thonny. Faça isso como uma preparação para a aula prática sobre o as-
sunto;
• Tente resolver os exercícios propostos neste livro texto, criando e executando/depurando os
9
códigos-fonte no Thonny e depois comparando com as soluções propostas. Faça isso como uma
preparação para a aula prática sobre o assunto;
• Matricule-se e participe da Tutoria. Trata-se de uma atividade extraclasse regular, ministrada

por um ex-aluno da disciplina, com controle de frequência e atividades articuladas para comple-
mentar o seu aprendizado. Além disso, serve para aproveitar horas em ATV;
• Sempre que tiver dúvidas fora do horário de aulas ou tutorias, você pode procurar a Monitoria.
Trata-se de um serviço de atendimento para esclarecimento de dúvidas realizado por ex-alunos
da disciplina. É ofertada uma grade de horários bastante abrangente, com atendimentos presen-
ciais e online;
• Ao estudar em grupo, certifique-se de que esteja aprendendo o conteúdo e a resolver os

problemas sozinho depois. Muitas vezes as atividades em grupo geram uma falsa sensação de
aprendizado, saindo dali, você precisa conseguir se virar sozinho sobre os assuntos estudados e
exercícios resolvidos;
• Ao receber soluções prontas, não basta entender o que o programa está fazendo, é necessá-
rio entender porque ele foi construído daquela maneira para resolver o problema ao qual
ele se propõe a solucionar. Problemas similares, serão resolvidos de maneira similar, mas você
precisa entender como aproveitar estas soluções no contexto do novo problema;
• Permanecendo as dúvidas, entre em contato com o seu professor, ele inclusive possui horá-
rios especificamente destinados ao atendimento extraclasse de alunos;
• Reserve as datas das avaliações teóricas unificadas, elas são realizadas aos sábados e encontram-
se definidas no plano de ensino da disciplina, apresentado na primeira semana de aula e dispo-
nível no site da disciplina (http://www.decom.ufop.br/bcc701/).
• Exercite regularmente a resolução de exercícios utilizando apenas lápis e papel. As ava-

liações teóricas unificadas são feitas em sala de aula desta maneira, com lápis e papel, sem o
auxílio do computador.
1.6 Organização deste documento

Este documento apresenta todo o conteúdo teórico, além de exemplos e exercícios práticos, relaci-
onados ao programa da disciplina Programação de Computadores I (BCC701), em nove capítulos:
• Capítulo 1, “Introdução”, onde foram apresentados alguns conceitos e dicas que serão importan-
tes ao longo dos próximos capítulos;
• Capítulo 2, “Variáveis e Expressões”, apresenta recursos necessários para manipular e processar

valores e seu armazenamento na memória do computador;
• Capítulo 3, “Entrada e Saída”, apresenta recursos necessários para realização de interações com
o usuário através da leitura de valores de entrada (Input) e da exibição de mensagens de saída
(Output);
• Capítulo 4, “Estrutura de Decisão”, apresenta recursos necessários para escolha pela execução
de blocos de instrução durante a execução de um programa;
• Capítulo 5, “Estrutura de Repetição”, apresenta recursos necessários para a execução de um
10
bloco de instruções repetidas vezes;
• Capítulo 6, “Implementação de Funções”, apresenta recursos necessários para permitir que o

programador crie suas próprias funções, promovendo a modularização do código;
• Capítulo 7, “Estruturas Homogêneas”, apresenta recursos necessários para agregar o armazena-

mento uma quantidade arbitrária de valores, todos de um mesmo tipo de dado, em uma única
variável;
• Capítulo 8, “Estruturas Heterogêneas”, apresenta recursos necessários para agregar o armazena-

mento de valores de diferentes tipos de dado em uma mesma variável;
• Capítulo 9, “Soluções dos Exercícios Propostos”, apresenta as soluções dos exercícios propostos
ao longo dos capítulos anteriores.
11
2
Variáveis e Expressões
CAPÍTULO
Em programação de computadores, uma variável é um contêiner que serve para armazenar valores
na memória do computador. Variáveis não são os próprios valores, mas uma forma de armazená-los
e utilizá-los, você pode pensar nelas como pequenas “caixas” nas quais você pode guardar valores,
conforme ilustrado na Figura 7.
Figura 7: Representação de três variáveis.
2.1 Para que serve uma variável?

Variáveis referenciam um espaço na memória do computador para armazenar valores. Quando
você cria uma variável, você está reservando um espaço na memória, que passa a ser referenciado di-
retamente através de seu “nome”. Em uma variável, você pode armazenar valores inteiros, caracteres,
decimais, dentre outros.
2.2 Atribuição de Valores para uma Variável

A atribuição de valores consiste na definição da informação a ser armazenada em uma determinada
variável. A linguagem Python define que o sinal que conhecemos pelo nome de igual (=) será o
operador de atribuição, conforme ilustrado na Figura 8.
12
Figura 8: Atribuição de valor para uma variável.
O lado esquerdo do operador de atribuição (“minha_variavel”) representa o nome da variável.

O outro lado representará o valor a ser armazenado, podendo ser qualquer valor ou expressão. Caso
a variável não exista, ela será criada, caso já exista, o valor atualmente armazenado será descartado,
e o valor definido, ou o resultado da expressão, será armazenado a partir de então.
Um valor a ser atribuído à variável pode ser, por exemplo:
• Um valor inteiro (int): 2, 4, 10, etc.;
• Um valor real (float): 2.7698, 0.0023, etc.;
• Um valor textual (string): “Um texto qualquer”;
• Um valor lógico (boolean): True ou False;
• Outros valores disponibilizados pela linguagem;
Observe que, para números reais, nós utilizamos apenas o “.” (ponto) para separar a parte inteira
da parte fracionada. Um erro muito comum em iniciantes de programação é trocar o “.” por “,”
(vírgula), confundindo a representação algébrica do português com a representação específica da
linguagem Python.
Nas próximas seções mostraremos regras para definição dos nomes de variáveis, inúmeras opções
para a construção de expressões e outros conceitos e recursos envolvidos.
2.3 Regras para o nome de uma variável

O programador pode escolher qualquer nome para uma variável, exceto as palavras-chave do
Python (palavras reservadas para finalidades específicas), e é uma boa prática escolher nomes sig-
nificativos que reflitam o conteúdo da variável no programa. Porém, algumas regras devem ser obser-
vadas:
• Não podem conter espaços;
• Não podem iniciar com números;
• Além de caracteres alfanuméricos, pode conter somente o caractere: “_”;
• Apesar de permitido em Python, caracteres acentuados em nomes de variáveis devem ser evita-
dos, pois a maioria das linguagens de programação não permite acentos em nomes de variáveis.
• Python é case-sensitive (diferencia letras maiúsculas e minúsculas): Nome 6= nome 6= NOME;
13
• É recomendado que as variáveis tenham nomes significativos. Escolher nomes significativos para
as variáveis ajuda o programador a entender o que o programa faz e a prevenir erros.
Alguns exemplos de nomes válidos em Python:
• var
• nome1
• total_de_alunos
• José (dica: apesar de válidos em Python, evite nomes de variáveis com acentos!)
Alguns exemplos de nomes inválidos em Python:
• 1Aluno (o primeiro caractere é um algarismo)
• total de alunos (tem espaços)
• #funcionarios (o uso do caractere inválido “#”)
• %valor (o uso do caractere inválido “%”)
2.4 Exemplos de utilização de variáveis

A seguir alguns exemplos de uso de variáveis em programas. Recomendamos que você crie os pro-
gramas de exemplo no Thonny e execute alterando os valores para observar os diferentes resultados.
Exemplo 1:
Criar um programa contendo uma variável para guardar a informação da idade de uma pessoa, em
seguida apresentar no monitor do computador o valor armazenado na variável.
Solução:
1 idade = 19
2 print(idade)
Na primeira linha, o operando à esquerda do sinal de igual é o nome da variável (idade), enquanto
o operando à direita do sinal de igual é o valor que será guardado na variável (19).
Na segunda linha, temos o comando print que apresenta na tela do computador o valor armaze-
nado na variável idade. Este comando é utilizado nos exemplos a seguir de forma semelhante, apenas
para imprimir o valor das variáveis, ele será detalhado no próximo capítulo.
Exemplo 2:
Criar um programa contendo uma variável para armazenar o nome do cliente de uma loja que,
em seguida, apresenta o valor desta variável na tela do computador. Observe que o nome é colocado
entre aspas, isto porque se trata de um valor textual.
14
Solução:
1 cliente = "João da Silva"
2 print(cliente)
Exemplo 3:
Criar um programa que armazene o valor inteiro 6 em uma variável e em seguida imprime esse
valor na tela do computador.
Solução:
1 resultado = 6
2 print(resultado)
Exemplo 4:
Criar um programa que armazene o valor inteiro 27 em uma variável e, em seguida, divida esse
valor por 3 e armazene em outra variável e por fim, imprima o resultado obtido na tela do computador.
Solução:
1 a = 27
2 x = a/3
3 print(x)
Exemplo 5:
Criar um programa que armazene o texto ‘Um texto qualquer.’ em uma variável e em seguida
imprima esse texto na tela do computador. Novamente temos a representação de um valor textual
entre aspas. Observe que pode-se usar aspas duplas ou simples.
Solução:
1 texto = 'Um texto qualquer.'
2 print(texto)
Exemplo 6 (Contraexemplo):
Suponha que você deseja resolver o seguinte problema matemático: Calcule o valor de x a partir
do valor de y, dado que o dobro de x equivale ao triplo de y.
Você naturalmente formulará a seguinte expressão para resolver o problema: 2 ∗ x = 3 ∗ y. Mas,

caso você queira resolver o problema para y = 10 em um programa de computador, você não pode
criar o programa usando diretamente esta expressão, veja:
15
Solução INCORRETA:
1 y = 10
2 2 * x = 3 * y
3 print(x)
A solução anterior está incorreta porque você está cometendo um erro de sintaxe, pois a atribuição
é definida como:
nome_variavel = valor
e não temos no lado esquerdo do símbolo = o nome de uma variável, temos a expressão 2 ∗ x.
Mesmo na Matemática, para resolver o problema seria recomendado realizar operações para ade-
quar a equação para o cálculo de x, obtendo a expressão: x = (3 ∗ y)/2.
E, a partir daí, já podemos representar o cálculo em um programa que respeite a sintaxe da atri-
buição de um valor para a variável x:
Solução CORRETA:
1 y = 10
2 x = (3 * y) / 2
3 print(x)
2.5 Tipos de Dados

O Python possui vários tipos de dados diferentes que você pode usar para armazenar valores
em variáveis, cada um com seu próprio conjunto de operações exclusivas que você pode usar para
manipular e trabalhar com as variáveis. Estes são alguns exemplos: Numéricos, String, Lógico, Lista,
Tupla, Dicionário. Inicialmente, apresentaremos apenas os dois primeiros tipos.
2.5.1 Numéricos
A linguagem Python permite manipular valores numéricos de variados tipos:
1. int: esse é o tipo de dado mais usado para manipular números inteiros. Seu valor máximo é
2.147.483.647 e seu valor mínimo é -2.147.483.648.
2. long: esse é o tipo de dado mais usado para manipular números inteiros com valor muito alto.
3. float: esse tipo é usado para manipular números reais.
4. complex: esse tipo é usado para manipular números complexos, que não serão explorados em
nossa disciplina.
Exemplo 7:
Criar um programa capaz de armazenar a quantidade e o preço de um produto e em seguida,

apresentar o valor total na tela do computador.
16
Solução:
1 quantidade = 6
2 preco = 4.85
3 print('O valor total é:')
4 print(quantidade * preco)
Aqui, atribuímos um valor inteiro à variável quantidade (linha 1) e um valor real à variável total
(linha 2). Em seguida, imprimimos o valor total, resultante da multiplicação da quantidade pelo preço
(linhas 3 e 4). A linha 3 apenas informa o significado do valor numérico impresso, enquanto a linha 4
calcula o valor numérico e imprime o resultado.
2.5.2 String
Uma string é identificada como um conjunto de caracteres que deve estar entre aspas. O Python
permite que os valores string sejam declarados com aspas simples (’) ou duplas (").
Exemplo 8:
Criar um programa capaz de armazenar o nome do cliente e em seguida, o programa deve apre-
sentar o valor dessa variável na tela do computador.
Solução:
1 nome_cliente = "João da Silva"
2 print('O nome do cliente é:')
3 print(nome_cliente)
Exemplo 9:
Criar um programa capaz de guardar dois valores na memória e em seguida exibir o conteúdo
armazenado em cada variável.
Solução:
1 a = 8
2 b = 4.5
3 print('Valores atribuídos: ')
4 print('a =')
5 print(a)
6 print('b =')
7 print(b)
Há duas operações úteis para a manipulação de strings, a saber: concatenação e replicação, que
podem ser realizadas utilizando os operadores + e *, respectivamente.
A concatenação (+) é aplicada quando se têm dois operandos do tipo string e produz a junção dos
dois, conforme o exemplo 11. A replicação (*) está definida considerando um operando do tipo string
17
e outro numérico inteiro, sem importar a ordem em que ambos aparecem na expressão. O número
inteiro na expressão indica o número de vezes que a string será replicada, conforme o exemplo 12.
Exemplo 10: Concatenação de strings:
Criar um programa capaz de guardar duas strings na memória e, em seguida, exibir o conteúdo da
concatenação das duas strings.
Solução:
1 O = 'Ouro'
2 P = ' Preto'
3 print(O + P)
Exemplo 11: Replicação de string:
Criar um programa capaz de guardar na memória uma string, replicá-la 4 vezes e exibir o conteúdo
da string resultante.
Solução:
1 S = 'Campeão! '
2 tetra = S * 4
3 print(tetra)
2.6 Operadores aritméticos

Operadores aritméticos são símbolos especiais que representam cálculos matemáticos como adição,
multiplicação e divisão, realizadas com valores numéricos. Os operadores aritméticos mais usados em
Python são listados na Tabela 1. O seu funcionamento é como conhecemos na Matemática.
Operador Operação
+ Adição
− Subtração
∗ Multiplicação
/ Divisão
// Divisão inteira
% Resto da divisão
∗∗ Potência
Tabela 1: Operadores aritméticos.
18
Exemplo 12: Adição:
Criar um programa capaz de somar dois números e em seguida apresentar o resultado na tela do
computador.
Solução:
1 a = 3
2 b = 6
3 c = a + b
4 print(c)
Obs.: perceba que no exemplo acima foi criada uma variável (c) adicional para armazenar o resultado
da soma. Ela é dispensável, pois poderia ser feito print(a + b), assim, primeiro o resultado da expres-
são é calculado para depois o print fazer a exibição do resultado. A criação de variáveis adicionais é
recomendado para facilitar a organização e entendimento do código, não é essencial neste caso, mas
poderá ser em várias outras situações daqui para frente.
Exemplo 13: Subtração:
Criar um programa para calcular a diferença entre dois números e em seguida, o programa deve
apresentar o resultado na tela do computador.
Solução:
1 a = 3
2 b = 6
3 c = a - b
4 print(c)
Exemplo 14: Multiplicação:
Criar um programa para calcular a multiplicação entre dois números e em seguida, o programa
deve apresentar o resultado na tela do computador.
Solução:
1 a = 3
2 b = 6
3 c = a * b
4 print(c)
Exemplo 15: Divisão:
Criar um programa para calcular a divisão entre dois números e em seguida, o programa deve
apresentar o resultado na tela do computador.
19
Solução:
1 a = 5
2 b = 2
3 c = a / b
4 print(c)
Este programa imprimirá o valor real 2.5 como resultado da divisão. Observe a diferença para o
próximo exemplo.
Exemplo 16: Divisão Inteira:
Criar um programa para calcular a divisão inteira entre dois números e em seguida, o programa
deve apresentar o resultado na tela do computador.
Solução:
1 a = 5
2 b = 2
3 c = a // b
4 print(c)
Diferentemente da divisão do exemplo anterior, o resultado neste exemplo é o valor inteiro 2, pois
a divisão inteira retorna o valor inteiro da divisão, ignorando o resto.
Exemplo 17: Resto da divisão:
Criar um programa capaz de inicializar duas variáveis, atribuindo números, calcular o resto da
divisão entre a primeira e a segunda variável e, por fim, exibir o resultado no monitor do computador.
Solução :
1 a = 11
2 b = 77
3 c = a % b
4 print('Resto da divisão =')
5 print(c)
Exemplo 18: Potência:
Criar um programa para calcular 9 elevado ao cubo e em seguida o programa deve apresentar o
resultado na tela do computador.
Solução:
1 a = 9
2 b = 3
3 c = a ** b
4 print(c)
20
Exemplo 19: Contraexemplo:
Criar um programa para calcular o dobro da soma de dois números armazenados em variáveis e,
ao final, apresentar o resultado na tela.
Solução INCORRETA:
1 a = 3
2 b = 6
3 c = 2 * a + b
4 print(c)
Deve-se tomar cuidado ao agrupar expressões com mais de um operador. O resultado da linha 3
estará incorreto, pois, pela precedência de operações, a multiplicação será executada antes da soma.
Para realizar o cálculo corretamente, usamos os parênteses para realizar primeiro a soma e depois a
multiplicação, conforme a solução a seguir.
Solução CORRETA:
1 a = 3
2 b = 6
3 c = 2 * (a + b)
4 print(c)
2.6.1 Precedência e associatividade de operadores
A precedência de operadores indica qual operador deverá ser executado primeiro:
• Assim, na expressão aritmética 2 + 3 ∗ 6, a sub-expressão 3 ∗ 6 é executada primeiro;
• Portanto, tem-se como resultado para a expressão o valor 20.
Exemplo 20:
Criar um programa para calcular e imprimir o resultado da seguinte expressão matemática: 2+3∗6.
Solução:
1 resultado = 2 + 3 * 6
2 print(resultado)
A associatividade define a regra usada quando os operadores possuem a mesma precedência:
• Define-se que a ordem de avaliação será da esquerda para a direita ou o contrário, da direita
para a esquerda;
• Para a expressão A − B + C + D, o termo A − B é avaliado primeiro;
• Para a expressão A ∗ ∗B ∗ ∗C ∗ ∗D, o termo C ∗ ∗D é avaliado primeiro.
21
Exemplo 21:
Criar um programa para calcular e imprimir o resultado das seguintes operações matemáticas:
5 − 4 + 2 e 5 ∗ ∗4 ∗ ∗2.
Solução:
1 e = 5 - 4 + 2
2 print(e)
3 e = 5 ** 4 ** 2
4 print(e)
Qual a ordem de execução das operações? Utilize a depuração do Thonny para observar como o
Python executa estas expressões.
Podemos alterar a ordem de execução das operações utilizando os símbolos de abre parênteses, (,
e fecha parênteses, ), como parte da expressão. O programa a seguir exibirá um resultado diferente.
Utilize, novamente, a depuração do Thonny para observar como o Python executa estas expressões e
compare com a execução do código anterior.
Solução :
1 e = 5 - (4 + 2)
2 print(e)
3 e = (5 ** 4) ** 2
4 print(e)
2.7 Funções elementares

A linguagem Python possui diferentes módulos (ou bibliotecas) que fornecem diversas funções
úteis para o programador. Um desses módulos é o math que fornece várias funções matemáticas úteis
para realizar cálculos matemáticos.
Para usar qualquer módulo em Python é necessário importá-lo antes. Por exemplo, para usar o
módulo math temos que acrescentar o seguinte comando no início do programa:
1 import math
Após o comando de importação do módulo, é possível usar as funções definidas por ele.
A seguir exploraremos várias funções elementares, apenas duas não pertencem ao módulo math:
abs e round. A Tabela 2 sumariza todas as funções.
Exemplo 22: função abs(x):
Função para calcular o valor absoluto do argumento x, ou seja, a distância (positiva) entre x e
zero.
1 resultado = abs(-12)
2 print(resultado)
22
Na primeira linha, a variável resultado recebe o valor absoluto de −12, calculado a partir da
função abs. Na segunda linha, temos o comando print que apresenta na tela do computador o valor
armazenado na variável resultado.
Observe que neste exemplo não foi necessário importar o módulo math, pois ela pertence ao
módulo padrão do Python, assim como função print usada em todos os exemplos.
Outra observação importante é em relação ao “argumento x”. Uma função que necessita receber
algum valor (um ou mais) para realizar sua tarefa, recebe estes valores a partir de argumentos, aqui
o nome x é usado apenas de forma ilustrativa, tanto que ele não apareceu no programa de exemplo.
Ao utilizar a função abs, que recebe apenas um argumento, nós passamos o valor que será utilizado
pela função, neste caso o valor −12. Qualquer valor numérico ou expressão que resulte em valor
numérico poderá ser utilizado, por exemplo, o resultado de abs(1 - 13) será o mesmo de abs(-12), já
que 1 − 13 = −12.
Agora exploraremos algumas funções do módulo math.
Exemplo 23: função sqrt(x):
É uma função para calcular a raiz quadrada de do argumento x.

1 import math
2 resultado = math.sqrt(9)
3 print(resultado)
A primeira linha importa o módulo math, permitindo assim o uso de todas as suas funções dentro
do programa. Na segunda linha, a variável resultado recebe a raiz quadrada de 9, sendo calculada a
partir da função sqrt. Na terceira linha, temos o comando print que apresenta na tela do computador
o valor armazenado na variável resultado.
Exemplo 24: função cos(x):
Função para calcular o cosseno do argumento x, em radianos.

1 import math
2 resultado = math.cos(30)
3 print(resultado)
A primeira linha importa o módulo math. Na segunda linha, a variável resultado recebe o cosseno
de 30 radianos, calculado a partir da função cos. Na terceira linha, temos o comando print que
apresenta na tela do computador o valor armazenado na variável resultado.
Exemplo 25: função tan(x):
Função para calcular a tangente do argumento x, em radianos.

1 import math
2 resultado = math.tan(3.1417)
3 print(resultado)
23
A primeira linha importa o módulo math. Na segunda linha, a variável resultado recebe a tangente
de 3.1417, calculada a partir da função tan. Na terceira linha, temos o comando print que apresenta
na tela do computador o valor armazenado na variável resultado.
Exemplo 26: função sin(x):
Função para calcular o seno de do argumento x.

1 import math
2 resultado = math.sin(3.1417)
3 print(resultado)
Exemplo 27: função log(x):
Calcula o logaritmo natural do argumento x.

1 import math
2 resultado = math.log(10)
3 print(resultado)
Exemplo 28: função log10(x):
Calcula o logaritmo de x na base 10.

1 import math
2 resultado = math.log10(1000)
3 print(resultado)
Exemplo 29: função log2(x):
Calcula o logaritmo de x na base 2.

1 import math
2 resultado = math.log2(256)
3 print(resultado)
Exemplo 30: função log(x, b):
Calcula o logaritmo de x na base b.

1 import math
2 resultado = math.log(81, 3)
3 print(resultado)
Calcular o logaritmo na base 2 ou base 10 usando log2(x) e log10(x), resulta em valores mais
precisos do que log(x, 2) e log(x, 10), já que são funções específicas para estas duas bases e utilizam
algoritmos mais precisos para realizar os cálculos necessários.
24
Exemplo 31: funções de arredondamento:
Existem variadas formas de arredondamento de um valor real que serão úteis em variadas situa-
ções. Elas se comportam de maneira ligeiramente diferente, conhecer seu comportamento é essencial
para fazer uma escolha adequada. No exemplo a seguir, mostramos o comportamento delas para um
valor negativo, e na Tabela 2 mostramos exemplos com um valor positivo, compare os resultados.
1 import math
2 x = -5.24739
3 print( round(x) )
4 print( round(x, 2) )
5 print( math.trunc(x) )
6 print( math.ceil(x) )
7 print( math.floor(x) )
2.7.1 Resumo das funções elementares
A Tabela 2 apresenta um resumo das funções apresentadas anteriormente. Lembre-se de que todas
são fornecidas pelo módulo math, à exceção apenas das funções abs e round.
Função Nome Exemplo Resultado

Valor absoluto abs abs(-2) 2
Raiz quadrada math.sqrt sqrt(9) 3
Cosseno math.cos cos(30) 0.1542514
Tangente math.tan tan(7.3456) 1.7945721
Seno math.sin sin(3.14) 1.5927e-03
Logaritmo natural math.log log(148.41315910257657) 5
Logaritmo base 10 math.log10 log10(1000) 3
Logaritmo base 2 math.log2 log2(256) 8
Logaritmo qualquer base math.log log(81,3) 4
Arredondamento para inteiro round round(5.24739) 5
Arredondamento com precisão round round(5.24739, 2) 5.25
Parte inteira math.trunc trunc(5.24739) 5
Arredondamento para cima math.ceil ceil(5.24739) 6
Arredondamento para baixo math.floor floor(5.24739) 5
Tabela 2: Funções elementares.
2.8 Constantes
A linguagem Python fornece algumas constantes úteis em diversos cálculos matemáticos no mó-
dulo math. A Tabela 3 apresenta um resumo de algumas das constantes fornecidas, em seguida,
alguns exemplos.
25
Constante Nome Valor
Pi (π) math.pi 3.141592..., até a precisão disponível
Número neperiano (e) math.e 2.718281..., até a precisão disponível
Tau (τ ) math.tau 6.283185..., até a precisão disponível
Infinito (∞) math.inf Uma representação do infinito positivo
Tabela 3: Algumas constantes do módulo math.
Exemplo 32: constante pi (π):
A constante matemática π é utilizada em diversas situações. Uma delas é para se calcular o com-
primento de uma circunferência, através da equação:
C = 2 ∗ π ∗ r,
onde C é o comprimento e r o raio da circunferência.
O programa a seguir pode ser usado para calcular o comprimento de uma circunferência de raio
igual a 100 metros.
1 import math
2 r = 100
3 C = 2 * math.pi * r
4 print(C)
Observe que, para usar a constante π importamos o módulo math e utilizamos math.pi, que re-
presenta o valor numérico de π com a maior precisão possível na linguagem Python.
Exemplo 33: número de Euler (ou neperiano) (e):
O número neperiano também é muito útil em diversas situações, como em logaritmos naturais, por
exemplo. Outra utilização é para o cálculo de juros compostos, onde o montante após um tempo t,
Mt , a uma taxa de juros composto r é definido como:
Mt = Mi ∗ er∗t ,
onde Mi é o montante inicial.
O programa a seguir pode ser utilizado para calcular o valor a ser pago considerando um montante
inicial de R$ 1.000,00, com juros compostos a uma taxa mensal de 1,5%, durante 12 meses.
1 import math
2 Mi = 1000
3 r = 0.015
4 t = 12
5 Mt = Mi * math.e ** (r*t)
6 print(Mt)
2.9 Outra forma de importação

Existem outras formas de importar uma biblioteca que podem simplificar ou facilitar o uso dos
recursos disponibilizados, observe os exemplos a seguir.
26
Exemplo 34:
Seja x = 121, o programa a seguir pode ser usado para calcular a raiz quadrada de x.
1 from math import * # nova forma de importação (todos os recursos)
2 x = 121
3 raiz_quadrada = sqrt(x) # nesta forma de importação não se usa 'math.'
4 print(raiz_quadrada)
Exemplo 35:
Seja o ângulo t = 0.5 * pi radianos, crie um programa que avalie o valor de y = sin(t) +
tau * log(t). Carregue da biblioteca math apenas as constantes e funções que utiliza de fato no
programa.
1 from math import pi, tau, sin, log # importa apenas o necessário
2 t = 0.5 * pi
3 y = sin(t) + tau * log(t)
4 print(y)
2.10 Exercícios Propostos

Exercício 1
Um prêmio em dinheiro será dividido entre três ganhadores de um concurso.
• O primeiro ganhador receberá 46% do valor total do prêmio
• O segundo ganhador receberá 32% do valor total do prêmio
• O terceiro receberá o restante
Escreva um programa que defina uma variável com o valor 780000 para o prêmio e, em seguida,
calcule e imprima a quantia que deve ser distribuída para cada um dos ganhadores.
Exemplo de execução 1:
O primeiro ganhador deve receber R$:
358800.0
O segundo ganhador deve receber R$:
249600.0
O terceiro ganhador deve receber R$:
171600.0
Exercício 2
Faça um programa que defina a largura e a altura de uma parede em 2.8 e 5.2 metros em duas
variáveis. Posteriormente, calcule a sua área e a quantidade de tinta necessária para pintá-la, sabendo
que cada litro de tinta pinta uma área de 2 metros quadrados.
27
Área da parede em metros quadrados:
14.559999999999999
Litros de tinta necessários para pintar essa parede:
7.279999999999999
Exercício 3
Escreva um programa que defina, em variáveis, a quantidade de Km percorridos por um carro

alugado (com valor 879) e a quantidade de dias pelos quais ele foi alugado (com valor 6). Calcule o
preço a pagar, sabendo que o carro custa R$ 60,00 por dia e R$ 0,15 por Km rodado.
O cliente deve pagar R$:
491.85
Exercício 4
Faça um programa que defina uma variável com área de um quadrado no valor de 256 e calcule o
valor de cada lado do quadrado.
Cada lado tem comprimento igual à:
16.0
Exercício 5
Faça um programa que defina uma variável com o raio de um círculo no valor de 1.2 e calcule sua
área. Utilize a fórmula:
area = π ∗ (raio2 )
Utilize a constante π definida na linguagem.
Ao final, o seu programa deve apresentar o valor calculado da área do círculo.
A área do círculo é:
4.523893421169302
Exercício 6
Faça um programa que define variáveis com seu nome e sobrenomes. Depois, armazena o resultado
da concatenação destas variáveis e, por fim, exibe o seu nome completo, que é o resultado da operação
de concatenação entre estas variáveis.
28
Nome completo:
José Maria Silva
Exercício 7
As bases nitrogenadas do DNA são: Adenina (A), Guanina (G), Citosina (C) e Timina (T). O padrão
“ATGC” se repete cinco vezes em uma sequência. Faça uma programa que mostra a sequência com
esta ocorrência de replicação informada utilizando uma variável e aplicando o operador de replicação
de string.
Sequência:
ATGCATGCATGCATGCATGC
Exercício 8
Implemente um programa que imprima o valor de π com os seguintes arredondamentos:
• para baixo;
• para cima;
• para duas casas decimais.
Você deve usar a biblioteca math e as funções específicas para cada arredondamento solicitado.
Arredondando pi...
para baixo:
3
para cima:
4
para duas casas:
3.14
Exercício 9
O comprimento de uma circunferência é igual a constante tau vezes o raio do círculo. Crie um
programa em que, dado o raio do círculo igual a 5, exibe o comprimento da sua circunferência e a
relação entre as constantes tau e pi.
Comprimento:
31.41592653589793
Relação entre as constantes tau e pi:
2.0
29
3
Entrada e Saída
CAPÍTULO
Normalmente, em um programa de computador, é necessário interagir com o usuário. Em algum

momento é necessária a inserção de dados, comumente definidos como entradas do usuário, que
posteriormente serão manipulados por um conjunto de instruções definidas no programa. Depois,
com os dados obtidos através das instruções executadas, o resultado poderá ser apresentado como
uma saída para o usuário do programa. O fluxograma da Figura 9 ilustra o cenário descrito com as
principais etapas de um programa que fornece instruções de entrada e saída.
Figura 9: Fluxograma de exemplo para entrada e saída.
Na linguagem de programação Python, a função input() realiza a entrada e a função print()

realiza a saída. Por uma questão didática, primeiro apresentaremos a saída e, em seguida, a entrada.
30
3.1 Saída: função print
A saída de dados em Python, como descrito anteriormente, através de sua interface padrão, é feita
por meio da função print. A seguir descrevemos a sintaxe da função print:
print(mensagem)
onde:
• print: nome da função responsável por exibir mensagens como saída para o usuário.
• mensagem: argumento de entrada para a função. É um valor que será exibido como mensagem
no terminal.
O exemplo a seguir apresenta o uso da função print gerando como saída para o usuário a frase
“Olá, Mundo!”.
1 frase = 'Olá, Mundo!'
2 print(frase)
3.1.1 Strings de formatação
Em muitos cenários será necessário compor o texto da saída a partir de informações variadas,
misturando textos explicativos com valores calculados ou armazenados em variáveis. Neste sentido, a
linguagem Python oferece vários recursos para a formatação e apresentação para compor um texto.
Uma string de formatação (ou simplesmente f-string) é escrita colocando-se a letra f imediata-
mente antes do delimitador que começa a string (aspas simples ou duplas). Em uma f-string, os
caracteres abre chave ({) e fecha chave (}) são especiais, sendo usados para intercalar valores de
expressões na string. Basta escrever a expressão desejada entre chaves dentro da f-string, e o Python
se encarregará de avaliar a expressão e inserir o valor resultante em seu lugar. Por exemplo:
f’A soma de 2 e 3 é {2+3}, certo?’
Nesta f-string a expressão entre chaves (2+3) é avaliada e o seu resultado (5) é inserido na string,
substituindo a expressão e as chaves. O texto gerado é:
’A soma de 2 e 3 é 5, certo?’
Podemos usar strings de formatação como argumentos para a função print para produzirmos saídas
de dados formatadas em nossos programas.
Exemplo 1:
Escreva um programa que armazene um nome e, em seguida, exibe uma saudação de boas-vindas,
incluindo o nome na saudação.
1 nome = 'Fulano de Tal'
2 print(f'Bom dia {nome}, seja bem vindo(a)!')
31
Exemplo 2:
Escreva um programa que exibe a média aritmética de dois números disponíveis em duas variáveis.
1 x = 5.6
2 y = 8.8
3 media = (x + y) / 2
4 print(f'A média aritmética de {x} e {y} é {media}')
3.1.2 Especificando a formatação
O Python permite a indicação da formatação dos valores inseridos em uma f-string. Para tanto
basta colocar, imediatamente após a expressão, antes de fechar as chaves, o caractere dois pontos (“:”)
seguido da indicação de formatação desejada.
Uma especificação de formatação simplificada consiste em indicar:
1. (opcional) a largura do campo (quantidade mínima de caracteres a ser usada);
2. (opcional) o caractere “.” seguido da precisão para números reais (quantidade de casas deci-
mais). Quando especificada uma precisão em casas decimais, o valor numérico será arredondado
para a precisão definida;
3. o tipo do dado:
• “s” para string (sequência de caracteres);
• “d” para decimal (valor numérico inteiro em notação decimal);
• “f” para float (valor numérico real).
Exemplo 3:
Para demonstrar o uso do operador de formatação observe o bloco de códigos abaixo.

1 cidade = 'Ouro Preto'
2 celsius = 32
3 fahrenheit = 89.6
4 kelvin = 305.15
5 print(f'A temperatura em {cidade}:')
6 print(f'{celsius} Celsius')
7 print(f'{fahrenheit:.1f} Fahrenheit')
8 print(f'{kelvin:.1f} Kelvin')
Neste código foram definidas e inicializadas quatro variáveis, nas linhas 1 a 4, que armazenam
valores de tipos distintos de dados. Na linha 5, a função print, como visto anteriormente, tem como
parâmetro uma f-string correspondente à mensagem a ser exibida. Observe a ocorrência da variável
cidade entre chaves – o seu valor será inserido na mensagem. Na linha 6, a função print também é
usado com uma f-string na qual é inserido o valor da variável celsius. Já nas linhas 7 e 8, os valores
das variáveis fahrenheit e kelvin são inseridas em f-strings usando uma casa decimal.
32
Exemplo 4:
O programa a seguir ilustra as indicações de tipo e tamanho do campo na formatação do valor

inserido em uma f-string.
1 x = 1
2 y = 10
3 print('Sem formatação:')
4 print(f'x = {x}')
5 print(f'y = {y}')
6 print('Formatação para número inteiro:')
7 print(f'x = {x:d}')
8 print(f'y = {y:d}')
9 print('Formatação para número inteiro com largura mínima igual a 10:')
10 print(f'x = {x:10d}')
11 print(f'y = {y:10d}')
Neste programa estão declaradas duas variáveis x e y, inicializadas com valores do tipo inteiro.
Observe que a especificação de formatação “:10d” reserva um espaço mínimo de dez caracteres para a
inserção do valor da expressão. O espaço não utilizado é preenchido com espaço em branco à esquerda
do número.
Exemplo 5:
O código a seguir mostra como o número de casas decimais pode ser ajustado na formatação de
números reais.
1 x = 1.1111111111
2 y = 1.88888888
3 z = 2.0
5 print(f'x = {x}')
6 print(f'y = {y}')
7 print(f'z = {z}')
8 print('Formatação para número real:')
9 print(f'x = {x:f}')
10 print(f'y = {y:f}')
11 print(f'z = {z:f}')
12 print('Formatação para número real com largura mínima igual a 10:')
13 print(f'x = {x:10f}')
14 print(f'y = {y:10f}')
15 print(f'z = {z:10f}')
16 print('Formatação para número real com largura mínima igual a 10 e
precisão igual a 3:')
17 print(f'x = {x:10.3f}')
18 print(f'y = {y:10.3f}')
19 print(f'z = {z:10.3f}')
33
Este programa recorre a três variáveis x, y e z para ilustrar a formatação de números reais. A es-
pecificação de formatação “:10.3f” reserva um espaço mínimo de largura dez para inserir um número
real, que será formatado com três casas decimais.
Exemplo 6:
Para ilustrar a formatação strings usamos o seguinte programa.

1 oi = 'Olá Mundo'
2 tchau = 'Adeus mundo cruel'
4 print(f'{oi}!!!')
5 print(f'{tchau}!!!')
6 print('Formatação para string:')
7 print(f'{oi:s}!!!')
8 print(f'{tchau:s}!!!')
9 print('Formatação para string com largura mínima igual a 25:')
10 print(f'{oi:25s}!!!')
11 print(f'{tchau:25s}!!!')
A especificação de formatação “:25s” insere a string em um espaço de largura mínima de 25

caracteres. O espaço não utilizado é preenchido com espaço em branco à direita da string.
3.1.3 Inserção de caracteres especiais em uma string
Em algumas situações desejamos incluir caracteres especiais em uma string. Para isso, o Python
permite o uso de sequências de escape. Uma sequência de escape é formada pelo caractere “\”
seguido de um código que identifica o caractere especial, veja alguns exemplos a seguir:
• \n: Representa o caractere de nova linha. Quando digitado no programa faz com que o cursar
avance para a próxima linha naquela posição.
• \t: Representa o caractere de tabulação horizontal. Quando digitado no programa faz com que
o cursor avance para a próxima parada de tabulação. Normalmente as paradas de tabulação
ocorrem a cada oito posições.
• \": Representa o caractere aspas. Deve ser usado para inserir aspas em um literal string delimi-
tado por aspas.
• \’: Representa o caractere apóstrofo. Deve ser usado para inserir apóstrofo em um literal string
delimitado por apóstrofos.
• \\: Representa o caractere barra inclinada para a esquerda. Deve ser usado para inserir a barra,
pois a barra por si só já é especial, uma vez que é usada para começar uma sequência de escape.
• Se um literal string é prefixado com as letras “r” ou “R” este mecanismo de sequências de escape
é desativado, e todos os caracteres são inseridos literalmente na string.
• Em um literal f-string os caracteres “{” e “}” são especiais e indicam a inserção do valor de
uma expressão. Para inserirmos estes caracteres na string precisamos escrevê-los duas vezes em
sequência na string: “{{” e “}}”.
34
Exemplo 7:
O programa abaixo exibe várias mensagens com ocorrências de sequências de escape em strings.
1 print('Ouro\tPreto\nMinas\tGerais')
2 print('\n')
3 print('Uma aspa \" no meio da string')
4 print('Um apóstrofo \' no meio da string')
5 print('Uma barra \\ no meio da string')
6 print(r'Aqui o caracter \ não é especial')
7 print(R'Nesta string \n não é nova linha')
8 aqui = 25
9 print(f'Chaves {{ aqui }} em uma string de formatação')
3.2 Entrada: função input

Abaixo a sintaxe da função input:
input(mensagem)
onde:
• input: nome da função responsável pela entrada de dados informados pelo usuário;
• mensagem: argumento de entrada para a função. É uma string (valor textual) que será exibida
como mensagem no terminal para orientar o usuário.
Abaixo, como exemplo, a função input imprime a mensagem “Informe um nome: ” e aguarda
a entrada de dados pelo usuário. Após a inserção dos dados é necessário um clique na tecla ENTER
para indicar o término da entrada e o retorno para o programa.
1 input('Informe um nome: ')
É comum no desenvolvimento, que os dados fornecidos sejam armazenados em variáveis para

serem posteriormente manipulados em algum ponto do programa. Em Python, as entradas feitas
através da função input podem ser atribuídas (usando o operador de atribuição “=”) diretamente a
uma variável.
Abaixo a sintaxe da função input em conjunto com a atribuição de dados a uma variável:
variável = input(mensagem)
onde:
• variável: nome da variável que armazenará o valor da entrada;
• =: operador de atribuição;
• input: nome da função responsável pela entrada de dados informados pelo usuário;
• mensagem: argumento de entrada para a função. É uma string (valor textual) que será exibida
como mensagem no terminal para orientar o usuário.
35
A seguir, um exemplo com a atribuição, primeiro a função input exibirá a mensagem na tela,
aguardará até que o usuário digite algo e conclua com a tecla ENTER, e depois, o valor informado
será atribuído à variável como um dado do tipo string (str), ou seja, uma sequência de caracteres
digitada pelo usuário através do terminal. Neste exemplo, são feitas duas entradas e em seguida a
saída das informações fornecidas.
1 nome = input('Informe um nome: ')
2 idade = input(f'{nome}, informe sua idade: ')
3 print(f'Obrigado {nome}, você tem {idade} anos!')
Observe que na linha 2 utilizamos uma f-string para definir a mensagem para o input para utilizar
o nome fornecido anteriormente. Primeiro a f-strig será processada, em seguida, o resultado será
utilizado pelo input como a mensagem recebida.
3.2.1 Conversão de tipos
O resultado da função input será sempre um valor string, independente do conteúdo informado
pelo usuário. Ou seja, para a realização de cálculos matemáticos, por exemplo, será necessário con-
verter o valor string para inteiro (int) ou real (float), conforme os exemplos a seguir.
3.2.2 Conversão para inteiro: função int
Converte um valor para o tipo numérico inteiro:

1 x = 10.7
2 y = '10'
3 print(f'Valor de x original (real): {x}')
4 print(f'Valor de x como um inteiro: {int(x)}')
5 print(f'Valor de y original (string): {y}')
6 print(f'Valor de y como um inteiro: {int(y)}')
3.2.3 Conversão para real: função float
Converte um valor para o tipo numérico real:

1 x = 10
2 y = '10.7'
3 print(f'Valor de x original (inteiro): {x}')
4 print(f'Valor de x como um real: {float(x)}')
5 print(f'Valor de y original (string): {y}')
6 print(f'Valor de y como um real: {float(y)}')
36
3.2.4 Conversão para string: função str
Converte um valor para o tipo string:

1 var_inteira = 10
2 var_string = str(var_inteira)
3 soma = var_inteira + 5
4 concatenacao = var_string + '5'
5 print(soma)
6 print(concatenacao)
Como resultado da execução do programa anterior teríamos como valor para a variável soma o
número inteiro 15, que será impresso no primeiro print, como valor para a variável var_string o valor
string “10” e como valor para a variável concatenação o valor string “105”, que será impresso pelo
segundo print.
Observe também que aqui o operador “+” funciona de maneira distinta para tipos numéricos e
tipos string. Para valores numéricos ele realiza a soma matemática e para valores string ele realiza
a concatenação textual. O Python não permite usar este operador para um operando numérico e
outro operando string na mesma expressão, se você tentar fazer isso ocorrerá um erro no programa.
3.2.5 Cuidados especiais com conversão de tipos
Existe um problema com a conversão de tipos envolvendo strings. Se o texto não puder ser repre-
sentado pelo tipo convertido, ocorrerá um erro de execução. Isto vale para qualquer tipo de conversão.
Execute os exemplos a seguir.
1 y = '10.2'
1 y = 'ops'
1 y = 'ops'
2 print(f'Valor de y como um real: {float(y)}')
3.2.6 Conversão de dados fornecidos pelo usuário
Dados fornecidos pelo usuário são normalmente armazenados em uma variável, assim, basta con-
verter o valor da variável fornecida:
1 peso = input('Forneça o peso total (número real): ')
2 peso = float(peso)
3 unid = input('Forneça a quantidade de unidades (número inteiro): ')
4 unid = int(unid)
5 print(f'O peso de cada unidade é {peso/unid:.2f}')
Sempre que precisarmos fazer a conversão, podemos fazê-la em uma única linha de instrução,
colocando o input dentro da função de conversão utilizada, conforme o programa a seguir:
37
1 peso = float(input('Forneça o peso total (real): '))
2 unid = int(input('Forneça a quantidade de unidades (inteiro): ' ))
3 print(f'O peso de cada unidade é {peso/unid:.2f}')
O resultado final é exatamente o mesmo, mas obtemos um programa mais compacto.
3.3 Entrada e Saída: Exemplos Práticos
Exemplo 8:
Implemente um programa que leia dois valores inteiros e calcule sua soma, armazenando o resul-
tado em uma variável. A seguir imprima o resultado da soma.
Solução:
Para a resolver este problema, devemos começar pensando em um encadeamento de passos, ou

seja, um algoritmo, a ser executado:
1. Entrada dos dados: duas variáveis com valor inteiro;
2. Cálculo da soma dos valores das duas entradas;
3. Saída do resultado: valor da soma.
O fluxograma da Figura 10 apresenta estas etapas de uma forma gráfica e um pouco mais deta-
lhada. Com isso, fica mais fácil converter as etapas em um programa.
Figura 10: Fluxograma de solução para o exemplo 8.
38
O programa que resolve este problema é mostrado a seguir.
1 # Entrada
2 valor1 = int(input('Digite um valor: '))
3 valor2 = int(input('Digite outro valor: '))
4 # Processamento
5 soma = valor1 + valor2
6 # Saída
7 print(f'O resultado da soma é {soma}')
No exemplo são solicitadas as leituras de dois valores inteiros, assim declaramos duas variáveis
valor1 e valor2. E através da função input associada à função int, definimos as entradas nas linhas
2 e 3. Na etapa seguinte, declaramos a variável soma, na linha 5, que será responsável por receber
e armazenar o valor correspondente ao somatório dos valores contidos nas variáveis valor1 e valor2.
Por fim, como saída para o usuário, utilizamos a função print, na linha 7. Como argumento da função,
a f-string f’O resultado da soma é {soma}’ onde o valor da variável soma será inserido no texto na
respectiva posição.
Exemplo 9:
Modifique o programa anterior, onde os dois valores passam a ser reais e o resultado da soma é o
numerador de uma divisão. O denominador será um novo valor real lido. O programa imprime apenas
resultado da divisão, que também deverá estar armazenado em uma variável. A saída do resultado
deve ser arredondada para duas casas decimais de precisão.
Solução:
Novamente, começaremos pensando em um algoritmo:
1. Entrada dos dados: três variáveis com valor real;
2. Cálculo da soma dos dois primeiros valores;
3. Cálculo do resultado: soma dividida pelo terceiro valor;
4. Saída do resultado: valor da divisão.
Agora vamos observar o fluxograma da Figura 11 e convertê-lo em código a seguir.
Na resolução deste exemplo, declaramos três variáveis valor1, valor2 e denominador, que serão
informadas pelo usuário nas linhas 2, 3 e 4, respectivamente. Na etapa seguinte definimos a variável
numerador, sendo esta inicializada com a soma dos valores contidos nas variáveis valor1 e valor2,
na linha 6. E a variável resultado, definida pela divisão do valor armazenado na variável numerador
pela variável denominador, na linha 7. Por fim, definimos uma saída através da função print, que
recebe a f-string f’O resultado da divisão é {resultado:.2f}’ como argumento na linha 9. Observe que,
conforme solicitado no enunciado, formatamos a saída com duas casas decimais de precisão.
39
1 # Entrada
2 valor1 = float(input('Digite um valor: '))
3 valor2 = float(input('Digite outro valor: '))
4 denominador = float(input('Digite o denominador: '))
5 # Processamento
6 numerador = valor1 + valor2
7 resultado = numerador / denominador
8 # Saída
9 print(f'O resultado da divisão é {resultado:.2f}')
Exemplo 10:
Implemente um programa que imprima a hipotenusa (h) de um triângulo retângulo de acordo com
a leitura de seus catetos (a e b). A saída deve ser arredondada para três casas decimais.
√
Observação: h = a2 + b2 .
Solução:
Novamente, o algoritmo segue uma estrutura semelhante: 1. Entradas; 2. Processamento; 3.

Saída; representado pelo fluxograma da Figura 12. A seguir definimos o programa correspondente.
Primeiramente, as variáveis a e b serão definidas pelo usuário através da função input e seus
valores convertidos pela função float, nas linhas 3 e 4. Na sequência, declaramos a variável h, que
armazenará o valor do cálculo da hipotenusa, linha 6. Note que para calcular o valor da raiz utilizamos
a função sqrt, disponível no módulo math através da declaração da diretiva import no início do
programa (linha 1). Por fim, como saída do programa, definiremos como parâmetros para a função
print a f-string f’A hipotenusa é {h:.3f}’, onde o valor da hipotenusa armazenado na variável h é
inserido com três casas decimais, na linha 8.
40
1 import math
2 # Entrada
3 a = float(input('Digite o cateto a: '))
4 b = float(input('Digite o cateto b: '))
5 # Processamento
6 h = math.sqrt(a*a + b*b)
7 # Saída
8 print(f'A hipotenusa é {h:.3f}')
Exemplo 11:
Implemente um programa que leia do teclado um valor de temperatura em Celsius (C), calcule e
imprima essa temperatura em Fahrenheit (F ) e em Kelvin (K), com precisão de duas casas decimais.
Equações de conversão:
F = C ∗ 1.8 + 32
K = C + 273.15
Solução:
O algoritmo tem as mesmas características dos exemplos anteriores, e seu fluxograma é apresen-
tado na Figura 13.
41
O programa construído é apresentado a seguir.

1 # Entrada
2 C = float(input('Digite a temperatura em Celsius: '))
3 # Processamento
4 F = C * 1.8 + 32
5 K = C + 273.15
6 # Saída
7 print(f'A temperatura em Fahrenheit é {F:.2f}')
8 print(f'A temperatura em Kelvin é {K:.2f}')
Exercício 1
Elabore um programa que leia o valor do raio de um círculo qualquer (número inteiro) e calcule
sua respectiva área. Ao final imprima como saída o valor da área do círculo (com duas casas decimais).
Fórmula:
Area = π.r2
onde:
• π : constante Pi;
• r: raio do círculo.
Exemplos de execução:
Digite o valor do raio: 5
A área do círculo é: 78.54
42
Exercício 2
Implemente um programa que leia o valor do raio r de uma esfera (número real) e calcule o volume
da esfera. No final imprima como saída o valor calculado (com duas casas decimais).
Fórmula:
4πr3
V olume =
3
onde:
• r: raio da esfera.
O volume da esfera é: 523.60
Digite o valor do raio: 10.5
Exercício 3
Implemente um programa que tem como dados de entrada o comprimento, a largura e a altura
(números inteiros), calcule e imprima o volume de um paralelepípedo (com duas casas decimais),
utilizando a seguinte fórmula:
V olume = comprimento ∗ largura ∗ altura
43
Digite o valor do comprimento: 50
Digite o valor da largura: 20
Digite o valor da altura: 15
O volume do paralelepípedo é: 15000.00
Exercício 4
Elabore um programa que receba como entradas um determinado valor em Real (R$) como saldo
de um usuário e um valor para a cotação do Dólar (US$) (números reais). No final apresente como
saída o valor convertido em Dólar (com duas casas decimais).
Digite o valor em real: 500
Digite o valor de cotação do dólar: 4.15
O valor convertido é: 120.48
44
Exercício 5
Implemente um programa que receba como entrada o valor de um veículo (número real) e calcule
e imprima o valor do IPVA (Imposto sobre a Propriedade de Veículos Automotores) considerando a
alíquota de 4.0% (com duas casas decimais).
Digite o valor do veículo: 100000
O valor do IPVA é : 4000.00
45
4
Estrutura de Decisão
CAPÍTULO
No desenvolvimento de programas, uma estrutura de decisão possibilita, por meio da validação

de uma condição, a execução de um bloco de comandos. Caso a condição seja válida, o bloco de
comandos será executado, caso contrário, será ignorado.
O teste de uma condição retornará sempre um valor do tipo lógico (o tipo de dados bool em
Python), que podem assumir os valores: verdade (True) ou falso (False). Assim, para uma con-
dição válida, ou seja, verdadeira, o valor de retorno será True e para uma condição falsa o valor
retornado será False. A Tabela 4 apresenta exemplos de condições avaliadas e o respectivo valor de
retorno.
Condição Valor
1>0 True
1 != 0 True
1<0 False
1 == 0 False
Tabela 4: Exemplos de condições do tipo lógico.
Os fluxogramas das Figuras 14 e 15 ilustram o fluxo de execução de uma Estrutura de Decisão

Simples e de uma Estrutura de Decisão Composta, respectivamente. Observe que na Figura 14, o
bloco de comandos de 1 a n será executado somente se a condição declarada for logicamente verda-
deira. Na Figura 15 são definidos dois blocos de comandos, um bloco que será executado quando a
condição for verdadeira e outro bloco alternativo a ser executado quando a condição for falsa.
46
Verdadeira Falsa
Condição
Instrução 1
Instrução 2
...
Instrução n
Figura 14: Estrutura de Decisão simples.
Verdadeira Falsa
Condição
Instrução a.1 Instrução b.1

Instrução a.2 Instrução b.2
... ...
Instrução a.n Instrução b.m
Figura 15: Estrutura de Decisão composta.
4.1 O comando if
Na linguagem de programação Python uma estrutura de decisão simples, como representada na
Figura 14, é definida pelo comando if e sua sintaxe é dada abaixo:
...
if condição:
Instrução 1
Instrução 2
...
Instrução n
...
Deste modo, o conjunto de comandos de 1 a n simbolizam um sub-bloco de instruções, que em

Python é feito com a indentação do código, que normalmente adotam-se espaçamentos ou tabu-
lações. Estas instruções ficam definidas no escopo do comando if e serão executadas se o teste da
condição for verdadeiro. Caso a condição seja falsa, então o sub-bloco de instruções é ignorado e o
programa seguirá o seu fluxo normal de execução passando para a próxima instrução declarada, no
caso, a primeira instrução posterior ao sub-bloco de instruções (sem a indentação, ou seja, no mesmo
alinhamento do comando if).
47
Exemplo 1:
Escreva um programa que leia dois valores inteiros distintos e posteriormente imprima, como saída,
o maior valor informado.
Solução:
O fluxograma da Figura 16 apresenta a sequência de tarefas para resolver o exemplo 1.
Figura 16: Fluxograma de exemplo para solução do exemplo 1.
O algoritmo também pode ser representado textualmente:
1. Faça a entrada de dois valores
2. Se o primeiro for maior que o segundo
(a) Imprima que o primeiro é maior
3. Se o segundo for maior que o primeiro
(a) Imprima que o segundo é maior
No programa, inicialmente definiremos as entradas de dados (linhas 2 e 3). Em seguida, a veri-

ficação do maior valor é feita por meio da declaração de uma condição simples. Assim, a primeira
estrutura de decisão deverá verificar se a condição definida (valor1 > valor2) é verdadeira (linha
5). Caso seja verdade, uma instrução de saída exibirá uma mensagem informando que o primeiro é
o maior (linha 6). Observe que o comando print está afastado (indentado) do início da linha, ou
seja, em relação ao comando if da linha 5. Isto é obrigatório no Python, identificando o bloco a ser
executado caso a condição seja verdadeira. Para finalizar, como o primeiro comando if faz apenas a
verificação de uma condição, ou seja, quando o valor1 for maior que o valor2. Uma segunda estrutura
condicional if é inserida na linha 7 para fazer a outra verificação necessária, ou seja, quando valor2
48
> valor1. No caso desta condição ser verdadeira, a saída será feita para informar que o segundo valor
é maior (linha 8).
1 # Entrada
2 valor1 = int(input('Informe o primeiro valor: '))
3 valor2 = int(input('Informe o segundo valor: '))
4 # Processamento e Saída
5 if valor1 > valor2:
6 print('O primeiro valor é o maior!')
8 print('O segundo valor é o maior!')
4.2 Operadores Relacionais

Normalmente, em uma estrutura de decisão, a definição de uma condição envolve uma relação
lógica entre dois elementos. Esta relação lógica é determinada por meio de operadores relacionais.
A Tabela 5 apresenta uma lista dos operadores relacionais suportados em Python.
Operador Operação
== Igualdade
!= Desigualdade
> Maior que
>= Maior ou igual
< Menor que
<= Menor ou igual
Tabela 5: Operadores relacionais.
Assim, o teste de uma condição tem como resultado um valor lógico. Ou seja, se a relação for ver-
dadeira, o valor de retorno será True, caso contrário, o retorno será o valor False. Os valores True
e False são utilizados pelo Python para representar os valores verdadeiro e falso, respectivamente.
4.3 A cláusula else

Em uma estrutura de decisão composta, como representada na Figura 15, define-se também um
fluxo alternativo de execução, através do emprego da cláusula else. Assim, caso a condição definida no
comando if seja falsa o fluxo da execução do programa será redirecionado para o bloco de instruções
declaradas na cláusula else, seguindo a sintaxe a seguir.
...
if <condição> :
comando a.1
...
comando a.n
else:
comando b.1
...
comando b.m
...
49
O exemplo 1 resolvido anteriormente poderia ser implementado usando a cláusula else como se
segue.
1 # Entrada
2 valor1 = int(input('Informe o primeiro valor: '))
3 valor2 = int(input('Informe o segundo valor: '))
6 print('O primeiro valor é o maior !')
7 else: # implica valor2 > valor1, pois são condições excludentes e o
enunciado determina que os valores sejam diferentes
8 print('O segundo valor é o maior !')
Observe que agora temos um único comando if, usando a cláusula else. Porém, o comportamento
do programa será exatamente o mesmo do anterior. Sendo assim, do ponto de vista lógico, os dois
estão corretos. Lembre-se que o enunciado determina que os dois valores sejam diferentes.
Exemplo 2:
Elabore um programa que leia a nota de um aluno em uma determinada disciplina (número real)
e exiba uma mensagem indicando sua aprovação, se a nota for maior ou igual a 70. Caso contrário, o
programa deverá exibir uma mensagem indicando a reprovação do aluno.
Solução:
O fluxograma da Figura 17 apresenta a sequência das operações a serem definidas para a solução
do exemplo 2.
50
O programa implementado fica assim:
1 # Entrada
2 nota = float(input('Digite a nota do aluno: '))
4 if nota >= 70:
5 print('O aluno foi aprovado !')
6 else:
7 print('O aluno foi reprovado !')
Na primeira etapa definiremos as entradas solicitadas no exercício. No enunciado pede-se apenas

a leitura da nota do aluno. Assim, declararemos a variável nota que será informada pelo usuário.
Em seguida, dependendo do valor da nota, será necessário decidir entre imprimir que o aluno foi
aprovado ou imprimir que o aluno foi reprovado.
Exemplo 3:
Elabore um programa que calcule as raízes reais de uma equação do 2o grau qualquer através da
fórmula de Bhaskara:
• O nome da fórmula foi dado em homenagem ao matemático Bhaskara Akaria;
• Tem como finalidade encontrar as duas raízes de uma equação do 2o grau;
• Formato: ax2 + bx + c = 0, sendo a 6= 0;
• Se a = 0, informar que não é uma equação do 2o grau;
• Caso contrário, calcular ∆ e as raízes da equação:
– ∆ = b2 − 4ac;
√ √
−b+ ∆ −b− ∆
– x1 = 2a ; e x2 = 2a .
Solução:
O fluxograma da figura 18 apresenta a sequência das operações que representam a solução para o
exemplo 3, apresentado no código completo a seguir.
Inicialmente, definiremos as entradas a serem fornecidas e observaremos a condição a == 0, para

uma equação ser considerada do segundo grau. Neste sentindo, definiremos uma estrutura de decisão
para efetuar o teste desta condição como declarado na linha 6.
Na próxima etapa, com as entradas informadas e a condição imposta, um fluxo alternativo (else)
pode ser definido para prosseguir com a declaração das demais operações necessárias para o cálculo
solicitado. Iniciando o cálculo, definimos uma instrução para definir o valor de Delta na linha 9. Em
seguida, uma nova condição deve ser imposta para o cálculo das raízes da equação, ∆ ≥ 0. Assim,
após a definição desta condição, as instruções para informar o erro (linha 11) ou para o cálculo das
raízes da equação podem ser declaradas e os resultados exibidos (linhas 13 a 16).
51
1 import math
2 print('Cálculo das raízes de uma equação do 2o grau')
3 a = float(input('Digite o coeficiente A: '))
4 b = float(input('Digite o coeficiente B: '))
5 c = float(input('Digite o coeficiente C: '))
6 if a == 0:
7 print('Erro: Coeficiente a == 0 !')
8 else: # a é diferente de zero
9 delta = b*b - 4*a*c
10 if delta < 0:
11 print('Erro: Delta < 0 !')
12 else: # delta é maior ou igual a zero
13 x1 = (-b + math.sqrt(delta)) / (2*a)
14 x2 = (-b - math.sqrt(delta)) / (2*a)
15 print(f'x1 = {x1:.2f}')
16 print(f'x2 = {x2:.2f}')
52
4.4 Operadores Lógicos
Em uma estrutura de decisão os operadores lógicos podem ser utilizados para construir expressões
lógicas. Em Python são definidos basicamente três operadores lógicos como apresenta a Tabela 6.
Operador Operação Descrição

not não Nega (inverte) um valor lógico, ou seja, not True resulta em False, e
not False resulta em True.
and e Retorna True caso TODAS as condições ligadas sejam True.
or ou Retorna True caso PELO MENOS UMA das condições ligadas seja True.
Tabela 6: Operadores lógicos.
Exemplo 4:
Vamos retornar ao exemplo 2, que avaliava a aprovação de um aluno descrito como: Elabore um
programa que leia a nota de um aluno em uma determinada disciplina (número real) e exiba uma
mensagem indicando sua aprovação, se a nota for maior ou igual a 70. Caso contrário, o programa
deverá exibir uma mensagem indicando a reprovação.
Agora vamos inserir um novo critério, o de frequência. Para o aluno ser aprovado ele precisa ter
também frequência maior ou igual a 75%.
Solução:
O programa poderia ser reformulado para avaliar o resultado do aluno, da seguinte forma:
1 # Entrada
3 frequencia = float(input('Digite a frequência do aluno: '))
5 if nota >= 70 and frequencia >= 75:
7 else:
Outra forma correta para fazer isso seria:

1 # Entrada
5 if nota < 70 or frequencia < 75:
7 else:
53
A seguir, mais uma solução correta:
1 # Entrada
5 if not (nota < 70 or frequencia < 75):
7 else:
Todas as soluções anteriores são corretas, pois as expressões lógicas avaliam corretamente a con-
dição imposta para aprovação ou reprovação segundo a regra definida, imprimindo a mensagem
correspondente ao resultado correto.
A solução a seguir, por outro lado, está incorreta:

1 # Entrada
5 if not (nota < 70 and frequencia < 75):
7 else:
Este programa está incorreto porque existem situações em que a resposta não estará correta. Um
exemplo disso é quando o aluno for reprovado apenas pela nota, ou pela frequência, pois o resultado
impresso será que o aluno foi aprovado. Isto acontece porque trocamos um or ou um and, um
erro muito comum se não avaliarmos todas as possibilidades. Teste os programas anteriores para as
variadas situações possíveis e observe estas considerações.
Um recurso interessante quando se fala em operadores lógicos é a tabela verdade, ela mostra
todos os resultados possíveis para estas operações, facilitando o seu entendimento. Veja a Tabela 7.
A B A and B A or B not A
True True True True False
True False False True False
False False False False True
False True False True True
Tabela 7: Tabela verdade para operadores lógicos.
4.5 Estruturas de decisão aninhadas

Uma outra possibilidade de construção por meio da estrutura de decisão if, quando é necessária
a verificação de múltiplos testes condicionais, é através do aninhamento destas condições, ou seja, a
definição de vários testes de forma sequencial.
54
Em Python a cláusula elif possibilita a declaração de uma condição e um sub-bloco de instruções
alternativos ao definido na instrução if. Assim, várias condições e sub-blocos de instruções podem ser
inseridos e na medida em que estas condições são verificadas o término culminará com a verificação de
todas as condições ou com a validação de uma condição e a execução do bloco de instruções associado
ou até o bloco definido com o comando else, se este for declarado. Abaixo descrevemos a sintaxe de
uma estrutura aninhada definida pelo comando elif.
...
if <condição 1> :
comando a.1
...
comando a.n
elif <condição 2> :
comando b.1
...
comando b.o
...
elif <condição k> :
comando c.1
...
comando c.p
else:
comando d.1
...
comando d.q
...
Exemplo 5:
Dados três valores inteiros distintos fornecidos pelo usuário escreva um programa para imprimi-los
em ordem crescente.
Solução:
Antes de tentar fazer uma ordenação, precisamos tomar uma decisão, se os números são válidos
ou não. Caso sejam válidos (todos diferentes entre si), devemos avaliar a ordem dos números, mas,
caso sejam inválidos, devemos informar esta situação ao usuário. Então, em uma primeira versão de
nosso algoritmo, colocaremos a validação da entrada, ficando assim:
1. Faça a entrada de três valores numéricos inteiros
2. Se os valores forem Inválidos:
(a) Informe ao usuário que os valores são inválidos
3. Caso contrário:
(a) Avalie a ordem dos números e gere a saída adequada
55
Para um número ser considerado inválido, devemos recorrer aos operadores relacionais e lógicos.
Como eles precisam ser todos diferentes para serem válidos, a lógica para que sejam inválidos é a
inversa, que pelo menos um par seja igual. Para isto, podemos avaliar: N 1 == N 2 or N 1 == N 3 or
N 2 == N 3. Nosso algoritmo já tem uma estrutura inicial definida que nos permite iniciar o programa,
ficando desta maneira:
1 N1 = int(input('Informe o primeiro valor: '))
2 N2 = int(input('Informe o segundo valor: ' ))
3 N3 = int(input('Informe o terceiro valor: '))
4 if N1 == N2 or N1 == N3 or N2 == N3:
5 # Informe ao usuário que os valores são inválidos
6 else:
7 # Avalie a ordem dos números e gere a saída adequada
Com o primeiro passo dado, agora vamos nos preocupar com estas tarefas específicas que deverão
substituir as linhas 5 e 7.
A primeira tarefa, substituindo a linha 5, “informar ao usuário que os valores são inválidos” é uma
tarefa simples, resolvida apenas com a função print. Então, avançamos mais um pouco:
4 if N1 == N2 or N1 == N3 or N2 == N3:
5 print('Erro: Os valores informados devem ser distintos.')
6 else:
7 # Avalie a ordem dos números e gere a saída adequada
A segunda tarefa, substituindo a linha 7, “avaliar a ordem dos números e gerar a saída adequada”, é
um pouco mais complexa, e é através das estruturas de decisão aninhadas que nós a resolveremos.
Se tivermos três números, por exemplo N1, N2 e N3, poderemos listar inúmeras possibilidades de
ordenação crescente para eles. Caso já soubéssemos quais são os números, a resposta seria muito
fácil. Porém, eles serão fornecidos pelo usuário, então precisamos de uma solução algorítmica que
avalie todas as possibilidades.
O importante aqui é começar a definir uma estratégia para isso. Como temos apenas três números,
é fácil listar as possibilidades, por exemplo, a ordem que primeiro nos vem à cabeça poderia ser N1, N2
e N3, para isso, teríamos que aplicar duas avaliações relacionais, e ambas resultarem em verdadeiro:
N 1 < N 2 e N 2 < N 3. Observe que não é necessário comparar N1 com N3, pois se as duas expressões
forem verdadeiras, está garantido que N 1 < N 3. Portanto, caso N 1 < N 2 and N 2 < N 3, a ordem
N1, N2 e N3 está correta, e podemos gerar o resultado. Caso isso não seja verdade, precisamos seguir
avaliando as outras possibilidades. Sendo assim, uma outra possibilidade seria a ordem N1, N3 e N2,
que, de forma similar, poderia ser verificada por N 1 < N 3 and N 3 < N 2. E assim, por diante.
Com isto em mente, podemos elaborar um fluxograma que resolve o problema, conforme apresen-
tado na Figura 19. E, em seguida, implementar o programa completo.
56
'Informe o primeiro valor: '
Início
'Informe o segundo valor: '
'Informe o terceiro valor: '
N1 == N2
'Erro: Os valores or
informados devem ser N1 == N3
Verdadeiro or
distintos.' N2 == N3
Falso
'A ordem dos valores é: '

N1 N1 < N2
and
N2
N2 < N3
N3 Verdadeiro
Falso

N1 < N3
N1
and
N3 N3 < N2
N2 Verdadeiro
Falso

N2 < N1
N2
and
N1 N1 < N3
N3 Verdadeiro
Falso

N2 < N3
N2
and
N3 N3 < N1
N1 Verdadeiro
Falso

N3 < N1
N3
and
N1 N1 < N2
Verdadeiro
N2
Falso

N3 N3 < N2
and
N2
Verdadeiro N2 < N1
N1
Falso
Fim
57
4 if N1 == N2 or N1 == N3 or N2 == N3:
5 print('Erro: Os valores informados devem ser distintos.')
6 else:
7 if N1 < N2 and N2 < N3:
8 print(f'A ordem dos valores é: {N1}, {N2}, {N3}')
9 elif N1 < N3 and N3 < N2:
11 elif N2 < N1 and N1 < N3:
13 elif N2 < N3 and N3 < N1:
15 elif N3 < N1 and N1 < N2:
17 elif N3 < N2 and N2 < N1:
Observe que no programa anterior foi necessário utilizar dois comandos if. Uma decisão para
a validação e outra para as diferentes possibilidades de ordenação dos números. Existem outras
formas de estruturar o programa, com apenas uma decisão ou com várias outras decisões. Porém,
recomendamos utilizar a estrutura do programa apresentado, pois ele separa bem as duas tarefas
principais do problema proposto: (1) validar os números; e (2) determinar a ordem dos números.
Exercício 1
Implemente um programa que faça a entrada de dois valores inteiros e informe:
• Se o primeiro número é par ou ímpar;
• Se o segundo número é par ou ímpar;
• Se o primeiro número é divisível pelo segundo.
Dicas: (1) para saber se um número A é ímpar, verifique se o resto da divisão de A por 2 é igual a
zero; (2) para saber se um número A é divisível por B, verifique se o resto da divisão de A por B é
igual a zero. (3) estudamos o operador de resto de divisão no Capítulo 2.
Informe o primeiro número: 1
Informe o segundo número: 2
O primeiro número é ímpar.
O segundo número é par.
58
O primeiro número não é divisível pelo segundo.
O primeiro número é par.
O segundo número é ímpar.
O primeiro número é divisível pelo segundo.
Exercício 2
Um vendedor recebe um determinado valor de comissão sobre o total de suas vendas efetuadas.
Em vendas superiores a 5000,00 o valor a receber corresponde a 25%, os valores na faixa de 5000,00
a 2500,00 corresponde a 20% e para valores inferiores a 2500,00 o valor corresponde a 15%. Im-
plemente um programa que leia o valor total das vendas (número real) e calcule a quantia que o
vendedor irá receber.
Digite o valor total das vendas: 7000
O valor de comissão é: 1750.00
Exercício 3
Elabore um programa que leia as quatro notas de um aluno, números reais entre 0 a 100, e calcule
a média das notas. E no final, como saída, imprima a média (com uma casa decimal) e uma mensagem
de aprovação se a média for maior ou igual a 70 ou reprovação caso a média for inferior.
59
Digite a primeira nota: 90
Digite a segunda nota: 85
Digite a terceira nota: 95
Digite a quarta nota: 100
A média é 92.5. O aluno foi aprovado.
A média é 57.5. O aluno foi reprovado.
Erro: os valores das notas devem estar entre 0 a 100.
Exercício 4
Elabore um programa que leia três valores inteiros x, y e z e verifique se estes valores podem cons-
tituir os comprimentos de um triângulo e se caso positivo informe se este é um triângulo equilátero,
isósceles ou escaleno.
Observações:
• O triângulo equilátero possui os três lados com medidas iguais;
• O triângulo isósceles possui dois lados com medidas iguais;
• O triângulo escaleno possui os três lados com medidas diferentes.
• Condição de desigualdade triangular: (x < y + z), (y < x + z) e (z < x + y)
Digite o valor de x: 10
Digite o valor de y: 10
Digite o valor de z: 10
Triângulo Equilátero
60
Triângulo Isósceles
Triângulo Escaleno
Erro: os valores informados não constituem um triângulo.
Exercício 5
Implemente um programa que leia o valor de um veículo (número real) e sua respectiva classe
(número inteiro), como descreve a Tabela abaixo, para o cálculo do IPVA (Imposto sobre a Propriedade
de Veículos Automotores). O cálculo deve considerar a alíquota da respectiva classe do veículo. No
final imprima o resultado do cálculo como saída.
Classe Descrição Alíquota

1 Automóveis, veículos de uso misto e utilitários, caminhonetes cabine 4,0%
estendida e dupla.
2 Caminhonetes de carga (pick-ups) e furgão. 3,0%
3 Automóveis, veículos de uso misto e utilitários com autorização para 2,0%
transporte público (ex: táxi, escolar) comprovada mediante registro no
órgão de trânsito na categoria aluguel.
4 Motocicletas e similares. 2,0%
5 Veículos de locadoras (pessoa jurídica). 1,0%
6 Ônibus, micro ônibus, caminhão, caminhão trator. 1,0%
Digite a classe do veículo: 1
61
Exercício 6
Elabore um programa que leia dois valores reais x e y e que pergunte qual operação deve ser
realizada. As operações que poderão ser calculadas são a soma (+), subtração(−), multiplicação(∗),
divisão(/) e potenciação (∧). Observação: para efetuar a divisão, y deverá ser diferente de zero.
Digite o primeiro valor: 25
Digite o segundo valor: 25
Informe a operação: +
25.00 + 25.00 = 50.00
Informe a operação: ^
5.00 ^ 5.00 = 3125.00
Informe a operação: /
81.00 / 9.00 = 9.00
Erro: Divisão por zero !
62
5
Estrutura de Repetição
CAPÍTULO
As estruturas de repetição (ou iteração, ou laço) definem um bloco de instruções a ser executado
repetidamente, consecutivamente em um número finito de vezes. Basicamente, existe duas formas de
definir uma estrutura de repetição:
• Controlada Logicamente: define-se explicitamente uma condição através de uma expressão

lógica, enquanto a condição se mantiver verdadeira durante a execução, as instruções definidas
no bloco da estrutura de repetição serão executadas. Esta estrutura será detalhada na Seção 5.1;
• Controlada por Contador: define-se implicitamente uma condição por meio de um contador,
existindo uma sequência de contagem predefinida: início, passo e fim. A cada iteração o valor
do contador é alterado pelo valor do passo. Assim, o bloco de instruções declaradas na estrutura
de repetição será executado enquanto o contador não alcançar ou ultrapassar o valor final da
sequência. Esta estrutura será detalhada na Seção 5.2.
5.1 Repetição controlada logicamente: comando while

No fluxograma da Figura 20 é apresentado um esquema do fluxo de execução para um estrutura
de repetição controlada logicamente, onde o conjunto de comandos (Instrução 1, Instrução
2, ..., Instrução n) serão executadas enquanto uma condição definida se mantiver verdadeira.
O comando while em Python define uma estrutura de repetição do tipo controlada logicamente.
Como mostrado a seguir, a sintaxe do comando while envolve a definição de uma condição que
enquanto verdadeira determinará a repetição e execução do bloco de instruções (Instrução 1,
Instrução 2, ..., Instrução n). Em Python, como visto em capítulos anteriores, a definição de
um bloco de instruções é feita por meio de indentação, onde normalmente se utilizam espaçamentos
ou tabulações.
63
Verdadeira Falsa
Condição
Instrução 1
Instrução 2
...
Instrução n
Figura 20: Estrutura de Repetição controlada logicamente.
...
while <condição>:
Instrução 1
Instrução 2
...
Instrução n
...
Exemplo 1:
Implemente um programa que leia do teclado um valor numérico N do tipo inteiro positivo e no
final imprima todos os valores numéricos que compreendem o intervalo de 0 a N.
Solução:
Para desenvolver uma solução neste exemplo através de uma estrutura de repetição, primeiro
consideraremos a definição das seguintes etapas a serem realizadas (um algoritmo em alto nível):
1. Definir a entrada do valor de N;
2. Declarar a variável item, que será responsável por assumir, a cada iteração, um valor da sequên-
cia que será gerada através da estrutura de repetição e inicializá-la com o primeiro valor da
sequência, ou seja, zero;
3. Definir a estrutura de repetição através do comando while e sua condição de repetição, ou seja,
enquanto o valor da variável for item <= N;
4. No escopo do comando while definir as seguintes instruções:
(a) Imprimir o valor da variável item;
(b) Atualizar o valor da variável, com a fórmula: item = item + 1, ou seja, a cada iteração
a variável item terá seu valor incrementado com um, gerando assim uma sequência de
valores;
64
(c) Verificar a condição de parada. Se a condição item <= N continuar verdadeira, execute
novamente as instruções definidas no bloco do comando while, caso contrário, se a condi-
ção for falsa, saia da estrutura de repetição.
No fluxograma da Figura 21 é apresentado o encadeamento das operações relacionadas às etapas

definidas anteriormente para uma proposta de solução via código para o Exemplo 1 através do uso de
uma estrutura de repetição controlada logicamente.
Figura 21: Fluxograma de execução para o Exemplo 1.
O programa a seguir apresenta uma solução. Primeiro, é efetuada a entrada e atribuição para a
variável N, e na sequência, a declaração da variável item que terá seu valor alternado na estrutura de
repetição, entre o intervalo de inicialização, ou seja, o valor zero, até o valor de N. Depois temos a
declaração da estrutura de repetição while com a condição de sua execução (item <= N).
No bloco da estrutura de repetição da linha 5, temos dois comandos: (a) o comando de saída, que
imprime o valor assumido pela variável item no terminal; e, (b) a instrução responsável por atualizar
o valor da variável item. Este processo de imprimir e atualizar o valor de item se repetirá enquanto
a condição declarada na estrutura de repetição for válida. E assim, serão impressos os valores da
sequência: 0, 1, 2, ..., N .
1 # Entrada
2 N = int(input('Digite o valor de N: '))
4 item = 0
5 while item <= N :
6 print(item)
7 item = item + 1
65
Exemplo 2:
Implemente um programa que leia um valor numérico N e calcule o somatório S = 1 + 2 + 3, ..., N .

No final imprima o resultado do somatório.
Solução:
Neste exemplo, para o desenvolvimento de uma solução, também definiremos um algoritmo que
descreve a sequência de etapas a serem seguidas para a elaboração da estrutura de repetição, que será
responsável por gerar os valores e efetuar o cálculo descrito. Assim as etapas consistem em:
1. Definir a entrada para o valor N;
2. Definir a variável item, que será responsável por assumir cada valor da sequência (1, 2, 3, ..., N )
gerada pela estrutura de repetição, e será inicializada com o primeiro valor da sequência;
3. Definir uma variável responsável por armazenar o valor resultante da soma dos itens a cada
iteração, denominamos como somatorio, e será inicializada com o valor zero;
4. Declarar a estrutura de repetição e sua condição de repetição. A repetição será realizada en-
quanto o valor da variável item for menor ou igual ao valor de N;
5. No bloco do comando while definir as seguintes instruções:
(a) Atualizar o valor do somatorio, com seu valor acrescido do item;
(b) Atualizar o valor do item com incremento de 1 (um), gerando o próximo item da sequência
(item = item + 1);
(c) Verificar a condição de parada. Se a condição definida for válida, as operações declaradas
na estrutura de repetição irão ser novamente executadas, senão a repetição será interrom-
pida;
6. Imprimir o resultado do somatório.
O fluxograma da Figura 22 apresenta a definição de uma sequência de operações a serem realizadas

em uma proposta de solução para o Exemplo 2.
O programa a seguir apresenta uma solução para o exemplo, similar ao Exemplo 1, através do
uso de uma estrutura de repetição. Inicialmente, realizamos a leitura para o valor da variável N.
Posteriormente declaramos e inicializamos a variável item que terá seu valor alternado com um valor
da sequência a cada repetição executada na estrutura e a variável somatorio responsável realizar e
armazenar o resultado da soma dos valores gerados. Em seguida, definimos a estrutura de repetição
com a condição: item <= N . Assim, enquanto os valores da variável item vão sendo alternados é
imposta a condição de que o valor seja menor ou igual ao valor de N e quando: item > N , a estrutura
de repetição será interrompida. Por fim, é realizada a impressão do resultado obtido com o cálculo
efetuado.
66
1 # Entrada
2 N = int(input('Digite o valor de N: '))
3 # Processamento
4 item = 1
5 somatorio = 0
6 while contador <= N:
7 somatorio = somatorio + item
8 item = item + 1
9 # Saída
10 print(f'O somatório é: {somatorio}')
Exemplo 3:
Elabore um programa que leia uma quantidade indeterminada de valores numéricos e no final
imprima o maior valor informado. O programa deverá finalizar a leitura quando o valor 0 for digitado.
Solução:
Neste exemplo, para a elaboração de uma solução consideraremos a sequência de etapas definidas a
seguir. No fluxograma da Figura 23 é apresentado o fluxo das principais operações para uma proposta
de solução através de uma estrutura de repetição controlada logicamente:
1. Declarar a variável que armazenará os valores informados na estrutura de repetição, denomina-

mos como valor e definimos a primeira entrada;
2. Declarar uma variável que armazenará o maior valor informado, denominamos como maior_va-
lor. E inicializamos maior_valor com o valor da variável valor;
67
3. Definir uma estrutura de repetição, com a condição do valor informado ser diferente de zero
(valor != 0). E no bloco da estrutura de repetição:
(a) Definir uma nova entrada de um valor para a variável valor;
(b) Definir uma estrutura de decisão responsável por verificar se o novo valor é maior que
o valor armazenado na variável maior_valor. E no bloco da estrutura de decisão se a
condição for verdadeira:
i. Atualizar o valor da variável maior_valor para o valor da variável valor;
(c) Retornar ao teste da condição da estrutura de repetição. Se for verdadeira executar nova-
mente as instruções definidas no bloco, se for falsa saia da estrutura de repetição;
4. Imprimir o maior valor informado, armazenado em maior_valor.
No programa a seguir apresentamos uma solução para o exemplo. Primeiro, é efetuada a leitura do
primeiro valor informado armazenado na variável valor. Depois, é declarada a variável maior_valor
que será responsável por armazenar o maior valor informado durante as iterações, esta variável é
inicializada com o valor da variável valor. Em seguida, temos a definição da estrutura de repetição
feita com o comando while com a condição para repetição sendo valor != 0. No sub-bloco de
instruções do comando while temos a entrada de um novo valor. Em seguida, a declaração de uma
estrutura de decisão com a condição valor > maior_valor, sendo a condição verdadeira uma
instrução responsável por atualizar o valor da variável maior_valor pelo novo valor informado, e caso
seja falsa a execução retornará na primeira instrução definida na estrutura de repetição solicitando
assim a leitura de novo valor. Estas instruções se repetirão enquanto o valor zero não for informado.
Quando o valor zero for informado, a estrutura de repetição será finalizada e a instrução de impressão
será executada imprimindo a frase com o maior valor informado.
68
1 # Entrada e Processamento
2 valor = float(input('Digite um valor: '))
3 maior_valor = valor
4 while valor != 0:
6 if valor > maior_valor:
7 maior_valor = valor
8 # Saída
9 print(f'O maior valor informado é: {maior_valor}')
5.2 Repetição controlada por contador: comando for

O fluxograma da Figura 24 apresenta um esquema de execução para um estrutura de repeti-
ção controlada por contador, onde o conjunto de comandos (Instrução 1, Instrução 2, ...,
Instrução n) serão executados enquanto o contator não atingir o valor final ou superior. A defini-
ção dos valores de início, passo e fim determinará o número de iterações a serem executadas.
Não Alcançou ou
alcançou ultrapassou
o Fim Início, o Fim
Fim,
Passo
Instrução 1
Instrução 2
...
Instrução n
Figura 24: Estrutura de Repetição controlada por contador.
O comando for pode ser utilizado como uma estrutura de repetição do tipo controlada por conta-
dor. Desta maneira, a declaração do comando será expressa pela definição de uma sequência com os
valores de início, fim e o passo que servirão como base no processo das repetições a serem realizadas.
A sintaxe do comando for em Python é descrita abaixo:

...
for <variável> in <sequência>:
Instrução 1
Instrução 2
...
Instrução n
...
69
A sintaxe apresenta os seguintes itens em destaque:
• for: comando que define a estrutura de repetição;
• <variável>: variável que assume a cada iteração um valor definido pela <sequência>;
• <sequência>: uma sequência enumerável de valores, em Python esta sequência pode ser defi-
nida de variadas formas, aqui usaremos sempre a função range, detalhada na Seção 5.2.1, para
definir os parâmetros de contagem:
– início: valor inicial da sequência (incluído na sequência);
– fim: valor limite do número de itens da sequência (não incluído na sequência);
– passo: valor de passo (ou de incremento) sobre os itens da sequência;
• Instrução 1, Instrução 2, ..., Instrução n: conjunto de instruções declaradas no bloco

do comando for a serem executadas de forma iterativa.
5.2.1 A função range
A função range em Python é normalmente utilizada em conjunto com o comando de repetição for
para representar uma repetição controlada por contador. É responsável por gerar uma sequência de
itens numéricos com base nos argumentos definidos. Pode-se utilizar a função range de três formas:
• range(vi, n, passo): gera uma sequência de números inteiros, sendo vi o primeiro item
da sequência (início); os itens seguintes são definidos conforme o valor de passo; e o item
n − 1 como valor limite (final);
• range(vi, n): gera uma sequência de números inteiros, sendo vi o primeiro item da sequên-
cia (início); os itens seguintes são definidos conforme o valor de passo padrão, passo = 1;
e o último item n − 1 como valor limite (final);
• range(n): gera uma sequência de n números inteiros, sendo por padrão zero o primeiro item
da sequência (início); os itens seguintes são definidos conforme o valor de passo padrão,
passo = 1; e o último item n − 1 como valor limite (final).
1 for i in range(0, 10, 1):
2 print(i)

2 print(i)

2 print(i)
1 for i in range(0, 10):

2 print(i)

2 print(i)
70
1 for i in range(10):
2 print(i)
Crie programas no Thonny com os códigos anteriores e execute para ver os resultados gerados.
Exemplo 4:
Elabore um programa que determine o fatorial de um valor inteiro positivo fornecido como entrada
e, no final, imprima o resultado do cálculo.
Observações:
• 0! = 1;
• n! = n ∗ (n − 1) ∗ (n − 2) ∗ (n − 3) ∗ ... ∗ 3 ∗ 2 ∗ 1
Solução:
No fluxograma da Figura 25 está definida uma sequência lógica de etapas das operações para uma
proposta de solução por meio de uma estrutura de repetição controlada por contador.
O programa a seguir implementa a solução. Primeiro, é efetuada a entrada armazenada na variável

valor para o cálculo do fatorial. Depois declaramos uma variável denominada fatorial responsável
por armazenar o valor do fatorial. Em seguida, a estrutura de repetição com os itens definidos para a
sequência de iteração variando entre 1 e valor, com o valor de incremento igual a 1. A única instrução
do bloco de comandos de repetição é responsável por efetuar a multiplicação do valor contido na
variável fatorial com o valor da variável i que armazena a cada iteração um valor definido na sequên-
cia cujos valores variam no intervalo de 1 a valor durante as iterações da estrutura de repetição. O
71
resultado a cada repetição é armazenado na própria variável fatorial. Chamamos este tipo de cálculo
de cumulativo, ou seja, a cada iteração da estrutura de repetição o valor é atualizado acumulativa-
mente. O valor final é obtido com o término da execução da estrutura de repetição, e impresso através
da função print.
1 # Entrada
2 valor = int(input('Digite um valor: '))
3 # Processamento
4 fatorial = 1
5 for i in range(1, valor + 1, 1):
6 fatorial = fatorial * i
7 # Saída
8 print(f'O fatorial de {valor} é {fatorial}')
Exemplo 5:
Implemente um programa que leia como entrada um valor N e calcule e imprima como saída o
valor da série:
N
X 2i − 1
S=
i
i=1
Solução:
No fluxograma da Figura 26 está definida uma sequência de etapas das operações para uma pro-
posta de solução para o Exemplo 5 através da aplicação de uma estrutura de repetição controlada por
contador.
O programa a seguir implementa a solução. Primeiro é definida a instrução de entrada para a

variável N. Em seguida, a declaração da variável s responsável por armazenar o valor do somatório
72
descrito pela fórmula, a variável é previamente inicializada com o valor zero. Depois é declarada a
estrutura de repetição usando o comando for sobre a sequência de valores definida por: (1, N + 1, 1),
que retornam a cada iteração os itens do intervalo de 1 a N (inclusive). No bloco de comandos de
repetição, temos a instrução responsável por efetuar o cálculo do somatório, onde o valor de i é obtido
através da variação dos itens da sequência ao longo das repetições, atualizando a variável s a cada
iteração da repetição. No final, o valor do somatório é impresso com a função print.
1 # Entrada
2 N = int(input('Digite a quantidade de termos: '))
3 # Processamento
4 s = 0
5 for i in range(1, N + 1, 1):
6 s = s + (2 * i - 1) /i
7 # Saída
8 print(f'O valor da série é {s}')
Exemplo 6:
Implemente um programa que gere e imprima os N termos da série de Fibonacci. O valor de N

deve ser fornecido como entrada.
A série de Fibonacci é uma sequência de números inteiros cujos valores iniciais são 0 e 1, e cada
termo subsequente corresponde à soma dos dois anteriores. Assim, um novo termo pode ser determi-
nado por meio da seguinte fórmula:
Fn = Fn−1 + Fn−2
E os valores iniciais são:
• F1 = 0;
• F2 = 1.
Solução:
O fluxograma da Figura 27 apresenta uma sequência de etapas das operações para a definição de
uma proposta de solução para o Exemplo 6 por meio de uma estrutura de repetição controlada por
contador.
O programa a seguir implementa a solução. Primeiro, é efetuada a entrada e inicialização da va-

riável N. Em seguida são declaradas e inicializadas as variáveis valor0, valor1 e valor2. Na estrutura
de repetição, a variável valor0 será responsável por armazenar o valor corrente da série que, será
impresso com a função print, a cada iteração. As variáveis valor1 e valor2 armazenam os itens ante-
riores da sequência utilizadas para o cálculo do novo valor corrente, e também são atualizadas a cada
iteração de forma a permitir a sequência correta de cálculo dos valores.
73
1 # Entrada
2 N = int(input('Digite o número de termos da série de Fibonacci: '))
4 valor0 = 0
5 valor1 = 1
6 valor2 = 0
7 for i in range(0, N, 1):
8 print(valor0)
9 valor0 = valor1 + valor2
10 valor1 = valor2
11 valor2 = valor0
5.3 Estruturas de repetição aninhadas

O aninhamento de estruturas de repetição consiste em declarar uma estrutura de repetição inter-
namente a outra estrutura de repetição, como, por exemplo:
...
while <condição 1>:
<bloco de instruções A>
while <condição 2>:
<bloco de instruções B>
<bloco de instruções C>
...
74
...
for <variável 1> in range(<intervalo 1>) :
for <variável 2> in range(<intervalo 2>) :
...
Porém, a definição de uma estrutura de repetição aninhada não se restringe somente ao uso for
ou while individualmente, podendo existir construções combinadas de for e while, como definimos a
seguir:
...
for < variável > in range(< intervalo >) :
while <condição>:
...
...
while <condição>:
for < variável > in range(< intervalo >) :
...
Para finalizar, uma estrutura de repetição aninhada não se limita a apenas duas declarações, ou
seja, pode haver qualquer número de repetições aninhadas, caso isso seja necessário para realizar
corretamente uma tarefa.
Exemplo 7:
Implemente um programa que exiba como saída a tabuada de multiplicação de 1 a 9, conforme o

exemplo de saída:
1 x 1 = 1
1 x 2 = 2
...
1 x 8 = 8
1 x 9 = 9
2 x 1 = 2
2 x 2 = 4
...
9 x 8 = 72
9 x 9 = 81
75
Solução:
O fluxograma da Figura 28 apresenta o encadeamento de duas estruturas de repetição para uma

solução do Exemplo 7. A primeira estrutura de repetição define uma sequência de valores para a
variável i no intervalo [1, 9]. E a segunda estrutura define uma sequência de valores para a variável
j no intervalo [1, 9], onde para cada valor assumido pela variável i uma sequência no intervalo [1, 9]
para a variável j é gerada.
A seguir, o código em Python para a solução do exemplo.

3 for j in range(1, 10):
4 produto = i * j
5 print(f'{i} x {j} = {produto}')
Exemplo 8:
Implemente um programa que leia como entrada um número N que determina a quantidade de
linhas a serem impressas na tela, contendo uma string com asteriscos, conforme o exemplo para
N = 5:
*
**
***
****
*****
76
Solução:
O fluxograma da Figura 29 apresenta a sequência das operações contendo duas estruturas de

repetição encadeadas para uma proposta de solução para o Exemplo 8.

1 # Entrada
2 N = int(input('Digite a quantidade de linhas: '))
4 for linha in range(1, N + 1):
5 for coluna in range(1, linha + 1):
6 print('*', end='')
7 print('')
Neste programa tivemos a necessidade de usar um recurso especial do Python na função print.
Por padrão, ela sempre encerra sua tarefa com uma quebra de linha. Como não queremos que
isso ocorra todas as vezes que imprimimos o caractere “*”, usamos um segundo argumento: end=‘’,
indicando que queremos modificar o caractere final do print para um espaço em branco, este caractere
substituirá a quebra de linha que não desejamos imprimir. A quebra de linha deve ser inserida apenas
após a impressão do último “*” da linha corrente, isso será feito apenas com a impressão de um texto
vazio, através da chamada de print(‘’) após o for de colunas, e dentro do for de linhas.
77
Exemplo 9:
Implemente um programa que leia o valor de N e em seguida leia N sequências de valores numé-
ricos não nulos (valor ! = 0). Cada sequência lida é encerrada pela leitura de um valor nulo. Para
cada sequência de números lidos, o programa deve calcular o somatório dos valores pares e imprimir
o resultado deste somatório na tela. Caso o valor numérico não seja inteiro, deve-se arrendondá-lo
para determinar se ele é par ou ímpar (para isso pode-se utilizar a função round).
Solução:
No fluxograma da Figura 30 é definida uma proposta de solução para o Exemplo 9.

1 N = int(input('Digite a quantidade de sequências de números: '))
2 for i in range (1, N + 1):
3 print(f'Sequência {i}')
4 soma = 0
5 valor = int(input('Digite um número: '))
6 while valor != 0:
7 valor = round(valor)
8 if valor % 2 == 0:
9 soma = soma + valor
10 valor = int(input ('Digite um número: '))
11 print(f'O somatório do números pares é {soma}')
78
79
Exercício 1
Escreva um programa que leia um valor inteiro positivo N e calcule o somatório dos valores ímpares
e o somatório dos valores pares presentes no intervalo entre 1 a N. No final imprima o resultado dos
somatórios.
Digite o valor de N: 10
A soma dos valores pares é: 30
A soma dos valores ímpares é: 25
Exercício 2
Implemente um programa que efetue a leitura de uma quantidade indeterminada de valores intei-
ros positivos. Quando um valor inválido (menor ou igual a zero) for informado, o processo de leitura
deverá ser finalizado. No final apresente como saída o menor valor, o maior valor, a média aritmé-
tica dos valores informados. O processamento só será possível se pelo menos 2 valores válidos forem
fornecidos.
Digite um valor: 10
Digite um valor: 20
Digite um valor: 30
Digite um valor: 40
Digite um valor: 50
Digite um valor: -1
O menor valor informado é: 10
O maior valor informado é: 50
A média dos valores é: 30.00
80
Digite um valor: 55
Digite um valor: 25
Digite um valor: 5
Digite um valor: 75
Digite um valor: 95
Digite um valor: 85
Digite um valor: 45
Digite um valor: -1
Digite um valor: 101
Digite um valor: -1
Digite um valor: -1
Quantidade de valores insuficiente
Digite um valor: 10
Digite um valor: -1
Digite um valor: 10
Digite um valor: 20
Digite um valor: -1
81
Exercício 3
Implemente um programa que leia dois valores inteiros não-negativos X e Y. O programa deve
calcular a potência X Y e imprimir o resultado como saída.
Digite o valor da base x: 2
Digite do expoente y: 5
2 ^ 5 = 32
10 ^ 0 = 1
9 ^ 9 = 387420489
Exercício 4
Implemente um programa que leia dois números inteiros positivos x e y quaisquer e calcule o
Máximo Divisor Comum (MDC). E no final imprima o resultado.
Observação: Para saber se um número é divisível por outro, normalmente verificamos se o resto
da divisão é zero. Em Python, isso pode ser feito usando o operador %, que retorna o resto da divisão.
Por exemplo, 9 % 3 resulta em zero, 5 % 2 resulta em 1, 24 % 5 resulta em 4. Assim, para saber se A é
divisível por B, use a expressão lógica A % B == 0.
O MDC é: 30
O MDC é: 25
82
O MDC é: 28
Exercício 5
Elabore um programa que leia um valor inteiro positivo N e no final imprima todos os valores
primos inferiores a N.
Observação: Os números primos são números naturais que possuem apenas dois divisores: 1 e ele
mesmo. Por definição, o número 1 não é considerado primo.
2
3
5
7
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
2
3
83
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97
Exercício 6
Seja a função f (x, y) definida da seguinte maneira:


 cos(y − x) se x < y

f (x, y) = tan(x) se x = y

sen(x − y) se x > y

Faça um programa que avalia os valores de f (x, y) para todas as combinações possíveis para x e
y variando de 0 a N − 1 (número inteiro definido pelo usuário). Os resultados devem ser exibidos
em forma tabular, onde as linhas representam o valor de x e as colunas representam o valor de y.
Considerando N = 4, o exemplo a seguir mostra os valores de x e y e os respectivos resultados
de f (x, y). Veja que serão impressos no terminal apenas o conteúdo dentro das bordas, conforme
ilustrado nos exemplos de execução. N não pode ser menor ou igual a zero e maior do que 20 (veja
exemplos de execução 3 e 4).
x\y 0 1 2 3
0 0 1 2 3
1 1 1 1 2
2 2 1 2 1
3 3 2 1 3
84
Forneça o valor de N: 4
Valores de f(x, y):
0 1 2 3
1 1 1 2
2 1 2 1
3 2 1 3
Valores de f(x, y):
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
1 1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
2 1 2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
3 2 1 3 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
4 3 2 1 4 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
5 4 3 2 1 5 1 2 3 4 5 6 7 8 9 10 11 12 13 14
6 5 4 3 2 1 6 1 2 3 4 5 6 7 8 9 10 11 12 13
7 6 5 4 3 2 1 7 1 2 3 4 5 6 7 8 9 10 11 12
8 7 6 5 4 3 2 1 8 1 2 3 4 5 6 7 8 9 10 11
9 8 7 6 5 4 3 2 1 9 1 2 3 4 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1 10 1 2 3 4 5 6 7 8 9
11 10 9 8 7 6 5 4 3 2 1 11 1 2 3 4 5 6 7 8
12 11 10 9 8 7 6 5 4 3 2 1 12 1 2 3 4 5 6 7
13 12 11 10 9 8 7 6 5 4 3 2 1 13 1 2 3 4 5 6
14 13 12 11 10 9 8 7 6 5 4 3 2 1 14 1 2 3 4 5
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 15 1 2 3 4
16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 16 1 2 3
17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 17 1 2
18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 18 1
19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 19
Forneça o valor de N: -5
N não pode ser menor ou igual a zero!
N não pode ser maior do que vinte!
85
6
Implementação de Funções
CAPÍTULO
Nos capítulos anteriores, aprendemos a usar funções predefinidas em módulos da linguagem Python
para resolver variados problemas. Relembre algumas destas funções que você já utilizou:
• Entrada e saída: input e print;
• Conversão de tipo: int, float e str;
• Cálculos matemáticos: abs, math.sqrt, math.cos, math.ceil e math.pow.
Além das funções predefinidas, podemos definir nossas próprias funções, permitindo reaproveitar
o mesmo bloco de instruções necessário para realizar uma tarefa específica.
As principais vantagens no uso de funções são:
• Códigos mais legíveis, especialmente para programas grandes;
• Modificações no código são mais fáceis, com menor chance de prejudicar o que já foi feito;
• Possibilidade de reaproveitamento da mesma estrutura em diversas seções do código-fonte.
Uma função é um bloco que recebe argumentos de entrada (input), executam comandos (proces-
samento) e retornam valores de saída (output), conforme ilustrado na Figura 31.
Figura 31: Representação ilustrativa de uma função.
86
A implementação de funções implica em dois conceitos importantes:
1. Definição de funções: determina o que a função faz (entradas, processamento e saídas);
2. Chamada de função: determina o momento em que a execução da função deve ser realizada.
Estes conceitos são detalhados nas seções 6.1 e 6.2 a seguir.
6.1 Definição de Função

Para uma função existir, ela precisa ser implementada através da definição explícita dos seus ar-
gumentos de entrada e das instruções necessárias para o processamento e geração das saídas. O
comando para definir funções é def. Abaixo apresentamos a sintaxe utilizada para esse fim:
def <nome da função> ( <argumentos> ):
Instrução 1
Instrução 2
...
Instrução n
return <resultados>
Um breve exemplo de função, que será explorado adiante neste capítulo, é mostrado abaixo:
1 def delta(a, b, c):
2 d = (b**2) - (4*a*c)
3 return d
Neste exemplo, criou-se uma função para calcular o valor de delta, usado na resolução de uma
equação de segundo grau. O <nome da função> é substituído por delta; os <argumentos> são
substituídos por a, b, c; as instruções, necessárias para realizar a tarefa de calcular delta, são
representados pela atribuição d = (b**2) - (4*a*c), que define um valor para a variável d (com
base nos argumentos a, b e c), que será retornada em seguida pela instrução return d. A seguir,
uma definição formal dos componentes de uma função:
• Cabeçalho da função: iniciada pela palavra reservada def, que determina:
– <nome da função>: assim como as variáveis criadas pelo programador, as funções preci-
sam ter um nome. As regras definidas são as mesmas das variáveis;
– <argumentos>: os argumentos determinam nomes de variáveis internas da função, auto-

maticamente criadas quando a função for chamada, e responsáveis por receber os valores
fornecidos como entrada para a função;
• Corpo da função: sequência de instruções que realiza a tarefa necessária e gera os resultados
esperados com a execução da função;
• Resultados: inserida no corpo da função, a cláusula return encerra imediatamente a execução

da função e retorna os resultados de saída esperados na chamada da função.
A utilização dos parênteses, caracteres “(” e “)”, delimitando os argumentos, e do caractere “:”
após o fechamento dos parênteses é obrigatória, assim como a indentação do código que representa o
corpo da função. Esquecer estes detalhes é um erro muito comum.
87
6.2 Chamada de Função
Após definida, uma função só será executada quando for chamada. Para isso, basta escrever o
nome dela no código, com os argumentos entre parênteses. Quando necessário, a chamada da função
é acompanhada de uma atribuição, visando transferir os valores retornados para variáveis. Isso você
já faz há muito tempo, quando usa as funções definidas internamente no Python, exemplificadas no
início deste capítulo (como print, int e abs, por exemplo). Observe o programa abaixo:
1 # Bloco de definição de funções
2 def calculoLinear(x):
3 y = 2 *x + 3
4 return y
5
6 # Bloco do programa principal

7 y1 = calculoLinear(1)
10 print(f'y1 = {y1}, y2 = {y2}, y3 = {y3}!')
Neste programa há a definição da função, entre as linhas 2 e 4, e o programa principal, entre

as linhas 7 e 10. Durante a execução, a definição da função é interpretada e registrada na memória.
O programa começa com a atribuição da variável y1, na linha 7, que chama a função calculoLinear,
passando o valor 1 como argumento. Isso leva a um desvio de fluxo de execução do programa, da
linha 7 para a linha 2, transferindo o valor 1 para a variável x da função. Em seguida, a linha 3 será
executada, criando a variável y, que assumirá o valor 2 ∗ 1 + 3 = 5, já que x = 1 neste momento.
Concluída a atribuição, o próximo comando a ser executado encontra-se na linha 4, cujo resultado é o
retorno do valor da variável y para quem fez a chamada da função. Agora, um novo desvio de fluxo é
realizado, concluindo a execução da função e retornando para a linha 7, de onde a chamada ocorreu.
Neste desvio, o valor de y é o resultado da função, gerando a atribuição y1 = 5 no programa principal.
Esta ação conclui a execução da linha 7, o que faz com que seja realizada a execução das linhas 8 e 9,
seguindo o mesmo padrão. Sendo assim, os resultados obtidos serão y2 = 7 e y3 = 9. O programa se
encerrará após a execução da função print da linha 10, imprimindo a mensagem “y1 = 5, y2 =
7, y3 = 9!” no terminal. Essencialmente, a função é chamada três vezes durante a execução do
programa principal, gerando diferentes valores de saída (5, 7 e 9, por intermédio das variáveis y1, y2
e y3) gerados a partir de três diferentes entradas (1, 2 e 3).
Exemplo 1:
Crie um programa que realize a soma e a subtração de dois números reais fornecidos pelo usuário,
imprimindo o resultado destas operações. Porém, deseja-se que as duas operações sejam realizadas
por duas funções, uma para cada operação. As duas funções recebem os dois números como entrada
e retornam o resultado da operação correspondente.
Solução:
Para solucionar este problema precisamos identificar exatamente o que cada função recebe como
argumentos de entrada e quais resultados são esperados para cada uma delas. O restante, deverá
estar no programa principal. Neste sentido, o enunciado é bem claro, as funções recebem os números
88
e retornam o resultado das respectivas operações sobre eles, então, as entradas (input’s) e as saídas
(print’s) serão realizadas no programa principal.
2 def soma(num1, num2):
3 resultado = num1 + num2
4 return resultado
5
6 def subtracao(num1, num2):

7 return num1 - num2
8

10 num1 = float(input('Digite o primeiro valor: '))
11 num2 = float(input('Digite o segundo valor: '))
12 s = soma(num1, num2)
13 print(f'A soma é {s}')
14 print(f'A subtração é {subtracao(num1, num2)}'}
Aproveitamos este exemplo para explicar vários conceitos relacionados às funções. Primeiro, em
linhas gerais, definimos duas funções que pretendem retornar uma soma e uma subtração, respecti-
vamente. Em um programa principal, fizemos a leitura dos números, as chamadas das funções e a
impressão dos resultados.
Adotamos estratégias diferentes nas duas funções. Para a soma, utilizamos uma variável para
armazenar o resultado da operação na linha 3, que será retornado em seguida na linha 4. Para a
subtração, nós não utilizamos uma variável, simplesmente retornamos o resultado da expressão na
linha 7.
Outro ponto importante é em relação às chamadas das funções. Observe que foi criada uma variável
para a obtenção da soma na linha 12, que depois foi usada para imprimir o resultado no terminal pela
linha 13. Para a subtração, não foi criada uma variável. Já que o objetivo é apenas imprimir o
resultado na tela, a chamada da função subtracao foi feito no print da linha 14, para o resultado
retornado ser diretamente usado na construção da mensagem.
6.3 Escopo de variáveis

No programa, variáveis têm escopos diferentes entre as funções e o programa principal. O escopo
define onde uma variável existe e pode ser usada.
Variáveis de funções têm escopo local, limitado à função onde são criadas. Variáveis do programa
principal têm escopo global, válidas em todo o programa. Funções podem usar variáveis globais, mas
é recomendável passar valores necessários como argumentos. Variáveis globais e locais podem ter o
mesmo nome, mas onde elas coexistem prevalecem as locais, não afetando as globais.
Exemplo 2:
Complemente o Exemplo1 acrescentando novas funções para mais duas operações: multiplicação
e divisão. Similarmente, estas duas novas funções recebem os dois números como argumentos de
entrada e retornam o resultado das respectivas operações.
89
Solução:
Na solução a seguir, optamos por sempre criar variáveis, assim, observarmos algumas questões
relacionadas ao escopo de variáveis.
4 return resultado
5
6 def subtracao(num1, num2):

7 resultado = num1 - num2
8 return resultado
9
10 def multiplicacao(num1, num2):

11 resultado = num1 * num2
12 return resultado
13
14 def divisao(num1, num2):

15 resultado = num1 / num2
16 return resultado
17

21 resultado = soma(num1, num2)
22 print(f'A soma é {resultado}')
23 resultado = subtracao(num1, num2)
24 print(f'A subtração é {resultado}'}
25 resultado = multipicacao(num1, num2)
26 print(f'A multiplicação é {resultado}')
27 resultado = divisao(num1, num2)
28 print(f'A divisão é {resultado}'}
Agora temos as variáveis num1, num2 e resultado de mesmo nome, mas escopos diferentes, no
programa principal e nas funções. Isso significa que, quando uma das funções estiverem em execução,
nós teremos duas variáveis num1, duas variáveis num2 e duas variáveis resultado, todas coexistindo
na memória em algum instante, uma no escopo local da função em execução e outra no escopo global.
6.4 Função sem argumento de entrada

Não é obrigatório que uma função receba argumentos de entrada. Neste caso, ela não dependerá de
nenhum valor “externo” a ela e, ainda assim, ela deverá cumprir com a sua tarefa. Isso é demonstrado
no exemplo a seguir.
90
Exemplo 3:
Crie um programa que realize a soma dois números reais fornecidos pelo usuário, imprimindo o
resultado destas operações. Porém, deseja-se que as entradas dos dois números e o resultado da soma
sejam realizados em uma função. O programa principal apenas chama a função e imprime o resultado.
Solução:
Observe que na descrição da função é determinado que as entradas são feitas pela função e não
pelo programa principal. A solução a seguir cumpre com os requisitos descritos no enunciado.
2 def soma():
6 return resultado
7

9 resultado = soma()
Como a função não recebe argumentos de entrada, na definição temos apenas abre e fecha parên-
teses na linha 2, assim como na chamada da função na linha 9. Adicionalmente, como parte da tarefa
da função é fazer as entradas, os inputs são agora feitos no corpo da função, nas linhas 3 e 4.
6.5 Função sem retorno

Também não é obrigatório que uma função retorne algum valor. Isso é demonstrado no exemplo a
seguir.
Exemplo 3:
Crie um programa que realize a soma dois números reais fornecidos pelo usuário. As entradas
devem ser feitas no programa principal, porém, a operação e a impressão do resultado devem ser
feitos em uma função.
Solução:
5

9 soma(num1, num2)
91
Como a função não retorna valores, a cláusula return não foi utilizada no corpo da função. Ao invés
disso, o corpo da função possui a instrução print na linha 4, visando gerar a impressão do resultado no
terminal. Adicionalmente, como a função não retorna valores, não é efetuada atribuição na chamada
à função, na linha 9.
6.6 Retornando vários valores

Eventualmente é necessário que uma função retorne mais de um valor como resultado. Para fazer
isso em Python, basta colocar todos os valores separados por vírgula na cláusula return e considerar
esta questão na chamada da função. Veja o exemplo a seguir e os comentários na sequência.
Exemplo 5:
Imagine que você quer fazer um programa que calcula as raízes reais de uma equação de segundo
grau. Sabemos que o formato dessas equações é:
ax2 + bx + c = 0
Ainda, sabemos que as raízes são calculadas usando a fórmula de Bhaskara:

√
−b ± ∆
x1,2 =
2a
E por último, sabemos que:

∆ = b2 − 4ac
Criemos um programa com duas funções definidas. Uma para calcular o delta e outra para calcular
as raízes. Como são duas raízes, esta função deverá retornar dois valores. Consideraremos que as
entradas são sempre válidas. Vejamos então o programa:
1 # Bloco de importação de bibliotecas
2 import math
3

5 def delta(a, b, c):
6 d = (b**2) - (4*a*c)
7 return d
8 def raizes(a, b, c):
9 d = delta(a,b,c)
10 x1 = (-b + (math.sqrt(d)))/(2*a)
11 x2 = (-b - (math.sqrt(d)))/(2*a)
12 return x1, x2
13

15 a = int(input('Digite o valor do termo A: '))
16 b = int(input('Digite o valor do termo B: '))
17 c = int(input('Digite o valor do termo C: '))
18 r1, r2 = raizes(a, b, c)
19 print(f'Raízes: {r1:.2f} e {r2:.2f}')
92
Como a função raizes retorna dois valores, um para a primeira raiz e outro para a segunda, observe
que a cláusula return retorna dois valores separados por vírgula na linha 12. Por consequência,
quando esta função é chamada, espera-se também receber dois valores. Assim, duas variáveis são
criadas para receber os valores retornados pela função, na linha 18. Neste caso, a atribuição respeitará
a ordem das variáveis e dos valores retornados, ou seja, r1 = x1 e r2 = x2.
Exercício 1
Elabore uma função que calcula a distância euclidiana entre dois pontos bidimensionais e imple-
mente um programa principal que faça a entrada e saída, gerando o resultado a partir de chamada à
função elaborada. Utilizar x1 , x2 , y1 e y2 como argumentos da função.
Fórmulas:
• P1 = (x1 , y1 )
• P2 = (x2 , y2 )
p
• D= (x1 − x2 )2 + (y1 − y2 )2
Digite o valor da coordenada X1: 1
Digite o valor da coordenada Y1: 2
A distância entre os pontos é 1.41
Exercício 2
Elabore uma função que converte uma entrada de temperatura em Celsius para Fahrenheit e im-
plemente um programa principal que faça a entrada e saída, gerando o resultado a partir de chamada
à função elaborada.
Fórmula:
• TF = (Tc . 95 ) + 32
Digite uma temperatura em Celsius: 37
A temperatura em Fahrenheit é 98.6
Exercício 3
Elabore uma função que converte uma entrada de temperatura em Fahrenheit para Celsius e im-
Fórmula:
93
• TC = (TF − 32). 59
Digite a temperatura em Fahrenheit: 98.6
A temperatura em Celsius é 37.0
Exercício 4
Elabore uma função que calcula a extensão de uma mola vertical com constante elástica k ao pen-
durar um objeto de massa m. Utilize k e m como argumentos da função e implemente um programa
principal que faça a entrada e saída, gerando o resultado a partir de chamada à função elaborada.
Fórmulas:
• Fe = k.x
• Fg = m.g
• g = 9, 807m/s2
Digite a massa do objeto: 5
Digite a constante da mola: 100
A extensão da mola é 0.49 m
Exercício 5
A inclinação de um telhado é dada por um percentual da largura, conforme a Figura 32.
Figura 32: Esquema de inclinação de telhado.
94
Quando o telhado é de “duas águas”, a largura deve ser dividida por dois antes de calcular a
altura. Esses dados podem ser usados para calcular o comprimento do telhado, que é a hipotenusa do
triângulo retângulo.
Elabore duas funções: uma função que calcula o comprimento c1 de um telhado de duas águas e
uma que calcula o comprimento c2 de um telhado de uma água, dadas como entradas uma largura l e
um percentual p.
Implemente um programa principal que realize a entrada e saída, gerando o resultado a partir de
chamada às funções elaboradas.
Fórmulas (uma água):

p.l
• h= 100
√
• c1 = l2 + h2
Fórmulas (duas águas):

p.(l/2)
• h= 100
p
• c2 = 2. (l/2)2 + h2
Observação: Os resultados encontrados devem ser iguais (por semelhança de triângulos, é fácil ob-
servar essa relação).
Digite a largura do telhado: 10
Digite a inclinação percentual: 30
O comprimento do telhado de uma água é 10.44
O comprimento do telhado de duas águas é 10.44
95
7
Estruturas Homogêneas
CAPÍTULO
Em capítulos anteriores, aprendemos quais tipos de dados podem ser armazenados e como utilizar
esses valores em Python. Alguns dos tipos de dados que aprendemos a usar são: inteiros (int);
números de ponto flutuante (float); texto (string); lógicos (bool).
Aprendemos também a armazenar esses tipos de dados em variáveis, conforme a nossa demanda,
como, por exemplo:
1 # Declarações de Variáveis
2 nome = 'Pedro'
3 idade = 15
4 matriculado = True
Contudo, algumas vezes queremos armazenar toda uma coleção de dados na memória durante a
execução de um programa. Suponha que, em um programa, você queira registrar o valor da conta de
luz dos 15 moradores do seu prédio. Somente com as ferramentas ensinadas até o momento, seriam
necessárias 15 variáveis diferentes, cada uma delas contendo o valor da conta de luz de cada morador:
1 conta_m0 = input('Digite o valor da conta: ')
6 ...
96
Além de ocupar muito espaço e tornar o código difícil de ler e entender, essa solução dificulta a
realização de operações sobre os dados em conjunto. Se quisermos calcular a média do valor das
contas de energia, por exemplo, precisaremos escrever manualmente todas as operações, fazendo
(conta_m0 + conta_m1 + ... + conta_m14)/15. Para facilitar o agrupamento de dados durante a
execução do programa, existem estruturas chamadas Vetores e Matrizes.
• Os Vetores são estruturas de uma dimensão, contendo uma lista de dados endereçados de de-
terminado tipo.
• As Matrizes são estruturas de duas dimensões, que armazenam uma tabela de dados endereça-
dos de determinado tipo.
Nesse capítulo, compreenderemos como criar e utilizar vetores e matrizes.
7.1 Vetores
Uma das maneiras mais comuns que utilizamos para agrupar dados é na forma de listas, aqui
denominadas Vetores. Conforme definido anteriormente, vetor é um tipo de dado homogêneo,
portanto, todos os dados armazenados devem ser do mesmo tipo. Na Figura 33 representamos uma
lista de nomes de produtos de um supermercado agrupados em um vetor.
"Arroz" "Feijão" "Carne" "Suco" "Cerveja"
0 1 2 3 4
Figura 33: Representação ilustrativa de um vetor de strings.
Nessas estruturas de dados, cada “caixa” pode receber um valor, como se fosse uma variável. Assim
como as caixas de correio dos apartamentos de um prédio, os contêineres de um vetor são endereça-
dos por meio de um número. Esses endereços são chamados índices (ou posições) dos elementos do
vetor, sendo definidos por números inteiros a partir de zero (0). Sendo assim, podemos expressar um
vetor A com n elementos da seguinte forma:
h i
An = a0 a1 a2 .. an−1
onde: ai representa o elemento de índice i, armazenado no vetor.
Agora que compreendemos o conceito da estrutura de dados vetor, é importante entender como
criá-los e manipulá-los em Python. Embora Python ofereça diversas estruturas de dados compostas,
escolhemos uma estrutura simples para representar vetores em nosso curso: a lista. Em Python,
uma lista pode conter elementos de diferentes tipos, diferenciando conceitualmente de um vetor
tradicional. Entretanto, chamaremos as listas de vetores sempre que seus elementos forem
do mesmo tipo de dados. Em nossos programas, trataremos as variáveis de lista como vetores,
assegurando que armazenem apenas um tipo de valor.
As principais operações com vetores são: (1) Criar um vetor; (2) Acessar ou modificar elementos
de um vetor; (3) Inserir elementos em um vetor; (4) Remover elementos de um vetor; (5) Descobrir
a dimensão de um vetor; (6) ‘Percorrer’ os elementos de um vetor; descritas nas subseções a seguir.
97
7.1.1 Criando um vetor
É possível criar um vetor já com alguns valores alocados ou um vetor vazio. Para isso, utilizamos
parênteses e colocamos todos os valores separados por vírgula. No programa a seguir, seis vetores
foram criados, cada um armazenado em uma variável na memória.
1 vetor_numericos = [ 2, 4.3, 6, 8.2, 10.8 ]
2 vetor_inteiros = [ 2, 4, 6, 8, 10 ]
3 vetor_reais = [ 2.1, 4.3, 6.0, 8.2, 10.8 ]
4 vetor_booleanos = [ True, False, True, True ]
5 vetor_strings = [ 'alpha', 'bravo', 'celta' ]
6 vetor_vazio = [ ]
7.1.2 Acessando ou modificando elementos de um vetor
Um elemento de um vetor tem o comportamento semelhante a uma variável simples de qualquer

tipo. Para tratar de um elemento individualmente, basta utilizar o índice correspondente ao índice
que se deseja acessar ou modificar. Veja como funciona no programa a seguir.
1 V = [ 10, 20, 30, 40, 50 ]
2 print(f'V no endereço 2: {V[2]}')
3 # O programa vai imprimir:
4 # V no endereço 2: 30
5 V[0] = V[0] + 1
6 # O vetor V passa conter: [ 11, 20, 30, 40, 50 ]
7 print(V) # imprime no terminal: [11, 20, 30, 40, 50]
7.1.3 Inserindo elementos em um vetor
Para inserir elementos em um vetor, utilizamos o método append. Esse método recebe o valor a
ser armazenado em uma nova posição no final do vetor, passando assim, a ser o último elemento do
vetor. O programa a seguir mostra como utilizá-lo.
1 V = []
2 V.append(1) # Inserindo o primeiro elemento, com valor 1
3 V.append(50) # Inserindo o segundo elemento, com valor 50
4 V.append(100) # Inserindo o terceiro elemento, com valor 100
5 print(V) # imprime no terminal: [1, 50, 100]
Método é um conceito de programação que define uma sub-rotina (função) aplicada a um objeto.
Observe que o método é aplicado em um objeto existente, por isso, antes de usá-lo, tivemos que criar
um vetor que, neste caso, começou vazio, para depois receber valores.
7.1.4 Removendo elementos de um vetor
Para remover elementos de um vetor, utilizamos o método pop. Esse método recebe o índice do
elemento a ser removido. Além de remover o elemento da posição informada, ela retorna o valor
armazenado. Lembrando que a indexação de vetores começa no índice zero. O programa a seguir
mostra como utilizá-lo.
98
1 V = [ 10, 20, 30, 40, 50 ]
2 x = V.pop(1)
3 # O vetor V passa conter: [ 10, 30, 40, 50 ]
4 print(x) # imprime no terminal: 20
5 print(V) # imprime no terminal: [10, 30, 40, 50]
7.1.5 Descobrindo a dimensão de um vetor
Para descobrir a dimensão de um vetor, utilizamos a função len. Ela retorna o tamanho do vetor
passado como argumento. Veja como utilizá-lo no programa a seguir.
1 V = [ 10, 20, 30, 40, 50 ]
2 tamanho = len(V)
3 # tamanho = 5
7.1.6 Percorrendo os elementos de um vetor
Ao resolver problemas que envolvem vetores, é muito comum a necessidade de se realizar al-
gum tipo de processamento com elementos individuais do vetor. Para isso, na maioria das vezes, é
necessário utilizar laço que definirá uma variável contadora que determina o índice do elemento a
ser manipulado individualmente a cada instante. No exemplo a seguir, cada elemento do vetor será
impresso no terminal, em um padrão de saída diferente do padrão visto anteriormente.
1 V = [ 10, 20, 30, 40, 50 ]
2 print('Todos os valores armazenados no vetor:')
3 for i in range(len(V)):
4 print(f'Elemento de índice {i} = {V[i]}')
No programa anterior manipulamos todos os elementos do vetor por meio de todos os índices
válidos, gerado no laço for pelo uso de range(len(V) (índices iniciando em 0 e indo até o índice do
último elemento – 4, neste caso, já que len(V) retornará 5).
No programa a seguir, será feito o cálculo do somatório dos valores armazenados em índices pares.
1 V = [ 10, 20, 30, 40, 50 ]
2 soma = 0
3 for i in range(0, len(V), 2):
4 soma += V[i]
5 print(f'soma = {soma}')
Observe que, se os índices dos elementos que nos interessa possuem um padrão de contagem,
eles podem ser representados diretamente pelo range no laço for. Dito isso, o que você alteraria no
programa anterior para obter o somatório de todos os elementos de índice ímpar?
As operações aplicadas a vetores mostradas anteriormente são essenciais para resolver a maioria
dos exercícios de programação envolvendo este tipo de estrutura. Nos exemplos a seguir, muitos deles
serão utilizados para ilustrar sua utilidade prática.
99
Exemplo 1 (elementos de uma função linear):
Como sabemos, uma função linear é dada por uma relação do tipo:
f (x) = ax + b
Podemos usar dois vetores, um x e um y para representar pares de pontos pertencentes a essa
função. Analisaremos então como fazer um programa que toma os elementos a e b como entrada,
além de um número de pares desejado, e gera pares de pontos positivos pertencentes a essa função,
armazenando-os na memória e, posteriormente, imprimindo os valores armazenados no terminal.
A estrutura do nosso programa é:
1. Entrada:
(a) Número de pares desejados;
(b) Valores a e b;
2. Processamento:
(a) Gerar vetor X;
(b) Utilizando a, b e X, gerar o vetor Y ;
3. Saída:
(a) Imprimir os pares de pontos usando X e Y .
A seguir, o programa em Python:

1 # Entrada
2 n = int(input('Digite o numero de pares desejado: '))
3 a = float(input('Digite o valor do termo "a": '))
4 b = float(input('Digite o valor do termo "b": '))
5 # Processamento
6 X = []
7 Y = []
8 for x in range(n):
9 X.append(x)
10 Y.append(a*x+b)
11 # Saída
12 print('Pares de pontos:')
13 for x in range(n):
14 print(f'{X[x]} {Y[i]}')
Neste programa aproveitamos uma característica da linguagem Python: a diferença entre letras
maiúsculas e minúsculas. No caso, X (maiúsculo) representa o vetor e x (minúsculo), representa a
coordenada x do ponto. Deve-se tomar muito cuidado para não usar uma variável no lugar da outra
nestas situações.
100
Exemplo 2 (valores acima da média):
No começo desse capítulo falamos sobre o problema da média de vários valores. Aqui considerare-
mos que os valores serão definidos pelo usuário enquanto ele forneça valores maiores do que 0 (zero)
e, ao final, o programa deve imprimir no terminal apenas os valores acima da média.
Uma das maneiras de se resolver este problema é armazenar os valores definidos em um vetor,
calculando a média e, depois disso, imprimindo apenas os valores acima da média calculada.
A seguir, o programa em Python que resolve o problema.

1 valores = [ ]
2 soma = 0
4 while valor > 0:
5 valores.append(valor)
6 soma += valor
8 media = soma / len(valores)
9 for i in range(len(valores)):
10 if valores[i] > media:
11 print(f'[{i}]: {media:%.2f}')
Neste programa, as linhas 1 a 8 realizam as entradas dos valores definidos pelo usuário, os cálculos
necessários para a obtenção da média e o armazenamento de todos os valores na memória. Para isso,
foram criadas e atualizadas variáveis auxiliares (valores, soma, valor e media) e foi feito um laço
de repetição para a realização das entradas (linha 4).
Com a média calculada e os valores armazenados no vetor, as linhas 9 a 11 realizam a impressão

de apenas os valores maiores do que a média. Para isso, foi necessário um laço para processar indi-
vidualmente cada elemento do vetor (linha 9) e uma decisão para avaliar se o elemento do vetor é
maior do que a média (linha 10) para que, neste caso, ele seja impresso no terminal (linha 11).
7.1.7 Exercícios propostos – Vetores
Exercício 1
Utilizando vetores, imprimir uma sequência de pontos indicando a distância de queda livre de um
corpo, dada uma sequência de tempo de t = 0 até um valor dado como entrada pelo usuário. Os
valores impressos devem ter uma precisão de uma casa decimal. Fórmulas:
• g = 9.807m/s2
gt2
• d= 2
Digite o tempo final: 3
t D(t)
0 0.0
101
1 4.9
2 19.6
3 44.1
t D(t)
0 0.0
1 4.9
2 19.6
3 44.1
4 78.5
5 122.6
Exercício 2
Uma função de segundo grau é dada pela fórmula:
f (x) = ax2 + bx + c
Dadas como entradas:
• Valores a, b e c
• Ponto x0 inicial
• Ponto xf final
Criar dois vetores com os dados dos valores da função nesses pontos.
Digite o valor de "a": 2
Digite o valor de "b": 3
Digite o valor de "c": 4
Digite o valor inicial de x: -3
Digite o valor final de x: 3
x f(x)
-3 13
-2 6
-1 3
0 4
1 9
2 18
3 31
102
x f(x)
-5 50
-4 32
-3 18
-2 8
-1 2
0 0
1 2
2 8
Exercício 3
Implemente um programa que realize a entrada de dados de um vetor. Primeiro o usuário fornece
a quantidade de elementos do vetor, em seguida, fornece um valor numérico para cada elemento.
Após preenchido o vetor, os valores armazenados no mesmo devem ser impressos na tela com uma
precisão de uma casa decimal.
Informe a dimensão do vetor: 3
Informe o valor do elemento 0: 3.5
Informe o valor do elemento 1: 7
Elementos do vetor:
3.5
7.0
10.7
Elementos do vetor:
6.9
4.0
103
5.3
2.3
2.3
7.2 Matrizes
Na última seção, aprendemos como criar, manipular e utilizar vetores para os mais diversos fins.
Nessa seção, aprenderemos a utilizar matrizes. Como uma estrutura homogênea, uma matriz é uma
estrutura de n linhas por m colunas, onde cada elemento armazena um dado de um tipo. Sendo assim,
podemos expressar uma matriz A, com dimensão n × m da seguinte forma:
 
a0,0 a0,1 a0,2 .. a0,m−1
 a1,0 a1,1 a1,2 .. a1,m−1 
 
 
An×m =  a2,0 a2,1 a2,2 .. a2,m−1  
: : : .. :
 
 
an−1,0 an−1,1 an−1,2 .. an−1,m−1
Podemos interpretar as matrizes como “vetores de vetores”. Cada uma das n linhas da matriz
corresponderá a um vetor contendo m elementos. Utilizaremos essa interpretação para ilustrar a
maneira de criar, acessar e modificar elementos de uma matriz. Também podemos dizer que um vetor
possui uma dimensão, enquanto uma matriz possui duas dimensões. As linguagens de programação
permitem criar estruturas com mais do que duas dimensões, porém, neste curso exploraremos apenas
uma e duas dimensões.
Assim como nos vetores, existem várias estruturas compostas de dados em Python que podem ser
usadas para representar matrizes. Para manter a simplicidade, seguiremos a mesma abordagem dos
vetores e usaremos a estrutura lista para representar matrizes em Python.
Desta maneira, tudo que aprendemos em relação aos vetores são também válidos para matrizes.
Destacaremos aqui algumas especificidades em relação a três operações com as matrizes: (1) Criar
uma matriz; (2) Acessar ou modificar elementos de uma matriz; (3) Descobrir a dimensão de uma
matriz; descritas nas subseções a seguir.
7.2.1 Criando uma matriz
Trataremos a criação de matrizes a partir de duas estratégias: (a) Criando de maneira fixa; ou (b)
criando a partir de entradas do usuário.
Para criar uma matriz de maneira fixa, existem dois caminhos. Primeiramente, é possível escrever
todos os elementos previamente, usando a atribuição. Veja a seguir:
1 # Criando uma matriz por atribuição
2 A = [ ] # uma matriz vazia é um vetor vazio
3 print(A) # imprimirá: []
4 A = [ [10, 20, 30], [40, 50, 60], [70, 80, 90] ] # matriz de inteiros
5 print(A) # imprimirá: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
Também é possível criar uma matriz usando uma rotina de código, a partir de um valor fixo ou
dado pelo usuário com linhas e colunas. Veja a seguir:
104
1 # Criando matrizes com rotinas:
2 linhas = 3
3 colunas = 3
4 #Criando matriz de zeros
5 matriz = [ ] # inicialmente a matriz está vazia
6 for lin in range(linhas):
7 linha = [ ] # um vetor vazio para representar a linha
8 for col in range(colunas):
9 linha.append(0) # preenchendo valor da coluna
10 matriz.append(linha) # colocando a linha na matriz
Na matriz anterior, tanto as dimensões quanto os valores poderiam ser obtidos por meio de entradas
do usuário, com a função input. Veja a seguir:
1 # Criando uma matriz com entradas do usuário
2 linhas = int(input('Quantidade de linhas: '))
3 colunas = int(input('Quantidade de colunas: '))
4 matriz = [ ]
5 for lin in range(linhas):
6 linha = [ ]
7 for col in range(colunas):
8 elemento = float(input(f'Digite o elemento {lin},{col}: '))
9 linha.append(elemento)
10 matriz.append(linha)
7.2.2 Acessando e modificando elementos em uma matriz
Conforme dito anteriormente, interpretaremos cada linha da matriz como um vetor de vetores.
Sendo assim, os elementos de uma matriz podem ser acessados e modificados de maneira similar aos
vetores. Com isso, o acesso a elementos de uma matriz pode ocorrer de duas formas: (a) uma linha
específica (um índice, de linha); (b) um elemento específico (dois índices, um de linha e outro de
coluna); veja a seguir:
1 A = [ [10, 20, 30], [40, 50, 60], [70, 80, 90] ]
2 print(A[2][1]) #imprime: 80
3 A[0] = [ 15, 25, 35]
4 print(A) # imprime: [[15, 25, 35], [40, 50, 60], [70, 80, 90]]
5 A[2][1] = 85
6 print(A[2][1]) #imprime: 85
7 A[1][0] += 1
8 print(A[1][0]) # imprime: 41
9 A[1][1] = A[1][2] + A[2][2]
10 print(A[1][1]) # imprime: 150
105
7.2.3 Descobrir as dimensões da matriz
Descobrir as dimensões de uma matriz é um pouco diferente do que para os vetores, já que ela tem
duas dimensões. O uso da função len(A) retorna a quantidade de linhas da matriz A. Para obter a
quantidade de colunas, deve-se aplicar len a uma linha qualquer da própria matriz.
1 A = [ [ 10, 20, 30 ], [ 40, 50, 60 ] ]
2 # Número de linhas
3 print( len(A) ) # imprime: 2
4 #Número de colunas
5 print( len(A[0]) ) # imprime: 3
Observe que, se a matriz fosse definida como vazia (A = []), a linha 0 não existiria, portanto,
len(A[0]) resultaria em erro. Sendo assim, é prudente realizar este comando apenas quando a
quantidade de linhas da matriz diferir de zero. O código a seguir trata esta situação de maneira
adequada, criando duas variáveis que, ao final, representam a dimensão da matriz.
1 A = [ ]
2 nLinhas = len(A)
3 if nLinhas > 0:
4 nColunas = len(A[0])
5 else:
6 nColunas = 0
7 print(nLinhas) # imprime: 0
8 print(nColunas) # imprime: 0
Na Seção 7.3.5 definiremos uma função que retornará as dimensões da matriz. Com isso, bastará
utilizar esta função, sem se preocupar com este detalhe.
7.2.4 Exercícios propostos – Matrizes
Exercício 4
Repetir a atividade do Exercício 1, da Seção 7.1.7, utilizando uma matriz para armazenar os dados.
Os dados devem estar separados por colunas.
['t', 'D(t)']
[0, 0.0]
[1, 4.9035]
[2, 19.614]
[3, 44.1315]
106
['t', 'D(t)']
[0, 0.0]
[1, 4.9035]
[2, 19.614]
[3, 44.1315]
[4, 78.456]
[5, 122.5875]
[6, 176.526]
Exercício 5
['x', 'f(x)']
[-5, 39]
[-4, 24]
[-3, 13]
[-2, 6]
[-1, 3]
[0, 4]
[1, 9]
[2, 18]
[3, 31]
[4, 48]
[5, 69]
Digite o valor de "c": -4
['x', 'f(x)']
[-3, 32]
107
[-2, 12]
[-1, 0]
[0, -4]
[1, 0]
[2, 12]
[3, 32]
[4, 60]
[5, 96]
[6, 140]
Exercício 6
Fazer um programa que gere uma matriz quadrada de dimensão n, preenchida em todas as posições
por um valor v. Ambos n e v são valores informados pelo usuário, como entradas. Imprimir o conteúdo
da matriz ao final do programa.
Digite a dimensão da matriz: 4
Digite o valor para preencher os campos: 2
[2, 2, 2, 2]
[2, 2, 2, 2]
[2, 2, 2, 2]
[2, 2, 2, 2]
Digite o valor para preencher os campos: -3
[-3, -3, -3, -3, -3, -3]
[-3, -3, -3, -3, -3, -3]
[-3, -3, -3, -3, -3, -3]
[-3, -3, -3, -3, -3, -3]
[-3, -3, -3, -3, -3, -3]
[-3, -3, -3, -3, -3, -3]
Exercício 7
Implemente um programa que realize a entrada de dados de uma matriz. Primeiro o usuário
fornece as dimensões da matriz, em seguida, fornece um valor textual para cada elemento. Após pre-
enchida a matriz, o usuário fornece uma linha e coluna, e o programa imprime o valor correspondente
a estes índices. Considere que os dados informados são sempre válidos.
Informe a quantidade de linhas: 2
108
Informe a quantidade de colunas: 3
Informe o valor do elemento 0, 0: Sardinha
Informe o valor do elemento 0, 1: Salame
Informe o valor do elemento 0, 2: Picanha
Informe o valor do elemento 1, 0: Coca-cola
Informe o valor do elemento 1, 1: Guaraná
Informe o valor do elemento 1, 2: Pipoca
Informe uma linha: 1
Informe uma coluna: 2
O valor armazenado em [1,2] é Pipoca
7.3 Construindo uma biblioteca de funções úteis

Podemos observar nos exemplos e exercícios sobre vetores e matrizes, apresentados anteriormente,
que muitas tarefas serão sempre iguais. Alguns exemplos: criar um vetor ou matriz com valores padrão
ou valores definidos pelo usuário. Com isso, criaremos algumas funções para compor uma biblioteca
padrão, e toda vez que precisarmos realizar uma destas tarefas, basta chamar a função. A seguir,
apresentamos algumas funções úteis que nos ajudarão a criar programas mais rapidamente. Depois
apresentamos exemplos de utilização da biblioteca criada.
7.3.1 Criando um vetor com valor padrão
Para esta função, consideraremos como argumentos de entrada a quantidade de elementos e o valor
padrão a ser atribuído a todos eles. Basicamente, a função precisa criar um vetor vazio e, em seguida,
repetir a operação de adicionar um novo elemento com o valor padrão, ao final, o vetor criado deve
ser retornado. O código é apresentado a seguir.
1 def criarVetor(qtdElementos, valorPadrao):
2 vetor = [ ]
3 for i in range(qtdElementos):
4 vetor.append(valorPadrao)
5 return vetor
Dada a flexibilidade proporcionada pelo Python, não é necessário se preocupar com o tipo do valor
padrão, basta passar o argumento com o valor desejado, independente de seu tipo.
7.3.2 Criando uma matriz com valor padrão
De forma similar, podemos criar uma matriz com um valor padrão, veja a seguir.
1 def criarMatriz(qtdLinhas, qtdColunas, valorPadrao):
2 matriz = [ ]
3 for lin in range(qtdLinhas):
4 linha = criarVetor(qtdColunas, valorPadrao)
6 return matriz
109
A criação da matriz se baseia na criação de um vetor de valores representando cada linha da matriz.
Sendo assim, utilizamos a função de criação de vetor (linha 4). Primeiro, a matriz é criada como um
vetor vazio (linha 2). Depois, um laço é utilizado para criar cada linha da matriz como um vetor
(linhas 3 e 4), e o vetor da linha é então adicionado à matriz (linha 5). A matriz criada é finalmente
retornada após a execução do laço (linha 6).
7.3.3 Criando um vetor com valores de uma string
Quando fazemos a entrada de dados de um vetor lendo o valor de cada elemento, são feitas várias
entradas do usuário. Em termos práticos, é uma tarefa enfadonha para o usuário fazer várias entradas.
Podemos oferecer a possibilidade do usuário fornecer todos os valores a partir de uma única entrada,
estabelecendo para isso um padrão. Em nosso caso, separaremos os elementos com um caractere
específico, a vírgula “,”. Assim, todos os elementos serão fornecidos em uma string, obtida em um
único input, que precisará ser tratada para preencher o vetor. Apresentamos o código a seguir e logo
depois explicamos mais detalhadamente seu funcionamento.
1 def inputVetor(mensagem, conversao):
2 valores = input(mensagem)
3 resultado = [ ]
4 if valores == '':
5 return resultado
6 valores = valores.split(',')
7 for i in range(len(valores)):
8 valor = conversao(valores[i].strip())
9 resultado.append(valor)
10 return resultado
A função primeiro lê uma entrada do usuário (através do terminal) usando a mensagem passada
como primeiro argumento de entrada (linha 1). No restante do programa, criará um novo vetor
(resultado) contendo os elementos passados na string valores, convertidos através da chamada
à função conversao, passada como segundo argumento (int, float ou str, por exemplo).
Após o input é criado o vetor resultado (linha 3), inicialmente vazio. Em seguida, é feita
uma verificação se valores é uma string vazia, neste caso o vetor resultado, ainda vazio, será
retornado (linhas 4 e 5), encerrando a execução da função. Caso contrário, como todos os valores
são definidos em uma única string, separados pela vírgula, é necessário “dividi-los” de acordo com o
caractere “,” (linha 6). Isto é feito com o uso da função split. Porém, o uso desta função é diferente
daquilo que estamos acostumados, ela funciona sobre um valor textual, com o uso de um ponto
separando o valor da função, que receberá como argumento o texto utilizado para fazer a separação
da string, neste caso a ’,’. Por exemplo, para a string valores = “1, -2, 6, -5”, o resultado
de valores.split(‘,’) será o vetor [“1”, “ -2”, “ 6”, “ -5”].
Observe que, antes da linha 6, o valor da variável valores será uma string, e depois da linha 6
ela passará a armazenar um vetor de strings, resultado do split. Em seguida, o laço for (linhas 7 a
9) vai processar cada valor string contido no vetor valores e inseri-lo no vetor resultado. Agora,
usamos a função strip, também aplicada a uma string de forma similar à split, mas o resultado é a
remoção dos espaços à direita e à esquerda da string, por exemplo, para o segundo elemento o valor
“ -2” resultará em “-2”.
110
Concluindo a função, o vetor resultado, agora preenchido, será retornado (linha 10). Por sim-
plicidade, não faremos validação da conversão dos valores contidos na string valores. Caso a string
seja mal formada, um erro será gerado durante a execução do programa.
7.3.4 Criando uma matriz com valores de uma string
De forma similar à função anterior, criaremos outra função, agora para uma matriz. Neste caso,
separaremos os elementos de cada coluna com a vírgula (“,”) e cada linha com um ponto-e-vírgula
(“;”). Desta vez, consideramos que valores sempre conterá um texto que pode ser transformado
em matriz. Neste caso, a estratégia é muito parecida, mas primeiro deveremos dividir as linhas pelo
caractere “;” e, para cada linha, teremos que dividir as colunas pelo caractere “,”. Apresentamos o
código e o seu funcionamento a seguir.
1 def inputMatriz(mensagem, conversao):
2 valores = input(mensagem)
3 resultado = [ ]
4 if valores == '':
5 return resultado
6 valoresLin = valores.split(';')
7 for lin in range(len(valoresLin)):
8 linha = [ ]
9 valoresCol = valoresLin[lin].split(',')
10 for col in range(len(valoresCol)):
11 valor = conversao(valoresCol[col].strip())
12 linha.append(valor)
13 resultado.append(linha)
14 return resultado
Observe que as primeiras linhas (2 a 5) são exatamente iguais à função inputVetor, e que depois
disso há algumas semelhanças, que detalharemos a seguir.
Ainda comparando as duas funções, a linha 6 se difere apenas pelo caractere usado para a separa-
ção dos valores. Agora usamos “;” para primeiro separar as linhas da matriz. Cada linha é definida
em uma string, com o mesmo padrão de vetor, considerando que cada string representará um vetor
com os valores da linha. Por exemplo, para a string valores = “5, 1; 2, -8”, o resultado de
valores.split(‘;’) será o vetor contendo duas strings: [“5, 1”, “ 2, -8”].
Agora, o for (linhas 7 a 13) vai processar cada elemento do vetor valoresLin, criando, para
cada elemento, um vetor contendo seus valores, de forma muito similar ao que fizemos na função
inputVetor, mas agora, preenchendo o vetor linha e dividindo os valores armazenados na string
valoresLin[lin] (linhas 8 a 12). Finalizando o preenchimento do vetor linha, ele será inserido
na matriz resultado (linha 13).
Concluindo a função, a matriz resultado, agora preenchida, será retornada (linha 14). Nova-
mente, por simplicidade, não faremos validação da conversão dos valores contidos na string valores.
Caso a string seja mal formada, um erro será gerado durante a execução do programa.
111
7.3.5 Dimensões de uma matriz
A última função útil de nossa biblioteca retorna as dimensões da matriz. Veja a seguir.
1 def dimMatriz(matriz):
2 qtdLins = len(matriz)
3 if qtdLins == 0:
4 return 0, 0
5 else:
6 qtdCols = len(matriz[0])
7 return qtdLins, qtdCols
Primeiro obtemos a quantidade de linhas da matriz (linha 2). Em seguida, verificamos se a matriz
é vazia (linha 3). Caso afirmativo, retornamos que a quantidade de linhas e de colunas são, respecti-
vamente, 0 e 0 (linha 4). Caso contrário, obtemos a quantidade de colunas (linha 6) e retornamos a
quantidade de linhas e de colunas obtidas, respectivamente, qtdLins e qtdCols (linha 7).
7.3.6 Criando e usando a biblioteca
Criar a biblioteca consiste em salvar todas as definições de funções em um arquivo “.py”, como por
exemplo “biblioteca.py”. E, para usa-la, você pode importar o arquivo de biblioteca em seu programa,
um outro arquivo “.py”, como por exemplo “teste.py”. No entanto, esta forma simples de utilização da
biblioteca exige que os dois arquivos estejam juntos, na mesma pasta do computador. Porém, isso já é
suficiente para que possamos resolver os exercícios que serão propostos, por isso, não aprofundaremos
neste assunto.
No programa a seguir testamos nossas funções, salvas no arquivo “biblioteca.py”. Criamos o ar-
quivo “teste.py” na mesma pasta do arquivo da biblioteca. Nele, importamos o arquivo da biblioteca,
com a instrução from biblioteca import * (linha 1). Isto significa que, a partir deste ponto,
podemos utilizar todas as funções implementadas na biblioteca. Um exemplo de execução deste pro-
grama você pode ver logo em seguida.
1 from biblioteca import *
2 v = criarVetor(5, 3)
3 print('Conteúdo do vetor:')
4 print(v)
5 m = criarMatriz(2, 3, 0.5)
6 print('\nConteúdo da matriz (em linha):')
7 print(m)
8 v = inputVetor('Defina os valores do vetor: ', float)
9 print('\nConteúdo do vetor:')
10 print(v)
11 m = inputMatriz('Defina os valores da matriz', str)
12 print('\nConteúdo da matriz (tabular):')
13 qtdL, qtdC = dimMatriz(m)
14 for l in range(qtdL):
15 print(m[l])
112
Exemplo de execução:
Conteúdo do vetor:
[3, 3, 3, 3, 3]
Conteúdo da matriz (em linha):

[[0.5, 0.5, 0.5], [0.5, 0.5, 0.5]]
Defina os valores do vetor: 1.0, 1.2, 1.4

Conteúdo do vetor:
[1.0, 1.2, 1.4]
Defina os valores da matriz: José, Maria ; José Maria, Maria José

Conteúdo da matriz (tabular):
['José', 'Maria']
['José Maria', 'Maria José']
7.4 Exercícios propostos

Resolva os exercícios a seguir fazendo uso da biblioteca de funções úteis.
Exercício 8
Implemente um programa para contabilizar a pontuação em uma Gincana, seguindo o algoritmo:
1. Pergunte a quantidade de equipes.
2. Crie um vetor, cada elemento representa uma equipe e possui pontuação inicial zero.
3. Pergunte o índice da equipe que pontuou.
4. Enquanto o índice for válido:
(a) Pergunte a quantidade de pontos.
(b) Atualize, de forma cumulativa, a pontuação da equipe no vetor.
(c) Pergunte o índice da equipe que pontuou.
5. Imprima o conteúdo do vetor.
Tanto os índices quanto a pontuação devem ser valores inteiros.
Informe a quantidade de equipes: 5
Informe o índice da equipe: 2
Informe a quantidade de pontos: 10
113
Informe o índice da equipe: -1
Pontuação das equipes:
[30, 5, 35, 0, 0]
[0, 7, 0, 0, 0, 4]
Exercício 9
Implemente um programa para ajudar na leitura de consumo de energia feito pela CEMIG nos
imóveis de uma cidade. O registro é feito pelo mapeamento de ruas e imóveis e armazenado em uma
matriz, as linhas representam as ruas e as colunas representam os números dos imóveis. Primeiro
o programa solicita que seja fornecida como entrada uma string que contenha os valores iniciais,
preenchendo uma matriz com estes valores. Em seguida, o programa pergunta quantas novas leituras
individuais serão fornecidas. Para cada leitura individual, o programa pergunta o índice da rua (linha),
o índice do imóvel (coluna), e o valor lido pelo funcionário. O programa deve então fornecer a
diferença da última leitura referente ao imóvel do valor lido pelo funcionário, e em seguida atualizar
a matriz com o valor lido para o imóvel.
Tanto os índices quanto as leituras devem ser valores inteiros. Não é necessário validar dados de
entrada, considere que serão sempre válidos.
Informe os valores iniciais: 5, 10, 4 ; 6, 3, 8 ; 7, 8, 2
Informe a quantidade de novas leituras: 5
Leitura 1:
- Informe o índice da rua: 0
- Informe o índice do imóvel: 2
- Informe o valor lido: 6
- Diferença: 2
Leitura 2:
114
- Diferença: 4
Leitura 3:
- Diferença: 3
Leitura 4:
- Diferença: 0
Leitura 5:
- Diferença: 2
Exercício 10
Implemente um programa similar ao anterior, Exercício 9. Mas, agora a entrada de cada leitura
deve ser feita por um único input, armazenando os valores em um vetor, onde, índice 0 representa a
rua, índice 1 representa o imóvel e índice 2 representa o valor lido. O restante do programa funciona
da mesma maneira, gerando o mesmo resultado, conforme o exemplo de execução a seguir.
Informe a leitura 1: 0, 2, 6
- Diferença: 2
- Diferença: 4
- Diferença: 3
- Diferença: 0
- Diferença: 2
115
8
Estruturas Heterogêneas
CAPÍTULO
No capítulo anterior trabalhamos com vetores e matrizes, que se caracterizam pela possibilidade de
armazenar diversos valores de um mesmo tipo de dados (por este motivo, denominadas homogêneas).
De forma similar, quando uma determinada estrutura de dados pode ser composta por valores de tipos
de dados diferentes, temos uma estrutura de dados heterogênea.
Por exemplo, para representar o cadastro de empregados, poderia ser implementada uma estrutura
de dados composta pelos seguintes campos: nome, idade, endereço, telefone, salário e cargo. Nesse caso
os campos idade, telefone e salário devem ser do tipo numérico, enquanto os demais campos devem
ser do tipo textual.
Basicamente, uma estrutura de dados heterogênea pode ser definida como uma coleção de uma
ou mais variáveis relacionadas (campos), onde cada variável pode ser de um tipo distinto. Esta
estrutura heterogênea também é conhecida como registro. Então, um registro contém campos, estes,
por sua vez, possuem valores associados, conforme a representação do exemplo dado anteriormente:



 nome = < valor textual >




 idade = < valor numérico >

endereco = < valor textual >
empregado


 telefone = < valor numérico >




 salario = < valor numérico >

 cargo = < valor textual >
Nesse capítulo, compreenderemos como criar e utilizar registros.
116
8.1 Sintaxe básica
Assim como ocorreu com vetores e matrizes, escolheremos uma estrutura com sintaxe simples,
mas que permita representar o conceito de estruturas heterogêneas através de registros na linguagem
Python na forma como foi definida conceitualmente na seção anterior. Esta estrutura em Python se
chama dicionário, e permite manipular pares chave-valor, conforme o exemplo a seguir.
Exemplo 1:
O código a seguir cria uma variável chamada empregado que será utilizada para armazenar os
dados de um empregado com os campos listados anteriormente. Inicialmente, todos os campos do
tipo textual foram definidos com valor de uma string vazia ‘’ e os campos numéricos com o valor
zero. Porém, no momento de criação os valores podem ser definidos conforme sua necessidade. Ou
seja, se você já possui nome, idade, etc, pode fornecê-los no momento da criação da variável.
1 empregado = {
2 "nome": '',
3 "idade": 0,
4 "endereco": '',
5 "telefone": 0,
6 "salario": 0,
7 "cargo": ''
8 }
Pela representação anterior, o registro empregado é:



 nome = ‘0




 idade = 0
endereco = ‘0

empregado


 telefone = 0




 salario = 0
= ‘0

 cargo
É importante destacar que, após a criação de um registro, empregado é uma variável que pode
ser manipulada em qualquer parte do programa. Para fazer o acesso ao conteúdo de um campo do
registro, deve-se usar o nome do registro seguido por colchetes “[]” e dentro dos colchetes o nome do
campo. Perceba que há uma grande semelhança com vetores e matrizes, porém, ao invés de índices,
temos a chave, que no caso corresponde ao nome do campo em questão. Em Python, a chave pode
ser representada por outros tipos de dados, não apenas string, como faremos uso aqui. No exemplo
a seguir mostramos como modificar o registro criado anteriormente, para definir todos os campos de
forma individual.
1 empregado["nome"] = 'Joaquim'
2 empregado["idade"] = 25
3 empregado["endereco"] = 'Rua A'
4 empregado["telefone"] = 53535353
5 empregado["salario"] = 1212.12
6 empregado["cargo"] = 'Vendedor'
117
Python diferencia letras maiúsculas de minúsculas, se você tentar acessar empregado[“Nome”]
ou empregado[“NOME”], por exemplo, ocorrerá um erro, pois estas chaves não existem no registro.
Após as alterações feitas anteriormente, o registro pode ser representado desta maneira:



 nome = ‘Joaquim0




 idade = 25
‘RuaA0

endereco =
empregado


 telefone = 53535353




 salario = 1212.12
= ‘V endedor0

 cargo
Exemplo 2:
Neste exemplo criamos um registro para representar um livro definindo os dados na atribuição.
Depois fazemos acesso de leitura, para imprimir seus valores na tela. Como o acesso ao registro
estará dentro do print, para diferenciar as aspas da mensagem das aspas da chave do registro, usamos
aspas simples para delimitar a mensagem e as aspas duplas para delimitar a chave do registro.
1 livro = {
2 "titulo": 'Algoritmos e lógica de programação',
3 "autor": 'Marco Antonio Furlan de Souza',
4 "ano": 2005,
5 "editora": 'Cenage Learning',
6 }
7
8 print('Dados do livro: ')

9 print(f'- Título: {livro["titulo"]}')
10 print(f'- Autor: {livro["autor"]}')
11 print(f'- Ano: {livro["ano"]}')
12 print(f'- Editora: {livro["editora"]}')
Exemplo 3:
Agora nós apresentamos um programa que modifica o registro após a sua criação, mas agora inse-
rindo um novo campo. Uma vez que o dicionário existe, podemos inserir novos campos simplesmente
com uma atribuição usando a chave do novo campo.
1 livro = {
2 "titulo": 'Algoritmos e lógica de programação',
3 "autor": 'Marco Antonio Furlan de Souza',
4 "ano": 2005,
5 "editora": 'Cenage Learning',
6 }
7
8 livro["isbn"] = '978-8575227183'
9
10 print('Dados do livro: ')
118
11 print(f'- Título: {livro["titulo"]}')
12 print(f'- Autor: {livro["autor"]}')
13 print(f'- Ano: {livro["ano"]}')
14 print(f'- Editora: {livro["editora"]}')
15 print(f'- ISBN: {livro["isbn"]}')
8.2 Vetores e matrizes de registros

Em programação de computadores, podemos criar uma estrutura de dados que combina registros
e vetores ou registros e matrizes a fim de resolver problemas mais complexos. Essa situação acontece,
quando temos que armazenar, em nosso programa, vários registros que possuem a mesma estrutura.
Por exemplo, armazenar dados de diversos alunos. Nesse caso, os dados de cada aluno será armaze-
nado em um registro, assim, temos vários registros diferentes com a mesma estrutura.
Exemplo 4:
Neste exemplo criaremos um programa que armazena o nome, a nota e a frequência dos alunos de
uma turma em um único vetor através do registro aluno. As informações são fornecidas pelo usuário.
Em seguida, ele imprime os alunos aprovados, que possuem nota maior ou igual a 6 e frequência
maior ou igual a 75.
1 N = int(input('Quantidade de alunos: '))
2 alunos = [ ]
3 for a in range(N):
4 aluno = { }
5 print(f'Dados do aluno {a+1}:')
6 aluno["nome"] = input('- Nome: ')
7 aluno["nota"] = float(input('- Nota: '))
8 aluno["freq"] = int(input('- Frequência: '))
9 alunos.append(aluno)
10 print('\nAlunos aprovados:')
11 for a in range(N):
12 if alunos[a]["nota"] >= 6 and alunos[a]["freq"] >= 75:
13 print(f'- {alunos[a]["nome"]}')
Observe que inicialmente criamos um vetor vazio chamado alunos. Depois temos um laço for
para fazer a entrada de dados de cada aluno, inserindo-os individualmente no vetor. Para cada aluno,
a primeira ação é criar um registro vazio, sem nenhum campo, de forma similar à criação do vetor
vazio, a diferença é o uso das chaves: aluno = { }. Estabelecemos aqui um padrão, o vetor, que
representa vários alunos, está no plural alunos, e o registro que representa um único aluno, está no
singular aluno. Em seguida fazemos três entradas de dados, uma para cada campo, criando novos
campos para o registro vazio criado no início do laço. Por fim, o registro aluno é adicionado ao
vetor alunos. Com o término da execução do laço temos todos os dados de alunos armazenados no
vetor, passamos então a imprimir os alunos aprovados. Um novo laço é iniciado para avaliar todos
os alunos, imprimindo apenas os alunos aprovados. Para isso utilizamos uma decisão, verificando
se o aluno a (variável contadora do laço, que determina os índices válidos do vetor), possui nota
maior do que 6 e frequência maior do que 75. Observe que são duas condições ligadas pelo operador
119
lógico and e que, para obter a nota do aluno precisamos acessar o índice do vetor e o nome do
campo (alunos[a]["nota"]) e para obter a frequência do aluno precisamos acessar o índice do
vetor e o nome do campo (alunos[a]["freq"]). Construindo a expressão lógica do if com estes
componentes e as operações relacionais necessárias para atender à condição de aprovação. Caso a
condição resulte em verdadeiro, deve-se imprimir o nome do aluno, caso contrário, não tem nada a
ser feito. De forma similar, para obter o nome do aluno precisamos acessar o índice do vetor e o nome
do campo (alunos[a]["nome"]).
A seguir um exemplo de execução do programa:

Quantidade de alunos: 3
Dados do aluno 1:
- Nome: João
- Nota: 6.5
- Frequência: 65
Dados do aluno 2:
- Nome: Maria
- Nota: 10
- Frequência: 95
Dados do aluno 3:
- Nome: José
- Nota: 3.8
- Frequência: 100
Alunos aprovados:
- Maria
O uso de registro em matrizes acontece de forma bastante similar, a diferença é que para matriz
precisamos acessar dois índices antes de acessar o nome do campo. Como exemplo, imagine que você
agora esteja representando o desempenho dos alunos em variadas disciplinas, para cada disciplina
uma nota e uma frequência. Você pode representar os alunos nas linhas e as disciplinas nas colunas.
Para obter a nota do aluno de índice de linha lin para a disciplina de índice de coluna col, você po-
deria acessar: alunos[lin][col]["nota"]. O termo alunos[lin][col] representa o acesso
a um elemento específico da matriz, e o termo ["nota"] representa o acesso ao campo nota deste
elemento da matriz.
8.3 Registros como argumento ou retorno de função

Como os registros são armazenados em variáveis, assim como vetores e matrizes, eles podem ser
utilizados como argumentos ou valor de retorno de uma função.
Exemplo 5:
Neste exemplo criamos uma função que recebe um registro que representa um retângulo com os
campos base e altura e retorna um registro de medidas contendo o perímetro e a área do retângulo.
1 def calcRetangulo(retangulo):
2 resultado = { }
3 resultado["perímetro"] = 2 * (retangulo["base"] + retangulo["
120
altura"])
4 resultado["área"] = retangulo["base"] * retangulo["altura"]
5 return resultado
6
7 ret = { "base": 10, "altura": 10 }

8 med = calcRetangulo(ret)
9 print(f'O perímetro do retângulo é {med["perímetro"]}')
10 print(f'A área do retângulo é {med["área"]}')
Observe que, como a chave do registro é do tipo textual, pode-se utilizar caracteres acentuados
sem nenhum problema. Porém, é aconselhável que se estabeleça padrões nas definições de nomes de
campos, uma boa prática é optar por não usar caracteres acentuados ou especiais. Mais importante
aqui é observar que os nomes dos campos usados dentro e fora da função devem ser exatamente
iguais, diferentemente dos nomes das variáveis.
Veja o resultado da execução do programa anterior:

O perímetro do retângulo é 40
A área do retângulo é 100
8.4 Exercícios propostos
Exercício 1
Implemente uma versão do Exemplo 4 para armazenar os dados de alunos em diferentes discipli-
nas. Sendo assim, deve-se utilizar uma matriz para armazenar os dados, em cada elemento da matriz
será armazenada a nota e a frequência. As linhas representam alunos e as colunas representam dis-
ciplinas, que serão referenciadas pelos seus respectivos índices. Primeiramente o programa pergunta
a quantidade de alunos e disciplinas, em seguida pergunta nota e frequência para cada elemento da
matriz. Depois disso, para cada aluno, o programa deve identificar a disciplina com a maior nota, im-
primindo a nota com precisão de uma casa decimal e a frequência nesta disciplina. Notas são valores
reais e frequência inteiros.
Digite a quantidade de alunos: 2
Digite a quantidade de disciplinas: 2
Dados do aluno 1:
- Dados da disciplina 1:
- Digite a nota: 4
- Digite a frequência: 4
- Digite a nota: 3
Dados do aluno 2:
121
- Digite a nota: 2
- Digite a nota: 1
Maiores notas e frequências:

- Aluno 1: nota = 4.0; frequência = 4
Dados do aluno 1:
- Digite a nota: 1
- Digite a nota: 2
Dados do aluno 2:
- Digite a nota: 3
- Digite a nota: 4
Dados do aluno 3:
- Digite a nota: 5
- Digite a nota: 6
Maiores notas:
122
Exercício 2
Implemente um programa que receba informações sobre retas, armazenando-as em um vetor. Pri-
meiramente pergunta-se quantas retas serão informadas, e em seguida pede-se as coordenadas dos
dois pontos (A e B) que definem cada reta. Uma reta deve ser representada por um registro que
contenha dois campos, representando os pontos. Cada ponto é um registro que possui as coordena-
das X e Y como campos. Depois que o vetor estiver totalmente preenchido, você deverá calcular e
imprimir o comprimento de cada reta armazenada no vetor. O comprimento é obtido por meio de
uma função, definida em seu programa, que recebe a reta como argumento e retorna o comprimento:
p
C = (BX − AX )2 + (BY − AY )2 . As coordenadas X e Y são números reais, e a saída das medidas
deve possuir precisão de 2 casas decimais. Dicas: (1) para obter o ponto B de uma reta, você deve
usar: reta["B"]; (2) para obter a coordenada X do ponto B desta mesma reta, você deve usar:
reta["B"]["X"], uma vez que temos aqui um registro “dentro” de outro registro.
Informe a quantidade de retas: 1
Reta 1:
- Informe a coordenada X de A: 1
- Informe a coordenada Y de A: 4
- Informe a coordenada X de B: 1
- Informe a coordenada Y de B: 1
Medidas das retas:

- Reta 1: 3.00
Reta 1:
- Informe a coordenada X de A: 3.5
- Informe a coordenada Y de A: 2.1
- Informe a coordenada Y de B: 8.6
Reta 2:
- Informe a coordenada X de A: -3
- Informe a coordenada X de B: 5.8
- Informe a coordenada Y de B: -9.1
Medidas das retas:

- Reta 1: 6.96
- Reta 2: 13.32
123
Exercício 3
Crie um registro para armazenar os dados de um evento, que deve conter os campos: nome, local,
preço e lotação. Implemente um programa que receba informações de N eventos e, em seguida,
informe o nome, o preço e arrecadação máxima do evento mais barato e do evento mais caro. Os
valores reais devem ser impressos com precisão de duas casas decimais.
>>> %Run -c $EDITOR_CONTENT

Informe a quantidade de eventos: 2
Dados do evento 1:
- Informe o nome: Concerto
- Informe o local: CineArt
- Informe o preço (R$): 125.50
- Informe a lotação: 100
Dados do evento 2:
- Informe o nome: Festival de Jazz
- Informe o local: Clube
Mais Barato:
- Festival de Jazz, preço: R$ 85.50, arrecadação máxima: R$ 17100.00
Mais Caro:
- Concerto, preço: R$ 125.50, arrecadação máxima: R$ 12550.00
>>>
Exercício 4
Crie um registro para armazenar os dados de um eletrodoméstico de uma casa, que deve conter os
campos: nome, potência (em kW) e tempo diário de funcionamento (em h). Implemente um programa
que receba informações de x eletrodomésticos. O programa deve calcular e mostrar o consumo total
(kWh) da sua casa e o consumo relativo de cada eletrodoméstico (%). Dicas: (1) o consumo de
energia elétrica é igual ao produto da potência do aparelho eletrodoméstico e o tempo em que esse
aparelho funciona e (2) consumo relativo (%) de um aparelho é igual ao seu consumo multiplicado
por 100, e depois, dividido pelo consumo total da casa.
Forneça a quantidade de eletrodomésticos: 4
Dados do eletrodoméstico 1:
- Forneça o nome: Televisão
- Forneça a potência (kW): 200
- Forneça o tempo diário (h): 5
- Forneça o nome: Geladeira
124
- Forneça o nome: Chuveiro
- Forneça o tempo diário (h): 1.5
- Forneça o nome: Máquina de lavar roupa
Consumo total (kWh): 22150.0

Consumo relativo:
Televisão: 4.51 %
Geladeira: 37.92 %
Chuveiro: 27.09 %
Máquina de lavar roupa: 30.47 %
Exercício 5
Considerando um vetor t representado no domínio tridimensional por t = (t1, t2, t3), onde
t1, t2 e t3 são suas componentes nas direções x, y e z do sistema Cartesiano, respectivamente. Crie um
registro para armazenar as componentes de um vetor a ser representado no domínio tridimensional.
Implemente uma função para calcular e retornar o resultado do produto vetorial entre dois vetores.
Faça um programa que realiza as seguintes tarefas: faz a leitura dos vetores u = (u1, u2, u3) e
v = (v1, v2, v3), chama a função elaborada para calcular produto vetorial entre estes vetores e,
por fim, mostra o vetor resultante deste produto vetorial. Dica: o produto vetorial entre os vetores
u = (u1, u2, u3) e v = (v1, v2, v3) é dado por u x v = (u2 * v3 u3 * v2, u3 *
v1 u1 * v3, u1 * v2 u2 * v1 ).
vetor u = (u1, u2, u3):
- Informe o componente u1: 2
vetor v = (v1, v2, v3):
- Informe o componente v1: 3
Resultado:
u x v = (36.00, -30.00, 6.00)
Exercício 6
Crie um registro para armazenar os dados de um funcionário, que deve conter campos que permita
informar o nome completo, cargo que ocupa, valor pago por hora extra, valor do salário base e horas
125
trabalhadas no mês. Crie também uma função que recebe uma lista de funcionários e retorna o valor
total da folha de pagamentos da empresa naquele mês. Implemente um programa que receba os
dados de N funcionários utilizando o registro criado e o número de dias úteis de trabalho no mês em
questão. Este programa deverá imprimir o valor total da folha de pagamentos da empresa usando
como resposta o cálculo da função elaborada. Dicas: (1) o tempo que excede 8 horas de trabalho por
dia é considerado hora extra, (2) a folha total de pagamentos da empresa é soma do valor a ser pago
do salário de cada funcionário.
Digite a quantidade de funcionários: 2
Digite o número de dias úteis do mês em questão: 10
Dados do funcionário 1:
- Digite o nome: Lucas
- Digite o cargo: Motorista
- Digite o valor pago por hora extra: 45.5
- Digite o valor do salário base: 1780
- Digite o valor de horas trabalhadas por mês: 80
- Digite o nome: Amanda
- Digite o cargo: Gerente
- Digite o valor pago por hora extra: 70
Total da folha de pagamento: 6180.00
Exercício 7
Crie um registro que represente um número complexo, onde um número complexo z é escrito da
seguinte forma: z = a + b * i tal que i * i = -1. Logo, os números reais a e b devem ser
armazenados como campos deste registro. Realize a implementação de uma função que encontra em
uma lista de números complexos aquele que possui o maior módulo. Esta função deverá retornar
a localização do número encontrado na lista e o valor do seu módulo. Implemente um programa
que realiza a leitura de N números complexos empregando o registro criado e, em seguida, mostra o
número complexo que atende a função elaborada com seu respectivo módulo. Dica: o módulo de um
número complexo z = a + b * i é calculado por: |z| = sqrt(a * a + b * b), onde sqrt
é a função que calcula a raiz quadrada de um número, disponível na biblioteca math.
Forneça a quantidade de números complexos: 2
Número complexo z1 = a + b * i
- Forneça a: 1
- Forneça b: 1
- Forneça a: 2
- Forneça b: 2
126
Resultado:
z2 = 2.0 + 2.0 * i, |z| = 2.828
127
Soluções dos Exercícios Propostos
9.1 Exercícios do Capítulo 2: Variáveis e Expressões
Exercício 1
9 CAPÍTULO
Um prêmio em dinheiro será dividido entre três ganhadores de um concurso.
• O primeiro ganhador receberá 46% do valor total do prêmio
• O segundo ganhador receberá 32% do valor total do prêmio
• O terceiro receberá o restante
Escreva um programa que defina uma variável com o valor 780000 para o prêmio e, em seguida,
calcule e imprima a quantia que deve ser distribuída para cada um dos ganhadores.
O primeiro ganhador deve receber R$:
358800.0
O segundo ganhador deve receber R$:
249600.0
O terceiro ganhador deve receber R$:
171600.0
Solução:
1 premio = 780000
2 primeiro_ganhador = premio * 46 / 100
3 segundo_ganhador = premio * 32 / 100
128
4 terceiro_ganhador = premio - primeiro_ganhador - segundo_ganhador
5 print('O primeiro ganhador deve receber R$:')
6 print(primeiro_ganhador)
7 print('O segundo ganhador deve receber R$:')
8 print(segundo_ganhador)
9 print('O terceiro ganhador deve receber R$:')
10 print(terceiro_ganhador)
Exercício 2
Faça um programa que defina a largura e a altura de uma parede em 2.8 e 5.2 metros em duas
variáveis. Posteriormente, calcule a sua área e a quantidade de tinta necessária para pintá-la, sabendo
que cada litro de tinta pinta uma área de 2 metros quadrados.
Área da parede em metros quadrados:
14.559999999999999
Litros de tinta necessários para pintar essa parede:
7.279999999999999
Solução:
1 altura = 2.8
2 largura = 5.2
3 area = altura * largura
4 quantidade_tinta = area / 2
5 print('Área da parede em metros quadrados')
6 print(area)
7 print('Litros de tinta necessários para pintar essa parede')
8 print(quantidade_tinta)
Exercício 3
Escreva um programa que defina, em variáveis, a quantidade de Km percorridos por um carro

alugado (com valor 879) e a quantidade de dias pelos quais ele foi alugado (com valor 6). Calcule o
preço a pagar, sabendo que o carro custa R$ 60,00 por dia e R$ 0,15 por Km rodado.
O cliente deve pagar R$:
491.85
Solução:
1 km_percorridos = 879
2 numero_diarias = 6
129
3 custo_km_percorridos = km_percorridos * 0.15
4 custo_diarias = numero_diarias * 60
5 custo_total = custo_km_percorridos + custo_diarias
6 print('O cliente deve pagar R$:')
7 print(custo_total)
Exercício 4
Faça um programa que defina uma variável com área de um quadrado no valor de 256 e calcule o
valor de cada lado do quadrado.
Cada lado tem comprimento igual à:
16.0
Solução:
1 import math
2 area_quadrado = 256
3 comprimento_quadrado = math.sqrt(area_quadrado)
4 print('Cada lado tem comprimento igual à:')
5 print(comprimento_quadrado)
Exercício 5
Faça um programa que defina uma variável com o raio de um círculo no valor de 1.2 e calcule sua
área. Utilize a fórmula:
area = π ∗ (raio2 )
Utilize a constante π definida na linguagem.
Ao final, o seu programa deve apresentar o valor calculado da área do círculo.
A área do círculo é:
4.523893421169302
Solução:
1 import math
2 raio_circulo = 1.2
3 area_circulo = math.pi * raio_circulo ** 2
4 print('A área do círculo é:')
5 print(area_circulo)
130
Exercício 6
Faça um programa que define variáveis com seu nome e sobrenomes. Depois, armazena o resultado
da concatenação destas variáveis e, por fim, exibe o seu nome completo, que é o resultado da operação
de concatenação entre estas variáveis.
Nome completo:
José Maria Silva
Solução:
1 J = 'José '
2 M = 'Maria '
3 S = 'Silva '
4 nome_completo = J+M+S
5 print('Nome completo:')
6 print(nome_completo)
Exercício 7
As bases nitrogenadas do DNA são: Adenina (A), Guanina (G), Citosina (C) e Timina (T). O padrão
“ATGC” se repete cinco vezes em uma sequência. Faça uma programa que mostra a sequência com
esta ocorrência de replicação informada utilizando uma variável e aplicando o operador de replicação
de string.
Sequência:
ATGCATGCATGCATGCATGC
Solução:
1 s = 'ATGC'
2 sequencia = s * 5
3 print('Sequência:')
4 print(sequencia)
Exercício 8
Implemente um programa que imprima o valor de π com os seguintes arredondamentos:
• para baixo;
• para cima;
• para duas casas decimais.
131
Você deve usar a biblioteca math e as funções específicas para cada arredondamento solicitado.
Arredondando pi...
para baixo:
3
para cima:
4
para duas casas:
3.14
Solução:
1 from math import pi, ceil, floor
2 print('Arredondando pi...')
3 print('para baixo:')
4 print(floor(pi))
5 print('para cima:')
6 print(ceil(pi))
7 print('para duas casas:')
8 print(round(pi, 2))
Exercício 9
O comprimento de uma circunferência é igual a constante tau vezes o raio do círculo. Crie um
programa em que, dado o raio do círculo igual a 5, exibe o comprimento da sua circunferência e a
relação entre as constantes tau e pi.
Comprimento:
31.41592653589793
Relação entre as constantes tau e pi:
2.0
Solução:
1 from math import pi, tau
2 raio = 5
3 C = tau * raio
4 relacao = tau /pi
5 print('Comprimento:')
6 print(C)
7 print('Relação entre as constantes tau e pi:')
8 print(relacao)
132
9.2 Exercícios do Capítulo 3: Entrada e Saída
Exercício 1
Elabore um programa que leia o valor do raio de um círculo qualquer (número inteiro) e calcule
sua respectiva área. Ao final imprima como saída o valor da área do círculo (com duas casas decimais).
Fórmula:
Area = π.r2
onde:
• r: raio do círculo.
Solução:
1 import math
2 # Entrada
3 raio = int(input('Digite o valor do raio: '))
4 # Processamento
5 area = math.pi * raio * raio
6 # Saída
7 print(f'A área do círculo é: {area:.2f}')
Exercício 2
Implemente um programa que leia o valor do raio r de uma esfera (número real) e calcule o volume
da esfera. No final imprima como saída o valor calculado (com duas casas decimais).
Fórmula:
4πr3
V olume =
3
onde:
133
• r: raio da esfera.
Solução:
1 import math
2 # Entrada
3 raio = float(input('Digite o valor do raio: '))
4 # Processamento
5 volume = (4 * math.pi * raio ** 3) / 3
6 # Saída
7 print(f'O volume da esfera é: {volume:.2f}')
Exercício 3
Implemente um programa que tem como dados de entrada o comprimento, a largura e a altura
(números inteiros), calcule e imprima o volume de um paralelepípedo (com duas casas decimais),
utilizando a seguinte fórmula:
V olume = comprimento ∗ largura ∗ altura
134
Solução:
1 # Entrada
2 comprimento = int(input('Digite o valor do comprimento: '))
3 largura = int(input('Digite o valor da largura: '))
4 altura = int(input('Digite o valor da altura: '))
5 # Processamento
6 volume = comprimento * largura * altura
7 # Saída
8 print(f'O volume do paralelepípedo é: {volume:.2f}')
Exercício 4
Elabore um programa que receba como entradas um determinado valor em Real (R$) como saldo
de um usuário e um valor para a cotação do Dólar (US$) (números reais). No final apresente como
saída o valor convertido em Dólar (com duas casas decimais).
135
Solução:
1 # Entrada
2 valor = float(input('Digite o valor em real: '))
3 cotacao = float(input('Digite o valor de cotação do dólar: '))
4 # Processamento
5 dolar = valor/cotacao
6 # Saída
7 print(f'O valor convertido é: {dolar:.2f}')
Exercício 5
Implemente um programa que receba como entrada o valor de um veículo (número real) e calcule
e imprima o valor do IPVA (Imposto sobre a Propriedade de Veículos Automotores) considerando a
alíquota de 4.0% (com duas casas decimais).
Solução:
1 # Entrada
2 valor = float(input('Digite o valor do veículo: '))
3 taxa = 0.04
4 # Processamento
5 ipva = valor * taxa
6 # Saída
7 print(f'O valor do IPVA é: {ipva:.2f}')
136
9.3 Exercícios do Capítulo 4: Estrutura de Decisão
Exercício 1
Implemente um programa que faça a entrada de dois valores inteiros e informe:
• Se o primeiro número é par ou ímpar;
• Se o segundo número é par ou ímpar;
• Se o primeiro número é divisível pelo segundo.
Dicas: (1) para saber se um número A é ímpar, verifique se o resto da divisão de A por 2 é igual a
zero; (2) para saber se um número A é divisível por B, verifique se o resto da divisão de A por B é
igual a zero. (3) estudamos o operador de resto de divisão no Capítulo 2.
O segundo número é par.
O primeiro número não é divisível pelo segundo.
O primeiro número é par.
Solução:
1 num1 = int(input('Informe o primeiro número: '))
2 num2 = int(input('Informe o segundo número: '))
3 if num1 % 2 == 0:
4 print(f'O primeiro número é par.')
5 else:
6 print(f'O primeiro número é ímpar.')
137
7 if num2 % 2 == 0:
8 print(f'O segundo número é par.')
9 else:
10 print(f'O segundo número é ímpar.')
11 if num1 % num2 == 0:
12 print(f'O primeiro número é divisível pelo segundo.')
13 else:
14 print(f'O primeiro número não é divisível pelo segundo.')
Exercício 2
Um vendedor recebe um determinado valor de comissão sobre o total de suas vendas efetuadas.
Em vendas superiores a 5000,00 o valor a receber corresponde a 25%, os valores na faixa de 5000,00
a 2500,00 corresponde a 20% e para valores inferiores a 2500,00 o valor corresponde a 15%. Im-
plemente um programa que leia o valor total das vendas (número real) e calcule a quantia que o
vendedor irá receber.
Solução:
1 valor = float(input('Digite o valor total das vendas: '))
2 comissao = 0
3 if valor > 5000:
4 comissao = valor * 0.25
5 elif valor >= 2500:
7 else:
9 print(f'O valor de comissão é: {comissao:.2f} ')
138
Exercício 3
Elabore um programa que leia as quatro notas de um aluno, números reais entre 0 a 100, e calcule
a média das notas. E no final, como saída, imprima a média (com uma casa decimal) e uma mensagem
de aprovação se a média for maior ou igual a 70 ou reprovação caso a média for inferior.
A média é 92.5. O aluno foi aprovado.
A média é 57.5. O aluno foi reprovado.
Erro: os valores das notas devem estar entre 0 a 100.
Solução:
1 nota1 = float(input('Digite a primeira nota: '))
2 nota2 = float(input('Digite a segunda nota: '))
3 nota3 = float(input('Digite a terceira nota: '))
4 nota4 = float(input('Digite a quarta nota: '))
5 if (nota1 >= 0 and nota1 <= 100) and (nota2 >= 0 and nota2 <= 100) and
(nota3 >= 0 and nota3 <= 100) and (nota4 >= 0 and nota4 <= 100):
6 media = (nota1 + nota2 + nota3 + nota4) / 4
7 if media >= 70:
8 print(f'A média é {media:.1f}. O aluno foi aprovado.')
9 else:
10 print(f'A média é {media:.1f}. O aluno foi reprovado.')
11 else:
12 print('Erro: os valores das notas devem estar entre 0 a 100.')
139
Exercício 4
Elabore um programa que leia três valores inteiros x, y e z e verifique se estes valores podem cons-
tituir os comprimentos de um triângulo e se caso positivo informe se este é um triângulo equilátero,
isósceles ou escaleno.
Observações:
• O triângulo equilátero possui os três lados com medidas iguais;
• O triângulo isósceles possui dois lados com medidas iguais;
• O triângulo escaleno possui os três lados com medidas diferentes.
• Condição de desigualdade triangular: (x < y + z), (y < x + z) e (z < x + y)
Triângulo Equilátero
Triângulo Isósceles
Triângulo Escaleno
Erro: os valores informados não constituem um triângulo.
140
Solução:
1 x = int(input('Digite o valor de x: '))
2 y = int(input('Digite o valor de y: '))
3 z = int(input('Digite o valor de z: '))
4 if (x < y + z) and (y < x + z) and (z < x + y):
5 if (x == y) and (y == z):
6 print('Triângulo Equilátero')
7 elif (x == y) or (y == z) or (x == z):
8 print('Triângulo Isósceles')
9 else:
10 print('Triângulo Escaleno')
11 else:
12 print('Erro: os valores informados não constituem um triângulo.')
Exercício 5
Implemente um programa que leia o valor de um veículo (número real) e sua respectiva classe
(número inteiro), como descreve a Tabela abaixo, para o cálculo do IPVA (Imposto sobre a Propriedade
de Veículos Automotores). O cálculo deve considerar a alíquota da respectiva classe do veículo. No
final imprima o resultado do cálculo como saída.
Classe Descrição Alíquota

1 Automóveis, veículos de uso misto e utilitários, caminhonetes cabine 4,0%
estendida e dupla.
2 Caminhonetes de carga (pick-ups) e furgão. 3,0%
3 Automóveis, veículos de uso misto e utilitários com autorização para 2,0%
transporte público (ex: táxi, escolar) comprovada mediante registro no
órgão de trânsito na categoria aluguel.
4 Motocicletas e similares. 2,0%
5 Veículos de locadoras (pessoa jurídica). 1,0%
6 Ônibus, micro ônibus, caminhão, caminhão trator. 1,0%
141
Solução:
1 valor = float(input('Digite o valor do veículo: '))
2 classe = int(input('Digite a classe do veículo: '))
3 taxa = 0
4 if classe == 1:
5 taxa = 0.04
6 elif classe == 2:
7 taxa = 0.03
8 elif classe == 3 or classe == 4:
9 taxa = 0.02
10 elif classe == 5 or classe == 6:
11 taxa = 0.01
12 ipva = valor * taxa
13 print(f'O valor do IPVA é : {ipva:.2f}')
Exercício 6
Elabore um programa que leia dois valores reais x e y e que pergunte qual operação deve ser
realizada. As operações que poderão ser calculadas são a soma (+), subtração(−), multiplicação(∗),
divisão(/) e potenciação (∧). Observação: para efetuar a divisão, y deverá ser diferente de zero.
Informe a operação: +
25.00 + 25.00 = 50.00
Informe a operação: ^
5.00 ^ 5.00 = 3125.00
142
81.00 / 9.00 = 9.00
Erro: Divisão por zero !
Solução:
1 valor1 = float(input('Digite o primeiro valor:'))
2 valor2 = float(input('Digite o segundo valor:'))
3 operacao = input('Informe a operação:')
4 if operacao == '+':
5 soma = valor1 + valor2
6 print(f'{valor1:.2f} + {valor2:.2f} = {soma:.2f}')
7 elif operacao == '-':
8 subtracao = valor1 - valor2
9 print(f'{valor1:.2f} - {valor2:.2f} = {subtracao:.2f}')
10 elif operacao == '*':
11 mult = valor1 * valor2
12 print(f'{valor1:.2f} * {valor2:.2f} = {mult:.2f}')
13 elif operacao == '/':
14 if valor2 != 0:
15 divisao = valor1 / valor2
16 print(f'{valor1:.2f} / {valor2:.2f} = {divisao:.2f}')
17 else:
18 print(f'Erro: Divisão por zero ! ')
19 elif operacao == '^':
20 pot = valor1 ** valor2
21 print(f'{valor1:.2f} ^ {valor2:.2f} = {pot:.2f}')
143
9.4 Exercícios do Capítulo 5: Estrutura de Repetição
Exercício 1
Escreva um programa que leia um valor inteiro positivo N e calcule o somatório dos valores ímpares
e o somatório dos valores pares presentes no intervalo entre 1 a N. No final imprima o resultado dos
somatórios.
Solução:
1 # Entrada
2 n = int(input('Digite o valor de N: '))
3 # Processamento
4 soma_par = 0
5 soma_impar = 0
6 for i in range(1, n + 1):
7 if i % 2 == 0:
8 soma_par = soma_par + i
9 else:
10 soma_impar = soma_impar + i
11 # Saída
12 print(f'A soma dos valores pares é: {soma_par}')
13 print(f'A soma dos valores ímpares é: {soma_impar}')
Exercício 2
Implemente um programa que efetue a leitura de uma quantidade indeterminada de valores intei-
ros positivos. Quando um valor inválido (menor ou igual a zero) for informado, o processo de leitura
144
deverá ser finalizado. No final apresente como saída o menor valor, o maior valor, a média aritmé-
tica dos valores informados. O processamento só será possível se pelo menos 2 valores válidos forem
fornecidos.
Digite um valor: 10
Digite um valor: 20
Digite um valor: 30
Digite um valor: 40
Digite um valor: 50
Digite um valor: -1
Digite um valor: 55
Digite um valor: 25
Digite um valor: 5
Digite um valor: 75
Digite um valor: 95
Digite um valor: 85
Digite um valor: 45
Digite um valor: -1
Digite um valor: -1
Digite um valor: -1
145
Digite um valor: 10
Digite um valor: -1
Digite um valor: 10
Digite um valor: 20
Digite um valor: -1
Solução:
1 import math
2 # Entrada
3 valor = int(input('Digite um valor:'))
4 # Processamento
5 maior = -math.inf
6 menor = math.inf
7 soma = 0
8 media = 0
9 contador = 0
10 while valor > 0:
11 if valor > maior:
12 maior = valor
13 if valor < menor:
14 menor = valor
15 soma = soma + valor
16 contador = contador + 1
17 valor = int(input('Digite um valor:'))
18
19 # Saída
20 if contador >= 2:
21 media = soma / contador
22 print(f'O menor valor informado é: {menor}')
23 print(f'O maior valor informado é: {maior}')
24 print(f'A média dos valores é: {media:.2f}')
25 else:
26 print('Quantidade de valores insuficiente')
146
Exercício 3
Implemente um programa que leia dois valores inteiros não-negativos X e Y. O programa deve
calcular a potência X Y e imprimir o resultado como saída.
2 ^ 5 = 32
10 ^ 0 = 1
9 ^ 9 = 387420489
Solução:
1 # Entrada
2 x = int(input('Digite o valor da base x:'))
3 y = int(input('Digite do expoente y:'))
4 # Processamento
5 resultado = 1
6 for i in range(y):
7 resultado = resultado * x
8 # Saída
9 print(f'{x} ^ {y} = {resultado}')
Exercício 4
Implemente um programa que leia dois números inteiros positivos x e y quaisquer e calcule o
Máximo Divisor Comum (MDC). E no final imprima o resultado.
Observação: Para saber se um número é divisível por outro, normalmente verificamos se o resto
da divisão é zero. Em Python, isso pode ser feito usando o operador %, que retorna o resto da divisão.
Por exemplo, 9 % 3 resulta em zero, 5 % 2 resulta em 1, 24 % 5 resulta em 4. Assim, para saber se A é
divisível por B, use a expressão lógica A % B == 0.
147
O MDC é: 30
O MDC é: 25
O MDC é: 28
Solução:
1 # Entrada
2 x = int(input('Digite o valor de x: '))
3 y = int(input('Digite o valor de y: '))
4 # Processamento
5 mdc = 1
6 for i in range(1, x + 1):
7 if x % i == 0 and y % i == 0:
8 mdc = i
9 # Saída
10 print(f'O MDC é: {mdc}')
Exercício 5
Elabore um programa que leia um valor inteiro positivo N e no final imprima todos os valores
primos inferiores a N.
Observação: Os números primos são números naturais que possuem apenas dois divisores: 1 e ele
mesmo. Por definição, o número 1 não é considerado primo.
2
3
5
7
148
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97
149
Solução:
1 # Entrada
2 n = int(input('Digite o valor de N: '))
4 for i in range (2, n):
5 teste = True
6 for j in range(2, i):
7 if i % j == 0:
8 teste = False
9 if (teste == True):
10 print(i)
Exercício 6
Seja a função f (x, y) definida da seguinte maneira:


 cos(y − x) se x < y

f (x, y) = tan(x) se x = y

sen(x − y) se x > y

Faça um programa que avalia os valores de f (x, y) para todas as combinações possíveis para x e
y variando de 0 a N − 1 (número inteiro definido pelo usuário). Os resultados devem ser exibidos
em forma tabular, onde as linhas representam o valor de x e as colunas representam o valor de y.
Considerando N = 4, o exemplo a seguir mostra os valores de x e y e os respectivos resultados
de f (x, y). Veja que serão impressos no terminal apenas o conteúdo dentro das bordas, conforme
ilustrado nos exemplos de execução. N não pode ser menor ou igual a zero e maior do que 20 (veja
exemplos de execução 3 e 4).
x\y 0 1 2 3
0 0 1 2 3
1 1 1 1 2
2 2 1 2 1
3 3 2 1 3
Valores de f(x, y):
0 1 2 3
1 1 1 2
2 1 2 1
3 2 1 3
Valores de f(x, y):
150
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
1 1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
2 1 2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
3 2 1 3 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
4 3 2 1 4 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
5 4 3 2 1 5 1 2 3 4 5 6 7 8 9 10 11 12 13 14
6 5 4 3 2 1 6 1 2 3 4 5 6 7 8 9 10 11 12 13
7 6 5 4 3 2 1 7 1 2 3 4 5 6 7 8 9 10 11 12
8 7 6 5 4 3 2 1 8 1 2 3 4 5 6 7 8 9 10 11
9 8 7 6 5 4 3 2 1 9 1 2 3 4 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1 10 1 2 3 4 5 6 7 8 9
11 10 9 8 7 6 5 4 3 2 1 11 1 2 3 4 5 6 7 8
12 11 10 9 8 7 6 5 4 3 2 1 12 1 2 3 4 5 6 7
13 12 11 10 9 8 7 6 5 4 3 2 1 13 1 2 3 4 5 6
14 13 12 11 10 9 8 7 6 5 4 3 2 1 14 1 2 3 4 5
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 15 1 2 3 4
16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 16 1 2 3
17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 17 1 2
18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 18 1
19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 19
Forneça o valor de N: -5
N não pode ser menor ou igual a zero!
N não pode ser maior do que vinte!
Solução:
1 from math import cos, sin, tan
2
3 N = int(input('Forneça o valor de N: '))

4 if N <= 0:
5 print('N não pode ser menor ou igual a zero!')
6 elif N > 20:
7 print('N não pode ser maior do que vinte!')
8 else:
9 print('Valores de f(x, y):')
10 for x in range(N):
11 for y in range(N):
12 if x < y:
13 f = y-x
151
14 elif x == y:
15 f = x
16 else:
17 f = x-y
18 print(f'{f:3d}', end='')
19 print()
152
9.5 Exercícios do Capítulo 6: Função
Exercício 1
Elabore uma função que calcula a distância euclidiana entre dois pontos bidimensionais e imple-
mente um programa principal que faça a entrada e saída, gerando o resultado a partir de chamada à
função elaborada. Utilizar x1 , x2 , y1 e y2 como argumentos da função.
Fórmulas:
• P1 = (x1 , y1 )
• P2 = (x2 , y2 )
p
• D= (x1 − x2 )2 + (y1 − y2 )2
A distância entre os pontos é 1.41
Solução:
2 def Distancia(x1,x2,y1,y2):
3 return ((x1-x2)**2 + (y1-y2)**2)**(1/2)
4

6 X1 = float(input("Digite o valor da coordenada X1: "))
7 Y1 = float(input("Digite o valor da coordenada Y1: "))
8 X2 = float(input("Digite o valor da coordenada X2: "))
9 Y2 = float(input("Digite o valor da coordenada Y2: "))
10 dist = Distancia(X1,X2,Y1,Y2)
11 print(f'A distância entre os pontos é {dist:.2f}')
Exercício 2
Elabore uma função que converte uma entrada de temperatura em Celsius para Fahrenheit e im-
Fórmula:
• TF = (Tc . 95 ) + 32
Digite uma temperatura em Celsius: 37
153
A temperatura em Fahrenheit é 98.6
Solução:
2 def fahrenheit(celsius):
3 return (celsius*9/5) + 32
4

6 T_c = float(input('Digite uma temperatura em Celsius: '))
7 T_f = fahrenheit(T_c)
8 print(f'A temperatura em fahrenheit é {T_f:.1f}')
Exercício 3
Elabore uma função que converte uma entrada de temperatura em Fahrenheit para Celsius e im-
Fórmula:
• TC = (TF − 32). 59
Digite a temperatura em Fahrenheit: 98.6
A temperatura em Celsius é 37.0
Solução:
2 def celsius(fahrenheit):
3 return (fahrenheit-32)*5/9
4

6 T_f = float(input('Digite uma temperatura em Celsius: '))
7 T_c = celsius(T_f)
8 print(f'A temperatura em celsius é {T_c:.1f')
Exercício 4
Elabore uma função que calcula a extensão de uma mola vertical com constante elástica k ao pen-
durar um objeto de massa m. Utilize k e m como argumentos da função e implemente um programa
principal que faça a entrada e saída, gerando o resultado a partir de chamada à função elaborada.
Fórmulas:
• Fe = k.x
154
• Fg = m.g
• g = 9, 807m/s2
Digite a massa do objeto: 5
Digite a constante da mola: 100
A extensão da mola é 0.49 m
Solução:
2 def extensao(m,k):
3 g = 9.807
4 return m*g/k
5

7 massa = float(input('Digite a massa do objeto: '))
8 const = float(input('Digite a constante da mola: '))
9 x = extensao(massa, const)
10 print(f'A extensão da mola é {x:.2f} m')
Exercício 5
A inclinação de um telhado é dada por um percentual da largura, conforme a Figura 32.
Figura 34: Esquema de inclinação de telhado.
Quando o telhado é de “duas águas”, a largura deve ser dividida por dois antes de calcular a
altura. Esses dados podem ser usados para calcular o comprimento do telhado, que é a hipotenusa do
155
triângulo retângulo.
Elabore duas funções: uma função que calcula o comprimento c1 de um telhado de duas águas e
uma que calcula o comprimento c2 de um telhado de uma água, dadas como entradas uma largura l e
um percentual p.
Implemente um programa principal que realize a entrada e saída, gerando o resultado a partir de
chamada às funções elaboradas.
Fórmulas (uma água):

p.l
• h= 100
√
• c1 = l2 + h2
Fórmulas (duas águas):

p.(l/2)
• h= 100
p
• c2 = 2. (l/2)2 + h2
Observação: Os resultados encontrados devem ser iguais (por semelhança de triângulos, é fácil ob-
servar essa relação).
Digite a largura do telhado: 10
Digite a inclinação percentual: 30
O comprimento do telhado de uma água é 10.44
O comprimento do telhado de duas águas é 10.44
Solução:
2 def comprimento_1(l,p):
3 h = l*p/100
4 c = (l**2 + h**2)**(1/2)
5 return c
6
7 def comprimento_2(l,p):
8 h = (l/2)*p/100
9 c = ((l/2)**2 + h**2)**(1/2)
10 return 2*c
11

13 largura = float(input('Digite a largura do telhado: '))
14 percentual = float(input('Digite a inclinação percentual: '))
15 c1 = comprimento_1(largura, percentual)
16 c2 = comprimento_2(largura, percentual)
17 print(f'O comprimento do telhado de uma água é {c1:.2f}')
18 print(f'O comprimento do telhado de duas águas é {c2:.2f}')
156
157
9.6 Exercícios do Capítulo 7: Estruturas Homogêneas
Exercício 1
Utilizando vetores, imprimir uma sequência de pontos indicando a distância de queda livre de um
corpo, dada uma sequência de tempo de t = 0 até um valor dado como entrada pelo usuário. Os
valores impressos devem ter uma precisão de uma casa decimal. Fórmulas:
• g = 9.807m/s2
gt2
• d= 2
t D(t)
0 0.0
1 4.9
2 19.6
3 44.1
t D(t)
0 0.0
1 4.9
2 19.6
3 44.1
4 78.5
5 122.6
Solução:
1 ft = int(input('Digite o tempo final: '))
2 g = 9.807
3 T = []
4 D = []
5 for i in range(ft+1):
6 T.append(i)
7 D.append(g*i*i/2)
8 print('t D(t)')
10 print(f'{T[i]} {D[i]:.1f}')
158
Exercício 2
Uma função de segundo grau é dada pela fórmula:
f (x) = ax2 + bx + c
Dadas como entradas:
• Valores a, b e c
• Ponto x0 inicial
• Ponto xf final
Criar dois vetores com os dados dos valores da função nesses pontos.
x f(x)
-3 13
-2 6
-1 3
0 4
1 9
2 18
3 31
x f(x)
-5 50
-4 32
-3 18
-2 8
-1 2
0 0
1 2
2 8
159
Solução:
1 a = int(input('Digite o valor de "a": '))
2 b = int(input('Digite o valor de "b": '))
3 c = int(input('Digite o valor de "c": '))
4 x0 = int(input('Digite o valor inicial de x: '))
5 x1 = int(input('Digite o valor final de x: '))
6 X = []
7 Y = []
8 for i in range(x0, x1+1):
9 X.append(i)
10 Y.append(a*i*i + b*i + c)
11 print('x f(x)')
12 for i in range(len(Y)):
13 print(f'{X[i]} {Y[i]}')
Exercício 3
Implemente um programa que realize a entrada de dados de um vetor. Primeiro o usuário fornece
a quantidade de elementos do vetor, em seguida, fornece um valor numérico para cada elemento.
Após preenchido o vetor, os valores armazenados no mesmo devem ser impressos na tela com uma
precisão de uma casa decimal.
Elementos do vetor:
3.5
7.0
10.7
Elementos do vetor:
6.9
4.0
5.3
160
2.3
2.3
Solução:
1 N = int(input('Informe a dimensão do vetor: '))
2 vetor = [ ]
3 for i in range(N):
4 vetor.append(float(input(f'Informe o valor do elemento {i}: ')))
5 print('Elementos do vetor: ')
7 print(f'{vetor[i]:.1f}')
Exercício 4
['t', 'D(t)']
[0, 0.0]
[1, 4.9035]
[2, 19.614]
[3, 44.1315]
['t', 'D(t)']
[0, 0.0]
[1, 4.9035]
[2, 19.614]
[3, 44.1315]
[4, 78.456]
[5, 122.5875]
[6, 176.526]
Solução:
1 ft = int(input('Digite o tempo final: '))
2 g = 9.807
3 data = []
161
5 linha = []
6 linha.append(i)
7 linha.append(g*i*i/2)
8 data.append(linha)
9 print('[\'t\', \'D(t)\']')
11 print(f'[{data[i][0]}, {data[i][1]}]')
Exercício 5
['x', 'f(x)']
[-5, 39]
[-4, 24]
[-3, 13]
[-2, 6]
[-1, 3]
[0, 4]
[1, 9]
[2, 18]
[3, 31]
[4, 48]
[5, 69]
Digite o valor de "c": -4
['x', 'f(x)']
[-3, 32]
[-2, 12]
162
[-1, 0]
[0, -4]
[1, 0]
[2, 12]
[3, 32]
[4, 60]
[5, 96]
[6, 140]
Solução:
1 #Entrada
2 a = int(input('Digite o valor de "a": '))
3 b = int(input('Digite o valor de "b": '))
4 c = int(input('Digite o valor de "c": '))
5 x0 = int(input('Digite o valor inicial de x: '))
6 x1 = int(input('Digite o valor final de x: '))
7 data = []
8 for i in range(x0, x1+1):
9 linha = []
10 linha.append(i)
11 linha.append(a*i*i + b*i + c)
12 data.append(linha)
13 print('[\'x\', \'f(x)\']')
14 for i in range(len(data)):
15 print(f'[{data[i][0]}, {data[i][1]}]')
Exercício 6
Fazer um programa que gere uma matriz quadrada de dimensão n, preenchida em todas as posições
por um valor v. Ambos n e v são valores informados pelo usuário, como entradas. Imprimir o conteúdo
da matriz ao final do programa.
Digite o valor para preencher os campos: 2
[2, 2, 2, 2]
[2, 2, 2, 2]
[2, 2, 2, 2]
[2, 2, 2, 2]
163
Digite o valor para preencher os campos: -3
[-3, -3, -3, -3, -3, -3]
[-3, -3, -3, -3, -3, -3]
[-3, -3, -3, -3, -3, -3]
[-3, -3, -3, -3, -3, -3]
[-3, -3, -3, -3, -3, -3]
[-3, -3, -3, -3, -3, -3]
Solução:
1 n = int(input('Digite a dimensão da matriz: '))
2 v = int(input('Digite o valor para preencher os campos: '))
3 matriz = []
4 for i in range(n):
5 linha = []
6 for j in range(n):
7 linha.append(v)
9 for i in range(n):
10 print(f'[{matriz[i][0]}', end='')
11 for j in range(1, n):
12 print(f', {matriz[i][j]}', end='')
13 print(']')
Exercício 7
Implemente um programa que realize a entrada de dados de uma matriz. Primeiro o usuário
fornece as dimensões da matriz, em seguida, fornece um valor textual para cada elemento. Após pre-
enchida a matriz, o usuário fornece uma linha e coluna, e o programa imprime o valor correspondente
a estes índices. Considere que os dados informados são sempre válidos.
Informe a quantidade de linhas: 2
Informe a quantidade de colunas: 3
Informe o valor do elemento 0, 0: Sardinha
Informe o valor do elemento 0, 1: Salame
Informe o valor do elemento 0, 2: Picanha
Informe o valor do elemento 1, 0: Coca-cola
Informe o valor do elemento 1, 1: Guaraná
Informe o valor do elemento 1, 2: Pipoca
Informe uma linha: 1
Informe uma coluna: 2
O valor armazenado em [1,2] é Pipoca
Solução:
164
1 qtdLin = int(input('Informe a quantidade de linhas: '))
2 qtdCol = int(input('Informe a quantidade de colunas: '))
3 matriz = [ ]
4 for lin in range(qtdLin):
5 linha = [ ]
6 for col in range(qtdCol):
7 valor = input(f'Informe o valor do elemento {lin}, {col}: ')
8 linha.append(valor)
10 lin = int(input('Informe uma linha: '))
11 col = int(input('Informe uma coluna: '))
12 print(f'O valor armazenado em [{lin},{col}] é {matriz[lin][col]}')
Exercício 8
Implemente um programa para contabilizar a pontuação em uma Gincana, seguindo o algoritmo:
1. Pergunte a quantidade de equipes.
2. Crie um vetor, cada elemento representa uma equipe e possui pontuação inicial zero.
3. Pergunte o índice da equipe que pontuou.
4. Enquanto o índice for válido:
(a) Pergunte a quantidade de pontos.
(b) Atualize, de forma cumulativa, a pontuação da equipe no vetor.
(c) Pergunte o índice da equipe que pontuou.
5. Imprima o conteúdo do vetor.
Tanto os índices quanto a pontuação devem ser valores inteiros.
Informe o índice da equipe: -1
165
[30, 5, 35, 0, 0]
[0, 7, 0, 0, 0, 4]
Solução:
2
3 N = int(input('Informe a quantidade de equipes: '))

4 pontuacao = criarVetor(N, 0)
5 equipe = int(input('Informe o índice da equipe: '))
6 while equipe >= 0 and equipe < N:
7 pontos = int(input('Informe a quantidade de pontos: '))
8 pontuacao[equipe] = pontuacao[equipe] + pontos
9 equipe = int(input('Informe o índice da equipe: '))
10 print('Pontuação das equipes:')
11 print(pontuacao)
Exercício 9
Implemente um programa para ajudar na leitura de consumo de energia feito pela CEMIG nos
imóveis de uma cidade. O registro é feito pelo mapeamento de ruas e imóveis e armazenado em uma
matriz, as linhas representam as ruas e as colunas representam os números dos imóveis. Primeiro
o programa solicita que seja fornecida como entrada uma string que contenha os valores iniciais,
preenchendo uma matriz com estes valores. Em seguida, o programa pergunta quantas novas leituras
individuais serão fornecidas. Para cada leitura individual, o programa pergunta o índice da rua (linha),
o índice do imóvel (coluna), e o valor lido pelo funcionário. O programa deve então fornecer a
diferença da última leitura referente ao imóvel do valor lido pelo funcionário, e em seguida atualizar
a matriz com o valor lido para o imóvel.
Tanto os índices quanto as leituras devem ser valores inteiros. Não é necessário validar dados de
entrada, considere que serão sempre válidos.
166
Leitura 1:
- Diferença: 2
Leitura 2:
- Diferença: 4
Leitura 3:
- Diferença: 3
Leitura 4:
- Diferença: 0
Leitura 5:
- Diferença: 2
Solução:
2
3 matriz = inputMatriz('Informe os valores iniciais: ', int)

4 N = int(input('Informe a quantidade de novas leituras: '))
6 print(f'Leitura {i+1}:')
7 lin = int(input(' - Informe o índice da rua: '))
8 col = int(input(' - Informe o índice do imóvel: '))
9 valor = int(input(' - Informe o valor lido: '))
10 diferenca = valor - matriz[lin][col]
11 matriz[lin][col] = valor
12 print(f' - Diferença: {diferenca}')
167
Exercício 10
Implemente um programa similar ao anterior, Exercício 9. Mas, agora a entrada de cada leitura
deve ser feita por um único input, armazenando os valores em um vetor, onde, índice 0 representa a
rua, índice 1 representa o imóvel e índice 2 representa o valor lido. O restante do programa funciona
da mesma maneira, gerando o mesmo resultado, conforme o exemplo de execução a seguir.
- Diferença: 2
- Diferença: 4
- Diferença: 3
- Diferença: 0
- Diferença: 2
Solução:
2
3 matriz = inputMatriz('Informe os valores iniciais: ', int)

4 N = int(input('Informe a quantidade de novas leituras: '))
6 leitura = inputVetor(f'Informe a leitura {i+1}: ', int)
7 lin = leitura[0]
8 col = leitura[1]
9 diferenca = leitura[2] - matriz[lin][col]
10 matriz[lin][col] = leitura[2]
11 print(f' - Diferença: {diferenca}')
168
9.7 Exercícios do Capítulo 8: Estruturas Heterogêneas
Exercício 1
Implemente uma versão do Exemplo 4 para armazenar os dados de alunos em diferentes discipli-
nas. Sendo assim, deve-se utilizar uma matriz para armazenar os dados, em cada elemento da matriz
será armazenada a nota e a frequência. As linhas representam alunos e as colunas representam dis-
ciplinas, que serão referenciadas pelos seus respectivos índices. Primeiramente o programa pergunta
a quantidade de alunos e disciplinas, em seguida pergunta nota e frequência para cada elemento da
matriz. Depois disso, para cada aluno, o programa deve identificar a disciplina com a maior nota, im-
primindo a nota com precisão de uma casa decimal e a frequência nesta disciplina. Notas são valores
reais e frequência inteiros.
Dados do aluno 1:
- Digite a nota: 4
- Digite a nota: 3
Dados do aluno 2:
- Digite a nota: 2
- Digite a nota: 1
Maiores notas e frequências:

Dados do aluno 1:
- Digite a nota: 1
169
- Digite a nota: 2
Dados do aluno 2:
- Digite a nota: 3
- Digite a nota: 4
Dados do aluno 3:
- Digite a nota: 5
- Digite a nota: 6
Maiores notas:
Solução:
1 nA = int(input('Digite a quantidade de alunos: '))
2 nD = int(input('Digite a quantidade de disciplinas: '))
3 alunos = [ ]
4 for a in range(nA):
5 linha = [ ]
6 print(f'\nDados do aluno {a+1}:')
7 for d in range(nD):
8 aluno = { }
9 print(f' - Dados da disciplina {d+1}:')
10 aluno["nota"] = float(input(' - Digite a nota: '))
11 aluno["freq"] = int(input(' - Digite a frequência: '))
12 linha.append(aluno)
13 alunos.append(linha)
14 print('\nMaiores notas:')
15 for a in range(nA):
16 maior = 0
17 for d in range(nD):
18 if alunos[a][d]["nota"] > alunos[a][maior]["nota"]:
19 maior = d
170
20 print(f' - Aluno {a+1}: nota = {alunos[a][maior]["nota"]:.1f};
frequência = {alunos[a][maior]["freq"]}')
Exercício 2
Implemente um programa que receba informações sobre retas, armazenando-as em um vetor. Pri-
meiramente pergunta-se quantas retas serão informadas, e em seguida pede-se as coordenadas dos
dois pontos (A e B) que definem cada reta. Uma reta deve ser representada por um registro que
contenha dois campos, representando os pontos. Cada ponto é um registro que possui as coordena-
das X e Y como campos. Depois que o vetor estiver totalmente preenchido, você deverá calcular e
imprimir o comprimento de cada reta armazenada no vetor. O comprimento é obtido por meio de
uma função, definida em seu programa, que recebe a reta como argumento e retorna o comprimento:
p
C = (BX − AX )2 + (BY − AY )2 . As coordenadas X e Y são números reais, e a saída das medidas
deve possuir precisão de 2 casas decimais. Dicas: (1) para obter o ponto B de uma reta, você deve
usar: reta["B"]; (2) para obter a coordenada X do ponto B desta mesma reta, você deve usar:
reta["B"]["X"], uma vez que temos aqui um registro “dentro” de outro registro.
Reta 1:
- Informe a coordenada X de A: 1
- Informe a coordenada Y de A: 4
- Informe a coordenada Y de B: 1
Medidas das retas:

- Reta 1: 3.00
Reta 1:
- Informe a coordenada X de A: 3.5
- Informe a coordenada Y de B: 8.6
Reta 2:
- Informe a coordenada X de A: -3
- Informe a coordenada X de B: 5.8
- Informe a coordenada Y de B: -9.1
171
Medidas das retas:
- Reta 1: 6.96
- Reta 2: 13.32
Solução:
1 import math
2
3 def calcReta(reta):
4 d1 = reta["B"]["X"] - reta["A"]["X"]
5 d2 = reta["B"]["Y"] - reta["A"]["Y"]
6 C = math.sqrt(d1 ** 2 + d2 ** 2)
7 return C
8
9 N = int(input('Informe a quantidade de retas: '))

10 retas = [ ]
12 print(f'\nReta {i+1}:')
13 A = { }
14 A["X"] = float(input(' - Informe a coordenada X de A: '))
15 A["Y"] = float(input(' - Informe a coordenada Y de A: '))
16 B = { }
17 B["X"] = float(input(' - Informe a coordenada X de B: '))
18 B["Y"] = float(input(' - Informe a coordenada Y de B: '))
19 reta = { "A": A, "B": B }
20 retas.append(reta)
21 print('\nMedidas das retas:')
23 print(f' - Reta {i+1}: {calcReta(retas[i]):.2f}')
Exercício 3
Crie um registro para armazenar os dados de um evento, que deve conter os campos: nome, local,
preço e lotação. Implemente um programa que receba informações de N eventos e, em seguida,
informe o nome, o preço e arrecadação máxima do evento mais barato e do evento mais caro. Os
valores reais devem ser impressos com precisão de duas casas decimais.
>>> %Run -c $EDITOR_CONTENT

Informe a quantidade de eventos: 2
Dados do evento 1:
- Informe o nome: Concerto
- Informe o local: CineArt
172
Dados do evento 2:
- Informe o nome: Festival de Jazz
- Informe o local: Clube
Mais Barato:
- Festival de Jazz, preço: R$ 85.50, arrecadação máxima: R$ 17100.00
Mais Caro:
- Concerto, preço: R$ 125.50, arrecadação máxima: R$ 12550.00
>>>
Solução:
1 import math
2
3 N = int(input('Informe a quantidade de eventos: '))

4 eventos = [ ]
5 for i in range(N) :
6 evento = { }
7 print(f'Dados do evento {i+1}:')
8 evento["nome"] = input(' - Informe o nome: ')
9 evento["local"] = input(' - Informe o local: ')
10 evento["preco"] = float(input(' - Informe o preço (R$): '))
11 evento["lotacao"] = int(input(' - Informe a lotação: '))
12 eventos.append(evento)
13
14 mais_barato = math.inf
15 mais_caro = - math.inf
16
18
19 if eventos[i]["preco"] > mais_caro :

20 mais_caro = eventos[i]["preco"]
21 icaro = i
22
23 if eventos[i]["preco"] < mais_barato :

24 mais_barato = eventos[i]["preco"]
25 ibarato = i
26
27 print(f'Mais Barato:')
28 print(f' - {eventos[ibarato]["nome"]}, preço: R$ {eventos[ibarato]["
preco"]:.2f}, arrecadação máxima: R$ {eventos[ibarato]["preco"] *
eventos[ibarato]["lotacao"]:.2f}')
29 print(f'Mais Caro:')
30 print(f' - {eventos[icaro]["nome"]}, preço: R$ {eventos[icaro]["preco
173
"]:.2f}, arrecadação máxima: R$ {eventos[icaro]["preco"] * eventos[
icaro]["lotacao"]:.2f}')
Exercício 4
Crie um registro para armazenar os dados de um eletrodoméstico de uma casa, que deve conter os
campos: nome, potência (em kW) e tempo diário de funcionamento (em h). Implemente um programa
que receba informações de x eletrodomésticos. O programa deve calcular e mostrar o consumo total
(kWh) da sua casa e o consumo relativo de cada eletrodoméstico (%). Dicas: (1) o consumo de
energia elétrica é igual ao produto da potência do aparelho eletrodoméstico e o tempo em que esse
aparelho funciona e (2) consumo relativo (%) de um aparelho é igual ao seu consumo multiplicado
por 100, e depois, dividido pelo consumo total da casa.
Forneça a quantidade de eletrodomésticos: 4
- Forneça o nome: Televisão
- Forneça o nome: Geladeira
- Forneça o nome: Chuveiro
- Forneça o nome: Máquina de lavar roupa
Consumo total (kWh): 22150.0

Consumo relativo:
Televisão: 4.51 %
Geladeira: 37.92 %
Chuveiro: 27.09 %
Máquina de lavar roupa: 30.47 %
Solução:
1 x = int(input('Forneça a quantidade de eletrodomésticos: '))
2
3 eletrodomesticos = [ ]
4 for i in range(x) :
5 eletrodomestico = { }
174
6 print(f'Dados do eletrodoméstico {i+1}:')
7 eletrodomestico["nome"] = input('- Forneça o nome: ')
8 eletrodomestico["potencia"] = float(input('- Forneça a potência (
kW): '))
9 eletrodomestico["tempo"] = float(input('- Forneça o tempo diário (
h): '))
10 eletrodomesticos.append(eletrodomestico)
11
12 consumo_total = 0
13 consumo_eletrodomesticos = [ ]
15 consumo_eletrodomestico_i = eletrodomesticos[i]["potencia"] *
eletrodomesticos[i]["tempo"]
16 consumo_total = consumo_total + consumo_eletrodomestico_i
17 consumo_eletrodomesticos.append(consumo_eletrodomestico_i)
18
19
20 print(f'\nConsumo total (kWh): {consumo_total}')

21 print('Consumo relativo:')
23 print(f'{eletrodomesticos[i]["nome"]}: {(consumo_eletrodomesticos[
i] * 100)/ consumo_total:.2f} %')
Exercício 5
Considerando um vetor t representado no domínio tridimensional por t = (t1, t2, t3), onde
t1, t2 e t3 são suas componentes nas direções x, y e z do sistema Cartesiano, respectivamente. Crie um
registro para armazenar as componentes de um vetor a ser representado no domínio tridimensional.
Implemente uma função para calcular e retornar o resultado do produto vetorial entre dois vetores.
Faça um programa que realiza as seguintes tarefas: faz a leitura dos vetores u = (u1, u2, u3) e
v = (v1, v2, v3), chama a função elaborada para calcular produto vetorial entre estes vetores e,
por fim, mostra o vetor resultante deste produto vetorial. Dica: o produto vetorial entre os vetores
u = (u1, u2, u3) e v = (v1, v2, v3) é dado por u x v = (u2 * v3 u3 * v2, u3 *
v1 u1 * v3, u1 * v2 u2 * v1 ).
vetor u = (u1, u2, u3):
vetor v = (v1, v2, v3):
Resultado:
175
u x v = (36.00, -30.00, 6.00)
Solução:
1 def produto_vetorial(u,v) :
2 prod = {}
3 prod ["x"] = (u["u2"] * v["v3"]) - (u["u3"] * v["v2"])
4 prod ["y"] = (u["u3"] * v["v1"]) - (u["u1"] * v["v3"])
5 prod ["z"] = (u["u1"] * v["v2"]) - (u["u2"] * v["v1"])
6 return prod
7
8 print ('vetor u = (u1, u2, u3):')

9 u = {}
10 u["u1"] = float( input('- Informe o componente u1: '))
13
14 print ('vetor v = (v1, v2, v3):')

15 v = {}
16 v["v1"] = float( input('- Informe o componente v1: '))
19
20 prod = produto_vetorial(u,v)
21 print ('\nResultado:')
22 print(f'u x v = ({prod["x"]:.2f}, {prod["y"]:.2f}, {prod["z"]:.2f})')
Exercício 6
Crie um registro para armazenar os dados de um funcionário, que deve conter campos que permita
informar o nome completo, cargo que ocupa, valor pago por hora extra, valor do salário base e horas
trabalhadas no mês. Crie também uma função que recebe uma lista de funcionários e retorna o valor
total da folha de pagamentos da empresa naquele mês. Implemente um programa que receba os
dados de N funcionários utilizando o registro criado e o número de dias úteis de trabalho no mês em
questão. Este programa deverá imprimir o valor total da folha de pagamentos da empresa usando
como resposta o cálculo da função elaborada. Dicas: (1) o tempo que excede 8 horas de trabalho por
dia é considerado hora extra, (2) a folha total de pagamentos da empresa é soma do valor a ser pago
do salário de cada funcionário.
Digite a quantidade de funcionários: 2
Digite o número de dias úteis do mês em questão: 10
- Digite o nome: Lucas
- Digite o cargo: Motorista
- Digite o valor pago por hora extra: 45.5
176
- Digite o nome: Amanda
- Digite o cargo: Gerente
- Digite o valor pago por hora extra: 70
Total da folha de pagamento: 6180.00
Solução:
1 def TotalFolhaPagamento(funcionarios, dias) :
2 N = len(funcionarios)
3 salario = 0
4 total_horas = dias * 8
5
7 horas_extras = 0
8 if (funcionarios[i]["horasPorMes"] > total_horas):
9 horas_extras = funcionarios[i]["horasPorMes"] -
total_horas
10 if (horas_extras < 0):
11 horas_extras = 0
12 salario = salario + (funcionarios[i]["salarioBase"] +
horas_extras * funcionarios[i]["valorHoraExtra"])
13 return(salario)
14
15 N = int(input('Digite a quantidade de funcionários: '))

16 dias = int(input('Digite o número de dias úteis do mês em questão: '))
17
18 funcionarios = [ ]
20 funcionario = { }
21 print(f'Dados do funcionário {i+1}:')
22 funcionario["nome"] = input('- Digite o nome: ')
23 funcionario["cargo"] = input('- Digite o cargo: ')
24 funcionario["valorHoraExtra"] = float(input('- Digite o valor pago
por hora extra: '))
25 funcionario["salarioBase"] = float(input('- Digite o valor do
salário base: '))
26 funcionario["horasPorMes"] = float(input('- Digite o valor de
horas trabalhadas por mês: '))
27 funcionarios.append(funcionario)
28
29 print(f'Total da folha de pagamento: {TotalFolhaPagamento(funcionarios
177
, dias):.2f}')
Exercício 7
Crie um registro que represente um número complexo, onde um número complexo z é escrito da
seguinte forma: z = a + b * i tal que i * i = -1. Logo, os números reais a e b devem ser
armazenados como campos deste registro. Realize a implementação de uma função que encontra em
uma lista de números complexos aquele que possui o maior módulo. Esta função deverá retornar
a localização do número encontrado na lista e o valor do seu módulo. Implemente um programa
que realiza a leitura de N números complexos empregando o registro criado e, em seguida, mostra o
número complexo que atende a função elaborada com seu respectivo módulo. Dica: o módulo de um
número complexo z = a + b * i é calculado por: |z| = sqrt(a * a + b * b), onde sqrt
é a função que calcula a raiz quadrada de um número, disponível na biblioteca math.
Forneça a quantidade de números complexos: 2
- Forneça a: 1
- Forneça b: 1
- Forneça a: 2
- Forneça b: 2
Resultado:
z2 = 2.0 + 2.0 * i, |z| = 2.828
Solução:
1 from math import inf, sqrt
2 def modulo_complexos(complexos) :
3
4 N = len(complexos)
5 modulo_max = -inf
6
7 for j in range(N) :
8 modulo = sqrt (complexos[j]["a"]**2 + complexos[j]["b"]**2)
9 if modulo > modulo_max :
10 modulo_max = modulo
11 pos = j
12
13 return pos, modulo

14
15
16 N = int(input('Forneça a quantidade de números complexos: '))

17
18 complexos = [ ]
178
20 complexo = { }
21 print(f'Número complexo z{i+1} = a + b * i')
22 complexo["a"] = float(input('- Forneça a: '))
23 complexo["b"] = float(input('- Forneça b: '))
24 complexos.append(complexo)
25
26 pos, modulo = modulo_complexos(complexos)

27
28 print('\nResultado:')
29 print(f'z{pos+1} = {complexos[pos]["a"]} + {complexos[pos]["b"]} * i,
|z| = {modulo:.3f}')
179

24.1 Conteudo Teorico Livro Texto

Enviado por

Direitos autorais:

Formatos disponíveis

24.1 Conteudo Teorico Livro Texto

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

24.1 Conteudo Teorico Livro Texto

Enviado por

Direitos autorais:

Formatos disponíveis

P ROGRAMAÇÃO DE C OMPUTADORES I – BCC701

C ONTEÚDO T EÓRICO EM L INGUAGEM P YTHON

2024/1 ( VERSÃO 1.2)

E LABORADO PELA C OMISSÃO DE U NIFICAÇÃO DA D ISCIPLINA BCC701,

DECOM – D EPARTAMENTO DE C OMPUTAÇÃO

8 Estruturas Heterogêneas 116

9 Soluções dos Exercícios Propostos 128

Neste capítulo introduzimos alguns conceitos importantes sobre programação de computadores,

1.1 Programas de Computadores

Existem diversas linguagens de programação, listamos alguns exemplos: C; Java; Javascript; e

Escrever um código em Python é semelhante a escrever qualquer sequência de instruções. Con-

É importante praticar e aprimorar os seus conhecimentos na ferramenta de programação esco-

1.3 Programação Estruturada

Figura 1: Estrutura do tipo sequência.

Figura 2: Estrutura do tipo Decisão.

Figura 3: Estrutura do tipo Iteração.

Figura 4: Fluxograma para o Exemplo 1.

Figura 5: Fluxograma para o Exemplo 2.

Observe que agora precisaremos da estrutura de iteração exemplificada na Figura 3. A Figura 6

Figura 6: Fluxograma para o Exemplo 3.

1.5 Dicas para um bom aproveitamento na disciplina

• Tente resolver os exercícios propostos neste livro texto, criando e executando/depurando os

• Matricule-se e participe da Tutoria. Trata-se de uma atividade extraclasse regular, ministrada

• Ao estudar em grupo, certifique-se de que esteja aprendendo o conteúdo e a resolver os

• Exercite regularmente a resolução de exercícios utilizando apenas lápis e papel. As ava-

1.6 Organização deste documento

• Capítulo 2, “Variáveis e Expressões”, apresenta recursos necessários para manipular e processar

• Capítulo 5, “Estrutura de Repetição”, apresenta recursos necessários para a execução de um

• Capítulo 6, “Implementação de Funções”, apresenta recursos necessários para permitir que o

• Capítulo 7, “Estruturas Homogêneas”, apresenta recursos necessários para agregar o armazena-

• Capítulo 8, “Estruturas Heterogêneas”, apresenta recursos necessários para agregar o armazena-

Figura 7: Representação de três variáveis.

2.1 Para que serve uma variável?

2.2 Atribuição de Valores para uma Variável

O lado esquerdo do operador de atribuição (“minha_variavel”) representa o nome da variável.

Um valor a ser atribuído à variável pode ser, por exemplo:

• Um valor inteiro (int): 2, 4, 10, etc.;

• Um valor real (float): 2.7698, 0.0023, etc.;

• Um valor textual (string): “Um texto qualquer”;

• Um valor lógico (boolean): True ou False;

• Outros valores disponibilizados pela linguagem;

2.3 Regras para o nome de uma variável

• Não podem conter espaços;

• Não podem iniciar com números;

• Além de caracteres alfanuméricos, pode conter somente o caractere: “_”;

• Python é case-sensitive (diferencia letras maiúsculas e minúsculas): Nome 6= nome 6= NOME;

Alguns exemplos de nomes válidos em Python:

Alguns exemplos de nomes inválidos em Python:

• 1Aluno (o primeiro caractere é um algarismo)

• total de alunos (tem espaços)

• #funcionarios (o uso do caractere inválido “#”)

• %valor (o uso do caractere inválido “%”)

2.4 Exemplos de utilização de variáveis

Você naturalmente formulará a seguinte expressão para resolver o problema: 2 ∗ x = 3 ∗ y. Mas,

2.5 Tipos de Dados

A linguagem Python permite manipular valores numéricos de variados tipos:

3. float: esse tipo é usado para manipular números reais.

Criar um programa capaz de armazenar a quantidade e o preço de um produto e em seguida,

Exemplo 10: Concatenação de strings: