Merge pull request mouredev#7464 from santiagobailleres/ej00

#7 - Python

Author: Roswell468

Roadmap/07 - PILAS Y COLAS/python/santiagobailleres.py

@@ -0,0 +1,107 @@
+'''EJERCICIO:
+Implementa los mecanismos de introducción y recuperación de elementos propios de las
+pilas (stacks - LIFO) y las colas (queue - FIFO) utilizando una estructura de array
+o lista (dependiendo de las posibilidades de tu lenguaje).
+
+DIFICULTAD EXTRA (opcional):
+- Utilizando la implementación de pila y cadenas de texto, simula el mecanismo adelante/atrás
+  de un navegador web. Crea un programa en el que puedas navegar a una página o indicarle
+  que te quieres desplazar adelante o atrás, mostrando en cada caso el nombre de la web.
+  Las palabras "adelante", "atrás" desencadenan esta acción, el resto se interpreta como
+  el nombre de una nueva web.
+- Utilizando la implementación de cola y cadenas de texto, simula el mecanismo de una
+  impresora compartida que recibe documentos y los imprime cuando así se le indica.
+  La palabra "imprimir" imprime un elemento de la cola, el resto de palabras se
+  interpretan como nombres de documentos.'''
+
+# Implementación de pilas y colas en Python
+# Pilas/stack: LIFO (Last In, First Out)
+pila = []
+# push: añadir un elemento a la pila
+pila.append(1)
+pila.append(2)
+pila.append(3)
+pila.append(4)
+pila.append(5)
+print(pila)
+# pop: eliminar un elemento de la pila
+pila.pop() 
+print(pila)
+print(pila.pop()) # este método devuelve el elemento eliminado
+print(pila)
+print(pila.pop())
+print(pila)
+
+# Colas/queue: FIFO (First In, First Out)
+cola = []
+# enqueue: añadir un elemento a la cola
+cola.append(1)
+cola.append(2)
+cola.append(3)
+cola.append(4)
+cola.append(5)
+print(cola)
+# dequeue: eliminar un elemento de la cola
+cola.pop(0) # pop(0) elimina el primer elemento de la lista
+print(cola)
+print(cola.pop(0)) # este método devuelve el elemento eliminado
+print(cola)
+
+# EXTRA 
+'''- Utilizando la implementación de pila y cadenas de texto, simula el mecanismo adelante/atrás
+  de un navegador web. Crea un programa en el que puedas navegar a una página o indicarle
+  que te quieres desplazar adelante o atrás, mostrando en cada caso el nombre de la web.
+  Las palabras "adelante", "atrás" desencadenan esta acción, el resto se interpreta como
+  el nombre de una nueva web.
+- Utilizando la implementación de cola y cadenas de texto, simula el mecanismo de una
+  impresora compartida que recibe documentos y los imprime cuando así se le indica.
+  La palabra "imprimir" imprime un elemento de la cola, el resto de palabras se
+  interpretan como nombres de documentos.'''
+
+# Navegador web
+def web_browser():
+    stack = []
+
+    while True:
+
+        action = input(
+            "Añade una url o interactúa con palabras adelante/atrás/salir: "
+        )
+
+        if action == "salir":
+            print("Saliendo del navegador web.")
+            break
+        elif action == "adelante":
+            pass
+        elif action == "atrás" or action == "atras":
+            if len(stack) > 0:
+                stack.pop()
+        else:
+            stack.append(action)
+
+        if len(stack) > 0:
+            print(f"Has navegado a la web: {stack[len(stack) - 1]}.")
+        else:
+            print("Estás en la página de inicio.")
+
+#web_browser()
+
+# Impresora compartida
+def printer():
+    queue = []
+    while True:
+        action = input("Ingrese el nombre de un documento o 'imprimir'/'salir': ")
+        if action == "salir":
+            print("Saliendo de la impresora...")
+            break
+        elif action == "imprimir":
+            if len(queue) > 0:
+                print(f"Imprimiendo documento: {queue[0]}.")
+                queue.pop(0)
+            else:
+                print("No hay documentos en la cola.")
+        else:
+            queue.append(action)
+        print(f"Documentos en cola: {queue}")
+
+printer()

