No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Comparación de números flotantes

17/38
Recursos

Aportes 205

Preguntas 46

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Este planteamiento servira, hago la consulta

tres formas de comparar flotates:

Esta clase en particular me pareció complicada de entender, el profesor no explica a qué se refiere con “format” y la explicación deja mucho que desear.

La razon de porque la division no es exacta es:

Python utiliza la IEEE 754-2008 para la representación de números de punto flotante, que es la norma internacional para la representación y el cálculo de números de punto flotante. Sin embargo, esta norma tiene sus limitaciones y, por lo tanto, python también tiene limitaciones en la representación y el cálculo de números de punto flotante.

Una de las limitaciones principales de la IEEE 754-2008 es que sólo permite representar un número finito de dígitos decimales. Esto significa que, en algunos casos, los números de punto flotante no se pueden representar de forma exacta y se producen errores de redondeo o truncamiento. Estos errores pueden ser pequeños y pueden no tener un impacto significativo en el cálculo, pero en algunos casos pueden ser muy grandes y afectar significativamente al resultado final.

Algo que se va del alcance de la clase pero es bueno saber es que ese 1.1+2.2 no da 3.3 en la computadora ya que lo que hace esta es pasar esos 1.1 y 2.2 a binario y sumarlos, pero en binario 1.1 y 2.2 tienen infinitos decimales, por lo que la computadora corta hasta cierto digito y asi los suma, generando un error que crece como bola de nieve, se le conoce como error de punto flotante.

Usando la función round(valor,decimales)

x = 3.3
print(x)
y = round((1.1 + 2.2),1) 
print(y)
print(x==y)

y_str = format(y, “.2g”)

Quiero aportar algunos datos sobre esta función.

.2g significa 2 digitos significativos, osea si el numero es 1.0, el 0 no lo toma en cuenta

.2f este si es para decimales, muestra 2 decimales.

y se puede realizar otras cosas como cambiarlo a moneda ‘$,.2f’

16 - Comparación de números flotantes

Como podemos comparar flotantes? para eso tenemos 3 métodos con las siguientes funciones:

  • format() Esta función formatea un string de forma flexible, de esta forma podemos quitar decimales a un Nro float, para después compararlo con otros números
  • abs() → obtiene el valor absoluto de un numero, que es la distancia entre el nro y el 0, es decir el valor nro sin considerar su signo
  • round() → Se utiliza para redondear un número a un determinado número de dígitos decimales. Puede tomar uno o dos argumentos: el 1er argumento es el número que se va a redondear y el 2do argumento, que es opcional, es el número de decimales a los que se quiere redondear.

Redondear un número a un entero:

num = 4.6
rounded_num = round(num)
print(rounded_num)  # Salida: 5

Redondear un número a dos decimales:

num = 3.14159265
rounded_num = round(num, 2)
print(rounded_num)  # Salida: 3.14

Pienso que al tratarse de números es mejor utilizar las formas matematicas para operarlos

Hmmm siendo honesto, el enfoque matemático, si bien es cierto que aplica matemática, no es tan directo como cuando se aplica una función como round() y redondear a 2 decimales. Esto teniendo en cuenta referencias de otros lenguajes de programación.

Revisando algunos ejemplos en línea, veo que ese método no funciona según lo esperado, por lo que se recurre a aplicar formatos.

Aquí dejo el link que encontré mencionando el tema.

Es importante aclarar que es un valor Absoluto o la función abs()
En forma Matematica y lo mas sencillo posible es que tomas el valor del digito sin importar su signo, en este caso positivo o negativo, por ejemplo 5 - 7 = -2 ; 7 - 5 = 2, el valor absoluto simplemente toma el resultado de la operación y le quita el signo, dejándolo como un valor absoluto, creo que es necesario recalcar esto porque no todas las personas están claros de esos detalles matematicos en cursos introductorios.

https://ellibrodepython.com/float-python

comparto este articulo me pareció super para complementar

