Tutorial de Estructuras de Datos en Python para Principiantes

 

Tutorial de Estructuras de Datos en Python para Principiantes

¡Hola! Te ayudo a crear un tutorial completo sobre estructuras de datos en Python. Este tutorial está diseñado específicamente para principiantes.

📚 Tabla de Contenidos

  1. Introducción a las Estructuras de Datos

  2. Listas

  3. Tuplas

  4. Diccionarios

  5. Conjuntos

  6. Pilas

  7. Colas

  8. Listas Enlazadas

  9. Árboles

  10. Ejercicios Prácticos

1. Introducción a las Estructuras de Datos <a name="introducción"></a>

Las estructuras de datos son formas de organizar y almacenar datos para que puedan ser utilizados eficientemente.

python
# Python tiene estructuras de datos incorporadas:
# - Listas: [1, 2, 3]
# - Tuplas: (1, 2, 3)
# - Diccionarios: {'a': 1, 'b': 2}
# - Conjuntos: {1, 2, 3}

2. Listas <a name="listas"></a>

Las listas son colecciones ordenadas y mutables.

python
# Crear una lista
frutas = ["manzana", "banana", "cereza"]
numeros = [1, 2, 3, 4, 5]

# Acceder a elementos
print(frutas[0])  # manzana
print(frutas[-1]) # cereza (último elemento)

# Modificar elementos
frutas[1] = "naranja"
print(frutas)  # ['manzana', 'naranja', 'cereza']

# Métodos útiles
frutas.append("uva")        # Agregar al final
frutas.insert(1, "mango")   # Insertar en posición
frutas.remove("manzana")    # Remover elemento
frutas.pop()                # Remover último elemento

# Slicing (rebanado)
sub_lista = numeros[1:4]    # [2, 3, 4]

3. Tuplas <a name="tuplas"></a>

Las tuplas son como listas pero inmutables (no se pueden modificar).

python
# Crear una tupla
coordenadas = (10, 20)
colores = ("rojo", "verde", "azul")

# Acceder a elementos
print(coordenadas[0])  # 10

# Las tuplas no se pueden modificar
# coordenadas[0] = 15  # Esto daría error

# Usos comunes: datos que no deben cambiar
punto = (x, y)
rgb = (255, 0, 0)

4. Diccionarios <a name="diccionarios"></a>

Los diccionarios almacenan pares clave-valor.

python
# Crear un diccionario
estudiante = {
    "nombre": "Ana",
    "edad": 20,
    "curso": "Python"
}

# Acceder a valores
print(estudiante["nombre"])  # Ana
print(estudiante.get("edad")) # 20

# Agregar o modificar
estudiante["nota"] = 95
estudiante["edad"] = 21

# Métodos útiles
claves = estudiante.keys()     # Todas las claves
valores = estudiante.values()  # Todos los valores
pares = estudiante.items()     # Todos los pares clave-valor

# Recorrer un diccionario
for clave, valor in estudiante.items():
    print(f"{clave}: {valor}")

5. Conjuntos <a name="conjuntos"></a>

Los conjuntos son colecciones no ordenadas de elementos únicos.

python
# Crear un conjunto
numeros = {1, 2, 3, 4, 5}
vocales = {'a', 'e', 'i', 'o', 'u'}

# Los conjuntos eliminan duplicados automáticamente
duplicados = {1, 2, 2, 3, 3, 3}
print(duplicados)  # {1, 2, 3}

# Operaciones de conjuntos
a = {1, 2, 3}
b = {3, 4, 5}

print(a.union(b))          # {1, 2, 3, 4, 5}
print(a.intersection(b))   # {3}
print(a.difference(b))     # {1, 2}

6. Pilas (Stacks) <a name="pilas"></a>

Las pilas siguen el principio LIFO (Last In, First Out).

python
# Implementación con lista
pila = []

# Apilar (push)
pila.append(1)
pila.append(2)
pila.append(3)

print(pila)  # [1, 2, 3]

# Desapilar (pop)
ultimo = pila.pop()
print(ultimo)  # 3
print(pila)    # [1, 2]

7. Colas (Queues) <a name="colas"></a>

Las colas siguen el principio FIFO (First In, First Out).

python
from collections import deque

# Crear una cola
cola = deque()

# Encolar
cola.append(1)
cola.append(2)
cola.append(3)

print(cola)  # deque([1, 2, 3])

# Desencolar
primero = cola.popleft()
print(primero)  # 1
print(cola)     # deque([2, 3])

8. Listas Enlazadas <a name="listas-enlazadas"></a>

python
class Nodo:
    def __init__(self, dato):
        self.dato = dato
        self.siguiente = None

class ListaEnlazada:
    def __init__(self):
        self.cabeza = None
    
    def agregar(self, dato):
        nuevo_nodo = Nodo(dato)
        if self.cabeza is None:
            self.cabeza = nuevo_nodo
        else:
            actual = self.cabeza
            while actual.siguiente:
                actual = actual.siguiente
            actual.siguiente = nuevo_nodo
    
    def mostrar(self):
        actual = self.cabeza
        while actual:
            print(actual.dato, end=" -> ")
            actual = actual.siguiente
        print("None")

# Ejemplo de uso
lista = ListaEnlazada()
lista.agregar(1)
lista.agregar(2)
lista.agregar(3)
lista.mostrar()  # 1 -> 2 -> 3 -> None

9. Árboles Binarios <a name="árboles"></a>

python
class NodoArbol:
    def __init__(self, dato):
        self.dato = dato
        self.izquierdo = None
        self.derecho = None

class ArbolBinario:
    def __init__(self):
        self.raiz = None
    
    def insertar(self, dato):
        if self.raiz is None:
            self.raiz = NodoArbol(dato)
        else:
            self._insertar_recursivo(dato, self.raiz)
    
    def _insertar_recursivo(self, dato, nodo_actual):
        if dato < nodo_actual.dato:
            if nodo_actual.izquierdo is None:
                nodo_actual.izquierdo = NodoArbol(dato)
            else:
                self._insertar_recursivo(dato, nodo_actual.izquierdo)
        else:
            if nodo_actual.derecho is None:
                nodo_actual.derecho = NodoArbol(dato)
            else:
                self._insertar_recursivo(dato, nodo_actual.derecho)
    
    def inorden(self, nodo):
        if nodo:
            self.inorden(nodo.izquierdo)
            print(nodo.dato, end=" ")
            self.inorden(nodo.derecho)

# Ejemplo
arbol = ArbolBinario()
arbol.insertar(5)
arbol.insertar(3)
arbol.insertar(7)
arbol.insertar(2)
arbol.insertar(4)
arbol.inorden(arbol.raiz)  # 2 3 4 5 7

10. Ejercicios Prácticos <a name="ejercicios"></a>

Ejercicio 1: Contador de Palabras

python
def contar_palabras(texto):
    palabras = texto.split()
    contador = {}
    for palabra in palabras:
        contador[palabra] = contador.get(palabra, 0) + 1
    return contador

texto = "hola mundo hola python mundo programacion"
print(contar_palabras(texto))

Ejercicio 2: Sistema de Inventario

python
class Inventario:
    def __init__(self):
        self.productos = {}
    
    def agregar_producto(self, nombre, cantidad):
        self.productos[nombre] = self.productos.get(nombre, 0) + cantidad
    
    def vender_producto(self, nombre, cantidad):
        if nombre in self.productos and self.productos[nombre] >= cantidad:
            self.productos[nombre] -= cantidad
            return True
        return False
    
    def mostrar_inventario(self):
        for producto, cantidad in self.productos.items():
            print(f"{producto}: {cantidad}")

# Uso
inventario = Inventario()
inventario.agregar_producto("manzanas", 50)
inventario.agregar_producto("naranjas", 30)
inventario.vender_producto("manzanas", 10)
inventario.mostrar_inventario()

Ejercicio 3: Calculadora de Expresiones con Pila

