Esta publicación proporciona una documentación introductoria para comenzar con NumPy en Python.

# importar numpy a este script de python 
import numpy 
# crear algunas listas y agregarlas con la biblioteca base de Python 
a = [1,2,3] 
b = [1,2,3] 
a+b

[1, 2, 3, 1, 2, 3]

# declarar una matriz con numpy 
a_np = numpy.array([1,2,3]) 
# verificar el tipo de la matriz para confirmar que es un tipo de matriz 
numpy(a_np)

numpy.ndarray

# las matrices numpy tienen un atributo .dtype, lo que le permite verificar el tipo de datos numpy de la matriz 
a_np.dtype

tipod('int32')

# a_np es de tipo entero; intentemos asignar un flotante 
a_np[0] = 13.33 
a_np

matriz ([13, ​​2, 3])

# las matrices numpy tienen un atributo .ndim, lo que le permite ver el número de dimensiones de la matriz 
a_np.ndim

1

# las matrices numpy también tienen un atributo .size; 
# .size le permite ver la cantidad de elementos contenidos en la matriz 
a_np.size

3

# las matemáticas se vuelven posibles a nivel de elementos, cuando se usan matrices numpy 
# -- creando una segunda matriz numpy para probar algunas operaciones matemáticas a nivel de elementos 
b_np = numpy.array([2,3,4]) 
# adición 
a_np + b_np

matriz ([11, -1, -1])

# resta 
a_np - b_np

matriz ([11, -1, -1])

# multiplicacion 
a_np * b_np

matriz ([26, 6, 12])

# uno elevado a otro 
a_np ** b_np

matriz ([169, 8, 81], dtype = int32)

# división 
a_np / b_np

matriz ([6.5, 0.66666667, 0.75])

# módulo; probando a_np módulo 2 
a_np % numpy.array([2,2,2])

matriz ([1, 0, 1], dtype = int32)

# módulo; probando b_np módulo 2 
b_np % numpy.array([2,2,2])

matriz ([0, 1, 0], dtype = int32)

# numpy permite usar "funciones universales"; 
# las funciones universales funcionan por elementos, con matrices numpy 
# un ejemplo es .sin 
numpy.sin(a_np)

matriz ([0.42016704, 0.90929743, 0.14112001])

# otro ejemplo es .sqrt 
numpy.sqrt(a_np)

matriz ([3.60555128, 1.41421356, 1.73205081])

# construyendo una tabla de datos 2D usando numpy 
c_np = numpy.array([[1,2,3], 
                   [4,5,6]]) 
c_np

matriz ([[1, 2, 3], 
       [4, 5, 6]])

# indexación, es decir, obtener el valor almacenado en una celda definida; 
# aquí: celda en la primera fila, primera columna 
c_np[0][0]

1

# aquí: celda en la última fila, última columna 
c_np[-1][-1]

6

# aquí: celda en la segunda fila, primera columna 
c_np[1][0]

4

# una forma alternativa de hacer lo anterior 
c_np[1,0]

4

# cortando a través de una matriz numpy 1d simple 
# aquí: obtener el segundo y tercer valor en d_np 
d_np = numpy.array([7,9,11]) 
d_np[1:3]

matriz ([9, 11])

# obtener el primer y tercer elemento 
d_np[0:3:2] # from:to:step

matriz ([ 7, 11])

# aquí: obtener todos los demás elementos en d_np 
d_np[::2]

matriz ([ 7, 11])

# aquí: obteniendo cada tercer elemento 
d_np[::3]

matriz ([7])

# podemos crear una matriz 1D usando .arange, un método del módulo 
numpy e_np = numpy.arange(0,26) #param1: from; param2: a (último valor excluido) 
e_np

matriz ([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 
       17, 18, 19, 20, 21, 22, 23 , 24, 25])

# vamos a comprobar el tipo de e_np 
type(e_np)

numpy.ndarray

# Los arreglos numpy pueden cambiar de forma usando el método numpy .reshape 
f_np = e_np.reshape(2,13) ​​#param1: número de filas; param2: número de columnas 
f_np

matriz ([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 
       [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]])

# Puedo usar .reshape no solo para crear 2D a partir de 1D; 
# por ejemplo, vea esto 
g_np = numpy.array([1,2,3,4,5,6,7,8,9,10,11,12]).reshape(3,2,2) 
g_np

matriz ([[[ 1, 2], 
        [ 3, 4]], 

       [[ 5, 6], 
        [ 7, 8]], 

       [[ 9, 10], 
        [11, 12]]])

# g_np no es 3D; vamos a cortar algunas dimensiones de este cubo de datos 
# todos los valores en las primeras direcciones de la segunda dimensión 
g_np[:,0,:]

matriz ([[ 1, 2], 
       [ 5, 6], 
       [ 9, 10]])

# una celda específica; primero en todas las dimensiones 
g_np[0,0,0]

1

# una celda específica; último en todas las dimensiones 
g_np[-1,-1,-1]

12

# una celda específica; SEGUNDO último en todas las dimensiones 
g_np[-2,-2,-2]

5

# completemos este primer tutorial sobre numpy con otro ejemplo; 
# Creo una matriz 2d y se la muestro 
ejemplo = numpy.array([[1,2,3,4,5], 
                      [1.1,2.2,3.3,4.4,5.5], 
                      [1.11,2.22,3.33,4.44 ,5.55], 
                      [1.111,2.222,3.333,4.444,5.555], 
                      [1.1111,2.2222,3.3333,4.4444,5.5555]]) 
ejemplo

matriz ([[1. , 2. , 3. , 4. , 5. ], 
       [1.1 , 2.2 , 3.3 , 4.4 , 5.5 ], 
       [1.11 , 2.22 , 3.33 , 4.44 , 5.55 ], 
       [1.111 , 2.222 , 3.333 , 4,444 , 5,555 ], 
       [1,1111, 2,2222, 3,3333, 4,4444, 5,5555]])

# ahora permite acceder a los valores 2.2, 4.4, 2.222 y 4.444 - en solo una línea de código 
ejemplo[1::2,1::2]

matriz ([[2.2 , 4.4 ], 
       [2.222, 4.444]])

# ahora algunos ejemplos de lo que sucede cuando 
# copia por referencia 
a_np = numpy.array([1,2,3]) 
b_np = a_np[:1] 
b_np

matriz ([1])

# cambiando el elemento 
b_np b_np[0] = 10000 
b_np

matriz ([10000])

# vamos a comprobar npw a_np 
a_np

matriz ([10000, 2, 3])

# arriba es el efecto de copiar por referencia; 
# esto sucede cuando cortamos matrices numpy; 
# ¿Ocurre con la lista estándar de python? 
a = [1,2,3] 
b = a[:1] 
b[0] = 1000 
a

[1, 2, 3]

# la copia por referencia no ocurre cuando se cortan listas predeterminadas en pyhton; 
# si no queremos copiar por referencia, podemos usar el método .copy(), como parte de numpy 
c_np = numpy.array([1,2,3,4,5]) 
d_np = c_np.copy() 
d_np [0] = 10000 
c_np[0] = 99999 
# vamos a comprobar c_np ahora 
print("esto es c_np:" + str(c_np))

esto es c_np:[99999 2 3 4 5]

# ¿Qué pasa con d_np? 
d_np

matriz ([10000, 2, 3, 4, 5])

# copiar con .copy() permite trabajar con dos objetos, con referencias independientes;

Linnart Felkl

Ingeniero industrial especializado en optimización y simulación (R, Python, SQL, VBA)