Condiciones

Otra funcion muy util de numpy tambien es np.where(condicion, valor si, valor si la condicion no se cumple), ejemplo:

matriz = array([[19,  4, 43],
       [ 8, 96, 80],
       [ 6, 99, 35]])

np.where(matriz > 50, 0, 1)
--> 
array([[1, 1, 1],
       [1, 0, 0],
       [1, 0, 1]])

✅Condiciones

Las condiciones nos permiten hacer consultas más específicas.

arr = np.linspace(1,10,10, dtype = 'int8')
arr ----> array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10], dtype=int8)

Regresa un array de booleanos donde la condiciones se cumple.

indices_cond = arr > 5
indices_cond
----> array([False, False, False, False, False,  True,  True,  True,  True, True])

Regresa los valores para donde la condiciones True.

arr[indices_cond] ----> array([ 6,  7,  8,  9, 10], dtype=int8)

Se pueden agregar múltiples condiciones.

arr[(arr > 5) & (arr < 9)] ----> array([6, 7, 8], dtype=int8)

De igual forma modificar los valores que cumplan la condición.

arr[arr > 5] = 99
arr ----> array([ 1,  2,  3,  4,  5, 99, 99, 99, 99, 99], dtype=int8)

También se puede hacer con funciones normales y lambdas

arr = np.arange(1,11)

def number_is_even(num):
    return num % 2 == 0


number_is_even(arr)

lambda_func = lambda x: x % 2 == 0

lambda_func(arr)

• Numeros pares en el array

arr = np.linspace(1,10,10, dtype='int8')
arr ----> array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10], dtype=int8)

arr[(arr % 2 == 0)]
arr ----> array([ 2,  4,  6,  8, 10], dtype=int8)

• Numeros impares en el array

arr[(arr % 2 == 1)]
arr ----> array([1, 3, 5, 7, 9], dtype=int8)

• Divisibles por un numero en particular (5)

arr[(arr % 5 == 0)]
arr ----> array([ 5, 10], dtype=int8)

Mi aporte!!
Cree una matriz y le agregue dos condiciones.

Ya vimos que para AND en NumPy se usa &, pero para el OR que no lo vimos se hace así arr[(arr > 3) | (arr == 99)]

Ejercicios de condicionales:
Encontré distintos métodos para usar condicionales, Dado un array numpy:

vector = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
vector

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

Cuales elementos son igual a 3 ó mayor a 8 (logical_or).

np.logical_or(vector == 3 , vector > 8)

array([False, False, True, False, False, False, False, False, True])

Cuales elementos son menores a 3 y mayores a 6 (greater/less/logical_and).

np.logical_and(np.greater(vector,3), np.less(vector, 6))

array([False, False, False, True, True, False, False, False, False])

Cuales elementos no son iguales a 7 (logical_not).

np.logical_not(vector == 7)

array([ True, True, True, True, True, True, False, True, True])

Si es menor a 5 = 1, si no = 1 (asarray para usar list comprehensions).

resultado = np.asarray([0 if val < 5 else 1 for val in vector])
resultado

array([0, 0, 0, 0, 1, 1, 1, 1, 1])

Si es mayor que 5 le sumo cinco sino es nulo (where(condicional,resultado si es verdadero, si es falso )).

resultado = np.where(vector > 5, vector + 5, np.NaN)
resultado

array([nan, nan, nan, nan, nan, 11., 12., 13., 14.])

Mi aporte

arr = np.arange(1,101, dtype='int8')
print(arr)
print(arr[(arr % 2 == 0)]) #Pares
print(arr[(arr % 2 != 0)]) #Impares
print(arr[(arr % 3 == 0)]) #Multiplos de 3

np.where

También podemos utilizar np.where(<condición>) en lugar de hacer un slice de Verdaderos y Falsos.

np.where => Lista de arrays con los índices

flt = np.where(arr > 25)
flt
[O] (array([3, 4, 5, 6, 7, 8, 9], dtype=int64),)

[<condicion>] => Lista de Datos Booleanos

arr > 2
[O] array([False,  True,  True,  True,  True,  True,  True,  True,  True, True])

Ambos dan el mismo resultado.

arr[arr>25] == arr[flt]
[O] array([ True,  True,  True,  True,  True,  True,  True])

