Estructuras de Datos para Principiantes en Python

 https://www.youtube.com/watch?v=D72y6vCEazw

Estructuras de Datos para Principiantes en Python

¡Hola! Te voy a explicar las estructuras de datos básicas en Python de manera sencilla. Empecemos:

1. ARRAYS (Arreglos)

En Python, los arrays no son tan comunes como en otros lenguajes. Usamos principalmente listas, pero si necesitas arrays puedes usar el módulo array.

Listas (el equivalente más común a arrays)

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

# Acceder a elementos
print(mi_lista[0])  # 1 (primer elemento)
print(frutas[1])    # "banana"

# Modificar elementos
mi_lista[2] = 10
print(mi_lista)  # [1, 2, 10, 4, 5]

# Longitud de la lista
print(len(mi_lista))  # 5

2. LISTAS (Lists)

Las listas son la estructura de datos más versátil en Python.

Operaciones básicas con listas:

python
# Crear lista
numeros = [1, 2, 3, 4, 5]

# Agregar elementos
numeros.append(6)        # Al final: [1, 2, 3, 4, 5, 6]
numeros.insert(0, 0)     # En posición específica: [0, 1, 2, 3, 4, 5, 6]

# Eliminar elementos
numeros.pop()            # Elimina el último: [0, 1, 2, 3, 4, 5]
numeros.remove(3)        # Elimina el valor 3: [0, 1, 2, 4, 5]
del numeros[0]           # Elimina por índice: [1, 2, 4, 5]

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

# Concatenar listas
lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
combinada = lista1 + lista2  # [1, 2, 3, 4, 5, 6]

3. STACKS (Pilas)

Un stack es una estructura LIFO (Last In, First Out - Último en entrar, primero en salir). En Python podemos usar listas como stacks.

Implementación de stack con lista:

python
# Crear un stack vacío
pila = []

# Operaciones de stack
pila.append(10)  # Push: agregar elemento
pila.append(20)
pila.append(30)

print(pila)  # [10, 20, 30]

# Ver el último elemento sin eliminarlo
ultimo = pila[-1]
print(f"Último elemento: {ultimo}")  # Último elemento: 30

# Pop: eliminar y obtener el último elemento
elemento = pila.pop()
print(f"Elemento eliminado: {elemento}")  # Elemento eliminado: 30
print(pila)  # [10, 20]

# Verificar si está vacío
if not pila:
    print("La pila está vacía")
else:
    print(f"La pila tiene {len(pila)} elementos")

Ejemplo práctico de stack - Revertir una palabra:

python
def revertir_palabra(palabra):
    pila = []
    
    # Agregar cada letra a la pila
    for letra in palabra:
        pila.append(letra)
    
    # Construir palabra revertida
    palabra_revertida = ""
    while pila:
        palabra_revertida += pila.pop()
    
    return palabra_revertida

print(revertir_palabra("Python"))  # "nohtyP"

Resumen comparativo:

EstructuraCaracterística principalUso común
Array/ListaAcceso rápido por índiceAlmacenar colecciones ordenadas
Stack (Pila)LIFO (último en entrar, primero en salir)Deshacer operaciones, navegación

Ejercicio práctico combinado:

python
# Usando lista como stack para verificar paréntesis balanceados
def parentesis_balanceados(expresion):
    pila = []
    
    for caracter in expresion:
        if caracter == '(':
            pila.append(caracter)
        elif caracter == ')':
            if not pila:  # Si la pila está vacía
                return False
            pila.pop()
    
    return len(pila) == 0

# Probemos la función
print(parentesis_balanceados("(2+3)*(4-1)"))  # True
print(parentesis_balanceados("(2+3)*((4-1)")) # False

¡Espero que te haya quedado claro! Las listas son muy flexibles en Python y puedes usarlas tanto como arrays como stacks según lo necesites. 


Estructuras de Datos para el Viajero Web

¡Bienvenidos a este nuevo capítulo de nuestro curso de programación! Hoy aprenderás todo sobre las estructuras de datos, esenciales para el buen desempeño y eficiencia de los programas.

🎯 ¿Qué son las Estructuras de Datos?

