Contenido

Librerías de Python para el Análisis de datos ....................................................................... 2

La dupla dinámica NumPy y Pandas ..................................................................................... 2
NumPy........................................................................................................................................ 2
Instalando NumPy ................................................................................................................ 3
Primeros Pasos ................................................................................................................... 3
Diferencia entre una lista de Python y un array NumPy ............................................... 4
¿Qué es un Array?................................................................................................................. 5
Creando un array básico .................................................................................................... 6
Generando arrays de forma aleatoria .......................................................................... 10
Operaciones básicas en arrays ............................................................................................ 12
Indexación y slicing ......................................................................................................... 12
Operaciones básicas (+, -, *, /) .............................................................................. 14
Operaciones vectorizadas y broadcasting en NumPy ....................................................... 15
Funciones matemáticas básicas en NumPy ........................................................................ 17
La indexación booleana y el filtrado de datos en NumPy................................................. 18
Funciones avanzadas en NumPy ......................................................................................... 20
Formas de un array NumPy ................................................................................................. 23
Referencias .......................................................................................................................... 24

Lic. Soria Juan Pablo - 2024

Librerías de Python para el Análisis de datos

La dupla dinámica NumPy y Pandas

En conjunto, NumPy y Pandas proveen una amplia variedad de herramientas para el manejo
y manipulación de datos en Python. NumPy permite realizar operaciones vectorizadas y
eficientes sobre grandes cantidades de datos, mientras que Pandas provee herramientas
especializadas para el manejo y filtrado de datos en forma tabular.
Además, Pandas también provee herramientas para la lectura y escritura de datos en
diferentes formatos, lo que permite integrar y analizar datos de diferentes fuentes con
facilidad.
Por estas razones, NumPy y Pandas son librerías ampliamente utilizadas en Python en
muchos campos, desde finanzas hasta ciencia de datos y más allá.

NumPy
NumPy[1] (Numerical Python) es una librería de código abierto de Python, implementada en
C y C++, que se utiliza para el procesamiento numérico y científico de datos. Se enfoca en el
manejo de arreglos multidimensionales y matrices numéricas.
Entre las características principales de NumPy, se encuentran:
• Arreglos multidimensionales: permite crear arreglos multidimensionales de forma
sencilla, lo que facilita el manejo y procesamiento de grandes cantidades de datos
numéricos.
• Funciones matemáticas y estadísticas: provee una gran variedad de funciones
matemáticas y estadísticas para realizar operaciones sobre arreglos, como sumas,
productos, cálculo de promedios, medianas, desviaciones estándar, entre otras.
• Indexación y selección avanzada: permite seleccionar y manipular elementos de un
arreglo de forma avanzada, como seleccionar elementos por rango, por posición, por
valores booleanos y más.
• Operaciones vectorizadas: permite realizar operaciones matemáticas y estadísticas
de forma vectorizada, lo que significa que se pueden aplicar estas operaciones a todo
el arreglo en una sola operación, lo que resulta en un procesamiento más rápido y
eficiente.

Lic. Soria Juan Pablo - 2024

 • Integración con otras librerías: se integra bien con otras librerías populares en
Python, como Matplotlib, SciPy y Pandas, lo que permite realizar análisis de datos
más avanzados y completos.
El uso de NumPy permite el procesamiento y análisis eficiente de grandes conjuntos de
datos, lo que lo convierte en una herramienta esencial para cualquier analista de datos.

Instalando NumPy
NumPy no viene instalada por defecto con Python. Sin embargo, es muy fácil de instalar a
través del gestor de paquetes pip de Python.

pip install numpy

Este comando descargará e instalará NumPy y todas sus dependencias automáticamente.

Una vez que se complete la instalación, podremos comenzar a utilizarlo en nuestro código
Python.
También es importante mencionar que, en algunas distribuciones de Python, como
Anaconda, ya viene instalado por defecto, por lo que, en esos casos no es necesario
instalarlo por separado.

Primeros Pasos
Para acceder a NumPy y sus funciones, hay que importarlo en el código Python de esta
manera:

import numpy as np

