2.7.2 Grandes Inteiros em Python

linguagens arredonda o valor da divisão inteira em direção ao valor zero, Python arredonda o valor em direção ao –∞ (“menos”

in nito).

Este comportamento tem uma razão matemática. Pense na operação de divisão entre números inteiros, que gera um

quociente e um resto:

dividendo ÷ divisor ⇒ quociente + resto

Assim, temos que:

divisor × quociente + resto Þ dividendo

Com números positivos, a conta é simples:

3 // 2 ⇒ 1 + 1

pois

2 * 1 + 1 ⇒ 3

Mas, o que acontece se usarmos um número negativo?

-3 // 2 ⇒-2 + 1

pois

2 * (-2) + 1 ⇒-3

Dessa maneira, a divisão inteira de -3 por 2 é igual a -2.

 

EXERCÍCIO 2.9

Faça um programa em Python que calcule a área de um quadrado.

 

EXERCÍCIO 2.10

Faça um programa em Python que calcule o número de segundos após a meia-noite. Crie identi cadores para hora, minuto e

segundo.

 

2.7.2 GRANDES INTEIROS EM PYTHON

Um inteiro em Python tem tamanho infinito, apenas limitado pela memória disponível. Se você cria uma variável com um valor inteiro pequeno, Python vai ligar esta variável ao tipo inteiro simples, cujo valor máximo é determinado pelo processador que seu computador utiliza. Se o valor referenciado por esta variável crescer muito, além da capacidade do inteiro simples, Python automaticamente passa a referenciar, com esta variável, um inteiro longo, que possui número infinito de dígitos. As operações com inteiros longos são mais lentas que aquelas com inteiros simples e esta deverá ser a única diferença que você vai notar durante a execução do seu programa.

Essas características dos inteiros longos é um grande diferencial de Python sobre outras

linguagens. Enquanto você tem que encontrar meios alternativos para trabalhar com grandes inteiros na maioria das linguagens de programação, em Python é possível fazer seu programa sem se preocupar com limites dos inteiros.

Vamos então fazer um exemplo simples com números inteiros realmente longos. Vamos calcular o

tamanho do Universo observável em milímetros para testar essa capacidade de Python em manipular grandes números. Como você pode imaginar, o resultado deve dar um número bem grande. Obviamente, este não é um resultado prático. É impossível ter esta precisão na medida do Universo. Mas é um pretexto divertido para testar os limites de Python (ou a sua falta).

Os astrônomos estimam que nosso Universo tem aproximadamente 93 bilhões de anos-luz. Um

ano-luz é a distância que a luz percorre em 1 ano. Sabendo que a velocidade da luz é de 299 792 458 metros por segundo, qual é o tamanho do Universo observável em milímetros? Vamos criar um programa para fazer este cálculo.

Não vamos, no entanto, escrever diretamente o programa. Vamos começar por um algoritmo.

Primeiro uma prosa, só para começar a organizar a solução:

Algoritmo que calcula o tamanho do Universo em milímetros:

O tamanho do Universo em milímetros é igual ao tamanho do Universo em anos-

luz vezes a velocidade da luz em mm/s vezes a quantidade de segundos em um ano.

Quais são os dados que já possuímos? Sabemos o tamanho do Universo em anos-luz: 93 000 000

000. A velocidade da luz em milímetros por segundo é fácil de obter e não precisa de cálculo. Como 1 metro tem 1000 milímetros, a velocidade da luz em milímetros por segundo é igual a 299 792 458 000. Falta saber quantos segundos tem um ano. Podemos escrever nossa primeira versão do algoritmo:

Algoritmo que calcula o tamanho do Universo em milímetros:

velocidade_luz_em_mms = 299 792 458 000

Calcule quantos segundos tem um ano

tamanho_universo_em_anosluz = 93 000 000 000

tamanho_universo_em_mm = tamanho_universo_em_anosluz

* velocidade_luz_em_mms

* segundos_em_1ano

Imprima tamanho_universo_em_mm

