Exercícios de Python

Para estudantes de
Experimentações de Física I Módulo A
Curso de Graduação em Astronomia

A. Baruffolo
INAF — Observatório Astronômico de Pádua &
Universidade de Padova — Departamento de Física e Astronomia

10 de fevereiro de 2016
Índice de exercícios

1 Introdução 4

2 Uso direto do intérprete Python 5

Exercício 1 Áreas e volumes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Exercício 2 Cálculo do montante .......................... 5
Exercício 3 Conversão de polegadas para centímetros . . . . . . . . . . . . . . . . . . . 5
Exercício 4 Conversione da centimetri a pollici . . . . . . . . . . . . . . . . . . . 5
Exercício 5 Aproximarπ ............................. 5
Exercício 6 Pressão atmosférica . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3 Lista 9
Esercizio 7 Gerar listas .............................. 9
Exercício 8 Liste a fette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Exercício 9 Extração da lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Exercício 10 Contagem de dígitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Exercício 11 Lorem ipsum 10

4 Ciclos 13
Exercício 12 Soma de números naturais com for .................... 13
Exercício 13 Soma de números naturais com while . . . . . . . . . . . . . . . . . 13
Exercício 14 Iterar sobre fatia 13
Exercício 15 A tabuada até 10 . . . . . . . . . . . . . . . . . . . . . . . . . 13
Esercizio 16 Sequência de Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . 14
Exercício 17 Sucessão de Tribonacci . . . . . . . . . . . . . . . . . . . . . . . 14
Exercício 18 Cálculo do montante . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Esercizio 19 Algoritmo de Gauss–Legendre . . . . . . . . . . . . . . . . . . . . . 15
Exercício 20 Triângulo de números ..................... 15
Exercício 21 Triângulo inverso de números . . . . . . . . . . . . . . . . . . . . . . 15
Exercício 22 Triângulo de Floyd . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Exercício 23 Diagonais de’ ’ *............................... 16
Exercício 24 Diagonale inversa di’ ’ * . . . . . . . . . . . . . . . . . . . . . . . 16
Exercício 25 Quadrado de’ ’ *. . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Exercício 26 Retângulo de’ ’ * 17
Exercício 27 Triângulo retângulosinistro di’ ’ 17 *
Exercício 28 Triângulo retângulosinistro e inverso di’ ’ .................. * 17
Exercício 29 Triângulo retângulodestro de’ ’ ........................................18
*
Esercizio 30 Triângulo retângulodestro e inverso de’ ’ 18 *
Exercício 31 Pirâmide de’ ’ em * pés 18
Exercício 32 Triângulo isósceles de’ ’ * 18
Exercício 33 Triângulo isóscelesinvertido di’ ’ 19 *
Exercício 34 Rombo de’ ’ .*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

5 Seleção se 26
Exercício 35 Frio ou quente .................................................. 26
Exercício 36 Números inteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Exercício 37 Verifica ângulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Exercício 38 Ano bissexto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Exercício 39 sexagesimal2decimal27

1
6 Ciclos e seleções 31
Esercizio 40 Iterações com if .................................................. 31
Exercício 41 Ciclo de comandos 31
Exercício 42 Da unidadeà imperiali a métricas . . . . . . . . . . . . . . . . . . . . . 31
Exercício 43 Computador adivinha número . . . . . . . . . . . . . . . . . . . . . . 32
Exercício 44 Computador adivinha número sem truques ................................ 32

7Funções e módulos 37
Exercício 45 Fórmula de Heron . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Esercizio 46 Raízes de equação de segundo grau . . . . . . . . . . . . . . . . . 37
Exercício 47 Ano bissexto, função 38
Exercício 48 Dia do ano . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Exercício 49 Do dia do ano a data 38
Esercizio 50 Páscoa Gregoriana 39
Exercício 51 De decimal para binário . . . . . . . . . . . . . . . . . . . . . . . . . 39
Exercício 52 De decimal para binário, recursivamente . . . . . . . . . . . . . . . . 40
Exercício 53 Um clone debin()40
Exercício 54 De decimal para octal .................................................. 40
Exercício 55 De decimal para octal, recursivamente . . . . . . . . . . . . . . . . . 41
Esercizio 56 Um clone deout(). . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Exercício 57 Números de Thabit 42
Exercício 58 Teorema de Pitágoras 42
Exercício 59 Gráficos de funções . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Exercício 60 Soma dos dígitos de um inteiro . . . . . . . . . . . . . . . . . . . . 42
Exercício 61 Soma dos dígitos de um inteirobis 42
Exercício 62 Algoritmo de Horner . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Exercício 63 Algoritmo de Horner recursivo . . . . . . . . . . . . . . . . . . . . . 43
Exercício 64 Dia Giuliano . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Exercício 65 Dia Giuliano modificado 44
Exercício 66 Números perfeitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Esercizio 67 Crivo de Eratóstenes . . . . . . . . . . . . . . . . . . . . . . . . . 44

8 Série numérico 53
Exercício 68 Série pore. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Exercício 69 Série pore, recursiva . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Exercício 70 Série de Nilakantha . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Exercício 71 Série de Nilakantha recursiva ..................................................................................... 53

9 Números casuais 55
Exercício 72 Lotto (embaralhamento) 55
Exercício 73 Loteria (escolha) 55
Exercício 74 Lotto (índice randômico) . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Exercício 75 Adivinha o número . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

10 Numpy 59
Exercício 76 Soma de inteiros, versão numpy . . . . . . . . . . . . . . . . . . . 59
Exercício 77 Tabellina, versão numpy 59
Exercício 78 Thabit, versão numpy . . . . . . . . . . . . . . . . . . . . . . . . 59
Esercizio 79 Montante, versão numpy . . . . . . . . . . . . . . . . . . . . . . . 59
Exercício 80 Seno e coseno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Exercício 81 Gráficos de funções, numpy 59
Esercizio 82 Gráfico de Celsius–Fahrenheit . . . . . . . . . . . . . . . . . . . . . . 60

2
 Exercício 83 Gráfico de polinômio .......................................................... 60
Exercício 84 Reproduzir gráfico 60
Exercício 85 Crivo de Eratóstenes, versão numpy 61
Exercício 86 Soma cumulativa . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Exercício 87 Verifica soma cumulativa . . . . . . . . . . . . . . . . . . . . . . 61

11 Simulações e Métodos Monte-Carlo 66

Exercício 88 Jogo da Galinha simplificado 66
Exercício 89 Área de Macchia Nera ......................................................... 66
Exercício 90 Representação estocástica dee67

3
Capítulo 1

Introdução

Os exercícios apresentados nesta coleção assumem que o estudante está familiarizado com os conceitos de
Python ilustrado durante o laboratório. Em particular, o estudante deve saber:

como escrever e executar breves programas na janela de editor do IDLE;

come importare moduli ed utilizzare le relative funzioni (limitatamente a quelle usa-

te durante o laboratório). Os módulos utilizados com mais frequência são: math, random,
[Link], numpy, [Link];

como escrever funções curtas com parâmetros opcionais que retornem valores ao chamador;

Alguns construtos utilizados com frequência nestes exercícios são:

