Representación de flotantes

Puse los números binarios para verlo de otra forma:

En la tabla se puede observar que los números decimales en binario (los float) siguen el mismo patrón matemático de
reducir 1 al exponente de la base 2. Nosotros hacemos lo mismo en el sistema decimal pero con la base 10 ->:

• 10^-1
• 10^-2
• 10^-3
• etc

En binario, intenten sumar varios decimales para llegar a 0.1 verán no es posible. Necesitarían una infinita cantidad de números decimales para ello y la memoria de una computadora finita.

Si es que te parece muy extraño no poder representar un número decimal y difícil de entender, piensa que **este problema ya lo has tenido antes toda tu vida **en el sistema decimal con 1/3. Para ese número necesitamos infinitos dígitos decimales para representarlo.

Mi primer aporte para la comunidad 😃

Conclusión se puede decir que los flotantes son inexactos por lo tanto se los debe tratar como tal. Esto quiere decir que tenemos que manejarlos de manera aproximada. “cercano a…” por esto se recomienda no utilizar igualdad exacta == sino mayor que o menor que como el ejemplo de si queremos un numero igual a 1 tenemos que utilizar x < 1.000 y x > 0.999 para obtener una equidad aproximada.

pd. Me gusta que estos temas sutiles pero muy importantes se plasmen por escrito, no todo tiene que ser vídeo como piden algunos, el video lo pasas a 2X y luego no recuerdas de que va y terminas utilizando un == para flotante y no te funciona bien tu código. Paciencia que leer esta bueno también 😁🤓

Para los que quedaron perdidos en la ultima parte partamos por esto:

• Primero

• Como pasamos el mumero (5) en base 10 a base 2, osea a binario?, pues dividiendo el numero entre dos y almacenando el modulo asi:

5 / 2 = 2
5 % 2 = 1 <— Numero que agregamos al binario

• Entonces tenemos que el primer digito binario es (1), y la operacion de division ENTERA NO DECIMAL nos dio (2), ahora sigamos dividiendo el resultsado entre (2):

2 / 2 = 1
2 % 2 = 0 <— Segundo numero que agregamos al binario

• Ahora tenermos los dos primeros digitos del numero binario (01), y como el resultado de la DIVISION ENTERA nos dio (1), automaticamente agregamos ese numero como tercer digito del numero binario, quedando asi

5 en base 10 = 101 en base 2

• Segundo
• Ahora como seria el caso de pasar (0.1) decimal a binario?, Es ligeramente diferente solo que multiplicando por (2) en ves de dividir

0.1 * 2 = 0.2 # cogemos la parte entera para nuestro numero binario quedando (0.0)
0.2 * 2 = 0.4 # cogemos la parte entera para nuestro numero binario quedando (0.00)
0.4 * 2 = 0.8 # asi sucecivamente (0.000)
0.8 * 2 = 1.6 # agregamos el (1) de la parte entera (0.0001), y seguimos operando con la parte decimal
0.6 * 2 = 1.2 # otra ves agregamos el (1), quedando (0.00011) y operamos la parte decimal
0.2 * 2 = 0.4 # como se daran cuenta el ciclo se esta repitiendo nos volvio a dar parte decimal de (0.2)

• Asi que si seguimos operando 0.1 a binario daria algo como

0.0001100110011001100110011001100110011… infinito

• Y como python tiene acceso a memoria finita, trata de recortar el binario hasta el maximo de digitos que puede sostener, por ejemplo si solo pudiera sostener 8-bits decimalel (8 digitos decimales)

• Solo podriamos tener los primero 8 digitos decimales binarios (0.00011001) los cuales a decimal serian = 0.09765625

• Si acogieramos mas bits o digitos decimales, el numero se proximaria mas, pero consume mas memoria

Si tienen alguna duda, estare atento, gracias

Acabo de escribir un tutorial acerca de por que pasa esto y como lidiar con ello!
https://platzi.com/tutoriales/1764-python-cs/9448-por-que-obtengo-resultados-inesperados-con-los-float-como-lidiar-con-eso/
Explicado de manera sencilla y paso a paso.
Fueron varios dias de investigación. Espero y les ayude! 👍

