Um dos tipos de dados mais comumente usados em Python é float, que representa números de ponto flutuante. Números de ponto flutuante são números, positivos ou negativos, que possuem uma casa decimal. Os números de ponto flutuante também incluem números representados em notação científica, com o caractere e ou E usado para indicar uma potência de 10.
Float é um tipo de dados muito importante, pois pode representar uma ampla gama de números reais, desde números muito pequenos até números muito grandes.
Exemplos de números de ponto flutuante em Python são mostrados abaixo:
# float numbers a = 20.0 b = -51.51345 c = 65e7 d = -1.08E12 e = 2E10 print(type(a)) print(type(b)) print(type(c)) print(type(d)) print(type(e))
Saída:
<class 'float'> <class 'float'> <class 'float'> <class 'float'> <class 'float'>
Além disso, permitem cálculos mais precisos em comparação com tipos de dados como números inteiros, que removem a parte fracionária dos números. Por exemplo, com números inteiros, um número como 3,142 seria representado simplesmente como 3.
No entanto, o tipo de dados float representaria o número real como está, que é 3.142. Portanto, os valores flutuantes são mais adequados para cálculos matemáticos, pois produzem resultados mais precisos.
A esse respeito, os valores de ponto flutuante são amplamente utilizados em modelagem do mundo real, aprendizado de máquina, ciência de dados, análise financeira e econômica, cálculos matemáticos, gráficos e visualizações, e cálculos científicos e de engenharia.
últimas postagens
Inteiros vs. Float em Python
Inteiros são outro tipo de dados muito popular em Python. Ao contrário dos números de ponto flutuante, os inteiros não possuem ponto decimal. Os inteiros são compostos de números inteiros positivos, números negativos e zero, todos sem parte fracionária.
Os inteiros são úteis quando realizamos operações que envolvem números inteiros, como contagem ou indexação. Em Python, valores inteiros são denotados como int.
Alguns inteiros são mostrados abaixo:
a = 0 b = 968 c = -14 print(type(a)) print(type(b)) print(type(c))
Saída:
<class 'int'> <class 'int'> <class 'int'>
Algumas das diferenças entre inteiros e números de ponto flutuante em Python incluem:
CaracterísticaInteiros(int)Números de ponto flutuante(float)Representam números inteiros, suas contrapartes negativas e zero, todos sem casa decimal.Números reais com ponto decimalPrecisãoPrecisão ilimitada, portanto, não há limite para o tamanho ou tamanho de um valor int. A única restrição será a memória disponível em seu sistema.Tem precisão limitada. O maior valor flutuante que você pode armazenar é cerca de 1,8 x 10308 Uso de memória Usa menos memória que flutua Use mais memória do que valores inteiros Operações bit a bit Amplamente usado em operações bit a bit Quase nunca é usado em operações bit a bit Uso Normalmente usado em contagem, indexação e operações bit a bit Amplamente usado em medições, cálculos científicos e a maioria das operações matemáticas
Diferentes maneiras de criar e usar floats em Python
Uma maneira fácil de começar a trabalhar com valores flutuantes em Python é atribuir a uma variável um valor flutuante como este:
# assign a variable a float value a = 3.142
Outra maneira de obter valores flutuantes é converter inteiros e strings numéricas em valores flutuantes usando o construtor float(). Se passarmos uma string inteira ou numérica para float(), ela será convertida em um valor float conforme mostrado abaixo:
number1 = 2524 numString1 = "513.523" numString2 = "1341" # Convert to a float and store the float value in a variable a = float(number1) print(a) b = float(numString1); print(b) c = float(numString2) print(c)
Saída:
2524.0 513.523 1341.0
No exemplo acima, o inteiro e as strings são convertidos em valor flutuante usando float() e depois armazenados em uma variável, que é impressa, mostrando o valor flutuante resultante após a conversão.
Outra forma de obter valores flutuantes é realizando cálculos matemáticos como divisão, conforme mostrado abaixo:
num1 = 20
num2 = 3
result = num1/num2
print("Result of the division as an integer:")
print(int(20/3))
print("Result of the division as a float value:")
print(result)
print(type(result))
Saída:
Result of the division as an integer: 6 Result of the division as a float value: 6.666666666666667 <class 'float'>
No exemplo acima, observe que o valor float nos dá uma resposta mais precisa em comparação com a divisão e obtenção do resultado como um número inteiro.
Ao trabalhar com números flutuantes em Python, você pode encontrar alguns resultados muito interessantes devido à forma como os valores flutuantes são representados internamente no computador. Os números de ponto flutuante são representados no hardware do computador como frações de base 2 (binárias).
No entanto, a maioria das frações decimais, especialmente aquelas com decimais recorrentes, não podem ser representadas como uma fração binária exata. Como resultado, os números de ponto flutuante são geralmente armazenados como uma aproximação do valor real.
Para ver isso na prática, considere o valor flutuante 0,3. Se você atribuir 0,3 a uma variável, internamente, ela não será armazenada exatamente como 0,3. Para ver isso, podemos usar a função format() para ver como 0,3 é representado internamente. format() nos permite exibir um número desejado de algarismos significativos de um valor com o qual estamos trabalhando. No exemplo abaixo, estamos imprimindo de 0,3 a 20 algarismos significativos para ver como eles são armazenados internamente.
num = 0.3
print("num to 20 significant figures")
print(format(num, '.20f'))
print("Value we stored for num")
print(num)
Saída:
num to 20 significant figures 0.29999999999999998890 Value we stored for num 0.3
Como você pode ver, o valor 0,3 que atribuímos a uma variável chamada num não é armazenado internamente exatamente como 0,3. Ao imprimir a variável num, você obtém um valor arredondado.
Devido a este fato, você pode obter alguns resultados inesperados ao trabalhar com valores flutuantes. Por exemplo, se você fizer um cálculo manual de 0,3 + 0,3 + 0,3, sua resposta será 0,9. No entanto, de acordo com Python, esse não é o caso porque internamente ele armazena aproximações de frações binárias do valor real. Isso pode ser visto abaixo:
sum = 0.3 + 0.3 + 0.3
answer = 0.9
print("Is sum equal to answer: ")
print(sum == answer)
print("The internal representation of of sum is: ")
print(sum)
print("The answer from manual calculation is: ")
print(answer)
Saída:
Is sum equal to answer: False The internal representation of of sum is: 0.8999999999999999 The answer from manual calculation is: 0.9
Portanto, ao trabalhar com valores flutuantes, é importante ter em mente que Python não armazena valores exatos internamente. Em vez disso, armazena aproximações do valor real.
Portanto, ao fazer comparações entre valores flutuantes, você pode primeiro arredondar para o mesmo número de algarismos significativos. Para maior precisão ao trabalhar com números de ponto flutuante em Python, considere usar o módulo decimal embutido.
Módulo Decimal em Python
Em situações onde a alta precisão é importante e obrigatória, como em cálculos financeiros e científicos, usar float não é o ideal. Para garantir alta precisão ao trabalhar com números de ponto flutuante, o módulo Python embutido decimal é usado.
Ao contrário de float, que é armazenado como representações binárias de ponto flutuante dependentes da máquina, o módulo decimal armazena números de ponto flutuante usando representação baseada em decimal independente da máquina, que oferece maior precisão.
Além disso, o módulo decimal é capaz de representar números decimais exatamente como são e usá-los exatamente como estão nos cálculos. Ele também oferece aritmética de ponto flutuante decimal corretamente arredondada.
Para começar a usar o módulo decimal, importe-o para o seu arquivo Python da seguinte maneira:
import decimal
Para ver o benefício do módulo decimal, vamos refazer a comparação anterior entre a soma de 0,3 + 0,3 + 0,3 e o valor 0,9. O código para fazer isso é mostrado abaixo:
import decimal
sum = decimal.Decimal('0.3') + decimal.Decimal('0.3') + decimal.Decimal('0.3')
answer = decimal.Decimal('0.9')
print("Is sum equal to answer: ")
print(sum == answer)
print("The internal representation of sum is: ")
print(sum)
print("The answer from manual calculation is: ")
print(answer)
Saída:
Is sum equal to answer: True The internal representation of sum is: 0.9 The answer from manual calculation is: 0.9
Portanto, ao trabalhar com números de ponto flutuante e precisar de alta precisão, lembre-se de sempre utilizar o módulo decimal.
Erros comuns ao trabalhar com carros alegóricos
Muitos dos erros que surgem ao trabalhar com Float em Python resultam da não compreensão de como os números de ponto flutuante são representados internamente pelo Python. Por exemplo, um valor como 0,3 não será armazenado exatamente como 0,3. Portanto, é provável que você encontre erros se trabalhar com valores flutuantes, presumindo que eles sejam armazenados exatamente como estão.
Um erro comum é o erro de arredondamento que você encontrará ao realizar cálculos matemáticos em valores flutuantes. Como o Python não pode representar os valores flutuantes reais, é provável que você encontre erros de arredondamento em que os resultados podem não ser os esperados.
Devido a erros como erros de arredondamento, é provável que você encontre erros ao tentar fazer comparações de igualdade entre valores de ponto flutuante. Tenha muito cuidado ao trabalhar com carros alegóricos em Python e esteja ciente de resultados inesperados.
A melhor maneira de evitar todos os erros que podem surgir ao trabalhar com valores flutuantes é usar o módulo decimal embutido. Dessa forma, os resultados dos cálculos de números de ponto flutuante serão mais previsíveis e precisos.
Conclusão
Como programador que trabalha com Python, você deve usar o tipo de dados float. Para evitar erros com esse tipo de dados, é importante entender como o Python representa os números flutuantes internamente. Como o Python não pode armazenar os números flutuantes reais, evite fazer comparações exatas de igualdade com valores flutuantes. Caso contrário, você encontrará erros.
Caso você precise de resultados precisos em sua aplicação, evite usar valores flutuantes. Em vez disso, use o módulo decimal embutido, que produz resultados precisos de números de ponto flutuante e os representa exatamente como são e de maneira independente da máquina.
Você também pode ler Python Itertools Functions e Python Try Except.