From 15ee72ae621e308f2e62b2c90e5f7ce7c887b439 Mon Sep 17 00:00:00 2001 From: mica98vero Date: Tue, 20 Sep 2022 13:01:41 -0300 Subject: [PATCH 1/3] 20 sep 22 --- .../__pycache__/Practica.cpython-37.pyc" | Bin 0 -> 243 bytes ...work_02-Resuelto-checkpoint.cpython-37.pyc | Bin 0 -> 988 bytes 02 - Variables y Tipos de Datos/README.md | 82 +- 02 - Variables y Tipos de Datos/Tarea.ipynb | 725 +++++++++++++++ .../Practica en Clase.cpython-37.pyc | Bin 0 -> 416 bytes ...Course_Homework_02-Resuelto.cpython-37.pyc | Bin 0 -> 958 bytes 03 - Flujos de Control/Tarea03.ipynb | 802 +++++++++++++++++ ...Course_Homework_03-Resuelto.cpython-37.pyc | Bin 0 -> 2754 bytes ...work_04-Resuelto-checkpoint.cpython-37.pyc | Bin 0 -> 1573 bytes 04 - Estructuras de datos/README.md | 331 ++++--- 04 - Estructuras de datos/Tarea_04.ipynb | 851 ++++++++++++++++++ ...Course_Homework_04-Resuelto.cpython-37.pyc | Bin 0 -> 1543 bytes .../Ejemplos_de_iteradores.ipynb | 305 +++++++ ...Course_Homework_05-Resuelto.cpython-37.pyc | Bin 0 -> 2083 bytes 05 - Iteradores e Iterables/tarea05.ipynb | 820 +++++++++++++++++ 06 - Funciones/Ejemplos.py | 49 + 06 - Funciones/Tarea06.ipynb | 679 ++++++++++++++ .../__pycache__/Ejemplos.cpython-37.pyc | Bin 0 -> 851 bytes ...Course_Homework_06-Resuelto.cpython-37.pyc | Bin 0 -> 3580 bytes 07 - Classes & OOP/Tarea07.ipynb | 783 ++++++++++++++++ ...Course_Homework_07-Resuelto.cpython-37.pyc | Bin 0 -> 7413 bytes .../__pycache__/herramientas.cpython-310.pyc | Bin 0 -> 2942 bytes .../__pycache__/herramientas.cpython-37.pyc | Bin 0 -> 2915 bytes ...Course_Homework_08-Resuelto.cpython-37.pyc | Bin 0 -> 3108 bytes .../__pycache__/checkpoint.cpython-310.pyc | Bin 0 -> 3053 bytes .../__pycache__/checkpoint.cpython-37.pyc | Bin 0 -> 3025 bytes .../checkpoint_Resuelto.cpython-37.pyc | Bin 0 -> 2820 bytes .../__pycache__/ejemplo_clase.cpython-37.pyc | Bin 0 -> 317 bytes .../__pycache__/herramientas.cpython-310.pyc | Bin 0 -> 2960 bytes .../__pycache__/herramientas.cpython-37.pyc | Bin 0 -> 2950 bytes .../__pycache__/tests.cpython-37.pyc | Bin 0 -> 2891 bytes ...Course_Homework_09-Resuelto.cpython-37.pyc | Bin 0 -> 1699 bytes .../__pycache__/clase09_ej1.cpython-37.pyc | Bin 0 -> 548 bytes .../__pycache__/clase09_ej2.cpython-37.pyc | Bin 0 -> 827 bytes .../ejemplo_parametros.cpython-37.pyc | Bin 0 -> 629 bytes 10 - Repaso/Entradas y salidas.py | 108 +++ 10 - Repaso/HC.ipynb | 251 ++++++ 10 - Repaso/HC.py | 130 +++ .../Entradas y salidas.cpython-37.pyc | Bin 0 -> 5377 bytes 10 - Repaso/__pycache__/HC.cpython-37.pyc | Bin 0 -> 6452 bytes HC_correciones.ipynb | 436 +++++++++ 41 files changed, 6182 insertions(+), 170 deletions(-) create mode 100644 "01 - Introducci\303\263n a la Programaci\303\263n/__pycache__/Practica.cpython-37.pyc" create mode 100644 02 - Variables y Tipos de Datos/.ipynb_checkpoints/__pycache__/Prep_Course_Homework_02-Resuelto-checkpoint.cpython-37.pyc create mode 100644 02 - Variables y Tipos de Datos/Tarea.ipynb create mode 100644 02 - Variables y Tipos de Datos/__pycache__/Practica en Clase.cpython-37.pyc create mode 100644 02 - Variables y Tipos de Datos/__pycache__/Prep_Course_Homework_02-Resuelto.cpython-37.pyc create mode 100644 03 - Flujos de Control/Tarea03.ipynb create mode 100644 03 - Flujos de Control/__pycache__/Prep_Course_Homework_03-Resuelto.cpython-37.pyc create mode 100644 04 - Estructuras de datos/.ipynb_checkpoints/__pycache__/Prep_Course_Homework_04-Resuelto-checkpoint.cpython-37.pyc create mode 100644 04 - Estructuras de datos/Tarea_04.ipynb create mode 100644 04 - Estructuras de datos/__pycache__/Prep_Course_Homework_04-Resuelto.cpython-37.pyc create mode 100644 05 - Iteradores e Iterables/Ejemplos_de_iteradores.ipynb create mode 100644 05 - Iteradores e Iterables/__pycache__/Prep_Course_Homework_05-Resuelto.cpython-37.pyc create mode 100644 05 - Iteradores e Iterables/tarea05.ipynb create mode 100644 06 - Funciones/Ejemplos.py create mode 100644 06 - Funciones/Tarea06.ipynb create mode 100644 06 - Funciones/__pycache__/Ejemplos.cpython-37.pyc create mode 100644 06 - Funciones/__pycache__/Prep_Course_Homework_06-Resuelto.cpython-37.pyc create mode 100644 07 - Classes & OOP/Tarea07.ipynb create mode 100644 07 - Classes & OOP/__pycache__/Prep_Course_Homework_07-Resuelto.cpython-37.pyc create mode 100644 07 - Classes & OOP/__pycache__/herramientas.cpython-310.pyc create mode 100644 07 - Classes & OOP/__pycache__/herramientas.cpython-37.pyc create mode 100644 08 - Error Handling/__pycache__/Prep_Course_Homework_08-Resuelto.cpython-37.pyc create mode 100644 08 - Error Handling/__pycache__/checkpoint.cpython-310.pyc create mode 100644 08 - Error Handling/__pycache__/checkpoint.cpython-37.pyc create mode 100644 08 - Error Handling/__pycache__/checkpoint_Resuelto.cpython-37.pyc create mode 100644 08 - Error Handling/__pycache__/ejemplo_clase.cpython-37.pyc create mode 100644 08 - Error Handling/__pycache__/herramientas.cpython-310.pyc create mode 100644 08 - Error Handling/__pycache__/herramientas.cpython-37.pyc create mode 100644 08 - Error Handling/__pycache__/tests.cpython-37.pyc create mode 100644 09 - Entrada-Salida y Manejo de Archivos/__pycache__/Prep_Course_Homework_09-Resuelto.cpython-37.pyc create mode 100644 09 - Entrada-Salida y Manejo de Archivos/__pycache__/clase09_ej1.cpython-37.pyc create mode 100644 09 - Entrada-Salida y Manejo de Archivos/__pycache__/clase09_ej2.cpython-37.pyc create mode 100644 09 - Entrada-Salida y Manejo de Archivos/__pycache__/ejemplo_parametros.cpython-37.pyc create mode 100644 10 - Repaso/Entradas y salidas.py create mode 100644 10 - Repaso/HC.ipynb create mode 100644 10 - Repaso/HC.py create mode 100644 10 - Repaso/__pycache__/Entradas y salidas.cpython-37.pyc create mode 100644 10 - Repaso/__pycache__/HC.cpython-37.pyc create mode 100644 HC_correciones.ipynb diff --git "a/01 - Introducci\303\263n a la Programaci\303\263n/__pycache__/Practica.cpython-37.pyc" "b/01 - Introducci\303\263n a la Programaci\303\263n/__pycache__/Practica.cpython-37.pyc" new file mode 100644 index 0000000000000000000000000000000000000000..d32550a983158de7515c2340e017bbc5a4747806 GIT binary patch literal 243 zcmXX=u}T9$5Zw&~f|#_nV;LlexmrY`MJ!AXg55Ub?vf1L%^s7Dkbsq6W9=vS7is+j zv3D*wFz?L_?>%NV9G;o3u9hzsO5dmDA9~7n+S_x5Xo7jS)&#pUI G(Kdf&Ekj=b literal 0 HcmV?d00001 diff --git a/02 - Variables y Tipos de Datos/.ipynb_checkpoints/__pycache__/Prep_Course_Homework_02-Resuelto-checkpoint.cpython-37.pyc b/02 - Variables y Tipos de Datos/.ipynb_checkpoints/__pycache__/Prep_Course_Homework_02-Resuelto-checkpoint.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b2af11878bd2610e5378fb58c69e7f404c79e24a GIT binary patch literal 988 zcmYjO&2G~`5Z+Ck#7Prq)1S1I!@`LQ61Cw{Aw)ylLxrHNpm4AvMNW2_x^=wPu2YDw zc>pfF1LD9-z+3pr1>bt%01^tbjw7e zrW5Ju&cIxD-~#cPs;6 zy_48xM7t5~MOodKJ9mX0L|GNcFGN<6KQVv4HX7{{4-Tbs4Xn=IdWcdv+~(}q?m5D< zUA;Nn*DE`)z0htS9kfqJ!G-YZr#LPfI7~>V?_gnjyNML<(yc38^BFEY+5Dj$2-R*l z{>bZgdKb{U@&%5i+M1(tAcj&w=SU3Ty^vR(?PmQos3Ew4sQ)i+_@l^tIuLy5!m|Z@ rfqH?)pk{Im(?CQ^4RdXZv}~HQtj2ZB>6oc6_EB@u%rEMn?xOzyw%710 literal 0 HcmV?d00001 diff --git a/02 - Variables y Tipos de Datos/README.md b/02 - Variables y Tipos de Datos/README.md index 0c0450770..b0b2ba9c0 100644 --- a/02 - Variables y Tipos de Datos/README.md +++ b/02 - Variables y Tipos de Datos/README.md @@ -32,11 +32,12 @@ Sin embargo, cuando ese dato no lo alojamos en una variable y lo utilizamos dire Es importante notar, que podemos encontrarnos con datos de tipos distintos, es decir numéricos, alfanuméricos o booleanos. En Python tenemos los siguientes: - * Enteros: el conjunto de números enteros - * Floats: el conjunto de números reales o de punto flotante - * Cadenas o Strings: es texto, caracteres alfanuméricos que se introducen entre comillas dobles o simples - * Booleanos: representan Verdadero ó Falso - * Complejos: el conjunto de números complejos + +* Enteros: el conjunto de números enteros +* Floats: el conjunto de números reales o de punto flotante +* Cadenas o Strings: es texto, caracteres alfanuméricos que se introducen entre comillas dobles o simples +* Booleanos: representan Verdadero ó Falso +* Complejos: el conjunto de números complejos Todo valor que pueda ser asignado a una variable tiene asociado un tipo de dato y esto establece qué operaciones se pueden realizar sobre la misma. @@ -52,44 +53,43 @@ Con diferentes tipos de datos podemos hacer diferentes tipos de operaciones. Y h **Operaciones aritméticas:** -| Operación | Operador | Ejemplo | -| :--- | :----: | ---: | -| Suma | + | 3 + 5.5 = 8.5 | -| Resta | - | 4 - 1 = 3 | -| Multiplicación | * | 4 * 2 = 8 | -| Potenciación | 42 | 4**2 = 16 | -| División (Cociente) | / | 4 / 2 = 2 | -| División (parte entera) | // | 14 // 3 = 4 | -| División (resto) | % | 14 % 3 = 2 | +| Operación | Operador | Ejemplo | +|:----------------------- |:-------------:| -------------:| +| Suma | + | 3 + 5.5 = 8.5 | +| Resta | - | 4 - 1 = 3 | +| Multiplicación | * | 4 * 2 = 8 | +| Potenciación | 42 | 4**2 = 16 | +| División (Cociente) | / | 4 / 2 = 2 | +| División (parte entera) | // | 14 // 3 = 4 | +| División (resto) | % | 14 % 3 = 2 | **Operadores relacionales:** -| Operación | Operador | Ejemplo | -| :--- | :----: | ---: | -| == | Igual | 10 == 3 = False | -| != | Distinto | 10 != 3 = True | -| > | Mayor | 10 > 3 = True | -| < | Menor | 10 < 3 = False | -| >= | Mayor o igual | 10 >= 3 = True | -| <= | Menor o igual | 10 <= 3 = False | +| Operación | Operador | Ejemplo | +|:--------- |:-------------:| ---------------:| +| == | Igual | 10 == 3 = False | +| != | Distinto | 10 != 3 = True | +| > | Mayor | 10 > 3 = True | +| < | Menor | 10 < 3 = False | +| >= | Mayor o igual | 10 >= 3 = True | +| <= | Menor o igual | 10 <= 3 = False | **Operaciones de asignación:** -| Operación | Operador | Ejemplo | -| :--- | :----: | ---: | -| = | x=7 | x=7 | -| += | x+=2 | x=x+2 = 9 | -| -= | x-=2 | x=x-2 = 5 | -| *= | x*=2 | x=x*2 = 14 | -| /= | x/=2 | x=x/2 = 3.5 | -| %= | x%=2 | x=x%2 = 1 | -| //= | x//=2 | x=x//2 = 3 | -| **= | x**=2 | x=x**2 = 49 | -| &= | x&=2 | x=x&2 = 2 | -| ^= | x^=2 | x=x^2 = 5 | -| >>= | x>>=2 | x=x>>2 = 1 | -| <<= | x<<=2 | x=x<<=2 = 28 | - +| Operación | Operador | Ejemplo | +|:--------- |:--------:| ------------:| +| = | x=7 | x=7 | +| += | x+=2 | x=x+2 = 9 | +| -= | x-=2 | x=x-2 = 5 | +| *= | x*=2 | x=x*2 = 14 | +| /= | x/=2 | x=x/2 = 3.5 | +| %= | x%=2 | x=x%2 = 1 | +| //= | x//=2 | x=x//2 = 3 | +| **= | x**=2 | x=x**2 = 49 | +| &= | x&=2 | x=x&2 = 2 | +| ^= | x^=2 | x=x^2 = 5 | +| >>= | x>>=2 | x=x>>2 = 1 | +| <<= | x<<=2 | x=x<<=2 = 28 | Operación: |=
Operador: x|=2
@@ -97,10 +97,10 @@ Ejemplo: x=x|2 = 7
Cuando tratamos con texto, podemos hacer otras operaciones: -| Operación | Operador | Ejemplo | -| :--- | :----: | ---: | -| Concatenar | + | 'hola ' + 'mundo !' = 'hola mundo!' | -| Multiplicar | * | 'ja ' * 3 = 'ja ja ja' | +| Operación | Operador | Ejemplo | +|:----------- |:--------:| -----------------------------------:| +| Concatenar | + | 'hola ' + 'mundo !' = 'hola mundo!' | +| Multiplicar | * | 'ja ' * 3 = 'ja ja ja' | Algunos ejemplos en Python: diff --git a/02 - Variables y Tipos de Datos/Tarea.ipynb b/02 - Variables y Tipos de Datos/Tarea.ipynb new file mode 100644 index 000000000..613610c49 --- /dev/null +++ b/02 - Variables y Tipos de Datos/Tarea.ipynb @@ -0,0 +1,725 @@ +{ + "cells": [ + { + "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": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20\n" + ] + } + ], + "source": [ + "aux = 20\n", + "print(aux)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2)Imprimir el tipo de dato de la constante 8.5" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "x = type(8.5)\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3)Imprimir el tipo de dato de la variable creada en el punto 1." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "int" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(aux)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4)Crear una variable que contenga tu nombre." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "miNomb = 'Micaela Verónica Paz'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5)Crear una variable que contenga un número complejo." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "complejo = 2+6j" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) Mostrar el tipo de dato de la variable crada en el punto 5" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "complex" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(complejo)" + ] + }, + { + "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": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.142" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pi = 3.1416\n", + "round(pi,3)" + ] + }, + { + "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": 24, + "metadata": {}, + "outputs": [], + "source": [ + "aux1 = 'True'\n", + "aux2 = True\n", + "#No son lo mismo, uno es un string y el otro es un booleano." + ] + }, + { + "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": 8, + "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(aux1), 'y la variable 2 es de tipo', type(aux2))" + ] + }, + { + "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": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "25.45\n" + ] + } + ], + "source": [ + "suma = 23+2.45\n", + "print(suma)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11) Realizar una operación de suma de números complejos" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3+9j)\n" + ] + } + ], + "source": [ + "complejo+=1+3j\n", + "print(complejo)" + ] + }, + { + "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": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(6.1416+9j)\n" + ] + } + ], + "source": [ + "suma1=pi+complejo\n", + "print(suma1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13) Realizar una operación de multiplicación" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "647.7025\n" + ] + } + ], + "source": [ + "suma*=suma\n", + "print(suma)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) Mostrar el resultado de elevar 2 a la octava potencia" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "256\n" + ] + } + ], + "source": [ + "y=2**8\n", + "print(y)" + ] + }, + { + "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": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.75\n" + ] + } + ], + "source": [ + "z=27\n", + "div=z/4\n", + "print(div)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "16) De la división anterior solamente mostrar la parte entera" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "div2=z//4\n", + "print(div2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "17) De la división de 27 entre 4 mostrar solamente el resto" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "div3=z%4\n", + "print(div3)" + ] + }, + { + "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": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + } + ], + "source": [ + "print(div2*4+div3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "19) Utilizar el operador \"+\" en una operación donde intervengan solo variables alfanuméricas\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Micaela Verónica Paz\n" + ] + } + ], + "source": [ + "print(aux1+' '+ miNomb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "20) Evaluar si \"2\" es igual a 2. ¿Por qué ocurre eso?" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2=='2'\n", + "#No son iguales porque son diferentes tipos de datos." + ] + }, + { + "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": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2==int('2')" + ] + }, + { + "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": 2, + "metadata": {}, + "outputs": [], + "source": [ + "a=float('3.8')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['1', '2', '3', '4', '5', '6']\n", + "['6', '5', '4', '3', '2', '1']\n", + "False\n" + ] + } + ], + "source": [ + "def NumeroCapicua(numero):\n", + " \n", + " a = True\n", + " \n", + " if(type(numero)!=int):\n", + " return None\n", + "\n", + " numero = str(numero)\n", + " list_num = []\n", + "\n", + " for i in numero:\n", + " list_num.append(i)\n", + "\n", + " list_reversed = list(reversed(list_num))\n", + " \n", + " print(list_num)\n", + " print(list_reversed)\n", + "\n", + " if (list_num != list_reversed):\n", + " a = False\n", + "\n", + " return a\n", + "\n", + "\n", + "\n", + "print(NumeroCapicua(123456))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Porque va con . no con ," + ] + }, + { + "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": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2\n" + ] + } + ], + "source": [ + "c=3\n", + "c-=5\n", + "print(c)" + ] + }, + { + "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": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1<<2 #Le estoy agragando 2 ceros y lo interpreta en binario 100 = 4" + ] + }, + { + "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": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22\n", + "4\n" + ] + }, + { + "ename": "TypeError", + "evalue": "can only concatenate str (not \"int\") to str", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32me:\\Prep-Henry\\Python-Prep\\02 - Variables y Tipos de Datos\\Tarea.ipynb Cell 50'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39m2\u001b[39m\u001b[39m'\u001b[39m\u001b[39m+\u001b[39m\u001b[39m'\u001b[39m\u001b[39m2\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m2\u001b[39m\u001b[39m+\u001b[39m\u001b[39m2\u001b[39m)\n\u001b[1;32m----> 3\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39;49m\u001b[39m2\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39m+\u001b[39;49m\u001b[39m2\u001b[39;49m)\n", + "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str" + ] + } + ], + "source": [ + "print('2'+'2')\n", + "print(2+2)\n", + "print('2'+2)\n", + "#No está permitido porque son de diferente tipo, si son del mismo tipo no hay problema." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "26) Realizar una operación válida entre valores de tipo entero y string\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "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": "be8ebe292a6fb22f2c19ec4d5075a38adaba2a2c1e51ef08f8bc0ed916701165" + }, + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/02 - Variables y Tipos de Datos/__pycache__/Practica en Clase.cpython-37.pyc b/02 - Variables y Tipos de Datos/__pycache__/Practica en Clase.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..196fb1fc2c6ace7ab47873139e46ded5f367e633 GIT binary patch literal 416 zcmYjLJxc>Y5Z%3x5H%4Cv9g#pNP?skkzi72VG{78I1Xf!9plR0?y-9pxKu)Zjep1@ zt(AYl%E_6+fqC!k&fB+h-EQx*ZJkYKpG05vVFw}cfZAUWNR}|<$kv=Q$&-L|Q0pKG zNrzjFkt9xHQOo4T3 zp~#q?_bK9Ox0;6v9#n4q_Wei{)~8b^=7pLIKm$W9JofTx)4a^AEHz$nTFM_1M7$a7 HI&AV^E#Gjz literal 0 HcmV?d00001 diff --git a/02 - Variables y Tipos de Datos/__pycache__/Prep_Course_Homework_02-Resuelto.cpython-37.pyc b/02 - Variables y Tipos de Datos/__pycache__/Prep_Course_Homework_02-Resuelto.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..557b0fd9695874854e9cca761759002372b5c9fa GIT binary patch literal 958 zcmYjO&2G~`5Z+Ck#7Prq)1S1I!@`LQ8nxk4Aw*5vLxrHNpm4AvMNW1a+&W%s?G)mx zAD|cB0r48}7QS-9w_Z4agu<-tNSSEn%lv+`UNki*fTrSHGfTW=mU-E%0Ob{omm|t`#7aaX4J)c9;Wg9+ zQ&&?#Z)KASueXR<#aK0EpuCaeopkcuxh?V>Uqq%Q#RO%jWOI0vFJBdqrwKK_98vWj z7Whg;k#iMi5WcoI_aar_B56%CqF9MNsbAyDPiLflJ@xCeJZ~ZQ`iy&pKwZ7CMfgU( z$GvxCYcr|i6^E!O4~%f>a%{P5U`a>#%mWGGB+IQBGaP>Xb=;mls2Z_$F2`^lZoIbG zwIywfO|K zV%m@CATFxD(uE_eATIiW{6=IG=cnfHO}pJab>T?b*TA;fdlymqHn%uCu?DtqEk|7r z@AbwCEH|{e$A{gsN$^p)+h@2g8`(@qduU@}cc+6RKIB*T@yzFV@bvOWRv`SYYUmw` zvGk#LEJpB2$gAE?XZtPqV{ih|_9n6Zd?fhTffoz7qyGwxM)g!QT|-1mHGM5ZTG#bi WR^dA4R7_WjeN0):\n", + " print('El número es mayor que cero')\n", + "elif(a<0):\n", + " print('El número es menor que cero') \n", + "else:\n", + " print('El número es igual que cero')" + ] + }, + { + "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": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Son el mismo tipo de dato: \n" + ] + } + ], + "source": [ + "b = 32\n", + "c = 5\n", + "if ( type(b) == type (c)):\n", + " print ('Son el mismo tipo de dato:','',type(b))\n", + "\n", + "else:\n", + " print('No son el mismo tipo de dato')" + ] + }, + { + "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": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 es impar\n", + "2 es par\n", + "3 es impar\n", + "4 es par\n", + "5 es impar\n", + "6 es par\n", + "7 es impar\n", + "8 es par\n", + "9 es impar\n", + "10 es par\n", + "11 es impar\n", + "12 es par\n", + "13 es impar\n", + "14 es par\n", + "15 es impar\n", + "16 es par\n", + "17 es impar\n", + "18 es par\n", + "19 es impar\n", + "20 es par\n", + "Otra letra\n", + "Letra h\n" + ] + } + ], + "source": [ + "for d in range(1,21):\n", + " if( d%2 == 0):\n", + " print(d,'','es par')\n", + " else:\n", + " print(d,'','es impar') \n", + "\n", + "d1 = 'ahora'\n", + "for d2 in d1:\n", + " if( d2 == 'h'):\n", + " print('Letra ',d2)\n", + " break #Si encuentro lo que estoy buscando cortá.\n", + " else:\n", + " print('Otra letra')" + ] + }, + { + "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": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 ^ 3 = 0\n", + "1 ^ 3 = 1\n", + "2 ^ 3 = 8\n", + "3 ^ 3 = 27\n", + "4 ^ 3 = 64\n", + "5 ^ 3 = 125\n", + "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 e in range(0,6):\n", + " print(e,'^ 3 =',(e)**3)\n", + "for e in range(0,6):\n", + " print('Valor:', str(e), ' Elevado a la 3ra potencia:', str(e**3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "f = 6\n", + "for g in range(f):\n", + " pass #Se suele escribir para no realizar ninguna acción.\n", + "print(g)" + ] + }, + { + "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": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El factorial de 6 es: 720\n" + ] + } + ], + "source": [ + "h = 6\n", + "h1 = h\n", + "if(type(h)== int): #Valida si h es entero.\n", + " if(h > 0): #Valida si h es mayor a 0.\n", + " factorial = h #Variable que va a guardar el dato del factorial\n", + " while (h>2): #Tiene que ser más grande que 2 porque no tiene sentido sacar el factorial de 2.\n", + " h -= 1 #Se va restando la variable\n", + " factorial *= h #Se va multiplicando\n", + " print('El factorial de ',h1,' es:', factorial)\n", + " else: #Si no se cumple que la variable > 0\n", + " print('La variable no es mayor a cero.')\n", + "else: #Si no se cumple que la variable sea un entero\n", + " print('La variable no es un entero.')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7) Crear un ciclo for dentro de un ciclo while" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 ° vez.\n", + "0\n", + "1\n", + "2 ° vez.\n", + "0\n", + "1\n", + "3 ° vez.\n", + "0\n", + "1\n" + ] + } + ], + "source": [ + "j = 1\n", + "while (j<=3):\n", + " print(j,'° vez.')\n", + " for k in range(0,2):\n", + " print(k)\n", + " j+=1" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ciclo while nro 2\n", + "Ciclo for nro 1\n", + "Ciclo while nro 3\n", + "Ciclo for nro 1\n", + "Ciclo while nro 3\n", + "Ciclo for nro 2\n", + "Ciclo while nro 4\n", + "Ciclo for nro 1\n", + "Ciclo while nro 4\n", + "Ciclo for nro 2\n", + "Ciclo while nro 4\n", + "Ciclo for nro 3\n", + "Ciclo while nro 5\n", + "Ciclo for nro 1\n", + "Ciclo while nro 5\n", + "Ciclo for nro 2\n", + "Ciclo while nro 5\n", + "Ciclo for nro 3\n", + "Ciclo while nro 5\n", + "Ciclo for nro 4\n" + ] + } + ], + "source": [ + "n = 0\n", + "while(n < 5): #El que corta es el while\n", + " n += 1\n", + " for i in range(1,n):\n", + " print('Ciclo while nro ' + str(n))\n", + " print('Ciclo for nro ' + str(i))\n", + "#Recién se comienza a imprimir en el while nro 2, porque recién entra en el for cuando\n", + "#el rango es (1,2).\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Crear un ciclo while dentro de un ciclo for" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 ° iteracción con for.\n", + "Iteración con While\n", + "Iteración con While\n", + "Iteración con While\n", + "2 ° iteracción con for.\n", + "Iteración con While\n", + "Iteración con While\n", + "Iteración con While\n", + "3 ° iteracción con for.\n", + "Iteración con While\n", + "Iteración con While\n", + "Iteración con While\n", + "4 ° iteracción con for.\n", + "Iteración con While\n", + "Iteración con While\n", + "Iteración con While\n" + ] + } + ], + "source": [ + "for l in range(0,4):\n", + " m = 0\n", + " print(l+1,'° iteracción con for.')\n", + " while(m<=2):\n", + " print('Iteración con While')\n", + " m +=1" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ciclo while nro 1\n", + "Ciclo while nro 2\n", + "Ciclo while nro 3\n", + "Ciclo while nro 4\n", + "Ciclo while nro 5\n", + "Ciclo for nro 0\n", + "Ciclo for nro 1\n", + "Ciclo for nro 2\n", + "Ciclo for nro 3\n", + "Ciclo for nro 4\n" + ] + } + ], + "source": [ + "n = 0\n", + "for i in range(n,5):\n", + " while(n < 5):\n", + " n += 1\n", + " print('Ciclo while nro ' + str(n))\n", + " print('Ciclo for nro ' + str(i))\n", + "#For tiene un rango determinado para trabajar, el while tiene una condición de corte\n", + "#SIEMPRE CORROBORAR LA CONDICIÓN DE CORTE FUNCIONE." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9) Imprimir los números primos existentes entre 0 y 30" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El número 1 es primo\n", + "El número 2 es primo\n", + "El número 3 es primo\n", + "El número 5 es primo\n", + "El número 7 es primo\n", + "El número 11 es primo\n", + "El número 13 es primo\n", + "El número 17 es primo\n", + "El número 19 es primo\n", + "El número 23 es primo\n", + "El número 29 es primo\n" + ] + } + ], + "source": [ + "min = 1\n", + "max = 30\n", + "for n in range(min, (max + 1)): #max+1 para no excluir al 30\n", + " primo = True #Variable con valor de verdad\n", + " o = 2 \n", + " while(o < n): #Si se cumple la condición entra, sino va directo al if(primo)\n", + " if (n % o == 0): #Si el resto es igual a cero entra, sino o se le suma uno y vuelve al comienzo de while\n", + " primo = False #Valor falso se saltea el If(primo)\n", + " break #Sale del while\n", + " o += 1 #vuelve al while\n", + " if (primo): #primo tiene la variable verdadera entonces entra directo.\n", + " print('El número', n, 'es primo')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "5\n", + "7\n", + "11\n", + "13\n", + "17\n", + "19\n", + "23\n", + "29\n" + ] + } + ], + "source": [ + "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", + " break\n", + " if (primo):\n", + " print(n)\n", + " else:\n", + " primo = True\n", + " n += 1" + ] + }, + { + "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": 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", + "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 #contador de la cantidad de veces que corre while\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": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "5\n", + "7\n", + "11\n", + "13\n", + "17\n", + "19\n", + "23\n", + "29\n", + "31\n", + "37\n", + "41\n", + "43\n", + "47\n", + "53\n", + "59\n", + "61\n", + "67\n", + "71\n", + "73\n", + "79\n", + "83\n", + "89\n", + "97\n", + "Cantidad de ciclos: 1132\n", + "Se optimizó a un 0.2381653692404797% 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')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "12) Si la cantidad de números que se evalúa es mayor a treinta, esa optimización crece?" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "5\n", + "7\n", + "11\n", + "13\n", + "17\n", + "19\n", + "23\n", + "29\n", + "31\n", + "37\n", + "41\n", + "43\n", + "47\n", + "53\n", + "59\n", + "61\n", + "67\n", + "71\n", + "73\n", + "79\n", + "83\n", + "89\n", + "97\n", + "Cantidad de ciclos: 4753\n" + ] + } + ], + "source": [ + "tope_rango=100\n", + "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": "markdown", + "metadata": {}, + "source": [ + "13) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "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 #Si voy de 100 a 300 comienzo desde 99\n", + "while(n <= 300): #Condición: si n es menor o igual a 300 se va a seguir ejecutando el while.\n", + " n+=1 #Define el corte de while. Cada vez que pasa por acá va a sumar 1\n", + " if (n % 12 != 0): #Valida si el número es divisible por 12\n", + " continue #Si no se cumple,indica que cotinué\n", + " print(n, ' es divisible por 12')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "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", + "Se finaliza el proceso\n" + ] + } + ], + "source": [ + "#Cada vez que ingresas 1, el programa te tira el siguiente nro primo\n", + "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'): #Ingreso por teclado, si es diferente a 1 finaliza el programa.\n", + " print('Se finaliza el proceso')\n", + " break\n", + " else:\n", + " primo = True\n", + " n += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "15) Crear un ciclo while que encuentre dentro del rango de 100 a 300 el primer número divisible por 3 y además múltiplo de 6" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "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" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "be8ebe292a6fb22f2c19ec4d5075a38adaba2a2c1e51ef08f8bc0ed916701165" + }, + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/03 - Flujos de Control/__pycache__/Prep_Course_Homework_03-Resuelto.cpython-37.pyc b/03 - Flujos de Control/__pycache__/Prep_Course_Homework_03-Resuelto.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d2642530a7ee95258d7a8f68393dc56e863a78c GIT binary patch literal 2754 zcmb7F&u<$=7~S#i#&%*mZki^c3F%U3NlO#8DT1o1plaHxhmuBVX{1$XH1SN@#p@mK z>^gP!zyV8$6Uqr8#EBDd-~gO@0I9uk;=rNum6Q7?a6r5nuU*qNZHeUFneWGY@B6-) z&4prd*ie6OUE3U)G>pIWCVk}aK967Yhiw?la1CxSQZ?iRCoIz<#0U;*izVk^F|{R! zm8Dk9b`3V=_Kq$n7?SuAA$LbJItV!9dt*UH+Ys0LoX)S zJPIB=)j8!B;3;(H1@8o#c1LzI;RL#XH+rYK4E2GfaC)^O!T>`L{bnEir{>%M`oSmA zV}-r~6=9s>f4e9CEsbC7bF8NvrkrUm3~)H$DC!9m|5M4sw33IK$&`gXneOX}&tNvi z-mJh{>NDT!Gk?`QIlz1v%q7iS8elf%YFeckuBP0$2hZ%H8J_ENmwMco@vG2M;>Bs4 zn@NMscFzktr04l`M=ZJU5*;z+Bi#`*e56%ba&}KufA&>9zay6X;Uzj^NtSlR3R%ki z^&Z?-xZLM{aYr0|>$2>%D%rI$;q)frJ*H2zxogRPcCE0j*w|rpqty;4E024TcSrTz zi1{eX<4a-7FP?LHZMm3MVTX&l3R`~Cs{%87UElF?%V2L*O<;Wr+Yx13dGhYq;S3ZU zg7$Zys;m8XtV-!EwB@hJJ&H4co2N9d81U+E%&r}NiQG4@8^`84>dW83&q$`PQfHe= zk8b+h;gM70fshV$DqM=5lX^WT-FeE{&-89LsGnwbGQf7NJHn^Q+*KO&DIzBlfy21( z)V!!BoY<=iY#l~pk<33UQinvn7>9XVT=F31QHQ7^4&c!k!Q+ze1P|`jAlpf@s**aD zNnS0y8kU_Q#3VyEsW0T&WZJpp^KHrm^!n5}EvZu%F%K#pJ=-xAZb3cp&(BCkfxJa4 zu|Si2;3czzEenM1+MbQ+`Wu0xG^3^EC9mQO=k6U3{SK7aQrEJD&Z>Q97Nj>WC*w;r zh&@J`D!rnTqO(q849@G^5%t)sdC7yHp&!`E^pVF=4z2rMg$5{YQ*v7EFjYzg5AOt8 zmW(UG%-i-NJ=QvSPc1g);lKaeMILbqsTC2#l1c}2iZEACiSM_!F1?y~zfDdh6Ogjy z1=RNvWcf~AiVBZJV-#Qm^Wadvd~9Ev(6)`_Aa0Y*wiWNxdE1sWxXs(dYnxFl+aze4 z@Vohb!`y3W1@;!}&Q#Dl~O>W%n&Lry`Le*FE} z!ovEsfM1l}Hh1Qo4+Feqq}#nrE1p12s-rj?AJCWv30=Rkw7#+v-x0z5isW@1Uk3-` zwkm%8y;x?8e#im36sLRL3Uo}ORjQG@%jSg7x`bLVP; zHGKY_I>OO$%*P@*GOT`?T+SjEDeG046v$X+JXa>Ou$Ez0-V!1$cyd@3GRVkxcV$G( z=s4x;t`$}RYn3wuOk`{Pu1&EHTD!3dw;xT)Lki=uXCMc-QyOj1|9>*OHK4K-Wl&WP P+LYf)H5Z_&L^9-GRehEs literal 0 HcmV?d00001 diff --git a/04 - Estructuras de datos/.ipynb_checkpoints/__pycache__/Prep_Course_Homework_04-Resuelto-checkpoint.cpython-37.pyc b/04 - Estructuras de datos/.ipynb_checkpoints/__pycache__/Prep_Course_Homework_04-Resuelto-checkpoint.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9b2c78749626cc70c06d25e2974b2b87a09b856 GIT binary patch literal 1573 zcmah|&2Jk;6rc6SdcFRL6T2;iQkGIaLP=DhM}$b+pdyhrG%AOYrD(EmT^v#a=n>zrcz2)^-{Y5+2WQ-kW*vH}5wyyWMK}jD8QE9saSx z*q?>7fF6!tVNV{H7y||ll%Nb1sDcZ%p~snYBs+JUVg&E@H5=+bm9G2}MP0@D(73k7 zpm8mhP0P@{AV#vvg|*y+O)JoX_C;yFU%|(wRak)ztPcMfi#b!5@|U}!x3=)uv7 z%*z=z^)48%qptcg6Y9M}7j(Ig^CjtDX+f)~#fKi;c&!O;O8?lMufeUQ4Qsq18cexD9dVRRW62ses%g zpz3q_kn#pWlb}V=Ccy8CI@ zV;QCTtg-Xjv9#Sp1oBiR>FlN8?)*TxhZ4lliV3gngjRqyy!OJ_Vy4sg1d}JfN%^YD;{`opQp@c@WrFvT>W$aIoAD&`z8Gt;Bl#uWe= Operaciones con listas: + * Creacion -```python -mi_lista = ['Rojo','Azul','Amarillo','Naranja','Violeta','Verde'] -``` + + ```python + mi_lista = ['Rojo','Azul','Amarillo','Naranja','Violeta','Verde'] + ``` + * Imprimir -```python -print(mi_lista) -``` + + ```python + print(mi_lista) + ``` + * Ver el tipo de dato -```python -type(mi_lista) -``` + + ```python + type(mi_lista) + ``` Las listas, así como otras estructuras de datos que se verán en adelante, tienen varios elementos, motivo por el cual cuando se quiere acceder en específico se requiere de un **índice** que va a hacer referencia al elemento dentro de la lista: * Imprimir el tercer elemento de la lista (el índice comienza en cero) -```python -print(mi_lista[2]) -``` + + ```python + print(mi_lista[2]) + ``` + * Acceder a un rango dentro de la lista (el límite inferior se incluye y el superior se excluye) -```python -print(mi_lista[0:2]) -``` + + ```python + print(mi_lista[0:2]) + ``` + * Al no poner primer valor, Python asume que es un 0 -```python ->>> print(mi_lista[:2]) -['Rojo', 'Azul'] -``` + + ```python + >>> print(mi_lista[:2]) + ['Rojo', 'Azul'] + ``` + * Al no poner segundo valor, Python asume que se trata de todos los elementos a partir del primero -```python - >>> print(mi_lista[0:]) - ['Rojo', 'Azul', 'Amarillo', 'Naranja', 'Violeta', 'Verde'] - ``` + + ```python + >>> print(mi_lista[0:]) + ['Rojo', 'Azul', 'Amarillo', 'Naranja', 'Violeta', 'Verde'] + ``` + * Agregar un elemento al final de la lista (Si el elemento ya existe va a quedar duplicado) -```python -mi_lista.append('Blanco') -``` + + ```python + mi_lista.append('Blanco') + ``` + * Agregar un elemento especificando el índice -```python - >>> mi_lista.insert(3,'Negro') - >>> print(mi_lista[:]) -['Rojo', 'Azul', 'Amarillo', 'Negro', 'Naranja', 'Violeta', 'Verde'] -``` + + ```python + >>> mi_lista.insert(3,'Negro') + >>> print(mi_lista[:]) + ['Rojo', 'Azul', 'Amarillo', 'Negro', 'Naranja', 'Violeta', 'Verde'] + ``` + * Concatenar una nueva lista a la lista previamente creada -```python -mi_lista.extend(['Marrón','Gris']) -``` + + ```python + mi_lista.extend(['Marrón','Gris']) + ``` + * Encontrar el índice de un valor específico -```python ->>> print(mi_lista.index('Azul')) -1 -``` + + ```python + >>> print(mi_lista.index('Azul')) + 1 + ``` + * Eliminar un elemento de la lista (Si el elemento no existe va a arrojar un error) -```python ->>> mi_lista.remove('Blanco') + + ```python + >>> mi_lista.remove('Blanco') + ``` + --------------------------------------------------------------------------- + ValueError Traceback (most recent call last) ~\AppData\Local\Temp/ipykernel_10044/308548076.py in ----> 1 mi_lista.remove('Blanco') ValueError: list.remove(x): x not in list ->>> mi_lista.remove('Negro') + +> > > mi_lista.remove('Negro') + ``` * Extraer y recuperar el último elemento de la lista ```python @@ -85,135 +113,180 @@ ValueError: list.remove(x): x not in list >>> print(ultimo) Gris ``` + * Multiplicar la lista 3 veces -```python ->>> print(['a','b','c'] * 3) -['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c'] -``` + + ```python + >>> print(['a','b','c'] * 3) + ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c'] + ``` + * Ordenar una lista de menor a mayor -```python ->>> lista= [1,4,3,6,8,2] ->>> lista.sort() ->>> print(lista) -[1,2,3,4,6,8] -``` + + ```python + >>> lista= [1,4,3,6,8,2] + >>> lista.sort() + >>> print(lista) + [1,2,3,4,6,8] + ``` + * Ordenar una lista de mayor a menor -```python ->>> lista= [1,4,3,6,8,2] ->>> lista.sort(reverse=True) ->>> print(lista) -[8,6,4,3,2,1] -``` + + ```python + >>> lista= [1,4,3,6,8,2] + >>> lista.sort(reverse=True) + >>> print(lista) + [8,6,4,3,2,1] + ``` ### Tupla Son una estructura similar a las listas, la diferencia está en que no se pueden modificar una vez creadas, es decir que son **inmutables**: * Convertir una lista a tupla -```python -mi_tupla=tuple(mi_lista) -``` + + ```python + mi_tupla=tuple(mi_lista) + ``` + * Imprimir el índice 1 de la tupla -```python ->>> print(mi_tupla[1]) -Azul -``` + + ```python + >>> print(mi_tupla[1]) + Azul + ``` + * Evaluar si un elemento está contenido en la tupla (Devuelve un valor booleano) -```python ->>> 'Rojo' in mi_tupla -True -``` + + ```python + >>> 'Rojo' in mi_tupla + True + ``` + * Evaluar las veces que está un elemento específico -```python ->>> mi_tupla.count('Rojo') -1 -``` + + ```python + >>> mi_tupla.count('Rojo') + 1 + ``` + * Tupla con un solo elemento -```python -mi_tupla_unitaria = ('Blanco',) -``` + + ```python + mi_tupla_unitaria = ('Blanco',) + ``` + * Empaquetado de tupla, tupla sin paréntesis -```python -mi_tupla='Gaspar', 5, 8, 1999 -``` + + ```python + mi_tupla='Gaspar', 5, 8, 1999 + ``` + * Desempaquetado de tupla, se guardan los valores en orden de las variables -```python ->>> nombre, dia, mes, año = mi_tupla ->>> print("Nombre: ", nombre, " - Dia:", dia, " - Mes: ", mes, " - Año: ", año) -Nombre: Gaspar - Dia: 5 - Mes: 8 - Año: 1999 -``` + + ```python + >>> nombre, dia, mes, año = mi_tupla + >>> print("Nombre: ", nombre, " - Dia:", dia, " - Mes: ", mes, " - Año: ", año) + Nombre: Gaspar - Dia: 5 - Mes: 8 - Año: 1999 + ``` + * Convertir una tupla en una lista -```python -mi_lista=list(mi_tupla) -``` + + ```python + mi_lista=list(mi_tupla) + ``` ### Diccionario Un diccionario tiene una organización de 'clave' y 'valor': * Crear un diccionario -```python -mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'], + + ```python + mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'], 'Colores secundarios': ['Naranja','Violeta','Verde'], 'Clave3': 10, 'Clave4': False} -``` + ``` + * Imprimir un valor a través de su clave -```python ->>> print(mi_diccionario['Colores secundarios']) -['Naranja', 'Violeta', 'Verde'] -``` + + ```python + >>> print(mi_diccionario['Colores secundarios']) + ['Naranja', 'Violeta', 'Verde'] + ``` + * Agregar un valor -```python -mi_diccionario['Clave5']='Otro ejemplo' -``` + + ```python + mi_diccionario['Clave5']='Otro ejemplo' + ``` + * Cambiar un valor -```python -mi_diccionario['Clave3']=2 -``` + + ```python + mi_diccionario['Clave3']=2 + ``` + * Eliminar un elemento de un diccionario a través de su clave -```python -del mi_diccionario['Clave4'] -``` + + ```python + del mi_diccionario['Clave4'] + ``` + * Utilizar una tupla como clave de un diccionario -```python -mi_tupla=("Argentina", "Italia", "Inglaterra") -mi_diccionario={mi_tupla[0]:"Buenos Aires", + + ```python + mi_tupla=("Argentina", "Italia", "Inglaterra") + mi_diccionario={mi_tupla[0]:"Buenos Aires", mi_tupla[1]:"Roma", mi_tupla[2]:"Londres"} -``` + ``` + * Colocar una tupla dentro de un diccionario -```python -mi_diccionario={'Clave1':'Valor1', 'Clave2':(1,2,3,4,5)} -``` + + ```python + mi_diccionario={'Clave1':'Valor1', 'Clave2':(1,2,3,4,5)} + ``` + * Colocar una lista dentro de un diccionario (Notar que la diferencia está en el paréntesis '()' y el corchete '[]') -```python - mi_diccionario={'Clave1':'Valor1', 'Clave2':[1,2,3,4,5]} - ``` + + ```python + mi_diccionario={'Clave1':'Valor1', 'Clave2':[1,2,3,4,5]} + ``` + * Colocar un diccionario dentro de un diccionario -```python -mi_diccionario={'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}} -``` + + ```python + mi_diccionario={'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}} + ``` + * Imprimir las claves del diccionario -```python - >>> print(mi_diccionario.keys()) - dict_keys(['Clave1', 'Clave2']) - ``` + + ```python + >>> print(mi_diccionario.keys()) + dict_keys(['Clave1', 'Clave2']) + ``` + * Imprimir los valores del diccionario -```python - >>> print(mi_diccionario.values()) - dict_values(['Valor1', {'numeros': [1, 2, 3, 4, 5]}]) - ``` + + ```python + >>> print(mi_diccionario.values()) + dict_values(['Valor1', {'numeros': [1, 2, 3, 4, 5]}]) + ``` + * Imprimir la longitud del diccionario -```python - >>> len(mi_diccionario) - 2 - ``` -
+ + ```python + >>> len(mi_diccionario) + 2 + ``` + +