Hola compañeros!
Acá mis notas de como entender pasar de decimal a binario,
Espero les sriva.

Honestamente no entendí 😢

Para el que sea mas visual les comparto este vídeo que lo explica muy bien:
¿Es 0’9999999… igual a 1?

Por favor mejoren esta lectura y si graban una clase con la explicación mucho mejor

Pago Platzi y aprendo en google y youtube. Por favor mejorar las explicaciones que van por texto. Gracias!

Aunque son temas que sé por la universidad, creo que seria mucho mas entendible el articulo si se utilizaran imágenes mínimamente para visualizar las expresiones. Lo ideal seria un video ya que es un tema que no todos podemos digerir tan facilmente…

"Hay 10 tipos de personas: los que saben binario y los que no" 🤔😅

Para entender el chiste y el funcionamiento de los binarios, les comparto este corto y contundente video.
https://www.youtube.com/watch?v=f9b0wwhTmeU

Espero les ayude!
🟢Un abrazo de gol!

Temas con este nivel de complejidad igual quedarian mejor en un video explicado con peras y manzanas en mi humilde opinion 😄

El artículo tiene muchos errores de caracteres y se pierde mucho la explicación.

pueden ver este vídeo que lo explica desde el punto de vista matemático
https://www.youtube.com/watch?v=11dd4srNb_E

Me sumo, a la petición de revisión de este articulo. Para poder tener un hilo conductivo al momento de la lectura.

La verdad, esta lectura es poco entendible. Se puede mejorar bastante para hacerla más sencilla

Creo entender el core del artículo, pero hubiese sido muchísimo mejor haberlo explicado en un vídeo. No es un tema que sea entendible para todos.

Una explicación un poco compleja, es mejor que realizaran un vídeo realizando la explicación.

Hubiera sido mejor una explicación en video usando la pizarra interactiva que un articulo para entender este concepto

Quizás esto ayude un poco a entender: 1/3 = 0.3333333333; entonces si multiplicamos 1/3 * 3 = 1 y si lo hacemos con los decimales (float) 0.333333 * 3 = 0.9999999; con lo que llegamos a la conclusión de que (0.9999999 == 1)

Hola chic@s, adjunto algunas ligas para comprender este tema. Es un tema muy bonito e importante. Así que, ¡aquí va!:

https://www.unioviedo.es/compnum/laboratorios_py/Aritmetica_finita/Aritmetica_finita_y_error.html

https://docs.python.org/2/tutorial/floatingpoint.html

http://docs.python.org.ar/tutorial/3/floatingpoint.html

Comprendo, algo importante a mencionar es que, cualquier número con exponente negativo representa un número decimal, por ejemplo (recordemos que doble asterisco en Python significa exponente): 10**-1 == 0.1, el primero número (10) es la base numérica (sistema decimal), el segundo número (-1) es el número de decimales con los que queremos ser precisos, en este caso, para el sistema decimal, el exponente negativo (-1) generará un resultado con un solo decimal, si pusiéramos 10**-2 entonces el resultado es de dos decimales: 0.01 y así sucesivamente.
.
Ahora, tomando como referencia lo explicado en la clase, un número con punto flotante (un número decimal) se compone de:
.

1. Los dígitos significativos
2. El exponente (el que acabo de explicar)

.
Y estos dos se multiplican. Los dígitos significativos son el número entero que queremos convertir a decimal, mientras más números y mayor el exponente, el decimal será más preciso:

1234 * 10**-1 = 123.4
(El exponente genera un solo decimal a partir de los digitos significativos)

1234 * 10**-2 = 12.34
(El exponente genera dos decimales a partir de los digitos significativos)

1234 * 10**-3 = 1.234
(El exponente genera dos decimales a partir de los digitos significativos)

Mientras más dígitos significativos tengamos, mayor exponente podremos poner para que el resultado sea más preciso. Lo que aún no entiendo es como se relacionan estos números para la base 2 (binario): 5 * 2**-3, no entiendo cómo se relaciona ese 5 con el número 0.625 (donde en decimal 625 serían los dígitos significativos) 🤔