python
def calcular_expresion(expresion):
    pila = []
    tokens = expresion.split()
    
    for token in tokens:
        if token.isdigit():
            pila.append(int(token))
        else:
            b = pila.pop()
            a = pila.pop()
            if token == '+':
                pila.append(a + b)
            elif token == '-':
                pila.append(a - b)
            elif token == '*':
                pila.append(a * b)
            elif token == '/':
                pila.append(a / b)
    
    return pila[0]

print(calcular_expresion("3 4 + 2 *"))  # (3 + 4) * 2 = 14

📝 Consejos Finales

  1. Practica regularmente: La práctica es clave para entender las estructuras de datos

  2. Comienza con lo simple: Domina listas y diccionarios antes de estructuras más complejas

  3. Visualiza: Dibuja las estructuras para entender cómo funcionan

  4. Experimenta: Modifica el código y observa qué pasa

  5. Resuelve problemas: Usa estas estructuras en proyectos reales

Comentarios

Publicar un comentario

Entradas populares de este blog

¿Qué es un Closure?

CÓDIGO SIMPLIFICADO python def contador_llamadas ( funcion_original ) : contador = 0 def funcion_envoltura ( ) : nonlocal contador contador += 1 print ( f"Llamada número: { contador } " ) return funcion_original ( ) # ← Ejecuta saludar() return funcion_envoltura # Definimos UNA sola función-funcion_original ) def saludar ( ) : return "¡Hola!" # Aplicamos el contador saludar_contador = contador_llamadas ( saludar ) # Usamos la función print ( saludar_contador ( ) ) # Llamada 1 print ( saludar_contador ( ) ) # Llamada 2 print ( saludar_contador ( ) ) # Llamada 3 🎯   SALIDA: text Llamada número: 1 ¡Hola! Llamada número: 2 ¡Hola! Llamada número: 3 ¡Hola! LA CLAVE ESTÁ EN ESTA LÍNEA: python return funcion_envoltura # ← ¡NO lleva paréntesis! 🔍  ¿QUÉ PASA PASO A PASO? PASO 1:  Cuando haces: python saludar_contador = contador_llamadas ( saludar ) contador_llamadas  crea  c...
Leer más

4 tipos de colecciones de datos más

  Te explico los 4 tipos de colecciones de datos más comunes en programación: 📋 Listas (Arrays)["",""] Características: Ordenadas  - Mantienen el orden de inserción Mutables  - Se pueden modificar después de crearlas Permiten duplicados  - Pueden tener elementos repetidos Indexadas  - Se accede por posición numérica (0, 1, 2...) Ejemplo (Python): python frutas = [ "manzana" , "banana" , "cereza" ] frutas . append ( "naranja" ) # Agregar elemento print ( frutas [ 1 ] ) # Output: "banana" 🔄 Conjuntos (Sets){} Características: No ordenados  - No mantienen un orden específico No permiten duplicados  - Elementos únicos Mutables  - Se pueden agregar/eliminar elementos No indexados  - No se puede acceder por posición Ejemplo (Python): python colores = { "rojo" , "verde" , "azul" } colores . add ( "amarillo" ) print ( "rojo" in colores ) # Output: True 📖 ...
Leer más

Calculadora de edad

    Calculadora de edad Trabajas en una compañía que ofrece seguros de vida y de gastos médicos. La empresa está desarrollando una herramienta tecnológica, para que los agentes puedan calcular el monto de una póliza. Para dicho cálculo, se consideran varios factores de riesgo, entre los que se encuentra la edad. Por ello, el contratante debe llenar un formulario, incluyendo su fecha de nacimiento. Como primer reto, deberás calcular la edad del cliente al momento de la cotización.     • La captura de la fecha de nacimiento debe ser en una sola cadena de texto con formato DD-MM-AAAA.  • Validar que sea una fecha existente, si supera los 31 días o menor a 1 día de un mes, se deberá marcar como inválido.  • El año de nacimiento debe ser mayor de 1900. • Validar si el cliente ya cumplió años en la fecha de captura o aún no.  • Validar que no se puede dejar información en blanco o campos vacíos.    Análisis del problema Necesitamos: ...
Leer más