Entrada de uma string pelo usuário, através da função cmd = raw input("Stringa
di prompt: ");

Conversão do conteúdo de uma variável em inteiro, através da função int(), em flutuante

ponto, função float(), ou em stringa, função str().

...;
` provável que no texto ou nas soluções propostas haja erros. É muito provável
É `
que haja amplas margens de melhoria, por exemplo, no que diz respeito à clareza. Os leitores são
cortesemente convidados a relatar erros e/ou possíveis melhorias através deemail.

4
Capitolo 2

Uso direto do intérprete Python

Os seguintes exercícios servem para se familiarizar com a forma como números e fórmulas são
escritos de maneira a poderem ser interpretados corretamente por um computador e em particular por
Python. É importante lembrar que:

escrevendo uma expressão e pressionando a tecla Entrar a expressão é avaliada pelo Python
e o resultado escrito na tela;

Os decimais são precedidos pelo ponto ‘.’, e não pela vírgula.

Exercício 1 Áreas e volumes:Aproximando π= 3.14159265 calcular:

1. a circunferência do círculo de raio 3,0 m;
2. a área do mesmo círculo;
3. o volume da esfera com o mesmo raio.

Exercício 2 Cálculo do montante:Sabendo que o montante é dado pela soma

de capitais e juros, ou seja Montante = Capital ·(1 + i), onde i é expresso em percentual,
verificar que o montante de um capital de 1000 €, investido à taxa i= 4% por um ano
ammonta a 1040 e.

Exercício 3 Conversão de polegadas para centímetros:Sabendo que uma polegada equivale

a 2,54 centímetros, converter para centímetros as seguintes medidas:
1. Diâmetro do espelho primário do Celestron C-14 (14 polegadas);
2. Diâmetro do espelho primário do telescópioSalve di Monte Palomar (200 polegadas).

Exercício 4 Conversão de centímetros para polegadas:Sabendo que uma polegada equivale

a 2,54 centímetros, converter em polegadas as seguintes medidas:
1. Diâmetro do espelho primário doTelescópio Nacional Galileu (3,58 m);
2. Diâmetro do espelho primário de cada um dosUnidade Telescópios del VLT (8,20 m).

Exercício 5 Aproximar π: Sabendo que π = 3,14159265358 . . . verifique as

seguinteaproximações:
1. 22/7 é uma aproximação de π com precisão 4 · 10−4
2. 333/106 é uma aproximação de π com precisão 2 ·10−5
3. 355/113 é uma aproximação de π com precisão 8 ·10−8
Dica: calcule primeiro a fração indicada e depois calcule a relação entre a diferença entre a
fração e o valor de π dado acima dividido por π.

5
Exercício 6 Pressione atmosferica: O andamento da pressão atmosférica P,
A pressão medida em atmosferas, em função da altura h (em metros), pode ser aproximada com a
formula:
h
P= 0.9877 100,0 . (2.1)

Calcular a pressão a 1000, 2000 e 4000 metros

6
 Solução do exercício1

>>> pi = 3.14159265
>>> r = 3.0
>>> 2.0 pi
* r*
18.849555900000002
>>> pi *r r*
28.274333850000005
>>> 4./3. pi* r r* r * *
113,09733539999999
O volume também pode ser calculado usando a elevação a potência:
>>> 4./3. pi* r 3* **
113.09733539999999

Soluzione dell’esercizio 2

>>> 1000. (1+4./100.)

*
1040.0

Solução do exercício3

in2cm = 2.54# polegadas para centímetros

>>> 14.0 in2cm#
* diâmetro M1 C14 em cm
35,56
200,0 in2cm#* diâmetro M1 Hale em cm
508,0

Soluzione dell’esercizio 4

>>> in2cm = 2.54# inches to centimeters

3,58 * 100.0 / in2cm# M1 TNG da m a cm e poi in pollici
140.94488188976376
8.20 100.0 / *in2cm# M1 UT de m a cm e depois em polegadas
322.83464566929126

Solução do exercício5

>>> pi=3.14159265358
22./7.
3,142857142857143
>>> (22/7.-pi)/pi
0,00040249943788918174
333./106.
3.141509433962264
(333./106.-pi)/pi
-2,648962704990393e-05
355/113.
3.1415929203539825
(355/113.-pi)/pi
8.491679599397461e-08

7
 Solução do exercício6

>>> h = 1000.0
>>> 0,9877 (h/100,0)
**
0.8835894823558638
>>> h = 2000.0
>>> 0.9877 (h/100.0)
**
0,7807303733299034
>>> h = 4000.0
>>> 0,9877 (h/100,0)
**
0.6095399158398502

8
Capítulo 3

Liste

Exercício 7 Gerar listas:Usando a função range() gerar uma lista contagem

nente:
todos os números inteiros de 1 a 30;
2. todos os números ímpares entre 1 e 30;
todos os números pares entre 1 e 30;
4. liste os números entre 1 e 30 divisíveis por três;
5. liste os números entre 1 e 30 divisíveis por cinco;
6. todos os números inteiros de 30 a 1 (ordem decrescente);
7. todos os números pares de 30 a 1 (ordem decrescente);
8. tutti i numeri da 30 a 1 (ordine decrescente) che sono divisibili per 5.

Exercício 8 Liste a fette:No prompt do IDLE, gerar uma lista com os números de 1 a 30
usando a função range(). Desta lista gerar, usando fatias, outras listas contendo:
Os números entre 11 e 20 (ambos inclusos)
2. os números da lista de partida que são ímpares
3. os números da lista de partida que são pares
4. os números da lista de partida que são divisíveis por três
5. os números da lista de partida que são divisíveis por cinco
6. a lista de partida invertida (= os números de 30 a 1)
7. i numeri della lista di partenza che sono pari in ordine decrescente
8. Os números da lista de partida que são divisíveis por cinco em ordem decrescente

Exercício 9 Extração da lista:Escrever um programa que cria uma lista n com i

números de 1 a 30 e inicializa uma lista vazia p. Então:
1. usando um ciclo foreach, removendo, através do pop(), os números pares da lista e adicionando-os
à fim da lista p;
2. usando um ciclo for, retire os números ímpares da lista utilizando pop() e adicione-os
à fim da lista p;
Atenção ao perigo: o método pop() modifica a lista sobre a qual atua...

Exercício 10 Contagem de dígitos:Escrever um programa que defina o seguinte

lista:
l = [3, 0, 2, 6, 3, 3, 8, 3, 2, 1, 0, 7, 8, 3, 6,
6, 1, 4, 8, 5, 6, 7, 8, 2, 7, 7, 6, 5, 3, 5]

nove
(pode fazer cópia e cola) e uma lista vazia n. Depois, usando o método count() contar
quantas vezes os dígitos de 0 a 9 aparecem ao colocar esses números, em ordem, na lista n. Na
outras palavras, no final da execução, o i-ésimo elemento de ndovr`a deve corresponder ao número de
volte que a cifra aparece em l. Resultado esperado:
[2,2,3,6,1,3,5,4,4,0]

Exercício 11 Lorem ipsum: Escrever um programa que conte quantas vezes cada uma
lettera minuscola dell’alfabeto (compresa la x) compare nel testo Lorem ipsum:

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud
exercício ullamco trabalho, exceto para aliquip ex ea commodo consequat. Duis aute
irure dolor em reprehenderit na voluptade velit esse cillum dolore eu fugiat nulla
pariatur. Excepteur sint occaecat cupidatat non proident, sunt em culpa que officios
deserunt mollit anim id est laborum.

Procedimento:

Fazendo copiar e colar, defina uma variável que contenha o texto Lorem ipsum (lembre-se
que se pode definir uma string em várias linhas colocando uma barra invertida '\' no final da linha, antes
di andar a linha);
converta a stringa em uma lista usando a função list();

definir uma variável alphabet que contenha a string 'abcdefghilmnopqrstuvxz';

inicializar uma lista n_lettervazia que conterá o número de ocorrências para cada uma
letra do alfabeto

iterar sobre todas as letras do alfabeto contidas na variável alphabet, com variável
de iteração l:

–usando o método count() contar quantas vezes aparece em Lorem ipsum;

–adicionar esse número ao final da lista n_letter.

em um segundo ciclo, separado, imprimir na tela todas as letras do alfabeto

lettera e il numero di volte che compare in Lorem ipsum.

Saída esperada (abreviada):

a : 29
b : 3
c : 16
d : 18
e : 37
...
u : 28
v : 3
x : 3
z : 0

10
 Solução do exercício7

1. intervalo(1,31)

2. range(30,0,-1)

3. range(2,31,2)

4. intervalo(3,31,3)

5. faixa(5,31,5)

6. intervalo(30,0,-1)

7. range(30,0,-2)

8. range(30,1,-5)

Solução do exercício8
Posto a = range(1,31):

1. a[10:20]

2. a[::2]

3. a[1::2]

4. a[2::3]

5. a[4::5]

6. a[::-1] ou a[-1::-1] ou a[29::-1]NOTA: o slice [::-1] é da preferir porque fun-

ziona para cada lista, independentemente do seu comprimento. A fatia [29::-1] responde
à solicitação do exercício apenas para uma lista de comprimento menor ou igual a 30.

7. a[::-2]

8. a[::-5]

Solução do exercício9

1. pop_append1.py:
n = range(1,31)
p = []
para i em intervalo(1,16):
[Link]([Link](i))
imprimirp

2. pop_append2.py:
n = range(1,31)
p = []
para i em intervalo(0,15):
[Link]([Link](i))
printp

11
 Solução do exercício10
count_digits.py:
l = [3, 0, 2, 6, 3, 3, 8, 3, 2, 1, 0, 7, 8, 3, 6,
6, 1, 4, 8, 5, 6, 7, 8, 2, 7, 7, 6, 5, 3, 5]
n = []
para i em range(10):
[Link]([Link](i))
printn

Solução do exercício11
contar_lorem_ipsum.py:
Lorem ipsum dolor sit amet, consectetur adipiscing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
Para obter o mínimo de desculpas, quem nos exerceu a atividade de trabalho
nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit na vontade velit esse cillum dolore eu fugiat nulla
pariatur. Excepteur sint occaecat cupidatat non proident, são em
culpa qui officia deserunt mollit anim id est laborum.

ltext = lista(texto)
alphabet = ’abcdefghilmnopqrstuvxz’
n_letter = []

forlinalphabet:
n = [Link](l)
n_letter.append(n)

for i em range(len(alphabet)):
printalphabet[i], ': ', n_letter[i]

12
Capítulo 4

Ciclos

Exercício 12 Soma de números naturais com for:Escreva um programa em Python

Ei, usando um loop for, calcule e mostre na tela a soma dos primeiros 100 números naturais.

Exercício 13 Soma de números naturais com while:Escrever um programa

Python que, usando um ciclo while, calcule e mostre na tela a soma dos primeiros 100 números
naturais.

Exercício 14 Iterar sobre fatia:Escrever um breve programa que gere uma lista
conteúdo os números de 1 a 30 usando a função range(). Usando um loop for:
1. iterar sobre a sub-lista formada por todos os números ímpares (identificados usando slices),
e imprima-os em uma única linha;
2. iterar sobre a sub-lista formada por todos os números pares (identificada usando slices), e
stampem em uma única linha;
3. iterar sobre a sub-lista formada por todos os números divisíveis por cinco (identificada
usando o slice), e imprimi-los em uma única linha.
Dica: Lembre-se que ao colocar uma vírgula no final da instrução print o texto não quebra a linha.

Exercício 15 As tabuadas até 10:Calcular e imprimir na tela as tabuadas

da multiplicação de 1 a 10:
1. usando o ciclo for;
2. usando o ciclo while;
Entre uma tabela e outra, deixe uma linha em branco.
Saída esperada:
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5
1 x 6 = 6
1 x 7 = 7
1 x 8 = 8
1 x 9 = 9
1 x 10 = 10

2 x 1 = 2
2 x 2 = 4

13
 ...
...
10 x 9 = 90
10 x 10 = 100

Exercício 16 Sucessão de Fibonacci:Sabendo que asucessão di Fibonacci e

definida cosí:
N 0= 0
N 1= 1
Nn= Nn−1+ Nn−2por n > 1
e che, portanto, os primeiros sete elementos da sequência são 0, 1, 1, 2, 3, 5, 8, . . ., escrever um
programa que calcula e imprime a sequência até n = 15 (ou seja, uma vez que começa do zero,
os primeiros dezesseis elementos da sequência), usando:
1. um ciclo while;
2. um ciclo for;
Il risultato atteso `e:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610

Esercizio 17 Sucessão de Tribonacci:Sabendo que asucessão di Tribonacci

om
co:)orirentaoicícrxeoajve( ibconaFideoãseucsàaogim
elnadaniifdeé
N 0= 0
N 1= 1
N 2= 1
Nn= Nn−1+ Nn−2 + Nn−3para n >2
e che, então, os primeiros sete elementos da sucessão são 0, 1, 1, 2, 4, 7, 13 . . ., escrever um
programma che calcola e stampa la successione fino a n= 15 (ovvero, siccome si parte da zero,
os primeiros dezesseis elementos da sequência), usando:
1. um ciclo while;
2. um ciclo for;
O resultado esperado é:
0 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136

Exercício 18 Cálculo do montante:Sabendo que o montante M de um capital C

investido à taxa de juro hiper nanni é dado por:
M= C·(1 + i)n
calcular e imprimir na tela o montante ano a ano de um capital de 1000 e, investido
por 10 anos à taxa de 4%. Resultado esperado:
1 1040.0
2 1081,6
3 1124,864
4 1169.85856
5 1216.6529024
6 1265.3190185
7 1315.93177924
8 1368.56905041
9 1423.31181242
10 1480.24428492

14
Exercício 19 Algoritmo de Gauss–Legendre: O algoritmo di Gauss–Legendre e
`
um algoritmo para o cálculo de π conhecido por convergir muito rapidamente. Foi utilizado
repetidamente na segunda metade do século passado para calcular progressivamente de dezenas de
milhões até centenas de bilhões de dígitos de π.
Escrever um programa Python que calcule π usando tal método, conforme descrito emPoços (1986).
Procedimento:
√
defina as variáveis A= 1, X= 1, B= 1/2 e C= 1/4 (atenção à matemática)
interar e lembrar-se de importar as funções/módulos necessários);

definir uma variável inteira niter = 5, número de iterações a serem realizadas;

iterar para nitervolte e em cada passo calcular e imprimir a aproximação de π:

Y= A
A+ B
A=
2
√
B= POR
2
C = C - X · (A - Y)

X = 2X
(A+ B)2
π≈
4C

Verifique se o algoritmo tem ordem de convergência quadrática, ou seja, se o número de dígitos

corrette raddoppia a cada passo da iteração e, na prática, na terceira iteração se atinge a
precisão permitida pelo formato de representação dos números de ponto flutuante (em outras palavras,
o número impresso não muda após o terceiro passo.
Output atteso:
>>>
3.14057925052
3.14159264621
3.14159265359
3.14159265359
3.14159265359
>>>

Exercício 20 Triângulo de números:Escrever uma função que aceite um parâmetro

nintero em entrada e imprime "um triângulo de números", ou seja, n linhas de comprimentos crescentes de
um a n, contendo os números de um ao número da linha. Exemplo:
>>> num_triângulo(5)
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

Exercício 21 Triângulo invertido de números: Escrever uma função que aceite

um parâmetro inteiro como entrada e imprima "um triângulo inverso de números", ou seja, n linhas de
comprimentos decrescentes de um a um, contendo os números de um ao comprimento da linha. Exemplo:

15
>>> num_triangle_inv(5)
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1

Exercício 22 Triângulo de Floyd:Escrever uma função que imprima oTriângulo di

Floyd com um número de linhas especificado pelo usuário, ou seja, um triângulo retângulo de números
naturais em que cada linha é preenchida com números consecutivos, começando de 1 para a primeira linha.
Exemplo:
>>> triangulo_de_floyd(4)
1
2 3
4 5 6
7 8 9 10

Exercício 23 Diagonale de’ ’:Escrever

* um programa que peça ao usuário um
número inteiro n na entrada. O programa então imprime asteriscos '*' na diagonal
* da esquerda.
vira à direita.
Esempio:
Numero: 5
*
*
*
*
*

Dica: Note que, se n é o número de ' ' na diagonal,

* os espaços a imprimir por linha serão
de zero fino a (n−1), no exemplo acima (n−1) = 4.

Exercício 24 Diagonale inversa di’ ’:Escrever

* um programa que solicite ao usuário
tente un numero intero nin input. Il programma poi stampa nasterischi ’ ’ in diagonale* da
direita para esquerda.
Exemplo:
Numero: 5
*
*
*
*
*

Nota: Observe que, se n é o número de ' ' na*diagonal, os espaços a serem impressos por linha vão
de (n−1) fino a zero, no exemplo acima (n−1) = 4.

Exercício 25 Quadrado de’ ’:Escrever

* um programa que peça ao usuário um
numero intero nin input. Il programma poi stampa un quadrato n×ndi asterischi ’ ’. *

dezesseis
Esempio:
Numero: 5
*****
*****
*****
*****
*****
Note que, uma vez que os caracteres na tela não ocupam o mesmo espaço na horizontal e
vertical, o "quadro" resultante não parece quadrado aos nossos olhos.

Exercício 26 Retângulo de' ':Escrever

* um programa que peça ao usuário dois
número inteiro em entrada: número de linhas, r, e número de colunas c. O programa então imprime
um retângulo r×c de asteriscos ' '. *
Exemplo:
Numero righe: 2
Numero colonne: 9
*********
*********
Note que, uma vez que os caracteres na tela não ocupam o mesmo espaço horizontalmente e
vertical, o "quadrado" resultante não parece quadrado aos nossos olhos.

Exercício 27 Triângulo retângulo isóscelesEscrever um programa*

que solicita ao usuário um número inteiro como entrada. O programa então imprime um triângulo
retângulo de asteriscos ’ ’ com
* vértice no canto superior esquerdo, base e altura de n’ ’.*
Exemplo:
Numero: 5
*
**
***
****
*****

Dica: Na prática, trata-se de iterar n vezes, a cada passo imprimindo um número crescente de
partindo
* de um.

Exercício 28 Triângulo retângulo isósceles e inverso de ' ':Escrever um *

programa que solicite ao usuário um número inteiro como entrada. O programa em seguida imprime um
triângulo Retângulo de asteriscos ’ ’ com
* vértice embaixo à esquerda, base e altura de n’ ’. *
Exemplo:
Numero: 5
*****
****
***
**
*

Dica: Na prática, trata-se de iterar n vezes, a cada passo imprimindo um número decrescente.
di ’ ’*partindo da n.

17
Exercício 29 Triângulo retângulo isóscelesEscrever um programa
* que
peça ao usuário um número inteiro como entrada. O programa então imprime um triângulo retângulo
de asteriscos ’ ’ *com vértice para cima à direita, base e altura de n’ ’. *
Esempio:
Numero: 5
*
**
***
****
*****

Dica: Na prática, trata-se de iterar n vezes, a cada passo imprimindo um número decrescente.
de espaços ( ), partindo de n−1, e um número crescente de ’ ’ partindo
* de um.

Exercício 30 Triângulo retângulo direito e inversoEscrever um *

programa que solicita ao usuário um número inteiro como entrada. O programa então imprime
um triângulo retângulo de asteriscos ' ' com
* o vértice na parte inferior direita, base e altura de n ' '. *

Esempio:
Numero: 5
*****
****
***
**
*

Dica: Na prática, trata-se de iterar n vezes, a cada passo imprimindo um número crescente de
espaços ( ), começando do 0, e um número decrescente de ' *' começando de n.

Exercício 31 Pirâmide de pé:Escrever

* um programa que solicite
all’utente un numero intero nin input. Il programma poi stampa una piramide in piedidi
asteriscos ' ',*com base 2n−1 ' ' e altura
* n ' '. *
Exemplo:
Numero: 5
*
**
***
****
*****
****
***
**
*

Dica: Reutilizar o que foi feito para os exercícios27 e28.

Exercício 32 Triângulo isósceles de':Escrever um

* programa que peça ao u-
tente um número inteiro como entrada. O programa então imprime um triângulo isósceles de asteriscos
’ *’ com vértice para cima e altura de *n’ ’.

18
Esempio:
Numero: 6
*
***
*****
*******
*********
***********

Dica: Na prática, trata-se de iterar n vezes, começando do zero, a cada passo imprimindo um
número decrescente de espaços e (2i + 1) ' ', *onde i é a variável de iteração.

Exercício 33 Triângulo isósceles capovolto de ' ':Escrever um programa

* que
peça ao usuário um número inteiro como entrada. O programa então imprime um triângulo isósceles
capovoltodi asterischi ’ ’ com* base em alto e altura de n’ ’. *
Exemplo:
Numero: 5
*********
*******
*****
***
*

Dica: Na prática, trata-se de iterar n vezes, começando do zero, a cada passo imprimindo um
número crescente de espaços ( ), começando de 0, e um número decrescente de ’*’ igual a 2·(n−i)−1,
dove è la variabile di iterazione.

Exercício 34 Rombo di’ ’:Escrever

* um programa que solicite ao usuário um
numero intero nin input. Il programma poi stampa un rombo di asterischi ’ ’, avente* diagonale
maior ou igual à diagonal menor e igual a base2n−1 ’ ’. *
Exemplo:
Numero: 5
*
***
*****
*******
*********
*******
*****
***
*

Dica: Reutilizar o que foi feito para os exercícios32 e33.

19
 Solução do exercício12
somma_100_for.py:
# Calcule a soma dos primeiros 100
# números naturais usando um ciclo for
somma = 0
para i em intervalo(1,101):
somma += i
printsomma

Solução do exercício13
somma_100_while.py:
# Calcule a soma dos primeiros 100
# números naturais usando um ciclo while
somma = 0
i = 1
enquanto i <= 100:
somma += i
i += 1
printsomma

Solução do exercício14

1. for_dispari.py:
a =range(1,31)
fornina[::2]:
imprimir
imprimir

Saída no IDLE:
1 3 5 7 9 11 13 15 17 19 21 23 25 27 29

2. for_pari.py:
a = range(1,31)
fornina[1::2]:
imprimirn
imprimir

Saída no IDLE:
2 4 6 8 10 12 14 16 18 20 22 24 26 28 30

3. for_multipli_5.py:
a =range(1,31)
fornina[4::5]:
imprimirn,
imprimir

Saída no IDLE:
5 10 15 20 25 30

20
 Solução do exercício15

1. tabelline_10_for.py:
para i no intervalo(1,11):
para i na faixa(1,11):
printi, " x ", j, " = ", i j *
imprimir

2. tabelline_10_while.py:
i = 1
enquanto i <= 10:
j = 1
enquanto j <= 10:
printi, " x ", j, " = ", i j *
j +=1
i += 1
imprimir

Solução do exercício16

1. fibonacci_while.py:
# Calcula a sequência de Fibonacci
# através do ciclo while
n0 = 0
n1 = 1
# Mostro na tela os dois primeiros
printn0, n1,
# já os tenho impressos, calculo os restantes
i = 2
enquanto i < 16:
temp = n0
n0 = n1
n1 = n1 + temp
printn1,
i += 1

2. fibonacci_for.py:
# Calcule a sequência de Fibonacci
# através do ciclo for
n0 = 0
n1 = 1
# Exibo na tela os primeiros dois
imprimir n0, n1,
# eu já os tenho impressos, calculo os restantes 14
para i em range(14):
temp = n0
n0 = n1
n1 = n1 + temp
printn1,

21
 Soluzione dell’esercizio 17

1. tribonacci_while.py:
# Calcula a sequência de Tribonacci
# através do ciclo while
n0 = 0
n1 = 1
n2 = 1
Stampo a schermo os três primeiros
imprimirn0, n1, n2,
# já os imprimi, calculo os restantes
i = 3
enquanto i <= 15:
t0 = n0
t1 = n1
n0 = n1
n1 = n2
n2 = n2 + t0 + t1
imprimirn2,
i += 1

2. tribonacci_for.py:
# Calcule a sequência de Tribonacci
# tramite ciclo for
n0 = 0
n1 = 1
n2 = 1
Stampo a tela os três primeiros
printn0, n1, n2,
# tre li ho já estampados, cálculo os restantes 13
for i in range(13):
t0 = n0
t1 = n1
n0 = n1
n1 = n2
n2 = n2 + t0 + t1
printn2,

Solução do exercício18
Diamo due possibili soluzioni, lo studente `e incoraggiato a capire il funzionamento di entrambe.
1. [Link]:
capitale = 1000
i = 0,04 # tasso di interesse
upi = 1.0+i# uno piu‘ i
montante = capitale
para i na faixa(1,11):
montante =* upi
printj, montante

22
 2. [Link]:
capitale = 1000
i = 0.04 # tasso di interesse
upi = 1.0+i# um mais i
montante = capitale
forjin intervalo(1,11):
montante = capitale * upi **j
printj, montante

Solução do exercício19
gauss_legendre_pi.py
frommathimportsqrt
A = 1
X = 1
B = 1.0/sqrt(2)
C = 0.25
ApB = A + B
niter = 5
for i em range(niter):
Y = A
A = ApB/2,0
B = raiz(B Y)*
C -= X *(A-Y) (A-Y)
*
X = 2.0 *X
ApB = (A+B)
pi_approx = ApB ApB/(4.0
* C) *
aproximar_pi

Soluzione dell’esercizio 20
prog_num_triangle.py
n = int(input("Número: "));
paraan 1,n+1):
parajin intervalo(1,i+1):
printj
imprimir’’

