El array, y por qué no una lista

import numpy as np

notas = np.array([9.7, 4.7, 8.6, 6.0, 3.8])
print("notas       :", notas)
print("  dtype     :", notas.dtype, "  <- el tipo de TODOS sus elementos")
print("  shape     :", notas.shape, "  <- 5 elementos en 1 dimension")
print("  ndim      :", notas.ndim)
print("  size      :", notas.size)
print("  itemsize  :", notas.itemsize, "bytes por elemento")
print("  nbytes    :", notas.nbytes, "bytes en total")

print()
grilla = np.array([[9.7, 4.7, 8.6],
                   [6.0, 3.8, 4.2],
                   [8.1, 3.6, 3.8]])
print("una grilla de 3x3:")
print(grilla)
print("  shape:", grilla.shape, "| ndim:", grilla.ndim, "| size:", grilla.size)
print("  shape es (filas, columnas), y ese orden no cambia nunca.")

print()
print("La homogeneidad no es opcional: si le das tipos mezclados, NumPy")
print("elige uno solo para todos y convierte. Se llama upcasting.")
for lista in ([1, 2, 3], [1, 2.5, 3], [1, 2, "tres"], [True, False, 1]):
    a = np.array(lista)
    print(f"   {str(lista):<22} -> dtype {str(a.dtype):<8} {a}")

print()
print("El tercero es el peligroso: un solo texto convirtio los numeros en")
print("texto. El dtype <U21 significa 'cadena de hasta 21 caracteres'.")
mezclado = np.array([1, 2, "tres"])
print("   dtype:", mezclado.dtype, "| el 1 ahora es", repr(mezclado[0]))
try:
    mezclado.sum()
except TypeError as error:
    print("   .sum() ->", type(error).__name__)
print("   NumPy 2 se niega a sumar cadenas, y eso es una suerte: avisa.")
print("   pandas, sobre la misma columna, las CONCATENA sin quejarse.")
print("   Los dos casos vienen del mismo origen: un solo valor de texto")
print("   en una columna numerica, que es el defecto mas comun del corpus.")

print()
print("Y el dtype se puede pedir explicitamente, que es lo que conviene")
print("cuando ya sabes que estas leyendo:")
enteros = np.array([1, 2, 3], dtype=np.int64)
flotantes = np.array([1, 2, 3], dtype=np.float64)
print("   dtype=int64   ->", enteros, enteros.dtype)
print("   dtype=float64 ->", flotantes, flotantes.dtype)

import sys
import timeit

import numpy as np

N = 100_000
lista = list(range(N))
arreglo = np.arange(N, dtype=np.int64)

print("MEMORIA, para", f"{N:,}".replace(",", ".") , "enteros:")
print("   lista de Python:", sys.getsizeof(lista), "bytes solo los punteros")
print("   ...mas cada objeto int, que pesa", sys.getsizeof(0), "bytes aparte")
print("   array de NumPy :", arreglo.nbytes, "bytes, y eso es todo")
print("   El array guarda los numeros pegados en memoria; la lista guarda")
print("   direcciones a objetos que estan cada uno por su lado.")

print()
print("VELOCIDAD, sumando 1 a cada elemento:")
con_lista = timeit.timeit(lambda: [x + 1 for x in lista], number=20) / 20
con_array = timeit.timeit(lambda: arreglo + 1, number=20) / 20
# Los milisegundos exactos cambian en cada corrida y en cada maquina,
# asi que esta pagina publica la comparacion, no el cronometro.
print("   [x + 1 for x in lista] : el bucle de Python")
print("   arreglo + 1            : una sola operacion de NumPy")
print("   ¿el array tarda menos de la decima parte?",
      con_array * 10 < con_lista)
print("   En esta maquina la diferencia es de uno a dos ordenes de")
print("   magnitud, y crece con el tamano: el bucle paga por elemento,")
print("   el array no.")

print()
print("Y la diferencia que mas se nota al escribir codigo:")
print("   lista * 2   ->", [1, 2, 3] * 2, "  <- repite la lista")
print("   array * 2   ->", np.array([1, 2, 3]) * 2, "      <- duplica cada valor")
print("   lista + 1   -> TypeError")
try:
    [1, 2, 3] + 1
except TypeError as error:
    print("     ", error)
print("   array + 1   ->", np.array([1, 2, 3]) + 1)

print()
print("Esa es la idea entera de NumPy: la operacion se escribe una vez y se")
print("aplica a todos los elementos. Se llama vectorizacion, y es la")
print("leccion 3.2.")

print()
print("Lo que se pierde a cambio:")
print("   - el array tiene UN tipo: no se pueden mezclar numeros y texto")
print("   - el tamano es fijo: no hay append barato")
print("   - se puede indexar y rebanar, pero no insertar en el medio")
print("Para una tabla de datos, esas tres perdidas no molestan nunca.")

import warnings

import numpy as np

notas = np.array([9.7, 4.7, 8.6, 6.0, 3.8])

print("astype convierte y devuelve un array NUEVO:")
enteros = notas.astype(np.int64)
print("   original:", notas, notas.dtype)
print("   astype  :", enteros, enteros.dtype)
print("   TRUNCA, no redondea: 9.7 -> 9, no 10.")
print("   Si queres redondear: np.round(notas).astype(int) ->",
      np.round(notas).astype(np.int64))

print()
print("Y no toca el original:", notas)

