FCFM 2023 UAdeC

Reporte 1: Calculadora de conversion de bases

Adrian Ramirez Ortiz.

Facultad de Ciencias Físico Matemáticas, Universidad Autónoma de Coahuila.
Ingeniería Física.
Metodos numericos.

1 de Septiembre del 2023

Resumen Numero en base 10 Modulo Division

23
23 23 mod 2= 1 2 = 11
En este reporte se explicara el como realizar la 11
11 11 mod 2= 1 2 =5
conversion de bases tanto decimal como fraccio- 5
5 5 mod 2= 1 2 =2
nara y se explicara un codigo propio de una calcu- 2
2 2 mod 2=0 2 =1
ladora que hace este tipo conversion. 1 1 mod 2=1 1
=0
2

1. Introducción Tabla 1: Ejemplo de conversion de base 10 a base 2

A conversion de bases nos referimos a cambiar Una vez hechas las operaciones necesarias ya
la cantidad de caracteres que tiene el sistema, tenemos el numero en binario, son los numeros
por ejemplo, ustede esta acostumbrado a usar el dados de abajo a arriba en la parte de modulo, es
sistema decimal, el cual consiste en 10 caracteres 10111.
distintos (0,1,2,3,4,5,6,7,8,9) con el cual se cons- Aunque este ejemplo es solo para base 10 a base 2,
truye todos los numeros conocidos, pero como puede hacerse de base 10 a base N.
sabemos las computadoras se a dicho que trabajan
con sistema binario, esto se refiere que con solo Pero como lo cambiamos de base N a base 10?,
dos caracteres (0,1) construye todos los numeros esto es mas sencillo solo debemos multiplicar un
existentes. digito por N Posi ci on y sumar el sigguiente digito
multiplicado por N Posi ci on , tomomes de ejemplo
Existen distintos metodos para poder hacer una el numero que encontramos en base 2 (10111) y
conversion de bases uno de ellos y con el que se convirtamoslo en base 10, esto mos queda como:
basa este programa es el siguiente: 1x24 + 0x23 + 1x22 + 1x21 + 1x20 = 23
De base 10 a una cierta base N primero del numero
de base 10 se saca el modulo de la base N y dado Ya sabemos como comvertir de base decimal a
a que el modulo solo te da el residuo entonces te una base N con numeros enteros, pero ahora debe-
dara un numero entre 0 y N. Por ejemplo: mos hacerlo con numeros fraccionarios. Para esto
10 mod 2=0 y 9 mod 2=1 se multipla por N y se obtendra una parte entera a
y una parte fraccionaria b, quitamos la parte entera
Despue dividimos el numero en sistema decimal y multiplicamos la parte b por N, esto lo hacemos
entre N y guardamos la parte entera, y volvemos a las veces que sea necesarias o hasta que b=0, pon-
repetir sacamos el modulo de la parte entera que gamos un ejemplo, usemos el numero 0.6 y convir-
nos dio en la division con N y lo guardamos y luego tamoslo a base 8.
volvemos a dividir y guardar, asi sucesivamente
hasta que el resultado de la division sea 0, ponga-
mos un ejemplo: En la siguiente tabla se muestra
el procedimiento explicado con N=2 y el numero
en base 10= 23

1
FCFM 2023 UAdeC

FraccionxN Resultado Resultado-parte entera 2. Metodología

0.6x8= 4.8 4.8-4=0.8
0.8x8= 6.4 6.4-6=0.4 Ahora veremos el desarrollo del codigo, este
0.4x8= 3.2 3.2-3=0.2 convierte numeros decimales a binarios y octales
0.2x8= 1.6 1.6-1=0.6 ya sean enteros o fraccionarios y tomando en
cuenta si son negativos o no, a su ves transforma
Tabla 2: Ejemplo de conversion de base 10 fraccio- numeros de base octal y binaria a decimal y de
naria a base 8 binaria a octal y viceversa.

