Cómo Convertir un Número Decimal en Binario en Python

Si en otro artículo veíamos cómo convertir un número binario en su equivalente decimal, en esta ocasión te voy a explicar exactamente lo opuesto. Es decir, veremos la manera de convertir un número que está en base 10 para ponerlo en base 2, es decir, pasar de decimal a binario. ¿Cómo conseguimos esto con Python?

Una forma sencilla de convertir decimal en binario en Python es dividir sucesivamente el número decimal entre 2 e ir guardando el módulo, resto o residuo de cada división hasta obtener cero en el cociente. Finalmente se concatenan todos los módulos en orden inverso para obtener el número en binario.

Te explico a continuación el proceso general para hacer la conversión y, después, paso a paso, la manera de implementar el algoritmo.

Cómo convertir de decimal a binario

Antes de explicártelo con texto, lo mejor es verlo en una imagen:

Como ves, se trata de tomar el número decimal, que en este caso es 29, y dividirlo entre 2. El cociente se divide entre 2. El cociente de esta última división se divide entre 2. Y así sucesivamente hasta obtener 0. Después se toman los módulos de las divisiones, que serán valores 0 o 1 y se invierte su orden. Con esto ya tenemos el número binario.

En realidad esta es la forma matemática de resolver este problema. Lo puedes realizar así con independencia del lenguaje que estés utilizando. Es decir, este es el algoritmo general para la conversión de un número decimal en su equivalente en binario.

Veamos ahora, entonces, cómo implementar este algoritmo en Python.

Paso 1: Hacer la división entera del número decimal entre 2

El primer paso, que es muy sencillo, es fundamental y tendremos que repetirlo en bucle para obtener el número deseado. Pero no nos adelantemos.

Se trata de dividir el número de origen entre 2. Además, necesitaremos dos números distintos resultado de esta división: el cociente y el módulo (también llamado resto o residuo).

Es por esto que necesitamos utilizar la división entera, no sirve utilizar la división estándar.

En Python 3 el símbolo de la división entera es la doble barra //. Si aplicas una sola barra / obtendrás el resultado de la división real y no te servirá, pues necesitas obtener de manera separada el cociente y el módulo.

Al hacer una división entera con la doble barra obtendrás el cociente. Vamos a ver unos ejemplos donde, como podrás observar, el resultado es el cociente.

>>> 10 // 4 
2 
>>> 6 // 3 
2 
>>> 15 // 2 
7 

Como te he dicho, también necesitamos obtener el módulo, para ello tendremos que aplicar el operador %, que se encarga de resolver la división entera nuevamente, pero esta vez el resultado es el módulo.

Vamos a ver los mismos ejemplos de antes pero obteniendo los módulos esta vez:

>>> 10 % 4 
2 
>>> 6 % 3 
0 
>>> 15 % 2 
1

Con esto tenemos todas las piezas necesarias. Podemos comprobar que son correctas con la típica prueba de la división que nos enseñaban en el cole, aquella que decía "dividendo es igual a divisor por cociente más resto". Podemos comprobarlo en Python:

>>> 10 == 5 * (10 // 5) + (10 % 5) 
True 
>>> 6 == 3 * (6 // 3) + (6 % 3)       
True 
>>> 15 == 2 * (15 // 2) + (15 % 2)      
True

Paso 2: Guardar el módulo de la división entre 2

En el segundo paso tienes que guardar el módulo obtenido en la división previa. Como este es un proceso iterativo donde vamos a guardar diversos módulos lo mejor es crear una lista e ir almacenándolos en ella.

Basta para esto con crear una lista vacía llamada, por ejemplo, modulos y añadir al final el módulo m recién calculado con la función append de la siguiente manera: modulos.append(m).

Paso 3: Repetir los pasos 1 y 2 hasta obtener 0 en el cociente

Cómo ya te dije, este es un proceso iterativo, así que necesitamos realizar los pasos 1 y 2 en un bucle teniendo en cuenta dos aspectos principales:

1. Cada vez que obtenemos un cociente, este pasa a ser el número que utilizamos en la siguiente iteración para realizar la división.
2. Debemos detener el bucle cuando el cociente obtenido sea 0. Ya no tiene sentido seguir dividiendo 0 entre 2.

A este proceso iterativo le llega un número de entrada, que es el número que deseamos convertir a binario. Este número se divide entre 2, como ya vimos, para obtener un cociente. Ese cociente pasa a ser el número de entrada en la siguiente operación. De esta manera el número se va reduciendo cada vez más hasta que, finalmente, llega a ser cero. Es en ese momento cuando detenemos el bucle. Vuelve a echar un ojo a la imagen de antes para no perderte.

Veamos cómo queda el código:

numero_decimal = 29 # este es el número que queremos convertir a binario

modulos = [] # la lista para guardar los módulos

while numero_decimal != 0: # mientras el número de entrada sea diferente de cero
    # paso 1: dividimos entre 2
    modulo = numero_decimal % 2
    cociente = numero_decimal // 2
    modulos.append(modulo) # guardamos el módulo calculado
    numero_decimal = cociente # el cociente pasa a ser el número de entrada

print(modulos)

De esta manera, el resultado por pantalla, donde se pueden ver los módulos calculados, es el siguiente:

[1, 0, 1, 1, 1]

Vamos a reescribir un poco el código pues, para que lo entendieras bien, lo he escrito paso a paso, pero puede optimizarse un poco más de la siguiente manera:

numero_decimal = 29 # este es el número que queremos convertir a binario

modulos = [] # la lista para guardar los módulos

while numero_decimal != 0: # mientras el número de entrada sea diferente de cero
    modulos.append(numero_decimal % 2) # se obtiene el módulo y se almacena
    numero_decimal //= 2 # el cociente pasa a ser el número de entrada

Paso 4: Invertir los módulos guardados

Una vez obtenidos los módulos hay que darles la vuelta, pues el número binario resultante se compone de todos estos módulos concatenados pero en orden inverso al de obtención. Esto se puede realizar muy fácil utilizando la notación de porciones para obtener toda la lista al revés de la siguiente manera: modulos = modulos[::-1].

No obstante, esta operación es innecesaria si, cuando tenemos que almacenar un módulo recién calculado en la lista ya lo hacemos guardándolo al principio de la lista en lugar de hacerlo por el final. De esta manera ya queda directamente invertidos que es el orden que deseamos.

Para hacer esto podemos hacer uso de la función insert que nos permite introducir un elemento en una lista pero en la posición que queramos. Si siempre introducimos el módulo en la posición 0 el elemento pasa a ser el primero de la lista desplazando a todos los demás una posición hacia la derecha.

La función insert necesita dos parámetros, el primero de ellos es la posición o índice en la que queremos insertar el nuevo elemento y el segundo es el propio elemento:

>>> lista = [] 
>>> lista.insert(0, 1) 
>>> lista.insert(0, 2) 
>>> lista.insert(0, 3) 
>>> print(lista) 
[3, 2, 1]

Adaptemos, entonces, nuestro código para guardar los módulos en el orden correcto:

numero_decimal = 29

modulos = []
while numero_decimal != 0:
    # se almacena el módulo en el orden correcto
    modulos.insert(0, numero_decimal % 2)
    numero_decimal //= 2

print(modulos)

El resultado será:

[1, 1, 1, 0, 1]

Paso 5: Concatenar los módulos para obtener el número binario final

Ten en cuenta que, al obtener los módulos de las divisiones entre 2, el resultado de cada módulo siempre es 0 o 1, pues son los posibles restos de dividir entre 2. Así que obtener el número binario final es muy directo ya.

Solo nos queda ahora concatenar todos los números para construir el número binario final.

Existe varias formas para poder hacer esta operación:

• Matemáticamente podemos multiplicar cada dígito por 10 elevando a su posición y sumar todos los resultados. Así el número correspondiente a las unidades lo multiplicamos por 10 elevado a 0, el de las decenas por 10 elevando a 1, el de las centenas por 10 elevando a 2 y así sucesivamente.
• Si convertimos los dígitos a carácter (por ejemplo cuando los vamos guardando en la lista) y hacemos una operación de join de esta manera: ''.join(modulos) solo quedaría transformar finalmente el número a un entero (si lo deseamos) con la función int: int(''.join(modulos)).

Lo que prefiero hacer yo es aplicar las matemáticas pero haciendo una pequeña optimización. ¿Por qué no ir creando el nuevo número binario con cada módulo calculado en lugar de ir almacenándolo en una lista que necesitamos procesar posteriormente? Para esto altero un poco el código que ya tenemos en el bucle para generar el número binario parcial. Así me ahorro hacer un segundo bucle y, además, ya no necesitamos la lista:

numero_decimal = 29

numero_binario = 0
multiplicador = 1

while numero_decimal != 0: # paso 3
    # pasos 1, 4 y 5 se multiplica el módulo por su multiplicador
    numero_binario = numero_binario + numero_decimal % 2 * multiplicador
    numero_decimal //= 2 # paso 1
    multiplicador *= 10 # paso 5

print(numero_binario)

Como ves, ya hemos sido capaces de obtener el número. Es cierto que ya no necesitamos la lista, pero necesitamos conocer la posición de cada dígito para multiplicarlo por 10 elevando a dicha posición. Como estos valores son 1, 10, 100, 1000, etc. respectivamente para las posiciones 0, 1, 2, 3, etc., lo único que tenemos que hacer es usar una variable multiplicador que comienza valiendo 1 y multiplicarla por 10 en cada iteración. Usaremos dicha variable para multiplicarla por el módulo calculado y sumaremos su resultado al número binario.

El resultado de este código es 11101, que es exactamente 29 en binario.

Paso 6 (opcional): Encapsular el algoritmo en una función de conversión de decimal a binario

Y listo, con todo esto solo nos queda crear una función con este código para que nos sirva para convertir a binario cualquier número decimal. Esto es interesante si en tu código necesitamos realizar esta operación varias veces porque evitarás la repetición de código y lo harás más modular, manejable y entendible. Además, así practicas la definición de funciones:

def decimal_a_binario(numero_decimal):
    numero_binario = 0
    multiplicador = 1

    while numero_decimal != 0:
        # se almacena el módulo en el orden correcto
        numero_binario = numero_binario + numero_decimal % 2 * multiplicador
        numero_decimal //= 2
        multiplicador *= 10

    return numero_binario

# ejemplos de uso

print(decimal_a_binario(5))
print(decimal_a_binario(35))
print(decimal_a_binario(22301))

Y tendremos como resultado los siguientes números binarios por pantalla:

101
100011
101011100011101

Infografía de resumen

Como no quiero que te marches de esta página sin que te quede perfectamente claro cómo convertir un número decimal en un número binario, he hecho una infografía con el resumen del proceso.

Alternativa

Lo que te he contado en este artículo es de interés si realmente estás aprendiendo Python y quieres saber la forma de hacer esta operación mediante un algoritmo.

Si no es así y necesitas una manera rápida de convertir un número decimal en binario, Python proporciona una función propia llamada bin que, dado un número decimal, te devuelve su equivalente en binario. Eso sí, en formato texto y con el prefijo 0b que indica número binario:

>>> bin(29) 
'0b11101' 
>>> bin(5) 
'0b101' 
>>> bin(14) 
'0b1110'

Cómo convertir un número decimal a otro en cualquier base

El algoritmo que hemos construido aquí tiene una gran ventaja, y es que es un algoritmo genérico para convertir un número decimal o de base 10 a cualquier base y no solo a base 2 o binario. Esto es porque el algoritmo funciona exactamente igual con solo sustituir la división por 2 por la división en la base que queramos.

Si necesitamos calcular el número en base 3 o en base 7, por ejemplo, dividiremos por 3 o por 7 respectivamente.

Modifiquemos la función creada para admitir un parámetro más que indique la base a la que queremos convertir:

def decimal_a_base(numero_decimal, base):
    numero_binario = 0
    multiplicador = 1

    while numero_decimal != 0:
        # dividimos por la base indicada
        numero_binario = numero_binario + numero_decimal % base * multiplicador
        numero_decimal //= base
        multiplicador *= 10

    return numero_binario

# ejemplos de uso

print(f'5 en base 3 es {decimal_a_base(5, 3)}')
print(f'35 en base 8 es {decimal_a_base(35, 8)}')
print(f'7 en base 7 es {decimal_a_base(7, 7)}')

El resultado por pantalla será el siguiente:

5 en base 3 es 12
35 en base 8 es 43
7 en base 7 es 10

Si necesitas convertir tu número a una base superior a 10 hay que modificar levemente la función para aplicar el multiplicador correcto. Por ejemplo, si la base es 12, como cada dígito de origen ocupará 2 dígitos en la nueva base el multiplicador tendrá que multiplicarse por 100 en cada iteración y no por 10.

Te dejo aquí modificada la función para obtener el número correcto en cualquier base:

def decimal_a_base(numero_decimal, base):
    numero_binario = 0
    longitud_base = len(str(base))
    multiplicador = 1

    while numero_decimal != 0:
        # dividimos por la base indicada
        numero_binario = numero_binario + numero_decimal % base * multiplicador
        numero_decimal //= base
        multiplicador *= 10 ** longitud_base

    return numero_binario

Si intentamos, con este algoritmo, trasformar el número 491 a base 27, obtendremos como resultado el número 1805, donde cada número está formado dos dígitos: 18 y 05.

Espero haber podido ayudarte con este artículo y, sobre todo, espero que hayas podido aprender algo nuevo. Por favor, comparte este artículo, si piensas que puede ser de utilidad para alguien. Tienes unos botones para hacerlo al final de esta página.