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 77

Preguntas 11

Ordenar por:

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

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.

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

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

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.

Mi aporte: ![](https://static.platzi.com/media/user_upload/Condiciones-b33afa51-3982-4e35-ab7a-ebd610120d89.jpg)
Dejo mi matriz de 8x10, donde los n煤meros pares los convierte en 1 ```python matriz = np.random.randint(1,100, (8, 10)) print(matriz) matriz[matriz % 2 == 0] = 1 print(matriz) ```Trat茅 de hacer este paso antes y despu茅s ocupar esa matriz en la anterior, pero por alguna raz贸n me dice que son de dimensiones diferentes ```python matriz_par = [matriz % 2 == 0] print(matriz_par) matriz[matriz_par] = 1 print(matriz) ```Si alguien sabe por qu茅 lo escucho
tenia ganas de ver cuantas veces me dijo te amo mi pareja y cuantos ok use chat gpt para ayudarme con el codigo igualmente ahora que veo todo entiendo lo que me dio el chat base de datos chat de wsp (le peregunte si podia) la base tenia mis mensajes tambi茅n entonces tenia que filtrar eso y los otros muuuchos mensajes intente que vs lea el .txt no puedo haci que decidi copiar todo el chat y pegarlo en vs en un entorno de python empece a probar codigo cuando me dio los resultados los grafique en tablo y me encanto la experiencia
Dejo mi aporte, Encontr茅 un m茅todo llamado "vectorize" que ayuda a evaluar una funci贸n dentro de un array. aqu铆 una aplicaci贸n, tratando de hallar n煤meros primos: ```js arr1 = np.arange(1,1001) # creamos un array de enteros consecutivos #creamos una funcion para averiguar si el numero es primo def es_primo (x): if x < 2: return False for i in range(2,x): if x % i == 0: return False return True # Funci贸n vectorizada para verificar primos en un array NumPy vectorized_es_primo = np.vectorize(es_primo) #funcion para recolectar los numeros que sean primos def encontrar_primos(array): primos_encontrados = vectorized_es_primo(array) return array[primos_encontrados] #instanciamos primos = encontrar_primos(arr1) primos ```arr1 = np.arange(1,1001) # creamos un array de enteros consecutivos#creamos una funcion para averiguar si el numero es primodef es\_primo (x): if x < 2: return False for i in range(2,x): if x % i == 0: return False return True \# Funci贸n vectorizada para verificar primos en un array NumPyvectorized\_es\_primo = np.vectorize(es\_primo) \#funcion para recolectar los numeros que sean primosdef encontrar\_primos(array): primos\_encontrados = vectorized\_es\_primo(array) return array\[primos\_encontrados] #instanciamosprimos = encontrar\_primos(arr1) primos

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.

![](

```js # Buscar el 铆ndice de un valor espec铆fico, por ejemplo, 19 coordenadas = np.where(matriz == 19) # Imprimir las coordenadas print("Coordenadas del valor 19:") for coord in zip(coordenadas[0], coordenadas[1]): print(coord) ```# Buscar el 铆ndice de un valor espec铆fico, por ejemplo, 19 coordenadas = np.where(matriz == 19) # Imprimir las coordenadas print("Coordenadas del valor 19:") for coord in zip(coordenadas\[0], coordenadas\[1]): print(coord)

Me di贸 curiosidad como crear una matriz de manera 鈥渁leatoria鈥 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
## 馃Condiciones Son expresiones l贸gicas aplicadas a elementos para que podamos realizar operaciones selectivas. Se pueden utilizar para: * Filtrar. * Seleccionar. * Realizar operaciones con ciertos criterios. ### 馃尭Operadores L贸gicos Los operadores l贸gicos nos permiten combinar y evaluar condiciones para la toma de decisiones. **AND (**`&`**):** Este operador es como el equipo din谩mico que trabaja junto. Devuelve `True` si ambas condiciones son verdaderas. `llueve = True` `viento_fuerte = False` `si_salgo = llueve & (not viento_fuerte)` OR (|): Es como tener opciones. Devuelve True si al menos una de las condici贸n es verdadera. `dia_libre = True` `clima_bueno = True` `si_salgo = dia_libre | clima_bueno` **NOT (**`~`**):** Este es el operador que cambia las reglas del juego. Devuelve `True` si la condici贸n es falsa y viceversa. `dia_lluvioso = True` `si_no_salgo = ~dia_lluvioso` ### 馃尭Operadores de Comparaci贸n Los operadores de comparaci贸n son herramientas poderosas, nos ayudan a determinar si un valor es igual, diferente, mayor, menor o igual. * `==` (igual) * `!=` (no igual) * `<` (menor que) * `>` (mayor que) * `<=` (menor o igual que) * `>=` (mayor o igual que) `import numpy as np` `arr = np.array([1, 2, 3, 4, 5])` `condition = (arr > 2)` `print(condition)` `---> [False False True True True]` ### 馃尭Funciones de Comparaci贸n Las funciones de comparaci贸n en NumPy nos permiten realizar comparaciones entre elementos. Nos retornan matrices de valores booleanos que nos indican el resultado de la comparaci贸n. Tambi茅n nos permite tener un mayor control y flexibilidad. `np.greater()` **(mayor que):** Devuelve una matriz de valores booleanos indicando si cada elemento es mayor que el correspondiente en otra matriz. `import numpy as np` `a = np.array([1, 2, 3, 4, 5])` `b = np.array([2, 2, 3, 4, 4])` `result = np.greater(a, b)` `print(result)` `---> [False False False False True]` `np.less()` **(menor que):** Devuelve una matriz de valores booleanos indicando si cada elemento es menor que el correspondiente en otra matriz. `import numpy as np` `a = np.array([1, 2, 3, 4, 5])` `b = np.array([2, 2, 3, 4, 4])` `result = np.less(a, b)` `print(result)` `---> [ True False False False False]` `np.equal()` **(igual a):** Devuelve una matriz de valores booleanos indicando si cada elemento es igual al correspondiente en otra matriz. `import numpy as np` `a = np.array([1, 2, 3, 4, 5])` `b = np.array([2, 2, 3, 4, 4])` `result = np.equal(a, b)` `print(result)` `---> [False True True True False]` `np.not_equal()` **(no igual a):** Devuelve una matriz de valores booleanos indicando si cada elemento no es igual al correspondiente en otra matriz. `import numpy as np` `a = np.array([1, 2, 3, 4, 5])` `b = np.array([2, 2, 3, 4, 4])` `result = np.not_equal(a, b)` `print(result)` `---> [ True False False False True]` `np.greater_equal()` **(mayor o igual a):** Devuelve una matriz de valores booleanos indicando si cada elemento es mayor o igual al correspondiente en otra matriz. `import numpy as np` `a = np.array([1, 2, 3, 4, 5])` `b = np.array([2, 2, 3, 4, 4])` `result = np.greater_equal(a, b)` `print(result)` `---> [False True True True True]` `np.less_equal()` **(menor o igual a):** Devuelve una matriz de valores booleanos indicando si cada elemento es menor o igual al correspondiente en otra matriz. `import numpy as np` `a = np.array([1, 2, 3, 4, 5])` `b = np.array([2, 2, 3, 4, 4])` `result = np.less_equal(a, b)` `print(result)` `---> [ True True True True False]` 馃挕Los operadores de comparaci贸n y las funciones de comparaci贸n son bastante parecidos. Ambos enfoques son v谩lidos y funcionan bien. Sin embargo, las funciones de comparaci贸n de NumPy, nos pueden ofrecer una mayor flexibilidad, especialmente cuando se trabaja con operaciones m谩s completas o espec铆ficas.

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.

Mi actividad: ![](https://static.platzi.com/media/user_upload/image-a1e4e97a-b33b-4811-87a8-056845467fc3.jpg)

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 鈥淚n_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=鈥渋nt8鈥)
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茅 鈥淏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.

`# Array` `arr_dens=np.random.randint(1,20,size=(5,6))` `print(f'Array = \n{arr_dens}\n')` `#Condicion 1 n煤meros pares o mayores a 10` `cond1=arr_dens[(arr_dens%2==0) | (arr_dens>10)]` `print(f'Condici贸n 1 = \n{cond1}\n')` `#Condicion 2 n煤meros pares` `cond2=arr_dens[arr_dens%2==0]` `print(f'Condici贸n 2 = \n{cond2}\n')` `#Copia del arreglo` `cp_arrden = arr_dens.copy()` `#Cambiando los impares por su valor multiplicado por 2` `cp_arrden[cp_arrden%2!=0]*=2` `print(f'Array original = \n{arr_dens}\n')` `print(f'Array condicionado = \n{cp_arrden}\n')`