diff --git a/M03_variablesydatos/Prep_Course_Homework_03-Resuelto.ipynb b/M03_variablesydatos/Prep_Course_Homework_03-Resuelto.ipynb index e3f2739bb..664c6f218 100644 --- a/M03_variablesydatos/Prep_Course_Homework_03-Resuelto.ipynb +++ b/M03_variablesydatos/Prep_Course_Homework_03-Resuelto.ipynb @@ -1,765 +1,765 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Variables" - ] - }, - { - "attachments": {}, - "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": [ - "12\n" - ] - } - ], - "source": [ - "a = 12\n", - "print(a)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "2) Imprimir el tipo de dato de la constante 8.5" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "float" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(8.5)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "3) Imprimir el tipo de dato de la variable creada en el punto 1" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "int" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(a)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "4) Crear una variable que contenga tu nombre" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "mi_nombre = 'Juan Carlos Perez'" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "5) Crear una variable que contenga un número complejo" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "n_complejo = 5 + 5j" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "6) Mostrar el tipo de dato de la variable creada en el punto 5" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "complex" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(n_complejo)" - ] - }, - { - "attachments": {}, - "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": 1, - "metadata": {}, - "outputs": [], - "source": [ - "pi = 3.1416" - ] - }, - { - "attachments": {}, - "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": 3, - "metadata": {}, - "outputs": [], - "source": [ - "var1 = 'True'\n", - "var2 = True" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "La variable 1 es de tipo y la variable 2 es de tipo \n" - ] - } - ], - "source": [ - "print('La variable 1 es de tipo ', type(var1), ' y la variable 2 es de tipo ', type(var2))" - ] - }, - { - "attachments": {}, - "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": 1, - "metadata": {}, - "outputs": [], - "source": [ - "a = 5.2 + 4" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "11) Realizar una operación de suma de números complejos" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(4+4j)\n" - ] - } - ], - "source": [ - "a = 3 + 1j\n", - "b = 1 + 3j\n", - "print(a + b)" - ] - }, - { - "attachments": {}, - "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": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(4.61+1j)\n" - ] - } - ], - "source": [ - "c = a + 1.61\n", - "print(c)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "13) Realizar una operación de multiplicación" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6\n" - ] - } - ], - "source": [ - "print(3 * 2)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "14) Mostrar el resultado de elevar 2 a la octava potencia" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "256\n" - ] - } - ], - "source": [ - "print(2**8)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6.75\n" - ] - } - ], - "source": [ - "a = 27 / 4\n", - "print(a)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "16) De la división anterior solamente mostrar la parte entera" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6\n" - ] - } - ], - "source": [ - "print(27 // 4)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "17) De la división de 27 entre 4 mostrar solamente el resto" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "27 % 4" - ] - }, - { - "attachments": {}, - "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": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "27" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "6 * 4 + 3" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "19) Utilizar el operador \"+\" en una operación donde intervengan solo variables alfanuméricas" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Buenos Aires\n" - ] - } - ], - "source": [ - "var1 = 'Buenos '\n", - "var2 = 'Aires'\n", - "print(var1 + var2)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "20) Evaluar si \"2\" es igual a 2. ¿Por qué ocurre eso?" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2 == '2'" - ] - }, - { - "attachments": {}, - "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": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2 == int('2')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8')" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "could not convert string to float: '3,8'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_17308/3442311956.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'3,8'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mValueError\u001b[0m: could not convert string to float: '3,8'" - ] - } - ], - "source": [ - "a = float('3,8')" - ] - }, - { - "attachments": {}, - "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": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-4\n" - ] - } - ], - "source": [ - "a = -3\n", - "a -= 1\n", - "print(a)" - ] - }, - { - "attachments": {}, - "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": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "1 << 2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Explicación:** La operación 1 << 2 en Python realiza un desplazamiento a la izquierda de bits (bitwise left shift) en el número entero 1.\n", - "En este caso, el número binario 1 se desplaza dos posiciones hacia la izquierda, y se rellena con ceros a la derecha. El resultado de esta operación es 4.\n", - "Explicación paso a paso:\n", - "1. El número 1 en binario es representado como 0001.\n", - "2. Realizamos un desplazamiento de dos posiciones hacia la izquierda: 0001 << 2.\n", - "3. El resultado es 0100, que en decimal representa el número 4.*\n", - "\n", - "\n", - "Es importante tener en cuenta que el desplazamiento a la izquierda de bits (<<) multiplica el número original por 2 elevado a la potencia del número de posiciones desplazadas. En este caso, 1 se multiplica por 2 elevado a la potencia de 2, lo que resulta en 4." - ] - }, - { - "attachments": {}, - "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": 23, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for +: 'int' and 'str'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_17308/1287754560.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m2\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m'2'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" - ] - } - ], - "source": [ - "2 + '2'" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4.0" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "float(2) + float('2')" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "int(2) + int('2')" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'22'" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "str(2) + str('2')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "26) Realizar una operación válida entre valores de tipo entero y string" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "este texto se repite este texto se repite este texto se repite 3 veces\n" - ] - } - ], - "source": [ - "var1 = 'este texto se repite '\n", - "var2 = 3\n", - "print(var1 * var2 + str(var2) + ' veces')" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.11" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Variables" + ] + }, + { + "attachments": {}, + "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": [ + "12\n" + ] + } + ], + "source": [ + "a = 12\n", + "print(a)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) Imprimir el tipo de dato de la constante 8.5" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "float" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(8.5)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Imprimir el tipo de dato de la variable creada en el punto 1" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "int" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(a)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) Crear una variable que contenga tu nombre" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "mi_nombre = 'Juan Carlos Perez'" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5) Crear una variable que contenga un número complejo" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "n_complejo = 5 + 5j" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) Mostrar el tipo de dato de la variable creada en el punto 5" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "complex" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(n_complejo)" + ] + }, + { + "attachments": {}, + "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": 1, + "metadata": {}, + "outputs": [], + "source": [ + "pi = 3.1416" + ] + }, + { + "attachments": {}, + "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": 3, + "metadata": {}, + "outputs": [], + "source": [ + "var1 = 'True'\n", + "var2 = True" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La variable 1 es de tipo y la variable 2 es de tipo \n" + ] + } + ], + "source": [ + "print('La variable 1 es de tipo ', type(var1), ' y la variable 2 es de tipo ', type(var2))" + ] + }, + { + "attachments": {}, + "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": 1, + "metadata": {}, + "outputs": [], + "source": [ + "a = 5.2 + 4" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11) Realizar una operación de suma de números complejos" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4+4j)\n" + ] + } + ], + "source": [ + "a = 3 + 1j\n", + "b = 1 + 3j\n", + "print(a + b)" + ] + }, + { + "attachments": {}, + "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": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4.61+1j)\n" + ] + } + ], + "source": [ + "c = a + 1.61\n", + "print(c)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13) Realizar una operación de multiplicación" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "print(3 * 2)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) Mostrar el resultado de elevar 2 a la octava potencia" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "256\n" + ] + } + ], + "source": [ + "print(2**8)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.75\n" + ] + } + ], + "source": [ + "a = 27 / 4\n", + "print(a)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "16) De la división anterior solamente mostrar la parte entera" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "print(27 // 4)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "17) De la división de 27 entre 4 mostrar solamente el resto" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "27 % 4" + ] + }, + { + "attachments": {}, + "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": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "27" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "6 * 4 + 3" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "19) Utilizar el operador \"+\" en una operación donde intervengan solo variables alfanuméricas" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Buenos Aires\n" + ] + } + ], + "source": [ + "var1 = 'Buenos '\n", + "var2 = 'Aires'\n", + "print(var1 + var2)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "20) Evaluar si \"2\" es igual a 2. ¿Por qué ocurre eso?" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 == '2'" + ] + }, + { + "attachments": {}, + "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": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 == int('2')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "could not convert string to float: '3,8'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_17308/3442311956.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'3,8'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mValueError\u001b[0m: could not convert string to float: '3,8'" + ] + } + ], + "source": [ + "a = float('3,8')" + ] + }, + { + "attachments": {}, + "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": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-4\n" + ] + } + ], + "source": [ + "a = -3\n", + "a -= 1\n", + "print(a)" + ] + }, + { + "attachments": {}, + "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": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 << 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Explicación:** La operación 1 << 2 en Python realiza un desplazamiento a la izquierda de bits (bitwise left shift) en el número entero 1.\n", + "En este caso, el número binario 1 se desplaza dos posiciones hacia la izquierda, y se rellena con ceros a la derecha. El resultado de esta operación es 4.\n", + "Explicación paso a paso:\n", + "1. El número 1 en binario es representado como 0001.\n", + "2. Realizamos un desplazamiento de dos posiciones hacia la izquierda: 0001 << 2.\n", + "3. El resultado es 0100, que en decimal representa el número 4.*\n", + "\n", + "\n", + "Es importante tener en cuenta que el desplazamiento a la izquierda de bits (<<) multiplica el número original por 2 elevado a la potencia del número de posiciones desplazadas. En este caso, 1 se multiplica por 2 elevado a la potencia de 2, lo que resulta en 4." + ] + }, + { + "attachments": {}, + "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": 23, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for +: 'int' and 'str'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_17308/1287754560.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m2\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m'2'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" + ] + } + ], + "source": [ + "2 + '2'" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4.0" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "float(2) + float('2')" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(2) + int('2')" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'22'" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "str(2) + str('2')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "26) Realizar una operación válida entre valores de tipo entero y string" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "este texto se repite este texto se repite este texto se repite 3 veces\n" + ] + } + ], + "source": [ + "var1 = 'este texto se repite '\n", + "var2 = 3\n", + "print(var1 * var2 + str(var2) + ' veces')" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/M03_variablesydatos/Prep_Course_Homework_03-Resuelto.py b/M03_variablesydatos/Prep_Course_Homework_03-Resuelto.py index 2c9056576..a9507288a 100644 --- a/M03_variablesydatos/Prep_Course_Homework_03-Resuelto.py +++ b/M03_variablesydatos/Prep_Course_Homework_03-Resuelto.py @@ -1,242 +1,242 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Variables - -# 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla - -# In[7]: - - -a = 12 -print(a) - - -# 2) Imprimir el tipo de dato de la constante 8.5 - -# In[3]: - - -type(8.5) - - -# 3) Imprimir el tipo de dato de la variable creada en el punto 1 - -# In[8]: - - -type(a) - - -# 4) Crear una variable que contenga tu nombre - -# In[2]: - - -mi_nombre = 'juan carlos perez' - - -# 5) Crear una variable que contenga un número complejo - -# In[3]: - - -n_complejo = 5 + 5j - - -# 6) Mostrar el tipo de dato de la variable crada en el punto 5 - -# In[4]: - - -type(n_complejo) - - -# 7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales - -# In[1]: - - -pi = 3.1416 - - -# 8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo? - -# In[3]: - - -var1 = 'True' -var2 = True - - -# 9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8 - -# In[5]: - - -print('La variable 1 es de tipo ', type(var1), ' y la variable 2 es de tipo ', type(var2)) - - -# 10) Asignar a una variable, la suma de un número entero y otro decimal - -# In[1]: - - -a = 5.2 + 4 - - -# 11) Realizar una operación de suma de números complejos - -# In[2]: - - -a = 3 + 1j -b = 1 + 3j -print(a + b) - - -# 12) Realizar una operación de suma de un número real y otro complejo - -# In[4]: - - -c = a + 1.61 -print(c) - - -# 13) Realizar una operación de multiplicación - -# In[5]: - - -print(3 * 2) - - -# 14) Mostrar el resultado de elevar 2 a la octava potencia - -# In[6]: - - -print(2**8) - - -# 15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla - -# In[8]: - - -a = 27 / 4 -print(a) - - -# 16) De la división anterior solamente mostrar la parte entera - -# In[9]: - - -print(27 // 4) - - -# 17) De la división de 27 entre 4 mostrar solamente el resto - -# In[1]: - - -27 % 4 - - -# 18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado - -# In[2]: - - -6 * 4 + 3 - - -# 19) Utilizar el operador "+" en una operación donde intervengan solo variables alfanuméricas - -# In[3]: - - -var1 = 'Buenos ' -var2 = 'Aires' -print(var1 + var2) - - -# 20) Evaluar si "2" es igual a 2. ¿Por qué ocurre eso? - -# In[4]: - - -2 == '2' - - -# 21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera - -# In[11]: - - -2 == int('2') - - -# 22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8') - -# In[12]: - - -a = float('3,8') - - -# 23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido - -# In[15]: - - -a = -3 -a -= 1 -print(a) - - -# 24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario? - -# In[29]: - - -1 << 2 - - -# 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? - -# In[23]: - - -2 + '2' - - -# In[25]: - - -float(2) + float('2') - - -# In[26]: - - -int(2) + int('2') - - -# In[27]: - - -str(2) + str('2') - - -# 26) Realizar una operación válida entre valores de tipo entero y string - -# In[30]: - - -var1 = 'este texto se repite ' -var2 = 3 -print(var1 * var2 + str(var2) + ' veces') - +#!/usr/bin/env python +# coding: utf-8 + +# ## Variables + +# 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla + +# In[7]: + + +a = 12 +print(a) + + +# 2) Imprimir el tipo de dato de la constante 8.5 + +# In[3]: + + +type(8.5) + + +# 3) Imprimir el tipo de dato de la variable creada en el punto 1 + +# In[8]: + + +type(a) + + +# 4) Crear una variable que contenga tu nombre + +# In[2]: + + +mi_nombre = 'juan carlos perez' + + +# 5) Crear una variable que contenga un número complejo + +# In[3]: + + +n_complejo = 5 + 5j + + +# 6) Mostrar el tipo de dato de la variable crada en el punto 5 + +# In[4]: + + +type(n_complejo) + + +# 7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales + +# In[1]: + + +pi = 3.1416 + + +# 8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo? + +# In[3]: + + +var1 = 'True' +var2 = True + + +# 9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8 + +# In[5]: + + +print('La variable 1 es de tipo ', type(var1), ' y la variable 2 es de tipo ', type(var2)) + + +# 10) Asignar a una variable, la suma de un número entero y otro decimal + +# In[1]: + + +a = 5.2 + 4 + + +# 11) Realizar una operación de suma de números complejos + +# In[2]: + + +a = 3 + 1j +b = 1 + 3j +print(a + b) + + +# 12) Realizar una operación de suma de un número real y otro complejo + +# In[4]: + + +c = a + 1.61 +print(c) + + +# 13) Realizar una operación de multiplicación + +# In[5]: + + +print(3 * 2) + + +# 14) Mostrar el resultado de elevar 2 a la octava potencia + +# In[6]: + + +print(2**8) + + +# 15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla + +# In[8]: + + +a = 27 / 4 +print(a) + + +# 16) De la división anterior solamente mostrar la parte entera + +# In[9]: + + +print(27 // 4) + + +# 17) De la división de 27 entre 4 mostrar solamente el resto + +# In[1]: + + +27 % 4 + + +# 18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado + +# In[2]: + + +6 * 4 + 3 + + +# 19) Utilizar el operador "+" en una operación donde intervengan solo variables alfanuméricas + +# In[3]: + + +var1 = 'Buenos ' +var2 = 'Aires' +print(var1 + var2) + + +# 20) Evaluar si "2" es igual a 2. ¿Por qué ocurre eso? + +# In[4]: + + +2 == '2' + + +# 21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera + +# In[11]: + + +2 == int('2') + + +# 22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8') + +# In[12]: + + +a = float('3.8') + + +# 23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido + +# In[15]: + + +a = -3 +a -= 1 +print(a) + + +# 24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario? + +# In[29]: + + +1 << 2 + + +# 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? + +# In[23]: + + +2 + '2' + + +# In[25]: + + +float(2) + float('2') + + +# In[26]: + + +int(2) + int('2') + + +# In[27]: + + +str(2) + str('2') + + +# 26) Realizar una operación válida entre valores de tipo entero y string + +# In[30]: + + +var1 = 'este texto se repite ' +var2 = 3 +print(var1 * var2 + str(var2) + ' veces') + diff --git a/M03_variablesydatos/Prep_Course_Homework_03.ipynb b/M03_variablesydatos/Prep_Course_Homework_03.ipynb index b4d68b08b..d76100e14 100644 --- a/M03_variablesydatos/Prep_Course_Homework_03.ipynb +++ b/M03_variablesydatos/Prep_Course_Homework_03.ipynb @@ -18,10 +18,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "a = 5\n", + "print(a)" + ] }, { "attachments": {}, @@ -33,10 +44,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8.5\n" + ] + } + ], + "source": [ + "print(\"8.5\")" + ] }, { "attachments": {}, @@ -48,10 +69,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "print(a)" + ] }, { "attachments": {}, @@ -63,10 +94,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "Nombre = \"Ricardo Escamilla\"" + ] }, { "attachments": {}, @@ -78,10 +111,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "Complejo = 5 + 3j" + ] }, { "attachments": {}, @@ -93,10 +128,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "complex" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(Complejo)" + ] }, { "attachments": {}, @@ -108,10 +156,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.1416\n" + ] + } + ], + "source": [ + "pi = 3.1416\n", + "print(pi)" + ] }, { "attachments": {}, @@ -123,10 +182,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "verdadero = \"True\"\n", + "verdadero2 = True" + ] }, { "attachments": {}, @@ -138,10 +200,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "print(type(verdadero))\n", + "print(type(verdadero2))" + ] }, { "attachments": {}, @@ -153,10 +227,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "c = 5 + 2.5" + ] }, { "attachments": {}, @@ -168,10 +244,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4+7j)\n" + ] + } + ], + "source": [ + "d = 3 + 2j\n", + "e = 1 + 5j\n", + "print(d+e)" + ] }, { "attachments": {}, @@ -183,10 +271,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(6+2j)\n" + ] + } + ], + "source": [ + "f = 3 + d\n", + "print(f)" + ] }, { "attachments": {}, @@ -198,10 +297,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], + "source": [ + "print(5*2)" + ] }, { "attachments": {}, @@ -213,10 +322,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "256\n" + ] + } + ], + "source": [ + "print(2**8)" + ] }, { "attachments": {}, @@ -228,10 +347,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.75\n" + ] + } + ], + "source": [ + "print(27/4)" + ] }, { "attachments": {}, @@ -243,10 +372,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "print(27//4)" + ] }, { "attachments": {}, @@ -258,10 +397,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "print(27%4)" + ] }, { "attachments": {}, @@ -273,10 +422,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + } + ], + "source": [ + "print(6*4 + 3)" + ] }, { "attachments": {}, @@ -288,10 +447,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12.5\n" + ] + } + ], + "source": [ + "print(a + c)" + ] }, { "attachments": {}, @@ -303,10 +472,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"2\" == 2" + ] }, { "attachments": {}, @@ -318,10 +500,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(\"2\") == 2" + ] }, { "attachments": {}, @@ -333,10 +528,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "a = float(\"3.8\")" + ] }, { "attachments": {}, @@ -348,10 +545,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "y = 3\n", + "y -=1\n", + "print(y)" + ] }, { "attachments": {}, @@ -363,10 +572,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 << 2" + ] }, { "attachments": {}, @@ -378,10 +600,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 + int(\"2\")" + ] }, { "attachments": {}, @@ -397,6 +632,11 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] } ], "metadata": { @@ -418,7 +658,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.11" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/M03_variablesydatos/Prep_Course_Homework_03.md b/M03_variablesydatos/Prep_Course_Homework_03.md index 7613cecef..e13295fd5 100644 --- a/M03_variablesydatos/Prep_Course_Homework_03.md +++ b/M03_variablesydatos/Prep_Course_Homework_03.md @@ -1,53 +1,53 @@ -## Variables - -1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla - -2) Imprimir el tipo de dato de la constante 8.5 - -3) Imprimir el tipo de dato de la variable creada en el punto 1 - -4) Crear una variable que contenga tu nombre - -5) Crear una variable que contenga un número complejo - -6) Mostrar el tipo de dato de la variable crada en el punto 5 - -7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales - -8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo? - -9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8 - -10) Asignar a una variable, la suma de un número entero y otro decimal - -11) Realizar una operación de suma de números complejos - -12) Realizar una operación de suma de un número real y otro complejo - -13) Realizar una operación de multiplicación - -14) Mostrar el resultado de elevar 2 a la octava potencia - -15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla - -16) De la división anterior solamente mostrar la parte entera - -17) De la división de 27 entre 4 mostrar solamente el resto - -18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado - -19) Utilizar el operador "+" en una operación donde intervengan solo variables alfanuméricas - -20) Evaluar si "2" es igual a 2. ¿Por qué ocurre eso? - -21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera - -22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8') - -23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido - -24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario? - -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? - -26) Realizar una operación válida entre valores de tipo entero y string +## Variables + +1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla + +2) Imprimir el tipo de dato de la constante 8.5 + +3) Imprimir el tipo de dato de la variable creada en el punto 1 + +4) Crear una variable que contenga tu nombre + +5) Crear una variable que contenga un número complejo + +6) Mostrar el tipo de dato de la variable crada en el punto 5 + +7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales + +8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo? + +9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8 + +10) Asignar a una variable, la suma de un número entero y otro decimal + +11) Realizar una operación de suma de números complejos + +12) Realizar una operación de suma de un número real y otro complejo + +13) Realizar una operación de multiplicación + +14) Mostrar el resultado de elevar 2 a la octava potencia + +15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla + +16) De la división anterior solamente mostrar la parte entera + +17) De la división de 27 entre 4 mostrar solamente el resto + +18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado + +19) Utilizar el operador "+" en una operación donde intervengan solo variables alfanuméricas + +20) Evaluar si "2" es igual a 2. ¿Por qué ocurre eso? + +21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera + +22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8') + +23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido + +24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario? + +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? + +26) Realizar una operación válida entre valores de tipo entero y string diff --git a/M03_variablesydatos/Prep_Course_Homework_03.py b/M03_variablesydatos/Prep_Course_Homework_03.py index eb7ddb9eb..5ffa8f08a 100644 --- a/M03_variablesydatos/Prep_Course_Homework_03.py +++ b/M03_variablesydatos/Prep_Course_Homework_03.py @@ -1,209 +1,209 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Variables - -# 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla - -# In[7]: - - - - -# 2) Imprimir el tipo de dato de la constante 8.5 - -# In[3]: - - - - - -# 3) Imprimir el tipo de dato de la variable creada en el punto 1 - -# In[8]: - - - - - -# 4) Crear una variable que contenga tu nombre - -# In[2]: - - - - -# 5) Crear una variable que contenga un número complejo - -# In[3]: - - - - - -# 6) Mostrar el tipo de dato de la variable crada en el punto 5 - -# In[4]: - - - - - -# 7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales - -# In[1]: - - -pi = 3.1416 - - -# 8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo? - -# In[3]: - - - - - -# 9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8 - -# In[5]: - - - - - -# 10) Asignar a una variable, la suma de un número entero y otro decimal - -# In[1]: - - - - - -# 11) Realizar una operación de suma de números complejos - -# In[2]: - - - - - -# 12) Realizar una operación de suma de un número real y otro complejo - -# In[4]: - - - - - -# 13) Realizar una operación de multiplicación - -# In[5]: - - - - - -# 14) Mostrar el resultado de elevar 2 a la octava potencia - -# In[6]: - - - - -# 15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla - -# In[8]: - - - - - -# 16) De la división anterior solamente mostrar la parte entera - -# In[9]: - - - - - -# 17) De la división de 27 entre 4 mostrar solamente el resto - -# In[1]: - - - - - -# 18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado - -# In[2]: - - - - - -# 19) Utilizar el operador "+" en una operación donde intervengan solo variables alfanuméricas - -# In[3]: - - - - - -# 20) Evaluar si "2" es igual a 2. ¿Por qué ocurre eso? - -# In[4]: - - - - - -# 21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera - -# In[11]: - - - - - -# 22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8') - -# In[12]: - - - - - -# 23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido y que de como resultado 2. - -# In[15]: - - - - - -# 24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario? - -# In[29]: - - - - - -# 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? - -# In[23]: - - - - - - -# 26) Realizar una operación válida entre valores de tipo entero y string - -# In[30]: - - - +#!/usr/bin/env python +# coding: utf-8 + +# ## Variables + +# 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla + +# In[7]: + + + + +# 2) Imprimir el tipo de dato de la constante 8.5 + +# In[3]: + + + + + +# 3) Imprimir el tipo de dato de la variable creada en el punto 1 + +# In[8]: + + + + + +# 4) Crear una variable que contenga tu nombre + +# In[2]: + + + + +# 5) Crear una variable que contenga un número complejo + +# In[3]: + + + + + +# 6) Mostrar el tipo de dato de la variable crada en el punto 5 + +# In[4]: + + + + + +# 7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales + +# In[1]: + + +pi = 3.1416 + + +# 8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo? + +# In[3]: + + + + + +# 9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8 + +# In[5]: + + + + + +# 10) Asignar a una variable, la suma de un número entero y otro decimal + +# In[1]: + + + + + +# 11) Realizar una operación de suma de números complejos + +# In[2]: + + + + + +# 12) Realizar una operación de suma de un número real y otro complejo + +# In[4]: + + + + + +# 13) Realizar una operación de multiplicación + +# In[5]: + + + + + +# 14) Mostrar el resultado de elevar 2 a la octava potencia + +# In[6]: + + + + +# 15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla + +# In[8]: + + + + + +# 16) De la división anterior solamente mostrar la parte entera + +# In[9]: + + + + + +# 17) De la división de 27 entre 4 mostrar solamente el resto + +# In[1]: + + + + + +# 18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado + +# In[2]: + + + + + +# 19) Utilizar el operador "+" en una operación donde intervengan solo variables alfanuméricas + +# In[3]: + + + + + +# 20) Evaluar si "2" es igual a 2. ¿Por qué ocurre eso? + +# In[4]: + + + + + +# 21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera + +# In[11]: + + + + + +# 22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8') + +# In[12]: + + + + + +# 23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido y que de como resultado 2. + +# In[15]: + + + + + +# 24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario? + +# In[29]: + + + + + +# 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? + +# In[23]: + + + + + + +# 26) Realizar una operación válida entre valores de tipo entero y string + +# In[30]: + + + diff --git a/M03_variablesydatos/Tipos_de_Datos.ipynb b/M03_variablesydatos/Tipos_de_Datos.ipynb new file mode 100644 index 000000000..9f8a976b4 --- /dev/null +++ b/M03_variablesydatos/Tipos_de_Datos.ipynb @@ -0,0 +1,25 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/M04_flujosdecontrol/Prep_Course_Homework_04-Resuelto.ipynb b/M04_flujosdecontrol/Prep_Course_Homework_04-Resuelto.ipynb index c3d46af97..aaaad8f22 100644 --- a/M04_flujosdecontrol/Prep_Course_Homework_04-Resuelto.ipynb +++ b/M04_flujosdecontrol/Prep_Course_Homework_04-Resuelto.ipynb @@ -1,1004 +1,1004 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Flujos de Control" - ] - }, - { - "attachments": {}, - "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": [ - "La variable es mayor a cero\n" - ] - } - ], - "source": [ - "a = 10\n", - "if (a < 0):\n", - " print('La variable es menor a cero')\n", - "elif (a > 0): \n", - " print('La variable es mayor a cero')\n", - "else:\n", - " print('La variable es igual a cero')" - ] - }, - { - "attachments": {}, - "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": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Las variables son de tipos de dato diferentes\n" - ] - } - ], - "source": [ - "a = 2\n", - "b = 'hola'\n", - "if (type(a) == type(b)):\n", - " print('Las variables son del mismo tipo de dato')\n", - "else:\n", - " print('Las variables son de tipos de dato diferentes')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# El formato utilizado a continuación en el print es conocido como f-string o formatted string literals en Python. Las f-strings permiten incrustar expresiones dentro de una cadena de texto mediante llaves {} y el prefijo \"f\" antes de la cadena. Dentro de las llaves, puedes colocar variables, expresiones o incluso invocar funciones para su evaluación e inclusión en la cadena resultante.\n", - "a = 3.2\n", - "b = 2\n", - "print(f'Las variables {a} y {b} son del mismo tipo de dato')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "El número 1 es impar\n", - "El número 2 es par\n", - "El número 3 es impar\n", - "El número 4 es par\n", - "El número 5 es impar\n", - "El número 6 es par\n", - "El número 7 es impar\n", - "El número 8 es par\n", - "El número 9 es impar\n", - "El número 10 es par\n", - "El número 11 es impar\n", - "El número 12 es par\n", - "El número 13 es impar\n", - "El número 14 es par\n", - "El número 15 es impar\n", - "El número 16 es par\n", - "El número 17 es impar\n", - "El número 18 es par\n", - "El número 19 es impar\n", - "El número 20 es par\n" - ] - } - ], - "source": [ - "#resuelto con bucle for\n", - "\n", - "for i in range(1, 21):\n", - " if i % 2 == 0:\n", - " print('El número ', str(i), ' es par')\n", - " else:\n", - " print('El número ', str(i), ' es impar')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# resuelto con while\n", - "\n", - "i = 1\n", - "while (i <= 20):\n", - " if (i % 2 == 0):\n", - " print(f'El numero {i} es par')\n", - " else:\n", - " print(f'El numero {i} es impar')\n", - " i = i + 1" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Valor: 0 Elevado a la 3ra potencia: 0\n", - "Valor: 1 Elevado a la 3ra potencia: 1\n", - "Valor: 2 Elevado a la 3ra potencia: 8\n", - "Valor: 3 Elevado a la 3ra potencia: 27\n", - "Valor: 4 Elevado a la 3ra potencia: 64\n", - "Valor: 5 Elevado a la 3ra potencia: 125\n" - ] - } - ], - "source": [ - "for i in range(0, 6):\n", - " print('Valor:', str(i), ' Elevado a la 3ra potencia:', str(i**3))" - ] - }, - { - "attachments": {}, - "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": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "11\n" - ] - } - ], - "source": [ - "n = 12\n", - "for i in range(0, n):\n", - " pass\n", - "print(i)" - ] - }, - { - "attachments": {}, - "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 a 0" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "El factorial es 120\n" - ] - } - ], - "source": [ - "n = 5\n", - "if (type(n) == int):\n", - " if (n > 0):\n", - " factorial = n\n", - " while (n > 2):\n", - " n = n - 1\n", - " factorial = factorial * n\n", - " print('El factorial es', factorial)\n", - " else:\n", - " print('La variable no es mayor a cero')\n", - "else:\n", - " print('La variable no es un entero')\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "120\n" - ] - } - ], - "source": [ - "# resolución con bucle for\n", - "\n", - "numero = 5\n", - "factorial = 1\n", - "for i in range(2, (numero + 1)):\n", - " factorial = i * factorial\n", - "print(factorial)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "7) Crear un ciclo for dentro de un ciclo while" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Ciclo while nro 1\n", - "Ciclo for nro 1\n", - "Ciclo while nro 2\n", - "Ciclo for nro 1\n", - "Ciclo for nro 2\n", - "Ciclo while nro 3\n", - "Ciclo for nro 1\n", - "Ciclo for nro 2\n", - "Ciclo for nro 3\n", - "Ciclo while nro 4\n", - "Ciclo for nro 1\n", - "Ciclo for nro 2\n", - "Ciclo for nro 3\n", - "Ciclo for nro 4\n" - ] - } - ], - "source": [ - "n = 1\n", - "while n < 5:\n", - " print('Ciclo while nro ' + str(n)) # Imprime el número del ciclo while\n", - " for i in range(1, n+1): # como la función range(a, b) genera una secuencia de números desde a hasta b-1. Para que el bucle for incluya el número n, usamos range(1, n+1) en lugar de range(1, n).\n", - " print('Ciclo for nro ' + str(i)) # Imprime el número del ciclo for\n", - " n += 1" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "8) Crear un ciclo while dentro de un ciclo for" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "n = 5\n", - "for i in range(1, n):\n", - " while(n < 5):\n", - " n -= 1\n", - " print('Ciclo while nro ' + str(n))\n", - " print('Ciclo for nro ' + str(i))" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Ciclo for nro 1\n", - "Ciclo while nro 5\n", - "Ciclo while nro 4\n", - "Ciclo while nro 3\n", - "Ciclo while nro 2\n", - "Ciclo while nro 1\n", - "Ciclo for nro 2\n", - "Ciclo while nro 5\n", - "Ciclo while nro 4\n", - "Ciclo while nro 3\n", - "Ciclo while nro 2\n", - "Ciclo while nro 1\n", - "Ciclo for nro 3\n", - "Ciclo while nro 5\n", - "Ciclo while nro 4\n", - "Ciclo while nro 3\n", - "Ciclo while nro 2\n", - "Ciclo while nro 1\n", - "Ciclo for nro 4\n", - "Ciclo while nro 5\n", - "Ciclo while nro 4\n", - "Ciclo while nro 3\n", - "Ciclo while nro 2\n", - "Ciclo while nro 1\n" - ] - } - ], - "source": [ - "n = 5\n", - "for i in range(1, n):\n", - " print('Ciclo for nro ' + str(i)) # Imprime el número del ciclo for\n", - " \n", - " n_temp = n # Almacena el valor original de n en una variable temporal\n", - " \n", - " while n_temp > 0: # Ciclo while que se ejecuta mientras n_temp sea mayor que 0\n", - " print('Ciclo while nro ' + str(n_temp)) # Imprime el número del ciclo while\n", - " n_temp -= 1\n", - " \n", - " if n_temp <= 0:\n", - " break # Sale del ciclo while cuando n_temp sea menor o igual a 0\n", - " \n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "9) Imprimir los números primos existentes entre 0 y 30" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "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": [ - "tope_rango=30\n", - "n = 0\n", - "primo = True\n", - "while (n < tope_rango):\n", - " for div in range(2, n):\n", - " if (n % div == 0):\n", - " primo = False\n", - " if (primo):\n", - " print(n)\n", - " else:\n", - " primo = True\n", - " n += 1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Código anterior explicado paso a paso:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "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": [ - "# Establecemos el valor máximo del rango\n", - "tope_rango = 30\n", - "\n", - "# Inicializamos la variable n en 0\n", - "n = 0\n", - "\n", - "# Inicializamos la variable primo como verdadera\n", - "primo = True\n", - "\n", - "# Comenzamos un bucle while que se ejecutará mientras n sea menor que el tope_rango\n", - "while n < tope_rango:\n", - " # Comenzamos un bucle for que itera desde 2 hasta n-1\n", - " for div in range(2, n):\n", - " # Comprobamos si n es divisible entre div\n", - " if n % div == 0:\n", - " # Si es divisible, marcamos primo como falso\n", - " primo = False\n", - " \n", - " # Verificamos si la variable primo es verdadera\n", - " if primo:\n", - " # Si es verdadera, significa que n es un número primo, por lo que lo imprimimos\n", - " print(n)\n", - " else:\n", - " # Si primo es falso, significa que n no es un número primo, por lo que lo restablecemos a verdadero\n", - " primo = True\n", - " \n", - " # Incrementamos n en 1 para pasar al siguiente número\n", - " n += 1\n" - ] - }, - { - "attachments": {}, - "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": 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" - ] - } - ], - "source": [ - "n = 0\n", - "primo = True\n", - "while (n < tope_rango):\n", - " for div in range(2, n):\n", - " if (n % div == 0):\n", - " primo = False\n", - " break\n", - " if (primo):\n", - " print(n)\n", - " else:\n", - " primo = True\n", - " n += 1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Código explicado paso a paso:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Inicializamos la variable n en 0\n", - "n = 0\n", - "\n", - "# Inicializamos la variable primo como verdadera\n", - "primo = True\n", - "\n", - "# Comenzamos un bucle while que se ejecutará mientras n sea menor que el tope_rango\n", - "while n < tope_rango:\n", - " # Comenzamos un bucle for que itera desde 2 hasta n-1\n", - " for div in range(2, n):\n", - " # Comprobamos si n es divisible entre div\n", - " if n % div == 0:\n", - " # Si es divisible, marcamos primo como falso y salimos del bucle for por la sentencia break\n", - " primo = False\n", - " break\n", - " \n", - " # Verificamos si la variable primo es verdadera\n", - " if primo:\n", - " # Si es verdadera, significa que n es un número primo, por lo que lo imprimimos\n", - " print(n)\n", - " else:\n", - " # Si primo es falso, significa que n no es un número primo, por lo que lo restablecemos a verdadero\n", - " primo = True\n", - " \n", - " # Incrementamos n en 1 para pasar al siguiente número\n", - " n += 1\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó?" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "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: 378\n" - ] - } - ], - "source": [ - "ciclos_sin_break = 0\n", - "n = 0\n", - "primo = True\n", - "while (n < tope_rango):\n", - " for div in range(2, n):\n", - " ciclos_sin_break += 1\n", - " if (n % div == 0):\n", - " primo = False\n", - " if (primo):\n", - " print(n)\n", - " else:\n", - " primo = True\n", - " n += 1\n", - "print('Cantidad de ciclos: ' + str(ciclos_sin_break))" - ] - }, - { - "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", - "Cantidad de ciclos: 134\n", - "Se optimizó a un 0.3544973544973545% de ciclos aplicando break\n" - ] - } - ], - "source": [ - "ciclos_con_break = 0\n", - "n = 0\n", - "primo = True\n", - "while (n < tope_rango):\n", - " for div in range(2, n):\n", - " ciclos_con_break += 1\n", - " if (n % div == 0):\n", - " primo = False\n", - " break\n", - " if (primo):\n", - " print(n)\n", - " else:\n", - " primo = True\n", - " n += 1\n", - "print('Cantidad de ciclos: ' + str(ciclos_con_break))\n", - "print('Se optimizó a un ' + str(ciclos_con_break/ciclos_sin_break) + '% de ciclos aplicando break')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "12) 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": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "108 es divisible por 12\n", - "120 es divisible por 12\n", - "132 es divisible por 12\n", - "144 es divisible por 12\n", - "156 es divisible por 12\n", - "168 es divisible por 12\n", - "180 es divisible por 12\n", - "192 es divisible por 12\n", - "204 es divisible por 12\n", - "216 es divisible por 12\n", - "228 es divisible por 12\n", - "240 es divisible por 12\n", - "252 es divisible por 12\n", - "264 es divisible por 12\n", - "276 es divisible por 12\n", - "288 es divisible por 12\n", - "300 es divisible por 12\n" - ] - } - ], - "source": [ - "n = 99\n", - "while(n <= 300):\n", - " n += 1\n", - " if (n % 12 != 0):\n", - " continue\n", - " print(n, ' es divisible por 12')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Código explicado:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "108 es divisible por 12\n", - "120 es divisible por 12\n", - "132 es divisible por 12\n", - "144 es divisible por 12\n", - "156 es divisible por 12\n", - "168 es divisible por 12\n", - "180 es divisible por 12\n", - "192 es divisible por 12\n", - "204 es divisible por 12\n", - "216 es divisible por 12\n", - "228 es divisible por 12\n", - "240 es divisible por 12\n", - "252 es divisible por 12\n", - "264 es divisible por 12\n", - "276 es divisible por 12\n", - "288 es divisible por 12\n", - "300 es divisible por 12\n" - ] - } - ], - "source": [ - "# Inicializamos la variable n en 99\n", - "n = 99\n", - "\n", - "# Comenzamos un bucle while que se ejecutará mientras n sea menor o igual a 300\n", - "while n <= 300:\n", - " # Incrementamos n en 1 para pasar al siguiente número\n", - " n += 1\n", - " \n", - " # Comprobamos si n no es divisible por 12 utilizando el operador de módulo (%)\n", - " if n % 12 != 0:\n", - " # Si n no es divisible por 12, se ejecuta la instrucción 'continue' para volver al inicio del bucle while\n", - " # y saltar a la siguiente iteración sin ejecutar el código que sigue\n", - " continue\n", - " \n", - " # Si se llega a esta línea de código, significa que n es divisible por 12\n", - " # por lo que se imprime el mensaje indicando que n es divisible por 12\n", - " print(n, 'es divisible por 12')\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "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" - ] - } - ], - "source": [ - "n = 1\n", - "sigue = 1\n", - "primo = True\n", - "while (sigue == 1):\n", - " for div in range(2, n):\n", - " if (n % div == 0):\n", - " primo = False\n", - " break\n", - " if (primo):\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", - " primo = True\n", - " n += 1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Código explicado." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "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", - "17\n", - "¿Desea encontrar el siguiente número primo?\n", - "19\n", - "¿Desea encontrar el siguiente número primo?\n", - "Se finaliza el proceso\n" - ] - } - ], - "source": [ - "# Inicializamos la variable n en 1\n", - "n = 1\n", - "\n", - "# Inicializamos la variable sigue en 1, esto indica si el proceso de búsqueda continúa\n", - "sigue = 1\n", - "\n", - "# Inicializamos la variable primo como verdadera\n", - "primo = True\n", - "\n", - "# Comenzamos un bucle while que se ejecutará mientras sigue sea igual a 1\n", - "while sigue == 1:\n", - " # Comenzamos un bucle for que itera desde 2 hasta n-1\n", - " for div in range(2, n):\n", - " # Comprobamos si n es divisible entre div\n", - " if n % div == 0:\n", - " # Si es divisible, marcamos primo como falso y salimos del bucle for\n", - " primo = False\n", - " break\n", - " \n", - " # Verificamos si la variable primo es verdadera\n", - " if primo:\n", - " # Si es verdadera, significa que n es un número primo, por lo que lo imprimimos\n", - " print(n)\n", - " print('¿Desea encontrar el siguiente número primo?')\n", - " \n", - " # Leemos la entrada del usuario para determinar si se continúa o se finaliza el proceso\n", - " if input() != '1':\n", - " print('Se finaliza el proceso')\n", - " break\n", - " else:\n", - " # Si primo es falso, significa que n no es un número primo, por lo que lo restablecemos a verdadero\n", - " primo = True\n", - " \n", - " # Incrementamos n en 1 para pasar al siguiente número\n", - " n += 1\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "14) 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": 75, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "El número es: 102\n" - ] - } - ], - "source": [ - "n = 100\n", - "while(n<=300):\n", - " if (n % 6 == 0):\n", - " print('El número es: ', str(n))\n", - " break\n", - " n += 1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Código explicado:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "El número es: 102\n" - ] - } - ], - "source": [ - "# Inicializamos la variable n en 100\n", - "n = 100\n", - "\n", - "# Comenzamos un bucle while que se ejecutará mientras n sea menor o igual a 300\n", - "while n <= 300:\n", - " # Comprobamos si n es divisible por 6 sin dejar residuo\n", - " if n % 6 == 0:\n", - " # Si es divisible, imprimimos el mensaje y el valor de n\n", - " print('El número es:', n)\n", - " # Salimos del bucle while utilizando la instrucción 'break'\n", - " break\n", - " \n", - " # Incrementamos n en 1 para pasar al siguiente número\n", - " n += 1\n" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.11" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Flujos de Control" + ] + }, + { + "attachments": {}, + "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": [ + "La variable es mayor a cero\n" + ] + } + ], + "source": [ + "a = 10\n", + "if (a < 0):\n", + " print('La variable es menor a cero')\n", + "elif (a > 0): \n", + " print('La variable es mayor a cero')\n", + "else:\n", + " print('La variable es igual a cero')" + ] + }, + { + "attachments": {}, + "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": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Las variables son de tipos de dato diferentes\n" + ] + } + ], + "source": [ + "a = 2\n", + "b = 'hola'\n", + "if (type(a) == type(b)):\n", + " print('Las variables son del mismo tipo de dato')\n", + "else:\n", + " print('Las variables son de tipos de dato diferentes')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# El formato utilizado a continuación en el print es conocido como f-string o formatted string literals en Python. Las f-strings permiten incrustar expresiones dentro de una cadena de texto mediante llaves {} y el prefijo \"f\" antes de la cadena. Dentro de las llaves, puedes colocar variables, expresiones o incluso invocar funciones para su evaluación e inclusión en la cadena resultante.\n", + "a = 3.2\n", + "b = 2\n", + "print(f'Las variables {a} y {b} son del mismo tipo de dato')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El número 1 es impar\n", + "El número 2 es par\n", + "El número 3 es impar\n", + "El número 4 es par\n", + "El número 5 es impar\n", + "El número 6 es par\n", + "El número 7 es impar\n", + "El número 8 es par\n", + "El número 9 es impar\n", + "El número 10 es par\n", + "El número 11 es impar\n", + "El número 12 es par\n", + "El número 13 es impar\n", + "El número 14 es par\n", + "El número 15 es impar\n", + "El número 16 es par\n", + "El número 17 es impar\n", + "El número 18 es par\n", + "El número 19 es impar\n", + "El número 20 es par\n" + ] + } + ], + "source": [ + "#resuelto con bucle for\n", + "\n", + "for i in range(1, 21):\n", + " if i % 2 == 0:\n", + " print('El número ', str(i), ' es par')\n", + " else:\n", + " print('El número ', str(i), ' es impar')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# resuelto con while\n", + "\n", + "i = 1\n", + "while (i <= 20):\n", + " if (i % 2 == 0):\n", + " print(f'El numero {i} es par')\n", + " else:\n", + " print(f'El numero {i} es impar')\n", + " i = i + 1" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Valor: 0 Elevado a la 3ra potencia: 0\n", + "Valor: 1 Elevado a la 3ra potencia: 1\n", + "Valor: 2 Elevado a la 3ra potencia: 8\n", + "Valor: 3 Elevado a la 3ra potencia: 27\n", + "Valor: 4 Elevado a la 3ra potencia: 64\n", + "Valor: 5 Elevado a la 3ra potencia: 125\n" + ] + } + ], + "source": [ + "for i in range(0, 6):\n", + " print('Valor:', str(i), ' Elevado a la 3ra potencia:', str(i**3))" + ] + }, + { + "attachments": {}, + "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": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11\n" + ] + } + ], + "source": [ + "n = 12\n", + "for i in range(0, n):\n", + " pass\n", + "print(i)" + ] + }, + { + "attachments": {}, + "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 a 0" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El factorial es 120\n" + ] + } + ], + "source": [ + "n = 5\n", + "if (type(n) == int):\n", + " if (n > 0):\n", + " factorial = n\n", + " while (n > 2):\n", + " n = n - 1\n", + " factorial = factorial * n\n", + " print('El factorial es', factorial)\n", + " else:\n", + " print('La variable no es mayor a cero')\n", + "else:\n", + " print('La variable no es un entero')\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "120\n" + ] + } + ], + "source": [ + "# resolución con bucle for\n", + "\n", + "numero = 5\n", + "factorial = 1\n", + "for i in range(2, (numero + 1)):\n", + " factorial = i * factorial\n", + "print(factorial)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7) Crear un ciclo for dentro de un ciclo while" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ciclo while nro 1\n", + "Ciclo for nro 1\n", + "Ciclo while nro 2\n", + "Ciclo for nro 1\n", + "Ciclo for nro 2\n", + "Ciclo while nro 3\n", + "Ciclo for nro 1\n", + "Ciclo for nro 2\n", + "Ciclo for nro 3\n", + "Ciclo while nro 4\n", + "Ciclo for nro 1\n", + "Ciclo for nro 2\n", + "Ciclo for nro 3\n", + "Ciclo for nro 4\n" + ] + } + ], + "source": [ + "n = 1\n", + "while n < 5:\n", + " print('Ciclo while nro ' + str(n)) # Imprime el número del ciclo while\n", + " for i in range(1, n+1): # como la función range(a, b) genera una secuencia de números desde a hasta b-1. Para que el bucle for incluya el número n, usamos range(1, n+1) en lugar de range(1, n).\n", + " print('Ciclo for nro ' + str(i)) # Imprime el número del ciclo for\n", + " n += 1" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Crear un ciclo while dentro de un ciclo for" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "n = 5\n", + "for i in range(1, n):\n", + " while(n < 5):\n", + " n -= 1\n", + " print('Ciclo while nro ' + str(n))\n", + " print('Ciclo for nro ' + str(i))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ciclo for nro 1\n", + "Ciclo while nro 5\n", + "Ciclo while nro 4\n", + "Ciclo while nro 3\n", + "Ciclo while nro 2\n", + "Ciclo while nro 1\n", + "Ciclo for nro 2\n", + "Ciclo while nro 5\n", + "Ciclo while nro 4\n", + "Ciclo while nro 3\n", + "Ciclo while nro 2\n", + "Ciclo while nro 1\n", + "Ciclo for nro 3\n", + "Ciclo while nro 5\n", + "Ciclo while nro 4\n", + "Ciclo while nro 3\n", + "Ciclo while nro 2\n", + "Ciclo while nro 1\n", + "Ciclo for nro 4\n", + "Ciclo while nro 5\n", + "Ciclo while nro 4\n", + "Ciclo while nro 3\n", + "Ciclo while nro 2\n", + "Ciclo while nro 1\n" + ] + } + ], + "source": [ + "n = 5\n", + "for i in range(1, n):\n", + " print('Ciclo for nro ' + str(i)) # Imprime el número del ciclo for\n", + " \n", + " n_temp = n # Almacena el valor original de n en una variable temporal\n", + " \n", + " while n_temp > 0: # Ciclo while que se ejecuta mientras n_temp sea mayor que 0\n", + " print('Ciclo while nro ' + str(n_temp)) # Imprime el número del ciclo while\n", + " n_temp -= 1\n", + " \n", + " if n_temp <= 0:\n", + " break # Sale del ciclo while cuando n_temp sea menor o igual a 0\n", + " \n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9) Imprimir los números primos existentes entre 0 y 30" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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": [ + "tope_rango=30\n", + "n = 0\n", + "primo = True\n", + "while (n < tope_rango):\n", + " for div in range(2, n):\n", + " if (n % div == 0):\n", + " primo = False\n", + " if (primo):\n", + " print(n)\n", + " else:\n", + " primo = True\n", + " n += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Código anterior explicado paso a paso:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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": [ + "# Establecemos el valor máximo del rango\n", + "tope_rango = 30\n", + "\n", + "# Inicializamos la variable n en 0\n", + "n = 0\n", + "\n", + "# Inicializamos la variable primo como verdadera\n", + "primo = True\n", + "\n", + "# Comenzamos un bucle while que se ejecutará mientras n sea menor que el tope_rango\n", + "while n < tope_rango:\n", + " # Comenzamos un bucle for que itera desde 2 hasta n-1\n", + " for div in range(2, n):\n", + " # Comprobamos si n es divisible entre div\n", + " if n % div == 0:\n", + " # Si es divisible, marcamos primo como falso\n", + " primo = False\n", + " \n", + " # Verificamos si la variable primo es verdadera\n", + " if primo:\n", + " # Si es verdadera, significa que n es un número primo, por lo que lo imprimimos\n", + " print(n)\n", + " else:\n", + " # Si primo es falso, significa que n no es un número primo, por lo que lo restablecemos a verdadero\n", + " primo = True\n", + " \n", + " # Incrementamos n en 1 para pasar al siguiente número\n", + " n += 1\n" + ] + }, + { + "attachments": {}, + "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": 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" + ] + } + ], + "source": [ + "n = 0\n", + "primo = True\n", + "while (n < tope_rango):\n", + " for div in range(2, n):\n", + " if (n % div == 0):\n", + " primo = False\n", + " break\n", + " if (primo):\n", + " print(n)\n", + " else:\n", + " primo = True\n", + " n += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Código explicado paso a paso:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Inicializamos la variable n en 0\n", + "n = 0\n", + "\n", + "# Inicializamos la variable primo como verdadera\n", + "primo = True\n", + "\n", + "# Comenzamos un bucle while que se ejecutará mientras n sea menor que el tope_rango\n", + "while n < tope_rango:\n", + " # Comenzamos un bucle for que itera desde 2 hasta n-1\n", + " for div in range(2, n):\n", + " # Comprobamos si n es divisible entre div\n", + " if n % div == 0:\n", + " # Si es divisible, marcamos primo como falso y salimos del bucle for por la sentencia break\n", + " primo = False\n", + " break\n", + " \n", + " # Verificamos si la variable primo es verdadera\n", + " if primo:\n", + " # Si es verdadera, significa que n es un número primo, por lo que lo imprimimos\n", + " print(n)\n", + " else:\n", + " # Si primo es falso, significa que n no es un número primo, por lo que lo restablecemos a verdadero\n", + " primo = True\n", + " \n", + " # Incrementamos n en 1 para pasar al siguiente número\n", + " n += 1\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó?" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "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: 378\n" + ] + } + ], + "source": [ + "ciclos_sin_break = 0\n", + "n = 0\n", + "primo = True\n", + "while (n < tope_rango):\n", + " for div in range(2, n):\n", + " ciclos_sin_break += 1\n", + " if (n % div == 0):\n", + " primo = False\n", + " if (primo):\n", + " print(n)\n", + " else:\n", + " primo = True\n", + " n += 1\n", + "print('Cantidad de ciclos: ' + str(ciclos_sin_break))" + ] + }, + { + "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", + "Cantidad de ciclos: 134\n", + "Se optimizó a un 0.3544973544973545% de ciclos aplicando break\n" + ] + } + ], + "source": [ + "ciclos_con_break = 0\n", + "n = 0\n", + "primo = True\n", + "while (n < tope_rango):\n", + " for div in range(2, n):\n", + " ciclos_con_break += 1\n", + " if (n % div == 0):\n", + " primo = False\n", + " break\n", + " if (primo):\n", + " print(n)\n", + " else:\n", + " primo = True\n", + " n += 1\n", + "print('Cantidad de ciclos: ' + str(ciclos_con_break))\n", + "print('Se optimizó a un ' + str(ciclos_con_break/ciclos_sin_break) + '% de ciclos aplicando break')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "12) 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": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "108 es divisible por 12\n", + "120 es divisible por 12\n", + "132 es divisible por 12\n", + "144 es divisible por 12\n", + "156 es divisible por 12\n", + "168 es divisible por 12\n", + "180 es divisible por 12\n", + "192 es divisible por 12\n", + "204 es divisible por 12\n", + "216 es divisible por 12\n", + "228 es divisible por 12\n", + "240 es divisible por 12\n", + "252 es divisible por 12\n", + "264 es divisible por 12\n", + "276 es divisible por 12\n", + "288 es divisible por 12\n", + "300 es divisible por 12\n" + ] + } + ], + "source": [ + "n = 99\n", + "while(n <= 300):\n", + " n += 1\n", + " if (n % 12 != 0):\n", + " continue\n", + " print(n, ' es divisible por 12')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Código explicado:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "108 es divisible por 12\n", + "120 es divisible por 12\n", + "132 es divisible por 12\n", + "144 es divisible por 12\n", + "156 es divisible por 12\n", + "168 es divisible por 12\n", + "180 es divisible por 12\n", + "192 es divisible por 12\n", + "204 es divisible por 12\n", + "216 es divisible por 12\n", + "228 es divisible por 12\n", + "240 es divisible por 12\n", + "252 es divisible por 12\n", + "264 es divisible por 12\n", + "276 es divisible por 12\n", + "288 es divisible por 12\n", + "300 es divisible por 12\n" + ] + } + ], + "source": [ + "# Inicializamos la variable n en 99\n", + "n = 99\n", + "\n", + "# Comenzamos un bucle while que se ejecutará mientras n sea menor o igual a 300\n", + "while n <= 300:\n", + " # Incrementamos n en 1 para pasar al siguiente número\n", + " n += 1\n", + " \n", + " # Comprobamos si n no es divisible por 12 utilizando el operador de módulo (%)\n", + " if n % 12 != 0:\n", + " # Si n no es divisible por 12, se ejecuta la instrucción 'continue' para volver al inicio del bucle while\n", + " # y saltar a la siguiente iteración sin ejecutar el código que sigue\n", + " continue\n", + " \n", + " # Si se llega a esta línea de código, significa que n es divisible por 12\n", + " # por lo que se imprime el mensaje indicando que n es divisible por 12\n", + " print(n, 'es divisible por 12')\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "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" + ] + } + ], + "source": [ + "n = 1\n", + "sigue = 1\n", + "primo = True\n", + "while (sigue == 1):\n", + " for div in range(2, n):\n", + " if (n % div == 0):\n", + " primo = False\n", + " break\n", + " if (primo):\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", + " primo = True\n", + " n += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Código explicado." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "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", + "17\n", + "¿Desea encontrar el siguiente número primo?\n", + "19\n", + "¿Desea encontrar el siguiente número primo?\n", + "Se finaliza el proceso\n" + ] + } + ], + "source": [ + "# Inicializamos la variable n en 1\n", + "n = 1\n", + "\n", + "# Inicializamos la variable sigue en 1, esto indica si el proceso de búsqueda continúa\n", + "sigue = 1\n", + "\n", + "# Inicializamos la variable primo como verdadera\n", + "primo = True\n", + "\n", + "# Comenzamos un bucle while que se ejecutará mientras sigue sea igual a 1\n", + "while sigue == 1:\n", + " # Comenzamos un bucle for que itera desde 2 hasta n-1\n", + " for div in range(2, n):\n", + " # Comprobamos si n es divisible entre div\n", + " if n % div == 0:\n", + " # Si es divisible, marcamos primo como falso y salimos del bucle for\n", + " primo = False\n", + " break\n", + " \n", + " # Verificamos si la variable primo es verdadera\n", + " if primo:\n", + " # Si es verdadera, significa que n es un número primo, por lo que lo imprimimos\n", + " print(n)\n", + " print('¿Desea encontrar el siguiente número primo?')\n", + " \n", + " # Leemos la entrada del usuario para determinar si se continúa o se finaliza el proceso\n", + " if input() != '1':\n", + " print('Se finaliza el proceso')\n", + " break\n", + " else:\n", + " # Si primo es falso, significa que n no es un número primo, por lo que lo restablecemos a verdadero\n", + " primo = True\n", + " \n", + " # Incrementamos n en 1 para pasar al siguiente número\n", + " n += 1\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) 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": 75, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El número es: 102\n" + ] + } + ], + "source": [ + "n = 100\n", + "while(n<=300):\n", + " if (n % 6 == 0):\n", + " print('El número es: ', str(n))\n", + " break\n", + " n += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Código explicado:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El número es: 102\n" + ] + } + ], + "source": [ + "# Inicializamos la variable n en 100\n", + "n = 100\n", + "\n", + "# Comenzamos un bucle while que se ejecutará mientras n sea menor o igual a 300\n", + "while n <= 300:\n", + " # Comprobamos si n es divisible por 6 sin dejar residuo\n", + " if n % 6 == 0:\n", + " # Si es divisible, imprimimos el mensaje y el valor de n\n", + " print('El número es:', n)\n", + " # Salimos del bucle while utilizando la instrucción 'break'\n", + " break\n", + " \n", + " # Incrementamos n en 1 para pasar al siguiente número\n", + " n += 1\n" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/M04_flujosdecontrol/Prep_Course_Homework_04-Resuelto.py b/M04_flujosdecontrol/Prep_Course_Homework_04-Resuelto.py index d71e51988..63ec682d3 100644 --- a/M04_flujosdecontrol/Prep_Course_Homework_04-Resuelto.py +++ b/M04_flujosdecontrol/Prep_Course_Homework_04-Resuelto.py @@ -1,239 +1,239 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Flujos de Control - -# 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 - -# In[4]: - - -a = 10 -if (a < 0): - print('La variable es menor a cero') -elif (a > 0): - print('La varaible es mayor a cero') -else: - print('La variable es igual a cero') - - -# 2) Crear dos variables y un condicional que informe si son del mismo tipo de dato - -# In[5]: - - -a = 2 -b = 'hola' -if (type(a) == type(b)): - print('Las variables son del mismo tipo de dato') -else: - print('Las variables son de tipos de dato diferentes') - - -# 3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar - -# In[7]: - - -for i in range(1, 21): - if i % 2 == 0: - print('El número ', str(i), ' es par') - else: - print('El número ', str(i), ' es impar') - - -# 4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3 - -# In[9]: - - -for i in range(0, 6): - print('Valor:', str(i), ' Elevado a la 3ra potencia:', str(i**3)) - - -# 5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos - -# In[10]: - - -n = 12 -for i in range(0, n): - pass -print(i) - - -# 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 a 0 - -# In[33]: - - -n = 5 -if (type(n) == int): - if (n > 0): - factorial = n - while (n > 2): - n = n - 1 - factorial = factorial * n - print('El factorial es', factorial) - else: - print('La variable no es mayor a cero') -else: - print('La variable no es un entero') - - - -# 7) Crear un ciclo for dentro de un ciclo while - -# In[38]: - - -n = 0 -while(n < 5): - n += 1 - for i in range(1,n): - print('Ciclo while nro ' + str(n)) - print('Ciclo for nro ' + str(i)) - - -# 8) Crear un ciclo while dentro de un ciclo for - -# In[3]: - - -n = 5 -for i in range(1, n): - while(n < 5): - n -= 1 - print('Ciclo while nro ' + str(n)) - print('Ciclo for nro ' + str(i)) - - -# 9) Imprimir los números primos existentes entre 0 y 30 - -# In[54]: - - -tope_rango=30 -n = 0 -primo = True -while (n < tope_rango): - for div in range(2, n): - if (n % div == 0): - primo = False - if (primo): - print(n) - else: - primo = True - n += 1 - - -# 10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin - -# In[55]: - - -n = 0 -primo = True -while (n < tope_rango): - for div in range(2, n): - if (n % div == 0): - primo = False - break - if (primo): - print(n) - else: - primo = True - n += 1 - - -# 11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó? - -# In[56]: - - -ciclos_sin_break = 0 -n = 0 -primo = True -while (n < tope_rango): - for div in range(2, n): - ciclos_sin_break += 1 - if (n % div == 0): - primo = False - if (primo): - print(n) - else: - primo = True - n += 1 -print('Cantidad de ciclos: ' + str(ciclos_sin_break)) - - -# In[57]: - - -ciclos_con_break = 0 -n = 0 -primo = True -while (n < tope_rango): - for div in range(2, n): - ciclos_con_break += 1 - if (n % div == 0): - primo = False - break - if (primo): - print(n) - else: - primo = True - n += 1 -print('Cantidad de ciclos: ' + str(ciclos_con_break)) -print('Se optimizó a un ' + str(ciclos_con_break/ciclos_sin_break) + '% de ciclos aplicando break') - - -# 12) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300 - -# In[62]: - - -n = 99 -while(n <= 300): - n += 1 - if (n % 12 != 0): - continue - print(n, ' es divisible por 12') - - -# 13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente - -# In[73]: - - -n = 1 -sigue = 1 -primo = True -while (sigue == 1): - for div in range(2, n): - if (n % div == 0): - primo = False - break - if (primo): - print(n) - print('¿Desea encontrar el siguiente número primo?') - if (input() != '1'): - print('Se finaliza el proceso') - break - else: - primo = True - n += 1 - - -# 14) 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 - -# In[75]: - - -n = 100 -while(n<=300): - if (n % 6 == 0): - print('El número es: ', str(n)) - break - n += 1 - +#!/usr/bin/env python +# coding: utf-8 + +# ## Flujos de Control + +# 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 + +# In[4]: + + +a = 10 +if (a < 0): + print('La variable es menor a cero') +elif (a > 0): + print('La varaible es mayor a cero') +else: + print('La variable es igual a cero') + + +# 2) Crear dos variables y un condicional que informe si son del mismo tipo de dato + +# In[5]: + + +a = 2 +b = 'hola' +if (type(a) == type(b)): + print('Las variables son del mismo tipo de dato') +else: + print('Las variables son de tipos de dato diferentes') + + +# 3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar + +# In[7]: + + +for i in range(1, 21): + if i % 2 == 0: + print('El número ', str(i), ' es par') + else: + print('El número ', str(i), ' es impar') + + +# 4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3 + +# In[9]: + + +for i in range(0, 6): + print('Valor:', str(i), ' Elevado a la 3ra potencia:', str(i**3)) + + +# 5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos + +# In[10]: + + +n = 12 +for i in range(0, n): + pass +print(i) + + +# 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 a 0 + +# In[33]: + + +n = 5 +if (type(n) == int): + if (n > 0): + factorial = n + while (n > 2): + n = n - 1 + factorial = factorial * n + print('El factorial es', factorial) + else: + print('La variable no es mayor a cero') +else: + print('La variable no es un entero') + + + +# 7) Crear un ciclo for dentro de un ciclo while + +# In[38]: + + +n = 0 +while(n < 5): + n += 1 + for i in range(1,n): + print('Ciclo while nro ' + str(n)) + print('Ciclo for nro ' + str(i)) + + +# 8) Crear un ciclo while dentro de un ciclo for + +# In[3]: + + +n = 5 +for i in range(1, n): + while(n < 5): + n -= 1 + print('Ciclo while nro ' + str(n)) + print('Ciclo for nro ' + str(i)) + + +# 9) Imprimir los números primos existentes entre 0 y 30 + +# In[54]: + + +tope_rango=30 +n = 0 +primo = True +while (n < tope_rango): + for div in range(2, n): + if (n % div == 0): + primo = False + if (primo): + print(n) + else: + primo = True + n += 1 + + +# 10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin + +# In[55]: + + +n = 0 +primo = True +while (n < tope_rango): + for div in range(2, n): + if (n % div == 0): + primo = False + break + if (primo): + print(n) + else: + primo = True + n += 1 + + +# 11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó? + +# In[56]: + + +ciclos_sin_break = 0 +n = 0 +primo = True +while (n < tope_rango): + for div in range(2, n): + ciclos_sin_break += 1 + if (n % div == 0): + primo = False + if (primo): + print(n) + else: + primo = True + n += 1 +print('Cantidad de ciclos: ' + str(ciclos_sin_break)) + + +# In[57]: + + +ciclos_con_break = 0 +n = 0 +primo = True +while (n < tope_rango): + for div in range(2, n): + ciclos_con_break += 1 + if (n % div == 0): + primo = False + break + if (primo): + print(n) + else: + primo = True + n += 1 +print('Cantidad de ciclos: ' + str(ciclos_con_break)) +print('Se optimizó a un ' + str(ciclos_con_break/ciclos_sin_break) + '% de ciclos aplicando break') + + +# 12) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300 + +# In[62]: + + +n = 99 +while(n <= 300): + n += 1 + if (n % 12 != 0): + continue + print(n, ' es divisible por 12') + + +# 13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente + +# In[73]: + + +n = 1 +sigue = 1 +primo = True +while (sigue == 1): + for div in range(2, n): + if (n % div == 0): + primo = False + break + if (primo): + print(n) + print('¿Desea encontrar el siguiente número primo?') + if (input() != '1'): + print('Se finaliza el proceso') + break + else: + primo = True + n += 1 + + +# 14) 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 + +# In[75]: + + +n = 100 +while(n<=300): + if (n % 6 == 0): + print('El número es: ', str(n)) + break + n += 1 + diff --git a/M04_flujosdecontrol/Prep_Course_Homework_04.ipynb b/M04_flujosdecontrol/Prep_Course_Homework_04.ipynb index 8b5ecb46c..8635ae0da 100644 --- a/M04_flujosdecontrol/Prep_Course_Homework_04.ipynb +++ b/M04_flujosdecontrol/Prep_Course_Homework_04.ipynb @@ -1,246 +1,246 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Flujos de Control" - ] - }, - { - "attachments": {}, - "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": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "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": [] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "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": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "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 a 0" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "7) Crear un ciclo for dentro de un ciclo while" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "8) Crear un ciclo while dentro de un ciclo for" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "9) Imprimir los números primos existentes entre 0 y 30" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "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": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "12) 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": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "14) 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": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.6" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Flujos de Control" + ] + }, + { + "attachments": {}, + "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": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "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": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "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": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "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 a 0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7) Crear un ciclo for dentro de un ciclo while" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Crear un ciclo while dentro de un ciclo for" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9) Imprimir los números primos existentes entre 0 y 30" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "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": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "12) 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": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) 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": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/M04_flujosdecontrol/Prep_Course_Homework_04.md b/M04_flujosdecontrol/Prep_Course_Homework_04.md index f64e3069c..43adf7c10 100644 --- a/M04_flujosdecontrol/Prep_Course_Homework_04.md +++ b/M04_flujosdecontrol/Prep_Course_Homework_04.md @@ -1,29 +1,29 @@ -## Flujos de Control - -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 - -2) Crear dos variables y un condicional que informe si son del mismo tipo de dato - -3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar - -4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3 - -5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos - -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 a 0 - -7) Crear un ciclo for dentro de un ciclo while - -8) Crear un ciclo while dentro de un ciclo for - -9) Imprimir los números primos existentes entre 0 y 30 - -10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin - -11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó? - -12) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300 - -13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente - -14) 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 +## Flujos de Control + +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 + +2) Crear dos variables y un condicional que informe si son del mismo tipo de dato + +3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar + +4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3 + +5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos + +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 a 0 + +7) Crear un ciclo for dentro de un ciclo while + +8) Crear un ciclo while dentro de un ciclo for + +9) Imprimir los números primos existentes entre 0 y 30 + +10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin + +11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó? + +12) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300 + +13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente + +14) 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 diff --git a/M04_flujosdecontrol/Prep_Course_Homework_04.py b/M04_flujosdecontrol/Prep_Course_Homework_04.py index 6a26d26df..ddaec8313 100644 --- a/M04_flujosdecontrol/Prep_Course_Homework_04.py +++ b/M04_flujosdecontrol/Prep_Course_Homework_04.py @@ -1,117 +1,117 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Flujos de Control - -# 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 - -# In[4]: - - - - - -# 2) Crear dos variables y un condicional que informe si son del mismo tipo de dato - -# In[5]: - - - - - -# 3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar - -# In[7]: - - - - - -# 4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3 - -# In[9]: - - - - - -# 5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos - -# In[10]: - - - - - -# 6) Utilizar un ciclo while para realizar el factoreo de un número guardado en una variable, sólo si la variable contiene un número entero mayor a 0 - -# In[33]: - - - - - -# 7) Crear un ciclo for dentro de un ciclo while - -# In[38]: - - - - - -# 8) Crear un ciclo while dentro de un ciclo for - -# In[3]: - - - - - -# 9) Imprimir los números primos existentes entre 0 y 30 - -# In[54]: - - - - -# 10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin - -# In[55]: - - - - - -# 11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó? - -# In[56]: - - - - -# In[57]: - - - - -# 12) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300 - -# In[62]: - - - - - -# 13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente - -# In[73]: - - - - -# 14) 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 - -# In[75]: - - - +#!/usr/bin/env python +# coding: utf-8 + +# ## Flujos de Control + +# 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 + +# In[4]: + + + + + +# 2) Crear dos variables y un condicional que informe si son del mismo tipo de dato + +# In[5]: + + + + + +# 3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar + +# In[7]: + + + + + +# 4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3 + +# In[9]: + + + + + +# 5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos + +# In[10]: + + + + + +# 6) Utilizar un ciclo while para realizar el factoreo de un número guardado en una variable, sólo si la variable contiene un número entero mayor a 0 + +# In[33]: + + + + + +# 7) Crear un ciclo for dentro de un ciclo while + +# In[38]: + + + + + +# 8) Crear un ciclo while dentro de un ciclo for + +# In[3]: + + + + + +# 9) Imprimir los números primos existentes entre 0 y 30 + +# In[54]: + + + + +# 10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin + +# In[55]: + + + + + +# 11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó? + +# In[56]: + + + + +# In[57]: + + + + +# 12) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300 + +# In[62]: + + + + + +# 13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente + +# In[73]: + + + + +# 14) 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 + +# In[75]: + + + diff --git a/M05_estructuradedatos/Prep_Course_Homework_05-Resuelto.ipynb b/M05_estructuradedatos/Prep_Course_Homework_05-Resuelto.ipynb index 754d5434d..414e4865a 100644 --- a/M05_estructuradedatos/Prep_Course_Homework_05-Resuelto.ipynb +++ b/M05_estructuradedatos/Prep_Course_Homework_05-Resuelto.ipynb @@ -1,738 +1,738 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Estructuras de Datos" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Buenos Aires', 'Brasilia', 'Asunción', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá']\n" - ] - } - ], - "source": [ - "lis = ['Buenos Aires','Brasilia','Asunción','Montevideo','Santiago','Lima','Caracas','Bogotá']\n", - "print(lis)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "2) Imprimir por pantalla el segundo elemento de la lista" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Brasilia\n" - ] - } - ], - "source": [ - "print(lis[1])" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "3) Imprimir por pantalla del segundo al cuarto elemento" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Brasilia', 'Asunción', 'Montevideo']\n" - ] - } - ], - "source": [ - "print(lis[1:4])" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "4) Visualizar el tipo de dato de la lista" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "print(type(lis))" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Asunción', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá']\n" - ] - } - ], - "source": [ - "print(lis[2:])" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "6) Visualizar los primeros 4 elementos de la lista" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Buenos Aires', 'Brasilia', 'Asunción', 'Montevideo']\n" - ] - } - ], - "source": [ - "print(lis[:4])\n", - " " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error?" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "lis.append('Ciudad de Méjico')" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "lis.append('Montevideo')" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Buenos Aires', 'Brasilia', 'Asunción', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo']\n" - ] - } - ], - "source": [ - "print(lis)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "8) Agregar otra ciudad, pero en la cuarta posición" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "lis.insert(3, 'Quito')" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Buenos Aires', 'Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo']\n" - ] - } - ], - "source": [ - "print(lis)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "9) Concatenar otra lista a la ya creada" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Buenos Aires', 'Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'Bruselas']\n" - ] - } - ], - "source": [ - "lis.extend(['Madrid','Roma','Bruselas'])\n", - "print(lis)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad?" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4\n" - ] - } - ], - "source": [ - "print(lis.index('Montevideo'))" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "11) ¿Qué pasa si se busca un elemento que no existe?" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "'París' is not in list", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[14], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(lis\u001b[39m.\u001b[39;49mindex(\u001b[39m'\u001b[39;49m\u001b[39mParís\u001b[39;49m\u001b[39m'\u001b[39;49m))\n", - "\u001b[1;31mValueError\u001b[0m: 'París' is not in list" - ] - } - ], - "source": [ - "print(lis.index('París'))" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "12) Eliminar un elemento de la lista" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "lis.remove('Buenos Aires')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'Bruselas']\n" - ] - } - ], - "source": [ - "print(lis)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "13) ¿Qué pasa si el elemento a eliminar no existe?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "list.remove(x): x not in list", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_2688/2377769693.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Buenos Aires'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mValueError\u001b[0m: list.remove(x): x not in list" - ] - } - ], - "source": [ - "lis.remove('Buenos Aires')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Bruselas\n" - ] - } - ], - "source": [ - "ultimo = lis.pop()\n", - "print(ultimo)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "15) Mostrar la lista multiplicada por 4" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma']\n" - ] - } - ], - "source": [ - "print(lis * 4)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "16) Crear una tupla que contenga los números enteros del 1 al 20" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)\n" - ] - } - ], - "source": [ - "tup = (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)\n", - "print(type(tup))\n", - "print(tup)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "17) Imprimir desde el índice 10 al 15 de la tupla" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(11, 12, 13, 14, 15, 16)\n" - ] - } - ], - "source": [ - "print(tup[10:16])" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "18) Evaluar si los números 20 y 30 están dentro de la tupla" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "True\n", - "False\n" - ] - } - ], - "source": [ - "print(20 in tup)\n", - "print(30 in tup)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "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." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Se insertó el elemento París\n" - ] - } - ], - "source": [ - "elemento = 'París'\n", - "if (not(elemento in lis)):\n", - " lis.append(elemento)\n", - " print('Se insertó el elemento', elemento)\n", - "else:\n", - " print('El elemento', elemento, 'ya existía')\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1\n", - "2\n" - ] - } - ], - "source": [ - "print(tup.count(10))\n", - "print(lis.count('Montevideo'))" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "21) Convertir la tupla en una lista" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n" - ] - } - ], - "source": [ - "lis2=list(tup)\n", - "print(lis2)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1\n", - "2\n", - "3\n" - ] - } - ], - "source": [ - "v1, v2, v3, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = tup\n", - "print(v1)\n", - "print(v2)\n", - "print(v3)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave \"ciudad\". Agregar tambien otras claves, como puede ser \"Pais\" y \"Continente\"." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "dicc = { 'Ciudad': lis, \n", - "'País': ['Brasil','Paraguay','Ecuador','Uruguay','Chile','Perú','Venezuela','Colombia','Méjico','Uruguay','España','Italia','Francia'], \n", - "'Continente' : ['América','América','América','América','América','América','América','América','América','América','Europa','Europa','Europa']}" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'Ciudad': ['Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'París'], 'País': ['Brasil', 'Paraguay', 'Ecuador', 'Uruguay', 'Chile', 'Perú', 'Venezuela', 'Colombia', 'Méjico', 'Uruguay', 'España', 'Italia', 'Francia'], 'Continente': ['América', 'América', 'América', 'América', 'América', 'América', 'América', 'América', 'América', 'América', 'Europa', 'Europa', 'Europa']}\n" - ] - } - ], - "source": [ - "print(dicc)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "24) Imprimir las claves del diccionario" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dict_keys(['Ciudad', 'País', 'Continente'])\n" - ] - } - ], - "source": [ - "print(dicc.keys())" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "25) Imprimir las ciudades a través de su clave" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'París']\n" - ] - } - ], - "source": [ - "print(dicc['Ciudad'])" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.6" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Estructuras de Datos" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Buenos Aires', 'Brasilia', 'Asunción', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá']\n" + ] + } + ], + "source": [ + "lis = ['Buenos Aires','Brasilia','Asunción','Montevideo','Santiago','Lima','Caracas','Bogotá']\n", + "print(lis)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) Imprimir por pantalla el segundo elemento de la lista" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Brasilia\n" + ] + } + ], + "source": [ + "print(lis[1])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Imprimir por pantalla del segundo al cuarto elemento" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Brasilia', 'Asunción', 'Montevideo']\n" + ] + } + ], + "source": [ + "print(lis[1:4])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) Visualizar el tipo de dato de la lista" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(lis))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Asunción', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá']\n" + ] + } + ], + "source": [ + "print(lis[2:])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) Visualizar los primeros 4 elementos de la lista" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Buenos Aires', 'Brasilia', 'Asunción', 'Montevideo']\n" + ] + } + ], + "source": [ + "print(lis[:4])\n", + " " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error?" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "lis.append('Ciudad de Méjico')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "lis.append('Montevideo')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Buenos Aires', 'Brasilia', 'Asunción', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo']\n" + ] + } + ], + "source": [ + "print(lis)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Agregar otra ciudad, pero en la cuarta posición" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "lis.insert(3, 'Quito')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Buenos Aires', 'Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo']\n" + ] + } + ], + "source": [ + "print(lis)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9) Concatenar otra lista a la ya creada" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Buenos Aires', 'Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'Bruselas']\n" + ] + } + ], + "source": [ + "lis.extend(['Madrid','Roma','Bruselas'])\n", + "print(lis)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad?" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + } + ], + "source": [ + "print(lis.index('Montevideo'))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11) ¿Qué pasa si se busca un elemento que no existe?" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "'París' is not in list", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[14], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(lis\u001b[39m.\u001b[39;49mindex(\u001b[39m'\u001b[39;49m\u001b[39mParís\u001b[39;49m\u001b[39m'\u001b[39;49m))\n", + "\u001b[1;31mValueError\u001b[0m: 'París' is not in list" + ] + } + ], + "source": [ + "print(lis.index('París'))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "12) Eliminar un elemento de la lista" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lis.remove('Buenos Aires')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'Bruselas']\n" + ] + } + ], + "source": [ + "print(lis)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13) ¿Qué pasa si el elemento a eliminar no existe?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "list.remove(x): x not in list", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_2688/2377769693.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Buenos Aires'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mValueError\u001b[0m: list.remove(x): x not in list" + ] + } + ], + "source": [ + "lis.remove('Buenos Aires')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bruselas\n" + ] + } + ], + "source": [ + "ultimo = lis.pop()\n", + "print(ultimo)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "15) Mostrar la lista multiplicada por 4" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma']\n" + ] + } + ], + "source": [ + "print(lis * 4)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "16) Crear una tupla que contenga los números enteros del 1 al 20" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)\n" + ] + } + ], + "source": [ + "tup = (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)\n", + "print(type(tup))\n", + "print(tup)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "17) Imprimir desde el índice 10 al 15 de la tupla" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(11, 12, 13, 14, 15, 16)\n" + ] + } + ], + "source": [ + "print(tup[10:16])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "18) Evaluar si los números 20 y 30 están dentro de la tupla" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "print(20 in tup)\n", + "print(30 in tup)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "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." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Se insertó el elemento París\n" + ] + } + ], + "source": [ + "elemento = 'París'\n", + "if (not(elemento in lis)):\n", + " lis.append(elemento)\n", + " print('Se insertó el elemento', elemento)\n", + "else:\n", + " print('El elemento', elemento, 'ya existía')\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n" + ] + } + ], + "source": [ + "print(tup.count(10))\n", + "print(lis.count('Montevideo'))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "21) Convertir la tupla en una lista" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n" + ] + } + ], + "source": [ + "lis2=list(tup)\n", + "print(lis2)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n" + ] + } + ], + "source": [ + "v1, v2, v3, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = tup\n", + "print(v1)\n", + "print(v2)\n", + "print(v3)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave \"ciudad\". Agregar tambien otras claves, como puede ser \"Pais\" y \"Continente\"." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dicc = { 'Ciudad': lis, \n", + "'País': ['Brasil','Paraguay','Ecuador','Uruguay','Chile','Perú','Venezuela','Colombia','Méjico','Uruguay','España','Italia','Francia'], \n", + "'Continente' : ['América','América','América','América','América','América','América','América','América','América','Europa','Europa','Europa']}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Ciudad': ['Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'París'], 'País': ['Brasil', 'Paraguay', 'Ecuador', 'Uruguay', 'Chile', 'Perú', 'Venezuela', 'Colombia', 'Méjico', 'Uruguay', 'España', 'Italia', 'Francia'], 'Continente': ['América', 'América', 'América', 'América', 'América', 'América', 'América', 'América', 'América', 'América', 'Europa', 'Europa', 'Europa']}\n" + ] + } + ], + "source": [ + "print(dicc)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "24) Imprimir las claves del diccionario" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['Ciudad', 'País', 'Continente'])\n" + ] + } + ], + "source": [ + "print(dicc.keys())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "25) Imprimir las ciudades a través de su clave" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Brasilia', 'Asunción', 'Quito', 'Montevideo', 'Santiago', 'Lima', 'Caracas', 'Bogotá', 'Ciudad de Méjico', 'Montevideo', 'Madrid', 'Roma', 'París']\n" + ] + } + ], + "source": [ + "print(dicc['Ciudad'])" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/M05_estructuradedatos/Prep_Course_Homework_05-Resuelto.py b/M05_estructuradedatos/Prep_Course_Homework_05-Resuelto.py index f8960094b..3e146de21 100644 --- a/M05_estructuradedatos/Prep_Course_Homework_05-Resuelto.py +++ b/M05_estructuradedatos/Prep_Course_Homework_05-Resuelto.py @@ -1,253 +1,253 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Estructuras de Datos - -# 1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla - -# In[3]: - - -lis = ['Buenos Aires','Brasilia','Asunción','Montevideo','Santiago','Lima','Caracas','Bogotá'] -print(lis) - - -# 2) Imprimir por pantalla el segundo elemento de la lista - -# In[4]: - - -print(lis[1]) - - -# 3) Imprimir por pantalla del segundo al cuarto elemento - -# In[8]: - - -print(lis[1:4]) - - -# 4) Visualizar el tipo de dato de la lista - -# In[12]: - - -print(type(lis)) - - -# 5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento - -# In[14]: - - -print(lis[2:]) - - -# 6) Visualizar los primeros 4 elementos de la lista - -# In[15]: - - -print(lis[:4]) - - - -# 7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error? - -# In[16]: - - -lis.append('Ciudad de Méjico') - - -# In[17]: - - -lis.append('Montevideo') - - -# In[18]: - - -print(lis) - - -# 8) Agregar otra ciudad, pero en la cuarta posición - -# In[20]: - - -lis.insert(3, 'Quito') - - -# In[21]: - - -print(lis) - - -# 9) Concatenar otra lista a la ya creada - -# In[22]: - - -lis.extend(['Madrid','Roma','Bruselas']) -print(lis) - - -# 10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad? - -# In[23]: - - -print(lis.index('Montevideo')) - - -# 11) ¿Qué pasa si se busca un elemento que no existe? - -# In[24]: - - -print(lis.index('París')) - - -# 12) Eliminar un elemento de la lista - -# In[25]: - - -lis.remove('Buenos Aires') - - -# In[26]: - - -print(lis) - - -# 13) ¿Qué pasa si el elemento a eliminar no existe? - -# In[27]: - - -lis.remove('Buenos Aires') - - -# 14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo - -# In[28]: - - -ultimo = lis.pop() -print(ultimo) - - -# 15) Mostrar la lista multiplicada por 4 - -# In[29]: - - -print(lis * 4) - - -# 16) Crear una tupla que contenga los números enteros del 1 al 20 - -# In[32]: - - -tup = (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20) -print(type(tup)) -print(tup) - - -# 17) Imprimir desde el índice 10 al 15 de la tupla - -# In[35]: - - -print(tup[10:16]) - - -# 18) Evaluar si los números 20 y 30 están dentro de la tupla - -# In[41]: - - -print(20 in tup) -print(30 in tup) - - -# 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. - -# In[48]: - - -elemento = 'París' -if (not(elemento in lis)): - lis.append(elemento) - print('Se insertó el elemento', elemento) -else: - print('El elemento', elemento, 'ya existía') - - -# 20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista - -# In[51]: - - -print(tup.count(10)) -print(lis.count('Montevideo')) - - -# 21) Convertir la tupla en una lista - -# In[52]: - - -lis2=list(tup) -print(lis2) - - -# 22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables - -# In[55]: - - -v1, v2, v3, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = tup -print(v1) -print(v2) -print(v3) - - -# 23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave "ciudad". Agregar tambien otras claves, como puede ser "Pais" y "Continente". - -# In[57]: - - -dicc = { 'Ciudad': lis, -'País': ['Brasil','Paraguay','Ecuador','Uruguay','Chile','Perú','Venezuela','Colombia','Méjico','Uruguay','España','Italia','Francia'], -'Continente' : ['América','América','América','América','América','América','América','América','América','América','Europa','Europa','Europa']} - - -# In[58]: - - -print(dicc) - - -# 24) Imprimir las claves del diccionario - -# In[59]: - - -print(dicc.keys()) - - -# 25) Imprimir las ciudades a través de su clave - -# In[61]: - - -print(dicc['Ciudad']) - +#!/usr/bin/env python +# coding: utf-8 + +# ## Estructuras de Datos + +# 1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla + +# In[3]: + + +lis = ['Buenos Aires','Brasilia','Asunción','Montevideo','Santiago','Lima','Caracas','Bogotá'] +print(lis) + + +# 2) Imprimir por pantalla el segundo elemento de la lista + +# In[4]: + + +print(lis[1]) + + +# 3) Imprimir por pantalla del segundo al cuarto elemento + +# In[8]: + + +print(lis[1:4]) + + +# 4) Visualizar el tipo de dato de la lista + +# In[12]: + + +print(type(lis)) + + +# 5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento + +# In[14]: + + +print(lis[2:]) + + +# 6) Visualizar los primeros 4 elementos de la lista + +# In[15]: + + +print(lis[:4]) + + + +# 7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error? + +# In[16]: + + +lis.append('Ciudad de Méjico') + + +# In[17]: + + +lis.append('Montevideo') + + +# In[18]: + + +print(lis) + + +# 8) Agregar otra ciudad, pero en la cuarta posición + +# In[20]: + + +lis.insert(3, 'Quito') + + +# In[21]: + + +print(lis) + + +# 9) Concatenar otra lista a la ya creada + +# In[22]: + + +lis.extend(['Madrid','Roma','Bruselas']) +print(lis) + + +# 10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad? + +# In[23]: + + +print(lis.index('Montevideo')) + + +# 11) ¿Qué pasa si se busca un elemento que no existe? + +# In[24]: + + +print(lis.index('París')) + + +# 12) Eliminar un elemento de la lista + +# In[25]: + + +lis.remove('Buenos Aires') + + +# In[26]: + + +print(lis) + + +# 13) ¿Qué pasa si el elemento a eliminar no existe? + +# In[27]: + + +lis.remove('Buenos Aires') + + +# 14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo + +# In[28]: + + +ultimo = lis.pop() +print(ultimo) + + +# 15) Mostrar la lista multiplicada por 4 + +# In[29]: + + +print(lis * 4) + + +# 16) Crear una tupla que contenga los números enteros del 1 al 20 + +# In[32]: + + +tup = (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20) +print(type(tup)) +print(tup) + + +# 17) Imprimir desde el índice 10 al 15 de la tupla + +# In[35]: + + +print(tup[10:16]) + + +# 18) Evaluar si los números 20 y 30 están dentro de la tupla + +# In[41]: + + +print(20 in tup) +print(30 in tup) + + +# 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. + +# In[48]: + + +elemento = 'París' +if (not(elemento in lis)): + lis.append(elemento) + print('Se insertó el elemento', elemento) +else: + print('El elemento', elemento, 'ya existía') + + +# 20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista + +# In[51]: + + +print(tup.count(10)) +print(lis.count('Montevideo')) + + +# 21) Convertir la tupla en una lista + +# In[52]: + + +lis2=list(tup) +print(lis2) + + +# 22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables + +# In[55]: + + +v1, v2, v3, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = tup +print(v1) +print(v2) +print(v3) + + +# 23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave "ciudad". Agregar tambien otras claves, como puede ser "Pais" y "Continente". + +# In[57]: + + +dicc = { 'Ciudad': lis, +'País': ['Brasil','Paraguay','Ecuador','Uruguay','Chile','Perú','Venezuela','Colombia','Méjico','Uruguay','España','Italia','Francia'], +'Continente' : ['América','América','América','América','América','América','América','América','América','América','Europa','Europa','Europa']} + + +# In[58]: + + +print(dicc) + + +# 24) Imprimir las claves del diccionario + +# In[59]: + + +print(dicc.keys()) + + +# 25) Imprimir las ciudades a través de su clave + +# In[61]: + + +print(dicc['Ciudad']) + diff --git a/M05_estructuradedatos/Prep_Course_Homework_05.ipynb b/M05_estructuradedatos/Prep_Course_Homework_05.ipynb index c71642967..de771bb95 100644 --- a/M05_estructuradedatos/Prep_Course_Homework_05.ipynb +++ b/M05_estructuradedatos/Prep_Course_Homework_05.ipynb @@ -18,10 +18,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['CDMX', 'Roma', 'Amsterdan', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona']\n" + ] + } + ], + "source": [ + "ListaCiudades = [\"CDMX\",\"Roma\",\"Amsterdan\",\"Berlin\",\"Nueva York\",\"Madrid\",\"Barcelona\"]\n", + "print(ListaCiudades)" + ] }, { "attachments": {}, @@ -33,10 +44,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Roma\n" + ] + } + ], + "source": [ + "print(ListaCiudades[1])" + ] }, { "attachments": {}, @@ -48,10 +69,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Roma', 'Amsterdan', 'Berlin']\n" + ] + } + ], + "source": [ + "print(ListaCiudades[1:4])" + ] }, { "attachments": {}, @@ -63,10 +94,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(ListaCiudades))" + ] }, { "attachments": {}, @@ -78,10 +119,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Amsterdan', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona']\n" + ] + } + ], + "source": [ + "print(ListaCiudades[2:])" + ] }, { "attachments": {}, @@ -93,10 +144,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['CDMX', 'Roma', 'Amsterdan', 'Berlin']\n" + ] + } + ], + "source": [ + "print(ListaCiudades[0:4])" + ] }, { "attachments": {}, @@ -108,10 +169,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "ListaCiudades.append(\"CDMX\")\n", + "ListaCiudades.append(\"Ottawa\")" + ] }, { "attachments": {}, @@ -123,10 +187,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "ListaCiudades.insert(3,\"Guadalajara\")" + ] }, { "attachments": {}, @@ -138,10 +204,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['CDMX', 'Roma', 'Amsterdan', 'Guadalajara', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona', 'CDMX', 'Ottawa', 'Washington', 'Ontario', 'Las Vegas']\n" + ] + } + ], + "source": [ + "NuevaLista = [\"Washington\",\"Ontario\",\"Las Vegas\"]\n", + "ListaCiudades = ListaCiudades + NuevaLista\n", + "print(ListaCiudades)" + ] }, { "attachments": {}, @@ -153,10 +231,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + } + ], + "source": [ + "print(ListaCiudades.index(\"CDMX\"))" + ] }, { "attachments": {}, @@ -168,10 +256,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "'Monterrey' is not in list", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[19], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(ListaCiudades\u001b[39m.\u001b[39;49mindex(\u001b[39m\"\u001b[39;49m\u001b[39mMonterrey\u001b[39;49m\u001b[39m\"\u001b[39;49m))\n", + "\u001b[1;31mValueError\u001b[0m: 'Monterrey' is not in list" + ] + } + ], + "source": [ + "print(ListaCiudades.index(\"Monterrey\"))" + ] }, { "attachments": {}, @@ -183,10 +285,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "list.remove(x): x not in list", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[21], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m ListaCiudades\u001b[39m.\u001b[39;49mremove(\u001b[39m\"\u001b[39;49m\u001b[39mOttawa\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(ListaCiudades)\n", + "\u001b[1;31mValueError\u001b[0m: list.remove(x): x not in list" + ] + } + ], + "source": [ + "ListaCiudades.remove(\"Ottawa\")\n", + "print(ListaCiudades)" + ] }, { "attachments": {}, @@ -198,10 +315,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "list.remove(x): x not in list", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[22], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m ListaCiudades\u001b[39m.\u001b[39;49mremove(\u001b[39m\"\u001b[39;49m\u001b[39mOttawa\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(ListaCiudades)\n", + "\u001b[1;31mValueError\u001b[0m: list.remove(x): x not in list" + ] + } + ], + "source": [ + "ListaCiudades.remove(\"Ottawa\")\n", + "print(ListaCiudades)" + ] }, { "attachments": {}, @@ -213,10 +345,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['CDMX', 'Roma', 'Amsterdan', 'Guadalajara', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona', 'CDMX', 'Washington', 'Ontario']\n", + "Las Vegas\n" + ] + } + ], + "source": [ + "UltimoValor = ListaCiudades.pop()\n", + "print(ListaCiudades)\n", + "print(UltimoValor)" + ] }, { "attachments": {}, @@ -228,10 +373,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['CDMX', 'Roma', 'Amsterdan', 'Guadalajara', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona', 'CDMX', 'Washington', 'Ontario', 'CDMX', 'Roma', 'Amsterdan', 'Guadalajara', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona', 'CDMX', 'Washington', 'Ontario', 'CDMX', 'Roma', 'Amsterdan', 'Guadalajara', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona', 'CDMX', 'Washington', 'Ontario', 'CDMX', 'Roma', 'Amsterdan', 'Guadalajara', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona', 'CDMX', 'Washington', 'Ontario']\n" + ] + } + ], + "source": [ + "print(ListaCiudades*4)" + ] }, { "attachments": {}, @@ -243,10 +398,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)\n" + ] + } + ], + "source": [ + "La_Tupla = (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)\n", + "print(La_Tupla)" + ] }, { "attachments": {}, @@ -258,10 +424,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(11, 12, 13, 14, 15, 16)\n" + ] + } + ], + "source": [ + "print(La_Tupla[10:16])" + ] }, { "attachments": {}, @@ -273,10 +449,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "print(20 in La_Tupla)\n", + "print(30 in La_Tupla)" + ] }, { "attachments": {}, @@ -288,10 +476,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La ciudad ya existia\n", + "['CDMX', 'Roma', 'Amsterdan', 'Guadalajara', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona', 'CDMX', 'Washington', 'Ontario', 'Paris']\n" + ] + } + ], + "source": [ + "Variable = \"Paris\"\n", + "if(not(Variable in ListaCiudades)):\n", + " print(\"Se agrega la ciudad\")\n", + " ListaCiudades.append(\"Paris\")\n", + "else:\n", + " print(\"La ciudad ya existia\")\n", + "print(ListaCiudades)" + ] }, { "attachments": {}, @@ -303,10 +508,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "1\n" + ] + } + ], + "source": [ + "print(ListaCiudades.count(\"CDMX\"))\n", + "print(La_Tupla.count(3))" + ] }, { "attachments": {}, @@ -318,10 +535,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n" + ] + } + ], + "source": [ + "NuevaLista = list(La_Tupla)\n", + "print(type(NuevaLista))\n", + "print(NuevaLista)" + ] }, { "attachments": {}, @@ -336,7 +566,12 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "Valor_1, Valor_2, Valor_3,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_, = La_Tupla\n", + "print(Valor_1)\n", + "print(Valor_2)\n", + "print(Valor_3)" + ] }, { "attachments": {}, @@ -348,10 +583,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Ciudad': ['CDMX', 'Roma', 'Amsterdan', 'Guadalajara', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona', 'CDMX', 'Washington', 'Ontario', 'Paris'], 'Pais': ['Mexico', 'USA', 'Italia'], 'Continente': 'America'}\n" + ] + } + ], + "source": [ + "Diccionario = {\"Ciudad\": ListaCiudades, \"Pais\":[\"Mexico\",\"USA\",\"Italia\"], \"Continente\": \"America\"}\n", + "type(Diccionario)\n", + "print(Diccionario)" + ] }, { "attachments": {}, @@ -363,10 +610,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['Ciudad', 'Pais', 'Continente'])\n" + ] + } + ], + "source": [ + "print(Diccionario.keys())" + ] }, { "attachments": {}, @@ -378,10 +635,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['CDMX', 'Roma', 'Amsterdan', 'Guadalajara', 'Berlin', 'Nueva York', 'Madrid', 'Barcelona', 'CDMX', 'Washington', 'Ontario', 'Paris']\n" + ] + } + ], + "source": [ + "print(Diccionario[\"Ciudad\"])" + ] } ], "metadata": { @@ -403,7 +670,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/M05_estructuradedatos/Prep_Course_Homework_05.md b/M05_estructuradedatos/Prep_Course_Homework_05.md index 3a08d2ab4..35acbf2bb 100644 --- a/M05_estructuradedatos/Prep_Course_Homework_05.md +++ b/M05_estructuradedatos/Prep_Course_Homework_05.md @@ -1,51 +1,51 @@ -## Estructuras de Datos - -1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla - -2) Imprimir por pantalla el segundo elemento de la lista - -3) Imprimir por pantalla del segundo al cuarto elemento - -4) Visualizar el tipo de dato de la lista - -5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento - -6) Visualizar los primeros 4 elementos de la lista - -7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error? - -8) Agregar otra ciudad, pero en la cuarta posición - -9) Concatenar otra lista a la ya creada - -10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad? - -11) ¿Qué pasa si se busca un elemento que no existe? - -12) Eliminar un elemento de la lista - -13) ¿Qué pasa si el elemento a eliminar no existe? - -14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo - -15) Mostrar la lista multiplicada por 4 - -16) Crear una tupla que contenga los números enteros del 1 al 20 - -17) Imprimir desde el índice 10 al 15 de la tupla - -18) Evaluar si los números 20 y 30 están dentro de la tupla - -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. - -20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista - -21) Convertir la tupla en una lista - -22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables - -23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave "ciudad". Agregar tambien otras claves, como puede ser "Pais" y "Continente". - -24) Imprimir las claves del diccionario - -25) Imprimir las ciudades a través de su clave +## Estructuras de Datos + +1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla + +2) Imprimir por pantalla el segundo elemento de la lista + +3) Imprimir por pantalla del segundo al cuarto elemento + +4) Visualizar el tipo de dato de la lista + +5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento + +6) Visualizar los primeros 4 elementos de la lista + +7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error? + +8) Agregar otra ciudad, pero en la cuarta posición + +9) Concatenar otra lista a la ya creada + +10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad? + +11) ¿Qué pasa si se busca un elemento que no existe? + +12) Eliminar un elemento de la lista + +13) ¿Qué pasa si el elemento a eliminar no existe? + +14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo + +15) Mostrar la lista multiplicada por 4 + +16) Crear una tupla que contenga los números enteros del 1 al 20 + +17) Imprimir desde el índice 10 al 15 de la tupla + +18) Evaluar si los números 20 y 30 están dentro de la tupla + +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. + +20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista + +21) Convertir la tupla en una lista + +22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables + +23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave "ciudad". Agregar tambien otras claves, como puede ser "Pais" y "Continente". + +24) Imprimir las claves del diccionario + +25) Imprimir las ciudades a través de su clave diff --git a/M05_estructuradedatos/Prep_Course_Homework_05.py b/M05_estructuradedatos/Prep_Course_Homework_05.py index 1d39ac89e..ad1653738 100644 --- a/M05_estructuradedatos/Prep_Course_Homework_05.py +++ b/M05_estructuradedatos/Prep_Course_Homework_05.py @@ -1,208 +1,208 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Estructuras de Datos - -# 1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla - -# In[3]: - - - - -# 2) Imprimir por pantalla el segundo elemento de la lista - -# In[4]: - - - - -# 3) Imprimir por pantalla del segundo al cuarto elemento - -# In[8]: - - - - - -# 4) Visualizar el tipo de dato de la lista - -# In[12]: - - - - - -# 5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento - -# In[14]: - - - - - -# 6) Visualizar los primeros 4 elementos de la lista - -# In[15]: - - - - - - -# 7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error? - -# In[16]: - - - - - - - - - -# 8) Agregar otra ciudad, pero en la cuarta posición - -# In[20]: - - - - - -# In[21]: - - - - -# 9) Concatenar otra lista a la ya creada - -# In[22]: - - - - -# 10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad? - -# In[23]: - - - - - -# 11) ¿Qué pasa si se busca un elemento que no existe? - -# In[24]: - - - - - -# 12) Eliminar un elemento de la lista - -# In[25]: - - - - - -# 13) ¿Qué pasa si el elemento a eliminar no existe? - -# In[27]: - - - - - -# 14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo - -# In[28]: - - - - - -# 15) Mostrar la lista multiplicada por 4 - -# In[29]: - - - - -# 16) Crear una tupla que contenga los números enteros del 1 al 20 - -# In[32]: - - - - -# 17) Imprimir desde el índice 10 al 15 de la tupla - -# In[35]: - - - - -# 18) Evaluar si los números 20 y 30 están dentro de la tupla - -# In[41]: - - - - - -# 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. - -# In[48]: - - - - - -# 20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista - -# In[51]: - - - - - -# 21) Convertir la tupla en una lista - -# In[52]: - - - - - -# 22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables - -# In[55]: - - - - - -# 23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave "ciudad". Agregar tambien otras claves, como puede ser "Pais" y "Continente". - -# In[57]: - - - - - - -# 24) Imprimir las claves del diccionario - -# In[59]: - - - - -# 25) Imprimir las ciudades a través de su clave - -# In[61]: - - - - +#!/usr/bin/env python +# coding: utf-8 + +# ## Estructuras de Datos + +# 1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla + +# In[3]: + + + + +# 2) Imprimir por pantalla el segundo elemento de la lista + +# In[4]: + + + + +# 3) Imprimir por pantalla del segundo al cuarto elemento + +# In[8]: + + + + + +# 4) Visualizar el tipo de dato de la lista + +# In[12]: + + + + + +# 5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento + +# In[14]: + + + + + +# 6) Visualizar los primeros 4 elementos de la lista + +# In[15]: + + + + + + +# 7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error? + +# In[16]: + + + + + + + + + +# 8) Agregar otra ciudad, pero en la cuarta posición + +# In[20]: + + + + + +# In[21]: + + + + +# 9) Concatenar otra lista a la ya creada + +# In[22]: + + + + +# 10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad? + +# In[23]: + + + + + +# 11) ¿Qué pasa si se busca un elemento que no existe? + +# In[24]: + + + + + +# 12) Eliminar un elemento de la lista + +# In[25]: + + + + + +# 13) ¿Qué pasa si el elemento a eliminar no existe? + +# In[27]: + + + + + +# 14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo + +# In[28]: + + + + + +# 15) Mostrar la lista multiplicada por 4 + +# In[29]: + + + + +# 16) Crear una tupla que contenga los números enteros del 1 al 20 + +# In[32]: + + + + +# 17) Imprimir desde el índice 10 al 15 de la tupla + +# In[35]: + + + + +# 18) Evaluar si los números 20 y 30 están dentro de la tupla + +# In[41]: + + + + + +# 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. + +# In[48]: + + + + + +# 20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista + +# In[51]: + + + + + +# 21) Convertir la tupla en una lista + +# In[52]: + + + + + +# 22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables + +# In[55]: + + + + + +# 23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave "ciudad". Agregar tambien otras claves, como puede ser "Pais" y "Continente". + +# In[57]: + + + + + + +# 24) Imprimir las claves del diccionario + +# In[59]: + + + + +# 25) Imprimir las ciudades a través de su clave + +# In[61]: + + + + diff --git a/M06_iterablesiteradores/Prep_Course_Homework_06-Resuelto.ipynb b/M06_iterablesiteradores/Prep_Course_Homework_06-Resuelto.ipynb index 955bb1fa2..0784f5fd9 100644 --- a/M06_iterablesiteradores/Prep_Course_Homework_06-Resuelto.ipynb +++ b/M06_iterablesiteradores/Prep_Course_Homework_06-Resuelto.ipynb @@ -234,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -267,7 +267,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -276,7 +276,7 @@ "1346268" ] }, - "execution_count": 24, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -303,18 +303,18 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1.6176470588235294\n", - "1.6181818181818182\n", - "1.6179775280898876\n", - "1.6180555555555556\n", - "1.6180257510729614\n" + "El valor n es: 10 y el resultado: 1.6176470588235294\n", + "El valor n es: 11 y el resultado: 1.6181818181818182\n", + "El valor n es: 12 y el resultado: 1.6179775280898876\n", + "El valor n es: 13 y el resultado: 1.6180555555555556\n", + "El valor n es: 14 y el resultado: 1.6180257510729614\n" ] } ], @@ -323,7 +323,7 @@ "n = primeros - 5 # Valor inicial de n\n", "\n", "while n < primeros: # Mientras n sea menor que el número de elementos a imprimir, se ejecuta el bucle\n", - " print(fibo[n] / fibo[n - 1]) # Imprime el resultado de la división de dos elementos consecutivos de la lista fibo\n", + " print(\"El valor n es: \", n , \"y el resultado: \" ,fibo[n] / fibo[n - 1]) # Imprime el resultado de la división de dos elementos consecutivos de la lista fibo\n", " n += 1 # Incrementa el valor de n en 1 en cada iteración" ] }, @@ -405,7 +405,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -684,7 +684,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/M06_iterablesiteradores/Prep_Course_Homework_06-Resuelto.py b/M06_iterablesiteradores/Prep_Course_Homework_06-Resuelto.py index ceb911aa4..b03642ca8 100644 --- a/M06_iterablesiteradores/Prep_Course_Homework_06-Resuelto.py +++ b/M06_iterablesiteradores/Prep_Course_Homework_06-Resuelto.py @@ -1,225 +1,225 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Iteradores e iterables - -# 1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1 - -# In[1]: - - -lista = [] -n = -15 -while (n < 0): - lista.append(n) - n += 1 -print(lista) - - -# 2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares? - -# In[3]: - - -n = 0 -while (n < len(lista)): - if (lista[n] % 2 == 0): - print(lista[n]) - n += 1 - - -# 3) Resolver el punto anterior sin utilizar un ciclo while - -# In[4]: - - -for elemento in lista: - if (elemento % 2 == 0): - print(elemento) - - -# 4) Utilizar el iterable para recorrer sólo los primeros 3 elementos - -# In[7]: - - -for elemento in lista[:3]: - print(elemento) - - -# 5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento - -# In[9]: - - -for i, e in enumerate(lista): - print(i, e) - - -# 6) Dada la siguiente lista de números enteros entre 1 y 20, crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20] - -# In[10]: - - -lista = [1,2,5,7,8,10,13,14,15,17,20] - - -# In[11]: - - -n = 1 -while(n <= 20): - if (not(n in lista)): - lista.insert((n-1), n) - n += 1 -print(lista) - - -# 7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
-# n0 = 0
-# n1 = 1
-# ni = ni-1 + ni-2
-# Crear una lista con los primeros treinta números de la sucesión.
- -# In[23]: - - -fibo = [0,1] -n = 2 -while(n < 30): - fibo.append(fibo[n-1]+fibo[n-2]) - n += 1 -print(fibo) - - -# 8) Realizar la suma de todos elementos de la lista del punto anterior - -# In[24]: - - -sum(fibo) - - -# 9) La proporción aurea se expresa con una proporción matemática que nace el número irracional Phi= 1,618… que los griegos llamaron número áureo. El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, imprimir el cociente de los últimos 5 pares de dos números contiguos:
-# Donde i es la cantidad total de elementos
-# ni-1 / ni
-# ni-2 / ni-1
-# ni-3 / ni-2
-# ni-4 / ni-3
-# ni-5 / ni-4
-# - -# In[38]: - - -primeros = 15 -n = primeros - 5 -while(n < primeros): - print(fibo[n]/fibo[n-1]) - n += 1 - - -# 10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra "n"
-# cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' - -# In[39]: - - -cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' -for i, c in enumerate(cadena): - if c == 'n': - print(i) - - -# 11) Crear un diccionario e imprimir sus claves utilizando un iterador - -# In[40]: - - -dicc = { 'Ciudad': ['Buenos Aires','Caracas','Bogotá','Lisboa','Roma'], -'País': ['Argentina','Venezuela','Colombia','Portugal','Italia'], -'Continente' : ['América','América','América','Europa','Europa']} -for i in dicc: - print(i) - - -# 12) Convertir en una lista la variable "cadena" del punto 10 y luego recorrerla con un iterador - -# In[41]: - - -cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' -print(type(cadena)) -cadena = list(cadena) -print(type(cadena)) - - -# In[45]: - - -recorre = iter(cadena) -largo = len(cadena) -for i in range(0, largo): - print(next(recorre)) - - -# 13) Crear dos listas y unirlas en una tupla utilizando la función zip - -# In[48]: - - -lis1 = ['run','fly','sleep'] -lis2 = ['correr','volar','dormir'] -lisz = zip(lis1, lis2) -print(type(lisz)) -print(list(lisz)) - - -# 14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
-# lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] - -# In[49]: - - -lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] -lis2 = [i for i in lis if i % 7 == 0] -print(lis2) - - -# 15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene, teniendo en cuenta que un elemento de la lista podría ser otra lista:
-# lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] - -# In[56]: - - -lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] - - -# In[51]: - - -type(lis) - - -# In[57]: - - -cantidad = 0 -for elemento in lis: - if (type(elemento) == list): - cantidad += len(elemento) - else: - cantidad += 1 -print('La cantidad total de elementos es', cantidad) - - -# 16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es - -# In[58]: - - -for indice, elemento in enumerate(lis): - if (type(elemento) != list): - lis[indice]=[elemento] -print(lis) - +#!/usr/bin/env python +# coding: utf-8 + +# ## Iteradores e iterables + +# 1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1 + +# In[1]: + + +lista = [] +n = -15 +while (n < 0): + lista.append(n) + n += 1 +print(lista) + + +# 2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares? + +# In[3]: + + +n = 0 +while (n < len(lista)): + if (lista[n] % 2 == 0): + print(lista[n]) + n += 1 + + +# 3) Resolver el punto anterior sin utilizar un ciclo while + +# In[4]: + + +for elemento in lista: + if (elemento % 2 == 0): + print(elemento) + + +# 4) Utilizar el iterable para recorrer sólo los primeros 3 elementos + +# In[7]: + + +for elemento in lista[:3]: + print(elemento) + + +# 5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento + +# In[9]: + + +for i, e in enumerate(lista): + print(i, e) + + +# 6) Dada la siguiente lista de números enteros entre 1 y 20, crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20] + +# In[10]: + + +lista = [1,2,5,7,8,10,13,14,15,17,20] + + +# In[11]: + + +n = 1 +while(n <= 20): + if (not(n in lista)): + lista.insert((n-1), n) + n += 1 +print(lista) + + +# 7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
+# n0 = 0
+# n1 = 1
+# ni = ni-1 + ni-2
+# Crear una lista con los primeros treinta números de la sucesión.
+ +# In[23]: + + +fibo = [0,1] +n = 2 +while(n < 30): + fibo.append(fibo[n-1]+fibo[n-2]) + n += 1 +print(fibo) + + +# 8) Realizar la suma de todos elementos de la lista del punto anterior + +# In[24]: + + +sum(fibo) + + +# 9) La proporción aurea se expresa con una proporción matemática que nace el número irracional Phi= 1,618… que los griegos llamaron número áureo. El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, imprimir el cociente de los últimos 5 pares de dos números contiguos:
+# Donde i es la cantidad total de elementos
+# ni-1 / ni
+# ni-2 / ni-1
+# ni-3 / ni-2
+# ni-4 / ni-3
+# ni-5 / ni-4
+# + +# In[38]: + + +primeros = 15 +n = primeros - 5 +while(n < primeros): + print(fibo[n]/fibo[n-1]) + n += 1 + + +# 10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra "n"
+# cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' + +# In[39]: + + +cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' +for i, c in enumerate(cadena): + if c == 'n': + print(i) + + +# 11) Crear un diccionario e imprimir sus claves utilizando un iterador + +# In[40]: + + +dicc = { 'Ciudad': ['Buenos Aires','Caracas','Bogotá','Lisboa','Roma'], +'País': ['Argentina','Venezuela','Colombia','Portugal','Italia'], +'Continente' : ['América','América','América','Europa','Europa']} +for i in dicc: + print(i) + + +# 12) Convertir en una lista la variable "cadena" del punto 10 y luego recorrerla con un iterador + +# In[41]: + + +cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' +print(type(cadena)) +cadena = list(cadena) +print(type(cadena)) + + +# In[45]: + + +recorre = iter(cadena) +largo = len(cadena) +for i in range(0, largo): + print(next(recorre)) + + +# 13) Crear dos listas y unirlas en una tupla utilizando la función zip + +# In[48]: + + +lis1 = ['run','fly','sleep'] +lis2 = ['correr','volar','dormir'] +lisz = zip(lis1, lis2) +print(type(lisz)) +print(list(lisz)) + + +# 14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
+# lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] + +# In[49]: + + +lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] +lis2 = [i for i in lis if i % 7 == 0] +print(lis2) + + +# 15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene, teniendo en cuenta que un elemento de la lista podría ser otra lista:
+# lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] + +# In[56]: + + +lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] + + +# In[51]: + + +type(lis) + + +# In[57]: + + +cantidad = 0 +for elemento in lis: + if (type(elemento) == list): + cantidad += len(elemento) + else: + cantidad += 1 +print('La cantidad total de elementos es', cantidad) + + +# 16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es + +# In[58]: + + +for indice, elemento in enumerate(lis): + if (type(elemento) != list): + lis[indice]=[elemento] +print(lis) + diff --git a/M06_iterablesiteradores/Prep_Course_Homework_06.ipynb b/M06_iterablesiteradores/Prep_Course_Homework_06.ipynb index 75d6c18b1..c2b842f97 100644 --- a/M06_iterablesiteradores/Prep_Course_Homework_06.ipynb +++ b/M06_iterablesiteradores/Prep_Course_Homework_06.ipynb @@ -18,10 +18,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[]\n", + "[-15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1]\n" + ] + } + ], + "source": [ + "Lista = []\n", + "print(Lista)\n", + "i = -15 \n", + "while i < 0:\n", + " Lista.append(i)\n", + " i+=1\n", + "print(Lista)" + ] }, { "attachments": {}, @@ -33,10 +50,30 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El número: -2 es par.\n", + "El número: -4 es par.\n", + "El número: -6 es par.\n", + "El número: -8 es par.\n", + "El número: -10 es par.\n", + "El número: -12 es par.\n", + "El número: -14 es par.\n" + ] + } + ], + "source": [ + "i = len(Lista)\n", + "while i-1 >= 0:\n", + " if(Lista[i-1]%2 == 0):\n", + " print(\"El número: \", Lista[i-1], \" es par.\")\n", + " i-=1" + ] }, { "attachments": {}, @@ -48,10 +85,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El número: -14 es par.\n", + "El número: -12 es par.\n", + "El número: -10 es par.\n", + "El número: -8 es par.\n", + "El número: -6 es par.\n", + "El número: -4 es par.\n", + "El número: -2 es par.\n" + ] + } + ], + "source": [ + "for elemento in Lista:\n", + " if(elemento%2 == 0):\n", + " print(\"El número: \", elemento, \" es par.\")" + ] }, { "attachments": {}, @@ -63,10 +118,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-15\n", + "-14\n", + "-13\n" + ] + } + ], + "source": [ + "i = 0\n", + "for elemento in Lista[0:3]:\n", + " print(elemento)" + ] }, { "attachments": {}, @@ -78,10 +147,35 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 -15\n", + "1 -14\n", + "2 -13\n", + "3 -12\n", + "4 -11\n", + "5 -10\n", + "6 -9\n", + "7 -8\n", + "8 -7\n", + "9 -6\n", + "10 -5\n", + "11 -4\n", + "12 -3\n", + "13 -2\n", + "14 -1\n" + ] + } + ], + "source": [ + "for indice, valor in enumerate(Lista):\n", + " print(indice,valor)" + ] }, { "attachments": {}, @@ -93,10 +187,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n" + ] + } + ], + "source": [ + "Lista = [1,2,5,7,8,10,13,14,15,17,20]\n", + "i = 1\n", + "while i-1 < len(Lista):\n", + " if(not(i in Lista)):\n", + " Lista.append(i)\n", + " i+=1\n", + "Lista.sort()\n", + "print(Lista)" + ] }, { "attachments": {}, @@ -112,10 +223,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1]\n", + "La serie es: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229]\n" + ] + } + ], + "source": [ + "Lista = [0,1]\n", + "print(Lista)\n", + "i = 2\n", + "while i <= 29:\n", + " Lista.append(Lista[(i-1)] + Lista[(i-2)])\n", + " i+=1\n", + "print(\"La serie es: \", Lista)" + ] }, { "attachments": {}, @@ -127,10 +255,26 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La suma es: 1346268\n", + "1346268\n" + ] + } + ], + "source": [ + "suma = 0\n", + "for Elemento in Lista:\n", + " suma += Elemento\n", + "print(\"La suma es: \", suma)\n", + "\n", + "print(sum(Lista))" + ] }, { "attachments": {}, @@ -149,10 +293,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Valor en: 29 es: 1.6180339887543225\n", + "Valor en: 28 es: 1.618033988738303\n", + "Valor en: 27 es: 1.6180339887802426\n", + "Valor en: 26 es: 1.6180339886704431\n", + "Valor en: 25 es: 1.618033988957902\n" + ] + } + ], + "source": [ + "Longitud = len(Lista)\n", + "i = 1\n", + "while i <= 5:\n", + " print(\"Valor en: \", Longitud - i, \" es: \", Lista[Longitud-i]/Lista[Longitud-i-1])\n", + " i +=1" + ] }, { "attachments": {}, @@ -165,10 +327,29 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hay una 'n' en la posición: 7\n", + "Hay una 'n' en la posición: 21\n", + "Hay una 'n' en la posición: 39\n", + "Hay una 'n' en la posición: 60\n", + "Hay una 'n' en la posición: 67\n" + ] + } + ], + "source": [ + "cadena = \"Hola Mundo. Esto es una practica del lenguaje de programación Python\"\n", + "i = 0;\n", + "for Elemento in cadena:\n", + " if(Elemento == \"n\"):\n", + " print(\"Hay una 'n' en la posición: \", i)\n", + " i+=1\n" + ] }, { "attachments": {}, @@ -180,10 +361,26 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pais\n", + "Ciudad\n", + "Continente\n" + ] + } + ], + "source": [ + "MiDiccionario = {\"Pais\" : [\"Mexico\",\"Estados Unidos,\",\"Italia\"], \n", + " \"Ciudad\" : [\"CDMX\",\"Monterrey\",\"SLP\"], \n", + " \"Continente\": [\"America\",\"Europa\"]}\n", + "for Elemento in MiDiccionario:\n", + " print(Elemento)" + ] }, { "attachments": {}, @@ -195,10 +392,91 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "H\n", + "o\n", + "l\n", + "a\n", + " \n", + "M\n", + "u\n", + "n\n", + "d\n", + "o\n", + ".\n", + " \n", + "E\n", + "s\n", + "t\n", + "o\n", + " \n", + "e\n", + "s\n", + " \n", + "u\n", + "n\n", + "a\n", + " \n", + "p\n", + "r\n", + "a\n", + "c\n", + "t\n", + "i\n", + "c\n", + "a\n", + " \n", + "d\n", + "e\n", + "l\n", + " \n", + "l\n", + "e\n", + "n\n", + "g\n", + "u\n", + "a\n", + "j\n", + "e\n", + " \n", + "d\n", + "e\n", + " \n", + "p\n", + "r\n", + "o\n", + "g\n", + "r\n", + "a\n", + "m\n", + "a\n", + "c\n", + "i\n", + "ó\n", + "n\n", + " \n", + "P\n", + "y\n", + "t\n", + "h\n", + "o\n", + "n\n" + ] + } + ], + "source": [ + "list(cadena)\n", + "Iterador = iter(cadena)\n", + "Longitud = len(cadena)\n", + "for Elemento in range(0,Longitud):\n", + " print(next(Iterador))" + ] }, { "attachments": {}, @@ -210,10 +488,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[('México', 1), (2, 'Cuba'), ('Panama', 3)]\n" + ] + } + ], + "source": [ + "Lista1 = [\"México\",2,\"Panama\"]\n", + "Lista2 = [1,\"Cuba\",3]\n", + "Resultado = zip(Lista1,Lista2)\n", + "print(list(Resultado))" + ] }, { "attachments": {}, @@ -226,10 +517,29 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La nueva lista es: [21, 35, 42, 56, 63, 84, 91]\n", + "[21, 35, 42, 56, 63, 84, 91]\n" + ] + } + ], + "source": [ + "lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100]\n", + "NuevaLista = []\n", + "for Elemento in lis:\n", + " if(Elemento%7 == 0):\n", + " NuevaLista.append(Elemento)\n", + "print(\"La nueva lista es: \", NuevaLista)\n", + "\n", + "lis2 = [i for i in lis if i % 7 == 0] # Comprensión de lista para filtrar elementos divisibles por 7\n", + "print(lis2) # Impresión de la lista resultante" + ] }, { "attachments": {}, @@ -242,10 +552,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total de elementos: 12\n" + ] + } + ], + "source": [ + "lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']]\n", + "Total = 0\n", + "for Elemento in lis:\n", + " if(type(Elemento) == list):\n", + " Total += len(Elemento)\n", + " else:\n", + " Total += 1\n", + "\n", + "print(\"Total de elementos: \", Total)\n" + ] }, { "attachments": {}, @@ -257,10 +585,31 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La lista final es: [[1, 2, 3, 4], ['rojo'], ['verde'], [True, False, False], ['uno', 'dos', 'tres']]\n" + ] + } + ], + "source": [ + "lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']]\n", + "#i = 0\n", + "#for Elemento in lis:\n", + "# if(not(type(Elemento) == list)):\n", + "# lis[i] = [Elemento]\n", + "# i +=1\n", + "#print(lis)\n", + "\n", + "for Indice, Elemento in enumerate(lis):\n", + " if(type(Elemento) != list):\n", + " lis[Indice] = [Elemento]\n", + "print(\"La lista final es: \", lis)" + ] } ], "metadata": { @@ -282,7 +631,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/M06_iterablesiteradores/Prep_Course_Homework_06.md b/M06_iterablesiteradores/Prep_Course_Homework_06.md index 16fc86895..9f95db9be 100644 --- a/M06_iterablesiteradores/Prep_Course_Homework_06.md +++ b/M06_iterablesiteradores/Prep_Course_Homework_06.md @@ -1,47 +1,47 @@ -## Iteradores e iterables - -1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1 - -2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares? - -3) Resolver el punto anterior sin utilizar un ciclo while - -4) Utilizar el iterable para recorrer sólo los primeros 3 elementos - -5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento - -6) Dada la siguiente lista de números enteros entre 1 y 20, crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20] - -7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
-n0 = 0
-n1 = 1
-ni = ni-1 + ni-2
-Crear una lista con los primeros treinta números de la sucesión.
- -8) Realizar la suma de todos elementos de la lista del punto anterior - -9) La proporción aurea se expresa con una proporción matemática que nace el número irracional Phi= 1,618… que los griegos llamaron número áureo. El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, imprimir el cociente de los últimos 5 pares de dos números contiguos:
-Donde i es la cantidad total de elementos
-ni-1 / ni
-ni-2 / ni-1
-ni-3 / ni-2
-ni-4 / ni-3
-ni-5 / ni-4
- - -10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra "n"
-cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' - -11) Crear un diccionario e imprimir sus claves utilizando un iterador - -12) Convertir en una lista la variable "cadena" del punto 10 y luego recorrerla con un iterador - -13) Crear dos listas y unirlas en una tupla utilizando la función zip - -14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
-lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] - -15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene, teniendo en cuenta que un elemento de la lista podría ser otra lista:
-lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] - -16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es +## Iteradores e iterables + +1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1 + +2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares? + +3) Resolver el punto anterior sin utilizar un ciclo while + +4) Utilizar el iterable para recorrer sólo los primeros 3 elementos + +5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento + +6) Dada la siguiente lista de números enteros entre 1 y 20, crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20] + +7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
+n0 = 0
+n1 = 1
+ni = ni-1 + ni-2
+Crear una lista con los primeros treinta números de la sucesión.
+ +8) Realizar la suma de todos elementos de la lista del punto anterior + +9) La proporción aurea se expresa con una proporción matemática que nace el número irracional Phi= 1,618… que los griegos llamaron número áureo. El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, imprimir el cociente de los últimos 5 pares de dos números contiguos:
+Donde i es la cantidad total de elementos
+ni-1 / ni
+ni-2 / ni-1
+ni-3 / ni-2
+ni-4 / ni-3
+ni-5 / ni-4
+ + +10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra "n"
+cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' + +11) Crear un diccionario e imprimir sus claves utilizando un iterador + +12) Convertir en una lista la variable "cadena" del punto 10 y luego recorrerla con un iterador + +13) Crear dos listas y unirlas en una tupla utilizando la función zip + +14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
+lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] + +15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene, teniendo en cuenta que un elemento de la lista podría ser otra lista:
+lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] + +16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es diff --git a/M06_iterablesiteradores/Prep_Course_Homework_06.py b/M06_iterablesiteradores/Prep_Course_Homework_06.py index 85add52ab..f181e1747 100644 --- a/M06_iterablesiteradores/Prep_Course_Homework_06.py +++ b/M06_iterablesiteradores/Prep_Course_Homework_06.py @@ -1,165 +1,165 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Iteradores e iterables - -# 1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1 - -# In[1]: - - - - - -# 2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares? - -# In[3]: - - - - - -# 3) Resolver el punto anterior sin utilizar un ciclo while - -# In[4]: - - - - - -# 4) Utilizar el iterable para recorrer sólo los primeros 3 elementos - -# In[7]: - - - - -# 5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento - -# In[9]: - - - - -# 6) Dada la siguiente lista de números enteros entre 1 y 20, crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20] - -# In[10]: - - - - - -# In[11]: - - -n = 1 - - - -# 7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
-# n0 = 0
-# n1 = 1
-# ni = ni-1 + ni-2
-# Crear una lista con los primeros treinta números de la sucesión.
- -# In[23]: - - - - - -# 8) Realizar la suma de todos elementos de la lista del punto anterior - -# In[24]: - - - - -# 9) La proporción aurea se expresa con una proporción matemática que nace el número irracional Phi= 1,618… que los griegos llamaron número áureo. El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, imprimir el cociente de los últimos 5 pares de dos números contiguos:
-# Donde i es la cantidad total de elementos
-# ni-1 / ni
-# ni-2 / ni-1
-# ni-3 / ni-2
-# ni-4 / ni-3
-# ni-5 / ni-4
-# - -# In[38]: - - - - -# 10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra "n"
-# cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' - -# In[39]: - - - - - -# 11) Crear un diccionario e imprimir sus claves utilizando un iterador - -# In[40]: - - - - - -# 12) Convertir en una lista la variable "cadena" del punto 10 y luego recorrerla con un iterador - -# In[41]: - - - - - -# In[45]: - - - - - -# 13) Crear dos listas y unirlas en una tupla utilizando la función zip - -# In[48]: - - - - - -# 14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
-# lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] - -# In[49]: - - - - - -# 15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene, teniendo en cuenta que un elemento de la lista podría ser otra lista:
-# lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] - -# In[56]: - - - - -# In[51]: - - - - - -# In[57]: - - - - - -# 16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es - -# In[58]: - - - +#!/usr/bin/env python +# coding: utf-8 + +# ## Iteradores e iterables + +# 1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1 + +# In[1]: + + + + + +# 2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares? + +# In[3]: + + + + + +# 3) Resolver el punto anterior sin utilizar un ciclo while + +# In[4]: + + + + + +# 4) Utilizar el iterable para recorrer sólo los primeros 3 elementos + +# In[7]: + + + + +# 5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento + +# In[9]: + + + + +# 6) Dada la siguiente lista de números enteros entre 1 y 20, crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20] + +# In[10]: + + + + + +# In[11]: + + +n = 1 + + + +# 7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
+# n0 = 0
+# n1 = 1
+# ni = ni-1 + ni-2
+# Crear una lista con los primeros treinta números de la sucesión.
+ +# In[23]: + + + + + +# 8) Realizar la suma de todos elementos de la lista del punto anterior + +# In[24]: + + + + +# 9) La proporción aurea se expresa con una proporción matemática que nace el número irracional Phi= 1,618… que los griegos llamaron número áureo. El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, imprimir el cociente de los últimos 5 pares de dos números contiguos:
+# Donde i es la cantidad total de elementos
+# ni-1 / ni
+# ni-2 / ni-1
+# ni-3 / ni-2
+# ni-4 / ni-3
+# ni-5 / ni-4
+# + +# In[38]: + + + + +# 10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra "n"
+# cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' + +# In[39]: + + + + + +# 11) Crear un diccionario e imprimir sus claves utilizando un iterador + +# In[40]: + + + + + +# 12) Convertir en una lista la variable "cadena" del punto 10 y luego recorrerla con un iterador + +# In[41]: + + + + + +# In[45]: + + + + + +# 13) Crear dos listas y unirlas en una tupla utilizando la función zip + +# In[48]: + + + + + +# 14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
+# lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] + +# In[49]: + + + + + +# 15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene, teniendo en cuenta que un elemento de la lista podría ser otra lista:
+# lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] + +# In[56]: + + + + +# In[51]: + + + + + +# In[57]: + + + + + +# 16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es + +# In[58]: + + + diff --git a/M07_funciones/Prep_Course_Homework_07-Resuelto.ipynb b/M07_funciones/Prep_Course_Homework_07-Resuelto.ipynb index 9e73b92ea..02fa8a9de 100644 --- a/M07_funciones/Prep_Course_Homework_07-Resuelto.ipynb +++ b/M07_funciones/Prep_Course_Homework_07-Resuelto.ipynb @@ -378,7 +378,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/M07_funciones/Prep_Course_Homework_07-Resuelto.py b/M07_funciones/Prep_Course_Homework_07-Resuelto.py index 92f23bb2b..0671ad51f 100644 --- a/M07_funciones/Prep_Course_Homework_07-Resuelto.py +++ b/M07_funciones/Prep_Course_Homework_07-Resuelto.py @@ -1,159 +1,159 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Funciones - -# 1) Crear una función que reciba un número como parámetro y devuelva si True si es primo y False si no lo es - -# In[1]: - - -def verifica_primo(nro): - es_primo = True - for i in range(2, nro): - if nro % i == 0: - es_primo = False - break - return es_primo - - -# 2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números y devuelva sólo aquellos que son primos en otra lista - -# In[25]: - - -def extrae_primos_de_lista(lista): - lista_primos = [] - for elemento in lista: - if verifica_primo(int(elemento)): - lista_primos.append(elemento) - return lista_primos - - -# In[26]: - - -lis_completa = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] -lis_primos = extrae_primos_de_lista(lis_completa) -lis_primos - - -# 3) Crear una función que al recibir una lista de números, devuelva el que más se repite y cuántas veces lo hace. Si hay más de un "más repetido", que devuelva cualquiera - -# In[33]: - - -def valor_modal(lista): - lista_unicos = [] - lista_repeticiones = [] - if len(lista) == 0: - return None - for elemento in lista: - if elemento in lista_unicos: - i = lista_unicos.index(elemento) - lista_repeticiones[i] += 1 - else: - lista_unicos.append(elemento) - lista_repeticiones.append(1) - moda = lista_unicos[0] - maximo = lista_repeticiones[0] - for i, elemento in enumerate(lista_unicos): - if lista_repeticiones[i] > maximo: - moda = lista_unicos[i] - maximo = lista_repeticiones[i] - return moda, maximo - - -# In[36]: - - -lis = [1,1,5,6,8,10,22,5,6,4,11,9,5] -moda, repite = valor_modal(lis) -print('El valor modal es', moda, 'y se repite', repite, 'veces.') - - -# 4) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
-# Fórmula 1 : (°C × 9/5) + 32 = °F
-# Fórmula 2 : °C + 273.15 = °K
-# Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino -# - -# In[56]: - - -def conversion_grados(valor, origen, destino): - if (origen == 'celsius'): - if (destino == 'celsius'): - valor_destino = valor - elif (destino == 'farenheit'): - valor_destino = (valor * 9 / 5) + 32 - elif (destino == 'kelvin'): - valor_destino = valor + 273.15 - else: - print('Parámetro de Destino incorrecto') - elif (origen == 'farenheit'): - if (destino == 'celsius'): - valor_destino = (valor - 32) * 5 / 9 - elif (destino == 'farenheit'): - valor_destino = valor - elif (destino == 'kelvin'): - valor_destino = ((valor - 32) * 5 / 9) + 273.15 - else: - print('Parámetro de Destino incorrecto') - elif (origen == 'kelvin'): - if (destino == 'celsius'): - valor_destino = valor - 273.15 - elif (destino == 'farenheit'): - valor_destino = ((valor - 273.15) * 9 / 5) + 32 - elif (destino == 'kelvin'): - valor_destino = valor - else: - print('Parámetro de Destino incorrecto') - else: - print('Parámetro de Origen incorrecto') - return valor_destino - - -# In[59]: - - -print('1 grado Celsius a Celsius:', conversion_grados(1, 'celsius', 'celsius')) -print('1 grado Celsius a Kelvin:', conversion_grados(1, 'celsius', 'kelvin')) -print('1 grado Celsius a Farenheit:', conversion_grados(1, 'celsius', 'farenheit')) -print('1 grado Kelvin a Celsius:', conversion_grados(1, 'kelvin', 'celsius')) -print('1 grado Kelvin a Kelvin:', conversion_grados(1, 'kelvin', 'kelvin')) -print('1 grado Kelvin a Farenheit:', conversion_grados(1, 'kelvin', 'farenheit')) -print('1 grado Farenheit a Celsius:', conversion_grados(1, 'farenheit', 'celsius')) -print('1 grado Farenheit a Kelvin:', conversion_grados(1, 'farenheit', 'kelvin')) -print('1 grado Farenheit a Farenheit:', conversion_grados(1, 'farenheit', 'farenheit')) - - -# 5) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, hacer un print para cada combinación de los mismos: - -# In[62]: - - -metricas = ['celsius','kelvin','farenheit'] -for i in range(0,3): - for j in range(0,3): - print('1 grado', metricas[i], 'a', metricas[j],':', conversion_grados(1, metricas[i], metricas[j])) - - -# 6) Armar una función que devuelva el factorial de un número. Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero o negativo - -# In[65]: - - -def factorial(numero): - if(type(numero) != int): - return 'El numero debe ser un entero' - if(numero < 0): - return 'El numero debe ser pisitivo' - if (numero > 1): - numero = numero * factorial(numero - 1) - return numero -print(factorial(3)) -print(factorial(-2)) -print(factorial(1.23)) -print(factorial('6')) - +#!/usr/bin/env python +# coding: utf-8 + +# ## Funciones + +# 1) Crear una función que reciba un número como parámetro y devuelva si True si es primo y False si no lo es + +# In[1]: + + +def verifica_primo(nro): + es_primo = True + for i in range(2, nro): + if nro % i == 0: + es_primo = False + break + return es_primo + + +# 2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números y devuelva sólo aquellos que son primos en otra lista + +# In[25]: + + +def extrae_primos_de_lista(lista): + lista_primos = [] + for elemento in lista: + if verifica_primo(int(elemento)): + lista_primos.append(elemento) + return lista_primos + + +# In[26]: + + +lis_completa = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] +lis_primos = extrae_primos_de_lista(lis_completa) +lis_primos + + +# 3) Crear una función que al recibir una lista de números, devuelva el que más se repite y cuántas veces lo hace. Si hay más de un "más repetido", que devuelva cualquiera + +# In[33]: + + +def valor_modal(lista): + lista_unicos = [] + lista_repeticiones = [] + if len(lista) == 0: + return None + for elemento in lista: + if elemento in lista_unicos: + i = lista_unicos.index(elemento) + lista_repeticiones[i] += 1 + else: + lista_unicos.append(elemento) + lista_repeticiones.append(1) + moda = lista_unicos[0] + maximo = lista_repeticiones[0] + for i, elemento in enumerate(lista_unicos): + if lista_repeticiones[i] > maximo: + moda = lista_unicos[i] + maximo = lista_repeticiones[i] + return moda, maximo + + +# In[36]: + + +lis = [1,1,5,6,8,10,22,5,6,4,11,9,5] +moda, repite = valor_modal(lis) +print('El valor modal es', moda, 'y se repite', repite, 'veces.') + + +# 4) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
+# Fórmula 1 : (°C × 9/5) + 32 = °F
+# Fórmula 2 : °C + 273.15 = °K
+# Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino +# + +# In[56]: + + +def conversion_grados(valor, origen, destino): + if (origen == 'celsius'): + if (destino == 'celsius'): + valor_destino = valor + elif (destino == 'farenheit'): + valor_destino = (valor * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'farenheit'): + if (destino == 'celsius'): + valor_destino = (valor - 32) * 5 / 9 + elif (destino == 'farenheit'): + valor_destino = valor + elif (destino == 'kelvin'): + valor_destino = ((valor - 32) * 5 / 9) + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'kelvin'): + if (destino == 'celsius'): + valor_destino = valor - 273.15 + elif (destino == 'farenheit'): + valor_destino = ((valor - 273.15) * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + else: + print('Parámetro de Destino incorrecto') + else: + print('Parámetro de Origen incorrecto') + return valor_destino + + +# In[59]: + + +print('1 grado Celsius a Celsius:', conversion_grados(1, 'celsius', 'celsius')) +print('1 grado Celsius a Kelvin:', conversion_grados(1, 'celsius', 'kelvin')) +print('1 grado Celsius a Farenheit:', conversion_grados(1, 'celsius', 'farenheit')) +print('1 grado Kelvin a Celsius:', conversion_grados(1, 'kelvin', 'celsius')) +print('1 grado Kelvin a Kelvin:', conversion_grados(1, 'kelvin', 'kelvin')) +print('1 grado Kelvin a Farenheit:', conversion_grados(1, 'kelvin', 'farenheit')) +print('1 grado Farenheit a Celsius:', conversion_grados(1, 'farenheit', 'celsius')) +print('1 grado Farenheit a Kelvin:', conversion_grados(1, 'farenheit', 'kelvin')) +print('1 grado Farenheit a Farenheit:', conversion_grados(1, 'farenheit', 'farenheit')) + + +# 5) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, hacer un print para cada combinación de los mismos: + +# In[62]: + + +metricas = ['celsius','kelvin','farenheit'] +for i in range(0,3): + for j in range(0,3): + print('1 grado', metricas[i], 'a', metricas[j],':', conversion_grados(1, metricas[i], metricas[j])) + + +# 6) Armar una función que devuelva el factorial de un número. Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero o negativo + +# In[65]: + + +def factorial(numero): + if(type(numero) != int): + return 'El numero debe ser un entero' + if(numero < 0): + return 'El numero debe ser pisitivo' + if (numero > 1): + numero = numero * factorial(numero - 1) + return numero +print(factorial(3)) +print(factorial(-2)) +print(factorial(1.23)) +print(factorial('6')) + diff --git a/M07_funciones/Prep_Course_Homework_07.ipynb b/M07_funciones/Prep_Course_Homework_07.ipynb index dc6c4e40d..d5dbad218 100644 --- a/M07_funciones/Prep_Course_Homework_07.ipynb +++ b/M07_funciones/Prep_Course_Homework_07.ipynb @@ -18,10 +18,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def ValidarPrimo(Numero):\n", + " EsPrimo = True\n", + " for div in range(2, Numero):\n", + " if (Numero % div == 0):\n", + " EsPrimo = False\n", + " break\n", + " return EsPrimo\n", + "EsPrimo(17)" + ] }, { "attachments": {}, @@ -33,10 +53,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def EvaluaNumeros(Listado):\n", + " ListaPrimos = []\n", + " for i in Listado:\n", + " if (ValidarPrimo(int(i))):\n", + " ListaPrimos.append(i)\n", + " return ListaPrimos\n" + ] }, { "attachments": {}, @@ -48,10 +75,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(11, 2)\n" + ] + } + ], + "source": [ + "Lista3 = [11,211,11,1,233,1]\n", + "def ContarDuplicados(ListaDeEvaluacion):\n", + " i = 0\n", + " TotalRepeticiones = 0\n", + " MasRepetido = 0\n", + " for Elemento in ListaDeEvaluacion:\n", + " Repeticiones = 0\n", + " j = 0 \n", + " for Elemento in ListaDeEvaluacion:\n", + " if (ListaDeEvaluacion[i] == ListaDeEvaluacion[j]):\n", + " Repeticiones+=1\n", + " j+=1\n", + " if(TotalRepeticiones < Repeticiones):\n", + " TotalRepeticiones = Repeticiones\n", + " MasRepetido = ListaDeEvaluacion[i]\n", + " i+=1\n", + " return MasRepetido,TotalRepeticiones\n", + "\n", + "print(ContarDuplicados(Lista3))\n" + ] }, { "attachments": {}, @@ -66,10 +121,67 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 140, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def ConvertirGrados(Grados,Origen,Destino):\n", + " if(Origen == \"Celsius\" and Destino == \"Farenheit\"):\n", + " Resultado = (Grados * 1.8) + 32\n", + " elif (Origen == \"Celsius\" and Destino == \"Kelvin\"):\n", + " Resultado = Grados + 273.15\n", + " elif (Origen == \"Celsius\" and Destino == \"Celsius\"):\n", + " Resultado = Grados\n", + " elif (Origen == \"Farenheit\" and Destino == \"Celsius\"):\n", + " Resultado = (Grados - 32) * (5/9)\n", + " elif (Origen == \"Farenheit\" and Destino == \"Kelvin\"):\n", + " Resultado = (Grados - 32) * (5/9) + 273.15\n", + " elif (Origen == \"Farenheit\" and Destino == \"Farenheit\"):\n", + " Resultado = Grados\n", + " elif (Origen == \"Kelvin\" and Destino == \"Celsius\"):\n", + " Resultado = (Grados - 273.15)\n", + " elif (Origen == \"Kelvin\" and Destino == \"Farenheit\"):\n", + " Resultado = (Grados - 273.15) * (9/5) + 32\n", + " elif (Origen == \"Kelvin\" and Destino == \"Kelvin\"):\n", + " Resultado = Grados\n", + " else:\n", + " print(\"Parámetros incorrectos\")\n", + " \n", + " return Resultado" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 grado Celsius a Celsius: 1\n", + "1 grado Celsius a Kelvin: 274.15\n", + "1 grado Celsius a Farenheit: 33.8\n", + "1 grado Kelvin a Celsius: -272.15\n", + "1 grado Kelvin a Kelvin: 1\n", + "1 grado Kelvin a Farenheit: -457.86999999999995\n", + "1 grado Farenheit a Celsius: -17.22222222222222\n", + "1 grado Farenheit a Kelvin: 255.92777777777775\n", + "1 grado Farenheit a Farenheit: 1\n" + ] + } + ], + "source": [ + "print('1 grado Celsius a Celsius:', ConvertirGrados(1, 'Celsius', 'Celsius'))\n", + "print('1 grado Celsius a Kelvin:', ConvertirGrados(1, 'Celsius', 'Kelvin'))\n", + "print('1 grado Celsius a Farenheit:', ConvertirGrados(1, 'Celsius', 'Farenheit'))\n", + "print('1 grado Kelvin a Celsius:', ConvertirGrados(1, 'Kelvin', 'Celsius'))\n", + "print('1 grado Kelvin a Kelvin:', ConvertirGrados(1, 'Kelvin', 'Kelvin'))\n", + "print('1 grado Kelvin a Farenheit:', ConvertirGrados(1, 'Kelvin', 'Farenheit'))\n", + "print('1 grado Farenheit a Celsius:', ConvertirGrados(1, 'Farenheit', 'Celsius'))\n", + "print('1 grado Farenheit a Kelvin:', ConvertirGrados(1, 'Farenheit', 'Kelvin'))\n", + "print('1 grado Farenheit a Farenheit:', ConvertirGrados(1, 'Farenheit', 'Farenheit'))" + ] }, { "attachments": {}, @@ -81,10 +193,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 159, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 Grado en: Celsius convertido a Celsius Es: 1\n", + "1 Grado en: Celsius convertido a Farenheit Es: 33.8\n", + "1 Grado en: Celsius convertido a Kelvin Es: 274.15\n", + "1 Grado en: Farenheit convertido a Celsius Es: -17.22222222222222\n", + "1 Grado en: Farenheit convertido a Farenheit Es: 1\n", + "1 Grado en: Farenheit convertido a Kelvin Es: 255.92777777777775\n", + "1 Grado en: Kelvin convertido a Celsius Es: -272.15\n", + "1 Grado en: Kelvin convertido a Farenheit Es: -457.86999999999995\n", + "1 Grado en: Kelvin convertido a Kelvin Es: 1\n" + ] + } + ], + "source": [ + "Temperaturas = [\"Celsius\",\"Farenheit\",\"Kelvin\"]\n", + "for i in range(0,3):\n", + " for j in range(0,3):\n", + " print(\"1 Grado en: \", Temperaturas[i] + \" convertido a \" , Temperaturas[j] + \" Es: \" , ConvertirGrados(1,Temperaturas[i],Temperaturas[j]))\n" + ] }, { "attachments": {}, @@ -96,10 +229,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 164, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def Factorial(Numero):\n", + " if(type(Numero) != int):\n", + " return \"EL número debe de ser entero\"\n", + " \n", + " if(Numero < 0):\n", + " return \"El número debe de ser positivo\"\n", + " \n", + " if(Numero <= 1):\n", + " return 1\n", + " \n", + " Numero = Numero * Factorial(Numero -1)\n", + " return Numero" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "120\n", + "El número debe de ser positivo\n", + "EL número debe de ser entero\n", + "EL número debe de ser entero\n" + ] + } + ], + "source": [ + "print(Factorial(5))\n", + "print(Factorial(-5))\n", + "print(Factorial(5.5))\n", + "print(Factorial(\"String\"))" + ] } ], "metadata": { @@ -121,7 +290,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/M07_funciones/Prep_Course_Homework_07.md b/M07_funciones/Prep_Course_Homework_07.md index 5c79a7232..69a4ff7c9 100644 --- a/M07_funciones/Prep_Course_Homework_07.md +++ b/M07_funciones/Prep_Course_Homework_07.md @@ -1,17 +1,17 @@ -## Funciones - -1) Crear una función que reciba un número como parámetro y devuelva si True si es primo y False si no lo es - -2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números y devuelva sólo aquellos que son primos en otra lista - -3) Crear una función que al recibir una lista de números, devuelva el que más se repite y cuántas veces lo hace. Si hay más de un "más repetido", que devuelva cualquiera - -4) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
-Fórmula 1 : (°C × 9/5) + 32 = °F
-Fórmula 2 : °C + 273.15 = °K
-Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino - - -5) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, hacer un print para cada combinación de los mismos: - -6) Armar una función que devuelva el factorial de un número. Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero o negativo +## Funciones + +1) Crear una función que reciba un número como parámetro y devuelva si True si es primo y False si no lo es + +2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números y devuelva sólo aquellos que son primos en otra lista + +3) Crear una función que al recibir una lista de números, devuelva el que más se repite y cuántas veces lo hace. Si hay más de un "más repetido", que devuelva cualquiera + +4) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
+Fórmula 1 : (°C × 9/5) + 32 = °F
+Fórmula 2 : °C + 273.15 = °K
+Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino + + +5) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, hacer un print para cada combinación de los mismos: + +6) Armar una función que devuelva el factorial de un número. Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero o negativo diff --git a/M07_funciones/Prep_Course_Homework_07.py b/M07_funciones/Prep_Course_Homework_07.py index 178453ee9..39feac696 100644 --- a/M07_funciones/Prep_Course_Homework_07.py +++ b/M07_funciones/Prep_Course_Homework_07.py @@ -1,52 +1,52 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Funciones - -# 1) Crear una función que reciba un número como parámetro y devuelva si True si es primo y False si no lo es - -# In[1]: - - - - - -# 2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números y devuelva sólo aquellos que son primos en otra lista - -# In[25]: - - - - -# 3) Crear una función que al recibir una lista de números, devuelva el que más se repite y cuántas veces lo hace. Si hay más de un "más repetido", que devuelva cualquiera - -# In[33]: - - - - - -# 4) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
-# Fórmula 1 : (°C × 9/5) + 32 = °F
-# Fórmula 2 : °C + 273.15 = °K
-# Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino -# - -# In[56]: - - - -# 5) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, hacer un print para cada combinación de los mismos: - -# In[62]: - - - - -# 6) Armar una función que devuelva el factorial de un número. Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero o negativo - -# In[65]: - - - - +#!/usr/bin/env python +# coding: utf-8 + +# ## Funciones + +# 1) Crear una función que reciba un número como parámetro y devuelva si True si es primo y False si no lo es + +# In[1]: + + + + + +# 2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números y devuelva sólo aquellos que son primos en otra lista + +# In[25]: + + + + +# 3) Crear una función que al recibir una lista de números, devuelva el que más se repite y cuántas veces lo hace. Si hay más de un "más repetido", que devuelva cualquiera + +# In[33]: + + + + + +# 4) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
+# Fórmula 1 : (°C × 9/5) + 32 = °F
+# Fórmula 2 : °C + 273.15 = °K
+# Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino +# + +# In[56]: + + + +# 5) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, hacer un print para cada combinación de los mismos: + +# In[62]: + + + + +# 6) Armar una función que devuelva el factorial de un número. Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero o negativo + +# In[65]: + + + + diff --git a/M08_clasesyOOP/LibreriaFunciones.py b/M08_clasesyOOP/LibreriaFunciones.py new file mode 100644 index 000000000..7eb7fec6d --- /dev/null +++ b/M08_clasesyOOP/LibreriaFunciones.py @@ -0,0 +1,80 @@ +class Funciones7: + def __init__(self, ListaEvaluada): + self.Lista = ListaEvaluada + + def ValidarPrimo(self): + for i in self.Lista: + if(self.__ValidarPrimo(i)): + print("El número: ", i, "es primo") + else: + print("El número: ", i, "no es primo") + + def ConvertirGrados(self, Origen, Destino): + for i in self.Lista: + print(i,"Grados ", Origen, " son: " , self.__ConvertirGrados(i, Origen, Destino), " en ", Destino) + + def Factorial(self): + for i in self.Lista: + print("El factorial de: ", i, " es: ", self.__Factorial(i)) + + def __ValidarPrimo(self, Numero): + EsPrimo = True + for div in range(2, Numero): + if (Numero % div == 0): + EsPrimo = False + break + return EsPrimo + + def ContarDuplicados(self, ListaDeEvaluacion): + i = 0 + TotalRepeticiones = 0 + MasRepetido = 0 + for Elemento in ListaDeEvaluacion: + Repeticiones = 0 + j = 0 + for Elemento in ListaDeEvaluacion: + if (ListaDeEvaluacion[i] == ListaDeEvaluacion[j]): + Repeticiones+=1 + j+=1 + if(TotalRepeticiones < Repeticiones): + TotalRepeticiones = Repeticiones + MasRepetido = ListaDeEvaluacion[i] + i+=1 + return MasRepetido,TotalRepeticiones + + def __ConvertirGrados(self, Grados, Origen, Destino): + if(Origen == "Celsius" and Destino == "Farenheit"): + Resultado = (Grados * 1.8) + 32 + elif (Origen == "Celsius" and Destino == "Kelvin"): + Resultado = Grados + 273.15 + elif (Origen == "Celsius" and Destino == "Celsius"): + Resultado = Grados + elif (Origen == "Farenheit" and Destino == "Celsius"): + Resultado = (Grados - 32) * (5/9) + elif (Origen == "Farenheit" and Destino == "Kelvin"): + Resultado = (Grados - 32) * (5/9) + 273.15 + elif (Origen == "Farenheit" and Destino == "Farenheit"): + Resultado = Grados + elif (Origen == "Kelvin" and Destino == "Celsius"): + Resultado = (Grados - 273.15) + elif (Origen == "Kelvin" and Destino == "Farenheit"): + Resultado = (Grados - 273.15) * (9/5) + 32 + elif (Origen == "Kelvin" and Destino == "Kelvin"): + Resultado = Grados + else: + print("Parámetros incorrectos") + + return Resultado + + def __Factorial(self, Numero): + if(type(Numero) != int): + return "EL número debe de ser entero" + + if(Numero < 0): + return "El número debe de ser positivo" + + if(Numero <= 1): + return 1 + + Numero = Numero * self.__Factorial(Numero -1) + return Numero \ No newline at end of file diff --git a/M08_clasesyOOP/Prep_Course_Homework_08-Resuelto.ipynb b/M08_clasesyOOP/Prep_Course_Homework_08-Resuelto.ipynb index cdaa0f8e5..7761b364b 100644 --- a/M08_clasesyOOP/Prep_Course_Homework_08-Resuelto.ipynb +++ b/M08_clasesyOOP/Prep_Course_Homework_08-Resuelto.ipynb @@ -1,678 +1,678 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Clases y Programación Orientada a Objetos" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "1) Crear la clase vehículo que contenga los atributos:
\n", - "Color
\n", - "Si es moto, auto, camioneta ó camión
\n", - "Cilindrada del motor" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "# El método especial __init__ es el constructor de la clase Vehiculo(Se llama automáticamente cuando se crea una nueva instancia de la clase.El constructor recibe tres parámetros: color, tipo y cilindrada. La variable self se refiere al objeto actual (la instancia de la clase Vehiculo). Los parámetros color, tipo y cilindrada se asignan a los atributos correspondientes del objeto.\n", - "\n", - "class Vehiculo:\n", - " def __init__(self, color, tipo, cilindrada): \n", - " self.color = color\n", - " self.tipo = tipo\n", - " self.cilindrada = cilindrada\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
\n", - "Acelerar
\n", - "Frenar
\n", - "Doblar
" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "class Vehiculo:\n", - " def __init__(self, color, tipo, cilindrada):\n", - " self.color = color\n", - " self.tipo = tipo\n", - " self.cilindrada = cilindrada\n", - " self.velocidad = 0\n", - " self.direccion = 0\n", - "\n", - " def Acelerar(self, vel): # El método Acelerar recibe un parámetro \"vel\" que representa la velocidad a aumentar.\n", - " self.velocidad += vel # Aumenta la velocidad actual del vehículo sumando el valor de \"vel\" al atributo \"velocidad\".\n", - "\n", - " def Frenar(self, vel): # El método Frenar recibe un parámetro \"vel\" que representa la velocidad a disminuir.\n", - " self.velocidad -= vel # Disminuye la velocidad actual del vehículo restando el valor de \"vel\" al atributo \"velocidad\".\n", - " \n", - " def Doblar(self, grados): # El método Doblar recibe un parámetro \"grados\" que representa la cantidad de grados para girar.\n", - " self.direccion += grados # Actualiza la dirección del vehículo sumando el valor de \"grados\" al atributo \"direccion\"." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "a1 = Vehiculo('rojo', 'auto', 2) # Creación de un objeto \"Vehiculo\" con color rojo, tipo auto y cilindrada 2.\n", - "a2 = Vehiculo('blanco', 'camioneta', 3.6) # Creación de un objeto \"Vehiculo\" con color blanco, tipo camioneta y cilindrada 3.6.\n", - "a3 = Vehiculo('negro', 'moto', 1) # Creación de un objeto \"Vehiculo\" con color negro, tipo moto y cilindrada 1." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "a1.Acelerar(40) # Llamada al método \"Acelerar\" del objeto \"a1\" para aumentar la velocidad en 40.\n", - "a2.Acelerar(60) # Llamada al método \"Acelerar\" del objeto \"a2\" para aumentar la velocidad en 60.\n", - "a3.Acelerar(30) # Llamada al método \"Acelerar\" del objeto \"a3\" para aumentar la velocidad en 30.\n", - "\n", - "a1.Doblar(30) # Llamada al método \"Doblar\" del objeto \"a1\" para girar la dirección en 30 grados.\n", - "a3.Doblar(-30) # Llamada al método \"Doblar\" del objeto \"a3\" para girar la dirección en -30 grados.\n", - "\n", - "a2.Frenar(-50) # Llamada al método \"Frenar\" del objeto \"a2\" para disminuir la velocidad en -50." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "class Vehiculo:\n", - " def __init__(self, color, tipo, cilindrada):\n", - " self.color = color\n", - " self.tipo = tipo\n", - " self.cilindrada = cilindrada\n", - " self.velocidad = 0\n", - " self.direccion = 0\n", - "\n", - " def Acelerar(self, vel):\n", - " self.velocidad += vel\n", - "\n", - " def Frenar(self, vel):\n", - " self.velocidad -= vel\n", - " \n", - " def Doblar(self, grados):\n", - " self.direccion += grados\n", - "\n", - " def Estado(self):\n", - " print('Velocidad:', self.velocidad, '- Dirección:', self.direccion)\n", - "\n", - " def Detalle(self):\n", - " print('Soy', self.tipo, 'de color', self.color, 'y mi cilindrada es de', self.cilindrada, 'litros')\n", - "\n", - " def Estado(self): #Método para imprimir el estado actual del vehículo.\n", - " print('Velocidad:', self.velocidad, '- Dirección:', self.direccion) #Muestra la velocidad y dirección.\n", - "\n", - " def Detalle(self): #Método para imprimir los detalles del vehículo.\n", - " print('Soy', self.tipo, 'de color', self.color, 'y mi cilindrada es de', self.cilindrada, 'litros') #Muestra el tipo, color y cilindrada.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Soy auto de color rojo y mi cilindrada es de 2 litros\n" - ] - } - ], - "source": [ - "a1 = Vehiculo('rojo', 'auto', 2)\n", - "a1.Detalle()" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Velocidad: 0 - Dirección: 0\n", - "Velocidad: 30 - Dirección: 0\n" - ] - } - ], - "source": [ - "a1.Estado()\n", - "a1.Acelerar(30)\n", - "a1.Estado()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 7
\n", - "Verificar Primo
\n", - "Valor modal
\n", - "Conversión grados
\n", - "Factorial
" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "class Herramientas:\n", - " def __init__(self) -> None:\n", - " pass\n", - "\n", - " def verifica_primo(self, nro):\n", - " es_primo = True\n", - " for i in range(2, nro):\n", - " if nro % i == 0:\n", - " es_primo = False\n", - " break\n", - " return es_primo\n", - "\n", - " def valor_modal(lista):\n", - " lista_unicos = []\n", - " lista_repeticiones = []\n", - " if len(lista) == 0:\n", - " return None\n", - " for elemento in lista:\n", - " if elemento in lista_unicos:\n", - " i = lista_unicos.index(elemento)\n", - " lista_repeticiones[i] += 1\n", - " else:\n", - " lista_unicos.append(elemento)\n", - " lista_repeticiones.append(1)\n", - " moda = lista_unicos[0]\n", - " maximo = lista_repeticiones[0]\n", - " for i, elemento in enumerate(lista_unicos):\n", - " if lista_repeticiones[i] > maximo:\n", - " moda = lista_unicos[i]\n", - " maximo = lista_repeticiones[i]\n", - " return moda, maximo\n", - "\n", - " def conversion_grados(self, valor, origen, destino):\n", - " valor_destino = None\n", - " if (origen == 'celsius'):\n", - " if (destino == 'celsius'):\n", - " valor_destino = valor\n", - " elif (destino == 'farenheit'):\n", - " valor_destino = (valor * 9 / 5) + 32\n", - " elif (destino == 'kelvin'):\n", - " valor_destino = valor + 273.15\n", - " else:\n", - " print('Parámetro de Destino incorrecto')\n", - " elif (origen == 'farenheit'):\n", - " if (destino == 'celsius'):\n", - " valor_destino = (valor - 32) * 5 / 9\n", - " elif (destino == 'farenheit'):\n", - " valor_destino = valor\n", - " elif (destino == 'kelvin'):\n", - " valor_destino = ((valor - 32) * 5 / 9) + 273.15\n", - " else:\n", - " print('Parámetro de Destino incorrecto')\n", - " elif (origen == 'kelvin'):\n", - " if (destino == 'celsius'):\n", - " valor_destino = valor - 273.15\n", - " elif (destino == 'farenheit'):\n", - " valor_destino = ((valor - 273.15) * 9 / 5) + 32\n", - " elif (destino == 'kelvin'):\n", - " valor_destino = valor\n", - " else:\n", - " print('Parámetro de Destino incorrecto')\n", - " else:\n", - " print('Parámetro de Origen incorrecto')\n", - " return valor_destino\n", - "\n", - " def factorial(self, numero):\n", - " if(type(numero) != int):\n", - " return 'El numero debe ser un entero'\n", - " if(numero < 0):\n", - " return 'El numero debe ser pisitivo'\n", - " if (numero > 1):\n", - " numero = numero * self.factorial(numero - 1)\n", - " return numero" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "h = Herramientas()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "6) Probar las funciones incorporadas en la clase del punto 5" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "h.verifica_primo(7)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "El valor modal es 8 y se reptie 2 veces\n" - ] - } - ], - "source": [ - "listado = [1,8,2,5,4,8,10,7]\n", - "moda, repe = h.valor_modal(listado, True)\n", - "print('El valor modal es', moda, 'y se reptie', repe, 'veces')" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "283.15" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "h.conversion_grados(10, 'celsius', 'kelvin')" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "720" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "h.factorial(6)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "class Herramientas:\n", - " def __init__(self, lista_numeros):\n", - " self.lista = lista_numeros\n", - "\n", - " def verifica_primo(self):\n", - " for i in self.lista:\n", - " if (self.__verifica_primo(i)):\n", - " print('El elemento', i, 'SI es un numero primo')\n", - " else:\n", - " print('El elemento', i, 'NO es un numero primo')\n", - "\n", - " def conversion_grados(self, origen, destino):\n", - " for i in self.lista:\n", - " print(i, 'grados', origen, 'son', self.__conversion_grados(i, origen, destino),'grados',destino)\n", - " \n", - " def factorial(self):\n", - " for i in self.lista:\n", - " print('El factorial de ', i, 'es', self.__factorial(i))\n", - "\n", - " def __verifica_primo(self, nro):\n", - " es_primo = True\n", - " for i in range(2, nro):\n", - " if nro % i == 0:\n", - " es_primo = False\n", - " break\n", - " return es_primo\n", - "\n", - " def valor_modal(self, menor):\n", - " lista_unicos = []\n", - " lista_repeticiones = []\n", - " if len(self.lista) == 0:\n", - " return None\n", - " if (menor):\n", - " self.lista.sort()\n", - " else:\n", - " self.lista.sort(reverse=True)\n", - " for elemento in self.lista:\n", - " if elemento in lista_unicos:\n", - " i = lista_unicos.index(elemento)\n", - " lista_repeticiones[i] += 1\n", - " else:\n", - " lista_unicos.append(elemento)\n", - " lista_repeticiones.append(1)\n", - " moda = lista_unicos[0]\n", - " maximo = lista_repeticiones[0]\n", - " for i, elemento in enumerate(lista_unicos):\n", - " if lista_repeticiones[i] > maximo:\n", - " moda = lista_unicos[i]\n", - " maximo = lista_repeticiones[i]\n", - " return moda, maximo\n", - "\n", - " def __conversion_grados(self, valor, origen, destino):\n", - " valor_destino = None\n", - " if (origen == 'celsius'):\n", - " if (destino == 'celsius'):\n", - " valor_destino = valor\n", - " elif (destino == 'farenheit'):\n", - " valor_destino = (valor * 9 / 5) + 32\n", - " elif (destino == 'kelvin'):\n", - " valor_destino = valor + 273.15\n", - " else:\n", - " print('Parámetro de Destino incorrecto')\n", - " elif (origen == 'farenheit'):\n", - " if (destino == 'celsius'):\n", - " valor_destino = (valor - 32) * 5 / 9\n", - " elif (destino == 'farenheit'):\n", - " valor_destino = valor\n", - " elif (destino == 'kelvin'):\n", - " valor_destino = ((valor - 32) * 5 / 9) + 273.15\n", - " else:\n", - " print('Parámetro de Destino incorrecto')\n", - " elif (origen == 'kelvin'):\n", - " if (destino == 'celsius'):\n", - " valor_destino = valor - 273.15\n", - " elif (destino == 'farenheit'):\n", - " valor_destino = ((valor - 273.15) * 9 / 5) + 32\n", - " elif (destino == 'kelvin'):\n", - " valor_destino = valor\n", - " else:\n", - " print('Parámetro de Destino incorrecto')\n", - " else:\n", - " print('Parámetro de Origen incorrecto')\n", - " return valor_destino\n", - "\n", - " def __factorial(self, numero):\n", - " if(type(numero) != int):\n", - " return 'El numero debe ser un entero'\n", - " if(numero < 0):\n", - " return 'El numero debe ser pisitivo'\n", - " if (numero > 1):\n", - " numero = numero * self.__factorial(numero - 1)\n", - " return numero" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "h = Herramientas([1,1,2,5,8,8,9,11,15,16,16,16,18,20])" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 grados celsius son 33.8 grados farenheit\n", - "1 grados celsius son 33.8 grados farenheit\n", - "2 grados celsius son 35.6 grados farenheit\n", - "5 grados celsius son 41.0 grados farenheit\n", - "8 grados celsius son 46.4 grados farenheit\n", - "8 grados celsius son 46.4 grados farenheit\n", - "9 grados celsius son 48.2 grados farenheit\n", - "11 grados celsius son 51.8 grados farenheit\n", - "15 grados celsius son 59.0 grados farenheit\n", - "16 grados celsius son 60.8 grados farenheit\n", - "16 grados celsius son 60.8 grados farenheit\n", - "16 grados celsius son 60.8 grados farenheit\n", - "18 grados celsius son 64.4 grados farenheit\n", - "20 grados celsius son 68.0 grados farenheit\n" - ] - } - ], - "source": [ - "h.conversion_grados('celsius','farenheit')" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "El elemento 1 SI es un numero primo\n", - "El elemento 1 SI es un numero primo\n", - "El elemento 2 SI es un numero primo\n", - "El elemento 5 SI es un numero primo\n", - "El elemento 8 NO es un numero primo\n", - "El elemento 8 NO es un numero primo\n", - "El elemento 9 NO es un numero primo\n", - "El elemento 11 SI es un numero primo\n", - "El elemento 15 NO es un numero primo\n", - "El elemento 16 NO es un numero primo\n", - "El elemento 16 NO es un numero primo\n", - "El elemento 16 NO es un numero primo\n", - "El elemento 18 NO es un numero primo\n", - "El elemento 20 NO es un numero primo\n" - ] - } - ], - "source": [ - "h.verifica_primo()" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "El valor modal es 16 y se reptie 3 veces\n" - ] - } - ], - "source": [ - "moda, repe = h.valor_modal(False)\n", - "print('El valor modal es', moda, 'y se reptie', repe, 'veces')" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "El factorial de 20 es 2432902008176640000\n", - "El factorial de 18 es 6402373705728000\n", - "El factorial de 16 es 20922789888000\n", - "El factorial de 16 es 20922789888000\n", - "El factorial de 16 es 20922789888000\n", - "El factorial de 15 es 1307674368000\n", - "El factorial de 11 es 39916800\n", - "El factorial de 9 es 362880\n", - "El factorial de 8 es 40320\n", - "El factorial de 8 es 40320\n", - "El factorial de 5 es 120\n", - "El factorial de 2 es 2\n", - "El factorial de 1 es 1\n", - "El factorial de 1 es 1\n" - ] - } - ], - "source": [ - "h.factorial()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "from herramientas import *" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "h2 = Herramientas([1,1,2,3,5,6,8,8])" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "El elemento 1 SI es un numero primo\n", - "El elemento 1 SI es un numero primo\n", - "El elemento 2 SI es un numero primo\n", - "El elemento 3 SI es un numero primo\n", - "El elemento 5 SI es un numero primo\n", - "El elemento 6 NO es un numero primo\n", - "El elemento 8 NO es un numero primo\n", - "El elemento 8 NO es un numero primo\n" - ] - } - ], - "source": [ - "h2.verifica_primo()" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.11" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clases y Programación Orientada a Objetos" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1) Crear la clase vehículo que contenga los atributos:
\n", + "Color
\n", + "Si es moto, auto, camioneta ó camión
\n", + "Cilindrada del motor" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# El método especial __init__ es el constructor de la clase Vehiculo(Se llama automáticamente cuando se crea una nueva instancia de la clase.El constructor recibe tres parámetros: color, tipo y cilindrada. La variable self se refiere al objeto actual (la instancia de la clase Vehiculo). Los parámetros color, tipo y cilindrada se asignan a los atributos correspondientes del objeto.\n", + "\n", + "class Vehiculo:\n", + " def __init__(self, color, tipo, cilindrada): \n", + " self.color = color\n", + " self.tipo = tipo\n", + " self.cilindrada = cilindrada\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
\n", + "Acelerar
\n", + "Frenar
\n", + "Doblar
" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "class Vehiculo:\n", + " def __init__(self, color, tipo, cilindrada):\n", + " self.color = color\n", + " self.tipo = tipo\n", + " self.cilindrada = cilindrada\n", + " self.velocidad = 0\n", + " self.direccion = 0\n", + "\n", + " def Acelerar(self, vel): # El método Acelerar recibe un parámetro \"vel\" que representa la velocidad a aumentar.\n", + " self.velocidad += vel # Aumenta la velocidad actual del vehículo sumando el valor de \"vel\" al atributo \"velocidad\".\n", + "\n", + " def Frenar(self, vel): # El método Frenar recibe un parámetro \"vel\" que representa la velocidad a disminuir.\n", + " self.velocidad -= vel # Disminuye la velocidad actual del vehículo restando el valor de \"vel\" al atributo \"velocidad\".\n", + " \n", + " def Doblar(self, grados): # El método Doblar recibe un parámetro \"grados\" que representa la cantidad de grados para girar.\n", + " self.direccion += grados # Actualiza la dirección del vehículo sumando el valor de \"grados\" al atributo \"direccion\"." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "a1 = Vehiculo('rojo', 'auto', 2) # Creación de un objeto \"Vehiculo\" con color rojo, tipo auto y cilindrada 2.\n", + "a2 = Vehiculo('blanco', 'camioneta', 3.6) # Creación de un objeto \"Vehiculo\" con color blanco, tipo camioneta y cilindrada 3.6.\n", + "a3 = Vehiculo('negro', 'moto', 1) # Creación de un objeto \"Vehiculo\" con color negro, tipo moto y cilindrada 1." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "a1.Acelerar(40) # Llamada al método \"Acelerar\" del objeto \"a1\" para aumentar la velocidad en 40.\n", + "a2.Acelerar(60) # Llamada al método \"Acelerar\" del objeto \"a2\" para aumentar la velocidad en 60.\n", + "a3.Acelerar(30) # Llamada al método \"Acelerar\" del objeto \"a3\" para aumentar la velocidad en 30.\n", + "\n", + "a1.Doblar(30) # Llamada al método \"Doblar\" del objeto \"a1\" para girar la dirección en 30 grados.\n", + "a3.Doblar(-30) # Llamada al método \"Doblar\" del objeto \"a3\" para girar la dirección en -30 grados.\n", + "\n", + "a2.Frenar(-50) # Llamada al método \"Frenar\" del objeto \"a2\" para disminuir la velocidad en -50." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "class Vehiculo:\n", + " def __init__(self, color, tipo, cilindrada):\n", + " self.color = color\n", + " self.tipo = tipo\n", + " self.cilindrada = cilindrada\n", + " self.velocidad = 0\n", + " self.direccion = 0\n", + "\n", + " def Acelerar(self, vel):\n", + " self.velocidad += vel\n", + "\n", + " def Frenar(self, vel):\n", + " self.velocidad -= vel\n", + " \n", + " def Doblar(self, grados):\n", + " self.direccion += grados\n", + "\n", + " def Estado(self):\n", + " print('Velocidad:', self.velocidad, '- Dirección:', self.direccion)\n", + "\n", + " def Detalle(self):\n", + " print('Soy', self.tipo, 'de color', self.color, 'y mi cilindrada es de', self.cilindrada, 'litros')\n", + "\n", + " def Estado(self): #Método para imprimir el estado actual del vehículo.\n", + " print('Velocidad:', self.velocidad, '- Dirección:', self.direccion) #Muestra la velocidad y dirección.\n", + "\n", + " def Detalle(self): #Método para imprimir los detalles del vehículo.\n", + " print('Soy', self.tipo, 'de color', self.color, 'y mi cilindrada es de', self.cilindrada, 'litros') #Muestra el tipo, color y cilindrada.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Soy auto de color rojo y mi cilindrada es de 2 litros\n" + ] + } + ], + "source": [ + "a1 = Vehiculo('rojo', 'auto', 2)\n", + "a1.Detalle()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Velocidad: 0 - Dirección: 0\n", + "Velocidad: 30 - Dirección: 0\n" + ] + } + ], + "source": [ + "a1.Estado()\n", + "a1.Acelerar(30)\n", + "a1.Estado()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 7
\n", + "Verificar Primo
\n", + "Valor modal
\n", + "Conversión grados
\n", + "Factorial
" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class Herramientas:\n", + " def __init__(self) -> None:\n", + " pass\n", + "\n", + " def verifica_primo(self, nro):\n", + " es_primo = True\n", + " for i in range(2, nro):\n", + " if nro % i == 0:\n", + " es_primo = False\n", + " break\n", + " return es_primo\n", + "\n", + " def valor_modal(lista):\n", + " lista_unicos = []\n", + " lista_repeticiones = []\n", + " if len(lista) == 0:\n", + " return None\n", + " for elemento in lista:\n", + " if elemento in lista_unicos:\n", + " i = lista_unicos.index(elemento)\n", + " lista_repeticiones[i] += 1\n", + " else:\n", + " lista_unicos.append(elemento)\n", + " lista_repeticiones.append(1)\n", + " moda = lista_unicos[0]\n", + " maximo = lista_repeticiones[0]\n", + " for i, elemento in enumerate(lista_unicos):\n", + " if lista_repeticiones[i] > maximo:\n", + " moda = lista_unicos[i]\n", + " maximo = lista_repeticiones[i]\n", + " return moda, maximo\n", + "\n", + " def conversion_grados(self, valor, origen, destino):\n", + " valor_destino = None\n", + " if (origen == 'celsius'):\n", + " if (destino == 'celsius'):\n", + " valor_destino = valor\n", + " elif (destino == 'farenheit'):\n", + " valor_destino = (valor * 9 / 5) + 32\n", + " elif (destino == 'kelvin'):\n", + " valor_destino = valor + 273.15\n", + " else:\n", + " print('Parámetro de Destino incorrecto')\n", + " elif (origen == 'farenheit'):\n", + " if (destino == 'celsius'):\n", + " valor_destino = (valor - 32) * 5 / 9\n", + " elif (destino == 'farenheit'):\n", + " valor_destino = valor\n", + " elif (destino == 'kelvin'):\n", + " valor_destino = ((valor - 32) * 5 / 9) + 273.15\n", + " else:\n", + " print('Parámetro de Destino incorrecto')\n", + " elif (origen == 'kelvin'):\n", + " if (destino == 'celsius'):\n", + " valor_destino = valor - 273.15\n", + " elif (destino == 'farenheit'):\n", + " valor_destino = ((valor - 273.15) * 9 / 5) + 32\n", + " elif (destino == 'kelvin'):\n", + " valor_destino = valor\n", + " else:\n", + " print('Parámetro de Destino incorrecto')\n", + " else:\n", + " print('Parámetro de Origen incorrecto')\n", + " return valor_destino\n", + "\n", + " def factorial(self, numero):\n", + " if(type(numero) != int):\n", + " return 'El numero debe ser un entero'\n", + " if(numero < 0):\n", + " return 'El numero debe ser pisitivo'\n", + " if (numero > 1):\n", + " numero = numero * self.factorial(numero - 1)\n", + " return numero" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "h = Herramientas()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) Probar las funciones incorporadas en la clase del punto 5" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h.verifica_primo(7)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El valor modal es 8 y se reptie 2 veces\n" + ] + } + ], + "source": [ + "listado = [1,8,2,5,4,8,10,7]\n", + "moda, repe = h.valor_modal(listado, True)\n", + "print('El valor modal es', moda, 'y se reptie', repe, 'veces')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "283.15" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h.conversion_grados(10, 'celsius', 'kelvin')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "720" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h.factorial(6)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "class Herramientas:\n", + " def __init__(self, lista_numeros):\n", + " self.lista = lista_numeros\n", + "\n", + " def verifica_primo(self):\n", + " for i in self.lista:\n", + " if (self.__verifica_primo(i)):\n", + " print('El elemento', i, 'SI es un numero primo')\n", + " else:\n", + " print('El elemento', i, 'NO es un numero primo')\n", + "\n", + " def conversion_grados(self, origen, destino):\n", + " for i in self.lista:\n", + " print(i, 'grados', origen, 'son', self.__conversion_grados(i, origen, destino),'grados',destino)\n", + " \n", + " def factorial(self):\n", + " for i in self.lista:\n", + " print('El factorial de ', i, 'es', self.__factorial(i))\n", + "\n", + " def __verifica_primo(self, nro):\n", + " es_primo = True\n", + " for i in range(2, nro):\n", + " if nro % i == 0:\n", + " es_primo = False\n", + " break\n", + " return es_primo\n", + "\n", + " def valor_modal(self, menor):\n", + " lista_unicos = []\n", + " lista_repeticiones = []\n", + " if len(self.lista) == 0:\n", + " return None\n", + " if (menor):\n", + " self.lista.sort()\n", + " else:\n", + " self.lista.sort(reverse=True)\n", + " for elemento in self.lista:\n", + " if elemento in lista_unicos:\n", + " i = lista_unicos.index(elemento)\n", + " lista_repeticiones[i] += 1\n", + " else:\n", + " lista_unicos.append(elemento)\n", + " lista_repeticiones.append(1)\n", + " moda = lista_unicos[0]\n", + " maximo = lista_repeticiones[0]\n", + " for i, elemento in enumerate(lista_unicos):\n", + " if lista_repeticiones[i] > maximo:\n", + " moda = lista_unicos[i]\n", + " maximo = lista_repeticiones[i]\n", + " return moda, maximo\n", + "\n", + " def __conversion_grados(self, valor, origen, destino):\n", + " valor_destino = None\n", + " if (origen == 'celsius'):\n", + " if (destino == 'celsius'):\n", + " valor_destino = valor\n", + " elif (destino == 'farenheit'):\n", + " valor_destino = (valor * 9 / 5) + 32\n", + " elif (destino == 'kelvin'):\n", + " valor_destino = valor + 273.15\n", + " else:\n", + " print('Parámetro de Destino incorrecto')\n", + " elif (origen == 'farenheit'):\n", + " if (destino == 'celsius'):\n", + " valor_destino = (valor - 32) * 5 / 9\n", + " elif (destino == 'farenheit'):\n", + " valor_destino = valor\n", + " elif (destino == 'kelvin'):\n", + " valor_destino = ((valor - 32) * 5 / 9) + 273.15\n", + " else:\n", + " print('Parámetro de Destino incorrecto')\n", + " elif (origen == 'kelvin'):\n", + " if (destino == 'celsius'):\n", + " valor_destino = valor - 273.15\n", + " elif (destino == 'farenheit'):\n", + " valor_destino = ((valor - 273.15) * 9 / 5) + 32\n", + " elif (destino == 'kelvin'):\n", + " valor_destino = valor\n", + " else:\n", + " print('Parámetro de Destino incorrecto')\n", + " else:\n", + " print('Parámetro de Origen incorrecto')\n", + " return valor_destino\n", + "\n", + " def __factorial(self, numero):\n", + " if(type(numero) != int):\n", + " return 'El numero debe ser un entero'\n", + " if(numero < 0):\n", + " return 'El numero debe ser pisitivo'\n", + " if (numero > 1):\n", + " numero = numero * self.__factorial(numero - 1)\n", + " return numero" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "h = Herramientas([1,1,2,5,8,8,9,11,15,16,16,16,18,20])" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 grados celsius son 33.8 grados farenheit\n", + "1 grados celsius son 33.8 grados farenheit\n", + "2 grados celsius son 35.6 grados farenheit\n", + "5 grados celsius son 41.0 grados farenheit\n", + "8 grados celsius son 46.4 grados farenheit\n", + "8 grados celsius son 46.4 grados farenheit\n", + "9 grados celsius son 48.2 grados farenheit\n", + "11 grados celsius son 51.8 grados farenheit\n", + "15 grados celsius son 59.0 grados farenheit\n", + "16 grados celsius son 60.8 grados farenheit\n", + "16 grados celsius son 60.8 grados farenheit\n", + "16 grados celsius son 60.8 grados farenheit\n", + "18 grados celsius son 64.4 grados farenheit\n", + "20 grados celsius son 68.0 grados farenheit\n" + ] + } + ], + "source": [ + "h.conversion_grados('celsius','farenheit')" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El elemento 1 SI es un numero primo\n", + "El elemento 1 SI es un numero primo\n", + "El elemento 2 SI es un numero primo\n", + "El elemento 5 SI es un numero primo\n", + "El elemento 8 NO es un numero primo\n", + "El elemento 8 NO es un numero primo\n", + "El elemento 9 NO es un numero primo\n", + "El elemento 11 SI es un numero primo\n", + "El elemento 15 NO es un numero primo\n", + "El elemento 16 NO es un numero primo\n", + "El elemento 16 NO es un numero primo\n", + "El elemento 16 NO es un numero primo\n", + "El elemento 18 NO es un numero primo\n", + "El elemento 20 NO es un numero primo\n" + ] + } + ], + "source": [ + "h.verifica_primo()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El valor modal es 16 y se reptie 3 veces\n" + ] + } + ], + "source": [ + "moda, repe = h.valor_modal(False)\n", + "print('El valor modal es', moda, 'y se reptie', repe, 'veces')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El factorial de 20 es 2432902008176640000\n", + "El factorial de 18 es 6402373705728000\n", + "El factorial de 16 es 20922789888000\n", + "El factorial de 16 es 20922789888000\n", + "El factorial de 16 es 20922789888000\n", + "El factorial de 15 es 1307674368000\n", + "El factorial de 11 es 39916800\n", + "El factorial de 9 es 362880\n", + "El factorial de 8 es 40320\n", + "El factorial de 8 es 40320\n", + "El factorial de 5 es 120\n", + "El factorial de 2 es 2\n", + "El factorial de 1 es 1\n", + "El factorial de 1 es 1\n" + ] + } + ], + "source": [ + "h.factorial()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from herramientas import *" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "h2 = Herramientas([1,1,2,3,5,6,8,8])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El elemento 1 SI es un numero primo\n", + "El elemento 1 SI es un numero primo\n", + "El elemento 2 SI es un numero primo\n", + "El elemento 3 SI es un numero primo\n", + "El elemento 5 SI es un numero primo\n", + "El elemento 6 NO es un numero primo\n", + "El elemento 8 NO es un numero primo\n", + "El elemento 8 NO es un numero primo\n" + ] + } + ], + "source": [ + "h2.verifica_primo()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/M08_clasesyOOP/Prep_Course_Homework_08-Resuelto.py b/M08_clasesyOOP/Prep_Course_Homework_08-Resuelto.py index 6dd60af6c..453d2b0c0 100644 --- a/M08_clasesyOOP/Prep_Course_Homework_08-Resuelto.py +++ b/M08_clasesyOOP/Prep_Course_Homework_08-Resuelto.py @@ -1,378 +1,378 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Clases y Programación Orientada a Objetos - -# 1) Crear la clase vehículo que contenga los atributos:
-# Color
-# Si es moto, auto, camioneta ó camión
-# Cilindrada del motor - -# In[1]: - - -class Vehiculo: - def __init__(self, color, tipo, cilindrada): - self.color = color - self.tipo = tipo - self.cilindrada = cilindrada - - -# 2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
-# Acelerar
-# Frenar
-# Doblar
- -# In[5]: - - -class Vehiculo: - def __init__(self, color, tipo, cilindrada): - self.color = color - self.tipo = tipo - self.cilindrada = cilindrada - self.velocidad = 0 - self.direccion = 0 - - def Acelerar(self, vel): - self.velocidad += vel - - def Frenar(self, vel): - self.velocidad -= vel - - def Doblar(self, grados): - self.direccion += grados - - -# 3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado - -# In[6]: - - -a1 = Vehiculo('rojo', 'auto', 2) -a2 = Vehiculo('blanco', 'camioneta', 3.6) -a3 = Vehiculo('negro', 'moto', 1) - - -# In[7]: - - -a1.Acelerar(40) -a2.Acelerar(60) -a3.Acelerar(30) -a1.Doblar(30) -a3.Doblar(-30) -a2.Frenar(-50) - - -# 4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada - -# In[12]: - - -class Vehiculo: - def __init__(self, color, tipo, cilindrada): - self.color = color - self.tipo = tipo - self.cilindrada = cilindrada - self.velocidad = 0 - self.direccion = 0 - - def Acelerar(self, vel): - self.velocidad += vel - - def Frenar(self, vel): - self.velocidad -= vel - - def Doblar(self, grados): - self.direccion += grados - - def Estado(self): - print('Velocidad:', self.velocidad, '- Dirección:', self.direccion) - - def Detalle(self): - print('Soy', self.tipo, 'de color', self.color, 'y mi cilindrada es de', self.cilindrada, 'litros') - - -# In[13]: - - -a1 = Vehiculo('rojo', 'auto', 2) -a1.Detalle() - - -# In[14]: - - -a1.Estado() -a1.Acelerar(30) -a1.Estado() - - -# 5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 7
-# Verificar Primo
-# Valor modal
-# Conversión grados
-# Factorial
- -# In[33]: - - -class Herramientas: - def __init__(self) -> None: - pass - - def verifica_primo(self, nro): - es_primo = True - for i in range(2, nro): - if nro % i == 0: - es_primo = False - break - return es_primo - - def valor_modal(lista): - lista_unicos = [] - lista_repeticiones = [] - if len(lista) == 0: - return None - for elemento in lista: - if elemento in lista_unicos: - i = lista_unicos.index(elemento) - lista_repeticiones[i] += 1 - else: - lista_unicos.append(elemento) - lista_repeticiones.append(1) - moda = lista_unicos[0] - maximo = lista_repeticiones[0] - for i, elemento in enumerate(lista_unicos): - if lista_repeticiones[i] > maximo: - moda = lista_unicos[i] - maximo = lista_repeticiones[i] - return moda, maximo - - def conversion_grados(self, valor, origen, destino): - valor_destino = None - if (origen == 'celsius'): - if (destino == 'celsius'): - valor_destino = valor - elif (destino == 'farenheit'): - valor_destino = (valor * 9 / 5) + 32 - elif (destino == 'kelvin'): - valor_destino = valor + 273.15 - else: - print('Parámetro de Destino incorrecto') - elif (origen == 'farenheit'): - if (destino == 'celsius'): - valor_destino = (valor - 32) * 5 / 9 - elif (destino == 'farenheit'): - valor_destino = valor - elif (destino == 'kelvin'): - valor_destino = ((valor - 32) * 5 / 9) + 273.15 - else: - print('Parámetro de Destino incorrecto') - elif (origen == 'kelvin'): - if (destino == 'celsius'): - valor_destino = valor - 273.15 - elif (destino == 'farenheit'): - valor_destino = ((valor - 273.15) * 9 / 5) + 32 - elif (destino == 'kelvin'): - valor_destino = valor - else: - print('Parámetro de Destino incorrecto') - else: - print('Parámetro de Origen incorrecto') - return valor_destino - - def factorial(self, numero): - if(type(numero) != int): - return 'El numero debe ser un entero' - if(numero < 0): - return 'El numero debe ser pisitivo' - if (numero > 1): - numero = numero * self.factorial(numero - 1) - return numero - - -# In[34]: - - -h = Herramientas() - - -# 6) Probar las funciones incorporadas en la clase del punto 5 - -# In[28]: - - -h.verifica_primo(7) - - -# In[29]: - - -listado = [1,8,2,5,4,8,10,7] -moda, repe = h.valor_modal(listado, True) -print('El valor modal es', moda, 'y se reptie', repe, 'veces') - - -# In[31]: - - -h.conversion_grados(10, 'celsius', 'kelvin') - - -# In[35]: - - -h.factorial(6) - - -# 7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas - -# In[55]: - - -class Herramientas: - def __init__(self, lista_numeros): - self.lista = lista_numeros - - def verifica_primo(self): - for i in self.lista: - if (self.__verifica_primo(i)): - print('El elemento', i, 'SI es un numero primo') - else: - print('El elemento', i, 'NO es un numero primo') - - def conversion_grados(self, origen, destino): - for i in self.lista: - print(i, 'grados', origen, 'son', self.__conversion_grados(i, origen, destino),'grados',destino) - - def factorial(self): - for i in self.lista: - print('El factorial de ', i, 'es', self.__factorial(i)) - - def __verifica_primo(self, nro): - es_primo = True - for i in range(2, nro): - if nro % i == 0: - es_primo = False - break - return es_primo - - def valor_modal(self, menor): - lista_unicos = [] - lista_repeticiones = [] - if len(self.lista) == 0: - return None - if (menor): - self.lista.sort() - else: - self.lista.sort(reverse=True) - for elemento in self.lista: - if elemento in lista_unicos: - i = lista_unicos.index(elemento) - lista_repeticiones[i] += 1 - else: - lista_unicos.append(elemento) - lista_repeticiones.append(1) - moda = lista_unicos[0] - maximo = lista_repeticiones[0] - for i, elemento in enumerate(lista_unicos): - if lista_repeticiones[i] > maximo: - moda = lista_unicos[i] - maximo = lista_repeticiones[i] - return moda, maximo - - def __conversion_grados(self, valor, origen, destino): - valor_destino = None - if (origen == 'celsius'): - if (destino == 'celsius'): - valor_destino = valor - elif (destino == 'farenheit'): - valor_destino = (valor * 9 / 5) + 32 - elif (destino == 'kelvin'): - valor_destino = valor + 273.15 - else: - print('Parámetro de Destino incorrecto') - elif (origen == 'farenheit'): - if (destino == 'celsius'): - valor_destino = (valor - 32) * 5 / 9 - elif (destino == 'farenheit'): - valor_destino = valor - elif (destino == 'kelvin'): - valor_destino = ((valor - 32) * 5 / 9) + 273.15 - else: - print('Parámetro de Destino incorrecto') - elif (origen == 'kelvin'): - if (destino == 'celsius'): - valor_destino = valor - 273.15 - elif (destino == 'farenheit'): - valor_destino = ((valor - 273.15) * 9 / 5) + 32 - elif (destino == 'kelvin'): - valor_destino = valor - else: - print('Parámetro de Destino incorrecto') - else: - print('Parámetro de Origen incorrecto') - return valor_destino - - def __factorial(self, numero): - if(type(numero) != int): - return 'El numero debe ser un entero' - if(numero < 0): - return 'El numero debe ser pisitivo' - if (numero > 1): - numero = numero * self.__factorial(numero - 1) - return numero - - -# In[56]: - - -h = Herramientas([1,1,2,5,8,8,9,11,15,16,16,16,18,20]) - - -# In[57]: - - -h.conversion_grados('celsius','farenheit') - - -# In[58]: - - -h.verifica_primo() - - -# In[59]: - - -moda, repe = h.valor_modal(False) -print('El valor modal es', moda, 'y se reptie', repe, 'veces') - - -# In[60]: - - -h.factorial() - - -# 8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones - -# In[1]: - - -from herramientas import * - - -# In[2]: - - -h2 = Herramientas([1,1,2,3,5,6,8,8]) - - -# In[3]: - - -h2.verifica_primo() - +#!/usr/bin/env python +# coding: utf-8 + +# ## Clases y Programación Orientada a Objetos + +# 1) Crear la clase vehículo que contenga los atributos:
+# Color
+# Si es moto, auto, camioneta ó camión
+# Cilindrada del motor + +# In[1]: + + +class Vehiculo: + def __init__(self, color, tipo, cilindrada): + self.color = color + self.tipo = tipo + self.cilindrada = cilindrada + + +# 2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
+# Acelerar
+# Frenar
+# Doblar
+ +# In[5]: + + +class Vehiculo: + def __init__(self, color, tipo, cilindrada): + self.color = color + self.tipo = tipo + self.cilindrada = cilindrada + self.velocidad = 0 + self.direccion = 0 + + def Acelerar(self, vel): + self.velocidad += vel + + def Frenar(self, vel): + self.velocidad -= vel + + def Doblar(self, grados): + self.direccion += grados + + +# 3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado + +# In[6]: + + +a1 = Vehiculo('rojo', 'auto', 2) +a2 = Vehiculo('blanco', 'camioneta', 3.6) +a3 = Vehiculo('negro', 'moto', 1) + + +# In[7]: + + +a1.Acelerar(40) +a2.Acelerar(60) +a3.Acelerar(30) +a1.Doblar(30) +a3.Doblar(-30) +a2.Frenar(-50) + + +# 4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada + +# In[12]: + + +class Vehiculo: + def __init__(self, color, tipo, cilindrada): + self.color = color + self.tipo = tipo + self.cilindrada = cilindrada + self.velocidad = 0 + self.direccion = 0 + + def Acelerar(self, vel): + self.velocidad += vel + + def Frenar(self, vel): + self.velocidad -= vel + + def Doblar(self, grados): + self.direccion += grados + + def Estado(self): + print('Velocidad:', self.velocidad, '- Dirección:', self.direccion) + + def Detalle(self): + print('Soy', self.tipo, 'de color', self.color, 'y mi cilindrada es de', self.cilindrada, 'litros') + + +# In[13]: + + +a1 = Vehiculo('rojo', 'auto', 2) +a1.Detalle() + + +# In[14]: + + +a1.Estado() +a1.Acelerar(30) +a1.Estado() + + +# 5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 7
+# Verificar Primo
+# Valor modal
+# Conversión grados
+# Factorial
+ +# In[33]: + + +class Herramientas: + def __init__(self) -> None: + pass + + def verifica_primo(self, nro): + es_primo = True + for i in range(2, nro): + if nro % i == 0: + es_primo = False + break + return es_primo + + def valor_modal(lista): + lista_unicos = [] + lista_repeticiones = [] + if len(lista) == 0: + return None + for elemento in lista: + if elemento in lista_unicos: + i = lista_unicos.index(elemento) + lista_repeticiones[i] += 1 + else: + lista_unicos.append(elemento) + lista_repeticiones.append(1) + moda = lista_unicos[0] + maximo = lista_repeticiones[0] + for i, elemento in enumerate(lista_unicos): + if lista_repeticiones[i] > maximo: + moda = lista_unicos[i] + maximo = lista_repeticiones[i] + return moda, maximo + + def conversion_grados(self, valor, origen, destino): + valor_destino = None + if (origen == 'celsius'): + if (destino == 'celsius'): + valor_destino = valor + elif (destino == 'farenheit'): + valor_destino = (valor * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'farenheit'): + if (destino == 'celsius'): + valor_destino = (valor - 32) * 5 / 9 + elif (destino == 'farenheit'): + valor_destino = valor + elif (destino == 'kelvin'): + valor_destino = ((valor - 32) * 5 / 9) + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'kelvin'): + if (destino == 'celsius'): + valor_destino = valor - 273.15 + elif (destino == 'farenheit'): + valor_destino = ((valor - 273.15) * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + else: + print('Parámetro de Destino incorrecto') + else: + print('Parámetro de Origen incorrecto') + return valor_destino + + def factorial(self, numero): + if(type(numero) != int): + return 'El numero debe ser un entero' + if(numero < 0): + return 'El numero debe ser pisitivo' + if (numero > 1): + numero = numero * self.factorial(numero - 1) + return numero + + +# In[34]: + + +h = Herramientas() + + +# 6) Probar las funciones incorporadas en la clase del punto 5 + +# In[28]: + + +h.verifica_primo(7) + + +# In[29]: + + +listado = [1,8,2,5,4,8,10,7] +moda, repe = h.valor_modal(listado, True) +print('El valor modal es', moda, 'y se reptie', repe, 'veces') + + +# In[31]: + + +h.conversion_grados(10, 'celsius', 'kelvin') + + +# In[35]: + + +h.factorial(6) + + +# 7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas + +# In[55]: + + +class Herramientas: + def __init__(self, lista_numeros): + self.lista = lista_numeros + + def verifica_primo(self): + for i in self.lista: + if (self.__verifica_primo(i)): + print('El elemento', i, 'SI es un numero primo') + else: + print('El elemento', i, 'NO es un numero primo') + + def conversion_grados(self, origen, destino): + for i in self.lista: + print(i, 'grados', origen, 'son', self.__conversion_grados(i, origen, destino),'grados',destino) + + def factorial(self): + for i in self.lista: + print('El factorial de ', i, 'es', self.__factorial(i)) + + def __verifica_primo(self, nro): + es_primo = True + for i in range(2, nro): + if nro % i == 0: + es_primo = False + break + return es_primo + + def valor_modal(self, menor): + lista_unicos = [] + lista_repeticiones = [] + if len(self.lista) == 0: + return None + if (menor): + self.lista.sort() + else: + self.lista.sort(reverse=True) + for elemento in self.lista: + if elemento in lista_unicos: + i = lista_unicos.index(elemento) + lista_repeticiones[i] += 1 + else: + lista_unicos.append(elemento) + lista_repeticiones.append(1) + moda = lista_unicos[0] + maximo = lista_repeticiones[0] + for i, elemento in enumerate(lista_unicos): + if lista_repeticiones[i] > maximo: + moda = lista_unicos[i] + maximo = lista_repeticiones[i] + return moda, maximo + + def __conversion_grados(self, valor, origen, destino): + valor_destino = None + if (origen == 'celsius'): + if (destino == 'celsius'): + valor_destino = valor + elif (destino == 'farenheit'): + valor_destino = (valor * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'farenheit'): + if (destino == 'celsius'): + valor_destino = (valor - 32) * 5 / 9 + elif (destino == 'farenheit'): + valor_destino = valor + elif (destino == 'kelvin'): + valor_destino = ((valor - 32) * 5 / 9) + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'kelvin'): + if (destino == 'celsius'): + valor_destino = valor - 273.15 + elif (destino == 'farenheit'): + valor_destino = ((valor - 273.15) * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + else: + print('Parámetro de Destino incorrecto') + else: + print('Parámetro de Origen incorrecto') + return valor_destino + + def __factorial(self, numero): + if(type(numero) != int): + return 'El numero debe ser un entero' + if(numero < 0): + return 'El numero debe ser pisitivo' + if (numero > 1): + numero = numero * self.__factorial(numero - 1) + return numero + + +# In[56]: + + +h = Herramientas([1,1,2,5,8,8,9,11,15,16,16,16,18,20]) + + +# In[57]: + + +h.conversion_grados('celsius','farenheit') + + +# In[58]: + + +h.verifica_primo() + + +# In[59]: + + +moda, repe = h.valor_modal(False) +print('El valor modal es', moda, 'y se reptie', repe, 'veces') + + +# In[60]: + + +h.factorial() + + +# 8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones + +# In[1]: + + +from herramientas import * + + +# In[2]: + + +h2 = Herramientas([1,1,2,3,5,6,8,8]) + + +# In[3]: + + +h2.verifica_primo() + diff --git a/M08_clasesyOOP/Prep_Course_Homework_08.ipynb b/M08_clasesyOOP/Prep_Course_Homework_08.ipynb index 3d21ca077..1729e3bb9 100644 --- a/M08_clasesyOOP/Prep_Course_Homework_08.ipynb +++ b/M08_clasesyOOP/Prep_Course_Homework_08.ipynb @@ -21,10 +21,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "class Vehiculo:\n", + " def __init__(self, Color,Tipo,Cilindros):\n", + " self.Color = Color\n", + " self.Tipo = Tipo\n", + " self.Cilindros = Cilindros\n", + " \n", + " pass" + ] }, { "attachments": {}, @@ -39,10 +47,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "class Vehiculo:\n", + " def __init__(self, Color, Tipo,Cilindros):\n", + " self.Color = Color\n", + " self.Tipo = Tipo\n", + " self.Cilindros = Cilindros\n", + " self.Velocidad = 0\n", + " self.Direccion = 0\n", + "\n", + " def Acelerar(self, Aceleracion):\n", + " self.Velocidad += Aceleracion\n", + "\n", + " def Frenar(self, Frenado):\n", + " if(self.Velocidad > 0):\n", + " self.Velocidad -= Frenado\n", + " \n", + " def Doblar(self, Sentido):\n", + " self.Direccion += Sentido\n" + ] }, { "attachments": {}, @@ -54,10 +80,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "Lamborghini = Vehiculo(\"Rojo\",\"Carro\",6)\n", + "Ducati = Vehiculo(\"Negra\",\"Moto\",2)\n", + "Ford = Vehiculo(\"Blanca\",\"Camioneta\",8)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "Lamborghini.Acelerar(100)\n", + "Lamborghini.Frenar(30)\n", + "Lamborghini.Doblar(45)\n", + "Ducati.Acelerar(40)\n", + "Ducati.Frenar(40)\n", + "Ducati.Doblar(20)\n", + "Ford.Frenar(20)\n", + "Ford.Doblar(-35)" + ] }, { "attachments": {}, @@ -69,10 +115,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "class Vehiculo:\n", + " def __init__(self, Color, Tipo,Cilindros):\n", + " self.Color = Color\n", + " self.Tipo = Tipo\n", + " self.Cilindros = Cilindros\n", + " self.Velocidad = 0\n", + " self.Direccion = 0\n", + "\n", + " def Acelerar(self, Aceleracion):\n", + " self.Velocidad += Aceleracion\n", + "\n", + " def Frenar(self, Frenado):\n", + " if(self.Velocidad > 0):\n", + " self.Velocidad -= Frenado\n", + " \n", + " def Doblar(self, Sentido):\n", + " self.Direccion += Sentido\n", + "\n", + " def Estado(self):\n", + " print(\"La velocidad es: \", self.Velocidad, \" y la dirección es: \", self.Direccion)\n", + "\n", + " def MostrarAtributos(self):\n", + " print(\"El color es: \", self.Color, \" el tipo es: \", self.Tipo, \" Los cilindros son: \", self.Cilindros)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La velocidad es: 30 y la dirección es: -2\n", + "El color es: Rojo el tipo es: Carro Los cilindros son: 6\n" + ] + } + ], + "source": [ + "Lamborghini = Vehiculo(\"Rojo\",\"Carro\",6)\n", + "Lamborghini.Acelerar(50)\n", + "Lamborghini.Frenar(20)\n", + "Lamborghini.Doblar(-2)\n", + "Lamborghini.Estado()\n", + "Lamborghini.MostrarAtributos()" + ] }, { "attachments": {}, @@ -88,10 +181,76 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "class Funciones7:\n", + " def __init__(self) -> None:\n", + " pass\n", + "\n", + " def ValidarPrimo(self, Numero):\n", + " EsPrimo = True\n", + " for div in range(2, Numero):\n", + " if (Numero % div == 0):\n", + " EsPrimo = False\n", + " break\n", + " return EsPrimo\n", + " \n", + " def ContarDuplicados(self, ListaDeEvaluacion):\n", + " i = 0\n", + " TotalRepeticiones = 0\n", + " MasRepetido = 0\n", + " for Elemento in ListaDeEvaluacion:\n", + " Repeticiones = 0\n", + " j = 0 \n", + " for Elemento in ListaDeEvaluacion:\n", + " if (ListaDeEvaluacion[i] == ListaDeEvaluacion[j]):\n", + " Repeticiones+=1\n", + " j+=1\n", + " if(TotalRepeticiones < Repeticiones):\n", + " TotalRepeticiones = Repeticiones\n", + " MasRepetido = ListaDeEvaluacion[i]\n", + " i+=1\n", + " return MasRepetido,TotalRepeticiones\n", + " \n", + " def ConvertirGrados(self, Grados,Origen,Destino):\n", + " if(Origen == \"Celsius\" and Destino == \"Farenheit\"):\n", + " Resultado = (Grados * 1.8) + 32\n", + " elif (Origen == \"Celsius\" and Destino == \"Kelvin\"):\n", + " Resultado = Grados + 273.15\n", + " elif (Origen == \"Celsius\" and Destino == \"Celsius\"):\n", + " Resultado = Grados\n", + " elif (Origen == \"Farenheit\" and Destino == \"Celsius\"):\n", + " Resultado = (Grados - 32) * (5/9)\n", + " elif (Origen == \"Farenheit\" and Destino == \"Kelvin\"):\n", + " Resultado = (Grados - 32) * (5/9) + 273.15\n", + " elif (Origen == \"Farenheit\" and Destino == \"Farenheit\"):\n", + " Resultado = Grados\n", + " elif (Origen == \"Kelvin\" and Destino == \"Celsius\"):\n", + " Resultado = (Grados - 273.15)\n", + " elif (Origen == \"Kelvin\" and Destino == \"Farenheit\"):\n", + " Resultado = (Grados - 273.15) * (9/5) + 32\n", + " elif (Origen == \"Kelvin\" and Destino == \"Kelvin\"):\n", + " Resultado = Grados\n", + " else:\n", + " print(\"Parámetros incorrectos\")\n", + " \n", + " def Factorial(self, Numero):\n", + " if(type(Numero) != int):\n", + " return \"EL número debe de ser entero\"\n", + " \n", + " if(Numero < 0):\n", + " return \"El número debe de ser positivo\"\n", + " \n", + " if(Numero <= 1):\n", + " return 1\n", + " \n", + " Numero = Numero * self.Factorial(Numero -1)\n", + " return Numero\n", + "\n", + "Herramientas = Funciones7()" + ] }, { "attachments": {}, @@ -103,10 +262,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validar Primo: True\n", + "Duplicados: (2, 7)\n", + "Convertir Grados: None\n", + "Factorial: 120\n" + ] + } + ], + "source": [ + "print(\"Validar Primo: \", Herramientas.ValidarPrimo(13))\n", + "Mi_Lista = [1,2,3,3,2,1,2,331,2,3111,23,21,12,3,1,2,24,1,34,2,1,2,31,12,23,11,22,1231,1]\n", + "print(\"Duplicados:\", Herramientas.ContarDuplicados(Mi_Lista))\n", + "print(\"Convertir Grados: \", Herramientas.ConvertirGrados(50,\"Celsius\",\"Farenheit\"))\n", + "print(\"Factorial: \", Herramientas.Factorial(5))" + ] }, { "attachments": {}, @@ -118,10 +294,123 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 92, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "class Funciones7:\n", + " def __init__(self, ListaEvaluada):\n", + " self.Lista = ListaEvaluada\n", + "\n", + " def ValidarPrimo(self):\n", + " for i in self.Lista:\n", + " if(self.__ValidarPrimo(i)):\n", + " print(\"El número: \", i, \"es primo\")\n", + " else:\n", + " print(\"El número: \", i, \"no es primo\")\n", + "\n", + " def ConvertirGrados(self, Origen, Destino):\n", + " for i in self.Lista:\n", + " print(i,\"Grados \", Origen, \" son: \" , self.__ConvertirGrados(i, Origen, Destino), \" en \", Destino)\n", + " \n", + " def Factorial(self):\n", + " for i in self.Lista:\n", + " print(\"El factorial de: \", i, \" es: \", self.__Factorial(i))\n", + " \n", + " def __ValidarPrimo(self, Numero):\n", + " EsPrimo = True\n", + " for div in range(2, Numero):\n", + " if (Numero % div == 0):\n", + " EsPrimo = False\n", + " break\n", + " return EsPrimo\n", + " \n", + " def ContarDuplicados(self, ListaDeEvaluacion):\n", + " i = 0\n", + " TotalRepeticiones = 0\n", + " MasRepetido = 0\n", + " for Elemento in ListaDeEvaluacion:\n", + " Repeticiones = 0\n", + " j = 0 \n", + " for Elemento in ListaDeEvaluacion:\n", + " if (ListaDeEvaluacion[i] == ListaDeEvaluacion[j]):\n", + " Repeticiones+=1\n", + " j+=1\n", + " if(TotalRepeticiones < Repeticiones):\n", + " TotalRepeticiones = Repeticiones\n", + " MasRepetido = ListaDeEvaluacion[i]\n", + " i+=1\n", + " return MasRepetido,TotalRepeticiones\n", + " \n", + " def __ConvertirGrados(self, Grados, Origen, Destino):\n", + " if(Origen == \"Celsius\" and Destino == \"Farenheit\"):\n", + " Resultado = (Grados * 1.8) + 32\n", + " elif (Origen == \"Celsius\" and Destino == \"Kelvin\"):\n", + " Resultado = Grados + 273.15\n", + " elif (Origen == \"Celsius\" and Destino == \"Celsius\"):\n", + " Resultado = Grados\n", + " elif (Origen == \"Farenheit\" and Destino == \"Celsius\"):\n", + " Resultado = (Grados - 32) * (5/9)\n", + " elif (Origen == \"Farenheit\" and Destino == \"Kelvin\"):\n", + " Resultado = (Grados - 32) * (5/9) + 273.15\n", + " elif (Origen == \"Farenheit\" and Destino == \"Farenheit\"):\n", + " Resultado = Grados\n", + " elif (Origen == \"Kelvin\" and Destino == \"Celsius\"):\n", + " Resultado = (Grados - 273.15)\n", + " elif (Origen == \"Kelvin\" and Destino == \"Farenheit\"):\n", + " Resultado = (Grados - 273.15) * (9/5) + 32\n", + " elif (Origen == \"Kelvin\" and Destino == \"Kelvin\"):\n", + " Resultado = Grados\n", + " else:\n", + " print(\"Parámetros incorrectos\")\n", + "\n", + " return Resultado\n", + " \n", + " def __Factorial(self, Numero):\n", + " if(type(Numero) != int):\n", + " return \"EL número debe de ser entero\"\n", + " \n", + " if(Numero < 0):\n", + " return \"El número debe de ser positivo\"\n", + " \n", + " if(Numero <= 1):\n", + " return 1\n", + " \n", + " Numero = Numero * self.__Factorial(Numero -1)\n", + " return Numero" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El número: 28 no es primo\n", + "El número: 31 es primo\n", + "El número: 27 no es primo\n", + "28 Grados Celsius son: 82.4 en Farenheit\n", + "31 Grados Celsius son: 87.80000000000001 en Farenheit\n", + "27 Grados Celsius son: 80.6 en Farenheit\n", + "El factorial de: 28 es: 304888344611713860501504000000\n", + "El factorial de: 31 es: 8222838654177922817725562880000000\n", + "El factorial de: 27 es: 10888869450418352160768000000\n", + "El más repetido es: 28 con: 1\n" + ] + } + ], + "source": [ + "Mi_Lista2 = [28,31,27]\n", + "Herramientas = Funciones7(Mi_Lista2)\n", + "Herramientas.ValidarPrimo()\n", + "Herramientas.ConvertirGrados(\"Celsius\",\"Farenheit\")\n", + "Herramientas.Factorial()\n", + "MasRepetido, Repeticiones = Herramientas.ContarDuplicados(Mi_Lista2)\n", + "print(\"El más repetido es: \", MasRepetido, \" con: \", Repeticiones)" + ] }, { "attachments": {}, @@ -133,10 +422,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 107, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El factorial de: 27 es: 10888869450418352160768000000\n", + "El factorial de: 28 es: 304888344611713860501504000000\n", + "El factorial de: 27 es: 10888869450418352160768000000\n", + "El factorial de: 30 es: 265252859812191058636308480000000\n", + "El factorial de: 31 es: 8222838654177922817725562880000000\n" + ] + } + ], + "source": [ + "from LibreriaFunciones import *\n", + "\n", + "Instancia = Funciones7([27,28,27,30,31])\n", + "Instancia.Factorial()" + ] } ], "metadata": { @@ -158,7 +464,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/M08_clasesyOOP/Prep_Course_Homework_08.md b/M08_clasesyOOP/Prep_Course_Homework_08.md index c02a29d1a..cfcde7e38 100644 --- a/M08_clasesyOOP/Prep_Course_Homework_08.md +++ b/M08_clasesyOOP/Prep_Course_Homework_08.md @@ -1,27 +1,27 @@ -## Clases y Programación Orientada a Objetos - -1) Crear la clase vehículo que contenga los atributos:
-Color
-Si es moto, auto, camioneta ó camión
-Cilindrada del motor - -2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
-Acelerar
-Frenar
-Doblar
- -3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado - -4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada - -5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 6
-Verificar Primo
-Valor modal
-Conversión grados
-Factorial
- -6) Probar las funciones incorporadas en la clase del punto 5 - -7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas - -8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones +## Clases y Programación Orientada a Objetos + +1) Crear la clase vehículo que contenga los atributos:
+Color
+Si es moto, auto, camioneta ó camión
+Cilindrada del motor + +2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
+Acelerar
+Frenar
+Doblar
+ +3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado + +4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada + +5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 6
+Verificar Primo
+Valor modal
+Conversión grados
+Factorial
+ +6) Probar las funciones incorporadas en la clase del punto 5 + +7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas + +8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones diff --git a/M08_clasesyOOP/Prep_Course_Homework_08.py b/M08_clasesyOOP/Prep_Course_Homework_08.py index 5a3b936ee..a12f6a8ce 100644 --- a/M08_clasesyOOP/Prep_Course_Homework_08.py +++ b/M08_clasesyOOP/Prep_Course_Homework_08.py @@ -1,85 +1,85 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Clases y Programación Orientada a Objetos - -# 1) Crear la clase vehículo que contenga los atributos:
-# Color
-# Si es moto, auto, camioneta ó camión
-# Cilindrada del motor - -# In[1]: - - - - -# 2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
-# Acelerar
-# Frenar
-# Doblar
- -# In[5]: - - - - - -# 3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado - -# In[6]: - - - - - -# 4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada - -# In[12]: - - - - - - -# In[13]: - - - - - - -# 5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 7
-# Verificar Primo
-# Valor modal
-# Conversión grados
-# Factorial
- -# In[33]: - - - - - - -# 6) Probar las funciones incorporadas en la clase del punto 5 - -# In[28]: - - - - - -# 7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas - -# In[55]: - - - - -# 8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones - -# In[1]: - - - - +#!/usr/bin/env python +# coding: utf-8 + +# ## Clases y Programación Orientada a Objetos + +# 1) Crear la clase vehículo que contenga los atributos:
+# Color
+# Si es moto, auto, camioneta ó camión
+# Cilindrada del motor + +# In[1]: + + + + +# 2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
+# Acelerar
+# Frenar
+# Doblar
+ +# In[5]: + + + + + +# 3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado + +# In[6]: + + + + + +# 4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada + +# In[12]: + + + + + + +# In[13]: + + + + + + +# 5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 7
+# Verificar Primo
+# Valor modal
+# Conversión grados
+# Factorial
+ +# In[33]: + + + + + + +# 6) Probar las funciones incorporadas en la clase del punto 5 + +# In[28]: + + + + + +# 7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas + +# In[55]: + + + + +# 8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones + +# In[1]: + + + + diff --git a/M08_clasesyOOP/herramientas.py b/M08_clasesyOOP/herramientas.py index 3be4065b5..2ffe91d4a 100644 --- a/M08_clasesyOOP/herramientas.py +++ b/M08_clasesyOOP/herramientas.py @@ -1,95 +1,95 @@ -class Herramientas: - def __init__(self, lista_numeros): - self.lista = lista_numeros - - def verifica_primo(self): - ''' - Explico lo que hace la funcion - ''' - for i in self.lista: - if (self.__verifica_primo(i)): - print('El elemento', i, 'SI es un numero primo') - else: - print('El elemento', i, 'NO es un numero primo') - - def conversion_grados(self, origen, destino): - for i in self.lista: - print(i, 'grados', origen, 'son', self.__conversion_grados(i, origen, destino),'grados',destino) - - def factorial(self): - for i in self.lista: - print('El factorial de ', i, 'es', self.__factorial(i)) - - def __verifica_primo(self, nro): - es_primo = True - for i in range(2, nro): - if nro % i == 0: - es_primo = False - break - return es_primo - - def valor_modal(self, menor): - lista_unicos = [] - lista_repeticiones = [] - if len(self.lista) == 0: - return None - if (menor): - self.lista.sort() - else: - self.lista.sort(reverse=True) - for elemento in self.lista: - if elemento in lista_unicos: - i = lista_unicos.index(elemento) - lista_repeticiones[i] += 1 - else: - lista_unicos.append(elemento) - lista_repeticiones.append(1) - moda = lista_unicos[0] - maximo = lista_repeticiones[0] - for i, elemento in enumerate(lista_unicos): - if lista_repeticiones[i] > maximo: - moda = lista_unicos[i] - maximo = lista_repeticiones[i] - return moda, maximo - - def __conversion_grados(self, valor, origen, destino): - valor_destino = None - if (origen == 'celsius'): - if (destino == 'celsius'): - valor_destino = valor - elif (destino == 'farenheit'): - valor_destino = (valor * 9 / 5) + 32 - elif (destino == 'kelvin'): - valor_destino = valor + 273.15 - else: - print('Parámetro de Destino incorrecto') - elif (origen == 'farenheit'): - if (destino == 'celsius'): - valor_destino = (valor - 32) * 5 / 9 - elif (destino == 'farenheit'): - valor_destino = valor - elif (destino == 'kelvin'): - valor_destino = ((valor - 32) * 5 / 9) + 273.15 - else: - print('Parámetro de Destino incorrecto') - elif (origen == 'kelvin'): - if (destino == 'celsius'): - valor_destino = valor - 273.15 - elif (destino == 'farenheit'): - valor_destino = ((valor - 273.15) * 9 / 5) + 32 - elif (destino == 'kelvin'): - valor_destino = valor - else: - print('Parámetro de Destino incorrecto') - else: - print('Parámetro de Origen incorrecto') - return valor_destino - - def __factorial(self, numero): - if(type(numero) != int): - return 'El numero debe ser un entero' - if(numero < 0): - return 'El numero debe ser pisitivo' - if (numero > 1): - numero = numero * self.__factorial(numero - 1) +class Herramientas: + def __init__(self, lista_numeros): + self.lista = lista_numeros + + def verifica_primo(self): + ''' + Explico lo que hace la funcion + ''' + for i in self.lista: + if (self.__verifica_primo(i)): + print('El elemento', i, 'SI es un numero primo') + else: + print('El elemento', i, 'NO es un numero primo') + + def conversion_grados(self, origen, destino): + for i in self.lista: + print(i, 'grados', origen, 'son', self.__conversion_grados(i, origen, destino),'grados',destino) + + def factorial(self): + for i in self.lista: + print('El factorial de ', i, 'es', self.__factorial(i)) + + def __verifica_primo(self, nro): + es_primo = True + for i in range(2, nro): + if nro % i == 0: + es_primo = False + break + return es_primo + + def valor_modal(self, menor): + lista_unicos = [] + lista_repeticiones = [] + if len(self.lista) == 0: + return None + if (menor): + self.lista.sort() + else: + self.lista.sort(reverse=True) + for elemento in self.lista: + if elemento in lista_unicos: + i = lista_unicos.index(elemento) + lista_repeticiones[i] += 1 + else: + lista_unicos.append(elemento) + lista_repeticiones.append(1) + moda = lista_unicos[0] + maximo = lista_repeticiones[0] + for i, elemento in enumerate(lista_unicos): + if lista_repeticiones[i] > maximo: + moda = lista_unicos[i] + maximo = lista_repeticiones[i] + return moda, maximo + + def __conversion_grados(self, valor, origen, destino): + valor_destino = None + if (origen == 'celsius'): + if (destino == 'celsius'): + valor_destino = valor + elif (destino == 'farenheit'): + valor_destino = (valor * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'farenheit'): + if (destino == 'celsius'): + valor_destino = (valor - 32) * 5 / 9 + elif (destino == 'farenheit'): + valor_destino = valor + elif (destino == 'kelvin'): + valor_destino = ((valor - 32) * 5 / 9) + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'kelvin'): + if (destino == 'celsius'): + valor_destino = valor - 273.15 + elif (destino == 'farenheit'): + valor_destino = ((valor - 273.15) * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + else: + print('Parámetro de Destino incorrecto') + else: + print('Parámetro de Origen incorrecto') + return valor_destino + + def __factorial(self, numero): + if(type(numero) != int): + return 'El numero debe ser un entero' + if(numero < 0): + return 'El numero debe ser pisitivo' + if (numero > 1): + numero = numero * self.__factorial(numero - 1) return numero \ No newline at end of file diff --git a/M09_errorhandling/LibreriaFunciones.py b/M09_errorhandling/LibreriaFunciones.py new file mode 100644 index 000000000..f5efaaaf1 --- /dev/null +++ b/M09_errorhandling/LibreriaFunciones.py @@ -0,0 +1,100 @@ +class Funciones7: + def __init__(self, ListaEvaluada): + if(type(ListaEvaluada) != list): + self.Lista = [] + raise ValueError("Se ha creado una lista vacia. Se esepraba una lista de número enteros") + else: + self.Lista = ListaEvaluada + + def ValidarPrimo(self): + ListaPrimos = [] + for i in self.Lista: + if(self.__ValidarPrimo(i)): + ListaPrimos.append(True) + else: + ListaPrimos.append(False) + return ListaPrimos + + def ConvertirGrados(self, Origen, Destino): + ValoresCorrectos = ["Celsius", "Farenheit", "Kelvin"] + ListaConvertida = [] + if str(Origen) not in ValoresCorrectos: + print("Parámetros incorrectos, utilizar: ", ValoresCorrectos) + return ListaConvertida + if str(Destino) not in ValoresCorrectos: + print("Parámetros incorrectos, utiliza: ", ValoresCorrectos) + return ListaConvertida + for i in self.Lista: + print(i,"Grados ", Origen, " son: " , self.__ConvertirGrados(i, Origen, Destino), " en ", Destino) + ListaConvertida.append(self.__ConvertirGrados(i, Origen, Destino)) + return ListaConvertida + + def Factorial(self): + ResultadosFactorial = [] + for i in self.Lista: + print("El factorial de: ", i, " es: ", self.__Factorial(i)) + ResultadosFactorial.append(self.__Factorial(i)) + return ResultadosFactorial + + def __ValidarPrimo(self, Numero): + EsPrimo = True + for div in range(2, Numero): + if (Numero % div == 0): + EsPrimo = False + break + return EsPrimo + + def ContarDuplicados(self, ListaDeEvaluacion): + i = 0 + TotalRepeticiones = 0 + MasRepetido = 0 + for Elemento in ListaDeEvaluacion: + Repeticiones = 0 + j = 0 + for Elemento in ListaDeEvaluacion: + if (ListaDeEvaluacion[i] == ListaDeEvaluacion[j]): + Repeticiones+=1 + j+=1 + if(TotalRepeticiones < Repeticiones): + TotalRepeticiones = Repeticiones + MasRepetido = ListaDeEvaluacion[i] + i+=1 + return MasRepetido,TotalRepeticiones + + def __ConvertirGrados(self, Grados, Origen, Destino): + if(Origen == "Celsius" and Destino == "Farenheit"): + Resultado = (Grados * 1.8) + 32 + elif (Origen == "Celsius" and Destino == "Kelvin"): + Resultado = Grados + 273.15 + elif (Origen == "Celsius" and Destino == "Celsius"): + Resultado = Grados + elif (Origen == "Farenheit" and Destino == "Celsius"): + Resultado = (Grados - 32) * (5/9) + elif (Origen == "Farenheit" and Destino == "Kelvin"): + Resultado = (Grados - 32) * (5/9) + 273.15 + elif (Origen == "Farenheit" and Destino == "Farenheit"): + Resultado = Grados + elif (Origen == "Kelvin" and Destino == "Celsius"): + Resultado = (Grados - 273.15) + elif (Origen == "Kelvin" and Destino == "Farenheit"): + Resultado = (Grados - 273.15) * (9/5) + 32 + elif (Origen == "Kelvin" and Destino == "Kelvin"): + Resultado = Grados + else: + print("Parámetros incorrectos") + Resultado = 0 + + return Resultado + + def __Factorial(self, Numero): + if(type(Numero) != int): + return "EL número debe de ser entero" + + if(Numero < 0): + return "El número debe de ser positivo" + + if(Numero <= 1): + return 1 + + Numero = Numero * self.__Factorial(Numero -1) + return Numero \ No newline at end of file diff --git a/M09_errorhandling/Prep_Course_Homework_09-Resuelto.ipynb b/M09_errorhandling/Prep_Course_Homework_09-Resuelto.ipynb index 61eea5c4b..42caba471 100644 --- a/M09_errorhandling/Prep_Course_Homework_09-Resuelto.ipynb +++ b/M09_errorhandling/Prep_Course_Homework_09-Resuelto.ipynb @@ -1,584 +1,584 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Manejo de errores" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "1) Con la clase creada en el módulo 8, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato?" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "sys.path.append(r'/C:/Users/lopez/Documents/Henry/Repos/Python-Prep/07 - Classes & OOP/herramientas.py') # Agrega la ruta al archivo 'herramientas.py' al sys.path\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import herramientas as h #se importa el módulo llamado 'herramientas' y se le asigna un alias 'h' utilizando la palabra clave as. " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Se ha creado una lista vacía. Se esperaba una lista de núemeros enteros", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[4], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m h1 \u001b[39m=\u001b[39m h\u001b[39m.\u001b[39;49mHerramientas(\u001b[39m'\u001b[39;49m\u001b[39mhola\u001b[39;49m\u001b[39m'\u001b[39;49m)\n", - "File \u001b[1;32mc:\\Users\\crisz\\Desktop\\borrar1\\Python-Prep\\08 - Error Handling\\herramientas.py:5\u001b[0m, in \u001b[0;36mHerramientas.__init__\u001b[1;34m(self, lista_numeros)\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[39mif\u001b[39;00m (\u001b[39mtype\u001b[39m(lista_numeros) \u001b[39m!=\u001b[39m \u001b[39mlist\u001b[39m):\n\u001b[0;32m 4\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlista \u001b[39m=\u001b[39m []\n\u001b[1;32m----> 5\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m'\u001b[39m\u001b[39mSe ha creado una lista vacía. Se esperaba una lista de núemeros enteros\u001b[39m\u001b[39m'\u001b[39m) \n\u001b[0;32m 6\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 7\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlista \u001b[39m=\u001b[39m lista_numeros\n", - "\u001b[1;31mValueError\u001b[0m: Se ha creado una lista vacía. Se esperaba una lista de núemeros enteros" - ] - } - ], - "source": [ - "h1 = h.Herramientas('hola') #si se envia un tipo de dato diferente al esperado, arroja error" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "h1 = h.Herramientas([2,3,5,6,2])" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import importlib #se importa el módulo importlib, el cual proporciona funciones para recargar (reload) módulos previamente importados. \n", - "importlib.reload(h) # la función reload() de importlib recargar el módulo herramientas (previamente importado y asignado a un alias h)." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "h1 = h.Herramientas([2,3,5,6,2])" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Los parametros esperados son: ['celsius', 'kelvin', 'farenheit']\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "h1.conversion_grados(1,2)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[35.6, 37.4, 41.0, 42.8, 35.6]" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "h1.conversion_grados('celsius','farenheit')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "3) Importar el modulo \"unittest\" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
\n", - "Creacion del objeto incorrecta
\n", - "Creacion correcta del objeto
\n", - "Metodo valor_modal()
\n", - "\n", - "Se puede usar \"raise ValueError()\" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "import unittest #se importa el módulo unittest,es un marco de trabajo integrado en Python para escribir y ejecutar pruebas unitarias. " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "class ProbandoMiClase(unittest.TestCase):\n", - " \n", - " def test_crear_objeto1(self):\n", - " param = 'hola'\n", - " self.assertRaises(ValueError, h.Herramientas, param)\n", - " #self.failUnlessRaises(ValueError, h.Herramientas, param)\n", - "\n", - " def test_crear_objeto2(self):\n", - " param = [1,2,2,5]\n", - " h1 = h.Herramientas(param)\n", - " self.assertEqual(h1.lista, param)\n", - "\n", - " def test_valor_modal(self):\n", - " lis = [1,2,1,3]\n", - " h1 = h.Herramientas(lis)\n", - " moda, veces = h1.valor_modal(False)\n", - " moda = [moda]\n", - " moda.append(veces)\n", - " resultado = [1, 2]\n", - " self.assertEqual(moda, resultado)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# comentado paso a paso\n", - "class ProbandoMiClase(unittest.TestCase):\n", - " \"\"\"\n", - " Clase de prueba para la clase Herramientas del módulo 'h'.\n", - " Esta clase hereda de unittest.TestCase, lo que la convierte en una clase de prueba.\n", - " \"\"\"\n", - "\n", - " def test_crear_objeto1(self):\n", - " \"\"\"\n", - " Método de prueba para verificar el comportamiento al crear un objeto Herramientas con un parámetro inválido.\n", - " \"\"\"\n", - " param = 'hola'\n", - " self.assertRaises(ValueError, h.Herramientas, param)\n", - " # self.failUnlessRaises(ValueError, h.Herramientas, param)\n", - " # Se utiliza assertRaises para verificar que al crear un objeto Herramientas con un parámetro inválido\n", - " # se genere una excepción de tipo ValueError. Se espera que el código en el bloque de prueba genere esta excepción.\n", - " # Si no se genera la excepción, el caso de prueba falla.\n", - "\n", - " def test_crear_objeto2(self):\n", - " \"\"\"\n", - " Método de prueba para verificar el comportamiento al crear un objeto Herramientas con una lista válida como parámetro.\n", - " \"\"\"\n", - " param = [1, 2, 2, 5]\n", - " h1 = h.Herramientas(param)\n", - " self.assertEqual(h1.lista, param)\n", - " # Se utiliza assertEqual para verificar que la lista almacenada en el objeto h1 de tipo Herramientas\n", - " # sea igual a la lista param proporcionada como parámetro al crear el objeto.\n", - " # Si las listas no son iguales, el caso de prueba falla.\n", - "\n", - " def test_valor_modal(self):\n", - " \"\"\"\n", - " Método de prueba para verificar el comportamiento del método valor_modal de la clase Herramientas.\n", - " \"\"\"\n", - " lis = [1, 2, 1, 3]\n", - " h1 = h.Herramientas(lis)\n", - " moda, veces = h1.valor_modal(False)\n", - " moda = [moda]\n", - " moda.append(veces)\n", - " resultado = [1, 2]\n", - " self.assertEqual(moda, resultado)\n", - " # Se utiliza assertEqual para verificar que el valor de moda y la cantidad de repeticiones devueltos\n", - " # por el método valor_modal de la clase Herramientas sean iguales a los valores esperados almacenados en resultado.\n", - " # Si los valores no coinciden, el caso de prueba falla.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "test_crear_objeto1 (__main__.ProbandoMiClase) ... ok\n", - "test_crear_objeto2 (__main__.ProbandoMiClase) ... ok\n", - "test_valor_modal (__main__.ProbandoMiClase) ... ok\n", - "\n", - "----------------------------------------------------------------------\n", - "Ran 3 tests in 0.003s\n", - "\n", - "OK\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "unittest.main(argv=[''], verbosity=2, exit=False)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "4) Probar una creación incorrecta y visualizar la salida del \"raise\"" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Se ha creado con un elemento 0. Se esperaba una lista de núemeros enteros", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4832/323435116.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mh2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mh\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mHerramientas\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'algo'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32mc:\\Users\\lopez\\Documents\\Henry\\Repos\\Python-Prep\\08 - Error Handling\\herramientas.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, lista_numeros)\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;32mif\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlista_numeros\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[0mlist\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[0;32m 4\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlista\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Se ha creado con un elemento 0. Se esperaba una lista de núemeros enteros'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 6\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlista\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlista_numeros\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mValueError\u001b[0m: Se ha creado con un elemento 0. Se esperaba una lista de núemeros enteros" - ] - } - ], - "source": [ - "h2 = h.Herramientas('algo')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "class ProbandoMiClase2(unittest.TestCase):\n", - "\n", - " def test_verifica_primos1(self):\n", - " lis = [2,3,8,10,13]\n", - " h1 = h.Herramientas(lis)\n", - " primos = h1.verifica_primo()\n", - " primos_esperado = [True, True, False, False, True]\n", - " self.assertEqual(primos, primos_esperado)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "importlib.reload(h)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "test_crear_objeto1 (__main__.ProbandoMiClase) ... ok\n", - "test_crear_objeto2 (__main__.ProbandoMiClase) ... ok\n", - "test_valor_modal (__main__.ProbandoMiClase) ... ok\n", - "test_verifica_primos1 (__main__.ProbandoMiClase2) ... ok\n", - "\n", - "----------------------------------------------------------------------\n", - "Ran 4 tests in 0.006s\n", - "\n", - "OK\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "unittest.main(argv=[''], verbosity=2, exit=False)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "7) Agregar casos de pruebas para el método conversion_grados()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "class ProbandoMiClase3(unittest.TestCase):\n", - "\n", - " def test_verifica_conversion1(self):\n", - " lis = [2,3,8,10,13]\n", - " h1 = h.Herramientas(lis)\n", - " grados = h1.conversion_grados('celsius','farenheit')\n", - " grados_esperado = [35.6, 37.4, 46.4, 50.0, 55.4]\n", - " self.assertEqual(grados, grados_esperado)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "importlib.reload(h)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "test_crear_objeto1 (__main__.ProbandoMiClase) ... ok\n", - "test_crear_objeto2 (__main__.ProbandoMiClase) ... ok\n", - "test_valor_modal (__main__.ProbandoMiClase) ... ok\n", - "test_verifica_primos1 (__main__.ProbandoMiClase2) ... ok\n", - "test_verifica_conversion1 (__main__.ProbandoMiClase3) ... ok\n", - "\n", - "----------------------------------------------------------------------\n", - "Ran 5 tests in 0.004s\n", - "\n", - "OK\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "unittest.main(argv=[''], verbosity=2, exit=False)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "8) Agregar casos de pruebas para el método factorial()" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "class ProbandoMiClase4(unittest.TestCase):\n", - "\n", - " def test_verifica_factorial(self):\n", - " lis = [2,3,8,10,13]\n", - " h1 = h.Herramientas(lis)\n", - " factorial = h1.factorial()\n", - " factorial_esperado = [2, 6, 40320, 3628800, 6227020800]\n", - " self.assertEqual(factorial, factorial_esperado)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "importlib.reload(h)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "test_crear_objeto1 (__main__.ProbandoMiClase) ... ok\n", - "test_crear_objeto2 (__main__.ProbandoMiClase) ... ok\n", - "test_valor_modal (__main__.ProbandoMiClase) ... ok\n", - "test_verifica_primos1 (__main__.ProbandoMiClase2) ... ok\n", - "test_verifica_conversion1 (__main__.ProbandoMiClase3) ... ok\n", - "test_verifica_factorial (__main__.ProbandoMiClase4) ... ok\n", - "\n", - "----------------------------------------------------------------------\n", - "Ran 6 tests in 0.004s\n", - "\n", - "OK\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "unittest.main(argv=[''], verbosity=2, exit=False)" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.6" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Manejo de errores" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1) Con la clase creada en el módulo 8, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato?" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(r'/C:/Users/lopez/Documents/Henry/Repos/Python-Prep/07 - Classes & OOP/herramientas.py') # Agrega la ruta al archivo 'herramientas.py' al sys.path\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import herramientas as h #se importa el módulo llamado 'herramientas' y se le asigna un alias 'h' utilizando la palabra clave as. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Se ha creado una lista vacía. Se esperaba una lista de núemeros enteros", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[4], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m h1 \u001b[39m=\u001b[39m h\u001b[39m.\u001b[39;49mHerramientas(\u001b[39m'\u001b[39;49m\u001b[39mhola\u001b[39;49m\u001b[39m'\u001b[39;49m)\n", + "File \u001b[1;32mc:\\Users\\crisz\\Desktop\\borrar1\\Python-Prep\\08 - Error Handling\\herramientas.py:5\u001b[0m, in \u001b[0;36mHerramientas.__init__\u001b[1;34m(self, lista_numeros)\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[39mif\u001b[39;00m (\u001b[39mtype\u001b[39m(lista_numeros) \u001b[39m!=\u001b[39m \u001b[39mlist\u001b[39m):\n\u001b[0;32m 4\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlista \u001b[39m=\u001b[39m []\n\u001b[1;32m----> 5\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m'\u001b[39m\u001b[39mSe ha creado una lista vacía. Se esperaba una lista de núemeros enteros\u001b[39m\u001b[39m'\u001b[39m) \n\u001b[0;32m 6\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 7\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlista \u001b[39m=\u001b[39m lista_numeros\n", + "\u001b[1;31mValueError\u001b[0m: Se ha creado una lista vacía. Se esperaba una lista de núemeros enteros" + ] + } + ], + "source": [ + "h1 = h.Herramientas('hola') #si se envia un tipo de dato diferente al esperado, arroja error" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "h1 = h.Herramientas([2,3,5,6,2])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import importlib #se importa el módulo importlib, el cual proporciona funciones para recargar (reload) módulos previamente importados. \n", + "importlib.reload(h) # la función reload() de importlib recargar el módulo herramientas (previamente importado y asignado a un alias h)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "h1 = h.Herramientas([2,3,5,6,2])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Los parametros esperados son: ['celsius', 'kelvin', 'farenheit']\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h1.conversion_grados(1,2)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[35.6, 37.4, 41.0, 42.8, 35.6]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h1.conversion_grados('celsius','farenheit')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Importar el modulo \"unittest\" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
\n", + "Creacion del objeto incorrecta
\n", + "Creacion correcta del objeto
\n", + "Metodo valor_modal()
\n", + "\n", + "Se puede usar \"raise ValueError()\" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import unittest #se importa el módulo unittest,es un marco de trabajo integrado en Python para escribir y ejecutar pruebas unitarias. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "class ProbandoMiClase(unittest.TestCase):\n", + " \n", + " def test_crear_objeto1(self):\n", + " param = 'hola'\n", + " self.assertRaises(ValueError, h.Herramientas, param)\n", + " #self.failUnlessRaises(ValueError, h.Herramientas, param)\n", + "\n", + " def test_crear_objeto2(self):\n", + " param = [1,2,2,5]\n", + " h1 = h.Herramientas(param)\n", + " self.assertEqual(h1.lista, param)\n", + "\n", + " def test_valor_modal(self):\n", + " lis = [1,2,1,3]\n", + " h1 = h.Herramientas(lis)\n", + " moda, veces = h1.valor_modal(False)\n", + " moda = [moda]\n", + " moda.append(veces)\n", + " resultado = [1, 2]\n", + " self.assertEqual(moda, resultado)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# comentado paso a paso\n", + "class ProbandoMiClase(unittest.TestCase):\n", + " \"\"\"\n", + " Clase de prueba para la clase Herramientas del módulo 'h'.\n", + " Esta clase hereda de unittest.TestCase, lo que la convierte en una clase de prueba.\n", + " \"\"\"\n", + "\n", + " def test_crear_objeto1(self):\n", + " \"\"\"\n", + " Método de prueba para verificar el comportamiento al crear un objeto Herramientas con un parámetro inválido.\n", + " \"\"\"\n", + " param = 'hola'\n", + " self.assertRaises(ValueError, h.Herramientas, param)\n", + " # self.failUnlessRaises(ValueError, h.Herramientas, param)\n", + " # Se utiliza assertRaises para verificar que al crear un objeto Herramientas con un parámetro inválido\n", + " # se genere una excepción de tipo ValueError. Se espera que el código en el bloque de prueba genere esta excepción.\n", + " # Si no se genera la excepción, el caso de prueba falla.\n", + "\n", + " def test_crear_objeto2(self):\n", + " \"\"\"\n", + " Método de prueba para verificar el comportamiento al crear un objeto Herramientas con una lista válida como parámetro.\n", + " \"\"\"\n", + " param = [1, 2, 2, 5]\n", + " h1 = h.Herramientas(param)\n", + " self.assertEqual(h1.lista, param)\n", + " # Se utiliza assertEqual para verificar que la lista almacenada en el objeto h1 de tipo Herramientas\n", + " # sea igual a la lista param proporcionada como parámetro al crear el objeto.\n", + " # Si las listas no son iguales, el caso de prueba falla.\n", + "\n", + " def test_valor_modal(self):\n", + " \"\"\"\n", + " Método de prueba para verificar el comportamiento del método valor_modal de la clase Herramientas.\n", + " \"\"\"\n", + " lis = [1, 2, 1, 3]\n", + " h1 = h.Herramientas(lis)\n", + " moda, veces = h1.valor_modal(False)\n", + " moda = [moda]\n", + " moda.append(veces)\n", + " resultado = [1, 2]\n", + " self.assertEqual(moda, resultado)\n", + " # Se utiliza assertEqual para verificar que el valor de moda y la cantidad de repeticiones devueltos\n", + " # por el método valor_modal de la clase Herramientas sean iguales a los valores esperados almacenados en resultado.\n", + " # Si los valores no coinciden, el caso de prueba falla.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test_crear_objeto1 (__main__.ProbandoMiClase) ... ok\n", + "test_crear_objeto2 (__main__.ProbandoMiClase) ... ok\n", + "test_valor_modal (__main__.ProbandoMiClase) ... ok\n", + "\n", + "----------------------------------------------------------------------\n", + "Ran 3 tests in 0.003s\n", + "\n", + "OK\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unittest.main(argv=[''], verbosity=2, exit=False)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) Probar una creación incorrecta y visualizar la salida del \"raise\"" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Se ha creado con un elemento 0. Se esperaba una lista de núemeros enteros", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4832/323435116.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mh2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mh\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mHerramientas\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'algo'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32mc:\\Users\\lopez\\Documents\\Henry\\Repos\\Python-Prep\\08 - Error Handling\\herramientas.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, lista_numeros)\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;32mif\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlista_numeros\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[0mlist\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[0;32m 4\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlista\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Se ha creado con un elemento 0. Se esperaba una lista de núemeros enteros'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 6\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlista\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlista_numeros\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mValueError\u001b[0m: Se ha creado con un elemento 0. Se esperaba una lista de núemeros enteros" + ] + } + ], + "source": [ + "h2 = h.Herramientas('algo')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "class ProbandoMiClase2(unittest.TestCase):\n", + "\n", + " def test_verifica_primos1(self):\n", + " lis = [2,3,8,10,13]\n", + " h1 = h.Herramientas(lis)\n", + " primos = h1.verifica_primo()\n", + " primos_esperado = [True, True, False, False, True]\n", + " self.assertEqual(primos, primos_esperado)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(h)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test_crear_objeto1 (__main__.ProbandoMiClase) ... ok\n", + "test_crear_objeto2 (__main__.ProbandoMiClase) ... ok\n", + "test_valor_modal (__main__.ProbandoMiClase) ... ok\n", + "test_verifica_primos1 (__main__.ProbandoMiClase2) ... ok\n", + "\n", + "----------------------------------------------------------------------\n", + "Ran 4 tests in 0.006s\n", + "\n", + "OK\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unittest.main(argv=[''], verbosity=2, exit=False)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7) Agregar casos de pruebas para el método conversion_grados()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "class ProbandoMiClase3(unittest.TestCase):\n", + "\n", + " def test_verifica_conversion1(self):\n", + " lis = [2,3,8,10,13]\n", + " h1 = h.Herramientas(lis)\n", + " grados = h1.conversion_grados('celsius','farenheit')\n", + " grados_esperado = [35.6, 37.4, 46.4, 50.0, 55.4]\n", + " self.assertEqual(grados, grados_esperado)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(h)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test_crear_objeto1 (__main__.ProbandoMiClase) ... ok\n", + "test_crear_objeto2 (__main__.ProbandoMiClase) ... ok\n", + "test_valor_modal (__main__.ProbandoMiClase) ... ok\n", + "test_verifica_primos1 (__main__.ProbandoMiClase2) ... ok\n", + "test_verifica_conversion1 (__main__.ProbandoMiClase3) ... ok\n", + "\n", + "----------------------------------------------------------------------\n", + "Ran 5 tests in 0.004s\n", + "\n", + "OK\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unittest.main(argv=[''], verbosity=2, exit=False)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Agregar casos de pruebas para el método factorial()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "class ProbandoMiClase4(unittest.TestCase):\n", + "\n", + " def test_verifica_factorial(self):\n", + " lis = [2,3,8,10,13]\n", + " h1 = h.Herramientas(lis)\n", + " factorial = h1.factorial()\n", + " factorial_esperado = [2, 6, 40320, 3628800, 6227020800]\n", + " self.assertEqual(factorial, factorial_esperado)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(h)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test_crear_objeto1 (__main__.ProbandoMiClase) ... ok\n", + "test_crear_objeto2 (__main__.ProbandoMiClase) ... ok\n", + "test_valor_modal (__main__.ProbandoMiClase) ... ok\n", + "test_verifica_primos1 (__main__.ProbandoMiClase2) ... ok\n", + "test_verifica_conversion1 (__main__.ProbandoMiClase3) ... ok\n", + "test_verifica_factorial (__main__.ProbandoMiClase4) ... ok\n", + "\n", + "----------------------------------------------------------------------\n", + "Ran 6 tests in 0.004s\n", + "\n", + "OK\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unittest.main(argv=[''], verbosity=2, exit=False)" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/M09_errorhandling/Prep_Course_Homework_09-Resuelto.py b/M09_errorhandling/Prep_Course_Homework_09-Resuelto.py index f7ea9384d..40f2839d8 100644 --- a/M09_errorhandling/Prep_Course_Homework_09-Resuelto.py +++ b/M09_errorhandling/Prep_Course_Homework_09-Resuelto.py @@ -1,191 +1,191 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Manejo de errores - -# 1) Con la clase creada en el módulo 8, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato? - -# In[1]: - - -import sys -sys.path.append(r'/C:/Users/lopez/Documents/Henry/Repos/Python-Prep/08 - Error Handling/herramientas.py') - - -# In[2]: - - -import herramientas as h - - -# In[3]: - - -h1 = h.Herramientas('hola') - - -# In[4]: - - -h1 = h.Herramientas([2,3,5,6,2]) - - -# 2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados. - -# In[5]: - - -import importlib -importlib.reload(h) - - -# In[6]: - - -h1 = h.Herramientas([2,3,5,6,2]) - - -# In[7]: - - -h1.conversion_grados(1,2) - - -# In[8]: - - -h1.conversion_grados('celsius','farenheit') - - -# 3) Importar el modulo "unittest" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
-# Creacion del objeto incorrecta
-# Creacion correcta del objeto
-# Metodo valor_modal()
-# -# Se puede usar "raise ValueError()" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad. - -# In[9]: - - -import unittest - - -# In[11]: - - -class ProbandoMiClase(unittest.TestCase): - - def test_crear_objeto1(self): - param = 'hola' - self.assertRaises(ValueError, h.Herramientas, param) - #self.failUnlessRaises(ValueError, h.Herramientas, param) - - def test_crear_objeto2(self): - param = [1,2,2,5] - h1 = h.Herramientas(param) - self.assertEqual(h1.lista, param) - - def test_valor_modal(self): - lis = [1,2,1,3] - h1 = h.Herramientas(lis) - moda, veces = h1.valor_modal(False) - moda = [moda] - moda.append(veces) - resultado = [1, 2] - self.assertEqual(moda, resultado) - - -# In[12]: - - -unittest.main(argv=[''], verbosity=2, exit=False) - - -# 4) Probar una creación incorrecta y visualizar la salida del "raise" - -# In[13]: - - -h2 = h.Herramientas('algo') - - -# 6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo - -# In[14]: - - -class ProbandoMiClase2(unittest.TestCase): - - def test_verifica_primos1(self): - lis = [2,3,8,10,13] - h1 = h.Herramientas(lis) - primos = h1.verifica_primo() - primos_esperado = [True, True, False, False, True] - self.assertEqual(primos, primos_esperado) - - -# In[15]: - - -importlib.reload(h) - - -# In[16]: - - -unittest.main(argv=[''], verbosity=2, exit=False) - - -# 7) Agregar casos de pruebas para el método conversion_grados() - -# In[17]: - - -class ProbandoMiClase3(unittest.TestCase): - - def test_verifica_conversion1(self): - lis = [2,3,8,10,13] - h1 = h.Herramientas(lis) - grados = h1.conversion_grados('celsius','farenheit') - grados_esperado = [35.6, 37.4, 46.4, 50.0, 55.4] - self.assertEqual(grados, grados_esperado) - - -# In[18]: - - -importlib.reload(h) - - -# In[19]: - - -unittest.main(argv=[''], verbosity=2, exit=False) - - -# 8) Agregar casos de pruebas para el método factorial() - -# In[20]: - - -class ProbandoMiClase4(unittest.TestCase): - - def test_verifica_factorial(self): - lis = [2,3,8,10,13] - h1 = h.Herramientas(lis) - factorial = h1.factorial() - factorial_esperado = [2, 6, 40320, 3628800, 6227020800] - self.assertEqual(factorial, factorial_esperado) - - -# In[21]: - - -importlib.reload(h) - - -# In[22]: - - -unittest.main(argv=[''], verbosity=2, exit=False) - +#!/usr/bin/env python +# coding: utf-8 + +# ## Manejo de errores + +# 1) Con la clase creada en el módulo 8, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato? + +# In[1]: + + +import sys +sys.path.append(r'/C:/Users/lopez/Documents/Henry/Repos/Python-Prep/08 - Error Handling/herramientas.py') + + +# In[2]: + + +import herramientas as h + + +# In[3]: + + +h1 = h.Herramientas('hola') + + +# In[4]: + + +h1 = h.Herramientas([2,3,5,6,2]) + + +# 2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados. + +# In[5]: + + +import importlib +importlib.reload(h) + + +# In[6]: + + +h1 = h.Herramientas([2,3,5,6,2]) + + +# In[7]: + + +h1.conversion_grados(1,2) + + +# In[8]: + + +h1.conversion_grados('celsius','farenheit') + + +# 3) Importar el modulo "unittest" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
+# Creacion del objeto incorrecta
+# Creacion correcta del objeto
+# Metodo valor_modal()
+# +# Se puede usar "raise ValueError()" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad. + +# In[9]: + + +import unittest + + +# In[11]: + + +class ProbandoMiClase(unittest.TestCase): + + def test_crear_objeto1(self): + param = 'hola' + self.assertRaises(ValueError, h.Herramientas, param) + #self.failUnlessRaises(ValueError, h.Herramientas, param) + + def test_crear_objeto2(self): + param = [1,2,2,5] + h1 = h.Herramientas(param) + self.assertEqual(h1.lista, param) + + def test_valor_modal(self): + lis = [1,2,1,3] + h1 = h.Herramientas(lis) + moda, veces = h1.valor_modal(False) + moda = [moda] + moda.append(veces) + resultado = [1, 2] + self.assertEqual(moda, resultado) + + +# In[12]: + + +unittest.main(argv=[''], verbosity=2, exit=False) + + +# 4) Probar una creación incorrecta y visualizar la salida del "raise" + +# In[13]: + + +h2 = h.Herramientas('algo') + + +# 6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo + +# In[14]: + + +class ProbandoMiClase2(unittest.TestCase): + + def test_verifica_primos1(self): + lis = [2,3,8,10,13] + h1 = h.Herramientas(lis) + primos = h1.verifica_primo() + primos_esperado = [True, True, False, False, True] + self.assertEqual(primos, primos_esperado) + + +# In[15]: + + +importlib.reload(h) + + +# In[16]: + + +unittest.main(argv=[''], verbosity=2, exit=False) + + +# 7) Agregar casos de pruebas para el método conversion_grados() + +# In[17]: + + +class ProbandoMiClase3(unittest.TestCase): + + def test_verifica_conversion1(self): + lis = [2,3,8,10,13] + h1 = h.Herramientas(lis) + grados = h1.conversion_grados('celsius','farenheit') + grados_esperado = [35.6, 37.4, 46.4, 50.0, 55.4] + self.assertEqual(grados, grados_esperado) + + +# In[18]: + + +importlib.reload(h) + + +# In[19]: + + +unittest.main(argv=[''], verbosity=2, exit=False) + + +# 8) Agregar casos de pruebas para el método factorial() + +# In[20]: + + +class ProbandoMiClase4(unittest.TestCase): + + def test_verifica_factorial(self): + lis = [2,3,8,10,13] + h1 = h.Herramientas(lis) + factorial = h1.factorial() + factorial_esperado = [2, 6, 40320, 3628800, 6227020800] + self.assertEqual(factorial, factorial_esperado) + + +# In[21]: + + +importlib.reload(h) + + +# In[22]: + + +unittest.main(argv=[''], verbosity=2, exit=False) + diff --git a/M09_errorhandling/Prep_Course_Homework_09.ipynb b/M09_errorhandling/Prep_Course_Homework_09.ipynb index e3e771b0b..0b06b4b73 100644 --- a/M09_errorhandling/Prep_Course_Homework_09.ipynb +++ b/M09_errorhandling/Prep_Course_Homework_09.ipynb @@ -18,10 +18,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "ename": "ValueError", + "evalue": "Se ha creado una lista vacia. Se esepraba una lista de número enteros", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[1], line 4\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mimportlib\u001b[39;00m \n\u001b[0;32m 3\u001b[0m importlib\u001b[39m.\u001b[39mreload(Lib)\n\u001b[1;32m----> 4\u001b[0m H1 \u001b[39m=\u001b[39m Lib\u001b[39m.\u001b[39;49mFunciones7(\u001b[39m\"\u001b[39;49m\u001b[39mHola\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n", + "File \u001b[1;32mc:\\Users\\Windows10\\Desktop\\Python-Prep\\M09_errorhandling\\LibreriaFunciones.py:5\u001b[0m, in \u001b[0;36mFunciones7.__init__\u001b[1;34m(self, ListaEvaluada)\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[39mif\u001b[39;00m(\u001b[39mtype\u001b[39m(ListaEvaluada) \u001b[39m!=\u001b[39m \u001b[39mlist\u001b[39m):\n\u001b[0;32m 4\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mLista \u001b[39m=\u001b[39m []\n\u001b[1;32m----> 5\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mSe ha creado una lista vacia. Se esepraba una lista de número enteros\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m 6\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 7\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mLista \u001b[39m=\u001b[39m ListaEvaluada\n", + "\u001b[1;31mValueError\u001b[0m: Se ha creado una lista vacia. Se esepraba una lista de número enteros" + ] + } + ], + "source": [ + "import LibreriaFunciones as Lib\n", + "import importlib \n", + "importlib.reload(Lib)\n", + "H1 = Lib.Funciones7(\"Hola\")\n" + ] }, { "attachments": {}, @@ -33,10 +51,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 Grados Celsius son: 33.8 en Farenheit\n", + "2 Grados Celsius son: 35.6 en Farenheit\n", + "3 Grados Celsius son: 37.4 en Farenheit\n", + "4 Grados Celsius son: 39.2 en Farenheit\n", + "5 Grados Celsius son: 41.0 en Farenheit\n" + ] + } + ], + "source": [ + "import importlib \n", + "importlib.reload(Lib)\n", + "Lista_Numeros = [1,2,3,4,5]\n", + "H2 = Lib.Funciones7(Lista_Numeros)\n", + "H2.ConvertirGrados(\"Celsius\",\"Farenheit\")" + ] }, { "attachments": {}, @@ -53,10 +89,74 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "import unittest" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "class PruebaFunciones(unittest.TestCase):\n", + " \n", + " def test_CrearObjeto(self):\n", + " Parametro = \"Texto\"\n", + " self.assertRaises(ValueError, Lib.Funciones7, Parametro)\n", + " \n", + " def test_CrearObjeto2(self):\n", + " Listado = [1,2,2,5]\n", + " H3 = Lib.Funciones7(Listado)\n", + " self.assertEqual(H3.Lista, Listado)\n", + " H3.Lista\n", + "\n", + " def test_ContarDuplicados(self):\n", + " Listado = [1,2,1,3]\n", + " H4 = Lib.Funciones7(Listado)\n", + " moda, veces = H4.ContarDuplicados(Listado)\n", + " moda = [moda]\n", + " moda.append(veces)\n", + " resultado = [1, 2]\n", + " self.assertEqual(moda, resultado)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test_ContarDuplicados (__main__.PruebaFunciones.test_ContarDuplicados) ... ok\n", + "test_CrearObjeto (__main__.PruebaFunciones.test_CrearObjeto) ... ok\n", + "test_CrearObjeto2 (__main__.PruebaFunciones.test_CrearObjeto2) ... ok\n", + "\n", + "----------------------------------------------------------------------\n", + "Ran 3 tests in 0.008s\n", + "\n", + "OK\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unittest.main(argv=[''], verbosity=2, exit=False)" + ] }, { "attachments": {}, @@ -73,6 +173,28 @@ "outputs": [], "source": [] }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Se ha creado una lista vacia. Se esepraba una lista de número enteros", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[24], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m H5 \u001b[39m=\u001b[39m Lib\u001b[39m.\u001b[39;49mFunciones7(\u001b[39m\"\u001b[39;49m\u001b[39mtexto\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n", + "File \u001b[1;32mc:\\Users\\Windows10\\Desktop\\Python-Prep\\M09_errorhandling\\LibreriaFunciones.py:5\u001b[0m, in \u001b[0;36mFunciones7.__init__\u001b[1;34m(self, ListaEvaluada)\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[39mif\u001b[39;00m(\u001b[39mtype\u001b[39m(ListaEvaluada) \u001b[39m!=\u001b[39m \u001b[39mlist\u001b[39m):\n\u001b[0;32m 4\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mLista \u001b[39m=\u001b[39m []\n\u001b[1;32m----> 5\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mSe ha creado una lista vacia. Se esepraba una lista de número enteros\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m 6\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 7\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mLista \u001b[39m=\u001b[39m ListaEvaluada\n", + "\u001b[1;31mValueError\u001b[0m: Se ha creado una lista vacia. Se esepraba una lista de número enteros" + ] + } + ], + "source": [ + "H5 = Lib.Funciones7(\"texto\")" + ] + }, { "attachments": {}, "cell_type": "markdown", @@ -83,10 +205,74 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "class PruebaPrimos(unittest.TestCase):\n", + "\n", + " def test_ValidaPrimos(self):\n", + " Listado = [2,3,8,10,13]\n", + " H6 = Lib.Funciones7(Listado)\n", + " primos = H6.ValidarPrimo()\n", + " primos_esperado = [True, True, False, False, True]\n", + " self.assertEqual(primos, primos_esperado)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(Lib)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test_ContarDuplicados (__main__.PruebaFunciones.test_ContarDuplicados) ... ok\n", + "test_CrearObjeto (__main__.PruebaFunciones.test_CrearObjeto) ... ok\n", + "test_CrearObjeto2 (__main__.PruebaFunciones.test_CrearObjeto2) ... ok\n", + "test_ValidaPrimos (__main__.PruebaPrimos.test_ValidaPrimos) ... ok\n", + "\n", + "----------------------------------------------------------------------\n", + "Ran 4 tests in 0.011s\n", + "\n", + "OK\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unittest.main(argv=[''], verbosity=2, exit=False)" + ] }, { "attachments": {}, @@ -98,10 +284,66 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "class ProbandoConversionGrados(unittest.TestCase):\n", + "\n", + " def test_CovertirGrados(self):\n", + " Listado = [104,86]\n", + " H7 = Lib.Funciones7(Listado)\n", + " H7.ConvertirGrados\n", + " Resultado = H7.ConvertirGrados('Farenheit','Celsius')\n", + " ValoresEsperados = [40.0,30.0]\n", + " self.assertEqual(Resultado, ValoresEsperados)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test_CovertirGrados (__main__.ProbandoConversionGrados.test_CovertirGrados) ... ok\n", + "test_ContarDuplicados (__main__.PruebaFunciones.test_ContarDuplicados) ... ok\n", + "test_CrearObjeto (__main__.PruebaFunciones.test_CrearObjeto) ... ok\n", + "test_CrearObjeto2 (__main__.PruebaFunciones.test_CrearObjeto2) ... ok\n", + "test_ValidaPrimos (__main__.PruebaPrimos.test_ValidaPrimos) ... ok\n", + "\n", + "----------------------------------------------------------------------\n", + "Ran 5 tests in 0.015s\n", + "\n", + "OK\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "104 Grados Farenheit son: 40.0 en Celsius\n", + "86 Grados Farenheit son: 30.0 en Celsius\n", + "[40.0, 30.0]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(Lib)\n", + "unittest.main(argv=[''], verbosity=2, exit=False)\n" + ] }, { "attachments": {}, @@ -117,6 +359,74 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "class ProbandoFactoriales(unittest.TestCase):\n", + "\n", + " def test_CalcularFactorial(self):\n", + " Listado = [1,2,3,4,5]\n", + " H8 = Lib.Funciones7(Listado)\n", + " Resultado = H8.Factorial()\n", + " ValoresEsperados = [1,2,6,24,120]\n", + " self.assertEqual(Resultado,ValoresEsperados)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test_CovertirGrados (__main__.ProbandoConversionGrados.test_CovertirGrados) ... ok\n", + "test_CalcularFactorial (__main__.ProbandoFactoriales.test_CalcularFactorial) ... ok\n", + "test_ContarDuplicados (__main__.PruebaFunciones.test_ContarDuplicados) ... ok\n", + "test_CrearObjeto (__main__.PruebaFunciones.test_CrearObjeto) ... ok\n", + "test_CrearObjeto2 (__main__.PruebaFunciones.test_CrearObjeto2) ... ok\n", + "test_ValidaPrimos (__main__.PruebaPrimos.test_ValidaPrimos) ... ok\n", + "\n", + "----------------------------------------------------------------------\n", + "Ran 6 tests in 0.019s\n", + "\n", + "OK\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "104 Grados Farenheit son: 40.0 en Celsius\n", + "86 Grados Farenheit son: 30.0 en Celsius\n", + "[40.0, 30.0]\n", + "El factorial de: 1 es: 1\n", + "El factorial de: 2 es: 2\n", + "El factorial de: 3 es: 6\n", + "El factorial de: 4 es: 24\n", + "El factorial de: 5 es: 120\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(Lib)\n", + "unittest.main(argv=[''], verbosity=2, exit=False)" + ] } ], "metadata": { @@ -138,7 +448,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/M09_errorhandling/Prep_Course_Homework_09.md b/M09_errorhandling/Prep_Course_Homework_09.md index c0223d19a..8a0afb728 100644 --- a/M09_errorhandling/Prep_Course_Homework_09.md +++ b/M09_errorhandling/Prep_Course_Homework_09.md @@ -1,20 +1,20 @@ -## Manejo de errores - -1) Con la clase creada en el módulo 7, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato? - -2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados. - -3) Importar el modulo "unittest" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
-Creacion del objeto incorrecta
-Creacion correcta del objeto
-Metodo valor_modal()
- -Se puede usar "raise ValueError()" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad. - -4) Probar una creación incorrecta y visualizar la salida del "raise" - -6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo - -7) Agregar casos de pruebas para el método conversion_grados() - +## Manejo de errores + +1) Con la clase creada en el módulo 7, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato? + +2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados. + +3) Importar el modulo "unittest" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
+Creacion del objeto incorrecta
+Creacion correcta del objeto
+Metodo valor_modal()
+ +Se puede usar "raise ValueError()" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad. + +4) Probar una creación incorrecta y visualizar la salida del "raise" + +6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo + +7) Agregar casos de pruebas para el método conversion_grados() + 8) Agregar casos de pruebas para el método factorial() \ No newline at end of file diff --git a/M09_errorhandling/Prep_Course_Homework_09.py b/M09_errorhandling/Prep_Course_Homework_09.py index 837b0a4d9..d20b02865 100644 --- a/M09_errorhandling/Prep_Course_Homework_09.py +++ b/M09_errorhandling/Prep_Course_Homework_09.py @@ -1,60 +1,60 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Manejo de errores - -# 1) Con la clase creada en el módulo 7, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato? - -# In[1]: - - - - -# 2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados. - -# In[5]: - - - - - -# 3) Importar el modulo "unittest" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
-# Creacion del objeto incorrecta
-# Creacion correcta del objeto
-# Metodo valor_modal()
-# -# Se puede usar "raise ValueError()" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad. - -# In[9]: - - - - -# 4) Probar una creación incorrecta y visualizar la salida del "raise" - -# In[13]: - - - - -# 6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo - -# In[14]: - - - - -# 7) Agregar casos de pruebas para el método conversion_grados() - -# In[17]: - - - - -# 8) Agregar casos de pruebas para el método factorial() - -# In[20]: - - - - +#!/usr/bin/env python +# coding: utf-8 + +# ## Manejo de errores + +# 1) Con la clase creada en el módulo 7, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato? + +# In[1]: + + + + +# 2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados. + +# In[5]: + + + + + +# 3) Importar el modulo "unittest" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
+# Creacion del objeto incorrecta
+# Creacion correcta del objeto
+# Metodo valor_modal()
+# +# Se puede usar "raise ValueError()" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad. + +# In[9]: + + + + +# 4) Probar una creación incorrecta y visualizar la salida del "raise" + +# In[13]: + + + + +# 6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo + +# In[14]: + + + + +# 7) Agregar casos de pruebas para el método conversion_grados() + +# In[17]: + + + + +# 8) Agregar casos de pruebas para el método factorial() + +# In[20]: + + + + diff --git a/M09_errorhandling/README.md b/M09_errorhandling/README.md index 62d856155..0d4b25488 100644 --- a/M09_errorhandling/README.md +++ b/M09_errorhandling/README.md @@ -1,250 +1,250 @@ -![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) - -## Manejo de Errores - -### Pruebas de caja negra - -Las pruebas de caja negra se basan en la especificación de la función o el programa, aquí debemos probar sus inputs y validar los outputs. Se llama caja negra por que no necesitamos saber necesariamente los procesos internos del programa, solo contrastar sus resultados. -Hay dos tipos de pruebas muy importantes: -* Pruebas Unitarias: se realizan pruebas a cada uno de los módulos para determinar su correcto funcionamiento. -* Pruebas de Integración: se valida que todos los módulos funcionan entre sí. - -Es una buena práctica realizar las pruebas antes de crear código, esto es porque cualquier cambio que se realice a futuro los test estarán incorporados para determinar si los cambios cumplen lo esperado. -En Python existe la posibilidad de realizar estas pruebas gracias a la librería **unittest**. - -```python ->>> import unittest ->>> ->>> def suma(num_1, num_2): ->>> return num_1 + num_2 ->>> ->>> class CajaNegraTest(unittest.TestCase): ->>> ->>> def test_suma_dos_positivos(self): ->>> num_1 = 10 ->>> num_2 = 5 ->>> ->>> resultado = suma(num_1, num_2) ->>> ->>> self.assertEqual(resultado, 15) ->>> ->>> def test_suma_dos_negativos(self): ->>> num_1 = -10 ->>> num_2 = -7 ->>> ->>> resultado = suma(num_1, num_2) ->>> ->>> self.assertEqual(resultado, -17) ->>> ->>> unittest.main(argv=[''], verbosity=2, exit=False) -test_suma_dos_negativos (__main__.CajaNegraTest) ... ok -test_suma_dos_positivos (__main__.CajaNegraTest) ... ok - ----------------------------------------------------------------------- -Ran 2 tests in 0.004s - -OK - -``` - -### Pruebas de caja de cristal - -Se basan en el flujo del programa, por lo que se asume que conocemos el funcionamiento del programa, por lo que podemos probar todos los caminos posibles de una función. Esto significa que vamos a probar las ramificaciones, bucles for y while, recursiónes, etc. -Este tipo de pruebas son muy buenas cuando descubrimos un bug cuando corremos el programa, por lo que vamos a buscar el **bug** ó error de código gracias a que conocemos su estructura. - -```python ->>> import unittest - ->>> def es_mayor_de_edad(edad): ->>> if edad >= 18: ->>> return True ->>> else: ->>> return False - ->>> class PruebaDeCristalTest(unittest.TestCase): ->>> ->>> def test_es_mayor_de_edad(self): ->>> edad = 20 ->>> ->>> resultado = es_mayor_de_edad(edad) ->>> ->>> self.assertEqual(resultado, True) ->>> ->>> def test_es_menor_de_edad(self): ->>> edad = 15 ->>> ->>> resultado = es_mayor_de_edad(edad) ->>> ->>> self.assertEqual(resultado, False) - ->>> unittest.main(argv=[''], verbosity=2, exit=False) -test_es_mayor_de_edad (__main__.PruebaDeCristalTest) ... ok -test_es_menor_de_edad (__main__.PruebaDeCristalTest) ... ok - ----------------------------------------------------------------------- -Ran 2 tests in 0.003s - -OK - -``` - -### Seguir el código paso a paso ó 'Debugging' - -Los bugs son un problema que les sucede a todos, sin embargo si realizamos test a nuestro programa probablemente tendremos menos bugs, pero esto no es suficiente. -Existen unas reglas generales que nos ayudaran: -* Aprende a utilizar el print statement. -* Estudia los datos disponibles. -* Utiliza los datos para crear hipótesis y experimentos. Método científico. -* Ten una mente abierta. Si entendes el programa, probablemente no habrán bugs. -* Lleva un registro de lo que has tratado, preferentemente en la forma de tests. -* Debuguear es un proceso de búsqueda de los bugs, por lo que al diseñar nuestros experimentos debemos acotar el espacio de búsqueda en cada prueba. Una forma ágil de debugear es utilizando una búsqueda binaria con print statements, esto significa que ejecutamos la mitad del código, si no falla entonces sabemos que el problema está en la otra mitad, y en cada área que vamos acortando lo dividimos por mitades, de esta forma hallaremos rápidamente nuestro bug. - -Existe un listado de errores comunes de los cuales también nos podemos apoyar: -* Encuentra a los sospechosos comunes (llamado a una función mal escrita, parámetros en orden incorrecto, etc.) -* En lugar de preguntarte por qué un programa no funciona, pregúntate por qué está funcionando de esta manera. -* Es posible que el bug no se encuentre donde crees que está. -* Explícale el problema a otra persona. De preferencia que no tenga contexto. -* Lleva un registro de lo que has tratado, preferentemente en la forma de tests. - -### Manejo de excepciones - -Los manejos de excepciones son muy comunes en la programación, no tienen nada de excepcional. Las excepciones de Python normalmente se relacionan con errores de semántica, también podemos crear nuestras propias excepciones, pero cuando una excepción no se maneja (unhandled exception), el programa termina en error. - -Las excepciones se manejan con los keywords: **try**, **except**, **finally**. Se pueden utilizar también para ramificar programas. -No deben manejarse de manera silenciosa (por ejemplo, con print statements). Para crear tu propia excepción utiliza el keyword **raise**. - -``` python ->>> def divide_elementos_de_lista(lista, divisor): ->>> ''' ->>> Cada elemento de una lista es dividida por un divisor definido. ->>> En caso de error de tipo ZeroDivisionError que ->>> significa error al dividir en cero ->>> la función devuelve la lista inicial ->>> ''' ->>> try: ->>> return [i / divisor for i in lista] ->>> ->>> except ZeroDivisionError as e: ->>> print(e) ->>> return lista ->>> ->>> lista = list(range(10)) ->>> divisor = 0 ->>> ->>> print(divide_elementos_de_lista(lista, divisor)) -division by zero -[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ->>> divisor = 3 ->>> print(divide_elementos_de_lista(lista, divisor)) -[0.0, 0.3333333333333, 0.6666666666666, 1.0, 1.3333333333333, 1.6666666666667, 2.0, 2.3333333333335, 2.6666666666665, 3.0] -``` - -### Excepciones y control de flujo - -Hasta ahora hemos visto como las excepciones nos permiten controlar los posibles errores que pueden ocurrir en nuestro código. Sin embargo, dentro de la comunidad de Python tienen otro uso: control de flujo. - -¿Por qué es necesaria otra modalidad para controlar el flujo? Una razón muy específica: el principio EAFP (easier to ask for forgiveness than permission, es más fácil pedir perdón que permiso, por sus siglas en inglés). - -El principio EAFP es un estilo de programación común en Python en el cual se asumen llaves, índices o atributos válidos y se captura la excepción si la suposición resulta ser falsa. Es importante resaltar que otros lenguajes de programación favorecen el principio LBYL (look before you leap, revisa antes de saltar) en el cual el código verifica de manera explícita las precondiciones antes de realizar llamadas. - -``` python -#Python -def busca_pais(paises, pais): -''' -Paises es un diccionario. Pais es la llave. -Codigo con el principio EAFP. -''' - -try: - return paises[pais] -except KeyError: - return None -``` - -``` javascript -// Javascript - -/** -* Paises es un objeto. Pais es la llave. -* Codigo con el principio LBYL. -*/ -function buscaPais(paises, pais) { - if(!Object.keys(paises).includes(pais)) { - return null; - } - - return paises[pais]; -} -``` - -Como se puede ver, el código de Python accede directamente a la llave y únicamente si dicho acceso falla, entonces se captura la excepción y se provee el código necesario. En el caso de JavaScript, se verifica primero que la llave exista en el objeto y únicamente con posterioridad se accede. - -Es importante resaltar que ambos estilos pueden utilizarse en Python, pero el estilo EAFP es mucho más propio de este lenguaje. - -``` python -#All possible errors - -except TypeError: - print("is thrown when an operation or function is applied to an object of an inappropriate type.") -except IndexError: - print("is thrown when trying to access an item at an invalid index.") -except KeyError: - print("is thrown when a key is not found.") -except ImportError: - print("Raised when the imported module is not found.") -except StopIteration: - print("is thrown when the next() function goes beyond the iterator items.") -except ValueError: - print("is thrown when a function's argument is of an inappropriate type.") -except NameError: - print("is thrown when an object could not be found.") -except ZeroDivisionError: - print("is thrown when the second operator in the division is zero.") -except KeyboardInterrupt: - print("is thrown when the user hits the interrupt key (normally Control-C) during the execution of the program.") -except MemoryError: - print("Raised when an operation runs out of memory.") -except FloatingPointError: - print("Raised when a floating point operation fails.") -except OverflowError: - print("Raised when the result of an arithmetic operation is too large to be represented.") -except ReferenceError: - print("Raised when a weak reference proxy is used to access a garbage collected referent.") -except TabError: - print("Raised when the indentation consists of inconsistent tabs and spaces.") -except SystemError: - print("Raised when the interpreter detects internal error.") -except RuntimeError: - print("Raised when an error does not fall under any other category.") -except: - print("Error detected can't be handled nor clasified.") -``` - -## Afirmaciones - -Las afirmaciones son un mecanismo en la que podemos determinar si una afirmación se cumple o no se cumple y poder seguir adelante con la ejecución de nuestro programa o darle término. -Consiste en un método de programación defensiva, esto significa que nos estamos preparando para verificar que los tipos de inputs de nuestro programa es del tipo que nosotros esperamos. Estos también nos sirven para debuggear. -Para realizar una afirmación en nuestro programa lo hacemos con la expresión assert (expresion booleana), (mensaje de error). - -``` python ->>> def primera_letra(lista_de_palabras): ->>> primeras_letras = [] ->>> ->>> for palabra in lista_de_palabras: ->>> assert type(palabra) == str, f'{palabra} no es str' ->>> assert len(palabra) > 0, 'No se permiten str vacíos' ->>> ->>> primeras_letras.append(palabra[0]) ->>> return primeras_letras -``` - -## Características de Python - -- Es un lenguaje interpretado, no compilado. -- Usa tipado dinámico, lo que significa que una variable puede tomar valores de distinto tipo. -- Es fuertemente tipado, lo que significa que el tipo no cambia de manera repentina. Para que se produzca un cambio de tipo tiene que hacer una conversión explícita. -- Es multiplataforma, ya que un código escrito en macOS funciona en Windows o Linux y viceversa. - - -* Si tienes dudas sobre este tema, puedes consultarlas en el canal **#m9_errorhandling** de Slack - +![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) + +## Manejo de Errores + +### Pruebas de caja negra + +Las pruebas de caja negra se basan en la especificación de la función o el programa, aquí debemos probar sus inputs y validar los outputs. Se llama caja negra por que no necesitamos saber necesariamente los procesos internos del programa, solo contrastar sus resultados. +Hay dos tipos de pruebas muy importantes: +* Pruebas Unitarias: se realizan pruebas a cada uno de los módulos para determinar su correcto funcionamiento. +* Pruebas de Integración: se valida que todos los módulos funcionan entre sí. + +Es una buena práctica realizar las pruebas antes de crear código, esto es porque cualquier cambio que se realice a futuro los test estarán incorporados para determinar si los cambios cumplen lo esperado. +En Python existe la posibilidad de realizar estas pruebas gracias a la librería **unittest**. + +```python +>>> import unittest +>>> +>>> def suma(num_1, num_2): +>>> return num_1 + num_2 +>>> +>>> class CajaNegraTest(unittest.TestCase): +>>> +>>> def test_suma_dos_positivos(self): +>>> num_1 = 10 +>>> num_2 = 5 +>>> +>>> resultado = suma(num_1, num_2) +>>> +>>> self.assertEqual(resultado, 15) +>>> +>>> def test_suma_dos_negativos(self): +>>> num_1 = -10 +>>> num_2 = -7 +>>> +>>> resultado = suma(num_1, num_2) +>>> +>>> self.assertEqual(resultado, -17) +>>> +>>> unittest.main(argv=[''], verbosity=2, exit=False) +test_suma_dos_negativos (__main__.CajaNegraTest) ... ok +test_suma_dos_positivos (__main__.CajaNegraTest) ... ok + +---------------------------------------------------------------------- +Ran 2 tests in 0.004s + +OK + +``` + +### Pruebas de caja de cristal + +Se basan en el flujo del programa, por lo que se asume que conocemos el funcionamiento del programa, por lo que podemos probar todos los caminos posibles de una función. Esto significa que vamos a probar las ramificaciones, bucles for y while, recursiónes, etc. +Este tipo de pruebas son muy buenas cuando descubrimos un bug cuando corremos el programa, por lo que vamos a buscar el **bug** ó error de código gracias a que conocemos su estructura. + +```python +>>> import unittest + +>>> def es_mayor_de_edad(edad): +>>> if edad >= 18: +>>> return True +>>> else: +>>> return False + +>>> class PruebaDeCristalTest(unittest.TestCase): +>>> +>>> def test_es_mayor_de_edad(self): +>>> edad = 20 +>>> +>>> resultado = es_mayor_de_edad(edad) +>>> +>>> self.assertEqual(resultado, True) +>>> +>>> def test_es_menor_de_edad(self): +>>> edad = 15 +>>> +>>> resultado = es_mayor_de_edad(edad) +>>> +>>> self.assertEqual(resultado, False) + +>>> unittest.main(argv=[''], verbosity=2, exit=False) +test_es_mayor_de_edad (__main__.PruebaDeCristalTest) ... ok +test_es_menor_de_edad (__main__.PruebaDeCristalTest) ... ok + +---------------------------------------------------------------------- +Ran 2 tests in 0.003s + +OK + +``` + +### Seguir el código paso a paso ó 'Debugging' + +Los bugs son un problema que les sucede a todos, sin embargo si realizamos test a nuestro programa probablemente tendremos menos bugs, pero esto no es suficiente. +Existen unas reglas generales que nos ayudaran: +* Aprende a utilizar el print statement. +* Estudia los datos disponibles. +* Utiliza los datos para crear hipótesis y experimentos. Método científico. +* Ten una mente abierta. Si entendes el programa, probablemente no habrán bugs. +* Lleva un registro de lo que has tratado, preferentemente en la forma de tests. +* Debuguear es un proceso de búsqueda de los bugs, por lo que al diseñar nuestros experimentos debemos acotar el espacio de búsqueda en cada prueba. Una forma ágil de debugear es utilizando una búsqueda binaria con print statements, esto significa que ejecutamos la mitad del código, si no falla entonces sabemos que el problema está en la otra mitad, y en cada área que vamos acortando lo dividimos por mitades, de esta forma hallaremos rápidamente nuestro bug. + +Existe un listado de errores comunes de los cuales también nos podemos apoyar: +* Encuentra a los sospechosos comunes (llamado a una función mal escrita, parámetros en orden incorrecto, etc.) +* En lugar de preguntarte por qué un programa no funciona, pregúntate por qué está funcionando de esta manera. +* Es posible que el bug no se encuentre donde crees que está. +* Explícale el problema a otra persona. De preferencia que no tenga contexto. +* Lleva un registro de lo que has tratado, preferentemente en la forma de tests. + +### Manejo de excepciones + +Los manejos de excepciones son muy comunes en la programación, no tienen nada de excepcional. Las excepciones de Python normalmente se relacionan con errores de semántica, también podemos crear nuestras propias excepciones, pero cuando una excepción no se maneja (unhandled exception), el programa termina en error. + +Las excepciones se manejan con los keywords: **try**, **except**, **finally**. Se pueden utilizar también para ramificar programas. +No deben manejarse de manera silenciosa (por ejemplo, con print statements). Para crear tu propia excepción utiliza el keyword **raise**. + +``` python +>>> def divide_elementos_de_lista(lista, divisor): +>>> ''' +>>> Cada elemento de una lista es dividida por un divisor definido. +>>> En caso de error de tipo ZeroDivisionError que +>>> significa error al dividir en cero +>>> la función devuelve la lista inicial +>>> ''' +>>> try: +>>> return [i / divisor for i in lista] +>>> +>>> except ZeroDivisionError as e: +>>> print(e) +>>> return lista +>>> +>>> lista = list(range(10)) +>>> divisor = 0 +>>> +>>> print(divide_elementos_de_lista(lista, divisor)) +division by zero +[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +>>> divisor = 3 +>>> print(divide_elementos_de_lista(lista, divisor)) +[0.0, 0.3333333333333, 0.6666666666666, 1.0, 1.3333333333333, 1.6666666666667, 2.0, 2.3333333333335, 2.6666666666665, 3.0] +``` + +### Excepciones y control de flujo + +Hasta ahora hemos visto como las excepciones nos permiten controlar los posibles errores que pueden ocurrir en nuestro código. Sin embargo, dentro de la comunidad de Python tienen otro uso: control de flujo. + +¿Por qué es necesaria otra modalidad para controlar el flujo? Una razón muy específica: el principio EAFP (easier to ask for forgiveness than permission, es más fácil pedir perdón que permiso, por sus siglas en inglés). + +El principio EAFP es un estilo de programación común en Python en el cual se asumen llaves, índices o atributos válidos y se captura la excepción si la suposición resulta ser falsa. Es importante resaltar que otros lenguajes de programación favorecen el principio LBYL (look before you leap, revisa antes de saltar) en el cual el código verifica de manera explícita las precondiciones antes de realizar llamadas. + +``` python +#Python +def busca_pais(paises, pais): +''' +Paises es un diccionario. Pais es la llave. +Codigo con el principio EAFP. +''' + +try: + return paises[pais] +except KeyError: + return None +``` + +``` javascript +// Javascript + +/** +* Paises es un objeto. Pais es la llave. +* Codigo con el principio LBYL. +*/ +function buscaPais(paises, pais) { + if(!Object.keys(paises).includes(pais)) { + return null; + } + + return paises[pais]; +} +``` + +Como se puede ver, el código de Python accede directamente a la llave y únicamente si dicho acceso falla, entonces se captura la excepción y se provee el código necesario. En el caso de JavaScript, se verifica primero que la llave exista en el objeto y únicamente con posterioridad se accede. + +Es importante resaltar que ambos estilos pueden utilizarse en Python, pero el estilo EAFP es mucho más propio de este lenguaje. + +``` python +#All possible errors + +except TypeError: + print("is thrown when an operation or function is applied to an object of an inappropriate type.") +except IndexError: + print("is thrown when trying to access an item at an invalid index.") +except KeyError: + print("is thrown when a key is not found.") +except ImportError: + print("Raised when the imported module is not found.") +except StopIteration: + print("is thrown when the next() function goes beyond the iterator items.") +except ValueError: + print("is thrown when a function's argument is of an inappropriate type.") +except NameError: + print("is thrown when an object could not be found.") +except ZeroDivisionError: + print("is thrown when the second operator in the division is zero.") +except KeyboardInterrupt: + print("is thrown when the user hits the interrupt key (normally Control-C) during the execution of the program.") +except MemoryError: + print("Raised when an operation runs out of memory.") +except FloatingPointError: + print("Raised when a floating point operation fails.") +except OverflowError: + print("Raised when the result of an arithmetic operation is too large to be represented.") +except ReferenceError: + print("Raised when a weak reference proxy is used to access a garbage collected referent.") +except TabError: + print("Raised when the indentation consists of inconsistent tabs and spaces.") +except SystemError: + print("Raised when the interpreter detects internal error.") +except RuntimeError: + print("Raised when an error does not fall under any other category.") +except: + print("Error detected can't be handled nor clasified.") +``` + +## Afirmaciones + +Las afirmaciones son un mecanismo en la que podemos determinar si una afirmación se cumple o no se cumple y poder seguir adelante con la ejecución de nuestro programa o darle término. +Consiste en un método de programación defensiva, esto significa que nos estamos preparando para verificar que los tipos de inputs de nuestro programa es del tipo que nosotros esperamos. Estos también nos sirven para debuggear. +Para realizar una afirmación en nuestro programa lo hacemos con la expresión assert (expresion booleana), (mensaje de error). + +``` python +>>> def primera_letra(lista_de_palabras): +>>> primeras_letras = [] +>>> +>>> for palabra in lista_de_palabras: +>>> assert type(palabra) == str, f'{palabra} no es str' +>>> assert len(palabra) > 0, 'No se permiten str vacíos' +>>> +>>> primeras_letras.append(palabra[0]) +>>> return primeras_letras +``` + +## Características de Python + +- Es un lenguaje interpretado, no compilado. +- Usa tipado dinámico, lo que significa que una variable puede tomar valores de distinto tipo. +- Es fuertemente tipado, lo que significa que el tipo no cambia de manera repentina. Para que se produzca un cambio de tipo tiene que hacer una conversión explícita. +- Es multiplataforma, ya que un código escrito en macOS funciona en Windows o Linux y viceversa. + + +* Si tienes dudas sobre este tema, puedes consultarlas en el canal **#m9_errorhandling** de Slack + diff --git a/M09_errorhandling/herramientas.py b/M09_errorhandling/herramientas.py index 36947e769..8d83b2b5b 100644 --- a/M09_errorhandling/herramientas.py +++ b/M09_errorhandling/herramientas.py @@ -1,101 +1,101 @@ -class Herramientas: - def __init__(self, lista_numeros): - if (type(lista_numeros) != list): - self.lista = [] - raise ValueError('Se ha creado una lista vacía. Se esperaba una lista de núemeros enteros') - else: - self.lista = lista_numeros - - def verifica_primo(self): - lista_primos = [] - for i in self.lista: - if (self.__verifica_primo(i)): - lista_primos.append(True) - else: - lista_primos.append(False) - return lista_primos - - def conversion_grados(self, origen, destino): - parametros_esperados = ['celsius','kelvin','farenheit'] - lista_conversion = [] - if str(origen) not in parametros_esperados: - print('Los parametros esperados son:', parametros_esperados) - return lista_conversion - if str(destino) not in parametros_esperados: - print('Los parametros esperados son:', parametros_esperados) - return lista_conversion - for i in self.lista: - lista_conversion.append(self.__conversion_grados(i, origen, destino)) - return lista_conversion - - def factorial(self): - lista_factorial = [] - for i in self.lista: - lista_factorial.append(self.__factorial(i)) - return lista_factorial - - def __verifica_primo(self, nro): - es_primo = True - for i in range(2, nro): - if nro % i == 0: - es_primo = False - break - return es_primo - - def valor_modal(self, menor): - lista_unicos = [] - lista_repeticiones = [] - if len(self.lista) == 0: - return None - if (menor): - self.lista.sort() - else: - self.lista.sort(reverse=True) - for elemento in self.lista: - if elemento in lista_unicos: - i = lista_unicos.index(elemento) - lista_repeticiones[i] += 1 - else: - lista_unicos.append(elemento) - lista_repeticiones.append(1) - moda = lista_unicos[0] - maximo = lista_repeticiones[0] - for i, elemento in enumerate(lista_unicos): - if lista_repeticiones[i] > maximo: - moda = lista_unicos[i] - maximo = lista_repeticiones[i] - return moda, maximo - - def __conversion_grados(self, valor, origen, destino): - valor_destino = None - if (origen == 'celsius'): - if (destino == 'celsius'): - valor_destino = valor - elif (destino == 'farenheit'): - valor_destino = (valor * 9 / 5) + 32 - else: - valor_destino = valor + 273.15 - elif (origen == 'farenheit'): - if (destino == 'celsius'): - valor_destino = (valor - 32) * 5 / 9 - elif (destino == 'farenheit'): - valor_destino = valor - else: - valor_destino = ((valor - 32) * 5 / 9) + 273.15 - else: - if (destino == 'celsius'): - valor_destino = valor - 273.15 - elif (destino == 'farenheit'): - valor_destino = ((valor - 273.15) * 9 / 5) + 32 - else: - valor_destino = valor - return valor_destino - - def __factorial(self, numero): - if(type(numero) != int): - return 'El numero debe ser un entero' - if(numero < 0): - return 'El numero debe ser pisitivo' - if (numero > 1): - numero = numero * self.__factorial(numero - 1) +class Herramientas: + def __init__(self, lista_numeros): + if (type(lista_numeros) != list): + self.lista = [] + raise ValueError('Se ha creado una lista vacía. Se esperaba una lista de núemeros enteros') + else: + self.lista = lista_numeros + + def verifica_primo(self): + lista_primos = [] + for i in self.lista: + if (self.__verifica_primo(i)): + lista_primos.append(True) + else: + lista_primos.append(False) + return lista_primos + + def conversion_grados(self, origen, destino): + parametros_esperados = ['celsius','kelvin','farenheit'] + lista_conversion = [] + if str(origen) not in parametros_esperados: + print('Los parametros esperados son:', parametros_esperados) + return lista_conversion + if str(destino) not in parametros_esperados: + print('Los parametros esperados son:', parametros_esperados) + return lista_conversion + for i in self.lista: + lista_conversion.append(self.__conversion_grados(i, origen, destino)) + return lista_conversion + + def factorial(self): + lista_factorial = [] + for i in self.lista: + lista_factorial.append(self.__factorial(i)) + return lista_factorial + + def __verifica_primo(self, nro): + es_primo = True + for i in range(2, nro): + if nro % i == 0: + es_primo = False + break + return es_primo + + def valor_modal(self, menor): + lista_unicos = [] + lista_repeticiones = [] + if len(self.lista) == 0: + return None + if (menor): + self.lista.sort() + else: + self.lista.sort(reverse=True) + for elemento in self.lista: + if elemento in lista_unicos: + i = lista_unicos.index(elemento) + lista_repeticiones[i] += 1 + else: + lista_unicos.append(elemento) + lista_repeticiones.append(1) + moda = lista_unicos[0] + maximo = lista_repeticiones[0] + for i, elemento in enumerate(lista_unicos): + if lista_repeticiones[i] > maximo: + moda = lista_unicos[i] + maximo = lista_repeticiones[i] + return moda, maximo + + def __conversion_grados(self, valor, origen, destino): + valor_destino = None + if (origen == 'celsius'): + if (destino == 'celsius'): + valor_destino = valor + elif (destino == 'farenheit'): + valor_destino = (valor * 9 / 5) + 32 + else: + valor_destino = valor + 273.15 + elif (origen == 'farenheit'): + if (destino == 'celsius'): + valor_destino = (valor - 32) * 5 / 9 + elif (destino == 'farenheit'): + valor_destino = valor + else: + valor_destino = ((valor - 32) * 5 / 9) + 273.15 + else: + if (destino == 'celsius'): + valor_destino = valor - 273.15 + elif (destino == 'farenheit'): + valor_destino = ((valor - 273.15) * 9 / 5) + 32 + else: + valor_destino = valor + return valor_destino + + def __factorial(self, numero): + if(type(numero) != int): + return 'El numero debe ser un entero' + if(numero < 0): + return 'El numero debe ser pisitivo' + if (numero > 1): + numero = numero * self.__factorial(numero - 1) return numero \ No newline at end of file diff --git a/M10_manejodearchivos/Homework10.ipynb b/M10_manejodearchivos/Homework10.ipynb new file mode 100644 index 000000000..a712354dc --- /dev/null +++ b/M10_manejodearchivos/Homework10.ipynb @@ -0,0 +1,28 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Entrada / Salida\n", + "\n", + "1) Crear un script con el nombre \"clase09_ej1.py\" que reciba 3 parametros a elección, verificando que sean exactamente esa cantidad, y muestre como salida los parámetros recibidos" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/M10_manejodearchivos/Prep_Course_Homework_09-Resuelto.ipynb b/M10_manejodearchivos/Prep_Course_Homework_09-Resuelto.ipynb index ad84c60f1..7cc8f4e39 100644 --- a/M10_manejodearchivos/Prep_Course_Homework_09-Resuelto.ipynb +++ b/M10_manejodearchivos/Prep_Course_Homework_09-Resuelto.ipynb @@ -92,23 +92,23 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "montañas = {'nombre':[ 'Everest','K2','Kanchenjunga','Lhotse','Makalu',\n", - " 'Cho Oyu','Dhaulagiri','Manaslu','Nanga Parbat','Annapurna I'],\n", - " 'orden':[1,2,3,4,5,6,7,8,9,10],\n", + " 'Cho Oyu','Dhaulagiri','Manaslu','Nanga Parbat','Annapurna I','Pico de orizaba'],\n", + " 'orden':[1,2,3,4,5,6,7,8,9,10,11],\n", " 'cordillera':['Himalaya','Karakórum','Himalaya','Himalaya','Himalaya'\n", - " ,'Himalaya','Himalaya','Himalaya','Karakórum','Himalaya'],\n", + " ,'Himalaya','Himalaya','Himalaya','Karakórum','Himalaya',\"Mexicana\"],\n", " 'pais': ['Nepal','Pakistán','Nepal','Nepal','Nepal','Nepal','Nepal','Nepal',\n", - " 'Pakistán','Nepal'],\n", - " 'altura':[8849,8611,8586,8516,8485,8188,8167,8163,8125,8091]}" + " 'Pakistán','Nepal',\"México\"],\n", + " 'altura':[8849,8611,8586,8516,8485,8188,8167,8163,8125,8091,12345]}" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -118,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -131,12 +131,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "ind = 0\n", - "while (ind < 10):\n", + "while (ind < 11):\n", " archivo.write(montañas['nombre'][ind]+',')\n", " archivo.write(str(montañas['orden'][ind])+',')\n", " archivo.write(montañas['cordillera'][ind]+',')\n", @@ -147,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -163,14 +163,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "El archivo tiene un tamaño de 0.36 MB\n" + "El archivo tiene un tamaño de 0.4 MB\n" ] } ], @@ -268,7 +268,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/M10_manejodearchivos/Prep_Course_Homework_09-Resuelto.py b/M10_manejodearchivos/Prep_Course_Homework_09-Resuelto.py index 3e3b3e273..97094d723 100644 --- a/M10_manejodearchivos/Prep_Course_Homework_09-Resuelto.py +++ b/M10_manejodearchivos/Prep_Course_Homework_09-Resuelto.py @@ -1,92 +1,92 @@ -# %% [markdown] -# ## Entrada / Salida - -# %% [markdown] -# 1) Crear un script con el nombre "clase09_ej1.py" que reciba 3 parametros a elección, verificando que sean exactamente esa cantidad, y muestre como salida los parámetros recibidos - -# %% [markdown] -# 2) Crear un script con el nombre "clase09_ej2.py2" que reciba como un valor de temperatura en grados centígrados, un valor de humedad y por último si llovio (Con True o False). Y que cada vez que sea invocado, cargue en el archivo provisto "clase09_ej2.csv" una marca de tiempo y esa información. - -# %% [markdown] -# Para trabajar con tipos de datos relacionados con la medición del tiempo, como ser fechas, horarios o marcas de tiempo se puede utilizar la clase *datetime* - -# %% -import datetime - -# %% -x = datetime.datetime.now() -print("Ahora =",x) -x = datetime.datetime(2020, 5, 10) -print("Fecha fija =",x) - -# %% -fecha_hora = '2022-05-10 12:30:00' -objeto_datetime = datetime.datetime.strptime(fecha_hora, '%Y-%m-%d %H:%M:%S') -print("objeto datetime =", objeto_datetime) -marca_de_tiempo = datetime.datetime.timestamp(objeto_datetime) -print("timestamp =", marca_de_tiempo) -fecha_hora2 = datetime.datetime.fromtimestamp(marca_de_tiempo) -print("fecha hora =", fecha_hora2) - -# %% [markdown] -# 3) Crear un archivo a partir de los datos presentes en el diccionario provisto. El cual debe contener en la primera fila el nombre de las claves y luego cada línea los elementos i-ésimos de las listas de valores contiguos y separados por coma ','. Este archivo debe llamarse clase09_ej3.csv - -# %% -montañas = {'nombre':[ 'Everest','K2','Kanchenjunga','Lhotse','Makalu', - 'Cho Oyu','Dhaulagiri','Manaslu','Nanga Parbat','Annapurna I'], - 'orden':[1,2,3,4,5,6,7,8,9,10], - 'cordillera':['Himalaya','Karakórum','Himalaya','Himalaya','Himalaya' - ,'Himalaya','Himalaya','Himalaya','Karakórum','Himalaya'], - 'pais': ['Nepal','Pakistán','Nepal','Nepal','Nepal','Nepal','Nepal','Nepal', - 'Pakistán','Nepal'], - 'altura':[8849,8611,8586,8516,8485,8188,8167,8163,8125,8091]} - -# %% -import os -archivo = open('clase09_ej3.csv', 'w') - -# %% -for clave in montañas.keys(): - if (clave == 'altura'): - archivo.write(clave+'\n') - else: - archivo.write(clave+',') - -# %% -ind = 0 -while (ind < 10): - archivo.write(montañas['nombre'][ind]+',') - archivo.write(str(montañas['orden'][ind])+',') - archivo.write(montañas['cordillera'][ind]+',') - archivo.write(montañas['pais'][ind]+',') - archivo.write(str(montañas['altura'][ind])+'\n') - ind += 1 - -# %% -archivo.close() - -# %% [markdown] -# 4) Mostrar el tamaño en MB del archivo generado en el punto 3 - -# %% -print('El archivo tiene un tamaño de', str(round(os.path.getsize('clase09_ej3.csv')/1024,2)),'MB') - -# %% [markdown] -# 5) Crear una carpeta llamada clase09_montañas_altas - -# %% -os.makedirs('clase09_montañas_altas') - -# %% [markdown] -# 6) Copiar el archivo clase09_ej3.scv en la carpeta clase09_montañas_altas usando la sentencia **os.system** - -# %% -os.system('copy clase09_ej3.csv clase09_montañas_altas') - -# %% [markdown] -# 7) Listar el contenido de la carpeta clase09_montañas_altas - -# %% -os.listdir('./clase09_montañas_altas') - - +# %% [markdown] +# ## Entrada / Salida + +# %% [markdown] +# 1) Crear un script con el nombre "clase09_ej1.py" que reciba 3 parametros a elección, verificando que sean exactamente esa cantidad, y muestre como salida los parámetros recibidos + +# %% [markdown] +# 2) Crear un script con el nombre "clase09_ej2.py2" que reciba como un valor de temperatura en grados centígrados, un valor de humedad y por último si llovio (Con True o False). Y que cada vez que sea invocado, cargue en el archivo provisto "clase09_ej2.csv" una marca de tiempo y esa información. + +# %% [markdown] +# Para trabajar con tipos de datos relacionados con la medición del tiempo, como ser fechas, horarios o marcas de tiempo se puede utilizar la clase *datetime* + +# %% +import datetime + +# %% +x = datetime.datetime.now() +print("Ahora =",x) +x = datetime.datetime(2020, 5, 10) +print("Fecha fija =",x) + +# %% +fecha_hora = '2022-05-10 12:30:00' +objeto_datetime = datetime.datetime.strptime(fecha_hora, '%Y-%m-%d %H:%M:%S') +print("objeto datetime =", objeto_datetime) +marca_de_tiempo = datetime.datetime.timestamp(objeto_datetime) +print("timestamp =", marca_de_tiempo) +fecha_hora2 = datetime.datetime.fromtimestamp(marca_de_tiempo) +print("fecha hora =", fecha_hora2) + +# %% [markdown] +# 3) Crear un archivo a partir de los datos presentes en el diccionario provisto. El cual debe contener en la primera fila el nombre de las claves y luego cada línea los elementos i-ésimos de las listas de valores contiguos y separados por coma ','. Este archivo debe llamarse clase09_ej3.csv + +# %% +montañas = {'nombre':[ 'Everest','K2','Kanchenjunga','Lhotse','Makalu', + 'Cho Oyu','Dhaulagiri','Manaslu','Nanga Parbat','Annapurna I'], + 'orden':[1,2,3,4,5,6,7,8,9,10], + 'cordillera':['Himalaya','Karakórum','Himalaya','Himalaya','Himalaya' + ,'Himalaya','Himalaya','Himalaya','Karakórum','Himalaya'], + 'pais': ['Nepal','Pakistán','Nepal','Nepal','Nepal','Nepal','Nepal','Nepal', + 'Pakistán','Nepal'], + 'altura':[8849,8611,8586,8516,8485,8188,8167,8163,8125,8091]} + +# %% +import os +archivo = open('clase09_ej3.csv', 'w') + +# %% +for clave in montañas.keys(): + if (clave == 'altura'): + archivo.write(clave+'\n') + else: + archivo.write(clave+',') + +# %% +ind = 0 +while (ind < 10): + archivo.write(montañas['nombre'][ind]+',') + archivo.write(str(montañas['orden'][ind])+',') + archivo.write(montañas['cordillera'][ind]+',') + archivo.write(montañas['pais'][ind]+',') + archivo.write(str(montañas['altura'][ind])+'\n') + ind += 1 + +# %% +archivo.close() + +# %% [markdown] +# 4) Mostrar el tamaño en MB del archivo generado en el punto 3 + +# %% +print('El archivo tiene un tamaño de', str(round(os.path.getsize('clase09_ej3.csv')/1024,2)),'MB') + +# %% [markdown] +# 5) Crear una carpeta llamada clase09_montañas_altas + +# %% +os.makedirs('clase09_montañas_altas') + +# %% [markdown] +# 6) Copiar el archivo clase09_ej3.scv en la carpeta clase09_montañas_altas usando la sentencia **os.system** + +# %% +os.system('copy clase09_ej3.csv clase09_montañas_altas') + +# %% [markdown] +# 7) Listar el contenido de la carpeta clase09_montañas_altas + +# %% +os.listdir('./clase09_montañas_altas') + + diff --git a/M10_manejodearchivos/Prep_Course_Homework_09.md b/M10_manejodearchivos/Prep_Course_Homework_09.md index 7723ba555..a4519a029 100644 --- a/M10_manejodearchivos/Prep_Course_Homework_09.md +++ b/M10_manejodearchivos/Prep_Course_Homework_09.md @@ -1,45 +1,45 @@ -## Entrada / Salida - -1) Crear un script con el nombre "clase09_ej1.py" que reciba 3 parametros a elección, verificando que sean exactamente esa cantidad, y muestre como salida los parámetros recibidos - -2) Crear un script con el nombre "clase09_ej2.py2" que reciba como un valor de temperatura en grados centígrados, un valor de humedad y por último si llovio (Con True o False). Y que cada vez que sea invocado, cargue en el archivo provisto "clase09_ej2.csv" una marca de tiempo y esa información. - -Para trabajar con tipos de datos relacionados con la medición del tiempo, como ser fechas, horarios o marcas de tiempo se puede utilizar la clase *datetime* - -``` python -import datetime - -x = datetime.datetime.now() -print("Ahora =",x) -x = datetime.datetime(2020, 5, 10) -print("Fecha fija =",x) - -fecha_hora = '2022-05-10 12:30:00' -objeto_datetime = datetime.datetime.strptime(fecha_hora, '%Y-%m-%d %H:%M:%S') -print("objeto datetime =", objeto_datetime) -marca_de_tiempo = datetime.datetime.timestamp(objeto_datetime) -print("timestamp =", marca_de_tiempo) -fecha_hora2 = datetime.datetime.fromtimestamp(marca_de_tiempo) -print("fecha hora =", fecha_hora2) -``` - -3) Crear un archivo a partir de los datos presentes en el diccionario provisto. El cual debe contener en la primera fila el nombre de las claves y luego cada línea los elementos i-ésimos de las listas de valores contiguos y separados por coma ','. Este archivo debe llamarse clase09_ej3.csv - -``` python -montañas = {'nombre':[ 'Everest','K2','Kanchenjunga','Lhotse','Makalu', - 'Cho Oyu','Dhaulagiri','Manaslu','Nanga Parbat','Annapurna I'], - 'orden':[1,2,3,4,5,6,7,8,9,10], - 'cordillera':['Himalaya','Karakórum','Himalaya','Himalaya','Himalaya' - ,'Himalaya','Himalaya','Himalaya','Karakórum','Himalaya'], - 'pais': ['Nepal','Pakistán','Nepal','Nepal','Nepal','Nepal','Nepal','Nepal', - 'Pakistán','Nepal'], - 'altura':[8849,8611,8586,8516,8485,8188,8167,8163,8125,8091]} -``` - -4) Mostrar el tamaño en MB del archivo generado en el punto 3 - -5) Crear una carpeta llamada clase09_montañas_altas - -6) Copiar el archivo clase09_ej3.scv en la carpeta clase09_montañas_altas usando la sentencia **os.system** - +## Entrada / Salida + +1) Crear un script con el nombre "clase09_ej1.py" que reciba 3 parametros a elección, verificando que sean exactamente esa cantidad, y muestre como salida los parámetros recibidos + +2) Crear un script con el nombre "clase09_ej2.py2" que reciba como un valor de temperatura en grados centígrados, un valor de humedad y por último si llovio (Con True o False). Y que cada vez que sea invocado, cargue en el archivo provisto "clase09_ej2.csv" una marca de tiempo y esa información. + +Para trabajar con tipos de datos relacionados con la medición del tiempo, como ser fechas, horarios o marcas de tiempo se puede utilizar la clase *datetime* + +``` python +import datetime + +x = datetime.datetime.now() +print("Ahora =",x) +x = datetime.datetime(2020, 5, 10) +print("Fecha fija =",x) + +fecha_hora = '2022-05-10 12:30:00' +objeto_datetime = datetime.datetime.strptime(fecha_hora, '%Y-%m-%d %H:%M:%S') +print("objeto datetime =", objeto_datetime) +marca_de_tiempo = datetime.datetime.timestamp(objeto_datetime) +print("timestamp =", marca_de_tiempo) +fecha_hora2 = datetime.datetime.fromtimestamp(marca_de_tiempo) +print("fecha hora =", fecha_hora2) +``` + +3) Crear un archivo a partir de los datos presentes en el diccionario provisto. El cual debe contener en la primera fila el nombre de las claves y luego cada línea los elementos i-ésimos de las listas de valores contiguos y separados por coma ','. Este archivo debe llamarse clase09_ej3.csv + +``` python +montañas = {'nombre':[ 'Everest','K2','Kanchenjunga','Lhotse','Makalu', + 'Cho Oyu','Dhaulagiri','Manaslu','Nanga Parbat','Annapurna I'], + 'orden':[1,2,3,4,5,6,7,8,9,10], + 'cordillera':['Himalaya','Karakórum','Himalaya','Himalaya','Himalaya' + ,'Himalaya','Himalaya','Himalaya','Karakórum','Himalaya'], + 'pais': ['Nepal','Pakistán','Nepal','Nepal','Nepal','Nepal','Nepal','Nepal', + 'Pakistán','Nepal'], + 'altura':[8849,8611,8586,8516,8485,8188,8167,8163,8125,8091]} +``` + +4) Mostrar el tamaño en MB del archivo generado en el punto 3 + +5) Crear una carpeta llamada clase09_montañas_altas + +6) Copiar el archivo clase09_ej3.scv en la carpeta clase09_montañas_altas usando la sentencia **os.system** + 7) Listar el contenido de la carpeta clase09_montañas_altas \ No newline at end of file diff --git a/M10_manejodearchivos/clase09_ej1.py b/M10_manejodearchivos/clase09_ej1.py index 499fc3442..fa1a9b35e 100644 --- a/M10_manejodearchivos/clase09_ej1.py +++ b/M10_manejodearchivos/clase09_ej1.py @@ -1,9 +1,9 @@ -import sys -# Comprobación de seguridad, ejecutar sólo si se recibe 3 argumentos -if len(sys.argv) == 4: - print("El primer parámetro es:",sys.argv[1]) - print("El segundo parámetro es:",sys.argv[2]) - print("El tercer parámetro es:",sys.argv[3]) -else: - print("ERROR: Introdujo una cantidad de argumentos distinta de tres (3)") +import sys +# Comprobación de seguridad, ejecutar sólo si se recibe 3 argumentos +if len(sys.argv) == 4: + print("El primer parámetro es:",sys.argv[1]) + print("El segundo parámetro es:",sys.argv[2]) + print("El tercer parámetro es:",sys.argv[3]) +else: + print("ERROR: Introdujo una cantidad de argumentos distinta de tres (3)") print('Ejemplo: clase09_ej1.py 1 2 3') \ No newline at end of file diff --git a/M10_manejodearchivos/clase09_ej2.csv b/M10_manejodearchivos/clase09_ej2.csv index b3a1c6c10..6d9131ec6 100644 --- a/M10_manejodearchivos/clase09_ej2.csv +++ b/M10_manejodearchivos/clase09_ej2.csv @@ -1,7 +1,7 @@ -timestamp,humedad,temperatura,lluvia -1645191499,29,45,False -1645191585,29,47,False -1645191620,27,50,False -1645191651,27,50,False -1645191869,30,40,False -1645191902,31,45,True +timestamp,humedad,temperatura,lluvia +1645191499,29,45,False +1645191585,29,47,False +1645191620,27,50,False +1645191651,27,50,False +1645191869,30,40,False +1645191902,31,45,True diff --git a/M10_manejodearchivos/clase09_ej2.py b/M10_manejodearchivos/clase09_ej2.py index 6f1b73826..204580ed9 100644 --- a/M10_manejodearchivos/clase09_ej2.py +++ b/M10_manejodearchivos/clase09_ej2.py @@ -1,22 +1,22 @@ -import sys -# Comprobación de seguridad, ejecutar sólo si se recibe 3 argumentos -if len(sys.argv) == 2: - import datetime - import os - marca_de_tiempo = datetime.datetime.now() - marca_de_tiempo = int(datetime.datetime.timestamp(marca_de_tiempo)) - - #temperatura = sys.argv[1] - #humedad = sys.argv[2] - lluvia = sys.argv[1] - temperatura = input('Ingrese la temperatura en grados centígrados') - humedad = input('Ingrese el porcentaje de humedad') - linea = str(marca_de_tiempo) + ',' + temperatura + ',' + humedad + ',' + lluvia - - logs_lluvia = open('clase09_ej2.csv', 'a') - logs_lluvia.write(linea+'\n') - logs_lluvia.close() - -else: - print("ERROR: Introdujo una cantidad de argumentos distinta de tres (3)") +import sys +# Comprobación de seguridad, ejecutar sólo si se recibe 3 argumentos +if len(sys.argv) == 2: + import datetime + import os + marca_de_tiempo = datetime.datetime.now() + marca_de_tiempo = int(datetime.datetime.timestamp(marca_de_tiempo)) + + #temperatura = sys.argv[1] + #humedad = sys.argv[2] + lluvia = sys.argv[1] + temperatura = input('Ingrese la temperatura en grados centígrados') + humedad = input('Ingrese el porcentaje de humedad') + linea = str(marca_de_tiempo) + ',' + temperatura + ',' + humedad + ',' + lluvia + + logs_lluvia = open('clase09_ej2.csv', 'a') + logs_lluvia.write(linea+'\n') + logs_lluvia.close() + +else: + print("ERROR: Introdujo una cantidad de argumentos distinta de tres (3)") print('Ejemplo: clase09_ej1.py ') \ No newline at end of file diff --git a/M10_manejodearchivos/clase09_ej3.csv b/M10_manejodearchivos/clase09_ej3.csv new file mode 100644 index 000000000..3fba9f95d --- /dev/null +++ b/M10_manejodearchivos/clase09_ej3.csv @@ -0,0 +1,12 @@ +nombre,orden,cordillera,pais,altura +Everest,1,Himalaya,Nepal,8849 +K2,2,Karakrum,Pakistn,8611 +Kanchenjunga,3,Himalaya,Nepal,8586 +Lhotse,4,Himalaya,Nepal,8516 +Makalu,5,Himalaya,Nepal,8485 +Cho Oyu,6,Himalaya,Nepal,8188 +Dhaulagiri,7,Himalaya,Nepal,8167 +Manaslu,8,Himalaya,Nepal,8163 +Nanga Parbat,9,Karakrum,Pakistn,8125 +Annapurna I,10,Himalaya,Nepal,8091 +Pico de orizaba,11,Mexicana,Mxico,12345 diff --git a/M10_manejodearchivos/datos.txt b/M10_manejodearchivos/datos.txt index 456eb0a06..d7d217488 100644 --- a/M10_manejodearchivos/datos.txt +++ b/M10_manejodearchivos/datos.txt @@ -1,3 +1,4 @@ -Esto es un archivo de ejemplo -Segunda linea -Tercera linea +Cebolla +Tomate +Aceite +ah perro \ No newline at end of file diff --git a/M10_manejodearchivos/ejemplo_parametros.py b/M10_manejodearchivos/ejemplo_parametros.py index f3215478e..92fdd1cdd 100644 --- a/M10_manejodearchivos/ejemplo_parametros.py +++ b/M10_manejodearchivos/ejemplo_parametros.py @@ -1,14 +1,14 @@ -import sys -# Comprobación de seguridad, ejecutar sólo si se reciben 2 -# argumentos realemente -if len(sys.argv) == 3: - texto = sys.argv[1] - repeticiones = int(sys.argv[2]) - for r in range(repeticiones): - print(texto) -else: - print("ERROR: Introdujo uno (1) o más de dos (2) argumentos") - print("SOLUCIÓN: Introduce los argumentos correctamente") - print('Ejemplo: ejemplo_parametros.py "Texto" 5') - +import sys +# Comprobación de seguridad, ejecutar sólo si se reciben 2 +# argumentos realemente +if len(sys.argv) == 3: + texto = sys.argv[1] + repeticiones = int(sys.argv[2]) + for r in range(repeticiones): + print(texto) +else: + print("ERROR: Introdujo uno (1) o más de dos (2) argumentos") + print("SOLUCIÓN: Introduce los argumentos correctamente") + print('Ejemplo: ejemplo_parametros.py "Texto" 5') + print("El argumento 0 es el nombre del archivo:", sys.argv[0]) \ No newline at end of file diff --git a/M10_manejodearchivos/prueba.ipynb b/M10_manejodearchivos/prueba.ipynb new file mode 100644 index 000000000..c313e0b11 --- /dev/null +++ b/M10_manejodearchivos/prueba.ipynb @@ -0,0 +1,256 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from bs4 import BeautifulSoup\n", + "import urllib.request" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "response = urllib.request.urlopen(\"https://es.wikipedia.org/wiki/Python\")\n", + "html = response.read()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "soup = BeautifulSoup(html, \"html.parser\")\n", + "text = soup.get_text()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "links = soup.find_all(\"a\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Ir al contenido, Portada, Portal de la comunidad, Actualidad, Cambios recientes, Páginas nuevas, Página aleatoria, Ayuda, Donaciones, Notificar un error, Ir arriba, \n", + "\"\"\n", + "\n", + "\"Wikipedia\"\n", + "\"La\n", + "\n", + ", \n", + "Buscar\n", + ", Crear una cuenta, Acceder, Crear una cuenta, Acceder, más información, Contribuciones, Discusión, \n", + "
Inicio
\n", + ", \n", + "
\n", + "1Historia
\n", + ", \n", + "
\n", + "2Características y paradigmas
\n", + ", \n", + "
\n", + "3Filosofía
\n", + ", \n", + "
\n", + "4Modo interactivo
\n", + ", \n", + "
\n", + "5Elementos del lenguaje y sintaxis
\n", + ", \n", + "
\n", + "5.1Comentarios
\n", + ", \n", + "
\n", + "5.2Variables
\n", + ", \n", + "
\n", + "5.3Tipos de datos
\n", + ", \n", + "
\n", + "5.4Condicionales
\n", + ", \n", + "
\n", + "5.5Bucle for
\n", + ", \n", + "
\n", + "5.6Bucle while
\n", + ", \n", + "
\n", + "5.7Listas y Tuplas
\n", + ", \n", + "
\n", + "5.8Diccionarios
\n", + ", \n", + "
\n", + "5.9Sentencia switch-case
\n", + ", \n", + "
\n", + "5.9.1Usando if, elif, else
\n", + ", \n", + "
\n", + "5.9.2Usando diccionarios
\n", + ", \n", + "
\n", + "5.10Conjuntos
\n", + ", \n", + "
\n", + "5.11Listas por comprensión
\n", + ", \n", + "
\n", + "5.12Funciones
\n", + ", \n", + "
\n", + "5.13Clases
\n", + ", \n", + "
\n", + "5.14Módulos
\n", + ", \n", + "
\n", + "5.14.1Instalación de módulos (pip)
\n", + ", \n", + "
\n", + "5.14.2Interfaz al sistema operativo
\n", + ", \n", + "
\n", + "5.14.3Comodines de archivos
\n", + ", \n", + "
\n", + "5.14.4Argumentos de línea de órdenes
\n", + ", \n", + "
\n", + "5.14.5Matemática
\n", + ", \n", + "
\n", + "5.14.6Fechas y horas
\n", + ", \n", + "
\n", + "5.14.7Módulo Turtle
\n", + ", \n", + "
\n", + "6Sistema de objetos
\n", + ", \n", + "
\n", + "7Biblioteca estándar
\n", + ", \n", + "
\n", + "8Implementaciones
\n", + ", \n", + "
\n", + "9Incidencias
\n", + ", \n", + "
\n", + "10Véase también
\n", + ", \n", + "
\n", + "11Referencias
\n", + ", \n", + "
\n", + "12Bibliografía
\n", + ", \n", + "
\n", + "13Enlaces externos
\n", + ", Afrikaans, Alemannisch, Aragonés, العربية, অসমীয়া, Asturianu, Azərbaycanca, تۆرکجه, Basa Bali, Беларуская, Български, भोजपुरी, বাংলা, Brezhoneg, Bosanski, Basa Ugi, Català, Cebuano, کوردی, Čeština, Cymraeg, Dansk, Deutsch, Ελληνικά, English, Esperanto, Eesti, Euskara, فارسی, Suomi, Na Vosa Vakaviti, Français, Galego, ગુજરાતી, עברית, हिन्दी, Hrvatski, Magyar, Հայերեն, Interlingua, Bahasa Indonesia, Ido, Íslenska, Italiano, 日本語, La .lojban., ქართული, Қазақша, ភាសាខ្មែរ, 한국어, Kurdî, Кыргызча, Latina, Lombard, Lietuvių, Latviešu, Македонски, മലയാളം, Монгол, मराठी, Bahasa Melayu, မြန်မာဘာသာ, Plattdüütsch, Nederlands, Norsk nynorsk, Norsk bokmål, ߒߞߏ, ଓଡ଼ିଆ, ਪੰਜਾਬੀ, Polski, پنجابی, Português, Runa Simi, Română, Русский, Саха тыла, ᱥᱟᱱᱛᱟᱲᱤ, Scots, Srpskohrvatski / српскохрватски, ၽႃႇသႃႇတႆး , සිංහල, Simple English, Slovenčina, Slovenščina, Shqip, Српски / srpski, Svenska, Kiswahili, தமிழ், తెలుగు, Тоҷикӣ, ไทย, Tagalog, Türkçe, Татарча / tatarça, ئۇيغۇرچە / Uyghurche, Українська, اردو, Oʻzbekcha / ўзбекча, Tiếng Việt, Walon, Winaray, 吴语, 中文, 文言, Bân-lâm-gú, 粵語, Editar enlaces, Artículo, Discusión, Leer, Editar, Ver historial, Leer, Editar, Ver historial, Lo que enlaza aquí, Cambios en enlazadas, Subir archivo, Páginas especiales, Enlace permanente, Información de la página, Citar esta página, Elemento de Wikidata, Crear un libro, Descargar como PDF, Versión para imprimir, Wikimedia Commons, MediaWiki, Wikilibros, Monty Python, Colt Python, Pythonidae, Pitón, , , Python Software Foundation, Sitio web oficial, Extensiones comunes, Paradigma, Multiparadigma, orientado a objetos, imperativo, funcional, reflexivo, Guido van Rossum, [1], Sistema de tipos, Fuertemente tipado, dinámico, CPython, IronPython, Jython, PyPy, ActivePython, Stackless Python, RPython, ABC, C, Haskell, Icon, Lisp, Modula-3, Perl, Smalltalk, Java, Boo, D, Falcon, Genie, Groovy, Ruby, JavaScript, Cython, Go, Latino, Sistema operativo, Multiplataforma, Licencia, Python Software Foundation License, editar datos en Wikidata, lenguaje de alto nivel de programación, interpretado, código, Instagram, Netflix, Spotify, Panda3D, [2], multiparadigma, orientación a objetos, programación funcional, lenguaje interpretado, dinámico, multiplataforma, Python Software Foundation, licencia, código abierto, Python Software Foundation License, [3], [4], editar, Historia de Python, , Guido van Rossum, Python, [5], Guido van Rossum, Países Bajos, lenguaje de programación ABC, manejar excepciones, sistema operativo Amoeba, [6], humoristas, Monty Python, [7], Benevolente Dictador Vitalicio, [8], [9], alt.sources, [10], herencia, funciones, Modula-3, [5], [6], comp.lang.python, programación funcional, lambda, [11], Lisp, [12], Corporation for National Research Initiatives, Virginia, software, DARPA, [13], [14], BeOpen.com, PythonLabs, [15], Digital Creations, programación funcional, Haskell, recolección de basura, [15], GNU GPL, Python License, Virginia, Free Software Foundation, Python Software Foundation License, FSF Award for the Advancement of Free Software, , coloreado de sintaxis, Python Software Foundation, Apache Software Foundation, [3], static scoping, Scheme, [16], [17], generadores, Icon, [18], Java, [19], log4j, SAX, [20], [21], [22], [23], entrada/salida, asíncrona, biblioteca, servidores web, bases de datos, [24], inteligencia artificial, machine learning, [25], editar, multiparadigma, programación orientada a objetos, programación imperativa, programación funcional, extensiones, tipado dinámico, conteo de referencias, gestión de memoria, variable, C, C++, [26], Lisp, Scheme, editar, filosofía de Unix, Tim Peters, El Zen de Python, holandés, [27], Tim Peters, El Zen de Python, huevo de pascua, [28], , LAMP, Squid, editar, intérprete de comandos, IDLE, bpython, IPython, [29], coloreado de la sintaxis, editar, sangrado, [30], [31], [32], [33], Función factorial, C, Función factorial, editar, comentarios, editar, variables, dinámica, palabras reservadas, [34], [35], editar, , UTF-8, Vector, editar, sentencia condicional, bloque de código, editar, foreach, editar, while, editar, editar, editar, Structural Pattern Matching, editar, editar, editar, intersección, unión, diferencia, diferencia simétrica, editar, editar, Lisp, editar, clases, hereda, [36], encapsulamiento, [37], editar, módulos, tkinter, [38], Tk, [39], editar, herramienta de software, Pip, editar, editar, editar, editar, editar, editar, gráficas tortuga, editar, objeto, clases, metaclase, herencia múltiple, polimorfismo, editar, , [40], editar, CPython, IronPython, Stackless Python, C, www.stackless.com, Jython, Java, Pippy, pippy.sourceforge.net, PyPy, JIT, pypy.org, ActivePython, editar, [41], [42], [43], [44], Windows 10, [45], editar, PyPI, Django, Cython, Flask, CubicWeb, Pygame, Tkinter, biblioteca, gráfica, Tcl/Tk, PyGTK, biblioteca, gráfica, GTK, wxPython, biblioteca, gráfica, wxWidgets, PyQt, PySide, biblioteca, gráfica, Qt, Plone, Biopython, NumPy, SciPy, Pandas, Pyomo, Scikit-learn, aprendizaje automático, editar, ↑, «Changelog - Python Documentation», ↑, «¿Qué es Python?», LUCA, el original, a, b, History and License, ↑, «TIOBE Index - TIOBE», a, b, «artima - The Making of Python», a, b, «Why was Python created in the first place?», ↑, «1. Whetting Your Appetite», ↑, «Guido van Rossum dimite como líder de Python», el original, ↑, «[python-committers] Transfer of power», el original, ↑, van Rossum, Guido, «A Brief Timeline of Python», ↑, ISBN, 8426732437, ↑, The fate of reduce() in Python 3000, ↑, Computer Programming for Everybody, ↑, Index of /cp4e, a, b, What's New in Python 2.0, ↑, PEP 227 -- Statically Nested Scopes, ↑, PEPs 252 and 253: Type and Class Changes, ↑, PEP 255: Simple Generators, ↑, PEP 282 -- A Logging System, ↑, threading — Higher-level threading interface, ↑, «Sunsetting Python 2», ↑, «PEP 373 -- Python 2.7 Release Schedule», ↑, «Python Developer's Guide — Python Developer's Guide», ↑, «asyncio — E/S asíncrona», ↑, «Machine Learning (aprendizaje automático) con Python: una introducción práctica», ↑, «Applications for Python», ↑, Guido van Rossum, holandés, ↑, PEP 20 -- The Zen of Python, ↑, «Copia archivada», el original, ↑, «More control flow options», ↑, «Function Definition», el original, ↑, «Funciones en Javascript», ↑, «Code Like a Pythonista: Idiomatic Python», el original, ↑, «Aprenda a Pensar Como un Programador con Python», el original, ↑, «2. Análisis léxico», ↑, «Python para todos: Diferencia entre método y función», el original, ↑, Encapsulación en Python, ↑, «Python GUI Programming With Tkinter», ↑, «Pequeño paseo por la Biblioteca Estándar», el original, ↑, «La Biblioteca Estándar de Python», ↑, Python 3.0.1, ↑, PEP 3000 -- Python 3000, ↑, 2to3 - Automated Python 2 to 3 code translation, ↑, Novedades de Python 3.0, ↑, «Who put Python in the Windows 10 May 2019 Update?», editar, ISBN, 978-84-415-2513-9, ISBN, 978-84-415-2317-3, editar, Wikilibros: Python, Control de autoridades, \"Wd\", Q28865, \"Commonscat\", Python (programming language), Q28865, \"Wikibooks\", Python, \"MediaWiki\", Python, BNF, 13560465c, (data), GND, 4434275-5, LCCN, sh96008834, NKC, ph170668, NLI, 987007563637105171, SUDOC, 051626225, \"Wd\", Q28865, \"Commonscat\", Python (programming language), Q28865, \"Wikibooks\", Python, \"MediaWiki\", Python, https://es.wikipedia.org/w/index.php?title=Python&oldid=153531025, Categorías, Python, Lenguajes de programación orientada a objetos, Lenguajes de programación de alto nivel, Lenguajes de programación dinámicamente tipados, Lenguajes de programación educativos, Software de 1991, Países Bajos en 1991, Ciencia y tecnología de los Países Bajos, Wikipedia:Artículos buenos en la Wikipedia en árabe, Wikipedia:Artículos buenos en la Wikipedia en alemán, Wikipedia:Artículos con identificadores BNF, Wikipedia:Artículos con identificadores GND, Wikipedia:Artículos con identificadores LCCN, Licencia Creative Commons Atribución Compartir Igual 4.0, , términos de uso, política de privacidad, Fundación Wikimedia, Inc., Política de privacidad, Acerca de Wikipedia, Limitación de responsabilidad, Código de conducta, Versión para móviles, Desarrolladores, Estadísticas, Declaración de cookies, \"Wikimedia, \"Powered]\n" + ] + } + ], + "source": [ + "print(links)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "\n", + "ingredientes = [\"Cebolla\",\"Tomate\", \"Aceite\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "archivo = open('datos.txt','w')\n", + "\n", + "\n", + "for elemento in ingredientes:\n", + " archivo.write(elemento+'\\n')\n", + "\n", + "\n", + "archivo.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cebolla\n", + "\n", + "Tomate\n", + "\n", + "Aceite\n", + "\n", + "ah perro\n" + ] + } + ], + "source": [ + "archivo = open(\"datos.txt\",\"r\")\n", + "\n", + "for linea in archivo:\n", + " print(linea)\n", + "\n", + "archivo.close()" + ] + } + ], + "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.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +}