NumPy en Python | Serie 1 (Introducción)

Este artículo lo ayudará a familiarizarse con la biblioteca de procesamiento de arrays ampliamente utilizada en Python, NumPy . ¿Qué es NumPy? NumPy es un paquete de procesamiento de arrays de propósito general. Proporciona un objeto de array multidimensional de alto rendimiento y herramientas para trabajar con estas arrays. Es el paquete fundamental para la computación científica con Python. Es un software de código abierto. Contiene varias características, incluidas estas importantes:

• Un poderoso objeto de array N-dimensional
• Funciones sofisticadas (de radiodifusión)
• Herramientas para integrar código C/C++ y Fortran
• Capacidades útiles de álgebra lineal, transformada de Fourier y números aleatorios

Además de sus usos científicos obvios, NumPy también se puede utilizar como un contenedor multidimensional eficiente de datos genéricos. Los tipos de datos arbitrarios se pueden definir utilizando Numpy, lo que permite que NumPy se integre sin problemas y rápidamente con una amplia variedad de bases de datos. Instalación:

• Los usuarios de Mac y Linux pueden instalar NumPy a través del comando pip:

pip install numpy

• Windows no tiene ningún administrador de paquetes análogo al de Linux o Mac. Descargue el instalador de Windows preconstruido para NumPy desde aquí (según la configuración de su sistema y la versión de Python). Y luego instale los paquetes manualmente.

Nota: Todos los ejemplos discutidos a continuación no se ejecutarán en un IDE en línea. 1. Arreglos en NumPy: El objeto principal de NumPy es el arreglo multidimensional homogéneo.

• Es una tabla de elementos (normalmente números), todos del mismo tipo, indexados por una tupla de enteros positivos.
• En NumPy las dimensiones se llaman ejes . El número de ejes es el rango .
• La clase de array de NumPy se llama ndarray . También es conocido por la array de alias .

Ejemplo :

[[ 1, 2, 3],
 [ 4, 2, 5]]
Here,
rank = 2 (as it is 2-dimensional or it has 2 axes)
first dimension(axis) length = 2, second dimension has length = 3
overall shape can be expressed as: (2, 3)

# Python program to demonstrate
# basic array characteristics
import numpy as np
 
# Creating array object
arr = np.array( [[ 1, 2, 3],
                 [ 4, 2, 5]] )
 
# Printing type of arr object
print("Array is of type: ", type(arr))
 
# Printing array dimensions (axes)
print("No. of dimensions: ", arr.ndim)
 
# Printing shape of array
print("Shape of array: ", arr.shape)
 
# Printing size (total number of elements) of array
print("Size of array: ", arr.size)
 
# Printing type of elements in array
print("Array stores elements of type: ", arr.dtype)

Producción :

Array is of type:  
No. of dimensions:  2
Shape of array:  (2, 3)
Size of array:  6
Array stores elements of type:  int64

2. Creación de arrays: hay varias formas de crear arrays en NumPy.

• Por ejemplo, puede crear una array a partir de una lista o tupla normal de Python utilizando la función de array . El tipo de la array resultante se deduce del tipo de los elementos de las secuencias.
• A menudo, los elementos de una array se desconocen originalmente, pero se conoce su tamaño. Por lo tanto, NumPy ofrece varias funciones para crear arrays con contenido de marcador de posición inicial . Estos minimizan la necesidad de hacer crecer arreglos, una operación costosa. Por ejemplo: np.ceros, np.unos, np.lleno, np.vacío, etc.
• Para crear secuencias de números, NumPy proporciona una función análoga a range que devuelve arrays en lugar de listas.
• arange: devuelve valores espaciados uniformemente dentro de un intervalo dado. se especifica el tamaño del paso .
• linspace: devuelve valores espaciados uniformemente dentro de un intervalo dado. núm . de elementos son devueltos.
• Remodelación de array: podemos usar el método de remodelación para remodelar una array . Considere una array con forma (a1, a2, a3, …, aN). Podemos remodelarlo y convertirlo en otra array con forma (b1, b2, b3, …, bM). La única condición requerida es: a1 x a2 x a3 … x aN = b1 x b2 x b3 … x bM . (es decir, el tamaño original de la array permanece sin cambios).
• Aplanar array: podemos usar el método aplanar para obtener una copia de la array colapsada en una dimensión . Acepta argumento de orden . El valor predeterminado es ‘C’ (para orden de fila principal). Use ‘F’ para el orden principal de las columnas.

