diff --git "a/01 - Introducci\303\263n a la Programaci\303\263n/.ipynb_checkpoints/Preliminares - 01-checkpoint.ipynb" "b/01 - Introducci\303\263n a la Programaci\303\263n/.ipynb_checkpoints/Preliminares - 01-checkpoint.ipynb" index a62bcd0ee..b91bde2df 100644 --- "a/01 - Introducci\303\263n a la Programaci\303\263n/.ipynb_checkpoints/Preliminares - 01-checkpoint.ipynb" +++ "b/01 - Introducci\303\263n a la Programaci\303\263n/.ipynb_checkpoints/Preliminares - 01-checkpoint.ipynb" @@ -564,7 +564,7 @@ } ], "source": [ - " mi_tupla.count('Rojo')" + "mi_tupla.count('Rojo')" ] }, { @@ -1308,23 +1308,11 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'divisor' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_10044/1862935505.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdivisor\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mNameError\u001b[0m: name 'divisor' is not defined" - ] - } - ], + "outputs": [], "source": [ - "print(divisor)" + "# print(divisor)" ] }, { @@ -2322,7 +2310,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -2336,7 +2324,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.6" + }, + "vscode": { + "interpreter": { + "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d" + } } }, "nbformat": 4, diff --git "a/01 - Introducci\303\263n a la Programaci\303\263n/Preliminares - 01.ipynb" "b/01 - Introducci\303\263n a la Programaci\303\263n/Preliminares - 01.ipynb" index a0181f9c0..325046170 100644 --- "a/01 - Introducci\303\263n a la Programaci\303\263n/Preliminares - 01.ipynb" +++ "b/01 - Introducci\303\263n a la Programaci\303\263n/Preliminares - 01.ipynb" @@ -2342,7 +2342,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -2356,7 +2356,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]" + }, + "vscode": { + "interpreter": { + "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d" + } } }, "nbformat": 4, diff --git a/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb b/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb index 8b24b6405..24c961bd1 100644 --- a/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb +++ b/03 - Flujos de Control/.ipynb_checkpoints/Prep_Course_Homework_03-Resuelto-checkpoint.ipynb @@ -716,11 +716,8 @@ } ], "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, "kernelspec": { - "display_name": "Python 3.9.7 64-bit ('henry': conda)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -734,7 +731,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]" + }, + "vscode": { + "interpreter": { + "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d" + } } }, "nbformat": 4, 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..e031e08b2 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 @@ -443,8 +443,8 @@ " num2 = num * num2\n", " num = num - 1\n", " print(num2) \n", - " else:\n", - " print('el número {num} es menor que 0') \n" + "else:\n", + " print('el número {num} es menor que 0') \n" ] }, { @@ -34589,11 +34589,8 @@ } ], "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -34607,7 +34604,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]" + }, + "vscode": { + "interpreter": { + "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d" + } } }, "nbformat": 4, diff --git a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb index 39f94f511..f2e303cbf 100644 --- a/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb +++ b/03 - Flujos de Control/Prep_Course_Homework_03-Resuelto.ipynb @@ -716,11 +716,8 @@ } ], "metadata": { - "interpreter": { - "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" - }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -734,7 +731,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]" + }, + "vscode": { + "interpreter": { + "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d" + } } }, "nbformat": 4, diff --git a/Estaesunaprueba.txt b/Estaesunaprueba.txt new file mode 100644 index 000000000..fd5fe2a25 --- /dev/null +++ b/Estaesunaprueba.txt @@ -0,0 +1 @@ +Subir prueba \ No newline at end of file diff --git a/Workbench/OrdenaTuplas.py b/Workbench/OrdenaTuplas.py new file mode 100644 index 000000000..34db83f4f --- /dev/null +++ b/Workbench/OrdenaTuplas.py @@ -0,0 +1,19 @@ +# +# Ordenar una lista de coches almacenados como tuplas +# +tuplas_coches = [('Rojo', '4859-A', 'A'), ('Azul', '2901-Z', 'M'), ('Gris', '1892-B', 'M') + ] +# Ordenar los coches por matrícula +ordenados = sorted(tuplas_coches, key=lambda coche : coche[1]) +print (ordenados) +#[('Gris', '1892-B', 'M'), ('Azul', '2901-Z', 'M'), ('Rojo', '4859-A', 'A')] +# Ordenar una lista de coches almacenados como diccionarios +diccionarios_coches = [ + {'color': 'Rojo', 'matricula': '4859-A', 'cambio': 'A'}, + {'color': 'Azul', 'matricula': '2901-Z', 'cambio': 'M'}, + {'color': 'Gris', 'matricula': '1892-B', 'cambio': 'M'} +] +ordenados = sorted(diccionarios_coches, key=lambda coche : coche['matricula']) +print (ordenados) + +#[{'color': 'Gris', 'matricula': '1892-B', 'cambio': 'M'}, {'color': 'Azul', 'matricula': '2901-Z', 'cambio': 'M'}, {'color': 'Rojo', 'matricula': '4859-A', 'cambio': 'A'}] \ No newline at end of file diff --git a/Workbench/Substrings.py b/Workbench/Substrings.py new file mode 100644 index 000000000..0c47a6cad --- /dev/null +++ b/Workbench/Substrings.py @@ -0,0 +1,79 @@ +# Buscar una subcadena con index +import re +obj_iter="palabra" +varany = int +pos_ini = int +pos_fin = int +# obj_iter.sub[varany, pos_ini, pos_fin]) +# es similar a find() pero en caso de que no se encuentre la subcadena sub lanza la excepción ValueError. +# TypeError : Ocurre cuando se aplica una operación o función a un dato del tipo inapropiado. +# ZeroDivisionError : Ocurre cuando se itenta dividir por cero. +# OverflowError : Ocurre cuando un cálculo excede el límite para un tipo de dato numérico. +# IndexError : Ocurre cuando se intenta acceder a una secuencia con un índice que no existe. +# KeyError : Ocurre cuando se intenta acceder a un diccionario con una clave que no existe. +# FileNotFoundError : Ocurre cuando se intenta acceder a un fichero que no existe en la ruta indicada. +# ImportError : Ocurre c +# Manejo de excepciones con TRY y EXCEPT +# try: + # Codigo a ejecutar + # Pero podria haber errores en este bloque +# +# except : + # Haz esto para manejar la excepcion + # El bloque except se ejecutara si el bloque try lanza un error +# +# else: + # Esto se ejecutara si el bloque try se ejecuta sin errores +# +# finally: + # Este bloque se ejecutara siempre +print ("") +frase = 'me gusta la mermelada' +busca = "lo" +try: + cadena = frase + print (cadena.index(busca)) + # La cadena 'lo' no existe, por lo que provocará un error +except ValueError: + print ("En el texto ", "'",cadena,"'", "no existe la cadena", busca) + +# Otro ejemplo, creamos una función "dividir" que divide dos números +num = 10 +div = 0 +def dividir(num,div): + try: + res = dividir(num, div) + print(res) + except ZeroDivisionError: + print("Trataste de dividir entre cero :( ") + return num/div +#Sin embargo no controla la división por 0, que no esta definida y devolverá un error +#Aquí usamos el control de errores con try y except + +# Traceback (most recent call last): +# File "", line 1, in +# ValueError: substring not found + +# Ejemplo +# Buscar la posición de una cadena, en el ejemplo "la" +# Debe retornar la pos anterior a dónde incia la cadena, en este caso 9 +print ("La posición anterior a iniciar la primera cadena 'la' que encuentra, es la pos ", cadena.index('la')) +print ("") + +# Ejemplo +# Encontrar la última posición de una subcadena con RFIND, la busca todas y devuelve la ÚLTIMA +cadena = 'me gusta la mermelada' +cadena.rfind('la') # ocupan las pos 18 y 19 +print ("La última posición anterior, a iniciar la cadena 'la', es la pos ", cadena.rfind('la')) +# 17 +print (cadena.rfind('lo')) +# -1 +# Encontrar la última posición de una subcadena con RINDEX +print (cadena.rindex('la')) +# 17 +# print (cadena.rindex('lo')) +# Debe arrojar un error porque no existe la cadena (ValueError: substring not found) +import re +texto = "tres tristes tigres comen trigo en un trigal" +busqueda = re.sub(" ", "-", texto) +print(busqueda) \ No newline at end of file diff --git a/Workbench/Taller/AgregarElementosaObj.py b/Workbench/Taller/AgregarElementosaObj.py new file mode 100644 index 000000000..7765b0f21 --- /dev/null +++ b/Workbench/Taller/AgregarElementosaObj.py @@ -0,0 +1,30 @@ +# Ejercicio 442: Agregar elementos a un objeto conjunto con el método de instancia add(). + +lenguajes = set() + +print(len(lenguajes)) +print(lenguajes) + +print() + +lenguajes.add('Python') +print(len(lenguajes)) +print(lenguajes) + +print() + +lenguajes.add('Java') +print(len(lenguajes)) +print(lenguajes) + +print() + +lenguajes.add('Java') +print(len(lenguajes)) +print(lenguajes) + +print() + +lenguajes.add('java') +print(len(lenguajes)) +print(lenguajes) \ No newline at end of file diff --git a/Workbench/Taller/Ciclos.py b/Workbench/Taller/Ciclos.py new file mode 100644 index 000000000..bf1ab9a44 --- /dev/null +++ b/Workbench/Taller/Ciclos.py @@ -0,0 +1,26 @@ +print ("Inicio de números pares") +lista_p=[] # Creo lista pares, para poder imprimirlos hor. +lista_i=[] # Creo lista impares, para poder imprmirlos ver. +for par in range(0, 21, 2): # En el rango 0-20, cada 2, partiendo de 0 + lista_p.append(par) + print (par) +print(lista_p) # Escribe la lista vertical +print ("Fin de números pares") # Escribe la lista horizontal +print ("Inicio de números impares") +for impar in range(1, 21, 2): # En el rango 1-20, cada 2, partiendo de 1 + lista_i.append(impar) + print (impar) # Escrbe la lista vertical + # Escribe la lista horizontal +print(lista_i) +print ("Fin de números impares") +""" +"""# Dado un valor entero, ejecutar el mismo número de ciclos con un while +a= 5 +num=1 +while num < a+1: + #print ("a vale ", a) + #print ("num vale ", num) + print ("Este es el ciclo", num) + num=num+1 + + diff --git a/Workbench/Taller/Clases.py b/Workbench/Taller/Clases.py new file mode 100644 index 000000000..1bf3669b9 --- /dev/null +++ b/Workbench/Taller/Clases.py @@ -0,0 +1,266 @@ +#******************************************************************* +#* * +#* TALLLER CLASES y OBJETOS * +#* * +#******************************************************************* +# En Python todo son clases, porque es un lenguaje flexible +# Una clase es la abstracción de un objeto, un molde para crear entidades similares. +# Una clase consta de ATRIBUTOS y MÉTODOS +# Con los atributos o CONSTRUCTOR se instancia (crea) el objeto, es una copia +# Con los métodos se manipula, se hacen cálculos, se accede al objeto. +# Un ATRIBUTO es una carcterística, cuantificable o no, que define al objeto, ej, su color, número de patas +# Como ATRIBUTO, a un objeto le puedo definir cualquuier cosa ej diccionario, listas, tuplas +# Agregamos los atributos que necesitemos y si es numérico se inicializan con algún valor, ej velocidad=0. +# Los ATRIBUTOS o se deben acceder desde fuera de la clase(ej print(a1.color), a1 es un objeto animal, +# con un atributo llamado color, en principio, la sentencia devolvería el color de a1, con el que fue +# creado, pero la buena práctica dice que debemos crear un método para acceder a su color y luego podemos +# imprimir lo que retorna el método. +# Para proteger un ATRIBUTO, se le agregan dos lineas bajas o underscore al INICIO del atributo. +# Luego creo los métodos o funciones asociados a él o los ATRIBUTOS, similar a los geters y seters. +# Este es un ejemplo de ENCAPSULACIÓN +# Un MÉTODO, básicamente, es una FUNCIóN, usada para ejecutar procedimientos u operaciones sobre la CLASE +# con los ATRIBUTOS de la CLASE. Por ejemplo, un objeto auto, tiene un atributo velocidad, por lo que puede acelerar o frenar. +# Qué es ABSTRACCIÓN => Separar los datos +# Qué es ENCAPSULAMIENTO => Proteger el objeto (lo accedo o conozco a través de sus métodos) +# Qué es HERENCIA => Permite crear nuevas clases heredando sus atributos,métodos y agregando nuevos, +# ej. Animales=>Humano +# Qué es POLIMORFISMO => Mismo nombre pero distinto comportamiento +# Se usa la palabara reservada class, seguida de __INIT__, y detro de los paréntesis (), la primera palabra +# DEBE ser self, seguido de sus atributos. A esto se denomina el método CONSTRUCTOR de la clase. +# SELF es una palabra reservada que le dice a Python que lo que viene son atributos y no genere conflictos. +# Para que la ayuda o help(), despliegue un mensaje de qué hace una CLASE o FUNCIÓN, se abren +# tres comillas dobles, se agrega una breve descripción con los tipos de varibles o sintaxis, y se vuelve +# a cerrar con tres comillas dobles. +# + +# Ej 1) Crear una clase que cree objetos del tipo automóvil con los atributos color y aceleración + +class Car1: + def __init__(self, color, aceleracion): + self.color = color + self.aceleracion = aceleracion + self.velocidad = 0 + self.ruedas = 4 + self.direccion = 90 + def Acelera(self): + self.acelera = self.aceleracion + self.velocidad + def frena(self): + v.frena = self.aceleracion - self.velocidad + if v < 0: + v = 0 + self.velocidad = 0 + + +class Perro (): + # El método __init__ es llamado al crear el objeto + def __init__(self, nombre, raza): + print(f"Creando perro {nombre}, {raza}") + # Atributos de instancia + self.nombre = nombre + self.raza = raza + +c1 = Car1('rojo', 20) +print (c1.color) +# rojo +print (c1.ruedas) +# 4 +c2 = Car1('azul', 30) +print(c2.color) +# azul +print(c2.ruedas) +# 4 + +# Ej 5 Crear una función que cree la clase Emprendedor +# El constructor de la clase Emprenddedor recibe los valores +# nombre (str), apellido (str), libros (array), mascotas (array de str) +# Inicializar las propiedades de la clase Emprendedor con los valores recibidos +class Emprendedor: + """ + recibe los valores nombre (str), apellido (str), libros (array), + mascotas (array de str) + """ + def __init__(self, nombre, apellido, libros, mascotas): + self.nombre = nombre + self. apellido = apellido #Este es el constructor de la clase + self.libros = libros + self. mascotas = mascotas + +# Estos los métodos de la clase Emprendedor + def getNombre (self): + pass + def getApellido (self): + pass + def getLibros (self): + pass + def getMascotas (self): + pass + def setNombre (self): + pass + def setApellido (self): + pass + def setLibros (self): + pass + def setMascotas (self): + pass + +# Ej 6 Creamos el objeto emp1 con el constructor Emprendedor +emp1 = Emprendedor ("Lionel", "Cordova", ["Dos palmeras", 1917, 'abc123'], ('Perro', 'Gato')) +print ("") +print (type(emp1)) # Debe retornar +print (type(emp1.nombre)) # Debe retornar +print (type(emp1.apellido)) # Debe retornar +print (type(emp1.libros)) # Debe retornar +print (type(emp1.mascotas)) # Debe retornar +print("") + +# Ej 8 ENCAPSULAMIENTO +# Encapsular, consiste en hacer que los atributos o métodos internos a una clase no se puedan +# acceder ni modificar desde fuera, sino que tan solo el propio objeto pueda acceder a ellos. +# Python por defecto NO OCULTA los atributos y métodos de una clase al exterior. +# +class miSaludo: + atributo_clase = "Hola" + def __init__(self, atributo_instancia): + self.atributo_instancia = atributo_instancia +# Mira lo que pasa +prueba_mi_clase = miSaludo("Que tal") #Instancio el objeto con el parámetro 'Que tal'=atributo_instancia +print (prueba_mi_clase.atributo_clase) # Le he pasado el valor de la variable +print (prueba_mi_clase.atributo_instancia) # Le he pasado el parámetro de la instancición de la clase + +# 'Hola' +# 'Que tal' + +# Primera reflexión: Ambos atributos son perfectamente accesibles desde el exterior!, va contra las buenas prácticas. +# Hay métodos o atributos que queremos que pertenezcan sólo a la clase o al objeto, y que sólo puedan ser accedidos +# por los mismos. Para ello podemos usar la doble __ (underscore) para ocultar un atributo o método. +# Esto hará que Python los interprete como “privados”, y ya no podrán ser accedidos desde el exterior. +# Eso es "ENCAPSULAMIENTO" +# Volvamos a revisar el ejemplo +class Clase: + atributo_clase = "Hola" # Es accesible desde el exterior + __atributo_clase = "Hola" # No es accesible desde el exterior de la clase + # Acá protegemos el método, ahora no es accesible desde el exterior + def __mi_metodo(self): + print("Este es un ejemplo de ENCAPSULAMIENTO") + self.__variable = 0 # La variable, también la hacemos privada + + # Este método lo exponemos para acceder a la clase, debe ser accesible desde el exterior + def metodo_normal(self): + # El método si es accesible desde el interior + self.__mi_metodo() + +mi_clase = Clase() +#mi_clase.__atributo_clase # Error! El atributo no es accesible +#mi_clase.__mi_metodo() # Error! El método no es accesible +mi_clase.atributo_clase # Ok! +mi_clase.metodo_normal() # Ok! +# Podemos hacer uso de 'dir' para ver el listado de métodos y atributos de nuestra clase que son PUBLICOS. +# Al hacer 'privados' el '_atributo_clase' y '_mi_metodo', no los podremos encontrar en la lista. +print(dir(mi_clase)) +#['_Clase__atributo_clase', '_Clase__mi_metodo', '_Clase__variable', +#'__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', +#'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', +#'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', +#'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', +#'__str__', '__subclasshook__', '__weakref__', 'atributo_clase', 'metodo_normal'] + +# Se puede acceder a los atribtos y métodos ocultos de una clase, como '__atributo_clase' y a '__mi_metodo', +# haciendo un poco de trampa. +# Python los guarda con un nombre distinto para ocultarlos (encapsularlos) y evitar su uso indebido. +# Podemos llamarlos con un 'truco sucio' de la siguiente manera aunque, por buenas prácticas, no es recomendable. +print("") +a = mi_clase._Clase__atributo_clase +print ("Escribiendo 'la ruta completa' del atributo oculto") +print ("de esta forma: 'mi_clase._Clase__atributo_clase', retornará su contenido") +print ("en este caso ", a) +# 'Hola' +print ("Caso 2, al escribir 'la ruta completa' del método así 'mi_clase._Clase__mi_metodo', retorna su contenido.") +print ("en este caso ", mi_clase._Clase__mi_metodo()) +# Conclusión, hay una precedencia en las operaciones...la función primero que el +# print, y se repite porque imprime la función y lo que retorna que es none. +# Por esa razón, a veces parece que se imprime en otra parte. + + +# Ej 7 POLIMORFISMO +# Suponga que tiene una clase ANIMAL, que tiene un atributo HABLAR +print("") +class Animal: # Creamos la clase con 1 atributo hablar + def hablar(self): + pass +# Por otro lado, creamos dos clases: Perro y Gato, que heredan de la anterior. +# Además, implementan el método hablar() de formas distintas. +# Entonces: +print ("") +class Perro(Animal): # Nótese que en este caso se le pasa como parámetro, la otra + def hablar(self): # clase entre paréntesis. + print("Guau!") + +class Gato(Animal): + def hablar(self): + print("Miau!") + +# Ahora creamos un objeto de cada clase y llamamos al método hablar(). +# Podemos observar que cada animal se comporta de manera distinta al usar hablar(). + +for sonidos in Perro(), Gato(): + sonidos.hablar() +# Guau! +# Miau! + +# Ejercicio 8 - Crear clase Persona + +class Persona(): + + def __init__(self,nombre="",edad=0,dni=""): + self.nombre=nombre + self.edad=edad + self.dni=dni + + @property + def nombre(self): + return self.__nombre + + @property + def edad(self): + return self.__edad + + @property + def dni(self): + return self.__dni + + @nombre.setter + def nombre(self,nombre): + self.__nombre=nombre + + def validar_dni(self): + letras = "TRWAGMYFPDXBNJZSQVHLCKE" + if len(self.__dni)!=9: + print("DNI incorrecto") + self.__dni = "" + else: + letra = self.__dni[8] + num = int(self.__dni[:8]) + if letra.upper() != letras[num % 23]: + print("DNI incorrecto") + self.__dni = "" + + @dni.setter + def dni(self,dni): + self.__dni=dni + self.validar_dni() + + @edad.setter + def edad(self,edad): + if edad < 0: + print("Edad incorrecta") + self.__edad=0 + else: + self.__edad=edad + + + def mostrar(self): + return "Nombre:"+self.nombre+" - Edad:"+str(self.edad)+" - DNI:"+self.dni + + def esMayorDeEdad(self): + return self.edad>=18 + diff --git a/Workbench/Taller/ComoComentar.py b/Workbench/Taller/ComoComentar.py new file mode 100644 index 000000000..e26328386 --- /dev/null +++ b/Workbench/Taller/ComoComentar.py @@ -0,0 +1,16 @@ +# Este es un comentario en Python +print ("This is an example of comments") +print ("also, this is an other example of comments") +print ("comments are preceded by a hash symbol #") +print ("and other way to do this it's preceeding a paragraph") +print ("by 3 dots at the beginig, and 3 at the end") + +"""este es un ejemplo de comentarios en varias líneas +es otra forma para organizar textos largos...""" +''' +otro +ejemplo +de lineas +múltiple +''' +print ("fin de los comments") \ No newline at end of file diff --git a/Workbench/Taller/CrearMenu.py b/Workbench/Taller/CrearMenu.py new file mode 100644 index 000000000..ebe1a4193 --- /dev/null +++ b/Workbench/Taller/CrearMenu.py @@ -0,0 +1,105 @@ + +""" +def accion1(): + print('Has elegido la opción 1') + + +def accion2(): + print('Has elegido la opción 2') + + +def accion3(): + print('Has elegido la opción 3') + + +def salir(): + print('Saliendo') + +#Guardamos en en un diccionario de tuplas, la opción y la acción +opciones = { + '1': ('Opción 1', accion1), + '2': ('Opción 2', accion2), + '3': ('Opción 3', accion3), + '4': ('Salir', salir) +} + +def generar_menu(opciones, opcion_salida): + opcion = None + while opcion != opcion_salida: + mostrar_menu(opciones) + opcion = leer_opcion(opciones) + ejecutar_opcion(opcion, opciones) + print() # se imprime una línea en blanco para clarificar la salida por pantalla + +def mostrar_menu(opciones): + print('Seleccione una opción:') + for clave in sorted(opciones): + print(f' {clave}) {opciones[clave][0]}') + +def leer_opcion(opciones): + while (a := input('Opción: ')) not in opciones: + print('Opción incorrecta, vuelva a intentarlo.') + return a + +def ejecutar_opcion(opcion, opciones): + opciones[opcion][1]() + +def menu_principal(): + opciones = { + '1': ('Opción 1', accion1), + '2': ('Opción 2', accion2), + '3': ('Opción 3', accion3), + '4': ('Salir', salir) + } +generar_menu(opciones, '4')""" + +# Creamos funciones asociadas a cada acción del menú +# Tercer paso es unir la lógica y para ellos crearemos con tres objetivos: +# 1) Mostrar el menú al usuario +# 2) Pedir una opción al usuario y leer esa opción por teclado. +# 3) Ejecutar la opción correspondiente. + +def mostrar_menu(opciones): + print('Seleccione una opción:') + for clave in sorted(opciones): + print(f' {clave}) {opciones[clave][0]}') + +def leer_opcion(opciones): + while (a := input('Opción: ')) not in opciones: + print('Opción incorrecta, vuelva a intentarlo.') + return a + +def ejecutar_opcion(opcion, opciones): + opciones[opcion][1]() + +def generar_menu(opciones, opcion_salida): + opcion = None + while opcion != opcion_salida: + mostrar_menu(opciones) + opcion = leer_opcion(opciones) + ejecutar_opcion(opcion, opciones) + print() + +def menu_principal(): + opciones = { + '1': ('Opción 1', accion1), + '2': ('Opción 2', accion2), + '3': ('Opción 3', accion3), + '4': ('Salir', salir) + } + generar_menu(opciones, '4') + +def accion1(): + print('Has elegido la opción 1') + +def accion2(): + print('Has elegido la opción 2') + +def accion3(): + print('Has elegido la opción 3') + +def salir(): + print('Saliendo') + +if __name__ == '__main__': + menu_principal() \ No newline at end of file diff --git a/Workbench/Taller/DesafioProgra.py b/Workbench/Taller/DesafioProgra.py new file mode 100644 index 000000000..80a644552 --- /dev/null +++ b/Workbench/Taller/DesafioProgra.py @@ -0,0 +1,335 @@ +#******************************************************************* +#* * +#* SIMULACRO HENRY CHALLENGE * +#* * +#******************************************************************* + +def ListaDivisibles(numero, tope): + ''' + Esta función devuelve una lista ordenada de menor a mayor con los números divisibles + por el parámetro número entre uno (1) y el valor del parámetro "tope" + Recibe dos argumentos: + numero: Numero entero divisor + tope: Máximo valor a evaluar a partir de uno (1) + Ej: + ListaDivisibles(6,30) debe retornar [6,12,18,24] + ListaDivisibles(10,5) debe retornar [] + ListaDivisibles(7,50) debe retornar [7,14,21,28,35,42,49] + ''' + #Tu código aca: + lista=[] + for i in range((tope)): + if (i+1)%numero==0: + lista.append(i+1) + + return lista + +def Exponente(numero, exponente): + ''' + Esta función devuelve el resultado de elevar el parámetro "numero" al parámetro "exponente" + Recibe dos argumentos: + numero: El número base en la operación exponencial + exponente: El número exponente en la operación exponencial + Ej: + Exponente(10,3) debe retornar 1000 + ''' + #Tu código aca: + exp=numero**exponente + return exp + +def ListaDeListas(lista): + ''' + Esta función recibe una lista, que puede contener elementos que a su vez sean listas y + devuelve esos elementos por separado en una lista única. + En caso de que el parámetro no sea de tipo lista, debe retornar nulo. + Recibe un argumento: + lista: La lista que puede contener otras listas y se convierte a una + lista de elementos únicos o no iterables. + Ej: + ListaDeListas([1,2,['a','b'],[10]]) debe retornar [1,2,'a','b',10] + ListaDeListas(108) debe retornar el valor nulo. + ListaDeListas([[1,2,[3]],[4]]) debe retornar [1,2,3,4] + ''' + #Tu código aca: + if type(lista) != list: + return None + else: + lista_final=[] + for elem in lista: + if isinstance(elem, list): + lista_final.extend(ListaDeListas(elem)) + else: + lista_final.append(elem) + return lista_final + + + + #return 'Funcion incompleta' + +def Factorial(numero): + ''' + Esta función devuelve el factorial del número pasado como parámetro. + En caso de que no sea de tipo entero y/o sea menor que 0, debe retornar nulo. + Recibe un argumento: + numero: Será el número con el que se calcule el factorial + Ej: + Factorial(4) debe retornar 24 + Factorial(-2) debe retornar nulo + Factorial(0) debe retornar 1 + ''' + #Tu código aca: + if (type(numero) != int): + return None + if (numero < 0): + return None + factorial = 1 + for n in range(1, (numero)+1): + factorial = factorial * n + return factorial + #return 'Funcion incompleta' + +def ListaPrimos(desde, hasta): + ''' + Esta función devuelve una lista con los números primos entre los valores "desde" y "hasta" + pasados como parámetro, siendo ambos inclusivos. + En caso de que alguno de los parámetros no sea de tipo entero y/o no sea mayor a cero, debe retornar nulo. + En caso de que el segundo parámetro sea mayor al primero, pero ambos mayores que cero, + debe retornar una lista vacía. + Recibe un argumento: + desde: Será el número a partir del cual se toma el rango + hasta: Será el número hasta el cual se tome el rango + Ej: + ListaPrimos(7,15) debe retornar [7,11,13] + ListaPrimos(100,99) debe retornar [] + ListaPrimos(1,7) debe retonan [1,2,3,5,7] + ''' + #Tu código aca: + lista=[] + if (type(desde) != int or type(hasta) != int): + return None + if (desde < 0 or hasta < 0): + return None + if (desde > hasta): + return lista + def esPrimo(num): + if num==2: + return True + for n in range (2,num): + if(num%n!=0): + continue + else: + return False + return True + for i in range(desde,(hasta+1)): + if esPrimo(i): + lista.append(i) + + return lista + + +def ListaRepetidos(lista): + ''' + Esta función recibe como parámetro una lista y devuelve una lista de tuplas donde cada + tupla contiene un valor de la lista original y las veces que se repite. Los valores + de la lista original no deben estar repetidos. + Debe respetarse el orden original en el que aparecen los elementos. + En caso de que el parámetro no sea de tipo lista debe retornar nulo. + Recibe un argumento: + lista: Será la lista que se va a evaluar. + Ej: + ListaRepetidos([]) debe retornar [] + ListaRepetidos(['hola', 'mundo', 'hola', 13, 14]) + debe retornar [('hola',2),('mundo',1),(13,1),(14,1)] + ListaRepetidos([1,2,2,4]) debe retornar [(1,1),(2,1),(4,1)] + ''' + #Tu código aca: + l=[] + if type(lista) != list: + return None + while len(lista)>0: + elemento=lista[0] + cuenta=lista.count(lista[0]) + l.append((elemento,cuenta)) + for i in range(lista.count(lista[0])): + lista.remove(elemento) + continue + return l + +def ClaseVehiculo(tipo, color): + ''' + Esta función devuelve un objeto instanciado de la clase Vehiculo, + la cual debe tener los siguientes atributos: + Tipo: Un valor dentro de los valores posibles: ['auto','camioneta','moto'] + Color: Un valor de tipo de dato string. + Velocidad: Un valor de tipo de dato float, que debe inicializarse en cero. + y debe tener el siguiente método: + Acelerar(): Este método recibe un parámetro con el valor que debe incrementar a la + propiedad Velocidad y luego retornarla. + Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero. + Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien. + Recibe dos argumento: + tipo: Dato que se asignará al atributo Tipo del objeto de la clase Vehiculo + color: Dato que se asignará al atributo Color del objeto de la clase Vehiculo + Ej: + a = ClaseVehículo('auto','gris') + a.Acelerar(10) -> debe devolver 10 + a.Acelerar(15) -> debe devolver 25 + a.Acelerar(-10) -> debe devolver 15 + ''' + #Tu código aca: + class Vehiculo: + def __init__(self, tipo, color): + if (tipo=='auto' or tipo =='camioneta' or tipo=='moto'): + self.Tipo = tipo + else: + raise TypeError ('el tipo de vehículo tiene que ser auto, camioneta o moto') + self.Color = color + self.Velocidad = 0 + + def Acelerar(self, acel): + self.Velocidad += acel + if self.Velocidad < 0: + self.Velocidad=0 + if self.Velocidad>100: + self.Velocidad=100 + return self.Velocidad + + a = Vehiculo(tipo, color) + return a + + +def OrdenarDiccionario(diccionario_par, clave, descendente=True): + ''' + Esta función recibe como parámetro un diccionario, cuyas listas de valores tienen el mismo + tamaño y sus elementos enésimos están asociados. Y otros dos parámetros que indican + la clave por la cual debe ordenarse y si es descendente o ascendente. + La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la + relación entre los elementos enésimos. + Recibe tres argumentos: + diccionario: Diccionario a ordenar. + clave: Clave del diccionario recibido, por la cual ordenar. + descendente: Un valor booleano, que al ser verdadero indica ordenamiento descendente y + ascendente si es falso. + Debe tratarse de un parámetro por defecto en True. + Si el parámetro diccionario no es un tipo de dato diccionario ó el parámetro clave no + se encuentra dentro de las claves del diccionario, debe devolver nulo. + Ej: + dicc = {'clave1':['c','a','b'], + 'clave2':['casa','auto','barco'], + 'clave3':[3,1,2]} + OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'], + 'clave2':['auto','barco','casa'], + 'clave3':[1,2,3]} + OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['c','b','a'], + 'clave2':['casa','barco','auto'], + 'clave3':[3,2,1]} + ''' + #Tu código aca: + if type(diccionario_par) != dict: + return None + diccion_lista=[] + diccion_lista=list(diccionario_par.keys()) + if clave not in diccion_lista: + return None + for key, value in diccionario_par.items(): + value.sort(reverse=descendente) + + return diccionario_par + +def Factorial(numero): + ''' + Esta función devuelve el factorial del número pasado como parámetro. + En caso de que no sea de tipo entero y/o sea menor que 1, debe retornar nulo. + Recibe un argumento: + numero: Será el número con el que se calcule el factorial + Ej: + Factorial(4) debe retornar 24 + Factorial(-2) debe retornar nulo + ''' + #Tu código aca: + if (type(numero) != int): + return None + if (numero < 1): + return None + factorial = 1 + while(numero > 1): + factorial = 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 + contrario devuelve False.. + En caso de que el parámetro no sea de tipo entero debe retornar nulo. + Recibe un argumento: + valor: Será el número a evaluar + Ej: + EsPrimo(7) debe retornar True + EsPrimo(8) debe retornar False + ''' + #Tu código aca: + if (type(valor) != int): + return None + for i in range(2, (int(valor / 2) + 1)): + if valor % i == 0: + return False + return True + +def ClaseAnimal(especie, color): + ''' + Esta función devuelve un objeto instanciado de la clase Animal, + la cual debe tener los siguientes atributos: + Edad (Un valor de tipo de dato entero, que debe inicializarse en cero) + Especie (Un valor de tipo de dato string) + Color (Un valor de tipo de dato string) + y debe tener el siguiente método: + CumplirAnios (este método debe sumar uno al atributo Edad y debe devolver ese valor) + Recibe dos argumento: + especie: Dato que se asignará al atributo Especie del objeto de la clase Animal + color: Dato que se asignará al atributo Color del objeto de la clase Animal + Ej: + a = ClaseAnimal('perro','blanco') + a.CumpliAnios() -> debe devolver 1 + a.CumpliAnios() -> debe devolver 2 + a.CumpliAnios() -> debe devolver 3 + ''' + #Tu código aca: + class Animal: + def __init__(self, especie, color): + self.Especie = especie + self.Color = color + self.Edad = 0 + + def CumplirAnios(self): + self.Edad += 1 + return self.Edad + + a = Animal(especie, color) + return a + + +# Caso 1 +# El constructor de la clase Emprendedor recibe nombre (str), apellido (str), +# libros (lista), mascotas (lista). + +# a) Inicializar la clase con sus atributos + +class Emprendedor: + """En esta clase se crean emprenderes""" + mascotas = [] # Acumulará las mascotas del Emprendedor + libros = [] # Es una lista de libros del Emprendedor + def __init__(self, nombre, apellido, libros, mascotas): + self.nombre = nombre + self.apellido = apellido + self.libros = libros + self.mascotas = mascotas + +# b) Crear un Método que agregue una mascota (mascota) a la lista, no debe +# retornar nada. Mascotas es una lista +# + + def addMascotas (self, newPet): + self.mascotas.add() + + \ No newline at end of file diff --git a/Workbench/Taller/Diccionarios.py b/Workbench/Taller/Diccionarios.py new file mode 100644 index 000000000..54d32aecc --- /dev/null +++ b/Workbench/Taller/Diccionarios.py @@ -0,0 +1,177 @@ +#******************************************************************* +#* * +#* TEORIA DICCIONARIOS * +#* * +#******************************************************************* +# Un dict es una colección de pares, no ordenados, compuestos por una KEY y un VALUE (valor) +# La KEY debe ser HASHEABLE, INMUTABLE, ÚNICA, NO REPETIBLE, los valores pueden ser cualquier cosa MUTABLE. +# Un VALUE puede ser otro DICCIONARIO, TUPLA, LISTA, más los tipos clásicos, como BOOLEAN, etc. +# Otras caracteristicas: Similar al tipo MAPA en otros lenguajes, no confundir con función map(), +# aunque retorna un DICT. La funicón map() es para objetos iterables como listas. +# Método keys() => nom_dic.keys() retorna una clase especial llamada dict_keys, sólo nombra las keys, +# Para acceder a las KEYS, se debe pasar a LISTA ==> nom_var = list(nom_dic.keys()) +# para poder iterar sobre cada LLAVE +# Método clear() => Borra todos los elementos del diccionario mi_dic.clear(), retorna {} +# Método del(key) => Elimina un elemento con su clave, le paso la clave como parámetro +# Método values() => devuelve todos los VALORES +# Método dict.items()=> Retorna tuplas (clave, valor), también se pasa a list siguen siendo TUPLAS. +# Función in retorna bool si encuentra valor de una clave "mi_key" in "mi_dic" +# Sólo sirve para claves, y es un booleano, TRUE o FALSE, si quiero preguntar po un valor, agregro +# VALUE de esta forma "mi_valor" in "mi_dic.value". +# Recorridos en diccionarios + + + +# Inicialización de DICCIONARIOS (dict) +# El constructor dict y argumentos. Ej: dict(color='Azul', num=4) +# Constructor dict y pares de valores. Ej: dict([('color', 'Azul'), ('num', 4)]) +# Usando un literal de pares separados por ':' y rodeado por {}. Ej: {'color': 'Azul', 'num': 4} +# + +# Ejemplo 1 +# Este es un dic de 4 elementos o pares cualquiera str, int, str y str. +# Obtenemos sus claves y las pasamos a una lista +d = {1: 'str cualquiera', 89: 'soy un valor', 'clave a': 'b', 'clave c': 27} # Inicializa el dict +listkey_d = list(d.keys()) # Hay que convertirlo a lista para acceder a las keys como índice +print (listkey_d) # Ahora veo los índices y los puedo trabajar como LISTA +print ("'D' es del tipo ", type (d)) # Retorna +print ("'listkey_d' es del tipo ", type (listkey_d)) # Retorna , se ve la diferencia +print ("El nombre de la clave en la posición 1 es ", listkey_d [1], " y es de tipo", type(listkey_d [1])) +print ("El nombre de la clave en la posición 3 es ", listkey_d [3], " y es de tipo", type(listkey_d [3])) +print ("") + +# Ejemplo 2 +# Crea un diccionario con 4 pares lógicos, colores primarios, colores secundarios, clave 3 y clave 4 + +mi_dic = {'Colores Primarios': ['Rojo','Azul','Amarillo'], + 'Colores secundarios': ['Naranja','Violeta','Verde'], + 'Clave3': 10, + 'Clave4': False} +mi_dic_keys = list (mi_dic.keys()) # Obtenemos las keys y las pasamos a una list "mi_dic_keys" +print (mi_dic_keys) # Imprime la lista +print (type (mi_dic_keys)) # Imprime el tipo de la variable mi_dic_keys, retorna +print ("Los colores de la clave ", mi_dic_keys [1], "son ", mi_dic['Colores secundarios']) +print ("") +print (mi_dic.keys()) + +print ("Los colores de la clave ", mi_dic_keys [0], "son ", mi_dic['Colores Primarios']) +print ("El valor de la clave 3", mi_dic_keys [2], "es ", mi_dic['Clave3']) +print ("El valor de la clave 4", mi_dic_keys [3], "son ", mi_dic['Clave4']) + +# Ejemplo 3 +dd2 = dict (width=4, members=['1', False], name='Pepe') # 3 elementos, 1 int, 1 dict, un str +print ("El contenido de 'dd2' es ", dd2) # # Retorna {'width': 4, 'members': ['1', False], 'name': 'Pepe'} +print (dd2.values()) # Retorna 4, ['1', False], "Pepe" + + +# Ejemplo 4 +print("") +dict2 = {} # Inicializa un diccionario vacío +print ("El contenido de 'dict2' debe ser vacío ", dict2) # Mostrará {} +# El contenido de 'dict2' debe ser {} + +# Ejemplo 5 +print ("") +# Observar varias formas de declarar diccionarios +{'1': 'primero', '2': 'segundo', 'tercero': 4 * 5 * 6} # Tres pares, str-str, str-str y str-int +{'1': 'primero', '2': 'segundo', 'tercero': 120} # Igual que el anterior, pero el último no es una operación +{str(x): x + 1 for x in range(5)} # Clave es un str x, el valor de x+1 en el rango 0-5 +{'0': 1, '1': 2, '2': 3, '3': 4, '4': 5} # 4 pare, str-int, str-int, str-int, str-int +dict(enumerate(range(5), start=10)) +{10: 0, 11: 1, 12: 2, 13: 3, 14: 4} +[(x, chr(x)) for x, idx in enumerate(range(5), start=65)] +[(65, 'A'), (66, 'B'), (67, 'C'), (68, 'D'), (69, 'E')] +#Este ejemplo crea un diccionario compuesto por un int (start=65), y el valor es un str que se calcula +# usando la función chr(), al pasarle el valor de x, retornará 5 letras sucesivas entre 65 y 69 (5 valores) +letters = [(x, chr(x)) for x, idx in enumerate(range(5), start=65)] +dict(letters) +print (letters) +{65: 'A', 66: 'B', 67: 'C', 68: 'D', 69: 'E'} + +# Ejemplo 6 +# Este es un diccionario +# Se define como nombre_dic = dict(pos=valor, key=valor, valor=valor), hay otras formas +# +miprimer_dic = dict(tipo='Moto', marca='Honda', power=599) +print(list(enumerate(miprimer_dic))) #convertimos el dict en lista. +#[(0, 'tipo'), (1, 'marca'), (2, 'power')] +print("") +print ("Inicio del ciclo for") +# En este ejemplo iteramos los elementos de un diccionario y me muestran los pares según posición +# Usamos el método "enumerate" que pertenece al tipo list, para recorrer el dict convertido en lista +# +print ("caso con f") +for idx, key in enumerate(miprimer_dic): # El enumerador de la forma ind, key, recorre el diccionario + print(f'Pos: {idx} - dict_key {key} - value {miprimer_dic[key]}') + #print('Pos: {idx} - dict_key {key} - value {miprimer_dic[key]}') +print("") +print ("caso sin f") +for idx, key in enumerate(miprimer_dic): # El enumerador de la forma ind, key, recorre el diccionario + #print(f'Pos: {idx} - dict_key {key} - value {miprimer_dic[key]}') + print('Pos: {idx} - dict_key {key} - value {miprimer_dic[key]}') + +#Pos: 0 - dict_key tipo - value Moto +#Pos: 1 - dict_key marca - value Honda +#Pos: 2 - dict_key power - value 599 + +# Ejemplo 7 +# Consultar a un dicc, si una clase existe => retorna un booleano TRUE o FALSE +# Ojo si preguntas por un VALUE, puede que existe la KEY, pero retornará FALSE +# Si quiero preguntar por un valor, agrego el método .value() + +print ("") +letters2 = [(x, chr(x)) for x, idx in enumerate(range(5), start=65)] +dd = dict(letters2) +print ("Este es el diccionario dd", dd) +mi_key1=65 +print (type(letters2)) +if mi_key1 in dd: + print ("La clave ", mi_key1," existe") +else: + print ("La clave ", mi_key1, ". No existe") +print ("") + +restaurant = {"Hamburguesa": 100, "Pizza": 50, "Jugo": 30} +if "Hamburguesa" in restaurant: + print ("SI está") + print() +else: + print ("NO está") + print() +print (restaurant) +print() + +# Ejemplo 8 - Unir dos diccionarios + +def unirDics (dic1, dic2): + temp=dic1.copy() + temp.update(dic2) + return temp +miDic1={'manzana':10.50, 'pera':12.8} +miDic2={'durazno':11.10, 'ciruela':23.8} + +dicUni2= unirDics (miDic1, miDic2) +print (dicUni2) +print() + +# Ejemplo 9 - Unir dos diccionarios +# Unir dos LISTAS y crear un Diccionario +# necesitamos una lsta que provea las llaves y otra que provea los values + +def lisADicc (liskey, lisval): + return dict(zip(liskey, lisval)) +newkeys = ['enero', 'febrero', 'marzo', 'abril'] +newval = [10, 50,12, 9, 11, 10, 23, 8] + +d=lisADicc (newkeys, newval) +print (d) +#print() + +# Ejemplo 9 - Encontrar el elemento más frecuente de una lista o MODA +# +def moda (lista): + return print (max(lista, key= lista.count)) +print() +lista = [3,1,3,2,1,5,2,3,2,1,5,4,3,3,3] +moda (lista) + diff --git a/Workbench/Taller/EjMix_DicLis.py b/Workbench/Taller/EjMix_DicLis.py new file mode 100644 index 000000000..e3ff8a747 --- /dev/null +++ b/Workbench/Taller/EjMix_DicLis.py @@ -0,0 +1,446 @@ +# 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 ListaDivisibles(numero, tope): + ''' + Esta función devuelve una lista ordenada de menor a mayor con los números divisibles + por el parámetro número entre uno (1) y el valor del parámetro "tope" + Recibe dos argumentos: + numero: Numero entero divisor + tope: Máximo valor a evaluar a partir de uno (1) + Ej: + ListaDivisibles(6,30) debe retornar [6,12,18,24,30] + ListaDivisibles(10,5) debe retornar [] + ListaDivisibles(7,50) debe retornar [7,14,21,28,35,42,49] + ''' + #Tu código aca: + lista_rango = list(range(numero,tope+1)) + lista_num_divisibles = [] + + if numero > tope: + print(lista_num_divisibles) + return lista_num_divisibles + if numero <= 0: + print(str(numero) + ', que corresponde a ser el divisor, NO puede ser = 0.') + return None + + for i in lista_rango: + if (i % numero) == 0: + lista_num_divisibles.append(i) + lista_num_divisibles.sort(reverse=False) + print(lista_num_divisibles) + return lista_num_divisibles + +#ListaDivisibles(6,30) +#ListaDivisibles(10,5) +#ListaDivisibles(7,50) + +#O.K. - Revisado y testeado! + + +def Exponente(numero, exponente): + ''' + Esta función devuelve el resultado de elevar el parámetro "numero" al parámetro "exponente" + Recibe dos argumentos: + numero: El número base en la operación exponencial + exponente: El número exponente en la operación exponencial + Ej: + Exponente(10,3) debe retornar 1000 + ''' + #Tu código aca: + exponente = numero**exponente + print(exponente) + return exponente + +#Exponente(10,3) + +#O.K. - Revisado y testeado! + + +def ListaDeListas(lista): + ''' + Esta función recibe una lista, que puede contener elementos que a su vez sean listas y + devuelve esos elementos por separado en una lista única. + En caso de que el parámetro no sea de tipo lista, debe retornar nulo. Listo! + Recibe un argumento: + lista: La lista que puede contener otras listas y se convierte a una + lista de elementos únicos o no iterables. + Ej: + ListaDeListas([1,2,['a','b'],[10]]) debe retornar [1,2,'a','b',10] + ListaDeListas(108) debe retornar el valor nulo. + ListaDeListas([[1,2,[3]],[4]]) debe retornar [1,2,3,4] + ''' + #Tu código aca: + listaplana = list() + + if type(lista) != list: + print('No es una lista.') + return None + + for elemento in lista: + if type(elemento) != list: + listaplana.append(elemento) + if type(elemento) == list: + for elemento2 in list(elemento): + if type(elemento2) != list: + listaplana.append(elemento2) + if type(elemento2) == list: + listaplana.extend(ListaDeListas(elemento2)) + + + + print(listaplana) + return listaplana + + +#ListaDeListas([1,2,['a','b'],[10]]) +#ListaDeListas(108) +#ListaDeListas([[1,2,[3]],[4]]) +#ListaDeListas([[1,2,[3,[6,6,6,[7,[['iri'],8,9,[11]],],6,6]]],[4]]) #extra prueba + + +def Factorial(numero): + ''' + Esta función devuelve el factorial del número pasado como parámetro. + En caso de que no sea de tipo entero y/o sea menor que 0, debe retornar nulo. ok + Recibe un argumento: + numero: Será el número con el que se calcule el factorial + Ej: + Factorial(4) debe retornar 24 + Factorial(-2) debe retornar nulo + Factorial(0) debe retornar 1 + ''' + #Tu código aca: + if (type(numero) != int) or (numero < 0): + print('El numero no pertence a los enteros positivos.') + return None + + import math + + factorial = math.factorial(numero) + print(factorial) + return factorial + +#Factorial(9) +#Factorial(4) +#Factorial(-2) +#Factorial(0) + +# O.K. tested & ok + + +def ListaPrimos(desde, hasta): + ''' + Esta función devuelve una lista con los números primos entre los valores "desde" y "hasta" + pasados como parámetro, siendo ambos inclusivos. + + En caso de que alguno de los parámetros no sea de tipo entero y/o no sea mayor a cero, + debe retornar nulo. ok + + En caso de que el segundo parámetro sea mayor al primero, pero ambos mayores que cero, + debe retornar una lista vacía. ok + + Recibe un argumento: + desde: Será el número a partir del cual se toma el rango + hasta: Será el número hasta el cual se tome el rango + + Ej: + ListaPrimos(7,15) debe retornar [7,11,13] + ListaPrimos(100,99) debe retornar [] + ListaPrimos(1,7) debe retonan [1,2,3,5,7] + ''' + #Tu código aca: + + # 1. En caso de que alguno de los parámetros no sea de tipo entero y/o no sea mayor a cero, + # debe retornar nulo. + + if(type(desde or hasta) != int) or ((desde or hasta) < 0): + print('Valores no son enteros reales positivos.') + return None + + # 2. En caso de que el segundo parámetro sea mayor al primero, pero ambos mayores que cero, + # debe retornar una lista vacía. + # entiendo que hay un error en la consigna, si no deberíamos utilizar valores absolutos ya que la cuenta seria regresiva en -1, -2, -3 etc + # y supongo que lo que no quiere es que hagamos esto. obtener un desplazamiento negatico coodenada final(hasta) menos inicial(desde).. + + if desde > hasta: + print('Parametros incorrectos.El valor "desde" debe ser menor que "hasta".') + return [] + + + # 3. Esta función devuelve una lista con los números primos entre los valores "desde" y "hasta" + # pasados como parámetro, siendo ambos inclusivos. + + # 3.1 Desde" y "hasta" pasados como parámetro, siendo ambos inclusivos. + + lista_a_analizar = range(desde,hasta+1) + lista_ya_analizados = [] + es_primo = True + lista_primos = [] + import math + + for elemento in lista_a_analizar: + for i in range(2,elemento): + if (elemento % i == 0): + es_primo = False + break + else: + es_primo = True + lista_primos.append(elemento) + break + + print(lista_primos) + return lista_primos + +#ListaPrimos(7,15) +#ListaPrimos(100,99) +#ListaPrimos(1,7) +#ListaPrimos(4,150) #prueba extra + +# O.K. tested & Chequed! + + + + + +def ListaRepetidos(lista): + ''' + Esta función recibe como parámetro una lista y devuelve una lista de tuplas donde cada + tupla contiene un valor de la lista original y las veces que se repite. Los valores + de la lista original no deben estar repetidos. + Debe respetarse el orden original en el que aparecen los elementos. + + En caso de que el parámetro no sea de tipo lista debe retornar nulo. ok + + Recibe un argumento: + lista: Será la lista que se va a evaluar. + Ej: + ListaRepetidos([]) debe retornar [] + ListaRepetidos(['hola', 'mundo', 'hola', 13, 14]) + debe retornar [('hola',2),('mundo',1),(13,1),(14,1)] + ListaRepetidos([1,2,2,4]) debe retornar [(1,1),(2,2),(4,1)] + ''' + #Tu código aca: + + # 1. Esta función recibe como parámetro una lista ; En caso de que el parámetro no sea de tipo lista debe retornar nulo. ok + if type(lista) != list: + print('El parámetro ingresado no es una Lista.') + return None + + # 2. Devuelve una lista de tuplas donde cada + # tupla contiene un valor de la lista original y las veces que se repite. + # Los valores de la lista original no deben estar repetidos. + # Debe respetarse el orden original en el que aparecen los elementos. + lista_ya_analizados = list() + for elemento in lista: + if (type(elemento) != list): + + if (elemento not in lista_ya_analizados): + lista_ya_analizados.append(elemento) + else: + pass + + if type(elemento) == list: + ListaRepetidos(elemento) + print('Lista de elementos unicos encontrados:') + print(lista_ya_analizados) + + lista_cant_de_repeticiones = [] + + for elemento2 in lista_ya_analizados: + cantidad_de_repes_del_elemento2 = lista.count(elemento2) + lista_cant_de_repeticiones.append(cantidad_de_repes_del_elemento2) + + print(lista_cant_de_repeticiones) + + #conversion a tupla + respuesta = list(zip (lista_ya_analizados,lista_cant_de_repeticiones)) + print(respuesta) + return respuesta + + +#ListaRepetidos([]) +#ListaRepetidos(['hola', 'mundo', 'hola', 13, 14]) +#ListaRepetidos([1,2,2,4]) +#ListaRepetidos(ListaDeListas([1,[2,3,4,2,['l','k','j'],1,'q','w',],2,2,4,])) #extra prueba + +# O.K. Tested ok chequed + + + +def ClaseVehiculo(tipo, color): + ''' + Esta función devuelve un objeto instanciado de la clase Vehiculo, + la cual debe tener los siguientes atributos: + + Tipo: Un valor dentro de los valores posibles: ['auto','camioneta','moto'] + Color: Un valor de tipo de dato string. + Velocidad: Un valor de tipo de dato float, que debe inicializarse en cero. + + y debe tener el siguiente método: + + Acelerar(): Este método recibe un parámetro con el valor que debe incrementar a la + propiedad Velocidad y luego retornarla. + Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero. + Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien. + + Recibe dos argumento: + tipo: Dato que se asignará al atributo Tipo del objeto de la clase Vehiculo + color: Dato que se asignará al atributo Color del objeto de la clase Vehiculo + + Ej: + a = ClaseVehículo('auto','gris') + a.Acelerar(10) -> debe devolver 10 + a.Acelerar(15) -> debe devolver 25 + a.Acelerar(-10) -> debe devolver 15 + ''' + #Tu código aca: + lista_tipos_permitidos = ['auto','camioneta','moto'] + + # Validaciones al crear la CLASE: + + if tipo not in lista_tipos_permitidos: + print('Error al crear la clase, este tipo de vehiculo no se permite crear, solo estos se pueden: ("auto", "camioneta", "moto").') + print('Error al crear vehiculo.') + return None + + if type(color) != str: + print('El dato "color" no es un str.') + print('Error al crear vehiculo.') + return None + + tipo = tipo + color = color + + # Creando un vehiculo + # Para ello debe existir primero la clase dentro de la funcion. + # de manera que siempre exista dentro del paquete de la funcion si esta se exporta. + class Vehicle: + ''' + Clase Veiculos dentro de funcion crear vehiculo. + ''' + def __init__(self,tipo,color,velocidad = float(0)): + + self.tipo = tipo + self.color = color + self.velocidad = float() + self.incremento_velocidad = float(0) + + def Acelerar(self,incremento_velocidad = float(0)): + """ + Este método recibe un parámetro con el valor que debe incrementar a la + propiedad Velocidad y luego retornarla. + + Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero. + + Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien. + """ + velocidad_inicial = self.velocidad + velocidad_final = velocidad_inicial + incremento_velocidad + + if velocidad_final > 100: + velocidad_final = 100 + self.velocidad = velocidad_final + return self.velocidad + elif velocidad_final < 0: + velocidad_final = 0 + self.velocidad = velocidad_final + return self.velocidad + else: + self.velocidad = velocidad_final + return self.velocidad + + def PropiedadesDelVehiculo(self,tipo,color,velocidad): + print(tipo) + print(color) + print(velocidad) + return tipo , color, velocidad + + vehiculo_creado = Vehicle(tipo,color) + return vehiculo_creado + +#a = ClaseVehiculo('auto','gris') +#print(a) +#print(a.Acelerar(10)) +#print(a.Acelerar(15)) +#print(a.Acelerar(-10)) + +# O.K. tested ok checked + + + +def OrdenarDiccionario(diccionario_par, clave, descendente=bool(True)): + ''' + Esta función recibe como parámetro un diccionario, + cuyas listas de valores tienen el mismo tamaño y + sus elementos enésimos están asociados. + + Y otros dos parámetros que indicanla clave por la cual debe ordenarse y si es descendente o ascendente. + + La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la + relación entre los elementos enésimos. + + Recibe tres argumentos: + diccionario: Diccionario a ordenar. + clave: Clave del diccionario recibido, por la cual ordenar. + descendente: Un valor booleano, que al ser verdadero indica ordenamiento ascendente y + descendente si es falso. + Debe tratarse de un parámetro por defecto en True. + + Si el parámetro diccionario no es un tipo de dato diccionario ok + ó el parámetro clave no se encuentra dentro de las claves del diccionario, debe devolver nulo. ok + + Ej: + + dicc = {'clave1':['c','a','b'], + 'clave2':['casa','auto','barco'], + 'clave3':[1,2,3]} + OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'], + 'clave2':['auto','barco','casa'], + 'clave3':[2,3,1]} + OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['b','a','c'], + 'clave2':['barco','auto','casa'], + 'clave3':[3,2,1]} + ''' + #Tu código aca: + + + # Si el parámetro diccionario no es un tipo de dato diccionario + # ó el parámetro clave no se encuentra dentro de las claves del diccionario, debe devolver nulo. + + if (type(diccionario_par) != dict) | (clave not in diccionario_par): + print('El parámetro recibido como diccionario, no lo es en cuanto a tipo de dato.') + print('O la clave ingresada no se encuentra dentro de las claves posivbles del diccionario.') + return None + + # valido longitud en ambas deirecciones de la matriz diccionario: + #cantidadd de claves como de elementos, a su vez, dentro de las claves.') + + """ + dicc = { 'clave1': ['c','a','b'], + 'clave2': ['casa','auto','barco'], + 'clave3': [1,2,3]} + + OrdenarDiccionario(dicc, 'clave1') + """ + + + for i in diccionario_par: + if i == clave: + for j in diccionario_par: + if descendente == False: + diccionario_par[j].sort() + if descendente == True: + diccionario_par[j].sort(reverse=True) + + + print(diccionario_par) + return diccionario_par + + +# OrdenarDiccionario(dicc, 'clave3',True) +# OrdenarDiccionario(dicc, 'clave3',False) +# OrdenarDiccionario(dicc, 'clave1',True) +#OrdenarDiccionario(dicc, 'clave4',False) + +#checked OK. tested OK. \ No newline at end of file diff --git a/Workbench/Taller/EjerciciosVarios.py b/Workbench/Taller/EjerciciosVarios.py new file mode 100644 index 000000000..c7d89db4a --- /dev/null +++ b/Workbench/Taller/EjerciciosVarios.py @@ -0,0 +1,50 @@ +# Ejercicio 1 - Obtener la inversa de un string +# Invertir cualquier cadena de caracteres + +cadena1 = "cebolla" # R=> allobec +cadena2 = "somos" # R=> 'somos', es palíndroma + +for i in range(len(cadena1) -1, -1, -1): + print (cadena1[i], end="") + +print() + +# Ejercicio 2 - Palabra inversa, caso PALÍNDROMO (se lee igual al revés) +# Detectar si es palíndromo y mandar un mensaje + +cadena3 = "coco" # R=> ococ +cadena4 = "reconocer" # R=> 'reconocer', es palíndroma +pali = [] +pali2 = [] +for i in range(len(cadena3) -1, -1, -1): + pali.append(cadena3[i]) +for j in range(len(pali)-1, -1, -1): + pali2.append(pali[j]) +#print (pali) # Se puede eliminar, es sólo para controlar la salida y sirven de manejo de errores +#print (pali2) # Se puede eliminar, es sólo para controlar la salida y sirven de manejo de errores +if (pali == pali2): + print ("Felicitaciones", cadena3, "es un palíndromo", end="") +else: + print ("La palabra","'", cadena3,"'", "no es palíndroma e invertida, es", pali, end="") +print() + +# Ejercicio 3 - Palabra inversa usando propiedades del método print - SLICING +print ('') +cadena= 'Pepino' +print (cadena[::-1]) # '::' Indica de 0 hasta el último de los caracteres, + # para variantes, funciona igual que los indices separados + # por ':', con un desde y hasta, finalmente el '-1', le + # indica al método que es en orden inverso. + +# Ejercicio 4 - Ordenar una lista de cadenas de caracteres según el último carácter con la +# función sorted() +# + +# Creamos un diccionario dic_cadenas y que almacena 8 str (ciudades) +# + +dic_cadenas = ['Talca', 'París', 'Londres', 'Bogotá', 'San José', 'Santiago', 'Lima', 'Sao Paulo'] +print (dic_cadenas) + +print() + diff --git a/Workbench/Taller/EstructurasControl.py b/Workbench/Taller/EstructurasControl.py new file mode 100644 index 000000000..36623ca54 --- /dev/null +++ b/Workbench/Taller/EstructurasControl.py @@ -0,0 +1 @@ +# Uso de IF/ELIF/ELSE, FOR, WHILE, otros ciclos diff --git a/Workbench/Taller/FuncionFactorial.py b/Workbench/Taller/FuncionFactorial.py new file mode 100644 index 000000000..33750e301 --- /dev/null +++ b/Workbench/Taller/FuncionFactorial.py @@ -0,0 +1,22 @@ +#def factorizar_numero(numero): +# if (type(numero) != int): +# return None +# if (numero < 0): +# return None +# factorial = 1 +# for n in range(1, (numero)+1): +# factorial = factorial * n +# return factorial + +#factorizar_numero() +def factorial(n): + if (n <1): + return None + elif n==0 or n==1: + resultado=1 + if n>1: + resultado=n*factorial(n-1) + return resultado + +fact=factorial(0) +print (fact) \ No newline at end of file diff --git a/Workbench/Taller/Funciones.py b/Workbench/Taller/Funciones.py new file mode 100644 index 000000000..82282c2f9 --- /dev/null +++ b/Workbench/Taller/Funciones.py @@ -0,0 +1,43 @@ +#******************************************************************* +#* * +#* B I E N V E N I D O A F U N C I O N E S * +#* * +#******************************************************************* +# Una función es una operación o procedimiento que retorna un valor o acción +# Se declaran con la palabra reservada 'def' y se cierra con ':', debe incluir 'return' y la logica +# del cálculo o lo que hace la función. +# Operaciones o métodos habituales como insert, append, sort...son funciones, porque hacen o retornan cosas. +# Para usar la función, le paso los parámetros definidos, ojo con los tipos y el control de las excepciones + +# Ejemplo 1 +def misuma (a,b): # Esta es una función, toma dos enteros a,b y los suma + """ + Los valores deben ser números + """ + suma =a+b + return suma # El calculo viene después de la palabra return +print (misuma(5,6)) + +res= misuma (2,3) # Uso la función, le paso los parámetros 2,3 y, el resultado lo almaceno en la variable res +print ("Resultado de sumar 2 y 3, es ", res) # Puedo ver su contenido con un print + +# Ejemplo 2 +# min y max son funciones integradas en Python que nos devuelven +# los valores mínimo y máximo de un iterable (como las listas o las tuplas) +def min_y_max(lista): # Declaro la función y le digo que le pasaré un argumento de tipo lista + return min(lista), max(lista) # Usando la funciones min y max que pertenecen a objetos iterables + # obtengo los valores y los devuelvo + +# ahora vamos a usar estas funciones +valor = misuma(10, 15) +print("Usando la función 'misuma', el resultado de sumar 10 y 15 es ", valor) + +minimo, maximo = min_y_max([30, 10, 50, 40, 20]) +print("Para el vector 30,10,50,40 y 20, los ",f'min y max son {minimo} y {maximo}') + +# Ejemplo 3 #Lo veremos más adelante +# En este ejemplo, creamos una función que realiza un test unitario +#def test_OrdenarDiccionario_03(self): +# dicc = {'clave1':['c','a','b'], 'clave2':['casa','auto','barco'], 'clave3':[3,1,2]} +# valor_test = ch.OrdenarDiccionario(dicc, 'clave3', False) +# valor_esperado = {'clave1':['b','a','c'], 'clave2':['barco','auto','casa'], 'clave3':[3,2,1]} \ No newline at end of file diff --git a/Workbench/Taller/HC280123.ipynb b/Workbench/Taller/HC280123.ipynb new file mode 100644 index 000000000..2091cee27 --- /dev/null +++ b/Workbench/Taller/HC280123.ipynb @@ -0,0 +1,564 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3, 6, 9]\n" + ] + } + ], + "source": [ + "# LISTA DIVISIBLES\n", + "\n", + "# ListaDivisibles(12, 10)\n", + "# lista_esperada = []\n", + "\n", + "# ListaDivisibles(12, 100)\n", + "# lista_esperada = [12,24,36,48,60,72,84,96]\n", + "\n", + "# ListaDivisibles(3, 9)\n", + "# lista_esperada = [3,6,9]\n", + "\n", + "def ListaDivisibles(numero, tope):\n", + " '''\n", + " Esta función devuelve una lista ordenada de menor a mayor con los números divisibles \n", + " por el parámetro número entre uno (1) y el valor del parámetro \"tope\"\n", + " Recibe dos argumentos:\n", + " numero: Numero entero divisor\n", + " tope: Máximo valor a evaluar a partir de uno (1)\n", + " Ej:\n", + " ListaDivisibles(6,30) debe retornar [6,12,18,24,30]\n", + " ListaDivisibles(10,5) debe retornar []\n", + " ListaDivisibles(7,50) debe retornar [7,14,21,28,35,42,49]\n", + " '''\n", + " #Tu código aca:\n", + " lint = list(range(numero,tope+1))\n", + " ldiv = []\n", + " \n", + " if numero > tope:\n", + " print(ldiv)\n", + " return ldiv\n", + " if numero <= 0:\n", + " print(str(numero) + ', que corresponde a ser el divisor, NO puede ser = 0.')\n", + " return None\n", + " for i in lint:\n", + " if (i % numero) == 0:\n", + " ldiv.append(i)\n", + " ldiv.sort(reverse=False)\n", + " print(ldiv) \n", + " return ldiv\n", + " \n", + "lista_divisible=ListaDivisibles(3, 9)\n", + " # 12, 10 []\n", + " # 12. 100 [12,24,36,48,60,72,84,96]\n", + " # 3, 9 [3,6,9]\n", + "\n", + "# Test OK!" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1000" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Exponente(10, 2)\n", + "# valor_esperado = 100\n", + "# Exponente(49, 0.5)\n", + "# valor_esperado = 7\n", + "# Exponente(3, 0)\n", + "# valor_esperado = 1\n", + " \n", + "def Exponente(numero, exponente):\n", + " '''\n", + " Esta función devuelve el resultado de elevar el parámetro \"numero\" al parámetro \"exponente\"\n", + " Recibe dos argumentos:\n", + " numero: El número base en la operación exponencial\n", + " exponente: El número exponente en la operación exponencial\n", + " Ej:\n", + " Exponente(10,3) debe retornar 1000\n", + " '''\n", + " #Tu código aca:\n", + " res=numero**exponente\n", + " return res\n", + "Exponente(10,3)\n", + "\n", + "# Test OK!" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#\n", + "def ListaDeListas(lista):\n", + " '''\n", + " Esta función recibe una lista, que puede contener elementos que a su vez sean listas y\n", + " devuelve esos elementos por separado en una lista única. \n", + " En caso de que el parámetro no sea de tipo lista, debe retornar nulo.\n", + " Recibe un argumento:\n", + " lista: La lista que puede contener otras listas y se convierte a una \n", + " lista de elementos únicos o no iterables.\n", + " Ej:\n", + " ListaDeListas([1,2,['a','b'],[10]]) debe retornar [1,2,'a','b',10]\n", + " ListaDeListas(108) debe retornar el valor nulo.\n", + " ListaDeListas([[1,2,[3]],[4]]) debe retornar [1,2,3,4]\n", + " '''\n", + " #Tu código aca:\n", + " if type(lista) != list:\n", + " return None\n", + " else:\n", + " guardaLdeL=[]\n", + " for elem in lista:\n", + " if isinstance(elem, list):\n", + " guardaLdeL.extend(ListaDeListas(elem))\n", + " else:\n", + " guardaLdeL.append(elem)\n", + " return guardaLdeL\n", + "ListaDeListas ([[[1]],2,[[[[3]]]]])\n", + "# ListaDeListas(100)\n", + "# lista_esperada = None\n", + "# # ListaDeListas([1,[2,3],[[4,5],6],[[7]]])\n", + "# lista_esperada = [1,2,3,4,5,6,7]\n", + "# # ListaDeListas(['a','b',1,2,['a1','b3'],[['a'],2]])\n", + "# lista_esperada = ['a','b',1,2,'a1','b3','a',2]\n", + "# # ListaDeListas([[[1]],2,[[[[3]]]]])\n", + "# lista_esperada = [1,2,3] \n", + "# Test OK!" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "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 0, 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", + " Factorial(0) debe retornar 1\n", + " '''\n", + " #Tu código aca:\n", + " if (type(numero) != int):\n", + " return None\n", + " if (numero < 0):\n", + " return None\n", + " factorial = 1\n", + " for n in range(1, (numero)+1):\n", + " factorial = factorial * n\n", + " return factorial\n", + " \n", + "Factorial(1)\n", + "\n", + "# Test 1 Factorial(5) OK\n", + "# valor_esperado = 120\n", + "# Test 2 Factorial(1) OK\n", + "# valor_esperado = 1 \n", + "# Test 3 Factorial(0) OK\n", + "# valor_esperado = 1\n", + "# Test 4 Factorial(9) OK\n", + "# valor_esperado = 362880" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "120" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def Factorial(numero):\n", + " if (type(numero) != int):\n", + " return None\n", + " if (numero < 0):\n", + " return None\n", + " f = 1\n", + " for n in range(1, (numero)+1):\n", + " f = f * n\n", + " return f\n", + "\n", + "Factorial(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[67, 71, 73]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def ListaPrimos(desde, hasta):\n", + " '''\n", + " Esta función devuelve una lista con los números primos entre los valores \"desde\" y \"hasta\"\n", + " pasados como parámetro, siendo ambos inclusivos.\n", + " En caso de que alguno de los parámetros no sea de tipo entero y/o no sea mayor a cero, debe retornar nulo.\n", + " En caso de que el segundo parámetro sea menor al primero, pero ambos mayores que cero,\n", + " debe retornar una lista vacía.\n", + " Recibe un argumento:\n", + " desde: Será el número a partir del cual se toma el rango\n", + " hasta: Será el número hasta el cual se tome el rango\n", + " Ej:\n", + " ListaPrimos(7,15) debe retornar [7,11,13]\n", + " ListaPrimos(100,99) debe retornar []\n", + " ListaPrimos(1,7) debe retonan [1,2,3,5,7]\n", + " '''\n", + " #Tu código aca:\n", + " lp=[]\n", + " # Ciclos 'if' Validar las variables de entrada\n", + " if (type(desde) != int or type(hasta) != int):\n", + " return None\n", + " if (desde < 0 or hasta < 0):\n", + " return None\n", + " if (desde > hasta):\n", + " return lp \n", + " def calculaPrimo(num):\n", + " if num==2:\n", + " return True\n", + " for n in range (2,num):\n", + " if(num%n!=0):\n", + " continue\n", + " else:\n", + " return False\n", + " return True\n", + " for i in range(desde,(hasta+1)):\n", + " if calculaPrimo(i):\n", + " lp.append(i)\n", + " return lp\n", + "\n", + "ListaPrimos(66,77)\n", + "# Test_01 ListaPrimos(1,11)\n", + "# Lista_esperada = [1,2,3,5,7,11] OK!\n", + "# Test_02 ListaPrimos('0',0)\n", + "# Lista_esperada = None OK!\n", + "# Test_03 ListaPrimos(66,77)\n", + "# Lista_esperada = [67, 71, 73] OK!\n", + "# Test__04 ListaPrimos(0,'66')\n", + "# Lista_esperada = None\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(1, 1), (2, 2), (4, 1)]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def ListaRepetidos(lista):\n", + " '''\n", + " Esta función recibe como parámetro una lista y devuelve una lista de tuplas donde cada \n", + " tupla contiene un valor de la lista original y las veces que se repite. Los valores \n", + " de la lista original no deben estar repetidos. \n", + " Debe respetarse el orden original en el que aparecen los elementos.\n", + " En caso de que el parámetro no sea de tipo lista debe retornar nulo.\n", + " Recibe un argumento:\n", + " lista: Será la lista que se va a evaluar.\n", + " Ej:\n", + " ListaRepetidos([]) debe retornar []\n", + " ListaRepetidos(['hola', 'mundo', 'hola', 13, 14]) \n", + " debe retornar [('hola',2),('mundo',1),(13,1),(14,1)]\n", + " ListaRepetidos([1,2,2,4]) debe retornar [(1,1),(2,1),(4,1)]\n", + " '''\n", + " #Tu código aca:\n", + " swap=[]\n", + " if type(lista) != list:\n", + " return None\n", + " while len(lista)>0:\n", + " eleTup=lista[0]\n", + " contador=lista.count(lista[0])\n", + " swap.append((eleTup,contador))\n", + " for i in range(lista.count(lista[0])):\n", + " lista.remove(eleTup)\n", + " continue\n", + " return swap\n", + "\n", + "ListaRepetidos([1,2,2,4])\n", + "# Test_01 ListaRepetidos (['hola', 'mundo', 'hola'])\n", + "# Lista_esperada = [('hola',2),('mundo',1)]\n", + "# Test_02 ListaRepetidos ([10,11,11,12,15,17,20,20])\n", + "# Lista_esperada = [(10,1),(11,2),(12,1),(15,1),(17,1),(20,2)]\n", + "# Test_03 ListaRepetidos ((1,2,3,3))\n", + "# Lista_esperada = None" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def ClaseVehiculo(tipo, color):\n", + " '''\n", + " Esta función devuelve un objeto instanciado de la clase Vehiculo, \n", + " la cual debe tener los siguientes atributos:\n", + " Tipo: Un valor dentro de los valores posibles: ['auto','camioneta','moto']\n", + " Color: Un valor de tipo de dato string.\n", + " Velocidad: Un valor de tipo de dato float, que debe inicializarse en cero.\n", + " y debe tener el siguiente método:\n", + " Acelerar(): Este método recibe un parámetro con el valor que debe incrementar a la\n", + " propiedad Velocidad y luego retornarla.\n", + " Si la propiedad Velocidad cobra un valor menor a cero, debe quedar en cero.\n", + " Si la propiedad Velocidad cobra un valor mayor a cien, debe quedar en cien.\n", + " Recibe dos argumento:\n", + " tipo: Dato que se asignará al atributo Tipo del objeto de la clase Vehiculo\n", + " color: Dato que se asignará al atributo Color del objeto de la clase Vehiculo\n", + " Ej:\n", + " a = ClaseVehículo('auto','gris')\n", + " a.Acelerar(10) -> debe devolver 10\n", + " a.Acelerar(15) -> debe devolver 25\n", + " a.Acelerar(-10) -> debe devolver 15\n", + " '''\n", + " #Tu código aca:\n", + " class Vehiculo:\n", + " def __init__(self, tipo, color):\n", + " if (tipo=='auto' or tipo =='camioneta' or tipo=='moto'):\n", + " self.Tipo = tipo\n", + " else:\n", + " raise TypeError ('el tipo de vehículo tiene que ser auto, camioneta o moto')\n", + " self.Color = color\n", + " self.Velocidad = 0\n", + "\n", + " def Acelerar(self, acel):\n", + " self.Velocidad += acel\n", + " if self.Velocidad < 0:\n", + " self.Velocidad=0\n", + " if self.Velocidad>100:\n", + " self.Velocidad=100\n", + " return self.Velocidad\n", + " \n", + " a = Vehiculo(tipo, color) \n", + " return a\n", + "\n", + "# Test_01 ClaseVehiculo('auto','verde')\n", + "# valor_test = a.Acelerar(10)\n", + "# valor_test = a.Acelerar(100)\n", + "# valor_test = a.Acelerar(-20)\n", + "# valor_esperado = 80\n", + "# self.assertEqual(valor_test, valor_esperado)\n", + "# Test_02 ClaseVehiculo('camioneta','azul')\n", + "# valor_test = a.Acelerar(20)\n", + "# valor_test = a.Acelerar(-30)\n", + "# valor_esperado = 0\n", + "# Test_03 ClaseVehiculo('moto','negra')\n", + "# valor_test = a.Acelerar(10)\n", + "# valor_test = a.Acelerar(100)\n", + "# valor_esperado = 100\n", + "\n", + "a= ClaseVehiculo ('auto','verde')\n", + "\n", + "a.Acelerar(10) #debe devolver 10\n", + "a.Acelerar(15) #debe devolver 25\n", + "a.Acelerar(-10) " + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "list indices must be integers or slices, not str", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[76], line 74\u001b[0m\n\u001b[0;32m 71\u001b[0m \u001b[39mreturn\u001b[39;00m diccionario_par\n\u001b[0;32m 72\u001b[0m \u001b[39mreturn\u001b[39;00m res\n\u001b[1;32m---> 74\u001b[0m OrdenarDiccionario(dicc, \u001b[39m'\u001b[39;49m\u001b[39mclave1\u001b[39;49m\u001b[39m'\u001b[39;49m) \n", + "Cell \u001b[1;32mIn[76], line 68\u001b[0m, in \u001b[0;36mOrdenarDiccionario\u001b[1;34m(diccionario_par, clave, descendente)\u001b[0m\n\u001b[0;32m 66\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m0\u001b[39m, cantidadValores):\n\u001b[0;32m 67\u001b[0m newArr2\u001b[39m.\u001b[39mappend(newArrSorted[i][key])\n\u001b[1;32m---> 68\u001b[0m res[key] \u001b[39m=\u001b[39m newArr2\n\u001b[0;32m 69\u001b[0m \u001b[39m#Si no tienen valores devolvemos el mismo diccionario:\u001b[39;00m\n\u001b[0;32m 70\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 71\u001b[0m \u001b[39mreturn\u001b[39;00m diccionario_par\n", + "\u001b[1;31mTypeError\u001b[0m: list indices must be integers or slices, not str" + ] + } + ], + "source": [ + "def OrdenarDiccionario(diccionario_par, clave, descendente=True):\n", + " '''\n", + " Esta función recibe como parámetro un diccionario, cuyas listas de valores tienen el mismo\n", + " tamaño y sus elementos enésimos están asociados. Y otros dos parámetros que indican\n", + " la clave por la cual debe ordenarse y si es descendente o ascendente.\n", + " La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la\n", + " relación entre los elementos enésimos.\n", + " Recibe tres argumentos:\n", + " diccionario: Diccionario a ordenar.\n", + " clave: Clave del diccionario recibido, por la cual ordenar.\n", + " descendente: Un valor booleano, que al ser verdadero indica ordenamiento ascendente y \n", + " descendente si es falso. \n", + " Debe tratarse de un parámetro por defecto en True.\n", + " Si el parámetro diccionario no es un tipo de dato diccionario ó el parámetro clave no \n", + " se encuentra dentro de las claves del diccionario, debe devolver nulo.\n", + " Ej:\n", + " dicc = {'clave1':['c','a','b'],\n", + " 'clave2':['casa','auto','barco'],\n", + " 'clave3':[1,2,3]}\n", + " OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'],\n", + " 'clave2':['auto','barco','casa'],\n", + " 'clave3':[2,3,1]}\n", + " OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['b','a','c'],\n", + " 'clave2':['barco','auto','casa'],\n", + " 'clave3':[3,2,1]}\n", + " '''\n", + " #Tu código aca:\n", + " # Variables a usar, incluye nuevas listas auxiliares para hacer los arreglos de swap, sin perder la hilación.\n", + " cantidadValores=0 # Recibe valores del diccionario en el proceso de pasarlo a Lista de diccs\n", + " numKeys=0 # Recibe n elementos del tipo llave que tiene el diccionario DICC, para ejecutar los ciclos. \n", + " newArr=[] \t\t # Va a recibir mi lista de diccionarios originales convertidos a listas\n", + " newArrSorted=[] # Va a recibir los diccionarios ordenados por la clave ingresada\n", + " res =[]\n", + " if not (type(diccionario_par) is dict): # diccionario_par= Parámetro que recibe un DICT\n", + "\t return 'Null' # Si el parámetro, no es de tipo diccionario, retorna 'null'\n", + " if not (clave in diccionario_par.keys()): # Si la clave recibiba como parámetro no existe, retorna null\n", + "\t return 'Null' # descendente=True ==> Orden ASCENDENTE, es al revés, FALSE==> DESCENDENTE \n", + " \n", + " # Este es un problema de Un diccionario de listas que debe ser transformado en una lista de diccionarios para poder\n", + " # ser maniplado con los métodos de 'list'. Al final, se debe convertir a DICT nuevamente.\n", + " # Convertimos el dicc de list a list de dict\n", + "\n", + " #print (len(diccionario_par[list(diccionario_par.keys())[0]]))\n", + " # chequeamos qué valor estamos reciendo\n", + " #print()\n", + " if len(diccionario_par[list(diccionario_par.keys())[0]])>0: \n", + " cantidadValores=len(diccionario_par[list(diccionario_par.keys())[0]])\n", + " # convertimos el diccionario de listas, a una lista de diccionarios:\t\n", + " for i in range(0, cantidadValores):\n", + " newObj={}\n", + " for key in diccionario_par:\n", + " newObj[key]=diccionario_par[key][i]\n", + " newArr.append(newObj)\n", + " #print(newArr) Aquí se generó una lista de diccionarios\n", + " # Ahora ordenemos\n", + " newArrSorted = sorted(newArr, key=lambda d: d[clave], reverse=not (descendente))\n", + " # print (newArrSorted) #verificar contenido del nuevo arreglo\n", + " # Convertimos la lista de diccionarios, en un diccionario de listas:\n", + " for key in diccionario_par:\n", + " newArr2 = []\n", + " for i in range(0, cantidadValores):\n", + " newArr2.append(newArrSorted[i][key])\n", + " res[key] = newArr2\n", + " #Si no tienen valores devolvemos el mismo diccionario:\n", + " else:\n", + " return diccionario_par\n", + " \n", + " return res\n", + "dicc = {\n", + " 'clave1':['c','a','b'],\n", + " 'clave2':['casa','auto','barco'],\n", + " 'clave3':[1,2,3]\n", + " }\n", + "OrdenarDiccionario(dicc, 'clave1') " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Workbench/Taller/HW08_POO_Sol.py b/Workbench/Taller/HW08_POO_Sol.py new file mode 100644 index 000000000..b411e5ab9 --- /dev/null +++ b/Workbench/Taller/HW08_POO_Sol.py @@ -0,0 +1,352 @@ + +# 1) Crear la clase vehículo que contenga los atributos: +# 'Color' +# 'Tipo' (Si es moto, auto, camioneta ó camión) +# 'Cilindrada' (en decimal, e.g. 1200cc = 1.2 cc de motor) + +class Vehiculo: + def __init__(self, color, tipo, cilindrada): + self.color = color + self.tipo = tipo + self.cilindrada = cilindrada + +# 2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos: +# Acelerar => El ejercicio no lo dice, pero necesito crear lo atributos que usaré +# Frenar para mostrar que mi objeto vehículo acelera y frena. +# Doblar Las acciones requieren de respectivo atributo, si doblo (acción), +# necesito que se refiera a un atributo de la clase, en este caso +# la 'dirección' o rumbo que lleva el móvil. + +class Vehiculo: + def __init__(self, color, tipo, cilindrada): + self.color = color + self.tipo = tipo + self.cilindrada = cilindrada + self.velocidad = 0 # Aquí creamos el atributo velocidad, no se requieren 2 + self.direccion = 0 # Aquí creamos el atributo velocidad + + def Acelerar(self, vel): # Recibe un parámetro velocidad + self.velocidad += vel # Este es método que modifica el atributo velocidad + + def Frenar(self, vel): # Recibe un parámetro velocidad, es sólo un valor + self.velocidad -= vel # Calcula la nueva velocidad + + def Doblar(self, grados): # Recibe la cantidad de grados del giro (0-360) + self.direccion += grados # Calcula la nueva dirección + +# 3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado + +a1 = Vehiculo ('rojo', 'auto', 2) +a2 = Vehiculo ('blanco', 'camioneta', 3.6) +a3 = Vehiculo ('negro', 'moto', 1) + +a1.Acelerar(40) # Si se hace un print se verá que el contenido de los atributos +a2.Acelerar(60) # velocidad y dirección, han cambiado +a3.Acelerar(30) # Para mostrar el contenido del atributo usar la sentencia +a1.Doblar(30) +a3.Doblar(-30) +a2.Frenar(-50) + +# 4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada + +class Vehiculo: + def __init__(self, color, tipo, cilindrada): + self.color = color + self.tipo = tipo + self.cilindrada = cilindrada + self.velocidad = 0 + self.direccion = 0 + + def Acelerar(self, vel): + self.velocidad += vel + + def Frenar(self, vel): + self.velocidad -= vel + + def Doblar(self, grados): + self.direccion += grados + + def Estado(self): + print('La velocidad actual es :', self.velocidad, '- y su rumbo actual es:', self.direccion, 'grados') + + def Detalle(self): + print('Soy del tipo ', self.tipo, 'de color', self.color, 'y mi cilindrada es de', self.cilindrada, 'litros') + +a1 = Vehiculo('rojo', 'auto', 2) +a1.Detalle() + +a1.Estado() +a1.Acelerar(30) +a1.Estado() + + +# 5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 6
+# Verificar Primo
+# Valor modal
+# Conversión grados
+# Factorial
+ +# In[33]: + + +class Herramientas: + def __init__(self) -> None: + pass + + def verifica_primo(self, nro): + es_primo = True + for i in range(2, nro): + if nro % i == 0: + es_primo = False + break + return es_primo + + def valor_modal(self, lista, menor): + lista_unicos = [] + lista_repeticiones = [] + if len(lista) == 0: + return None + if (menor): + lista.sort() + else: + lista.sort(reverse=True) + for elemento in lista: + if elemento in lista_unicos: + i = lista_unicos.index(elemento) + lista_repeticiones[i] += 1 + else: + lista_unicos.append(elemento) + lista_repeticiones.append(1) + moda = lista_unicos[0] + maximo = lista_repeticiones[0] + for i, elemento in enumerate(lista_unicos): + if lista_repeticiones[i] > maximo: + moda = lista_unicos[i] + maximo = lista_repeticiones[i] + return moda, maximo + + def conversion_grados(self, valor, origen, destino): + valor_destino = None + if (origen == 'celsius'): + if (destino == 'celsius'): + valor_destino = valor + elif (destino == 'farenheit'): + valor_destino = (valor * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'farenheit'): + if (destino == 'celsius'): + valor_destino = (valor - 32) * 5 / 9 + elif (destino == 'farenheit'): + valor_destino = valor + elif (destino == 'kelvin'): + valor_destino = ((valor - 32) * 5 / 9) + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'kelvin'): + if (destino == 'celsius'): + valor_destino = valor - 273.15 + elif (destino == 'farenheit'): + valor_destino = ((valor - 273.15) * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + else: + print('Parámetro de Destino incorrecto') + else: + print('Parámetro de Origen incorrecto') + return valor_destino + + def factorial(self, numero): + if(type(numero) != int): + return 'El numero debe ser un entero' + if(numero < 0): + return 'El numero debe ser pisitivo' + if (numero > 1): + numero = numero * self.factorial(numero - 1) + return numero + + +# In[34]: + + +h = Herramientas() + + +# 6) Probar las funciones incorporadas en la clase del punto 5 + +# In[28]: + + +h.verifica_primo(7) + + +# In[29]: + + +listado = [1,8,2,5,4,8,10,7] +moda, repe = h.valor_modal(listado, True) +print('El valor modal es', moda, 'y se reptie', repe, 'veces') + + +# In[31]: + + +h.conversion_grados(10, 'celsius', 'kelvin') + + +# In[35]: + + +h.factorial(6) + + +# 7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas + +# In[55]: + + +class Herramientas: + def __init__(self, lista_numeros): + self.lista = lista_numeros + + def verifica_primo(self): + for i in self.lista: + if (self.__verifica_primo(i)): + print('El elemento', i, 'SI es un numero primo') + else: + print('El elemento', i, 'NO es un numero primo') + + def conversion_grados(self, origen, destino): + for i in self.lista: + print(i, 'grados', origen, 'son', self.__conversion_grados(i, origen, destino),'grados',destino) + + def factorial(self): + for i in self.lista: + print('El factorial de ', i, 'es', self.__factorial(i)) + + def __verifica_primo(self, nro): + es_primo = True + for i in range(2, nro): + if nro % i == 0: + es_primo = False + break + return es_primo + + def valor_modal(self, menor): + lista_unicos = [] + lista_repeticiones = [] + if len(self.lista) == 0: + return None + if (menor): + self.lista.sort() + else: + self.lista.sort(reverse=True) + for elemento in self.lista: + if elemento in lista_unicos: + i = lista_unicos.index(elemento) + lista_repeticiones[i] += 1 + else: + lista_unicos.append(elemento) + lista_repeticiones.append(1) + moda = lista_unicos[0] + maximo = lista_repeticiones[0] + for i, elemento in enumerate(lista_unicos): + if lista_repeticiones[i] > maximo: + moda = lista_unicos[i] + maximo = lista_repeticiones[i] + return moda, maximo + + def __conversion_grados(self, valor, origen, destino): + valor_destino = None + if (origen == 'celsius'): + if (destino == 'celsius'): + valor_destino = valor + elif (destino == 'farenheit'): + valor_destino = (valor * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'farenheit'): + if (destino == 'celsius'): + valor_destino = (valor - 32) * 5 / 9 + elif (destino == 'farenheit'): + valor_destino = valor + elif (destino == 'kelvin'): + valor_destino = ((valor - 32) * 5 / 9) + 273.15 + else: + print('Parámetro de Destino incorrecto') + elif (origen == 'kelvin'): + if (destino == 'celsius'): + valor_destino = valor - 273.15 + elif (destino == 'farenheit'): + valor_destino = ((valor - 273.15) * 9 / 5) + 32 + elif (destino == 'kelvin'): + valor_destino = valor + else: + print('Parámetro de Destino incorrecto') + else: + print('Parámetro de Origen incorrecto') + return valor_destino + + def __factorial(self, numero): + if(type(numero) != int): + return 'El numero debe ser un entero' + if(numero < 0): + return 'El numero debe ser pisitivo' + if (numero > 1): + numero = numero * self.__factorial(numero - 1) + return numero + + +# In[56]: + + +h = Herramientas([1,1,2,5,8,8,9,11,15,16,16,16,18,20]) + + +# In[57]: + + +h.conversion_grados('celsius','farenheit') + + +# In[58]: + + +h.verifica_primo() + + +# In[59]: + + +moda, repe = h.valor_modal(False) +print('El valor modal es', moda, 'y se reptie', repe, 'veces') + + +# In[60]: + + +h.factorial() + + +# 8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones + +# In[1]: + + +from herramientas import * + + +# In[2]: + + +h2 = Herramientas([1,1,2,3,5,6,8,8]) + + +# In[3]: + + +h2.verifica_primo() \ No newline at end of file diff --git a/Workbench/Taller/Hello-world.py b/Workbench/Taller/Hello-world.py new file mode 100644 index 000000000..c7a3e0986 --- /dev/null +++ b/Workbench/Taller/Hello-world.py @@ -0,0 +1,2 @@ +print ("Hello World") +print ("hello", "world", 2023) diff --git a/Workbench/Taller/Herramientas.py b/Workbench/Taller/Herramientas.py new file mode 100644 index 000000000..e69de29bb diff --git a/Workbench/Taller/LibroAlumnos.py b/Workbench/Taller/LibroAlumnos.py new file mode 100644 index 000000000..dc300f7d8 --- /dev/null +++ b/Workbench/Taller/LibroAlumnos.py @@ -0,0 +1,76 @@ + +class Alumnos: + + def __init__(self): + self.nombres=[] + self.notas=[] + +# El método menu muestra una serie de opciones y solicita al usuario que +# elija una de ellas, según cual de ellas selecciona procede a llamar al método respectivo: + def menu(self): + opcion=0 + while opcion!=4: + print("1- Cargar alumnos") + print("2- Listar alumnos") + print("3- Listado de alumnos con notas mayores o iguales a 7") + print("4- Finalizar programa") + opcion=int(input("Ingrese su opcion:")) + if opcion==1: + self.cargar() + elif opcion==2: + self.listar() + elif opcion==3: + self.notas_altas() +# Algo que no utilizamos hasta ahora del lenguaje Python, es una forma +# simplificada de if anidados con la sentencia elif: + if opcion==1: + self.cargar() + elif opcion==2: + self.listar() + elif opcion==3: + self.notas_altas() +# Nosotros, hasta ahora, lo resolvíamos y podemos sin problema seguir utilizando +# la sintaxis:: + if opcion==1: + self.cargar() + else: + if opcion==2: + self.listar() + else: + if opcion==3: + self.notas_altas() +# Pero podemos comprobar que, si hay muchos if anidados la nueva sintaxis es más +# clara. +# Un ciclo WHILE, repite el método menu, mientras no se ingrese como opción en la +# variable local, el valor 4. + +# El método cargar, se llama desde el método menu, en el mismo procedemos a cargar +# las dos listas paralelas, con los nombres de alumnos y sus notas: + + def cargar(self): + for x in range(5): + nom=input("Ingrese nombre del alumno:") + self.nombres.append(nom) + no=int(input("Nota del alumno:")) + self.notas.append(no) + +# El método listar muestra las dos listas paralelas por completo e imprime una línea separadora para que se vea in forma más clara: + + def listar(self): + print("Listado completo de alumnos") + for x in range(5): + print(self.nombres[x],self.notas[x]) + print("_____________________") +# Finalmente el método notas_altas muestra solo los elementos de las listas cuyas +# notas sean igual o superior a 7: + + def notas_altas(self): + print("Alumnos con notas superiores o iguales a 7") + for x in range(5): + if self.notas[x]>=7: + print(self.nombres[x],self.notas[x]) + print("_____________________") +# bloque principal + +alumnos=Alumnos() +alumnos.menu() diff --git a/Workbench/Taller/ListaEnteros.py b/Workbench/Taller/ListaEnteros.py new file mode 100644 index 000000000..297be6e85 --- /dev/null +++ b/Workbench/Taller/ListaEnteros.py @@ -0,0 +1,34 @@ +""" def test_ListaEnteros_01(self): + lista_test = ch.ListaEnteros(1, 10) + lista_esperada = [1,2,3,4,5,6,7,8,9,10] + self.assertEqual(lista_test, lista_esperada) + + def test_ListaEnteros_02(self): + lista_test = ch.ListaEnteros(3, 7) + lista_esperada = [3,4,5,6,7,8,9,10] + self.assertEqual(lista_test, lista_esperada) + + def test_ListaEnteros_03(self): + lista_test = ch.ListaEnteros(-2, 4) + lista_esperada = [-2,-1,0,1] + self.assertEqual(lista_test, lista_esperada) + +Esta función devuelve una lista de números enteros +Recibe dos argumentos: + inicio: Numero entero donde inicia la lista + tamanio: Cantidad de números enteros consecutivos + Ej: + ListaEnteros(10,5) debe retornar [10,11,12,13,14] + +""" + +def ListaEnteros (inicio, tamanio): + lista = [] + for i in range(inicio, inicio + tamanio): + lista.append(i) + return lista + +print (ListaEnteros (10,5)) +print (ListaEnteros (1,10)) +print (ListaEnteros (3,7)) +print (ListaEnteros (-2,4)) \ No newline at end of file diff --git a/Workbench/Taller/Matrices.py b/Workbench/Taller/Matrices.py new file mode 100644 index 000000000..ed2f911ab --- /dev/null +++ b/Workbench/Taller/Matrices.py @@ -0,0 +1,27 @@ +# Ejemplo 1 +# Uso de 'enumerate' para recorrer matrices +m = [['enteros', 1, 2, 3, 4], #Define una matriz 'm' + ['complex', 1j, 2j, 3j, 4j], + ['float', 1.0, 2.0, 3.0, 4.0]] +# [['enteros', 1, 2, 3, 4], ['complex', 1j, 2j, 3j, 4j], ['float', 1.0, 2.0, 3.0, 4.0]] +for i, elems in enumerate(m): + for j, jelem in enumerate(elems): + print(f'row {i} - column {j}: {jelem}') + +""" +row 0 - column 0: enteros +row 0 - column 1: 1 +row 0 - column 2: 2 +row 0 - column 3: 3 +row 0 - column 4: 4 +row 1 - column 0: complex +row 1 - column 1: 1j +row 1 - column 2: 2j +row 1 - column 3: 3j +row 1 - column 4: 4j +row 2 - column 0: float +row 2 - column 1: 1.0 +row 2 - column 2: 2.0 +row 2 - column 3: 3.0 +row 2 - column 4: 4.0 +""" \ No newline at end of file diff --git a/Workbench/Taller/Mix_ejercicios.py b/Workbench/Taller/Mix_ejercicios.py new file mode 100644 index 000000000..0c0ebdef6 --- /dev/null +++ b/Workbench/Taller/Mix_ejercicios.py @@ -0,0 +1,561 @@ +#******************************************************************* +#* * +#* MIX DE EJERCICIOS Y REVISIÓN DE EJEMPLOS * +#* CON COMENTARIOS Y CITAS * +#******************************************************************* +# +# Ej 1) Cocatenar cadenas de caracteres, deben ser del mismo tipo (str+str) + +a = 'Hola ' +b = 'Mundo !' +# Ej 2) Sumar dos enteros, puedo imprimir directo el resultado + +print(a + b) + +# Ej 3) Mismo ejemplo, almaceno en variable +x = 3 +y = 12 +print(x + y) # 15 + +# Ej 4) Manejo de errores por tipo, no sumar tipos distintos. +# print(a + x)==> Da un error porque son de distinto tipo, concatencación +# a= string Para que funcione, puedo cambiar el tipo a str(3) +# x= int quedaría como 'Hola 3' + +# Ej 5) Dividir "y" entre "x" +y = 9 +x = 3 +print(y/x) # => 3.0 + +# Ej 6) Potencia de "y" elevado a la "x" +y = 2 +x = 4 +print(y**x) # si elevo a 0.5, Python entiende que es raíz cuadrada igual que 1/2 +# R=> 16 + +# Ej 7) Devolver el resto de la división +y = 13 +x = 3 +print(y%x) # Sirve para todas las operaciones en que deba detectar pares, impares, primos + +# Ej 8) Ciclo IF/ELIF/ELSE +valor = 0 # Inicializo un contador para entrar al ciclo +if (valor < 0): + print('El número es negativo') +elif (valor > 0): + print('El número es positivo') +else: + print('El número es igual a cero') # R=> El número es igual a cero + +# Ej 9) Ciclo FOR - Simple (ver ciclos listas dobles) +for n in range(1,11): #Incluye el primero y excluye el último + print(n,(')')) + +# Ej 10) Ciclo WHILE - Simple con un contador +n = 1 # Contador definido en 0 +while (n < 10): # Mientras n sea menor que 10, haga lo que está dentro + print(n) # Imprimir el contenido de la variable en cada ciclo + n = n + 1 # El contador es la condición de termino. Al llegar a 11, no entra el nuevo ciclo. + +# Ej 11) Lista Simple - Inicializa una lista y obtener la cantidad de elementos con LEN + +edad = (3,1,0.2,8,7) # Declara un objeto lista y le asigna elementos, la lista es mutable, no ordenada +print (len(edad)) # Imprime la cantidad de elementos de la lista usando la función LEN +#5 # La función retornó 5 + +# Ej 12) Lista - Retornar tipo de variable usando TYPE, isertar con INSERT, pegar dos listas con EXTEND, +# eliminar un elemento con REMOVE, retornar un elemento usando su índice con INDEX[]y modificadores en la salida + +mi_lista = ['Rojo','Azul','Amarillo','Naranja','Violeta','Verde'] # Lista de 6 elementos +type(mi_lista) # la lista, como objeto es de tipo list, pero sus objetos no, pueden ser de cualquier tipo. +# R => list +print(mi_lista) # Imprime los elementos de la lista, en el orden que están...se pueden ordenar +# R=> ['Rojo', 'Azul', 'Amarillo', 'Negro', 'Naranja', 'Violeta', 'Verde'] +print(mi_lista[0:2]) # Imprimo la lista desde el índice 0, al 2, es decir el 0 y el 1, excluye el 2 +# R=> ['Rojo', 'Azul'] +print(mi_lista[:2]) # Imprime la lista desde el inicio, hasta el indice, desde el 0 al 1, excluye el 2 +# R=> ['Rojo', 'Azul'] +print(mi_lista[1:]) # Imprime la lista desde la posición 1, hasta el final, excluye la posición 0. +# R=> ['Azul', 'Amarillo', 'Naranja', 'Violeta', 'Verde'] +mi_lista.insert(3,'Negro') # INSERT, inserta un elemento en la posición del índice dado. +print(mi_lista.index('Azul')) #Retorna el valor (int) del índice cuando halla la coincidencia, este caso=1. +print(mi_lista [1]) # => Azul, retorna el valor del elemento en el indice, en este caso [1]= Azul +mi_lista.insert(3,'Negro') # Inserta el elemento 'Negro', en la posición 3. +mi_lista.extend(['Marrón','Gris']) # EXTEND, 'pega' la lista ('Marrón','Gris'), al final de mi_lista +print(['a','b','c'] * 3 ) # Igual que la concatenación, puedo 'multiplizar str =>['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c'] +mi_lista.remove('Blanco') # Recorre la lista, si existe el elemento, lo borra 1 vez, si no, da ERROR (not in list). +ultimo = mi_lista.pop() # Remueve el último elemento de la lista +print(ultimo) # Conserva el último elemento eliminado con POP, si ejecuto otra vez, elimina el anterior. + +# Ej 13) Tuplas - Operaciones de cambio de tipo, recorrer la tupla, contar elementos, imprimir, asignar +mi_tupla=tuple(mi_lista) # La lista fue 'casteada?, se le ambio el tipo a TUPLE (lista INMUTABLE) +print(mi_tupla[1]) # Se accede a sus elementos igual que la lista, NO SE PUEDE ORDENAR R=> Index 1 = Azul +'Rojo' in mi_tupla # Puedo hacer evaluaciones BOOLEANAS (T/F), está el elemento en la tupla, retorna T/F =>T +mi_tupla.count('Rojo') # Puedo contar los elementos que coinciden con un valor, retorna 1 entero +print(mi_lista[:] * 3) # Concatena la lista veces, igual que los strings. +# R=> ['Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris', 'Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris', 'Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris'] +mi_tupla='Gaspar', 5, 8, 1999 # Crea una tupla a partir asignarle elementos +nombre, dia, mes, año = mi_tupla # Asigna los valores de la tupla a variables +print("Nombre: ", nombre, " - Dia:", dia, " - Mes: ", mes, " - Año: ", año) # Imprime el contenido de las variables +# R=> Nombre: Gaspar - Dia: 5 - Mes: 8 - Año: 1999 + +# Ej 14) Formateo de impresión - 3 casos (sólo variables, con texto y con formato) +nombre = 'Darío' # Inicializo var nombre con el str 'Darío' +edad = 39 # Inicializo var edad con el int 39 +print(nombre, edad) # Caso 1) Imprimo el contenido de las variables. Puede ser cualquier variable. +print("Mi nombre es", nombre, ". Mi edad es", edad, "años") # Caso 2) Impresión tradicional con variables. +print("Mi nombre es {}. Mi edad es {} años". format(nombre, edad)) # Caso 3) Impresión con FORMATO +# Caso 1) Darío 39 +# Caso 2) Mi nombre es Darío . Mi edad es 39 años +# Casi 3) Mi nombre es Darío. Mi edad es 39 años + +# Ej 15) Diccionarios - Creación y operaciones (pares de elementos, {key:elemento}) +mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'], # Crear con {key:Elm, key:Elm...} + 'Colores secundarios': ['Naranja','Violeta','Verde'], # Elm= Cualquier cosa, mutable + 'Clave3': 10, # Key= Hasheable, inmutable + 'Clave4': False} +print (mi_diccionario['Colores secundarios']) # Lo puedo acceder por sus claves o índices y retorna los VALORES +# R=> ['Naranja', 'Violeta', 'Verde'] # Para la clave dad, retorno los elementos respectivos + +mi_diccionario = {'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}} # Dic key1=str y val1=str, key2=str, val2=lista +print (mi_diccionario.keys()) # Retorna R=> dict_keys(['Clave1', 'Clave2']) +print(mi_diccionario.values()) # Retorna R=> dict_values(['Valor1', {'numeros': [1, 2, 3, 4, 5]}]) +len (mi_diccionario) # R=> 2, la función LEN es útil cuando se debe recorrer el DICT + +# Ej 16) Ciclo IF/ELIF/ELSE + +edad = 60 +edad_compa = 50 +if (edad < edad_compa): # Compara dos números, y establece dos condiciones + print(edad) + if (edad < 100): + print(edad + 100) + else: + print(edad - 100) +else: + print(edad_compa) # No cumple ninguna e imprime el contenido de la var edd_compa R=> 50 + +# Ej 17) Recorre una lista con un ciclo FOR y extrae los PARES + +primeros_10 = [0,1,2,3,4,5,6,7,8,9] +print(primeros_10) # R=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +outlist = [] # Esta lista acumula los valores encontrados +for n in primeros_10: # For 'var' in 'lista/tupla/dict' + if (n%2 == 0): # Uso la función resto para reconocer los PARES + outlist.append(n) # Los guardo en una lista para poder mostrarlos horizontalmente +print ('Los pares son', outlist) # R=> Los pares son [0, 2, 4, 6, 8] + +# Ej 18) Recorrer una lista con su índice y ver error fuera de rango + +print(primeros_10[9]) # R=> 9, el valor existe dentro del rango +primeros_10 = ['a','b','c','d'] # Esta lista de str, tiene 4 elm, índices del 0 al 3. +primeros_10[4] # Al intentar accesar a una posición que NO existe, retornará un error (out of range) + +# Ej 19) Uso de la función SEQUENCE - Recorre un rango +n = 40 +sequence = [0,1] +for i in range(2,n): + sequence.append(sequence[i-1]+sequence[i-2]) +print (sequence) +# [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, 832040, 1346269, +# 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986] + +mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'], + 'Colores secundarios': ['Naranja','Violeta','Verde'], + 'Clave3': 10, + 'Clave4': False} +print(mi_diccionario['Colores secundarios']) +# ['Naranja', 'Violeta', 'Verde'] + +mi_diccionario['Clave3']=2 + +mi_diccionario +{'Argentina': 'Buenos Aires', 'Italia': 'Roma', 'Inglaterra': 'Londres'} +mi_diccionario['Clave5']='Otro ejemplo' +mi_tupla=("Argentina", "Italia", "Inglaterra") +mi_diccionario={mi_tupla[0]:"Buenos Aires", mi_tupla[1]:"Roma", mi_tupla[2]:"Londres"} +mi_diccionario={'Clave1':'Valor1', 'Clave2':(1,2,3,4,5)} +type(mi_diccionario['Clave2']) +# tuple +mi_diccionario={'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}} +type(mi_diccionario['Clave2']) +# dict +mi_diccionario={'Clave1':'Valor1', 'Clave2':[1,2,3,4,5]} +type(mi_diccionario['Clave2']) +# list +print(mi_diccionario.keys()) +# dict_keys(['Clave1', 'Clave2']) +print(mi_diccionario.values()) +# dict_values(['Valor1', [1, 2, 3, 4, 5]]) +len(mi_tupla) +# 3 + +def imprimir_valor_variable(var): + print('El valor de la variable es' + str(var)) +imprimir_valor_variable(mi_lista) +# El valor de la variable es['Rojo', 'Azul', 'Amarillo', 'Negro', 'Marrón', 'Gris'] + +def ordenar_dos_numeros(num1, num2): + if (num1 > num2): + return num2, num1 + else: + return num1, num2 + +ordenar_dos_numeros(8,1) +# (1, 8) + +def factorial(numero): +# Devuelve el factorial + if (numero > 1): + numero = numero * factorial(numero - 1) + return numero + +factorial(3) +# 6 +#help(factorial) +#Help on function factorial in module __main__: + +#factorial(numero) +# Devuelve el factorial + +def dividir(dividendo, divisor = 1): + if (divisor == 0): + return 'No se puede dividir por cero' + else: + return dividendo / divisor +print(dividir(10)) +# 10.0 +print(divisor) +""" +--------------------------------------------------------------------------- +NameError Traceback (most recent call last) +~\AppData\Local\Temp/ipykernel_10044/1862935505.py in +----> 1 print(divisor) + +NameError: name 'divisor' is not defined +""" + +divisor = 5 +def dividir(dividendo): + if (divisor == 0): + return 'No se puede dividir por cero' + else: + return dividendo / divisor +print(dividir(10)) +# 2.0 +print(divisor) +# 5 + +divisor = 5 + +def dividir(dividendo, divisor = 1): + if (divisor == 0): + return 'No se puede dividir por cero' + else: + return dividendo / divisor + +print(dividir(10)) +# 10.0 + +print(divisor) +# 5 + +lambda_producto = lambda x, y: x * y +lambda_producto(3, 4) +# 12 + +class Animal: + ''' + En esta clase se crean los animales + ''' + def __init__(self, especie, edad, color): + self.especie = especie + self.edad = edad + self.color = color + def mePresento(self): + print('Hola, soy ', self.especie, ', de color', self.color, ' y tengo ', self.edad, ' años') + def cumplirAños(self): + self.edad = self.edad + 1 + +a1 = Animal('Ratón', 2, 'Marrón') + +print(a1.especie) +print(a1.edad) + +a2 = Animal('Liebre', 3, 'Gris') +print(a2.especie) +print(a2.edad) +# Ratón +# 2 +# Liebre +# 3 + +a1.mePresento() +# Hola, soy Ratón , de color Marrón y tengo 2 años +a2.mePresento() +# Hola, soy Liebre , de color Gris y tengo 3 años +a1.cumplirAños() +a1.mePresento() +# Hola, soy Ratón , de color Marrón y tengo 3 años + +# Caja Negra +import unittest +def suma(num_1, num_2): + return num_1 + num_2 +class CajaNegraTest(unittest.TestCase): + + def test_suma_dos_positivos(self): + num_1 = 10 + num_2 = 5 + + resultado = suma(num_1, num_2) + + self.assertEqual(resultado, 15) + + def test_suma_dos_negativos(self): + num_1 = -10 + num_2 = -7 + + resultado = suma(num_1, num_2) + + self.assertEqual(resultado, -17) + +unittest.main(argv=[''], verbosity=2, exit=False) + +""" +" test_suma_dos_negativos (__main__.CajaNegraTest) ... ok +" test_suma_dos_positivos (__main__.CajaNegraTest) ... ok + +---------------------------------------------------------------------- +Ran 2 tests in 0.004s + +OK + +if __name__ == '__main__': + unittest.main() +""" +#Caja de Cristal + +import unittest +def es_mayor_de_edad(edad): + if edad >= 18: + return True + else: + return False +class PruebaDeCristalTest(unittest.TestCase): + def test_es_mayor_de_edad(self): + edad = 20 + resultado = es_mayor_de_edad(edad) + self.assertEqual(resultado, True) + def test_es_menor_de_edad(self): + edad = 15 + resultado = es_mayor_de_edad(edad) + self.assertEqual(resultado, False) +unittest.main(argv=[''], verbosity=2, exit=False) + +""" +test_suma_dos_negativos (__main__.CajaNegraTest) ... ok +test_suma_dos_positivos (__main__.CajaNegraTest) ... ok +test_es_mayor_de_edad (__main__.PruebaDeCristalTest) ... ok +test_es_menor_de_edad (__main__.PruebaDeCristalTest) ... ok + +---------------------------------------------------------------------- +Ran 4 tests in 0.006s + +OK + +if __name__ == '__main__': + unittest.main() +""" + +# Python + +def busca_pais(paises, pais): +# Paises es un diccionario. Pais es la llave. +# Codigo con el principio EAFP (Easier to Ask Forgiveness than Permission/Mejor pedir perdón que pedir permiso) +# Otro LBYL (Look Before You Leap/Piensa antes de actuar 🤐). + + try: + return paises[pais] + except KeyError: + return None + +def divide_elementos_de_lista(lista, divisor): + + ''' + Cada elemento de una lista es dividida por un divisor definido. + En caso de error de tipo ZeroDivisionError que + significa error al dividir en cero + la función devuelve la lista inicial + ''' + try: + return [i / divisor for i in lista] + + except ZeroDivisionError as e: + print(e) + return lista + +lista = list(range(10)) +divisor = 0 + +print(divide_elementos_de_lista(lista, divisor)) +# division by zero +# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + +divisor = 3 +print(divide_elementos_de_lista(lista, divisor)) +# [0.0, 0.3333333333333333, 0.6666666666666666, 1.0, 1.3333333333333333, +# 1.6666666666666667, 2.0, 2.3333333333333335, 2.6666666666666665, 3.0] + +lista = [5, 4, 9, 2] +i = 0 +while i < len(lista): + elemento = lista[i] + print(elemento) + i += 1 + +""" +5 +4 +9 +2 +""" + +lista = [5, 4, 9, 2] +for elemento in lista: + print(elemento) + +""" +5 +4 +9 +2 +""" +from collections import Iterable +cadena = "Hola" +numero = 3 +print("cadena", isinstance(cadena, Iterable)) +print("numero", isinstance(numero, Iterable)) + +""" +cadena True +numero False +C:\Users\lopez\AppData\Local\Temp/ipykernel_10044/1562366592.py:1: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3, and in 3.10 it will stop working + from collections import Iterable +""" + +print(list("Hola")) +# ['H', 'o', 'l', 'a'] +print(sum([1, 2, 3])) +# 6 +print("-".join("Hola")) +# H-o-l-a + +mi_dict = {'a':1, 'b':2, 'c':3} +for i in mi_dict: + print(i) +""" +a +b +c +""" + +libro = ['página1', 'página2', 'página3', 'página4'] +marcapaginas = iter(libro) +print(next(marcapaginas)) +print(next(marcapaginas)) +print(next(marcapaginas)) +print(next(marcapaginas)) +""" +página1 +página2 +página3 +página4 +print(next(marcapaginas)) +--------------------------------------------------------------------------- +StopIteration Traceback (most recent call last) +~\AppData\Local\Temp/ipykernel_10044/1391636315.py in +----> 1 print(next(marcapaginas)) + +StopIteration: +14 % 3 +2 +14 // 3 +4 +""" +a = [1,2] +b = a.copy() +b.append(3) +print(a) +# [1, 2] + +print(b) +# [1, 2, 3] +b.append(4) +print(a) +# [1, 2, 3] +print(b) +# [1, 2, 3, 4] +x = 7 +# 7 & 7 +# 2 +print(x) +# 2 +a = [1, 2] +b = ["Uno", "Dos"] +c = zip(a, b) +type(c) +# zip +list(c) +[(1, 'Uno'), (2, 'Dos')] +frase = "El perro de san roque no tiene rabo" +errores = [i for i in frase if i == 'r'] +print(errores) +# ['r', 'r', 'r', 'r'] +n = 40 +sequence = [0,1] +for i in range(2,n): + sequence.append(sequence[i-1]+sequence[i-2]) + print (sequence) + +"""2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +4 << 1 +8""" \ No newline at end of file diff --git a/Workbench/Taller/NumeroCapicua.py b/Workbench/Taller/NumeroCapicua.py new file mode 100644 index 000000000..112932398 --- /dev/null +++ b/Workbench/Taller/NumeroCapicua.py @@ -0,0 +1,36 @@ +def NumeroCapicua(numero): + ''' + En matemáticas, la palabra capicúa (del catalán cap i cua, 'cabeza y cola')​ + se refiere a cualquier número que se lee igual de izquierda a derecha que + de derecha a izquierda. Se denominan también números palíndromos. + Esta función devuelve el valor booleano True si el número es capicúa, de lo contrario + devuelve el valor booleano False + En caso de que el parámetro no sea de tipo entero, debe retornar nulo. + Recibe un argumento: + numero: Será el número sobre el que se evaluará si es capicúa o no lo es. + Ej: + NumeroCapicua(787) debe retornar True + NumeroCapicua(108) debe retornar False + ''' + cadena3 = str(numero) + pali = [] + pali2 = [] + if type(numero) == int: + for i in range(len(cadena3) -1, -1, -1): + pali.append(cadena3[i]) + for j in range(len(pali)-1, -1, -1): + pali2.append(pali[j]) + if (pali == pali2): + return True + else: + return False + else: + return None + + +# Probar +numeros = [11, 20, 123, 9889, 2811, 1801, 777, 12321, ] + +for num in numeros: + es_capicua = NumeroCapicua(num) + print(f"El número {num} es capicúa? {es_capicua}") \ No newline at end of file diff --git a/Workbench/Taller/OrdenaDic b/Workbench/Taller/OrdenaDic new file mode 100644 index 000000000..06e30b663 --- /dev/null +++ b/Workbench/Taller/OrdenaDic @@ -0,0 +1,55 @@ +dicc ={ +'clave1':['c', 'a', 'b'], +'clave2':['casa', 'auto', 'barco'], +'clave3':[3,2,1]} +# 1) Convertir este dic de listas en una lista de dicts +# 2) verificar que no pasan datos nulos o que no cumplen las condciones a) calaves no vacías y que el dic, sea un DICT +# No se puede perder la hilación, or eso tarbajamos con listas. +# Crequear condiciones +clave='clave1' + +# def ordenaDic (dicc_rec, clave): +newArr=[] # Va a recibir mi lista de diccionarios originales convertidos a listas +newArrSorted=[] # Va a recibir los diccionarios ordenados por la clave ingresada +res = [] +cantidadValores = 0 +numKeys = 0 # Recibe la cantidad de elementos del tipo llave que tiene el diccionario DICC, para ejecutar los ciclos. +if not (type(dicc) is dict): #dict_rec= Debería ser el DICC recibido + pass #return 'Null' #None +if not (clave in dicc.keys()): #clave=clave del parámetro + pass #return 'Null' + # definir variables a usar, incluye nuevas listas + # Convertimos el dicc de list a list de dict + # print (len(dicc_rec[list(dicc_par.keys())[0]])) + # chequeamos qué valor estamos reciendo + # print() +print (len(dicc[list(dicc.keys())[0]])) +if len(dicc[list(dicc.keys())[0]])>0: # convertimos el diccionario de listas, a una lista de diccionarios: + cantidadValores = len(dicc[list(dicc.keys())[0]]) + print (cantidadValores) + for i in range(0, cantidadValores): + newObj={} + for key in dicc: + newObj[key]=dicc[key][i] + newArr.append(newObj) #print(newArr) #aquí se generó una lista de diccionarios + newArrSorted = sorted(newArr, key=lambda d: d[clave], reverse=not) # (descendente) Ahora ordenemos + #print (newArrSorted) #verificar contenido del nuevo arreglo + # Convertimos la lista de diccionarios, en un diccionario de listas: + for key in dicc: + newArr2 = [] + for i in range(0, cantidadValores): + newArr2.append(newArrSorted[i][key]) + res[key] = newArr2 + #Si no tienen valores devolvemos el mismo diccionario: +else: + #return dicc_par + print (dicc) + print (res) + +#dicc ={ +#'clave1':['c', 'a', 'b'], +#'clave2':['casa', 'auto', 'barco'], +#'clave3':[3,2,1]} +# print (OrdenarDiccionario(dicc,"clave3",false)) + +# ordenaDic (dicc, 'clave1') \ No newline at end of file diff --git a/Workbench/Taller/OrdenarDiccionario.py b/Workbench/Taller/OrdenarDiccionario.py new file mode 100644 index 000000000..12f5352d4 --- /dev/null +++ b/Workbench/Taller/OrdenarDiccionario.py @@ -0,0 +1,34 @@ +def OrdenarDiccionario(diccionario_par, clave, descendente=True): + cantidadValores=0 + newArr=[] + newArrSorted=[] + res ={} + if not (type(diccionario_par) is dict): + return None + if not (clave in diccionario_par.keys()): + return None + if len(diccionario_par[list(diccionario_par.keys())[0]])>0: + cantidadValores=len(diccionario_par[list(diccionario_par.keys())[0]]) + for i in range(0, cantidadValores): + newObj={} + for key in diccionario_par: + newObj[key]=diccionario_par[key][i] + newArr.append(newObj) + newArrSorted = sorted(newArr, key=lambda d: d[clave], reverse=not (descendente)) + for key in diccionario_par: + newArr2 = [] + for i in range(0, cantidadValores): + newArr2.append(newArrSorted[i][key]) + res[key] = newArr2 + else: + return diccionario_par + + return res + +dicc = { + 'clave1':['c','a','b'], + 'clave2':['casa','auto','barco'], + 'clave3':[1,2,3] + } + +print (OrdenarDiccionario(dicc,"clave1")) diff --git a/Workbench/Taller/Problemasumas.py b/Workbench/Taller/Problemasumas.py new file mode 100644 index 000000000..93d84b855 --- /dev/null +++ b/Workbench/Taller/Problemasumas.py @@ -0,0 +1,36 @@ +# Crear una clase Operación que solicite en el método __init__ +# la carga de dos enteros e inmediatamente muestre +# su suma, resta, multiplicación y división. +# Hacer cada operación en otro método de la clase Operación y llamarlos +# desde el mismo método __init__ + +class Operacion: + + def __init__(self): + self.valor1=int(input("Ingrese primer valor:")) + self.valor2=int(input("Ingrese segundo valor:")) + self.sumar() + self.restar() + self.multiplicar() + self.dividir() + + def sumar(self): + suma=self.valor1+self.valor2 + print("La suma es",suma) + + def restar(self): + resta=self.valor1-self.valor2 + print("La resta es",resta) + + def multiplicar(self): + multi=self.valor1*self.valor2 + print("El producto es",multi) + + def dividir(self): + divi=self.valor1/self.valor2 + print("La division es",divi) + + +# bloque principal + +operacion1=Operacion() \ No newline at end of file diff --git a/Workbench/Taller/Prueba240123.py b/Workbench/Taller/Prueba240123.py new file mode 100644 index 000000000..e69de29bb diff --git a/Workbench/Taller/TodasLasOperaciones.py b/Workbench/Taller/TodasLasOperaciones.py new file mode 100644 index 000000000..1b7ae6522 --- /dev/null +++ b/Workbench/Taller/TodasLasOperaciones.py @@ -0,0 +1,27 @@ +class Operacion: + + def __init__(self): + self.valor1=int(input("Ingrese primer valor:")) + self.valor2=int(input("Ingrese segundo valor:")) + self.sumar() + self.restar() + self.multiplicar() + self.dividir() + + def sumar(self): + suma=self.valor1+self.valor2 + print("La suma es",suma) + + def restar(self): + resta=self.valor1-self.valor2 + print("La resta es",resta) + + def multiplicar(self): + multi=self.valor1*self.valor2 + print("El producto es",multi) + + def dividir(self): + divi=self.valor1/self.valor2 + print("La division es",divi) + +operacion1=Operacion() \ No newline at end of file diff --git a/Workbench/Taller/aritmetica.py b/Workbench/Taller/aritmetica.py new file mode 100644 index 000000000..ef449849a --- /dev/null +++ b/Workbench/Taller/aritmetica.py @@ -0,0 +1,22 @@ +print (3.5 // 3) +#print ("7"+"0") +#print (int("7"+"0")/2) #Este es un ejemplo de casteo +#print ( 2**1 / 12) +#print (4*9) +#Intersante como se pueden declarar variables +""" +a, b, c, d = 26, 11.3, 5, 3.5 +print (a) +print (c) +print (b) +print (d) +print (type (a)) +print (type (b)) +print (type (d)) +""" +#print (4*9) +#print (2+4) +print (30%10) +i = 5 +i -= 1 +print(i) # 4 \ No newline at end of file diff --git a/Workbench/Taller/datatypes.py b/Workbench/Taller/datatypes.py new file mode 100644 index 000000000..642414419 --- /dev/null +++ b/Workbench/Taller/datatypes.py @@ -0,0 +1,40 @@ + +# On this file we going to learn about different data types +# Boolean, int, float, complex mumbers +# Boolean true or false +# String, list (dictionary) + +current_year=2023 +print (current_year) +next_year=current_year+1 +print (next_year) +print (type (current_year)) +print(type (3.14)) +print (type (1+2j)) +print (type (9.81)) +a = input ("Ingresa un texto") +print ("El texto ingresado es", a) +# Convertir data type e.g int to float o viceversa +print (int(9.81)) +print (round (9.81)) +#BOOLEAN CASES +enjoying_lesson=True +is_light_on=True +is_single=False +value = 3 < 2 #almacena el valor lógico de la expresión +print (value) +#STRINGS ==> Son datos almacenados del tipo cadena de texto +#Concatenación se suman las variables de texto +firstname = "Jota" +print (firstname) +lastname="Cordova" +print (lastname) +print (firstname+" "+ lastname) +country = "Finland" +print (country) +#Recordar +fullname = firstname + " "+lastname +print (fullname,", aquí usamos la variable concatenada") +print (type (firstname)) +print (country.upper()) #métodos de la clase print +print (fullname.title()) \ No newline at end of file diff --git a/Workbench/Taller/listas.py b/Workbench/Taller/listas.py new file mode 100644 index 000000000..c50e047bf --- /dev/null +++ b/Workbench/Taller/listas.py @@ -0,0 +1,400 @@ +#******************************************************************* +#* * +#* TEORIA LISTAS - TUPLAS - DICCIONARIOS - ETC * +#* C O L E C C I O N E S Y MUCHO MAAASSSS * +#******************************************************************* + +# Una LIST, es un objeto, es una colección de cosas, pueden ser tareas, +# vegetales, nombres, mercaderías, cualquier cosa. + +# Dos formas para declararlas o iniciaizarlas, aunque hay otras. + +# 1) Defino una variable y le asigno un tipo lista VACÍO con paréntesis +empty_list1 = list() # Note que se debe indicar el tipo lista o lo +print (empty_list1, "esta es la lista 1 con '()'") # considerará una TUPLA +print (type(empty_list1)) + +# 2) Defino una variable y sé que es del tipo lista por los corchetes '[]' +empty_list2 = [] # A la variable se le asigna una lista vacía con +print (empty_list2, "esta es la lista 2") # CORCHETES +print (type (empty_list2)) + +# Ejemplo 1 +numbers = [1,2,3,4,5,6] # Lista de números +print("'numbers' es del tipo ", type(numbers)) # Imprime un texto + su 'type' + +# Ejemplo 2 +groceries = ["tomato", "carrot", "letuce"] # Una lista con 3 str de 'vegetales' +print (groceries [0]) # El índice va con [] y parte en 0, imprime "tomato" +print (numbers [3]) # Es 'la' COLECCION, imprime todos sus elementos +print (len(groceries)) # LEN devuelve el largo de la lista con len, retorna 3 + +# Ejemplo 3 +lastname = "Cordova" # Variable de tipo string, contiene "Cordova" +mix_of_data_types_list = [1, "Jota", lastname, 2+5, 1-3j, 3.14] # Lista con distintos tipos de var +print ("'mix_of_data_types_list' es del tipo-", type(mix_of_data_types_list)) # devuelve un 'list' + +# Podemos almacenar cualquier 'mix' de datos u objetos, en Python TODO es un objeto + +# Ejemplo 4 +listadeletras = [] # Crea un objeto list llamado listadeletras vacío +for unaletra in "paralelepipedo": # Define una var 'unaletra' y recorre el string "paralelepípedo" + listadeletras.append(unaletra)# Agrega cada caracter del string a 'listadeletras' usando el método 'append' +print (listadeletras) # Imprime los valores de la lista que son los caracteres de la palabra 'paralelepípedo'', lo que sea + # Salida esperada ['p', 'a', 'r', 'a', 'l', 'e', 'l', 'e', 'p', 'í', 'p', 'e', 'd', 'o'] + +# Ejemplo 5 +# Crear una lista de 4 elementos y, para cada elemento, calcularle su potencia de 2, usando +# el método tradicional, eso seria así, luego veremos con expresiones o por comprensión: +# Alternativa 1 +lista_potencias = [] # Crea una lista llamada "lista_potencias" +for i in range(4): # Ciclo for para recorrer lista de 4 elementos, va de 0 a 3, el índice lo llamamos "i" + lista_potencias.append(i**2)# La lista "lista_potencias", la voy poblando con el dato calculado. +print(lista_potencias) # Imprime los 4 valores almacendaos en la lista [0, 1, 4, 9] + +# Ejemplo 6 +# El ejemplo 5, usando listas por comprensión (es decir, fórmulas o expresiones), seria así: +lista_potencias2 = [i**2 for i in range(4)] # Usa un FOR +print ("Esta es la lista de potencias Nr2", lista_potencias2) # Imprime [0, 1, 4, 9] + +# Ejemplo 7 +# Lista con las potencias de 2 de los primeros 10 números, método tradicional: +# Alternativa 1 +lista1_pot10_2 = [] # Creamos un objeto lista vacio [] +for num in range (0, 11): # Incluye el 1ro, pero no el últimmo. Recorremos el rangoUsando un ciclo FOR usando la var "num" en el tramo de 0-10, ambos incluidos + lista1_pot10_2.append (num**2) # Llenamos la lista con potencias PARTIENDO DE 0, a 10 (11-1) +print(lista1_pot10_2) # Salida por pantalla [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100] + +# Alternativa 2 +# Usando listas por comprensión, seria así: +lista2_pot10_2 = [num2**2 for num2 in range(0, 11)] #Creamos la lista con los valores según condición +print("Aquí usamos una expresión para crear la lista de 10 nros. y sus potencias",lista2_pot10_2) +# R=> Aquí usamos una expresión para crear la lista de 10 nros. y sus potencias [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100] +# Con este método, es más simple modificar los elementos que van a la lista. + +# Ejemplo 8 +# Este ejemplo muestra como operan las posiciones en una lista (cada elemento es una posX) +lista = ["pos0", "pos1", "pos2", "pos3", "pos4", "pos5"] +print("Esta es la lista:\n", lista, "\n") +print("1° Mostrar 'lista[2:5]', significa la pos2, pero excluye la 5, ojo!\n", lista[2:5]) # tomamos del 2 al 5 (sin incluir el 5) +print("2° Mostrar 'lista[4:]', significa desde la pos4 hasta la última\n",lista[4:]) # tomamos del 4 hasta el final +print("3° Mostrar 'lista[:2]', significa desde el BOF hasta la pos2, excluye la pos2\n", lista[:2]) # tomamos desde el principio hasta el 2 (sin incluir) +print("4° Mostrar 'lista[1:6:2]', significa 1 por medio, desde la pos1, incluye la 5\n", lista[1:6:2]) # tomamos 1 de cada 2 elementos desde el 1 hasta el 6 (sin incluir) +print("5° Mostrar 'lista[4:1:-1]', significa orden desc de la pos4 a la 2, excluye la pos1",lista[4:1:-1]) +print("6° Mostrar 'lista[:]', significa mostrar todos los elementos de la lista\n",lista[:]) # tomamos desde el principio hasta el final (es como hacer una copia de la lista) +print("7° Mostrar 'lista[::-1]', significa mostrar todos los elementos de la lista en orden inverso\n",lista[::-1]) # tomamos desde el final hasta el principip (orden inverso) + +# Ejemplo 9 +# Usamos un truco para controlar la salida, un método de print llamado end +# +for i in range (15): + if i < 14: + print (i, end=", ") + else: + print (i) + +# Ejemplo 10 +# Mismo ejemplo sin controlar la salida, cada linea se ejecuta y se apila. +for i in range (15): + print (i) # No agregué el print por espacio ...se ve muy feo + +# Ejemplo 11 +# Revisar otra formas de ordenar listas (pero en este archivo van muchas) +lista_desordenada = [5,7,2,8,3,6] +lista_desordenada.sort() # Usamos el método SORT +print ("Resultado esperado 2,3,5,6,7,8, lista generada :", lista_desordenada) +print (type(lista_desordenada)) # Verifico, como medida extra, el tipo de dato generado + +# Ejemplo 12 +# Lista negada = los inversos y lista doble = multiplicadas por algo +# Hay que acostumbrarse a usar 'trucos' para resolver la lógica de los problemas +lista = [10, 20, 30] +lista_negada = [ -e for e in lista ] # Es por comprensión. Genera los inversos de los elementos +lista_doble = [ e*2 for e in lista] # Esta genera los elementos multiplicados por 2 +print(lista_negada) # Todos negativos +print(lista_doble) # Todos x 2 + +# Ejemplo 13 +# Ojo!! No se pueden negar valores float o strings. +lista2 = [True, True, False, 5, 2-3j] # Ojo con los BOOLEANOS +lista_negada2 = [ -e for e in lista2] # Los inversos de los elementos numéricos +lista_doble2 = [ e*2 for e in lista2] # Los elementos multiplicados por 2 +print(lista_negada2) # Nótese la salida [-1, -1, 0, -5, (-2+3j)], los booleanos los tomo como 1 y 0 +print(lista_doble2) # Nótese la salida [2, 2, 0, 10, (4-6j)], fijarse en los booleanos + +# Ejemplo 14 +# Usando 1 ciclo FOR, poblar 2 listas dependiendo de una condición y mostrar la información horizontal. +lista_i = [] +lista_p = [] +for i in range (1,11): + n=(i%2) + if n==1: + lista_i.append (i) + elif n==0: + lista_p.append (i) +print ("Los números impares entre 1 y 10 son ", lista_i) +print ("Los números pares entre 1 y 10 son ", lista_p) + +# Ejemplo 15 +# Usos de 'enumerate' en listas, tuplas, diccionarios, cadenas +for i, val in enumerate(['A', 'B', 'C']): # ENUMERATE recorre la lista y su ÍNDICE + print(i, val) +# 0 A +# 1 B +# 2 C + +# En este caso imprime la posición, índice, o puntero, y el contenido de la posición, verticamente +# Cómo o haría para mostrarlo horizontalmente? +# +# Ejemplo 16 + +for i, val in enumerate(['A', 'B', 'C'], start=5): # Mismo anterior, pero cambia el valor del puntero que parte en 5 + print(i, val) +# 5 A +# 6 B +# 7 C La salida va de 5 a 7 + + +# Ejemplo 17 +# En este caso va de 5 a 14, se salta de a 3, y el puntero inicia en 1 +for i, val in enumerate(range(5, 15, 3), start=1): + print(f'Pos: {i} -> {val}') +# La salida va con los textos 'Pos: ' y '->' +# Pos: 1 -> 5 +# Pos: 2 -> 8 +# Pos: 3 -> 11 +# Pos: 4 -> 14 +print ("") + +# Ejemplo 18 +# Iterar 2 listas usando un FOR y ZIP +a = [1, 2] +b = ["Uno", "Dos"] +c = zip(a, b) +for numero, texto in zip(a, b): + print("Número", numero, "Letra", texto) + print(type(numero), type(texto)) +# Número 1 Letra Uno +# +# Número 2 Letra Dos +# + +# Ejemplo 19) zip() con n argumentos - Ejemplo con varias listas +# Como ZIP está definida como, zip(*iterables) o cualquier iterable, +# es posible pasar un número arbitrario de iterables como entrada. +# Es importante notar, que todas tienen la misma longitud, dos. +# Es necesario experimentar para tener una 'idea' cuando toque + +numeros = [1, 2] +espanol = ["Uno", "Dos"] +ingles = ["One", "Two"] +frances = ["Un", "Deux"] +c = zip(numeros, espanol, ingles, frances) +for n, e, i, f in zip(numeros, espanol, ingles, frances): + print(n, e, i, f) +# Note la forma en que organiza la salida de los datos en pares +# 1 Uno One Un +# 2 Dos Two Deux + +# Ejemplo 20 - Caso: Hacer zip() con listas de diferentes longitudes +# Podemos usar zip con iterables de diferentes longitudes. +# En este caso, el iterador se detiene, cuando la lista más pequeña se acaba. + +numeros = [1, 2, 3, 4, 5] +espanol = ["Uno", "Dos"] +for n, e in zip(numeros, espanol): + print(n, e) +# Ojo!, sólo completa los dos primeros pares +# 1 Uno +# 2 Dos + +# Ejemplo 21 - Caso: zip() con un argumento +# Por definición, se puede hacer, porque ZIP está definido para un 'n' +# arbitrario de listas, ergo, también es posible usar un único valor. +# El resultado son tuplas de un elemento...raras, pero se puede. + +numeros = [1, 2, 3, 4, 5] +zz = zip(numeros) # ZIP de si mismo +print (list(zz)) # R=> [(1,), (2,), (3,), (4,), (5,)] + +# Ejemplo 22 - Caso: zip() con diccionarios +# Lo común es usar ZIP con listas, pero al estar definida para cualquier +# clase iterable. +# Podemos usarla con DICCIONARIOS. + +# Por ejemplo, si (a,b) toman los valores de las key del diccionario, no parece +# muy interesante. + +esp = {'1': 'Uno', '2': 'Dos', '3': 'Tres'} +eng = {'1': 'One', '2': 'Two', '3': 'Three'} + +for a, b in zip(esp, eng): + print(a, b) +# 1 1 +# 2 2 +# 3 3 + +# Sin embargo, si usamos la función items del tipo DICT, podemos acceder +# al key y al value de cada elemento. +# Se puede facilitar para modificar valores usando, e.g casteo de dict a list y viceversa +esp = {'1': 'Uno', '2': 'Dos', '3': 'Tres'} +eng = {'1': 'One', '2': 'Two', '3': 'Three'} + +for (k1, v1), (k2, v2) in zip(esp.items(), eng.items()): + print(k1, v1, v2) +# Nótese que en este caso ambas key k1 y k2 son iguales. +# 1 Uno One +# 2 Dos Two +# 3 Tres Three + +# Ejemplo 23 - Caso: Deshacer el zip() +# Es posible deshacer un zip, en una sola línea de código. +# Supongamos que hemos usado zip para obtener 'c'. + +a = [1, 2, 3] +b = ["One", "Two", "Three"] +c = zip(a, b) + +print (list(c)) # R=> [(1, 'One'), (2, 'Two'), (3, 'Three')] +# ¿Es posible obtener a y b desde c? Sí, tan sencillo como: +c = [(1, 'One'), (2, 'Two'), (3, 'Three')] +a, b = zip(*c) +print(a) # (1, 2, 3) +print(b) # ('One', 'Two', 'Three') + +# Uso de STRIP Ejemplo 24 - STRIP eliminar espacios, cadenas de texto, incluso comparar +# Este ejemplo es como un "A inter B" +colores = ['yellow', 'wine', 'blue', 'green', 'red', 'brown', 'red'] +sec_colr = ['blue', 'green', 'red'] + +strColores = str(colores).strip("[]") +strSec_colr = str(sec_colr).strip("[]") + +if strSec_colr in strColores: + print("Si") +else: + print("No") + +# Ejemplo 24 - Usar listas como PILAS +# Los métodos de lista, facilitan usar una lista como una pila (stack), donde el +# último elemento añadido es el primer elemento retirado (LIFO). Para agregar un +# elemento a la cima de la pila, utilizamos APPEND(). Para retirar un elemento de la +# cima de la pila, se utiliza POP() sin un índice explícito. Por ejemplo: + +mi_pila = [3, 4, 5] +mi_pila.append(6) +mi_pila.append(7) +print (mi_pila) # R=> [3, 4, 5, 6, 7] +mi_pila.pop() # R=> Elimina el 7, y lo guarda en memoria hasta que lo ocupe otro +print (mi_pila) # Chequeamos si está el 7 y no está en la lista R=> [3, 4, 5, 6] +mi_pila.pop() # El siguiente elemento eliminado será el 6. R=> 6 +mi_pila.pop() # Ahora elimina el 5, R=> 5 +print (mi_pila) # verificamos y vemos que se han borrado los elementos. R=> [3, 4] + +# Ejemplo 25 - Usar listas como COLAS +# También es posible usar una lista como una cola, donde el primer elemento añadido +# es el primer elemento retirado (FIFO); sin embargo, las listas no son eficientes +# para este propósito. Agregar y sacar del final de la lista es rápido, pero +# insertar o sacar del comienzo de una lista es lento (porque todos los otros +# elementos tienen que ser desplazados en uno). +# Para implementar una cola, utiliza 'COLLECTIONS.DEQUE', el cual fue diseñado para +# añadir y quitar de ambas puntas de forma rápida. Por ejemplo: + +from collections import deque + +mi_Cola = deque(["Pedro", "Juan", "Diego"]) # Están Pedro, Juan y Diego en la cola +mi_Cola.append("Luis") # Llega Luis +print (mi_Cola) # R=> (['Pedro', 'Juan', 'Diego', 'Luis']) +mi_Cola.append("Jorge") # Llega Jorge +print (mi_Cola) # R=> (['Pedro', 'Juan', 'Diego', 'Luis', 'Jorge']) +print(mi_Cola.popleft()) # El primero en llegar se va => Pedro +print(mi_Cola) # R=> ('Juan', 'Diego', 'Luis', 'Jorge']) +print(mi_Cola.popleft()) # Ahora se va el segundo en llegar R=> Juan +print(mi_Cola) # R=> ('Diego', 'Luis', 'Jorge']) + # La lista restante en orden de llegada + +# Ejemplo 26 - Listas por Comprensión . MUY IMPORTANTE ENTENDERLO BIEN !! +# Permite usar expresiones y condiciones para poblar una lista. +# Sus usos comunes son para hacer nuevas colecciones donde cada elemento es el resultado +# de algunas operaciones aplicadas a cada miembro de otra secuencia o iterable, o +# para crear un segmento de la secuencia de esos elementos para satisfacer una +# condición determinada ==> Es muy parecido a EXRESIONES REGULARES (import re), +# que son fundamentales en ciencia de datos. + +# Por ejemplo, queremos crear una lista de cuadrados, como: + +cuadrados1 = [] +for x in range(10): + cuadrados1.append(x**2) # Agrega los cuadrados en el rango 0-10, a lista cuadrados +print (cuadrados1) # => [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] + +# Nótese que esto crea (o sobreescribe) una variable llamada x que sigue existiendo +# luego de que el bucle haya terminado. sin embargo, podemos aplicar listas por +# COMPRENSIÓN, poblando la lista de cuadrados sin efecto secundario haciendo: + +cuadrados2 = list(map(lambda x: x**2, range(10))) # Usamos una función lambda y map +cuadrados3 = [x**2 for x in range(10)] # otra expresión equivalente sería: + # lo cual es más conciso y legible. + +# Una lista por comprensión, consta de corchetes rodeando una expresión seguida de la +# declaración FOR, y luego 0 o más declaraciones FOR o IF. El resultado será una +# nueva lista que sale de evaluar la expresión, en el contexto de los FOR o IF que le +# siguen. Por ejemplo, esta lista de comprensión combina los elementos de 2 listas +# si no son iguales: + +# Ejemplo 27 Lista Distintos +# +[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y] # R=> [(1, 3), (1, 4), (2, 3), + # (2, 1), (2, 4), (3, 1), (3, 4)] + +# y es equivalente a: + +combinar_listaDistintos = [] +for x in [1,2,3]: + for y in [3,1,4]: + if x != y: + combinar_listaDistintos.append((x, y)) +print (combinar_listaDistintos) # R=> [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), + # (3, 4)] +# Nótese como el orden de los for e if es el mismo en ambos pedacitos de código. +# Si la expresión es una tupla (como el (x, y) en el ejemplo anterior), debe estar entre paréntesis. + +# Ejemplo 28 - Operaciones con vectores +vector1 = [-4, -2, 0, 2, 4] # Crear un nueva lista con los valores *2 +vector2 = [x*2 for x in vector1] # Llenamos la lista, usando una expresión que calcula x^2 +print ("La lista de los x^2, del Vector 1 es ", vector2) # Comprobamos el resultado imprimiento la lista, OK! R=> [-8, -4, 0, 4, 8] +# Filtrar la lista para excluir los valores negativos +vector3 = [x for x in vector2 if x >= 0] # Esta expresión, llena la lista, separando positivos de negativos. +print (vector3) # Comprobamos el resultado imprimiento la lista, OK! R=> [0, 2, 4] +# Creamos una nueva lista, aplicado una función de valor absoluto (abs) a todos los elementos del vector1 +vector4 = [abs(x) for x in vector1] # Llenamos vector 4 con el resultado +print (vector4) # Comprobamos el resultado imprimiento la lista, OK! R=> [4, 2, 0, 2, 4] + +# Ejemplo 29 Limpiar datos usando STRIP +# También usamos expresiones para tareas repetitivas. +# En este ejemplo se usa la función STRIP para recortar los espacios en blanco + +fruta_fresca = [' banana', ' mora ', 'kiwi '] # Nótese que el 'raw data', viene con espacios a ambos lados del str +[cortar_espacios.strip() for cortar_espacios in fruta_fresca] # Al aplicar la función STRIP, se recortan los espacios +# La lista resultante queda R=> ['banana', 'mora', 'kiwi'] + +# Ejemplo 30 - Crear una lista de 2 tuplas como (número, su_cuadrado) +# +lista_cuad = [(x, x**2) for x in range(6)] # Recordar, va de 0 a 5, excluye el lim_sup del intervalo +print ('La lista de pares (x, x^2), es ', lista_cuad) +# La lista de pares (x, x^2), es [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)] +# La expresión a comparar (x, x**2), debe estar entre paréntesis, de lo contrario se genera un error + +# Ejemplo 31 - Aplanar una lista usando listas compuestas (listcomp) con dos 'FOR' + +vec = [[1,2,3], [4,5,6], [7,8,9]] # vec es un arreglo de listas y queremos ponerlas en una sola lista +flat_vec= [num for elem in vec for num in elem] # Nótese que en este caso no uso paréntesis, no es comparación o formula +print ("La lista 'aplanada' es ", flat_vec) # La lista esperada R=>[1, 2, 3, 4, 5, 6, 7, 8, 9] + +# Ejemplo 32 - Listas anidades con expresiones complejas +# Las listas por comprensión pueden contener expresiones complejas y funciones anidadas: + +from math import pi # Importamos una librería "MATH" que nos permite hacer cálculos científicos y usar constantes +pi_evol= [str(round(pi, i)) for i in range(1, 6)] # Creamos una lista con incrementales de pi +print ('Los valores incrementales de pi, son ', pi_evol) +# R=> Los valores incrementales de pi, son ['3.1', '3.14', '3.142', '3.1416', '3.14159'] \ No newline at end of file diff --git a/Workbench/Taller/pruebaerror.ipynb b/Workbench/Taller/pruebaerror.ipynb new file mode 100644 index 000000000..11e97c9d6 --- /dev/null +++ b/Workbench/Taller/pruebaerror.ipynb @@ -0,0 +1,1442 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class Clase:\n", + " atributo_clase = \"Hola\" # Accesible desde el exterior\n", + " __atributo_clase = \"Hola\" # No accesible\n", + "\n", + " # No accesible desde el exterior usando guión bajo\n", + " def __mi_metodo(self):\n", + " print(\"Haz algo\")\n", + " self.__variable = 0\n", + "\n", + " # Este código es accesible desde el exterior\n", + " def metodo_normal(self):\n", + " # El método si es accesible desde el interior\n", + " self.__mi_metodo()\n", + "\n", + "mi_clase = Clase()\n", + "#mi_clase.__atributo_clase # Error! El atributo no es accesible\n", + "#mi_clase.__mi_metodo() # Error! El método no es accesible\n", + "mi_clase.atributo_clase # Ok!\n", + "mi_clase.metodo_normal() # Ok!\n", + "print (mi_clase._Clase__atributo_clase)\n", + "# 'Hola'\n", + "mi_clase._Clase__mi_metodo()\n", + "# 'Haz algo'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class Vehiculo:\n", + " def __init__(self, color, tipo, cilindrada):\n", + " self.color = color\n", + " self.tipo = tipo\n", + " self.cilindrada = cilindrada\n", + " self.velocidad = 0 # Aquí creamos el atributo velocidad, no se requieren 2\n", + " self.direccion = 0 # Aquí creamos el atributo velocidad\n", + "\n", + " def Acelerar(self, vel): # Recibe un parámetro velocidad\n", + " self.velocidad += vel # Este es método que modifica el atributo velocidad\n", + "\n", + " def Frenar(self, vel): # Recibe un parámetro velocidad, es sólo un valor\n", + " self.velocidad -= vel # Calcula la nueva velocidad\n", + " \n", + " def Doblar(self, grados): # Recibe la cantidad de grados de l giro (0-360)\n", + " self.direccion += grados # Calcula la nueva dirección\n", + " \n", + " def Estado(self):\n", + " print('La velocidad actual es :', self.velocidad, '- y su rumbo es:', self.direccion, 'grados')\n", + "\n", + " def Detalle(self):\n", + " print('Soy del tipo ', self.tipo, 'de color', self.color, 'y mi cilindrada es de', self.cilindrada, 'litros')\n", + "\n", + "# 3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego\n", + "# el resultado\n", + "\n", + "a1 = Vehiculo ('rojo', 'auto', 2)\n", + "a2 = Vehiculo ('blanco', 'camioneta', 3.6)\n", + "a3 = Vehiculo ('negro', 'moto', 1)\n", + "\n", + "#a1.Acelerar(40)\n", + "a2.Acelerar(60)\n", + "a3.Acelerar(30)\n", + "#a1.Doblar(30)\n", + "a3.Doblar(30)\n", + "a2.Frenar(50)\n", + "a1.Doblar(100)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3, 6, 9]\n" + ] + } + ], + "source": [ + "# LISTA DIVISIBLES\n", + "\n", + "# ListaDivisibles(12, 10)\n", + "# lista_esperada = []\n", + "\n", + "# ListaDivisibles(12, 100)\n", + "# lista_esperada = [12,24,36,48,60,72,84,96]\n", + "\n", + "# ListaDivisibles(3, 9)\n", + "# lista_esperada = [3,6,9]\n", + "\n", + "def ListaDivisibles(numero, tope):\n", + " '''\n", + " Esta función devuelve una lista ordenada de menor a mayor con los números divisibles \n", + " por el parámetro número entre uno (1) y el valor del parámetro \"tope\"\n", + " Recibe dos argumentos:\n", + " numero: Numero entero divisor\n", + " tope: Máximo valor a evaluar a partir de uno (1)\n", + " Ej:\n", + " ListaDivisibles(6,30) debe retornar [6,12,18,24,30]\n", + " ListaDivisibles(10,5) debe retornar []\n", + " ListaDivisibles(7,50) debe retornar [7,14,21,28,35,42,49]\n", + " '''\n", + " #Tu código aca:\n", + " lint = list(range(numero,tope+1))\n", + " ldiv = []\n", + " \n", + " if numero > tope:\n", + " print(ldiv)\n", + " return ldiv\n", + " if numero <= 0:\n", + " print(str(numero) + ', que corresponde a ser el divisor, NO puede ser = 0.')\n", + " return None\n", + " for i in lint:\n", + " if (i % numero) == 0:\n", + " ldiv.append(i)\n", + " ldiv.sort(reverse=False)\n", + " print(ldiv) \n", + " return ldiv\n", + " \n", + "lista_divisible=ListaDivisibles(3, 9)\n", + " # 12, 10 []\n", + " # 12. 100 [12,24,36,48,60,72,84,96]\n", + " # 3, 9 [3,6,9]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "blanco 10 3.6\n", + "Soy del tipo auto de color rojo y mi cilindrada es de 2 litros\n", + "La velocidad actual es : 0 - y su rumbo es: 0 grados\n" + ] + } + ], + "source": [ + "print (a2. color, a2.velocidad, a2.cilindrada)\n", + "a1 = Vehiculo('rojo', 'auto', 2)\n", + "a1.Detalle()\n", + "a1.Estado()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print (a1.velocidad) # Tenía 0, le sume 40, queda en 40\n", + "print (a2.velocidad) # Tenía 0, le sume 40, queda en 60\n", + "print (a3.velocidad) # Tenía 0, le sume 40, queda en 30\n", + "print (a1.direccion) # Tenía 0 grados, queda en 30\n", + "print (a3.direccion) # Tenía 0 grados, queda en -30\n", + "print (a2.velocidad) # Frena y DISMINUYE (resta -50), debe quedar en 10" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "class Operacion:\n", + "\n", + " def __init__(self):\n", + " self.valor1=int(input(\"Ingrese primer valor:\"))\n", + " self.valor2=int(input(\"Ingrese segundo valor:\"))\n", + " self.sumar()\n", + " self.restar()\n", + " self.multiplicar()\n", + " self.dividir()\n", + "\n", + " def sumar(self):\n", + " suma=self.valor1+self.valor2\n", + " print(\"La suma es\",suma)\n", + "\n", + " def restar(self):\n", + " resta=self.valor1-self.valor2\n", + " print(\"La rersta es\",resta)\n", + "\n", + " def multiplicar(self):\n", + " multi=self.valor1*self.valor2\n", + " print(\"El producto es\",multi)\n", + "\n", + " def dividir(self):\n", + " divi=self.valor1/self.valor2\n", + " print(\"La division es\",divi)\n", + "\n", + "\n", + "# bloque principal\n", + "\n", + "#operacion1=Operacion5\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "for n in range(1,11): #Incluye el primero y excluye el último\n", + " print(n,(')'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n = 1\n", + "while (n < 11):\n", + " print(n)\n", + " n = n + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Azul', 'Amarillo', 'Naranja', 'Violeta', 'Verde']\n" + ] + } + ], + "source": [ + "mi_lista = ['Rojo','Azul','Amarillo','Naranja','Violeta','Verde'] # Lista de 6 elementos\n", + "\n", + "print(mi_lista[1:]) # Imprime la lista desde la posición 1, hasta el final, \n", + "#" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Rojo', 'Azul', 'Amarillo', 'Negro', 'Naranja', 'Violeta', 'Verde']\n" + ] + } + ], + "source": [ + "#mi_lista.insert(3,'Negro')\n", + "print(mi_lista)\n", + "#print(type(mi_lista.index('Azul')))\n", + "#print(mi_lista[1])\n", + "#mi_lista.insert(3,'Negro')\n", + "\n", + "#n = 1\n", + "#while (n < 11):\n", + "# mi_lista.remove('Negro')\n", + "# n = n + 1\n", + "#mi_lista.remove('Blanco')\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ultimo = mi_lista.pop() # Remueve el último elemento de la lista,\n", + "# print (mi_lista) # Falta el 'Verde'\n", + "#ultimo = mi_lista.pop()\n", + "#print(ultimo) #Conserva el último elemento eliminado con POP, si ejecuto otra vez, elimina violeta." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_tupla = ('Rojo','Azul','Amarillo','Naranja','Rojo','Violeta','Rojo','Verde')\n", + "mi_tupla.count('Rojo')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_tupla='Gaspar', 5, 8, 1999\n", + "#print (type(mi_tupla[3]))\n", + "nombre, dia, mes, año = mi_tupla\n", + "print (mi_tupla)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nombre = 'Darío' # Inicializo var nombre con el str 'Darío'\n", + "edad = 39 # Inicilizo var edad con el int 39\n", + "print(nombre, edad) # Imprimo el contenido de las variables.\n", + "print(\"Mi nombre es\", nombre, \". Mi edad es\", edad, \"años\")\n", + "print(\"Mi nombre es {}. Mi edad es {} años\". format(nombre, edad))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'], # Crear con {key:Elm, key:Elm...}\n", + " 'Colores secundarios': ['Naranja','Violeta','Verde'], # Elm= Cualquier cosa, mutable\n", + " 'Clave3': 10, # Key= Hasheable, inmutable\n", + " 'Clave4': False}\n", + "#print (mi_diccionario['Colores secundarios']) # Lo puedo acceder por sus claves o índices y retorna los VALORES\n", + "# R=> ['Naranja', 'Violeta', 'Verde'] # Para la clave dad, retorno los elementos respectivos\n", + "\n", + "mi_diccionario2 = {'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}} # Dic key1=str y val1=str, key2=str, val2=lista\n", + "print (mi_diccionario2.keys()) # Retorna R=> dict_keys(['Clave1', 'Clave2'])\n", + "print(mi_diccionario2.values()) # Retorna R=> dict_values(['Valor1', {'numeros': [1, 2, 3, 4, 5]}])\n", + "len (mi_diccionario) # Retorna el número de pares R=>2\n", + "print(mi_diccionario2)\n", + "print(type(mi_diccionario2.keys[1]))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "edad = 60\n", + "edad_compa = 50\n", + "if (edad < edad_compa):\n", + " print(edad)\n", + " if (edad < 100):\n", + " print(edad + 100)\n", + " else:\n", + " print(edad - 100)\n", + "else:\n", + " print(edad_compa)\n", + "# 50\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "primeros_10 = [0,1,2,3,4,5,6,7,8,9]\n", + "# print(primeros_10) # R=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "outlist = []\n", + "for n in primeros_10: # For 'var' in 'lista/tupla/dict'\n", + " if (n%2 == 0): # Uso la función resto para reconocer los PARES \n", + " outlist.append(n)\n", + " #primeros_10[n]=0\n", + "print ('Los pares son', outlist)\n", + "#print(\"\\va de nuevo....\\n\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "outlist = []\n", + "for n in primeros_10: # For 'var' in 'lista/tupla/dict'\n", + " if (n%2 == 0): # Uso la función resto para reconocer los PARES \n", + " outlist.append(n) # Los guardo en una lista para poder mostrarlos horizontalmente \n", + "print ('Los pares son', outlist) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n = 40\n", + "sequence = [0,1]\n", + "for i in range(2,n):\n", + " sequence.append(sequence[i-1]+sequence[i-2])\n", + "print (sequence)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = [1, 2]\n", + "b = [\"Uno\", \"Dos\"]\n", + "c = zip(a, b)\n", + "for numero, texto in zip(a, b):\n", + " print(\"Número\", numero, \"Letra\", texto)\n", + " print(type(numero), type(texto))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "colores = ['yellow', 'wine', 'blue', 'green', 'red', 'brown', 'red']\n", + "sec_colr = ['blue', 'green', 'red']\n", + "\n", + "\n", + "strColores = str(colores).strip(\"[]\")\n", + "strSec_colr = str(sec_colr).strip(\"[]\")\n", + "\n", + "if strSec_colr in strColores:\n", + " print(\"Si\")\n", + "else:\n", + " print(\"No\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hola = ' \\t\\t\\n\\tHola \\n '\n", + "print(hola)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hola_limpio = hola.strip()\n", + "print(type(hola_limpio))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "texto = ' hola mundo hola \\ni'\n", + "print(texto.strip(' oahl'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "colores = ['yellow', 'wine', 'blue', 'green', 'red', 'brown', 'red']\n", + "sec_colr = ['blue', 'green', 'red']\n", + "\n", + "strColores = str(colores).strip(\"[]\")\n", + "strSec_colr = str(sec_colr).strip(\"[]\")\n", + "\n", + "if strSec_colr in strColores:\n", + " print(\"Si\")\n", + "else:\n", + " print(\"No\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import deque\n", + "\n", + "mi_Cola = deque([\"Pedro\", \"Juan\", \"Diego\"]) # Están Pedro, Juan y Diego en la cola\n", + "mi_Cola.append(\"Luis\") # Llega Luis\n", + "print (mi_Cola) # R=> (['Pedro', 'Juan', 'Diego', 'Luis'])\n", + "mi_Cola.append(\"Jorge\") # Llega Jorge\n", + "print (mi_Cola) # R=> (['Pedro', 'Juan', 'Diego', 'Luis', 'Jorge'])\n", + "print(mi_Cola.popleft()) # El primero en llegar se va => Pedro\n", + "print(mi_Cola) # R=> ('Juan', 'Diego', 'Luis', 'Jorge'])\n", + "print(mi_Cola.popleft()) # Ahora se va el segundo en llegar R=> Juan\n", + "print(mi_Cola) # R=> ('Diego', 'Luis', 'Jorge'])\n", + " # La lista restante en orden de llegada" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from collections import deque\n", + "\n", + "queue = deque([\"Eric\", \"John\", \"Michael\"])\n", + "queue.append(\"Terry\") # Terry arrives\n", + "print (queue) # (['Eric', 'John', 'Michael', 'Terry'])\n", + "queue.append(\"Graham\") # Graham arrives\n", + "print (queue) # (['Eric', 'John', 'Michael', 'Terry', 'Graham'])\n", + "print(queue.popleft()) # The first to arrive now leaves\n", + "#print(queue.popleft()) # 'Eric'\n", + "print (queue) # (['John', 'Michael', 'Terry', 'Graham'])\n", + "print(queue.popleft()) # The second to arrive now leaves\n", + "print(queue.popleft()) #'John'\n", + "queue # Remaining queue in order of arrival\n", + "deque(['Michael', 'Terry', 'Graham'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n = 40\n", + "sequence = [0,1]\n", + "for i in range(2,n):\n", + " sequence.append(sequence[i-1]+sequence[i-2])\n", + "print (sequence)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cuadrados1 = []\n", + "for x in range(10):\n", + " cuadrados1.append(x**2) # Agrega los cuadrados en el rango 0-10, a lista cuadrados\n", + "print (cuadrados1) # => [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] \n", + "\n", + "# Nótese que esto crea (o sobreescribe) una variable llamada x que sigue existiendo \n", + "# luego de que el bucle haya terminado. sin embargo, podemos aplicar listas por \n", + "# COMPRENSIÓN, poblando la lista de cuadrados sin efecto secundario haciendo:\n", + "\n", + "cuadrados2 = list(map(lambda x: x**2, range(10))) # Usamos una función lambda y map\n", + "print (cuadrados1)\n", + "cuadrados3 = [x**2 for x in range(10)] # otra equivalente sería:\n", + "print (cuadrados1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "lista_cuad = [(x, x**2) for x in range(6)]\n", + "print ('La lista de pares (x, x^2), es ', lista_cuad)\n", + "#[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Ejemplo - aplanar una lista usando un listas compuestas (listcomp) con dos 'FOR'\n", + "\n", + "vec = [[1,2,3], [4,5,6], [7,8,9]] # vec es un arreglo de listas\n", + "flat_vec= [num for elem in vec for num in elem] # Nótese que en este caso no uso paréntesis, no es comparación o formula\n", + "\n", + "print (\"La lista 'aplanada' es \", flat_vec) # La lista esperada R=>[1, 2, 3, 4, 5, 6, 7, 8, 9]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from math import pi # Importamos una librería \"MATH\" que nos permite hacer cálculos científicos y usar constantes \n", + "pi_evol= [str(round(pi, i)) for i in range(1, 6)] # Creamos una lista con incrementales de pi\n", + "print ('Los valores incrementales de pi, son ', pi_evol)\n", + "# R=> Los valores incrementales de pi, son ['3.1', '3.14', '3.142', '3.1416', '3.14159']" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [], + "source": [ + "class Persona():\n", + "\n", + " def __init__(self,nombre=\"\",edad=0,dni=\"\"):\n", + " self.nombre=nombre\n", + " self.edad=edad\n", + " self.dni=dni\n", + " \n", + " @property\n", + " def nombre(self):\n", + " return self.__nombre\n", + "\n", + " @property\n", + " def edad(self):\n", + " return self.__edad\n", + "\n", + " @property\n", + " def dni(self):\n", + " return self.__dni\n", + " \n", + " @nombre.setter\n", + " def nombre(self,nombre):\n", + " self.__nombre=nombre\n", + "\n", + " def validar_dni(self):\n", + " letras = \"TRWAGMYFPDXBNJZSQVHLCKE\"\n", + " if len(self.__dni)!=9:\n", + " print(\"DNI incorrecto\")\n", + " self.__dni = \"\"\n", + " else:\n", + " letra = self.__dni[8]\n", + " num = int(self.__dni[:8])\n", + " if letra.upper() != letras[num % 23]:\n", + " print(\"DNI incorrecto\")\n", + " self.__dni = \"\"\n", + "\n", + " @dni.setter\n", + " def dni(self,dni):\n", + " self.__dni=dni\n", + " self.validar_dni()\n", + " \n", + " @edad.setter\n", + " def edad(self,edad):\n", + " if edad < 0:\n", + " print(\"Edad incorrecta\")\n", + " self.__edad=0\n", + " else:\n", + " self.__edad=edad\n", + " \n", + " \n", + " def mostrar(self):\n", + " return \"Nombre:\"+self.nombre+\" - Edad:\"+str(self.edad)+\" - DNI:\"+self.dni\n", + "\n", + " def esMayorDeEdad(self):\n", + " return self.edad>=18\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def swap(a,b):\n", + " c=a\n", + " a=b\n", + " b=c\n", + " return (a,b)\n", + "\n", + "x = ['ab', 'cd','ef',5]\n", + "y = 4\n", + "print (x,y)\n", + "x,y= swap(x,y)\n", + "print (x,y)\n", + "print ()\n", + "\n", + "# caso 2) Directo y,x = x,y, propiedades de Python\n", + "# \n", + "x= 'diez'\n", + "y= True\n", + "print (x,y)\n", + "x,y=y,x\n", + "print (x,y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class Complex:\n", + " def __init__(self, realpart, imagpart):\n", + " self.r = realpart\n", + " self.i = imagpart\n", + "\n", + "x = Complex(3.0, -4.5)\n", + "x.r, x.i\n", + "print (type (x.r))\n", + "3.0, -4.5" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "metadata": {}, + "outputs": [], + "source": [ + "class Emprendedor:\n", + " \"\"\"En esta clase se crean emprendedores\n", + " Recibe: str (nombre), str (apellido), list (libros), list (mascotas) \n", + " \"\"\"\n", + " mascotas = [] # Lista que acumulará las mascotas del Emprendedor\n", + " libros = [] # Lista que colectará los libros del Emprendedor\n", + " \n", + " def __init__(self, nombre, apellido, libros, mascotas):\n", + " self.nombre = nombre\n", + " self.apellido = apellido\n", + " self.libros = libros\n", + " self.mascotas = mascotas\n", + "\n", + "# b) Crear un Método que agregue una mascota (mascota) a la lista, no debe \n", + "# retornar nada. Mascotas es una lista\n", + "# \n", + "\n", + " def addMascotas (self, newPet): # Si el Empredendor tiene perro y gato, agregué una tortuga\n", + " self.mascotas.append(newPet) #\n", + "\n", + " def getmascotas (self): #\n", + " pass #\n", + "\n", + " def addBook (self, book, newautor): # El método addBook, recibe un str (book) y un str (autor)\n", + " self.libros.append(book) # Debe agregar un objeto DICT que recibe y guarda los parámetros\n", + " pass # dic = {nombre:book, autor:autor} \n", + " # No retorna nada\n", + "\n", + " def getCase (self): # Retorna qtty de mascotas que tiene el emprendedor\n", + " pass # Ej. Si tiene 2 mascotas, debe retornar 2\n", + " # Como es una lista, puedo hacer list.len(self.mascotas)\n", + "\n", + " def getBooks (self): # Debe retornar sólo los nombres de los libros\n", + " pass # Debería devolver ['El Señor de las Moscas', 'Fundación']\n", + "\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 401, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "la lista de primos es [5, 7, 11, 13]\n" + ] + } + ], + "source": [ + "# LISTA PRIMOS\n", + "\n", + "def ListaPrimos(desde, hasta):\n", + " List_pri=[]\n", + " tope=hasta\n", + " n=desde\n", + " primo = True\n", + " if(type(n) != int):\n", + " return None\n", + " if(type(tope)!= int):\n", + " return None\n", + " while (n<=tope):\n", + " for div in range(2,n):\n", + " if(n%div==0):\n", + " primo=False\n", + " if (primo):\n", + " List_pri.insert(n-1,n)\n", + " else:\n", + " primo = True\n", + " n +=1\n", + " return List_pri\n", + "\n", + "imprime=ListaPrimos (5, 15)\n", + "print ('la lista de primos es',imprime)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 252, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'clave1': ['c', 'b', 'a'],\n", + " 'clave2': ['casa', 'barco', 'auto'],\n", + " 'clave3': [3, 2, 1]}" + ] + }, + "execution_count": 252, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "# Esta función recibe como parámetro un diccionario, cuyas listas de valores tienen el mismo\n", + "# tamaño y sus elementos enésimos están asociados. Y otros dos parámetros que indican\n", + "# la clave por la cual debe ordenarse y si es descendente o ascendente.\n", + "# La función debe devolver el diccionario ordenado, teniendo en cuenta de no perder la\n", + "# relación entre los elementos enésimos.\n", + "# Recibe tres argumentos:\n", + "#\n", + "# diccionario: Diccionario a ordenar.\n", + "# clave: Clave del diccionario recibido, por la cual ordenar.\n", + "# descendente: Un valor booleano, que al ser verdadero indica ordenamiento ascendente y \n", + "# descendente si es falso. \n", + "# Debe tratarse de un parámetro por defecto en True.\n", + "# Si el parámetro diccionario no es un tipo de dato diccionario ó el parámetro clave no \n", + "# se encuentra dentro de las claves del diccionario, debe devolver nulo.\n", + "# Ej:\n", + "# dicc = {'clave1':['c','a','b'],\n", + "# 'clave2':['casa','auto','barco'],\n", + "# 'clave3':[1,2,3]}\n", + "#\n", + "# OrdenarDiccionario(dicc, 'clave1') debe retornar {'clave1':['a','b','c'],\n", + "# 'clave2':['auto','barco','casa'],\n", + "# 'clave3':[2,3,1]}\n", + "# OrdenarDiccionario(dicc, 'clave3', False) debe retornar {'clave1':['b','a','c'],\n", + "# 'clave2':['barco','auto','casa'],\n", + "# 'clave3':[3,2,1]}\n", + "#debe retornar\n", + "\n", + "# {'clave1':['b','a','c'], 'clave2':['barco','auto','casa'],'clave3':[3,2,1]}\n", + "# \n", + "dicc = {'clave1':['c','a','b'],\n", + " 'clave2':['casa','auto','barco'],\n", + " 'clave3':[1,2,3]}\n", + "\n", + "def OrdenarDiccionario(diccionario_par, clave, descendente=True):\n", + " listet = list(diccionario_par.keys())\n", + " #print = (listet)\n", + " for i in diccionario_par:\n", + " if i == clave:\n", + " for j in diccionario_par:\n", + " diccionario_par[j].sort()\n", + " if descendente == True:\n", + " diccionario_par[j].reverse()\n", + " \n", + " return diccionario_par\n", + " #return(print (listet))\n", + "\n", + "# print (dicc)\n", + "OrdenarDiccionario(dicc, 'clave1') \n", + "\n", + "#OrdenarDiccionario(dicc, 'clave3', False)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Sin embargo, si usamos la función items del tipo DICT, podemos acceder\n", + "# al key y al value de cada elemento.\n", + "# Se puede facilitar para modificar valores usando, e.g casteo de dict a list y viceversa\n", + "#esp = {'1': 'Uno', '2': 'Dos', '3': 'Tres'}\n", + "#eng = {'1': 'One', '2': 'Two', '3': 'Three'}\n", + "\n", + "#for (k1, v1), (k2, v2) in zip(esp.items(), eng.items()):\n", + "# print(k1, v1, v2)\n", + "# Nótese que en este caso ambas key k1 y k2 son iguales.\n", + "# 1 Uno One\n", + "# 2 Dos Two\n", + "# 3 Tres Three\n", + "dicc = {'clave1':['c','a','b'],\n", + " 'clave2':['casa','auto','barco'],\n", + " 'clave3':[1,2,3]}\n", + "dicc_list = dicc.items()\n", + "dicc_list = list (dicc_list)\n", + "#print (dicc_items[1:3]) \n", + "k0 = ['clave1', 'clave2', 'clave3']\n", + "v1 = ['c', 'b', 'a']\n", + "v2 = ['casa', 'barco', 'auto']\n", + "v3 = [3, 2, 1]\n", + "i=1\n", + "#print(k0[0], v1[0], v2[0], v3[0])\n", + "#keyword=\n", + "#for i (k[i], v1), (k[i], v2), (k[i],v3) in dicc.items():\n", + "for i in dicc_list:\n", + " print(dicc_list(i), dicc_items.values(i), dicc_items.values(i), dicc_items.values(3))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "'''\n", + " En matemáticas, la palabra capicúa (del catalán cap i cua, 'cabeza y cola')​ \n", + " se refiere a cualquier número que se lee igual de izquierda a derecha que \n", + " de derecha a izquierda. Se denominan también números palíndromos.\n", + " Esta función devuelve el valor booleano True si el número es capicúa, de lo contrario\n", + " devuelve el valor booleano False \n", + " En caso de que el parámetro no sea de tipo entero, debe retornar nulo.\n", + " Recibe un argumento:\n", + " numero: Será el número sobre el que se evaluará si es capicúa o no lo es.\n", + " Ej:\n", + " NumeroCapicua(787) debe retornar True\n", + " NumeroCapicua(108) debe retornar False\n", + "'''\n", + "def NumeroCapicua(numero):\n", + " cadena3 = str(numero)\n", + " pali = []\n", + " pali2 = []\n", + " if type(numero) == int:\n", + " for i in range(len(cadena3) -1, -1, -1):\n", + " pali.append(cadena3[i])\n", + " for j in range(len(pali)-1, -1, -1):\n", + " pali2.append(pali[j])\n", + " if (pali == pali2):\n", + " return True\n", + " else:\n", + " return False\n", + " else:\n", + " return None\n", + " \n", + " \n", + "print (NumeroCapicua(92529))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# factorizar_numero(5)\n", + "# valor_esperado = [[5],[1]]\n", + "# \n", + "# factorizar_numero(1428)\n", + "# valor_esperado = [[2,3,7,17], [2,1,1,1]]\n", + "# \n", + "# factorizar_numero('cinco')\n", + "# valor_esperado = None\n", + "# \n", + "\n", + "def factorizar_numero(numero):\n", + " '''\n", + " Esta función recibe como parámetro un número entero mayor a cero y devuelva dos listas, \n", + " una con cada factor común y otra con su exponente, \n", + " esas dos listas tienen que estar contenidas en otra lista.\n", + " En caso de que el parámetro no sea de tipo entero y/ó mayor a cero debe retornar nulo.\n", + " Recibe un argumento:\n", + " numero: Será el número sobre el que se hará la factorización.\n", + " Ej:\n", + "\n", + " factorizar_numero(12) debe retornar [[2,3],[2,1]]\n", + " factorizar_numero(13) debe retornar [[13],[1]]\n", + " factorizar_numero(14) debe retornar [[2,7],[1,1]]\n", + " '''\n", + " lista_factores = []\n", + " lista_exponentes = []\n", + " if type(numero) == int:\n", + " #i= \n", + " while numero%2 != 1:\n", + " n=(i%2)\n", + " if n==1:\n", + " lista_i.append (i)\n", + " elif n==0:\n", + " lista_p.append (i)\n", + " print (\"Los números impares entre 1 y 10 son \", lista_i)\n", + " print (\"Los números pares entre 1 y 10 son \", lista_p)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def factoriza(n):\n", + " l = []\n", + " i = 2\n", + " while (i * i) <= n:\n", + " while (n % i) == 0:\n", + " l.append(i)\n", + " n = n / i\n", + " i = i + 1\n", + " if n != 1:\n", + " l.append(n)\n", + " return l\n", + "factoriza (10)" + ] + }, + { + "cell_type": "code", + "execution_count": 415, + "metadata": {}, + "outputs": [], + "source": [ + "#def divisores ():\n", + "num = 10 #int (input ('Escribe un entero'))\n", + "listaFC = []\n", + "i=2\n", + "while num/c) !=1:\n", + " if num%i==0:\n", + " listaFC.append(num//i)\n", + " listaFC.sort()\n", + " i+=1\n", + "for f in listaFC:\n", + " print (f)\n", + " #, end=',')\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 376, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La palabra ' 777 ' no es palíndroma e invertida, es []\n" + ] + } + ], + "source": [ + "num = input ('Ingrese número _')\n", + "cadena3 = str(num)\n", + "cadena4 = \"reconocer\" # R=> 'reconocer', es palíndroma\n", + "pali = []\n", + "pali2 = []\n", + "if (num!=int):\n", + " print (\"La palabra\",\"'\", cadena3,\"'\", \"no es palíndroma e invertida, es\", pali, end=\"\") \n", + " \n", + "elif (nun>0):\n", + " for i in range(len(cadena3) -1, -1, -1):\n", + " pali.append(cadena3[i])\n", + " for j in range(len(pali)-1, -1, -1):\n", + " pali2.append(pali[j])\n", + " if (pali == pali2):\n", + " #return True\n", + " print(\"es palíndromo\")\n", + "else:\n", + " #return False\n", + " print (\"La palabra\",\"'\", cadena3,\"'\", \"no es palíndroma e invertida, es\", pali, end=\"\")\n", + "print()" + ] + }, + { + "cell_type": "code", + "execution_count": 353, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('Rojo', '4859-A', 'A'), ('Gris', '1892-B', 'M'), ('Azul', '2901-Z', 'M')]" + ] + }, + "execution_count": 353, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tuplas_coches = [\n", + " ('Rojo', '4859-A', 'A'),\n", + " ('Azul', '2901-Z', 'M'),\n", + " ('Gris', '1892-B', 'M')\n", + "]\n", + "ordenarpor='0'\n", + "\n", + "if ordenarpor == 0:\n", + "\n", + "sorted(tuplas_coches, key=itemgetter(2, 1))\n", + "#[('Rojo', '4859-A', 'A'), ('Gris', '1892-B', 'M'), ('Azul', '2901-Z', 'M')]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from operator import itemgetter\n", + "def OrdenarDiccionario(diccionario_par, clave, descendente=True):\n", + " dicc = {'clave1':['c','a','b'], 'clave2':['casa','auto','barco'], 'clave3':[1,2,3]}\n", + "\n", + " for n in sorted(dicc), str(\"clave1\"):\n", + " return n\n", + "\n", + "def ordenardiccionario2(self):\n", + " dicc = ['c','a','b']\n", + " for x in sorted(dicc, str(\"clave1\"), True):\n", + " return None\n", + " \n", + "def ordenardiccionario3(self): \n", + " dicc = {'clave1':['c','a','b'], 'clave2':['casa','auto','barco'], 'clave3':[3,1,2]}\n", + " for j in sorted(dicc, str(\"clave3\"), False):\n", + " return j\n", + "\n", + "OrdenarDiccionario(dicc, 'clave3') \n", + "print(dicc.get('clave1')) #Sara" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dicc = {\n", + " 'clave1':['c','a','b'],\n", + " 'clave2':['casa','auto','barco'],\n", + " 'clave3':[1,2,3]\n", + " }\n", + "bykey=dicc.keys () # Guardo las llaves en una var\n", + "keyord='clave1' # Guardo la la clave por la que quiero ordenar\n", + "# sorted_bykey={}\n", + "# print (bykey)\n", + "# sorted_bykey=sorted(bykey)\n", + "# print (sorted_bykey)\n", + "# sorted_bykey={}\n", + "#for\n", + "dic_ord_by_key = sorted(dicc, key=keyord)\n", + "print (\"Ordenada por calificación ascendente: \")\n", + "for algo in dic_ord_by_key:\n", + " print (keyword)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dicc = {\n", + " 'clave1':['c','a','b'],\n", + " 'clave2':['casa','auto','barco'],\n", + " 'clave3':[1,2,3]\n", + " }\n", + "\n", + "#for x in dicc:\n", + "# print(dicc[x])\n", + "# ['c', 'a', 'b']\n", + "# ['casa', 'auto', 'barco']\n", + "# [1, 2, 3]\n", + "print(dicc)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "key_list = ['clave1', 'clave2', 'clave3']\n", + "value_list1 = [['c', 'a', 'b'], ['casa', 'auto', 'barco'], [1, 2, 3]]\n", + "\n", + "# ['c', 'a', 'b']\n", + "# ['casa', 'auto', 'barco']\n", + "# [1, 2, 3]\n", + "dict_from_list = dict(zip(key_list, value_list1))\n", + "print(dict_from_list)\n", + "# {'clave1':['b','a','c'], 'clave2':['barco','auto','casa'],'clave3':[3,2,1]}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'clave1': 'Juan', 'clave2': '27', 'clave3': 'Nueva York'}\n" + ] + } + ], + "source": [ + "# Une dos listas en un dict\n", + "key_list = ['clave1', 'clave2', 'clave3']\n", + "value_list = ['Juan', '27', 'Nueva York']\n", + "\n", + "dict_from_list = {k: v for k, v in zip(key_list, value_list)}\n", + "print(dict_from_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "dicc = {\n", + " 'clave1':['c','a','b'],\n", + " 'clave2':['casa','auto','barco'],\n", + " 'clave3':[1,2,3]\n", + " }\n", + "varkeys=len()\n", + "\n", + "if len(varkeys[list(dicc.keys()]>0) \n", + "\tvalores=len(dicc_par[list(dicc_par.keys())[0]])\n", + "# convertimos el diccionario de listas, a una lista de diccionarios:\t\n", + "\tfor i in range(0, valores):\n", + "\t\tnewObj[key] = dicc_par[key][i]\n", + "\tnewArr.append(newObj)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dicc ={\n", + "'clave1':['c', 'a', 'b'],\n", + "'clave2':['casa', 'auto', 'barco'],\n", + "'clave3':[3,2,1]}\n", + "dicc_swp= {} # Recibe dic transitorios no ordenados, ver si es lista o no\n", + "dicc_ord= {} # Recibe el nuevo dic ordenado \n", + "listkeys =list(dicc.keys())\n", + "listvalues = list(dicc.values())\n", + "print (listvalues)\n", + "print (type(listkeys))\n", + "print (len(listkeys)) # List horz de las keys\n", + "print (listkeys) # Ahora sabemos cuantos elementos tiene\n", + "for k in listkeys:\n", + " print (k)\n", + "for v in listvalues:\n", + " print (v)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Ordenar una lista de coches almacenados como tuplas\n", + "tuplas_coches = [\n", + " ('Rojo', '4859-A', 'A'),\n", + " ('Azul', '2901-Z', 'M'),\n", + " ('Gris', '1892-B', 'M')\n", + " ]\n", + "\n", + "# Ordenar los coches por matrícula\n", + "ordenados1 = sorted(tuplas_coches, key=lambda coche : coche[1])\n", + "print ('Ord1=', ordenados1)\n", + "# [('Gris', '1892-B', 'M'), ('Azul', '2901-Z', 'M'), ('Rojo', '4859-A', 'A')]\n", + "\n", + "# Ordenar una lista de coches almacenados como diccionarios\n", + "diccionarios_coches = [\n", + " {'color': 'Rojo', 'matricula': '4859-A', 'cambio': 'A'},\n", + " {'color': 'Azul', 'matricula': '2901-Z', 'cambio': 'M'},\n", + " {'color': 'Gris', 'matricula': '1892-B', 'cambio': 'M'}\n", + "]\n", + "ordenados2 = sorted (diccionarios_coches, key=lambda coche : coche['matricula'])\n", + "print ('Ord2=', ordenados2)\n", + "# [{'color': 'Gris', 'matricula': '1892-B', 'cambio': 'M'}, \n", + "# {'color': 'Azul', 'matricula': '2901-Z', 'cambio': 'M'}, \n", + "# {'color': 'Rojo', 'matricula': '4859-A', 'cambio': 'A'}]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "este es el dicc ordenado por la clave X {'clave1': ['b', 'a', 'c'], 'clave2': ['barco', 'auto', 'casa'], 'clave3': [3, 2, 1]}\n" + ] + } + ], + "source": [ + "dicc={'midic':('a','b')}\n", + "if type(dicc) != dict:\n", + " if type(getattr(dicc)!= False):\n", + " pass #return None\n", + "dicc2={'clave1':['b','a','c'], 'clave2':['barco','auto','casa'],'clave3':[3,2,1]}\n", + "print ('este es el dicc ordenado por la clave X', dicc2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dicc ={\n", + "'clave1':['c', 'a', 'b'],\n", + "'clave2':['casa', 'auto', 'barco'],\n", + "'clave3':[3,2,1]}\n", + "\n", + "juegos = [\n", + "{\"nombre\": \"Resident Evil 2\", \"calificacion\": 99,},\n", + "{\"nombre\": \"Crash Bandicoot\", \"calificacion\": 76,},\n", + "{\"nombre\": \"Cuphead\", \"calificacion\": 100,},\n", + "{\"nombre\": \"Minecraft\", \"calificacion\": 80,},\n", + "{\"nombre\": \"Bioshock\", \"calificacion\": 95,},]\n", + "\n", + "def funcion_que_devuelve_clave(juego):\n", + " # Vamos a ordenar basándonos en su calificación, y como se nos\n", + " # va a pasar un diccionario, devolvemos el elemento \"calificacion\"\n", + " return juego[\"nombre\"]\n", + "# La ordenamos\n", + "juegos_ordenados = sorted(juegos, key=funcion_que_devuelve_clave)\n", + "print(\"Ordenada por calificación ascendente: \")\n", + "for juego in juegos_ordenados:\n", + " print(juego)\n", + "# También se puede en orden inverso\n", + "juegos_ordenados = sorted(juegos, key=funcion_que_devuelve_clave, reverse=True)\n", + "print(\"Ordenada por calificación descendente: \")\n", + "for juego in juegos_ordenados:\n", + " print(juego)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "clients = {'clave1': 1.97,\n", + " 'clave2': 8.49,\n", + " 'clave3': 9.79,\n", + " 'clave4': 8.53,\n", + " 'clave5': 0.43}\n", + "\n", + "dicc = {'clave1':['c','a','b'],\n", + " 'clave2':['casa','auto','barco'],\n", + " 'clave3':[1,2,3]}\n", + "\n", + "clients ['clave1']\n", + "clients ['clave4'] = 1.20\n", + "clients ['clave6'] = ['a', 'b', 'c']\n", + "# print (clients)\n", + "#for idx in enumerate (clients): # Creo una variable cualquiera\n", + "# print (idx[0], 'ha gastado', clients[idx[1]]) # \"algo\" para recorrer clients\n", + "#clients_sort=sorted(clients)\n", + "orden = len (clients.keys())\n", + "print ('Número de claves', orden)\n", + "print (clients) \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "clients = {'clave1': 1.97,\n", + " 'clave2': 8.49,\n", + " 'clave3': 9.79,\n", + " 'clave4': 8.53,\n", + " 'clave5': 0.43}\n", + "print (clients)\n", + "clients ['clave6']= ['a','b','c']\n", + "print (clients)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lisdic=[]\n", + "for i in range (3):\n", + " for j in range (3):\n", + " for k in range (3):\n", + " lisdic=print(i,j,k)\n", + "\n", + "print (lisdic, end=\", \")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6 (tags/v3.10.6:9c7b4bd, Aug 1 2022, 21:53:49) [MSC v.1932 64 bit (AMD64)]" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "d3777ed8f5fe800f0d3d1926318eb186c93d9a88e13881725c87e5bdd2f1dd1d" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Workbench/Taller/variables.py b/Workbench/Taller/variables.py new file mode 100644 index 000000000..feb9d0f3f --- /dev/null +++ b/Workbench/Taller/variables.py @@ -0,0 +1,34 @@ +#Variables +#It's a memory location to assign data to store and use it later +a=10 +b=3 +print (a) + +print ("what's the value of a", a) +print ("what's the value of b", b) +print (a+b) +total =2+4 +print (total) +# Ejemplo 10 - SWAP de variable - Deben ser del mismo tipo (INT) +# caso 1) Creamos una Función + +def swap(a,b): + c=a + a=b + b=c + return a,b + +x = 5 +y = 4 +print (x,y) +x,y= swap(x,y) +print (x,y) +print () + +# caso 2) Directo y,x = x,y, propiedades de Python +# +x=10 +y=20 +print (x,y) +x,y=y,x +print (x,y) \ No newline at end of file