diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..763513e910f7036a1a3cdb21dce8e57da2451891
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.ipynb_checkpoints
diff --git a/Untitled.ipynb b/Untitled.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..0c50de04970fe913b05cfb8d46112bdddadfd58c
--- /dev/null
+++ b/Untitled.ipynb
@@ -0,0 +1,42 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Ejercicio 01 Lista de palabras separadas por guiones\n",
+ "\n",
+ "## LA-CoNGA 2021\n",
+ "\n",
+ "### Ejercicio elaborado por Eduardo E. Escalante R.\n",
+ "\n",
+ "### Nuestro programa debe aceptar una lista de palabras separadas por guiones, imprimir de vuelta las mismas palabras sin repetición y nuevamente separadas por guiones. Después ordenarlas alfabéticamente.\n",
+ "\n",
+ "Ejemplo: naranja-avión-melodÃa-tupla-avión\n",
+ "\n",
+ "salida esperada: avión-melodÃa-naranja-tupla"
+ ]
+ }
+ ],
+ "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
+}
diff --git a/compas.txt b/compas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d7d9e1d3491682d8ea71f8621dd9767c7199f6dc
--- /dev/null
+++ b/compas.txt
@@ -0,0 +1,11 @@
+#nombre, usuario, edad, pais, residencia, especialidad, instituto, hobbie
+"jose martin serrano torres","serranoj","27","peru","Lima","ciencia_de_materiales","Universidad_nacional_de_Ingenieria","videojuegos"
+"teofilo vargas aucalla","teofilo","54","peru","Lima","cosmologia","Universidad nacional mayor de san marcos","wing chun kuen"
+"luis alberto leon aldonayre","leonl","22","peru","provincia","gravitacion","Universidad nacional mayor de san marcos","guitarra"
+"siria sadeddin","sadeddins","30","venezuela","bogota","cosmologia","Universidad simon bolivar","data science"
+"rafael vinasco","vinascor","26","colombia","bogota","fisica de particulas","Universidad nacional de colombia","ajedrez"
+"anamaria font","afont","61","venezuela","alemania","teoria de campos y particulas","Universidad Central de venezuela","leer"
+"andrea carolina tugores hernandez","tugoresa","24","venezuela","caracas","isica","Universidad central de venezuela","tennis"
+"jesus david bermudez sanchez","bermudezj","25","colombia","bogota","estado solido","Universidad nacional de colombia","senderismo"
+"daniel arturo brito urbina","britod","26","venezuela","caracas","teoria de campos","Universidad central de venezuela","videojuegos"
+"juan david hernandez","hernandezj","24","colombia","bogota","electrodinamica cuantica","Universidad nacional de colombia","leer"
diff --git a/ejercicio1.ipynb b/ejercicio1.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..0e0142fcc0d394308cecd190a92fabc451c76545
--- /dev/null
+++ b/ejercicio1.ipynb
@@ -0,0 +1,253 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Ejercicio 01 Lista de palabras separadas por guiones\n",
+ "\n",
+ "## LA-CoNGA 2021\n",
+ "\n",
+ "### Ejercicio elaborado por Eduardo E. Escalante R.\n",
+ "\n",
+ "### Nuestro programa debe:\n",
+ "\n",
+ "1. aceptar una lista de palabras separadas por guiones\n",
+ "\n",
+ "2. Imprimir de vuelta las mismas palabras sin repetición y nuevamente separadas por guiones.\n",
+ "\n",
+ "3. Después ordenarlas alfabéticamente.\n",
+ "\n",
+ "Ejemplo: naranja-avión-melodÃa-tupla-avión\n",
+ "\n",
+ "salida esperada: avión-melodÃa-naranja-tupla"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 1. Aceptar una lista de palabras separadas por guiones"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\n",
+ "Ingrese las palabras que desea, separarlas con guiones naranja-avión-melodÃa-tupla-avión\n",
+ "\n",
+ "naranja-avión-melodÃa-tupla-avión\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Fase 1: Lectura de la cadena\n",
+ "# Pedimos que se ingrese la lista de palabras separadas por guiones\n",
+ "print(\"\")\n",
+ "print(\"\")\n",
+ "cadena = input(\"Ingrese las palabras que desea, separarlas con guiones \")\n",
+ "print(\"\")\n",
+ "print(cadena)\n",
+ "print(\"\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2. Imprimimos de vuelta las mismas palabras sin repetición y nuevamente separadas por guiones\n",
+ " \n",
+ "\n",
+ " 2.1. Como se muestra a continuación tomamos una serie de palabras separadas por guiones y mediante la función `split(\"-\")` separamos estas palabras y convertimos cada una de ellas en elementos de una lista."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\n",
+ "['naranja', 'avión', 'melodÃa', 'tupla', 'avión']\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "lista = cadena.split(\"-\")\n",
+ "print(\"\")\n",
+ "print(\"\")\n",
+ "print(lista)\n",
+ "print(\"\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " 2.2. Ordenemos la lista alfabéticamente usando la función `sort()`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\n",
+ "['avión', 'avión', 'melodÃa', 'naranja', 'tupla']\n"
+ ]
+ }
+ ],
+ "source": [
+ "lista.sort()\n",
+ "print(\"\")\n",
+ "print(\"\")\n",
+ "print(lista)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " 2.3. Por definición disponemos de un objeto de datos que puede almacenar nuestra lista de palabras y filtrar las repetidas haciendo que solo aparezcan una vez. Esto nos permitirá eliminar duplicaciones de palabras. Estos objetos los conocemos como conjuntos *(SETS)* en inglés."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\n",
+ "{'naranja', 'melodÃa', 'avión', 'tupla'}\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "palabras_filtradas = set(lista)\n",
+ "\n",
+ "print(\"\")\n",
+ "print(\"\")\n",
+ "print(palabras_filtradas)\n",
+ "print(\"\")\n",
+ "print(\"\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " 2.4. Convertimos el SET `palabras_filtradas` a lista para poder ordenar alfabeticamente sus elementos"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\n",
+ "['avión', 'melodÃa', 'naranja', 'tupla']\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "lista = list(palabras_filtradas)\n",
+ "\n",
+ "lista.sort()\n",
+ "\n",
+ "print(\"\")\n",
+ "print(\"\")\n",
+ "print(lista)\n",
+ "print(\"\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " 2.5. Si deseamos convertir esta lista nuevamente en una cadena de texto, utilizaremos la función `join` de la siguiente manera:\n",
+ "\n",
+ " `(\"sep\").join(lista)`\n",
+ "\n",
+ " donde *sep* representa el o los caracteres que deseamos utilizar como delimitador."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\n",
+ "avión-melodÃa-naranja-tupla\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Usamos la función join() para tomar los elementos de nuestra variable \"lista\" \n",
+ "# para imprimir nuevamente la cadena de palabras separadas por guiones\n",
+ "\n",
+ "cadena_de_caracteres = (\"-\").join(lista)\n",
+ "print(\"\")\n",
+ "print(\"\")\n",
+ "print(cadena_de_caracteres)\n",
+ "print(\"\")"
+ ]
+ }
+ ],
+ "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
+}
diff --git a/ejercicio2.ipynb b/ejercicio2.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..abeaee453ce03ca41f1106b6f90efcda26717693
--- /dev/null
+++ b/ejercicio2.ipynb
@@ -0,0 +1,289 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Ejercicio 02 Triángulo de Pascal\n",
+ "\n",
+ "## LA-CoNGA 2021\n",
+ "\n",
+ "### Ejercicio elaborado por Eduardo E. Escalante R.\n",
+ "\n",
+ "### 1. Escribiremos una rutina que reciba como entrada un número entero `n` y que imprimirá los números de la *n*-ésima fila del triángulo de Pascal, en el proceso debe verificar si el número `n` es de tipo entero y en caso contrario imprimir un mensaje informando que hay un error.\n",
+ "\n",
+ "\n",
+ "#### 1.1. Primer paso diseñemos nuestro código\n",
+ "\n",
+ "\n",
+ "\n",
+ "En esta primera parte del ejercicio construà un programa compuesto de dos partes principales basadas en el enunciado del problema:\n",
+ "\n",
+ "- Ingreso de datos: esta parte solicita el dato necesario para que el programa se ejecute (un número entero positivo > 0) y mediante un lazo while hacemos el proceso de validación del tipo de variable ingresada, de hecho, la ejecución permanece en esta etapa del código hasta que se entregue un valor valido.\n",
+ "\n",
+ "- La segunda parte corresponde al cálculo de los valores, aquà jugué con las listas y su similitud en el lenguaje FORTRAN (puesto mi experiencia en programación era solo en ese lenguaje). Aquà generamos una lista, llamada `lista`que usaremos para guardar los valores calculados dentro de un lazo anidado donde se ajusta la longitud de `lista` y dentro del lazo más interno hacer el cálculo de los nuevos valores almacenándolos en la variable `nueva_lista` para luego actualizar `lista`. Cuando el cálculo se ejecuta ubicamos la estructura condicional `if i == (n-1):` para escribir únicamente la última fila de nuestro triángulo de pascal. Si comentamos el condicional nuestro programa imprimirá todas las filas con los valores correspondientes al triangulo hasta el valor entero `n`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "Escribe la altura del triangulo, debe ser un entero >= 1: 6\n",
+ "\n",
+ "\n",
+ "Lo que escribiste es un entero\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"\")\n",
+ "\n",
+ "# Hacemos la validación de la variable de entrada notificando\n",
+ "# al usuario que debe ser entero,\n",
+ "# Para validarlo, simplemente intentamos convertir el número a\n",
+ "# entero, esto lo hacemos dentro de try. De ser entero se imprime\n",
+ "# \"Lo que escribiste es un entero\" y salimos del lazo while usando el break.\n",
+ "# En caso que el valor ingresado no sea entero esperamos una excepción con except\n",
+ "# ValueError y notificamos por pantalla \"Lo que escribiste NO es un entero\"\n",
+ "# El lazo while tiene la finalidad de mantenernos dentro del programa hasta\n",
+ "# que el usuario nos de un valor de tipo válido.\n",
+ "#*****************************************************\n",
+ "\n",
+ "while True:\n",
+ " n = input(\"Escribe la altura del triangulo, debe ser un entero >= 1: \")\n",
+ " try:\n",
+ " n = int(n)\n",
+ " print(\"\")\n",
+ " print(\"\")\n",
+ " print(\"Lo que escribiste es un entero\")\n",
+ " break\n",
+ " except ValueError:\n",
+ " print(\"\")\n",
+ " print(\"\")\n",
+ " print(\"Lo que escribiste NO es un entero\")\n",
+ "\n",
+ "#*****************************************************"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "Fila 6 [1, 5, 10, 10, 5, 1]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Nuestro primer paso es darle el valor 1 al primer elemento de nuestra lista\n",
+ "\n",
+ "lista = [1]\n",
+ "\n",
+ "for i in range(n):\n",
+ " # LÃnea del lazo principal donde imprimo, únicamente la última fila del triángulo de Pascal\n",
+ " if i == (n-1):\n",
+ " print(\"\")\n",
+ " print(\"Fila \", i + 1, lista)\n",
+ " \n",
+ " # Dado que la cantidad de elementos que imprimimos depende del número n\n",
+ " # construiremos una lista vacÃa \n",
+ " nueva_lista = []\n",
+ " \n",
+ " # Esa nueva lista la ajustamos a la cantidad de elementos de cada fila calculada\n",
+ " # sabiendo que los elementos de los extremos siempre son igual a 1\n",
+ " nueva_lista.append(lista[0])\n",
+ "\n",
+ " # Lazo anidado (nested) en el cual vamos sumando los elementos guardados en lista\n",
+ " # para generar los valores correspondientes a nuestra nueva_lista que viene a ser\n",
+ " # nuestra nueva fila de valores\n",
+ " for i in range(len(lista) - 1):\n",
+ " nueva_lista.append(lista[i] + lista[i+1])\n",
+ " nueva_lista.append(lista[-1])\n",
+ " lista = nueva_lista"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### 1.2. Convirtamos este programa en una función\n",
+ "\n",
+ "Ya no tenemos la necesidad de modificar el código, este nos servirá como base fundamental para que en esta etapa apliquemos la definición de función en Python y construyamos una función llamada `pascal`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def pascal (n):\n",
+ " lista = [1]\n",
+ " \n",
+ " for i in range(n):\n",
+ " \n",
+ " if i == (n-1):\n",
+ " print(\"\")\n",
+ " return(lista)\n",
+ " nueva_lista = []\n",
+ " nueva_lista.append(lista[0])\n",
+ " for i in range(len(lista) - 1):\n",
+ " nueva_lista.append(lista[i] + lista[i+1])\n",
+ " nueva_lista.append(lista[-1])\n",
+ " lista = nueva_lista"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Escribe la altura del triangulo, debe ser un entero >= 1: 15\n",
+ "\n",
+ "\n",
+ "Lo que escribiste es un entero\n"
+ ]
+ }
+ ],
+ "source": [
+ "while True:\n",
+ " n = input(\"Escribe la altura del triangulo, debe ser un entero >= 1: \")\n",
+ " try:\n",
+ " n = int(n)\n",
+ " print(\"\")\n",
+ " print(\"\")\n",
+ " print(\"Lo que escribiste es un entero\")\n",
+ " break\n",
+ " except ValueError:\n",
+ " print(\"\")\n",
+ " print(\"\")\n",
+ " print(\"Lo que escribiste NO es un entero\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "En la siguiente celda presentamos el llamado a la función `pascal`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "[1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Esta es la manera como se invoca nuestra función pascal()\n",
+ "\n",
+ "print(pascal(n))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2. Modifiquemos la rutina para que reciba un número variable de argumentos $n_{1},n_{2},n_{3}...$ y retorne una lista conteniendo los números de la *n*-ésima fila\n",
+ "\n",
+ "Para manejar una cantidad variable de argumentos planteo la siguiente solución:\n",
+ "\n",
+ "- Guardar la cantidad de argumentos que quiere ingresar el usuario usando la variable `tamanho`\n",
+ "\n",
+ "- Una vez que se conoce el valor de la variable `tamanho` podemos crear una lista donde almacenaremos los valores que se usarán, en nuestro caso esa lista se llama `lista_de_valores` con lo cual podremos disponer del conjunto de valores deseados e ingresarlos uno a uno en nuestra función `pascal`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Cuantos valores quieres utilizar?6\n",
+ "ingrese el valor 11\n",
+ "ingrese el valor 9\n",
+ "ingrese el valor 5\n",
+ "ingrese el valor 3\n",
+ "ingrese el valor 6\n",
+ "ingrese el valor 2\n",
+ "Escogiste los valores: [11, 9, 5, 3, 6, 2]\n",
+ "\n",
+ "\n",
+ "Para el entero 11 ----> [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1]\n",
+ "\n",
+ "Para el entero 9 ----> [1, 8, 28, 56, 70, 56, 28, 8, 1]\n",
+ "\n",
+ "Para el entero 5 ----> [1, 4, 6, 4, 1]\n",
+ "\n",
+ "Para el entero 3 ----> [1, 2, 1]\n",
+ "\n",
+ "Para el entero 6 ----> [1, 5, 10, 10, 5, 1]\n",
+ "\n",
+ "Para el entero 2 ----> [1, 1]\n"
+ ]
+ }
+ ],
+ "source": [
+ "tamanho = int(input(\"Cuantos valores quieres utilizar?\"))\n",
+ "\n",
+ "lista_de_valores = []\n",
+ "\n",
+ "for i in range(tamanho):\n",
+ " temp = int(input(\"ingrese el valor \"))\n",
+ " lista_de_valores.append(temp)\n",
+ "print(\"\")\n",
+ "print(\"Escogiste los valores:\",lista_de_valores)\n",
+ "print(\"\")\n",
+ "\n",
+ "for j in lista_de_valores:\n",
+ " print(\"Para el entero \", j,\" ----> \", pascal(j))"
+ ]
+ }
+ ],
+ "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
+}
diff --git a/ejercicio3.ipynb b/ejercicio3.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..7dfc744695ac4c9d22355d437566a7a86d39ccc4
--- /dev/null
+++ b/ejercicio3.ipynb
@@ -0,0 +1,143 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Ejercicio 03 Lista de palabras separadas por guiones\n",
+ "\n",
+ "## LA-CoNGA 2021\n",
+ "\n",
+ "### Ejercicio elaborado por Eduardo E. Escalante R.\n",
+ "\n",
+ "En este ejercicio debemos entrar en contacto con 10 estudiantes y 2 profesores o personal de soporte de LA-CoNGA, uno del curso de datos y otro de afuera, y consulte:\n",
+ "\n",
+ "- nombre\n",
+ "- nombre de usuario en mattermost\n",
+ "- edad\n",
+ "- paÃs de origen\n",
+ "- ciudad donde reside\n",
+ "- especialidad cientÃfica\n",
+ "- nombre del instituto en el que estudia o labora\n",
+ "- un hobbie o afición\n",
+ "\n",
+ "Crear un diccionario llamado compas donde la llave sea el nombre del usuario en mattermost y si despliego el valor almacenado, por ejemplo en compas[juan-pineda] lo que obtengo es a la vez otro diccionario con las llaves \"nombre\", \"apellido\", \"paÃs\", \"residencia\", \"edad\", \"institucion\" y \"hobbie\"\n",
+ "\n",
+ "crear una función que reciba como entrada el diccionario y un paÃs de origen y retorne la información completa de todas las personas de ese paÃs tabuladas en una forma fácil de entender\n",
+ "\n",
+ "-Busque una forma de calcular a partir del diccionario, el promedio de edad de todas las personas en él, y una forma de mostrar las instituciones sin repetición.\n",
+ "\n",
+ "\n",
+ "En este tercer ejercicio no tuve algunos problemas para implementar el programa usando un archivo `compas.txt`, pero lo abordé probando algunas ideas por pantalla y comprobé que el diccionario compuesto por claves y valores que a su vez están compuestas por subclaves y subvalores funcionó.\n",
+ "\n",
+ "El programa es muy sencillo en su estructura:\n",
+ "\n",
+ "- genera un diccionario llamado compas con los datos de mis compañeros y profesores\n",
+ "\n",
+ "- solicita el nombre del usuario\n",
+ "\n",
+ "- Se realiza la busqueda, si la clave está en nuestro diccionario imprime la información de ese usuario por pantalla en el caso de no aparecer en el registro imprimirá \"usuario desconocido\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Ingrese un nombre de usuariobritod\n",
+ "\n",
+ "Esta en mis contactos!\n",
+ "\n",
+ "{'nombre': 'daniel brito', 'edad': '26', 'pais': 'Venezuela', 'residencia': 'Caracas', 'especialidad': 'teoria de campos', 'instituto': 'Universidad central de venezuela', 'hobbie': 'videojuegos'}\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "compas = {}\n",
+ "\n",
+ "# nombre, usuario, edad, pais, residencia, especialidad, instituto, hobbie\n",
+ "\n",
+ "compas = {\"serranoj\": {\"nombre\":\"jose serrano\",\"edad\":\"27\", \"pais\":\"Peru\",\n",
+ " \"residencia\":\"Lima\", \"especialidad\":\"ciencia de materiales\",\n",
+ " \"instituto\":\"Universidad nacional de ingenieria\",\n",
+ " \"hobbie\":\"videojuegos\"},\n",
+ " \"teofilo\": {\"nombre\":\"teofilo vargas\", \"edad\":\"54\", \"pais\":\"Peru\",\n",
+ " \"residencia\":\"Lima\", \"especialidad\":\"cosmologia\",\n",
+ " \"instituto\":\"Universidad nacional mayor de san marcos\",\n",
+ " \"hobbie\":\"wing chun kuen\"},\n",
+ " \"leonl\": {\"nombre\":\"luis leon\", \"edad\":\"22\", \"pais\":\"Peru\",\n",
+ " \"residencia\":\"Provincia\", \"especialidad\":\"gravitacion\",\n",
+ " \"instituto\":\"Universidad mayor de san marcos\",\n",
+ " \"hobbie\":\"guitarra\"},\n",
+ " \"sadeddins\": {\"nombre\":\"siria sadeddin\", \"edad\":\"30\", \"pais\":\"Venezuela\",\n",
+ " \"residencia\":\"bogota\", \"especialidad\":\"cosmologia\",\n",
+ " \"instituto\":\"Universidad simon bolivar\",\n",
+ " \"hobbie\":\"data science\"},\n",
+ " \"vinascor\": {\"nombre\":\" rafael vinasco\", \"edad\":\"26\", \"pais\":\"Colombia\",\n",
+ " \"residencia\":\"Bogota\", \"especialidad\":\"fisica de particulas\",\n",
+ " \"instituto\":\"Universidad nacional de colombia\",\n",
+ " \"hobbie\":\"ajedrez\"},\n",
+ " \"afont\": {\"nombre\":\"anamaria font\", \"edad\":\"61\", \"pais\":\"Venezuela\",\n",
+ " \"residencia\":\"Alemania\", \"especialidad\":\"teoria de campos y particulas\",\n",
+ " \"instituto\":\"Universidad central de venezuela\",\n",
+ " \"hobbie\":\"leer\"},\n",
+ " \"tugoresa\": {\"nombre\":\"andrea tugores\", \"edad\":\"24\", \"pais\":\"Venezuela\",\n",
+ " \"residencia\":\"Caracas\", \"especialidad\":\"fisica\",\n",
+ " \"instituto\":\"Universidad central de venezuela\",\n",
+ " \"hobbie\":\"tenis\"},\n",
+ " \"bermudezj\": {\"nombre\":\"jesus bermudez\", \"edad\":\"25\", \"pais\":\"Colombia\",\n",
+ " \"residencia\":\"Bogota\", \"especialidad\":\"estado solido\",\n",
+ " \"instituto\":\"Universidad nacional de colombia\",\n",
+ " \"hobbie\":\"senderismo\"},\n",
+ " \"britod\": {\"nombre\":\"daniel brito\", \"edad\":\"26\", \"pais\":\"Venezuela\",\n",
+ " \"residencia\":\"Caracas\", \"especialidad\":\"teoria de campos\",\n",
+ " \"instituto\":\"Universidad central de venezuela\",\n",
+ " \"hobbie\":\"videojuegos\"},\n",
+ " \"hernandezj\": {\"nombre\":\"juan hernandez\", \"edad\":\"24\", \"pais\":\"Colombia\",\n",
+ " \"residencia\":\"Bogota\", \"especialidad\":\"electrodinamica cuantica\",\n",
+ " \"instituto\":\"Universidad nacional de colombia\",\n",
+ " \"hobbie\":\"leer\"}}\n",
+ "\n",
+ "usuario = input(\"Ingrese un nombre de usuario\")\n",
+ "\n",
+ "valor = compas.get(usuario)\n",
+ "\n",
+ "if valor is None:\n",
+ " print(\"\")\n",
+ " print(\"Usuario desconocido\")\n",
+ "else:\n",
+ " print(\"\")\n",
+ " print(\"Esta en mis contactos!\")\n",
+ " print(\"\")\n",
+ " print(valor)\n",
+ " print(\"\")\n"
+ ]
+ }
+ ],
+ "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
+}