Solução do exercício21
prog_num_triangle_inv.py:
n = int(input("Número: "));
for i in range(n):
forjin range(1,n-i+1):
printj,
imprimir’’

Solução do exercício22
floyds_triangle.py:
deffloyds_triangle(n):
k = 1
para i em range(n):

23
 parajin faixa(0,i+1):
printk,
k += 1
imprimir''

Solução do exercício23
diag_pat.py:
n = int(input("Número: "));
para i em range(n):
imprimir' ' i+'
* ' *

Solução do exercício24
inv_diag_pat.py:
n =int(raw_input("Numero: "));
para i em range(n-1, -1, -1):
imprimir' ' i+'
* ' *

Solução do exercício25
square_pat.py:
n = int(input("Número: "));
para i em range(n):
print’ ’ n* *

Solução do exercício26
rect_pat.py
r =int(raw_input("Numero righe: "));
c = int(input('Número de colunas: '));
for i em range(r):
imprimir''* c*

Solução do exercício27
ltriangle_pat.py:
n = int(input("Número: "));
for i in range(1, n + 1):
print’ ’ i * *

Solução do exercício28
inv_ltriangle_pat.py:
n = int(raw_input("Número: "));
para i em intervalo(n, 0, -1):
imprimir' *' i*

Solução do exercício29
rtriangle_pat.py:
n = int(input("Número: "));
para i em range(1, n + 1):
imprimir' ' *(n-i)+' ' i * *

24
 Solução do exercício30
inv_rtriangle_pat.py:
n = int(input("Número: "));
para i em range(n, 0, -1):
print’ ’ (n-i)+’
* ’ i * *

Solução do exercício31
di_ltriangle_pat.py:
n = int(input("Número: "));
for i na faixa(1, n + 1):
print’ ’ (n-i)+’
* ’ i * *
para i em range(n-1, 0, -1):
imprimir' ' (n-i)+
* ' ' i* *

Soluzione dell’esercizio 32
tree_pat.py:
n = int(input("Número: "));
para i em range(n):
na = 2 *i+1# número asteriscos
ns = n-i-1 # número de espaços
imprimir' ' *ns+' ' *na*

Solução do exercício33
inv_tree_pat.py:
n = int(input("Número: "));
for i in range(n):
na = 2 *(n-i)-1# número asteriscos
ns = i # numero spazi
print’ ’ ns+’* ’ na * *

Solução do exercício34
diamond_pat.py
n =int(raw_input("Numero: "));
# Parte "sopra"
para i em range(n):
na = 2 *i+1
ns = n-i-1
imprimir' ' ns+
* ' ' *na+* ' ' ns *
# Parte "sotto", notare che
# O intervalo começa em 1.
para i em range(1,n):
na = 2 *(n-i)-1
ns = i
imprimir ' ' ns
* + ' ' *na* + ' ' ns *

25
Capitolo 5

Selecione

Exercício 35 Frio ou quente:Escrever um programa que peça ao usuário

um número. Como a função raw input() retorna uma string, converter a entrada em número
com a função float(). Supondo interpretar o número como uma temperatura em graus
Celsius, verificar se o número é:

menor que -15, em caso afirmativo escreva na tela "frio polar!";

maior ou igual a -15 e menor que 0, em caso afirmativo escreva "muito frio";

maior ou igual a 0 e menor que 18, em caso afirmativo escrever "frio";

maior ou igual a 18 e menor que 26, em caso afirmativo escreva "morno";

maior ou igual a 26 e menor que 32, em caso afirmativo escrever "calor";

maior que 32, em caso afirmativo escrever "tórrido!";

Exercício 36 Números inteiros:Escrever um programa que peça ao usuário

