just missing some more personal info

4e6df2c9 · David Ramos Salamanca · a25d5e78 · 4e6df2c9 · 4e6df2c9 · 4e6df2c9
Commit 4e6df2c9 authored 4 years ago by David Ramos Salamanca
--- a/ejercicio1.html
+++ b/ejercicio1.html
@@ -14269,7 +14269,7 @@ a.anchor-link {
 </div>
 <div class="jp-Cell-inputWrapper"><div class="jp-InputPrompt jp-InputArea-prompt">
 </div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
-<p>Escriba un programa en python que acepte una lista de palabras separadas por guiones e imprima de vuelta las mismas palabras, sin repetición y nuevamente separadas por guiones,después de ordenarlas alfabéticamente.</p>
+<p><strong>Escriba un programa en python que acepte una lista de palabras separadas por guiones e imprima de vuelta las mismas palabras, sin repetición y nuevamente separadas por guiones,después de ordenarlas alfabéticamente.</strong></p>
 <p><strong>Ejemplo de entrada:</strong> naranja-avión-melodía-tupla-avión</p>
 <p><strong>Salida esperada:</strong> avión-melodía-naranja-tupla</p>

--- a/ejercicio1.ipynb
+++ b/ejercicio1.ipynb
@@ -18,7 +18,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "Escriba un programa en python que acepte una lista de palabras separadas por guiones e imprima de vuelta las mismas palabras, sin repetición y nuevamente separadas por guiones,después de ordenarlas alfabéticamente.\n",
+    "**Escriba un programa en python que acepte una lista de palabras separadas por guiones e imprima de vuelta las mismas palabras, sin repetición y nuevamente separadas por guiones,después de ordenarlas alfabéticamente.**\n",
    "\n",
    "**Ejemplo de entrada:** naranja-avión-melodía-tupla-avión\n",
    "\n",

 %% Cell type:markdown id: tags:
 # David Ramos -  UIS
 %% Cell type:markdown id: tags:
 ## Problema: Lista de palabras
 %% Cell type:markdown id: tags:
-Escriba un programa en python que acepte una lista de palabras separadas por guiones e imprima de vuelta las mismas palabras, sin repetición y nuevamente separadas por guiones,después de ordenarlas alfabéticamente.
+**Escriba un programa en python que acepte una lista de palabras separadas por guiones e imprima de vuelta las mismas palabras, sin repetición y nuevamente separadas por guiones,después de ordenarlas alfabéticamente.**
 **Ejemplo de entrada:** naranja-avión-melodía-tupla-avión
 **Salida esperada:** avión-melodía-naranja-tupla
 %% Cell type:markdown id: tags:
 ## Solución
 %% Cell type:markdown id: tags:
 Primero se adquieren las palabras
 %% Cell type:code id: tags:
 ``` python
 disordered_words = input('Escriba una lista de palabras separadas or guíones:  ') # input() convierte todo input a string
 ```
 %% Output
    Escriba una lista de palabras separadas or guíones:  ola-hola-ala
 %% Cell type:code id: tags:
 ``` python
 disordered_words
 ```
 %% Output
    'ola-hola-ala'
 %% Cell type:markdown id: tags:
 La estrategia es crear una lista de palabras a partir del string. La cual que se puede organizar fácilmente con métodos de las listas para luego devolver como un solo string.
 %% Cell type:markdown id: tags:
 Para crear la lista de palabras se irán añadiendo los caracteres del string en una variable hasta encontrar un guión, en cuyo caso se agrega el contenido de la variable a una lista y se resetea la variable donde se guardan los caracteres para almacenar la siguiente palabra.
 %% Cell type:code id: tags:
 ``` python
 mywords = [] # en esta lista se almacenarán las palabras
 word = '' # string vacío para almacenar los caracteres de cada palabra
 for char in disordered_words: # iterando sobre los caracteres del string
    if char != '-': # si el caracter no es - se añade a la palabra
        word += char
    else: # si el caracter es -, se añade la palabra a la lista y vacía la palabra
        mywords.append(word)
        word = ''
 mywords.append(word) # añadiendo la última palabra
 ```
 %% Cell type:code id: tags:
 ``` python
 mywords
 ```
 %% Output
    ['ola', 'hola', 'ala']
 %% Cell type:markdown id: tags:
 Usando los conjuntos se eliminan duplicados y luego se organiza usando *sorted()*
 %% Cell type:code id: tags:
 ``` python
 sorted(list(set(mywords))) #se orgniza alfabéticamente y eliminan repeticiones
 ```
 %% Output
    ['ala', 'hola', 'ola']
 %% Cell type:code id: tags:
 ``` python
 mywords
 ```
 %% Output
    ['ola', 'hola', 'ala']
 %% Cell type:markdown id: tags:
 Finalmente se usa la función *join()* de python para unir en un string las palabras. La lista que se unió fue una en la cual todas las palabras finalizan con un guión excepto la última.
 %% Cell type:code id: tags:
 ``` python
 ordered_words = ''.join([word + '-' for word in mywords])[:-1]
 ```
 %% Cell type:code id: tags:
 ``` python
 ordered_words
 ```
 %% Output
    'ola-hola-ala'
 %% Cell type:markdown id: tags:
 Organizando todo en una función
 %% Cell type:code id: tags:
 ``` python
 def word_orderer(disordered_words):
    """Sort alphabetically a string with a list of words separated by a hyphen eliminating repetitions."""
    mywords = [] # en esta lista se almacenarán las palabras
    word = '' # string vacío para almacenar los caracteres de cada palabra
    for char in disordered_words: # iterando sobre los caracteres del string
        if char != '-': # si el caracter no es - se añade a la palabra
            word += char
        else: # si el caracter es -, se añade la palabra a la lista y vacía la palabra
            mywords.append(word)
            word = ''
    mywords.append(word) # añadiendo la última palabra
    mywords = sorted(list(set(mywords))) # se organiza alfabéticamente y eliminan repeticiones
    return ''.join([word + '-' for word in mywords])[:-1]
 ```
 %% Cell type:code id: tags:
 ``` python
 word_orderer('naranja-avión-melodía-tupla-avión')
 ```
 %% Output
    'avión-melodía-naranja-tupla'

--- a/ejercicio2.html
+++ b/ejercicio2.html
@@ -14269,7 +14269,7 @@ a.anchor-link {
 </div>
 <div class="jp-Cell-inputWrapper"><div class="jp-InputPrompt jp-InputArea-prompt">
 </div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
-<p>Escriba una rutina en python que reciba como entrada un número entero, <em>n</em>, e imprima los números en la <em>n-ésima</em> fila del triángulo de Pascal. El programa debe verificar si el número <em>n</em> es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso contrario.</p>
+<p><strong>Escriba una rutina en python que reciba como entrada un número entero, <em>n</em>, e imprima los números en la <em>n-ésima</em> fila del triángulo de Pascal. El programa debe verificar si el número <em>n</em> es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso contrario.</strong></p>
 </div>
 </div>
@@ -14643,7 +14643,7 @@ $$ {n\choose k} = \frac{n!}{k!(n-k)!} .$$
 </div>
 <div class="jp-Cell-inputWrapper"><div class="jp-InputPrompt jp-InputArea-prompt">
 </div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput " data-mime-type="text/markdown">
-<p>Modifique la rutina anterior para que reciba un número variable de argumentos: <em>n1</em>, <em>n2</em>, <em>n3</em>,...y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila <em>n1</em> del triángulo de Pascal, el segundo elemento una lista con los números en la fila <em>n2</em>, y así sucesivamente.</p>
+<p><strong>Modifique la rutina anterior para que reciba un número variable de argumentos: <em>n1</em>, <em>n2</em>, <em>n3</em>,...y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila <em>n1</em> del triángulo de Pascal, el segundo elemento una lista con los números en la fila <em>n2</em>, y así sucesivamente.</strong></p>
 </div>
 </div>

--- a/ejercicio2.ipynb
+++ b/ejercicio2.ipynb
@@ -18,7 +18,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "Escriba una rutina en python que reciba como entrada un número entero, *n*, e imprima los números en la *n-ésima* fila del triángulo de Pascal. El programa debe verificar si el número *n* es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso contrario."
+    "**Escriba una rutina en python que reciba como entrada un número entero, *n*, e imprima los números en la *n-ésima* fila del triángulo de Pascal. El programa debe verificar si el número *n* es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso contrario.**"
   ]
  },
  {
@@ -242,7 +242,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "Modifique la rutina anterior para que reciba un número variable de argumentos: *n1*, *n2*, *n3*,...y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila *n1* del triángulo de Pascal, el segundo elemento una lista con los números en la fila *n2*, y así sucesivamente."
+    "**Modifique la rutina anterior para que reciba un número variable de argumentos: *n1*, *n2*, *n3*,...y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila *n1* del triángulo de Pascal, el segundo elemento una lista con los números en la fila *n2*, y así sucesivamente.**"
   ]
  },
  {

 %% Cell type:markdown id: tags:
 # David Ramos - UIS
 %% Cell type:markdown id: tags:
 ## Problema: Triángulo de Pascal
 %% Cell type:markdown id: tags:
-Escriba una rutina en python que reciba como entrada un número entero, *n*, e imprima los números en la *n-ésima* fila del triángulo de Pascal. El programa debe verificar si el número *n* es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso contrario.
+**Escriba una rutina en python que reciba como entrada un número entero, *n*, e imprima los números en la *n-ésima* fila del triángulo de Pascal. El programa debe verificar si el número *n* es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso contrario.**
 %% Cell type:markdown id: tags:
 ## Solución 1 (mathy)
 %% Cell type:markdown id: tags:
 Los números en la *n-ésima* (empezando en cero) fila del triángulo de Pascal corresponden a los coeficientes binomiales ${n\choose 0},\,{n\choose 1},\,...,\,{n\choose n}$ donde
 $$ {n\choose k} = \frac{n!}{k!(n-k)!} .$$
 %% Cell type:code id: tags:
 ``` python
 import numpy as np
 ```
 %% Cell type:code id: tags:
 ``` python
 def pascal1(n):
    if int(n)==n: # reviso que el número sea entero
        row = ''
        for i in range(n+1): # calculo cada uno de los coeficientes binomiales y lo almaceno en fila
            row += str(int(np.math.factorial(n)/(np.math.factorial(i)*np.math.factorial(n-i)))) + '\t'
        print(row)
    else:
        print('Error: el número ingresado no es entero')
 ```
 %% Cell type:code id: tags:
 ``` python
 pascal1(0)
 ```
 %% Output
    1
 %% Cell type:code id: tags:
 ``` python
 pascal1(4)
 ```
 %% Output
    1	4	6	4	1
 %% Cell type:code id: tags:
 ``` python
 pascal1(3.3)
 ```
 %% Output
    Error: el número ingresado no es entero
 %% Cell type:markdown id: tags:
 ## Solución 2 (cody)
 %% Cell type:markdown id: tags:
 La otra opción es construir el triángulo de pascal hasta la *n-ésima* fila e imprimirla.
 %% Cell type:code id: tags:
 ``` python
 def pascal2(n):
    if int(n) != n:
        print('Error: el número ingresado no es entero')
    elif n == 0: # sabemos que la primera fila es un 1
        print('1')
    else:
        prow = (int(1)) # guardando la primera fila, se usan tuplas para que sea inmutable
        row =[] # lista donde se crearán las filas
        for i in range(1,n+1): # iterando sobre el número de filas
            for k in range(i+1): # segunda iteración (shame on me) para moverse en "columnas"
                if k == 0 or k == i:
                    row.append(int(1)) # el primer y el último número es 1
                else:
                    row.append(prow[k-1]+prow[k]) # elementos interiores como suma de elementos de la fila anterior
            prow = tuple(row) # re asigno la fila anterior (como una tupla) para la nueva iteración
            frow = row # guardo la fila actual
            row = [] # vacío la fila para volverla a llenar
        print(''.join([str(number) + '\t' for number in frow])) # imprimo los número separados por tab
 ```
 %% Cell type:code id: tags:
 ``` python
 pascal2(0)
 ```
 %% Output
    1
 %% Cell type:code id: tags:
 ``` python
 pascal2(1)
 ```
 %% Output
    1	1
 %% Cell type:code id: tags:
 ``` python
 pascal2(2)
 ```
 %% Output
    1	2	1
 %% Cell type:code id: tags:
 ``` python
 pascal2(3)
 ```
 %% Output
    1	3	3	1
 %% Cell type:code id: tags:
 ``` python
 pascal2(3.1)
 ```
 %% Output
    Error: el número ingresado no es entero
 %% Cell type:markdown id: tags:
-Modifique la rutina anterior para que reciba un número variable de argumentos: *n1*, *n2*, *n3*,...y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila *n1* del triángulo de Pascal, el segundo elemento una lista con los números en la fila *n2*, y así sucesivamente.
+**Modifique la rutina anterior para que reciba un número variable de argumentos: *n1*, *n2*, *n3*,...y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila *n1* del triángulo de Pascal, el segundo elemento una lista con los números en la fila *n2*, y así sucesivamente.**
 %% Cell type:markdown id: tags:
 Para este caso la estrategia será buscar el número más alto de los brindados por el usuario y la estructura de la rutina es la misma, la única diferencia es que se guardan algunas de las filas intermedias.
 %% Cell type:code id: tags:
 ``` python
 def multipascal(*args):
    nmax = max(*args)
    rows = []
    if not all(int(n) == n for n in args): # usando all() para verificar que todos los números sean enteros
        print('Error: uno o más de los números ingresados no es entero')
    elif nmax == 0: # sabemos que la primera fila es un 1
        rows.append([int(1)])
        return rows
    else:
        prow = (int(1)) # guardando la primera fila, se usan tuplas para que sea inmutable
        row =[] # lista donde se crearán las filas
        for i in range(1,nmax+1): # iterando sobre el número de filas
            for k in range(i+1): # segunda iteración (shame on me) para moverse en "columnas"
                if k == 0 or k == i:
                    row.append(int(1)) # el primer y el último número es 1
                else:
                    row.append(prow[k-1]+prow[k]) # elementos interiores como suma de elementos de la fila anterior
            prow = tuple(row) # re asigno la fila anterior (como una tupla) para la nueva iteración
            rows.append(row) # guardo la fila actual
            row = [] # vacío la fila para volverla a llenar
        return rows
 ```
 %% Cell type:code id: tags:
 ``` python
 multipascal(1,2,3,4)
 ```
 %% Output
    [[1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]
 %% Cell type:code id: tags:
 ``` python
 multipascal(1,2,3,4.1)
 ```
 %% Output
    Error: uno o más de los números ingresados no es entero

--- a/ejercicio3.html
+++ b/ejercicio3.html
--- a/ejercicio3.ipynb
+++ b/ejercicio3.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# David Ramos - UIS"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Problema: Amigos congueros"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Entre en contacto con 10 estudiantes del curso de datos y 2 profesores o personal de soporte de LaConga, uno del curso de datos y otro de afuera, y consulte su nombre completo, su nombre de usuario en mattermost, edad, país de origen, ciudad donde residen, su especialidad científica, nombre del instituto en que estudian/laboran, y un hobbie o afición.**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Solución (sin pandas)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Después de recopilar la información, creé un csv con todos los datos llamado *p_info.csv* y lo importé usando numpy."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = np.loadtxt('p_info.csv', delimiter = '\\t', dtype='str', unpack=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "La estrategia es crear una lista de *keys* que sean los usuarios de Mattermost y una lista de *values* que sean diccionarios con los otros datos."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "users = data[0][1:] # lista de usuarios usando slicing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "info = [{data[i][0]:data[i][j] for i in range(1,len(data[1:])+1)} for j in range(1,len(data[0][1:])+1)] \n",
+    "# lista de diccionarios usando un dic-comprehension dentro de una list-comprehension"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ahora, usando el constructor *dic()* y la función *zip()* se puede crear el diccionario deseado [[1](https://stackoverflow.com/questions/209840/how-do-i-convert-two-lists-into-a-dictionary)]."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "compas = dict(zip(users,info))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Cree una función que reciba como entrada el diccionario y un país de origen, y retorne las informaciones completas de todas las personas de ese país, tabuladas en una forma fácil de entender.**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def bycountry(dic,country):\n",
+    "    # obtengo los usuarios de las personas nacidas en ese pais\n",
+    "    compatriots = [user for user in compas.keys() if compas[user]['pais'] == country]\n",
+    "    # voy a imprimir verticalmente porque no cabe de manera horizontal\n",
+    "    for compatriot in compatriots:\n",
+    "        print('usuario: ' + compatriot)\n",
+    "        for header in compas[compatriot].keys():\n",
+    "            print('   \\u25ba ' + header +  ' : ' + compas[compatriot][header])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "usuario: nicole\n",
+      "   ► nombre : Nicole\n",
+      "   ► apellido : Hernández\n",
+      "   ► pais : Colombia\n",
+      "   ► residencia : Bucaramanga\n",
+      "   ► edad : 23\n",
+      "   ► especialidad : análisis de imagen médica\n",
+      "   ► institucion : Universidad Industrial de Santander\n",
+      "   ► hobbie : dibujar\n",
+      "usuario: vargass\n",
+      "   ► nombre : Sasiri\n",
+      "   ► apellido : Vargas\n",
+      "   ► pais : Colombia\n",
+      "   ► residencia : Cali\n",
+      "   ► edad : 20\n",
+      "   ► especialidad : sistemas de reacción difusión unidimensionales\n",
+      "   ► institucion : Universidad del Valle\n",
+      "   ► hobbie : bailar\n",
+      "usuario: navasa\n",
+      "   ► nombre : Alfonso\n",
+      "   ► apellido :  Navas\n",
+      "   ► pais : Colombia\n",
+      "   ► residencia : Bogotá\n",
+      "   ► edad : 24\n",
+      "   ► especialidad : física de sistemas complejos\n",
+      "   ► institucion : Universidad Nacional de Colombia\n",
+      "   ► hobbie : crossfit\n"
+     ]
+    }
+   ],
+   "source": [
+    "bycountry(compas,'Colombia')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Busque una forma de calcular, a partir del diccionario, el promedio de edad de todas las personas en él, y una forma de mostrar todas las instituciones (sin repetición).**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def age_average(dic):\n",
+    "    # recupero la edad de cada persona (convertida a un entero) usando una list-comprehension\n",
+    "    ages = [int(value['edad']) for value in dic.values()]\n",
+    "    # imprimo el promedio\n",
+    "    return sum(ages)/len(ages)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "22.5"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "age_average(compas)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def institutions(dic):\n",
+    "    # recupero las instituciones usando una list-comprehension y elimino duplicados convirtiéndola a un conjunto\n",
+    "    insts = set([value['institucion'] for value in dic.values()])\n",
+    "    # imprimo en distintas filas por claridad\n",
+    "    for inst in insts:\n",
+    "        print(inst)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Universidad Nacional de Colombia\n",
+      "Universidad del Valle\n",
+      "Universidad Industrial de Santander\n",
+      "Universidad de los Andes\n"
+     ]
+    }
+   ],
+   "source": [
+    "institutions(compas)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
+%% Cell type:markdown id: tags:
+# David Ramos - UIS
+%% Cell type:markdown id: tags:
+## Problema: Amigos congueros
+%% Cell type:markdown id: tags:
+**Entre en contacto con 10 estudiantes del curso de datos y 2 profesores o personal de soporte de LaConga, uno del curso de datos y otro de afuera, y consulte su nombre completo, su nombre de usuario en mattermost, edad, país de origen, ciudad donde residen, su especialidad científica, nombre del instituto en que estudian/laboran, y un hobbie o afición.**
+%% Cell type:markdown id: tags:
+## Solución (sin pandas)
+%% Cell type:markdown id: tags:
+Después de recopilar la información, creé un csv con todos los datos llamado *p_info.csv* y lo importé usando numpy.
+%% Cell type:code id: tags:
+``` python
+import numpy as np
+```
+%% Cell type:code id: tags:
+``` python
+data = np.loadtxt('p_info.csv', delimiter = '\t', dtype='str', unpack=True)
+```
+%% Cell type:markdown id: tags:
+La estrategia es crear una lista de *keys* que sean los usuarios de Mattermost y una lista de *values* que sean diccionarios con los otros datos.
+%% Cell type:code id: tags:
+``` python
+users = data[0][1:] # lista de usuarios usando slicing
+```
+%% Cell type:code id: tags:
+``` python
+info = [{data[i][0]:data[i][j] for i in range(1,len(data[1:])+1)} for j in range(1,len(data[0][1:])+1)]
+# lista de diccionarios usando un dic-comprehension dentro de una list-comprehension
+```
+%% Cell type:markdown id: tags:
+Ahora, usando el constructor *dic()* y la función *zip()* se puede crear el diccionario deseado [[1](https://stackoverflow.com/questions/209840/how-do-i-convert-two-lists-into-a-dictionary)].
+%% Cell type:code id: tags:
+``` python
+compas = dict(zip(users,info))
+```
+%% Cell type:markdown id: tags:
+**Cree una función que reciba como entrada el diccionario y un país de origen, y retorne las informaciones completas de todas las personas de ese país, tabuladas en una forma fácil de entender.**
+%% Cell type:code id: tags:
+``` python
+def bycountry(dic,country):
+    # obtengo los usuarios de las personas nacidas en ese pais
+    compatriots = [user for user in compas.keys() if compas[user]['pais'] == country]
+    # voy a imprimir verticalmente porque no cabe de manera horizontal
+    for compatriot in compatriots:
+        print('usuario: ' + compatriot)
+        for header in compas[compatriot].keys():
+            print('   \u25ba ' + header +  ' : ' + compas[compatriot][header])
+```
+%% Cell type:code id: tags:
+``` python
+bycountry(compas,'Colombia')
+```
+%% Output
+    usuario: nicole
+       ► nombre : Nicole
+       ► apellido : Hernández
+       ► pais : Colombia
+       ► residencia : Bucaramanga
+       ► edad : 23
+       ► especialidad : análisis de imagen médica
+       ► institucion : Universidad Industrial de Santander
+       ► hobbie : dibujar
+    usuario: vargass
+       ► nombre : Sasiri
+       ► apellido : Vargas
+       ► pais : Colombia
+       ► residencia : Cali
+       ► edad : 20
+       ► especialidad : sistemas de reacción difusión unidimensionales
+       ► institucion : Universidad del Valle
+       ► hobbie : bailar
+    usuario: navasa
+       ► nombre : Alfonso
+       ► apellido :  Navas
+       ► pais : Colombia
+       ► residencia : Bogotá
+       ► edad : 24
+       ► especialidad : física de sistemas complejos
+       ► institucion : Universidad Nacional de Colombia
+       ► hobbie : crossfit
+%% Cell type:markdown id: tags:
+**Busque una forma de calcular, a partir del diccionario, el promedio de edad de todas las personas en él, y una forma de mostrar todas las instituciones (sin repetición).**
+%% Cell type:code id: tags:
+``` python
+def age_average(dic):
+    # recupero la edad de cada persona (convertida a un entero) usando una list-comprehension
+    ages = [int(value['edad']) for value in dic.values()]
+    # imprimo el promedio
+    return sum(ages)/len(ages)
+```
+%% Cell type:code id: tags:
+``` python
+age_average(compas)
+```
+%% Output
+    22.5
+%% Cell type:code id: tags:
+``` python
+def institutions(dic):
+    # recupero las instituciones usando una list-comprehension y elimino duplicados convirtiéndola a un conjunto
+    insts = set([value['institucion'] for value in dic.values()])
+    # imprimo en distintas filas por claridad
+    for inst in insts:
+        print(inst)
+```
+%% Cell type:code id: tags:
+``` python
+institutions(compas)
+```
+%% Output
+    Universidad Nacional de Colombia
+    Universidad del Valle
+    Universidad Industrial de Santander
+    Universidad de los Andes