Tips: La funcionalidad **del** permite eliminar cualquier estructura de datos y la funcionalidad **len** permite obtener el tamaño de la estructura de datos

-
+
## Homework diff --git a/04 - Estructuras de datos/Tarea_04.ipynb b/04 - Estructuras de datos/Tarea_04.ipynb new file mode 100644 index 000000000..fada5cdb8 --- /dev/null +++ b/04 - Estructuras de datos/Tarea_04.ipynb @@ -0,0 +1,851 @@ +{ + "cells": [ + { + "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": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán']\n" + ] + } + ], + "source": [ + "#Mantener la convección entre 'comillas simples' o \"comillas dobles\" durante todo el código\n", + "paises_a=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "print(paises_a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) Imprimir por pantalla el segundo elemento de la lista" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Casanova\n" + ] + } + ], + "source": [ + "#Las listas estan idexadas, es decir comienzan por el 0\n", + "paises_b=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "print(paises_b[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Imprimir por pantalla del segundo al cuarto elemento" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán']\n", + "['Casanova', 'Hurlingham', 'Buenos Aires']\n", + "['Casanova', 'Buenos Aires']\n" + ] + } + ], + "source": [ + "paises_c=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "print(paises_c)\n", + "print(paises_c[1:4])\n", + "#Como ir recorriendo la lista\n", + "print(paises_c[1:4:2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) Visualizar el tipo de dato de la lista" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "paises_d=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "print(type(paises_d))" + ] + }, + { + "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": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Hurlingham', 'Buenos Aires', 'Catán']\n" + ] + } + ], + "source": [ + "#Arranco desde un indice a imprimir la lista\n", + "paises_e=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "print(paises_e[2:])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) Visualizar los primeros 4 elementos de la lista" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires']\n" + ] + } + ], + "source": [ + "#Indico hasta que indice imprimir la lista\n", + "paises_f=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "print(paises_f[:4])" + ] + }, + { + "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": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán', 'Casanova', 'Morón']\n" + ] + } + ], + "source": [ + "#Sólo se puede agregagar uno a la vez, sino arroja error.\n", + "\n", + "paises_g=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "paises_g.append('Casanova')\n", + "paises_g.append('Morón')\n", + "print(paises_g)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Agregar otra ciudad, pero en la cuarta posición" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Barcelona', 'Buenos Aires', 'Catán']\n" + ] + } + ], + "source": [ + "#Agregar con indice\n", + "paises_h=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "paises_h.insert(3,'Barcelona')\n", + "print(paises_h)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9) Concatenar otra lista a la ya creada" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán', 'La Ferrere', 'Casanova', 'Hurlingham', 'Barcelona', 'Buenos Aires', 'Catán']\n" + ] + } + ], + "source": [ + "#Agregar lista\n", + "paises_i=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "paises_i.extend(paises_h)\n", + "print(paises_i)" + ] + }, + { + "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": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán', 'Casanova', 'Morón']\n", + "1\n" + ] + } + ], + "source": [ + "#Solo muestra el índice de la primera vez que aparece.\n", + "print(paises_g)\n", + "print(paises_g.index('Casanova'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11) ¿Qué pasa si se busca un elemento que no existe?" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "'moron' is not in list", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32me:\\Prep-Henry\\Python-Prep\\04 - Estructuras de datos\\Tarea_04.ipynb Cell 22'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39m#Me da error porque no está en la lista\u001b[39;00m\n\u001b[0;32m 2\u001b[0m paises_j\u001b[39m=\u001b[39m[\u001b[39m'\u001b[39m\u001b[39mLa Ferrere\u001b[39m\u001b[39m'\u001b[39m,\u001b[39m'\u001b[39m\u001b[39mCasanova\u001b[39m\u001b[39m'\u001b[39m,\u001b[39m'\u001b[39m\u001b[39mHurlingham\u001b[39m\u001b[39m'\u001b[39m,\u001b[39m'\u001b[39m\u001b[39mBuenos Aires\u001b[39m\u001b[39m'\u001b[39m,\u001b[39m'\u001b[39m\u001b[39mCatán\u001b[39m\u001b[39m'\u001b[39m]\n\u001b[1;32m----> 3\u001b[0m \u001b[39mprint\u001b[39m(paises_j\u001b[39m.\u001b[39;49mindex(\u001b[39m'\u001b[39;49m\u001b[39mmoron\u001b[39;49m\u001b[39m'\u001b[39;49m))\n", + "\u001b[1;31mValueError\u001b[0m: 'moron' is not in list" + ] + } + ], + "source": [ + "#Me da error porque no está en la lista\n", + "paises_j=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "print(paises_j.index('moron'))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "12) Eliminar un elemento de la lista" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Catán']\n" + ] + } + ], + "source": [ + "paises_k=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "paises_k.remove('Buenos Aires')\n", + "print(paises_k)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13) ¿Qué pasa si el elemento a eliminar no existe?" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "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;32me:\\Prep-Henry\\Python-Prep\\04 - Estructuras de datos\\Tarea_04.ipynb Cell 26'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m paises_k\u001b[39m.\u001b[39;49mremove(\u001b[39m'\u001b[39;49m\u001b[39mBuenos Aires\u001b[39;49m\u001b[39m'\u001b[39;49m)\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(paises_k)\n", + "\u001b[1;31mValueError\u001b[0m: list.remove(x): x not in list" + ] + } + ], + "source": [ + "#Me da ERROR\n", + "paises_k.remove('Buenos Aires')\n", + "print(paises_k)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Catán Hurlingham\n", + "['La Ferrere', 'Casanova', 'Buenos Aires']\n" + ] + } + ], + "source": [ + "paises_l=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "#Extraigo el último o le doy un indice para extraer.\n", + "ultimo = paises_l.pop()\n", + "otro = paises_l.pop(2)\n", + "print(ultimo, otro)\n", + "print(paises_l)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "15) Mostrar la lista multiplicada por 4" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán', 'La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán', 'La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán', 'La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán']\n" + ] + } + ], + "source": [ + "paises_m=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "print(paises_m*4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "16) Crear una tupla que contenga los números enteros del 1 al 20" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "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", + "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)\n" + ] + } + ], + "source": [ + "#Las tuplas son inmutables, no puedo ir metiendo elementos.\n", + "#creo una lista que si puedo modificar.\n", + "nueva_lista=[] \n", + "\n", + "for i in range(1,21):\n", + " nueva_lista.append(i)\n", + "\n", + "#Convierto la lista en una tupla\n", + "mi_tupla=tuple(nueva_lista)\n", + "#Lista\n", + "print(nueva_lista)\n", + "#Tupla\n", + "print(mi_tupla)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "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": [ + "#Otra opción más fácil\n", + "tup=tuple(range(1,21))\n", + "print(tup)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "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": [ + "#Sirve también en listas\n", + "lista = list(range(1,21))\n", + "print(lista)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "17) Imprimir desde el índice 10 al 15 de la tupla" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(11, 12, 13, 14, 15, 16)\n" + ] + } + ], + "source": [ + "#Es lo mismo con las listas\n", + "print(tup[10:16])" + ] + }, + { + "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": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "20 Esta en la tupla\n" + ] + } + ], + "source": [ + "print(20 in tup)\n", + "print(30 in tup)\n", + "\n", + "#Más compleja\n", + "for i in tup:\n", + " if(i==20):\n", + " print(i, 'Esta en la tupla')\n", + " elif(i==30):\n", + " print(i, 'Esta en la tupla')" + ] + }, + { + "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": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán']\n", + "Se insertó el elemento París\n", + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán', 'París']\n" + ] + } + ], + "source": [ + "paises_a=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "elemento ='París'\n", + "print(paises_a)\n", + "\n", + "#Si el elemento NO esta en la lista, lo agrega\n", + "if(not(elemento in paises_a)):\n", + " paises_a.append(elemento)\n", + " print('Se insertó el elemento',elemento)\n", + "\n", + "#Si está en la lista, imprime\n", + "else:\n", + " print('EL elemento', elemento, 'ya existía') \n", + "\n", + "print(paises_a)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán']\n", + "El elemento forma parte de la lista\n", + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán']\n" + ] + } + ], + "source": [ + "#Otra Opción con input (inpunt siempre me da un string)\n", + "paises_n=['La Ferrere','Casanova','Hurlingham','Buenos Aires','Catán']\n", + "print(paises_n)\n", + "ciudad = input('Ingrese la ciudad que desea agregar: ')\n", + "\n", + "if(ciudad in paises_n):\n", + " print('El elemento forma parte de la lista')\n", + "else:\n", + " paises_n.append(ciudad)\n", + " print('Se agregó', ciudad,'a la lista') \n", + "print(paises_n)" + ] + }, + { + "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 lis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "1\n" + ] + } + ], + "source": [ + "print(tup.count(10))\n", + "print(paises_a.count('Casanova'))" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán', 'París', 'Catán']\n", + "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)\n", + "True\n", + "True\n", + "2\n", + "1\n" + ] + } + ], + "source": [ + "paises_a.append('Catán')\n", + "print(paises_a)\n", + "print(tup)\n", + "\n", + "print('Catán' in paises_a)\n", + "print(10 in tup)\n", + "\n", + "print(paises_a.count('Catán'))\n", + "print(tup.count(10))" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Catán aparece 1 vez/ces en la lista\n" + ] + } + ], + "source": [ + "#Otra opción con input\n", + "busqueda = input('Ingrese la cuidad que desea buscar: ')\n", + "#VAriable contadora\n", + "n=0 \n", + "#Itero en la lista\n", + "for i in paises_n:\n", + " #Comparo el elemento de la lista con el que busco\n", + " if(i==busqueda):\n", + " n +=1 #Por cada vez que lo encuentre, sumo uno\n", + " \n", + "print(busqueda,'aparece',n,'vez/ces en la lista')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "21) Convertir la tupla en una lista" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "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_z = list(tup)\n", + "print(lista_z)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2 3\n" + ] + } + ], + "source": [ + "#Si no desempaqueto todo, tengo que darle un límite\n", + "var1,var2,var3 = tup[:3]\n", + "print(var1,var2,var3)" + ] + }, + { + "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": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Ciudad': ['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán', '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": [ + "diccionario = {'Ciudad': paises_n,\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']}\n", + "\n", + "print(diccionario)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "24) Imprimir las claves del diccionario" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['Ciudad', 'País', 'Continente'])\n" + ] + } + ], + "source": [ + "print(diccionario.keys())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "25) Imprimir las ciudades a través de su clave" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['La Ferrere', 'Casanova', 'Hurlingham', 'Buenos Aires', 'Catán', 'París']\n" + ] + } + ], + "source": [ + "print(diccionario['Ciudad'])" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "be8ebe292a6fb22f2c19ec4d5075a38adaba2a2c1e51ef08f8bc0ed916701165" + }, + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/04 - Estructuras de datos/__pycache__/Prep_Course_Homework_04-Resuelto.cpython-37.pyc b/04 - Estructuras de datos/__pycache__/Prep_Course_Homework_04-Resuelto.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a800a1bf64d2ab4e38d6ed27e9f62068309827f0 GIT binary patch literal 1543 zcmah|&u<$=6rS~u^?JQ_oY-wCl(Lla!<0k?dPIoC4Js08L!)vSS&F89BX@|svzpxr zajp>uZu|ipoMR3>px(HezhbYP_Fv${duuxl2nmnpoA+kk`{sQ!vpdbE&**pW$@4$f z82htume9rVE9}X`5@W!?ffAIV0#$IKHu5-=j$~(!Q;gu9y7Z6S#TwjL*|5PIvLV?~ z?H9)Y>648`74U{^oS~{HkPh6G4S4gcyx^S$(7mD|xKz}nDtHU)X%+kUgDzj=ZNAPo z{;y%q+OqEUa$GM)25-SFcpGlRI}pOVa0lK)`!2i>AB>vt;eWJ`02{9Lel7D3@^+Sd zomuyM^%gqt@!}mocexD9dVRRW62ses%g zpz3q_kn#pWK+q&;5#V>l@-_jLm2VJq2J7%Lp=ep*?fu zNlJcIMIcWy*T{)JmRUL0F?a1aRTG_+QyX({bwF8ls4ej!cghJrGiR440j%BzRK8tWPiK18ZSPYep#F(DbScH2b715~} zJn9ejr|AnFZSETxhZ7ZQqecn?2lpQ!#cq-sJ4`J;bIJsf>SREnhkb2LA`c(wiTqKU zqr>|THlNA_FCo=i@iguSqPOe5>$~Vb8`nN80O zCMi4xPgYsz(efZi4qnuYSMp!X)zf4H0*1zIomKy|3So?zuQHP!jw*dSmtW zh!B6}gI%c5`(t|I?@b|mp#%seH)c?RTod{bieC(r&!iMIW1Ob7_0k=ICW>vE14-Ny zDAD3E@gE@ZCIpycw6%n;tJ z1vN$4P326f>Kn(||Lzewe?xpak?U&eb6BVBXiRsa9y(ahZ%6&9xjxAqh7YmMXK`bJ zIzw8dFiV}8enZ71l?E1kiBmYeB*?RopN-zm*5_jGeDKe!SFgH!Q@fJEAh_P8iz>PW zh9ZN*z!$tbz`z%}JIFB1Fv>7PkX|OZ616<{vowTg!Mz+Ok&CgLhMwEeUNZ@ro(tG= zTNwJO_Yi473z4tAw$}`Heh=N1&E!E8W-{C=UraHKV)sIzF;>N8j|99p<$x|mew6Gy zQ}(qWUX46u-Hh6v>bszQ43i)v^EQUKm14_N&T`a>+N%LsE0Io8-)kxRYT~s5FXg;0 zw0E9sic8s-Qyq1@IaAroK?)wET!0mC=hs-3mLnD>b<9kihRVF(+Ej(Oh1gMcGtwHh zDm{@%O8w&ZmXefqG)!0PNU3NSj=Rg_wyvf%kLHz8aG0`q=QH3 z&bwcP^wx1eS-aP%6H(~3xHsHNFY&@HuW@C$(d*6pipGxH4%|owJ{7ywSUgD*R}<78 zrB3a}-e9$baf8YCmZMb1c<)No#;+s2c5m_I{7sChJxR3C*?d`AY6Wr9jM|;^e^PKU z=V}X`7mIUNmX01qR9~d8;H^)TnTC-vA&Qli(0*G7u6b_LqXu#KNkqNn*s+CeY8ag$ zjOS)lf%otFF|&g(Mx7|@ey|#4 zW}LQ_L%zhKAnc|G7 bq}to5+~=})->mJBGWp1gQIRFukN5u<_htXu literal 0 HcmV?d00001 diff --git a/05 - Iteradores e Iterables/tarea05.ipynb b/05 - Iteradores e Iterables/tarea05.ipynb new file mode 100644 index 000000000..10d8e4cc5 --- /dev/null +++ b/05 - Iteradores e Iterables/tarea05.ipynb @@ -0,0 +1,820 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1]\n" + ] + } + ], + "source": [ + "lista = [] #Crear una lista vacía\n", + "n = -15 #Comienzo desde -15 porque desde aí voy a guardar los valores\n", + "while (n < 0): #Condicón del while\n", + " lista.append(n) #Acá le voy agregando valor a la lista\n", + " n += 1 #Incrementar para que el while finalice\n", + "print(lista) #Imprimo la lista creada" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares?" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-14\n", + "-12\n", + "-10\n", + "-8\n", + "-6\n", + "-4\n", + "-2\n", + "[-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15]\n" + ] + } + ], + "source": [ + "n = 0 #Con esta variable voy a recorrer la lista\n", + "while (n < len(lista)): #len() me devuelve 15, entonces n<15\n", + " if (lista[n] % 2 == 0): #Si el resto de la : por 2 = 0 cumple la condición\n", + " print(lista[n]) #Se impmrime el número alojado en ese indice\n", + " n += 1 #incrementa el número \n", + "\n", + "lista.sort(reverse=True) #Ordena de mayoro a menor.\n", + "print(lista)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3) Resolver el punto anterior sin utilizar un ciclo while" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2\n", + "-4\n", + "-6\n", + "-8\n", + "-10\n", + "-12\n", + "-14\n" + ] + } + ], + "source": [ + "for i in lista:\n", + " if (i % 2 == 0):\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) Utilizar el iterable para recorrer sólo los primeros 3 elementos" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1\n", + "-2\n", + "-3\n" + ] + } + ], + "source": [ + "for i in lista[:3]:\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 -1\n", + "1 -2\n", + "2 -3\n", + "3 -4\n", + "4 -5\n", + "5 -6\n", + "6 -7\n", + "7 -8\n", + "8 -9\n", + "9 -10\n", + "10 -11\n", + "11 -12\n", + "12 -13\n", + "13 -14\n", + "14 -15\n" + ] + } + ], + "source": [ + "for i, c in enumerate(lista):\n", + " print(i, c)\n", + "\n", + "#A mi me sale al revés porque lo ordene de mayor a menor" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "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]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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_2=[1,2,5,7,8,10,13,14,15,17,20]\n", + "i=1\n", + "n=0\n", + "while(i<20):\n", + " if(i\n", + "n0 = 0
\n", + "n1 = 1
\n", + "ni = ni-1 + ni-2
\n", + "Crear una lista con los primeros treinta números de la sucesión.
" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[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": [ + "fibo = [0,1] #Ya pertenecen al listado, no tengo que dar más intrucciones\n", + "n = 2 #Por eso comienzo desde el 2\n", + "while(n < 30): #Declaramos el recorrido del while\n", + " fibo.append(fibo[n-1]+fibo[n-2]) #Yo agregando el resultado al final\n", + " n += 1 #Sumo el contador\n", + "print(fibo)\n", + "\n", + "#Lo importante es entender como se construye el fibonachi, después es solo realizar el código." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[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": [ + "#Otra opción. Recorro vacía la lista\n", + "fibonacci = []\n", + "for i in range(0,30):\n", + " if(i==0 or i==1): #Si i es = 0 o = 1 \n", + " fibonacci.append(i) #Lo agrego directamente, en su respectivo indice\n", + " else: #Si no es = 0 o = 1\n", + " fibonacci.append(fibonacci[i-1]+fibonacci[i-2]) #Agrego el resultado de la suma.\n", + "print(fibonacci)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8) Realizar la suma de todos elementos de la lista del punto anterior" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1346268" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum(fibo) #Métodos que me permitían operar dentro de un iterable." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1346268\n" + ] + } + ], + "source": [ + "#Otra opción\n", + "suma = sum(fibonacci)\n", + "print(suma)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "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:
\n", + "Donde i es la cantidad total de elementos
\n", + "ni-1 / ni
\n", + "ni-2 / ni-1
\n", + "ni-3 / ni-2
\n", + "ni-4 / ni-3
\n", + "ni-5 / ni-4
" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6176470588235294\n", + "1.6181818181818182\n", + "1.6179775280898876\n", + "1.6180555555555556\n", + "1.6180257510729614\n" + ] + } + ], + "source": [ + "#5 pares es igual a 10. Leer bien los enunciados!!!\n", + "primeros = 15\n", + "n = primeros - 5\n", + "while(n < primeros):\n", + " print(fibo[n]/fibo[n-1])\n", + " n += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6176470588235294\n", + "1.6181818181818182\n", + "1.6179775280898876\n", + "1.6180555555555556\n", + "1.6180257510729614\n", + "for\n", + "1.6176470588235294\n", + "1.6181818181818182\n", + "1.6179775280898876\n", + "1.6180555555555556\n", + "1.6180257510729614\n" + ] + } + ], + "source": [ + "i=10\n", + "while i < 15:\n", + " print(fibonacci[i]/fibonacci[i-1])\n", + " i +=1\n", + "print('for')\n", + "\n", + "for i in range(10,15):\n", + " print(fibonacci[i]/fibonacci[i-1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra \"n\"
\n", + "cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python'" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7 n\n", + "21 n\n", + "39 n\n", + "60 n\n", + "67 n\n" + ] + } + ], + "source": [ + "#i recorre la posición de la letra en la cadena y se el valor de la posición de i\n", + "cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python'\n", + "for i, c in enumerate(cadena): #Si o si se utiliza enumerate\n", + " if c == 'n':\n", + " print(i, c)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11) Crear un diccionario e imprimir sus claves utilizando un iterador" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ciudad\n", + "País\n", + "Continente\n" + ] + } + ], + "source": [ + "dicc = { 'Ciudad': ['Buenos Aires','Caracas','Bogotá','Lisboa','Roma'], \n", + " 'País': ['Argentina','Venezuela','Colombia','Portugal','Italia'], \n", + " 'Continente' : ['América','América','América','Europa','Europa']}\n", + "#Con el Iterador, recorro las claves\n", + "for i in dicc:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prep\n", + "Data Sciense\n", + "['Python', 'Math']\n", + "['Librerias Python', 'SQL', 'Estadística']\n", + "Python\n", + "Librerias Python\n" + ] + } + ], + "source": [ + "alumnos = {'Prep':['Python','Math'],\n", + " 'Data Sciense':['Librerias Python','SQL','Estadística']}\n", + "\n", + "#Claves del diccionario\n", + "for i in alumnos:\n", + " print(i)\n", + "\n", + "#Valor que forman parte de las claves dentro del diccionario\n", + "for i in alumnos:\n", + " print(alumnos[i])\n", + "\n", + "#Valor de la posición de la lista. Indice. \n", + "#Prestar mucha atención a la cantidad de elementos de cada lista porque puede dar ERROR.\n", + "for i in alumnos:\n", + " print(alumnos[i][0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "12) Convertir en una lista la variable \"cadena\" del punto 10 y luego recorrerla con un iterador " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python'\n", + "print(type(cadena))\n", + "cadena = list(cadena) #Convierto la cadena en una lista\n", + "print(type(cadena))" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "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": [ + "recorre = iter(cadena) #Devuelve un Iterador\n", + "largo = len(cadena) #Me devuelve un entero\n", + "for i in range(0, largo):\n", + " print(next(recorre)) #Me muestra en que posición estoy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13) Crear dos listas y unirlas en una tupla utilizando la función zip" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[('run', 'correr'), ('fly', 'volar'), ('sleep', 'dormir')]\n" + ] + } + ], + "source": [ + "lis1 = ['run','fly','sleep'] #Valor de la lista\n", + "lis2 = ['correr','volar','dormir'] #Valor de la lista\n", + "lisz = zip(lis1, lis2) #Variable con la función de unir las dos listas\n", + "print(type(lisz)) #Imprimo el tipo de la variable lisz\n", + "print(list(lisz)) #Imprimo la lista" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
\n", + "lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[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", + "#Se va guardando los datos si se cumple la condición:\n", + "#De i en i en lis si el resto de i:7 es igual a 0\n", + "lis2 = [i for i in lis if i % 7 == 0]\n", + "\n", + "print(lis2) #Imprimo la lista" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "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:
\n", + "lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "La cantidad total de elementos es 12\n" + ] + } + ], + "source": [ + "#Lista que contiene otra lista, string, booleano, otra lista con string\n", + "lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']]\n", + "\n", + "print(type(lis))\n", + "\n", + "cantidad = 0 #Contador\n", + "\n", + "for elemento in lis:\n", + " if (type(elemento) == list): #Si el elemento es una lista\n", + " cantidad += len(elemento) #Que cuente cada elemento de la lista\n", + " else: #Si no es una lista\n", + " cantidad += 1 #Solo suma 1\n", + "print('La cantidad total de elementos es', cantidad)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1, 2, 3, 4], ['r', 'o', 'j', 'o'], ['v', 'e', 'r', 'd', 'e'], [True, False, False], ['uno', 'dos', 'tres']]\n" + ] + } + ], + "source": [ + "for indice, elemento in enumerate(lis):\n", + " if (type(elemento) != list): #Si el elemento no es una lista\n", + " lis[indice]=[elemento] #Lo guardo como una en el indice indicado\n", + "print(lis)\n", + "\n", + "#El ['uno','dos,'tres'] no lo guardo por separado porque ya es una lista" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1, 2, 3, 4], ['r', 'o', 'j', 'o'], ['v', 'e', 'r', 'd', 'e'], [True, False, False], ['uno', 'dos', 'tres']]\n" + ] + } + ], + "source": [ + "for indice, elemento in enumerate(lis):\n", + " if (type(elemento) != list): #Si el elemento no es una lista\n", + " lis[indice]=list(elemento) #Lo guardo como una en el indice indicado\n", + "print(lis)\n", + "\n", + "#El ['uno','dos,'tres'] no lo guardo por separado porque ya es una lista" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "70956b4a6c64855e044259549ca8e1795d293bdfd9b2c72edb2802a64e434e5c" + }, + "kernelspec": { + "display_name": "Python 3.10.4 64-bit (windows store)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/06 - Funciones/Ejemplos.py b/06 - Funciones/Ejemplos.py new file mode 100644 index 000000000..6e816aae6 --- /dev/null +++ b/06 - Funciones/Ejemplos.py @@ -0,0 +1,49 @@ +#Creo un diccionario: +mi_diccionario = { 'Colores Primarios': ['Rojo', 'Azul','Amarillo'], + 'Colores secundarios': ['Naranja','Violeta','Verde'], + 'Clave3': 10, + 'Clave4': False} + +#imprimir un diccionario +print(mi_diccionario) + +#Imprimir un valor a través de su clave +print(mi_diccionario['Colores secundarios']) + +#Agregar un valor +mi_diccionario['Clave5']='Otro ejemplo' + +#Cambiar un valor +mi_diccionario['Clave3']=2 + +#Eliminar un elemento a través de su clave. +del mi_diccionario['Clave4'] +print(mi_diccionario) + +#Utilizar una tupla como clave de un diccionario. +mi_tupla=('Argentina','Italia','Inglaterra') +mi_diccionario={mi_tupla[0]:'Buenos Aires', + mi_tupla[1]:'Roma', + mi_tupla[2]:'Londres'} +print(mi_diccionario) + +#Colocar una (tupla) dentro de un diccionario +mi_diccionario={'clave1':'Valor1','Clave2':(1,2,3,4,5)} +print(mi_diccionario) + +#Colocar una [lista] dentro de un diccionario. +mi_diccionario={'clave1':'Valor1','Clave2':[1,2,3,4,5]} +print(mi_diccionario) + +#Colocar un diccionario dentro de un diccionario +mi_diccionario={'Clave1':'Valor1', ' Clave2':{'numeros':[1,2,3,4,5]}} +print(mi_diccionario) + +#Imprimir las clves del diccionario +print(mi_diccionario.keys()) + +#Imprimir los valores del diccionario +print(mi_diccionario.values()) + +#Imprimir la longitud del diccionario +print(len(mi_diccionario)) \ No newline at end of file diff --git a/06 - Funciones/Tarea06.ipynb b/06 - Funciones/Tarea06.ipynb new file mode 100644 index 000000000..fdb4e9999 --- /dev/null +++ b/06 - Funciones/Tarea06.ipynb @@ -0,0 +1,679 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "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" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "#Siempre definir la función con verbos o con lo que hace la función\n", + "def calcular_primos(numeros):\n", + " #Variable local para retornar\n", + " _es_primo = True\n", + " #Número negativo, devuelvo False\n", + " if (numeros<=1):\n", + " _es_primo = False\n", + "\n", + " #Itera a partir de un 2 hasta el número dado\n", + " for i in range(2,numeros): \n", + " #Si devuelve un resto cero es porque es divisible\n", + " if numeros%i==0:\n", + " _es_primo = False\n", + " #Rompo la iteración porque ya cumplí con mi condición\n", + " break\n", + " #Devuelvo el valor de la variable, no la variable en si\n", + " return _es_primo\n", + "\n", + "#Llamo a la función\n", + "print(calcular_primos(1))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "#Otra opción con input\n", + "def primos(numero):\n", + " n=True\n", + " if(numero<=1):\n", + " n=False\n", + " else:\n", + " for i in range(2,numero):\n", + " if(numero%i==0):\n", + " n=False\n", + " return n\n", + "\n", + "#Tengo que castearlo porque input me devuelve un string\n", + "numero = int(input('Ingrese numero:'))\n", + "\n", + "print(primos(numero)) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "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" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "#Función que recibe la lista de números\n", + "def extrae_primos_de_lista(lista):\n", + " #Creo una lista local\n", + " lista_primos=[]\n", + " #Recorro la lista que recibo\n", + " for elemento in lista:\n", + " #Utilizo la función calcular si es primo o no\n", + " if calcular_primos(int(elemento)):\n", + " #Si lo es, lo agrego a la lista local\n", + " lista_primos.append(elemento)\n", + " #Retorno los valores de la lista \n", + " return lista_primos" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 3, 5, 7, 11, 13, 17, 19]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lis_completa = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]\n", + "#Cargo la lista de primos a través de la función que le envió la lis_completa\n", + "_lis_primos = extrae_primos_de_lista(lis_completa)\n", + "_lis_primos" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "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", + "[2, 3, 5, 7, 11, 13, 17, 19]\n" + ] + } + ], + "source": [ + "#Otra opción. Iteración para cargar la lista\n", + "#Declaro la Lista\n", + "lista_numeros=[]\n", + "\n", + "#Cargo la lista con números de un rango\n", + "for i in range(1,21):\n", + " lista_numeros.append(i)\n", + "\n", + "print(lista_numeros)\n", + "\n", + "#Cargo la lista de primos a través de la función que le envió la lista de números\n", + "lis_primos = extrae_primos_de_lista(lista_numeros)\n", + "\n", + "print(lis_primos)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "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" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "#Declaro la función\n", + "def valor_modal(lista):\n", + " \n", + " #Lista para guardar los elementos repetidos y cuantas veces se repite.\n", + " lista_unicos = [] \n", + " lista_repeticiones = [] \n", + " \n", + " #Si no hay elementos en la lista, no devuelve nada.\n", + " if len(lista) == 0: \n", + " return None\n", + "\n", + " #Recorro cada elemento de la lista \n", + " for elemento in lista:\n", + " #Si el elemento ya está en lista_unicos\n", + " if elemento in lista_unicos:\n", + " #Busco el indice por el elmento y lo guardo en i\n", + " i = lista_unicos.index(elemento) \n", + " #Con el indice, voy a la otra lista y le sumo uno\n", + " lista_repeticiones[i] += 1 #Así cuento las veces que se repite\n", + "\n", + " #Si el elemento no está en la lista\n", + " else: \n", + " #Agrego al final de las dos listas, tanto al elemento y a 1 \n", + " lista_unicos.append(elemento) #se agrega al final de la lista.\n", + " lista_repeticiones.append(1) #Ademas, agrego el valor 1 a las lista_repeticiones.\n", + " \n", + " #Creamos dos variables y le damos el valor del primer elemento de cada lista.\n", + " moda = lista_unicos[0] \n", + " maximo = lista_repeticiones[0] \n", + " \n", + " #Con enumerate y dos variables en el for recorremos los indices y sus valores\n", + " for i, elemento in enumerate(lista_unicos): \n", + " #Verifico si el valor guardado en [i] es mayor a maximo.\n", + " if lista_repeticiones[i] > maximo: \n", + " #Si lo es, asigno el valor del [i] de cada lista para moda y maximo.\n", + " moda = lista_unicos[i] \n", + " maximo = lista_repeticiones[i]\n", + "\n", + " #Termina el bucley devuelvo el valor maximo de repeticiones junto al valor modal. \n", + " return moda, maximo " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El valor modal es 3 y se repite 4 veces.\n" + ] + } + ], + "source": [ + "lis = [2,3,4,7,3,4,2,7,2,8,3,3,5,1]\n", + "moda, repite = valor_modal(lis)\n", + "print('El valor modal es', moda, 'y se repite', repite, 'veces.')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 7)\n" + ] + } + ], + "source": [ + "#Sin bucle for al final\n", + "def valores_repetidos(lista):\n", + " #Lista para guardar los elementos repetidos y cuantas veces se repite.\n", + " lista_unicos=[] \n", + " lista_repeticiones=[] \n", + " \n", + " #Recorro la lista\n", + " for c in lista: \n", + " #Si no está en la lista\n", + " if(not(c in lista_unicos)):\n", + " #Agrego al final de las dos listas, tanto al elemento y a 1\n", + " lista_unicos.append(c) \n", + " lista_repeticiones.append(1) \n", + "\n", + " #Si está en la lista\n", + " else: \n", + " #busco y guardo el valor del índice\n", + " i=lista_unicos.index(c)\n", + " #A ese indice i del lista_repeticiones. Le vamos a sumar uno.\n", + " lista_repeticiones[i]+=1 \n", + " \n", + " #Busco el max de esa lista y lo guardo en la variable\n", + " repeticiones = max(lista_repeticiones) \n", + " #Utilizo el valor de repeticiones para buscar el indice.\n", + " moda=lista_unicos[lista_repeticiones.index(repeticiones)] \n", + " \n", + " return moda,repeticiones\n", + "\n", + "lista_prueba = [1,1,2,2,2,2,3,4,4,4,4,4,1,2,2,5,2,6,1]\n", + "print(valores_repetidos(lista_prueba))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4) A la función del punto 3, agregar un parámetro más, que permita elegir si se requiere el menor o el mayor de los mas repetidos." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "([1, 8, 9], 3)\n" + ] + } + ], + "source": [ + "#Para devolver el menor valor repetido\n", + "def valores_repetidos_menor(lista, menor):\n", + " lista_unicos = []\n", + " lista_repeticiones = []\n", + " for c in lista:\n", + " if(not(c in lista_unicos)): #Si no está en la lista\n", + " lista_unicos.append(c)\n", + " lista_repeticiones.append(1)\n", + "\n", + " else:\n", + " i=lista_unicos.index(c)\n", + " lista_repeticiones[i]+=1\n", + "\n", + " repeticiones = max(lista_repeticiones) #Este máximo puede estar repetido\n", + " moda = [] #Otra lista, porque puedo tener más de un número que se repite la misma cantidad de veces\n", + " \n", + " for i,c in enumerate(lista_repeticiones):\n", + "\n", + " if(c==repeticiones):\n", + " moda.append(lista_unicos[i]) \n", + "\n", + " if (menor):\n", + " moda.sort()\n", + " moda=moda[0]\n", + " return moda,repeticiones \n", + "\n", + " return moda,repeticiones\n", + "\n", + "lista2=[1,1,1,5,6,7,8,8,8,9,9,9]\n", + "print(valores_repetidos_menor(lista2,False))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "def valor_modal(lista, menor):\n", + " '''\n", + " Esta función devuelve el valor modal y recibe de parámetros dos valores:\n", + " 1-Una lista de números\n", + " 2-Verdadero (por defecto) por si se requiere el mínimo de los más repetidos, o Falso si se requiere el máximo\n", + " '''\n", + " lista_unicos = []\n", + " lista_repeticiones = []\n", + " if len(lista) == 0:\n", + " return None\n", + " if (menor):\n", + " lista.sort()\n", + " else:\n", + " lista.sort(reverse=True)\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" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El valor modal es 5 y se repite 3 veces.\n" + ] + } + ], + "source": [ + "lis = [10,1,5,6,8,10,22,5,6,4,11,10,9,5]\n", + "moda, repite = valor_modal(lis, True)\n", + "print('El valor modal es', moda, 'y se repite', repite, 'veces.')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
\n", + "Fórmula 1\t: (°C × 9/5) + 32 = °F
\n", + "Fórmula 2\t: °C + 273.15 = °K
\n", + "Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def conversion_grados(valor, origen, destino): #La función recibe un valor de un número, con un sistema de medición y en que lo con\n", + " \n", + " if (origen == 'celsius'): #Si el origen es celsius\n", + " if (destino == 'celsius'): #Y el destino es celsius\n", + " valor_destino = valor #No commbierto nada\n", + " \n", + " elif (destino == 'farenheit'): #Si el destino es farenheit\n", + " valor_destino = (valor * 9 / 5) + 32 #Lo convierto con la formula\n", + " \n", + " elif (destino == 'kelvin'): #Si el destino es Kelvin\n", + " valor_destino = valor + 273.15 #Lo convierto con la formula\n", + " \n", + " else:\n", + " print('Parámetro de Destino incorrecto') #Si el destino no coincide con ninguno impripo el texto.\n", + " \n", + " \n", + " elif (origen == 'farenheit'): #Si el origen es Farenheit\n", + " if (destino == 'celsius'): #Y el destino es celsius\n", + " valor_destino = (valor - 32) * 5 / 9 #Lo convierto con la formula\n", + "\n", + " elif (destino == 'farenheit'): #Si el destino es farenheit\n", + " valor_destino = valor #No commbierto nada\n", + "\n", + " elif (destino == 'kelvin'): #Si el destino es Kelvi\n", + " valor_destino = ((valor - 32) * 5 / 9) + 273.15 #Lo convierto con la formula\n", + "\n", + " else:\n", + " print('Parámetro de Destino incorrecto')#Si el destino no coincide con ninguno impripo el texto.\n", + "\n", + " elif (origen == 'kelvin'): #Si el origen es Kervin\n", + " if (destino == 'celsius'): #Y el destino es celsius\n", + " valor_destino = valor - 273.15 #Lo convierto con la formula\n", + "\n", + " elif (destino == 'farenheit'): #Si el destino es farenheit\n", + " valor_destino = ((valor - 273.15) * 9 / 5) + 32 #Lo convierto con la formula\n", + "\n", + " elif (destino == 'kelvin'): #Si el destino es Kelvi\n", + " valor_destino = valor #No convierto nada\n", + " else:\n", + " print('Parámetro de Destino incorrecto') #Si el destino no coincide con ninguno impripo el texto.\n", + "\n", + " else:\n", + " print('Parámetro de Origen incorrecto') #Si el origen no coincide con ninguno impripo el texto.\n", + "\n", + " return valor_destino #Devuelvo el valor convertido o el mismo si el origen o destino son iguales" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "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.87\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:', conversion_grados(1, 'celsius', 'celsius'))\n", + "print('1 grado Celsius a Kelvin:', conversion_grados(1, 'celsius', 'kelvin'))\n", + "print('1 grado Celsius a Farenheit:', conversion_grados(1, 'celsius', 'farenheit'))\n", + "print('1 grado Kelvin a Celsius:', conversion_grados(1, 'kelvin', 'celsius'))\n", + "print('1 grado Kelvin a Kelvin:', conversion_grados(1, 'kelvin', 'kelvin'))\n", + "print('1 grado Kelvin a Farenheit:', conversion_grados(1, 'kelvin', 'farenheit'))\n", + "print('1 grado Farenheit a Celsius:', conversion_grados(1, 'farenheit', 'celsius'))\n", + "print('1 grado Farenheit a Kelvin:', conversion_grados(1, 'farenheit', 'kelvin'))\n", + "print('1 grado Farenheit a Farenheit:', conversion_grados(1, 'farenheit', 'farenheit'))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 grado celsius a kelvin: 274.15\n" + ] + } + ], + "source": [ + "#Otra opción\n", + "def conversion_grados_2(valor,origen,destino):\n", + " #Operaciones de conversión\n", + " celsius_farenheit = (valor*9/5)+32\n", + " celsius_kelvin = valor+273.15\n", + " farenheit_celsius = (valor-32)/(5/9)\n", + " farenheit_kelvin = farenheit_celsius+273.15\n", + " kelvin_celsius = valor-273.15\n", + " kelvin_farenheit = (kelvin_celsius*9/5) + 32\n", + "\n", + " #Operaciones de asignación\n", + " #Celsius\n", + " if( origen == 'c' and destino == 'f'):\n", + " valor_destino = celsius_farenheit\n", + " elif( origen == 'c' and destino == 'c'):\n", + " valor_destino = valor\n", + " elif( origen == 'c' and destino == 'k'):\n", + " valor_destino = celsius_kelvin\n", + " \n", + " #Farenheit\n", + " elif( origen == 'f' and destino == 'f'):\n", + " valor_destino = valor\n", + " elif( origen == 'f' and destino == 'c'):\n", + " valor_destino = farenheit_celsius\n", + " elif( origen == 'f' and destino == 'k'):\n", + " valor_destino = farenheit_kelvin\n", + " \n", + " #Kelvin\n", + " elif( origen == 'k' and destino == 'k'):\n", + " valor_destino = valor\n", + " elif( origen == 'k' and destino == 'c'):\n", + " valor_destino = kelvin_celsius\n", + " elif( origen == 'k' and destino == 'f'):\n", + " valor_destino = kelvin_farenheit\n", + " else: return print ('Ingrese los parámetros correctos')\n", + " \n", + " return valor_destino\n", + "print('1 grado celsius a kelvin:', conversion_grados_2(1,'c','k')) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) 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:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "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.87\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": [ + "metricas = ['celsius','kelvin','farenheit']\n", + "for i in range(0,3):\n", + " for j in range(0,3):\n", + " print('1 grado', metricas[i], 'a', metricas[j],':', conversion_grados(1, metricas[i], metricas[j]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7) 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" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n", + "El numero debe ser positivo\n", + "El numero debe ser un entero\n", + "El numero debe ser un entero\n" + ] + } + ], + "source": [ + "def factorial(numero):\n", + " if(type(numero) != int):\n", + " return 'El numero debe ser un entero'\n", + " if(numero < 0):\n", + " return 'El numero debe ser positivo'\n", + " if (numero > 1):\n", + " numero = numero * factorial(numero - 1)\n", + " return numero\n", + "print(factorial(3))\n", + "print(factorial(-2))\n", + "print(factorial(1.23))\n", + "print(factorial('6'))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ratón\n", + "2\n", + "Liebre\n", + "3\n", + "Hola, soy Ratón , de color Marrón y tengo 2 años\n", + "Hola, soy Liebre , de color Gris y tengo 4 años\n" + ] + } + ], + "source": [ + "class Animal:\n", + " def __init__(self, especie, edad, color):\n", + " self.especie = especie\n", + " self.edad = edad\n", + " self.color = color\n", + "\n", + " def mePresento(self):\n", + " print('Hola, soy', self.especie,', de color', self.color,' y tengo', self.edad,' años')\n", + " \n", + " def cumplirAños(self):\n", + " self.edad = self.edad + 1\n", + "\n", + "a1 = Animal('Ratón', 2,'Marrón')\n", + "a2 = Animal('Liebre', 3,'Gris')\n", + "\n", + "print(a1.especie)\n", + "print(a1.edad)\n", + "print(a2.especie)\n", + "print(a2.edad)\n", + "\n", + "a1.mePresento()\n", + "a2.cumplirAños()\n", + "a2.mePresento()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "be8ebe292a6fb22f2c19ec4d5075a38adaba2a2c1e51ef08f8bc0ed916701165" + }, + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/06 - Funciones/__pycache__/Ejemplos.cpython-37.pyc b/06 - Funciones/__pycache__/Ejemplos.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1782e61c2536e935fe840f13eb5e27f38c85c7cb GIT binary patch literal 851 zcmZuvOK;RL5O$uME@`0;pyj1p_s|tBk5fTx3l){1R3Lh=RzhZHSX>-?gBF2fbLdg%Y5@!Q&!4&q98?+_=Q!R_Vju6E@ZJ9g)#;1Unhf_aAJN^%DfcEmU1b{xNOb}})w4s? zrPPAQTcuD^@b;D-Dp8`fVnRWzPS-2crpS7diko=kavkQ>$TOpXd_3M2RQXCLvN7%2 zkYM62m^6wW2J84d9=NhsPHI`T?tR$A!4v^+=_*HS3K!WlxKg*WMyzgkVm_10Hy{TC zX|$WdI2u{0OP-LstVT+V!w+~+jN^TwDlEo% zZ6QHGwk?`dRR)+Tkv$is(6#74-RSQel<$pR-my5!a+w(`hcqeGzkQ#M*sQe6!=nG> wc*;e0bTCfVas!pZhi=M6mmu*H&-aob2~x5oh)IX!OT3g+n{0t>ku0U}H)}fFdjJ3c literal 0 HcmV?d00001 diff --git a/06 - Funciones/__pycache__/Prep_Course_Homework_06-Resuelto.cpython-37.pyc b/06 - Funciones/__pycache__/Prep_Course_Homework_06-Resuelto.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4d596ee472ac2cbba4a354c067d265823e3530e1 GIT binary patch literal 3580 zcma)8&u<(_6|U-E(;kl<$7{TH60)7F*Xtp%*I7a~SkbcDWX(!|W3gU>T1KXKs_gCc zOt+`HC)lGNE=J;ng!afOmN>wH6%scNdss^x`2$)A2_X){6;3Ne_+E8;JdP8I8TISx zSM|Pn{odE_)w^S3RYt!X4?jw08T-3_D8&@+@8C){48{Z#{AbK(!Vo6zTv);uj;IJ% zjEJfj6*Vy?#>E9OAuftZ@sgMlUlG&d<((iQUDBfp z>}$f^8S`yvN&Ap*8ouLKq$@5p6+3k8PiOdyM~$&R*$c<_QWHWaUj`i8-1{p^>MM) zI?rttL_4x>`evkJ-<8SMo(fxW&coj_WnF|GDts)xMeoB1ca?-95Z+qQ z2;(SddO~{5!24d122nTIeE4?5 zKkleRZoMD3bNCJ}viC707bkmXKT84#k5dx|YE4D%>CE zir%JA8CE3vl;1x2->3NZ39V1>*LO*bkRX6QMWU~5$7nQ8;sS{Y5*JBKl6Z*(6{$gh z2#v6HfPRAk1qc^H0~T??!JHYvK4AL~bkOeg%*@RAuA^2FFrJx5yk})bX4wqvH{Jpz z@3Hn(9Zbw|@b8Hsim+a#unIoQdUj^$yR*NX0_~6^9dnyT&jLEIW?AO!T53PzG^W-1 z?zH!TU}w&@0sfk6is-B8jq6r!Hf5CCVI<_fqQK-MGU~LX3Q}3GD2h^ErmGW$jX23C zi{ycJG7Sq7DvG0`c;{9t7D4W`f_;1f&n9&AanOv_7Af@;v#6G_Pq;9J^$R3okU%R#!jQlpQ))5`3AB+?TPM&i6L=SM zCe0y%<`YxcG-}^P_{+p)rcPi52?W|8fi}nhEF`dk1b&LdVcc^HU9Zyq6bMdM(Ft@q z|GJ^bFo*W_(eEja!|gc9-?pFB#8JR76~M5hscB&o*i1?u>yB~ukAp1`GpDU%fq zcWd#(DDZTCX>D};M-U-S^xT_^KadI)3kq*xFIHHvEgNZE_vj%BizKu=p;X#|*75Hm zP=Iin*r#=Tlu(ku8Ekvgi@nvLnZ(aEJR3Hc(_MN>a^~1#NBRAq2UV#41(S zFx1plM5nr|N$cAvDX~(o(&QY80Y}wq^f*s~sBv0wG|$$dN){lPbHYnh8KVYfKA)W% zs|_kQ^rJ6;n5T;Zh@?MT6oT(k_Hm!iz`XW<@MPd=IYWb)V#2!2g#Gf#jDwkXF;git zXiF|Ny6E>P0c7>-5-Y+Qdj{4(FfX52(~4}c3t|20?7DNfKLjqV`*(@^Iqf|&jQ5v9 z^8#Q0S?o6O)5U0nJkCrMo9bF#X~<2g;4`pCE|5nIk)H`dZdho)=+mwGmg@_<=dL-zC(>vMt(&U zi2hhnl*-3vD3M=m#F1{+akRCg0&w@|*fzNh!E}*wbfE$@P_~Mq<)WLqe7bxl?KCdO zs2VO;%dqQSy5(ss?|u;)FE|;ks2j9k_WXkH=n$G13c?$s0A;mN^xMSteqO1UWK!Iykx&}pfm(}$%$ zs=F8zr90)jCeCI!k%6AZE>l+o2#2wS0(v`RDb8@hnn5p~Vm;{f$*p?@{X@4mDom(| zC@5Yh@^JbPmOtT2 z=zzg=uXEA!TpYgiT>rmMpFZ9B?Aw3qPJQ;TZ{_^XTK$4PKk0LgJ}zxF;?`bM;_y^O zeJ+ngx?uSx6uPGQPSFL`8`woN&3CEPuj=Q5b;i~1jGgsmIgzH}O(4Z$AEo<)FBpUUZzgxwNP4GLe>(*dV\n", + "Color
\n", + "Si es moto, auto, camioneta ó camión
\n", + "Cilindrada del motor" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gris\n", + "2.0\n", + "21\n" + ] + } + ], + "source": [ + "#Defino la clase\n", + "class Vehiculo: \n", + " \n", + " #Función instancio el objeto. __init__ es necesaria para inicializar\n", + " #Self para hacer referencia así mismo y a los atributos(color,tipo...)\n", + " def __init__(self, color, tipo, cilindrada):\n", + " #Variables que hacen referencia hacia si mismos\n", + " self.color = color \n", + " self.tipo = tipo\n", + " self.cilindrada = cilindrada\n", + " self.velocidad = 0 #Puedo crear variables y definirlas dentro de la clase\n", + " self.direccion = 0\n", + " \n", + " #Método. Funciones que son propias de las clases.\n", + " #Se diferencian principalmente por el argumento self\n", + " def Acelerar(self, velocidad): #Pide un argumento\n", + " int(velocidad) #Lo convierto en entero\n", + " velocidad += 1 #Sumo uno\n", + " return velocidad #Devuelvo\n", + " \n", + "#Objeto Vehículo.\n", + "corsa = Vehiculo('Gris','Auto',1.4) \n", + "focus = Vehiculo('Azul','Auto', 2.0)\n", + "\n", + "print(corsa.color)\n", + "print(focus.cilindrada)\n", + "print(focus.Acelerar(20)) #Le envió a la función un argumento \n" + ] + }, + { + "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": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "None\n", + "3\n", + "None\n", + "6\n", + "None\n", + "7\n" + ] + } + ], + "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 #No se la pido al usuario\n", + " self.direccion = 0 #Las inicializo yo\n", + " \n", + " def Acelerar(self, vel): #Pide un argumento\n", + " #Le sumo ese argumento, a la variable velocidad\n", + " self.velocidad += vel \n", + " \n", + " def AcelerarDoble(self, vel):\n", + " self.velocidad = vel*2\n", + " \n", + " def Frenar(self, vel):\n", + " self.velocidad += vel \n", + " \n", + " def Doblar(self, grados):\n", + " self.direccion += grados\n", + "\n", + "corsa = Vehiculo('Gris','Auto',1.4)\n", + "\n", + "print(corsa.velocidad) \n", + "#Le envió a la función un entero. No devuelve nada porque no hay return\n", + "print(corsa.Acelerar(3)) \n", + "#Pero si se produce el cambio en el atributo\n", + "print(corsa.velocidad)\n", + "\n", + "print(corsa.AcelerarDoble(3)) \n", + "print(corsa.velocidad)\n", + "\n", + "print(corsa.Frenar(1)) \n", + "print(corsa.velocidad)\n" + ] + }, + { + "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": 44, + "metadata": {}, + "outputs": [], + "source": [ + "a1 = Vehiculo('rojo', 'auto', 2) #Objeto\n", + "a2 = Vehiculo('blanco', 'camioneta', 3.6) #Objeto\n", + "a3 = Vehiculo('negro', 'moto', 1) #Objeto" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "40\n", + "30\n", + "10\n", + "30\n", + "-30\n" + ] + } + ], + "source": [ + "#Llamo a los Métodos\n", + "a1.Acelerar(40)\n", + "a1.Doblar(30)\n", + "\n", + "a2.Acelerar(60)\n", + "a2.Frenar(-50)\n", + "\n", + "a3.Acelerar(30)\n", + "a3.Doblar(-30)\n", + "\n", + "#Imprimo los cambios\n", + "print(a1.velocidad)\n", + "print(a1.direccion)\n", + "\n", + "print(a2.velocidad)\n", + "\n", + "print(a3.velocidad)\n", + "print(a3.direccion)" + ] + }, + { + "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": 46, + "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", + " #Métodos Print. Sólo imprime cuando se lo llama\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')" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "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", + "#Llamo al método\n", + "a1.Detalle()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Velocidad: 0 - Dirección: 0\n", + "Velocidad: 30 - Dirección: 0\n" + ] + } + ], + "source": [ + "#Llamo dos veces al método para ver el cambio\n", + "a1.Estado()\n", + "a1.Acelerar(30)\n", + "a1.Estado()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 6
\n", + "Verificar Primo
\n", + "Valor modal
\n", + "Conversión grados
\n", + "Factorial
" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "#Clase que va a guardar Funciones\n", + "class Herramientas:\n", + " #No necesito dotar atributos, pero necesito este espacio\n", + " def __init__(self) -> None:\n", + " pass\n", + "\n", + " def verifica_primo(self, nro): #Traemos y copiamos las funciones de la clase 6\n", + " es_primo = True\n", + " if(nro>=1):\n", + " es_primo=False\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, lista, menor):\n", + " lista_unicos = []\n", + " lista_repeticiones = []\n", + " if len(lista) == 0:\n", + " return None\n", + " if (menor):\n", + " lista.sort()\n", + " else:\n", + " lista.sort(reverse=True)\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": 53, + "metadata": {}, + "outputs": [], + "source": [ + "#Creo un Objeto de Herramientas donde tengo guardado todos los métodos\n", + "h = Herramientas()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6) Probar las funciones incorporadas en la clase del punto 5" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gris\n", + "24\n" + ] + } + ], + "source": [ + "#Llamo a los métodos que estan dentro del Objeto\n", + "h.verifica_primo(7)\n", + "\n", + "# Instancio una objeto de la clase vehículo\n", + "#Requiere atributos\n", + "corsa = Vehiculo('Gris', 'Auto', 1.4)\n", + "\n", + "#Instancio un objeto de la clase herramientas\n", + "#No requiere atributos\n", + "herr = Herramientas()\n", + "\n", + "#Invoco un atributo de esa clase\n", + "print(corsa.color) \n", + "\n", + "corsa.Acelerar(10) #Cambia el valor de una variable interna\n", + "\n", + "print (her.factorial(4)) #Invoco un método de esa clase. Este esta retornando un valor" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "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": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "283.15" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h.conversion_grados(10, 'celsius', 'kelvin')" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "720" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h.factorial(6)" + ] + }, + { + "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": 40, + "metadata": {}, + "outputs": [], + "source": [ + "class Herramientas:\n", + " #Se pide un atributo a la clase herramientas\n", + " def __init__(self, lista_numeros): \n", + " self.lista = lista_numeros\n", + " \n", + " #Función para imprimir si es primo o no\n", + " def verifica_primo(self):\n", + " #Iteramos y recorro la lista\n", + " for i in self.lista:\n", + " #Verifico si es primo con la función __verifica_primo\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", + " #Función para verificar primo\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": 41, + "metadata": {}, + "outputs": [], + "source": [ + "#Crea un Objeto. Pasa la lista\n", + "#Siempre le tengo que pasar una lista porque es lo que definí en __init__\n", + "h = Herramientas([1,1,2,5,8,8,9,11,15,16,16,16,18,20]) " + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "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": [ + "#Llama al método, y pasa por cada elemento de la lista\n", + "h.conversion_grados('celsius','farenheit') " + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "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": [ + "#Verifico si cada elemento de la Lista es Primo\n", + "h.verifica_primo()" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "Herramientas.valor_modal() missing 1 required positional argument: 'menor'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32me:\\Prep-Henry\\Python-Prep\\07 - Classes & OOP\\Tarea07.ipynb Cell 25'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m moda, repe \u001b[39m=\u001b[39m h\u001b[39m.\u001b[39;49mvalor_modal(\u001b[39mFalse\u001b[39;49;00m)\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mEl valor modal es\u001b[39m\u001b[39m'\u001b[39m, moda, \u001b[39m'\u001b[39m\u001b[39my se reptie\u001b[39m\u001b[39m'\u001b[39m, repe, \u001b[39m'\u001b[39m\u001b[39mveces\u001b[39m\u001b[39m'\u001b[39m)\n", + "\u001b[1;31mTypeError\u001b[0m: Herramientas.valor_modal() missing 1 required positional argument: 'menor'" + ] + } + ], + "source": [ + "moda, repe = h.valor_modal(False)\n", + "print('El valor modal es', moda, 'y se reptie', repe, 'veces')" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "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()" + ] + }, + { + "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": 65, + "metadata": {}, + "outputs": [], + "source": [ + "#Invoco un modulo(herramientas.py). Se ve en la carrera\n", + "from herramientas import * \n" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "#Creo el objeto\n", + "h2 = Herramientas([1,1,2,3,5,6,8,8])" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "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": [ + "#Trabajo con sus métodos\n", + "h2.verifica_primo()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "be8ebe292a6fb22f2c19ec4d5075a38adaba2a2c1e51ef08f8bc0ed916701165" + }, + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/07 - Classes & OOP/__pycache__/Prep_Course_Homework_07-Resuelto.cpython-37.pyc b/07 - Classes & OOP/__pycache__/Prep_Course_Homework_07-Resuelto.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f287d5e3f4baa7ad80a10f23d538896cfc30703b GIT binary patch literal 7413 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 literal 0 HcmV?d00001 diff --git a/07 - Classes & OOP/__pycache__/herramientas.cpython-310.pyc b/07 - Classes & OOP/__pycache__/herramientas.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26733d49c7d39294a6e6ab73e907fe491bc2f4e9 GIT binary patch literal 2942 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 literal 0 HcmV?d00001 diff --git a/08 - Error Handling/__pycache__/Prep_Course_Homework_08-Resuelto.cpython-37.pyc b/08 - Error Handling/__pycache__/Prep_Course_Homework_08-Resuelto.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..37127614911192478fab29008341887291458064 GIT binary patch literal 3108 zcmbuBTW=dh6o6;;=CxxxiJP_*UQ8*aE;MeMN>r$-LeonSty_9QXccKS@l5Ou>s>Rm zPDx}-NbM^U;vLC(M2IK;2K<42S6g z2V3Xn3Hdjvj6@E;Yw)V;ln_oh^@&3S*`Y&?YX_93ZMtI!V`y^yfI3!EGPubtp5sQ# z#J0pT=j23gXbS`FW@!m)nCCV(4m9Y;a-J8koLCo}!d=4Wc<}|{MN!z9d#*e9E%8!| za)X!o{LlJm+y$7k4BCsl0@{_4_IzgcV|Ji@f-iyg(nx#Zf3#2XQ=olnq`mkiZB8GP z+UY|KX=DFsef^92QzfLT`(an?*KdW*UPlCxs&9xu?$sZOZm8-H_o8+fTzV))w|@Cr z^-}e=l%cF{uz>qs(5knEl&s@{9aGEQz1V1nK0DN4ibEZRiNZnw;7FWn3SW6W73a5^ z6hT{fQ4`w74;rq)tImNC#G#xx8mC-)K^&dy+<GSE{QH_j~k4`h#b){3F8GQAP@NIEn`3< zGNcelI?y1nT0aeIa#kR$MnmGkl{kV#5;a2>v0MTX&!wTh{X>uWj_G?UVl`csu^)~< ziM94h64F#GV$*TIt~`czg&T~}A}zd)XII9aq1o88dr(O{qsKhcAj?3u*whC4!078O zI?((2Q12%h1Z`T{zy$xHuWzQA0=ze~-s3cPYUYvq&fG5ZL+N%x&ivS7-L43@JOOGo zD+xlZLrCNjG&lw-Ip(ft3gzS_fc7KC!|CWOBoH&heh0=11DeLBOf86zP4}xa>1PZZ zH7mAVH((v%x^cn9RrY)=7hM;5r9H9&L(7vW@OWj`gGWIkGKo1ILz^(NHQTh!q%DSU z=&`|MYd6lr5!nir7eW3IKYEd4FuxTx!D{@B69We1cw)fK7B5V>bp#ss-Z&H7fJy=y z(g`(W zy(V+J((8mNU^Ct2r$IdhY$ct_nNPp2P+cKs5I&g_o)}WCJcDsma(B{l0=P`~&rio9 zJ>iq9Q7a8t>=|6f`zSs@aSlbo??@yhtI*MdS0M{qlURReMyun)IKk*9jQu7?Nap~K zBV5yPIpcLalT#_fNqz`p%CjgwLV?(19z^S(zw!BUt+k5JUpGgE)w^pg=!WO3S6yGP zW#Pt)%`ix^dlKIq`LOu@T41#fIT1KmX!Zzejto&Uhe zM(D6!tHiq6Q?b!yQCpsZ7N?l~*LHLzCAlchd!245Bj4MKEh+qvad{q%>|WqS=%8ai z0l5zUw9-UwbeI=7TKh_p5hQLGi4)ISVQgPduaX;cprJkkVbh{zTLo*$wkb%fXcbGg QRXJ0!3wEVcuqqk(5^!|J`Tzg` literal 0 HcmV?d00001 diff --git a/08 - Error Handling/__pycache__/checkpoint.cpython-310.pyc b/08 - Error Handling/__pycache__/checkpoint.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0514d3d5dd5d422b1e6fc43b0fd6efeb9b41ac19 GIT binary patch literal 3053 zcmbVOTW{1x6!zHO%_c0A21F69(9nyrmXfqwBv48bZ3u;z2sO}3+f=KGXA(?o&oZ_n zCE7@p!msFCA9?OuU-K{g+9&=(pZcBgUYrmDswL0OXU=@*%y-VQK6`e?!SmIfKQ=bc zIL<#bsXs0z_wi=8&`3wJ*hyHIF&ewEn|NIhV^8|8oUSh$vWdPSr(_F#Q%@#v5$8dZ+0I|?hKp*ma}cov?N=@OuF05%;v824(R-9 z&ENLT)q#_H`0iiEj*HGdWN~hz_ytO5IG&X(7kslw!|3p@luNZ!sCY+l74tC|tj0V& z{5w%b^S;Q0)I8J)jm_boiOP*$taPP36q$xRe_1G=YMv=Uvpni+uF{+o?0#J>Co0v( z%3Ys_%!cAd!T3}do)+;?<4-D#@TEw(Fk1z-T6krhI5ynubG$jm~ z0;D)B;-e;2a9>PxJsf$yb1OK8=Ekk@i4&=X8^^^6v=v-6bYaD3XjUeetc95}ysxt; zk9PDMk_!CN&v*N(^rAE`8+}9F^!S*7b(@uyuN^ZD`G3DvOY2XJ>MuM}so7nBvYS8G z=>n~+e{+W~@D*d=)kh+gag=VYhtE~G-Ph2%*xxlRXrMPckEY%BS<7uPYR@y@wO^0$ zjyN~wU5trj`%Jp~ZjFEE$DH#m4;$N#xq`K(^|5y@GcQ! zU9&K7W#hK9?@|x8-juC<_VU^Q{0*jy{`)z)BVw4lp>?bT==Rjml}B|h7!_?qZxfcQ zjKkZBChqZAb9;3lPHu#Wh{D4_cqrmbEuP44P;3$b?_m4?BDS^a1YQfS@Tm~yE&8rx zPso_g?c=N@kBsR%lDczT${K0Ko?7zmeepQmG773hb$&8&$={gxju7$2dB?LB&6d<4?*_u+FVK@`Xg8^-B;k_0hm2-!A^#e zH}Jqgueb@}%G)RBN%%)^yg=gOQ3?s9QOb@)DZ#^7z=PkXQ6l2`ieR)#?z6PWRf>EN z>kO3LDk92{85g;UHi}$lliai-g`|Afd6x2u@S~K9UJ9IDrPg_y@vQ17jesPM_Jjch zg}jVR8Ptf-M`Bf{Xv_d3-J0xJ))Z)`VW{uets96i8QaH`!`Hc%wIse=B>gxt@DlvM zJ1Wc7NT^bh6$wg0f#@dM4ZXvyPlm@JRyAstK}@U4K^5*{@sLn_LiJFY^}!N-C~R;L92jxQ6hDq3~s`U)9;Zhmef z2Kn^d-re+dqr=2xadtQ8jj*^)Q|s_DCU&YWzy-oRpfQO z$v+ZeuDSPV&A`RGu|@&U?k!dZhZMY{hsLCM4R3Y{&43M@o8MgQ3DS#J8 zn~s!Ls{MrCBEN{i0G0LyQqgS~1Pd^(a8tetnE9ycsBRxe)via-uMo&+&p9C5>zszG zzHK#Vl&~%piR$&rnO-l^62D9sw|l*pNLbYubAiq$xHS;;TViZ-ZdOFjaa2xrXk&>n9?AZpe}L h@5QEjD^^oG!PmN5nRSo6pV4t`ugzLs>vH?^{{TY1FB$*< literal 0 HcmV?d00001 diff --git a/08 - Error Handling/__pycache__/checkpoint.cpython-37.pyc b/08 - Error Handling/__pycache__/checkpoint.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75c23aa941319ff619a9228082e42e98b2dbb1d1 GIT binary patch literal 3025 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 literal 0 HcmV?d00001 diff --git a/08 - Error Handling/__pycache__/tests.cpython-37.pyc b/08 - Error Handling/__pycache__/tests.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4310cdf4a1b17d9f58e76929f01600115a57a93 GIT binary patch literal 2891 zcmb_eTW{Mo6ee}C<-2p)mUS2CVH;))3A$t$ilP|0xykY}H)t~qATk(?$=FI|$tC3= zF`Os&bx->P$>V_iBE9a(e_>BMhe}Q1w#HY z&V_J6KZd6N1|f)`Az_)Oj2ho!_RmCE!hS`BEye}A2!R&{GoSP zU`1InR(V2M<-)FlU6VywSs}8vLReic2ya3u0bP)bvN)j=%XmfbDl@MHUTx-;!K-JU zpwCI8G6lq>)j|3CvcPx@P49w`1iye;f(q*uVYaY^1KL5%pk0v{9_XAXh$85`D2Xy? zPgFz|bV1Za9duDFh(*vPu>`9wr^`EPDEIlcjMPc9$HP!YUD=_qAYL{!2U-)F{v1R? z&Zwa0^b}B>T4Qo%jp^7rhwl{x=CfN<`~}lv5Dh!EI=!^8#XCu?0v@I%uC-Lj=F1@u zq1VweJV=X2Jd9O4kvd7MnJx7|DlX!`h$_KE|Mu3__MS%ai3*OSzv}-QfmS*YT=*^C z3F3%{zL0*%{a<*(qY>ZRZtm@zB)vFV-BEJj_X8ggbOU&C@BRarVpFMD`P)1aVGwoq zaB;mhI7t`KYR?e2?|+*I06GVP&?0r{=&Q^4T6<^MwHTzAFle==NPfdsNTkA*6=Hw~ z9@-G`MBxT7)MTOz?z_;}@$t=}uU`u~xfHs3PtZ3OZUuegTF@_#TZN&%dqI1e-_$!Q z=*QQizGi;^#Sn;@58p!n#nmzMX3!n5Pd|YLw_b+~a(64->p0DPz+4CSUBYFwJm8A= zWujs~h&r)S5>myTzhlF{#do}k9n5#Loc92nEawTxa;J1m&#ZF{{M9Q9N3DRJvEXJ| z?_=zw!HuX`Uxh*1oE3nIIca;c*Aq);QF&Ja_K)yu9g8$rN9MWS2Tzb&t{lkhmY~AUR1Lc^o7x z|4iy(Uq++yZk)iuU>9rq!%-#kwjc;OxYf)x=Ku+QJ@cCvIY>WjEHQ5w1qp7k)QUAL zc6ze&Vh{&WVgirOz3vOj$fqiKmmf()`^rUOdxy?fo!s zcaz%J+&G|eLxMvrP8<>Ep85}P-fNLi{)LJI^K2&(Rd@A%@6B&!-puUGJ{TXjnR>2o z?pzsX?A1URL6P<^XhoNF#(;t5G0u>+*rC>ETt@?R)DLuxxI+d8WFXr&2D~}sA;&WV z`z&U_>g(JjpD{FtK6FnG&A!GhVr{fe*fF$-wTaE6tyn0)I22(5CSeMuVFu2?*03X5vT!ZVx-uN}k z^MiT|yny3ShRT7?i_exYe>l-+E9|=ppTtSH+18(H@){Nor%0;KvA(9Upg59m4dv(B z_k}0)_4xF&A8{J8ZALzS4Q%pIn`byZ&tPObU}rE7w}77-Ug6JO_)a zIy%k6(&%&^K2;~s9OQrRt(&OG#xYNQobU?%yyFQX@UhPpV z{0<3)r-NIEA$e|f4<+fi{;~ZidcgH{te5 zQzV|)b*0O5>mm>lX$u>IoSZEocSPLF-wy)ONn{|LuZ}cT5&aJA$WV|`U@D+;*^#AS zjDTBft}i^%6^SbUp^&2e@=uxgJiCD%%0L-yiMAWXFZ+S}(^baY->wk+pkPHoNx{FD z3I0*=O2G>SzYr{BQ!@zt9f@f+lz>5MH)wY~52Z*m9pOf)DZDt5qBqg-M1=?aN6DpKA7N?S?GSQPQu^r260G1VM6%VAXSkY&6}y(1~3P&`AP^KD&7N2lWG8 zMx}Fo{XsHEw#O0tFo?-OM0JWSqU46sg`KW*Y%ogUM1Ip@o*XJSkFDR(E?nT&@g#5~ z2=`O%S(@!gH;B1Cn1s5T1a3vK?5Hu}6T|tbpLmU(Ob?&%sXS2!tW$Y@C*x9zXb;)qMx=2^72C)<%%8!Ld z*En5r46voT>)ao9KH65E_2n>;5!Tm2ANNDqu2&b!Ut^S@7l)NjH?{8hAtWAtt_CQ2 xL|_@VW@|;wHZlse!f=`DG&?v?YNmG4u*gE`C-pOAsdVRQDJ&Y6dDXP({SOlC*LnZ| literal 0 HcmV?d00001 diff --git a/09 - Entrada-Salida y Manejo de Archivos/__pycache__/clase09_ej1.cpython-37.pyc b/09 - Entrada-Salida y Manejo de Archivos/__pycache__/clase09_ej1.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..646b2964ef23e57471f14e3c6e3c8babb68bd4ef GIT binary patch literal 548 zcmZWl%St0b6s_uxPJAM>(#61C8YDr-l|e+E3Fty25jR7FlwFrtnd+*hsydKt1OCS> z{SN=4x3kJG%*xxX3_hx;b2-Ji=RQu?)|OdycKUY@oUy+(d4&eWV|qRzkW6yTelg_8 zM$wGR=y&AKFqUz}Wn+uYBF=~})O_(j|5Eej3pX32Seo%#xm-obuUTtlP8HbYysB7i z67)3WPG#sI7w+j#hQV1t-pc3R6><{*ke(fh|&`XMf8KJ90~~9%PLZ|^^U@(&aSn)4oa^1 z8$FO?50&~K`Y(L#iNC<9V>bvK`MsUV&U>R7zgu6AN%_1y`*so%^0x|>P(wb#*ZoG2 zMADRS0u;z7m{S>i5A2UB8}hK?8m~b(3UBHQ!W*zsog-*0=$vAVRWf`=_$tJ*hM6XE z9eEAbp@DjhZ34}0Qt{f7SGNgo!G>Is(LCU7Xx}`6mc;CWQi9Ruf>5H{uqESpnc0%f zk|n()J8QStH95Tv5N|0$-a$CgLkkXADwv0H23Gjo3I>`Dt&qmC1hoJ2>whp~_tzn1 znX%=6VgyVAyUNEPg}kG$W*bQ=9PI87V6@jw+@zqQpz-YJ_~PR1;s7PQH8LL=mTSQh zp}oSwQbX7ws%Vd{QaP_syi9v+kiB@bGwU6Xu*K9Ium^|N-E7JZAGO|Nhs$2@^u^}D z4Ercj2fdxAMd+rk2vg8S4b3JzlEQ;mV<-aSc&N=a-xv#!OwG^@?rX2D@=(;1)HtNfqQ_5S zH*p~q+|9e){+WgkR!x9)*jJ5gT{Wmvktm}@T8;*{_E~tLXQKbmH7^hz`fNs1$nT*W#Wd XL_v#2_={<~7FQ=0#I!}@Frxne4y5%W literal 0 HcmV?d00001 diff --git a/09 - Entrada-Salida y Manejo de Archivos/__pycache__/ejemplo_parametros.cpython-37.pyc b/09 - Entrada-Salida y Manejo de Archivos/__pycache__/ejemplo_parametros.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15e6e41d983055a360b226ffa988bc69eb228826 GIT binary patch literal 629 zcmZuu!EVz)5Z$%o)~(VWIMLgvr$i`GTd5L62tnIO6hTrYR7jQ)+ImN+!+O`@u9Qls^g|D3Q0bDpSP9u83E5A3^%)B?AJ=xjWX7%%Ic=ekz_G|UAh6eF#dfkjb zGRYN-7;xM4qaK{=!Wvml4V2nI z>#z+5vilznB!V;!T1RaVc2Z`j3**W|>KqT>U!I=de;@qoP7oB;KGs2Eti_}dbsOHb z`cuquWqN=Q!IxZE%8|9}=5yHph_{8=hhwT#k1}uo=l~UHlU-SwheBbK>vU#%?XAjp zb65Eab=4r}SrintO68}zh?*92EYc)38eJ7wp(j{zTLrnL^iO7+^dl?y^R3&BhZ@gp zIz#Bdr6#s6l|sTm)B-})%TNM7h(hQ)5x+f+FXqLy(VYvjfh+}M(@9E&@xcp{=+jPx x6rHh9Bm;A5)JPj9l{XLLyZFD0sKS>SU53I}^ 1:\n", + " numero = numero*Factorial(numero-1)\n", + "\n", + " return numero" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def ProximoPrimo(actual_primo):\n", + " '''\n", + " Esta función devuelve el número primo siguiente al enviado como parámetro.\n", + " En caso de que el parámetro no sea de tipo entero y/o no sea un número primo, debe retornar nulo.\n", + " Recibe un argumento:\n", + " actual_primo: Será el número primo a partir del cual debo buscar el siguiente\n", + " Ej:\n", + " ProximoPrimo(7) debe retornar 11\n", + " ProximoPrimo(8) debe retornar nulo\n", + " '''\n", + " #Tu código aca:\n", + " return 'Funcion incompleta'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def FactorizarNumero(numero):\n", + " '''\n", + " Esta función recibe como parámetro un número entero mayor a cero y devuelva dos listas, \n", + " una con cada factor común y otra con su exponente, \n", + " esas dos listas tienen que estar contenidas en otra lista.\n", + " En caso de que el parámetro no sea de tipo entero y/ó mayor a cero debe retornar nulo.\n", + " Recibe un argumento:\n", + " numero: Será el número sobre el que se hará la factorización.\n", + " Ej:\n", + "\n", + " factorizar_numero(12) debe retornar [[2,3],[2,1]]\n", + " factorizar_numero(13) debe retornar [[13],[1]]\n", + " factorizar_numero(14) debe retornar [[2,7],[1,1]]\n", + " '''\n", + " #Tu código aca:\n", + " return 'Funcion incompleta'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def ListaDeListas(lista):\n", + " '''\n", + " Esta función recibe una lista, que puede contener elementos que a su vez sean listas y\n", + " devuelve esos elementos por separado en una lista única. \n", + " En caso de que el parámetro no sea de tipo lista, debe retornar nulo.\n", + " Recibe un argumento:\n", + " lista: La lista que puede contener otras listas y se convierte a una \n", + " lista de elementos únicos o no iterables.\n", + " Ej:\n", + " ListaDeListas([1,2,['a','b'],[10]]) debe retornar [1,2,'a','b',10]\n", + " ListaDeListas(108) debe retornar el valor nulo.\n", + " ListaDeListas([[1,2,[3]],[4]]) debe retornar [1,2,3,4]\n", + " '''\n", + " #Tu código aca:\n", + " return 'Funcion incompleta'" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def ClaseVehiculo(tipo, color):\n", + " '''\n", + " Esta función devuelve un objeto instanciado de la clase Vehiculo, \n", + " la cual debe tener los siguientes atributos:\n", + " Tipo: Un valor dentro de los valores posibles: ['auto','camioneta','moto']\n", + " Color: Un valor de tipo de dato string.\n", + " Velocidad: Un valor de tipo de dato float, que debe inicializarse en cero.\n", + " y debe tener el siguiente método:\n", + " Acelerar(): Este método recibe un parámetro con el valor que debe incrementar a la\n", + " propiedad Velocidad y luego retornarla.\n", + " Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero.\n", + " Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien.\n", + " Recibe dos argumento:\n", + " tipo: Dato que se asignará al atributo Tipo del objeto de la clase Vehiculo\n", + " color: Dato que se asignará al atributo Color del objeto de la clase Vehiculo\n", + " Ej:\n", + " a = ClaseVehículo('auto','gris')\n", + " a.Acelerar(10) -> debe devolver 10\n", + " a.Acelerar(15) -> debe devolver 25\n", + " a.Acelerar(-10) -> debe devolver 15\n", + " '''\n", + " #Tu código aca:\n", + " class Vehículo:\n", + " def __init__(self, tipo, color):\n", + " self.tipo = tipo\n", + " self.color = color\n", + " self.velocidad = 0\n", + "\n", + " def Acelerar(self, vel):\n", + " self.velocidad += vel\n", + " if (self.velocidad<0):\n", + " self.velocidad = 0\n", + " if (self.velocidad>100):\n", + " self.velocidad = 100\n", + " \n", + " return self.velocidad\n", + " \n", + " a = Vehículo(tipo, color) \n", + " return a\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def OrdenarDiccionario(diccionario_par, clave, descendente=True):\n", + " '''\n", + " Esta función recibe como parámetro un diccionario, cuyas listas de valores tienen el mismo\n", + " tamaño y sus elementos enésimos están asociados. Y otros dos parámetros que indican\n", + " la clave por la cual debe ordenarse y si es descendente o ascendente.\n", + " La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la\n", + " relación entre los elementos enésimos.\n", + " Recibe tres argumentos:\n", + " diccionario: Diccionario a ordenar.\n", + " clave: Clave del diccionario recibido, por la cual ordenar.\n", + " descendente: Un valor booleano, que al ser verdadero indica ordenamiento ascendente y \n", + " descendente si es falso. \n", + " Debe tratarse de un parámetro por defecto en True.\n", + " Si el parámetro diccionario no es un tipo de dato diccionario ó el parámetro clave no \n", + " se encuentra dentro de las claves del diccionario, debe devolver nulo.\n", + " Ej:\n", + " dicc = {'clave1':['c','a','b'],\n", + " 'clave2':['casa','auto','barco'],\n", + " 'clave3':[1,2,3]}\n", + " OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'],\n", + " 'clave2':['auto','barco','casa'],\n", + " 'clave3':[2,3,1]}\n", + " OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['b','a','c'],\n", + " 'clave2':['barco','auto','casa'],\n", + " 'clave3':[3,2,1]}\n", + " '''\n", + " #Tu código aca:\n", + " return 'Funcion incompleta' " + ] + } + ], + "metadata": { + "interpreter": { + "hash": "be8ebe292a6fb22f2c19ec4d5075a38adaba2a2c1e51ef08f8bc0ed916701165" + }, + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/10 - Repaso/HC.py b/10 - Repaso/HC.py new file mode 100644 index 000000000..404f41ee7 --- /dev/null +++ b/10 - Repaso/HC.py @@ -0,0 +1,130 @@ +# Importante: No modificar ni el nombre ni los argumetos que reciben las funciones, sólo deben escribir +# código dentro de las funciones ya definidas. + +def NumeroCapicua(numero): + ''' + En matemáticas, la palabra capicúa (del catalán cap i cua, 'cabeza y cola')​ + se refiere a cualquier número que se lee igual de izquierda a derecha que + de derecha a izquierda. Se denominan también números palíndromos. + Esta función devuelve el valor booleano True si el número es capicúa, de lo contrario + devuelve el valor booleano False + En caso de que el parámetro no sea de tipo entero, debe retornar nulo. + Recibe un argumento: + numero: Será el número sobre el que se evaluará si es capicúa o no lo es. + Ej: + NumeroCapicua(787) debe retornar True + NumeroCapicua(108) debe retornar False + ''' + #Tu código aca: + return 'Funcion incompleta' + +def Factorial(numero): + ''' + Esta función devuelve el factorial del número pasado como parámetro. + En caso de que no sea de tipo entero y/o sea menor que 1, debe retornar nulo. + Recibe un argumento: + numero: Será el número con el que se calcule el factorial + Ej: + Factorial(4) debe retornar 24 + Factorial(-2) debe retornar nulo + ''' + #Tu código aca: + return 'Funcion incompleta' + +def ProximoPrimo(actual_primo): + ''' + Esta función devuelve el número primo siguiente al enviado como parámetro. + En caso de que el parámetro no sea de tipo entero y/o no sea un número primo, debe retornar nulo. + Recibe un argumento: + actual_primo: Será el número primo a partir del cual debo buscar el siguiente + Ej: + ProximoPrimo(7) debe retornar 11 + ProximoPrimo(8) debe retornar nulo + ''' + #Tu código aca: + return 'Funcion incompleta' + +def FactorizarNumero(numero): + ''' + Esta función recibe como parámetro un número entero mayor a cero y devuelva dos listas, + una con cada factor común y otra con su exponente, + esas dos listas tienen que estar contenidas en otra lista. + En caso de que el parámetro no sea de tipo entero y/ó mayor a cero debe retornar nulo. + Recibe un argumento: + numero: Será el número sobre el que se hará la factorización. + Ej: + + factorizar_numero(12) debe retornar [[2,3],[2,1]] + factorizar_numero(13) debe retornar [[13],[1]] + factorizar_numero(14) debe retornar [[2,7],[1,1]] + ''' + #Tu código aca: + return 'Funcion incompleta' + +def ListaDeListas(lista): + ''' + Esta función recibe una lista, que puede contener elementos que a su vez sean listas y + devuelve esos elementos por separado en una lista única. + En caso de que el parámetro no sea de tipo lista, debe retornar nulo. + Recibe un argumento: + lista: La lista que puede contener otras listas y se convierte a una + lista de elementos únicos o no iterables. + Ej: + ListaDeListas([1,2,['a','b'],[10]]) debe retornar [1,2,'a','b',10] + ListaDeListas(108) debe retornar el valor nulo. + ListaDeListas([[1,2,[3]],[4]]) debe retornar [1,2,3,4] + ''' + #Tu código aca: + return 'Funcion incompleta' + +def ClaseVehiculo(tipo, color): + ''' + Esta función devuelve un objeto instanciado de la clase Vehiculo, + la cual debe tener los siguientes atributos: + Tipo: Un valor dentro de los valores posibles: ['auto','camioneta','moto'] + Color: Un valor de tipo de dato string. + Velocidad: Un valor de tipo de dato float, que debe inicializarse en cero. + y debe tener el siguiente método: + Acelerar(): Este método recibe un parámetro con el valor que debe incrementar a la + propiedad Velocidad y luego retornarla. + Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero. + Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien. + Recibe dos argumento: + tipo: Dato que se asignará al atributo Tipo del objeto de la clase Vehiculo + color: Dato que se asignará al atributo Color del objeto de la clase Vehiculo + Ej: + a = ClaseVehículo('auto','gris') + a.Acelerar(10) -> debe devolver 10 + a.Acelerar(15) -> debe devolver 25 + a.Acelerar(-10) -> debe devolver 15 + ''' + #Tu código aca: + +def OrdenarDiccionario(diccionario_par, clave, descendente=True): + ''' + Esta función recibe como parámetro un diccionario, cuyas listas de valores tienen el mismo + tamaño y sus elementos enésimos están asociados. Y otros dos parámetros que indican + la clave por la cual debe ordenarse y si es descendente o ascendente. + La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la + relación entre los elementos enésimos. + Recibe tres argumentos: + diccionario: Diccionario a ordenar. + clave: Clave del diccionario recibido, por la cual ordenar. + descendente: Un valor booleano, que al ser verdadero indica ordenamiento ascendente y + descendente si es falso. + Debe tratarse de un parámetro por defecto en True. + Si el parámetro diccionario no es un tipo de dato diccionario ó el parámetro clave no + se encuentra dentro de las claves del diccionario, debe devolver nulo. + Ej: + dicc = {'clave1':['c','a','b'], + 'clave2':['casa','auto','barco'], + 'clave3':[1,2,3]} + OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'], + 'clave2':['auto','barco','casa'], + 'clave3':[2,3,1]} + OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['b','a','c'], + 'clave2':['barco','auto','casa'], + 'clave3':[3,2,1]} + ''' + #Tu código aca: + return 'Funcion incompleta' \ No newline at end of file diff --git a/10 - Repaso/__pycache__/Entradas y salidas.cpython-37.pyc b/10 - Repaso/__pycache__/Entradas y salidas.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6bc840dad02185f81dd295b4d86e42c564f61d68 GIT binary patch literal 5377 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 a$2dE@?ao)P;`!>0)iwOPv3h;=H~$B@w|@!% literal 0 HcmV?d00001 diff --git a/HC_correciones.ipynb b/HC_correciones.ipynb new file mode 100644 index 000000000..3274c3852 --- /dev/null +++ b/HC_correciones.ipynb @@ -0,0 +1,436 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " En matemáticas, la palabra capicúa (del catalán cap i cua, 'cabeza y cola')​ \n", + " se refiere a cualquier número que se lee igual de izquierda a derecha que \n", + " de derecha a izquierda. Se denominan también números palíndromos.\n", + " Esta función devuelve el valor booleano True si el número es capicúa, de lo contrario\n", + " devuelve el valor booleano False \n", + " En caso de que el parámetro no sea de tipo entero, debe retornar nulo.\n", + " Recibe un argumento:\n", + " numero: Será el número sobre el que se evaluará si es capicúa o no lo es.\n", + " Ej:\n", + " NumeroCapicua(787) debe retornar True\n", + " NumeroCapicua(108) debe retornar False" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def NumeroCapicua(numero):\n", + " \n", + " if(type(numero)!=int):\n", + " return None\n", + "\n", + " numero = str(numero)\n", + " list_num = []\n", + "\n", + " for i in numero:\n", + " list_num.append(i)\n", + " list_reversed = list(reversed(list_num))\n", + " \n", + " if (list_num != list_reversed):\n", + " return False\n", + "\n", + " return True" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "None\n" + ] + } + ], + "source": [ + "print(NumeroCapicua(1234))\n", + "print(NumeroCapicua(358853))\n", + "print(NumeroCapicua('hola'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Esta función devuelve el factorial del número pasado como parámetro.\n", + " En caso de que no sea de tipo entero y/o sea menor que 1, debe retornar nulo.\n", + " Recibe un argumento:\n", + " numero: Será el número con el que se calcule el factorial\n", + " Ej:\n", + " Factorial(4) debe retornar 24\n", + " Factorial(-2) debe retornar nulo" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def Factorial(numero):\n", + " \n", + " #Tu código aca:\n", + " if(type(numero)!=int):\n", + " return None\n", + " if numero <= 0:\n", + " return None\n", + " if numero > 1:\n", + " numero = numero*Factorial(numero-1)\n", + " return numero" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "720\n", + "362880\n" + ] + } + ], + "source": [ + "print(Factorial(6))\n", + "print(Factorial(9))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Esta función devuelve el número primo siguiente al enviado como parámetro.\n", + " En caso de que el parámetro no sea de tipo entero y/o no sea un número primo, debe retornar nulo.\n", + " Recibe un argumento:\n", + " actual_primo: Será el número primo a partir del cual debo buscar el siguiente\n", + " Ej:\n", + " ProximoPrimo(7) debe retornar 11\n", + " ProximoPrimo(8) debe retornar nulo" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def ProximoPrimo(actual_primo):\n", + " \n", + " #Tu código aca:\n", + " contar = 0\n", + " contar2 = 0\n", + " Primo = False\n", + " \n", + " if(type(actual_primo)!=int):\n", + " return None\n", + " if (actual_primo < 1):\n", + " return None\n", + " for i in range(2, actual_primo+1):\n", + " if(actual_primo%i == 0):\n", + " contar += 1\n", + " if contar > 1:\n", + " return None\n", + " \n", + " actual_primo += 1\n", + " \n", + " while not (Primo):\n", + " contar2 = 0 \n", + " actual_primo += 1\n", + " for i in range(2, actual_primo+1):\n", + " if(actual_primo%i == 0):\n", + " contar2 += 1\n", + " \n", + " if(contar2 == 1):\n", + " sig_primo = actual_primo\n", + " Primo = True\n", + " return sig_primo\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "67\n", + "149\n", + "None\n" + ] + } + ], + "source": [ + "print(ProximoPrimo(61))\n", + "print(ProximoPrimo(139))\n", + "print(ProximoPrimo(200))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "'''\n", + " Esta función recibe como parámetro un número entero mayor a cero y devuelva dos listas, \n", + " una con cada factor común y otra con su exponente, \n", + " esas dos listas tienen que estar contenidas en otra lista.\n", + " En caso de que el parámetro no sea de tipo entero y/ó mayor a cero debe retornar nulo.\n", + " Recibe un argumento:\n", + " numero: Será el número sobre el que se hará la factorización.\n", + " Ej:\n", + " factorizar_numero(12) debe retornar [[2,3],[2,1]]\n", + " factorizar_numero(13) debe retornar [[13],[1]]\n", + " factorizar_numero(14) debe retornar [[2,7],[1,1]]\n", + " '''" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def FactorizarNumero(numero):\n", + " \n", + " #Tu código aca:\n", + " fac_com = []\n", + " fac_expo = []\n", + " list1 = []\n", + " \n", + "\n", + " if(type(numero)!=int):\n", + " return None\n", + " if (numero < 0):\n", + " return None\n", + " \n", + " for i in range (2, numero+1):\n", + " cont = 0\n", + " while numero % i == 0:\n", + "\n", + " if not (i in fac_com):\n", + " fac_com.append(i)\n", + " fac_expo.append(1)\n", + " \n", + " elif (i in fac_com) :\n", + " n = fac_com.index(i)\n", + " fac_expo[n] = +1\n", + " \n", + " numero=numero/i\n", + " \n", + " \n", + " list1.append(fac_com)\n", + " list1.append(fac_expo)\n", + " \n", + " return list1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[2, 5], [1, 1]]\n" + ] + } + ], + "source": [ + "print(FactorizarNumero(40))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Esta función recibe una lista, que puede contener elementos que a su vez sean listas y\n", + " devuelve esos elementos por separado en una lista única. \n", + " En caso de que el parámetro no sea de tipo lista, debe retornar nulo.\n", + " Recibe un argumento:\n", + " lista: La lista que puede contener otras listas y se convierte a una \n", + " lista de elementos únicos o no iterables.\n", + " Ej:\n", + " ListaDeListas([1,2,['a','b'],[10]]) debe retornar [1,2,'a','b',10]\n", + " ListaDeListas(108) debe retornar el valor nulo.\n", + " ListaDeListas([[1,2,[3]],[4]]) debe retornar [1,2,3,4]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def ListaDeListas(lista):\n", + " \n", + " #Tu código aca:\n", + " return 'Funcion incompleta'\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " '''\n", + " Esta función devuelve un objeto instanciado de la clase Vehiculo, \n", + " la cual debe tener los siguientes atributos:\n", + " Tipo: Un valor dentro de los valores posibles: ['auto','camioneta','moto']\n", + " Color: Un valor de tipo de dato string.\n", + " Velocidad: Un valor de tipo de dato float, que debe inicializarse en cero.\n", + " y debe tener el siguiente método:\n", + " Acelerar(): Este método recibe un parámetro con el valor que debe incrementar a la\n", + " propiedad Velocidad y luego retornarla.\n", + " Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero.\n", + " Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien.\n", + " Recibe dos argumento:\n", + " tipo: Dato que se asignará al atributo Tipo del objeto de la clase Vehiculo\n", + " color: Dato que se asignará al atributo Color del objeto de la clase Vehiculo\n", + " Ej:\n", + " a = ClaseVehículo('auto','gris')\n", + " a.Acelerar(10) -> debe devolver 10\n", + " a.Acelerar(15) -> debe devolver 25\n", + " a.Acelerar(-10) -> debe devolver 15\n", + " '''" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def ClaseVehiculo(tipo, color):\n", + " \n", + " #Tu código aca:\n", + " class Vehículo:\n", + " def __init__(self, tipo, color):\n", + " self.tipo = tipo\n", + " self.color = color\n", + " self.velocidad = 0\n", + " def Acelerar(self, vel):\n", + " self.velocidad += vel\n", + " if (self.velocidad<0):\n", + " self.velocidad = 0\n", + " if (self.velocidad>100):\n", + " self.velocidad = 100\n", + " \n", + " return self.velocidad\n", + " \n", + " a = Vehículo(tipo, color) \n", + " return a\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "'''\n", + " Esta función recibe como parámetro un diccionario, cuyas listas de valores tienen el mismo\n", + " tamaño y sus elementos enésimos están asociados. Y otros dos parámetros que indican\n", + " la clave por la cual debe ordenarse y si es descendente o ascendente.\n", + " La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la\n", + " relación entre los elementos enésimos.\n", + " Recibe tres argumentos:\n", + " diccionario: Diccionario a ordenar.\n", + " clave: Clave del diccionario recibido, por la cual ordenar.\n", + " descendente: Un valor booleano, que al ser verdadero indica ordenamiento ascendente y \n", + " descendente si es falso. \n", + " Debe tratarse de un parámetro por defecto en True.\n", + " Si el parámetro diccionario no es un tipo de dato diccionario ó el parámetro clave no \n", + " se encuentra dentro de las claves del diccionario, debe devolver nulo.\n", + " Ej:\n", + " dicc = {'clave1':['c','a','b'],\n", + " 'clave2':['casa','auto','barco'],\n", + " 'clave3':[1,2,3]}\n", + " OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'],\n", + " 'clave2':['auto','barco','casa'],\n", + " 'clave3':[2,3,1]}\n", + " OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['b','a','c'],\n", + " 'clave2':['barco','auto','casa'],\n", + " 'clave3':[3,2,1]}\n", + " '''" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def OrdenarDiccionario(diccionario_par, clave, descendente=True):\n", + " \n", + " #Tu código aca:\n", + " return 'Funcion incompleta' " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.5 64-bit (windows store)", + "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.5" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "93dac0cefe5923a3f5fe671185a1239056384d9553d26861fdf316add6918ee3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From ab1799bf2386c84bed28801faad624d3139e8481 Mon Sep 17 00:00:00 2001 From: mica98vero Date: Tue, 20 Sep 2022 18:33:36 -0300 Subject: [PATCH 2/3] 19 sep 22 --- 02 - Variables y Tipos de Datos/README.md | 74 ++++++++++------------- 03 - Flujos de Control/README.md | 46 +++++--------- 2 files changed, 48 insertions(+), 72 deletions(-) diff --git a/02 - Variables y Tipos de Datos/README.md b/02 - Variables y Tipos de Datos/README.md index b0b2ba9c0..1af45b1d3 100644 --- a/02 - Variables y Tipos de Datos/README.md +++ b/02 - Variables y Tipos de Datos/README.md @@ -1,10 +1,6 @@ -![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) - -## Grabación de la Clase 2 +# -
- -
+![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) ## Variables @@ -14,14 +10,14 @@ Una variable es un espacio de memoria donde guardamos un dato, ese espacio de me Por otro lado existen ciertas normas a la hora de nombrar variables: -* El nombre no puede empezar con un número
- Por ejemplo "mi_variable" sería correcto, pero "123mi_variable" sería erróneo -* No se permite el uso de guiones del medio -
- Por ejemplo "mi-variable" sería erróneo -* No se permite el uso de espacios.
- Por ejemplo "mi variable" sería erróneo -* No usar nombres reservados para Python. Las palabras reservadas son utilizadas por Python internamente, por lo que no podemos usarlas para nuestras variables o funciones.
- Por ejemplo, a veces podríamos usar "int" ó "for" y esto nos daría error, porque como se verá más adelante, esas palabras son parte de la sintaxis de Python. +* El nombre no puede empezar con un número + * Por ejemplo "mi_variable" sería correcto, pero "123mi_variable" sería erróneo. +* No se permite el uso de guiones del medio - + * Por ejemplo "mi-variable" sería erróneo +* No se permite el uso de espacios. + * Por ejemplo "mi variable" sería erróneo +* No usar nombres reservados para Python. Las palabras reservadas son utilizadas por Python internamente, por lo que no podemos usarlas para nuestras variables o funciones. + * Por ejemplo, a veces podríamos usar "int" ó "for" y esto nos daría error, porque como se verá más adelante, esas palabras son parte de la sintaxis de Python. ### Constantes @@ -41,11 +37,11 @@ En Python tenemos los siguientes: Todo valor que pueda ser asignado a una variable tiene asociado un tipo de dato y esto establece qué operaciones se pueden realizar sobre la misma. -
-

- Tip: En Python hay algunas funcionalidades ya presentes por defecto, como por ejemplo la funcion **print()** que permite mostrar una salida por pantalla y la función range() que devuelve un rango numérico según los parámetros que recibe y con la función **type()** es posible ver el tipo de dato de una variable -

-
+--- + + > **Tip:** En Python hay algunas funcionalidades ya presentes por defecto, como por ejemplo la funcion **print()** que permite mostrar una salida por pantalla y la función range() que devuelve un rango numérico según los parámetros que recibe y con la función **type()** es posible ver el tipo de dato de una variable + +--- ### Operaciones entre Variables @@ -58,7 +54,7 @@ Con diferentes tipos de datos podemos hacer diferentes tipos de operaciones. Y h | Suma | + | 3 + 5.5 = 8.5 | | Resta | - | 4 - 1 = 3 | | Multiplicación | * | 4 * 2 = 8 | -| Potenciación | 42 | 4**2 = 16 | +| Potenciación | $4^2$ | 4**2 = 16 | | División (Cociente) | / | 4 / 2 = 2 | | División (parte entera) | // | 14 // 3 = 4 | | División (resto) | % | 14 % 3 = 2 | @@ -91,9 +87,11 @@ Con diferentes tipos de datos podemos hacer diferentes tipos de operaciones. Y h | >>= | x>>=2 | x=x>>2 = 1 | | <<= | x<<=2 | x=x<<=2 = 28 | -Operación: |=
-Operador: x|=2
-Ejemplo: x=x|2 = 7
+Operación: |= + +Operador: x|=2 + +Ejemplo: x = x|2 = 7 Cuando tratamos con texto, podemos hacer otras operaciones: @@ -155,7 +153,7 @@ float Notar que anteponiendo el carácter numeral (#) es posible agregar comentarios en el código. Por otra parte, la función **type()** es muy útil para saber a qué tipo de dato corresponde un elemento. -**Operaciones Lógicas** +#### **Operaciones Lógicas** Son operaciones en las que entran en uso el tipo de datos booleano, es decir, que nos permiten representar valores verdadero o falso. Para verlo mejor, es necesario recurrir a lo que llamamos tablas de verdad. Veremos muy comúnmente representar verdadero con un "1" y falso con un "0". @@ -168,7 +166,7 @@ Tabla del operador lógico "and", se verifican que A y B sean verdaderas. | 0 | 1 | 0 | | 1 | 1 | 1 | -Tabla del operador lógico "or", se verifican que A o B sean verdaderas. +Tabla del operador lógico "or", se verifican que A o B sean verdaderas. | A | B | A or B | | :- | :--: | -: | | 1 | 0 | 1 | @@ -193,15 +191,15 @@ Tabla del operador lógico "Or Exclusiva", se verifica ((A and not(B)) or (not(A True ``` -
-

- Tips: Notar que las constantes "True" y "False" se escriben con la primer letra mayúscula y el resto minúsculas, de otra forma arrojaría un error -

-
+--- + +> Tips: Notar que las constantes "True" y "False" se escriben con la primer letra mayúscula y el resto minúsculas, de otra forma arrojaría un error + +--- ### Conversión de tipos de datos -Puede haber ocasiones en las que desee especificar un tipo en una variable. Esto se puede hacer con lo que se denomina **casting**. +Puede haber ocasiones en las que desee especificar un tipo en una variable. Esto se puede hacer con lo que se denomina **casting**. La conversión de tipo de dato en python se realiza mediante funciones: int(): construye un número entero a partir de un literal entero, un literal flotante (eliminando todos los decimales) o un literal de cadena (siempre que la cadena represente un número entero) @@ -224,14 +222,6 @@ str(): construye una cadena a partir de una amplia variedad de tipos de datos, i Completa la tarea descrita en el archivo [README](https://github.com/soyHenry/Python-Prep/blob/4aec1885136fdcff98899d2be13c8908b39f8b21/02%20-%20Variables%20y%20Tipos%20de%20Datos/Prep_Course_Homework_02.md) - - - - -
- - -
- Hacé click acá para dejar tu feedback sobre esta clase. - -
+![x](https://static.thenounproject.com/png/204643-200.png) + +[Hacé click acá para dejar tu feedback sobre esta clase.]("https://airtable.com/shrSzEYT4idEFGB8d?prefill_clase=00-PrimerosPasos") diff --git a/03 - Flujos de Control/README.md b/03 - Flujos de Control/README.md index 2fb2a6c0b..f3f7ddf4d 100644 --- a/03 - Flujos de Control/README.md +++ b/03 - Flujos de Control/README.md @@ -1,22 +1,17 @@ -![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) - -## Grabación de la Clase 3 +# -
- -
+![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) ## Flujos de Control ### Condicionales -Los condicionales son bloques de código que se ejecutan únicamente si se cumple una condición. +Los condicionales son bloques de código que se ejecutan únicamente si se cumple una condición. El resultado de esta condición debe ser booleano (True o False). Esto se logra mediante la sentencia **if**. -Con la sentencia **elif** se puede agregar un número arbitrario de condiciones. +Con la sentencia **elif** se puede agregar un número arbitrario de condiciones. Por otra parte, se puede ejecutar código si la/s condición/es no se cumple/n con la sentencia **else**. - ```python >>> valor = 0 >>> if (valor < 0): @@ -66,15 +61,14 @@ Un ciclo **while** repite un bloque de código mientras que cierta condición se 9 ``` -
-

- Hemos llegado hasta este punto y se repasaron algunos de los conceptos más fundamentales de la programación y de Python, pero es necesario detenerse en algunos detalles, que tienen que ver precisamente con el lenguaje que estamos utilizando: +--- +> Hemos llegado hasta este punto y se repasaron algunos de los conceptos más fundamentales de la programación y de Python, pero es necesario detenerse en algunos detalles, que tienen que ver precisamente con el lenguaje que estamos utilizando: - * En Python es importante la indentación, notar que el código que se ejecuta dentro de una sentencia if, for o while está indentado. - * También es importante notar los ":" - * En Python, cada vez que hagamos referencia a un rango, por ejemplo "1,10" el primer número se incluye y el último no. -

-
+* En Python es importante la indentación, notar que el código que se ejecuta dentro de una sentencia if, for o while está indentado. +* También es importante notar los ":" +* En Python, cada vez que hagamos referencia a un rango, por ejemplo "1,10" el primer número se incluye y el último no. + +--- ### Sentencia Break @@ -146,16 +140,8 @@ n ## Homework -Completa la tarea descrita en el archivo [README](https://github.com/soyHenry/Python-Prep/blob/4aec1885136fdcff98899d2be13c8908b39f8b21/03%20-%20Flujos%20de%20Control/Prep_Course_Homework_03.md) - - - - - -
- - -
- Hacé click acá para dejar tu feedback sobre esta clase. - -
+Completa la tarea descrita en el archivo [README](https://github.com/soyHenry/Python-Prep/blob/4aec1885136fdcff98899d2be13c8908b39f8b21/02%20-%20Variables%20y%20Tipos%20de%20Datos/Prep_Course_Homework_02.md) + +![x](https://static.thenounproject.com/png/204643-200.png) + +[Hacé click acá para dejar tu feedback sobre esta clase.]("https://airtable.com/shrSzEYT4idEFGB8d?prefill_clase=00-PrimerosPasos") From c0515c04f7641426bb14ee1e9cf821b83d3f22b8 Mon Sep 17 00:00:00 2001 From: mica98vero Date: Thu, 22 Sep 2022 17:37:38 -0300 Subject: [PATCH 3/3] 22 sep 22 1 --- .../Prep_Course_Homework_03-Resuelto.ipynb | 34 +++---- 04 - Estructuras de datos/README.md | 98 ++++++++----------- 05 - Iteradores e Iterables/README.md | 25 ++--- 08 - Error Handling/README.md | 71 ++++++-------- 4 files changed, 93 insertions(+), 135 deletions(-) diff --git a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb index 39f94f511..8fddb9495 100644 --- a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb +++ b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb @@ -215,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -263,16 +263,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "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))" + "#Lo borre porque daba una bucle infinito y paja arreglarlo xd" ] }, { @@ -284,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -330,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -353,6 +348,7 @@ } ], "source": [ + "tope_rango=30\n", "n = 0\n", "primo = True\n", "while (n < tope_rango):\n", @@ -640,7 +636,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -657,10 +653,6 @@ "¿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" ] } @@ -716,11 +708,8 @@ } ], "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.10.7 64-bit (microsoft store)", "language": "python", "name": "python3" }, @@ -734,7 +723,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.7" + }, + "vscode": { + "interpreter": { + "hash": "6085004884d7fe2d487ef9b1c33a506ee19a6a4095578a744a51e1ad1ca70fa0" + } } }, "nbformat": 4, diff --git a/04 - Estructuras de datos/README.md b/04 - Estructuras de datos/README.md index 69ce4eff6..8d6c2f57a 100644 --- a/04 - Estructuras de datos/README.md +++ b/04 - Estructuras de datos/README.md @@ -1,10 +1,6 @@ -![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) - -## Grabación de la Clase 4 +# -
- -
+![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) ## Estructuras de datos @@ -13,11 +9,11 @@ Anteriormente se mencionó que un dato representa la realidad, y se presentó el ### Lista Una estructura de datos muy importante en Python es la lista, que consiste en una serie de elementos ordenados. -Esos elementos pueden ser de distinto tipo, e incluso pueden ser de tipo lista también.
+Esos elementos pueden ser de distinto tipo, e incluso pueden ser de tipo lista también. Operaciones con listas: -* Creacion +* Creacion ```python mi_lista = ['Rojo','Azul','Amarillo','Naranja','Violeta','Verde'] @@ -29,7 +25,7 @@ Operaciones con listas: print(mi_lista) ``` -* Ver el tipo de dato +* Ver el tipo de dato ```python type(mi_lista) @@ -56,7 +52,7 @@ Las listas, así como otras estructuras de datos que se verán en adelante, tien ['Rojo', 'Azul'] ``` -* Al no poner segundo valor, Python asume que se trata de todos los elementos a partir del primero +* Al no poner segundo valor, Python asume que se trata de todos los elementos a partir del primero ```python >>> print(mi_lista[0:]) @@ -69,7 +65,7 @@ Las listas, así como otras estructuras de datos que se verán en adelante, tien mi_lista.append('Blanco') ``` -* Agregar un elemento especificando el índice +* Agregar un elemento especificando el índice ```python >>> mi_lista.insert(3,'Negro') @@ -77,13 +73,13 @@ Las listas, así como otras estructuras de datos que se verán en adelante, tien ['Rojo', 'Azul', 'Amarillo', 'Negro', 'Naranja', 'Violeta', 'Verde'] ``` -* Concatenar una nueva lista a la lista previamente creada +* Concatenar una nueva lista a la lista previamente creada ```python mi_lista.extend(['Marrón','Gris']) ``` -* Encontrar el índice de un valor específico +* Encontrar el índice de un valor específico ```python >>> print(mi_lista.index('Azul')) @@ -99,22 +95,22 @@ Las listas, así como otras estructuras de datos que se verán en adelante, tien --------------------------------------------------------------------------- ValueError Traceback (most recent call last) -~\AppData\Local\Temp/ipykernel_10044/308548076.py in +~\AppData\Local\Temp/ipykernel_10044/308548076.py in ----> 1 mi_lista.remove('Blanco') ValueError: list.remove(x): x not in list -> > > mi_lista.remove('Negro') +> mi_lista.remove('Negro') -``` -* Extraer y recuperar el último elemento de la lista -```python +* Extraer y recuperar el último elemento de la lista + +```python >>> ultimo = mi_lista.pop() >>> print(ultimo) Gris ``` -* Multiplicar la lista 3 veces +* Multiplicar la lista 3 veces ```python >>> print(['a','b','c'] * 3) @@ -143,13 +139,13 @@ Gris Son una estructura similar a las listas, la diferencia está en que no se pueden modificar una vez creadas, es decir que son **inmutables**: -* Convertir una lista a tupla +* Convertir una lista a tupla ```python mi_tupla=tuple(mi_lista) ``` -* Imprimir el índice 1 de la tupla +* Imprimir el índice 1 de la tupla ```python >>> print(mi_tupla[1]) @@ -163,26 +159,26 @@ Son una estructura similar a las listas, la diferencia está en que no se pueden True ``` -* Evaluar las veces que está un elemento específico +* Evaluar las veces que está un elemento específico ```python >>> mi_tupla.count('Rojo') 1 ``` -* Tupla con un solo elemento +* Tupla con un solo elemento ```python mi_tupla_unitaria = ('Blanco',) ``` -* Empaquetado de tupla, tupla sin paréntesis +* Empaquetado de tupla, tupla sin paréntesis ```python mi_tupla='Gaspar', 5, 8, 1999 ``` -* Desempaquetado de tupla, se guardan los valores en orden de las variables +* Desempaquetado de tupla, se guardan los valores en orden de las variables ```python >>> nombre, dia, mes, año = mi_tupla @@ -190,7 +186,7 @@ Son una estructura similar a las listas, la diferencia está en que no se pueden Nombre: Gaspar - Dia: 5 - Mes: 8 - Año: 1999 ``` -* Convertir una tupla en una lista +* Convertir una tupla en una lista ```python mi_lista=list(mi_tupla) @@ -200,7 +196,7 @@ Son una estructura similar a las listas, la diferencia está en que no se pueden Un diccionario tiene una organización de 'clave' y 'valor': -* Crear un diccionario +* Crear un diccionario ```python mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'], @@ -209,32 +205,32 @@ Un diccionario tiene una organización de 'clave' y 'valor': 'Clave4': False} ``` -* Imprimir un valor a través de su clave +* Imprimir un valor a través de su clave ```python >>> print(mi_diccionario['Colores secundarios']) ['Naranja', 'Violeta', 'Verde'] ``` -* Agregar un valor +* Agregar un valor ```python mi_diccionario['Clave5']='Otro ejemplo' ``` -* Cambiar un valor +* Cambiar un valor ```python mi_diccionario['Clave3']=2 ``` -* Eliminar un elemento de un diccionario a través de su clave +* Eliminar un elemento de un diccionario a través de su clave ```python del mi_diccionario['Clave4'] ``` -* Utilizar una tupla como clave de un diccionario +* Utilizar una tupla como clave de un diccionario ```python mi_tupla=("Argentina", "Italia", "Inglaterra") @@ -243,7 +239,7 @@ Un diccionario tiene una organización de 'clave' y 'valor': mi_tupla[2]:"Londres"} ``` -* Colocar una tupla dentro de un diccionario +* Colocar una tupla dentro de un diccionario ```python mi_diccionario={'Clave1':'Valor1', 'Clave2':(1,2,3,4,5)} @@ -255,51 +251,41 @@ Un diccionario tiene una organización de 'clave' y 'valor': mi_diccionario={'Clave1':'Valor1', 'Clave2':[1,2,3,4,5]} ``` -* Colocar un diccionario dentro de un diccionario +* Colocar un diccionario dentro de un diccionario ```python mi_diccionario={'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}} ``` -* Imprimir las claves del diccionario +* Imprimir las claves del diccionario ```python >>> print(mi_diccionario.keys()) dict_keys(['Clave1', 'Clave2']) ``` -* Imprimir los valores del diccionario +* Imprimir los valores del diccionario ```python >>> print(mi_diccionario.values()) dict_values(['Valor1', {'numeros': [1, 2, 3, 4, 5]}]) ``` -* Imprimir la longitud del diccionario +* Imprimir la longitud del diccionario ```python >>> len(mi_diccionario) 2 ``` - -
-

- Tips: La funcionalidad **del** permite eliminar cualquier estructura de datos y la funcionalidad **len** permite obtener el tamaño de la estructura de datos -

-
+ +--------------------------------------------------------------------------- +>Tips: La funcionalidad **del** permite eliminar cualquier estructura de datos y la funcionalidad **len** permite obtener el tamaño de la estructura de datos +--------------------------------------------------------------------------- ## Homework -Completa la tarea descrita en el archivo [README](https://github.com/soyHenry/Python-Prep/blob/4aec1885136fdcff98899d2be13c8908b39f8b21/04%20-%20Estructuras%20de%20datos/Prep_Course_Homework_04.md) - - - - - -
- - -
- Hacé click acá para dejar tu feedback sobre esta clase. - -
+Completa la tarea descrita en el archivo [README](https://github.com/soyHenry/Python-Prep/blob/4aec1885136fdcff98899d2be13c8908b39f8b21/02%20-%20Variables%20y%20Tipos%20de%20Datos/Prep_Course_Homework_02.md) + +![x](https://static.thenounproject.com/png/204643-200.png) + +[Hacé click acá para dejar tu feedback sobre esta clase.]("https://airtable.com/shrSzEYT4idEFGB8d?prefill_clase=00-PrimerosPasos") diff --git a/05 - Iteradores e Iterables/README.md b/05 - Iteradores e Iterables/README.md index e79297984..54e2ed238 100644 --- a/05 - Iteradores e Iterables/README.md +++ b/05 - Iteradores e Iterables/README.md @@ -1,10 +1,6 @@ -![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) - -## Grabación de la Clase 5 +# -
- -
+![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) ## Iteradores e Iterables @@ -144,7 +140,6 @@ StopIteration Traceback (most recent call last) Una nota muy importante es que cuando el iterador es obtenido con iter() como hemos visto, apunta por defecto fuera de la lista. Es decir, si queremos acceder al primer elemento de la lista, deberemos llamar una vez a next(). Por otro lado, a diferencia de un marcapáginas de un libro, el iterador sólo puede ir hacia delante. No es posible retroceder. - ### Sentencia zip Dadas dos listas, digamos lista1 y lista2, al pasarlas a **zip** como entrada, el elemento 1 de lista1 se asocia con el elemento 1 de lista2, el elemento 2 de lista1 se asocia con el elemento 2 de lista2, el elemento 3 de lista1 se asocia con el elemento 3 de lista2, y así sucesivamente. Es decir que el resultado será una tupla donde cada elemento tendrá todos y cada uno de los elementos i-ésimos de las listas pasadas como entrada. @@ -161,7 +156,7 @@ zip ### Añadiendo condicionales -Hemos visto cómo modificar todos los elementos de un iterable (como una lista) de diferentes maneras, pero ¿y si quisiéramos realizar la operación sobre el elemento sólo si una determinada condición se cumple? Debemos añadir un condicional if. +Hemos visto cómo modificar todos los elementos de un iterable (como una lista) de diferentes maneras, pero ¿y si quisiéramos realizar la operación sobre el elemento sólo si una determinada condición se cumple? Debemos añadir un condicional if. La expresión genérica sería la siguiente. lista = [expresión for elemento in iterable if condición] @@ -183,14 +178,6 @@ Lo que hace el código anterior es iterar cada letra de la frase, y si es una r, Completa la tarea descrita en el archivo [README](https://github.com/soyHenry/Python-Prep/blob/4aec1885136fdcff98899d2be13c8908b39f8b21/05%20-%20Iteradores%20e%20Iterables/Prep_Course_Homework_05.md) - - - - -
- - -
- Hacé click acá para dejar tu feedback sobre esta clase. - -
+![x](https://static.thenounproject.com/png/204643-200.png) + +[Hacé click acá para dejar tu feedback sobre esta clase.]("https://airtable.com/shrSzEYT4idEFGB8d?prefill_clase=00-PrimerosPasos") diff --git a/08 - Error Handling/README.md b/08 - Error Handling/README.md index 3a89c0288..91c687af1 100644 --- a/08 - Error Handling/README.md +++ b/08 - Error Handling/README.md @@ -1,10 +1,6 @@ -![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) - -## Grabación de la Clase 8 +# -
- -
+![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) ## Manejo de Errores @@ -12,6 +8,7 @@ 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í. @@ -51,7 +48,7 @@ Ran 2 tests in 0.004s OK -``` +``` ### Pruebas de caja de cristal @@ -98,6 +95,7 @@ OK 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. @@ -106,6 +104,7 @@ Existen unas reglas generales que nos ayudaran: * 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á. @@ -181,7 +180,7 @@ function buscaPais(paises, pais) { 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. @@ -191,39 +190,39 @@ Es importante resaltar que ambos estilos pueden utilizarse en Python, pero el es #All possible errors except TypeError: - print("is thrown when an operation or function is applied to an object of an inappropriate type.") + 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.") + print("is thrown when trying to access an item at an invalid index.") except KeyError: - print("is thrown when a key is not found.") + print("is thrown when a key is not found.") except ImportError: - print("Raised when the imported module is not found.") + print("Raised when the imported module is not found.") except StopIteration: - print("is thrown when the next() function goes beyond the iterator items.") + 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.") + 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.") + print("is thrown when an object could not be found.") except ZeroDivisionError: - print("is thrown when the second operator in the division is zero.") + 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.") + 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.") + print("Raised when an operation runs out of memory.") except FloatingPointError: - print("Raised when a floating point operation fails.") + 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.") + 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.") + 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.") + print("Raised when the indentation consists of inconsistent tabs and spaces.") except SystemError: - print("Raised when the interpreter detects internal error.") + print("Raised when the interpreter detects internal error.") except RuntimeError: - print("Raised when an error does not fall under any other category.") + print("Raised when an error does not fall under any other category.") except: - print("Error detected can't be handled nor clasified.") + print("Error detected can't be handled nor clasified.") ``` ## Afirmaciones @@ -246,23 +245,15 @@ Para realizar una afirmación en nuestro programa lo hacemos con la expresión a ## 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. +* 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. ## Homework Completa la tarea descrita en el archivo [README](https://github.com/soyHenry/Python-Prep/blob/4aec1885136fdcff98899d2be13c8908b39f8b21/08%20-%20Error%20Handling/Prep_Course_Homework_08.md) - - - - -
- - -
- Hacé click acá para dejar tu feedback sobre esta clase. - -
+![x](https://static.thenounproject.com/png/204643-200.png) + +[Hacé click acá para dejar tu feedback sobre esta clase.]("https://airtable.com/shrSzEYT4idEFGB8d?prefill_clase=00-PrimerosPasos")