Tipos de datos

Python tiene varios tipos de datos integrados. A continuación, veremos los más usados: números, cadenas, listas, tuplas y diccionarios.

1Tipos numéricos¶

int

Números enteros positivos o negativos, de cualquier tamaño. Los enteros se representan en memoria como una secuencia de bits, limitados por la memoria disponible

float

Números con parte decimal, representados en memoria como un conjunto de bits en punto flotante

complex

Números complejos, representados en memoria como dos números de punto flotante

1.1Ejemplos¶

a = 5  # int
b = 3.14  # float
c = 2 + 3j  # complex

Existen varias maneras de representar o crear números complejos

import math

z1 = math.sqrt(-1)  # Número complejo (0+j)

z2 = complex(0, 1)  # También se puede crear un número complejo directamente

z3 = 1j  # Representación alternativa de un número complejo

1.2Operaciones comunes¶

x = 10 + 5
y = 10 / 3  # división real
u = 10 // 3  # división entera
w = 2**3  # potencia
v = 10 % 3  # módulo

1.3Conversión de tipos¶

En Python los tipos numéricos se pueden convertir entre sí, ya sea de forma explícita o implícita.

float(5)

int(3.7)

x = 10 + 5.5

x

Un operador útil para verificar el tipo de una variable es type():

y = 10 + (2 - 3j)

type(y)

Es importante no confundir el tipado dinámico de Python con un tipado débil. Aunque el tipo de una variable se determina en tiempo de ejecución, Python es un lenguaje fuertemente tipado, lo que significa que las operaciones entre tipos incompatibles generarán un error.

x = 5 + "10"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 1
----> 1 x = 5 + "10"

TypeError: unsupported operand type(s) for +: 'int' and 'str'

2Cadenas de caracteres (str)¶

Una cadena es una secuencia inmutable de caracteres.

Un objeto inmutable es aquel cuyo contenido no puede ser modificado una vez creado. En el caso de las cadenas, esto significa que no se pueden cambiar los caracteres individuales de una cadena después de su creación.

mensaje = "Hola, mundo"
mensaje[0] = "h"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[6], line 2
      1 mensaje = "Hola, mundo"
----> 2 mensaje[0] = "h"

TypeError: 'str' object does not support item assignment

Si quiero modificar una cadena, debo crear una nueva cadena con el contenido deseado:

mensaje = "Hola, mundo"
mensaje = "h" + mensaje[1:]

mensaje

En la segunda línea se crea una nueva cadena con el contenido deseado y se asigna nuevamente a la variable mensaje, lo que da la sensación de que se ha modificado la cadena original, pero en realidad se ha creado una nueva cadena, y el contenido original de mensaje se ha perdido.

2.1Indexado y slicing¶

Las cadenas de caracteres están indexadas, es decir, que se puede manipular cada carácter por su posición. El primer carácter tiene índice 0, el segundo 1, y así sucesivamente. También se pueden usar índices negativos para acceder a los caracteres desde el final de la cadena, y tajadas o slicing para obtener subcadenas. En las tajadas, el primer parámetro es el índice inicial y el segundo es el índice final (sin incluir), similar a Go.

nombre = "Python"

nombre[0]

nombre = "Python"

nombre[-1]

nombre = "Python"

nombre[1:4]

nombre = "Python"

nombre[:2]

nombre = "Python"

nombre[2:]

nombre = "Python"

nombre[-3:]

Las tajadas o slices en Python tienen un tercer parámetro opcional que indica el paso entre los índices. Por ejemplo, nombre[::2] devuelve cada segundo carácter de la cadena.

nombre = "Python"

nombre[::2]

nombre = "Python"

nombre[::-1]

2.2Métodos útiles para manipular cadenas¶

texto = "Hola mundo"

texto.upper()

texto = "Hola mundo"

texto.lower()

texto = "Hola mundo"

texto.replace("mundo", "Python")

texto = "Hola mundo"

texto.split()

texto = "Hola mundo"

"Python" in texto

texto = "Hola mundo"

len(texto)

2.3Concatenación¶

Las cadenas se pueden concatenar usando el operador + o multiplicar por un número entero para repetirlas.

saludo = "Hola " + "mundo"

saludo

saludo = "Hola mundo"

saludo * 3

saludo = "Hola mundo"

(saludo + ". ") * 3

2.4Iteración sobre cadenas de caracteres¶

Las cadenas de caracteres son iterables, lo que significa que se pueden recorrer carácter por carácter usando un bucle for.

for caracter in "Python":
    print(caracter)

P
y
t
h
o
n

2.5Formateo de cadenas¶

El formateo de cadenas permite insertar valores en una cadena de texto de manera más legible y flexible. Hay varias formas de hacerlo:

• Usando el método format()

nombre = "Juan"
edad = 30