Esto resolvería la comparación entre dos tipos de variables float con un decimal…

a=3.3
b = 1.1 + 2.2
print (round(a,1)==round(b,1))

también podemos usar la función math

import math

a = 0.1 + 0.1 + 0.1
b = 0.3

if math.isclose(a, b):
    print("Los valores son aproximadamente iguales")
else:
    print("Los valores son diferentes")

""" formas de comparar floats """
x = 7.7
print("x =", x)

y = 3.4 + 4.3
print("y = 3.4 + 4.3 =", y)

print(f"x == y: {x == y}")

# Haciendo uso de strings
print("*" * 35)
print("Haciendo uso de strings")
print("x =", x)
y_str = format(y, ".2g")
print("y_str =", y_str)
print(f"x == y: {str(x) == y_str}")

# Comparando por margen de error
print("*" * 35)
print("Comparando por margen de error")
print("x =", x)
print("y =", y)
error = 0.001
print(f"x == y, considerando un margen de error de {error} : {abs(x - y) < error}")

Que genial explicación

De acuerdo con RealPython, .2g determina el número total de dígitos significativos antes y después del punto decimal:

La TOLERANCIA se entiende más con números grandes. Supongamos que tengo:

x = 33 000 000 ⇒ treinta y tres millones de pesos

y = 33 000 003 ⇒ treinta y tres millones tres pesos

Son cifras muy similares, no obstante la última cifra de ‘y’ el ‘3’ hace que no sean iguales.

Pero tengo que hacer contabilidad de los gastos y el presupuesto es de 33 millones y no de 33 millones tres, pero hipotéticamente me doy cuenta de que no me importa perder 3 pesos pero sí me importa perder 5 pesos porque ya estaría perdiendo mucho (hipotéticamente).

Aquí es donde entra la tolerancia, no quiero tener en cuenta los gastos menores a 5 pesos pero si los que son de 5 pesos en adelante entonces digo que:

TOLERANCIA = 5

Ahora hago la resta y guardo en la variable r

r = (33 000 000 - 33 000 003) < 5

El resultado es -3

r ⇒ -3

Aquí llamamos al método abs(), el cual ignora el signo que tenga el número y solo toma el número así:

abs( r ) ⇒ 3

Finalmente lo comparamos con nuestra tolerancia, en este ejemplo con la cantidad de pesos que estamos dispuestos a perder

(3 < 5) ⇒ True

Al ser el número que tenemos de más (3) menor que el número que NO estamos dispuestos a perder, es decir la TOLERANCIA, hacemos aproximación y decimos que

x == y

Como ves hacemos la misma operación de la clase solo que desglosada en partes.

Esto es lo mismo que hacen en el ejemplo y esta técnica se aplica para generalmente para números muy pequeños como los decimales de la variable ‘y’ de la clase donde son cantidades tan pequeñas que ignorarlas no afecta al resultado.

  1. Algo nuevo que leí en los comentarios es que Python utiliza la norma IEEE754-2008 para hacer cálculos de números decimales, lo cual ocasiona que el resultado final no sea exactamente igual a cuando se usan cálculos matemáticos. No se cual es el objetivo, pero supongo que se verá más adelante y voy a investigar por mi cuenta.

  2. El uso de tolerancias me parece interesante para comparar números, además que puede ser aplicable a varias ramas de la ciencia, como la Ingeniería (industrial, química), en la cual muchas veces utilizamos tolerancias, márgenes de error, etc. para muchas variables.

Considero que es mejor realizarla de forma matemática para no seguir confundiendo a las personas o creando mas miedo con los números.

Aunque claro que si estamos aquí es por que realmente nos gusta y nos apasionan estas materias.

Estuve leyendo algunos comentarios y tengo para decir lo siguiente:

  1. Muchas veces los profesores no nos van a entregar toda la información. También tenemos que buscar y averiguar cosas por nosotros mismos, para eso existe la documentación. Muchas veces ellos solo nos dan las bases, eso hace parte del ejercicio de aprendizaje. Nisiquiera en las mejores universidades hacen eso. Empoderense de su proceso.

  2. Tambien leí mucho de compañeros que se preguntaban porque el profesor no solo redujo el numero de decimales con float. Me di a la tarea de averiguarlo y encontré la siguiente respuesta:

La representación de punto flotante no es exacta y los errores de redondeo pueden acumularse en operaciones más complejas.

La aproximación basada en tolerancia (como la que mencionó el profe) es más general y robusta, ya que toma en cuenta los posibles errores de redondeo y la naturaleza imprecisa de los cálculos con números de punto flotante. Utilizar una tolerancia permite considerar valores como “cercanos” si están dentro de un rango aceptable de diferencia, en lugar de depender de la igualdad exacta de las representaciones numéricas.

😃

# Así se usa la función ROUND para comparar
x = 3.3
y = 1.1 + 2.2

print("Valor de x: ",x)
print(" ")
print("Valor de y: ",y)
print(" ")
print("x == y: ",x == round(y,1)) # x == y: True 


Comparaciones, apuntes de clase: x = 3.3 print(x) y= 1.1 + 2.2 print(y) print(x==y) y\_str = format(y,".2g") print("str -->", y\_str) print(y\_str == str(x)) print("\*" \*10) print(y,x) tolerance = 0.00001 print(abs(x -y) < tolerance)

¿Por qué no suma 3.3?

Se debe a la imprecisión de la representación binaria de los números decimales 1.1 y 2.2 y cómo se manejan las operaciones aritméticas en el lenguaje de programación.

Detalle.

Cuando se realiza la suma de 1.1 y 2.2 en un lenguaje de programación, los números se convierten a su representación binaria interna y luego se realiza la operación. Sin embargo, debido a las limitaciones del formato binario, el resultado puede contener pequeños errores.

¿Qué puedo hacer?

Puedo considerar técnicas como redondeo o uso de tipos de datos más precisos cuando se requiere una mayor precisión en los cálculos decimales.

x = 1.1 + 2.2
y = 3.3

print(round(x,1) == y)
  1. y_str = format(y, ".2g"): Esta línea utiliza la función format() para formatear el valor de la variable y con dos dígitos significativos. El especificador ".2g" indica que se debe usar el formato general (sin notación científica) y se deben mostrar dos dígitos significativos. El resultado se guarda en la variable y_str.

  2. print('str =>', y_str): Esta línea imprime en la consola el texto “str =>” seguido del valor de la variable y_str. En este caso, imprimirá “str => 3.3”.

  3. print(y_str == str(x)): Esta línea compara el valor de la variable y_str con el valor de la variable x convertido a una cadena de texto utilizando str(). Si ambos valores son iguales, la expresión será True; de lo contrario, será False. En este caso, la expresión evaluará a True si el valor de x es igual a “3.3” como una cadena de texto.

En resumen, el código formatea un número y con dos dígitos significativos y lo guarda como una cadena de texto en y_str. Luego, imprime ese valor formateado y compara si es igual a la representación en cadena de texto del valor de x. Si son iguales, imprimirá True.

La comparación de flotantes por el método de strings y matemático; son muy interesantes ambos. Es de anotar, que si solo le colocamos a la tolerancia un 0.1; ya estamos aprobando (True) la comparación ; ya que la suma de los flotantes tiene 14 ceros hacia la derecha. Para que fuera Falsa tendríamos que colocarle quince ceros.

Hay que ser mas precisos a la hora de explicar, al momento de usar la función format(), el argumento ideal para el ejercicio debio ser “.2f”, dado que de esta forma se redondea a dos decimales, en cambio al usar el “.2g”, hablamos de conceptos como dígitos significativos, redondeo etc, que como se pudo mostrar en el ejemplo, según lo que comenta el instructor, el uso “.2g” para tomar solo dos decimales pero en el resultado le sale “3.3” el cual solo tiene un decimal. Estos detalles pueden confundir a personas que son muy curiosas, me he pasado mucho tiempo buscando explicación a porque le sale “3.3” si el dice que lo redondea a 2 decimales, recurrí a chatgpt y ya con eso pude aclarar mi idea.