Nota: el tipo de array se puede definir explícitamente al crear la array. 

# Python program to demonstrate
# array creation techniques
import numpy as np
 
# Creating array from list with type float
a = np.array([[1, 2, 4], [5, 8, 7]], dtype = 'float')
print ("Array created using passed list:\n", a)
 
# Creating array from tuple
b = np.array((1 , 3, 2))
print ("\nArray created using passed tuple:\n", b)
 
# Creating a 3X4 array with all zeros
c = np.zeros((3, 4))
print ("\nAn array initialized with all zeros:\n", c)
 
# Create a constant value array of complex type
d = np.full((3, 3), 6, dtype = 'complex')
print ("\nAn array initialized with all 6s."
            "Array type is complex:\n", d)
 
# Create an array with random values
e = np.random.random((2, 2))
print ("\nA random array:\n", e)
 
# Create a sequence of integers
# from 0 to 30 with steps of 5
f = np.arange(0, 30, 5)
print ("\nA sequential array with steps of 5:\n", f)
 
# Create a sequence of 10 values in range 0 to 5
g = np.linspace(0, 5, 10)
print ("\nA sequential array with 10 values between"
                                        "0 and 5:\n", g)
 
# Reshaping 3X4 array to 2X2X3 array
arr = np.array([[1, 2, 3, 4],
                [5, 2, 4, 2],
                [1, 2, 0, 1]])
 
newarr = arr.reshape(2, 2, 3)
 
print ("\nOriginal array:\n", arr)
print ("Reshaped array:\n", newarr)
 
# Flatten array
arr = np.array([[1, 2, 3], [4, 5, 6]])
flarr = arr.flatten()
 
print ("\nOriginal array:\n", arr)
print ("Fattened array:\n", flarr)

Producción :

Array created using passed list:
 [[ 1.  2.  4.]
 [ 5.  8.  7.]]

Array created using passed tuple:
 [1 3 2]