Veja que não tentei resolver cada detalhe do problema de uma só vez. Em vez disso, dividi o

problema maior em subproblemas menores. Este método, chamado de refinamentos sucessivos, permite que partamos de uma solução bem genérica, impossível de implementar diretamente como um programa, até chegar a uma solução com detalhes suficientes para ser implementada. Falta então resolver o problema de calcular quantos segundos tem um ano. Poderíamos fazer este cálculo nós mesmos, ou criar um algoritmo também para isso:

segundos_por_min = 60

segundos_por_h = 60 * segundos_por_min

segundos_por_dia = 24 * segundos_por_h

segundos_por_ano = 365 * segundos_por_dia

Agora substituímos o cálculo dos segundos por ano no algoritmo do tamanho do Universo:

Algoritmo que calcula o tamanho do Universo em milímetros:

velocidade_luz_em_mms = 299 792 458 000

segundos_por_min = 60

segundos_por_h = 60 * segundos_por_min

segundos_por_dia = 24 * segundos_por_h

segundos_por_ano = 365 * segundos_por_dia

tamanho_universo_em_anosluz = 93 000 000 000

tamanho_universo_em_mm = tamanho_universo_em_anosluz

* velocidade_luz_em_mms

* segundos_em_1ano

Imprima tamanho_universo_em_mm

A tradução para Python é imediata:

#Programa que calcula o tamanho do Universo em milímetros.

tamanho_universo = 93000000000 #em anos-luz

#Cálculo da quantidade de segundos em 1 ano

segundos_por_min = 60

segundos_por_h = 60 * segundos_por_min

segundos_por_dia = 24 * segundos_por_h

segundos_por_ano = 365 * segundos_por_dia

velocidade_luz_em_mms = 299792458000

tamanho_universo_mm = tamanho_universo \

* velocidade_luz_em_mms \

* segundos_por_ano

print (“O Universo tem aproximadamente”,

tamanho_universo_mm, “milímetros.”)

■ Programa 2.6: universo.py.

No algoritmo, separei os números em grupos de 3 dígitos, para facilitar a leitura. Em um programa,

este não é um recurso válido. O resultado da execução é mostrado no Programa 2.6a.

O Universo tem aproximadamente

879245710860384000000000000000 milímetros.

■ Programa 2.6a: Execução de universo.py.

 

Este programa nos permite apresentar duas características de Python: comentários e comandos que ultrapassam a extensão de uma linha. O caractere “#” inicia um comentário e tudo até o fim da linha fará parte deste caractere. Comentários não são processados pelo interpretador Python. Servem como lembretes ao leitor, esclarecendo algum aspecto do programa.

Dica 2.11 – Faça comentários relevantes.

Quando comentar seu programa, procure fazer comentários que realmente esclareçam algum aspecto do seu programa. Um

programa bem escrito deve ser claro para o leitor, sem precisar de muitos comentários.

No início de cada algoritmo sempre é útil colocar um comentário explicando o que será feito. Trechos que podem ter algum

código mais obscuro também merecem ser comentados, porém é sempre melhor tentar escrever seu código de maneira que o

comentário seja dispensável. Escolhendo nomes signi cativos de variáveis e dividindo expressões complexas em partes mais

simples, você pode reduzir muito a necessidade de comentários.

Se você sentir necessidade de escrever muitos comentários explicando seu código, pergunte a si próprio se o código não

poderia ser escrito de forma mais clara. Um exemplo evidente é o código do cálculo de área de um triângulo:

a = (b * c)/2 # Calcula a área de um triângulo

A versão com nomes relevantes de variáveis dispensa o uso de comentários:

area_triangulo = (base * altura)/2

Também não crie comentários que repitam aquilo que o código faz. Por exemplo, o comentário a seguir é totalmente

desnecessário:

x = x + 1 # soma 1 a x

Resumindo, comentários são úteis em um programa, mas sempre é preferível ter um código claro, com poucos ou nenhum

comentário, do que ter um código confuso que demande muitos comentários para ser compreendido.

Também note a atribuição: