RA06- tarea - Python

Clases e instancias I class Reloj: def __init__(self, horas): self.horas = horas def adelantar(self, h): self.horas += h r1 = Reloj(10) r2 = Reloj(5) r1.adelantar(2) Despues de ejecutar este codigo, que valor tiene r2.horas. 12. 5. 2. 0.

Clases e instancias II class Foco: encendidos = 0 def __init__(self): Foco.encendidos += 1 f1 = Foco() f2 = Foco() f3 = Foco() Que valor tendra Foco.encendidos tras crear f1 f2 y f3. 1. 2. 0. 3.

Atributo de clase frente a instancia class Juego: max_jugadores = 4 def __init__(self, nombre): self.nombre = nombre Que afirmacion es correcta. max_jugadores es un atributo de clase compartido por todas las instancias. max_jugadores es un atributo de instancia que cambia en cada objeto. nombre es un atributo de clase. max_jugadores solo existe dentro de __init__.

Metodo de instancia class Sensor: def __init__(self, valor): self.valor = valor def leer(self): return self.valor * 2 s = Sensor(7) resultado = s.leer() Que afirmacion describe mejor leer. Es un metodo estatico. Es un atributo de clase. Es un metodo de instancia que usa self. Es una funcion global.

Metodo de clase class Config: modo = "produccion" @classmethod def cambiar_modo(cls, nuevo): cls.modo = nuevo Config.cambiar_modo("test") Que efecto tiene la llamada a cambiar_modo. Cambia solo el atributo modo de una instancia concreta. Cambia el atributo de clase modo para todas las instancias. Crea una nueva instancia de Config obligatoriamente. Elimina el atributo modo.

Metodo estatico class Mat: @staticmethod def doble(x): return x * 2 res = Mat.doble(5) Por que doble se define como metodo estatico. Porque no necesita acceder ni a self ni a cls. Porque siempre modifica atributos de instancia. Porque obliga a crear una instancia antes de llamarlo. Porque es obligatorio en todas las clases.

Encapsulacion basica class Cuenta: def __init__(self, saldo): self._saldo = saldo c = Cuenta(100) c._saldo = -50 Que problema ilustra este ejemplo. Que __init__ no se ha definido correctamente. Que los atributos de clase no se pueden modificar. Que no se puede acceder a _saldo desde fuera. Que usar solo un guion bajo no impide modificar estado invalido.

Uso de property class Usuario: def __init__(self, nombre): self._nombre = nombre @property def nombre(self): return self._nombre @nombre.setter def nombre(self, nuevo): nuevo = nuevo.strip() if not nuevo: raise ValueError("nombre vacio") self._nombre = nuevo Que ventaja tiene este diseño. Obliga a que nombre nunca cambie. Permite validar el nuevo valor de nombre usando sintaxis de atributo. Impide leer el nombre desde fuera. Evita tener que escribir __init__.

Propiedad derivada solo lectura class Circulo: def __init__(self, radio): self.radio = radio @property def diametro(self): return self.radio * 2 Que ocurre si intentamos asignar c.diametro = 10 en una instancia de Circulo. Cambia tambien el radio automaticamente. No pasa nada se crea un nuevo atributo diametro. Se lanza un error porque diametro no tiene setter. El valor se almacena pero no se usa.

Invariantes class Deposito: def __init__(self, capacidad): self.capacidad = capacidad self._nivel = 0 def llenar(self, litros): if self._nivel + litros > self.capacidad: raise ValueError("se desborda") self._nivel += litros Que invariante se intenta proteger. Que el nivel nunca supere la capacidad. Que el nivel sea siempre negativo. Que capacidad cambie en cada llamada. Que __init__ no se ejecute.

Herencia basica class Vehiculo: def __init__(self, marca): self.marca = marca class Coche(Vehiculo): def __init__(self, marca, puertas): super().__init__(marca) self.puertas = puertas Que relacion hay entre Coche y Vehiculo. Coche tiene un Vehiculo mediante composicion. Coche no esta relacionado con Vehiculo. Vehiculo hereda de Coche. Coche es un tipo de Vehiculo mediante herencia.

Sobrescritura de metodos class Notificador: def enviar(self, texto): return "enviando generico" class NotificadorEmail(Notificador): def enviar(self, texto): return "enviando por email " + texto Que describe mejor lo que hace NotificadorEmail. Oculta por completo el metodo enviar de la clase base sin poder llamarlo. Sobrescribe enviar con un comportamiento mas especifico. Elimina el metodo enviar de Notificador. Convierte Notificador en abstracta.

Polimorfismo con herencia class Forma: def area(self): raise NotImplementedError class Cuadrado(Forma): def __init__(self, lado): self.lado = lado def area(self): return self.lado * self.lado class Triangulo(Forma): def __init__(self, base, altura): self.base = base self.altura = altura def area(self): return self.base * self.altura / 2 def mostrar_area(figura): print(figura.area()) Que ventaja tiene la funcion mostrar_area. Solo funciona con Cuadrado. Puede trabajar con cualquier objeto que implemente area sin cambiar su codigo. Requiere comprobar el tipo con isinstance. Solo admite tipos primitivos.

Duck typing class PDF: def imprimir(self): return "imprimiendo pdf" class Imagen: def imprimir(self): return "imprimiendo imagen" def cola_impresion(doc): print(doc.imprimir()) Que principio se aplica en cola_impresion. Duck typing se usa cualquier objeto con el metodo imprimir. Solo se aceptan objetos de la clase PDF. Es obligatorio que PDF herede de Imagen. Es obligatorio usar una clase abstracta base.

Mixins class ReprMixin: def __repr__(self): return f"{self.__class__.__name__}({vars(self)})" class Cliente(ReprMixin): def __init__(self, nombre): self.nombre = nombre Que aporta ReprMixin a Cliente. Un sistema de logs completo. Una jerarquia de herencia muy profunda. Una implementacion reutilizable de __repr__. Un constructor alternativo obligatorio.

Clase base abstracta from abc import ABC, abstractmethod class Filtro(ABC): @abstractmethod def aplicar(self, datos): pass class FiltroMayus(Filtro): def aplicar(self, datos): return datos.upper() Que afirmacion es correcta. Se puede crear una instancia de Filtro directamente. Filtro no se puede heredar. FiltroMayus no puede sobrescribir aplicar. Cualquier subclase de Filtro debe implementar aplicar para poder instanciarse.

Protocolos dunder de coleccion class Bolsa: def __init__(self): self._items = [] def agregar(self, x): self._items.append(x) def __len__(self): return len(self._items) b = Bolsa() b.agregar(10) b.agregar(20) Que permite esta implementacion de __len__. Usar len(b) para obtener el numero de elementos. Ordenar automaticamente los elementos. Convertir la bolsa en diccionario. Evitar que se puedan agregar mas elementos.

Operador suma polimorfico class Vector: def __init__(self, x, y): self.x = x self.y = y def __add__(self, otro): return Vector(self.x + otro.x, self.y + otro.y) v1 = Vector(1, 2) v2 = Vector(3, 4) v3 = v1 + v2 Que contendran v3.x y v3.y. 1 y 2. 4 y 6. 3 y 4. 0 y 0.

Encapsulacion de lista interna class Historico: def __init__(self): self._eventos = [] def registrar(self, texto): self._eventos.append(texto) @property def eventos(self): return tuple(self._eventos) Que ventaja tiene devolver una tupla en eventos. Que los eventos se puedan modificar directamente. Que la estructura interna quede protegida al ser inmutable desde fuera. Que se pueda agregar texto a la tupla. Que se puedan borrar elementos sin usar metodos.

Interfaz publica class Pedido: def __init__(self, numero, total): self._numero = numero self._total = total @property def numero(self): return self._numero def total_con_iva(self, iva): return self._total * (1 + iva) Que miembros son razonables como parte de la interfaz publica. Solo __init__. Solo _numero. numero y total_con_iva. Ningun metodo.