Las estructuras de datos son formas de organizar y almacenar datos en un programa de computadora de manera que se pueda acceder y manipular eficientemente. Son fundamentales en la programación y se utilizan en una amplia variedad de aplicaciones, desde bases de datos hasta inteligencia artificial.

¿Por qué son importantes?

  • Permiten crear algoritmos más eficientes y escalables

  • Optimizan el rendimiento de los programas

  • Minimizan el consumo de recursos

  • Facilitan la organización de grandes conjuntos de datos

📊 Tipos de Estructuras de Datos

1. Arrays (Arreglos)

Colección de elementos del mismo tipo organizados en secuencia contigua de memoria.

2. Listas

Colección de elementos que se enlazan entre sí mediante punteros.

3. Pilas (Stacks)

Estructura lineal donde los elementos se insertan y eliminan por el mismo extremo (LIFO).

4. Colas (Queues)

Estructura lineal donde los elementos se insertan por un extremo y eliminan por otro (FIFO).

5. Árboles

Estructura jerárquica con un elemento raíz y ramas que se extienden hacia abajo.

6. Grafos

Estructura compuesta de nodos y aristas donde cada nodo puede conectarse a otros.

💻 Implementación en Python

1. Arrays (Listas en Python)

python
# Crear un arreglo (lista)
numeros = [5, 10, 15, 20, 25]
frutas = ["manzana", "banana", "naranja"]

# Acceder a elementos
print("Primer elemento:", numeros[0])  # Índice 0 = 5
print("Tercer elemento:", numeros[2])  # Índice 2 = 15

# Modificar elementos
numeros[3] = 30  # Cambiar el cuarto elemento (índice 3)
print("Array modificado:", numeros)

# Tamaño del array
print("Tamaño del array:", len(numeros))

2. Listas Enlazadas (Linked Lists)

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

# Crear lista enlazada: 15 → 10 → 5
nodo3 = Nodo(15)
nodo2 = Nodo(10)
nodo1 = Nodo(5)

# Enlazar los nodos
nodo3.siguiente = nodo2
nodo2.siguiente = nodo1

# Recorrer la lista
def imprimir_lista(inicio):
    actual = inicio
    while actual is not None:
        print(actual.valor, end=" → ")
        actual = actual.siguiente
    print("None")

print("Lista enlazada:")
imprimir_lista(nodo3)

3. Pilas (Stacks)

python
# Implementación de pila usando lista
pila = []

# Apilar elementos (push)
pila.append(5)
pila.append(10)
pila.append(15)

print("Pila después de apilar:", pila)

# Desapilar elementos (pop)
elemento1 = pila.pop()
print("Elemento desapilado:", elemento1)
print("Pila después de desapilar:", pila)

# Ver cima de la pila
print("Cima de la pila:", pila[-1])

# Ejemplo práctico: Revertir palabra
def revertir_palabra(palabra):
    pila = []
    for letra in palabra:
        pila.append(letra)
    
    palabra_revertida = ""
    while pila:
        palabra_revertida += pila.pop()
    
    return palabra_revertida

print("Python revertido:", revertir_palabra("Python"))

4. Colas (Queues)

python
from collections import deque

# Implementación de cola
cola = deque()

# Encolar elementos
cola.append(5)
cola.append(10)
cola.append(15)

print("Cola después de encolar:", list(cola))

# Desencolar elementos
elemento1 = cola.popleft()
print("Elemento desencolado:", elemento1)
print("Cola después de desencolar:", list(cola))

# Ejemplo práctico: Sistema de tickets
class SistemaTickets:
    def __init__(self):
        self.cola_tickets = deque()
    
    def nuevo_ticket(self, nombre):
        self.cola_tickets.append(nombre)
        print(f"Ticket agregado para: {nombre}")
    
    def atender_ticket(self):
        if self.cola_tickets:
            atendido = self.cola_tickets.popleft()
            print(f"Atendiendo a: {atendido}")
        else:
            print("No hay tickets en espera")

# Usar el sistema
sistema = SistemaTickets()
sistema.nuevo_ticket("Juan")
sistema.nuevo_ticket("María")
sistema.atender_ticket()

5. Árboles (Trees)

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