um número inteiro. Como a função raw input() retorna uma string, converter a entrada em
número inteiro com a função int(). Depois verifique se o número é:

divisível por dois, em caso afirmativo escreva "par" em saída, caso contrário escreva
dispari

divisível por três, em caso afirmativo escrever "divisível por três";

divisível por cinco, em caso afirmativo escreva "divisível por cinco";

Note que a função int() retorna um erro se a entrada não for uma string convertível em
número inteiro.

Exercício 37 Verifique o ângulo:Escrever um programa que peça input ao usuário

um número. Como a função raw input() retorna uma string, converta a entrada em número
com a função float(). Supondo interpretar o número como um ângulo em graus,
verifique se o número é:

menor que zero ou maior ou igual a 360, em caso afirmativo escreva na tela "Ângulo
fora do intervalo.

uguale a zero, in caso affermativo scrivere "Angolo nullo."

maior que zero e menor que 90, em caso afirmativo escrever 'Primeiro quadrante.'

26
 igual a 90, em caso afirmativo escreva 'Ângulo reto.'

maior que 90 e menor que 180, em caso afirmativo escreva "Segundo quadrante."

igual a 180, em caso afirmativo escrever "Ângulo plano."

maior que 180 e menor que 270, em caso afirmativo escreva "Terceiro quadrante."

igual a 270, em caso afirmativo escrevaEsplementardo ângulo reto

maior que 270, em caso afirmativo escrever "Quarto quadrante."

Exercício 38 Ano bissexto:Escrever um programa que peça ao usuário para inserir

um número (inteiro positivo), que represente um ano. O programa, utilizando a seleção
se, estabelece se o número corresponde a um anobissexto, no qual caso escreve na tela
"ano bissexto", caso contrário escreve "não bissexto". Para determinar se um ano é bissexto ou
menos (vejao algoritmo em Wikipedia):

se o número não é divisível por 4 não é bissexto;

caso contrário, se não for divisível por 100, é bissexto;

caso contrário, se não for divisível por 400, não é bissexto;

em todos os outros casos é bissexto.

Verifique o programa com os seguintes valores:

Anos bissextos: 2000, 2400, 1872, 1984, 1996, 2016;

Anos não bissextos: 1700, 1800, 1900, 1999, 2001, 2015.

Exercício 39 sessagesimal2decimal: Escrever um programa Python que converta

um ângulo expresso em graus no formato sexagesimal em formato decimal. A entrada esperada é
uma string do tipo "dd:pp:ss", onde dd representa os graus, número inteiro no intervalo
[0,360), pprappresenta os minutos, um número inteiro no intervalo [0,59) e ssrappresemta os segundos,
número inteiro no intervalo [0,59).
O usuário deve sempre especificar os primeiros e os segundos usando dois dígitos, sendo o primeiro dos quais deve
ser 0 se os primeiros ou os segundos são menores que 10. Portanto, o comprimento da string de entrada
pu`o variare a seconda del numero di cifre utilizzate per i gradi. Ne consegue inoltre che le cifre
as que compõem o número de segundos são sempre os dois últimos da string. De forma semelhante
os números dos primeiros e dos graus são obtidos especificando fatias apropriadas a partir do final
da stringa.
Procedimento:
através da função raw_input() solicitar ao usuário uma string contendo a representação
representação sexagesimal de um ângulo;

se o caractere ':' não está presente na string nas posições esperadas (especificadas a partir
do final da stringa), escreva uma mensagem de erro;

caso contrário, extraia as substrings (por meio de fatiamento como dito acima) correspondentes aos graus,
primi e secondi e convertere-os em números de ponto flutuante através da função float();

se o número de graus está fora do intervalo [0,360) escreva uma mensagem de erro;

27
 caso contrário, se o número de primos estiver fora do intervalo [0,59), escreva uma mensagem
de erro;

caso contrário, se o número de segundos estiver fora do intervalo [0,59), escreva uma mensagem
de erro;

caso contrário, converta os graus em decimais:

dec = dd + (pp + ss/60)/60

e imprimir na tela o valor obtido.

Exemplo de execução:
>>>
Angolo: 1:02:03
Angolo decimale: 1.03416666667
>>>
Angolo: 1:2:3
Erro de formato
>>>
Angolo: 1:99:00
Erro nos primeiros

28
 Solução do exercício35
freddo_o_caldo.py:
temp =float(raw_input("Temperatura: "))

se temperatura < -15:

freddo polare!
eliftemp < 0:
muito frio
eliftemp < 18:
print"freddo"
eliftemp < 26:
tiepido
eliftemp < 32:
caldo
caso contrário:
torrido!
Soluzione dell’esercizio 36
numero_intero.py:
num = int(input("Número: "))
se num % 2:
imprimir 'dispari'
senão:
print"pari"
se(num % 3) == 0:
divisível por três
se(num % 5) == 0:
divisível por cinco
Solução do exercício37
verifica_angolo.py:
ang =float(raw_input("Angolo: "))

se fang < 0 ou >= 360:

Angolo fora do intervalo
elifang == 0:
Angulo nulo
elifang < 90:
Primo quadrante
elifang == 90:
Angulo reto
elifang < 180:
Segundo quadrante
elifang == 180:
Ângulo plano
elifang < 270:
print"Terceiro quadrante"
elifang == 270:
Esplementar do ângulo reto
senão:
Quarto quadrante

29
 Solução do exercício38
anno_bisestile.py:
y =int(raw_input("Anno: "))
ify % 4:
não bissexto
elify % 100:
impar
elify % 400:
imprimir "não bissexto"
senão:
imprimir "bisestile"

Solução do exercício ??
[Link]:
ang =raw_input("Angolo: ")
ifang[-3] != ':' orang[-6] != ':':
Erro de formato
senão:
dd = float(ang[:-6])
pp = float(ang[-5:-3])
ss = float(ang[-2:])
se dd < 0 ou dd > 359:
Errore nos graus
elif pp < 0 or pp > 59:
Errore nos primeiros
elifss < 0ou ss > 59:
Erro nos segundos
senão:
dec = dd + (pp + ss/60.)/60.
print"Ângulo decimal:",dec

30
Capítulo 6

Ciclos e seleções

Exercício 40 Iterações com if:Scrivere un breve programma che generi una lista
contendo os números de 1 a 30 usando a função range(). Usando um loop for, itere sobre
todos os elementos da lista, e imprima-os, em uma única linha:
1. os números da lista de partida que são ímpares
2. os números da lista de partida que são pares
Os números da lista de partida que são divisíveis por cinco
use a instrução if para verificar as condições necessárias.

Exercício 41 Ciclo de comandos:Escrever um programa que, dentro de um ciclo

enquantoinfinito:

imprima na tela a mensagem "Comando: ";

memorizza a stringa escrita pelo usuário em uma variável cmd;

se a stringa no cmd é igual a "end" termine o ciclo (e a execução do programa),

Dica: para os primeiros dois pontos, use a instrução cmd =raw_input("Comando: ").

Exercício 42 Das unidades imperiais para métricas:Escrever um programa que converta

de comprimentos de unidades imperiais para métricas, interativamente e limitadamente à conversão
da yarde a metri, da piedi a decimetri e da pollici a centimetri. I fattori di conversione sono:
100= 2,54cm, 10= 1200e 1y = 30 , onde indica00 polegadas, pés0 e y indica jardas.
O programa deve iterar enquanto o usuário inserir uma string vazia (ou seja, pressionar Entrar
ao prompt sem inserir nenhum caractere). O usuário especifica a medida como um número (real)
seguido do apóstrofo duplo para indicar polegadas, apóstrofo simples para indicar pés e o caractere y
para indicar as jardas. Se a string inserida pelo usuário não termina com um dos caracteres que
indicano l’unit`a di misure il programma scrive a schermo un messaggio di errore e prosegue con
as iterações.1
Exemplo de execução:
>>>
Medida a converter: 1"
1" = 2.54 cm
Medida a converter: 2,1’
2,1' = 6,4008 dm
Medida a converter: 3.245y
1
Não se verifica se os caracteres antes da unidade de medida representam um número real válido porque isso
requer conhecimentos que não aprendemos em laboratório.

31
3.245y = 2.967228 m
Misura da convertire: 12
não entendo...
Misura da convertire:
>>>

Exercício 43 Computador adivinha número: Escreva um programa que procure

di adivinhar um número entre 1 e 100 pensado pelo usuário. O programa usará o método de
bisseção, em cada iteração dividindo ao meio o intervalo de números em que se encontra o que foi pensado
do usuário. Procedimento:

Escreva na tela as seguintes instruções

Pense em um número (inteiro) de 1 a 100.

Escreva '+' se o número que você pensou é maior,
escreva '-' se for menor, ou 'y' se eu acertei.

defina as variáveis low = 1 e high = 101;

iterare all’infinito
defina a variável guesspari como (low+high)/2;
–usando raw_input() perguntar ao usuário se o número que ele pensou é igual ao valor
di indovinare (convertido em stringa com str()) e atribuir o texto digitado pelo usuário
à variável res;
–se res`e uguale a 'y', o programa adivinhou, interrompa o ciclo;
se res`e igual a '+' coloque low igual a guess;
–se res`e igual a ’-’ colocar highigual a guess;
–caso contrário, escreva na tela: "Não entendi..."

Escreva na tela "Eu adivinhei!"

Exemplo:
Pense em um número (inteiro) de 1 a 100.
Escreva '+' se o número que você pensou é maior,
escreva '-' se for menor, ou 'y' se eu acertei.
O número que você pensou é 51?
O número que você pensou é 76?
O número que você pensou é 88?
O número que você pensou é 82?
O número que você pensou é 85?
O número que você pensou é 83?
Eu adivinhei!

Exercício 44 Computador adivinha número sem truques:O programa escri-

ao Exercício43 não é robusto, no sentido de que não percebe se o usuário está trapaceando (por exemplo.
respondendo sempre ’-’ ou sempre ’+’ ou alternando tais respostas).
Você poderia modificar o programa para identificar a trapaça e encerrar a execução? (E mais) `
facil do que parece.)
Dica: Note que, se você trapacear nas respostas, em certo ponto o valor de palpite...
Exemplo:

32
Pense em um número (inteiro) de 1 a 100.
Scrivi ’+’ se il numero che hai pensato e‘ piu‘ grande,
escreva '-' se for menor, ou 'y' se eu acertei.
O número que você pensou é 51?
O número que você pensou é 76?
O número que você pensou é 63?
O número que você pensou é 69?
O número que você pensou é 66?
O número que você pensou é 67?
O número que você pensou é 66?
Você está trapaceando e eu não jogo mais

33
 Solução do exercício40

1. for_and_if_dispari.py:
a = intervalo(1,31)
fornina:
se n % 2 == 1:
imprimirn
imprimir

2. for_e_if_pari.py:
a =range(1,31)
fornina:
se n % 2 == 0:
printn,
imprimir

3. for_and_if_multipli_5.py:
a = range(1,31)
fornina:
ifn % 5 == 0:
printn
imprimir

Solução do exercício41
[Link]:
enquantoVerdadeiro:

cmd =raw_input("Command: ")

comando de impressão

secmd == "fim":
quebrar

Solução do exercício42
[Link]:
in2cm = 2.54
ft2dm = in2cm * 1.2
y2m = ft2dm * 0,3

enquantoVerdadeiro:

dat =raw_input("Misura da convertire: ")

se o dado == "":
pausa
elifdat[-1] == '"':
inches =float(dat[:-1])
cm = inches * em2cm
printdat,'=',cm,'cm'
elifdat[-1] == "’":
pés = float(dat[:-1])
dm = feet * ft2dm

34
 printdat,'=',dm,'dm'
elifdat[-1] == 'y':
yards =float(dat[:-1])
m = jardas * y2m
imprimir dados,'=',m,'m'
senão:
não entendo...

Solução do exercício43
computer_indovina_numero.py:
Pense em um número (inteiro) de 1 a 100.
escreva ‘+’ se o número que você pensou é maior,
escreva '-' se for menor, ou 'y' se eu acertei.
low = 1
high = 101
enquantoVerdadeiro:

palpite = (alto+baixo)/2
res =raw_input("Il numero che hai pensato e‘ "+str(guess)+"? ")
se 'y':
quebrar
elifres == '+' :
low = guess
elifres == '-'
high = guess
senão:
Não entendi...
Eu adivinhei!