Roadmap/08 - CLASES/python/santiagobailleres.py

@@ -0,0 +1,108 @@
+'''EJERCICIO:
+Explora el concepto de clase y crea un ejemplo que implemente un inicializador,
+atributos y una función que los imprima (teniendo en cuenta las posibilidades
+de tu lenguaje).
+Una vez implementada, créala, establece sus parámetros, modifícalos e imprímelos
+utilizando su función.
+DIFICULTAD EXTRA (opcional):
+Implementa dos clases que representen las estructuras de Pila y Cola (estudiadas
+en el ejercicio número 7 de la ruta de estudio)
+- Deben poder inicializarse y disponer de operaciones para añadir, eliminar,
+retornar el número de elementos e imprimir todo su contenido.'''
+
+# Clase/class: es un molde para crear objetos. Un objeto es una instancia de una clase.
+# Atributos/atributes: son las características que tiene un objeto.
+# Métodos/methods: son las acciones que puede realizar un objeto. 
+# Constructor/initializer: es un método que se llama cuando se crea un objeto.
+# self: es una referencia al objeto que se está creando.
+# __init__: es el método constructor de una clase.
+# __str__: es el método que se llama cuando se imprime un objeto.
+
+class Persona:
+    surname: str = None # surname es un atributo de clase
+    def __init__(self, name: str, age: int, habilidades: list):
+        self.name = name
+        self.age = age
+        self.habilidades = habilidades
+    
+    def __str__(self):
+        return f'Nombre: {self.name}, Apellido: {self.surname}, Age: {self.age}, Habilidades: {self.habilidades}'
+
+mi_persona = Persona('Santiago', 24, ['Python', 'SQL'])
+mi_persona.surname = 'Bailleres'
+print(mi_persona)
+mi_persona.age = 25
+print(mi_persona)
+
+# EXTRA
+# Clase Pila (Stack) LIFO
+class Pila:
+    def __init__(self): # self es una referencia al objeto que se está creando 
+        self.items = []
+    
+    def push(self, item):
+        self.items.append(item)
+    
+    def pop(self):
+        if self.count() == 0:
+            return None
+        return self.items.pop()
+    
+    def count(self):
+        return len(self.items)
+    
+    def print(self):
+        for item in reversed(self.items):
+            print(item)
+
+mi_pila = Pila()
+mi_pila.push(1)
+mi_pila.push(2)
+mi_pila.push(3)
+print(mi_pila.count())
+mi_pila.print()
+mi_pila.pop()
+print(mi_pila.count())
+print('---')
+print(mi_pila.pop())
+print(mi_pila.pop())
+print(mi_pila.pop())
+print(mi_pila.pop())
+print(mi_pila.count())
+print('---')
+
+# Clase Cola (Queue) FIFO
+class Cola:
+    def __init__(self):
+        self.queue = []
+    
+    def enqueue(self, item):
+        self.queue.append(item)
+    
+    def dequeue(self):
+        if self.count() == 0:
+            return None
+        return self.queue.pop(0)
+    
+    def count(self):
+        return len(self.queue)
+    
+    def print(self):
+        for item in self.queue:
+            print(item)
+
+mi_cola = Cola()
+mi_cola.enqueue('A')
+mi_cola.enqueue('B')
+mi_cola.enqueue('C')
+print(mi_cola.count())
+print('---')
+mi_cola.print()
+mi_cola.dequeue()
+print(mi_cola.count())
+print('---')
+print(mi_cola.dequeue())
+print(mi_cola.dequeue())
+print(mi_cola.dequeue())
+print(mi_cola.dequeue())
+print(mi_cola.count())

Roadmap/09 - HERENCIA/python/santiagobailleres.py

