Ejercicios terminados y archivos en formato html añadidos

.gitignore

+.ipynb_checkpoints/

ejercicio1.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Estudiante: Angie Nicole Hernández Durán - UIS**\n",
+    "\n",
+    "# Lista de palabras\n",
+    "\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."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Voy a hacer una función que reciba dicha lista de palabras y haga lo requerido\n",
+    "\n",
+    "def organizador(string_of_words): #El argumento de mi función debe ser tipo str\n",
+    "    \n",
+    "    x = string_of_words.split('-')#Separo el string que tengo para poder comparar y ordenar las palabras\n",
+    "    x = list(dict.fromkeys(x))    #Hago de la lista un diccionario, y toma las keys, esto hace que se ignoren\n",
+    "                                  #las keys repetidas. luego se hace del diccionario de nuevo una lista\n",
+    "    x_sorted = sorted(x)          #Ordeno alfabéticamente\n",
+    "    y = '-'.join(x_sorted)        #Concateno la lista, poniendo guiones entre las palabras\n",
+    "    \n",
+    "    print(y)                      #Imprimo dicha lista\n",
+    "    \n",
+    "    return y                      #Dicha lista es además lo que devuelve mi función"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ahora una prueba"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ingrese una lista de palabras separadas SOLAMENTE por guiones:mesa-pared-piso-techo-edificio-pared-escritorio-botella-vaso-botella-libreta-lápiz-closet\n"
+     ]
+    }
+   ],
+   "source": [
+    "lista = input(\"Ingrese una lista de palabras separadas SOLAMENTE por guiones: \")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ingresamos lo anterior a la función"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "botella-closet-edificio-escritorio-libreta-lápiz-mesa-pared-piso-techo-vaso\n"
+     ]
+    }
+   ],
+   "source": [
+    "n = organizador(lista)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Parece que funciona bien"
+   ]
+  }
+ ],
+ "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
+}

ejercicio2.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Estudiante: Angie Nicole Hernández Durán - UIS**\n",
+    "\n",
+    "# Triángulo de Pascal\n",
+    "\n",
+    "## Parte 1\n",
+    "\n",
+    "Escriba una rutina en python que reciba como entrada un número entero, n, e imprima losnúmeros en la n-ésimafila del triángulo de Pascal. El programa debe verificar si el número es entero, o arrojar un mensaje informando que ha habido un error del usuario en caso contrario."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Primero voy a hacer una función para hacer un triángulo de pascal hasta la n-ésima linea"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "def triangulo_de_pascal(n):\n",
+    "\n",
+    "    pascal_matrix = np.zeros((n,n))     #Voy a comenzar con un arreglo de ceros donde poner mi triángulo\n",
+    "\n",
+    "    for i in range(n):\n",
+    "        pascal_matrix[i,0] = 1          #todos los números sobre lado izquierdo del triángulo son 1\n",
+    "        for j in range(n):\n",
+    "            if i == j:\n",
+    "                pascal_matrix[i,j] = 1  #todos los números sobre lado derecho del triángulo son 1 también\n",
+    "            elif i != j:\n",
+    "                pascal_matrix[i,j] = pascal_matrix[i-1,j-1] + pascal_matrix[i-1,j] #esta es la condición para \n",
+    "                                                                                   #todas las demás posiciones\n",
+    "    \n",
+    "    return pascal_matrix                #la función me devuelve el arreglo con el tríangulo de pascal\n",
+    "                                        #hasta la fila n\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ahora continúo con una función que tome este triángulo de pascal y me imprima la fila deseada"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def print_pascal(numero_entero):\n",
+    "    \n",
+    "    check = isinstance(numero_entero, int)                 #Aquí reviso si el número introducido es entero\n",
+    "    \n",
+    "    if check == True:                                      #Si sí lo es, continúa al triángulo de pascal\n",
+    "        triangle = triangulo_de_pascal(numero_entero)      #Usando mi función anterior, obtengo la matriz \n",
+    "                                                           #que necesito\n",
+    "        print(triangle[numero_entero-1,:])                 #Finalmente, imprimo la última fila\n",
+    "    else:\n",
+    "        print(\"Error, no se introdujo un número entero.\")   #Si el 'check' nota que no se introdujo un número entero\n",
+    "                                                           #devuelve un mensaje de error"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ahora una pequeña prueba"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[ 1.  8. 28. 56. 70. 56. 28.  8.  1.]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print_pascal(9)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Error, no se introdujo un número entero.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print_pascal(12.3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parte 2\n",
+    "\n",
+    "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.\n",
+    "\n",
+    "Para esto, modifico la anterior rutina para que revise que todas las entradas de la función sean enteros, obtengo el triángulo de pascal con tantas filas como necesite, es decir, hasta la mayor fila introducida. finalmente tomo solamente las líneas que indican los argumentos que se introducen en la función."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def print_pascal_var(*args):\n",
+    "    \n",
+    "    lista = list(args)\n",
+    "    check = [isinstance(x, int) for x in lista]            #Reviso si todos los números introducidos son enteros\n",
+    "    \n",
+    "    if False in check:                                     #Si alguno no lo es (hay algún 'False' en check)\n",
+    "                                                           # imprimo un mensaje de error\n",
+    "        print(\"Error, uno o más de los números introducidos no son enteros.\")  \n",
+    "        \n",
+    "    else:                                                  #Si todo es 'True', osea si todos son números enteros,\n",
+    "        max_num = int(max(lista))                          #hallo el número mayor\n",
+    "        \n",
+    "        triangle = triangulo_de_pascal(max_num)            #saco la matriz que necesito con el número mayor\n",
+    "        \n",
+    "        n = [list(triangle[i-1,:]) for i in lista]         #hago la lista con las filas requeridas, queda una\n",
+    "                                                           #lista de listas\n",
+    "        \n",
+    "        n = [[element for element in sub if element != 0.0] for sub in n] \n",
+    "                                                           #como comencé con una matriz de ceros,\n",
+    "                                                           #quito estos valores (0.0) de las filas que no son\n",
+    "                                                           #la más larga\n",
+    "        \n",
+    "        return n                                           #La función devuelve la lista de listas, 'nested list'.\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ahora unas pruebas"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Error, uno o más de los números introducidos no son enteros\n"
+     ]
+    }
+   ],
+   "source": [
+    "print_pascal_var(1,5,4.2,7,9,2,4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[1.0, 3.0, 3.0, 1.0], [1.0, 1.0], [1.0, 6.0, 15.0, 20.0, 15.0, 6.0, 1.0]]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "print_pascal_var(4,2,7)"
+   ]
+  }
+ ],
+ "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
+}