Solução do exercício44
computador_adivinha_numero_robusto.py
Pense em um número (inteiro) de 1 a 100.
Escreva '+' se o número que você pensou é maior,
escreva '-' se for menor, ou 'y' se eu acertei.
low = 1
high = 101
guess = 0
enquantoVerdadeiro:

nova_chute = (alto+baixo)/2
se_chute == novo_chute:
Você está trapaceando e eu não jogo mais.
quebrar
palpite = novo_palpite
res = input("O número que você pensou é '" + str(guess) + "'? ")
se as refeições == 'y':

Eu adivinhei!
quebrar
elifres == '+' :
low = guess
elifres == '-'
high = guess
senão:

35
Não entendi...

36
 Capítulo 7

Funções e módulos

Exercício 45 Fórmula de Heron:Sabendo que afórmula di Erone:

A= p·(p−a)
p ·(p−b) ·(p−c)

permite calcular a área de um triângulo conhecendo os comprimentos de seus três lados (a, b, c) e

a+ b+ c
p=
2
quee)doasldosom
co(sinpterosm
ârpatesêrtetiecaqueouãnçm
fvaercseo,m
rím
etsrpeoie
retorne a área do triângulo correspondente calculada usando a fórmula de Heron.
Dica: para calcular a raiz quadrada, use a função sqrt() do módulo math.

Exercício 46 Raízes de equação de segundo grau:Escrever uma função que

calcoli le radici di una equação de segundo grado, ou seja:

ax2+ bx + c = 0.

Procedimento:

defina uma função que aceite três parâmetros (correspondentes a a, b e c);

se a = 0, escreva uma mensagem de erro e execute return sem parâmetros;

calcular o discriminante ∆ = b2-4ac;

se ∆ <0, a equação não tem raízes reais, executar retorno sem parâmetros;

se ∆ = 0, a equação tem duas soluções coincidentes, retornar −b/2a;

caso contrário, retornar as duas soluções:

√ √
x 1= −b−∆ ; x 2= -b+ ∆ .
2a 2a
Usar a função para encontrar as raízes de:

x2-5x + 6 = 0 [2; 3]
2x2−3x−5 = 0 [−1; 2.5]

37
Exercício 47 Ano bissexto, função:Transformar o programa do Exercício38
em uma função que aceite um inteiro como parâmetro de entrada e que retorne verdadeiro se o número
corrisponde ad un anno bisestile o False in caso contrario.

Exercício 48 Giorno dell’anno: Escrever uma função que aceite três parâmetros inteiros
que representam dia, mês e ano de uma certa data e que calcule os dias transcorridos desde o início
do ano naquela data. Por exemplo, para o primeiro de janeiro (de qualquer ano) o resultado será
1, o dia seguinte será 2, e assim por diante. Para as datas posteriores a 28 de fevereiro, o resultado muda para
segundo se o ano é bissexto ou não. Para isso, utilize a função escrita como solução
do Exercício47. Procedimento:

definir uma função que aceite três parâmetros: dia, mês e ano;

definire una lista contenente i giorni di ciascun mese dell’anno (in ordine da gennaio a
dezembro);

se o ano passado em entrada é bissexto, colocar o segundo elemento da lista igual a 29;

verificar se o número do mês está entre 1 e 12, caso contrário escrever a

exibir uma mensagem de erro e retornar zero;

verificar se o dia especificado está entre 1 e o número de dias do mês

st’ultimo preso dalla lista preparata in precedenza) in caso contrario scrivere a schermo
uma mensagem de erro e retornar zero;

inicializar a zero uma variável (por ex. dia do ano) que conterá o resultado;

por todos os meses de janeiro até o mês anterior à data especificada, iterar sobre a lista
dei giorni di ciascun mese e sommarli alla variabile dia do ano;

adicionar os dias da data considerada (parâmetro dia, em entrada);

retornar o resultado ao chamador.

Experimente a função com as seguintes datas:

dados doy
1 gennaio 1
31 de janeiro 31
1 marzo 2015 60
1 marzo 2016 61
28 ottobre 2015 301
28 ottobre 2016 302
31 dicembre 1900 365
31 de dezembro de 2000 366

Esercizio 49 De dia do ano a data:Escrever uma função inversa em relação a

aquela descrita no Exercício48. A função aceita como entrada dois parâmetros, dia do ano
e ano, e calcula a data correspondente.
Verifique a função com as datas do Exercício48.
Dica: itere sobre a lista dos dias do mês, construída como no Exercício48. Finch`e il giorno
do ano `é maior dos dias no mês considerado, subtrair estes últimos do primeiro. Ao
Ao final da iteração, a variável dia do ano conterá o dia da data procurada...

38
Exercício 50 Páscoa Gregoriana:Escrever uma função Python que calcule o dia
em que cai a Páscoa nocalendário Gregoriano, portanto para os anos seguintes a 1582, segundo
o método ilustrado no Capítulo 8 de Meeus (1991).
Procedimento:
definir uma função que aceite um único parâmetro ano;
forçar, através da função int(), a variável ano a conter um valor inteiro;

efetuar os seguintes cálculos, armazenando os valores em variáveis com o mesmo nome das
quantita` indicate:
Dividir por quociente resto
ano 19 - a
ano 100 b c
b 4 d e
b+8 25 f -
b−f+ 1 3 g -
19a + b - d - g + 15 30 - h
c 4 eu k
32 + 2e + 2i - h - k 7 - l
a+ 11h+ 22l 451 m -
h+ l−7m+ 114 31 n p
onde por quociente e resto entendem-se aqueles obtidos por meio da divisão inteira1

a questo punto il numero del mese in cui cade la Pasqua (3 o 4, marzo o aprile) `e contenuto
na variável n, enquanto o número do dia é dado por p+1.

retornar a data da Páscoa como uma única string do tipo 'ano-mês-dia'

(por exemplo '2015-4-5'), utilizando a função str() para converter as variáveis
números em string e o operador de concatenação de strings +.

Verifique a função escrita com as seguintes datas:

ano mês dia

1950 4 9
1999 4 4
2000 4 23
2016 3 27
2022 4 17

Exercício 51 De decimal para binário: Escrever uma função que converta um

numero intero positivo in una stringa contenente la rappresentazione del numero in binario.
Procedimento:
definir uma função que aceita um único parâmetro: n;

inicializar uma variável com uma string vazia;

se não é inteiro ou se é negativo:

imprimir uma mensagem de erro e retornar a string vazia b;

forçar n a ser variável de tipo inteiro n =int(n)
1
Por exemplo, o quociente e o resto da divisão inteira 2015/15 são, respectivamente, 134 e 5.

39
 iterar enquanto n for diferente de zero;
–se o resto da divisão inteira de n por dois é diferente de zero, colocar b = '1' + b
–caso contrário, coloque b = '0'+b
–atribuir a nil o resultado da sua divisão inteira por 2

retornar '0b'+b
Verifique a função comparando o resultado com a função bin(), por exemplo:
>>> dec2bin(7)
'0b111'
>>>bin(7)
’0b111’
>>> dec2bin(1234)
’0b10011010010’
>>>bin(1234)
’0b10011010010
>>> dec2bin(7) == bin(7)
Verdadeiro
>>> dec2bin(1234) == bin(1234)
Verdadeiro

Exercício 52 De decimal a binário, recursivamente: Escrever uma função

recursiva que converte um número inteiro positivo em uma string contendo a representação
do número em binário. Procedimento:
definir uma função que aceita um único parâmetro: n;

se não é inteiro ou se é negativo: retornar uma mensagem de erro;

caso contrário, se o número for zero, retornar a string vazia '';

caso contrário, retorna o resultado da chamada recursiva com o parâmetro o número dividido por dois;
piu` a representação em string do resto da divisão inteira por dois;
Confrontar o resultado da função escrita com o resultado de bin(). Exemplo:
>>> dec2bin_rec(1234)
10011010010
>>>bin(1234)
’0b10011010010’

Exercício 53 Um clone dibin():Escrever uma função que, usando a que foi escrita
como solução do Exercício52, ritorni la rappresentazione binaria del numero intero in input
como uma string que começa com '0b', da mesma forma que a função bin(). Exemplo:
>>> bin_clone(4321)
’0b1000011100001’
>>>binário(4321)
’0b1000011100001’

Exercício 54 Da decimale a ottale: Escrever uma função que converta um número

intero positivo em uma string contendo a representação do número em octal. Procedimen-
to:

40
 definir uma função que aceita um único parâmetro: n;

inicializar uma variável como uma string vazia;

se não é inteiro ou se é negativo:

imprimir uma mensagem de erro e retornar a string vazia ou;

forçar n a ser variável de tipo inteiro n =int(n)

iterar enquanto n for diferente de zero;

–porre igual à representação em string do resto da divisão inteira de n
por 8 mais o;
–atribuir a nil o resultado da sua divisão inteira por 8.

retornar ’0’+o
Verifique a função comparando o resultado com a função oct(), por exemplo:

Exercício 55 De decimal para octal, recursivamente:Escrever uma função recursiva

siva que converte um número inteiro positivo em uma string contendo a representação do
número em octal. Procedimento:
definir uma função que aceita um único parâmetro;

verificar se o número de entrada é menor que zero, se for, retornar uma mensagem de
errore;
caso contrário, se o número for zero, retornar a string vazia '';

caso contrário, retorna o resultado da chamada recursiva com o parâmetro do número dividido por oito;
piu` a representacao em string do resto da divisao inteira por oito;
Compare o resultado da função escrita com o resultado de oct(). Exemplo:
>>> dec2oct_rec(1234)
2322
>>>oct(1234)
’02322’
>>> dec2oct_rec(4321)
10341
>>>oct(4321)
’010341’

Exercício 56 Um clone dioct():Escrever uma função que, usando a que foi escrita
como solução do Exercício55, retorna a representação binária do número inteiro de entrada
como uma string que começa com '0', da mesma forma que feito pela função oct(). Exemplo:
>>> clonar_oct(1234)
’02322’
>>>oct(1234)
02322
>>> oct_clone(4321)
’010341’
>>>oct(4321)
’010341’

41
Exercício 57 Números de Thabit:Escrever uma função que, dado um inteiro positivo
nin input, calcoli ilnúmero di Thabit: 3 ·2n-1. Verifique se o número resultante, em
binário, é composto por '10' seguido de n'1' (com base no que foi visto na aula a respeito de
representação dos números inteiros positivos, vocês sabem explicar o por quê?)
Exemplo:
>>> thabit(5)
95
>>>bin(95)
’0b1011111’

Exercício 58 Teorema de Pitágoras:Escrever uma função que aceite dois parâmetros

de entrada, interpretados como comprimentos dos catetos de um triângulo retângulo, e que calcule a
√
comprimento da hipotenusa usando oTeorema di Pitágoras: c = a2+ b2(onde evidentemente a e
b são os comprimentos dos catetos, c o da hipotenusa e assume-se a geometria euclidiana).

Exercício 59 Gráficos de funções:Escrever funções que façam o gráfico de:

1. y= sen(x) em [−π, π]
2. y = cos(x) em [−π, π]
3. y= log(x) em [1,100]
4. y = exem [0,5]
Defina as funções com três parâmetros opcionais: xmin, xmax e npts, número de pontos a
Grafique. Escolham os valores padrão de forma adequada, dependendo da função. Lembrem-se
as funções seno, cosseno, logaritmo e exponencial, assim como π, são definidas no módulo
matemática.

Esercizio 60 Soma dos dígitos de um inteiro:Escrever uma função que, dado

um inteiro como parâmetro de entrada, calcule a soma dos dígitos que o compõem, de acordo com o
seguinte procedimento:

verifique se o parâmetro de entrada nsia um inteiro, caso contrário escreva na tela

uma mensagem de erro e retornar zero;

atribuir a nil o resultado da função int() aplicada a n (para garantir que a variável
sia de tipo inteiro)

inicializar a zero uma variável que conterá o resultado;

iterar enquanto n for maior que zero:

–somar a nil resto da divisão inteira de nper dez;

atribuir a nil o resultado da sua divisão inteira por dez;