De manera muy general, como los numeros en la computadora son representados en binarios, toma mas espacio representar un numero racional en binario que un numero entero. Ademas sabiendo que python tiene un limite de 53 bits para la precision de los numeros con decimales, no se puede entonces llegar a calcular exactamente el 1.0, asi que con la capacidad de python se puede llegar es al numero dado en el articulo.

Bastante complejos estos conceptos. Alguien tiene un video o algo donde expliquen este tema de otra forma ?

Si bien se entiende el artículo y la idea principal, hubiera sido mejor crear el video con mostrando el problema y la explicación de todo el asunto.

Excelente, muy buen aporte a considerar!!!
Conclusión:
- si se espera un entero usar ==
- si se espera flotante usar un intervalo.

Es un poco mas facil verlo con las bases y los exponentes. Senti como si me tiraran una piedra en la cara con esto!

Me costó entenderlo y eso que me considero bueno con las matemáticas. Creo que sería bueno hacer la explicación por vídeo para mejorar la comprensión.

Concuerdo, no es una lectura sencilla, por favor revisar el tema.

KHA, cuando cambió tanto el nivel del curso ? jajaja
Empezó muy sencillo todo

Qué genial, cómo todos comparten sus apuntes y sus dudas y todos responden o apoyan muy respetuosamente. La verdad los videos y cursos son muy buenos, pero la comunidad acá dentro es más que genial 😃.

Me gustaría compartir este completo video de Youtube:
https://youtu.be/RVGIXfC4Xeg
Se trata de la base del funcionamiento del PC y su electrónica, mediante los números binarios. Cómo se implementan los binarios en la electrónica, transistores, puertas lógicas,…muy didáctico.

En los números reales: 1 = 0.9999999…
https://www.youtube.com/watch?v=11dd4srNb_E

Creo que para principiantes en este mundo del código no es muy fácil entender los binarios con solo texto. Si no se tiene un mínimo de background matemático, que te permita entender esto de una forma más rápida, es muy complicado aprender con lecturas tan complejas.

La lectura esta bien , pero sugiero que para los ejemplos se haga algún video corto.
Si desean mas información les sugiero que lean el capítulo 1 del libro de Quarteroni y Saleri , llamado Calculo científico con Matlab y Octave.
Saludos

Con ciertos temas les da flojera explicarlos o que? El profe es excelente y el curso tambien, pero los modulos en texto le baja muchos puntos

Está parte la hubieran explicado mejor en video.

Al imprimir el resultado de cada iteracion, se puede notar lo que se explica en esta clase
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999

Éste video explica el tema https://www.youtube.com/watch?v=pQs_wx8eoQ8

Díganme por favor, que no fui el únio que no entendió.

no entendí nada

Es mejor redondear los valores:

x = 0.0
for i in range(10):
	x += 0.1
x=round(x,1) "Re-asigno la variable x, redondeandola con la función round(numero,cantidad de decimales)"
if x == 1.0:
	print(f’x = {x}’)
else:
	print(f’x != {x}’)

Resultado, x = 1.0

la verdad no entendí nada :v

En resumen. Si estas en cualquier lenguaje de programación tienes que tener cuidado con los números flotantes porque en binario muchos de ellos son inexactos. LISTO.

para que nos de 1.0 podemos utilizar la función round() donde le pasas el número que quieres redondear y número de decimales.

x = 0.0
for i in range(10):    
    x += 0.1
    x = round(x, 2)

if x == 1.0:
    print(f'x = {x}')
else:
    print(f'x != {x}')

Resultado
x = 1.0

No entiendo

No entiendo porque Platzi implementa este tipo de “clases”, si ya estan armando el curso ¿qué les puede quitar una o dos clases mas?
Está es una clase que se pudo armar como un video, lo mismo pasa con otros cursos en donde tienes que instalar y te ponen un articulo, mejor pasame el link y listo… y por qué? Bueno hay personas a las que les puede surgir un detalle, en windows pasa con algunas cosillas, pero aunque se pueda investigar, entonces para que tomar esa clase? Mejor voy al articulo, instalo y resuelvo los problemas desde alli. En fin.