print()
print("El caso que hay que conocer: un NaN convertido a entero.")
con_hueco = np.array([9.7, np.nan, 8.6])
print("   con_hueco:", con_hueco, con_hueco.dtype)
with warnings.catch_warnings(record=True) as avisos:
    warnings.simplefilter("always")
    convertido = con_hueco.astype(np.int64)
print("   .astype(int64) ->", convertido)
print("   avisos:", [a.category.__name__ for a in avisos])
print()
print("   NO levanta excepcion: emite un RuntimeWarning y devuelve")
print("   -9223372036854775808, que es el entero mas chico que existe.")
print("   Ese numero entra al calculo como si fuera un dato.")
print()
print("   pandas, sobre lo mismo, se niega:")
print("     IntCastingNaNError: Cannot convert non-finite values to integer")
print("   NaN es un float y solo existe en float. En pandas hay un tipo")
print("   entero que admite ausentes (Int64, con I mayuscula); en NumPy")
print("   puro no: o hay float, o no hay huecos.")

print()
print("El otro caso que muerde: el desborde, que NO siempre avisa.")
print("   np.int8 admite de -128 a 127.")
try:
    np.array([200], dtype=np.int8)
except OverflowError as error:
    print("   crear el array con 200 ->", type(error).__name__, "  <- avisa")
grandes = np.array([200, 300])
print("   pero .astype(np.int8) NO avisa:",
      grandes, "->", grandes.astype(np.int8))
al_borde = np.array([127], dtype=np.int8)
print("   y sumar tampoco:", al_borde, "+ 1 ->", al_borde + np.int8(1))
print("   Da la vuelta y sigue. Por eso los tipos chicos se usan solo")
print("   cuando la memoria importa de verdad y se sabe el rango.")

print()
print("Y el redondeo de NumPy no es el que se aprende en la escuela:")
medios = np.array([0.5, 1.5, 2.5, 3.5, 4.5])
print("   np.round([0.5 1.5 2.5 3.5 4.5]) ->", np.round(medios))
print("   Redondea al PAR mas cercano, no siempre hacia arriba. Es el")
print("   estandar IEEE 754 y lo mismo hace round() de Python.")
print("   round(2.5) de Python ->", round(2.5))
print("   Va a volver en la leccion 7.4, cuando dos archivos correctos")
print("   difieran en un centavo.")

print()
print("Resumen de lo que hay que mirar antes de un astype:")
print("   ¿hay NaN?            -> a entero, no se puede")
print("   ¿hay decimales?      -> a entero, se truncan")
print("   ¿el tipo entra?      -> int8 no aguanta 200")
print("   ¿es una copia?       -> si, siempre: astype no modifica")

import numpy as np

print("Las cinco formas de crear un array sin escribir los valores:")
print("   np.zeros(5)      ->", np.zeros(5))
print("   np.ones(3)       ->", np.ones(3))
print("   np.full(4, -1)   ->", np.full(4, -1))
print("   np.arange(0, 10, 2) ->", np.arange(0, 10, 2))
print("   np.linspace(0, 1, 5) ->", np.linspace(0, 1, 5))
print()
print("arange va de a pasos y NO incluye el final, como range().")
print("linspace va por cantidad de puntos y SI incluye el final.")
print("   np.arange(0, 1, 0.25) ->", np.arange(0, 1, 0.25))
print("   np.linspace(0, 1, 5)  ->", np.linspace(0, 1, 5))

print()
print("Y en dos dimensiones se le pasa la forma como tupla:")
print("   np.zeros((2, 3)) ->")
print(np.zeros((2, 3)))

print()
print("=" * 62)
print("Ahora el archivo real: numpy_sensores.csv")
print("=" * 62)

# genfromtxt lee texto a un array. skip_header saltea la cabecera y
# usecols elige las 24 columnas horarias, que son las numericas.
lecturas = np.genfromtxt("numpy_sensores.csv", delimiter=",",
                         skip_header=1, usecols=range(2, 26))

with open("numpy_sensores.csv", encoding="utf-8") as f:
    cabecera = f.readline().strip().split(",")
sensores = np.genfromtxt("numpy_sensores.csv", delimiter=",", skip_header=1,
                         usecols=(0,), dtype=str)

print("shape :", lecturas.shape, " <- 10 sensores x 24 horas")
print("dtype :", lecturas.dtype)
print("size  :", lecturas.size, "lecturas")
print("horas :", cabecera[2], "...", cabecera[-1])
print("sensores:", sensores)

print()
print("primeras 4 horas de los 3 primeros sensores:")
print(lecturas[:3, :4])

print()
print("Las celdas vacias del archivo llegaron como NaN, sin pedirlo:")
huecos = np.isnan(lecturas)
print("   cuantos NaN:", int(huecos.sum()))
filas, columnas = np.nonzero(huecos)
for fila, columna in zip(filas, columnas):
    print(f"     {sensores[fila]}  {cabecera[columna + 2]}")

print()
print("Y ojo con el maximo:")
print("   lecturas.max()    ->", lecturas.max(), " <- un solo NaN contamina")
print("   np.nanmax()       ->", np.nanmax(lecturas))
posicion = np.nanargmax(lecturas)
print("   ...y ese maximo esta en", sensores[posicion // 24],
      cabecera[posicion % 24 + 2])
print()
print("El 999.9 sigue ahi porque es un numero perfectamente valido: ni")
print("genfromtxt ni el dtype lo detectan. Solo lo encuentra un chequeo")
print("de rango, que es codigo que hay que escribir (leccion 3.7).")
print("Y lo del NaN que arruina la reduccion es la leccion 3.6.")