Estructuras de Control y Funciones para Analisis

En data science, raramente analizas un solo dato. Trabajas con miles o millones de registros, y necesitas logica para filtrar, transformar y procesar esos datos. En esta leccion vas a aprender las estructuras de control y funciones de Python que son esenciales para el trabajo con datos.

Los condicionales te permiten tomar decisiones en tu codigo. En analisis de datos los usas para clasificar, filtrar y crear nuevas variables.

# Clasificar rendimiento de ventas
ventas_mensuales = 85000

if ventas_mensuales >= 100000:
    rendimiento = "Excelente"
    bono = ventas_mensuales * 0.10
elif ventas_mensuales >= 70000:
    rendimiento = "Bueno"
    bono = ventas_mensuales * 0.05
elif ventas_mensuales >= 50000:
    rendimiento = "Regular"
    bono = ventas_mensuales * 0.02
else:
    rendimiento = "Bajo"
    bono = 0

print(f"Rendimiento: {rendimiento}")
print(f"Bono: ${bono:,.2f}")

Operadores de comparacion y logicos

edad = 28
salario = 65000
experiencia = 5

# Operadores de comparacion
print(edad > 25)          # True
print(salario == 65000)   # True
print(experiencia != 3)   # True
print(edad >= 28)         # True

# Operadores logicos
print(edad > 25 and salario > 60000)   # True
print(edad > 30 or experiencia > 3)     # True
print(not (salario < 50000))             # True

# Operador ternario (muy util en data science)
categoria = "Senior" if experiencia >= 5 else "Junior"
print(categoria)  # Senior

Ejemplo: Clasificacion de clientes

clientes = [
    {"nombre": "Empresa A", "compras_anuales": 250000, "antiguedad": 5},
    {"nombre": "Empresa B", "compras_anuales": 80000, "antiguedad": 2},
    {"nombre": "Empresa C", "compras_anuales": 500000, "antiguedad": 8},
    {"nombre": "Empresa D", "compras_anuales": 30000, "antiguedad": 1},
    {"nombre": "Empresa E", "compras_anuales": 150000, "antiguedad": 4},
]

for cliente in clientes:
    compras = cliente["compras_anuales"]
    anios = cliente["antiguedad"]
    
    if compras >= 200000 and anios >= 3:
        segmento = "VIP"
    elif compras >= 100000 or anios >= 5:
        segmento = "Premium"
    elif compras >= 50000:
        segmento = "Estandar"
    else:
        segmento = "Basico"
    
    cliente["segmento"] = segmento
    print(f"{cliente['nombre']}: {segmento} (${compras:,} | {anios} anios)")

Salida:

Empresa A: VIP ($250,000 | 5 anios)
Empresa B: Estandar ($80,000 | 2 anios)
Empresa C: VIP ($500,000 | 8 anios)
Empresa D: Basico ($30,000 | 1 anios)
Empresa E: Premium ($150,000 | 4 anios)

El bucle for

El for es el bucle mas usado en data science. Iteras sobre listas, diccionarios, rangos, archivos.

# Iterar sobre una lista
meses = ["Ene", "Feb", "Mar", "Abr", "May", "Jun"]
ventas = [120, 135, 98, 145, 167, 189]

for i, (mes, venta) in enumerate(zip(meses, ventas)):
    variacion = ((venta - ventas[i-1]) / ventas[i-1] * 100) if i > 0 else 0
    signo = "+" if variacion >= 0 else ""
    print(f"{mes}: ${venta}k ({signo}{variacion:.1f}%)")

Salida:

Ene: $120k (+0.0%)
Feb: $135k (+12.5%)
Mar: $98k (-27.4%)
Abr: $145k (+48.0%)
May: $167k (+15.2%)
Jun: $189k (+13.2%)

Funciones utiles para bucles

nombres = ["Ana", "Carlos", "Lucia", "Pedro"]
scores = [92, 85, 97, 78]

# enumerate: obtener indice + valor
for i, nombre in enumerate(nombres):
    print(f"{i+1}. {nombre}")

# zip: iterar dos listas en paralelo
for nombre, score in zip(nombres, scores):
    print(f"{nombre}: {score} puntos")

# range: generar secuencias
for i in range(0, 100, 10):
    print(f"Percentil {i}: ...")

# sorted: iterar en orden
for nombre, score in sorted(zip(nombres, scores), key=lambda x: x[1], reverse=True):
    print(f"{nombre}: {score}")

El bucle while

Menos comun en data science, pero util para procesos iterativos:

# Simulacion: cuantos meses para duplicar una inversion?
inversion = 10000
tasa_mensual = 0.03  # 3% mensual
objetivo = inversion * 2
meses = 0

