Tutorial de conversión de tipos de datos en Python

En el ejemplo, un valor int a_int a un valor flotante b_floaty el resultado se convirtió automáticamente en un valor flotante c_sum sin que tengas que decírselo al compilador. Esta es la conversión implícita de datos.

¿Por qué no se convirtió el valor flotante a entero?

Esto se debe a un concepto más amplio de la promoción de tipos en informática. En pocas palabras, se trata de un mecanismo de defensa del compilador que te permite realizar operaciones siempre que sea posible convirtiendo tus datos en un supertipo diferente sin pérdida de información.

Eso significa que no se realiza la conversión de flotante a entero, porque entonces el compilador tendrá que eliminar la parte fraccionaria, lo que conlleva una pérdida de información.

Conversión explícita de tipos de datos en Python

La conversión explícita, también conocida como fundición de tipos, se produce cuando la conversión de tipos de datos tiene lugar porque la has definido claramente en tu programa. Básicamente, obligas a una expresión a ser de un tipo determinado. La forma general de una conversión explícita de tipos de datos es la siguiente:

(required_data_type)(expression)

Nota: como puedes imaginar, con la conversión explícita de tipos de datos, existe un riesgo de pérdida de información, ya que estás forzando a una expresión a ser de un tipo específico.

Con todo esto en mente, puedes profundizar en algunas de las conversiones de tipos de datos explícitos más utilizadas...

Estructuras de datos primitivas frente a no primitivas

Las estructuras de datos primitivas son los bloques de construcción para la manipulación de datos y contienen valores puros y simples de datos. Python tiene cuatro tipos de variables primitivas:

• Enteros
• Flotador
• Cuerdas
• Booleano

Las estructuras de datos no primitivas no almacenan sólo un valor, sino una colección de valores en diversos formatos. En Python, tienes las siguientes estructuras de datos no primitivas:

• Listas
• Tuplas
• Diccionario
• Establece

Puedes aprender más sobre ellas con el Tutorial de Estructuras de Datos en Python de DataCamp .

Conversiones de estructuras de datos primitivas

Conversiones de enteros y flotantes

Los enteros y los flotantes son tipos de datos que tratan con números.

Para convertir el entero en flotante, utiliza la función float() en Python. Del mismo modo, si quieres convertir un flotante en un entero, puedes utilizar la función int() función.

a_int = 3
b_int = 2

# Explicit type conversion from int to float
c_float_sum = float(a_int + b_int)
print(c_float_sum)

5.0

a_float = 3.3
b_float = 2.0

# Explicit type conversion from float to int
c_int_sum = int(a_float + b_float)
print(c_int_sum)

c_float_sum = a_float + b_float
print(c_float_sum)

5
5.3

Conversión de tipos de datos reales a complejos

Puedes convertir números enteros en números complejos utilizando complex(real,imag). Requiere dos números enteros (real e imaginario) y convierte los números reales en números complejos.

real = 2
imag = 5
print(complex(real, imag))

(2+5j)

Conversión de tipos de datos con cadenas

Una cadena es una colección de uno o varios caracteres (letras, números, símbolos). Puede que necesites convertir cadenas a números o números a cadenas con bastante frecuencia. Comprueba cómo puedes hacerlo utilizando str() función:

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + total  + "$")

 
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-54bd76b9b4bd> in <module>()
      2 price_cookie = 6
      3 total = price_cake + price_cookie
----> 4 print("The total is: " + total  + "$")


TypeError: Can't convert 'int' object to str implicitly

El ejemplo anterior da una TypeErrorinformando de que el compilador no puede convertir implícitamente un valor entero en una cadena.

Puede parecerte intuitivo lo que el programa debe hacer aquí. Sin embargo, puede que el compilador no siempre esté seguro, y por eso proporciona un mecanismo con la fundición de tipos explícita para que puedas indicar claramente lo que quieres. Veamos el mismo ejemplo con la fundición de tipos:

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + str(total)  + "$")

The total is: 21$

Funciona igual cuando conviertes valores flotantes en valores de cadena.

En Python, también puedes convertir cadenas en valores enteros y flotantes siempre que sea posible. Veamos qué significa esto:

price_cake = '15'
price_cookie = '6'

# String concatenation
total = price_cake + price_cookie
print("The total is: " + total + "$")

# Explicit type conversion to integer
total = int(price_cake) + int(price_cookie)
print("The total is: " + str(total)  + "$")

The total is: 156$
The total is: 21$

Desglosemos el código.

