Número real

Definição

Os números reais são caracterizados pela existência do ponto decimal.

\hspace{0.5cm} {\mathbb{R}} = \{ \ldots, -1.0, \ldots, -0.53333, \ldots, 0.0, \ldots, 0.41, \ldots, 1.3232, \ldots \}

Vejamos alguns exemplos de variáveis associadas a números reais no Python.

a = 6.2
b = float(14)
c = float(1/3)
d = float(5.6789)
e = float()
print('a =',a,', b =', b, ', c =', c, ', d =', d, ', e =', e)

O resultado obtido pelo programa é

a = 6.2 , b = 14.0 , c = 0.3333333333333333 , d = 5.6789 , e = 0.0

Observe que nenhum tipo foi associado à variável a. O Python então assume que é um objeto do tipo float, pois 6.2 é um número com ponto decimal. O valor associado à variável b é o número inteiro 14. Como foi usado o método float(), a variável recebe o valor 14.0. Por último, note que nenhum valor foi atribuído à variável e no programa. Neste caso, Python associou a variável ao objeto float zero.

Método float()

O método float() retorna um objeto do tipo real. São valores aceitos como argumentos:

valores numéricos negativos e positivos
strings com valores numéricos
valor numérico indefinido (‘nan’)
infinito (‘Infinity’ ou ‘inf’)

Abaixo um exemplo de diferentes valores passados para o método float.

a = float('123e-02')
b = float('nan')
c = float(-45.7)
d = float('inf')
e = float('-Infinity')
print('a =',a,', b =', b, ', c =', c, ', d =', d, ', e =', e)

A resposta obtida pelo programa é

a = 1.23 , b = nan , c = -45.7 , d = inf , e = -inf

Identificador

No Python, duas variáveis do tipo real e com o mesmo valor são associadas a um mesmo objeto. São dois nomes para um mesmo objeto. Podemos verificar isso usando o método id(). Este método informa a identificação única de um objeto durante a execução do programa.

a = 12.3456
b = 12.34567
c = 12.3456
d = b
print('id(a) =',id(a),', id(b) =', id(b))
print('id(c) =', id(c), ', id(d) =', id(d))

O resultado do programa mostra que a e c são dois nomes para um mesmo objeto float que possui identificação igual a 140591672361512 e que b e d são dois nomes para um outro objeto com identificação igual a 140591672361584.

id(a) = 140591672361512 , id(b) = 140591672361584
id(c) = 140591672361512 , id(d) = 140591672361584

Limites

O programa abaixo verifica o maior e o menor valores positivos que um objeto float pode armazenar.

import sys
print(sys.float_info.max)
print(sys.float_info.min)

O resultado obtido para uma máquina de 64 bits é

1.7976931348623157e+308
2.2250738585072014e-308

O que acontece se definirmos números que ultrapassam os valores definidos acima? No programa abaixo, um pequeno valor é adicionado ao valor máximo e o valor mínimo é elevado ao quadrado.

a = sys.float_info.max
b = a + 0.01e+308
print('a = ', a, ', b = ', b)
a = sys.float_info.min
b = a * a
print('a = ', a, ', b = ', b)

O resultado da execução do programa mostra que qualquer valor maior que o valor máximo é considerado infinito e que qualquer valor menor que o valor mínimo é considerado zero.

a = 1.7976931348623157e+308 , b = inf
a = 2.2250738585072014e-308 , b = 0.0

Os testes feitos acima para os valores máximo e mínimo também são válidos para os números negativos, basta acrescenta o sinal negativo (neste caso, a resposta é -inf e –0.0).

Representação

O computador usa internamente a base binária para fazer todas as suas operações. A conversão de um número real da base binária para a base decimal leva em consideração a posição de cada algarismo como mostra a figura abaixo.

Por exemplo,

( 37.0)_{10} = (100101)_2

Isto pode ser facilmente verificado.

1 \times 2^5 + 0 \times 2^4 + 0 \times 2^3 +1 \times 2^2 + 0 \times 2^1 + 1 \times 2^0 = (37.0)_{10}

A conversão da base decimal para a binária (e vice-versa) pode ser obtida para qualquer número inteiro, não importa o tamanho do número (a implementação é limitada apenas pela arquitetura do computador e pela linguagem de programação usada). O mesmo não pode ser dito para um número real. Vejamos primeiro um exemplo.

a = 1.25
b = 1.26
c = b**2 
d = b**3
e = 1/3
print('{:1.30f}'.format(a))
print('{:1.30f}'.format(b))
print('{:1.30f}'.format(c))
print('{:1.30f}'.format(d))
print('{:1.30f}'.format(e))

O resultado obtido pelo programa é mostrado abaixo. Neste exemplo temos 5 variáveis do tipo float e o conteúdo dessas variáveis é mostrado com trinta casas decimais.

1.250000000000000000000000000000
1.260000000000000008881784197001
1.587600000000000122213350550737
2.000376000000000153988821693929
0.333333333333333314829616256247

Note que apenas a variável a apresenta o conteúdo esperado, as outras variáveis apresentam uma aproximação dos valores definidos. Isto ocorre porque nem sempre é possível definir o valor exato de um número float no sistema binário.

Como os valores fracionários são representados com potências negativas, não é sempre possível obter um determinado número real. A tabela seguinte mostra alguns valores que podem ser obtidos com as potências negativas.

Potência	Fração	valor
$2^{-1}$	${\displaystyle\frac{1}{2}}$	0.5
$2^{-2}$	${\displaystyle\frac{1}{4}}$	0.25
$2^{-3}$	${\displaystyle\frac{1}{8}}$	0.125
$2^{-4}$	${\displaystyle\frac{1}{16}}$	0.0625
$2^{-5}$	${\displaystyle\frac{1}{32}}$	0.03125

Sabemos que $0.75 = 0.5 + 0.25 = {\displaystyle\frac{1}{2} + \frac{1}{4}} = 2^{-1} + 2^{-2}$ . Logo, é possível converter 0.75 para a base 2. Mas como converter 0.26? Não é possível obter um valor exato para esse número na base binária, por isso usa-se uma aproximação para representar esse número.

A implementação de números reais no computador é definida pelo padrão IEEE 754.