diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..87620ac7e74efee566c6ee9d2ed7281ebafb4788
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.ipynb_checkpoints/
diff --git a/ejercicio1.ipynb b/ejercicio1.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..adde077ddd4efecf4102907e44832ebc5f75f50e
--- /dev/null
+++ b/ejercicio1.ipynb
@@ -0,0 +1,125 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Jocabed Martínez"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Ejercicio 1. 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.\n",
+    "\n",
+    "Ejemplo de entrada: naranja-avión-melodía-tupla-avión\n",
+    "Salida esperada: avión-melodía-naranja-tupla"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Creamos una función llamada list_palabras que haga todo el procedimiento descrito en el ejercicio"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Función\n",
+    "\n",
+    "def list_palabras(palabras): \n",
+    "    lista_1 = palabras.split('-') #Separa el str del argumento en las palabras y se crea una lista con estas  \n",
+    "    lista_2 = [] #Creamos una lista vacía\n",
+    "    for palabra in lista_1: #Para cada palabra en la lista_1\n",
+    "        if palabra not in lista_2: #Si la palabra no está en la lista_2, agregar a esta \n",
+    "            lista_2.append(palabra) \n",
+    "    lista_2 = sorted(lista_2) #Ordenamos alfabéticamente las palabras de la lista\n",
+    "    lista_2 = '-'.join(lista_2) #Vuelve a unir las palabras de la lista ordenada anteriormente con un guíon \n",
+    "    return lista_2 #La función retorna las palabras ordenadas alfabéticamente y separadas por un guión"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Aplicamos la función al ejemplo del ejercicio: naranja-avión-melodía-tupla-avión, e imprimimos el resultado"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "avión-melodía-naranja-tupla\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(list_palabras('avión-melodía-naranja-tupla'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Vemos que se obtuvo lo esperado. Probemos con otro ejemplo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "bien-como-estas-hola-yo\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(list_palabras('hola-como-estas-yo-bien'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Vemos así que la función ordena alfabéticamente las palabras y las separa nuevamente con guiones"
+   ]
+  }
+ ],
+ "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..589d7ef250f78ff4e9ecc60858064039362b944b
--- /dev/null
+++ b/ejercicio2.ipynb
@@ -0,0 +1,325 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Jocabed Martínez"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Ejercicio 2. Triángulo de Pascal\n",
+    "\n",
+    "* 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.\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. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Creamos una función para obtener la n-ésima fila del triángulo de Pascal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Función para obtener la n-ésima fila del triángulo de Pascal\n",
+    "\n",
+    "def Pascal_triangle(n): #El argumento sería el número correspondiente a la fila deseada\n",
+    "    list1 = [] #Creamos una lista que contenga las n filas\n",
+    "    for i in range(n): #Para cada posición de la lista anterior, agregaremos la fila, seria otra lista\n",
+    "        list2 = [] #Esta sería cada fila \n",
+    "        for j in range(i + 1): #Para cada fila\n",
+    "            if j == 0 or j == i: #Para la primera y última posición de la fila, debe haber un uno\n",
+    "                list2.append(1)\n",
+    "            else: #Los valores intermedios son la suma de los valores de la fila anterior\n",
+    "                list2.append(list1[i-1][j-1] + list1[i-1][j]) #y de la posición j y anterior\n",
+    "        list1.append(list2) #Agregamos cada fila en la lista de n filas\n",
+    "    print('La fila del triángulo de Pascal correspondiente al número', n, 'es:', list1[-1])  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ahora, para verificar si el número es entero, utilizamos try, except. Con try intentamos de que aplique la función definida anteriormente, si es un número entero, no habrá problema; si no es un número entero utilizamos el except para que muestre un mensaje de error."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "La fila del triángulo de Pascal correspondiente al número 4 es: [1, 3, 3, 1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    Pascal_triangle(4)\n",
+    "except:\n",
+    "    print('Error. Lo que ha ingresado no es un número entero')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Vemos que para el número 4 se obtuvo la cuarta fila correspondiente al triángulo de Pascal. Ahora intentemos con otro número."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "La fila del triángulo de Pascal correspondiente al número 6 es: [1, 5, 10, 10, 5, 1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    Pascal_triangle(6)\n",
+    "except:\n",
+    "    print('Error. Lo que ha ingresado no es un número entero')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Vemos que para el número 6 se obtuvo la sexta fila correspondiente al triángulo de Pascal. Probemos ahora ingresar algo que no es un número entero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Error. Lo que ha ingresado no es un número entero\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    Pascal_triangle(0.4)\n",
+    "except:\n",
+    "    print('Error. Lo que ha ingresado no es un número entero')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Vemos que para 0.4, efectivamente muestra un error, ya que 0.4 no es un número entero. Probemos con un string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Error. Lo que ha ingresado no es un número entero\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    Pascal_triangle('hola')\n",
+    "except:\n",
+    "    print('Error. Lo que ha ingresado no es un número entero')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nuevamente muestra el mismo error."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ahora generalizamos lo anterior para varios n. Definimos ahora una función similar a la anterior pero que admita varios argumentos. Utilizamos también try y except dentro de la función para verificar si los números dados son enteros."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def Pascal_triangle_ns(*args):\n",
+    "    lista_pascal = [] #Lista que va a contener las filas de todos los números\n",
+    "    for n in args:\n",
+    "        try:#Si es un entero que haga el procedimiento para obtener la fila\n",
+    "            #EL procedimiento es similar al descrito en la función para un solo número\n",
+    "            list1 = [] \n",
+    "            for i in range(n): \n",
+    "                list2 = [] \n",
+    "                for j in range(i + 1): \n",
+    "                    if j == 0 or j == i: \n",
+    "                        list2.append(1)\n",
+    "                    else: \n",
+    "                        list2.append(list1[i-1][j-1] + list1[i-1][j]) \n",
+    "                list1.append(list2) \n",
+    "            lista_pascal.append(list1[-1]) \n",
+    "        except: #Si no es un entero que muestre un mensaje de error\n",
+    "            print('Error.', n, 'no es un entero')     \n",
+    "    print('Las filas son:', lista_pascal)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Probamos con 3 números."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Las filas son: [[1, 3, 3, 1], [1, 5, 10, 10, 5, 1], [1, 4, 6, 4, 1]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "Pascal_triangle_ns(4,6,5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Probamos con 5 números."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Las filas son: [[1, 3, 3, 1], [1, 5, 10, 10, 5, 1], [1, 4, 6, 4, 1], [1, 2, 1]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "Pascal_triangle_ns(4,6,5,3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Vemos que se obtiene una lista con las filas correspondientes a cada número. Ahora probemos ingresando un número que sea entero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Error. 0.4 no es un entero\n",
+      "Las filas son: [[1, 3, 3, 1], [1, 5, 10, 10, 5, 1], [1, 4, 6, 4, 1]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "Pascal_triangle_ns(4,6,5,0.4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Obtenemos una lista con las filas de los que si son números enteros, mientras que para el que no es número entero obtenemos un mensaje de error. Intentemos ahora con un string y un float."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Error. 0.4 no es un entero\n",
+      "Error. hola no es un entero\n",
+      "Las filas son: [[1, 3, 3, 1], [1, 5, 10, 10, 5, 1], [1, 4, 6, 4, 1]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "Pascal_triangle_ns(4,6,5,0.4,'hola')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "De nuevo, obtenemos un mensaje de error para los que no son números enteros, y la lista de filas de los que si lo son."
+   ]
+  }
+ ],
+ "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
+}