Conversión de tipos de datos en Python: Una guía con ejemplos

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

¿Por qué no se convirtió el valor flotante a un número 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 perder información.

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

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

La conversión explícita de tipos de datos, a menudo denominada conversión de tipos, se produce cuando conviertes deliberadamente un valor de un tipo de datos a otro. Este enfoque te da un control directo sobre la conversión, ya que especificas explícitamente el tipo de datos de destino en tu código. Se suele utilizar cuando la conversión automática (implícita) que proporciona Python no satisface tus necesidades.

La sintaxis para la conversión explícita es

target_data_type(expression)

Por ejemplo, si quieres convertir un número de coma flotante en un número entero, escribirías

int(3.14)  # Converts 3.14 to 3

Nota: Aunque las conversiones explícitas son muy útiles, pueden provocar pérdidas de información. Por ejemplo, al convertir un número en coma flotante a un número entero, se descartará su parte fraccionaria. Es importante comprender estas consecuencias para evitar resultados no deseados en tus programas.

Exploremos algunas conversiones explícitas de tipos de datos de uso común.

Estructuras de datos primitivas y no primitivas en Python

Las estructuras de datos primitivas son los bloques de construcción para la manipulación de datos y contienen valores de datos puros y simples. 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
• Diccionarios
• 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 en Python

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

Para convertir un entero en un 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().

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

Problemas de precisión del flotador y el Decimal módulo

La aritmética de coma flotante en Python puede provocar problemas de precisión:

print(0.1 + 0.2)  # Output: 0.30000000000000004

Para evitarlo, utiliza el módulo Decimal:

from decimal import Decimal

print(Decimal('0.1') + Decimal('0.2'))  # Output: 0.3

Conversión de tipos de datos reales a complejos en Python

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 Python 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.

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 un TypeError, informando de que el compilador no puede convertir implícitamente un valor entero en una cadena.

Lo que el programa debe hacer aquí puede parecerte intuitivo. Sin embargo, puede que el compilador no siempre esté seguro, por lo que proporciona un mecanismo con fundición de tipos explícita para que puedas indicar claramente lo que quieres. Así es como puedes convertir un número entero en una cadena en Python utilizando la función str():

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 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'

Resumen: Conversiones de tipos de datos primitivos en Python

Conversiones de estructuras de datos no primitivas

Conversión de tipos Python 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. Así, puedes convertirlas en listas, hacer el cambio y volver a convertirlas en tuplas.

En Python, puedes utilizar la función tuple() para devolver una versión en tupla del valor que se le ha pasado, y del mismo modo la función list() para convertir una tupla 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)]

Del mismo modo, te explicamos cómo convertir una cadena en una lista o tupla en Python:

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 Python a diccionarios y conjuntos

Puedes utilizar la función 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.

Utilizando dataclasses para Datos Estructurados (Python 3.7+)

En lugar de utilizar diccionarios o tuplas, dataclasses proporciona una forma mejor de manejar datos estructurados.

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    in_stock: bool

item = Product("Laptop", 799.99, True)
print(item)  # Output: Product(name='Laptop', price=799.99, in_stock=True)

Resumen: Conversiones de estructuras de datos no primitivas de Python

Enteros Unicode, Binarios, Octales y Hexadecimales en Python

Los sistemas numéricos se refieren al número de símbolos o caracteres que representan 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.

Pasas a la siguiente colocación de dígitos cuando te quedas sin símbolos. 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, cuando consideras un sistema binario que sólo utiliza dos símbolos, 0 y 1, necesitas pasar a la siguiente colocación de dígitos cuando se te acaban los símbolos. Así es como contarás en binario: 0, 1, 10, 11, 100, 101, etc.

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

Convertir binario a decimal en Python

Los enteros binarios son los números representados con base dos. Esto significa que en el sistema numérico binario sólo se utilizan 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.

Del mismo modo, la función int() para convertir un valor binario a su valor decimal. La función 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 decimal convencional. 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 de un valor decimal a su correspondiente valor octal. También puedes utilizar la función int() y 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, utiliza seis símbolos adicionales 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í, 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 y 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 de un valor decimal a su correspondiente valor hexadecimal, o la función int() en 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 los enteros unicode en una cadena. Unicode es una codificación de caracteres universalmente aceptada para mostrar los textos escritos de 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 número 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

Resumen: Conversiones de sistemas numéricos en Python

¡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 puedes aplicar todo lo que has aprendido y poner en práctica tus conocimientos.