Estructuras de Datos en Python
Introducción
Las estructuras de datos en Python son contenedores que permiten organizar, almacenar y manipular información de manera eficiente. Estas estructuras facilitan el manejo de colecciones de elementos (como listas de números, cadenas o diccionarios de datos).
A continuación se presentan las principales estructuras de datos en Python, junto con su descripción:
Listas (list):Tuplas (tuple):Diccionarios (dict):Conjuntos (set):Cadenas de texto (str):
Listas (list)
- Son colecciones ordenadas (mantienen una posición fija o índice y conservan la posición en el que fueron agregados) y mutables (pueden modificarse después de su creación).
- Permiten almacenar diferentes tipos de datos.
- Se definen con corchetes
[ ]. - Ejemplo:
Sintaxis básica:
numeros = [10, 20, 30, 40] nombres = ["Juan", "María", "Pedro"] - Características:
- Mantienen el orden de los elementos.
- Permiten duplicados.
- Soportan operaciones como agregar, eliminar o modificar elementos.
- Funciones para listas:
- Crear y conocer listas:
# Creación de una lista, uso de corchetes ([ ]) lst = [1, 2, 3] # list(iterable): Permite convertir un iterable t = (1, 2, 3) # tupla lst = list(t) # [1, 2, 3] # len(lista): Función que devuelve el número de elementos de la lista. nums = [5, 10, 15] print(len(nums)) # 3 - Métodos para agregar elementos a listas:
# lista.append(x): Agrega el elemento x al final de la lista. fruits = ['apple', 'banana'] fruits.append('orange') # ['apple', 'banana', 'orange'] # lista.extend(iterable): Agrega todos los elementos del iterable al final de la lista. nums = [1, 2] nums.extend([3, 4, 5]) # [1, 2, 3, 4, 5] # lista.insert(i, x): Inserta el elemento x en la posición i, desplazando los elementos posteriores. vals = [10, 30] vals.insert(1, 20) # [10, 20, 30] - Métodos para consultar / encontrar elementos en una Lista:
# lista.index(x): Devuelve el índice (posición) de la primera # aparición de x en la lista (y da error si no está). items = ['a', 'b', 'c'] print(items.index('b')) # 1 # lista.count(x): Cuenta cuántas veces aparece x en la lista. numbers = [1,2,2,3] print(numbers.count(2)) # 2 - Métodos para eliminar / vaciar elementos en una Lista:
# lista.remove(x): Elimina la primera aparición de x en la lista. Da error si x no está. letters = ['a','b','c','b'] letters.remove('b') # ['a','c','b'] # lista.pop(i): Elimina y devuelve el elemento en el índice i. Si no se indica i, elimina el último elemento. stack = [10,20,30] x = stack.pop() # x = 30, stack = [10,20] lista.clear(): Elimina todos los elementos de la lista, dejándola vacía. data = [1,2,3] data.clear() # [] - Métodos para reordenar / copiar en una Lista:
# lista.sort(): Ordena los elementos de la lista in-place (modifica la lista) en orden ascendente por defecto. arr = [3, 1, 2] arr.sort() # [1,2,3] # lista.reverse(): Invierte el orden de los elementos en la lista (in-place). seq = [1,2,3] seq.reverse() # [3,2,1] # lista.copy(): Devuelve una copia superficial (“shallow copy”) de la lista. orig = [1,2,3] copy_lst = orig.copy()
- Crear y conocer listas:
- Algunos ejemplos de uso:
# Crear una lista mi_lista = [5, 10, 15] # Agregar mi_lista.append(20) # [5,10,15,20] mi_lista.extend([25,30]) # [5,10,15,20,25,30] mi_lista.insert(2, 12) # [5,10,12,15,20,25,30] # Consultar print(mi_lista.index(15)) # posición de 15 → 3 print(mi_lista.count(10)) # cuántas veces aparece 10 → 1 # Eliminar mi_lista.remove(12) # elimina el elemento 12 ult = mi_lista.pop() # elimina y retorna el último → 30 mi_lista.clear() # queda [] # Reordenar / copiar otra = [3,1,2] otra.sort() # [1,2,3] otra.reverse() # [3,2,1] copia = otra.copy() # copia de la lista
Tuplas (tuple)
- Son colecciones ordenadas pero inmutables (no se pueden modificar después de creadas).
- Se definen con paréntesis
( ). - Ejemplo:
Sintaxis básica:
coordenadas = (4, 5) colores = ("rojo", "verde", "azul") - Características:
- Más rápidas que las listas.
- Útiles para datos que no deben cambiar (por ejemplo, posiciones o configuraciones fijas).
- Funciones para Tuplas:
- Crear y conocer tuplas:
# tuple(iterable): Función que convierte un iterable (por ejemplo una lista, una cadena de caracteres) en una tupla. lista = [1, 2, 3] tup = tuple(lista) # (1, 2, 3) # Uso de paréntesis () para definir una tupla literal. t = (4, 5, 6) # Función que devuelve el número de elementos de la tupla. len(tupla) t = (10, 20, 30) print(len(t)) # 3 - Inmutabilidad: lo que NO se puede hacer: Dado que una tupla es inmutable, una vez creada no se
puede modificar (no se pueden añadir, eliminar o cambiar elementos).
t = (1, 2, 3) t[0] = 5 # Produce error: 'tuple' object does not support item assignment - Métodos para consultar / encontrar elementos:
# tupla.count(x): Devuelve la cantidad de veces que aparece x en la tupla. t = (1, 2, 2, 3, 2) print(t.count(2)) # 3 # tupla.index(x[, start[, end]]): Devuelve el índice de la primera aparición de x en la tupla (puede opcionalmente buscar desde start hasta end). Si x no está, lanza ValueError. t = (0, 1, 2, 3, 2, 3) print(t.index(3)) # 3 print(t.index(2, 3)) # 4 - Operaciones comunes con tuplas: Además de los métodos, hay funciones y operadores que funcionan
con tuplas (y en muchos casos con otros tipos de secuencias).
# in: Verificar si un valor está en la tupla. t = ('apple', 'banana', 'cherry') print('banana' in t) # True # Indexación y slicing (rebanado): t = (10, 20, 30, 40) print(t[1]) # 20 print(t[1:3]) # (20, 30) # Concatenación (+): Combina dos o más tuplas en una nueva tupla. t1 = (1, 2) t2 = (3, 4) t3 = t1 + t2 # (1, 2, 3, 4) # Repetición (*): Repite una tupla un número de veces. t = (5,) t2 = t * 3 # (5, 5, 5) # Funciones como max(), min(), sum() (para tuplas de valores numéricos) o sorted() (que devuelve una lista ordenada de los elementos) también se pueden usar. t = (4, 1, 7, 3) print(max(t)) # 7 print(min(t)) # 1 print(sum(t)) # 15 print(sorted(t)) # [1, 3, 4, 7] — nota: devuelve lista, no tupla
Algunos ejemplos de uso:
# Crear una tupla mi_tupla = ('python', 'java', 'c#') # Consultar print(mi_tupla.index('java')) # 1 print(mi_tupla.count('python')) # 1 # Operaciones if 'c#' in mi_tupla: print("c# está en la tupla") otra = (100, 200) combinada = mi_tupla + otra # ('python','java','c#',100,200) repetida = (0,)*4 # (0,0,0,0) # Funciones numeros = (10, 20, 30, 40) print(len(numeros)) # 4 print(max(numeros)) # 40 print(min(numeros)) # 10 print(sum(numeros)) # 100 sorted(numeros) # [10,20,30,40] - Crear y conocer tuplas:
Diccionarios (dict)
- Son colecciones no ordenadas de pares clave–valor.
- Se definen con llaves
{ }. - Ejemplo:
Sintaxis básica:
persona = {"nombre": "Eduardo", "edad": 35, "ciudad": "Bogotá"} - Características:
- Se accede a los datos mediante la clave.
- Muy usados para representar objetos o registros de datos.
- Permiten duplicados.
- Funciones para Diccionarios:
- Crear y conocer diccionarios en Diccionarios:
# dict(iterable): Permite crear un diccionario a partir de un iterable de pares clave-valor o mediante el constructor dict(). d = dict(a = 1, b = 2) # {'a': 1, 'b': 2} # len(diccionario): Función que devuelve el número de pares clave-valor en el diccionario. d = {'x': 10, 'y': 20} print(len(d)) # 2 - Métodos para agregar o actualizar elementos en Diccionarios:
# diccionario[key] = value: Añade una nueva clave con su valor o actualiza el valor si la clave ya existe. config = {'color': 'green', 'width': 42} config['height'] = 100 # Añade config['width'] = 50 # Actualiza # diccionario.update(other_dictionary_or_iterable): Añade múltiples pares clave-valor de otro diccionario o iterable, # actualizando los existentes si las claves coinciden. d1 = {'a': 1, 'b': 2} d2 = {'b': 3, 'c': 4} d1.update(d2) # d1 ahora es {'a':1, 'b':3, 'c':4} - Métodos para consultar / encontrar elementos en Diccionarios:
# diccionario.get(key, default=None): Devuelve el valor asociado a key; si la clave no existe, devuelve default (por defecto None). # Evita que se produzca un KeyError. d = {'name': 'Alice', 'age': 30} print(d.get('age')) # 30 print(d.get('gender', 'N/A')) # 'N/A' # diccionario.keys(): Devuelve un objeto “vista” de todas las claves del diccionario. d = {'x':10, 'y':20} print(d.values()) # dict_values([10,20]) # diccionario.items(): Devuelve un objeto vista de pares (clave, valor). Muy útil para iterar sobre ambos. d = {'x':10, 'y':20} for key, value in d.items(): print(key, value) # x 10 y y 20 - Métodos para eliminar / vaciar elementos en Diccionarios:
# diccionario.pop(key, default): Elimina la clave key y devuelve su valor; si no existe, devuelve default si se especifica, o lanza KeyError. d = {'a':1, 'b':2} val = d.pop('a') # val=1, d={'b':2} # diccionario.popitem(): Elimina y devuelve el último par clave-valor insertado (desde Python 3.7 las inserciones tienen un orden definido). d = {'a':1, 'b':2} last = d.popitem() # e.g. ('b',2) # diccionario.clear(): Elimina todos los elementos del diccionario, dejándolo vacío. d = {'a':1, 'b':2} d.clear() # {} - Métodos para copia / estructuras en Diccionarios:
# diccionario.copy(): Devuelve una copia superficial (“shallow copy”) del diccionario. orig = {'x':10, 'y':20} copy_dic = orig.copy() # dict.fromkeys(iterable_of_keys, value=None): Crea un nuevo diccionario con las claves provenientes de iterable_of_keys y asigna a todas el valor value. keys = ['a','b','c'] new_dic = dict.fromkeys(keys, 0) # {'a':0, 'b':0, 'c':0}
- Crear y conocer diccionarios en Diccionarios:
- Algunos ejemplos de uso:
# Crear un diccionario mi_dic = {'name':'Eduardo', 'role':'Ingeniero', 'city':'Bogotá'} # Agregar/actualizar mi_dic['project'] = 'Telecom' mi_dic.update({'city':'Bogotá D.C.', 'experience':5}) # Consultar print(mi_dic.get('name')) # 'Eduardo' print(mi_dic.keys()) # todas las claves print(mi_dic.items()) # pares (clave, valor) # Eliminar mi_dic.pop('experience') # elimina clave 'experience' mi_dic.popitem() # elimina el último par insertado mi_dic.clear() # deja el diccionario vacío {} # Copiar / estructuras otra = mi_dic.copy() base = dict.fromkeys(['a','b','c'], None)
Conjuntos (set)
- Son colecciones no ordenadas de elementos únicos (no se repiten).
- Se definen con llaves
{ }, igual que los diccionarios, pero sin pares clave–valor. - Ejemplo:
Sintaxis básica:
frutas = {"manzana", "pera", "uva"} numeros = {1, 2, 3, 4, 5} - Características:
- No permiten duplicados.
- Soportan operaciones matemáticas como unión, intersección y diferencia.
-
Funciones para Conjuntos:
- Crear y conocer conjuntos:
# set(iterable): Permite crear un conjunto a partir de un iterable (lista, tupla, cadena, etc.). t = [1, 2, 2, 3] conj = set(t) # {1, 2, 3} # {…}: Literal de conjunto con elementos explícitos. conj2 = {'apple', 'banana', 'cherry'} # len(conj): Función que devuelve la cantidad de elementos del conjunto (la “cardinalidad”). - Métodos para agregar y eliminar elementos en Conjuntos:
# conj.add(x): Agrega el elemento x al conjunto, si no estaba ya. conj.add(x): Agrega el elemento x al conjunto, si no estaba ya. # conj.update(iterable): Agrega todos los elementos del iterable al conjunto. s.update([5,6,2]) # {1,2,3,4,5,6} # conj.remove(x): Elimina el elemento x. Si no existe, genera un KeyError. s.remove(2) # elimina 2 # conj.discard(x): Elimina el elemento x si existe; no genera error si no existe s.discard(10) # si 10 no está, no pasa nada # conj.pop(): Elimina y retorna un elemento arbitrario del conjunto. Como el conjunto es desordenado, no es “el primero” o “el último” según posición. x = s.pop() # s se modifica, x puede ser cualquier elemento. # conj.clear(): Elimina todos los elementos del conjunto, dejándolo vacío. s.clear() # s = set() - Métodos para consultar relaciones entre conjuntos
# conj.issubset(other): Devuelve True si todos los elementos de conj están en other. {1,2}.issubset({1,2,3}) # True # conj.issuperset(other): Devuelve True si el conjunto conj contiene todos los elementos de other. {1,2,3}.issuperset({1,2}) # True # conj.isdisjoint(other): Devuelve True si conj y other no tienen elementos en común. {1,2}.isdisjoint({3,4}) # True - Métodos / operaciones para combinación de conjuntos
# conj.union(other, ...): Devuelve un nuevo conjunto con todos los elementos de conj y de los otros. (También se puede usar el operador |). a = {1,2,3} b = {3,4,5} c = a.union(b) # {1,2,3,4,5} # conj.intersection(other, …): Devuelve el nuevo conjunto que contiene solo los elementos presentes en ambos conjuntos. (Operador &). a.intersection(b) # {3} # conj.difference(other, …): Devuelve los elementos de conj que no están en other. (Operador -). a.difference(b) # {1,2} # conj.symmetric_difference(other): Devuelve el conjunto de elementos que están en uno u otro conjunto, pero no en ambos. (Operador ^) a.symmetric_difference(b) # {1,2,4,5} # Métodos “_update” para modificar el conjunto existente en lugar de devolver uno nuevo: conj.difference_update(other) conj.intersection_update(other) conj.symmetric_difference_update(other) conj.update(other) (ya indicado antes) - Algunos ejemplos de uso de Conjuntos:
# Crear un conjunto mi_conj = set([5, 10, 15, 10]) # {5,10,15} # Agregar mi_conj.add(20) # {5,10,15,20} mi_conj.update([25,30,10]) # {5,10,15,20,25,30} # Consultar relaciones print(mi_conj.issubset({5,10,15,20,25,30,40})) # True print(mi_conj.isdisjoint({100,101})) # True # Operaciones de conjuntos a = {1,2,3} b = {2,3,4} print(a.union(b)) # {1,2,3,4} print(a.intersection(b)) # {2,3} print(a.difference(b)) # {1} print(a.symmetric_difference(b)) # {1,4} # Eliminar / vaciar mi_conj.discard(10) # elimina 10 si estaba mi_conj.remove(25) # elimina 25, error si no está x = mi_conj.pop() # elimina y retorna un elemento arbitrario mi_conj.clear() # conjunto queda vacío - Crear y conocer conjuntos:
Cadenas de texto (str)
- Aunque no siempre se consideran una estructura de datos compleja, las cadenas son secuencias inmutables de caracteres.
- Se definen con comillas simples o dobles.
- Ejemplo:
Sintaxis básica:
saludo = "Hola, mundo" - Características:
- Se accede a los datos mediante la clave.
- Muy usados para representar objetos o registros de datos.
- Permiten duplicados.
- Funciones para Cadenas de Texto:
- Crear y conocer cadenas de texto:
# str(obj): Convierte el objeto en su representación como cadena de texto. x = 123 s = str(x) # x = "123" # len(cadena): Devuelve el número de caracteres de la cadena (incluye espacios, signos). saludo = "Hola" print(len(saludo)) # 4 - Métodos para cambiar mayúsculas/minúsculas y título:
# cadena.lower(): Devuelve una nueva cadena con todos los caracteres alfabéticos en minúscula. texto = "PYTHON" print(texto.lower()) # "python" # cadena.upper(): Devuelve una nueva cadena con todos los caracteres alfabéticos en mayúscula. texto = "python" print(texto.upper()) # "PYTHON" # cadena.title(): Devuelve una cadena en “title case”: la primera letra de cada palabra en mayúscula, el resto en minúscula. frase = "hola mundo desde python" print(frase.title()) # "Hola Mundo Desde Python" # cadena.capitalize(): Devuelve la cadena con el primer carácter en mayúscula y el resto en minúscula. palabra = "hOLA" print(palabra.capitalize()) # "Hola" - Métodos para buscar, dividir, comprobar:
# cadena.count(subcadena): Cuenta cuántas veces aparece subcadena en la cadena. texto = "ababa" print(texto.count("ba")) # 2 # cadena.find(subcadena): Devuelve el índice de la primera aparición de subcadena, o -1 si no la encuentra. texto = "Hola mundo" print(texto.find("mundo")) # 5 # cadena.startswith(prefijo): Devuelve True si la cadena empieza por prefijo. texto = "Python es genial" print(texto.startswith("Python")) # True # cadena.endswith(sufijo): Devuelve True si la cadena termina con sufijo. archivo = "documento.pdf" print(archivo.endswith(".pdf")) # True # cadena.split(separador): Divide la cadena usando separador (o espacio por defecto) y devuelve una lista de sub-cadenas. lista = "uno,dos,tres".split(",") # ['uno', 'dos', 'tres'] # separador.join(iterable_de_cadenas): Une un iterable de cadenas en una sola, usando el string que invoca join como separador. palabras = ["Hola", "mundo"] - Métodos para eliminar espacios, prefijos, sufijos o cambiar:
# cadena.strip(): Devuelve una nueva cadena con los espacios (u otros caracteres especificados) eliminados al inicio y al final. s = " hola " print(s.strip()) # "hola" # cadena.lstrip() / cadena.rstrip(): Similar a strip(), pero solo a la izquierda (lstrip) o a la derecha (rstrip). s = "...hola..." print(s.rstrip(".")) # "...hola" # cadena.replace(viejo, nuevo): Devuelve una cadena en la que todas las apariciones de viejo se reemplazan por nuevo. s = "manzana manzana" print(s.replace("manzana", "pera")) # "pera pera" # cadena.removeprefix(prefijo) / cadena.removesuffix(sufijo): Métodos añadidos en Python 3.9+ que eliminan un prefijo o sufijo si está presente. codigo = "0xFFAA" print(codigo.removeprefix("0x")) # "FFAA" print(codigo.removeprefix("AA")) # "FF" - Métodos para formatear, justificar o modificar el “relleno”:
# cadena.format(...): Método para formatear cadenas con placeholders. Aunque hoy en día se recomienda el uso de f-strings, aún es útil. plantilla = "Hola {nombre}, tienes {n} mensajes" print(plantilla.format(nombre="Eduardo", n=5)) # cadena.center(width, fillchar=' '): Devuelve la cadena centrada dentro de un ancho width, rellenando con fillchar. s = "Hola" print(s.center(10, "-")) # "--Hola---" # cadena.zfill(width): Rellena la cadena por la izquierda con ceros hasta que tenga longitud width. numero = "42" print(numero.zfill(5)) # "00042" # cadena.ljust(width, fillchar=' ') / cadena.rjust(width, fillchar=' '): Son métodos de cadenas que ajustan el ancho de un texto añadiendo caracteres de relleno. # ljust() = left justify (justificar a la izquierda) - añade relleno a la derecha # rjust() = right justify (justificar a la derecha) - añade relleno a la izquierda texto = "Python" print(texto.ljust(10)) # 'Python ' (Python + 4 espacios a la derecha) print(texto.rjust(10, '-')) # '----Python' (4 guiones a la izquierda + Python)
- Crear y conocer cadenas de texto:
- Algunos ejemplos de uso con combinaciones:
texto = " Bienvenido al Curso de Python " # Eliminar espacios al inicio/final limpio = texto.strip() # Convertir a mayúsculas mayus = limpio.upper() # Reemplazar palabra nuevo = mayus.replace("PYTHON", "IA") # Dividir en palabras palabras = nuevo.split() # Unir con guiones resultado = "-".join(palabras) print(resultado) # Ejemplo salida: "BIENVENIDO-AL-CURSO-DE-IA"
Clasificación General de Estructuras de Datos en Python
| Tipo de estructura | Ordenada | Mutable | Sintaxis |
|---|---|---|---|
Lista (list) |
✔️ Sí | ✔️ Sí | [ ] |
Tupla (tuple) |
✔️ Sí | ❌ No | ( ) |
Diccionario (dict) |
❌ No | ✔️ Sí | {clave: valor} |
Conjunto (set) |
❌ No | ✔️ Sí | {elemento} |
Cadena (str) |
✔️ Sí | ❌ No | "texto" o 'texto' |