diff --git a/.ipynb_checkpoints/main_esp-checkpoint.ipynb b/.ipynb_checkpoints/main_esp-checkpoint.ipynb new file mode 100644 index 0000000..ec9d3f2 --- /dev/null +++ b/.ipynb_checkpoints/main_esp-checkpoint.ipynb @@ -0,0 +1,786 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En este laboratorio pondremos en práctica algunos de los conceptos que hemos aprendido en los últimos días.\n", + "\n", + "`NOTA: En este laboratorio deberías intentar escribir todas las funciones por ti mismo utilizando solo la sintaxis más básica de Python y sin funciones como len, count, sum, max, min, in, etc. Dale una oportunidad. 🧑🏻‍💻👩🏻‍💻`\n", + "\n", + "La celda después de cada ejercicio contiene algunas pruebas para verificar si tu función funciona como se espera." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from mod.testing import *\n", + "import unittest" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Escribe una función que devuelva el mayor de dos números" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def greater(a,b):\n", + "#your code here#tu codigo aquí\n", + " if a > b:\n", + " return f\"{a} is greater than {b}\"\n", + " elif a < b:\n", + " return f\"{b} is greater than {a}\"\n", + " else:\n", + " return f\"{a} is equal to {b}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'8 is greater than 4'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "greater (4,8)\n", + "# greater (7,7)\n", + "# greater (9,4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Ahora escribe una función que devuelva el elemento más" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# #tu codigo aquí\n", + "\n", + "def mayor(*numeros:int)->int:\n", + " mayornum = numeros[0] \n", + " for value in numeros:\n", + " if value> mayornum:\n", + " mayornum = value\n", + " return mayornum\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "73\n" + ] + } + ], + "source": [ + "# Para testear tu función\n", + "print(mayor(2,3,5,73,3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Escribe una función que sume todos los elementos de una lista" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20\n" + ] + } + ], + "source": [ + "lst=[1,2,8,4,5]\n", + "\n", + "def sum_all(lst):\n", + "#tu codigo aquí\n", + "# numlista = lst[0]\n", + " total = 0\n", + " for i in lst:\n", + " total += i\n", + "\n", + " return total\n", + "print(sum_all(lst))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.038s\n", + "\n", + "OK\n" + ] + } + ], + "source": [ + "# Para testear tu función\n", + "test_sum(sum_all)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Escribe otra función que multiplique todos los elementos de una lista" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "lst=[1,2,8,4,5]\n", + "def mult_all(lst):\n", + "#tu codigo aquí\n", + " totalmult = 1\n", + " for i in lst:\n", + " totalmult *=i\n", + " return totalmult\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "320\n" + ] + } + ], + "source": [ + "# Para testear tu función\n", + "print(mult_all(lst))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Ahora combina esas dos ideas y escribe una función que reciba una lista y ya sea \"+\" o \"*\", y produzca el resultado acorde" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "arr = [9,6,4,2,5,6,8]\n", + "\n", + "def oper_all(arr, oper = \"+\"):\n", + "#tu codigo aquí\n", + "\n", + " if oper == \"*\":\n", + " totmult=1\n", + " for i in arr:\n", + " totmult *=i\n", + " return totmult\n", + " elif oper == \"+\":\n", + " totsum=0\n", + " for i in arr:\n", + " \n", + " totsum +=i\n", + " return totsum\n", + " else:\n", + " return \"Wrong operation\"\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "103680\n", + "40\n", + "40\n" + ] + } + ], + "source": [ + "# Para testear tu función\n", + "# test_operations(oper_all)\n", + "print(oper_all(arr, \"*\")) \n", + "print(oper_all(arr, \"+\"))\n", + "print(oper_all(arr))\n", + "# print(f\"El resultado de * es {totmult} el resultado de + es {totsum}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Escribe una función que devuelva el factorial de un número." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "40320\n" + ] + } + ], + "source": [ + "def factorial(n):\n", + " factorn = 1 \n", + " \n", + " if n > 0: # Si n es mayor que 0\n", + " while n > 0: # Mientras n sea mayor que 0\n", + " factorn *= n # Multiplicamos factorn por n\n", + " n -= 1 \n", + " return factorn \n", + " elif n == 0: # El factorial de 0 es 1\n", + " return 1\n", + " else: # Si n es negativo\n", + " return \"No existe\"\n", + "\n", + "print(factorial(8))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Fórmula factorial\n", + "# n! = n * (n - 1) *...*1\n", + "\n", + "# Este código define una función llamada \"factorial\" que toma una entrada \"n\". La función utiliza un bucle for para iterar a través del rango de números\n", + "# desde 1 hasta n+1. Para cada número en ese rango, multiplica el valor actual de x por el número en el rango. Al final del bucle,\n", + "# la función devuelve el valor final de x, que será el factorial del número de entrada \"n\".\n", + "\n", + "# El factorial de un entero positivo n es el producto de todos los enteros positivos menores o iguales a n.\n", + "# Por ejemplo, el factorial de 6 (escrito \"6!\") es 6 * 5 * 4 * 3 * 2 * 1 = 720.\n", + "\n", + "# Así que esta función toma una entrada de cualquier entero positivo y devuelve el factorial de ese número." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "40320\n" + ] + } + ], + "source": [ + "# This will test your function \n", + "print(factorial(8))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Escribe una función que tome una lista y devuelva una lista de los valores únicos.\n", + "\n", + "`NOTE: No podemos usar set. 🤔`" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "lista= [5,4,8,7,2,4,8,5,6,7,9,0]\n", + "lst_un =[]\n", + "def unique(lst_un):\n", + " lista.sort()\n", + "# print(lista)\n", + " \n", + " for i in lista:\n", + " if i not in lst_un:\n", + " lst_un.append(i)\n", + " \n", + "# else:\n", + " \n", + " return lst_un\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 2, 4, 5, 6, 7, 8, 9]\n" + ] + } + ], + "source": [ + "# Para testear tu función \n", + "print(unique(lst_un))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Escribe una función que devuelva la moda de una lista, es decir: el elemento que aparece más veces.\n", + "\n", + "`NOTE: No se debe usar count... 🧐`" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "arr=[4,9,56,9,4,2,6,7,8,4,3,7,5,8,4,2,1,0]\n", + "moda = ()\n", + "def mode_counter(arr):\n", + " arr.sort()\n", + " count_dict = {} # para contar cada vez que se repite\n", + " \n", + " for num in arr:\n", + "\n", + " if num in count_dict:\n", + " count_dict[num] += 1 # Si el número ya está en el diccionario, aumentamos su conteo\n", + " else:\n", + " count_dict[num] = 1 # Si el número no está en el diccionario, lo añadimos con valor 1\n", + "\n", + " moda = max(count_dict, key=count_dict.get)\n", + " \n", + " \n", + " \n", + " return moda\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.042s\n", + "\n", + "OK\n" + ] + } + ], + "source": [ + "# Para testear tu función \n", + "test_mode(mode_counter)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Escribe una función que calcule la desviación estándar de una lista.\n", + "`NOTE: no utilices librerías ni ninguna función ya construida. 😉`" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12.913994030897852\n" + ] + } + ], + "source": [ + "def st_dev(list2):\n", + " \n", + " media = 0\n", + " desvstd= 0\n", + "# contarvalor=0\n", + "# def calc_media(lista2):\n", + " suma=0\n", + " contarvalor=0\n", + " for i in lista2: \n", + " suma += i\n", + " contarvalor += 1\n", + " media = suma / contarvalor\n", + "# print((media),(contarvalor))\n", + "# return media, contarvalor\n", + "\n", + "# def numerador():\n", + " restacuad = 0\n", + " for i in lista2:\n", + " restacuad += (i-media)**2\n", + " \n", + "# print(restacuad) #hasta aqui bien\n", + "# return restacuad\n", + "\n", + " varianza = restacuad/(contarvalor-1) \n", + "# print((varianza))\n", + " desvstd = varianza **0.5\n", + "\n", + "\n", + " return desvstd \n", + "lista2 = [2, 5, 6, 7, 8, 9, 3, 4, 5, 6,5,4,6,7,8,9,40,50]\n", + "print(st_dev(lista2))\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12.913994030897852\n" + ] + } + ], + "source": [ + "# Para testear tu función\n", + "print(st_dev(lista2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10. Escribe una función para verificar si una cadena es un pangrama, es decir: si contiene todas las letras del alfabeto al menos una vez. Ten en cuenta que las cadenas pueden contener caracteres que no son letras." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# alf = [q,w,e,r,t,y,u,i,o,p,a,s,d,f,g,h,j,k,l,z,x,c,v,b,n,m]\n", + "string=\"asdflkjerp\"\n", + "string1=\"abcdefghijklmnopqrstuvwxyz\"\n", + "\n", + "def pangram(string):\n", + " alf = \"qwertyuiopasdfghjklzxcvbnm\"\n", + " for i in alf:\n", + " if i not in string:\n", + " return \"No es panagrama\"\n", + "\n", + " \n", + " return \"Es panagrama\"\n", + " \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No es panagrama\n", + "Es panagrama\n" + ] + } + ], + "source": [ + "# Para testear tu función\n", + "print(pangram(string))\n", + "print(pangram(string1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 11. Escribe una función que reciba una cadena de palabras separadas por comas y devuelva una cadena de palabras separadas por comas ordenadas alfabéticamente.\n", + "\n", + "`NOTA: Puedes usar sorted pero no split y definitivamente no join! 🤪`" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Palabra agregada: hola\n", + "Palabra agregada: como\n", + "Palabra agregada: estas\n", + "Palabra agregada: me\n", + "Palabra agregada: gusta\n", + "Palabra agregada: no\n", + "Palabra agregada: estudiar\n", + "Palabra agregada: los\n", + "Palabra agregada: sabados\n", + "Lista de palabras antes de ordenar: ['hola', 'como', 'estas', 'me', 'gusta', 'no', 'estudiar', 'los', 'sabados']\n", + "Cadena final construida: como,estas,estudiar,gusta,hola,los,me,no,sabados\n", + "como,estas,estudiar,gusta,hola,los,me,no,sabados\n" + ] + } + ], + "source": [ + "def sort_alpha(string):\n", + "#tu codigo aquí\n", + " string = \"hola,como,estas,me,gusta,no,estudiar,los,sabados\"\n", + "# dict_palabras={}\n", + " palabra = \"\"\n", + " w = []\n", + " \n", + " for i in string:\n", + " if i == \",\":\n", + " if palabra:\n", + " w.append(palabra)\n", + " print(f\"Palabra agregada: {palabra}\")\n", + " palabra=\"\"\n", + " else:\n", + " palabra += i\n", + " if palabra:\n", + " w.append(palabra)\n", + " print(f\"Palabra agregada: {palabra}\") # Imprimir palabra agregada\n", + " \n", + " print(f\"Lista de palabras antes de ordenar: {w}\")\n", + " \n", + "# ordenar\n", + "\n", + " ws= sorted(w)\n", + " \n", + " result = \"\"\n", + " for n, w in enumerate(ws):\n", + " if n > 0:\n", + " result += \",\"\n", + " result += w\n", + " \n", + " print(f\"Cadena final construida: {result}\") # Imprimir cadena final construida\n", + " \n", + " return result\n", + " \n", + "\n", + "\n", + "print(sort_alpha(string)) " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Palabra agregada: hola\n", + "Palabra agregada: como\n", + "Palabra agregada: estas\n", + "Palabra agregada: me\n", + "Palabra agregada: gusta\n", + "Palabra agregada: no\n", + "Palabra agregada: estudiar\n", + "Palabra agregada: los\n", + "Palabra agregada: sabados\n", + "Lista de palabras antes de ordenar: ['hola', 'como', 'estas', 'me', 'gusta', 'no', 'estudiar', 'los', 'sabados']\n", + "Cadena final construida: como,estas,estudiar,gusta,hola,los,me,no,sabados\n", + "como,estas,estudiar,gusta,hola,los,me,no,sabados\n" + ] + } + ], + "source": [ + "# Para testear tu función \n", + "print(sort_alpha(string)) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 12. Escribe una función para verificar si una contraseña dada es fuerte (al menos 8 caracteres, al menos una minúscula, al menos una mayúscula, al menos un número y al menos un carácter especial). Debería devolver True si es fuerte y False si no lo es." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "False\n" + ] + } + ], + "source": [ + "def check_pass(password):\n", + " if len(password)<8:\n", + " return False\n", + " \n", + " tiene_mayuscula = False\n", + " tiene_minuscula = False\n", + " tiene_numero = False\n", + " tiene_caracter_especial = False\n", + " \n", + " caracteres_especiales = \"!@#$%^&*()-_=+[]{}|;:'\\\",.<>?/\\\\`~\"\n", + " \n", + " for char in password:\n", + " if char.islower(): \n", + " tiene_minuscula = True\n", + " elif char.isupper(): \n", + " tiene_mayuscula = True\n", + " elif char.isdigit(): \n", + " tiene_numero = True\n", + " elif char in caracteres_especiales: \n", + " tiene_caracter_especial = True\n", + " \n", + " if tiene_mayuscula and tiene_minuscula and tiene_numero and tiene_caracter_especial:\n", + " return True\n", + " else:\n", + " return False\n", + "\n", + " \n", + "password1 = \"Password123!\"\n", + "password2 = \"password\"\n", + "password3 = \"Passw@1\"\n", + "\n", + "print(check_pass(password1)) # Debería devolver True\n", + "print(check_pass(password2)) # Debería devolver False (sin mayúscula, número ni especial)\n", + "print(check_pass(password3)) # Debería devolver False (menos de 8 caracteres)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# Para testear tu función\n", + "print(check_pass(password1))" + ] + } + ], + "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" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/main_esp.ipynb b/main_esp.ipynb index 8890780..ec9d3f2 100644 --- a/main_esp.ipynb +++ b/main_esp.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -37,22 +37,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def greater(a,b):\n", - "#your code here#tu codigo aquí" + "#your code here#tu codigo aquí\n", + " if a > b:\n", + " return f\"{a} is greater than {b}\"\n", + " elif a < b:\n", + " return f\"{b} is greater than {a}\"\n", + " else:\n", + " return f\"{a} is equal to {b}\"" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'8 is greater than 4'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Para testear tu función\n", - "test_greater(greater)" + "greater (4,8)\n", + "# greater (7,7)\n", + "# greater (9,4)" ] }, { @@ -64,21 +82,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "#tu codigo aquí" + "# #tu codigo aquí\n", + "\n", + "def mayor(*numeros:int)->int:\n", + " mayornum = numeros[0] \n", + " for value in numeros:\n", + " if value> mayornum:\n", + " mayornum = value\n", + " return mayornum\n", + "\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "73\n" + ] + } + ], "source": [ "# Para testear tu función\n", - "test_greatest(greatest)" + "print(mayor(2,3,5,73,3))" ] }, { @@ -90,21 +124,50 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20\n" + ] + } + ], + "source": [ + "lst=[1,2,8,4,5]\n", + "\n", "def sum_all(lst):\n", - "#tu codigo aquí" + "#tu codigo aquí\n", + "# numlista = lst[0]\n", + " total = 0\n", + " for i in lst:\n", + " total += i\n", + "\n", + " return total\n", + "print(sum_all(lst))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.038s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función\n", "test_sum(sum_all)" @@ -119,24 +182,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ + "lst=[1,2,8,4,5]\n", "def mult_all(lst):\n", - "#tu codigo aquí" + "#tu codigo aquí\n", + " totalmult = 1\n", + " for i in lst:\n", + " totalmult *=i\n", + " return totalmult\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "320\n" + ] + } + ], "source": [ "# Para testear tu función\n", - "test_mult(mult_all)" + "print(mult_all(lst))" ] }, { @@ -148,22 +224,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "def oper_all(arr, oper = \"*\"):\n", - "#tu codigo aquí" + "arr = [9,6,4,2,5,6,8]\n", + "\n", + "def oper_all(arr, oper = \"+\"):\n", + "#tu codigo aquí\n", + "\n", + " if oper == \"*\":\n", + " totmult=1\n", + " for i in arr:\n", + " totmult *=i\n", + " return totmult\n", + " elif oper == \"+\":\n", + " totsum=0\n", + " for i in arr:\n", + " \n", + " totsum +=i\n", + " return totsum\n", + " else:\n", + " return \"Wrong operation\"\n", + " " ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "103680\n", + "40\n", + "40\n" + ] + } + ], "source": [ "# Para testear tu función\n", - "test_operations(oper_all)" + "# test_operations(oper_all)\n", + "print(oper_all(arr, \"*\")) \n", + "print(oper_all(arr, \"+\"))\n", + "print(oper_all(arr))\n", + "# print(f\"El resultado de * es {totmult} el resultado de + es {totsum}\")" ] }, { @@ -175,17 +282,37 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "40320\n" + ] + } + ], "source": [ "def factorial(n):\n", - "#tu codigo aquí" + " factorn = 1 \n", + " \n", + " if n > 0: # Si n es mayor que 0\n", + " while n > 0: # Mientras n sea mayor que 0\n", + " factorn *= n # Multiplicamos factorn por n\n", + " n -= 1 \n", + " return factorn \n", + " elif n == 0: # El factorial de 0 es 1\n", + " return 1\n", + " else: # Si n es negativo\n", + " return \"No existe\"\n", + "\n", + "print(factorial(8))" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -204,12 +331,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "40320\n" + ] + } + ], "source": [ "# This will test your function \n", - "test_factorial(factorial)" + "print(factorial(8))\n" ] }, { @@ -223,22 +358,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ + "lista= [5,4,8,7,2,4,8,5,6,7,9,0]\n", + "lst_un =[]\n", "def unique(lst_un):\n", - "#tu codigo aquí" + " lista.sort()\n", + "# print(lista)\n", + " \n", + " for i in lista:\n", + " if i not in lst_un:\n", + " lst_un.append(i)\n", + " \n", + "# else:\n", + " \n", + " return lst_un\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 2, 4, 5, 6, 7, 8, 9]\n" + ] + } + ], "source": [ "# Para testear tu función \n", - "test_unique(unique)" + "print(unique(lst_un))" ] }, { @@ -252,19 +406,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ + "arr=[4,9,56,9,4,2,6,7,8,4,3,7,5,8,4,2,1,0]\n", + "moda = ()\n", "def mode_counter(arr):\n", - "#tu codigo aquí" + " arr.sort()\n", + " count_dict = {} # para contar cada vez que se repite\n", + " \n", + " for num in arr:\n", + "\n", + " if num in count_dict:\n", + " count_dict[num] += 1 # Si el número ya está en el diccionario, aumentamos su conteo\n", + " else:\n", + " count_dict[num] = 1 # Si el número no está en el diccionario, lo añadimos con valor 1\n", + "\n", + " moda = max(count_dict, key=count_dict.get)\n", + " \n", + " \n", + " \n", + " return moda\n", + " \n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.042s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función \n", "test_mode(mode_counter)" @@ -280,22 +463,68 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def st_dev(list_sd):\n", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12.913994030897852\n" + ] + } + ], + "source": [ + "def st_dev(list2):\n", + " \n", + " media = 0\n", + " desvstd= 0\n", + "# contarvalor=0\n", + "# def calc_media(lista2):\n", + " suma=0\n", + " contarvalor=0\n", + " for i in lista2: \n", + " suma += i\n", + " contarvalor += 1\n", + " media = suma / contarvalor\n", + "# print((media),(contarvalor))\n", + "# return media, contarvalor\n", + "\n", + "# def numerador():\n", + " restacuad = 0\n", + " for i in lista2:\n", + " restacuad += (i-media)**2\n", + " \n", + "# print(restacuad) #hasta aqui bien\n", + "# return restacuad\n", + "\n", + " varianza = restacuad/(contarvalor-1) \n", + "# print((varianza))\n", + " desvstd = varianza **0.5\n", + "\n", + "\n", + " return desvstd \n", + "lista2 = [2, 5, 6, 7, 8, 9, 3, 4, 5, 6,5,4,6,7,8,9,40,50]\n", + "print(st_dev(lista2))\n", "#tu codigo aquí" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12.913994030897852\n" + ] + } + ], "source": [ "# Para testear tu función\n", - "test_stdev(st_dev)" + "print(st_dev(lista2))" ] }, { @@ -307,22 +536,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ + "# alf = [q,w,e,r,t,y,u,i,o,p,a,s,d,f,g,h,j,k,l,z,x,c,v,b,n,m]\n", + "string=\"asdflkjerp\"\n", + "string1=\"abcdefghijklmnopqrstuvwxyz\"\n", + "\n", "def pangram(string):\n", - "#tu codigo aquí" + " alf = \"qwertyuiopasdfghjklzxcvbnm\"\n", + " for i in alf:\n", + " if i not in string:\n", + " return \"No es panagrama\"\n", + "\n", + " \n", + " return \"Es panagrama\"\n", + " \n", + " \n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No es panagrama\n", + "Es panagrama\n" + ] + } + ], "source": [ "# Para testear tu función\n", - "test_pangram(pangram)" + "print(pangram(string))\n", + "print(pangram(string1))" ] }, { @@ -336,22 +587,96 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Palabra agregada: hola\n", + "Palabra agregada: como\n", + "Palabra agregada: estas\n", + "Palabra agregada: me\n", + "Palabra agregada: gusta\n", + "Palabra agregada: no\n", + "Palabra agregada: estudiar\n", + "Palabra agregada: los\n", + "Palabra agregada: sabados\n", + "Lista de palabras antes de ordenar: ['hola', 'como', 'estas', 'me', 'gusta', 'no', 'estudiar', 'los', 'sabados']\n", + "Cadena final construida: como,estas,estudiar,gusta,hola,los,me,no,sabados\n", + "como,estas,estudiar,gusta,hola,los,me,no,sabados\n" + ] + } + ], "source": [ "def sort_alpha(string):\n", - "#tu codigo aquí" + "#tu codigo aquí\n", + " string = \"hola,como,estas,me,gusta,no,estudiar,los,sabados\"\n", + "# dict_palabras={}\n", + " palabra = \"\"\n", + " w = []\n", + " \n", + " for i in string:\n", + " if i == \",\":\n", + " if palabra:\n", + " w.append(palabra)\n", + " print(f\"Palabra agregada: {palabra}\")\n", + " palabra=\"\"\n", + " else:\n", + " palabra += i\n", + " if palabra:\n", + " w.append(palabra)\n", + " print(f\"Palabra agregada: {palabra}\") # Imprimir palabra agregada\n", + " \n", + " print(f\"Lista de palabras antes de ordenar: {w}\")\n", + " \n", + "# ordenar\n", + "\n", + " ws= sorted(w)\n", + " \n", + " result = \"\"\n", + " for n, w in enumerate(ws):\n", + " if n > 0:\n", + " result += \",\"\n", + " result += w\n", + " \n", + " print(f\"Cadena final construida: {result}\") # Imprimir cadena final construida\n", + " \n", + " return result\n", + " \n", + "\n", + "\n", + "print(sort_alpha(string)) " ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Palabra agregada: hola\n", + "Palabra agregada: como\n", + "Palabra agregada: estas\n", + "Palabra agregada: me\n", + "Palabra agregada: gusta\n", + "Palabra agregada: no\n", + "Palabra agregada: estudiar\n", + "Palabra agregada: los\n", + "Palabra agregada: sabados\n", + "Lista de palabras antes de ordenar: ['hola', 'como', 'estas', 'me', 'gusta', 'no', 'estudiar', 'los', 'sabados']\n", + "Cadena final construida: como,estas,estudiar,gusta,hola,los,me,no,sabados\n", + "como,estas,estudiar,gusta,hola,los,me,no,sabados\n" + ] + } + ], "source": [ "# Para testear tu función \n", - "test_alpha(sort_alpha)" + "print(sort_alpha(string)) " ] }, { @@ -363,28 +688,78 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "False\n" + ] + } + ], "source": [ "def check_pass(password):\n", - "#tu codigo aquí" + " if len(password)<8:\n", + " return False\n", + " \n", + " tiene_mayuscula = False\n", + " tiene_minuscula = False\n", + " tiene_numero = False\n", + " tiene_caracter_especial = False\n", + " \n", + " caracteres_especiales = \"!@#$%^&*()-_=+[]{}|;:'\\\",.<>?/\\\\`~\"\n", + " \n", + " for char in password:\n", + " if char.islower(): \n", + " tiene_minuscula = True\n", + " elif char.isupper(): \n", + " tiene_mayuscula = True\n", + " elif char.isdigit(): \n", + " tiene_numero = True\n", + " elif char in caracteres_especiales: \n", + " tiene_caracter_especial = True\n", + " \n", + " if tiene_mayuscula and tiene_minuscula and tiene_numero and tiene_caracter_especial:\n", + " return True\n", + " else:\n", + " return False\n", + "\n", + " \n", + "password1 = \"Password123!\"\n", + "password2 = \"password\"\n", + "password3 = \"Passw@1\"\n", + "\n", + "print(check_pass(password1)) # Debería devolver True\n", + "print(check_pass(password2)) # Debería devolver False (sin mayúscula, número ni especial)\n", + "print(check_pass(password3)) # Debería devolver False (menos de 8 caracteres)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], "source": [ "# Para testear tu función\n", - "test_pass(check_pass)" + "print(check_pass(password1))" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -398,7 +773,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.7.3" }, "vscode": { "interpreter": { diff --git a/mod/__pycache__/testing.cpython-37.pyc b/mod/__pycache__/testing.cpython-37.pyc new file mode 100644 index 0000000..0f305e1 Binary files /dev/null and b/mod/__pycache__/testing.cpython-37.pyc differ