Update numpy files

Author: valenfiumana

Cheatsheets/img/np_sorting.png

@@ -105,6 +105,79 @@ a = np.array([1, 2, 3, 4])
 b = np.array([5, 6, 7, 8])
 np.concatenate((a, b)) # [1, 2, 3, 4, 5, 6, 7, 8]
 ```
+```python
+b = np.array([71,63,75])
+
+b[ [0,2] ] # [ 71 75 ]
+
+b[ [1,0,2] ] # [63 71 75]
+```
+
+**argsort()**
+
+```python
+c = np.array([99, 33, 66, 55, 77, 22, 11, 88, 44])
+
+c_sorted = c[ np.argsort(c) ]
+print(c_sorted) # [11 22 33 44 55 66 77 88 99]
+```
+
+#### Sorting 2D
+
+For 2D arrays we can sort from left to right (axis 1) or from top to bottom (axis 0).
+
+![sorting](./img/np_sorting.png)
+
+* np.sort(a)
+* np.sort(a, axis=0)
+* np.sort(a, axis=1)
+
+```python
+import numpy as np 
+a = np.array([[99, 21, 33],
+               [44, 55, 66],
+               [71, 8, 53]])
+
+simple = np.sort(a)
+# [[21 33 99]
+#  [44 55 66]
+#  [ 8 53 71]] 
+
+b = np.sort(a, axis=0) # top to bottom 
+# [[44  0 33]
+#  [71 21 53]
+#  [99 55 66]]
+
+c = np.sort(a, axis=1) # left to right
+# [[21 33 99]
+#  [44 55 66]
+#  [ 8 53 71]]
+```
+
+```python
+a = np.array([[ 99, 21, 33 ],[ 44, 55, 66 ], [ 71,  0, 53 ]])
+ # [[99 21 33]
+ # [44 55 66]
+ # [71  0 53]] 
+ 
+# sort 1st col
+a[ np.argsort(a[:,0]), : ]
+ # [[44 55 66]
+ # [71  0 53]
+ # [99 21 33]]
+
+# sort 2nd col
+a[ np.argsort(a[:,1]), : ]
+ # [[71  0 53]
+ # [99 21 33]
+ # [44 55 66]]
+
+# sort by 3rd col
+a[ np.argsort(a[:,2]), : ]
+# [[99 21 33]
+#  [71  0 53]
+#  [44 55 66]]
+```
 
 ### Dimension and size
 ```python
@@ -154,15 +227,4 @@ csv_arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
 np.savetxt('new_file.csv', csv_arr)
 np.loadtxt('new_file.csv')
 ```
-```python
-
-```
-```python
 
-```
-```python
-
-```
-```python
-
-```

Cheatsheets/numpy.md

@@ -114,8 +114,13 @@ Escribir una función que reciba una lista como entrada y que devuelva 0 si la l
 Podes verificar que tu función devuelva el valor correcto comparandola con la función primitiva de Python len().
 
 ```python
