Máscaras booleanas

import numpy as np

lecturas = np.genfromtxt("numpy_sensores.csv", delimiter=",",
                         skip_header=1, usecols=range(2, 26))
s01 = lecturas[0]
print("las 24 lecturas de S01:")
print(np.round(s01, 1))

print()
print("PASO 1 - la comparacion devuelve un array de booleanos del MISMO largo:")
calido = s01 > 22
print("   s01 > 22 ->")
print(calido)
print("   dtype:", calido.dtype, "| shape:", calido.shape)

print()
print("PASO 2 - ese array booleano se usa como indice:")
print("   s01[s01 > 22] ->", s01[calido])
print("   Se quedan solo las posiciones donde la mascara dice True.")
print("   shape:", s01[calido].shape, " <- ya NO son 24")

print()
print("PASO 3 - y sumarla cuenta, porque True vale 1:")
print("   calido.sum()          ->", calido.sum())
print("   np.count_nonzero()    ->", np.count_nonzero(calido))
print("   calido.mean()         ->", round(float(calido.mean()), 3),
      " <- la PROPORCION")
print("   Ese ultimo es el truco mas util: el promedio de una mascara es")
print("   el porcentaje de filas que cumplen.")

print()
print("Sobre la grilla entera funciona igual, y la mascara es 2D:")
mascara = lecturas > 22
print("   (lecturas > 22).shape ->", mascara.shape)
print("   total de lecturas > 22:", mascara.sum())
print("   por sensor (axis=1)   :", mascara.sum(axis=1))
print("   por hora   (axis=0)   :", mascara.sum(axis=0))

print()
print("Y el filtrado sobre una grilla APLANA el resultado:")
print("   lecturas[lecturas > 22].shape ->", lecturas[mascara].shape)
print("   Tiene sentido: las que cumplen no forman un rectangulo.")

print()
print("Un detalle que salva horas: NaN no cumple NINGUNA comparacion.")
print("   np.nan > 0   ->", np.nan > 0)
print("   np.nan < 0   ->", np.nan < 0)
print("   np.nan == np.nan ->", np.nan == np.nan)
print("   Asi que una mascara descarta los ausentes sin que lo pidas...")
print("   ...y eso puede ser lo que queres, o puede ser un dato perdido")
print("   en silencio. Para preguntarlo explicitamente: np.isnan(a).")
print("   NaN en la grilla:", int(np.isnan(lecturas).sum()))

import numpy as np

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

print("Los tres operadores de mascaras son simbolos, no palabras:")
print("   &  Y     |  O     ~  NO")

templado = (s01 > 20) & (s01 < 22)
print()
print("templado = (s01 > 20) & (s01 < 22)")
print("   cuantas:", templado.sum(), "de", s01.size)
print("   valores:", np.round(s01[templado], 1))

extremo = (s01 <= 20) | (s01 >= 22)
print()
print("extremo = (s01 <= 20) | (s01 >= 22)")
print("   cuantas:", extremo.sum())

print()
print("~ invierte la mascara:")
print("   (~templado).sum() ->", (~templado).sum(), "= 24 -", templado.sum())
print("   ¿~templado es igual a extremo?",
      np.array_equal(~templado, extremo))
print("   Si, y no es casualidad: negar un Y da un O con las dos")
print("   condiciones negadas. NO(a>20 Y a<22) = (a<=20) O (a>=22).")
print("   Se llaman leyes de De Morgan, y sirven para no escribir")
print("   condiciones dobles cuando alcanza con negar una.")

print()
print("=" * 62)
print("LOS DOS ERRORES QUE TODO EL MUNDO COMETE")
print("=" * 62)

print()
print("1. Usar 'and' en vez de '&':")
try:
    s01 > 20 and s01 < 22
except ValueError as error:
    print("   s01 > 20 and s01 < 22 ->", type(error).__name__)
    print("   ", error)
print("   'and' necesita un solo True o False para decidir, y le estas")
print("   dando 24. NumPy se niega a adivinar cual queres.")

print()
print("2. Olvidar los parentesis:")
try:
    s01 > 20 & s01 < 22
except (ValueError, TypeError) as error:
    print("   s01 > 20 & s01 < 22 ->", type(error).__name__)
    print("   ", str(error)[:70])
print("   '&' tiene MAS precedencia que '>' y '<', asi que Python lee")
print("   s01 > (20 & s01) < 22. Los parentesis no son estilo: son")
print("   obligatorios.")

print()
print("La forma correcta, siempre:")
print("   (condicion_a) & (condicion_b)")
print("   (condicion_a) | (condicion_b)")
print("   ~(condicion_a)")

print()
print("Y la variante que evita el problema cuando hay muchas condiciones:")
condiciones = [s01 > 20, s01 < 22, ~np.isnan(s01)]
todas = np.logical_and.reduce(condiciones)
print("   np.logical_and.reduce([a, b, c]) ->", todas.sum(), "cumplen las 3")
print("   np.logical_and(a, b)  es lo mismo que  a & b")
print("   np.logical_or(a, b)   es lo mismo que  a | b")
print("   np.logical_not(a)     es lo mismo que  ~a")

print()
print("Sobre la grilla, combinar es igual de barato:")
usable = ~np.isnan(lecturas) & (lecturas <= 50)
print("   usable = ~np.isnan(lecturas) & (lecturas <= 50)")
print("   lecturas usables:", usable.sum(), "de", lecturas.size)
print("   descartadas     :", lecturas.size - usable.sum(),
      "= 4 ausentes + 1 imposible")