Buen día,
En los tutoriales del curso pueden encontrar un excelente aporte del compañero @josuegranados1219 que trata también esta problemática y nos propone varias alternativas para tratarla.
¿Por qué obtengo resultados inesperados con los float? 🤔 ¿Comó lidiar con eso? 🔧

un año despues, estamos viendo esta informacion, hoy es 12-12-2020

Range, controla el número de veces que se ejecuta un bucle

Hay algunos errores en el artículo, ya que cuando ponen ** se pone en negrita algunos números y se confunde, tengan en cuenta eso.

Sinceramente no entendí nada

me parece que no es buena la explicación de este tema en particular

Comparto otro artículo que puede servir para comprender más:
https://www.ciencia-explicada.com/2012/10/numeros-flotantes-curiosidades-y.html

🎈 Para los que nos perdimos un poco con los ciclos For, aquí les dejo una excelente página para practicar. 🎈
.
😯 Además, a continuación les compartiré el tema de esta clase, con esta otra liga.
.

.
Nota: todo está en Inglés. ⚡

Solución:

x = 0.0
for i in range(10):
x += 0.1

x = round(x, 1)

if x == 1.0:
print(f’x = {x}’)
else:
print(f’x != {x}’)

Ha sido una muy buena explicación, pero para que me quede claro averigüé como pasar un número racional en base decimal (como 0.7 o 0.125) a binario. De esta manera te das cuenta que no puedes hallar el resultado final de 0.7 ó 0.1 en binario, se vuelve un ciclo infinito.

La manera es la siguiente: para 0.125:
Se trata de multiplicar por 2 el número, si es que este es mayor a 1 entero, se agrega un 1, si es menor, se agrega un 0, en el caso de ser igual a 1, se agrega un 1 y se termina la conversión.

.125 x 2 = .250 , agregamos un cero…
.250 x 2 = .500 , agregamos otro cero…
.500 x 2 = 1.000 , agregamos un 1 y terminamos.

resultado de 0.125 en decimal a binario es: 0.001

Si hacemos esto para 0.7:
0.7×2 = 1.4 ≥ 1 ⇒ 1
0.4×2 = 0.8 < 1 ⇒ 0
0.8×2 = 1.6 ≥ 1 ⇒ 1
0.6×2 = 1.2 ≥ 1 ⇒ 1
0.2×2 = 0.4 < 1 ⇒ 0
0.4×2 = 0.8 < 1 ⇒ 0
0.8×2 = 1.6 ≥ 1 ⇒ 1
0.6×2 = 1.2 ≥ 1 ⇒ 1
0.2×2 = 0.4 < 1 ⇒ 0
0.4×2 = 0.8 < 1 ⇒ 0
el ciclo nunca acaba… igual para 0.1

Dejo un gran recurso para entender mejor los números binarios 🎁

https://es.khanacademy.org/computing/ap-computer-science-principles/x2d2f703b37b450a3:digital-information/x2d2f703b37b450a3:binary-numbers/a/bits-and-binary#:~:text=El sistema binario funciona de,por una potencia de 2.&text=Bien%2C tal vez podrías haber,%2C ¡ahora un número mayor!

Reto 👀
¿A qué número decimal equivale el número binario 1010?

https://docs.python.org/es/3/tutorial/floatingpoint.html
Explicacion oficial sobre este tema y como manejarlo

Creo que este tema debió haberse explicado en vídeo 😦

Video porrrfavorrr

No me queda muy claro.
Si deberían hacer un video.

Después de leer este artículo me entro la curiosidad de como calcular la representación flotante de un numero decimal según los dígitos significativos requeridos, así que después de hacer varios cálculos a mano llegué a este algoritmo que está pensado para realizarse con papel y lápiz, pero como estamos en un curso de Python lo traduje a código y se los comparto.
Son solo 18 líneas de código el resto son comentarios explicativos.
#xxxxxxx = comentarios