2.1. Codigo decimal a binario

Ahora que ya hicimos esto, como sabemos cual
es la parte fraccionaria en octal? estos van a ser Conversion de bases.py
la parte entera que se quito del resultado de mul-
tiplicar bx8, se colocaran de arriba a abajo como def decimal_bin ( m ):
esta en la tabla, como despues de las 4 iteraciones M = abs ( m ) - abs ( int ( m ))
se repiten entonces 0.6 a base 8 tiene infinidad de b=""
caracteres, 0.6 a base 8 es: 0.46314631... s =0

Como podemos observar aunque en base 10

sean infinitos en otras bases no pueden serlo.
Primero vamos a definir la funcion, tendra el nom-
bre: decimal_bin, esta tomara como parametro m,
Por ultimo veremos como convertir numeros el cual sera un numero del tipo flotante que se le
fraccionarios de base N a base 10, esto es pare- pedira al usuario, M como se ve se le realizan ope-
cido a convertir enteros de base N a base 10, ya raciones con la variable m, esta operacion tiene la
que tiene la forma a 0 xN Posi ci on + a 1 xN posi ci on + finalidad de guardar la parte decimal del numero
...a n xN posi ci on donde a es el digito y N es la ba- en otra variable, y s es una variable que va a deter-
se y se eleva a su posicion, la unica diferencia con minar el signo del numero. Codigo decimal a bina-
los enteros es que la primer posicion se eleva a -1 rio
y la segunda seeleva -2 y asi sucecivamente has-
ta -n, demos un ejemplo, para esto utilicemos el
numero en base 8 que calculamos anteriormente Conversion de bases.py
0.46314631...
def decimal_bin ( m ):
Siguiendo las instrucciones anteriores nos que-
M = abs ( m ) - abs ( int ( m ))
da como: 4x8−1 + 6x8−2 + 3x8−3 + 1x8−4 + 4x8−5 +
b=""
6x8−6 + 3x8−7 + 1x8−8 = 0,5999999642.
s =0
Como podemos ver no da exactamente 0.6, esto es
debido a la conversion, siempre va a existir un cier-
if m * -1== abs ( m ):
to error, es por esto que se originan errores de pun-
s =1
to flotante, ya que la computadora lo trabaja con
binarios y como no siempre en binario sera finito
if m ==0:
como en decimal van a existir ciertas variaciones
b="0"
pequeñas como en este caso al momento de que la
retun b
computadora hace la conversion.
m = abs ( int ( m ))

El primer if es para analizar si m es negativo, y si es

negativo cambiar el valor de s a 1, esto para asignar

2
FCFM 2023 UAdeC

el signo al final de la conversion, y el segundo if es File

para el caso especial donde m es cero devolvemos
cero, luego le asignamos a m su valor absoluto de def decimal_bin ( m ):
la parte entera, esto ya que ya dividimos la parte M = abs ( m ) - abs ( int ( m ))
fraccionaria de m. b=""
s =0
if m * -1== abs ( m ):
Conversion de bases.py s =1
if m ==0:
def decimal_bin ( m ): b="0"
M = abs ( m ) - abs ( int ( m )) return b
b="" m = abs ( int ( m ))
s =0 while m !=0:
b = str ( m %2) + b
if m * -1== abs ( m ): m = int ( m /2)
s =1 if M !=0:
b += " . "
if m ==0: i =0
b="0"
return b while M !=0:
M = M *2
m = abs ( int ( m )) if M <1:
b += " 0 "
while m !=0: if M >=1:
b = str ( m %2) + b M -=1
m = int ( m /2) b += " 1 "
i +=1
if M !=0: if i ==25:
b += " . " break
i =0
if s ==1:
b = " -" + b
return b

El primer while es para convertir de decimal a bi-

