Python en Algoritmos y Estructuras Básicas

Python es ideal para aprender a programar algoritmos por su sintaxis clara y legible.

Variables y Tipos de Datos

# Python no necesita declarar tipos
nombre = "Freddy"        # str
edad   = 30             # int
nota   = 4.5            # float
activo = True           # bool

# Verificar tipo
type(nota)              # <class 'float'>

# Conversión
int("42")               # 42
str(100)                # "100"
float("3.14")           # 3.14

Condicionales

nota = 4.2

if nota >= 4.5:
    print("Sobresaliente")
elif nota >= 4.0:
    print("Notable")
elif nota >= 3.0:
    print("Aprobado")
else:
    print("Reprobado")

# Operador ternario
estado = "Aprobado" if nota >= 3.0 else "Reprobado"

Bucles for y while

# Bucle for con range
for i in range(1, 6):
    print(i)           # 1 2 3 4 5

# Bucle while
contador = 0
while contador < 5:
    print(contador)
    contador += 1

# for sobre lista
frutas = ["mango", "pera", "uva"]
for fruta in frutas:
    print(fruta.upper())

# enumerate para índice + valor
for i, f in enumerate(frutas):
    print(i, f)

Funciones

# Función simple
def saludar(nombre):
    return f"Hola, {nombre}!"

saludar("Freddy")      # "Hola, Freddy!"

# Con valor por defecto
def potencia(base, exp=2):
    return base ** exp

potencia(3)           # 9
potencia(2, 8)        # 256

# Lambda (función anónima)
cuadrado = lambda x: x ** 2
cuadrado(5)           # 25

Listas

nums = [4, 2, 8, 1, 5]

nums.append(9)        # agregar al final
nums.sort()            # ordenar
nums.reverse()         # invertir
nums.pop()             # eliminar último
len(nums)              # cantidad de elementos
nums[0]               # primer elemento
nums[-1]              # último elemento
nums[1:3]             # slicing: [2, 8]

# List comprehension
pares = [x for x in nums if x % 2 == 0]

Diccionarios

alumno = {
    "nombre": "Ana",
    "edad": 15,
    "nota": 4.8
}

alumno["curso"] = "10°"  # agregar clave
alumno["nota"]             # acceder: 4.8
"edad" in alumno          # True
alumno.keys()             # claves
alumno.values()           # valores
alumno.items()            # pares clave-valor
del alumno["edad"]         # eliminar clave

🔎 Algoritmos Clásicos en Python

Algoritmos de Búsqueda

Búsqueda Lineal — O(n)

def busqueda_lineal(lista, objetivo):
    for i, valor in enumerate(lista):
        if valor == objetivo:
            return i      # índice encontrado
    return -1           # no encontrado

nums = [4, 7, 2, 9, 1]
busqueda_lineal(nums, 9)   # → 3
busqueda_lineal(nums, 5)   # → -1

Búsqueda Binaria — O(log n)

def busqueda_binaria(lista, objetivo):
    izq, der = 0, len(lista) - 1
    while izq <= der:
        mid = (izq + der) // 2
        if lista[mid] == objetivo:
            return mid
        elif lista[mid] < objetivo:
            izq = mid + 1
        else:
            der = mid - 1
    return -1

# La lista DEBE estar ordenada
nums = [1, 3, 5, 7, 9, 11]
busqueda_binaria(nums, 7)  # → 3

Algoritmos de Ordenamiento

Burbuja — O(n²)

def burbuja(lista):
    n = len(lista)
    for i in range(n):
        for j in range(n - i - 1):
            if lista[j] > lista[j+1]:
                lista[j], lista[j+1] = lista[j+1], lista[j]
    return lista

burbuja([5, 2, 8, 1])  # [1, 2, 5, 8]

Selección — O(n²)

def seleccion(lista):
    n = len(lista)
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if lista[j] < lista[min_idx]:
                min_idx = j
        lista[i], lista[min_idx] = lista[min_idx], lista[i]
    return lista

seleccion([64, 25, 12, 22])
# [12, 22, 25, 64]

Recursividad

Factorial

def factorial(n):
    if n <= 1:           # caso base
        return 1
    return n * factorial(n - 1)

factorial(5)   # 5*4*3*2*1 = 120
factorial(0)   # 1

Fibonacci

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

[fibonacci(i) for i in range(8)]
# [0, 1, 1, 2, 3, 5, 8, 13]

Suma recursiva de lista

def suma_lista(lista):
    if len(lista) == 0:   # caso base
        return 0
    return lista[0] + suma_lista(lista[1:])

suma_lista([1, 2, 3, 4, 5])  # 15

Potencia recursiva

def potencia(base, exp):
    if exp == 0:
        return 1
    return base * potencia(base, exp - 1)

potencia(2, 10)     # 1024

Pilas (Stack) y Colas (Queue)

Pila (LIFO — último en entrar, primero en salir)

# Usando lista como pila
pila = []
pila.append("A")   # push: ['A']
pila.append("B")   # push: ['A','B']
pila.append("C")   # push: ['A','B','C']
pila.pop()         # pop: 'C' ← último
pila.pop()         # pop: 'B'

# Usos: historial, deshacer (Ctrl+Z)

Cola (FIFO — primero en entrar, primero en salir)

from collections import deque

cola = deque()
cola.append("Ana")     # enqueue
cola.append("Juan")    # enqueue
cola.append("María")   # enqueue
cola.popleft()         # dequeue: 'Ana' ← primero
cola.popleft()         # dequeue: 'Juan'

# Usos: fila de impresión, turnos

📖 Diccionario

Algoritmo
Secuencia de pasos ordenados para resolver un problema. Debe ser finito, claro y efectivo.
Complejidad O(n)
Notación Big-O que mide el crecimiento del tiempo de ejecución según el tamaño de entrada.
Lista (list)
Colección ordenada y mutable de elementos. Permite duplicados. Acceso por índice.
Diccionario (dict)
Colección de pares clave-valor. Acceso rápido por clave. No tiene orden garantizado (Python 3.7+ sí lo mantiene).
Tupla (tuple)
Como una lista pero inmutable (no se puede modificar después de crearse).
Set (conjunto)
Colección de elementos únicos, sin orden ni duplicados. Operaciones: unión, intersección, diferencia.
Recursividad
Función que se llama a sí misma. Necesita un caso base para terminar y evitar bucle infinito.
Pila (Stack)
Estructura LIFO: el último en entrar es el primero en salir. Se implementa con list y append/pop.
Cola (Queue)
Estructura FIFO: el primero en entrar es el primero en salir. Se implementa con deque.
List Comprehension
Forma compacta de crear listas: [expr for item in iterable if condicion].
Lambda
Función anónima de una línea. lambda argumentos: expresión. Útil con map, filter, sorted.
Slicing
Extraer sublista: lista[inicio:fin:paso]. lista[1:4] devuelve elementos del índice 1 al 3.

🎬 Videos en Español

Python desde cero — Variables y Tipos

Estructuras de Datos en Python

Algoritmos de Búsqueda y Ordenamiento

Recursividad en Python — Ejemplos prácticos

Cuestionario

10 preguntas aleatorias del banco de 50. Calificación de 0 a 100.