Vectorización

import numpy as np

lecturas = np.genfromtxt("numpy_sensores.csv", delimiter=",",
                         skip_header=1, usecols=range(2, 26))
print("lecturas:", lecturas.shape, lecturas.dtype)

celsius = lecturas[0, :6]
print()
print("las 6 primeras horas del sensor S01, en Celsius:")
print("  ", celsius)

print()
print("A Fahrenheit, sin escribir un solo bucle:")
print("   celsius * 9 / 5 + 32 ->", np.round(celsius * 9 / 5 + 32, 1))

print()
print("Todos los operadores aritmeticos funcionan igual, elemento a elemento:")
print("   + 10  ->", np.round(celsius + 10, 1))
print("   - 20  ->", np.round(celsius - 20, 1))
print("   * 2   ->", np.round(celsius * 2, 1))
print("   / 2   ->", np.round(celsius / 2, 1))
print("   ** 2  ->", np.round(celsius ** 2, 1))
print("   // 5  ->", celsius // 5)
print("   % 5   ->", np.round(celsius % 5, 1))

print()
print("Y entre DOS arrays del mismo tamano, tambien elemento a elemento:")
manana = lecturas[0, 6:12]
tarde = lecturas[0, 12:18]
print("   manana (h06-h11):", manana)
print("   tarde  (h12-h17):", tarde)
print("   tarde - manana  :", np.round(tarde - manana, 1))
print("   Cada resta usa la lectura de la misma posicion. No hay que")
print("   emparejar nada a mano.")

print()
print("Las funciones de NumPy (las ufunc) hacen lo mismo:")
print("   np.sqrt   ->", np.round(np.sqrt(celsius), 2))
print("   np.abs    ->", np.abs(np.array([-3.0, 2.0, -1.5])))
print("   np.round  ->", np.round(celsius))
print("   np.log    ->", np.round(np.log(celsius), 3))
print("   np.minimum(celsius, 20) ->", np.minimum(celsius, 20))

print()
print("Las comparaciones tambien: devuelven un array de booleanos.")
print("   celsius > 20 ->", celsius > 20)
print("   Ese array booleano es la mascara de la leccion 3.4, y es")
print("   exactamente lo mismo que hace df[df.nota > 7] en pandas.")

print()
print("La regla: si escribiste un for para recorrer un array, casi siempre")
print("hay una expresion que lo reemplaza. Y no es solo velocidad: la")
print("expresion dice QUE se calcula, el bucle dice COMO se recorre.")

import numpy as np

lecturas = np.genfromtxt("numpy_sensores.csv", delimiter=",",
                         skip_header=1, usecols=range(2, 26))
print("original :", lecturas.shape, "=", lecturas.size, "lecturas")

plano = lecturas.reshape(-1)
print("aplanado :", plano.shape, " <- reshape(-1) siempre da 1 dimension")
print("   primeros 6:", plano[:6])
print("   son las 6 primeras horas de S01: reshape recorre FILA POR FILA.")

print()
por_horas = lecturas.reshape(24, 10)
print("reshape(24, 10):", por_horas.shape)
print("   OJO: esto NO es 'las 24 horas por los 10 sensores'.")
print("   Solo reagrupo los mismos 240 numeros de a 10, en el mismo orden.")
print("   primera fila:", np.round(por_horas[0], 1))
print("   ...que son las 10 primeras horas de S01, no la hora 0 de todos.")

print()
print("Para eso esta la transpuesta, que SI intercambia los ejes:")
transpuesta = lecturas.T
print("   lecturas.T:", transpuesta.shape)
print("   primera fila:", np.round(transpuesta[0], 1))
print("   ahora si: la hora h00 de los 10 sensores.")
print("   Se comprueba contra la columna 0 del original:",
      np.array_equal(transpuesta[0], lecturas[:, 0], equal_nan=True))

print()
print("El -1 significa 'calcula vos esta dimension':")
print("   reshape(-1)      ->", lecturas.reshape(-1).shape)
print("   reshape(5, -1)   ->", lecturas.reshape(5, -1).shape)
print("   reshape(-1, 4)   ->", lecturas.reshape(-1, 4).shape)
print("   Solo puede haber UN -1, y el total tiene que dar justo:")
try:
    lecturas.reshape(7, -1)
except ValueError as error:
    print("   reshape(7, -1) ->", type(error).__name__ + ":", error)

print()
print("Y el detalle que sorprende: reshape devuelve una VISTA, no una copia.")
copia_o_no = lecturas.reshape(24, 10)
copia_o_no[0, 0] = -999
print("   toque copia_o_no[0, 0] = -999")
print("   lecturas[0, 0] ahora vale:", lecturas[0, 0])
print("   Comparten la memoria. Si hace falta independencia: .copy()")
lecturas[0, 0] = 20.8       # dejar el array como estaba

print()
print("Un caso real donde reshape resuelve el problema: pasar la grilla a")
print("formato largo, una fila por (sensor, hora).")
sensores = np.repeat(np.arange(1, 11), 24)
horas = np.tile(np.arange(24), 10)
largo = np.column_stack([sensores, horas, lecturas.reshape(-1)])
print("   shape:", largo.shape)
print("   primeras 3 filas:")
print(largo[:3])
print("   ultimas 2 filas:")
print(largo[-2:])
print("   Es el melt() de la leccion 6.5, en tres lineas de NumPy.")

import numpy as np

lecturas = np.genfromtxt("numpy_sensores.csv", delimiter=",",
                         skip_header=1, usecols=range(2, 26))
print("lecturas:", lecturas.shape, " (10 sensores, 24 horas)")

print()
print("Sin axis, la reduccion aplasta TODO a un solo numero:")
print("   np.nanmean(lecturas) ->", round(float(np.nanmean(lecturas)), 2))
print("   shape del resultado  :", np.nanmean(lecturas).shape, "(un escalar)")

print()
print("Con axis, el eje que nombras es el que DESAPARECE:")
por_sensor = np.nanmean(lecturas, axis=1)
por_hora = np.nanmean(lecturas, axis=0)
print("   axis=1 -> desaparecen las 24 horas ->", por_sensor.shape,
      "un promedio POR SENSOR")
print("   axis=0 -> desaparecen los 10 sensores ->", por_hora.shape,
      "un promedio POR HORA")

print()
print("Esa es la regla, y es la unica que hay que recordar:")
print("   (10, 24) con axis=0 -> (24,)")
print("   (10, 24) con axis=1 -> (10,)")
print("   El numero del axis es la POSICION en shape que se elimina.")

print()
print("promedio por sensor (axis=1):")
for i, valor in enumerate(por_sensor, start=1):
    print(f"   S{i:02d}  {valor:6.2f}")

print()
print("promedio por hora (axis=0), las primeras 8:")
print("  ", np.round(por_hora[:8], 2))

print()
print("La forma de saber cual pediste: el resultado tiene que tener tantos")
print("elementos como la dimension que QUEDA.")
print("   10 sensores -> 10 promedios (axis=1)")
print("   24 horas    -> 24 promedios (axis=0)")

print()
print("Y hay una senal barata: el 999.9 imposible esta en S05.")
print("   S05 con axis=1 ->", round(float(por_sensor[4]), 2),
      "  <- salta a la vista")
print("   los otros nueve estan entre",
      round(float(np.delete(por_sensor, 4).min()), 2), "y",
      round(float(np.delete(por_sensor, 4).max()), 2))
print("   Un promedio por eje es tambien una herramienta de diagnostico.")

print()
print("Las reducciones que mas se usan, todas aceptan axis:")
for nombre, funcion in (("sum", np.nansum), ("mean", np.nanmean),
                        ("min", np.nanmin), ("max", np.nanmax),
                        ("std", np.nanstd)):
    resultado = funcion(lecturas, axis=1)
    print(f"   np.nan{nombre:<5}(a, axis=1) -> shape {resultado.shape}, "
          f"primer valor {resultado[0]:.2f}")

import numpy as np

lecturas = np.genfromtxt("numpy_sensores.csv", delimiter=",",
                         skip_header=1, usecols=range(2, 26))

# TAREA: para cada sensor, cuantas horas estuvo por encima de 21 grados,
# ignorando las lecturas ausentes y la imposible.

VALIDO_MAX = 50.0
UMBRAL = 21.0

# --- Version con bucles ------------------------------------------------
con_bucle = []
for fila in range(lecturas.shape[0]):
    cuantas = 0
    for columna in range(lecturas.shape[1]):
        valor = lecturas[fila, columna]
        if np.isnan(valor):
            continue
        if valor > VALIDO_MAX:
            continue
        if valor > UMBRAL:
            cuantas += 1
    con_bucle.append(cuantas)
con_bucle = np.array(con_bucle)

# --- Version vectorizada ------------------------------------------------
usable = ~np.isnan(lecturas) & (lecturas <= VALIDO_MAX)
sin_bucle = ((lecturas > UMBRAL) & usable).sum(axis=1)

print("con bucle  :", con_bucle)
print("sin bucle  :", sin_bucle)
print("¿iguales?  :", np.array_equal(con_bucle, sin_bucle))

print()
print("12 lineas contra 2, y el mismo resultado. Pero lo que importa no es")
print("la cantidad de lineas: es que la version de abajo se LEE.")
print("   usable      = no es NaN Y no supera el maximo posible")
print("   sin_bucle   = de las usables, cuantas superan el umbral, por fila")

print()
print("El detalle que hace que ande: sumar booleanos.")
mascara = (lecturas > UMBRAL) & usable
print("   dtype de la mascara:", mascara.dtype)
print("   mascara.sum(axis=1) cuenta los True, porque True vale 1.")
print("   int(True) ->", int(True), "| int(False) ->", int(False))

print()
print("Y NO siempre se puede vectorizar. El caso tipico es cuando cada")
print("elemento depende del ANTERIOR:")
serie = np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0])
maximo_hasta_aca = []
tope = -np.inf
for valor in serie:
    tope = max(tope, valor)
    maximo_hasta_aca.append(tope)
print("   serie              :", serie)
print("   maximo acumulado   :", np.array(maximo_hasta_aca))
print("   ...pero NumPy tambien tiene eso, y se llama acumulador:")
print("   np.maximum.accumulate ->", np.maximum.accumulate(serie))
print("   np.cumsum             ->", np.cumsum(serie))
print("   Antes de escribir el bucle, conviene buscar si ya existe.")