nario numeros enteros, hace el procedimiento vis-
to anteriormente si m es distinto de 0 como que-
remos ir de arriba a abajo entonces guardamos el
resultado de m mod 2 como string y le sumamos lo
demas en b asi seria como lo que hicimos de juntar
de abajo hacia arriba, despues a m le guardamos la
parte entera de la division m/2 asi si repetimos este
codigo en un momento nos dara m=0 y habara ter-
minado el ciclo guardando exitosamente el nume-
ro binario, el siguiente if es para ver si tiene parte
fraccionaria, si tiene parte fraccionaria a lo que ya
tenemos como parte entera le agregamos el pun-
to para separar la parte entera de la fraccionaria y
definimos la variable i=0 para el proximo ciclo de
numero fraccionario decimal a binario.
El segundo while es para convertir la parte fraacio-
nara decimal a binario, para esto, si M es distinto
de 0 entra en el ciclo, este numero se multiplica por
dos y como no puede ser mayor o igual a dos des-
pues de multiplicarse, la parte entera sera 1 o 0, si
es 0 la parte entera a el numero binario se le agre-
ga un 0 y si es 1 la parte entera a el numero bina-
rio se le agrega uno y le quitamos la parte entera,
despues de esto contamos el numero de iteracio-
nes con la variable i sumandole 1 y luego se agrega
un if donde despues de 25 iteraciones se acabe el
programa, esto debido a que puede haber nume-
ros infinitos, al final al salir del siclo una vez que ya
tenemos el numero binario le asignamos el signo
con la variable s, si se cambio el valor de s a 1 en-

3
FCFM 2023 UAdeC

tonces se le agregara el signo menos al principio Conversion de bases.py

del numero binario, por ultimo, se regresa el nu-
mero convertido a binario. def decimal_oct ( m ):
M = abs ( m ) - abs ( int ( m ))
2.2. Codigo decimal a octal b=""
s =0
Conversion de bases.py if m * -1== abs ( m ):
s =1
def decimal_oct ( m ): if m ==0:
M = abs ( m ) - abs ( int ( m )) b="0"
b="" return b
s =0 m = abs ( int ( m ))
if m * -1== abs ( m ): while m !=0:
s =1 b = str ( m %8) + b
if m ==0: m = int ( m /8)
b="0" if M !=0:
return b b += " . "
m = abs ( int ( m )) i =0
while M !=0:
M = M *8
Estas lineas de codigo son exactamente iguales a
if M <1:
las del codigo decimal a binario y tienen la misma
b += " 0 "
funcion, lo unico distinto es que el nombre de la
if M >=1 and M <2:
funcion es decimal_oct.
M -=1
Conversion de bases.py b += " 1 "
if M >=2 and M <3:
def decimal_oct ( m ):
M -=2
M = abs ( m ) - abs ( int ( m ))
b += " 2 "
b=""
if M >=3 and M <4:
s =0
M -=3
if m * -1== abs ( m ):
b += " 3 "
s =1
if M >=4 and M <5:
if m ==0:
M -=4
b="0"
b += " 4 "
return b
if M >=5 and M <6:
m = abs ( int ( m ))
M -=5
while m !=0:
b += " 5 "
b = str ( m %8) + b
if M >=6 and M <7:
m = int ( m /8)
M -=6
if M !=0:
b += " 6 "
b += " . "
if M >=7:
i =0
M -=7
b += " 7 "
Esta parte tambien es muy parecida, el primer whi- i +=1
le es para convertir de base decimal a octal, para if i ==25:
esto en ves de sacar el modulo de m mod 2 y dividir break
m/2, sacamos el modulo de m mod 8 y dividimos if s ==1:
m/8, esto ya que queremos pasarlo a base 8, el si- b = " -" + b
guiente if tambien tiene la misma funcion que en el return b
codigo de decimal a binario, si tiene parte fraccio-
naria le agrega un punto decimal al numero octal.

4
FCFM 2023 UAdeC