price_cake y price_cookie son inicialmente cadenas. Luego, tienes que hallar el total, lo que significa que primero hay que convertirlos a sus correspondientes valores enteros. De lo contrario, el compilador asumirá que la operación que quieres es una concatenación de cadenas en lugar de una suma numérica. A continuación, tienes que poner este valor en la cadena de visualización final y, en consecuencia, tienes que convertir el total en una cadena para concatenarla con el resto del mensaje de visualización.

Esperamos que este ejemplo te ayude a ver la importancia de las conversiones de tipos de datos. Aunque éste es un ejemplo muy pequeño de conversión de tipos de datos, ya puedes ver lo útil que puede ser.

Nota: ¿te has fijado en el "siempre que sea posible" al intentar convertir una cadena a enteros o flotantes? Esto se debe a que no siempre es posible convertir cadenas en números y aplicarles operaciones numéricas. El compilador es consciente de ello y, por tanto, te dará un error cuando intentes hacerlo. Mira el siguiente ejemplo:

price_cake = 'fifteen'
price_cookie = 'six'
total = int(price_cake) + int(price_cookie)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-25-80591b8accda> in <module>()
      1 price_cake = 'fifteen'
      2 price_cookie = 'six'
----> 3 total = int(price_cake) + int(price_cookie)


ValueError: invalid literal for int() with base 10: 'fifteen'

Estructuras de datos no primitivas

Conversión de tipos a tuplas y listas

Al igual que con los enteros y los flotantes, también puedes convertir listas en tuplas y tuplas en listas.

¿Recuerdas qué son las tuplas y las listas? Las listas y tuplas en Python se utilizan para almacenar una colección de elementos homogéneos. La diferencia entre las tuplas y las listas es que las tuplas son inmutables, lo que significa que, una vez definidas, no puedes borrar, añadir ni editar ningún valor de su interior.

¿Por qué convertir listas en tuplas?

Esto se debe a que las tuplas son tipos de datos inmutables y permiten una optimización sustancial de los programas que creas.

¿Y por qué convertirías tuplas en listas?

Tal vez quieras hacer cambios en la tupla inicial. Por tanto, puedes convertirlas en listas y luego hacer el cambio, y después volver a convertirlas en tuplas.

Puedes utilizar el tuple() para que devuelva una versión tupla del valor que se le ha pasado, y del mismo modo la función list() para convertirla en una lista:

a_tuple = ('a', 1) ,('f', 2), ('g', 3)
b_list = [1,2,3,4,5]

print(tuple(b_list))
print(list(a_tuple))

(1, 2, 3, 4, 5)
[('a', 1), ('f', 2), ('g', 3)]

También puedes convertir una cadena en una lista o tupla. 

dessert = 'Cake'

# Convert the characters in a string to individual items in a tuple
print(tuple(dessert))

# Convert a string into a list
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)

('C', 'a', 'k', 'e')
['C', 'a', 'k', 'e', 's']

Conversión de tipos en diccionarios y conjuntos

Puedes utilizar el dict() para convertir una tupla en un diccionario y set() para convertir una lista en un conjunto. 

print(dict(a_tuple))
print(set(b_list))

{'a': 1, 'f': 2, 'g': 3}
{1, 2, 3, 4, 5}

Más sencillo que otras funciones de conversión, sólo tienes que proporcionar un nombre de función para convertir cualquier tipo de dato en diccionarios y conjuntos. 

Enteros Unicode, Binarios, Octales y Hexadecimales en Python

Los sistemas numéricos se refieren al número de símbolos o caracteres utilizados para representar cualquier valor numérico. El sistema numérico que sueles utilizar todos los días se llama decimal. En el sistema decimal se utilizan diez símbolos diferentes: 0, 1, 2, 3, 4, 5, 6, 7, 8 y 9. Con estos diez símbolos, puedes representar cualquier cantidad. Unicode, Binario, Hexadecimal y Octal se refieren a sistemas numéricos diferentes.

Cuando te quedas sin símbolos, pasas a la siguiente colocación de dígitos. En el sistema decimal, para representar uno mayor que 9, se utiliza 10, que significa una unidad de diez y cero unidades de uno. Sin embargo, es diferente en otros sistemas numéricos. Por ejemplo, si consideras un sistema binario que sólo utiliza dos símbolos: 0 y 1, cuando te quedes sin símbolos, tienes que pasar a la siguiente colocación de dígitos. Así es como contarás en binario: 0, 1, 10, 11, 100, 101 y así sucesivamente.

Veamos con más detalle algunos de los sistemas numéricos en los siguientes apartados.

Convertir Binario a Decimal en Python

