From 05a72807c12111d7ac3b9a94c6589cf5486ed097 Mon Sep 17 00:00:00 2001 From: elizabeth Date: Wed, 6 Apr 2022 23:41:30 -0500 Subject: [PATCH 1/7] 02-Variables_y_Tipos_de_Datos_Resuelto_Eliza --- .../Practica en Clase.py | 8 +- .../Preliminares en Clase - 02.ipynb | 24 +++-- ...ep_Course_Homework_02-Resuelto Clase.ipynb | 21 +++- .../Prep_Course_Homework_02_Eliza.py | 99 +++++++++++++++++++ 4 files changed, 141 insertions(+), 11 deletions(-) create mode 100644 02 - Variables y Tipos de Datos/Prep_Course_Homework_02_Eliza.py diff --git a/02 - Variables y Tipos de Datos/Practica en Clase.py b/02 - Variables y Tipos de Datos/Practica en Clase.py index 61df2efb3..08997dfca 100644 --- a/02 - Variables y Tipos de Datos/Practica en Clase.py +++ b/02 - Variables y Tipos de Datos/Practica en Clase.py @@ -9,4 +9,10 @@ mi_numero = input('Ingrese un valor') -print('el valor ingresado fue', mi_numero) \ No newline at end of file +print('el valor ingresado fue', mi_numero) + +a=input('ingrese num1: ') + +b=input('ingrese num2: ') +sumar=(int(a)+int(b)) +print(sumar) diff --git a/02 - Variables y Tipos de Datos/Preliminares en Clase - 02.ipynb b/02 - Variables y Tipos de Datos/Preliminares en Clase - 02.ipynb index a2fc129a3..bbb1b26ab 100644 --- a/02 - Variables y Tipos de Datos/Preliminares en Clase - 02.ipynb +++ b/02 - Variables y Tipos de Datos/Preliminares en Clase - 02.ipynb @@ -9,23 +9,35 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "complex" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "mi_var = 12 + 1j" + "mi_var = 12 + 1j\n", + "type(mi_var)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "12\n" + "(12+1j)\n" ] } ], @@ -2624,7 +2636,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.4" } }, "nbformat": 4, diff --git a/02 - Variables y Tipos de Datos/Prep_Course_Homework_02-Resuelto Clase.ipynb b/02 - Variables y Tipos de Datos/Prep_Course_Homework_02-Resuelto Clase.ipynb index 942bff045..d6de725a8 100644 --- a/02 - Variables y Tipos de Datos/Prep_Course_Homework_02-Resuelto Clase.ipynb +++ b/02 - Variables y Tipos de Datos/Prep_Course_Homework_02-Resuelto Clase.ipynb @@ -170,12 +170,25 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7.1\n" + ] + } + ], "source": [ "var1 = 'True'\n", - "var2 = True" + "var2 = True\n", + "a = '4,5'\n", + "b = ' 2,6'\n", + "a = float(a.replace(',','.'))\n", + "b = float(b.replace(',','.'))\n", + "print(a + b)" ] }, { @@ -715,7 +728,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.4" } }, "nbformat": 4, diff --git a/02 - Variables y Tipos de Datos/Prep_Course_Homework_02_Eliza.py b/02 - Variables y Tipos de Datos/Prep_Course_Homework_02_Eliza.py new file mode 100644 index 000000000..56ca84319 --- /dev/null +++ b/02 - Variables y Tipos de Datos/Prep_Course_Homework_02_Eliza.py @@ -0,0 +1,99 @@ +## Variables + +#1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla + +bebecita=24 +print(bebecita) +#2) Imprimir el tipo de dato de la constante 8.5 +print(type(8.5)) + +#3) Imprimir el tipo de dato de la variable creada en el punto 1 +print(type(bebecita)) + +#4) Crear una variable que contenga tu nombre +nombre='Elizabeth' +print(nombre) +#5) Crear una variable que contenga un número complejo +n_complejo=1-2j +print(n_complejo) +#6) Mostrar el tipo de dato de la variable crada en el punto 5 +print(type(n_complejo)) +#7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales +import math +v_pi=math.pi +print(v_pi) +num_pi=round(v_pi,4) +print(num_pi) +#8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo? +v_t='True' +v_tt=True +print(v_t) +print(v_tt) +#9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 9 +print(type(v_t)) +#10) Asignar a una variable, la suma de un número entero y otro decimal +n1=14 +n2=15.45 +suma=n1+n2 +print(suma) +#11) Realizar una operación de suma de números complejos +n_c=1+14j +n1_c=2+15j +s_complejo=n_c+n1_c +print(s_complejo) +#12) Realizar una operación de suma de un número real y otro complejo +n_r=12.3 +print(n_r + n_c) + +#13) Realizar una operación de multiplicación +a=3 +m=6 +print(a*m) + +#14) Mostrar el resultado de elevar 2 a la octava potencia +print(2**8) + +#15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla +dividendo=27 +divisor=4 +cociente=27/4 +print(cociente) + +#16) De la división anterior solamente mostrar la parte entera + +cociente=27//4 +print(cociente) +#17) De la división de 27 entre 4 mostrar solamente el resto +resto=27%4 +print(resto) +#18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado +dividendo=resto+divisor*cociente +print(dividendo) + +#19) Utilizar el operador "+" en una operación donde intervengan solo variables alfanuméricas +word1='Hola soy' +word2=' Elizabeth' +word3=word1+word2 +print(word3) +#20) Evaluar si "2" es igual a 2. ¿Por qué ocurre eso? +print("pon") +print(2=='2') +#21)( Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera +print(type(2==int('2'))) +#22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8') +print( "PregunTa #22 porque no se puede convertir de string a float") +#23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido +a = -3 +a -= 1 +print(a) +#24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario? +print("1<<2") +print(1<<2) +print("es un sistema de numeración en el que los números se representan utilizando las cifras 0 y 1") +#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? +float(2) + float('2') + +#26) Realizar una operación válida entre valores de tipo entero y string +var1 = 'este texto se repite ' +var2 = 3 +print(var1 * var2 + str(var2) + ' veces' ) \ No newline at end of file From 8471f2ad4982b9274260f3e8a260fe3f0b868174 Mon Sep 17 00:00:00 2001 From: elizabeth Date: Wed, 6 Apr 2022 23:51:55 -0500 Subject: [PATCH 2/7] 01-Introduccion_a_la_Programacion_Resuelto_Elizabeth --- .../Practica.py" | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git "a/01 - Introducci\303\263n a la Programaci\303\263n/Practica.py" "b/01 - Introducci\303\263n a la Programaci\303\263n/Practica.py" index f3425b165..543214c55 100644 --- "a/01 - Introducci\303\263n a la Programaci\303\263n/Practica.py" +++ "b/01 - Introducci\303\263n a la Programaci\303\263n/Practica.py" @@ -1 +1,5 @@ -print('Hola Mundo!222') \ No newline at end of file +print('Hola Mundo!222 soy Eliza') +a=5 +b=6 +c=a+b +print('la suma es: \n', c) \ No newline at end of file From 8c7a8983f563dcde12f23e2acd40542b32761ca5 Mon Sep 17 00:00:00 2001 From: elizabeth Date: Wed, 6 Apr 2022 23:55:44 -0500 Subject: [PATCH 3/7] 03-Fujos_de_Control_ResueltO_Eliza --- .../Prep_Course_Homework_03-Eliza.ipynb | 621 ++++++++++++++++++ .../Prep_Course_Homework_03-Eliza.py | 174 +++++ ...ep_Course_Homework_03-Resuelto Clase.ipynb | 6 +- .../Prep_Course_Homework_03-Resuelto.py | 17 +- .../Prep_Course_Homework_03.md | 1 + 5 files changed, 806 insertions(+), 13 deletions(-) create mode 100644 03 - Flujos de Control/Prep_Course_Homework_03-Eliza.ipynb create mode 100644 03 - Flujos de Control/Prep_Course_Homework_03-Eliza.py diff --git a/03 - Flujos de Control/Prep_Course_Homework_03-Eliza.ipynb b/03 - Flujos de Control/Prep_Course_Homework_03-Eliza.ipynb new file mode 100644 index 000000000..2bf5edf0c --- /dev/null +++ b/03 - Flujos de Control/Prep_Course_Homework_03-Eliza.ipynb @@ -0,0 +1,621 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Es igual a 0\n" + ] + } + ], + "source": [ + "## Flujos de Control\n", + "\n", + "#1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla si es mayor o menor a cero\n", + "from cgi import print_arguments\n", + "from math import factorial\n", + "\n", + "\n", + "a=0\n", + "if a>0:\n", + " print(\"Es mayor a 0\")\n", + "elif a<0:\n", + " print(\"Es menor a 0\")\n", + "else:\n", + " print(\"Es igual a 0\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "no son del mismo tipo\n" + ] + } + ], + "source": [ + "#2) Crear dos variables y un condicional que informe si son del mismo tipo de dato\n", + "a='Elizabeth'\n", + "b=45\n", + "if(type(a)==type(b)):\n", + " print(\" son del mismo tipo\")\n", + "else:\n", + " print(\"no son del mismo tipo\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 no es par\n", + "2 es par\n", + "3 no es par\n", + "4 es par\n", + "5 no es par\n", + "6 es par\n", + "7 no es par\n", + "8 es par\n", + "9 no es par\n", + "10 es par\n", + "11 no es par\n", + "12 es par\n", + "13 no es par\n", + "14 es par\n", + "15 no es par\n", + "16 es par\n", + "17 no es par\n", + "18 es par\n", + "19 no es par\n", + "20 es par\n" + ] + } + ], + "source": [ + "#3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar\n", + "for n in range (1,21):\n", + " if n%2==0:\n", + " print(n,\"es par\")\n", + " else:\n", + " print(n,\"no es par\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0potencia\n", + "1potencia\n", + "8potencia\n", + "27potencia\n", + "64potencia\n", + "125potencia\n" + ] + } + ], + "source": [ + "#4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3\n", + "\n", + "for n in range (0,6):\n", + " p=n**3\n", + " print(str(p)+\"potencia\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "10\n", + "11\n" + ] + } + ], + "source": [ + "#5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos\n", + "a=12\n", + "for i in range (0,a):\n", + " print(i)\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hola\n", + "el factorial es: 120\n" + ] + } + ], + "source": [ + "#6) Utilizar un ciclo while para realizar el factorial de un número guardado en una variable, \n", + "#sólo si la variable contiene un número entero mayor a 0\n", + "print(\"hola\")\n", + "n=5\n", + "if type(n)==int:\n", + " if n>0:\n", + " factorial=n\n", + " while n>2:\n", + " n=n-1\n", + " factorial=factorial*n\n", + " print(\"el factorial es: \",factorial)\n", + " else:\n", + " print(\"no es mayor a 0\")\n", + "else:\n", + " print(\"no es un numero entero\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hola 2\n", + "chau chau 1\n", + "hola 3\n", + "chau chau 1\n", + "hola 3\n", + "chau chau 2\n", + "hola 4\n", + "chau chau 1\n", + "hola 4\n", + "chau chau 2\n", + "hola 4\n", + "chau chau 3\n", + "hola 5\n", + "chau chau 1\n", + "hola 5\n", + "chau chau 2\n", + "hola 5\n", + "chau chau 3\n", + "hola 5\n", + "chau chau 4\n" + ] + } + ], + "source": [ + "#7) Crear un ciclo for dentro de un ciclo while\n", + "n=0\n", + "while n<5:\n", + " n=n+1\n", + " for i in range (1,n):\n", + " print(\"hola\", n)\n", + " print(\"chau chau\", i)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#8) Crear un ciclo while dentro de un ciclo for\n", + "\n", + "n = 5\n", + "for i in range(1, n):\n", + " while(n < 5):\n", + " n -= 1 #4\n", + " print('Ciclo while nro ' + str(n))#4\n", + " print('Ciclo for nro ' + str(i))#1" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 es primo\n", + "1 es primo\n", + "2 es primo\n", + "3 es primo\n", + "4 no es primo\n", + "5 es primo\n", + "6 no es primo\n", + "7 es primo\n", + "8 no es primo\n", + "9 no es primo\n", + "10 no es primo\n", + "11 es primo\n", + "12 no es primo\n", + "13 es primo\n", + "14 no es primo\n", + "15 no es primo\n", + "16 no es primo\n", + "17 es primo\n", + "18 no es primo\n", + "19 es primo\n", + "20 no es primo\n", + "21 no es primo\n", + "22 no es primo\n", + "23 es primo\n", + "24 no es primo\n", + "25 no es primo\n", + "26 no es primo\n", + "27 no es primo\n", + "28 no es primo\n", + "29 es primo\n", + "30 no es primo\n" + ] + } + ], + "source": [ + "#9) Imprimir los números primos existentes entre 0 y 30\n", + "for nro in range(0, 31):\n", + " es_primo=True\n", + " for i in range(2, nro): \n", + " if (nro%i==0):\n", + " es_primo=False\n", + " if (es_primo):\n", + " print(nro, \"es primo\")\n", + " else:\n", + " print(nro, 'no es primo') " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 es primo\n", + "1 es primo\n", + "2 es primo\n", + "3 es primo\n", + "4 no es primo\n", + "5 es primo\n", + "6 no es primo\n", + "7 es primo\n", + "8 no es primo\n", + "9 no es primo\n", + "10 no es primo\n", + "11 es primo\n", + "12 no es primo\n", + "13 es primo\n", + "14 no es primo\n", + "15 no es primo\n", + "16 no es primo\n", + "17 es primo\n", + "18 no es primo\n", + "19 es primo\n", + "20 no es primo\n", + "21 no es primo\n", + "22 no es primo\n", + "23 es primo\n", + "24 no es primo\n", + "25 no es primo\n", + "26 no es primo\n", + "27 no es primo\n", + "28 no es primo\n", + "29 es primo\n", + "30 no es primo\n", + "Cantidad de ciclos: 135\n" + ] + } + ], + "source": [ + "#10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias\n", + "# break y/ó continue para tal fin\n", + "cantidad_ciclos = 0\n", + "for nro in range(0, 31):\n", + " es_primo=True\n", + " for i in range(2, nro): \n", + " cantidad_ciclos +=1\n", + " if (nro%i==0):\n", + " es_primo=False\n", + " break\n", + " if (es_primo):\n", + " print(nro, \"es primo\")\n", + " else:\n", + " print(nro, 'no es primo') \n", + "print('Cantidad de ciclos: ' +str(cantidad_ciclos))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 es primo\n", + "1 es primo\n", + "2 es primo\n", + "3 es primo\n", + "4 no es primo\n", + "5 es primo\n", + "6 no es primo\n", + "7 es primo\n", + "8 no es primo\n", + "9 no es primo\n", + "10 no es primo\n", + "11 es primo\n", + "12 no es primo\n", + "13 es primo\n", + "14 no es primo\n", + "15 no es primo\n", + "16 no es primo\n", + "17 es primo\n", + "18 no es primo\n", + "19 es primo\n", + "20 no es primo\n", + "21 no es primo\n", + "22 no es primo\n", + "23 es primo\n", + "24 no es primo\n", + "25 no es primo\n", + "26 no es primo\n", + "27 no es primo\n", + "28 no es primo\n", + "29 es primo\n", + "30 no es primo\n", + "Cantidad de ciclos sin break: 406\n", + "0 es primo\n", + "1 es primo\n", + "2 es primo\n", + "3 es primo\n", + "4 no es primo\n", + "5 es primo\n", + "6 no es primo\n", + "7 es primo\n", + "8 no es primo\n", + "9 no es primo\n", + "10 no es primo\n", + "11 es primo\n", + "12 no es primo\n", + "13 es primo\n", + "14 no es primo\n", + "15 no es primo\n", + "16 no es primo\n", + "17 es primo\n", + "18 no es primo\n", + "19 es primo\n", + "20 no es primo\n", + "21 no es primo\n", + "22 no es primo\n", + "23 es primo\n", + "24 no es primo\n", + "25 no es primo\n", + "26 no es primo\n", + "27 no es primo\n", + "28 no es primo\n", + "29 es primo\n", + "30 no es primo\n", + "Cantidad de ciclos: 135\n", + "Se optimizo a un 0.33251231527093594% de ciclos aplicando break\n" + ] + } + ], + "source": [ + "#11) En los puntos 9 y 10, se diseño un código que encuentra números primos\n", + "# y además se lo optimizó. ¿Es posible saber en qué medida se optimizó?\n", + "ciclos_sin_break = 0\n", + "for nro in range(0, 31):\n", + " es_primo=True\n", + " for i in range(2, nro): \n", + " ciclos_sin_break +=1\n", + " if (nro%i==0):\n", + " es_primo=False\n", + " if (es_primo):\n", + " print(nro, \"es primo\")\n", + " else:\n", + " print(nro, 'no es primo') \n", + "print('Cantidad de ciclos sin break: ' +str(ciclos_sin_break))\n", + "\n", + "ciclos_con_break = 0\n", + "for nro in range(0, 31):\n", + " es_primo=True\n", + " for i in range(2, nro): \n", + " ciclos_con_break +=1\n", + " if (nro%i==0):\n", + " es_primo=False\n", + " break\n", + " if (es_primo):\n", + " print(nro, \"es primo\")\n", + " else:\n", + " print(nro, 'no es primo') \n", + "print('Cantidad de ciclos: ' +str(ciclos_con_break))\n", + "print('Se optimizo a un ' + str(ciclos_con_break/ciclos_sin_break) + '% de ciclos aplicando break')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Con 31: 0.3325% de optimizacion/n\n", + "Con 100: 1132/4756 0.23916% de optimizacion/n\n" + ] + } + ], + "source": [ + "#12) Si la cantidad de números que se evalúa es mayor a treinta, esa optimización crece?\n", + "print(\"Con 31: 0.3325% de optimizacion/n\")\n", + "print(\"Con 100: 1132/4756 0.23916% de optimizacion/n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "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": [ + "#13) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12,\n", + "# dentro del rango de números de 100 a 300\n", + "\n", + "n=99\n", + "while (n<=300):\n", + " n+=1\n", + " if (n % 12 != 0):\n", + " continue\n", + " print(str(n), \"es divisible por 12\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "¿Desea encontrar el siguiente número primo?\n", + "Se finaliza el proceso\n" + ] + } + ], + "source": [ + "#14) Utilizar la función **input()** que permite hacer ingresos por teclado, \n", + "# para encontrar números primos y dar la opción al usuario de buscar el siguiente\"\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'):\n", + " print('Se finaliza el proceso')\n", + " break\n", + " else:\n", + " primo = True\n", + " n += 1\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "El número es: 102\n" + ] + } + ], + "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\n", + "n = 100\n", + "while(n<=300):\n", + " if (n % 6 == 0):\n", + " print('El número es: ', str(n))\n", + " break\n", + " n += 1\n", + "\n" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "e371a547b05cc06fe9399c68d0811fab82050f0eaa2349dcabfd68d0d68f365a" + }, + "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/Prep_Course_Homework_03-Eliza.py b/03 - Flujos de Control/Prep_Course_Homework_03-Eliza.py new file mode 100644 index 000000000..61cea67d2 --- /dev/null +++ b/03 - Flujos de Control/Prep_Course_Homework_03-Eliza.py @@ -0,0 +1,174 @@ +## Flujos de Control + +#1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla si es mayor o menor a cero +from cgi import print_arguments +from math import factorial + + +a=0 +if a>0: + print("Es mayor a 0") +elif a<0: + print("Es menor a 0") +else: + print("Es igual a 0") + +#2) Crear dos variables y un condicional que informe si son del mismo tipo de dato +a='Elizabeth' +b=45 +if(type(a)==type(b)): + print(" son del mismo tipo") +else: + print("no son del mismo tipo") + +#3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar +for n in range (1,21): + if n%2==0: + print(n,"es par") + else: + print(n,"no es par") + +#4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3 + +for n in range (0,6): + p=n**3 + print(str(p)+"potencia") +#5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos +a=12 +for i in range (0,a): + print(i) + pass + +#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 +print("hola") +n=5 +if type(n)==int: + if n>0: + factorial=n + while n>2: + n=n-1 + factorial=factorial*n + print("el factorial es: ",factorial) + else: + print("no es mayor a 0") +else: + print("no es un numero entero") + +#7) Crear un ciclo for dentro de un ciclo while +n=0 +while n<5: + n=n+1 + for i in range (1,n): + print("hola", n) + print("chau chau", i) + +#8) Crear un ciclo while dentro de un ciclo for + +n = 5 +for i in range(1, n): + while(n < 5): + n -= 1 #4 + print('Ciclo while nro ' + str(n))#4 + print('Ciclo for nro ' + str(i))#1 +#9) Imprimir los números primos existentes entre 0 y 30 +for nro in range(0, 31): + es_primo=True + for i in range(2, nro): + if (nro%i==0): + es_primo=False + if (es_primo): + print(nro, "es primo") + else: + print(nro, 'no es primo') + +#10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias +# break y/ó continue para tal fin +cantidad_ciclos = 0 +for nro in range(0, 31): + es_primo=True + for i in range(2, nro): + cantidad_ciclos +=1 + if (nro%i==0): + es_primo=False + break + if (es_primo): + print(nro, "es primo") + else: + print(nro, 'no es primo') +print('Cantidad de ciclos: ' +str(cantidad_ciclos)) + +#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ó? +ciclos_sin_break = 0 +for nro in range(0, 31): + es_primo=True + for i in range(2, nro): + ciclos_sin_break +=1 + if (nro%i==0): + es_primo=False + if (es_primo): + print(nro, "es primo") + else: + print(nro, 'no es primo') +print('Cantidad de ciclos sin break: ' +str(ciclos_sin_break)) + +ciclos_con_break = 0 +for nro in range(0, 31): + es_primo=True + for i in range(2, nro): + ciclos_con_break +=1 + if (nro%i==0): + es_primo=False + break + if (es_primo): + print(nro, "es primo") + else: + print(nro, 'no es primo') +print('Cantidad de ciclos: ' +str(ciclos_con_break)) +print('Se optimizo a un ' + str(ciclos_con_break/ciclos_sin_break) + '% de ciclos aplicando break') + +#12) Si la cantidad de números que se evalúa es mayor a treinta, esa optimización crece? +print("Con 31: 0.3325% de optimizacion/n") +print("Con 100: 1132/4756 0.23916% de optimizacion/n") + +#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 + +n=99 +while (n<=300): + n+=1 + if (n % 12 != 0): + continue + print(str(n), "es divisible por 12") + +#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" +n = 1 +sigue = 1 +primo = True +while (sigue == 1): + for div in range(2, n): + if (n % div == 0): + primo = False + break + if (primo): + print(n) + print('¿Desea encontrar el siguiente número primo?') + if (input() != '1'): + print('Se finaliza el proceso') + break + else: + primo = True + n += 1 + + + +#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 +n = 100 +while(n<=300): + if (n % 6 == 0): + print('El número es: ', str(n)) + break + n += 1 + diff --git a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb index ce4105c8d..5f8513083 100644 --- a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb +++ b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto Clase.ipynb @@ -23,7 +23,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "La varaible es mayor a cero\n" + "La variable es mayor a cero\n" ] } ], @@ -32,7 +32,7 @@ "if (a < 0):\n", " print('La variable es menor a cero')\n", "elif (a > 0): \n", - " print('La varaible es mayor a cero')\n", + " print('La variable es mayor a cero')\n", "else:\n", " print('La variable es igual a cero')" ] @@ -34607,7 +34607,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.4" } }, "nbformat": 4, diff --git a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.py b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.py index afe810608..af7059e84 100644 --- a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.py +++ b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.py @@ -79,22 +79,18 @@ print('La variable no es mayor a cero') else: print('La variable no es un entero') - - # 7) Crear un ciclo for dentro de un ciclo while # In[38]: - n = 0 while(n < 5): - n += 1 - for i in range(1,n): + n += 1 # n=1,2,3,4,5 + for i in range(1,n): # print('Ciclo while nro ' + str(n)) print('Ciclo for nro ' + str(i)) - # 8) Crear un ciclo while dentro de un ciclo for # In[3]: @@ -103,9 +99,9 @@ n = 5 for i in range(1, n): while(n < 5): - n -= 1 - print('Ciclo while nro ' + str(n)) - print('Ciclo for nro ' + str(i)) + n -= 1 #4 + print('Ciclo while nro ' + str(n))#4 + print('Ciclo for nro ' + str(i))#1 # 9) Imprimir los números primos existentes entre 0 y 30 @@ -244,7 +240,8 @@ print(n, ' es divisible por 12') -# 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 +# 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 # In[73]: diff --git a/03 - Flujos de Control/Prep_Course_Homework_03.md b/03 - Flujos de Control/Prep_Course_Homework_03.md index 76b90eed3..9445a23f6 100644 --- a/03 - Flujos de Control/Prep_Course_Homework_03.md +++ b/03 - Flujos de Control/Prep_Course_Homework_03.md @@ -2,6 +2,7 @@ 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla si es mayor o menor a cero + 2) Crear dos variables y un condicional que informe si son del mismo tipo de dato 3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar From a39289b6bff403add772f8ea3a825e9637ce8723 Mon Sep 17 00:00:00 2001 From: elizabeth Date: Sun, 10 Apr 2022 11:56:30 -0500 Subject: [PATCH 4/7] 04-Estructura-de-datos-Eliza --- .../Prep_Course_Homework_04_Clase.ipynb | 922 +++++++++++++++++ .../Prep_Course_Homework_04_Eliza.ipynb | 933 ++++++++++++++++++ 2 files changed, 1855 insertions(+) create mode 100644 04 - Estructuras de datos/Prep_Course_Homework_04_Clase.ipynb create mode 100644 04 - Estructuras de datos/Prep_Course_Homework_04_Eliza.ipynb diff --git a/04 - Estructuras de datos/Prep_Course_Homework_04_Clase.ipynb b/04 - Estructuras de datos/Prep_Course_Homework_04_Clase.ipynb new file mode 100644 index 000000000..39af808ea --- /dev/null +++ b/04 - Estructuras de datos/Prep_Course_Homework_04_Clase.ipynb @@ -0,0 +1,922 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#04 - Estructuras de datos\n", + "mi_lista = ['rojo', 'azul','amarillo','verde',100,2000]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['azul', 'amarillo']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista[1:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "int" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(mi_lista[4])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['rojo', 'azul', 'amarillo', 'verde', 100, 2000]\n" + ] + } + ], + "source": [ + "print(mi_lista)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista[4] = 'blanco'\n", + "mi_lista[5] = 'negro'" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['rojo', 'azul', 'amarillo', 'verde', 'blanco', 'negro']\n" + ] + } + ], + "source": [ + "print(mi_lista)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista.append('marron')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['rojo', 'azul', 'amarillo', 'verde', 'blanco', 'negro', 'marron']\n" + ] + } + ], + "source": [ + "print(mi_lista)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista.insert(1,'violeta')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['rojo', 'violeta', 'azul', 'amarillo', 'verde', 'blanco', 'negro', 'marron']\n" + ] + } + ], + "source": [ + "print(mi_lista)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista.index('verde')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "marron\n" + ] + } + ], + "source": [ + "#pop sirve para eliminar el ultimo elemento de una lista\n", + "a = mi_lista.pop()\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['rojo', 'violeta', 'azul', 'amarillo', 'verde', 'blanco', 'negro']\n" + ] + } + ], + "source": [ + "print(mi_lista)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista.remove('violeta')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "#ESTAMOS haciendo q se extienda mi_lista con mi_lista2\n", + "mi_lista2 = ['azul','negro','blanco']\n", + "mi_lista.extend(mi_lista2)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['rojo',\n", + " 'azul',\n", + " 'amarillo',\n", + " 'verde',\n", + " 'blanco',\n", + " 'negro',\n", + " 'azul',\n", + " 'negro',\n", + " 'blanco']" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['rojo', 'azul', 'amarillo', 'verde', 'blanco', 'negro', 'azul', 'negro', 'blanco', 'magenta']\n" + ] + } + ], + "source": [ + "mi_lista.extend(['magenta']) \n", + "print(mi_lista)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista3 = [mi_lista, mi_lista2, 'hola', 1, True, 1.2]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[['rojo',\n", + " 'azul',\n", + " 'amarillo',\n", + " 'verde',\n", + " 'blanco',\n", + " 'negro',\n", + " 'azul',\n", + " 'negro',\n", + " 'blanco',\n", + " 'magenta'],\n", + " ['azul', 'negro', 'blanco'],\n", + " 'hola',\n", + " 1,\n", + " True,\n", + " 1.2]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista3" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['rojo', 'azul', 'amarillo']" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#accedeme de mi_lista3 a la 1era lista y los 3 primeros elementos de esa 1era lista\n", + "mi_lista3[0][0:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista3.index('hola')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'<' not supported between instances of 'str' and 'list'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\HP SUPPORT\\Desktop\\Python-Prep\\04 - Estructuras de datos\\Prep_Course_Homework_04_Clase.ipynb Cell 22'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39m#sort sirve para ordenar elementos de mi lista, y tiene q tener mismo tipo de elementos\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m mi_lista3\u001b[39m.\u001b[39;49msort()\n", + "\u001b[1;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'list'" + ] + } + ], + "source": [ + "#sort sirve para ordenar elementos de mi lista, y tiene q tener mismo tipo de elementos\n", + "mi_lista3.sort()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista4 = [8,7,2,5,9,0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista4.sort()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 2, 5, 7, 8, 9]" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista4" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista5 =['c','d','b','a']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista5.sort()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['a', 'b', 'c', 'd']" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Tupla\n", + "list(range(0,11))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista6=[1,5,4,8,9,7]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista6=tuple(mi_lista6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 5, 4, 8, 9, 7)" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista6" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_tupla1=('a','c','b','e','d')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_lista7=list(mi_tupla1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['a', 'b', 'c', 'd', 'e']" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista7.sort()\n", + "mi_lista7" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "mi_tupla2=(1,2,3,3)\n", + "print(mi_tupla2.count(1))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 in mi_tupla2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 in mi_tupla2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Tupla: se puede empaquetar y desempaquetar en un tupla\n", + "mi_tupla3 = 'Rojo', 1, 'Verde', 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('Rojo', 1, 'Verde', 2)" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_tupla3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "var1, var2, var3, var4 = mi_tupla3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Var1: Rojo Var2: 1 Var3: Verde Var4: 2\n" + ] + } + ], + "source": [ + "print(\"Var1:\", var1,\"Var2:\", var2, \"Var3:\", var3, \"Var4:\", var4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 0, 5, 8, 9, 7]" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista8=[2,0,5,8,9,7]\n", + "mi_lista8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 0, 5]" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista8[:3]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 0, 5, 8, 9, 7]" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_lista8[0:]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#te da la cantidad de elementos de la lista\n", + "len(mi_lista8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#te da el ultimo elemento de la lista\n", + "mi_lista8[len(mi_lista8)-1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Diccionario\n", + "mi_diccionario ={'Frutas': ['Manzana','Naranja','Durazno'],\n", + " 'Verduras': ['Tomate','Lechuga','Papa'],\n", + " 'Especies': ['Pimienta','Azafran','Canela']}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Manzana', 'Naranja', 'Durazno']" + ] + }, + "execution_count": 112, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_diccionario['Frutas']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Frutas': ['Pera', 'Frutilla', 'Melón'],\n", + " 'Verduras': ['Tomate', 'Lechuga', 'Papa'],\n", + " 'Especies': ['Pimienta', 'Azafran', 'Canela'],\n", + " 'Arboles': ['Nogal', 'Roble', 'Sauce']}" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# para cambiar y agregar valores\n", + "mi_diccionario['Frutas'] = ['Pera','Frutilla','Melón']\n", + "mi_diccionario['Arboles'] = ['Nogal', 'Roble', 'Sauce']\n", + "mi_diccionario\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Eliminar un elemento a traves de su clave\n", + "del mi_diccionario['Frutas']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Verduras': ['Tomate', 'Lechuga', 'Papa'],\n", + " 'Especies': ['Pimienta', 'Azafran', 'Canela'],\n", + " 'Arboles': ['Nogal', 'Roble', 'Sauce']}" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_diccionario" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['Verduras', 'Especies', 'Arboles'])\n" + ] + } + ], + "source": [ + "#Se puede acceder a las claves y a los valores del diccionario\n", + "print(mi_diccionario.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_values([['Tomate', 'Lechuga', 'Papa'], ['Pimienta', 'Azafran', 'Canela'], ['Nogal', 'Roble', 'Sauce']])" + ] + }, + "execution_count": 118, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_diccionario.values()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "e371a547b05cc06fe9399c68d0811fab82050f0eaa2349dcabfd68d0d68f365a" + }, + "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/Prep_Course_Homework_04_Eliza.ipynb b/04 - Estructuras de datos/Prep_Course_Homework_04_Eliza.ipynb new file mode 100644 index 000000000..0f28eb4e9 --- /dev/null +++ b/04 - Estructuras de datos/Prep_Course_Homework_04_Eliza.ipynb @@ -0,0 +1,933 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 219, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Lima', 'Asuncion', 'Washington', 'Santiago de Chile', 'Buenos Aires', 'Montevideo']\n" + ] + } + ], + "source": [ + "## Estructuras de Datos: Clase 4\n", + "#1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla\n", + "lista_ciudades=['Lima', 'Asuncion', 'Washington','Santiago de Chile','Buenos Aires','Montevideo']\n", + "print(lista_ciudades)" + ] + }, + { + "cell_type": "code", + "execution_count": 220, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Asuncion\n" + ] + } + ], + "source": [ + "#2) Imprimir por pantalla el segundo elemento de la lista\n", + "print(lista_ciudades[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 221, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Asuncion', 'Washington', 'Santiago de Chile']\n" + ] + } + ], + "source": [ + "#3) Imprimir por pantalla del segundo al cuarto elemento\n", + "print(lista_ciudades[1:4])" + ] + }, + { + "cell_type": "code", + "execution_count": 222, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "#4) Visualizar el tipo de dato de la lista\n", + "print(type(lista_ciudades))" + ] + }, + { + "cell_type": "code", + "execution_count": 223, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Washington', 'Santiago de Chile', 'Buenos Aires', 'Montevideo']\n" + ] + } + ], + "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\n", + "print(lista_ciudades[2:])" + ] + }, + { + "cell_type": "code", + "execution_count": 224, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Lima', 'Asuncion', 'Washington', 'Santiago de Chile']" + ] + }, + "execution_count": 224, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#6) Visualizar los primeros 4 elementos de la lista\n", + "lista_ciudades[:4]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 225, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Lima',\n", + " 'Asuncion',\n", + " 'Washington',\n", + " 'Santiago de Chile',\n", + " 'Buenos Aires',\n", + " 'Montevideo',\n", + " 'Lima',\n", + " 'Paris']" + ] + }, + "execution_count": 225, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error?\n", + "lista_ciudades.append('Lima')\n", + "lista_ciudades.append('Paris')\n", + "lista_ciudades" + ] + }, + { + "cell_type": "code", + "execution_count": 226, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Lima', 'Asuncion', 'Washington', 'Santiago de Chile', 'Buenos Aires', 'Montevideo', 'Lima', 'Paris', 'Lima', 'eliza']\n" + ] + } + ], + "source": [ + "lista_ciudades.extend(['Lima','eliza']) \n", + "print(lista_ciudades)" + ] + }, + { + "cell_type": "code", + "execution_count": 227, + "metadata": {}, + "outputs": [], + "source": [ + "#8) Agregar otra ciudad, pero en la cuarta posición\n", + "lista_ciudades.insert(3,'Managua')" + ] + }, + { + "cell_type": "code", + "execution_count": 228, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Lima',\n", + " 'Asuncion',\n", + " 'Washington',\n", + " 'Managua',\n", + " 'Santiago de Chile',\n", + " 'Buenos Aires',\n", + " 'Montevideo',\n", + " 'Lima',\n", + " 'Paris',\n", + " 'Lima',\n", + " 'eliza']" + ] + }, + "execution_count": 228, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lista_ciudades" + ] + }, + { + "cell_type": "code", + "execution_count": 229, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Lima',\n", + " 'Asuncion',\n", + " 'Washington',\n", + " 'Managua',\n", + " 'Santiago de Chile',\n", + " 'Buenos Aires',\n", + " 'Montevideo',\n", + " 'Lima',\n", + " 'Paris',\n", + " 'Lima',\n", + " 'eliza',\n", + " ['celular', 'television', 'laptop']]" + ] + }, + "execution_count": 229, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#9) Concatenar otra lista a la ya creada\n", + "nueva_lista=['celular','television','laptop']\n", + "lista_ciudades.append(nueva_lista)\n", + "lista_ciudades" + ] + }, + { + "cell_type": "code", + "execution_count": 230, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Lima', 'Asuncion', 'Washington', 'Managua', 'Santiago de Chile', 'Buenos Aires', 'Montevideo', 'Lima', 'Paris', 'Lima', 'eliza', ['celular', 'television', 'laptop'], 'islas malvinas', 'chernobil', 'Fukushima']\n" + ] + } + ], + "source": [ + "nueva_lista1 = ['islas malvinas','chernobil','Fukushima']\n", + "lista_ciudades.extend(nueva_lista1)\n", + "print(lista_ciudades)" + ] + }, + { + "cell_type": "code", + "execution_count": 231, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 231, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad?\n", + "lista_ciudades.index('Lima')" + ] + }, + { + "cell_type": "code", + "execution_count": 232, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "'Quito' 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;32mc:\\Users\\HP SUPPORT\\Desktop\\Python-Prep\\04 - Estructuras de datos\\Prep_Course_Homework_04_Homework_Eliza.ipynb Cell 14'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39m#11) ¿Qué pasa si se busca un elemento que no existe?\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m lista_ciudades\u001b[39m.\u001b[39;49mindex(\u001b[39m'\u001b[39;49m\u001b[39mQuito\u001b[39;49m\u001b[39m'\u001b[39;49m)\n", + "\u001b[1;31mValueError\u001b[0m: 'Quito' is not in list" + ] + } + ], + "source": [ + "#11) ¿Qué pasa si se busca un elemento que no existe?\n", + "lista_ciudades.index('Quito')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'Quito' in lista_ciudades" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "no hay la ciudad de Quito\n" + ] + } + ], + "source": [ + "if ('Quito' in lista_ciudades):\n", + " print(lista_ciudades.index('Quito'))\n", + "else:\n", + " print(\"no hay la ciudad de Quito\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#12) Eliminar un elemento de la lista\n", + "lista_ciudades.remove('Asuncion')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Lima',\n", + " 'Washington',\n", + " 'Managua',\n", + " 'Santiago de Chile',\n", + " 'Buenos Aires',\n", + " 'Montevideo',\n", + " 'Lima',\n", + " 'Paris',\n", + " 'Lima',\n", + " 'eliza',\n", + " ['celular', 'television', 'laptop']]" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lista_ciudades" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "list.remove(x): x not in list", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\HP SUPPORT\\Desktop\\Python-Prep\\04 - Estructuras de datos\\Prep_Course_Homework_04_Homework_Eliza.ipynb Cell 16'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39m#13) ¿Qué pasa si el elemento a eliminar no existe?\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m lista_ciudades\u001b[39m.\u001b[39;49mremove(\u001b[39m'\u001b[39;49m\u001b[39mflores\u001b[39;49m\u001b[39m'\u001b[39;49m)\n", + "\u001b[1;31mValueError\u001b[0m: list.remove(x): x not in list" + ] + } + ], + "source": [ + "#13) ¿Qué pasa si el elemento a eliminar no existe?\n", + "lista_ciudades.remove('flores')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fukushima\n" + ] + } + ], + "source": [ + "#14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo\n", + "a=lista_ciudades.pop()\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['television',\n", + " 'laptop',\n", + " 'islas malvinas',\n", + " 'chernobil',\n", + " 'celular',\n", + " 'Washington',\n", + " 'Santiago de Chile',\n", + " 'París',\n", + " 'Montevideo',\n", + " 'Managua',\n", + " 'Lima',\n", + " 'Buenos Aires']" + ] + }, + "execution_count": 159, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lista_ciudades.sort(reverse=True)\n", + "lista_ciudades" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Buenos Aires',\n", + " 'Lima',\n", + " 'Managua',\n", + " 'Montevideo',\n", + " 'París',\n", + " 'Santiago de Chile',\n", + " 'Washington',\n", + " 'celular',\n", + " 'chernobil',\n", + " 'islas malvinas',\n", + " 'laptop',\n", + " 'television']" + ] + }, + "execution_count": 161, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lista_ciudades.sort()\n", + "lista_ciudades" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Buenos Aires', 'Lima', 'Managua', 'Montevideo', 'París', 'Santiago de Chile', 'Washington', 'celular', 'chernobil', 'islas malvinas', 'laptop', 'television', 'Buenos Aires', 'Lima', 'Managua', 'Montevideo', 'París', 'Santiago de Chile', 'Washington', 'celular', 'chernobil', 'islas malvinas', 'laptop', 'television', 'Buenos Aires', 'Lima', 'Managua', 'Montevideo', 'París', 'Santiago de Chile', 'Washington', 'celular', 'chernobil', 'islas malvinas', 'laptop', 'television', 'Buenos Aires', 'Lima', 'Managua', 'Montevideo', 'París', 'Santiago de Chile', 'Washington', 'celular', 'chernobil', 'islas malvinas', 'laptop', 'television']\n" + ] + } + ], + "source": [ + "#15) Mostrar la lista multiplicada por 4\n", + "print(lista_ciudades*4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)" + ] + }, + "execution_count": 218, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#16) Crear una tupla que contenga los números enteros del 1 al 20\n", + "tupl=tuple(range(1,21))\n", + "tupl" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(11, 12, 13, 14, 15, 16)\n" + ] + } + ], + "source": [ + "#17) Imprimir desde el índice 10 al 15 de la tupla\n", + "print(tupl[10:16])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "False\n" + ] + } + ], + "source": [ + "#18) Evaluar si los números 20 y 30 están dentro de la tupla\n", + "print(20 in tupl)\n", + "print(30 in tupl)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "se agrego a la lista de ciudades Par\n" + ] + } + ], + "source": [ + "#19) Con la lista creada en el punto 1, validar la existencia del\n", + "# elemento 'París' y si no existe, agregarlo. Utilizar una variable e informar lo sucedido.\n", + "elemento = 'Par'\n", + "if (not(elemento in lista_ciudades)):\n", + " lista_ciudades.append(elemento)\n", + " print('se agrego a la lista de ciudades',elemento)\n", + "else:\n", + " print('No se agregó a la lista porq ',elemento,' ya existia')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Buenos Aires',\n", + " 'Lima',\n", + " 'Managua',\n", + " 'Montevideo',\n", + " 'París',\n", + " 'Santiago de Chile',\n", + " 'Washington',\n", + " 'celular',\n", + " 'chernobil',\n", + " 'islas malvinas',\n", + " 'laptop',\n", + " 'television',\n", + " 'París',\n", + " 'Pari',\n", + " 'Paris',\n", + " 'Par']" + ] + }, + "execution_count": 185, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lista_ciudades" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 186, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#sirve para cambiar de false a True o de True a False\n", + "not(True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "lista_ciudad['Paris']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "1\n" + ] + } + ], + "source": [ + "#20) Mostrar la cantidad de veces que se encuentra un elemento específico\n", + "# dentro de la tupla y de la lista\n", + "print(tupl.count(5))\n", + "print(lista_ciudades.count('Lima'))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 233, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]" + ] + }, + "execution_count": 233, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#21) Convertir la tupla en una lista\n", + "convertido_a_lista=list(tupl)\n", + "convertido_a_lista\n" + ] + }, + { + "cell_type": "code", + "execution_count": 243, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2 3\n" + ] + } + ], + "source": [ + "#22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables\n", + "var1, var2, var3 =tupl[:3]\n", + "print(var1, var2, var3)" + ] + }, + { + "cell_type": "code", + "execution_count": 246, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 2, 3, 4)" + ] + }, + "execution_count": 246, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tuuu=(1,2,3,4)\n", + "tuuu" + ] + }, + { + "cell_type": "code", + "execution_count": 257, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 257, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v1,v2,v3,_4=tuuu\n", + "v3\n" + ] + }, + { + "cell_type": "code", + "execution_count": 244, + "metadata": {}, + "outputs": [], + "source": [ + "var1, var2, var3, _4,_5,_6,_7,_8,_9,_10,_11,_12, _13, _14, _15, _16, _17, _18, _19, _20 = tupl" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)\n" + ] + } + ], + "source": [ + "print(tupl)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#23) Crear un diccionario utilizando la lista crada en el punto 1,\n", + "# asignandole la clave \"ciudad\". Agregar tambien otras claves, como puede ser \"Pais\" y \"Continente\".\n", + "diccionario1={'ciudad': ['Lima', 'Asuncion', 'Washington','Santiago de Chile','Buenos Aires','Montevideo'],\n", + " 'Pais': ['Perú','Paraguay','USA','Chile','Argentina','Uruguay'],\n", + " 'Continente':['America','Europa','Asia','Africa','Oceania','Antartida']}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ciudad': ['Lima',\n", + " 'Asuncion',\n", + " 'Washington',\n", + " 'Santiago de Chile',\n", + " 'Buenos Aires',\n", + " 'Montevideo'],\n", + " 'Pais': ['Perú', 'Paraguay', 'USA', 'Chile', 'Argentina', 'Uruguay'],\n", + " 'Continente': ['America', 'Europa', 'Asia', 'Africa', 'Oceania', 'Antartida']}" + ] + }, + "execution_count": 128, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "diccionario1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['ciudad', 'Pais', 'Continente'])" + ] + }, + "execution_count": 136, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#24) Imprimir las claves del diccionario\n", + "diccionario1.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Lima',\n", + " 'Asuncion',\n", + " 'Washington',\n", + " 'Santiago de Chile',\n", + " 'Buenos Aires',\n", + " 'Montevideo']" + ] + }, + "execution_count": 147, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#25) Imprimir las ciudades a través de su clave\n", + "diccionario1['ciudad']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Perú', 'Paraguay', 'USA', 'Chile', 'Argentina', 'Uruguay']" + ] + }, + "execution_count": 145, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "diccionario1['Pais']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['America', 'Europa', 'Asia', 'Africa', 'Oceania', 'Antartida']" + ] + }, + "execution_count": 146, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "diccionario1['Continente']" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "e371a547b05cc06fe9399c68d0811fab82050f0eaa2349dcabfd68d0d68f365a" + }, + "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 +} From 4882e89e20e050f9d6c665b6873c6e0e9dd549c8 Mon Sep 17 00:00:00 2001 From: elizabeth Date: Sun, 10 Apr 2022 16:38:09 -0500 Subject: [PATCH 5/7] 04_Estructura_Datos_Eliza --- .../Prep_Course_Homework_04_Clase.ipynb | 91 ++++++++++++------- 1 file changed, 58 insertions(+), 33 deletions(-) diff --git a/04 - Estructuras de datos/Prep_Course_Homework_04_Clase.ipynb b/04 - Estructuras de datos/Prep_Course_Homework_04_Clase.ipynb index 39af808ea..5daa13023 100644 --- a/04 - Estructuras de datos/Prep_Course_Homework_04_Clase.ipynb +++ b/04 - Estructuras de datos/Prep_Course_Homework_04_Clase.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 95, "metadata": {}, "outputs": [], "source": [ @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 96, "metadata": {}, "outputs": [ { @@ -21,7 +21,7 @@ "['azul', 'amarillo']" ] }, - "execution_count": 3, + "execution_count": 96, "metadata": {}, "output_type": "execute_result" } @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 97, "metadata": {}, "outputs": [ { @@ -41,7 +41,7 @@ "int" ] }, - "execution_count": 4, + "execution_count": 97, "metadata": {}, "output_type": "execute_result" } @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 98, "metadata": {}, "outputs": [ { @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 99, "metadata": {}, "outputs": [], "source": [ @@ -79,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 100, "metadata": {}, "outputs": [ { @@ -96,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 101, "metadata": {}, "outputs": [], "source": [ @@ -105,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 102, "metadata": {}, "outputs": [ { @@ -122,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 103, "metadata": {}, "outputs": [], "source": [ @@ -131,7 +131,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 104, "metadata": {}, "outputs": [ { @@ -148,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 105, "metadata": {}, "outputs": [ { @@ -157,7 +157,7 @@ "4" ] }, - "execution_count": 12, + "execution_count": 105, "metadata": {}, "output_type": "execute_result" } @@ -168,7 +168,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 106, "metadata": {}, "outputs": [ { @@ -187,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 107, "metadata": {}, "outputs": [ { @@ -204,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 108, "metadata": {}, "outputs": [], "source": [ @@ -213,7 +213,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 109, "metadata": {}, "outputs": [], "source": [ @@ -224,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 110, "metadata": {}, "outputs": [ { @@ -241,7 +241,7 @@ " 'blanco']" ] }, - "execution_count": 17, + "execution_count": 110, "metadata": {}, "output_type": "execute_result" } @@ -252,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 111, "metadata": {}, "outputs": [ { @@ -270,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 112, "metadata": {}, "outputs": [], "source": [ @@ -279,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 113, "metadata": {}, "outputs": [ { @@ -302,7 +302,7 @@ " 1.2]" ] }, - "execution_count": 20, + "execution_count": 113, "metadata": {}, "output_type": "execute_result" } @@ -313,7 +313,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 114, "metadata": {}, "outputs": [ { @@ -322,7 +322,7 @@ "['rojo', 'azul', 'amarillo']" ] }, - "execution_count": 21, + "execution_count": 114, "metadata": {}, "output_type": "execute_result" } @@ -334,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 115, "metadata": {}, "outputs": [ { @@ -343,7 +343,7 @@ "2" ] }, - "execution_count": 22, + "execution_count": 115, "metadata": {}, "output_type": "execute_result" } @@ -354,7 +354,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 116, "metadata": {}, "outputs": [ { @@ -861,10 +861,14 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "dict_keys(['Verduras', 'Especies', 'Arboles'])\n" + "ename": "NameError", + "evalue": "name 'mi_diccionario' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\HP SUPPORT\\Desktop\\Python-Prep\\04 - Estructuras de datos\\Prep_Course_Homework_04_Clase.ipynb Cell 53'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39m#Se puede acceder a las claves y a los valores del diccionario\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[39mprint\u001b[39m(mi_diccionario\u001b[39m.\u001b[39mkeys())\n", + "\u001b[1;31mNameError\u001b[0m: name 'mi_diccionario' is not defined" ] } ], @@ -892,6 +896,27 @@ "source": [ "mi_diccionario.values()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'mi_diccionario' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\HP SUPPORT\\Desktop\\Python-Prep\\04 - Estructuras de datos\\Prep_Course_Homework_04_Clase.ipynb Cell 55'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m mi_diccionario\u001b[39m.\u001b[39mkeys()\n", + "\u001b[1;31mNameError\u001b[0m: name 'mi_diccionario' is not defined" + ] + } + ], + "source": [ + "mi_diccionario.keys()" + ] } ], "metadata": { From a8d04ad6800f3e606383d3fbfa75ea964ee7cecf Mon Sep 17 00:00:00 2001 From: elizabeth Date: Sun, 17 Apr 2022 17:16:39 -0500 Subject: [PATCH 6/7] 05_Iteradores_e_iterables --- .../Prep_Course_Homework_05-Clase.ipynb | 398 ++++++++++ .../Prep_Course_Homework_05-Resuelto.ipynb | 2 +- .../Prep_Course_Homework_05_Eliza.ipynb | 723 ++++++++++++++++++ .../Prep_Course_Homework_06-Clase.ipynb | 404 ++++++++++ .../Prep_Course_Homework_06-Eliza.ipynb | 435 +++++++++++ .../Prep_Course_Homework_06-Resuelto.ipynb | 10 +- .../Prep_Course_Homework_07-Resuelto.ipynb | 36 +- .../Prep_Course_Homework_08-Resuelto.ipynb | 7 + 8 files changed, 2004 insertions(+), 11 deletions(-) create mode 100644 05 - Iteradores e Iterables/Prep_Course_Homework_05-Clase.ipynb create mode 100644 05 - Iteradores e Iterables/Prep_Course_Homework_05_Eliza.ipynb create mode 100644 06 - Funciones/Prep_Course_Homework_06-Clase.ipynb create mode 100644 06 - Funciones/Prep_Course_Homework_06-Eliza.ipynb diff --git a/05 - Iteradores e Iterables/Prep_Course_Homework_05-Clase.ipynb b/05 - Iteradores e Iterables/Prep_Course_Homework_05-Clase.ipynb new file mode 100644 index 000000000..88723c9a8 --- /dev/null +++ b/05 - Iteradores e Iterables/Prep_Course_Homework_05-Clase.ipynb @@ -0,0 +1,398 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "4\n", + "9\n", + "2\n" + ] + } + ], + "source": [ + "#ITERADORES E ITERABLES\n", + "lista = [5,4,9,2]\n", + "i = 0\n", + "while i < len(lista):\n", + " elemento = lista[i]\n", + " print(elemento)\n", + " i += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "lista = [5,4,9,2]\n", + "for elemento in lista\n", + " print(elemento)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "4\n", + "9\n", + "2\n" + ] + } + ], + "source": [ + "lista = [5,4,9,2]\n", + "for elemento in lista:\n", + " print(elemento)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "H\n", + "o\n", + "l\n", + "a\n" + ] + } + ], + "source": [ + "cadena = 'Hola'\n", + "for c in cadena:\n", + " print(c)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['h', 'o', 'l', 'a']\n" + ] + } + ], + "source": [ + "print(list(\"hola\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + } + ], + "source": [ + "print(sum([1,2,3]))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "H-o-l-a\n" + ] + } + ], + "source": [ + "print(\"-\".join(\"Hola\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pais\n", + "continente\n", + "ciudad\n" + ] + } + ], + "source": [ + "#Iteración sobre un diccionario\n", + "mi_dict = {'pais':['peru','uruguay','bolivia'],\n", + " 'continente':['america','asia','africa'],\n", + " 'ciudad':['lima','quito','asuncion']}\n", + "for i in mi_dict:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pagina1\n" + ] + } + ], + "source": [ + "libro = ['pagina1','pagina2','pagina3','pagina4']\n", + "marcapaginas = iter(libro)\n", + "print(next(marcapaginas))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lis1 = ['grace','eliza','celeste','franco']\n", + "lis2 = ['peru','chile','brasil','argentina']" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(1, 'Uno'), (2, 'Dos')]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#ITERADORES: ZIP\n", + "a = [1, 2]\n", + "b = [\"Uno\", \"Dos\"]\n", + "c = zip(a,b)\n", + "type(c)\n", + "zip\n", + "list(c)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['r', 'r', 'r', 'r']\n" + ] + } + ], + "source": [ + "#Añadiendo condicionales\n", + "frase = \"El perro de san roque no tiene rabo\"\n", + "erres = [i for i in frase if i == 'r']\n", + "print(erres)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + } + ], + "source": [ + "print(len(erres))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'pais': ['peru', 'uruguay', 'bolivia'],\n", + " 'continente': ['america', 'asia', 'africa'],\n", + " 'ciudad': ['lima', 'quito', 'asuncion']}" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'pais': ['peru', 'uruguay', 'bolivia'],\n", + " 'continente': ['america', 'asia', 'africa', 'Europa', 'Europa'],\n", + " 'ciudad': ['lima', 'quito', 'asuncion']}" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_dict['continente'].append('Europa')\n", + "mi_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['pais', 'continente', 'ciudad'])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_dict.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'pais': ['peru', 'uruguay', 'bolivia'],\n", + " 'continente': ['america', 'asia', 'africa', 'Europa', 'Europa'],\n", + " 'ciudad': ['lima', 'quito', 'asuncion'],\n", + " 'ejemplo': [10, 10, 10, 10]}" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_dict['ejemplo'] = [10,10,10,10]\n", + "mi_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'pais': ['peru', 'uruguay', 'bolivia'],\n", + " 'continente': ['america', 'asia', 'africa', 'Europa', 'Europa'],\n", + " 'ciudad': ['lima', 'quito', 'asuncion'],\n", + " 'ejemplo': [10, 10, 10, 10],\n", + " 'Habitantes': [100, 1001, 100, 100, 100]}" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mi_dict['Habitantes'] = [100,1001,100,100,100]\n", + "mi_dict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#ITERADORES: ES for, iter, next y todo eso" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "e371a547b05cc06fe9399c68d0811fab82050f0eaa2349dcabfd68d0d68f365a" + }, + "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/05 - Iteradores e Iterables/Prep_Course_Homework_05-Resuelto.ipynb b/05 - Iteradores e Iterables/Prep_Course_Homework_05-Resuelto.ipynb index 79e75fd6c..aa4868477 100644 --- a/05 - Iteradores e Iterables/Prep_Course_Homework_05-Resuelto.ipynb +++ b/05 - Iteradores e Iterables/Prep_Course_Homework_05-Resuelto.ipynb @@ -234,7 +234,7 @@ "fibo = [0,1]\n", "n = 2\n", "while(n < 30):\n", - " fibo.append(fibo[n-1]+fibo[n-2])\n", + " fibo.append(fibo[n-1]+fibo[n-2])# 0, 1, 1+0=1, 2+1=3, 3+2=5, 4+3=8\n", " n += 1\n", "print(fibo)" ] diff --git a/05 - Iteradores e Iterables/Prep_Course_Homework_05_Eliza.ipynb b/05 - Iteradores e Iterables/Prep_Course_Homework_05_Eliza.ipynb new file mode 100644 index 000000000..0616a3aaf --- /dev/null +++ b/05 - Iteradores e Iterables/Prep_Course_Homework_05_Eliza.ipynb @@ -0,0 +1,723 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "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": [ + "## Iteradores e iterables\n", + "\n", + "#1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1\n", + "\n", + "lista = []\n", + "i = -15\n", + "while (i < 0):\n", + " lista.append(i)\n", + " i += 1\n", + "print(lista)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-14\n", + "-12\n", + "-10\n", + "-8\n", + "-6\n", + "-4\n", + "-2\n" + ] + } + ], + "source": [ + "#2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares?\n", + "n=0\n", + "while (n < len(lista)):\n", + " if (lista[n]%2)==0:\n", + " print(lista[n])\n", + " n+=1\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-14\n", + "-12\n", + "-10\n", + "-8\n", + "-6\n", + "-4\n", + "-2\n" + ] + } + ], + "source": [ + "#3) Resolver el punto anterior sin utilizar un ciclo while\n", + "for elemento in lista:\n", + " if(elemento % 2 == 0):\n", + " print(elemento)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-15\n", + "-14\n", + "-13\n" + ] + } + ], + "source": [ + "#4) Utilizar el iterable para recorrer sólo los primeros 3 elementos\n", + "\n", + "for elemento in lista[0:3]:\n", + " print(lista[elemento])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 -15\n", + "1 -14\n", + "2 -13\n", + "3 -12\n", + "4 -11\n", + "5 -10\n", + "6 -9\n", + "7 -8\n", + "8 -7\n", + "9 -6\n", + "10 -5\n", + "11 -4\n", + "12 -3\n", + "13 -2\n", + "14 -1\n" + ] + } + ], + "source": [ + "#5) Utilizar la función **enumerate** para obtener dentro del iterable,\n", + "# tambien el índice al que corresponde el elemento\n", + "for i, e in enumerate(lista):\n", + " print(i,e)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'lista = [1,2,5,7,8,10,13,14,15,17,20]\\n\\nfor n in lista:\\n if not(n in lista):\\n lista.insert(n-1,n)\\nprint(lista)'" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#6) Dada la siguiente lista de números enteros entre 1 y 20, \n", + "# crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20]\n", + "\"\"\"lista = [1,2,5,7,8,10,13,14,15,17,20]\n", + "\n", + "for n in lista:\n", + " if not(n in lista):\n", + " lista.insert(n-1,n)\n", + "print(lista)\"\"\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n" + ] + } + ], + "source": [ + "lista = [1,2,5,7,8,10,13,14,15,17,20]\n", + "for i in range(1, lista[len(lista)-1]):\n", + " if(i in lista):\n", + " continue\n", + " else:\n", + " lista.append(i)\n", + "lista.sort()\n", + "print(lista)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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": [ + "#7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
\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.
\n", + "fibo = [0,1]\n", + "n = 2\n", + "while n < 30:\n", + " fibo.append(fibo[n-1]+fibo[n-2])\n", + " n+=1\n", + "print(fibo)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'fibonacci = []\\nfor i in range(0,30):\\n if(i==0 or i==1):\\n fibonacci.append[i]\\n else:\\n fibonacci.append(fibonacci[i-1]+fibonacci[(i-2)])\\nprint(fibonacci)'" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"fibonacci = []\n", + "for i in range(0,30):\n", + " if(i==0 or i==1):\n", + " fibonacci.append[i]\n", + " else:\n", + " fibonacci.append(fibonacci[i-1]+fibonacci[(i-2)])\n", + "print(fibonacci)\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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", + "1346268\n" + ] + } + ], + "source": [ + "#8) Realizar la suma de todos elementos de la lista del punto anterior\n", + "fibo = [0,1]\n", + "n = 2\n", + "suma = 0\n", + "while n < 30:\n", + " fibo.append(fibo[n-1]+fibo[n-2])\n", + " n+=1\n", + " # suma = suma + fibo\n", + "print(fibo)\n", + "print(sum(fibo))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "1.6176470588235294\n", + "1.6181818181818182\n", + "1.6179775280898876\n", + "1.6180555555555556\n", + "1.6180257510729614\n" + ] + } + ], + "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.\n", + "# El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, \n", + "# 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
\n", + "\n", + "primeros = 15\n", + "n = primeros - 5\n", + "print(n)\n", + "while(n < primeros):\n", + " print(fibo[n]/fibo[n-1])\n", + " n+=1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7 n\n", + "21 n\n", + "39 n\n", + "60 n\n", + "67 n\n" + ] + } + ], + "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'\n", + "cadena = 'Hola Mundo. Esto es una practica del lenguaje de programacion Python'\n", + "for i,c in enumerate(cadena):\n", + " if(c=='n'):\n", + " print(i,c)\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "songs\n", + "singers\n", + "movies\n" + ] + } + ], + "source": [ + "# 11) Crear un diccionario e imprimir sus claves utilizando un iterador\n", + "diccionario = {'songs':['rigth_now','scandal_of_grace','escape_my_mind','cosmic_dancer'],\n", + " 'singers':['grace','tasha','haile','billie'],\n", + " 'movies':['bumblebee','tomorrowland','transformer','alice_and_wonderland']}\n", + "\n", + "for i in diccionario:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['H', 'o', 'l', 'a', ' ', 'M', 'u', 'n', 'd', 'o', '.', ' ', 'E', 's', 't', 'o', ' ', 'e', 's', ' ', 'u', 'n', 'a', ' ', 'p', 'r', 'a', 'c', 't', 'i', 'c', 'a', ' ', 'd', 'e', 'l', ' ', 'l', 'e', 'n', 'g', 'u', 'a', 'j', 'e', ' ', 'd', 'e', ' ', 'p', 'r', 'o', 'g', 'r', 'a', 'm', 'a', 'c', 'i', 'o', 'n', ' ', 'P', 'y', 't', 'h', 'o', 'n']\n" + ] + } + ], + "source": [ + "# 12) Convertir en una lista la variable \"cadena\" del punto 10 y luego recorrerla con un iterador \n", + "cadena = 'Hola Mundo. Esto es una practica del lenguaje de programacion Python'\n", + "cadena=list(cadena)\n", + "print(cadena)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "recorre = iter(cadena)\n", + "print(recorre)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "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", + "o\n", + "n\n", + " \n", + "P\n", + "y\n", + "t\n", + "h\n", + "o\n", + "n\n" + ] + } + ], + "source": [ + "recorre = iter(cadena)\n", + "largo = len(cadena)\n", + "for i in range(0, largo):\n", + " print(next(recorre))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "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", + "o\n", + "n\n", + " \n", + "P\n", + "y\n", + "t\n", + "h\n", + "o\n", + "n\n" + ] + } + ], + "source": [ + "#mi manera\n", + "for i in cadena:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('Paulina', 'mama'),\n", + " ('Armando', 'mayor'),\n", + " ('Kely', 'hermana'),\n", + " ('Franco', 'hermano'),\n", + " ('Elizabeth', 'yo')]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 13) Crear dos listas y unirlas en una tupla utilizando la función zip\n", + "a = ['Paulina','Armando','Kely','Franco','Elizabeth']\n", + "b = ['mama','mayor','hermana', 'hermano', 'yo']\n", + "c = zip(a, b)\n", + "type(c)\n", + "list(c)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[21, 35, 42, 56, 63, 84, 91]\n" + ] + } + ], + "source": [ + "\n", + "# 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", + "lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100]\n", + "n_lis = []\n", + "for i, e in enumerate(lis):\n", + " if (e % 7 == 0):\n", + " n_lis.append(e)\n", + "print(n_lis)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "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", + "nueva_lista = [i for i in lis if i % 7 == 0] \n", + "print(nueva_lista)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12\n" + ] + } + ], + "source": [ + "# 15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene,\n", + "# 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", + "lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']]\n", + "\n", + "cantidad = 0\n", + "for e in lis:\n", + " if (type(e) == list):\n", + " cantidad += len(e)\n", + " else:\n", + " cantidad+=1\n", + "\n", + "print(cantidad)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1, 2, 3, 4], ['rojo'], ['verde'], [True, False, False], ['uno', 'dos', 'tres']]\n" + ] + } + ], + "source": [ + "# 16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es\n", + "for i,e in enumerate(lis):\n", + " if (type(e) != list):\n", + " lis[i]=[e]\n", + "print(lis)\n", + " \n" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "e371a547b05cc06fe9399c68d0811fab82050f0eaa2349dcabfd68d0d68f365a" + }, + "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/Prep_Course_Homework_06-Clase.ipynb b/06 - Funciones/Prep_Course_Homework_06-Clase.ipynb new file mode 100644 index 000000000..1f8c837af --- /dev/null +++ b/06 - Funciones/Prep_Course_Homework_06-Clase.ipynb @@ -0,0 +1,404 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10.0\n" + ] + } + ], + "source": [ + "#FUNCIONES\n", + "\n", + "def dividir(dividiendo, divisor = 1):\n", + " if (divisor == 0):\n", + " return 'No se puede dividir por cero'\n", + " else:\n", + " return dividiendo / divisor\n", + "print(dividir(10))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0\n", + "5\n" + ] + } + ], + "source": [ + "divisor = 5\n", + "def dividir(dividiendo):\n", + " if (divisor == 0):\n", + " return 'No se puede dividir por cero'\n", + " else:\n", + " return dividiendo / divisor\n", + "print(dividir(10))\n", + "print(divisor)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10.0\n", + "5\n" + ] + } + ], + "source": [ + "divisor = 5\n", + "def dividir(dividiendo, divisor = 1):\n", + " if (divisor == 0):\n", + " return 'No se puede dividir por cero'\n", + " else:\n", + " return dividiendo / divisor\n", + "print(dividir(10))\n", + "print(divisor)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "120" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Recursividad\n", + "def factorial(numero):\n", + " '''\n", + " Devuelve el factorial\n", + " '''\n", + " if (numero > 1):\n", + " numero = numero * factorial(numero - 1)\n", + " return numero\n", + "factorial(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "help(factorial)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], + "source": [ + "#Pasaje de parametros por valor\n", + "x = 10\n", + "def funcion(entrada):\n", + " entrada = 0\n", + "funcion(x)\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[10, 20, 30, 40]\n" + ] + } + ], + "source": [ + "#Pasaje de parametros por referencia\n", + "x = [10, 20, 30]\n", + "def funcion(entrada):\n", + " entrada.append(40)\n", + "funcion(x)\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2782447862288\n" + ] + } + ], + "source": [ + "#Pasaje de parametro por referencia\n", + "#funcion \"id\" devuelve un identificador unico para casa objeto\n", + "x = 10\n", + "print(id(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2782447861968\n" + ] + } + ], + "source": [ + "def funcion(entrada):\n", + " entrada = 0\n", + " print(id(entrada))\n", + "funcion(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], + "source": [ + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2782556729984\n" + ] + } + ], + "source": [ + "#ejemplo siguiente del mismo\n", + "x = [10, 20, 30]\n", + "print(id(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2782556729984\n" + ] + } + ], + "source": [ + "def funcion(entrada):\n", + " entrada.append(40)\n", + " print(id(entrada))\n", + "funcion(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[10, 20, 30, 40]\n" + ] + } + ], + "source": [ + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "#se crea la variable x con el valor 1\n", + "x = 1\n", + "#se asigna x a la variable y\n", + "y = x\n", + "#se modifica la variable y asigna\n", + "y = 2\n", + "#¿Qué valor ahora tienen ambas?\n", + "print(x)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3]\n" + ] + } + ], + "source": [ + "#se crea la variable x con la lista [1,2]\n", + "x =[1, 2]\n", + "#se asigna x a la variable y\n", + "y = x\n", + "#se modifica la variable y agregando un elemento\n", + "y.append(3)\n", + "#¿que valores ahora tiene ambas?\n", + "print(x)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3]\n" + ] + } + ], + "source": [ + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "16" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Funciones lambda: es un aforma de crera una funcion en una sola linea\n", + "#pueden tener cantidad de argumento, pero solo una expresion\n", + "#no necesitan un return\n", + "#muy comodas para crear funciones rapido\n", + "lambda_producto = lambda x, y: y * y\n", + "lambda_producto(3, 4)\n" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "e371a547b05cc06fe9399c68d0811fab82050f0eaa2349dcabfd68d0d68f365a" + }, + "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/Prep_Course_Homework_06-Eliza.ipynb b/06 - Funciones/Prep_Course_Homework_06-Eliza.ipynb new file mode 100644 index 000000000..497e50856 --- /dev/null +++ b/06 - Funciones/Prep_Course_Homework_06-Eliza.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "## Funciones\n", + "\n", + "#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\n", + "def verifica_primo(nro):#nro = 5\n", + " es_primo = True\n", + " if nro <=1:\n", + " es_primo = False\n", + " for i in range (2, nro):#i=2,3,4\n", + " if nro % i == 0:#5%2=1, 5%3=2,5%4=1 #eentonces como i solo va iterar hasta 4 y como todo salio else y ya no\n", + " es_primo = False #volver al for entonces va tener q retorner co el utlimo valor q tomo es primo = true\n", + " break \n", + " return es_primo\n", + "nro = int(input('Ingrese un numero: '))\n", + "print(verifica_primo(nro))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "#2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números\n", + "# y devuelva sólo aquellos que son primos en otra lista\n", + "\n", + "def extrae_primo_de_lista(lista):\n", + " lista_primos = []\n", + " for elemento in lista:\n", + " if verifica_primo(int(elemento)):\n", + " lista_primos.append(elemento)\n", + " return lista_primos\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 3, 5, 7, 11, 13, 17, 19]" + ] + }, + "execution_count": 38, + "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", + "lis_primos = extrae_primo_de_lista(lis_completa)\n", + "lis_primos" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5, 3)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "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.\n", + "# Si hay más de un \"más repetido\", que devuelva cualquiera\n", + "lista = [5, 2, 5, 3, 5, 1, 4, 4, 6, 3]\n", + "#indi = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "\"\"\"\n", + "lista_unicos = [5, 2, 5, 3, 5, 1, 4, 4, 6, 3]\n", + "lista_repeticiones = []\n", + "\"\"\"\n", + "#Para lograr esto existen muchas alternativas, una de ellas es hacerlo mediante dos listas.\n", + "def valor_modal(lista):\n", + " #Creamos una lista para guardar los elementos repetidos.\n", + " lista_unicos = []\n", + " #lista para guardar la cantidad de veces que se repite ese elmento.\n", + " lista_repeticiones = []\n", + " #Si la lista que forma parte del argumento no tiene valores, la funcion no devuelve nada.\n", + " if len(lista) == 0:\n", + " return print(None)\n", + " #Vamos a recorrer cada elemento de la lista que forma parte del argumento.\n", + " for elemento in lista:\n", + " if (elemento in lista_unicos):\n", + " i = lista_unicos.index(elemento) #Si el elemento se encuentra en la lista_unicos, vamos a igualar una variable i a su indice.\n", + " lista_repeticiones[i] += 1 #A ese indice i de la lista_repeticiones. Le vamos a sumar uno porque siginifica que valor ya esta.\n", + " else:\n", + " lista_unicos.append(elemento) #Si el elemento no esta en la lista_unicos, lo agrego. Esta es la condicion que corre al principio.\n", + " lista_repeticiones.append(1) #Además de agregar el elemento a la otra lista, agrego el valor 1 a la lista_repeticiones.\n", + "#lista = [5, 2, 5, 3, 5, 1, 4, 4, 6, 3]\n", + "#lista_unicos = [5,2,3,1,4,6,3]\n", + "#lista_repeticiones = [3,1,1,1,2,1,1]\n", + " moda = lista_unicos[0] #Creamos la variable moda para utilizarla en un bucle, la iniciamos con el valor del primer indice de lista_unicos.\n", + " maximo = lista_repeticiones[0] #Creamos la variable maximo y la inicamos con el valor del primer indice de la lista_repeticiones\n", + " for i, elemento in enumerate(lista_unicos): #con enumerate y dos variables en el for recorremos los indices y sus valores.\n", + " if lista_repeticiones[i] > maximo: #i toma valores numericos, por lo que verfico si el valor guardado en [i] es mayor a máximo.\n", + " moda = lista_unicos[i] # Si lo anterior se cumple, asigno el valor del [i] de cada lista para moda y máximo.\n", + " maximo = lista_repeticiones[i]\n", + " return moda, maximo #Una vez que el bucle termine tendre el valor maximo de repeticiones junto al valor modal.\n", + "valor_modal(lista)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4, 5)\n" + ] + } + ], + "source": [ + "#Sin bucle for al final\n", + "def valores_repetidos(lista):\n", + " lista_unicos=[]\n", + " lista_repeticiones=[]\n", + " for c in lista:\n", + " if(not(c in lista_unicos)):\n", + " lista_unicos.append(c)\n", + " lista_repeticiones.append(1)\n", + " else:\n", + " i = lista_unicos.index(c)\n", + " lista_repeticiones[i] += 1\n", + " repeticiones = max(lista_repeticiones)\n", + " moda=lista_unicos[lista_repeticiones.index(repeticiones)]\n", + " return moda, repeticiones\n", + "\n", + "lista_prueba = [1,1,2,3,4,4,4,4,4,1,2,2,5,2,6,1]\n", + "print(valores_repetidos(lista_prueba))" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "([1, 8, 9], 3)\n" + ] + } + ], + "source": [ + "#Para varios valores repetidos\n", + "\n", + "def valores_repetidos(lista):\n", + " lista_unicos=[]\n", + " lista_repeticiones=[]\n", + " for c in lista:\n", + " if(not(c in lista_unicos)):\n", + " lista_unicos.append(c)\n", + " #lista_unicos = [1,5,6,7,8,9]\n", + " lista_repeticiones.append(1)\n", + " #lista_repeticiones = [3,1,1,1,3,3]\n", + " else:\n", + " i=lista_unicos.index(c)#0,\n", + " lista_repeticiones[i]+=1\n", + " repeticiones = max(lista_repeticiones)\n", + " moda=[]\n", + " for i, c in enumerate(lista_repeticiones):\n", + " if(c==repeticiones):\n", + " moda.append(lista_unicos[i])\n", + " return moda, repeticiones\n", + "\n", + "lista2=[1,1,1,5,6,7,8,8,8,9,9,9]\n", + "print(valores_repetidos(lista2))" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "([1, 8, 9], 3)\n" + ] + } + ], + "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.\n", + "\n", + "#Para devolver el menor valor repetido\n", + "\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)):\n", + " lista_unicos.append(c)\n", + " #lista_unicos = [1,5,6,7,8,9]\n", + " lista_repeticiones.append(1)\n", + " #lista_repeticiones = [3,1,1,1,3,3]\n", + " else:\n", + " i=lista_unicos.index(c)#0,\n", + " lista_repeticiones[i]+=1\n", + " repeticiones = max(lista_repeticiones)\n", + " moda=[]\n", + "\n", + " for i, c in enumerate(lista_repeticiones):\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", + " 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))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "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": 67, + "metadata": {}, + "outputs": [], + "source": [ + "def conversion_grados2(valor, origen, destino):\n", + " #Operacines de conversion\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 asignacion \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", + " #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", + " #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 pramatros correctos')\n", + "\n", + " return valor_destino\n" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "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: -55.8\n", + "1 grado Farenheit a Kelvin: 217.34999999999997\n", + "1 grado Farenheit a Farenheit: 1\n" + ] + } + ], + "source": [ + "print('1 grado Celsius a Celsius:', conversion_grados2(1, 'c', 'c'))\n", + "print('1 grado Celsius a Kelvin:', conversion_grados2(1, 'c', 'k'))\n", + "print('1 grado Celsius a Farenheit:', conversion_grados2(1, 'c', 'f'))\n", + "print('1 grado Kelvin a Celsius:', conversion_grados2(1, 'k', 'c'))\n", + "print('1 grado Kelvin a Kelvin:', conversion_grados2(1, 'k', 'k'))\n", + "print('1 grado Kelvin a Farenheit:', conversion_grados2(1, 'k', 'f'))\n", + "print('1 grado Farenheit a Celsius:', conversion_grados2(1, 'f', 'c'))\n", + "print('1 grado Farenheit a Kelvin:', conversion_grados2(1, 'f', 'k'))\n", + "print('1 grado Farenheit a Farenheit:', conversion_grados2(1, 'f', 'f'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#6) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, \n", + "# hacer un print para cada combinación de los mismos:" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 grado c a c : 1\n", + "1 grado c a f : 33.8\n", + "1 grado c a k : 274.15\n", + "1 grado f a c : -55.8\n", + "1 grado f a f : 1\n", + "1 grado f a k : 217.34999999999997\n", + "1 grado k a c : -272.15\n", + "1 grado k a f : -457.87\n", + "1 grado k a k : 1\n" + ] + } + ], + "source": [ + "metricas = ['c','f','k']\n", + "for i in range (0,3):\n", + " for j in range (0,3):\n", + " print('1 grado',metricas[i], 'a', metricas[j],':', conversion_grados2(1,metricas[i], metricas[j]))" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n", + "Debe ingresar un numero positivo\n", + "Debe ingresar un numero entero\n", + "Debe ingresar un numero entero\n" + ] + } + ], + "source": [ + "#7) Armar una función que devuelva el factorial de un número.\n", + "# Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero \n", + "# o negativo\n", + "\n", + "def factorial(numero):\n", + " if(type(numero) != int):\n", + " return \"Debe ingresar un numero entero\"\n", + " if(numero < 0):\n", + " return \"Debe ingresar un numero positivo\"\n", + " if(numero > 1):\n", + " numero = numero*factorial(numero - 1)\n", + " return numero\n", + "\n", + "print(factorial(3))\n", + "print(factorial(-2))\n", + "print(factorial(1.23))\n", + "print(factorial('7'))" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "e371a547b05cc06fe9399c68d0811fab82050f0eaa2349dcabfd68d0d68f365a" + }, + "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/Prep_Course_Homework_06-Resuelto.ipynb b/06 - Funciones/Prep_Course_Homework_06-Resuelto.ipynb index 9e00f9705..e6384ac69 100644 --- a/06 - Funciones/Prep_Course_Homework_06-Resuelto.ipynb +++ b/06 - Funciones/Prep_Course_Homework_06-Resuelto.ipynb @@ -81,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -108,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -120,8 +120,8 @@ } ], "source": [ - "lis = [1,1,5,6,8,10,22,5,6,4,11,9,5]\n", - "moda, repite = valor_modal(lis)\n", + "lista = [1,1,5,6,8,10,22,5,6,4,11,9,5]\n", + "moda, repite = valor_modal(lista)\n", "print('El valor modal es', moda, 'y se repite', repite, 'veces.')" ] }, @@ -381,7 +381,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.4" } }, "nbformat": 4, diff --git a/07 - Classes & OOP/Prep_Course_Homework_07-Resuelto.ipynb b/07 - Classes & OOP/Prep_Course_Homework_07-Resuelto.ipynb index 2f184c853..795596ef2 100644 --- a/07 - Classes & OOP/Prep_Course_Homework_07-Resuelto.ipynb +++ b/07 - Classes & OOP/Prep_Course_Homework_07-Resuelto.ipynb @@ -19,15 +19,38 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\n def acelerar(self, velocidad):\\n int(velocidad)\\n velocidad += 1\\n return velocidad\\n\\ncorsa = Vehiculo('Gris','Auto',1.4)\\nfocus = Vehiculo('Azul','Auto',2.0)\\n\\nprint(focus.acelerar(21))\\nprint(corsa.color) \"" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "class Vehiculo:\n", " def __init__(self, color, tipo, cilindrada):\n", " self.color = color\n", " self.tipo = tipo\n", - " self.cilindrada = cilindrada" + " self.cilindrada = cilindrada\n", + " self.velocidad = 0\n", + "\"\"\"\n", + " def acelerar(self, velocidad):\n", + " int(velocidad)\n", + " velocidad += 1\n", + " return velocidad\n", + "\n", + "corsa = Vehiculo('Gris','Auto',1.4)\n", + "focus = Vehiculo('Azul','Auto',2.0)\n", + "\n", + "print(focus.acelerar(21))\n", + "print(corsa.color) \"\"\"" ] }, { @@ -199,7 +222,10 @@ " es_primo = False\n", " break\n", " return es_primo\n", - "\n", + " \"\"\"\n", + "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') \"\"\"\n", " def valor_modal(self, lista, menor):\n", " lista_unicos = []\n", " lista_repeticiones = []\n", @@ -655,7 +681,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.4" } }, "nbformat": 4, diff --git a/08 - Error Handling/Prep_Course_Homework_08-Resuelto.ipynb b/08 - Error Handling/Prep_Course_Homework_08-Resuelto.ipynb index ef2da854f..9b7af5eea 100644 --- a/08 - Error Handling/Prep_Course_Homework_08-Resuelto.ipynb +++ b/08 - Error Handling/Prep_Course_Homework_08-Resuelto.ipynb @@ -425,6 +425,13 @@ "8) Agregar casos de pruebas para el método factorial()" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 20, From c2ad91c919a18b69ad5564858835472ee3c45b02 Mon Sep 17 00:00:00 2001 From: elizabeth Date: Mon, 18 Apr 2022 15:11:53 -0500 Subject: [PATCH 7/7] Eliza-Repaso --- 08 - Error Handling/Eliza.ipynb | 209 +++++++++++++++++++++ 08 - Error Handling/checkpoint.py | 40 +++- 08 - Error Handling/checkpoint_Resuelto.py | 3 +- 3 files changed, 248 insertions(+), 4 deletions(-) create mode 100644 08 - Error Handling/Eliza.ipynb diff --git a/08 - Error Handling/Eliza.ipynb b/08 - Error Handling/Eliza.ipynb new file mode 100644 index 000000000..b2eb28a06 --- /dev/null +++ b/08 - Error Handling/Eliza.ipynb @@ -0,0 +1,209 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "def Factorial(numero):\n", + " '''\n", + " 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\n", + " '''\n", + " #Tu código aca:\n", + " if (type(numero) != int):\n", + " return print(None)\n", + " if (numero < 1):\n", + " return None\n", + " factorial = 1\n", + " while(numero > 1):\n", + " factorial = factorial * numero\n", + " numero -= 1\n", + " return factorial" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "120\n" + ] + } + ], + "source": [ + "respuesta=Factorial(5)\n", + "print(respuesta)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "def EsPrimo(valor):\n", + " '''\n", + " Esta función devuelve el valor booleano True si el número reibido como parámetro es primo, de lo \n", + " contrario devuelve False..\n", + " En caso de que el parámetro no sea de tipo entero debe retornar nulo.\n", + " Recibe un argumento:\n", + " valor: Será el número a evaluar\n", + " Ej:\n", + " EsPrimo(7) debe retornar True\n", + " EsPrimo(8) debe retornar False\n", + " '''\n", + " #Tu código aca:\n", + " if (type(valor != int)):\n", + " return None\n", + " for i in range(2, (int(valor/2)+1)):\n", + " if valor % i == 0:\n", + " return False\n", + " return True" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "rprimo=EsPrimo(5)\n", + "print(rprimo)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [], + "source": [ + "def EsPrimo(valor):\n", + " '''\n", + " Esta función devuelve el valor booleano True si el número reibido como parámetro es primo, de lo \n", + " contrario devuelve False..\n", + " En caso de que el parámetro no sea de tipo entero debe retornar nulo.\n", + " Recibe un argumento:\n", + " valor: Será el número a evaluar\n", + " Ej:\n", + " EsPrimo(7) debe retornar True\n", + " EsPrimo(8) debe retornar False\n", + " '''\n", + " #Tu código aca:\n", + " if (type(valor) != int):\n", + " return None\n", + " for i in range(2, (int(valor / 2) + 1)):\n", + " if valor % i == 0:\n", + " return False\n", + " return True" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "r=EsPrimo(5)\n", + "print(r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def ClaseAnimal(especie, color):\n", + " '''\n", + " Esta función devuelve un objeto instanciado de la clase Animal, \n", + " la cual debe tener los siguientes atributos:\n", + " Edad (Un valor de tipo de dato entero, que debe inicializarse en cero)\n", + " Especie (Un valor de tipo de dato string)\n", + " Color (Un valor de tipo de dato string)\n", + " y debe tener el siguiente método:\n", + " CumplirAnios (este método debe sumar uno al atributo Edad y debe devolver ese valor)\n", + " Recibe dos argumento:\n", + " especie: Dato que se asignará al atributo Especie del objeto de la clase Animal\n", + " color: Dato que se asignará al atributo Color del objeto de la clase Animal\n", + " Ej:\n", + " a = ClaseAnimal('perro','blanco')\n", + " a.CumpliAnios() -> debe devolver 1\n", + " a.CumpliAnios() -> debe devolver 2\n", + " a.CumpliAnios() -> debe devolver 3\n", + " '''\n", + " #Tu código aca:\n", + " class Animal:\n", + " def __init__(self, especie, color):\n", + " self.especie = especie\n", + " self.color = color\n", + " self.edad = 0\n", + " def CumplirAnios(self):\n", + " self.edad +=1\n", + " return self.edad\n", + " return especie, color\n", + "\n", + " a = Animal(especie, color) \n", + " return a" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "e371a547b05cc06fe9399c68d0811fab82050f0eaa2349dcabfd68d0d68f365a" + }, + "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/08 - Error Handling/checkpoint.py b/08 - Error Handling/checkpoint.py index 71eb47fe4..fe51e3673 100644 --- a/08 - Error Handling/checkpoint.py +++ b/08 - Error Handling/checkpoint.py @@ -1,6 +1,8 @@ # 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 Factorial(numero): ''' Esta función devuelve el factorial del número pasado como parámetro. @@ -12,7 +14,17 @@ def Factorial(numero): Factorial(-2) debe retornar nulo ''' #Tu código aca: - return 'Funcion incompleta' + if (type(numero) != int): + return None + if (numero < 1): + return None + factorial = 1 + while(numero > 1): + factorial = factorial * numero + numero -= 1 + return factorial +respuesta=Factorial(-9) +print(respuesta) def EsPrimo(valor): ''' @@ -26,7 +38,14 @@ def EsPrimo(valor): EsPrimo(8) debe retornar False ''' #Tu código aca: - return 'Funcion incompleta' + if (type(valor) != int): + return None + for i in range(2, (int(valor / 2) + 1)): + if valor % i == 0: + return False + return True +rprimo=EsPrimo(5) +print(rprimo) def ClaseAnimal(especie, color): ''' @@ -47,4 +66,19 @@ def ClaseAnimal(especie, color): a.CumpliAnios() -> debe devolver 3 ''' #Tu código aca: - return 'Funcion incompleta' + class Animal: + def __init__(self, especie, color): + self.especie = especie + self.color = color + self.edad = 0 + def CumpliAnios(self): + self.edad +=1 + return self.edad + return especie, color + + +a = ClaseAnimal('perro','blanco') +print(a) + + + diff --git a/08 - Error Handling/checkpoint_Resuelto.py b/08 - Error Handling/checkpoint_Resuelto.py index 0e8711c67..782562e5e 100644 --- a/08 - Error Handling/checkpoint_Resuelto.py +++ b/08 - Error Handling/checkpoint_Resuelto.py @@ -22,6 +22,7 @@ def Factorial(numero): numero -= 1 return factorial + def EsPrimo(valor): ''' Esta función devuelve el valor booleano True si el número reibido como parámetro es primo, de lo @@ -70,5 +71,5 @@ def CumplirAnios(self): self.Edad += 1 return self.Edad - a = Animal(especie, color) + a = Animal('gato', 'blanco') return a