diff --git a/your-code/.ipynb_checkpoints/main-checkpoint.ipynb b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb index d68aeb6..4935251 100755 --- a/your-code/.ipynb_checkpoints/main-checkpoint.ipynb +++ b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -30,23 +30,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def summation(num):\n", " # This function returns 1+2+3+....+num\n", " \n", - " # Your code here: " + " # Your code here:\n", + " \"\"\"Esta funcion se encarga se encontrar la sumatoria de 1 hasta el numero introducido\"\"\"\n", + "# count = 0 # Otra forma de hacerlo!\n", + "# for i in range(num + 1):\n", + "# count += i\n", + "# return count\n", + " \n", + " list_numbers = [i for i in range(num+1)] # Añadimos 1 porque queremos que el ultimo numero se cuente\n", + " return sum(list_numbers)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2926\n" + ] + } + ], "source": [ - "# print summation" + "# print summation\n", + "print(summation(num))" ] }, { @@ -60,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -69,23 +86,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def summation2(*args):\n", " # This function returns the sum of *args\n", " \n", - " # Your code here:" + " # Your code here:\n", + " return sum(args)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + } + ], "source": [ - "# print summation2" + "# print summation2\n", + "print(summation2(*array))" ] }, { @@ -97,23 +124,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def summation3(a, b, c):\n", " # This function returns a+b+c\n", " \n", - " # Your code here:" + " # Your code here:\n", + " return a + b + c" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + } + ], "source": [ - "# print summation3" + "# print summation3\n", + "print(summation3(*array))" ] }, { @@ -125,32 +162,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "dictionary={'red':3, 'blue':8, 'green':24, 'orange':12, 'purple':10}" + "dictionary={'red':3, 'blue':8, 'green':24, 'orange':12, 'purple':10}\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "def summation4(**kwargs):\n", " # This function returns the sum of all M&Ms, except the red ones\n", " \n", - " # Your code here:" + " # Your code here:\n", + " valores_MM = [values for keys, values in kwargs.items() if keys != 'red']\n", + " return sum(valores_MM)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "54\n" + ] + } + ], "source": [ - "# print summation4" + "# print summation4\n", + "print(summation4(**dictionary))" ] }, { @@ -162,7 +210,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -175,23 +223,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "def summation5('define the function input'):\n", + "def summation5(a, b, c, *args, **kwargs):\n", " # This function returns the sum of a,b,c,d and e\n", " # You need to define the function input\n", - " # Your code here:" + " # Your code here:\n", + " dict_values = [values for keys, values in kwargs.items()]\n", + " return (a + b + c + sum(args) + sum(dict_values))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "769\n" + ] + } + ], "source": [ - "# print summation5" + "# print summation5\n", + "print(summation5(a, b, c, *d, **e))" ] }, { @@ -205,13 +264,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], "source": [ "# We first define our iterator:\n", "\n", - "iterator = iter([1,2,3])\n", + "iterator = iter([1,2,3]) # Los iteradores son objetos que representan un conjunto de datos. Se crean usando la funcion\n", + " # iter([1, 2, 6, 8]) y soportan la funcion next(NAME) que nos devuelve el proximo valor del\n", + " # iterable. IMPORTANTE no se puede volver al iterable anterior\n", "\n", "# We can now iterate through the object using the next function\n", "\n", @@ -220,9 +289,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], "source": [ "# We continue to iterate through the iterator.\n", "\n", @@ -231,18 +308,38 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], "source": [ "print(next(iterator))" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "ename": "StopIteration", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mStopIteration\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# After we have iterated through all elements, we will get a StopIteration Error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mStopIteration\u001b[0m: " + ] + } + ], "source": [ "# After we have iterated through all elements, we will get a StopIteration Error\n", "\n", @@ -251,12 +348,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n" + ] + } + ], "source": [ "# We can also iterate through an iterator using a for loop like this:\n", - "# Note: we cannot go back directly in an iterator once we have traversed through the elements. \n", + "# Note: we cannot go back directly in an iterator once we have traversed through the elements. #IMPORTANTE\n", "# This is why we are redefining the iterator below\n", "\n", "iterator = iter([1,2,3])\n", @@ -274,11 +381,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ - "iterator=iter([1,2,3])\n", + "iterator=iter([1,5,10,4,2,3])\n", "\n", "def divisible2(iterator):\n", " # This function takes an iterable and returns the first element that is divisible by 2 and zero otherwise\n", @@ -288,16 +395,34 @@ " # Sample Input: iter([1,2,3])\n", " # Sample Output: 2\n", " \n", - " # Your code here:" + " # Your code here:\n", + " value = 0\n", + " for i in iterator:\n", + " if i % 2 == 0:\n", + " value = i\n", + " break # Una vez conseguido nuestro primer iterador que es divisible entre 2 rompemos el for loop\n", + " # y regresamos el valor correspondiente\n", + " return value" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 28, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], "source": [ - "# print divisible2" + "# print divisible2\n", + "print(divisible2(iterator))" ] }, { @@ -311,12 +436,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ - "def firstn(n):\n", - " number = 0\n", + "def firstn(n): # Generators son funciones que nos permiten crear iterables. Se definen igual que la funciones pero \n", + " number = 0 # en vez de return usan yield\n", " while number < n:\n", " yield number\n", " number = number + 1" @@ -331,13 +456,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n" + ] + } + ], "source": [ "iterator = firstn(5)\n", "\n", - "for i in iterator:\n", + "for i in iterator: # Solo podemos movernos a travez del obtejo iterator a travez de la funcion next() o con un foor loop\n", " print(i)" ] }, @@ -350,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -360,16 +497,49 @@ " # Output: iterator\n", " \n", " # Sample Input: 5\n", - " # Sample Output: iter([0, 2, 4])" + " # Sample Output: iter([0, 2, 4])\n", + " \n", + " number = 0 # Contador\n", + " while number <= n: # Hasta que no pase por todos los valores de n no sale del loop while\n", + " if number % 2 == 0: # Este if nos permitira que solo los valores que son divisibles entre dos de devuelvan en forma de iterador\n", + " yield number\n", + " \n", + " number += 1" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# print even_iterator" + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "0\n", + "2\n", + "4\n", + "6\n", + "8\n", + "10\n", + "12\n", + "14\n", + "16\n", + "18\n", + "20\n", + "22\n", + "24\n", + "26\n", + "28\n" + ] + } + ], + "source": [ + "# print even_iterator\n", + "print(type(iterator))\n", + "for i in even_iterator(29):\n", + " print(i)" ] }, { @@ -396,7 +566,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/your-code/main.ipynb b/your-code/main.ipynb index d68aeb6..4935251 100755 --- a/your-code/main.ipynb +++ b/your-code/main.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -30,23 +30,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def summation(num):\n", " # This function returns 1+2+3+....+num\n", " \n", - " # Your code here: " + " # Your code here:\n", + " \"\"\"Esta funcion se encarga se encontrar la sumatoria de 1 hasta el numero introducido\"\"\"\n", + "# count = 0 # Otra forma de hacerlo!\n", + "# for i in range(num + 1):\n", + "# count += i\n", + "# return count\n", + " \n", + " list_numbers = [i for i in range(num+1)] # Añadimos 1 porque queremos que el ultimo numero se cuente\n", + " return sum(list_numbers)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2926\n" + ] + } + ], "source": [ - "# print summation" + "# print summation\n", + "print(summation(num))" ] }, { @@ -60,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -69,23 +86,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def summation2(*args):\n", " # This function returns the sum of *args\n", " \n", - " # Your code here:" + " # Your code here:\n", + " return sum(args)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + } + ], "source": [ - "# print summation2" + "# print summation2\n", + "print(summation2(*array))" ] }, { @@ -97,23 +124,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def summation3(a, b, c):\n", " # This function returns a+b+c\n", " \n", - " # Your code here:" + " # Your code here:\n", + " return a + b + c" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + } + ], "source": [ - "# print summation3" + "# print summation3\n", + "print(summation3(*array))" ] }, { @@ -125,32 +162,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "dictionary={'red':3, 'blue':8, 'green':24, 'orange':12, 'purple':10}" + "dictionary={'red':3, 'blue':8, 'green':24, 'orange':12, 'purple':10}\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "def summation4(**kwargs):\n", " # This function returns the sum of all M&Ms, except the red ones\n", " \n", - " # Your code here:" + " # Your code here:\n", + " valores_MM = [values for keys, values in kwargs.items() if keys != 'red']\n", + " return sum(valores_MM)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "54\n" + ] + } + ], "source": [ - "# print summation4" + "# print summation4\n", + "print(summation4(**dictionary))" ] }, { @@ -162,7 +210,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -175,23 +223,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "def summation5('define the function input'):\n", + "def summation5(a, b, c, *args, **kwargs):\n", " # This function returns the sum of a,b,c,d and e\n", " # You need to define the function input\n", - " # Your code here:" + " # Your code here:\n", + " dict_values = [values for keys, values in kwargs.items()]\n", + " return (a + b + c + sum(args) + sum(dict_values))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "769\n" + ] + } + ], "source": [ - "# print summation5" + "# print summation5\n", + "print(summation5(a, b, c, *d, **e))" ] }, { @@ -205,13 +264,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], "source": [ "# We first define our iterator:\n", "\n", - "iterator = iter([1,2,3])\n", + "iterator = iter([1,2,3]) # Los iteradores son objetos que representan un conjunto de datos. Se crean usando la funcion\n", + " # iter([1, 2, 6, 8]) y soportan la funcion next(NAME) que nos devuelve el proximo valor del\n", + " # iterable. IMPORTANTE no se puede volver al iterable anterior\n", "\n", "# We can now iterate through the object using the next function\n", "\n", @@ -220,9 +289,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], "source": [ "# We continue to iterate through the iterator.\n", "\n", @@ -231,18 +308,38 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], "source": [ "print(next(iterator))" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "ename": "StopIteration", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mStopIteration\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# After we have iterated through all elements, we will get a StopIteration Error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mStopIteration\u001b[0m: " + ] + } + ], "source": [ "# After we have iterated through all elements, we will get a StopIteration Error\n", "\n", @@ -251,12 +348,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n" + ] + } + ], "source": [ "# We can also iterate through an iterator using a for loop like this:\n", - "# Note: we cannot go back directly in an iterator once we have traversed through the elements. \n", + "# Note: we cannot go back directly in an iterator once we have traversed through the elements. #IMPORTANTE\n", "# This is why we are redefining the iterator below\n", "\n", "iterator = iter([1,2,3])\n", @@ -274,11 +381,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ - "iterator=iter([1,2,3])\n", + "iterator=iter([1,5,10,4,2,3])\n", "\n", "def divisible2(iterator):\n", " # This function takes an iterable and returns the first element that is divisible by 2 and zero otherwise\n", @@ -288,16 +395,34 @@ " # Sample Input: iter([1,2,3])\n", " # Sample Output: 2\n", " \n", - " # Your code here:" + " # Your code here:\n", + " value = 0\n", + " for i in iterator:\n", + " if i % 2 == 0:\n", + " value = i\n", + " break # Una vez conseguido nuestro primer iterador que es divisible entre 2 rompemos el for loop\n", + " # y regresamos el valor correspondiente\n", + " return value" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 28, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], "source": [ - "# print divisible2" + "# print divisible2\n", + "print(divisible2(iterator))" ] }, { @@ -311,12 +436,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ - "def firstn(n):\n", - " number = 0\n", + "def firstn(n): # Generators son funciones que nos permiten crear iterables. Se definen igual que la funciones pero \n", + " number = 0 # en vez de return usan yield\n", " while number < n:\n", " yield number\n", " number = number + 1" @@ -331,13 +456,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n" + ] + } + ], "source": [ "iterator = firstn(5)\n", "\n", - "for i in iterator:\n", + "for i in iterator: # Solo podemos movernos a travez del obtejo iterator a travez de la funcion next() o con un foor loop\n", " print(i)" ] }, @@ -350,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -360,16 +497,49 @@ " # Output: iterator\n", " \n", " # Sample Input: 5\n", - " # Sample Output: iter([0, 2, 4])" + " # Sample Output: iter([0, 2, 4])\n", + " \n", + " number = 0 # Contador\n", + " while number <= n: # Hasta que no pase por todos los valores de n no sale del loop while\n", + " if number % 2 == 0: # Este if nos permitira que solo los valores que son divisibles entre dos de devuelvan en forma de iterador\n", + " yield number\n", + " \n", + " number += 1" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# print even_iterator" + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "0\n", + "2\n", + "4\n", + "6\n", + "8\n", + "10\n", + "12\n", + "14\n", + "16\n", + "18\n", + "20\n", + "22\n", + "24\n", + "26\n", + "28\n" + ] + } + ], + "source": [ + "# print even_iterator\n", + "print(type(iterator))\n", + "for i in even_iterator(29):\n", + " print(i)" ] }, { @@ -396,7 +566,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.8.8" } }, "nbformat": 4,