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

En el ejemplo, se suma un entero a_int a un float b_float, y el resultado se convierte automáticamente en float c_sum sin que tengas que indicarlo al compilador. Esto es conversión implícita.

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

Se debe a un concepto más amplio llamado promoción de tipos. En pocas palabras, es un mecanismo de defensa del compilador que permite realizar operaciones siempre que sea posible convirtiendo tus datos a un supertipo sin perder información.

Es decir, no se convierte de float a entero porque habría que eliminar la parte fraccionaria y se perdería información.

Conversión explícita de tipos en Python

La conversión explícita de tipos, también llamada type casting, ocurre cuando conviertes deliberadamente un valor de un tipo a otro. Este enfoque te da control directo sobre la conversión, ya que especificas explícitamente el tipo de destino en tu código. Se usa cuando la conversión automática (implícita) de Python no cumple con tus necesidades.

La sintaxis para la conversión explícita es:

target_data_type(expression)

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

int(3.14)  # Convierte 3.14 en 3

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

Veamos algunas conversiones explícitas habituales.

Estructuras de datos primitivas y no primitivas en Python

Las estructuras de datos primitivas son los bloques básicos para manipular datos y contienen valores simples y puros. Python tiene cuatro tipos de variables primitivas:

• Enteros
• Float
• Cadenas
• Booleanos

Las estructuras no primitivas no almacenan solo un valor, sino colecciones de valores en distintos formatos. En Python, las estructuras de datos no primitivas son:

• Listas
• Tuplas
• Diccionarios
• Conjuntos

Puedes aprender más con el tutorial de estructuras de datos en Python de DataCamp.

Conversiones en estructuras de datos primitivas

Conversiones entre enteros y float en Python

Enteros y float son tipos numéricos.

Para convertir un entero a float, usa la función float() en Python. Del mismo modo, si quieres convertir un float a entero, usa int().

a_int = 3
b_int = 2

# Conversión explícita de int a float
c_float_sum = float(a_int + b_int)
print(c_float_sum)

5.0

a_float = 3.3
b_float = 2.0

# Conversión explícita de float a 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 con float y el módulo Decimal

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

print(0.1 + 0.2)  # Output: 0.30000000000000004

Para evitarlos, usa el módulo Decimal:

from decimal import Decimal

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

Conversión de números reales a complejos en Python

Puedes convertir enteros en números complejos con complex(real,imag). Recibe dos números (parte real e imaginaria) y crea un número complejo.

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

(2+5j)

Conversión de tipos con cadenas en Python

Una cadena es una colección de uno o más caracteres (letras, números, símbolos). Es muy habitual convertir cadenas a números o números a cadenas.

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 lanza un TypeError: el compilador no puede convertir implícitamente un entero a cadena.

Lo que el programa debería hacer puede parecerte obvio. Sin embargo, el compilador no siempre puede deducirlo, así que te ofrece conversión explícita para que especifiques lo que quieres. Así conviertes un entero en cadena en Python con str():

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

The total is: 21$

Funciona igual al convertir float a cadena.

En Python, también puedes convertir cadenas a enteros y float siempre que sea posible. Veamos qué significa:

price_cake = '15'
price_cookie = '6'

# Concatenación de cadenas
total = price_cake + price_cookie
print("The total is: " + total + "$")

# Conversión explícita a entero
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. Como necesitas el total, primero hay que convertirlas a enteros. Si no, el compilador asumirá concatenación de cadenas en lugar de suma numérica. Luego, para mostrar el resultado, conviertes el total a cadena para concatenarlo con el mensaje.

Esperamos que este ejemplo te ayude a ver la importancia de las conversiones de tipos. Aunque sea un caso sencillo, ya puedes apreciar lo útiles que son.

Nota: ¿te fijaste en el "siempre que sea posible" al convertir cadenas a enteros o float? No siempre es posible convertir cadenas a números y operar con ellas. El compilador lo sabe y te dará un error si lo intentas. Mira el 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 en estructuras de datos no primitivas

Conversión a tuplas y listas en Python

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

¿Recuerdas qué son tuplas y listas? Las listas y las tuplas en Python sirven para almacenar colecciones de elementos. La diferencia es que las tuplas son inmutables: una vez definidas, no puedes borrar, añadir ni editar sus valores.

¿Por qué convertir listas en tuplas?

Porque las tuplas, al ser inmutables, permiten optimizar significativamente tus programas.

¿Y por qué convertir tuplas en listas?