Profesor no entendí la forma matemática, usted explica muy bien pero ceo que omitió muchas cosas

Debo admitir que este tema si me dio duro…

Lo hice utilizando la formula round y un solo decimal y al compáralos el resultado es True.

Desde algo tan básico como esto, se nota el esfuerzo que le ponen a los cursos, muchas gracias, me encanto la clase

No me había percatado de esa situación en python por números flotantes. Se me hizo curioso.

Me parece muy interesante el Formato g de python, aquí mi resumen con la explicación de porque tenemos que transformar la variable x en string.

Buenas tardes, a mi me resulto mucho mas facil de esta forma
x = 3.3
print(x)
y = 1.1 + 2.2
y = (round(y, 2))
print(y)

print(x == y)

Me parece bastante ùtil la tecnica que ha utilizado el docente para igualar los valores de 3.3 y 3.300000000004.

Y también importante el uso de la función abs()

Por más que repito la clase, se me hace muy complejo y no logro entender.

Otra forma que encontré para solucionar este problema es a función round() ,en Python se utiliza para redondear un número a una cierta cantidad de dígitos decimales o a un número entero.

x = 3.3000000000000003
rounded_x = round(x, 2)
print(rounded_x)
'''
print(round(y,2))

La tolerancia en matemáticas es la cantidad de error que se puede permitir en un cálculo o medición sin que afecte significativamente el resultado final. En Python, la tolerancia se puede aplicar en comparaciones de números de punto flotante utilizando la función isclose() del módulo math. Esta función compara dos números y devuelve True si son iguales dentro de una tolerancia dada. Por ejemplo, para comparar si dos números son iguales dentro de una tolerancia de 0.001, se puede usar el siguiente código:

import math

a = 0.1 + 0.1 + 0.1
b = 0.3

if math.isclose(a, b):
    print("Los valores son aproximadamente iguales")
else:
    print("Los valores son diferentes")

En este caso, la función isclose() devuelve True porque los valores de a y b son iguales dentro de una tolerancia de 0.001.

Otra forma de aplicar la tolerancia es redondeando los números a un número determinado de decimales utilizando la función round(). Por ejemplo, para comparar si dos números son iguales dentro de una tolerancia de 0.01 y redondearlos a dos decimales, se puede usar el siguiente código:

x = 3.3
y = 1.1 + 2.2

if round(x, 2) == round(y, 2):
    print("Los valores son aproximadamente iguales")
else:
    print("Los valores son diferentes")

a = y-x
print(a)

print(y-a)
print(y-a == x)

Otra forma de lograr esa comparación fue con la función round, donde redondee el y a 1 decimal.

#round
print(x == round(y,1))

ay no! no me gustan las matemática, pero no me rendiré

tolerance=0.00001
#comparar
print(abs(x-y)<tolerance)
#abs valor absoluto

a

Gracias por el aporte me quedo con este método.
x = 3.3
y = 1.1 + 2.2
print(round(y, 1))
print(x + y)

Tengamos en cuenta que la explicación nos lleva a entender el porqué. Sin embargo, no es lo más práctico, en las labores diarias haces un Round y después de la coma (,) eliges cuantos decimales quieres y listo.

float1 = Round(3.322, 1)
float2 = 3
print (float1 + float2)
Otras 2 maneras de escribir la tolerancia: `tolerance = 1e-05 # 0.00001 ó 10 ** -5`
Definitivamente es mucho mas sencillo de hacer y entender con la funcion round
Hola! Adjunto un material que encontré acerca de cómo comparar números flotantes. <https://platzi.com/tutoriales/4227-python-fundamentos/25068-como-comparar-numeros-flotantes/> Quizá en la clase no profundiza tanto en el tema pero si hay alguien que quedó con dudas le recomiendo leer esto.
Esta comparación se nota ya inicia lo chido.
Alguien pudiera decirme si en alguna parte del curso veremos todas las funciones? creo que estaría bien tener una lista de todas las que existen para estudiarlas
Por aqui dejo mi aporte se puede usar la funcion roud. ![](https://static.platzi.com/media/user_upload/Screenshot_68-b37eae20-d74c-41c5-8170-dd2e6f5f249c.jpg)
Si calculo solo el valor absoluto de la expresión sin incluir la tolerancia no me da cero exacto tampoco. ¿Es correcto? print (abs(x -y)) 4.440892098500626e-16 = 0.44
Formas de realizarlo: ![](https://static.platzi.com/media/user_upload/image-0997a1e9-1317-4b6c-a128-f4ef3ee28f47.jpg)
Ejemplo de código en Python para usar un margen de tolerancia para comparar números flotantes:   \# función **def casi\_igual**(a, b, tolerancia=1e-6):     return abs(a - b) <= tolerancia \# Ejemplo de uso x = 0.1 + 0.2 y = 0.3 **if casi\_igual**(x, y):     print("x e y son casi iguales") **else:**     print("x e y no son iguales")
me parece que la ultima explicacion de los decimales y compararlos se debio mencionar round(variable, cantidad de decimas) asi es menos engorroso al final del dia el codigo debe ser lo mas sencillo posible
Si bien ambas formas son un tanto complicadas, creo que la segunda forma, la manera matemática es mejor ya que te lleva a pensar y analizar un poco más para la comparación de los números flotantes, además de que te impide convertirlos a string de manera tan brusca.
Me dio curiosidad que el profesor utilizara ".2g" en vez de ".2f" para determinar la cantidad de decimales que tendría el número decimal y estuve investigando y aquí la información: ![]()![](https://static.platzi.com/media/user_upload/image-629bd2ac-b5d5-4c2b-b7fe-c4cd925510e1.jpg)
Me dio curiosidad que el profesor utilizara ".2g" en vez de ".2f" para determinar la cantidad de decimales que tendría el número decimal y estuve investigando y aquí la información: ![]()
Hay casos en donde la suma de los números da un resultado con un único decimal y no es necesario realizar ese procedimiento. ![](https://static.platzi.com/media/user_upload/image-a19c2535-c305-44af-ad34-ca6ed7c65618.jpg)
en VSC no me salio 3.30000000 etc me salio de una 4 3.3 3.4 False mmmm
Tengo una duda, porque si utilizo otros valores para la suma que no sea 3.3 me da valores exactos de 1 decimal? ![](https://static.platzi.com/media/user_upload/image-9489c5fc-188e-41c2-9aeb-92063fc158f0.jpg)
Aquí les dejo otra posible solución. ```js y_str = format(y, ".2g") #string y_str = float(y_str) # float print("El tipo de dato es:", y_str, type(y_str)) ```
Hola, estoy practicando lo del curso en Visual Studio Code. esta linea no me la ejecuta me sale con un error. y\_str = format(y. "2g").
Muy interesante, el manejo de los números flotantes, gracias por esta clase profe.
algo que observar en el ejercicio. Si comparas la x sin convertirla a string con la y\_string dice que es false, pero si conviertes la x a string te da True. entonces si hay comparación de string y float?, solo que por la diferencia de tipos da False?.
Fotrma 3: ```python x = 3.3 print(x) y = 1.1 + 2.2 print(y) if round(y, 1) == round(x, 1): print("La comparación es True") else: print("La comparación es False") ```
Comparar números flotantes (números decimales) en la programación puede ser un poco más complicado debido a la naturaleza de los números de punto flotante en la representación binaria. Debido a esto, los cálculos pueden tener pequeños errores de redondeo que podrían afectar la comparación directa. Aquí hay algunas técnicas comunes para comparar números flotantes: 1. **Comparación con tolerancia**: En lugar de verificar si dos números son exactamente iguales, se puede verificar si la diferencia entre ellos es menor que una cierta tolerancia.pythonCopy code`tolerancia = 0.0001` `numero1 = 0.1 + 0.2` `numero2 = 0.3` `if abs`(numero1 - numero2) < tolerancia: ` print("Los números son aproximadamente iguales."`) `else`: ` print("Los números no son iguales."`) 2. **Comparación relativa**: En lugar de comparar directamente los valores, se puede comparar la diferencia relativa entre ellos.pythonCopy code`numero1 = 0.1 + 0.2` `numero2 = 0.3` `if abs(numero1 - numero2) < 1e-9 * max(abs(numero1), abs`(numero2)): ` print("Los números son aproximadamente iguales."`) `else`: ` print("Los números no son iguales."`) 3. **Utilizar bibliotecas especializadas**: En algunos lenguajes de programación, hay bibliotecas especializadas que manejan correctamente las comparaciones de números de punto flotante, teniendo en cuenta los errores de redondeo.pythonCopy code`import` math `math.isclose(0.1 + 0.2, 0.3`) Dependiendo del contexto y los requisitos específicos de tu programa, puedes elegir la técnica que mejor se adapte a tus necesidades. Sin embargo, es importante tener en cuenta que las comparaciones de números de punto flotante pueden ser un área complicada y a menudo es necesario tener cuidado al realizar tales comparaciones.
![](https://static.platzi.com/media/user_upload/image-7420ddeb-7e71-40fa-a9e2-be6b03fd7945.jpg)Asi es mas sencillo y con el mismo resultado si no me equivoco
Creería que hay una falla en Python print(1.1 + 2.2) // 3.300000000003 print(1.2 + 2.1) // 3.3
![](https://static.platzi.com/media/user_upload/image-41fab283-0a47-4b7a-9d79-d9aceed2a43e.jpg) Siento que faltaría volver a preguntar si x es igual a y
![](https://static.platzi.com/media/user_upload/image-77690994-87bc-46ac-a62f-021acaa87a8a.jpg) En mi opinión (soy nueva en esto), la comparación que se hace al usar la variable "tolerance" no es la misma comparación de x==y, porque al hacer la comparación (abs(x-y) < tolerance) estamos comparando si la diferencia (sustracción) entre x y y, en positivo, es menor a la tolerancia establecida, no que si x es igual a y.
Hola , alguien me puede explicar mejor porque se hace así en la forma matemática que explica el profe, no entendi como haciendo esa comparación me dicen que son iguales
Además de las operaciones aritméticas, los números de punto flotante pueden ser alterados por una variedad de operaciones y situaciones en programación. Aquí hay algunos ejemplos: 1. **Conversiones de tipo de datos**: Si conviertes un número de punto flotante a otro tipo de datos, como enteros o cadenas, podrías perder precisión o experimentar redondeo, dependiendo de cómo se manejen las conversiones en el lenguaje de programación que estés utilizando. 2. **Operaciones de comparación**: Al comparar números de punto flotante, especialmente usando operadores de igualdad, podrías encontrar resultados inesperados debido a la imprecisión inherente en la representación de los números de punto flotante. 3. **Almacenamiento en estructuras de datos**: Cuando almacenas números de punto flotante en estructuras de datos como listas, diccionarios o bases de datos, podrías encontrar problemas de precisión si no se manejan adecuadamente. 4. **Operaciones de entrada/salida**: Si estás leyendo o escribiendo números de punto flotante desde o hacia archivos o bases de datos, es importante tener en cuenta cómo se maneja la precisión durante estas operaciones. El rango mínimo y máximo de números de punto flotante que se puede operar depende del estándar de punto flotante que esté implementado en el sistema o en el lenguaje de programación. El estándar IEEE 754 es comúnmente utilizado y define diferentes formatos de punto flotante, como precisión simple (float) y doble precisión (double). En precisión simple, un float de 32 bits, el rango típico es de aproximadamente 1.4×10−451.4×10−45 a 3.4×10383.4×1038, mientras que en doble precisión, un double de 64 bits, el rango es mucho más amplio, desde aproximadamente 5.0×10−3245.0×10−324 hasta 1.8×103081.8×10308. Es importante tener en cuenta que los límites exactos pueden variar según la implementación y la arquitectura del sistema. Además, fuera de estos rangos, los números pueden representarse como infinito o NaN (Not a Number) según el estándar de punto flotante.
# Comparación de Números Flotantes en Python 🧐 Cuando trabajas con números de punto flotante en Python, compararlos puede ser un desafío debido a la precisión y los errores de redondeo. Aquí tienes tres métodos que pueden ayudarte a hacer estas comparaciones más efectivas: ### 1. Uso de `format()` 📝 * **Función**: `format()` nos permite convertir un número flotante en una cadena de texto, permitiéndonos limitar el número de decimales. * **Ejemplo**: `format(3.14159, '.2f')` dará como resultado `'3.14'`. ### 2. Uso de `abs()` ✔️ * **Función**: `abs()` devuelve el valor absoluto de un número, que es su distancia desde 0 en la línea numérica, sin considerar su signo. * **Ejemplo**: `abs(-3.14)` resultará en `3.14`. ### 3. Uso de `round()` 🔵 * **Función**: `round()` redondea un número a una cantidad específica de decimales. * **Redondear a entero**: * **Código**:pythonCopy code`num = 4.6` `rounded_num = round`(num) `print(rounded_num) # Salida: 5` * **Redondear a dos decimales**: * **Código**:pythonCopy code`num = 3.14159265` `rounded_num = round(num, 2`) `print(rounded_num) # Salida: 3.14` ## Entendiendo la TOLERANCIA 🎯 La **tolerancia** se hace más evidente cuando trabajamos con números grandes. Imagina que tienes dos cantidades de dinero muy cercanas, pero no exactamente iguales: * `x = 33 000 000` (treinta y tres millones) * `y = 33 000 003` (treinta y tres millones tres) ### Escenario Contable 🏦 Supón que en la contabilidad, una diferencia de 3 unidades no es significativa, pero una de 5 o más sí lo es. Así que estableces una **TOLERANCIA = 5**. ### La Operación 🔍 Realizas la siguiente operación para ver si `x` y `y` son "suficientemente" iguales: * Calculas la diferencia: `r = abs(x - y)` * Comparas con la tolerancia: `es_aceptable = (r < TOLERANCIA)` ### El Resultado ✅ Si `r` es menor que la tolerancia, decides que para tus propósitos contables, `x` es igual a `y`. ### ¿Por qué es útil? 🤔 Esta técnica es muy útil para lidiar con números muy pequeños, como los errores de punto flotante que pueden surgir al hacer cálculos. Si las diferencias son menores que tu tolerancia, puedes considerar que son efectivamente iguales para tu caso de uso específico. ### Recordatorio 📌 Recuerda que la tolerancia dependerá del contexto de tu problema y debe ser definida de manera que tenga sentido para la precisión que necesitas en tus cálculos. ### Ejemplo en Python 🐍 pythonCopy code`# Definimos los números y la tolerancia` `x = 33000000` `y = 33000003` `tolerancia = 5` `# Calculamos la diferencia y aplicamos la tolerancia` `diferencia = abs`(x - y) es\_aceptable = diferencia < tolerancia `# Comprobamos si la diferencia es aceptable` `print("¿Son x e y aproximadamente iguales?", es_aceptable) # Salida: True` Con estos métodos, ¡puedes manejar números flotantes en Python como un pro! 💪
Usando round tambien pude obtener el resultado de que sea true el resultado:![](https://static.platzi.com/media/user_upload/image-3c7ec77f-77c5-4e64-a046-8f216e716eeb.jpg)
chimbo!!! no debería agregar basura en la precisión
No seria mejor hacer un redondeo a la cantidad de decimales ingresados o un trunc es mas exacto ya que no corremos el riesgo de la aproximación x = 3.3 y = 1.1 + 2.2 print(x == round(y,1))
Auxilio! No entendí bien porque se pone abs. Gracias
Mis apuntes ![](https://static.platzi.com/media/user_upload/image-2ff1120c-6273-4565-9b4f-3d268c4f7145.jpg)
No seria mejor hacer un redondeo a la cantidad de decimales ingresados o un trunc x = 3.3 y = 1.1 + 2.2 print(x == round(y,1))
la tolerancia en Python se utiliza para medir la diferencia entre dos números y determinar si son iguales o no. Si dos números son iguales dentro de la tolerancia definida, entonces se consideran iguales. Por ejemplo, si tienes una tolerancia de 0.1, y tienes dos números, 3.1 y 3.11, entonces se considerarían iguales, ya que su diferencia
Ayuda! Quisierá entender qué está pasando aquí: ![](https://static.platzi.com/media/user_upload/image-ad104bef-ddd4-4e88-84aa-2fec259c9376.jpg) Yo pensé que el resultado de print sería: 123.45 No esa noación científica
Creo que esto tambien podria funcionar. x = 3.3 y = 1.1 + 2.2 print(x)print(y) newy=(round(y,1))print(x == newy)
Honestamente me pareció más sencillo resolverlo mediante la función *round.* **Me quedo así:** x = 3.3 y = 1.1 + 2.2 print(x == round(y,ndigits= 2)) `#El ndigits lo use para la cantidad de dígitos de ``Y` Puedes ver que hace la función y la estructura de la misma si dejas el cursor quieto en el nombre de la función, en este caso es: ![](https://static.platzi.com/media/user_upload/image-910e79f9-e765-4645-8170-10e64e232d6f.jpg)![]()
Aporte, cuando imprimí abs(x - y) me daba un resultado raro que no comprendía 4.440892098500626e-16. Esto se debe a que a la hora de hacer cálculos teoricamente no era 0 el resultado, sino un número decimal muy pequeño, por eso se me imprime como exponente negativo a la -16 en notación cientifica. Espero haberme dado a entender, muchas veces al trabajar decimales nos tendremos que acostumbrar a los valores exponenciales en vez de esperar siempre resultados concretos como cero
```js import math x = 0.1 + 0.1 + 0.1 y = 0.3 if math.isclose(x, y): print("Los números son cercanos.") else: print("Los números no son cercanos.") ```
Bueno la tolerancia es aceptable para algunos calculos pero si deseamos mayor precision se debe buscar otras opciones.
![](https://static.platzi.com/media/user_upload/image-f877e31b-a307-42bf-b50f-3cb00dfdc178.jpg)
o como lo haría el verdadero padre de python, Facundo: `rounded_y = round(y, 2)` `print(rounded_y)` Aunque esta forma también es util.
```js x = 3.3 print(x) y = 1.1 + 2.2 print(y) print (x == y) # string y_string = format(y,".2g") print(y_string) print ( y_string == str(x)) # Matematica print('x' * 10) print (y , x) tolerance =0.00001 print(abs(x - y) < tolerance) ```Genial!!!!

Yo lo hice de esta forma y me funcionó
x = 3.3
print(x)

y = round(1.1 + 2.2, 1)
print(y)

print(x == y)

y_str = format(y, ‘.2g’)
print(y_str)

print(y_str == str(x))

Esta forma es simplemente limitar los decimales de cada uno a 2 para que tenga como una misma cantidad de precisión de los 2![](https://static.platzi.com/media/user_upload/carbon%20%281%29-812c5a47-d1bf-412e-b515-ffc033c3c7b5.jpg)
Hola, como funciona el "y\_str"? No me quedó muy claro. Gracias por sus comentarios
¿Cómo hago para copiar el python 10\_float.py en el Shell de forma rápida? No me deja con control c -.-

Formas de hacer comparaciones
1. Comparacion con la forma precision decimal (String):

2. Comparación con precision matemática: