No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Recursos

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 d贸nde la condici贸n se cumple.

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

Regresa los valores para d贸nde la condiciones True.

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

M煤ltiples condiciones.

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

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)

Contribuci贸n creada por: Edward Giraldo.

Aportes 55

Preguntas 11

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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

鉁匔ondiciones


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=鈥渋nt8鈥)
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茅 鈥淏inary 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 鉂わ笍