Los números enteros binarios son los números representados con base dos. Lo que significa que en el sistema numérico binario sólo hay dos símbolos para representar los números: 0 y 1. Cuando cuentas desde cero en binario, te quedas sin símbolos más rápidamente: 0, 1, ???

Además, ya no quedan símbolos. No vas al dígito 2 porque el 2 no existe en binario. En su lugar, utiliza una combinación especial de 1s y 0s. En un sistema binario, 1000 es igual a 8 en decimal. En binario, se utilizan potencias de dos, lo que significa que 8 es básicamente: (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0))= 8. La posición del 1 y del 0 define la potencia a la que debe elevarse 2.

Veámoslo con un ejemplo más complejo para que quede claro:

Binary Number = 1001111
Decimal value = (1*(2^6)) + (0*(2^5)) + (0*(2^4)) + (1*(2^3)) + (1*(2^2)) + (1*(2^1)) + (1*(2^0))
              = 79

En Python, puedes utilizar simplemente la función bin() para convertir de un valor decimal a su correspondiente valor binario.

Y del mismo modo, la int() para convertir un valor binario en su valor decimal. En int() toma como segundo argumento la base del número a convertir, que es 2 en el caso de los números binarios.

a = 79

# Base 2(binary)
bin_a = bin(a)
print(bin_a)
print(int(bin_a, 2)) #Base 2(binary)

0b1001111
79

Convertir Octal a Decimal en Python

El octal es otro sistema numérico con menos símbolos que el sistema numérico decimal convencional. Octal es de base ocho, lo que significa que se utilizan ocho símbolos para representar todas las cantidades. Son 0, 1, 2, 3, 4, 5, 6 y 7. Después del 7 está el 10, ya que el 8 no existe.

Igual que en binario utilizabas potencias de dos para determinar el valor de un número, en base ocho utilizarás potencias de 8.

En un sistema binario, 10 es igual a 8 en octal. Vamos a desglosarlo: (1(8^1)) + (0(8^0))= 8.

Un ejemplo más complejo:

Octal Number = 117
Decimal value = (1*(8^2)) + (1*(8^1)) + (7*(8^0))
              = 79

En Python, puedes utilizar la función oct() para convertir un valor decimal en su correspondiente valor octal. También puedes utilizar la función int() junto con la base correcta, que es 8 para el sistema numérico octal.

a = 79

# Base 8(octal)
oct_a = oct(a)
print(oct_a)
print(int(oct_a, 8))

0o117
79

Convertir Hexadecimal a Decimal en Python

El hexadecimal es un sistema numérico de base 16. A diferencia del binario y el octal, el hexadecimal tiene seis símbolos adicionales que utiliza además de los números que se encuentran en el sistema numérico decimal.

Pero, ¿qué viene después del 9?

Cuando se necesiten símbolos adicionales más allá de los valores numéricos normales, se utilizarán letras. Así que en hexadecimal, la lista total de símbolos utilizados es: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, and F.

Utilizando el mismo ejemplo anterior:

Hexadecimal Number = 4F
Decimal value = (4*(16^1)) + (F*(16^0))
              = 79

En Python, puedes utilizar la función hex() para convertir un valor decimal en su correspondiente valor hexadecimal, o la función int() con base 16 para el sistema numérico hexadecimal.

a = 79

# Base 16(hexadecimal)
hex_a = hex(a)
print(hex_a)
print(int(hex_a, 16))

0x4f
79

Convertir Unicode en carácter

Python chr() convierte enteros unicode a cadena. Unicode es una codificación de caracteres universalmente aceptada para mostrar los textos escritos de las diversas lenguas.

Hemos proporcionado varios enteros unicode a la función chr() para mostrar "DATACAMP". También puedes utilizar ord() para convertir un único carácter en un entero unicode. 

print(
    chr(68),
    chr(65),
    chr(84),
    chr(65),
    chr(67),
    chr(65),
    chr(77),
    chr(80),
)

D A T A C A M P

¡Lo has conseguido!

¡Enhorabuena! Has aprendido sobre las conversiones de tipos de datos en Python, principalmente utilizando métodos incorporados. Esto te ayudará sin duda a trabajar con distintos tipos de datos, proporcionándote más flexibilidad a la hora de escribir tus programas.

Tenemos un excelente curso sobre Python Intermedio para la Ciencia de Datos en el que puedes aprender a trazar tus datos utilizando matplotlib, y a trabajar con diccionarios y el famoso pandas DataFrame. También verás cómo puedes controlar el flujo de tu programa con bucles. También hay un caso práctico al final del curso en el que podrás aplicar todo lo que has aprendido y poner en práctica tus conocimientos.