Por qué arreglos y qué es un arreglo
Una lista de Python puede contener cualquier cosa, lo que la hace flexible pero lenta para números: cada elemento es un objeto distinto. NumPy añade el ndarray, un bloque de memoria con números de un único tipo dispuestos uno tras otro. Operar sobre todo el bloque en código compilado suele ser decenas de veces más rápido que un bucle de Python y usa mucha menos memoria. Casi toda biblioteca cuantitativa (pandas, SciPy, scikit-learn) se construye sobre él. Por convención se importa como import numpy as np.
import numpy as np
# Create arrays
prices = np.array([184.25, 185.0, 183.2])
print(prices) # [184.25 185. 183.2 ]
print(np.zeros(3)) # [0. 0. 0.]
print(np.arange(0, 10, 3)) # [0 3 6 9]
print(np.linspace(0, 1, 5)) # [0. 0.25 0.5 0.75 1. ]
# An array knows its shape
table = np.array([[1, 2, 3], [4, 5, 6]])
print(table.shape, table.ndim, table.size) # (2, 3) 2 6Crear arreglos
np.array(lista) convierte una lista (o una lista de listas para dos dimensiones). np.zeros(n) y np.ones(n) crean arreglos rellenos, y np.zeros((filas, columnas)) recibe una tupla de forma. np.arange(inicio, fin, paso) funciona como range pero admite pasos decimales y excluye fin; por el redondeo, prefiere np.linspace(inicio, fin, num), que da exactamente num puntos equiespaciados e incluye ambos extremos. Todo arreglo tiene .shape (el tamaño en cada dimensión), .ndim (número de dimensiones) y .size (número total de elementos).
import numpy as np
# arange with floats can surprise; linspace gives exactly the points you ask for
print(len(np.arange(0, 1, 0.1))) # 10 (1.0 is excluded)
print(len(np.linspace(0, 1, 11))) # 11 (both ends included)
# Shapes and sizes
grid = np.zeros((3, 4))
print(grid.shape, grid.ndim, grid.size) # (3, 4) 2 12
print(np.ones(2) * 5) # [5. 5.]dtypes: un solo tipo para todo el arreglo
Todo arreglo tiene un dtype: int64 (enteros), float64 (decimales), bool y variantes más pequeñas o grandes como float32 o int8. NumPy elige el dtype según los datos: enteros dan int64, un solo decimal convierte todo a float64 y np.nan (not-a-number, la marca de valor ausente) es un float, así que fuerza float64. Elige tú el dtype con dtype=... o convierte con .astype(...), que devuelve un arreglo nuevo. Un dtype más pequeño ahorra memoria (float32 ocupa la mitad que float64), a costa de precisión.
import numpy as np
print(np.array([1, 2, 3]).dtype) # int64
print(np.array([1, 2.5, 3]).dtype) # float64 (one decimal upgrades everything)
print(np.array([True, False]).dtype) # bool
print(np.array([1, 2, np.nan])) # [ 1. 2. nan] (nan is a float)
# astype returns a new array; smaller dtypes use less memory
prices = np.zeros(1000)
print(prices.nbytes) # 8000
print(prices.astype(np.float32).nbytes) # 4000
print(np.array(["1.5", "2"], dtype=float)) # [1.5 2. ] (text converted to numbers)Trampas de conversión: truncamiento y desbordamiento
Convertir decimales a enteros con .astype(int) trunca hacia cero, y los floats no representan exactamente la mayoría de los decimales: 19.99 * 100 es 1998.9999999999998 y se trunca a 1998, un céntimo menos. Para convertir precios a céntimos enteros, redondea primero: np.round(prices * 100).astype(np.int64). Los dtypes enteros tienen además un rango fijo y dan la vuelta en silencio: un int8 va de -128 a 127, así que 100 * 2 pasa a -56. Usa int64 para dinero y conteos, y recuerda que dividir enteros con / siempre da floats mientras que // redondea hacia abajo.
import numpy as np
# Truncation: astype(int) cuts the decimals off
print(np.array([1.9, -1.9]).astype(int)) # [ 1 -1]
print(19.99 * 100, int(19.99 * 100)) # 1998.9999999999998 1998
print(np.round(np.array([19.99]) * 100).astype(np.int64)) # [1999]
# Overflow: an int8 wraps around silently
small = np.array([100, 50], dtype=np.int8)
print(small * 2) # [-56 100]
# / always gives floats, // floors
counts = np.array([1, 2, 3])
print(counts / 2, counts // 2) # [0.5 1. 1.5] [0 1 1].shape y .dtype de cada arreglo implicado: un int64 inesperado donde esperabas float64, o una forma (5, 1) en lugar de (5,), explica la mayoría de los errores. Prefiere construir arreglos con funciones de NumPy (np.linspace, np.asarray, astype) en lugar de bucles de Python; los labs rechazan los bucles justo por esto.np.array,zeros,ones,arange,linspacecrean arreglos;.shape,.ndim,.sizelos describen.- Un dtype por arreglo:
int64,float64,bool;astypeconvierte en un arreglo nuevo. astype(int)trunca (redondea antes); los dtypes enteros pequeños dan la vuelta en silencio;nanfuerza floats.
A continuación: indexación y segmentación de arreglos, para elegir filas, columnas, ventanas y valores que cumplen una condición.
Lab: qué se califica
- Trazar puntos equiespaciados con
make_grid25 pts - Convertir valores brutos mixtos en floats con
to_float_array25 pts - Informar forma, tamaño y dtype con
describe_array25 pts - Convertir precios a céntimos enteros sin riesgo con
to_cents25 pts