diff --git a/02 - Variables y Tipos de Datos/Homework_Tipos_de_Datos.ipynb b/02 - Variables y Tipos de Datos/Homework_Tipos_de_Datos.ipynb new file mode 100644 index 000000000..d701c5931 --- /dev/null +++ b/02 - Variables y Tipos de Datos/Homework_Tipos_de_Datos.ipynb @@ -0,0 +1,692 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Homework I: Variables y Tipos de Datos" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**1. Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "my_var = 3\n", + "print(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**2. Imprimir el tipo de dato de la constante 8.5**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8.5\n" + ] + } + ], + "source": [ + "CONST_VAR = 8.5\n", + "print(CONST_VAR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**3. Imprimir el tipo de dato de la variable creada en el punto 1**" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(my_var))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**4. Crear una variable que contenga tu nombre**" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "my_name = 'Ligia Jorge'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**5. Crear una variable que contenga un número complejo**" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4+5j)\n" + ] + } + ], + "source": [ + "my_complex_number = 4 + 5j" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**6. Mostrar el tipo de dato de la variable creada en el punto 5**" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(my_complex_number))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**7. Crear una variable que contenga el valor del número Pi redondeado a 4 decimales**" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1416\n" + ] + } + ], + "source": [ + "import math\n", + "my_pi = round(math.pi, 4)\n", + "print(my_pi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**8. Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo?**" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "type of my_str: \n", + "type of my_bool: \n" + ] + } + ], + "source": [ + "my_str = 'True'\n", + "my_bool = True\n", + "print('type of my_str: ' + str(type(my_str)))\n", + "print('type of my_bool: ' + str(type(my_bool)))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No es lo mismo, son distintos tipos de dato." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**9. Imprimir el tipo de dato correspondiente a las variables creadas en el punto 9**" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "print(type(my_str))\n", + "print(type(my_bool))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**10. Asignar a una variable, la suma de un número entero y otro decimal**" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10.5\n" + ] + } + ], + "source": [ + "my_sum = 10 + 0.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**11. Realizar una operación de suma de números complejos**" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4+5j)\n" + ] + } + ], + "source": [ + "my_complex_sum_1 = 1j + 4 + 4j" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**12. Realizar una operación de suma de un número real y otro complejo**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_comple_sum_2 = 3 + 5 + 4j" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**13. Realizar una operación de multiplicación**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_mult = 4 * 4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**14. Mostrar el resultado de elevar 2 a la octava potencia**" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "256\n" + ] + } + ], + "source": [ + "print(2 ** 8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**15. Obtener el cociente d ela division de 27 entre 4 en una variable y luego mostrarla**" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.75\n" + ] + } + ], + "source": [ + "my_div = 27 / 4\n", + "print(my_div)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**16. De la división anterior solamente motrar la parte entera**" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "print(int(my_div))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**17. De la división de 27 entre 4 mostrar solamente el resto**" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "print(27 % 4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**18. Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17, obtener 27 como resultado**" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + } + ], + "source": [ + "print(4 * int(my_div) + 27 % 4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**19. Utilizar el operador \"+\" en una operación donde intervengan sólo dos valores alfanúmericos**" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ligia Jorge\n" + ] + } + ], + "source": [ + "print('Ligia' + ' Jorge')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**20. Evalar si \"2\" es igual a 2 . ¿Por qué ocurre eso?**" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "print(2 == '2')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "El resultado es 'False' porque no son el mismo tipo de dato" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**21. Utilizar las funciones de cambio de tipo de dato para que la validación del punto 20 resulte verdadera**" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(2 == int('2'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**22. ¿Por qué arroja error el siguiente cambio de tipo de dato? a = float('3,8')**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Porque se está utilizando una coma en lugar de un punto" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**23. Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido**" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "num = 3\n", + "num -= 1\n", + "print(num)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**24. Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario?**" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + } + ], + "source": [ + "print(1 << 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Operador <<**: Realiza un desplazamiento a la izquierda bit a bit. Dsplaza los bits del operando de la izquierda a la izquierda tantos bits como especifique el operador de la derecha (Ejemplo: : 00000010 << 00000011 = 00001000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Para 1 << 2**:\n", + "0001 << 0011 = 0100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**25. Realizar la operación 2 + '2' ¿Por qué no está permitido?¿Si los dos operandos serían del mismo tipo, siempre arrojaría el mismo resultado?**" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for +: 'int' and 'str'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/lljd/HenryDS/M0/Python-Prep/02 - Variables y Tipos de Datos/.ipynb_checkpoints/Homework_Tipos_de_Datos.ipynb Cell 55\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m2\u001b[39;49m \u001b[39m+\u001b[39;49m \u001b[39m'\u001b[39;49m\u001b[39m2\u001b[39;49m\u001b[39m'\u001b[39;49m)\n", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" + ] + } + ], + "source": [ + "print(2 + '2')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(2 + 2) # Suma\n", + "print('2' + '2') # Contatenación" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**26. Realizar una operación válida entre valores de tipo entero y string**" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xxx\n" + ] + } + ], + "source": [ + "print(3 * 'x')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "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.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/03 - Flujos de Control/.ipynb_checkpoints/Homework_Flujos_de_Control.ipynb b/03 - Flujos de Control/.ipynb_checkpoints/Homework_Flujos_de_Control.ipynb new file mode 100644 index 000000000..3cdff4d17 --- /dev/null +++ b/03 - Flujos de Control/.ipynb_checkpoints/Homework_Flujos_de_Control.ipynb @@ -0,0 +1,697 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Homework 2: Flujos de Control" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**1. Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla si es mayor o menor a cero**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-8 -> the number is less tha zero\n" + ] + } + ], + "source": [ + "import random\n", + "# randrabge(a, b, salto)\n", + "\n", + "random_number = random.randrange(-10,10,1)\n", + "if random_number < 0:\n", + " print(random_number, '-> the number is less tha zero')\n", + "elif random_number == 0:\n", + " print(random_number, '-> the number is zero')\n", + "else:\n", + " print(random_number, '-> the number is greatter than zero')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**2. Crear dos variables y un condicional que informe si son del mismo tipo de dato**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "var_1 = 3\n", + "var_2 = '3'\n", + "\n", + "if var_1 == var_2:\n", + " print('are equals')\n", + "else:\n", + " print('are not equals')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**3. Para los valores del 1 al 20, imprimir por pantalla si es par o impar**" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 odd\n", + "2 pair\n", + "3 odd\n", + "4 pair\n", + "5 odd\n", + "6 pair\n", + "7 odd\n", + "8 pair\n", + "9 odd\n", + "10 pair\n", + "11 odd\n", + "12 pair\n", + "13 odd\n", + "14 pair\n", + "15 odd\n", + "16 pair\n", + "17 odd\n", + "18 pair\n", + "19 odd\n", + "20 pair\n" + ] + } + ], + "source": [ + "for i in range(1,21):\n", + " if i % 2 == 0:\n", + " print(i, 'pair')\n", + " else:\n", + " print(i, 'odd')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**4. En un ciclo for mostar para los valores entre 0 y 5 el resultado de elevarlo a la potecia igual a 3**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0\n", + "1 1\n", + "2 8\n", + "3 27\n", + "4 64\n", + "5 125\n" + ] + } + ], + "source": [ + "for i in range(6):\n", + " print(i, i ** 3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**5. Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "7\n" + ] + } + ], + "source": [ + "var_i = 8\n", + "for i in range(var_i):\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**6. Utilizar un ciclo while para realizar el factorial de un número guardado en una variable, sólo si la variable contiene un número entero mayor que 0**" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n", + "720\n" + ] + } + ], + "source": [ + "n = random.randrange(-10,10,1)\n", + "print(n)\n", + "fact = 1\n", + "if n > 0:\n", + " while n > 1:\n", + " fact *= n\n", + " n -= 1\n", + " print(fact)\n", + "else:\n", + " print('Error')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**7. Crear un ciclo for dentro de un ciclo while**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "while:0\n", + "for:0\n", + "for:1\n", + "for:2\n", + "while:1\n", + "for:0\n", + "for:1\n", + "for:2\n", + "while:2\n", + "for:0\n", + "for:1\n", + "for:2\n" + ] + } + ], + "source": [ + "x = 0\n", + "while x < 3:\n", + " print('while:' + str(x))\n", + " x += 1\n", + " for item in range(3):\n", + " print('for:' + str(item))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**8. Crear un ciclo while dentro de un ciclo for**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "for:0\n", + "while:0\n", + "while:1\n", + "while:2\n", + "for:1\n", + "while:0\n", + "while:1\n", + "while:2\n", + "for:2\n", + "while:0\n", + "while:1\n", + "while:2\n" + ] + } + ], + "source": [ + "x = 0\n", + "for i in range(3):\n", + " print('for:' + str(i))\n", + " while x < 3:\n", + " print('while:' + str(x))\n", + " x += 1\n", + " x = 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**9. Imprimir los números primos existentes entre 0 y 30**" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "5\n", + "7\n", + "11\n", + "13\n", + "17\n", + "19\n", + "23\n", + "29\n", + "Ciclos sin utilizar el Break: 406\n" + ] + } + ], + "source": [ + "flag = True\n", + "total_cycles = 0\n", + "for i in range(0, 31):\n", + " for j in range (2, i):\n", + " total_cycles += 1\n", + " if (i % j == 0):\n", + " flag = False\n", + " if (flag):\n", + " print(i)\n", + " else:\n", + " flag = True\n", + "print('Ciclos sin utilizar el Break: ' + str(total_cycles))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**10. ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias ```break``` y/ó ```continue``` para tal fin**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "5\n", + "7\n", + "11\n", + "13\n", + "17\n", + "19\n", + "23\n", + "29\n" + ] + } + ], + "source": [ + "flag = True\n", + "for i in range(0, 31):\n", + " for j in range(2, i):\n", + " if i % j == 0:\n", + " flag = False\n", + " break\n", + " if flag == True:\n", + " print(i)\n", + " else:\n", + " flag = True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**11. En los puntos 9 y 10, se diseñó un código que encuentra números primos y además se optimizó. ¿Es posible saber en qué medida se optimizó?**" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "5\n", + "7\n", + "11\n", + "13\n", + "17\n", + "19\n", + "23\n", + "29\n", + "Cantidad de ciclos: 135\n", + "Se optimizó a un 33.251231527093594% de ciclos aplicando break\n" + ] + } + ], + "source": [ + "flag = True\n", + "break_cycles = 0\n", + "for i in range(0, 31):\n", + " for j in range(2, i):\n", + " break_cycles += 1\n", + " if (i % j == 0):\n", + " flag = False\n", + " break\n", + " if (flag):\n", + " print(i)\n", + " else:\n", + " flag = True\n", + "print('Cantidad de ciclos: ' + str(break_cycles))\n", + "print('Se optimizó a un ' + str(break_cycles / 406 * 100) + \n", + " '% de ciclos aplicando break')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**12. Si la cantidad de números que se evalúa es mayor a treinta, esa optimización crece?**" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "5\n", + "7\n", + "11\n", + "13\n", + "17\n", + "19\n", + "23\n", + "29\n", + "31\n", + "37\n", + "41\n", + "43\n", + "47\n", + "53\n", + "59\n", + "61\n", + "67\n", + "71\n", + "73\n", + "79\n", + "83\n", + "89\n", + "97\n", + "Ciclos sin utilizar el Break: 4753\n" + ] + } + ], + "source": [ + "flag = True\n", + "total_cycles = 0\n", + "for i in range(0, 100):\n", + " for j in range (2, i):\n", + " total_cycles += 1\n", + " if (i % j == 0):\n", + " flag = False\n", + " if (flag):\n", + " print(i)\n", + " else:\n", + " flag = True\n", + "print('Ciclos sin utilizar el Break: ' + str(total_cycles))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "5\n", + "7\n", + "11\n", + "13\n", + "17\n", + "19\n", + "23\n", + "29\n", + "31\n", + "37\n", + "41\n", + "43\n", + "47\n", + "53\n", + "59\n", + "61\n", + "67\n", + "71\n", + "73\n", + "79\n", + "83\n", + "89\n", + "97\n", + "Cantidad de ciclos: 1132\n", + "Se optimizó a un 278.81773399014776% de ciclos aplicando break\n" + ] + } + ], + "source": [ + "flag = True\n", + "break_cycles = 0\n", + "for i in range(0, 100):\n", + " for j in range(2, i):\n", + " break_cycles += 1\n", + " if (i % j == 0):\n", + " flag = False\n", + " break\n", + " if (flag):\n", + " print(i)\n", + " else:\n", + " flag = True\n", + "print('Cantidad de ciclos: ' + str(break_cycles))\n", + "print('Se optimizó a un ' + str(break_cycles / 406 * 100) + \n", + " '% de ciclos aplicando break')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**13. Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300**" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "108\n", + "120\n", + "132\n", + "144\n", + "156\n", + "168\n", + "180\n", + "192\n", + "204\n", + "216\n", + "228\n", + "240\n", + "252\n", + "264\n", + "276\n", + "288\n", + "300\n" + ] + } + ], + "source": [ + "n = 100\n", + "while(n <= 300):\n", + " n += 1\n", + " if (n % 12 != 0):\n", + " continue\n", + " print(n)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**14. Utilizar la función `input()` que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usuario de buscar el siguiente**" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "¿Desea encontrar el siguiente número primo?\n" + ] + } + ], + "source": [ + "n = 1\n", + "following = 1\n", + "prime = True\n", + "while (following == 1):\n", + " for div in range(2, n):\n", + " if (n % div == 0):\n", + " prime = False\n", + " break\n", + " if (prime):\n", + " print(n)\n", + " print('¿Desea encontrar el siguiente número primo?')\n", + " if (input() != '1'):\n", + " print('Se finaliza el proceso')\n", + " break\n", + " else:\n", + " prime = True\n", + " n += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**15. Crear un ciclo while que encuentre dentro del rango de 100 a 300 el primer número divisible por 3 y además múltiplo de 6**" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "102\n" + ] + } + ], + "source": [ + "n = 100\n", + "while (n <= 300):\n", + " if (n % 6 == 0):\n", + " print(n)\n", + " break\n", + " n += 1" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "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.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb b/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb index 8b24b6405..c24ec0e22 100644 --- a/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb +++ b/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb @@ -284,7 +284,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -376,7 +376,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -418,7 +418,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -624,7 +624,7 @@ ], "source": [ "n = 99\n", - "while(n <= 300):\n", + "while (n <= 300):\n", " n += 1\n", " if (n % 12 != 0):\n", " continue\n", @@ -640,7 +640,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -648,20 +648,7 @@ "output_type": "stream", "text": [ "1\n", - "¿Desea encontrar el siguiente número primo?\n", - "2\n", - "¿Desea encontrar el siguiente número primo?\n", - "3\n", - "¿Desea encontrar el siguiente número primo?\n", - "5\n", - "¿Desea encontrar el siguiente número primo?\n", - "7\n", - "¿Desea encontrar el siguiente número primo?\n", - "11\n", - "¿Desea encontrar el siguiente número primo?\n", - "13\n", - "¿Desea encontrar el siguiente número primo?\n", - "Se finaliza el proceso\n" + "¿Desea encontrar el siguiente número primo?\n" ] } ], @@ -694,7 +681,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -707,7 +694,7 @@ ], "source": [ "n = 100\n", - "while(n<=300):\n", + "while (n<=300):\n", " if (n % 6 == 0):\n", " print('El número es: ', str(n))\n", " break\n", @@ -716,11 +703,8 @@ } ], "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, "kernelspec": { - "display_name": "Python 3.9.7 64-bit ('henry': conda)", + "display_name": "Python 3.10.4 64-bit", "language": "python", "name": "python3" }, @@ -734,7 +718,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.4" + }, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } } }, "nbformat": 4, diff --git a/04 - Estructuras de datos/Homework_Estructuras_de_Datos.py b/04 - Estructuras de datos/Homework_Estructuras_de_Datos.py new file mode 100644 index 000000000..0ddf9e020 --- /dev/null +++ b/04 - Estructuras de datos/Homework_Estructuras_de_Datos.py @@ -0,0 +1,126 @@ +# HOMEWORK DE ESTRUCTURAS DE DATOS # ___________________________________________ +# 1. Crear una lista que contenga nombres de ciudades del mundo. La lista debe +# contener más de 5 elementos +cities = ['Caracas', 'Londres', 'Cairns', 'Valencia', 'Tokio'] +#------------------------------------------------------------------------------- +# 2. Imprimir en pantalla el segundo elemento de la lista +print(cities[1]) +#------------------------------------------------------------------------------- +# 3. Imprimir en pantalla del segundo al cuarto elements +print(cities[1:4]) +#------------------------------------------------------------------------------- +# 4. Visualizar el tipo de dato de la lista +print(type(cities)) +#------------------------------------------------------------------------------- +# 5. Visualizar todos los elementos de la lista a partir del tercero de manera +# genérica, es decir, sin colocar de forma explícita la posición del último +# elemento +print(cities[2:]) +#------------------------------------------------------------------------------- +# 6. Visualizar los primeros 4 elementos de la lista +print(cities[:4]) +#------------------------------------------------------------------------------- +# 7. Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún +# tipo de error? +cities.append('Caracas') +cities.append('LA') +print(cities) +# No arroja ningún error +#------------------------------------------------------------------------------- +# 8. Agregar otra ciudad pero en la cuarta posición +cities.insert(3, 'Osaka') +print(cities) +#------------------------------------------------------------------------------- +# 9. Concatenar otra lista a la ya creada +cities.extend(['París', 'Seúl']) +print(cities) +#------------------------------------------------------------------------------- +# 10. Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. +# ¿Se nota alguna particularidad? +print(cities.index('Caracas')) +# Retorna el índice de la primera coincidencia +#------------------------------------------------------------------------------- +# 11. ¿Qué pasa si se busca un elemento que no existe? +# print(cities.index(8)) +print('...') +# Detiene la ejecución del código y arroja un error +#------------------------------------------------------------------------------- +# 12. Eliminar un elemento d ela lista +cities.remove('LA') +print(cities) +#------------------------------------------------------------------------------- +# 13. ¿Qué pasa si el elemento a eliminar no existe? +#cities.remove(8) +print(cities) +# Detiene la ejecución del código en esa línea y arroja un error +#------------------------------------------------------------------------------- +# 14. Extraer el úlimo elemento de la lista, guardarlo en una variable e +# imprimirlo +last_element = cities.pop() +print(cities, last_element) +#------------------------------------------------------------------------------- +# 15. Mostrar la lista multiplicada por 4 +print(cities * 4) +#------------------------------------------------------------------------------- +# 16. Crear una tupla que contenga los números enteros del 1 al 20 +my_tuple = tuple(range(1, 21)) +print(my_tuple) +#------------------------------------------------------------------------------- +# 17. Imprimir desde en índice 10 al 15 de la tupla +print(my_tuple[10:16]) +#------------------------------------------------------------------------------- +# 18. Evaluar si los números 20 y 30 están dentro de la tupla +print(20 in my_tuple) +print(30 in my_tuple) +#------------------------------------------------------------------------------- +# 19. Con la lista creada en el punto 1, validar la existencia del elemento +# 'París' y si no existe, agregarlo. Utilizar una variable e informar lo +# sucedido +if ('París' in cities): + print('La ciudad ya se encuentra almacenada') +else: + print('La ciudad no se encuentra almacenada') + cities.append('París') +print(cities) +#------------------------------------------------------------------------------- +# 20. Mostrar la cantidad de veces que se encuentra un elemento específico +# dentro de la tupla y de la lista +print(cities.count('Caracas')) +print(my_tuple.count(8)) +#------------------------------------------------------------------------------- +# 21. convertir la tupla en una lista +print(list(my_tuple)) +print(my_tuple) +# No modifica la tupla original, es necesario almacenarlo en una variable. +# únicamente se pasa el valor de la tupla como argumento de la función +# (no se pasa por referencia) +#------------------------------------------------------------------------------- +# 22. Desempaquetar sólo los primeros 3 elementos de la tupla en tres variables +first, second, third = my_tuple[:3] +print(my_tuple[:3]) +print(first) +print(second) +print(third) +# Son validas las siguientes dos formas de desempaquetar: +nombre1, apellido1 = 'Ligia', 'Jorge' +nombre2, apellido2 = 'Lilibeth', 'Jorge' +print('Hola, ' + nombre1 + ' ' + apellido1) +print('Hola, ' + nombre2 + ' ' + apellido2) +#------------------------------------------------------------------------------- +# 23. Crear un diccionario utilizando la lista creada en el punto 1, +# asignandole la clave "ciudad". Agregar también otras claves, como puede ser +# "país" y "continente" +my_dictionary = { + 'cities': cities, + 'numbers': my_tuple +} +print(my_dictionary) +#------------------------------------------------------------------------------- +# 24. Imprimir las claves del diccionario +print(my_dictionary.keys()) +for i in my_dictionary.keys(): + print(i) +#------------------------------------------------------------------------------- +# 25. Imprimir las ciudades a través de su clave +print(my_dictionary['cities']) +#_______________________________________________________________________________