Representaci贸n de flotantes

11/31

Lectura

La mayor铆a del tiempo los n煤meros flotantes (tipo float) son una muy buena aproximaci贸n de los n煤meros que queremos calcular con nuestras computadoras. Sin embargo, 鈥渓a mayor铆a del tiempo鈥 no significa todo el tiempo, y cuando no se comportan de esta manera 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}')

Es probable que te hayas sorprendido con el resultado. La mayor铆a de nosotros esperar铆amos que imprimiera 1.0 en vez de 0.999999999999. 驴Qu茅 es lo que pas贸?.

Para entender qu茅 es lo que pas贸 tenemos que entender que es lo que pasa en la computadora cuando realizamos c贸mputos con n煤meros flotantes. Y para eso necesitamos entender n煤meros binarios.

Cuando aprendiste a contar, lo que en realidad aprendiste es una t茅cnica combinatoria para manipular los siguientes s铆mbolos que le llamamos n煤meros: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

La forma en la que funciona esta t茅cnica es asignando el n煤mero 10 a la 0 al n煤mero de la extrema derecha, 10 a la 1 al siguiente, 10 a la 2 al siguiente y as铆 sucesivamente. De tal manera que el n煤mero 525 es simplemente la representaci贸n de (5 * 100) + (2 * 10) + (5 * 1).

Esto nos dice que el n煤mero de n煤meros que podemos representar depende de cuanto espacio tengamos. Si tenemos un espacio de 3, podemos representar 1,000 n煤meros (10 elevado a la 3) o la secuencia del 0 al 999. Si tenemos 4, podemos representar 10,000 (10 elevado a la 4) o la secuencia del 0 al 9,999. De manera general podemos decir que con una secuencia de tama帽o n, podemos representar 10 elevado a la n n煤meros.

Los n煤meros binarios funcionan de la misma manera (de hecho cualquier n煤mero en cualquier base, por ejemplo, octales o hexadecimales). La 煤nica diferencia es cu谩ntos s铆mbolos tenemos para representar. En binario nada m谩s tenemos 0, 1;
en hexadecimal tenemos 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f.

De esta manera podemos decir que el n煤mero de la extrema derecha es cantidad_de_simbolos**0, cantidad_de_simbolos**1, cantidad_de_simbolos**2, etc. Por lo que en binario, que nada m谩s tenemos 2 s铆mbolos, decimos 2**0, 2**1, 2**2, etc. Por ejemplo el n煤mero binario 101 es la representaci贸n de (1 * 4) + (0 * 2) + (1 * 1), es decir 5.

Esta representaci贸n nos permite trabajar con todos los n煤meros positivos enteros dentro del computador, pero 驴Qu茅 hacemos con los negativos y los racionales?.

El caso de los n煤meros negativos es sencillo: simplemente agregamos un bit adicional que representa el signo y la a帽adimos en la extrema izquierda. Por lo que el n煤mero 0101 ser铆a +5 y el n煤mero 1101 ser铆a -5.

El caso de los racionales es m谩s complejo. En la mayor铆a de los lenguajes de programaci贸n modernos los racionales utilizan una implementaci贸n llamada punto flotante. 驴C贸mo funciona esta representaci贸n?.

Antes de pasar a binario, vamos a pretender que estamos trabajando con una computadora basada en decimales. Un n煤mero flotante lo representar铆amos con un par de enteros: los d铆gitos significativos y el exponente. Por ejemplo, el n煤mero 2.345 se representar铆a como (2345 * 10**-3) o (2345, -3).

El n煤mero de d铆gitos significativos determinan la precisi贸n con la que podemos representar n煤mero. Por ejemplo si nada m谩s tuvi茅ramos dos d铆gitos significativos el n煤mero 2.345 no se podr铆a representar de manera exacta y tendr铆amos que convertirlo a una aproximaci贸n, en este caso 2.3.