"Hola, mi nombre es {} y tengo {} años.".format(nombre, edad)

• Usando f-strings (Python 3.6+)

nombre = "Ana"
edad = 32

f"Hola, mi nombre es {nombre} y tengo {edad} años."

La letra f antes de la cadena indica que es una f-string, lo que permite insertar variables directamente dentro de llaves {}.

• Usando el operador % (menos recomendado)

nombre = "Eva"
edad = 28

"Hola, mi nombre es %s y tengo %d años." % (nombre, edad)

El carácter % se usa para formatear cadenas, donde %s es un marcador de posición para una cadena y %d para un número entero, pero es menos legible y flexible que las otras opciones.

El carácter de escape \ se utiliza para insertar caracteres especiales en una cadena, como comillas, saltos de línea o tabulaciones.

mensaje = "Hola, \"mundo\".\n¿Cómo estás?"

mensaje

\n inserta un salto de línea, y \" permite incluir comillas dobles dentro de una cadena delimitada por comillas dobles.

Otra forma de usar comillas dobles en una cadena es usar comillas simples para delimitar la cadena:

mensaje = 'Hola, "mundo".\n¿Cómo estás?'

mensaje

mensaje = "Hola, \tmundo."

mensaje

3Listas (list)¶

Las listas son colecciones ordenadas, polimórficas y mutables de elementos.

Ordenadas

Los elementos de una lista tienen un orden definido, dado por su posición.

Polimórficas

Las listas pueden contener elementos de diferentes tipos, como enteros, cadenas, flotantes, etc.

Mutables

Los elementos de una lista pueden ser modificados, añadidos o eliminados después de su creación.

3.1Operaciones básicas¶

numeros = [1, 2, 3, 4]
numeros.append(5)

numeros

numeros = [1, 2, 3, 4]

numeros[0]

numeros = [1, 2, 3, 4]

numeros[1:3]

numeros = [1, 2, 3, 4]
numeros.remove(3)

numeros

mezcla = [1, "dos", 3.0, True]
mezcla[0] = "uno"

mezcla

numeros = [1, 2, 3, 4]
mezcla = [1, "dos", 3.0, True]

mezcla + numeros

numeros = [1, 2, 3, 4]

numeros * 2

La lista vacía se puede definir con corchetes vacíos [] o con la función list():

lista_vacia = []

lista_vacia

lista_vacia2 = list()

lista_vacia2

3.2Iteración sobre listas¶

numeros = [1, 2, 3, 4]

for n in numeros:
    print(n)

1
2
3
4

4Tuplas (tuple)¶

Son similares a las listas, ordenadas y polimórficas, pero inmutables, es decir, una vez creada no se puede modificar.

coordenadas = (10.0, 20.5, 1)

type(coordenadas)

Se definen con paréntesis y pueden contener diferentes tipos de datos, mientras que las listas se definen con corchetes.

4.1Acceso¶

coordenadas = (10.0, 20.5, 1)

coordenadas[0]

coordenadas = (10.0, 20.5, 1)

coordenadas[-1]

coordenadas = (10.0, 20.5, 1)

coordenadas[1:]

4.2Ventajas¶

• Más livianas que las listas.

• Se pueden usar como claves en diccionarios y se pueden empaquetar varios valores en una sola variable, lo que permite que las funciones puedan devolver múltiples valores, o usar tuplas como claves en diccionarios, entre otros usos.

La forma de empaquetar y desempaquetar tuplas es similar a las listas:

coordenadas = (10.0, 20.5, 1)
a, b, c = coordenadas

print("a =", a)
print("b =", b)
print("c =", c)

a = 10.0
b = 20.5
c = 1

a = 10.0
b = 20.5
c = 1

(a, b, c)

La tupla vacía se puede definir con paréntesis vacíos () o con la función tuple():

tupla_vacia = ()

tupla_vacia

tupla_vacia2 = tuple()

tupla_vacia2

4.3Anidamiento¶

Tanto las listas como las tuplas se pueden anidar, es decir, se pueden incluir dentro de otras listas o tuplas.

tupla_anidada = (1, 2, (3, 4), [5, 6])

for elemento in tupla_anidada:
    print(elemento)

1
2
(3, 4)
[5, 6]

tupla_anidada = (1, 2, (3, 4), [5, 6])

tupla_anidada[3][0]

tupla_anidada = (1, 2, (3, 4), [5, 6])
tupla_anidada[3].append(7)

tupla_anidada

La tupla no se modificó, sigue teniendo 4 elementos, pero la lista que está adentro de la tupla sí se puede modificar.

Las tuplas se pueden iterar de la misma manera que las listas.

5Diccionarios (dict)¶

Almacenan pares clave-valor. Las claves deben ser únicas e inmutables (por ejemplo, strings, números o tuplas).