retornar o valor de s.

Esercizio 61 Soma dos dígitos de um número inteiro:Escrever uma função que, dado
um inteiro como parâmetro de entrada, calcule a soma dos dígitos que o compõem, de acordo com o
seguente procedimento:

verificar se o parâmetro de entrada nsi é um inteiro, caso contrário escrever na tela

uma mensagem de erro e retornar zero;

assegnare ad una variabile nsil valore di nconvertito in stringa;

42
 inicializar a zero uma variável que conterá o resultado;

iterar sobre todos os caracteres de nse somar ao valor da variável de iteração

convertido para inteiro;

retornar o valor de s.

Exercício 62 Algoritmo de Horner:Escrever uma função que avalie um polinômio

definido como:

PN(x) = aMxM+ a(M −1)xM −1. . .+ a 2 x2+ a1 x + a0

em um dado ponto x0 , por meio deo algoritmo di Horner, de acordo com o seguinte procedimento:
definir uma função que aceite dois parâmetros. Sendo o primeiro, x0, o ponto onde se quer
avaliar o polinômio e o segundo, coeffs, uma lista de coeficientes, em ordem a partir do que do
termine de grau maior aMa aquele do termo de grau zero, a0 .
atribuir a uma variável o valor do primeiro coeficiente (primeiro elemento da
lista);
iterar sobre os elementos restantes da lista e atribuir a result a soma da variável
de iteração mais o produto de x0 por resultado.

Experimentar a função com o polinômio:

PN(x) = (x−3)(x+3)(x+5)(x+8)(x−2)(x−7) =
= x6+ 4x5-72x4-214x3+ 1127x2+ 1602x−5040.

Verifique que -8, -5, -3, 2, 3, 7 são raízes do polinômio (ou seja, o polinômio calculado naquele
ponto vale zero). Verifique que PN(2.7) = 424.0695 . . . e PN(−8,001) = 24,76958 . . .

Exercício 63 Algoritmo de Horner recursivo:Implementar a função do Eser-

cício62 utilizando recursão em vez de loop.

Exercício 64 Dia Giuliano:Eledia Giuliano (Dia Juliano), muito utilizado

na Astronomia, conta os dias (e frações) a partir do ano -4712. Por tradição, o dia
Giuliano começa ao meio-dia médio de Greenwich. Vamos escrever uma função que recebe como entrada
o ano, o mês e o dia (fracionário), calcule o correspondente dia Juliano, seguindo o
método descrito no Capítulo 7 deMeeus (1991).
Procedimento:
Indique o ano, o mês e o dia da data considerada;

Se m≤2, subtrair 1 de y e adicionar 12 a m;

Calcular tst = y + (m + dd / 100,0) / 100,0, depois:

–se tst ≥1582.1015, então calcule A= INT (y/100) e B= 2 −A+ INT (A/4);
-caso contrário, defina B = 0.

Calcule e retorne:

JD = INT (365,25 ·(y+ 4716)) + INT (30,6001 ·(m+ 1)) + dd + B−1524,5

43
Exercício 65 Dia Giuliano modificado:Reutilizando a função escrita para
O Exercício64, escrever uma função que retorne odia Giuliano modificado (Juliano Modificado
Dia, MJD), definido simplesmente como:
MJD = JD −2400000,5.

Exercício 66 Números perfeitos:Em matemática, um número natural N é chamado denúmero

perfeito quando la somma di tutti i suoi divisori propri `e pari al numero stesso. Scrivere una
função que, dado um número natural N de entrada, retorne verdadeiro se o número é perfeito
segundo a definição dada antes, ou False no caso contrário. Procedimento:
se o parâmetro de entrada não é um inteiro ou é ≤0, retornar Falso;

inicializar uma lista de divisores como uma lista vazia;

inicializar uma variável maxnperi à divisão inteira de nper por dois mais um;
iterar de um a maxn, com a variável de iteração i:
–se não é divisível por i, adicionar à lista de divisores;
ritornar Truese a soma dos divisores (função sum()) `e igual a no False em caso
contrário.
Verifique se a função retorna True para os números 6, 28, 496 e False para 10, 34, 500.

Exercício 67 Crivello de EratóstenesElecrivello di Eratóstenesm

odieucm
ntepré
para encontrar todos os números primos até um número predefinido. Implementar o crivo em uma
função Python segundo o seguinte procedimento:
defina uma função que aceite um único parâmetro de entrada maxn (o número máximo
dentro do qual buscar números primos);
definir uma lista com todos os números inteiros de zero a maxn;
definir uma variável limite, igual à parte inteira da raiz quadrada de maxn;
iterar de dois a limite, com variável de iteração n:
–se o valor de listanella posição de índice n é diferente de -1:
a partir do elemento de índice n, colocar
* -1 em todos os elementos cujos índices são
um múltiplo de n;
inicializar uma lista de primos, vazia;
iterar sobre todos os elementos da lista a partir do índice dois e até o final:
–se o elemento corrente `e diferente de -1, adicioná-lo ao final da lista primos
retornar ao chamador a lista de primos.
Esempio di esecuzione:
>>> crivello_eratostene(20)
[2, 3, 5, 7, 11, 13, 17, 19]
>>> crivello_eratostene(40)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
>>> crivello_eratostene(50)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

44
 Solução do exercício45
[Link]:
importarmadilha como m
deferone(a, b, c):
p = (a+b+c)/2.0
[Link](p (p-a)* (p-b) (p-c))
* *
Solução do exercício46
eq2_roots.py:
importar sqrt de matemática
defeq2_raizes(a, b, c):
ifa == 0:
print 'a deve ser diferente de zero'
return
delta = b b *- 4 a c* *
se delta < 0:
return
elifdelta == 0:
retornar-b/(2 a) *
caso contrário:
sd = raiz(delta)
retornar(-b-sd)/(2 a), (-b+sd)/(2
* a) *
Solução do exercício47
is_leap.py:
defis_leap(y):
y = int(y) # Garantimos que y seja inteiro
ify % 4:returnFalse
ify % 100:returnTrue
se % 400:retornarFalso
retornarVerdadeiro

Solução do exercício48
dia_do_ano.py:
# A função is_leap está contida em is_leap.py
# na diretório atual.
fromis_leapimport *

defdias_do_ano(dia, mês, ano):

# Lista dei giorni per ciascun mese
month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
Se ano bissexto, Fevereiro tem 29 dias
ifis_leap(ano): dias_do_mês[1] = 29

# Vamos verificar o mês e o dia de entrada

se mês < 1 ou mês > 12:
Mês inexistente
retornar0
se o dia < 1 ou o dia > dias_do_mês[mês-1]:
print"Dia inexistente"

45
 retorno0

O dia do ano é dado pela soma dos

dias de todos os meses anteriores ao especificado
# piu‘ o dia dado como entrada
day_of_year = 0
for i in range(mês-1):
dia_do_ano += dias_do_mês[i]
dia_do_ano += dia

returnday_of_year

Solução do exercício49
[Link]:
# A função is_leap está contida em is_leap.py
na diretório atual.
fromis_leapimport *

defdoy2date(doy, ano):
Lista dos dias para cada mês
month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
Se ano bissexto, Fevereiro tem 29 dias
ifis_leap(ano): dias_no_mês[1] = 29

se ifdoy < 1 ou ordoy > soma(dias_do_mês):

Dia do ano fora do intervalo
retornar

mm = 0
dd = dias_do_mês[mm]
enquanto dd < doy:
doy -= dd
mm += 1
dd = dias_do_mês[mm]

returnyear, mm+1, doy

Solução do exercício50
pasqua_gregoriana.py:
defpasqua_gregoriana(ano):
anno =int(anno)
a = ano % 19
b = anno / 100
c = anno % 100
d = b / 4
e = b % 4
f = (b + 8) / 25
g = (b - f + 1) / 3
h = (19 a* + b - d - g + 15) % 30
i = c / 4
k = c % 4

46
 l = (32 + 2 e* + 2 i *- h - k) % 7
m = (a + 11 *h + 22 l)* / 451
t = h + l - 7 m* + 114
n = t / 31
p = t % 31
return str(anno)+’-’+str(n)+’-’+str(p+1)

Soluzione dell’esercizio 51
[Link]:
defdec2bin(n):
b = ""
se int(n) != norn < 0:
n deve ser um número inteiro positivo
retornar
n = int(n)
enquanto n != 0:
se n % 2:
b = "1"+b
senão:
b = "0"+b
n /= 2
return '0b' + b

Soluzione dell’esercizio 52
dec2bin_rec.py:
defdec2bin_rec(n):
se n < 0:
return’Input must be a positive integer’
elifn==0:
retornar''
senão:
returndec2bin_rec(n/2) + str(n%2)

Solução do exercício53
bin_clone.py:
# A função dec2bin_rec está no arquivo
# dec2bin_rec.py nella directory corrente.
fromdec2bin_recimport *

defbin_clone(n):
se n < 0:
return’Input must be a positive integer’
senão:
retornar '0b' + dec2bin_rec(n)

Solução do exercício54
[Link]:
defdec2oct(n):
o = ’’
se int(n) != norn < 0:

47
 n deve ser um número inteiro positivo
retornar''
n = int(n)
enquanto n != 0:
o = str(n % 8) + o
n /= 8
retornar'0' + o

Soluzione dell’esercizio 55
dec2oct_rec.py:
defdec2oct_rec(n):
se ifn < 0:
retornar 'A entrada deve ser um número inteiro positivo'
elifn==0:
retornar
senão:
returndec2oct_rec(n/8) + str(n%8)

Solução do exercício56
oct_clone.py:
# A função dec2oct_rec está no arquivo
# dec2oct_rec.py na diretório atual.
fromdec2oct_recimport *

defoct_clone(n):
se fn < 0:
return’Input must be a positive integer’
caso contrário:
retornar '0' + dec2oct_rec(n)

Solução do exercício57
[Link]:
# [Link]
defthabit(n):
retornar3 2* n-1**

Solução do exercício58
[Link]:
importar matemática como m

defpitagora(a, b):
retorna [Link](a a *+ b b) *

Solução do exercício59

1. [Link]:
importar matemática

importar [Link] como plt

defplotsin(xmin = -[Link], xmax = [Link], npts = 201):
xdif = (xmax-xmin)/(npts-1.)
lx = []

48
 ly = []
para i em range(npts):
x = xmin+i xdif
*
y = [Link](x)
[Link](x)
[Link](y)
[Link](lx,ly)
[Link]()

2. [Link]:
importar matemática

importar [Link] como plt

defplotcos(xmin = -[Link], xmax = [Link], npts = 201):
xdif = (xmax-xmin)/(npts-1.)
lx = []
ly = []
para i em range(npts):
x = xmin + *i xdif
y = [Link](x)
[Link](x)
[Link](y)
[Link](lx, ly)
[Link]()

3. [Link]:
importar matemática

importar [Link] como plt

defplotlog(xmin = 1., xmax = 100, npts = 201):
xdif = (xmax-xmin)/(npts-1.)
lx = []
ly = []
for i em range(npts):
x = xmin+i xdif
*
y = [Link](x)
[Link](x)
[Link](y)
[Link](lx, ly)
[Link]()

4. [Link]:
importar matemática

importar [Link] como plt

defplotexp(xmin = 0., xmax = 5, npts = 201):
xdif = (xmax-xmin)/(npts-1.)
lx = []
ly = []
para i em range(npts):
x = xmin+i xdif
*
y = [Link](x)
[Link](x)

49
 [Link](y)
[Link](lx,ly)
[Link]()

Solução do exercício60
soma_dí[Link]:
defsomar_dígitos(n):
se int(n) != n:
O número de entrada deve ser um inteiro.
retornar0
n = int(n)
s = 0
enquanto n > 0:
s += n % 10
n /= 10
retornos

Solução do exercício61
sum_digits_str.py:
defsomar_dígitos_str(n):
se int(n) != n:
Em número de entrada deve ser um inteiro.
retorno0
ns = str(int(n))
s = 0
fordinns:
s += int(d)
retornos

Soluzione dell’esercizio 62
[Link]
defhorner(x0, coeffs):
result =float(coeffs[0])
forcincoeffs[1:]:
result = c + result x0 *
retornaresultado

Solução do exercício63
horner_rec.py:
defhorner_rec(x0, coeficientes):
se len(coeffs) == 1:
retornar float(coeffs[0])
senão:
returncoeffs[-1] + x0 * horner_rec(x0, coeffs[:-1])

50
 Solução do exercício64
[Link]:
defjd(y, m, dd):
se mf <= 2:
y -= 1
m += 12
tst = y + (m + dd/100.0)/100.0
iftst >= 1582.1015:
A = int(y/100.)
B = 2-A+int(A/4.)
senão:
B = 0
JD =int(365,25 (y+4716))+int(30,6001
* (m+1))+dd+B-1524,5
*
returnarJD

Solução do exercício65
[Link]:
fromjdimport *

defmjd(y, m, dd):
returnjd(y, m, dd)-2400000.5

Soluzione dell’esercizio 66
is_perfect.py:
frommathimportsqrt

defis_perfeito(n):
se int(n) != norn <= 0:
retornarFalso
divisors = []
maxn = int(n/2) + 1
para i em range(1, maxn):
se n % i == 0: [Link](i)
retorna soma(divisores) == n

Solução do exercício67
crivello_eratostene.py:
importar matemática como m

defcrivello_eratostene(maxn):
lista = list(range(maxn+1))
limite =int([Link](maxn))
for i in range(2, limite+1):
iflista[n] != -1:
idx = n n*
enquanto idx < len(lista):
lista[idx] = -1
idx += n
primi = []
forninlista[2:]
ifn != -1:

51
 [Link](n)
returnprimi

52
Capítulo 8

Séries numéricas

Exercício 68 Serie pere:A base do logaritmo natural e = 2,7182818284590...

ser calculada usando a seguinte série:
∞ 1
e= X
n=0
n!

Escrever uma função Python que, dado um número inteiro de entrada, calcule por meio de um loop.
para a série até o termo m-ésimo.

Exercício 69 Série par, recursiva:Reescrever a função do Exercício68 de modo

usar a recursão em vez de um loop.

Exercício 70 Série de Nilakantha: Uma série infinita para o cálculo de π foi

publicada no século quinze pelo astrônomo indianoNilakantha Somayaji:
4 4 4 4
π= 3 + + ...
2 ×3 ×4 4 ×− 5 × 6 6 × 7 × 8 8 × 9 × 10−
que também pode ser escrito como:
∞
π= 3 + 4 × X -1n .
n=0
(2n + 2) × (2n + 3) × (2n + 4)

Escreva uma função Python que, usando um loop for, calcule a série até o N-ésimo termo.
(com Nintero e ≥0), ou seja:
N
π≈3 + 4 × -1n .
X (2n + 2) × (2n + 3) × (2n + 4)
n=0

Dica: Uma vez que nos termos do denominador aparece apenas 2n, é vantajoso iterar usando a função
range() a passi de 2. Observe também que o sinal de cada termo é inicialmente positivo
e depois 'é o oposto do termo anterior.

Exercício 71 Série de Nilakantha recursiva:Reescrever a função do Exercício70

de modo a usar a recursão em vez de um loop.

53
 Solução do exercício68
natural_e.py:
importar matemática

defnatural_e(n):
e = 0.0
for i in range(n+1):
e += 1.0/[Link](i)
retorne

Soluzione dell’esercizio 69
natural_e_rec.py:
importar matemática

defnatural_e_rec(n):
se ifn == 0:
retorno1.0
return1.0/[Link](n)+natural_e_rec(n-1)

Solução do exercício70
nilakantha_pi.py
Nilakantha
veja [Link] (Taxa de convergência)
defnilakantha_pi(n):
acc = 0.0
sign = +1.0# segno inizialmente positivo
para i em range(0, 2 n+1,* 2):
acc += sinal / ((i + 2.0) (i + *3.0) (i + 4.0))
*
sinal =* -1.0# sinal alternado
retornar 3.0 + 4.0 acc
*

Solução do exercício71
nilakantha_pi_rec.py
defnilakantha_pi_rec(n):
sinal = 1.0-2.0 (n *% 2)
se ifn == -1:
retorno3.0
senão:
i = 2.0 n*
returnsign 4.0/((i+2.0)
* (i+3.0) (i+4.0))
* + nilakantha_pi_rec(n-1)
*

54
Capítulo 9

Números aleatórios

Exercício 72 Lotto (embaralhar): Escrever uma função que simule uma extração de
cinco números da loteria. Os cinco números "sorteados" devem, portanto, estar entre 1 e 90
e não devem se repetir. Procedimento:

generare una lista lcon i numeri interi da 1 a 90;

“misturar” a lista usando a função shuffle() do módulo random;

retornar os primeiros cinco elementos da lista l.

Exercício 73 Lotto (choice): Implementar uma função que simule uma extração
de cinco números da loteria, com as características descritas no Exercício72, mas que você usa a
função choice() do módulo random. Procedimento:

gerar uma lista com os números inteiros de 1 a 90 e uma lista inicialmente vazia;

iterar por 5 vezes e a cada passo:

escolher um elemento aleatório de l;

–adicioná-lo ao final da lista r;
remover o elemento de l.

retornar a lista r.

Exercício 74 Lotto (índice aleatório):Implementar uma função que simule uma

extração de cinco números da loteria, com as características descritas no Exercício73, mas o que
Utilize a função randint() do módulo random para gerar o índice do elemento de
selecione na lista o. Remova o elemento assim selecionado usando pop().

Exercício 75 Adivinha o número:Escrever um programa Python que gere um nu-

um número aleatório entre 1000 e 9999 e peça ao usuário para adivinhá-lo, iterando até obter a
resposta certa e fornecendo algumas "sugestões."
Procedimento:

gerar um número inteiro aleatório entre 1000 e 9999 e convertê-lo em string usando a
função str();

ripetere finch`e l’utente non indovina il numero:

–usando a função raw_input() peça ao usuário para adivinhar o número;

55
 Se a stringa inserida pelo usuário não é composta por quatro caracteres, os
passos seguintes e volta-se a solicitar entrada;
Se a stringa inserida é igual ao número a ser adivinhado, imprimir "Adivinhou!"
e interromper as iterações;
–caso contrário, itere sobre cada caractere da entrada e:
se la cifra corrispondente del numero da indovinare coincide, stampare tale cifra
(sem ir para a próxima linha)
se a cifra correspondente do número a adivinhar é menor, imprimir ' - '
(sem ir para a nova linha)
além disso, imprimir '+' (sem ir para a linha)
–imprimir uma linha em branco para ir para a próxima linha.

Esempio:
Numero ? 5555
+ - - +
Numero ? 6446
+ - - 6
Numero ? 7336
+ - - 6
Numero ? 8226
+ - 2 6
Numero ? 9126
Acertou!

56
 Solução do exercício72
lotto_shuffle.py:
de random import shuffle

deflotto_embaralhar():
lst = range(1, 91) # todos os números de 1 a 90
embaralhar(lst) vamos misturar a lista
returnlst[0:5] # e retornamos os primeiros 5 números

Solução do exercício73
lotto_choice.py:
de random import choice

deflotto_escolha():
l = range(1,91,1) # todos os números de 1 a 90
r = []# lista resultado inicialmente vazia
para i em range(5): # 'extrair 5 números
el = escolha(l)# escolhemos um elemento aleatório
[Link](el) Nós adicionamos à lista de resultados
[Link](el) e o removemos da lista de números
# para evitar que apareça novamente
retornar

Solução do exercício74
lotto_randint.py:
de random import randint

deflotto_randint():
lst = range(1,91)# todos os números de 1 a 90
res = []# lista risultato inizialmente vuota
for i in range(5):# 'extraímos' 5 números
# índice entre 0 e len(lst)-1
idx = randint(0,len(lst)-1)
# adicionemos aos resultados o número à
# posizione (causale) idx
[Link](lst[idx])
removemos o elemento da lista para
evitar que apareça novamente
[Link](idx)
retorno

Solução do exercício75
indovina_numero.py:
de random import randint

num = str(randint(1000, 9999))

enquantoVerdadeiro:

guess =raw_input("Numero ? ")

se len(chute) == 4:
se o palpite == num:

57
 print"Adivinhado!"
quebrar
foriin range(len(guess)):
se num[i] == palpite[i]:
printnum[i],
elif int(num[i]) < int(guess[i]):
print'-'
caso contrário:
imprimir '+'
print’’

58
Capitolo 10

Numpy

Exercício 76 Soma de inteiros, versão numpy:Escrever um programa Python

che, usando array numpy senza impiegare dei cicli, calcoli e mostri a video la somma dei primi
100 números naturais.

Exercício 77 Tabellina, versão numpy:Escrever um curto programa em Python

che, usando um array numpy, calcule e imprima a tabela de multiplicação dos números de um
a dez.
Output atteso:
[ 1 2 3 4 5 6 7 8 9 10]
[ 2 4 6 8 10 12 14 16 18 20]
[ 3 6 9 12 15 18 21 24 27 30]
[ 4 8 12 16 20 24 28 32 36 40]
[ 5 10 15 20 25 30 35 40 45 50]
[ 6 12 18 24 30 36 42 48 54 60]
[ 7 14 21 28 35 42 49 56 63 70]
[ 8 16 24 32 40 48 56 64 72 80]
[ 9 18 27 36 45 54 63 72 81 90]
[ 10 20 30 40 50 60 70 80 90 100]

Exercício 78 Thabit, versão numpy:Escrever uma função Python que aceite