# Este es un algoritmo para realizar calculos en punto flotante de una división cuyo resultado es menor a uno.
# PROCEDIMIENTO:
# 1. Ingresar 1er Numero y 2do Numero
# 2. Elegir cantidad de cifras significativas en flotante.
# 3. Se muestra el resultado del algoritmo (con la cantidad de digitos significativos elegido) comparando la aproximación
# a la computadora(53 bits de precisión para Python).
# AUTOR: Miguel Salinas, algoritmo desarrollado apartir del artículo leido.
# Fuente: https://platzi.com/clases/1764-python-cs/25239-representacion-de-flotantes/ 

import math #impoorta las operacione matemáticas avanzadas
numero1 = int(input('Ingrese primer numero: '))
numero2 = int(input('Ingrese segundo numero: '))
num_cifras_signif = int(input('Ingrese el numero de cifras significativas: '))
if numero1 > numero2:
    print(f'El resultado de dividir: {numero2} / {numero1} = ')
    Numerador = numero2
    Denominador = numero1
elif numero2 > numero1:
    print(f'El resultado de dividir: {numero1} / {numero2} = ')
    Numerador = numero1
    Denominador = numero2
else:
    print(f'El resultado de dividir: {numero1} / {numero2} = 1')

# definiciones:
# A/B = (X,-n); donde A < B, X = representación en binario del numerador
# -n; es el exponente de la base 2(de binario), 
# La aproximación de la división es: A/B = X/2^n
# #####    ALGORITMO EN 3 PASOS:   ########
# 1. Estimación de X y calculo de n
# 2. Calculo de X
# 3. Mostrar resultados con la aproximación especificada.

# ================ PROCEDIMIENTO ==================
# Estimación de "X"
# x <= int(2^num_cifras_signif - 1)
x = int(math.pow(2,num_cifras_signif))

# Calculo de "n"
# n = int(log2(X*B/A))
n = int(math.log2(x*Denominador/Numerador))

# Calculo de "X"
# x = int(A / B * 2 exp(n))
x = int(Numerador/Denominador*math.pow(2,n))

# finalmente A/B = X/2^n
print('===========================================================')
print(f'Resultado del Algoritmo: {Numerador}/{Denominador} = {x}/{math.pow(2,n)} ={ x / math.pow(2,n) }, para una aprox. de {num_cifras_signif} cifras significativas')
print(f'comparado a : {Numerador}/{Denominador} ={Numerador/Denominador}, considerando hasta 53 bits de precisión para numero flotante')
print('===========================================================')

Muy interesante saber la precisión de los flotantes en Python, realmente fue algo nuevo, cuando me enseñaron el sistema binario siempre me pregunte como exactamente se aplicaba y con esta lectura acabo de ver una de sus implementaciones, de hecho me costo y eso que si tenia algo de bases.

Por donde comienzo… Bueno creo que será por lo del sistema binario, en el sistema binario a diferencia del decimal, solo maneja dos números el 0 y 1, donde podrías decir que la posición importa. el 0 indica que vale eso 0 y el 1 indica el valor total de esa posición, la posición tiene vale el doble de la anterior por ejemplo un numero binario normal seria el siguiente

0 0 0 0 pero este numero lo puedes ver también como
0*(8) 0*(4) 0*(2) 0*(1)

dice

Si fueran cinco ceros entonces el primero de izquierda a derecha se podría multiplicar por 16 por que es el doble del 8 y así sucesivamente.
Es por eso que si queremos un 10 por ejemplo solo tenemos que asignar los colocar 1s en las posiciones que podrían dar un 10 que seria:
1010 = 1*(8) 0*(4) 1*(2) 0*(1) = 8 + 0 + 2 + 0

Con esto creo que puede ser mas claro
si quieren practicar demuestren que
17 = 10001
6 = 110
27 = 11011

Ahora la lectura nos dice que el flotante se representa con dos números en sistema binario se parados por una “,”, donde el primero es el que se quiere dividir y el segundo es el numero que será un exponencial aplicado al numero 2(siempre es este numero porque indica el que es sistema binario).

Por lo tanto cuando pone el 5 que es 101 y el segundo numero binario -11 que es -3 que realmente el menos solo es para indicar que se aplicara como divisor, lo que realmente se esta haciendo es la siguiente operación

