Python, un lenguaje de programación ampliamente utilizado, sobresale en tareas de computación numérica, pero no es inmune a los desafíos que plantea la aritmética de punto flotante. Los números de coma flotante en Python son aproximaciones de números reales, lo que lleva a errores de redondeo, pérdida de precisión y cancelaciones eso puede alterar los cálculos. Podemos Detecte estos errores buscando resultados extraños y usando herramientasnumpy.finfo>a monitorizar la precisión . Con algo de precaución y trucos inteligentes, podemos Mantenga estos errores bajo control y garantizar que nuestros cálculos de Python sean confiables. En este artículo, exploraremos las complejidades de los errores de punto flotante en Pitón .
¿Qué son los números de coma flotante?
Los números de coma flotante son una forma eficaz de representar números reales en las computadoras. Constan de tres partes:
fecha javascript
- Significativo: Los dígitos reales que representan el número (por ejemplo, 3,14159)
- Exponente: Indica cuántos lugares desplazar el significado hacia la izquierda o hacia la derecha (por ejemplo, -2 en 3,14159 x 10^-2)
- Base: Normalmente 2 para computadoras, lo que determina cómo se representan los números internamente
¿Por qué ocurren errores de punto flotante?
Los errores de punto flotante surgen porque las computadoras almacenan números reales utilizando un número finito de bits, lo que genera aproximaciones y posibles imprecisiones. Los números de punto flotante tienen limitaciones intrínsecas:
- Precisión finita: Sólo se puede almacenar un número limitado de dígitos en el significado, lo que lleva a errores de redondeo al representar decimales exactos.
- Pérdida de precisión: Operaciones como la suma o la resta pueden reducir aún más la precisión, agravando los efectos del redondeo.
- Desbordamiento insuficiente/desbordamiento: Números extremadamente pequeños o grandes pueden quedar fuera del rango representable, lo que lleva a desbordamiento (se vuelve cero) o Desbordamiento (se vuelve infinito).
Tipos de errores de coma flotante
a) Errores de redondeo: El más común ocurre cuando es necesario aproximar un decimal exacto para que se ajuste a la precisión limitada de un flotador.
b) Pérdida de precisión: Las operaciones posteriores pueden acumular gradualmente errores de redondeo, lo que da lugar a importantes imprecisiones en el resultado final.
c) Cancelación catastrófica: Al restar números casi iguales con signos opuestos, sus dígitos significativos se cancelan, dejando un resultado pequeño e inexacto.
d) Desbordamiento/Desbordamiento insuficiente: Estos ocurren cuando los cálculos exceden el rango representable de valores flotantes, lo que genera resultados inexactos o sin sentido.
Detección de errores de punto flotante
- Observando resultados inesperados: Comparar los valores calculados con los resultados esperados o visualizar datos puede revelar inconsistencias a menudo causadas por errores.
- Usando bibliotecas como
numpy.finfo>: Bibliotecas comonumpy>proporcionar herramientas comofinfo>para comprobar la precisión y las limitaciones de diferentes tipos de datos flotantes.
Error de punto flotante de Python
Aquí discutiremos diferentes tipos de ejemplos que ilustran errores de punto flotante en Python:
Pérdida de precisión en la conversión de decimal a binario
En este ejemplo, el número decimal 0,1 se convierte a binario. Debido a la expansión binaria infinita de 0,1, sólo se utiliza un número finito de bits, lo que provoca una pérdida de precisión.
Python3
decimal_number>=> 0.1> binary_representation>=> format>(decimal_number,>'.30f'>)># 30 decimal places> print>(f>'Decimal: {decimal_number}
Binary: {binary_representation}'>)> |
>
>
Producción:
Decimal: 0.1 Binary: 0.100000000000000005551115123126>
Errores de redondeo
Aquí, se espera que el resultado de la suma de 1/3 tres veces sea 1,0. Sin embargo, debido a errores de redondeo al representar 1/3, es posible que la suma no sea exactamente 1,0.
Python3
result>=> 1.0> /> 3.0> sum_result>=> result>+> result>+> result> print>(f>'Expected Result: 1.0
Actual Result: {sum_result}'>)> |
>
>
Producción:
Expected Result: 1.0 Actual Result: 1.0>
Errores acumulativos en cálculos iterativos
Este ejemplo demuestra cómo pueden ocurrir errores acumulativos en cálculos iterativos. Es posible que sumar 0,1 diez veces no produzca un resultado exacto de 1,0 debido a limitaciones de precisión del punto flotante.
Python3
total>=> 0.0> for> i>in> range>(>10>):> >total>+>=> 0.1> print>(f>'Expected Result: 1.0
Actual Result: {total}'>)> |
>
>
Producción:
Expected Result: 1.0 Actual Result: 0.9999999999999999>
Problemas de comparación
En este caso, comparar la suma de 0,1 y 0,2 con 0,3 puede no producir el resultado esperado.True>resultado debido a la imprecisión inherente de los números de punto flotante.
Python3
a>=> 0.1> +> 0.2> b>=> 0.3> print>(f>'a: {a}
b: {b}
Equal: {a == b}'>)> |
>
>
Producción:
a: 0.30000000000000004 b: 0.3 Equal: False>
Resultados inesperados en los cálculos
Aquí, la resta de1e16>de la suma(1e16 + 1)>Se espera que produzca 1, pero debido a errores de punto flotante, es posible que el resultado no sea exactamente 1.
Python3
a>=> 0.1> +> 0.2> b>=> 0.3> print>(f>'a: {a}
b: {b}
Equal: {a == b}'>)> |
>
>
Producción:
Expected Result: 1 Actual Result: 0.0>
Comprender la precisión del punto flotante
Aquí entenderemos la precisión del punto flotante: La anomalía 1.2 – 1.0 en Python-
Desafíos de representación
Como se sabe que 1,2 – 1,0 = 0,2. Pero cuando intentes hacer lo mismo en Python, te sorprenderán los resultados:
>>> 1.2 - 1.0>
Producción:
0.199999999999999996>
Esto puede considerarse un error en Python, pero no lo es. Esto tiene poco que ver con Python y mucho más con cómo la plataforma subyacente maneja los números de punto flotante. Es un caso normal que se encuentra cuando se manejan números de punto flotante internamente en un sistema. Es un problema causado por la representación interna de números de punto flotante, que utiliza un número fijo de dígitos binarios para representar un número decimal. Es difícil representar algunos números decimales en binario, por lo que en muchos casos se producen pequeños errores de redondeo. Conocemos casos similares en matemáticas decimales, muchos resultados no se pueden representar con un número fijo de dígitos decimales, por Ejemplo
10 / 3 = 3.33333333.......>
En este caso, tomando 1,2 como ejemplo, la representación de 0,2 en binario es 0,00110011001100110011001100…… y así sucesivamente. Es difícil almacenar internamente este número decimal infinito. Normalmente, el valor de un objeto flotante se almacena en punto flotante binario con una precisión fija ( normalmente 53 bits ). Entonces representamos 1.2 internamente como,
1.0011001100110011001100110011001100110011001100110011>
Que es exactamente igual a:
1.1999999999999999555910790149937383830547332763671875>
Manejo del error de punto flotante
Aquí discutiremos diferentes ejemplos sobre cómo manejar errores de punto flotante en Python:
Redondear a un decimal específico
Al redondear el resultado a un decimal específico (por ejemplo, 2), puede mitigar el impacto de pequeños errores de punto flotante.
Python3
result>=> 1.2> -> 1.0> rounded_result>=> round>(result,>2>)> print>(f>'Original Result: {result}
Rounded Result: {rounded_result}'>)> |
>
>
Producción:
Original Result: 0.19999999999999996 Rounded Result: 0.2>
Uso de clases decimales para alta precisión
Eldecimal>El módulo proporciona laDecimal>clase, lo que permite una aritmética de mayor precisión. Ajustar la precisión congetcontext().prec>puede ayudar a gestionar la precisión de cálculos específicos
Python3
from> decimal>import> Decimal, getcontext> getcontext().prec>=> 4> # Set precision to 4 decimal places> result>=> Decimal(>'1.2'>)>-> Decimal(>'1.0'>)> print>(f>'High Precision Result: {result}'>)> |
>
>
Producción:
lista a matriz java
High Precision Result: 0.2>
Usar fracciones para representaciones exactas
Elfractions>El módulo permite trabajar con representaciones fraccionarias exactas, evitando errores de punto flotante.
Python3
from> fractions>import> Fraction> result>=> Fraction(>'1.2'>)>-> Fraction(>'1.0'>)> print>(f>'Exact Fractional Result: {result}'>)> |
>
>
Producción:
Exact Fractional Result: 1/5>
Manejo de resultados intermedios con decimales
Utilizar elDecimal>clase para cálculos intermedios para minimizar los errores acumulativos antes de volver a convertirlos a flotantes.
Python3
from> decimal>import> Decimal, getcontext> getcontext().prec>=> 6> # Set precision to 6 decimal places> intermediate_result>=> Decimal(>'1.2'>)>-> Decimal(>'1.0'>)> final_result>=> float>(intermediate_result)># Convert back to float if needed> print>(f>'Intermediate Result: {intermediate_result}
Final Result: {final_result}'>)> |
>
>
Producción:
Intermediate Result: 0.2 Final Result: 0.2>
Conclusión
Aún así, ¿piensas por qué? Python no está resolviendo este problema , en realidad no tiene nada que ver con Python. Sucede porque es la forma en que la plataforma c subyacente maneja números de punto flotante y, en última instancia, con la inexactitud, siempre habremos estado escribiendo números como una cadena de un número fijo de dígitos. Tenga en cuenta que esto está en la naturaleza misma del punto flotante binario: esto tampoco es un error en Pitón o C , y tampoco es un error en su código. Verá el mismo tipo de comportamiento en todos los idiomas que admiten la aritmética de punto flotante de nuestro hardware, aunque es posible que algunos idiomas no muestren la diferencia de forma predeterminada o en todos los modos de salida). Tenemos que considerar este comportamiento cuando nos preocupamos por problemas matemáticos que necesitan precisiones exactas o cuando lo usamos dentro de declaraciones condicionales. Controlar punto flotante sección en la documentación de Python para conocer más comportamientos de este tipo.
Preguntas frecuentes (FAQ)
1. ¿Qué es un error de punto flotante en Python?
Un error de punto flotante en Python se refiere a discrepancias entre los resultados esperados y reales cuando se trabaja con números de punto flotante, que surgen de las limitaciones de representar números reales en un sistema binario.
2. Por que 1.2 - 1.0> no es igual 0.2> en Python?
La discrepancia se debe a los desafíos inherentes a la representación de números decimales en binario. Se producen errores de redondeo durante la representación binaria interna, lo que genera resultados inesperados.
3. ¿El error de punto flotante es un error en Python?
No, no es un error en Python. Es un problema común en informática relacionado con cómo se representan internamente los números de punto flotante. Python cumple con el estándar IEEE 754 para aritmética de punto flotante.
4. ¿Cómo puedo redondear un resultado de punto flotante a un decimal específico?
Puedes usar el
round()>función para redondear un resultado de punto flotante a un lugar decimal específico. Por ejemplo,rounded_result = round(result, 2)>.
5. Cuál es el decimal> módulo y ¿cómo ayuda a manejar los errores de punto flotante?
El
decimal>El módulo proporciona laDecimal>clase para aritmética de mayor precisión. Ajuste de la precisión y usoDecimal>puede ayudar a mitigar los errores de punto flotante.