Este segundo ciclo tambien sigue el mismo algo- en C la parte sin el signo, primero vemos si j es me-
ritmo que el de la funcion decimal_bin solamente nor al numero de digitos que tiene el numero y si
que como se multiplica por ocho hay ocho casos es menor entonces guardamos el digito de la posi-
distintos despues de hacer esta multiplicacion, que cion j en C y le sumamos una posicion a j y repeti-
van que la parte entera sea desde 0 a 7 en los if se mos hasta terminar con todo el numero, al final a
observa a que cada caso corresponde y se agrega el m le asignamos en numero si el signo.
respectivo entero a la parte fraccionaria del nume-
ro octal y se le quita a la parte decimal este entero Conversion de bases.py
para solo tener la parte fraccionaria para seguir ite-
rando tambien teniendo un limite de 25 iteracio- def bin_decimal ( m ):
nes, al final igual se define su signo con la variable N =0
s y se devuelve el valor convertido a octal. i =0
M=""
C=""
2.3. Binario a decimal
J =0
s =0
Conversion de bases.py
if m [0]== " -" :
s =1
def bin_decimal ( m ):
j =1
N =0
while j < len ( m ):
i =0
C += m [ j ]
M=""
j +=1
C=""
m=C
J =0
s =0
while i < len ( m ):
if m [ i ]== " . " and
if m [0]== " -" :
( m [ i +1]== " 1 " or
s =1
m [ i +1]== " 0 " ):
j =1
j = i +1
while j < len ( m ):
J=i
C += m [ j ]
while j < len ( m ):
j +=1
M += m [ j ]
m=C
j +=1

Primero definimos la nueva funcion, esta tendra
el nombre bin_decimal y recibira como dato un
string m que sera otrogado por el usuario, y defini-
mos las bariables, N sera la variable donde se guar-
dara el numero convertido a base decimal, i sera
una variable para iterar, en M se guardara la parte
fraccionaria en caso de tenerla, C sera utilizado y
explicado e el primer while, por ultimo la variable J
sera usada como apuntador a la posicion en la que
este ubicado el punto decimal en caso de tenerlo.
el primer if es para ver si tiene signo negativo en
el primer caracter, en caso de tenerlo s cambia su
valor a 1 y se define la variable j=1 para iterar des-
pues del signo, en el primer while con ayuda de la
variable C se quitara el signo negativo, guardando
i +=1
i = len ( m )
if m [ J ]== " . " :
i=J
El primer while es para poder saber si tiene parte
fraccionaria, si i es menor al numero de digitos en-
tramos l ciclo y preguntamos si m en la posicion i
es un punto y si lo es si el siguiente numero es 1 o
0, sino lo es ignoramos lo demas y sumamos 1 a i,
y volvemos a iterar hasta encontrar un punto deci-
mal o recorrer todo el numero, si encontramos un
punto y el siguiente numero es 1 o 0 entonces defi-
nimos j como i+1 pra continuar iterando sin usar i,
a su vez definimos J=i para guardar la posicion en la

5
FCFM 2023 UAdeC

que encontramos el punto, si j es menor al tamaño En el proximo while vamos a convertir la parte en-
del numero, entonces, a M vamos a ir guardando la tera a sistema decimal, si i es mayor a 0 entramos
parte fraccionaria digito a digito con la operacion en el ciclo, devido a la teoria ya vista a N se le de-
M+=m[j], sumamos 1 a j y volvemos a iterar hasta be sumar el digito multiplicado por 2 y elevarlo a
guardar toda la parte fraccionaria en M, por ultimo su posicion, para esto se usa el codigo N+=int(m[J-
al terminar los ciclos en i guardamos el tamaño de i])*2**(i-1) al valor en la posicion m[J-i]lo multpli-
m y si m en la posicion J hay un punto entonces a i camos por dos y lo elevamos a i-1 que seria su posi-
le guardamos el valor J. cion, luego a i le restamos 1 y si el numero siguiente
es distinto de 1 o 0 o . entonces tiene un digito no
Conversion de bases.py desado y damos el error, al salir del ciclo prepara-
mos las variables para convertir la parte fracciona-
def bin_decimal ( m ): ria a base 10 guardando en i la cantidad de digitos
N =0 en M y en j gurdamos -1 para poder hacer los calcu-
i =0 los.
M=""
C=""
J =0
s =0
if m [0]== " -" :
s =1
j =1
while j < len ( m ):
C += m [ j ]
j +=1
m=C
while i < len ( m ):
if m [ i ]== " . " and
( m [ i +1]== " 1 " or
m [ i +1]== " 0 " ):
j = i +1
J=i
while j < len ( m ):
M += m [ j ]
j +=1
i +=1
i = len ( m )
if m [ J ]== " . " :
i=J