import numpy as np

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

print("np.where(condicion, si, no) elige valor por valor:")
etiquetas = np.where(s01 > 22, "calido", "templado")
print("   np.where(s01 > 22, 'calido', 'templado'), primeros 8:")
print("  ", etiquetas[:8])
print("   Devuelve un array del MISMO largo: no filtra, reemplaza.")

print()
print("Y es la forma de limpiar sin perder filas:")
limpias = np.where(lecturas > 50, np.nan, lecturas)
print("   np.where(lecturas > 50, np.nan, lecturas)")
print("   shape:", limpias.shape, " <- las 240 siguen ahi")
print("   NaN antes :", int(np.isnan(lecturas).sum()))
print("   NaN despues:", int(np.isnan(limpias).sum()),
      " <- el 999.9 paso a ser un ausente declarado")

print()
print("Se pueden encadenar, aunque anidados se leen mal:")
tres = np.where(s01 < 20, "frio", np.where(s01 < 22, "templado", "calido"))
print("   primeros 8:", tres[:8])

print()
print("=" * 62)
print("any y all: contestan SI o NO sobre todo el array")
print("=" * 62)
print("   np.isnan(lecturas).any() ->", np.isnan(lecturas).any(),
      "  ¿hay ALGUN ausente?")
print("   np.isnan(lecturas).all() ->", np.isnan(lecturas).all(),
      " ¿son TODOS ausentes?")
print("   (lecturas > 0).all()     ->", (lecturas > 0).all(),
      " ¿son TODAS positivas? (los NaN dicen que no)")
print("   (~np.isnan(lecturas)).all() ->", (~np.isnan(lecturas)).all())

print()
print("Con axis contestan por fila o por columna:")
print("   np.isnan(lecturas).any(axis=1) ->", np.isnan(lecturas).any(axis=1))
print("   ...los sensores con al menos un hueco: S03, S06 y S09")
con_hueco = np.nonzero(np.isnan(lecturas).any(axis=1))[0]
print("   posiciones:", con_hueco, "-> S03, S06, S09")

print()
print("Son la herramienta de los assert de invariantes:")
print("   assert (salida['edad'] >= 18).all()")
print("   assert not salida.isna().any().any()")
print("   Un any/all que falla dice que una regla se rompio, y eso es")
print("   mucho mejor que descubrirlo en el informe.")

print()
print("Y las tres que dicen DONDE:")
print("   np.nonzero(s01 > 23)  ->", np.nonzero(s01 > 23)[0],
      " (las posiciones)")
print("   np.argmax(s01)        ->", np.argmax(s01),
      " (la posicion del maximo)")
print("   np.nanargmax(lecturas) ->", np.nanargmax(lecturas),
      " (en el array aplanado)")
print("   np.unravel_index(np.nanargmax(lecturas), lecturas.shape) ->",
      np.unravel_index(np.nanargmax(lecturas), lecturas.shape),
      " <- fila 4, hora 11: el 999.9")

import numpy as np
import pandas as pd

# TAREA: las lecturas usables (no ausentes, no imposibles) que superan
# los 22 grados, contadas por sensor.

VALIDO_MAX = 50.0
UMBRAL = 22.0

# ---------------------------------------------------------------- NumPy
grilla = np.genfromtxt("numpy_sensores.csv", delimiter=",",
                       skip_header=1, usecols=range(2, 26))
usable_np = ~np.isnan(grilla) & (grilla <= VALIDO_MAX)
calidas_np = ((grilla > UMBRAL) & usable_np).sum(axis=1)

# --------------------------------------------------------------- pandas
tabla = pd.read_csv("numpy_sensores.csv")
horas = [c for c in tabla.columns if c.startswith("h")]
valores = tabla[horas]
usable_pd = valores.notna() & (valores <= VALIDO_MAX)
calidas_pd = ((valores > UMBRAL) & usable_pd).sum(axis=1)

print("NumPy :", calidas_np)
print("pandas:", calidas_pd.to_numpy())
print("¿iguales?", np.array_equal(calidas_np, calidas_pd.to_numpy()))

print()
print("Las dos lineas que importan, una al lado de la otra:")
print("   NumPy : ~np.isnan(g) & (g <= 50)")
print("   pandas: valores.notna() & (valores <= 50)")
print()
print("   NumPy : ((g > 22) & usable).sum(axis=1)")
print("   pandas: ((valores > 22) & usable).sum(axis=1)")
print()
print("Es la MISMA idea con otro nombre para 'no es ausente'. Todo lo")
print("demas (el &, los parentesis, sumar booleanos, el axis) es igual,")
print("porque pandas usa NumPy por debajo.")

print()
print("Y la version con nombres, que es lo que agrega pandas:")
resumen = pd.DataFrame({
    "sensor": tabla["sensor_id"],
    "ubicacion": tabla["ubicacion"],
    "horas_calidas": calidas_pd,
    "horas_usables": usable_pd.sum(axis=1),
})
print(resumen.to_string(index=False))

print()
print("Las tres filas con menos horas usables son S03 (2 huecos), S06 y")
print("S09 (uno cada uno), mas S05, que pierde su lectura imposible.")
print()
print("El paso de NumPy a pandas no es aprender otra cosa: es que las")
print("filas y columnas pasan a tener NOMBRE. La mascara es la misma.")