5/(2^3) donde 2^3 = 8
o sea 5/(2^3) = 5/8 = (101, -11)

En la lectura pone que el máximo es 53 o sea que el divisor mas grande que podemos tener es de 2^53, eso al menos en python

Espero esto sea de ayuda y si no pues… se intento.

Entendí algo, pero no todo.

Al comienzo creí entender perfectamente, luego todo se fue al carajo cuando empecé a leer lo del 101. sigo leyendo para ver si comprendo.

Ojalá el profesor responda esta pregunta, y es por qué pasa de 1/10 a 3/32 en esto= _Regresemos a nuestro problema inicial: ¿Cómo representaremos 1/10 (que escribimos en Python cómo 0.1)? Lo mejor que podemos hacer con cuatro dígitos significativos es (0011, -101) que es equivalente a 3/32 (0.09375). _

Me perdí en esa parte…

Mucho texto :'v

el covid se llevo el video 😦 RIP

Creo que se entendería mejor por medio de un vídeo que en formato texto

Este ejemplo lo explicaron en mi facultad, ademas el profe de matemática discreta explicó por que 1 == 0.9999...
Les dejo este video que lo explica muy bien: VIDEO
Pero el resumen es que 1/3 = 0.333…,
entonces, 1/3 *3 = (1/3 + 1/3 + 1/3) = 1,
PERO, también (0.333… + 0.333… + 0.333…) = 1,
lo que 0.999… = 1

Así que la computadora nos dio el cálculo correcto

Este vídeo explica que 0.999 es lo mismo matemáticamente por lo tanto la computadora no se equivoca en los cálculos.
https://youtu.be/11dd4srNb_E

HAGAN GRABADAS LAS CLASES!!!

Encontré también esto, espero les ayude:

Llamemos a X = 0,9999999…
Entonces 10X = 9,9999999…
Podemos restar estos dos valores 10X-X = 9X = 9,99999… - 0,99999…
Como se ve, la parte decimal se cancela (ya que hay infinitos 9) y se llega a la expresión
9X = 9
Es decir
X = 1
Y como X también es X = 0,99999…
Podemos decir que
0,99999… = 1

Me gustó la explicación. La conclusión final es de lo más importante “cuando estamos trabajando con flotantes es mejor asegurarnos que los números sean aproximados en vez de idénticos. Por ejemplo x < 1.0 and x > 0.99999.” … Teniendo esto en cuenta les aseguro que nos evitamos un montón de dolores de cabeza al testear que el código de resultados correctos o aceptables…

En conclusion en el caso de los numeros flotantes el operaror == es deficiente, es mejor dar un rango de precision a<x<b aceptable.

Ejecuté el programa y agregue una instrucción para que cada iteración, imprimiera el valor que iba tomando “x”

Este fue el resultado:

  DevEd git:(master) ✗ /usr/bin/python3.7 "/mnt/c/Desarrollo/DevEd/Python/Introduccion Pensamiento Computacional/iteraciones.py"
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
x != 0.9999999999999999

La parte de “No existe ningún número que cumpla con la siguiente ecuación: sim * 2**-exp” es algo confusa, tal vez sería mejor algo como:
No existen números naturales a y b que cumplan la ecuación:
a * 2 ** -b = c
cuando c = 0.1
Por lo cual se recurre a números a y b que den un aproximado a 0.1, y pasa lo mismo con otros números decimales c.

Si alguien todavía está interesado en saber cómo la computadora trabaja con los números, les dejo un par de artículos de wikipedia sobre, números binarios, álgebra de boole, complemeto a uno y a dos, y el estandar actual para manejar números con coma flotante:
https://es.wikipedia.org/wiki/Sistema_binario
https://es.wikipedia.org/wiki/Complemento_a_uno
https://es.wikipedia.org/wiki/Complemento_a_dos
https://es.wikipedia.org/wiki/IEEE_754

¿Saben cómo se puede sugerir al profesor de Platzi de hacer un video sobre este argumento? 🤨🧐

