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.

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

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.])

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)]

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?

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.

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

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

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

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

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

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))])```

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

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.

Encontré utilidad para esto ❤️