d = dict()
d["clave1"] = "valor1"
d[25] = "valor2"
d[(1, 2)] = "valor3"

d

También se pueden crear diccionarios, de forma explícita, usando llaves {}:

persona = {"nombre": "Ana", "edad": 30}

persona

5.1Acceso y modificación¶

Los diccionarios permiten acceder a los valores mediante sus claves. También se pueden modificar, añadir o eliminar pares clave-valor. La sintaxis es similar a las listas o tuplas, pero en lugar de índices, se utilizan claves.

persona = {"nombre": "Ana", "edad": 30}

persona["nombre"]

persona = {"nombre": "Ana", "edad": 30}
persona["edad"] = 31

persona

persona = {"nombre": "Ana", "edad": 30}
persona["email"] = "ana@mail.com"

persona

persona = {"nombre": "Ana", "edad": 30, "email": "ana@mail.com"}
del persona["edad"]

persona

5.2Métodos útiles¶

persona = {"nombre": "Ana", "email": "ana@mail.com"}

persona.keys()

persona = {"nombre": "Ana", "email": "ana@mail.com"}

persona.values()

persona = {"nombre": "Ana", "email": "ana@mail.com"}

persona.items()

Un método muy útil es get(), que permite acceder a un valor sin generar un error si la clave no existe:

persona = {"nombre": "Ana", "email": "ana@mail.com"}

print(persona.get("nombre", "No encontrado"))
print(persona.get("edad", "No encontrado"))

Ana
No encontrado

setdefault() es otro método que permite acceder a un valor y, si la clave no existe, añadirla con un valor por defecto:

persona = {"nombre": "Ana", "email": "ana@mail.com"}

print(persona.setdefault("edad", 30))

persona

30

persona = {"nombre": "Ana", "edad": 30, "email": "ana@mail.com"}
lista = persona.setdefault("telefonos", [])
lista.append("123-456-7890")

persona

5.3Iteración sobre diccionarios¶

Los diccionarios se pueden iterar para acceder a las claves y valores.

for clave, valor in persona.items():
    print(f"{clave}: {valor}")

nombre: Ana
edad: 30
email: ana@mail.com
telefonos: ['123-456-7890']

6Conjuntos (set)¶

Los conjuntos son colecciones no ordenadas de elementos únicos. No permiten duplicados y no tienen un índice asociado a sus elementos.

conjunto = {1, 2, 3, 4, 5}

conjunto

El conjunto vacío se puede definir con la función set():

conjunto_vacio = set()

conjunto_vacio

conjunto_vacio2 = {}

type(conjunto_vacio2)

Para agregar un elemento a un conjunto, se utiliza el método add():

conjunto = {1, 2, 3, 4, 5}
conjunto.add(6)

conjunto

Si intentamos agregar un elemento que ya existe, no se producirá un error, pero el conjunto no cambiará:

conjunto = {1, 2, 3, 4, 5, 6}
conjunto.add(6)

conjunto

Se puede crear un conjunto a partir de una lista o tupla usando la función set():

lista = [1, 2, 3, 4, 5, 5]
conjunto_desde_lista = set(lista)

conjunto_desde_lista

Para eliminar un elemento de un conjunto, se utiliza el método remove() o discard(). La diferencia es que remove() genera un error si el elemento no existe, mientras que discard() no lo hace:

conjunto = {1, 2, 3, 4, 5, 6}
conjunto.remove(7)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[72], line 2
      1 conjunto = {1, 2, 3, 4, 5, 6}
----> 2 conjunto.remove(7)

KeyError: 7

conjunto = {1, 2, 3, 4, 5, 6}
conjunto.discard(7)  # No genera error

conjunto

El operador in se puede usar para verificar si un elemento está en un conjunto:

conjunto = {1, 2, 3, 4, 5, 6}

3 in conjunto

No se puede acceder a los elementos de un conjunto por índice, ya que no están ordenados. Sin embargo, se pueden iterar:

conjunto = {1, 2, 3, 4, 5, 6}

for elemento in conjunto:
    print(elemento)

1
2
3
4
5
6

Los conjuntos son útiles para realizar operaciones matemáticas como unión, intersección, diferencia y diferencia simétrica.

6.1Operaciones con conjuntos¶

# Unión
conjunto1 = {1, 2, 3, 4, 5, 6}
conjunto2 = {4, 5, 6, 7}

print(conjunto1, " union ", conjunto2, "=", conjunto1 | conjunto2)

{1, 2, 3, 4, 5, 6}  union  {4, 5, 6, 7} = {1, 2, 3, 4, 5, 6, 7}

# Intersección
conjunto1 = {1, 2, 3, 4, 5, 6}
conjunto2 = {4, 5, 6, 7}

print(conjunto1, " interseccion ", conjunto2, "=", conjunto1 & conjunto2)