-def longitudLista(lista):
-    return len(lista)
+def longitud(lista):
+  if lista == []:          # me fijo si la lista está vacia
+    return 0
+  else:
+    # si la lista no está vacía, la función devuelve 1 
+    # más la longitud de la lista restante (es decir, la lista sin el primer elemento)
+    return 1 + longitud(lista[1:])
 ```
 
 ### Ejercicio 7 - Listas pares e impares
@@ -139,7 +144,7 @@ En este ejercicio vamos a estimar π generando puntos al azar (esto es un ejempl
 <br> b) Usando el array del inciso anterior, contá la cantidad de puntos que caen dentro del cículo (es decir, contá cuántos cumplen que x**2 + y**2 < 1). Luego estimá el valor de π dividiendo ese valor por la cantidad de puntos (o sea, en este caso 10000), y multiplicando el resultado por 4. ¿Dió similar al valor conocido de π?
 <br> c) Creá una función estimar_pi(n) que devuelva una estimación del valor de π como la que hiciste antes pero usando n puntos, donde n es el parámetro de entrada.
 
-[Solución](./Weeks/Week%2005/3_acciones_uva.py)
+[Solución](./Weeks/Week06/9_estimar_pi.py)
 
 ### Ejercicio 10 - Ejercicio con datos antropométricos
 #### Descripcion
@@ -171,3 +176,17 @@ Calcular la relación entre altura del torso (sitting height) y longitud de las
 <br> b. ¿Que valores minimo, maximo, promedio, desvio tiene?
 <br> c. ¿Hay correlación entre los dos valores (longitud torso vs longitud de las piernas) para hombres y mujeres?
 
+[Solución](./Weeks/Week06
+
+### Ejercicio 11 - Sort pesos y alturas
+#### Descripcion
+Ordenar los datos por peso (o altura) y mantener los pares peso-altura de cada persona, sin hacer un array estructurado, y usando argsort().
+
+```python
+# altura en metros de personas
+alturas = [1.73, 1.68, 1.71, 1.89, 1.79, 1.76, 1.67]
+# peso en Kg de personas
+pesos = [65.4, 59.2, 63.6, 88.4, 68.7, 89.7, 73.2]
+```
+
+[Solucion](./Weeks/Week06/11_sort.py)

Exercises/06.md

@@ -0,0 +1,81 @@
+# Explore los datos ANSUR I para mujeres y hombres
+# Cree funciones para poder trabajar con los dos conjuntos de datos de la misma forma para:
+# <br> a. Leer los datos con NumPy y armar un nuevo array que contenga solamente los pesos y alturas.
+# <br> b. Determinar cuáles son los valores máximo, mínimo y promedio de los pesos y alturas para hombres y mujeres por separado.
+# <br> c. Estudie si hay correlación entre el peso y la altura para cada conjunto de datos.
+#
+# Calcular la relación entre altura del torso (sitting height) y longitud de las piernas (se puede calcular como la resta de la altura del torso y la altura total.
+# <br> a. ¿Cómo es ese cociente?
+# <br> b. ¿Que valores minimo, maximo, promedio, desvio tiene?
+# <br> c. ¿Hay correlación entre los dos valores (longitud torso vs longitud de las piernas) para hombres y mujeres?
+import numpy as np
+ansurWomen = np.genfromtxt('../../../Data/ansurWomen.csv', delimiter=",", skip_header=1)
+
+# explorar los datos: dimensiones, forma, filas, columnas, etc.
+print("Shape:", ansurWomen.shape, "Dim:", ansurWomen.ndim)
+print(ansurWomen[:,0])
+print(ansurWomen[0,:])
+
+# donde está el peso? (weight?) → Index = 124
+pesos = ansurWomen[:,124]
+print("Pesos de las primeras 10 mujeres de la base de datos:\n", pesos[:10])
+
+# donde está la altura? (stature) → Index = 99
+alturas = ansurWomen[:,99]
+print("Alturas de las primeras 10 mujeres de la base de datos:\n", alturas[:10])
+
+
+peso_stats = (pesos.min(), pesos.max(), round(pesos.mean(),4))
+altura_stats = (alturas.min(), alturas.max(), round(alturas.mean(),4))
+nombres_stats = ('Mínimo','Máximo','Promedio')
+print('\n')
+print("{:>10} {:>6} {:>8} {:>12}".format("  ", *nombres_stats))
+print("{:>10} {:>6} {:>8} {:>12}".format("PESO:", *peso_stats))
+print("{:>10} {:>6} {:>8} {:>12}".format("ALTURA:", *altura_stats))
+
+
+# 2.
+# A ansur_file hay que asignarle el path del archivo que se desea analizar.
+
+def ansur(ansur_file):
+    ansur = np.genfromtxt(ansur_file, delimiter=",", skip_header=1)
+    # Creo la variable datos con:  Columna 1: peso, Columna 2: alturas
+    datos = np.transpose(np.stack((ansur[:,124], ansur[:,99])))
+    # Tupla con el valor mínimo, máximo y promedio de los pesos respectivamente
+    peso_stats = (datos[:,0].min(), datos[:,0].max(), round(datos[:,0].mean(),2))
+    # Tupla con el valor mínimo, máximo y promedio de las alturas respectivamente
+    altura_stats = (datos[:,1].min(), datos[:,1].max(), round(datos[:,1].mean(),2))
+    # Calculo el coeficiente de correlación
+    corr = np.corrcoef(datos[:,0], datos[:,1])
+    return ansur, datos, peso_stats, altura_stats, corr # la función devuelve 5 variables (valores).
+
+# Ejemplo para ejecutar sobre las mujeres:
+asur, datos, peso_stats, altura_stats, corr = ansur('/content/drive/MyDrive/Colab Notebooks/Data/ansurWomen.csv')
+# Imprimo una tabla con los datos. (No era necesario mostrarlo de esta forma)
+print("Para las Mujeres")
+print("{:>15} {:>8} {:>8} {:>10}".format("Característica", "Min", "Máx", "Promedio"))
+print("{:>15} {:>8} {:>8} {:>10}".format("PESO:", *peso_stats))
+print("{:>15} {:>8} {:>8} {:>10}".format("ALTURA:", *altura_stats))
+print(f"Correlación: {corr[0,1]}")
+
+
+# 3.a.
+import matplotlib.pyplot as plt
+ansurWomen = np.genfromtxt('/content/drive/MyDrive/Colab Notebooks/Data/ansurWomen.csv', delimiter=",", skip_header=1)
+
+altura_torso = ansurWomen[:,93]
+long_piernas = ansurWomen[:,99] - altura_torso
+relacion = altura_torso / long_piernas
+
+plt.figure(figsize=(15,5))
+plt.plot(relacion)
+# Al mirar los valores del cociente "relacion" podemos ver que es ligeramente mayor a 1 para toda la población.
+# Esto muestra que la tendencia es que no importa cuales sean la altura del torso y la longitud de las piernas, su cociente se mantiene
+# El desvio cuantifica la afirmación "el cociente se mantiene"
+
+# 3.b.
+print(f"Promedio: {round(relacion.mean(),2)}, Max: {round(relacion.max(),2)}, Min: {round(relacion.min(),2)}, Desvio: {round(relacion.std(),2)}")
+
+# 3.c.
+corr = np.corrcoef(altura_torso, long_piernas)
+print(f"Correlación: {round(corr[0,1],4)}")

Exercises/Weeks/Week06/10_datos_antropometricos.py

@@ -0,0 +1,32 @@
+import numpy as np
+
+# altura en metros de personas
+alturas = [1.73, 1.68, 1.71, 1.89, 1.79, 1.76, 1.67]
+# peso en Kg de personas
+pesos = [65.4, 59.2, 63.6, 88.4, 68.7, 89.7, 73.2]
+
+# ap es el array de pesos y alturas
+ap = np.array([ alturas, pesos ])
+print("original: \n", ap, "\n")
+
+#       0     1     2     3     4     5     6     <--- Columnas
+#  [[ 1.73  1.68  1.71  1.89  1.79  1.76  1.67]]   --- Fila 0
+#  [[65.4  59.2  63.6  88.4  68.7  89.7  73.2 ]]]  --- Fila 1
+
+
+# obtengo los indices ordenados usando argsort()
+indices_ordenados_alturas = ap[0,:].argsort()
+indices_ordenados_pesos   = ap[1,:].argsort()
+print("Alturas ordenadas (indices): \n", indices_ordenados_alturas )
+print("Pesos ordenados (indices): \n", indices_ordenados_pesos )
+
+# ahora ordenamos el array usando estos indices ordenados
+# por altura
+personas_ordenadas_por_altura = ap[ :, indices_ordenados_alturas ]
+print("Ordenadas por altura:\n", personas_ordenadas_por_altura)
+
+# por peso
+personas_ordenadas_por_peso = ap[ :, indices_ordenados_pesos ]
+# == ap[ :, ap[1,:].argsort() ]
+# == ap[ :, np.argsort(ap[1,:]) ]
+print("Ordenadas por peso:\n", personas_ordenadas_por_peso)

Exercises/Weeks/Week06/11_sort.py

@@ -6,8 +6,8 @@
 
 import numpy as np
 
-a = np.ones((3, 3))
-b = np.zeros((256, 256))
+a = np.ones((3, 3), dtype=int)
+b = np.zeros((256, 256), dtype=int)
 
 print(a.itemsize) # 8 bytes
 print(a.size) # 3 x 3 = 9 elements

Exercises/Weeks/Week06/1_ones_zeros.py

@@ -12,9 +12,16 @@
 #  [ True  True  True]
 #  [ True  True  True]]
 
-c = np.array(a[a%2!=0]) # [1 3 5 7 9]
+b2 = np.ones((3, 3), dtype=bool) # Al ser tipo bool, muestra los 1 como True y los 0 como False
 
-d = np.where(a%2!=0, -1, a) # [ 0 -1  2 -1  4 -1  6 -1  8 -1]
+c = np.array( a[a % 2 != 0] ) # [1 3 5 7 9]
+
+d = np.where(a % 2 != 0, -1, a) # [ 0 -1  2 -1  4 -1  6 -1  8 -1]
+d2 = a[a % 2 == 1] = -1
 
 e = np.reshape(a, (2, 5)) # [[0 1 2 3 4]
-                        # [5 6 7 8 9]]
+                        # [5 6 7 8 9]]
+
+e2 = np.reshape(arr_a, (2, -1)) # Cambiamos la forma del array. (2,-1) es el nuevo tamaño que se le quiere dar.
+                                # El primer número de la tupla (2) pide que el primer eje tenga dos elementos.
+                                # El segundo número de la tupla (-1) indica que numpy calcule el tamaño del segundo eje, teniendo en cuenta el tamaño original de arra_a

Exercises/Weeks/Week06/2_ndarrays.py

@@ -21,3 +21,9 @@
 print(c.itemsize) # 4
 print(d.itemsize) # 8
 
+# Leo cuanto ocupan en la memoria y lo paso a kilobytes
+print("===> Memoria")
+print("a %d kilobytes" % ((a.size * a.itemsize) / 1024))
+print("b %d kilobytes" % ((b.size * b.itemsize) / 1024))
+print("c %d kilobytes" % ((c.size * c.itemsize) / 1024))
+print("d %d kilobytes" % ((d.size * d.itemsize) / 1024))

Exercises/Weeks/Week06/3_dtypes.py

@@ -21,4 +21,8 @@ def mult_table(n):
     #  [ 9]
     #  [10]]
 
-print(mult_table(10))
+print(mult_table(10))
+
+def tabla():
+    tablas = np.array([np.arange(1,11)] * 10)  # Generamos un array que va del 1 al 10, la transformamos en lista con la operación * concatenamos la misma lista 10 veces
+    tablas = np.transpose(tablas) * tablas[0,:]  # Transponemos dicho array y usando la operación * entre arrays que multiplica cada columna de tablas por tablas[0,:]

Exercises/Weeks/Week06/4_tablas_multiplicar.py

@@ -2,4 +2,23 @@
 # La idea consiste en generar puntos al azar (todos con valores de x e y ubicados entre 0 y 1), y ver cuántos de ellos están contenidos dentro del círculo de radio 1 alrededor del punto central (0, 0).
 # a) Usando la función de Numpy numpy.random.rand(), generá un array de números al azar de tamaño (10000, 2), que representa 10000 puntos generados al azar.
 # b) Usando el array del inciso anterior, contá la cantidad de puntos que caen dentro del cículo (es decir, contá cuántos cumplen que x**2 + y**2 < 1). Luego estimá el valor de π dividiendo ese valor por la cantidad de puntos (o sea, en este caso 10000), y multiplicando el resultado por 4. ¿Dió similar al valor conocido de π?
-# c) Creá una función estimar_pi(n) que devuelva una estimación del valor de π como la que hiciste antes pero usando n puntos, donde n es el parámetro de entrada.
+# c) Creá una función estimar_pi(n) que devuelva una estimación del valor de π como la que hiciste antes pero usando n puntos, donde n es el parámetro de entrada.
+
+import numpy as np
+puntos = np.random.rand(10000, 2) # a. array numeros al azar
+
+cantidad = np.count_nonzero(puntos[:,0]**2 + puntos[:,1]**2 < 1) # b. cuántos cumplen que x**2 + y**2 < 1
+print('La estimación de Pi dio:', cantidad*4/10000)
+
+# es igual que:
+# cantidad = 0
+# for punto in puntos:
+#   if punto[0]**2 + punto[1]**2 < 1:
+#     cantidad += 1
+
+def estimar_pi(n): # c. estimar pi con n puntos
+    puntos = np.random.rand(n, 2)
+    cantidad = np.count_nonzero(puntos[:, 0] ** 2 + puntos[:, 1] ** 2 < 1)
+
+    return cantidad * 4 / n
+print(estimar_pi(10000000))