An array initialized with all zeros:
 [[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]

An array initialized with all 6s. Array type is complex:
 [[ 6.+0.j  6.+0.j  6.+0.j]
 [ 6.+0.j  6.+0.j  6.+0.j]
 [ 6.+0.j  6.+0.j  6.+0.j]]

A random array:
 [[ 0.46829566  0.67079389]
 [ 0.09079849  0.95410464]]

A sequential array with steps of 5:
 [ 0  5 10 15 20 25]

A sequential array with 10 values between 0 and 5:
 [ 0.          0.55555556  1.11111111  1.66666667  2.22222222  2.77777778
  3.33333333  3.88888889  4.44444444  5.        ]

Original array:
 [[1 2 3 4]
 [5 2 4 2]
 [1 2 0 1]]
Reshaped array:
 [[[1 2 3]
  [4 5 2]]

 [[4 2 1]
  [2 0 1]]]

Original array:
 [[1 2 3]
 [4 5 6]]
Fattened array:
 [1 2 3 4 5 6]

3. Indexación de arrays: conocer los conceptos básicos de la indexación de arrays es importante para analizar y manipular el objeto de la array. NumPy ofrece muchas formas de indexar arrays.

• Rebanado: al igual que las listas en python, las arrays NumPy se pueden rebanar. Como las arrays pueden ser multidimensionales, debe especificar un sector para cada dimensión de la array.
• Indexación de arrays enteras: en este método, se pasan listas para la indexación de cada dimensión. El mapeo uno a uno de los elementos correspondientes se realiza para construir una nueva array arbitraria.
• Indexación de arrays booleanas: este método se utiliza cuando queremos seleccionar elementos de una array que cumplan alguna condición.

# Python program to demonstrate
# indexing in numpy
import numpy as np
 
# An exemplar array
arr = np.array([[-1, 2, 0, 4],
                [4, -0.5, 6, 0],
                [2.6, 0, 7, 8],
                [3, -7, 4, 2.0]])
 
# Slicing array
temp = arr[:2, ::2]
print ("Array with first 2 rows and alternate"
                    "columns(0 and 2):\n", temp)
 
# Integer array indexing example
temp = arr[[0, 1, 2, 3], [3, 2, 1, 0]]
print ("\nElements at indices (0, 3), (1, 2), (2, 1),"
                                    "(3, 0):\n", temp)
 
# boolean array indexing example
cond = arr > 0 # cond is a boolean array
temp = arr[cond]
print ("\nElements greater than 0:\n", temp)

Producción :

Array with first 2 rows and alternatecolumns(0 and 2):
 [[-1.  0.]
 [ 4.  6.]]

Elements at indices (0, 3), (1, 2), (2, 1),(3, 0):
 [ 4.  6.  0.  3.]

Elements greater than 0:
 [ 2.   4.   4.   6.   2.6  7.   8.   3.   4.   2. ]

4. Operaciones básicas: NumPy proporciona una plétora de funciones aritméticas integradas.

• Operaciones en una sola array: podemos usar operadores aritméticos sobrecargados para realizar operaciones por elementos en una array para crear una nueva array. En el caso de los operadores +=, -=, *=, se modifica la array existente.

# Python program to demonstrate
# basic operations on single array
import numpy as np
 
a = np.array([1, 2, 5, 3])
 
# add 1 to every element
print ("Adding 1 to every element:", a+1)
 
# subtract 3 from each element
print ("Subtracting 3 from each element:", a-3)
 
# multiply each element by 10
print ("Multiplying each element by 10:", a*10)
 
# square each element
print ("Squaring each element:", a**2)
 
# modify existing array
a *= 2
print ("Doubled each element of original array:", a)
 
# transpose of array
a = np.array([[1, 2, 3], [3, 4, 5], [9, 6, 0]])
 
print ("\nOriginal array:\n", a)
print ("Transpose of array:\n", a.T)

Producción :

Adding 1 to every element: [2 3 6 4]
Subtracting 3 from each element: [-2 -1  2  0]
Multiplying each element by 10: [10 20 50 30]
Squaring each element: [ 1  4 25  9]
Doubled each element of original array: [ 2  4 10  6]

Original array:
 [[1 2 3]
 [3 4 5]
 [9 6 0]]
Transpose of array:
 [[1 3 9]
 [2 4 6]
 [3 5 0]]

• Operadores unarios: muchas operaciones unarias se proporcionan como método de la clase ndarray . Esto incluye suma, mínimo, máximo, etc. Estas funciones también se pueden aplicar por filas o por columnas configurando un parámetro de eje.

# Python program to demonstrate
# unary operators in numpy
import numpy as np
 
arr = np.array([[1, 5, 6],
                [4, 7, 2],
                [3, 1, 9]])
 
# maximum element of array
print ("Largest element is:", arr.max())
print ("Row-wise maximum elements:",
                    arr.max(axis = 1))
 
# minimum element of array
print ("Column-wise minimum elements:",
                        arr.min(axis = 0))
 
# sum of array elements
print ("Sum of all array elements:",
                            arr.sum())
 
# cumulative sum along each row
print ("Cumulative sum along each row:\n",
                        arr.cumsum(axis = 1))

Producción :

Largest element is: 9
Row-wise maximum elements: [6 7 9]
Column-wise minimum elements: [1 1 2]
Sum of all array elements: 38
Cumulative sum along each row:
[[ 1  6 12]
 [ 4 11 13]
 [ 3  4 13]]

• Operadores binarios: estas operaciones se aplican en la array por elementos y se crea una nueva array. Puede usar todos los operadores aritméticos básicos como +, -, /, , etc. En el caso de los operadores +=, -=, =, se modifica la array existente.

# Python program to demonstrate
# binary operators in Numpy
import numpy as np
 
a = np.array([[1, 2],
            [3, 4]])
b = np.array([[4, 3],
            [2, 1]])
 
# add arrays
print ("Array sum:\n", a + b)
 
# multiply arrays (elementwise multiplication)
print ("Array multiplication:\n", a*b)
 
# matrix multiplication
print ("Matrix multiplication:\n", a.dot(b))

Producción:

Array sum:
[[5 5]
 [5 5]]
Array multiplication:
[[4 6]
 [6 4]]
Matrix multiplication:
[[ 8  5]
 [20 13]]

• Funciones universales (ufunc): NumPy proporciona funciones matemáticas familiares como sin, cos, exp, etc. Estas funciones también operan por elementos en una array, produciendo una array como salida.

Nota: Todas las operaciones que hicimos anteriormente usando operadores sobrecargados se pueden hacer usando ufuncs como np.add, np.subtract, np.multiply, np.divide, np.sum, etc. 

# Python program to demonstrate
# universal functions in numpy
import numpy as np
 
# create an array of sine values
a = np.array([0, np.pi/2, np.pi])
print ("Sine values of array elements:", np.sin(a))
 
# exponential values
a = np.array([0, 1, 2, 3])
print ("Exponent of array elements:", np.exp(a))
 
# square root of array values
print ("Square root of array elements:", np.sqrt(a))

Producción:

Sine values of array elements: [  0.00000000e+00   1.00000000e+00   1.22464680e-16]
Exponent of array elements: [  1.           2.71828183   7.3890561   20.08553692]
Square root of array elements: [ 0.          1.          1.41421356  1.73205081]

4. Clasificación de arrays: hay un método np.sort simple para clasificar arrays NumPy. Vamos a explorarlo un poco. 

# Python program to demonstrate sorting in numpy
import numpy as np
 
a = np.array([[1, 4, 2],
                 [3, 4, 6],
              [0, -1, 5]])
 
# sorted array
print ("Array elements in sorted order:\n",
                    np.sort(a, axis = None))
 
# sort array row-wise
print ("Row-wise sorted array:\n",
                np.sort(a, axis = 1))
 
# specify sort algorithm
print ("Column wise sort by applying merge-sort:\n",
            np.sort(a, axis = 0, kind = 'mergesort'))
 
# Example to show sorting of structured array
# set alias names for dtypes
dtypes = [('name', 'S10'), ('grad_year', int), ('cgpa', float)]
 
# Values to be put in array
values = [('Hrithik', 2009, 8.5), ('Ajay', 2008, 8.7),
           ('Pankaj', 2008, 7.9), ('Aakash', 2009, 9.0)]
            
# Creating array
arr = np.array(values, dtype = dtypes)
print ("\nArray sorted by names:\n",
            np.sort(arr, order = 'name'))
             
print ("Array sorted by graduation year and then cgpa:\n",
                np.sort(arr, order = ['grad_year', 'cgpa']))

Producción:

Array elements in sorted order:
[-1  0  1  2  3  4  4  5  6]
Row-wise sorted array:
[[ 1  2  4]
 [ 3  4  6]
 [-1  0  5]]
Column wise sort by applying merge-sort:
[[ 0 -1  2]
 [ 1  4  5]
 [ 3  4  6]]

Array sorted by names:
[('Aakash', 2009, 9.0) ('Ajay', 2008, 8.7) ('Hrithik', 2009, 8.5)
 ('Pankaj', 2008, 7.9)]
Array sorted by graduation year and then cgpa:
[('Pankaj', 2008, 7.9) ('Ajay', 2008, 8.7) ('Hrithik', 2009, 8.5)
 ('Aakash', 2009, 9.0)]

Entonces, esta fue una introducción breve pero concisa con tutorial de la biblioteca NumPy. Para un estudio más detallado, consulte la Guía de referencia de NumPy . Este artículo es una contribución de Nikhil Kumar. Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.