ejercicio3.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Estudiante: Angie Nicole Hernández Durán -UIS**\n",
+    "\n",
+    "# Amigos Congueros\n",
+    "\n",
+    "Entre en contacto con 10 estudiantes del curso de datos y 2 profesores o personal de soportede LaConga, uno del curso de datos y otro de afuera, y consulte su nombre completo, sunombre de usuario en mattermost, edad, pais de origen, ciudad donde residen, su especialidad científica, nombre del instituto en que estudian/laboran, y un hobbie o afición.\n",
+    "\n",
+    "**Guardé la información recopilada en un archivo csv que guardé en esta misma carpeta**\n",
+    "\n",
+    "## Parte1\n",
+    "\n",
+    "Cree un diccionario llamado “compas”, donde la llave sea el nombre de usuario en mattermost, y si depliego el valor almacenado, por ejemplo en compas[“juan-pineda”], lo que obtengo esa la vez otro diccionario, con las llaves “nombre”, “apellido”, “país”, “residencia”, “edad”,“institución”, “hobbie”.\n",
+    "\n",
+    "Para esto usaré Pandas porque son lo mejor."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pandas_ods_reader import read_ods       #Para leer mi archivo .ods\n",
+    "import pandas as pd                          #Por la gran ayuda que brindan para tratar datos"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "compas_data = read_ods(\"compas.ods\", 1)                            #leo lo que tengo en el archivo\n",
+    "\n",
+    "compas = compas_data.set_index(\"usuario\").to_dict(orient=\"index\")  \n",
+    "\n",
+    "#Aquí, primero tomo mi dataframe y hago que 'usuario' indexe el resto de datos, con 'set_index'. Luego, 'to_dict' \n",
+    "#hace un diccionario donde las llaves son los índices, pero como el resto de mis datos están así mismo \n",
+    "#sub-indexados por los nombres de las columnas, resulta también haciendo los diccionarios dentro del diccionario.\n",
+    "#De esta manera obtengo lo que se pide en esta primera parte."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'nombre': 'Jennifer',\n",
+       " 'apellido': 'Ortega',\n",
+       " 'edad': 25.0,\n",
+       " 'país': 'Ecuador',\n",
+       " 'residencia': 'Quito',\n",
+       " 'especialidad': 'imagen médica',\n",
+       " 'institución': 'Escuela Politécnica Nacional',\n",
+       " 'hobbie': 'dibujar'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "compas['ortegaj']\n",
+    "\n",
+    "#Aquí vemos que dentro de la llave 'ortegaj' hay un diccionario con las llaves 'nombre', \n",
+    "#'apellido', 'edad', etcétera"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(24.0, 'Caracas', 'ballet, cantar')"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Ahora accedemos a algunos de los valores de los sub-diccionarios de algunos compas\n",
+    "\n",
+    "compas['ramosd']['edad'], compas['britod']['residencia'], compas['vivasm']['hobbie']  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parte 2 \n",
+    "\n",
+    "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",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def paisanos(diccionario,país):\n",
+    "    \n",
+    "    dicc = diccionario\n",
+    "    \n",
+    "    obj = país\n",
+    "    \n",
+    "    #Encontré que se puede hacer \"dictionary comprehension\", y de esta manera obtengo sólo las llaves de los compas\n",
+    "    #que están en el mismo país. Me pareción una manera genial de acceder a los valores de \"nested dictionaries\".\n",
+    "    llaves = [k for k, v in dicc.items() if obj in v.values()]\n",
+    "    \n",
+    "    #Hago un diccionario donde pongo toda la información de los paisanos cuyas llaves encontré anteriormente\n",
+    "    paisanos_dict = {key : value for key, value in compas.items() if key in llaves}\n",
+    "    \n",
+    "    #Vuelvo el diccionario un dataframe para que sea fácil de entender.\n",
+    "    #Para esto, primero hago de los diccionarios dentro del diccionario, dataframes con pd.DataFrame.from_dict()\n",
+    "    #Luego hago un dataframe con las parejas de las llaves que encontré anteriormente, y todos los datos que hice\n",
+    "    #datasets previamente.\n",
+    "    #Honestamente me confundí un poco con el eje, y solo dejé 1 e 'index' porque se ve mejor que las alternativas.\n",
+    "    paisanos_data = pd.concat({k : pd.DataFrame.from_dict(v, 'index') for k, v in paisanos_dict.items()}, axis=1)\n",
+    "    \n",
+    "    #Devuelve el dataframe con la información completa de los paisanos\n",
+    "    return paisanos_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",