Ahora pasemos a la verdadera representaci贸n interna de la computadora, que es en binario. 驴C贸mo representar铆as el n煤mero 5/8 o 0.625? Lo primero que tenemos que saber es que 5/8 es en realidad el n煤mero 5 * 2**-3. Por lo que podr铆amos decir (101, -11) (recuerda que el n煤mero 5 es 101 en binario y el 3 es 11).

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). 驴Qu茅 tal si tuvi茅ramos cinco d铆gitos significativos? La mejor representaci贸n ser铆a (11001, -1000) que es equivalente a 25/256 (0.09765625). 驴Cu谩ntos d铆gitos significativos necesitamos entonces? Un n煤mero infinito. No existe ning煤n n煤mero que cumpla con la siguiente ecuaci贸n: sim * 2**-exp.

En la mayor铆a de las implementaciones de Python tenemos 53 bits de precisi贸n para n煤meros flotantes. As铆 que los d铆gitos significativos para representar el n煤mero 0.1 es igual a:

11001100110011001100110011001100110011001100110011001 que es equivalente al n煤mero decimal: 0.1000000000000000055511151231257827021181583404541015625

Muy cercano a 1/10 pero no exactamente 1/10. Ahora ya sabemos la raz贸n de esa respuesta tan extra帽a. Hay muy pocas situaciones en la que 1.0 es aceptable, pero 0.9999999999999999 no. Pero 驴Cu谩l es la moraleja de esta historia?

Hasta ahora hemos verificado igualdad con el operador ==. Sin embargo, 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.

Aportes 283

Preguntas 7

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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. 鈥渃ercano 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鈥

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

"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 馃槃

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.

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)

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

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

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) 馃

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 馃槂.

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.

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,鈥uy 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

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

No entiendo

No entiendo porque Platzi implementa este tipo de 鈥渃lases鈥, 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.

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

Soluci贸n:

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

x = round(x, 1)

if x == 1.0:
print(f鈥檟 = {x}鈥)
else:
print(f鈥檟 != {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

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

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.

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 鈥渃uando 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 鈥渪鈥

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 鈥淣o 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


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

<h3>PHP</h3>
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

馃巿 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. 鈿

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}鈥)
else:
print(f鈥檟 != {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)```

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

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?

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.

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.

Aporte

Este art铆culo se me hizo algo complejo de entender, pero despert贸 una curiosidad por aprender del tema as铆 que me puse a investigar.

Nota: Lo que mencionar茅 a continuaci贸n es considerando una arquitectura de 32 bits.

<h3>IEEE 754</h3>

Existe un est谩ndar propuesto por la asociaci贸n IEEE (Institute of Electrical and Electronics Engineers) que describe como los n煤meros flotantes deben ser almacenados en memoria (RAM) llamado IEEE 754, el cual propone una forma de almacenar n煤meros de punto flotante d贸nde el primer bit indica si el n煤mero es positivo (Ser谩 un 0) o negativo (Ser谩 un 1), los siguientes 8 bits indican el exponente de la expresi贸n ya que los n煤meros se almacenan de una forma muy similar a la notici贸n cient铆fica (Como 1.2x10^-2 solo que en binario la base no es un 10 si no 2) y los siguientes 23 bits son algo llamado mantisa, que es la representaci贸n binaria del n煤mero entero concatenado con la representaci贸n binaria de los n煤meros despu茅s del punto.

<h4>Conversor en python3.</h4>

Para entender un poco m谩s de c贸mo estos n煤meros son almacenados decid铆 hacer mi propio conversor de n煤meros de punto flotante a binario IEEE 754 y viceversa.

Les comparto el c贸digo de mi soluci贸n; prob茅 con varios n煤meros y parece tener buenos resultados.
https://github.com/JoseNoriegaa/python-ieee754/blob/master/main.py

No entend铆 :v gracias por la confusi贸n 馃槶

Pero si 0.1 se representa m谩s o menos como 1.000鈥555鈥 no deber铆a x ser = a un n煤mero mayor a 1? no entend铆 porqu茅 termina siendo 0.99鈥

Me estoy rompiendo el cerebro con esto "La forma en la que funciona esta t茅cnica es asignando el n煤mero 10 a la 0 al n煤mero de la extrema derecha,"
Osea no se supone que el numero 10 no existe, si no que es una combinacion de 1 y 0 -.- !
Ya si explot茅