Me surgió la curiosidad de Ejecutar el mismo código en js y php y descubrí algo que no sabía

$x = 0.0
>0
for ($i=0;$i<10;$i++){
$x+=0.1;
}
> 0.9999999999999999

php >  $x = 0.0;
php > for ($i=0;$i<10;$i++)
php > {
php {  $x+=0.1;
php { }
php > var_dump($x);
php shell code:1:
double(1)

Lo interesante es que en php el resultado es 1 y no 0.9999 ya que a nivel de lenguaje c (núcleo de php) las variables numéricas se almacenan como double lo que le da un poco mas de precisión.

Números de punto flotante en PHP

Profe un video por favor, hay cosas que no he logrado comprender.

Un video porfaaaaaa

Es decir que si uso decimales, para tener mayor control, es preferible en vez de usar una igualdad ==, definir un rango:

if x < 1.0 and x > 0.99999:
print(f’x = {x}’)
else:
print(f’x != {x}’)

Se entiende, aunque quedan dudas :S

En el casos de FLOAT a veces tenemos el inconveniente que imprime mucho decimales para solucionarlo utilizamos ROUND(numero float, cant. decimales)

total = 6 / 9
total = round (total, 2)
print(total)```

Gracias por aclarar este tipo de punto con los flotantes.
Hace años había programado una calculadora científica muy simple en lenguaje C. Sin embargo, me topé con este diminuto tipo de error en cierto tipo de cálculos, a pesar de que era un error de cálculo tan pequeño que podría considerarse despreciable, era una astilla que se me había quedado y que si me causaba mucha inquietud haha, sobre todo porque los profesores a los que les pregunté no me supieron dar respuesta. Y bueno, ahora por fin la tengo haha.
Gracias por compartir esos aspectos de conocimiento que ningún profesor (al menos ninguno de los que me han dado clases en la escuela) toca al respecto cuando se habla de programar con números flotantes

Comparto la opinión me costo entender, me toco volver al lápiz y papel para entenderlo.
Pero no se les hace fabuloso esto?

https://www.youtube.com/watch?v=PzNYQg7J4bs

Me costó trabajo esta clase y leí los comentarios de que no está bien explicada.

Personalmente le invertí 2 horas sólo en esta clase, pero al final comprendí y fué de mucha ayuda.

Aquí está lo del range por si a alguien le ayuda:

https://www.w3schools.com/python/ref_func_range.asp

seria mejor que sea grabado las clases

No quería pasar de página hasta entender bien lo que quería decir el profesor. Gracias a los compañeros por sus comentarios. Por eso al usar flotantes nunca vas a llegar a x == 1.0.

Así quedaría el código aproximado.
x = 0.0
for i in range(10):
    x += 0.1

if x < 1.0 and x > 0.99999:
    print(f'x = {x}')
else:
    print(f'x != {x}')
Output:
x = 0.9999999999999999

Ahora, ¿por qué el range con flotante se va a 0.99999 en vez de detenerse en 0.9?

Un poco densa la info, pero entendí el concepto aunque no quedó muy clara la explicación

Cuando tenia 18 años pense en esta hipotesis de la no existencia del 0, nunca llegamos de un punto a otro punto, solo pensamos en un desplazamiento aproximado, y luego pensé que las matematicas como las conocemos no representan toda la realidad, solo es una herramienta que en nuestra realidad es bastante útil.

Les dejo mis apuntes https://github.com/karlbehrensg/introduccion-pensamiento-computacional

Investigué mas sobre este tema y encontré más detalle en la documentación oficial de Python en https://docs.python.org/es/3/tutorial/floatingpoint.html. También apliqué un cambié las líneas de código adicionando la función de redondeo posterior a la suma, de esta manera el valor final da 1.0 exacto. Esto lo aplique basado en la explicación de la documentación:

x = 0.0
for i in range(10):
    x = x + 0.1
    x = round(x,15)
    print(x)

if x == 1.0:
    print(f'x = {x}')
else:
    print(f'x != {x}')```

Espero resuelva las inquietudes.
Saludos

Lo que entendi:

1. En base x tenemos x^n números entonces en base 2 tenemos 2^n números.
2. En Negativos se usa un bit adicional al inicio donde 0=positivo y 1=negativo
3. En decimales
   2,345(10)=2345*(10)^^(digitos signi)
   0,625 = 5/8 = 5*2^-3 =(binario) 101^-11

DECIMAL A BINARIO FACIL

0,625
0,625x2=1,250—1
0,250x2=0,500—0
0,500x2=1,000—1
0,625(10) = 0,101(2)

1/10 = 0,1
0,1x2=0,2–0
0,2x2=0,4–0
0,4x2=0,8–0
0,8x2=1,6–1
0,6x2=1,2–1
0,2 …
0,0001100110011001100110011…

Hay numeros decimales que en base dos son periodicos puros pero aun asi debemos encontrar una forma de expresarlos y esta forma es haciendo aproximaciones

El resto no lo entendi.

https://youtu.be/HcjXH9WGmAU Este video me ayudo a entender bastante bien 😃

Estoy haciendo mi resumen, pero resulto que con 2 aportes del chat lo hicieron bastante mas entendible que la lectura:

11-Representación de flotantes

La mayoría del tiempo los Nros flotantes (tipo float) son una buena aproximación de los números que queremos calcular con nuestras computadoras. Sin embargo, a veces no se comportan de esta manera y esto puede tener consecuencias inesperadas.

Por ejemplo, trata de correr el siguiente código:

x = 0.0
for i in range(10):
    x += 0.1

if x == 1.0:
    print(f'x = {x}')
else:
    print(f'x != {x}')
# esperamos como resultado 1.0 y nos da -> 0.999999999999
# Porque pasa esto? 

En la tabla se puede observar que los números decimales en binario (los float) siguen el mismo patrón matemático de reducir 1 al exponente de la base 2. Nosotros hacemos lo mismo en el sistema decimal pero con la base 10 ->:

binarios1.webp

• 10^-1
• 10^-2
• 10^-3
• etc

En binario, intenten sumar varios decimales para llegar a 0.1 verán no es posible. Necesitarían una infinita cantidad de números decimales para ello y la memoria de una computadora finita.

Si es que te parece muy extraño no poder representar un número decimal y difícil de entender, piensa que **este problema ya lo has tenido antes toda tu vida **en el sistema decimal con 1/3. Para ese número necesitamos infinitos dígitos decimales para representarlo.

CONCLUSION:

Se puede decir que los flotantes son inexactos por lo tanto se los debe tratar como tal. Esto quiere decir que tenemos que manejarlos de manera aproximada. “cercano a…” por esto se recomienda no utilizar igualdad exacta == sino mayor que o menor que como el ejemplo de si queremos un numero igual a 1 tenemos que utilizar x < 1.000 y x > 0.999 para obtener una equidad aproximada.

En resumen, mas alla de que este buena la explicacion, y se entienda, y para no truncarle la progresion a los que vienen porque pueden sentirse frustrados al no entender del todo este tema, la solucion al problema con los numeros flotantes es buscar redondear el numero obtenido para que asi esas infimas milesimas, no afecten y poder seguir trabajando, por ejemplo con la funcion round()

x = 0.0
for i in range(10):
    x += 0.1

if x == 1.0:
    print(f'x = {x}')
else:
    print(f'x != {round(x)}')

Si lo que necesitas son representaciones precisas de numeros decimales utiliza el modulo decimal en Python
👉 https://docs.python.org/3/library/decimal.html#module-decimal

Tambien existe el modulo fractions para representar exactamente fracciones
👉 https://docs.python.org/3/library/fractions.html#module-fractions

Esta es la sintetizacion de este tema y de esta guia:
https://platzi.com/tutoriales/1764-python-cs/9448-por-que-obtengo-resultados-inesperados-con-los-float-como-lidiar-con-eso/

Aquí un tutorial que explica el tema, fue hecho por un compañero nuestro en Platzi 😃
https://platzi.com/tutoriales/1764-python-cs/9448-por-que-obtengo-resultados-inesperados-con-los-float-como-lidiar-con-eso/