Quizá necesites hacer cambios sobre la tupla inicial. Puedes convertirla en lista, modificarla y volver a convertirla en tupla.

En Python, usa tuple() para devolver una versión en tupla del valor que le pases, y list() para convertir una tupla en 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)]

De forma similar, así conviertes una cadena en lista o tupla en Python:

dessert = 'Cake'

# Convertir los caracteres de una cadena en elementos individuales de una tupla
print(tuple(dessert))

# Convertir una cadena en lista
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)

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

Conversión a diccionarios y conjuntos en Python

Puedes usar dict() para convertir una tupla en diccionario y set() para convertir una lista en conjunto.

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

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

Al igual que con otras funciones de conversión, basta con usar la función adecuada para transformar cualquier tipo de dato en diccionarios o conjuntos.

Uso de dataclasses para datos estructurados (Python 3.7+)

En lugar de diccionarios o tuplas, dataclasses ofrece 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 en estructuras de datos no primitivas en Python

Unicode y enteros binarios, octales y hexadecimales en Python

Los sistemas de numeración se basan en el número de símbolos usados para representar valores. El sistema que usas a diario es el decimal. En el decimal usas diez símbolos: 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 hacen referencia a sistemas de numeración diferentes.

Cuando se agotan los símbolos, pasas a la siguiente posición. En decimal, para representar uno más que 9 usas 10: una unidad de decenas y cero unidades. En otros sistemas es distinto. Por ejemplo, en binario solo existen 0 y 1, así que cuando se acaban los símbolos avanzas de posición. Así contarías en binario: 0, 1, 10, 11, 100, 101, etc.

Veamos algunos de estos sistemas con más detalle.

Convertir binario a decimal en Python

Los enteros binarios están representados en base dos. Es decir, solo se usan dos símbolos: 0 y 1. Al contar desde cero en binario te quedas sin símbolos rápidamente: 0, 1, ¿y ahora?

No existe el dígito 2 en binario. En su lugar, usas combinaciones de 1 y 0. En binario, 1000 equivale a 8 en decimal. En binario se usan potencias de dos, así que 8 es básicamente: (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0)) = 8. La posición de los 1 y 0 define la potencia a la que se eleva el 2.

Veámoslo con un ejemplo más complejo:

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 usar la función bin() para convertir de decimal a su valor binario correspondiente.

De forma similar, usa int() para convertir de binario a decimal. int() recibe como segundo argumento la base del número a convertir, que en binario es 2.

a = 79

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

0b1001111
79

Convertir octal a decimal en Python

Octal es otro sistema con menos símbolos que el decimal. Es base ocho, por lo que usa 0, 1, 2, 3, 4, 5, 6 y 7. Después del 7 viene el 10, ya que el 8 no existe.

Igual que en binario usabas potencias de dos, aquí usarás potencias de ocho.

En el sistema octal, 10 equivale a 8 en decimal. Desglose: (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 usar oct() para convertir de decimal a su valor octal. Alternativamente, también puedes usar int() con la base 8.

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

Hexadecimal es un sistema en base 16. A diferencia de binario y octal, usa seis símbolos adicionales más allá de los números del sistema decimal.

¿Qué viene después del 9?

Cuando hacen falta símbolos adicionales, se usan letras. En hexadecimal, la lista completa es 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E y F.

Usando el mismo ejemplo de antes:

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

En Python, puedes usar hex() para convertir de decimal a su valor hexadecimal, o int() con base 16 para el sistema hexadecimal.

a = 79

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

0x4f
79

Convertir Unicode a carácter

Python chr() convierte enteros Unicode en una cadena. Unicode es un estándar universal de codificación de caracteres para mostrar textos de distintos idiomas.

Hemos proporcionado varios enteros Unicode a la función chr() para mostrar "DATACAMP". También puedes usar ord() para convertir un solo carácter a 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

Resumen: conversiones entre sistemas numéricos en Python

¡Lo has conseguido!

¡Enhorabuena! Has aprendido a realizar conversiones de tipos de datos en Python, principalmente usando métodos incorporados. Esto te ayudará a trabajar con distintos tipos de datos y te dará más flexibilidad al programar.

Tenemos un excelente curso de Intermediate Python for Data Science donde aprenderás a representar datos con matplotlib y a trabajar con diccionarios y el famoso DataFrame de pandas. También verás cómo controlar el flujo de tu programa con bucles. Al final del curso hay un caso práctico para aplicar todo lo aprendido y poner tus conocimientos en acción.