Sin embargo, no se puede realizar operaciones bitwise entre ambos ya que, probablemente, no tengan las mismas dimensiones y si las tienen, estas se relizan entre dos tuplas de valores booleanos, y como np.where nos devuelve una lista de indices (enteros), no existe método que implemente esta operación confiable para este caso entre ambos tipos.

Con la prueba anterior

arr[(arr>25) & flt] 
[O] ValueError: operands could not be broadcast together with shapes (10,) (1,7) 

Con filt = np.where(arr>-1)

arr[(arr>-1) & flt] 
[O] array([[ 0., 10.,  0., 10.,  0., 10.,  0., 10.,  0., 10.]])
# Absurdo, se esperaría: array([ 0., 10., 20., 30., 40., 50., 60., 70., 80., 90.])
# ya que ambas condiciones son iguales

Es un ejercicio muy sencillo pero creo que se ejemplifica el reto, a final de cuentas hago una operación que me trae del mazo de cartas las que son rojas.
¿Válido o no?

Jugando un poco …

import numpy as np
#Medidas de personas

medidas = np.linspace(1.51,1.99,10, dtype='float64')
medidas = np.round(medidas, 2)  # Redondea los valores a dos decimales
print(f"Estas son las medidas de 10 personas {medidas}")

#NECESITO QUE ME RETORNE CUANTAS PERSONAS MIDEN  MAS DE 1.59
mayores = medidas > 1.59
conteo = mayores.sum()
print(f"Estos son las personas mayores de 1.59: -> {conteo}")

#NECESITO QUE ME MUESTRE LOS DATOS MAYORES DE 1.59
datos_mayores = medidas[mayores]
print(f"Estos son las personas mayores de 1.59: -> {datos_mayores}")

#NECESITO CUANTAS PERSONAS  MIDEN MAS DE 1.59 PERO MENOS DE 1.71
entre = (medidas > 1.59) & (medidas < 1.71)
#en este caso especifico tengo que llamar el np. para que me lo convierta en un array
conteo2 = np.sum(entre)
print(f"Estos son las personas entre  1.59 - 1.71: -> {conteo2}")
datos_entre = medidas[entre]
print(f"Estos son las personas mayores de 1.59: -> {datos_entre}")

salidas:

Estas son las medidas de 10 personas [1.51 1.56 1.62 1.67 1.72 1.78 1.83 1.88 1.94 1.99]
Estos son las personas mayores de 1.59: -> 8
Estos son las personas mayores de 1.59: -> [1.62 1.67 1.72 1.78 1.83 1.88 1.94 1.99]
Estos son las personas entre 1.59 - 1.71: -> 2
Estos son las personas mayores de 1.59: -> [1.62 1.67]

aquí dejo un aporte usando una matriz sencilla con una condición para cambiar valores.

Propongo el siguiente ejemplo.

"""Acceder a los números impares que sean mayores a 35 y sumarles uno para que sean pares. """

import numpy as np
#crea una matriz aleatoria de números enteros
m = np.random.randint(0,100,(5,6))

#Crea una copia de la matriz m y la asigna a la variable m1.
m1 = m.copy()
print("m1: \n", m1)

#Crea las máscaras booleanas mask1 y mask2 a partir de los elementos de la matriz m1
#Si niego la mask1, entonces obtendré los números impares
mask1 = m1%2 == 0
mask2 = m1>35

#Selecciona los elementos de la matriz m1 que cumplen la condición ~mask1 & mask2 y los asigna a la variable m1_cond.
m1_cond = m1[~mask1&mask2]
print("cumplen con la condición: \n", m1_cond)

#Utiliza un ciclo for para modificar cada elemento de m1_cond sumándole 1
for i,num in enumerate(m1_cond):
    m1_cond[i] = num+1

#Asigna los elementos modificados de m1_cond a la matriz m1
m1[~mask1&mask2] = m1_cond
print("m1 modificada: \n",m1)

Acepto sugerencias para mejorar el código. Saludos

😮 Estas funciones están rotísimas, definitivamente NumPy me sorprende cada vez más

Un poco del sprint no vino mal 😃

Reto:

tensor = np.random.randint(0, 20, (3, 3, 2))
tensor.sort()
tensor
# -- > array([[[ 4,  9],
        				[ 8, 12],
       				  [ 1,  4]],

								[[ 1,  5],
       					 [ 2, 19],
       					 [ 3, 14]],

     					  [[13, 15],
        				 [ 3, 14],
       					 [14, 16]]])
      	
"FILTRADOS"
pares = tensor[(tensor%2) == 0]
pares.sort()
pares #array([ 2,  4,  4,  8, 12, 14, 14, 14, 16])

impares = tensor[(tensor%2) != 0]
impares.sort()
impares #array([ 1,  1,  3,  3,  5,  9, 13, 15, 19])

cifras_2 = tensor[(tensor//10) > 0]
cifras_2.sort()
cifras_2 #array([12, 13, 14, 14, 14, 15, 16, 19])

"divisibles entre 3 y divisibles entr 4."
multi_3_4 = tensor[(tensor%3 == 0) & (tensor%4 == 0)]
multi_3_4.sort()
multi_3_4 #array([12])

"potencia al cuadrado y raiz cuadrada par."
arr = tensor[((tensor**2)%2 == 0) & ((tensor**(1/2))%2 == 0)]
arr #array([ 4,  4, 16])

Excelente, en esta clase vimos que podíamos aplicar .copy() al arreglo para reemplazar los valores mayores a 5 sin afectar el valor original.

Me sorprende conocer el valor de las condiciones. Si que es interesante con su desarrollo y la forma de declararlo en python. Es muy bueno saber sus distintos tipos de usos.

![](

Me dió curiosidad como crear una matriz de manera “aleatoria” con linspace, les comparto una opción:

arr2 = np.linspace(1,0,10*5)
arr3 = np.random.shuffle(arr2)
arr2 = arr2.reshape(5,10)
arr2

Mi aporte:

matriz = np.random.randint(1,100,(3,3,3))
matriz

matriz[matriz % 2 == 0] = 0
matriz[matriz % 2 == 1] = 1
matriz

Y el resultado es el siguiente:

array([[[1, 0, 1],
        [1, 1, 1],
        [0, 0, 0]],

       [[1, 0, 1],
        [0, 0, 0],
        [0, 0, 1]],

       [[1, 1, 1],
        [0, 1, 0],
        [1, 1, 0]]])

✅

matriz = np.array([[19,  4, 43],[ 8, 96, 80],[ 6, 99, 35]])
array = np.array(np.where(matriz % 2 == 0, 1, 0),dtype="float64")
array

un aporte muy basico sobre el uso de where en Numpy.
where recibe 3 parametros, 1 que es la condicion, 2, si es cierto devuelve x de lo contrario devuelve y.

Me quede sorprendido con este código

arr = np.linspace(1,10,10, dtype = 'int8')

Que alguien lo explique matemáticamente? porque yo no lo entiendo muy bien, imagino que como son decimales muy pequeños y esta convertido a int, no podemos detectar el intervalo

Muy bacano como Numpy viene y nos muestra una mejor manera de manejar un iterable como lo es una lista.
mira:

arr_p = np.linspace(1,10,10, dtype="int8")
print(arr_p)
def using_for(arr_c):
    list_c = []
    for i in arr_c:
        if i  > 5:
            list_c.append(True)
        else:
            list_c.append(False)
    return list_c
print(using_for(arr_p))

con esas lineas de codigo estoy haciendo lo mismo que con tansolo en 1 linea de codigo resumido está usando numpy.
es una bestialidad.

my task

Conseguir todos los numeros que son pares en un array

arr[(arr % 2 == 0)] 

Encontré utilidad para esto ❤️

Extraer elementos pares e impares de una lista en Numpy:

& vs and

son operadores lógicos útiles para operaciones de conjunción (AND) entre condiciones booleanas. Sin embargo, hay diferencias sutiles entre ellos: El operador & realiza una evaluación a nivel de bit a bit, mientras que and realiza una evaluación lógica. Esto significa que & puede ser utilizado para operaciones de bits en enteros, mientras que and es exclusivamente utilizado para valores booleanos

Con and si la primera expresión es evaluada como falsa, no se evalúa la segunda expresión. En cambio, el operador & siempre evalúa ambas expresiones, sin importar el resultado de la primera

np.logical_and(cond_1, cond_2)

Se usa para combinar dos condiciones booleanas. Las evalúa elemento por elemento, creando un array booleano con los resultados. Luego, se utiliza este array booleano para indexar el array original y obtener los elementos que cumplen ambas condiciones

Todo indica que esta forma para establecer condiciones tiene el atributo “In_place” por defecto en True. Cada vez que se hace una modificación, sin necesidad de hacer una condición, cambia directamente el objeto en cuestión.

Numpy filtra datos utilizando los Booleanos: Donde sea False, el dato será excluido, donde sea True, el dato será incluido. Ej: Filtrar los datos que sean pares:

arr = np.array([1, 2, 3, 4, 5, 6, 7])
#Creamos una variable donde estará el filtro
filter_arr = []
# pasar por cada elemento en arr
for element in arr:
  # si el elemento es completamente divisible por 2, ponemos el valor en Verdadero, de lo contrario, Falso
  if element % 2 == 0:
    filter_arr.append(True)
  else:
    filter_arr.append(False)

newarr = arr[filter_arr]

print(filter_arr)
>>[False, True, False, True, False, True, False]
print(newarr)
>>[2 4 6]

Interesante esta clase

9. Condiciones

import numpy as np

arr = np.linspace(1,10,10, dtype='int8')
arr

indices = arr > 5 # condicionales normales aplicados a un array devuelve un array booleano
indices

arr[(arr>5)&(arr<9)]

arr[arr>5] = 99 # cambiar el valor de los condicionados
arr

arr[arr==99] # ingresar la condicion en square brackets

Para utilizar mas de una condición dentro de los arrays debemos utilizar operadores de conjuntos (Operadores del tipo de dato SET) en el video vimos la intersección, dejo algunos adicionales para recordarlos que son importantes.

| -> Union
& -> Interseccion (como en el ejemplo de la clase)
\ -> Diferencia
^ -> Diferencia simetrica

n NumPy, las condiciones se utilizan para crear arreglos o matrices booleanas que representan el resultado de una evaluación lógica en elementos de otro arreglo o matriz. Las condiciones en NumPy permiten realizar operaciones de filtrado, selección o asignación basadas en ciertas condiciones lógicas.

Las condiciones en NumPy se crean utilizando operadores lógicos como >, <, ==, !=, >=, <=, entre otros, para comparar elementos en arreglos o matrices. El resultado es un arreglo o matriz booleana, donde cada elemento es True o False en función de si la condición se cumple o no para el elemento correspondiente.

import numpy as np

# Crear un arreglo de ejemplo
arr = np.array([1, 2, 3, 4, 5])

# Crear una condición para verificar si los elementos son mayores a 3
condicion = arr > 3

# Imprimir la condición
print("Condición:", condicion)

# Crear un arreglo filtrado usando la condición
arr_filtrado = arr[condicion]

# Imprimir el arreglo filtrado
print("Arreglo filtrado:", arr_filtrado)

Salida :

Condición: [False False False  True  True]
Arreglo filtrado: [4 5]

En este ejemplo, se crea una condición para verificar si los elementos del arreglo arr son mayores a 3. La condición resultante es un arreglo booleano donde True indica que la condición se cumple y False indica que no se cumple. Luego, se utiliza esta condición para filtrar los elementos del arreglo original y crear un nuevo arreglo con los elementos que cumplen con la condición, en este caso, los elementos mayores a 3.

arr = np.linspace(1,10,10, dtype=“int8”)
arr[(arr >= 5)] += 2
arr

arr = np.linspace(1,10,10, dtype='int8')
arr

indices_dos = (arr > 5) & (arr < 9)

arr[indices_dos]

arr_copy = arr.copy()
arr_copy[arr_copy > 5] = 99
arr_copy
-->
array([ 1,  2,  3,  4,  5, 99, 99, 99, 99, 99], dtype=int8)

arr_copy[(arr_copy < 3) | (arr_copy == 99)]
-->
array([ 1,  2, 99, 99, 99, 99, 99], dtype=int8)

Que buena herramienta la de condicionales, muy intuitiva con el uso de corchetes.

Me puse a jugar también con map, filter y reduce 😄
Archivo de la clase 9 - Condiciones

Condiciones

• Podemos selecionar sólo los valores que cumplan una determinada condicion, es decir podemos aplicar máscaras a nuestro arreglo:

mask = my_array > 5
filtered_array = my_array[mask]

• Es también muy útil el médoto wher que permite ingresar valores según una condicion se cumpla o no, por ejemplo

np.where(matrix == 5, 'Ok', 'No es igual a 5')

A diferencia de Python, Numpy utiliza otros operadores condicionales, por ejemplo …

import numpy as np
numpyarray = np.linspace(1,10,10, dtype='int8')

# Operadores Condicionales
# And Alt + 38 ( & )
print(numpyarray[(numpyarray > 5) & (numpyarray < 9)])
# Or Alt + 124 ( | )
print(numpyarray[(numpyarray < 3) | (numpyarray > 6)])
# Not Alt + 126 ( ~ )
print(numpyarray[~((numpyarray < 3) | (numpyarray > 6))])```

arr=np.linspace(1, 100, 100, dtype = 'int8')
arr```

array([  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,  26,
        27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,
        40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,
        53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,
        66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,
        79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,
        92,  93,  94,  95,  96,  97,  98,  99, 100], dtype=int8)

indces_cond1 = arr > 5
indces_cond1

array([  6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,
        19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,
        32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,
        45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,
        58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,  70,
        71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,
        84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,
        97,  98,  99, 100], dtype=int8)

arr[arr==88]

array([88], dtype=int8)

arr[(arr>=30) & (arr <= 50)]

array([30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
       47, 48, 49, 50], dtype=int8)

Mi resumen #10 (Notion + Notas de Cornell)

PProbando si funciona con arrays bidimencionales

print(reduceVector) # [[1 2 3 4], [5 6 7 8]]

arrFilter = reduceVector.copy()[(reduceVector > 2) & (reduceVector < 8)]
print(arrFilter)
# result: [3 4 5 6 7]

condiciones: para filtrar objetos de estructuras de datos (dataframes, arrays…)
Sueles ser condiciones muy especificas.

arr = np.linspace(1,10,10, dtype='int8')
print(arr)
a = arr>5
print(a)

print(arr[a]) #me devuelve aquellos valores que esten en "true"
#puedo filtrar el array solo para aquello que cumplen una determinada cond
print(arr[(arr>5) & (arr<9)]) #2 condiciones a la vez
arr[arr>5] = 99 #modifico los datos con condiciones especificas
arr
arr[arr==99]

Una condición interesante: Divisibilidad.

mod_condition = arr%3==0
arr[(mod_condition)]

Output:
array([3, 6, 9], dtype=int8)

Información resumida de esta clase
#EstudiantesDePlatzi

• Utilizando las condiciones puedo traer datos que cumpla con cierta condición que yo desee

• Las condiciones nos sirven para hacer filtros o editar datos de una manera muy rápida

Consulto los valores donde su cuadrado es menor a 20 y a estos los multiplico por 2

arr3 = np.arange(0, 20)
---
     array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

arr3[arr3 ** 2 < 20] = arr3[arr3 ** 2 < 20] * 2

arr3
---
      array([ 0,  2,  4,  6,  8,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

Numpy es una locura!! 🤯

Iba a preguntar si se pueden hacer operaciones lógicas a nivel de bit hasta que buscando en la doc, encontré “Binary Operations”:
https://numpy.org/doc/stable/reference/routines.bitwise.html

Esto es genial para hacer opearciones a nivel de bit en sistemas digitales o comunicaciones. 😄

Algunos ejercicios que hice para el reto. 🤓

Hola a todos,

En el uso de condicionales en combinación con pandas me parece de gran utilidad el np.where el cual hace las veces del famoso case when de SQL

CONDICIONES los usamos cuando queremos algo especifico de nuestro array, también lo usamos cundo solo queremos los números pares o que cumplan una función especifica
________________________________________
[2]
0 s
import numpy as np
________________________________________
[12]
0 s
arr = np.linspace(1,60,20, dtype="int8")
arr
array([ 1,  4,  7, 10, 13, 16, 19, 22, 25, 28, 32, 35, 38, 41, 44, 47, 50,
       53, 56, 60], dtype=int8)
________________________________________
[13]
0 s
indices_cond = arr > 18 
indices_cond
# al ejecutar esto me arroja una lista bool, indicandome de los que cumple
# y de los que no con la función
array([False, False, False, False, False, False,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True])
________________________________________
[14]
0 s
arr[indices_cond]
# esta funcion solo me retonara solo los valores que se encuentran en true
#con esta funcion puedo filtrar los valores del array que solo cumplen con la funcion
array([19, 22, 25, 28, 32, 35, 38, 41, 44, 47, 50, 53, 56, 60], dtype=int8)
________________________________________
[15]
0 s
arr[(arr > 18) & (arr < 40)]
#con esta estructura puedo sumar diferentes condiciones, entrando directamente al array
#y cumpliendo con amabas condiciones 
array([19, 22, 25, 28, 32, 35, 38], dtype=int8)
________________________________________
[16]
0 s
arr[arr > 30] = 100
# aca intercambiamos el valor de aquellos que solo cumplen con esta condicion 
# lo cual puedo modificar mis datos con condiciones muy detalladas 
________________________________________
[17]
0 s
arr
array([  1,   4,   7,  10,  13,  16,  19,  22,  25,  28, 100, 100, 100,
       100, 100, 100, 100, 100, 100, 100], dtype=int8)
________________________________________
[18]
0 s
arr[arr==100]
#aca encuentro solo los calores que modifique anteriormente 
 
 
array([100, 100, 100, 100, 100, 100, 100, 100, 100, 100], dtype=int8)
________________________________________
[19]
0 s
arr[(arr > 8) & (arr < 16)]
 
 
array([10, 13], dtype=int8)
________________________________________
[28]
0 s
arr[(arr % 2 == 0)]
 
 
array([  4,  10,  16,  22,  28, 100, 100, 100, 100, 100, 100, 100, 100,
       100, 100], dtype=int8)
________________________________________
con las condiciones, es muy fácil filtras los arrays o datafrens o diferentes objectos con estructura de datos

Aqui dejo mis apuntes: Aqui

Condiciones en matrices
Ejecutando las condiciones en matrices retornaria un vector.

Ejemplo
Genero una matriz de 10x10 con numeros aleatorios del 1 al 100

matriz = np.random.randint(1,100, (10,10))
matriz

Resultado
array([[57, 43, 64, 69, 88, 58, 39, 78, 76, 72],
[55, 64, 85, 95, 54, 34, 70, 14, 18, 10],
[53, 53, 36, 51, 65, 4, 86, 84, 56, 7],
[98, 58, 3, 66, 78, 16, 21, 19, 22, 69],
[68, 72, 95, 33, 65, 67, 9, 41, 66, 23],
[42, 36, 95, 38, 14, 26, 94, 51, 95, 69],
[25, 96, 97, 62, 92, 21, 64, 82, 94, 65],
[43, 26, 75, 31, 82, 87, 22, 64, 67, 87],
[60, 82, 89, 21, 36, 9, 59, 90, 94, 90],
[59, 89, 80, 73, 12, 30, 23, 10, 50, 37]])

Condición efectuada

matriz[(matriz > 60) & (matriz < 70)]

Resultado final
array([64, 69, 64, 65, 66, 69, 68, 65, 67, 66, 69, 62, 64, 65, 64, 67])

Generando los valores pares

import numpy as np
arr = np.random.randint(1,40,15)
matriz_copy = matriz.copy()
matriz_copy
#Sacar los numeros pares de un array
matriz_copy[(np.mod(matriz_copy, 2) == 0)]
matriz_copy

tarea = np.random.randint(0,100, (3,2,3))
print(tarea)
tarea_cond = tarea[(tarea > 40) & (tarea < 60)]
tarea_cond

[[[70 34 83]
  [99 19 29]]

 [[ 2 48 61]
  [ 5 38  0]]

 [[16 94 34]
  [ 2 50 85]]]
array([48, 50])

# devuelve un array con los elementos pares del array
array_challenge = arr.copy()
array_challenge =  array_challenge[ array_challenge%2 == 0]
array_challenge

import numpy as np

new_arr = np.array(range(0,21))
even_numbers = new_arr[new_arr % 2 == 0]
even_numbers

# Output
# array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20])

Excelente clase

Una maravilla de herramienta para ir a datos sumamente concretos. De verdad que hace la diferencia.