while inversion < objetivo:
    inversion *= (1 + tasa_mensual)
    meses += 1

print(f"Se necesitan {meses} meses para duplicar la inversion")
print(f"Monto final: ${inversion:,.2f}")

Las funciones encapsulan logica que podes reutilizar. En data science creas funciones para limpieza, transformacion y analisis.

def calcular_estadisticas(datos, nombre="Dataset"):
    """Calcula estadisticas basicas de una lista de numeros."""
    n = len(datos)
    promedio = sum(datos) / n
    datos_ordenados = sorted(datos)
    
    # Mediana
    if n % 2 == 0:
        mediana = (datos_ordenados[n//2 - 1] + datos_ordenados[n//2]) / 2
    else:
        mediana = datos_ordenados[n//2]
    
    # Varianza y desviacion estandar
    varianza = sum((x - promedio) ** 2 for x in datos) / n
    desviacion = varianza ** 0.5
    
    print(f"--- {nombre} ---")
    print(f"N: {n}")
    print(f"Promedio: {promedio:.2f}")
    print(f"Mediana: {mediana:.2f}")
    print(f"Min: {min(datos):.2f}")
    print(f"Max: {max(datos):.2f}")
    print(f"Desv. Estandar: {desviacion:.2f}")
    
    return {
        "n": n, "promedio": promedio, "mediana": mediana,
        "min": min(datos), "max": max(datos), "desviacion": desviacion
    }

# Uso
ventas_norte = [45, 52, 38, 61, 55, 48, 67, 43, 59, 51]
ventas_sur = [32, 28, 41, 35, 39, 45, 31, 37, 42, 33]

stats_norte = calcular_estadisticas(ventas_norte, "Ventas Norte")
stats_sur = calcular_estadisticas(ventas_sur, "Ventas Sur")

Funciones lambda (anonimas)

Muy usadas con Pandas para transformaciones rapidas:

# Lambda basica
doble = lambda x: x * 2
print(doble(5))  # 10

# Lambda con map
precios_usd = [10, 25, 50, 100]
tipo_cambio = 1050
precios_ars = list(map(lambda p: p * tipo_cambio, precios_usd))
print(precios_ars)  # [10500, 26250, 52500, 105000]

# Lambda con filter
edades = [15, 22, 17, 30, 12, 28, 19]
mayores = list(filter(lambda e: e >= 18, edades))
print(mayores)  # [22, 30, 28, 19]

# Lambda con sorted
empleados = [("Ana", 85000), ("Carlos", 72000), ("Lucia", 91000)]
ordenados = sorted(empleados, key=lambda e: e[1], reverse=True)
print(ordenados)  # [('Lucia', 91000), ('Ana', 85000), ('Carlos', 72000)]

Cuando trabajas con datos reales, SIEMPRE hay errores: valores faltantes, formatos incorrectos, archivos que no existen.

def convertir_a_numero(valor):
    """Convierte un valor a float, manejando errores comunes."""
    try:
        if isinstance(valor, str):
            valor = valor.strip().replace(",", "").replace("$", "")
        return float(valor)
    except (ValueError, TypeError):
        return None

# Datos sucios de una encuesta
respuestas = ["45,000", "$62,500", "38000", "no responde", "55.5k", "71,200", None, ""]

limpios = []
for r in respuestas:
    numero = convertir_a_numero(r)
    if numero is not None:
        limpios.append(numero)
    else:
        print(f"  Valor descartado: '{r}'")

print(f"Valores validos: {len(limpios)} de {len(respuestas)}")
print(f"Promedio: {sum(limpios)/len(limpios):,.2f}")

Funciones en Python - Curso Completo en Espanol

Crea un notebook 03_funciones.ipynb y resolve:

1. Crea una funcion clasificar_imc(peso, altura) que calcule el IMC y retorne la clasificacion
2. Crea una funcion analizar_notas(notas) que reciba una lista de notas y retorne: promedio, maxima, minima, cantidad de aprobados y porcentaje de aprobacion
3. Usando list comprehensions y lambdas, transforma una lista de temperaturas de Celsius a Fahrenheit
4. Crea una funcion que reciba una lista de diccionarios y calcule estadisticas de una columna especifica

Resumen

• Condicionales: Clasificar y filtrar datos
• Bucles for: Iterar sobre datasets (enumerate, zip, sorted)
• Funciones: Encapsular logica reutilizable de analisis
• Lambdas: Transformaciones rapidas (muy usadas con Pandas)
• Try/except: Manejar datos sucios sin que el programa se rompa

Con estos fundamentos de Python, estas listo para el modulo 2 donde vamos a empezar con Pandas, la libreria mas importante de data science.