while i >0:
N += int ( m [J - i ])*2**( i -1)
i -=1
if m [ i ]!= " 0 " and
m [ i ]!= " 1 " and m [ i ]!= " . " :
raise ValueError
( f " { n } ␣ NO ␣ ES ␣ UN
␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ NUMERO ␣ BINARIO " )
i = len ( M )
j = -1

6
FCFM 2023 UAdeC

Conversion de bases.py El ultimo ciclo es para convertir la parte fracciona-

ria a base 10, es parecido al ciclo anterior, si i es ma-
def bin_decimal ( m ): yor a cero entramos al ciclo, hacemos la operacion
N =0 M+=int(m[len(M)-i])*2**(j), primero al digito de la
i =0 posicion len(M)-i lo multiplicamos por dos y lo ele-
M="" vamos a la j, esto para seguir el algoritmo visto en la
C="" introduccion, por ejemlplo en la primera iteracion
J =0 i=len(M) por lo que sera el digito de la primera po-
s =0 sicion que multiplicaremos por 2 y elevamos a la j
if m [0]== " -" : que es -1 al principio, luego a i le restamos 1 para
s =1 continuar al siguiente digito y a j le restamos 1 para
j =1 elevar el siguiente digito a su posicion, al igual que
while j < len ( m ): el ciclo anterior si el siguiente digito es distinto de
C += m [ j ] 0 o 1 se dara un error y terminara el programa. por
j +=1 ultimo al terminar el ciclo si se cambio el valor de
m=C s a 1 se le cambia el signo a N a -N y se devuelve el
while i < len ( m ): numero en base 10.
if m [ i ]== " . " and
( m [ i +1]== " 1 " or
m [ i +1]== " 0 " ):
j = i +1
J=i
while j < len ( m ):
M += m [ j ]
j +=1
i +=1
i = len ( m )
if m [ J ]== " . " :
i=J
while i >0:
N += int ( m [J - i ])*2**( i -1)
i -=1
if m [ i ]!= " 0 " and
m [ i ]!= " 1 " and m [ i ]!= " . " :
raise ValueError
( f " { n } ␣ NO ␣ ES ␣ UN
␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ NUMERO ␣ BINARIO " )
i = len ( M )
j = -1
2.4. Octal a decimal
while i >0:
N += int ( M [ len ( M ) - i ])*2**( j )
i -=1
j -=1
if M [ i ]!= " 0 " and
M [ i ]!= " 1 " :
raise ValueError
( f " { n } ␣ NO ␣ ES ␣ UN
␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ NUMERO ␣ BINARIO " )

if s ==1:
N *= -1
return N 7
FCFM 2023 UAdeC

Conversion de bases.py te fragmento de codigo, el codigo para guardar la

parte fraccionaria en M es igual. Al igual que el co-
def oct_decimal ( m ): digo de binario a decimal despues de este ciclo a i
N =0 le guardamos el numero de digitos que hay en m
i =0 i el if tambien tiene la misma finalidad que en el
M="" codigo anterior.
C=""
J =0
s =0
if m [0]== " -" :
s =1
j =1
while j < len ( m ):
C += m [ j ]
j +=1
m=C
while i < len ( m ):
if m [ i ]== " . " and
( m [ i +1]== " 0 "
or m [ i +1]== " 1 "
or m [ i +1]== " 2 "
or m [ i +1]== " 3 "
or m [ i +1]== " 4 "
or m [ i +1]== " 5 "
or m [ i +1]== " 6 "
or m [ i +1]== " 7 " ):
j = i +1
J=i
while j < len ( m ):
M += m [ j ]
j +=1
i +=1
i = len ( m )
if m [ J ]== " . " :
i=J

Este codigo de la funcion llamada oct_decimal es

muy parecido al de bin_decimal, ya que usan el
mismo algoritmo, por ejemplo, ambas reciben un
string m que se pide al usuario y todas las variables
definidas desde el principio tienen el mismo uso
y estan definidas igual, incluso el primer if y whi-
le tienen el mismo uso y codigo, el segundo whi-
le aunque tiene la misma funcion es un poco dis-
tinto en el if en su interior, esto se debe a que al
estar en base 8 tiene 8 caracteres distintos que to-
mar en cuenta por lo que si en la posicion m[i] hay
un punto en la siguiente debe estar uno de estos 8
caracteres, sin embargo, es lo unico distinto en es-

8
FCFM 2023 UAdeC

Conversion de bases.py El codigo para pasar de octal a decimal la parte en-

tera es muy similar a cuando pasamos de binario a
def oct_decimal ( m ): decimal, solamente que en ves de ser: N+=int(m[J-
N =0 i])*2**(i-1), es: N+=int(m[J-i])*8**(i-1), esto ya que
i =0 se quiere pasar de base 8 a base 10 por lo que se
M="" multiplica por 8 en ves de 2, ademas al ser un nu-
C="" mero en octal tambien si el digito en la posicion
J =0 m[i] es distinto a 0,1,2,3,4,5,6,7 o "..entonces no es
s =0 un numero octal por lo que se imprime el error, al
if m [0]== " -" : final de convertir la parte entera del octal a decimal
s =1 se nos preparamos para el ciclo para convertir los
j =1 fraccionarios en octal a base 10, esto guardando el
while j < len ( m ): numero de digitos de M en i, y guardamos -1 en j.
C += m [ j ]
j +=1
m=C
while i < len ( m ):
if m [ i ]== " . " and
( m [ i +1]== " 0 "
or m [ i +1]== " 1 "
or m [ i +1]== " 2 "
or m [ i +1]== " 3 "
or m [ i +1]== " 4 "
or m [ i +1]== " 5 "
or m [ i +1]== " 6 "
or m [ i +1]== " 7 " ):
j = i +1
J=i
while j < len ( m ):
M += m [ j ]
j +=1
i +=1
i = len ( m )
if m [ J ]== " . " :
i=J
while i >0:
N += int ( m [J - i ])*8**( i -1)
i -=1
if m [ i ]!= " 0 "
and m [ i ]!= " 1 "
and m [ i ]!= " 2 "
and m [ i ]!= " 3 "
and m [ i ]!= " 4 "
and m [ i ]!= " 5 "
and m [ i ]!= " 6 "
and m [ i ]!= " 7 "
and m [ i ]!= " . " :
raise ValueError
( f " { n } ␣ NO ␣ ES ␣ UN
␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ NUMERO ␣ OCTAL " )
i = len ( M )
j = -1
9
FCFM 2023 UAdeC

Conversion de bases.py Conversion de bases.py

def oct_decimal ( m ): while i >0:

N =0 N += int ( M [ len ( M ) - i ])*8**( j )
i =0 i -=1
M="" j -=1
C="" if M [ i ]!= " 0 "
J =0 and M [ i ]!= " 1 "
s =0 and M [ i ]!= " 2 "
if m [0]== " -" : and M [ i ]!= " 3 "
s =1 and M [ i ]!= " 4 "
j =1 and M [ i ]!= " 5 "
while j < len ( m ): and M [ i ]!= " 6 "
C += m [ j ] and M [ i ]!= " 7 " :
j +=1 raise ValueError
m=C ( f " { n } ␣ NO ␣ ES ␣ UN
while i < len ( m ): ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ NUMERO ␣ OCTAL " )
if m [ i ]== " . " and
( m [ i +1]== " 0 " if s ==1:
or m [ i +1]== " 1 " N *= -1
or m [ i +1]== " 2 "
or m [ i +1]== " 3 " return N
or m [ i +1]== " 4 "
or m [ i +1]== " 5 "
or m [ i +1]== " 6 "
or m [ i +1]== " 7 " ): Esta parte de octal fraccionario a base diez igual es
j = i +1 muy similar, en ves de: N+=int(M[len(M)-i])*2**(j),
J=i es: N+=int(M[len(M)-i])*8**(j), esto porque es de
while j < len ( m ): base 8 a base 2, ademas tambien por estar en ba-
M += m [ j ] se 8 debemos verificar que el digito de la posicion
j +=1 M[i] corresponda a uno de los 8 caracteres en base
i +=1 8, tambien si s camvio su valor a 1 le cambiamos el
i = len ( m ) singo a N a -N y devolvemos el numero en base 10.
if m [ J ]== " . " :
i=J 2.5. Binario a Octal
while i >0:
N += int ( m [J - i ])*8**( i -1) Esta conversion es la mas sencilla, ya que
i -=1 usamos las funciones hechas anteriormente
if m [ i ]!= " 0 " bin_decimal, decimal_oct, le pedimos un numero
and m [ i ]!= " 1 " binario al usuario y lo guardamos como str en una
and m [ i ]!= " 2 " variable m,luego usamos las fuciones de la ma-
and m [ i ]!= " 3 " nera: decimal_oct(bin_decimal(m)), le damos el
and m [ i ]!= " 4 " valor m a la funcion bin_decimal para convertirlo
and m [ i ]!= " 5 " a decimal y luego ese decimal lo pasamos a octal
and m [ i ]!= " 6 " con la funcion decimal_oct.
and m [ i ]!= " 7 "
and m [ i ]!= " . " : 2.6. Octal a binario
raise ValueError
( f " { n } ␣ NO ␣ ES ␣ UN El procedimiento es muy parecido, usando las
␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ NUMERO ␣ OCTAL " ) funciones: oct_decimal, decimal_bin y un nume-
i = len ( M ) ro octal que se le pide al usuario y se guarda en
j = -1
10
FCFM 2023 UAdeC

una variable string m, hacemos lo siguiente: deci- .

mal_bin(oct_decimal(m)), le damos el valor m a la
funcion oct_decimal para convertirlo a decimal y
luego ese decimal lo pasamos a binario con la fun-
cion decimal_bin.

3. Resultados
3.1. Ejemplo de decimal a binario con el codigo

Figura 1: Ejemplo de decimal a binario

3.2. Ejemplo de decimal a octal con el codigo

Figura 2: Ejemplo de decimal a octal

11
FCFM 2023 UAdeC

3.3. Ejemplo de binario a decimal con el codigo

..

Figura 3: Ejemplo de binario a decimal

3.4. Ejemplo de octal a decimal con el codigo

.
Figura 4: Ejemplo de octal a decimal

12
FCFM 2023 UAdeC

3.5. Ejemplo de binario a octal con el codigo

Figura 5: Ejemplo de binario a octal

3.6. Ejemplo de octal a binario con el codigo

Figura 6: Ejemplo de octal a binario

4. Conclusiones

Este programa fue hecho principalmente para

entender los errores de punto flotante y el porque
suceden debido a estas conversiones que hace la
computadora, ademas de esto se logro aprender el
como se realizan estas conversiones a familiarizar-
nos con las demas bases existentes.

13