@@ -0,0 +1,100 @@
+'''EJERCICIO:
+Explora el concepto de herencia según tu lenguaje. Crea un ejemplo que
+implemente una superclase Animal y un par de subclases Perro y Gato,
+junto con una función que sirva para imprimir el sonido que emite cada Animal.
+DIFICULTAD EXTRA (opcional):
+Implementa la jerarquía de una empresa de desarrollo formada por Empleados que
+pueden ser Gerentes, Gerentes de Proyectos o Programadores.
+Cada empleado tiene un identificador y un nombre.
+Dependiendo de su labor, tienen propiedades y funciones exclusivas de su
+actividad, y almacenan los empleados a su cargo.'''
+
+# Superclase: una superclase es una clase de la que se heredan otras clases.
+class Animal:
+    def __init__(self, nombre):
+        self.nombre = nombre
+
+    def sonido(self): # Método que se hereda a las subclases
+        pass # Este método se define en las subclases. Pass es una palabra clave que no hace nada.
+
+# Subclases: una subclase es una clase que hereda de una superclase.
+class Dog(Animal):
+    def sonido(self):
+        print('Guau')
+
+class Cat(Animal):
+    def sonido(self):
+        print('Miau')
+
+def sonido_animal(animal: Animal): 
+    animal.sonido() # Llama al método sonido de la clase animal
+
+mi_animal = Animal('Animal')
+sonido_animal(mi_animal)
+mi_perro = Dog('Perro')
+sonido_animal(mi_perro)
+mi_gato = Cat('Gato')
+sonido_animal(mi_gato)
+
+# EXTRA
+class Empleado:
+    def __init__(self, id:int, nombre:str):
+        self.id = id
+        self.nombre = nombre
+        self.employees=[]
+    
+    def add_employee(self, employee):
+        self.employees.append(employee)
+    
+    def print_employees(self):
+        for employee in self.employees:
+            print(employee.nombre)
+
+class Gerente(Empleado):
+    def coordinate_projects(self):
+        print(f"{self.nombre} está coordinando todos los proyectos de la empresa.")
+
+class GerenteProyecto(Empleado):
+    def __init__(self, id:int, nombre:str, project:str):
+        super().__init__(id, nombre)
+        self.project = project
+    
+    def coordinate_project(self):
+        print(f"{self.nombre} está coordinando el proyecto {self.project}.")
+
+class Programador(Empleado):
+    def __init__(self, id:int, nombre:str, lenguaje:str):
+        super().__init__(id, nombre)
+        self.lenguaje = lenguaje
+    
+    def code(self):
+        print(f"{self.nombre} está programando en {self.lenguaje}.")
+    
+    def add(self, employee:Empleado):
+        print(f"Un programador no tiene empleados a su cargo. {employee.nombre} no se añadirá.")
+
+# Crear empleados
+mi_gerente = Gerente(1, 'Santiago Bailleres')
+mi_project_manager = GerenteProyecto(2, 'Juan Perez', 'Proyecto 1')
+mi_project_manager2 = GerenteProyecto(3, 'Pedro Lopez', 'Proyecto 2')
+mi_programador = Programador(4, 'Maria Garcia', 'Python')
+mi_programador2 = Programador(5, 'Ana Martinez', 'Java')
+mi_programador3 = Programador(6, 'Luis Ramirez', 'C++')
+mi_programador4 = Programador(7, 'Carlos Sanchez', 'JavaScript')
+
+mi_gerente.add_employee(mi_project_manager)
+mi_gerente.add_employee(mi_project_manager2)
+
+mi_project_manager.add_employee(mi_programador)
+mi_project_manager.add_employee(mi_programador2)
+mi_project_manager2.add_employee(mi_programador3)
+mi_project_manager2.add_employee(mi_programador4)
+
+mi_programador.add(mi_programador4)
+
+mi_programador.code()
+mi_project_manager.coordinate_project()
+mi_gerente.coordinate_projects()
+mi_gerente.print_employees()
+mi_project_manager.print_employees()
+mi_programador.print_employees()