# Crear árbol binario
#       5
#      / \
#     3   7
raiz = NodoArbol(5)

# Nodos hijos
raiz.izquierdo = NodoArbol(3)
raiz.derecho = NodoArbol(7)

# Recorrido en orden (in-order)
def recorrer_inorden(nodo):
    if nodo:
        recorrer_inorden(nodo.izquierdo)
        print(nodo.valor, end=" ")
        recorrer_inorden(nodo.derecho)

print("Recorrido in-order:")
recorrer_inorden(raiz)
print()

6. Grafos (Graphs)

python
# Representación de grafo usando matriz de adyacencia
# Vértices: 0, 1, 2, 3
grafo = [
    [0, 1, 0, 1],  # Vértice 0 conectado a 1 y 3
    [1, 0, 1, 1],  # Vértice 1 conectado a 0, 2 y 3
    [0, 1, 0, 0],  # Vértice 2 conectado solo a 1
    [1, 1, 0, 0]   # Vértice 3 conectado a 0 y 1
]

def mostrar_conexiones(grafo):
    for i, fila in enumerate(grafo):
        conexiones = [j for j, valor in enumerate(fila) if valor == 1]
        print(f"Vértice {i} conectado a: {conexiones}")

print("Conexiones del grafo:")
mostrar_conexiones(grafo)

⚡ Ventajas de las Estructuras de Datos

  1. Mejoran la eficiencia: Operaciones de búsqueda y ordenamiento más rápidas

  2. Reutilización de código: Estructuras bien diseñadas pueden usarse en diferentes partes

  3. Mayor organización: Facilitan la gestión de grandes conjuntos de datos

  4. Flexibilidad: Se adaptan a diferentes situaciones y necesidades

  5. Menor complejidad: Reducen la complejidad del código

📈 Complejidad de Algoritmos (Big-O)

La notación Big-O mide el peor tiempo de ejecución de un algoritmo:

python
# Ejemplo: Encontrar el valor máximo en un array
def encontrar_maximo(arr):
    maximo = arr[0]  # O(1)
    
    for numero in arr:  # O(n) - depende del tamaño del array
        if numero > maximo:
            maximo = numero
    
    return maximo

# Complejidad: O(n) - tiempo crece linealmente con el tamaño del array
numeros = [3, 7, 2, 9, 5, 1]
print("Valor máximo:", encontrar_maximo(numeros))

Complejidades comunes:

  • O(1): Tiempo constante

  • O(log n): Tiempo logarítmico

  • O(n): Tiempo lineal

  • O(n²): Tiempo cuadrático

🎓 Conclusión

Cada estructura de datos tiene sus ventajas y desventajas. La elección correcta depende de:

  • El tipo de operaciones que necesitas realizar

  • La eficiencia requerida

  • La escalabilidad del programa

  • La facilidad de implementación

¡Recuerda seguir practicando! La mejor manera de aprender estructuras de datos es implementándolas en proyectos reales.

¿Te gustó este contenido? ¡Suscríbete y activa la campanita para no perderte las próximas clases! 



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

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

Funciones en Python: con y sin paréntesis

  Funciones en Python: con y sin paréntesis Te explico la diferencia fundamental entre usar funciones con y sin paréntesis en Python: 1. Función CON paréntesis:  Ejecución Cuando usas paréntesis después del nombre de una función,  estás ejecutando o llamando  esa función: python def saludar ( ) : return "¡Hola!" # Con paréntesis - EJECUTA la función mensaje = saludar ( ) print ( mensaje ) # Output: ¡Hola! 2. Función SIN paréntesis:  Referencia Cuando usas el nombre sin paréntesis,  estás haciendo referencia  a la función como objeto: python def saludar ( ) : return "¡Hola!" # Sin paréntesis - REFERENCIA a la función mi_funcion = saludar print ( mi_funcion ) # Output: <function saludar at 0x...> # Ahora puedes ejecutarla usando la referencia print ( mi_funcion ( ) ) # Output: ¡Hola! Ejemplos prácticos Ejemplo 1: Funciones como objetos de primera clase python def sumar ( a , b ) : return a + b def multipli...
Leer más