Acortamos el nombre importado np (alias) para una mejor legibilidad del código usando
NumPy. Esta es una convención ampliamente adoptada que deberíamos seguir para que
cualquier persona que trabaje con nuestro código pueda entenderla fácilmente.

arr = [Link]([1,2,3,4,5,6])
print(f"El array 'a': {arr}") #Mostramos el array "arr"

a1rr = [Link]([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

print(f"El array 'a1': {a1rr}") #Mostramos la matriz "a1rr"

Lic. Soria Juan Pablo - 2024

 El array 'a': [1 2 3 4 5 6]
El array 'a1': [[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]

Diferencia entre una lista de Python y un array NumPy

Si bien una lista de Python puede contener diferentes tipos de datos, los elementos de una
matriz [2] NumPy deben ser homogéneos. Las operaciones matemáticas que deben realizarse
en matrices serían extremadamente ineficientes si las matrices no fueran homogéneas.
Las matrices NumPy son más rápidas y compactas que las listas de Python. Una matriz
consume menos memoria y es conveniente de usar. NumPy usa mucha menos memoria para
almacenar datos y proporciona un mecanismo para especificar los tipos de datos, debido a su
implementación en C y C++. Esto permite optimizar aún más el código.
Un ejemplo: “Supongamos que queremos calcular la suma de dos vectores de 100000
elementos cada uno.”

#Con listas de Python

import time

alist = list(range(100000))
blist = list(range(100000))

inicio = [Link]()

clist = list(map(lambda x, y: x+y, alist, blist))

fin = [Link]()
total_proceso = fin - inicio

print(f"El proceso duró {total_proceso} sec")

El proceso duró 0.006024599075317383 sec

En Python, usamos una lista para almacenar los elementos de cada vector y luego usamos
la función map() para sumar los elementos de cada lista.
Mientras que en NumPy, podemos crear dos arrays de 100000 elementos cada uno y luego
sumarlos directamente usando el operador ‘+’:

Lic. Soria Juan Pablo - 2024

 # Usando un array NumPy
import numpy as np
import time

arr = [Link](100000)
brr = [Link](100000)

inicio = [Link]()
crr = arr + brr

fin = [Link]()
total_proceso = fin - inicio
print(f"El proceso duró {total_proceso} sec")

El proceso duró 0.00100159645080566 sec

El segundo enfoque es mucho más eficiente ya que el array NumPy está optimizado para
realizar operaciones vectorizadas, mientras que el enfoque de lista de Python es menos
eficiente en términos de tiempo de ejecución.

¿Qué es un Array?
Un array es una estructura de datos fundamental en NumPy que consiste en una grilla de
valores. Contiene información sobre los datos, cómo ubicarlos y cómo interpretarlos. Los
elementos en un array son todos del mismo tipo y se pueden indexar de varias maneras.
El rank del array se refiere al número de dimensiones, mientras que el shape es una tupla
que describe el tamaño de la matriz a lo largo de cada dimensión.
Una forma común de inicializar un array en NumPy es usando listas de Python anidadas para
datos de dos o más dimensiones.

# Usando un array NumPy

import numpy as np

arr = [Link]([10,15,20,25,30,35])
print(arr)

[10 15 20 25 30 35]

Lic. Soria Juan Pablo - 2024

 arr = [Link]([[10, 20, 30, 40], [15, 25, 35, 45], [25, 45, 65, 85]])
print(arr)

[[10 20 30 40]
[15 25 35 45]
[25 45 65 85]]

Los elementos de un array NumPy se pueden acceder utilizando corchetes ‘[ ]’. Es importante
tener en cuenta que, al igual que en otras estructuras de datos en Python, la indexación en
NumPy comienza en 0. Esto significa que, si deseamos acceder al primer elemento de un array,
deberemos utilizar la indexación 0.

print(arr[0])

[10 20 30 40]

Creando un array básico

Para crear un array en NumPy usaremos la función [Link](). Lo único que debemos
hacer es pasar una lista de Python. Además, es posible especificar el tipo de dato del array,
aunque es opcional.

arr = [Link]([10, 20, 30])

print(f"Un array del tipo int: {arr}\n")

brr = [Link]([10, 20, 30], 'float')

print(f"Un array del tipo float: {brr}")

Un array del tipo int: [10 20 30]

Un array del tipo float: [10. 20. 30.]

Visualmente la estructura simplificada de un array de NumPy sería la siguiente:

Lic. Soria Juan Pablo - 2024

 Ilustración 1

En este caso, el rank de la matriz es igual a uno, por lo tanto, es de una sola dimensión, lo
que se conoce como un vector. Su shape es igual a (3,), lo que indica que tiene tres elementos
en la dimensión de las filas y ninguno en la dimensión de las columnas.

Los arreglos y las operaciones de arreglos pueden ser mucho más

complicados de lo que se pretende mostrar aquí.

#calculando shape
print(f"El tamaño de arr: {[Link](arr)} }\n ") #Una forma de usar shape
print(f"El tamaño de arr: {[Link]}") #Otra forma de usar shape

El tamaño de arr: (3,)

El tamaño de arr: (3,)

#calculando el rank

print(f"La dimensión de arr: {[Link](arr)}\n") #Una forma de obtener el rank

print(f"La dimensión de arr: {[Link]}") #Otra forma de obtener el rank

La dimensión de arr: 1
La dimensión de arr: 1

#Otro ejemplo

brr = [Link]([[10, 20, 30], [15, 25, 35], [5, 9, 3]], 'float')
print(f"El tamaño de brr: {[Link](brr)}")
print(f"La dimensión de brr: {[Link](brr)}")

Lic. Soria Juan Pablo - 2024

 El tamaño de brr: (3, 3)
La dimensión de brr: 2

zeros()
La función [Link]() es una función de NumPy que permite crear un array con todos sus
elementos iguales a cero. Esta función recibe como argumento una tupla que indica las
dimensiones del array que se desea crear.

>> [Link](2) #array([0. 0.])

Ejemplo de una matriz de ceros.

crr = [Link]((2, 3, 4)) #Creo un array donde los valores de las celdas son
igual a 0.

print(f"El tamaño de crr: {[Link](crr)}")

print(f"La dimensión de crr: {[Link](crr)}")

El tamaño de crr: (2, 3, 4)

La dimensión de crr: 3

ones()
O crear un array con solo 1’s. Usando la función [Link]().
Su sintaxis básica:

>> [Link](shape, dtype=None, order='C')

• shape: especifica el tamaño del array. Por ejemplo, si se desea crear un array de
2x2x2, el parámetro shape será igual a (2, 2, 2).
• dtype: Es un parámetro opcional que especifica el tipo de datos de los elementos del
array. Si no se especifica, se utiliza el tipo de datos por defecto de NumPy, que es
float64.
• order: Es un parámetro opcional que especifica la manera en que se almacenan los
elementos del array en la memoria. Los dos valores posibles son ‘C’ (por defecto) para
el orden de fila principal (estilo C) y ‘F’ para el orden de columna principal (estilo
Fortran).

Lic. Soria Juan Pablo - 2024

Ejemplo:
arr = [Link]((2, 2, 2))
print(arr)

[[[1. 1.]
[1. 1.]]
[[1. 1.]
[1. 1.]]]

La función [Link]() es útil para crear matrices de unos, las cuales pueden ser utilizadas en
operaciones matemáticas como multiplicación de matrices, cálculo de determinantes, etc.

arange()
Se puede crear un array de valores separados uniformemente dentro de un intervalo dado
con [Link](). Donde el primer argumento es el inicio del intervalo, el segundo
argumento es el final del intervalo y el tercer argumento es el tamaño del paso entre los
valores en el array.

arr = [Link](10, 40, 5)

print(arr)

[10 15 20 25 30 35]

linspace()
Otra función de NumPy para crear arrays es [Link](), la cual toma como entrada un
valor de inicio, un valor de finalización y la cantidad de elementos que se desean en la
secuencia y genera una secuencia de números equidistantes comenzando desde el valor de
inicio y avanzando hasta el valor de finalización, con la cantidad de elementos especificada

arr = [Link](10, 40, 5)

print(arr) #muestra un array equidistantes entre el [inicio, final)

[10. 17.5 25. 32.5 40.]

Lic. Soria Juan Pablo - 2024

Generando arrays de forma aleatoria
NumPy maneja una sub-libreia [Link][3] la cual produce números pseudoaleatorios
usando combinaciones de BitGenerator para crear secuencias y Generator para muestrear
diferentes distribuciones estadísticas usando esas secuencias.
Generadores de bits (BitGenerator): Objetos que generan números aleatorios.
Suelen ser palabras enteras sin signo llenas de secuencias de 32 o 64 bits
aleatorios.
Generadores (Generador): Objetos que transforman secuencias de bits
aleatorios de un BitGenerator en secuencias de números que siguen una
distribución de probabilidad específica (como uniforme, Normal o Binomial)
dentro de un intervalo especificado.
La función [Link]() es una de las funciones más utilizadas para generar arrays
de números aleatorios en NumPy. Esta función devuelve un array de números aleatorios en
el rango [0,1) con la forma especificada.
La sintaxis básica de [Link]() es la siguiente:

>> [Link](d0, d1, ..., dn)

Parámetros: d0, d1, …, dn Las dimensiones del array devuelto deben ser no negativas. Si
no se proporciona ningún argumento, se devuelve un solo flotante de Python.

[Link](2, 2, 3) # un array de 2x3 de números aleatorios en el rango

[0,1)

[[[0.76495189 0.19531789 0.96660526]

[0.0584992 0.69544292 0.73347273]]
[[0.69433723 0.92766171 0.94534571]
[0.01905184 0.27109329 0.94576972]]]

Lic. Soria Juan Pablo - 2024

Las funciones más comunes de [Link]
• [Link]: genera un array de números enteros aleatorios de un rango
dado.
• [Link]: genera un array de números aleatorios en el intervalo [0.0,
1.0).
• [Link]: genera una matriz de números aleatorios con distribución
normal estándar (media 0 y desviación estándar 1).
• [Link]: genera una matriz de números aleatorios con distribución
normal con media y desviación estándar personalizadas.
• [Link]: genera una matriz de números aleatorios uniformemente
distribuidos en un intervalo dado.

import numpy as np
import [Link] as plt

arr = [Link](10000)
print(arr)

[Link](arr, bins=50, density=True)

[Link]("Distribución normal con media 0 y desviación estándar 1")

[Link]("Valor")
[Link]("Frecuencia")

[Link]()

[-0.57250617 -0.68567959 -1.0457098… … 0.15931952 2.44208039

-0.08799454]

Lic. Soria Juan Pablo - 2024

NumPy proporciona varias funciones para generar números aleatorios, incluyendo
distribuciones uniformes, normales y personalizadas. Estas funciones son útiles en muchas
aplicaciones, como simulaciones, análisis de datos y aprendizaje automático, donde se
requiere la generación de datos aleatorios o la selección de muestras aleatorias de una
población.

Operaciones básicas en arrays

Las operaciones básicas con arrays incluyen la indexación, slicing y el acceso a elementos
individuales. Esto permite trabajar con arrays de manera similar a como se trabaja con listas
y otros tipos de estructuras en Python. Además, estas operaciones permiten realizar
manipulaciones de datos de manera más rápida y eficiente que con otros métodos.
Otro aspecto fundamental es la realización de operaciones matemáticas básicas como la
suma, la resta, la multiplicación y la división, entre otras. Estas operaciones permiten realizar
cálculos y análisis de datos de manera más eficiente y con una mayor precisión.

Indexación y slicing
En NumPy la indexación permite acceder y manipular elementos individuales o grupos de
elementos de un array de manera eficiente. Es similar a la indexación en listas de Python.
Los elementos de un array se pueden acceder mediante índices enteros o, en el caso de arrays
multidimensionales, mediante tuplas de índices enteros.

Lic. Soria Juan Pablo - 2024

#Ejemplo nro1 - índice

arr = [Link]([1, 2, 3, 4, 5]) #matriz de una dimensión.

print(arr[2]) # salida: 3

#Ejemplo nro2 - tuplas

arr = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) #matriz de dos dimensiones.
print(arr[0, 2]) # salida: 3

Además, NumPy ofrece indexación avanzada, que permite acceder a elementos de un array
mediante una lista de índices o un array booleano. Esto resulta útil en aplicaciones de filtrado
y selección de datos.

#generemos un array de dimensión 3 de 5x5

[Link](42)
arr = [Link](1, 10, size=(3, 5, 5)) #Generamos un array aleateorio
de enteros
print(arr)

[[[7 4 8 5 7]
[3 7 8 5 4]
[8 8 3 6 5]
[2 8 6 2 5]
[1 6 9 1 3]]

[[7 4 9 3 5]
[3 7 5 9 7]
[2 4 9 2 9]
[5 2 4 7 8]
[3 1 4 2 8]]

[[4 2 6 6 4]
[6 2 2 4 8]
[7 9 8 5 2]
[5 8 9 9 1]
[9 7 9 8 1]]]

Listas de índices
Supongamos que queremos obtener la fila [2, 8, 6, 2, 5] del array arr generado.

Lic. Soria Juan Pablo - 2024

print(arr[0, 3])

[2 8 6 2 5]

Para seleccionar la sub-fila [2, 8, 6, 2, 5], lo primero que debemos hacer es ubicar el
array en el que se encuentra dicha sub-fila. Luego, debemos indicar la posición donde se
encuentra su primer elemento para poder realizar la indexación adecuada y obtener la
subfila deseada.
Otro ejemplo. Supongamos que queremos seleccionar ahora la siguientes sub-filas

>> sub_fila = [[8, 8, 3, 6, 5], [2, 4, 9, 2, 9]]

print(arr[0:2, 2])

[[8 8 3 6 5]
[2 4 9 2 9]]

Seleccionamos los arrays que contienen las sub-filas deseadas y luego identificar la posición
de las filas para obtener ambas sub-filas completas.

Operaciones básicas (+, -, *, /)

NumPy proporciona operaciones aritméticas básicas para trabajar con arrays
multidimensionales.
La suma de dos arrays se realiza elemento a elemento y se puede realizar utilizando el
operador ‘+’. Por ejemplo:

arr1 = [Link]([[1, 2], [3, 4]])

arr2 = [Link]([[5, 6], [7, 8]])

print(arr1 + arr2)

[[6 8]
[10 12]]

Lic. Soria Juan Pablo - 2024

La resta de dos arrays también se realiza elemento a elemento y se puede realizar utilizando
el operador ‘-’. Por ejemplo:

arr1 = [Link]([[1, 2], [3, 4]])

arr2 = [Link]([[5, 6], [7, 8]])

print(arr1 - arr2)

[[-4 -4]
[-4 -4]]
La multiplicación de dos arrays se realiza elemento a elemento, y se puede realizar utilizando
el operador ‘*’. Por ejemplo:

arr1 = [Link]([[1, 2], [3, 4]])

arr2 = [Link]([[5, 6], [7, 8]])

print(arr1 * arr2)

[[ 5 12]
[21 32]]

La división de dos arrays también se realiza elemento a elemento, y se puede realizar

utilizando el operador ‘/‘. Por ejemplo:

arr1 = [Link]([[1, 2], [3, 4]])

arr2 = [Link]([[5, 6], [7, 8]])
print(arr1 / arr2)

[[0.2 0.33333333]
[0.42857143 0.5]]

Es importante tener en cuenta que cuando se realiza una operación entre dos arrays, los
dos arrays deben tener la misma forma o una forma que se pueda transmitir.

Operaciones vectorizadas y broadcasting en NumPy

En NumPy, las operaciones vectorizadas son aquellas que permiten aplicar una función u
operación a todo un array de forma simultánea, sin necesidad de iterar por cada elemento del
mismo. Esto se logra gracias a que NumPy permite trabajar con arrays de datos de forma

Lic. Soria Juan Pablo - 2024

homogénea y eficiente, lo que permite realizar cálculos de manera más rápida y sencilla.
Como se vio en la sección anterior.
Sin embargo, NumPy también permite realizar operaciones entre arrays de formas diferentes
a través del broadcasting. El broadcasting es un mecanismo que permite tratar arrays de
diferentes formas como si tuvieran la misma forma, y, por lo tanto, realizar operaciones
vectorizadas entre ellos.

arr = [Link]([[1, 2], [3, 4]])

brr = 2
crr = arr + brr
print(crr)

[[3 4]
[5 6]]

En este caso, NumPy realiza automáticamente la operación de broadcasting para que el

escalar brr tenga la misma forma que el array arr. El resultado de esta operación será un
nuevo array crr con la misma forma que arr, donde cada elemento de crr es la suma del
elemento correspondiente de arr y el escalar brr.
Además de la suma, NumPy también permite realizar otras operaciones vectorizadas como la
resta (-), la multiplicación (*) y la división (/), así como otras operaciones más avanzadas
como la exponenciación (**) y la comparación (<, >, ==, !=, etc.). Todas estas
operaciones pueden ser aplicadas tanto a arrays de NumPy como a escalares, y pueden ser
combinadas con el broadcasting para realizar operaciones entre arrays de formas
diferentes
Veamos algunos ejemplos:

#Comparación de dos arrays

arr1 = [Link]([1, 2, 3, 4, 5])
arr2 = [Link]([3, 2, 1, 4, 6])

# Comparación de elementos de los dos arrays

resultado = arr1 >= arr2
print(resultado)

[False True True True False]

Lic. Soria Juan Pablo - 2024

#Potencia de cada elemento de un array
arr = [Link]([1, 2, 3, 4, 5])

# Potencia de cada elemento del array

result = arr ** 2
print(result)

[ 1 4 9 16 25]

Funciones matemáticas básicas en NumPy

NumPy proporciona numerosas funciones matemáticas para realizar operaciones en
matrices y arrays. Algunas de las funciones matemáticas básicas en NumPy son:
• [Link](): calcula la media de los elementos del array.
• [Link](): calcula la desviación estándar de los elementos del array.
• [Link](): calcula la suma de los elementos del array.
• [Link](): encuentra el valor máximo en el array.
• [Link](): encuentra el valor mínimo en el array.
Estas funciones son muy útiles para analizar y resumir datos en un array. Por ejemplo, si
tenemos un array x con algunos datos, podemos calcular su media, desviación estándar,
suma, máximo y mínimo de la siguiente manera:

[Link](42)
x = [Link](1, 2)

media = [Link](x)
desviacion_estandar = [Link](x)
suma = [Link](x)
maximo = [Link](x)
minimo = [Link](x)

print("Media:", media)
print("Desviación estándar:", desviacion_estandar)
print("Suma:", suma)
print("Máximo:", maximo)
print("Mínimo:", minimo)

Lic. Soria Juan Pablo - 2024

 Media: 0.179224925920024
Desviación estándar: 0.31748922709120864
Suma: 0.358449851840048
Máximo: 0.4967141530112327
Mínimo: -0.13826430117118466

Además de estas funciones básicas, NumPy también proporciona muchas otras funciones
matemáticas [4] útiles para realizar diversas operaciones en arrays y matrices.

La indexación booleana y el filtrado de datos en NumPy

La indexación booleana y el filtrado de datos en NumPy permiten seleccionar elementos de
un array que cumplan una determinada condición booleana o que se encuentren en un rango de
valores específicos. Esto se realiza utilizando máscaras booleanas, que son arrays con el
mismo tamaño que el array original y cuyos elementos son valores booleanos True o False, en
función de si la condición se cumple o no para cada elemento.
Por ejemplo: Queremos seleccionar todos los elementos de un array arr que sean mayores
que 5.

arr = [Link]([1, 3, 5, 7, 9])

mask = arr > 5
print(arr[mask])

[7 9]
La máscara booleana mask será un array con los valores [False, False, False, True, True], ya
que los dos últimos elementos de arr cumplen la condición arr > 5.

arr = [Link]([1, 2, 3, 4, 5, 6, 7, 8, 9])

umbral = 5

# Indexación booleana
mascara = arr > umbral
resultados = arr[mascara]

print(resultados)

[6 7 8 9]

Lic. Soria Juan Pablo - 2024

También es posible combinar múltiples condiciones booleanas utilizando operadores lógicos
como & (and) y | (or), y utilizar funciones como np.logical_and() y np.logical_or() para
realizar operaciones lógicas más complejas en los arrays booleanos.
Ejemplos con & y |:

[Link](42)
arr = [Link](0, 10, size=(5, 5))
print("Array original:")
print(arr)

# Seleccionamos los elementos del array que son mayores que 5 y menores que 8
mask = (arr > 5) & (arr < 8)
selection = arr[mask]
print("\nElementos mayores que 5 y menores que 8:")
print(selection)

# Seleccionamos los elementos del array que son iguales a 2 o 4

mask = (arr == 2) | (arr == 4)
selection = arr[mask]
print("\nElementos iguales a 2 o 4:")
print(selection)

Array original:
[[6 3 7 4 6]
[9 2 6 7 4]
[3 7 7 2 5]
[4 1 7 5 1]
[4 0 9 5 8]]

Elementos mayores que 5 y menores que 8:

[6 7 6 6 7 7 7 7]

Elementos iguales a 2 o 4:
[4 2 4 2 4 4]

Lic. Soria Juan Pablo - 2024

# Creamos un array aleatorio de 10 elementos
[Link](42)
arr = [Link](0, 10, size=10)
print(arr)
# Creamos una máscara booleana para seleccionar los elementos mayores que 3 y
menores que 8
mask = np.logical_and(arr > 3, arr < 8)

# Imprimimos los elementos que cumplen la condición

print("\nElementos mayores que 3 y menores que 8:")
print(arr[mask])

# Creamos una máscara booleana para seleccionar los elementos menores que 2 o
mayores que 8
mask2 = np.logical_or(arr < 2, arr > 8)

# Imprimimos los elementos que cumplen la condición

print("\nElementos menores a 2 o mayores a 8:")
print(arr[mask2])

[6 3 7 4 6 9 2 6 7 4]

Elementos mayores que 3 y menores que 8:

[6 7 4 6 6 7 4]

Elementos menores a 2 o mayores a 8:

[9]

Funciones avanzadas en NumPy

Las funciones avanzadas en NumPy ofrecen una amplia gama de funcionalidades para el
procesamiento de datos y el análisis numérico. A continuación, se presentan algunas de las
funciones avanzadas en NumPy.
• [Link](): Permite unir dos o más arrays a lo largo de un eje determinado.
• [Link](): Permite dividir un array en sub-arrays a lo largo de un eje determinado.
• [Link](): Permite encontrar los índices de los elementos de un array que cumplan
una determinada condición.
• [Link](): Permite encontrar los elementos únicos de un array y devolverlos en un
nuevo array.
• np.apply_along_axis(): Permite aplicar una función a lo largo de un eje determinado
del array.

Lic. Soria Juan Pablo - 2024

 • [Link](): Permite convertir una función que opera sobre elementos
individuales en una función que opera sobre arrays completos.
Estas funciones son muy útiles para realizar operaciones más avanzadas en NumPy y trabajar
con arrays de manera más eficiente.
Ejemplos con [Link]():

# Crear dos arrays

arr1 = [Link]([[1, 2], [3, 4]])
arr2 = [Link]([[5, 6]])

# Concatenar los dos arrays en la fila (eje 0)

concatenado = [Link]((arr1, arr2), axis=0)

# Imprimir el resultado
print(concatenado)

[[1 2]
[3 4]
[5 6]]

Este código creó dos arrays, arr1 y arr2, y luego concatenó arr2 debajo de arr1, creando
un nuevo array de forma (3, 2).
También podemos concatenar a lo largo de otras dimensiones especificando el parámetro
axis. Por ejemplo, si arr1 y arr2 son ambos arrays de forma (2, 3), podríamos concatenarlos
en la columna (eje 1) con:

arr_mod = arr2.T
print(arr_mod)
print(" ")
concatenado = [Link]((arr1, arr_mod), axis=1)
print(concatenado)

[[5]
[6]]

[[1 2 5]
[3 4 6]]

Aquí, arr2.T transpone arr2 antes de la concatenación para asegurarse de que tenga la
misma forma que arr1.

Lic. Soria Juan Pablo - 2024

Ejemplo [Link]():

#Ejemplo con [Link]()

arr = [Link]([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

# Dividimos el array en dos partes de 5 elementos cada una

partes = [Link](arr, 2)

print(partes)

[array([1, 2, 3, 4, 5]), array([ 6, 7, 8, 9, 10])]

[Link]() Es una función en NumPy que devuelve los índices de los elementos de un array
que cumplen cierta condición. Puede usarse para filtrar elementos que cumplan una cierta
condición, o para asignar valores a esos elementos.
La sintaxis básica de [Link]() es la siguiente:

>> [Link](condicion, [x, y])

Donde:
condición: es una expresión booleana.
x: es el valor que se asignará a los elementos que cumplan la condición.
y: es el valor que se asignará a los elementos que no cumplan la condición.
Si x e y no se especifican, [Link]() devuelve una tupla de índices que cumplen la
condición.

arr = [Link]([1, 2, 3, 4, 5])

brr = [Link](arr > 2) # devuelve una tupla de índices donde los elementos
son mayores que 2
crr = [Link](arr > 2, "mayor que 2", "menor o igual que 2") # devuelve un
#array con los elementos que cumplen la condición asignados a "mayor que 2" y
#los que no a "menor o igual que 2"

print(brr)
print(" ")
print(crr)

Lic. Soria Juan Pablo - 2024

 (array([2, 3, 4], dtype=int64),)

['menor o igual que 2' 'menor o igual que 2' 'mayor que 2' 'mayor que 2'
'mayor que 2']

[Link]() Es una función de NumPy que devuelve los valores únicos de un array. Puede
ser muy útil cuando se quiere obtener los valores únicos de un conjunto de datos,
especialmente si se está trabajando con grandes cantidades de datos.
La sintaxis básica de [Link]() es la siguiente:

>>[Link](arr, return_index=False, return_inverse=False,

return_counts=False, axis=None)

Donde:
ar: es el array de entrada.
return_index: si se establece como True, se devolverán los índices de los elementos
únicos.
return_inverse: si se establece como True, se devolverá un array de enteros del mismo
tamaño que ar que puede usarse para reconstruir ar.
return_counts: si se establece como True, se devolverá el número de veces que aparece
cada valor único en ar.
axis: el eje a lo largo del cual se realizará la operación. Si se omite, se operará en todo el
array.

arr = [Link]([1, 2, 3, 4, 4, 3, 2, 1])

unique_vals = [Link](arr)
print(unique_vals)

[1 2 3 4]

Formas de un array NumPy

La función reshape() en NumPy se utiliza para cambiar la forma de un array sin cambiar sus
datos. La sintaxis general es la siguiente:

>> new_array = [Link](array, new_shape)

Lic. Soria Juan Pablo - 2024

Donde:
array: es el array que se quiere cambiar de forma.
new_shape: es una tupla que indica la nueva forma deseada.
El número total de elementos en el nuevo array debe ser igual al número total de elementos
en el array original.
Por ejemplo, si tenemos un array de 1D con 12 elementos:

arr = [Link]([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

Podemos cambiarlo a un array de 2D con 4 filas y 3 columnas de la siguiente manera:

new_arr = [Link](arr, (4, 3))

print(new_arr)

[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]

También es posible usar -1 en la tupla new_shape para indicar que NumPy debe
determinar automáticamente la longitud de esa dimensión. Por ejemplo:

new_arr = [Link](arr, (4, -1))

print(new_arr)

[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]

Aquí, NumPy ha determinado automáticamente que la longitud de la segunda dimensión debe

ser 3, ya que eso es lo que se necesita para que el número total de elementos en el nuevo array
sea igual al número total de elementos en el array original.

Referencias
[1] NumPy documentation (2008). NumPy Developers.
[2] NumPy ¿Qué es una matriz? (2008). NumPy Documentation.
[3] NumPy Random sampling ([Link]) (2008). NumPy Documentation.
[4] Numpy Mathematical functions (2008). NumPy Documentation.

Lic. Soria Juan Pablo - 2024