em entrada um único parâmetro, maxnche assume-se ser um número inteiro, e retorna um array
numpy contendo todos os números de Thabit 3 ·2n-1, com nche vai de zero a maxn.
Esercizio 79 Montante, versão numpy:Usando os dados do Exercício18 escrever
um breve programa que calcule a tabela de anos, montante usando numpy. Calcule primeiro um
array com os anos de 1 a 10 e depois um array com os montantes correspondentes. Então iterar sobre
tutti gli anni e stampare la tabella anno, montante (l’output atteso `e lo stesso di Esercizio 18)

Exercício 80 Seno e coseno: Usando la funzione linspace()del modulo numpy,

escrever um breve programa que gere um array com os números de 0 a 2π, ambos inclusos, e
equispaciados de π/4. Calcule as funções seno e cosseno nesses pontos e verifique o resultado
era quello esperado, ou seja:
[0,1/(2),1,1/(2),0,−1/(2),−1,−1/(2),0]
p p p p
[1,1/(2),0,−1/(2),−1,−1/(2),0,1/(2),1]
p p p p

Exercício 81 Gráficos de funções, numpy: Scrivere delle funzioni Python che,

usando o módulo numpy, façam o gráfico de:

59
 1. y = sen(x) em [−π, π]
2. y = cos(x) em [−π, π]
3. y = log(x) em [1,100]
4. y= exem [0,5]
Defina as funções com três parâmetros opcionais: xmin, xmax e npts, número de pontos para
graficare. Escolham os valores padrão de maneira adequada, dependendo da função. Definir x
come vetor numpye calcular seus valores com a função linspace(). Lembre-se de usar
as funções seno, cosseno, logaritmo e exponencial, assim como π definidas no módulo numpy.

Exercício 82 Grafico di Celsius–Farenheit: Escrever uma função Python que

faccia un grafico della relazione (lineare) tra gradi Celsius e Farenheit. La funzione dovr`a avere
três parâmetros opcionais: limites para o cálculo e o gráfico (Tmin, Tmax) número de pontos (N), com
valores padrão respectivamente -10, 120 e 130. Calcule os graus Celsius usando a função
linspace(), depois converta-os em Fahrenheit usando a seguinte relação:
9
F = C + 32.
5
Fazer o gráfico colocando os graus Celsius no eixo X e os correspondentes Fahrenheit no eixo Y.

Exercício 83 Gráfico de polinômio:Utilizando a função para o cálculo de polinômios

através do algoritmo de Horner, descrito no Exercício62, calcular o polinômio:

x3−30x2+ 2552
em 201 pontos no intervalo [−10,30] e fazer o gráfico.
Output atteso:

Exercício 84 Reproduzir gráfico:Sabendo que, para realizar o gráfico mostrado na

Figura seguinte:

60
foram utilizadas as funções linspace(), fabs() e sin() do módulo numpy, plot(),
xlim(), ylim(), show()del modulo [Link] che sono stati graficati 201
pontos, escreva um breve programa em Python que reproduza o gráfico acima.

Exercício 85 Crivello de Eratóstenes, versão numpy:Escrever uma função

que implementa o Crivo de Eratóstenes, conforme descrito no Exercício67, ma utilizando array
numpyal posto das listas. Utilizar as funcionalidades do numpy, em particular para reduzir os ciclos.
da três a um só.

Exercício 86 Somma cumulativa:Escrever uma função Python que aceite como entrada
um array unidimensional numérico e calcular a soma cumulativa, definida como o array:
n
s[n] = X v[i] n= 0, . . . , N −1.
i=0

onde está o array de soma cumulativa, o array de entrada, de tamanho N.

Testar a função passando como entrada um array numpy contendo os números inteiros de 1 a 10.
Output atteso:
>>> soma_cumulativa(a)
array([ 1., 3. 6., 10., 15., 21., 28., 36., 45., 55.]

Exercício 87 Verifica soma cumulativa:Escrever uma função Python que ac-

insira um array numérico unidimensional e verifique se a soma cumulativa calculada
lata con la funzione descritta nell’Esercizio 86 coincida com aquela calculada usando a função
cumsum() do numpy.
Procedimento:

calcular a soma cumulativa com a função escrita como solução do Exercício86 e

com cumsum(), atribua os resultados a duas variáveis a1 e a2, respectivamente;

calcular, usando a função fabs() do numpy, o valor absoluto da diferença entre a1

e a2elemento per elemento;

usando a função where() determinar para quantos elementos o valor absoluto de

diferença é maior que 10−12 ;

se houver pelo menos um elemento do valor absoluto da diferença que seja maior que 10−12 ,
retornar Falso;

caso contrário, retornar Verdadeiro;

Exemplo de saída:
>>> verifica_somma_cumulativa([Link](-10, [Link], 200)) * *
Verdadeiro

61
 Solução do exercício76
somma_100_numpy.py:
importar numpy como np

arr = [Link](1,101)
[Link](arr)

Solução do exercício77
tabellina_numpy.py:
importar numpy como np
n = [Link](1,11)
para i em range(1,11):
imprimir *n

Solução do exercício78
thabit_np.py:
importar numpy como np

defthabit_np(maxn):
n = [Link](int(maxn)+1)
retornar3 2* n-1
**

Solução do exercício79
montante_numpy.py:
importar numpy como np

upi = 1.04 (1+i)

anni = 10
n = [Link](1,anni+1)
M = 1000. *(upi [Link](10))
* n **
foriin range(anni):
printn[i], M[i]

Solução do exercício80
numpy_sin_cos.py:
importar numpy como np

theta = [Link](0, 2. [Link], 9)*

[Link](theta)
[Link](theta)

Solução do exercício81

1. plotsin_numpy.py:
importar numpy como np
importar [Link] como plt

defplotsin_numpy(xmin = -[Link], xmax = [Link], npts = 201):

x = [Link](xmin, xmax, npts)

62
 y = [Link](x)
[Link](x,y)
[Link](x,y)
[Link]()

2. plotcos_numpy.py:
importar numpy como np
importar [Link] como plt

def plotcos_numpy(xmin = -[Link], xmax = [Link], npts = 201):

x = [Link](xmin, xmax, npts)
y = [Link](x)
[Link](x,y)
[Link](x,y)
[Link]()

3. plotlog_numpy.py:
importar numpy como np
importar [Link] como plt

def plotlog_numpy(xmin = 1., xmax = 100, npts = 201):

x = [Link](xmin, xmax, npts)
y = [Link](x)
[Link](x,y)
[Link]()

4. plotexp_numpy.py:
importar numpy como np
importar [Link] como plt

defplotexp_numpy(xmin = 0., xmax = 5, npts = 201):

x = [Link](xmin, xmax, npts)
y = [Link](x)
[Link](x,y)
[Link]()

Solução do exercício82
c2f_graph_numpy.py:
importar [Link] como plt
importar numpy como np

defc2f_graph_numpy(Tmin=-10, Tmax=120, N=130):

C = [Link](Tmin, Tmax, N)
F = 9./5. C * + 32
[Link](C, F)
[Link]()
retornar

63
 Solução do exercício83
plot_poly.py:
importar numpy como np
importar [Link] como plt
dehornerimportar *

definir_plotagem_poligonal():

x = [Link](-10.,30.,201)
c = [Link]([1., -30., 0., 2552.])
y = horner(x, c)
[Link](x, y)
[Link]()
retornar
Solução do exercício84
plot_fabs_sin_np.py:
importar numpy como np
importar [Link] como plt

x=[Link](-2 [Link],2
* [Link],201)*
y=[Link]([Link](x))
[Link](x,y)
[Link](-2 [Link],
* 2 [Link]) *
[Link]([-1,2])
[Link]()
Solução do exercício85
crivello_eratostene_numpy.py
importnumpy as np

defcrivello_eratostene_numpy(maxn):
numeros = [Link](maxn+1)
limite = int([Link](maxn))
fornin intervalo(2, limite+1):
se numeros[n] != -1:
idx = [Link](n n, maxn+1,
* n)
numbers[idx] = -1
qp = ([Link](numbers[2:] != -1))[0]
returnnumbers[2+qp]
Solução do exercício86
somma_cumulativa.py:
importar numpy como np

defsomma_cumulativa(arr):
npts =len(arr)
sc = [Link](npts)
sc[0] = arr[0]
para i em range(1, npts):
sc[i] = sc[i-1]+arr[i]
retornos

64
 Soluzione dell’esercizio 87
verifica_somma_cumulativa.py:
importar numpy como np
fromsomma_cumulativaimportar *

defverifica_somma_cumulativa(arr):
a1 = somma_cumulativa(arr)
a2 = [Link](arr)
ad = [Link](a1 - a2)
q = [Link](ad > 1e-12)
nq = len(q[0])
se ifnq != 0:
returnFalse
retornarVerdadeiro

65
Capítulo 11

Simulações e Métodos Monte-Carlo

Exercício 88 Jogo da glória simplificado:Escrever uma função Python que simule

un gioco dell’oca semplificato. Vi sono quattro giocatori, identificati con i numeri da 1 a 4 (ma
internamente identificados com os índices de um array de 0 a 3). A cada turno, cada jogador
tira um dado, o resultado soma aos anteriores e representa o número da casa em que se
troverá o jogador. Vence o jogador que chega na casa 63 ou a supera. Se em uma turno
Se dois ou mais jogadores chegam ou superam a casa 63, vence o jogador com a maior pontuação. Em
em caso de empate, vence o jogador com o número mais baixo (equivalente ao jogador que
tira i dati per primo).
Procedimento:

Criar um array numpy de quatro elementos que represente a pontuação, inicialmente

posto tudo a zero;

Iterar até a vitória de um dos jogadores:

–simular o lançamento do dado por cada jogador gerando um array com

quatro números inteiros aleatórios uniformemente distribuídos entre 1 e 6;
– adicionar o resultado à pontuação total de cada jogador;
–imprimir na tela a pontuação de cada jogador;
–se pelo menos uma pontuação é maior ou igual a 63 (caso afirmativo, há pelo menos um
vincitore):
procurar o valor máximo da pontuação;
encontrar os índices dos valores no array de pontuação que são iguais a esse máximo
(pode haver mais de um);
pegar o primeiro elemento do array de índices, somar um e obter o
numero del giocatore che ha vinto;
terminar as iterações;

escrever na tela os pontos finais;

scrivere a schermo il numero del giocatore vincente.

Exercício 89 Área de Macchia Nera:Baixar o arquivo [Link]

e extrair o arquivo [Link] na diretório de onde foi iniciado o IDLE.
O arquivo contém um array numpy bidimensional que representa a seguinte imagem:

66
Escrever uma função que calcule a área da parte preta na figura usando o método hit-or-
senhorita.
Procedimento:

escrever uma função que aceite dois parâmetros de entrada, img_namenome do arquivo de onde
ler os dados e npts número de pontos aleatórios a serem gerados;

carregar a imagem contida no arquivo em um array numpy bidimensional através da instrução

zione ima = [Link]("[Link]")

atribuir a duas variáveis nre ncil o número de linhas e de colunas da imagem (como
deduzidos de [Link]

gerar os índices de nptspontos aleatórios uniformemente distribuídos dentro da...

gine:
–um array contendo números inteiros pseudo-aleatórios uniformemente distribuídos entre zero
e nr-1
–um array contendo números inteiros pseudo-aleatórios uniformemente distribuídos entre zero
e nc-1

através da função where() encontrar os pontos onde ima[r,c] > 0 (acerto, ou seja, o ponto
cade nell’area nera);
atribuir a uma variável n_inil o número de tais pontos;

retornar a estimativa da área dada por n_in/npts nr nc* *

Exercício 90 Representação estocástica de:Se pode demonstrar que se:

V= min{n|X 1+ X2 + . . .+ Xn1}

ou seja, se V`e o número n mínimo tal que a soma de n variáveis aleatórias independentes Xeu
uniformemente distribuidas en [0,1] si es mayor que 1, entonces el valor esperado de V es el número e,
ou seja, a base do logaritmo natural(Gnedenko (1978)).
Escreva uma função Python que implemente um método estocástico para calcular e.
Procedimento:

definir uma função que aceita um único parâmetro n, número de estimativas a serem geradas;

inicializar uma lista vazia;

iterar várias vezes:

67
 inicializar a zero duas variáveis: j, inteira, que conterá o número de dados aleatórios gerados
e arqué conterá a soma de tais números;

iterar enquanto r < 1.0:

–incrementar jdi um;

– adicionar a execução um novo número aleatório uniformemente distribuído entre zero e um;

adicionar jalla ao final da lista ln

retornar a média dos valores armazenados na lista ln (usar a função sum() para
soma todos os valores e depois divide pela extensão da lista.

Exemplo de execução:
>>> natural_e_sim(1000)
2.702
>>> natural_e_sim(10000)
2.7215
>>> natural_e_sim(100000)
2.71853

68
 Solução do exercício88
simple_goose.py:
importar numpy como np
importar [Link] como npr

defsimul_oca():
num_players = 4
finished = False
score = [Link](num_players)
enquanto não terminado:
dice = npr.random_integers(1, 6, num_players)
score += dado
print "Punteggio:", score
vitorias = [Link](pontuacao >= 63)
n_wins =len(score[wins])
se ifn_wins > 0:
max_score = [Link](score)
winner_idx = ([Link](score == max_score))[0]
winner = winner_idx[0]+1
finished = True
print "Punteggio finale: ", score
print"Vence o jogador:", vencedor
Solução do exercício89
area_macchianera.py:
importar numpy como np
importar [Link] como npr

defarea_macchianera(img_name, npts):
ima = [Link](img_name)
nr, nc = [Link]
r = npr.random_integers(0, nr-1, npts)
c = npr.random_integers(0, nc-1, npts)
q = ([Link](ima[r,c] > 0))[0]
n = len(q)
area =float(n)/npts nr nc * *
área de retorno

Solução do exercício90
natural_e_sim.py:
de aleatório importar aleatório
defnatural_e_sim(n):
ln = []
para i em range(n):
j = 0
r = 0,0
enquanto < 1.0:
j += 1
r += aleatório()
[Link](j)
retornar float(soma(ln))/len(ln)

69
Bibliografia

B. V. Gnedenko. A Teoria da Probabilidade. Editores MIR, Moscovo, 1978.

Jean Meeus. Algoritmos Astronômicos. Willman-Bell, Richmond, Virgínia, 1991.

David Wells. O Dicionário de Números Curiosos e Interessantes de Penguin. Penguin Group,

Londres, Reino Unido, 1ª edição, 1986.

70
Este trabalho é distribuído sob uma licença Creative Commons Atribuição - Não Comercial -
Condividi allo stesso modo 4.0 Internacional
(CC BY-NC-SA 4.0).
Para ler a licença, visite[Link] o mandar
uma carta para a Creative Commons, PO Box 1866, Mountain View, CA 94042, EUA.

71