{1, 2, 3, 4, 5, 6}  interseccion  {4, 5, 6, 7} = {4, 5, 6}

# Diferencia
conjunto1 = {1, 2, 3, 4, 5, 6}
conjunto2 = {4, 5, 6, 7}

print(conjunto1, " diferencia ", conjunto2, "=", conjunto1 - conjunto2)
print(conjunto2, " diferencia ", conjunto1, "=", conjunto2 - conjunto1)

{1, 2, 3, 4, 5, 6}  diferencia  {4, 5, 6, 7} = {1, 2, 3}
{4, 5, 6, 7}  diferencia  {1, 2, 3, 4, 5, 6} = {7}

# Diferencia simétrica
conjunto1 = {1, 2, 3, 4, 5, 6}
conjunto2 = {4, 5, 6, 7}

print(f"{conjunto1} diferencia simetrica {conjunto2} = "
      f"{conjunto1 ^ conjunto2}")

print(f"{conjunto2} diferencia simetrica {conjunto1} = "
      f"{conjunto2 ^ conjunto1}")

{1, 2, 3, 4, 5, 6} diferencia simetrica {4, 5, 6, 7} = {1, 2, 3, 7}
{4, 5, 6, 7} diferencia simetrica {1, 2, 3, 4, 5, 6} = {1, 2, 3, 7}

conjunto = {1, 2, 3, 4, 5, 6}

es_subconjunto = {1, 2} <= conjunto
print("{1, 2} es subconjunto de", conjunto, "?: ", es_subconjunto)

{1, 2} es subconjunto de {1, 2, 3, 4, 5, 6} ?:  True

conjunto = {1, 2, 3, 4, 5, 6}

es_superconjunto = {1, 2} >= conjunto
print("{1, 2} es superconjunto de", conjunto, "?: ", es_superconjunto)

{1, 2} es superconjunto de {1, 2, 3, 4, 5, 6} ?:  False

Existen otros tipos de conjuntos que permiten almacenar elementos únicos, pero que una vez creados no se pueden modificar, se llaman conjuntos inmutables o frozensets. Se crean usando la función frozenset():

conjunto_inmutable = frozenset([1, 2, 3, 4, 5])

conjunto_inmutable

Los conjuntos inmutables son útiles cuando se necesita un conjunto que no cambie a lo largo del tiempo, por ejemplo, como claves en un diccionario o elementos en otro conjunto.

Los métodos de los conjuntos inmutables son limitados, ya que no se pueden modificar. Por ejemplo, no se pueden usar add() o remove(), pero sí se pueden usar operaciones como unión, intersección y diferencia.

conjunto_inmutable = frozenset([1, 2, 3, 4, 5])
conjunto2 = frozenset([4, 5, 6, 7])

print(conjunto_inmutable | conjunto2)  # Unión
print(conjunto_inmutable & conjunto2)  # Intersección
print(conjunto_inmutable - conjunto2)  # Diferencia
print(conjunto2 - conjunto_inmutable)  # Diferencia
print(conjunto_inmutable ^ conjunto2)  # Diferencia simétrica

frozenset({1, 2, 3, 4, 5, 6, 7})
frozenset({4, 5})
frozenset({1, 2, 3})
frozenset({6, 7})
frozenset({1, 2, 3, 6, 7})

El resultado de estas operaciones es un nuevo conjunto inmutable, ya que el conjunto original no se modifica.

7Generación de colecciones de datos por comprensión (comprehension)¶

Las comprensiones de listas, tuplas y diccionarios son una forma concisa de crear colecciones en Python. Permiten aplicar una expresión a cada elemento de una colección existente, filtrando o transformando los elementos según sea necesario.

numeros = [x for x in range(1, 6)]

[x**2 for x in numeros]

Si en lugar de corchetes [] se usan paréntesis (), se crea un generador, no una tupla. Para obtener una tupla, debemos usar el constructor tuple():

numeros = tuple(x for x in range(1, 6))

tuple(x**2 for x in numeros)

Si se usan llaves {}, se crea un conjunto o un diccionario, dependiendo de si se especifica una clave o un par clave-valor:

numeros = {x for x in range(1, 6)}

{x**2 for x in numeros}

numeros = {"uno": 1, "dos": 2, "tres": 3}

{clave: valor**2 for clave, valor in numeros.items()}

diccionario = {"nombre": "Ana", "edad": 30, "email": "ana@example.com"}

[(clave, valor) for clave, valor in diccionario.items()]

La comprensión es una característica funcional de Python muy poderosa.

8Recursos para profundizar¶

• Tutorial de Python - Estructuras de datos

• setdefault() (KeepCoding)

• Comprensiones de listas (Python Docs)

• Comprensión de listas (Hektor Profe)

• Operadores Encadenados (Hektor Profe)

• Intérprete Python, para entender como funciona