Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Herencia

9/25
Recursos

Aportes 411

Preguntas 32

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Un aspecto importantísimo de la Herencia es la posibilidad de reutilizar código. La reutilización es uno de los pilares de la POO, de manera que evitemos reinventar la rueda cada vez. Si tenemos un comportamiento que es común entre una serie de objetos de la misma categoría, este comportamiento debe enviarse a un clase superior que permita compartirlo con sus clases hijas. Esto facilita la mantenibilidad del código haciéndolo más estable.

Para el que tenga hambre de conocimiento:

class PasapalosVenezolanos:

    def __init__(self, precio_unidad, numero_racion, relleno):
        self.precio_unidad = precio_unidad
        self.numero_racion = numero_racion
        self.relleno = relleno
    
    def precio_plato(self):
        return self.precio_unidad * self.numero_racion

class Arepa(PasapalosVenezolanos):

    def __init__(self, precio_unidad, numero_racion, relleno, tipo_de_preparacion, tipo_hmaiz):
        super().__init__(precio_unidad, numero_racion, relleno)
        self.tipo_de_preparacion = tipo_de_preparacion # horno, frita, asada
        self.tipo_hmaiz = tipo_hmaiz # harina de maiz blanco / amarilla

class Tequeno(PasapalosVenezolanos):

    def __init__(self, precio_unidad, numero_racion, relleno, tipo_masa):
        super().__init__(precio_unidad, numero_racion, relleno)
        self.tipo_masa = tipo_masa # masa tradicional, masa cachapa

class Pastelito(PasapalosVenezolanos):

    def __init__(self, precio_unidad, numero_racion, relleno, tipo_salsa):
        super().__init__(precio_unidad, numero_racion, relleno)
        self.tipo_salsa = tipo_salsa # de ajo, rosada, picante, tartara

Cual añadirías?

A mi se me ocurrió un programa donde se puedan crear varios programadores que se tengan en una empresa

class Programador:
    
    def __init__(self, nombre, edad, numero_de_empleado, skill):
        self.nombre = nombre
        self.edad = edad
        self.numero_de_empleado = numero_de_empleado 
        self.skill = skill

    def programar(self):
        print(f'Hola, estoy programando en {self.skill}')

class ProgramadorJava(Programador):

    def __init__(self, nombre, edad, numero_de_empleado, skill = 'Java'):
        super().__init__(nombre, edad, numero_de_empleado, skill)

class ProgramadorPython(Programador):
    
    def __init__(self, nombre, edad, numero_de_empleado, skill = 'Python'):
        super().__init__(nombre, edad, numero_de_empleado, skill)

class ProgramadorCpp(Programador):

    def __init__(self, nombre, edad, numero_de_empleado, skill = 'C++'):
        super().__init__(nombre, edad, numero_de_empleado, skill)
    

def main():
    programador_java = ProgramadorJava('Ricardo', 25, 1234)
    programador_python = ProgramadorPython('Sofía', 20, 1345)
    programador_cpp = ProgramadorCpp('Gilberto', 35, 5637)

    programador_java.programar()
    programador_python.programar()
    programador_cpp.programar()


if __name__ == "__main__":
    main()

Me he visto involucrado en proyectos donde se ha abusado de la herencia tratando de llegar a una granularidad exagerada en el detalle de la definición de los objetos. Hay que encontrar una abstracción correcta y no tratar de evitar repetición de código sin un objetivo claro. A veces una mala abstracción es peor que no tener una abstracción.

Reto Solucionado

class TipoComprobante:
    def __init__(self, precioUnitario, cantidad):
        self.precioUnitario = precioUnitario
        self.cantidad = cantidad

    def calcularTotal(self):
        return self.precioUnitario * self.cantidad

class Factura(TipoComprobante):

    def __init__(self, precioUnitario):
        super().__init__(precioUnitario, cantidad=5)

class Nota_credito(TipoComprobante):

    def __init__(self, precioUnitario):
        super().__init__(precioUnitario,cantidad=1)

if __name__ == '__main__':
    tipo_comprobante = TipoComprobante(precioUnitario=20, cantidad=10)
    print (tipo_comprobante.calcularTotal())

    factura = Factura(precioUnitario=50)
    print(factura.calcularTotal())

    nota_credito = Nota_credito(precioUnitario=30)
    print(nota_credito.calcularTotal())```

Hice un ejemplo con dos tipos de células en los que se pueden ver las diferencias entre atributos y método. Espero que les sea útil!

"""
    En este programa se crea un superclase Celula cuyos atributos son el diámetro, su funcionamiento y el estado en el que se encuentra.
    De esta superclase nacen dos subclases con diferentes métodos en función de sus especializaciones: 
    - Neurona: es una Celula que además tiene una longitud y un número de dendritas(conexines con otras neuronas). Dispone de un método para calcular su volúmen.
    - Hematocito: es una Celula que además se encuentra en una determinada concentración en sangre. Dispone de un método que evalua esta concentración.

"""
class Celula:

    def __init__(self,diametro,funcionamiento,estado):
        self.diametro = diametro #en micrómetros
        self.funcionamiento = funcionamiento #normal, cancerosa
        self.estado=estado #viva, muerta
    
    def area(self):
        return f'Area: {2*3.14*(self.diametro/2)**2} um^2.'

class Neurona(Celula):

    def __init__(self,diametro,funcionamiento,estado,longitud,num_dendritas):
        super().__init__(diametro,funcionamiento,estado) #atributos propios de la superclase celula comunes con otras subclases
        self.longitud = longitud #atributos únicos de esta subclase en concreto
        self.num_dendritas = num_dendritas #atributos únicos de esta subclase en concreto
    
    def volumen(self): #Método único de Neurona que valora si la concentración de hematocitos en sangre está por debajo de un umbral fijo.
        return f'Volumen: {self.diametro * self.longitud} um^3'  

class Hematocito(Celula):

    def __init__(self,diametro,funcionamiento,estado,concentracion):
        super().__init__(diametro,funcionamiento,estado) #atributos propios de la superclase celula comunes con otras subclases
        self.concentracion = concentracion #atributos únicos de esta subclase en concreto
    
    def valorar_concentracion(self): #Método único de Hematocito que valora si la concentración de hematocitos en sangre está por debajo de un umbral fijo.
        umbral_concentracion_hematocitos = 300
        if self.concentracion < umbral_concentracion_hematocitos:
            return 'Concentración baja.'
        else:
            return 'Concentración correcta.'

if __name__=="__main__":

    #Se crean ambas instancias. Vease que al tratarse de subclases diferentes pero con la misma superclase comparten las variables de ésta pero difieren en las suyas propias.
    neurona = Neurona(diametro=10, funcionamiento='cancerosa', estado='muerta', longitud=200, num_dendritas=25)
    hematocito = Hematocito(diametro=5, funcionamiento='normal', estado='viva', concentracion=400)


    #se imprimen determinados atributos y las respuestas de detrminados métodos para cada subclase en concreto.
    print(f'Estado de la neurona: {neurona.estado}, Funcionamiento: {neurona.funcionamiento}, {neurona.volumen()}, Número de dendritas: {neurona.num_dendritas}')
    print(f'Estado del hematocito: {hematocito.estado}, Funcionamiento: {hematocito.funcionamiento}, {hematocito.area()}, Concentración: {hematocito.concentracion} U/dL. {hematocito.valorar_concentracion()}')

Cuando tenemos programas bastante complejo la red de clases hijas se puede volver bastante confuso y para eso podemos usar un método de python llamado isinstance(<objeto>,<clase>) el cual recibe como parámetro el objeto que queremos evaluar y la clase de la cual queremos saber si pertenece el objeto evaluado, la cual nos devuelve True o False

Este tutorial (en inglés) lo explica desde otro ángulo muy bien:

Inheritance: creating subclasses

Muy buena clase.

Algo importante es que así como se utiliza super(). __ init __ (lado, lado) también se puede utilizar Rectangulo. __ init __ (self, lado, lado) y correría bien el programa, sin embargo si es más recomendable utilizar super().

class Rectangulo:

    def __init__ (self, base, altura):
        self.base = base
        self.altura = altura

    def area (self):
        return self.base * self.altura

class Cuadrado(Rectangulo):

    def __init__ (self, lado):
        #super().__init__(lado, lado) # Recomendable
        Rectangulo.__init__(self, lado, lado) # Otra forma

if __name__ == "__main__":
    rectangulo1 = Rectangulo(base = 3, altura = 4)
    print(rectangulo1.area())

    cuadrado1 = Cuadrado(lado = 5)
    print(cuadrado1.area())

Ejemplo sencillo con pedales de efectos para instrumentos musicales:

class EffectPedal:
    def __init__(self, tipo, bateria=True, output='mono', input='mono'):
        self.tipo = tipo
        self.bateria = bateria
        self.output = output
        self.input = input
        self._plugged = True

    def prender(self):
        if self._plugged is True:
            print('Pedal prendido')
        else:
            print('Falta conectarse')


class GuitarPedal(EffectPedal):
    def __init__(self):
        super().__init__('overdive', True, 'mono', 'mono')

if __name__ == "__main__":
    pedal = GuitarPedal()
    pedal.prender()
    
<code>
class Presidente:
  def __init__(self,nombre, pais, edad, cargo='Presidente'):
    self.nombre = nombre
    self.pais = pais
    self.edad = edad
    self.cargo = cargo
  
  def obtener(self):
    print(f'El {self.cargo} de {self.pais} tine {self.edad} años y se llama {self.nombre}')
  

class Gobernador(Presidente):
  def __init__(self, nombre, departamento, edad, ):
    
    super().__init__(nombre, departamento, edad, cargo='Gobernador')

class Alcalde(Presidente):
   def __init__(self,nombre,municipio,edad):
    
    super().__init__(nombre, municipio, edad, cargo='Alcalde')

presidente = Presidente('Duque', 'Colombia','40')
print(presidente.obtener())

gobernador = Gobernador('Anibal','Antioquía','50')
print(gobernador.obtener())

alcalde= Alcalde('Andres','Medellín','39')
print(alcalde.obtener())```

Siguiendo con mi idea relacionada a una herramienta de gestión empresarial, publico el resultado del reto:

<code>
class Empleado:
    def __init__(self, nombre, area, cargo, salario):
        self.nombre = nombre
        self.area = area
        self.cargo = cargo
        self.salario = salario

    def Escala_Salarial(self, escala):
        self.escala = escala

        if self.salario <= 10:
            escala = 3
        elif self.salario <= 20:
            escala = 2
        else:
            escala = 1

class Nivel_Directivo(Empleado)
    def __init__(self, nivel_directivo)
        super().__init__(escala)

if __name__ == "__main__":
    empleado_1 = Empleado(Jean, Ingenieria, Director de Ingenieria, 17)
    empleado_2 = Empleado(Malena, Gerencia, Gerente General, 28)
    empleado_3 = Empleado(Gupta, Desarrollo, Ingeniero Junior, 10)

    print(f'{empleado_1} está en el área de {área} y su nivel directivo es{nivel_directivo}')
    print(f'{empleado_2} está en el área de {área} y su nivel directivo es{nivel_directivo}')
    print(f'{empleado_3} está en el área de {área} y su nivel directivo es{nivel_directivo}')

Mi ejemplo, tenía hambre, no me culpen xd

class Tamales():
    def __init__(self, tipo, precio, carne):
        self.tipo = tipo
        self.precio = precio
        self.carne = carne
    
    def imprimir_tamales(self):
        print(f'Los tamales son de {self.tipo}, cuestan {self.precio} pesos y tienen carne de {self.carne}')

class TamalDeElote(Tamales):
    def __init__(self, tipo, precio, carne):
        super().__init__(tipo, precio, carne)
    
class TamalDeMasa(Tamales):
    def __init__(self, tipo, precio, carne):
        super().__init__(tipo, precio, carne)

if __name__=='__main__':
    tamalElote = TamalDeElote("elote",10,"puerco 🐖")
    tamalElote.imprimir_tamales()
    tamalMasa = TamalDeMasa("masa",12,"pollo 🐓")
    tamalMasa.imprimir_tamales()

En el siguiente código genero una jerarquía de herencia de donde puedo obtener un EmpleadoPorComision cuyo sueldo se calcula en base a una tarifa por ventas brutas. De él hereda un EmpleadoBaseMasComision cuyo sueldo se calcula como la suma de un salario base + la tarifa por ventas brutas.

class EmpleadoPorComision():
    def __init__(self, nombre, dni):
        self._nombre = nombre
        self._dni = dni
        self._ventas_brutas = None
        self._tarifa_comision = None

    def getventas_brutas(self):
        return self._ventas_brutas

    def setventas_brutas(self, value):
        if value > 0.0:
            self._ventas_brutas = value
        else:
            self._tarifa_comision = 0.0

    def gettarifa_comision(self):
        return self._tarifa_comision

    def settarifa_comision(self, value):
        if value > 0 and value < 1.0:
            self._tarifa_comision = value
        else:
            self._tarifa_comision = 0.0

    ventas_brutas = property(getventas_brutas, setventas_brutas)
    tarifa_comision = property(gettarifa_comision, settarifa_comision)

    def ingresos(self):
        return self.gettarifa_comision() * self.getventas_brutas()

    def datos_empleado(self):
        return f'Nombre: {self._nombre}. Dni: {self._dni}'


class EmpleadoBaseMasComision(EmpleadoPorComision):
    def __init__(self, nombre, dni):
        super().__init__(nombre, dni)
        self._salario_base = None

    def getsalario_base(self):
        return self._salario_base

    def setsalario_base(self, value):
        if value > 0.0:
            self._salario_base = value

    salario_base = property(getsalario_base, setsalario_base)

    def ingresos(self):
        return self.getsalario_base() + self.gettarifa_comision() * self.getventas_brutas()


if __name__ == "__main__":
    empleado_por_comision = EmpleadoPorComision('Juan', '11111111')
    empleado_base_mas_comision = EmpleadoBaseMasComision('Lucia', '22222222')

    empleado_por_comision.settarifa_comision(0.6)
    empleado_por_comision.setventas_brutas(15000)

    empleado_base_mas_comision.settarifa_comision(0.6)
    empleado_base_mas_comision.setventas_brutas(15000)
    empleado_base_mas_comision.setsalario_base(10000)

    print(
        f'{empleado_por_comision.datos_empleado()} Salario: ${empleado_por_comision.ingresos()}')
    print(
        f'{empleado_base_mas_comision.datos_empleado()}. Salario: ${empleado_base_mas_comision.ingresos()}')

<code>
#Aqui comparto un ejemplo donde estoy utilizando la descomposicion y la herencia.
class Transportes:

    def __init__(self):
        pass

    def transportar(self, Transportacion="Activo"):
        self._encender_vehiculo(Transportacion)
        self._acelerar_vehiculo()
        self._frenar_vehivulo()
        self._apagar_vehiculo(Transportacion)

    def _encender_vehiculo(self, Transportacion):
        print(f'El vehiculo puede arrancar ahora esta en modo {Transportacion}.')

    def _acelerar_vehiculo(self):
        print('El vehiculo esta acelerando ...')
    

    def _frenar_vehivulo(self):
        print('El vehiculo esta disminuyendo su velocidad ...')

    def _apagar_vehiculo(self, Transportacion):
        Transportacion = 'Inactivo'
        print(f'El vehiculo esta apagado se encuetra {Transportacion}.')

class Autobus(Transportes):
    def __init__(self):
        super().__init__()

class Automovil(Transportes):
    def __init__(self):
        super().__init__()

if __name__ == '__main__':
    autobus = Autobus()
    autobus.transportar()

    automovil = Automovil()
    automovil.transportar()
class Docente:
    def __init__(self,nombre,nota_evaluacion1,nota_evaluacion2):
        self.nombre = nombre
        self.nota_evaluacion1 = nota_evaluacion1
        self.nota_evaluacion2 = nota_evaluacion2
        
    def promedio_final(self):
        return (self.nota_evaluacion1+self.nota_evaluacion2)/2

class Estudiante(Docente):
    def __init__(self,nombre,nota_parcial,nota_final):
        super().__init__(nombre,nota_parcial,nota_final)

if __name__ == '__main__':
    docente = Docente(nombre = 'Edwin',nota_evaluacion1 = 15, nota_evaluacion2 = 18)
    print(f'Docente {docente.nombre}, su promedio final es: {docente.promedio_final()}')

    estudiante = Estudiante(nombre = 'Jair',nota_parcial = 14, nota_final = 16)
    print(f'Estudiante {estudiante.nombre}, su promedio final es: {estudiante.promedio_final()}')

Tome mi ejemplo de la clase anterior y a la clase CCuenta le agregue la clase que extiende CCuentaAhorro, donde sus atributos los hereda de la clase padre y se le agrega uno nuevo

Saludos dejo un ejemplo de una clase llamada calculadora y su subclase llamada calculadora cientifica


#high class
class Calculator:


    def __init__(self,numA,numB):
        self._numa=int(numA)
        self._numb=int(numB)

    #This define the property Num A for the getter and setter
    @property
    def numa(self):
        return self._numa
         
    @numa.setter
    def setNumA(self,value):
        if (int(value)>=0):
            self._numa=value
            print(f"NumA value was setted to: {value}")
        else:
            print("use only positive numbers")
    
    #This define the property Num B for the getter and setter
    @property
    def numb(self):
        return self._numb
         
    @numb.setter
    def setNumB(self,value):
        if (int(value)>=0):
            self._numb=value
            print(f"NumB value was setted to: {value}")
        else:
            print("use only positive numbers")

    #generic methods
    def sum(self):
        return self._numa + self._numb

    def sub(self):
        return self._numa - self._numb

    def mult(self):
        return self._numa * self._numb

    def div(self):
        return self._numa / self._numb


#subclass

class Cientific_calculator(Calculator):
    def __init__(self, numA, numB):
        super().__init__(numA, numB)

    #adding method pow
    def pow(self):
        result=super().numa
        for i in range (super().numb-1):
            result= result*super().numa
        return result



if __name__=="__main__":

    Calculator2=Cientific_calculator(numA=0,numB=0)
    number1=input("Enter number A ")
    Calculator2.setNumA=int(number1)
    number2=input("Enter number B ")
    Calculator2.setNumB=int(number2)
    print(f"the multiplication of both numbers have the following result:  {Calculator2.mult()}")

    #using the subclass method
    print(f"{number1} raised to {number2} have the following result:  {Calculator2.pow()}")

    

Les dejo un ejemplo de reutilización de parámetros con Herencia

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
 
    def saludar(self):
        print(f'Hola, mi nombre es {self.nombre} y tengo {self.edad} años')
 
class Estudiante(Persona):
    def __init__(self, nombre, edad, carrera):
        super().__init__(nombre, edad)
        self.carrera = carrera
        
    def saludar(self):
        super().saludar()
        print("Y estudio", self.carrera)


pepe = Estudiante("Pepe", 20, "ingeniería")
pepe.saludar()

Resultando en:

>>> Hola, mi nombre es Pepe
>>> Y estudio ingeniería

Nótese como solo se instancia únicamente la clase Estudiante, la cual por sí sola obtiene los datos que requiere la clase Persona y los imprime en pantalla junto a los datos que le pertenecen únicamente. Esto mediante super().saludar() dentro del saludar() dentro de Estudiante

🧙‍♂️ Uso de herencia versión Harry Potter:
_

_
Resultado:
_

Adjunto un pequeño ejercicio con estadísticos básicos calculados manualmente:

class estadisticos:
    def __init__(self, lista_numeros):
        self.lista_numeros = lista_numeros
    
    def media_max_min(self):
        promedio = np.sum(self.lista_numeros)/len(self.lista_numeros)
        maximo = np.max(self.lista_numeros)
        minimo = np.min(self.lista_numeros)
        return (f'El promedio es: {promedio}, el valor máximo es: {maximo}, el valor mínimo es: {minimo}')
    
    
    def var_desvest(self):
        suma = 0
        for i in self.lista_numeros:
            suma += (i - np.sum(self.lista_numeros)/len(self.lista_numeros)) ** 2
        
        varianza2 = suma / (len(self.lista_numeros) - 1)
        varianza = varianza2
        
        desvest = np.sqrt(varianza)
        return (f'La varianza es: {varianza}, la desviación estándar es: {desvest}')



    estadisticos_prueba = estadisticos(Conjunto)
estadisticos_prueba.media_max_min()
estadisticos_prueba.var_desvest()

# Herencia

class estadisticos_rapidos(estadisticos):
    def __init__(self, lista_datos):
        super().__init__(lista_datos)


lista_Datos1 = range(1, 1250)

fast_statistics = estadisticos_rapidos(lista_Datos1)

fast_statistics.media_max_min()
fast_statistics.var_desvest()

Hice un ejemplo de volumen de un cilindro y el área de una circunferencia

¿Es una buena práctica indicar el nombre de la clase con Mayúscula?
Gracias 😃

""" Reto de clase 7: Herencia."""

class Personaje:
    """ Representación de cualquier personaje en un videojuego."""

    def __init__(self, fuerza, energia, salud, nombre):
        self._fuerza = fuerza
        self._energia = energia
        self._salud = salud
        self._nombre = nombre


    def imprimir_datos(self):
        print(f'Nombre: {self._nombre}\nFuerza: {self._fuerza}\n'
              f'Salud: {self._salud}\nEnergía: {self._energia}')
        print('-' * 50)



class Aldeano(Personaje):
    """ Representación de un aldeano en un videojuego."""

    def __init__(self):
        super().__init__(fuerza=1, energia=1, salud=1, nombre="Aldeano")



class Enemigo(Personaje):
    """ Representación de un enemigo en un videojuego."""

    def __init__(self, fuerza=10, energia=10, salud=10):
        super().__init__(fuerza, energia, salud, nombre="Enemigo")



if __name__ == "__main__":
    heroe = Personaje(fuerza=100, energia=120, salud=50, nombre="Leví")
    heroe.imprimir_datos()

    aldeano = Aldeano()
    aldeano.imprimir_datos()

    enemigo_basico = Enemigo(fuerza=3, energia=1, salud=5)
    enemigo_basico.imprimir_datos()

Ahora python soporta herencia múltiple:

https://pythones.net/herencia-simple-y-multiple-python-oop/


Como ingeniero de automatización industrial les deje un pequeño ejemplo

class Motor:

    def __init__(self,start,stop):
        self.start=start
        self.stop=stop 
        self.contact=False

    def run(self):
        if self.start and not self.stop:
            return True
        else:
            return False

class MotorVaridor(Motor):

     def __init__(self,start,stop,speed):
        super().__init__(start,stop)
        self.speed=speed
 

if __name__=='__main__': 

    dosificadora=Motor(start=True,stop=False)
    dosificadora.contact=dosificadora.run()
    print("El motor esta >>:"+str(dosificadora.contact))
    molino=MotorVaridor(start=True,stop=False,speed=60.3)
    molino.contact=molino.run()
    print("\nEl molino esta >>:"+str(molino.contact))
    print("la velocidad del molino esta >>:"+str(molino.speed))

Cuenta Basica y cuenta Bussines

Codigo Python

Mi ejercicio aplicando herencia, es muy sencillo . Pero por algo se comienza.

from typing import AsyncGenerator


class Worker ():

    def __init__ (self,name,lastname,age,gender):
        self.name = name
        self.lastname = lastname
        self.age = age
        self.gender = gender

    def greeting(self):
        return print('Hello My name is {self}')

class Teacher(Worker):

    def __init__(self,subject):
        super().__init__(subject)

if __name__=='__main__':
    Teacher.name= 'Marlon'
    Teacher.lastname = 'Ramirez'
    Teacher.age = 22
    Teacher.gender = 'Male' 

    subject= 'Math' 

    print(Teacher.name)
    print(Teacher.lastname)
    print(Teacher.age)
    print(Teacher.gender)
    print(subject) 

Ejemplo de herencia:

class Persona():

    def __init__(self, apellidoPat, apellidoMat, nom):
        self.apellidoPaterno = apellidoPat
        self.apellidoMaterno = apellidoMat
        self.nombres = nom

    def mostrarNombre(self):
        txt = "{0}, {1}, {2}"
        return txt.format(self.apellidoPaterno, self.apellidoMaterno, self.nombres)

class Estudiante(Persona):

    def __init__(self, apellidoPat, apellidoMat, nom , pro):
#Se declaran los atributos a heredad
        super().__init__(apellidoPat, apellidoMat, nom)
#Se hace la declaracion de los atributos heredados
        self.profesion = pro

#El argumento "pro" se refiere a la profesion esto quiere decir que solamente va a poder ser utilizado en esta clase,
# ya que esta clase es para estudiante, del mismo modo pudiesemos crear otra clase para trabajador y colocar el puesto de trabajo

estudiante1 = Estudiante("Rojas", "Ollarves", "Jose", "Ingenieria de Sistemas")

print(estudiante1.mostrarNombre())
print(estudiante1.profesion)```

Herencia

class registroDotacion():
    
    def __init__(self):
        self.__registro = {}
    
    def agregar(self, empleado):
        self.__registro[empleado.id] = empleado.fecha_dotacion
        print(f"Usuario {empleado.nombre} ha sido agregado a la base")

    @property
    def listar(self):
        print(self.__registro)

    def eliminar(self, empleado):
        if empleado.id in self.__registro:
            del self.__registro[empleado.id]
            print("Se ha eliminado")
        else:
            raise ValueError("Empleado no encontrado")
        
class empleado():

    def __init__(self, nombre, id, fecha_dotacion):
        self.__nombre = nombre
        self.__id = id
        self.__fecha_dotacion = fecha_dotacion
        

    @property
    def id(self):
        return self.__id
    @property
    def nombre(self):
        return self.__nombre
    @property
    def fecha_dotacion(self):
        return self.__fecha_dotacion

    @fecha_dotacion.setter
    def set_fecha_dotacion(self, fecha_dotacion):
        self.__fecha_dotacion = fecha_dotacion

class empleado_directo(empleado):
    def __init__(self, nombre, id, fecha_dotacion):
        super().__init__(nombre, id, fecha_dotacion)

class empleado_indirecto(empleado):
    def __init__(self, nombre, id, fecha_dotacion):
        super().__init__(nombre, id, fecha_dotacion)

def añadir_listar(registro, empleado):
    registro.agregar(empleado)
    registro.listar

registro  = registroDotacion()

empleado1 = empleado("Oliver", "1", "12-de-diciembre")
empleado2 = empleado("bernardo", "2", "14-de-diciembre")
añadir_listar(registro, empleado1)
añadir_listar(registro, empleado2)

empleado2.set_fecha_dotacion = "20-de-diciembre" #Setter
añadir_listar(registro, empleado2)

empleado3 = empleado_directo("nicoll", "3", "24-de-diciembre")
añadir_listar(registro, empleado3)

empleado4 = empleado_indirecto("esteban", "4", "28-de-diciembre")
añadir_listar(registro, empleado4)

empleado4.set_fecha_dotacion = "30-de-diciembre" #Setter
añadir_listar(registro, empleado4)

y se puede implementar de la siguiente manera

class mueble:

    def __init__(self,patas,dimensiones,materiales,esquema):

        self.patas=patas
        self.dimensiones=dimensiones
        self.materiales=materiales
        self.esquema=esquema

    def correr_mueble(self,distancia):
        print(f'trasladando {distancia} metros...')

    def reparar(self, tiempo):
        print(f'reparando mueble... esto tomara aproximadamente {tiempo} minutos')

    def desechar(self):
        print('Se esta desechando el mueble actual..., que triste :(')

    def limpiar(self):
        print('limpiando el mueble actual...')

class sofa(mueble):

    def __init__(self,cojines,tallado,pasamanos,espaldar,capacidad,detalles):
        
        self.cojines=cojines
        self.tallado=tallado
        self.pasamanos=pasamanos
        self.espaldar=espaldar
        self.capacidad=capacidad
        super().__init__(detalles[0],detalles[1],detalles[2],detalles[3])

    def sentarse(self):
        print('tienes asientos fabulosos!')

    def cambiar_cojineria(self,cojines):
        self.cojines=cojines
        print(f'Los cojines ahora tienen un fabuloso color {cojines}')

class closet(mueble):

    def __init__(self,puertas,cerraduras,cajones,detalles):

        self.puertas=puertas
        self.cerraduras=cerraduras
        self.cajones=cajones
        self._cosas=[]
        super().__init__(detalles[0],detalles[1],detalles[2],detalles[3])
        
    def abrir_puertas(self):
        print(f'Abriendo puertas, dentro hay {self._cosas}')

    @property
    def cosas(self):
        return self._cosas

    @cosas.setter
    def cosas(self, elemento):
        self._cosas.append(elemento)

    def eliminar_cosas(self,elemento):
        if elemento in self._cosas:
            self._cosas.remove(elemento)
        else:
            print(f'{elemento} no se encuentra en el closet actual')

class silla(sofa):

    def __init__(self,altura,cojines1,tallado1,pasamanos1,espaldar1,detalles1,ruedas=True):

        self.min_altura=altura[0]
        self.max_altura=altura[1]
        self.ruedas=ruedas
        super().__init__(cojines1,tallado1,pasamanos1,espaldar1,1,detalles1)

class escritorio(closet):

    def __init__(self,altura,superficie,agujeros,puertas1,cerraduras1,cajones1,detalles1):
        if altura<0.9:
            raise TypeError('altura debe ser mayor de 0.9 metros')
        self.altura=altura
        if superficie<1:
            raise TypeError('La superficie debe ser mayor de 1 metro cuadrado')
        self.superficie=superficie
        self.agujeros=agujeros
        super().__init__(puertas1,cerraduras1,cajones1,detalles1)

    def trabajar(self,hours):
        print(f'escritorio ocupado durante {hours} hora(s)')

Muy poderosa cuando se sabe usar. Abusar de la herencia puede hacer de su software un monstruo.

Reto:
Uber
Cuenta
-Nombre
-Id
-Edad
-etc

Super Clase Cuenta
Hereda Usuario
Hereda Conductor
-Carro
-Si cuenta o no con licencia de conducir
-Permiso
Trasporte
-Placa de Vehiculo
-Conductor

Super Clase Transporte
-Uber X
-Uber Pool
-Uber Black
-Uber Van

También existen diferentes formas de escribir la herencia, en esta clase se uso:

super().__init__(.....)

Está forma solo se puede hacer en python 3 en python 2 es necesarios especificar los parámetros de la función super

super(clase_hija, self).__init__(.....)

Es algo raro que el parámetro que el parámetro sea la clase hija pero es debido a la sintaxis de la función.
Por último la forma más especifica en mi opinión es usar directamente la notación de punto como una clase cualquiera

ClasePadre.variable = value 

todos los fragmentos de código van dentro del constructor de la clase.
Por último se debe tener especial cuidado con la herencia múltiple usando la función “super” ya que la jerarquía va depender del comportamiento de esta función.

<code>
class NewtonLawII:
	def __init__(self, masa, aceleracion):
		self.masa=masa #float(input('ingrese la cantidad de masa del objeto: '))
		self.aceleracion=aceleracion #float(input('ingrese la aceleracion del objeto: '))
	
	def fuerza(self):
		return self.masa*self.aceleracion

class Weight(NewtonLawII):
	def __init__(self, masa):
		super().__init__(masa, aceleracion=10)
		pass

if __name__ == '__main__':
	Fuerza=NewtonLawII(masa=5, aceleracion=3)
	print(Fuerza.fuerza())

	peso=Weight(masa=3)
	print(peso.fuerza())

Un ensayo con este reto

#**Reto con Herencia - Usando tipos de Vehiculo***

class Vehiculo:
    def __init__(self,motor, puertas, llantas):
        self.motor = motor
        self.puertas = puertas
        self.llantas = llantas
    def componentes(self):
        return f" tiene como componentes {self.llantas} llantas, {self.puertas} puertas y {self.motor} motor"

class Moto(Vehiculo):
    def __init__(self, motor, sin, llantas):
        super().__init__(motor, sin, llantas)

class Bici(Vehiculo):
    def __init__(self,sin, llantas):
        super().__init__(sin, sin, llantas)

if __name__ == "__main__":
    vehiculo = Vehiculo("1", "4", "4")
    print(f"El {vehiculo} {vehiculo.componentes()}")
    moto = Moto("1","sin","2")
    print(f"La {moto} {moto.componentes()}")
    bici = Bici("sin","2")
    print(f"La {bici} {bici.componentes()}")

Reto:

class Potencia_Motor:

    def __init__(self, rpm, torque):
        self.rpm = rpm
        self.torque = torque

    def potencia(self):
        return (self.rpm * self.torque) / 5252

class Porshe(Potencia_Motor):

    def __init__(self, rpm, torque, num_puertas, color):
        super().__init__(rpm, torque)
        self.num_puertas = num_puertas
        self.color = color

if __name__ == '__main__':
    potencia_motor = Potencia_Motor(1500, 250)
    print(potencia_motor.potencia())

    porshe = Porshe(2500, 480, 3, 'rojo')
    print(f'Porshe con {porshe.potencia()} HP, con {porshe.num_puertas} puertas, color {porshe.color}')

No pensé en otra jerarquía pero implemente el triángulo y el círculo

import math

class Recatangulo:
    def __init__(self, base, altura):
        self.base = base 
        self.altura = altura

    def area(self):
        return self.base * self.altura 


class Cuadrado(Recatangulo):
    def __init__(self, lado):
        super().__init__(lado, lado)


class Triangulo(Recatangulo):
    def __init__(self, base, altura):
        super().__init__(base, altura)

    def area(self):
        return super().area() // 2


class Circulo(Cuadrado):
    def __init__(self, radio):
        super().__init__(radio)

    def area(self):
        return math.pi * (self.base**2)

if __name__ == '__main__':
    rectangulo = Recatangulo(3, 4)
    print(rectangulo.area())

    cuadrado = Cuadrado(5)
    print(cuadrado.area())

    triangulo = Triangulo(10, 8)
    print(triangulo.area())

    circulo = Circulo(3)
    print(circulo.area())

class Gramo:
    
    def __init__(self, cantidad, equivalencia = 1):
        
        self.cantidad = cantidad
        self.equivalencia = equivalencia
        
    
    def peso(self):
        
        return str((self.cantidad * self.equivalencia))
        

class Miligramo(Gramo):
    
    def __init__(self, cantidad):
        
        super().__init__(cantidad, 10**3)
        
class Kilogramo(Gramo):
    
    def __init__(self, cantidad):
        
        super().__init__(cantidad, 10**-3)
    
class Libra(Gramo):
    
    def __init__(self, cantidad):
        
        super().__init__(cantidad, 1/454)
        
class Onza(Gramo):
    
    def __init__(self, cantidad):
        
        super().__init__(cantidad, 1/28.35)

    
if __name__ == '__main__':
    
    valor = float(input('Ingrese la cantidad de gramos a convertir: '))

    miligramos =  Miligramo(valor) 
    print(f'{valor} gramos son equivalentes a : {miligramos.peso()} miligramos')
    
    kilos =  Kilogramo(valor) 
    print(f'{valor} gramos son equivalentes a : {kilos.peso()} kilogramos')
    
    libras = Libra(valor)
    print(f'{valor} gramos son equivalentes a : {libras.peso()} libras')
    
    onza = Onza(valor)
    print(f'{valor} gramos son equivalentes a : {onza.peso()} onzas')

class Persona():

	def __init__(self,edad,nombre,lugar_residencia):

		self.edad = edad
		self.nombre = nombre
		self.lugar_residencia = lugar_residencia
		self.pais ="Chile"

	def descripcion(self):

		print("Edad: {}, Nombre: {}, Ciudad: {}".format(self.edad,self.nombre,self.lugar_residencia))


class Empleado(Persona):

	# Debemos pasarle los parametros necesario para el constructor de la clase padre
	def __init__(self, salario, antiguedad, persona_edad, persona_nombre, persona_lugar_residencia):
		# Con la función super() llamamos al metodo __init__ de la clase padre y le pasamos los parametros que necesita dicho constructor
		super().__init__(persona_edad,persona_nombre,persona_lugar_residencia) 
		self.salario = salario
		self.antiguedad = antiguedad

	# Si quiero imprimir todos los datos de ambas clases, debemos sobre escribir el metodo descripción y llamar el metodo
	# descripción de la clase padre con la función super().

	def descripcion(self): # Sobre escribo el metodo descripción

		super().descripcion() # Llamo el metodo descripción de la clase padre para mostrar los datos "Edad", "Nombre", "Ciudad"

		print("Salario: {}, Antiguedad: {}".format(self.salario,self.antiguedad)) # Muestro los datos "Salario, "Antiguedad"


	def descripcion_2(self):
		#Con este metodo se desmuestra que se hereda las variables de instancia de la clase padre (persona)
		print("Salario: {}, Antiguedad: {}, Edad: {}, Nombre: {}, Ciudad: {}, Pais: {}".format(self.salario,self.antiguedad,self.edad,self.nombre,self.lugar_residencia,self.pais))


if __name__ == '__main__':
	jonathan = Empleado(150000,2,30,'Jonathan','Santiago')
	jonathan.descripcion()
	jonathan.descripcion_2()

Hola, estaba practicando la parte de los decoradores @, pero me di cuenta que solo funcionan con atributos privados, ya que los publicos los podemos asignar directamente.

Esto se me hizo interesante, ya que podemos ver como funciona todo esto, tambien intente hacer la parte de herencia multiple, pero no logre hacer que el constructor iniciara los constructores de las clases padres

class Ropa:
    def __init__(self, material = None, tamanio = None, precio = None, color = None):
        self._material = material
        self._precio = precio
        self._tamanio = tamanio
        self._color = color

    @property
    def material(self):
        return self._material

    @material.setter
    def material(self, material):
        self._material = material

    @property
    def tamanio(self):
        return self._tamanio

    @tamanio.setter
    def tamanio(self, tamanio):
        self._tamanio = tamanio

    @property
    def precio(self):
        return self._precio

    @precio.setter
    def precio(self,precio):
        self._precio = precio

    @property
    def color(self):
        return self._color

    @color.setter
    def color(self, color):
        self._color = color

# Herencia
class Playera(Ropa):

    def __init__(self,material, tamanio, precio, color, tipo = None):
        super().__init__(material,tamanio,precio, color)
        self._tipo = tipo

    @property
    def tipo(self):
        return self._tipo

    @tipo.setter
    def tipo(self,tipo):
        self._tipo = tipo

class Pantalon(Ropa):

    def __init__(self, material, tamanio, precio, color , tipo, genero = None):
        super().__init__(material, tamanio, precio, color)
        self._genero = genero
        self._tipo = tipo

    @property
    def tipo(self):
        return  self._tipo

    @tipo.setter
    def tipo(self, tipo):
        self._tipo = tipo

    @property
    def genero(self):
        return self._genero

    @genero.setter
    def genero(self, genero):
        self._genero = genero

if __name__ == '__main__':
    miPlayera = Playera('Algodon','Mediano',9.99,'Rojo','Basica')
    miPantalon = Pantalon('Casimir','32',14.99,'Baige','Vaquero','Hombre')

    print(miPlayera.material)
    print(miPlayera.tamanio)
    print(miPlayera.precio)
    print(miPlayera.color)
    print(miPlayera.tipo)
    print()
    print(miPantalon.material)
    print(miPantalon.tamanio)
    print(miPantalon.precio)
    print(miPantalon.color)
    print(miPantalon.tipo)
    print(miPantalon.genero)

Me costo pero esto es lo que pude hacer mi único problema es que me sale un none al final de cada print que no supe solucionar si alguien lo consigue se los agradeceria. esto es una pregunta?

class Animal:
    def __init__(self, nombre, color, animal, sonido):
        self.nombre = nombre
        self.color = color
        self.animal = animal
        self.sonido = sonido
    
    def animal_se_presenta(self):
        print(f"Yo soy {self.nombre}, soy un {self.animal}, {self.sonido} y soy de color {self.color}")

class Gato(Animal):
    def __init__(self, nombre, color, animal, sonido):
        super().__init__(nombre, color, animal, sonido)

class Lobo(Animal):
    def __init__(self, nombre, color, animal, sonido):
        super().__init__(nombre, color, animal, sonido)

class Perro(Animal):
    def __init__(self, nombre, color, animal, sonido):
        super().__init__(nombre, color, animal, sonido)



if __name__ == "__main__":
    gato = Gato("Carlos", "rojo", "gato", "maullo")
    print(gato.animal_se_presenta())

    lobo = Lobo("Jose", "gris", "lobo", "aullo")
    print(lobo.animal_se_presenta())

    perro = Perro("Miguel", "naranja", "perro", "ladro")
    print(perro.animal_se_presenta())

Hola, yo hice esta herencia de estudiante y trabajador, basado en persona, agradezco mucho el feedback para mejorar el código:

class Persona:

  def __init__(self, nombre, apellido):
    self.nombre = nombre
    self.apellido = apellido

class Estudiante(Persona):

  def __init__(self, nombre, apellido, escuela, jornada):
    Persona.__init__(self, nombre, apellido)
    self.escuela = escuela
    self.jornada = jornada

  def saludar(self):
    return f'Hola mucho gusto me llamo {self.nombre} y estudio en {self.escuela}'

class Trabajador(Persona):

  def __init__(self, nombre, apellido, empresa, tipo_empleado):
    Persona.__init__(self, nombre, apellido)
    self.empresa = empresa
    self.tipo_empleado = tipo_empleado

  def saludar(self):
    return f'Hola mucho gusto me llamo {self.nombre} y trabajo en {self.empresa} soy del personal {self.tipo_empleado}'

if __name__ == '__main__':

  estudiante = Estudiante('Arturo', 'Elias', 'Universidad', 'Matutina')
  print(f'{estudiante.saludar()} ')

  trabajador = Trabajador('Alex', 'Torrenegra', 'Empresa', 'Administrativo')
  print(f'{trabajador.saludar()} ')
  • Permite modelar una jerarquía de clases.
  • Permite compartir comportamiento común en la jerarquía.
  • Al padre se le conoce como superclase y al hijo como subclase.

Funciona, pero ¿Alguien sabe por qué, cuando pido las especificaciones de una pc o laptop con sus valores default, es decir, sin haber elegido reemplazar previamente, crashea?

class Computer:

    def __init__(self, processor, brand, ram):
        self.processor = processor
        self.model = brand
        self.ram = ram

    def show_components(self):
        print(f'Esta computadora es de marca {self.brand}, tiene un procesador {processor} y tiene {ram} de RAM ')

    def change_computer(self, processor, brand, ram):
        self.processor = processor
        self.brand = brand
        self.ram = ram
        print('Computadora cambiada exitosamente')


class Laptop(Computer):

    def __init__(self, processor, brand ,ram, battery = 1):
        super().__init__(processor, brand, ram)
        self.battery = battery
        self._closed = True

    def close_laptop(self):
        if self._closed:
            print('¡La laptop ya está cerrada!')
        else:
            self._closed = True
            print('La laptop se cerró')

    def open_laptop(self):
        if not self._closed:
            print('¡La laptop ya está abierta!')
        else:
            self._closed = False
            print('La laptop se abrió')

    def show_battery(self):
        if self._closed:
            print('¡La laptop está cerrada!')
        else:
            print(f'Queda {self.battery}% de batería')

        

class PC(Computer):
    def __init__(self, processor, brand, ram):
        super().__init__(processor, brand, ram)
        self.monitor_is_on = True

    def monitor_off(self):
        if not self.monitor_is_on:
            print('¡El monitor ya está apagado!')
        self.monitor_is_on = False

    def monitor_on(self):
        if self.monitor_is_on:
            print('¡El monitor ya está encendido!')
        self.monitor_is_on = True

if __name__ == "__main__":
    my_laptop = (Laptop(processor = 'Intel core generación 1 con medio nucleo', brand = 'HP', ram = '100mb'))
    my_pc = (PC(processor = 'Intel core generación 1 con medio nucleo', brand = 'HP', ram = '100mb'))
    while True:
        print('* --- * --- * --- * --- * --- * --- * ---')
        print('[l]aptop')
        print('[p]c')
        print('* --- * --- * --- * --- * --- * --- * ---')
        command = input('¿Qué eliges?: ')
        
        if command == 'l':
            print('[r]eemplazar mi laptop')
            print('[c]errar laptop')
            print('[a]brir laptop')
            print('[v]er batería')
            print('[e]specificaciones')

            command_inner = input('¿Qué eliges? ')
            if command_inner == 'r':
                processor = input('¿Qué procesador tiene tu nueva laptop? ')
                brand = input('¿Qué marca es tu nueva laptop? ')
                ram = input('¿Cuánta ram tiene tu nueva laptop?')
                battery = input('¿Cuánta batería tiene tu nueva laptop ahora mismo?')
                my_laptop.change_computer(processor, brand, ram)
            elif command_inner == 'c':
                my_laptop.close_laptop()
            elif command_inner == 'a':
                my_laptop.open_laptop()
            elif command_inner == 'v':
                my_laptop.show_battery()
            elif command_inner == 'e':
                my_laptop.show_components()


        if command =='p':
            print('[r]eemplazar mi PC')
            print('[a]pagar el monitor')
            print('[p]render el monitor')
            print('[e]specificaciones')

            command_inner = input('¿Qué eliges? ')
            if command_inner == 'r':
                processor = input('¿Qué procesador tiene tu nueva PC? ')
                brand = input('¿Qué marca es tu nueva PC? ')
                ram = input('¿Cuánta ram tiene tu nueva PC?')
                my_pc.change_computer(processor, brand, ram)
            elif command_inner == 'a':
                my_pc.monitor_off()
            elif command_inner == 'p':
                my_pc.monitor_on()
            elif command_inner == 'e':
                my_pc.show_components()

Herencia

Permite modelar una jerarquia de objetos o clases, nos permite compartir cierto comportamiento comun en la jerarquia.
Al padra se le conoce como superclase y al hijo como subclase.
las super clases se las menciona asi por que estan arriba.
las sub clases se les llama asi porque heredan el codigo de las super clases

class Rectangulo:

    def __init_(self, base, altura):
        self.base = base
        self.altura = altura

    def area(self):
        return self.base * self.altura

class Cuadrado(Rectangulo):
# Para heredar el comportamiento se define la super clase que es el rectangulo, porque esta arriba.
    
    def __init__(self, lado):
    #solo necesitamos un lado para definir un cuadrado
        super().__init__(lado, lado)
        #super nos permite tener una referencia de la super clase

if __name__ == "__main__":
    rectangulo = Rectangulo(base=3, altura=4)
    print(rectangulo.area())

    cuadrado = Cuadrado(lado=5)
    print(cuadado.area())
    #ejecutamos el metodo area  dentro de la clase cuadrado, es decir estamos heredando el metodo de la super clase

😫 quisiera entender un poco mejor con un codigo mas explicado.

class Componentes_notebook:

    def __init__(self, ram_ddrl, disco_25, placa_madre_m, pantalla_led):
        self._archivos = [ram_ddrl, disco_25, placa_madre_m, pantalla_led] 

    def lista(self):
        return self._archivos

class Componente_desktop(Componentes_notebook):
    def __init__(self, ram_ddr4, disco_35, placa_madre_atx, monitor):
        super().__init__(ram_ddr4, disco_35, placa_madre_atx, monitor)

if __name__ == '__main__':

    especificaciones_note = Componentes_notebook(ram_ddrl=4, disco_25=250, placa_madre_m='chica', pantalla_led = 14)
    print(especificaciones_note.lista())

    especificaciones_desktop = Componente_desktop(ram_ddr4=8, disco_35=500, placa_madre_atx='grande', monitor=21)
    print(especificaciones_desktop.lista())



En mi caso particular atiendo a clientes que comercializan servicios de Internet, de los cuales se derivan dos servicios principales(al margen del triple play y demás aditamentos), Internet Banda Ancha(generalmente usado en hogares y pequeñas empresas), e Internet Dedicado(Generalmente usado en grandes empresas, o empresas con requerimientos muy puntuales en velocidad); en fin, los costos se calculan de manera diferente(Debido a lo que llaman el reuso, pero no los aburriré con los detalles); por lo que el código quedaría así (aunque requiere de algunos afinamientos):

class Internet:

    def __init__(self, paquete, precio_mega):
        self.paquete = paquete
        self.precio_mega = precio_mega
     #   self.__descuento_paquete = descuento_paquete

    def costo(self):
         return self.paquete * self.precio_mega
        
class Banda_Ancha(Internet):
    
    def __init__(self, paquete, precio_mega, descuento):
        super().__init__(paquete, precio_mega)
        self.descuento = descuento
        self.precio_mega = precio_mega * self.descuento

class Dedicado(Internet):
    
    def __init__(self, paquete, precio_mega, descuento):
        super().__init__(paquete, precio_mega)
        self.descuento = descuento
        self.precio_mega = precio_mega * self.descuento

if __name__ == "__main__":
    precio = Internet(paquete=10, precio_mega=15)
    print(precio.costo())

    banda_ancha = Banda_Ancha(paquete=100, precio_mega=5, descuento=0.9)
    print(banda_ancha.costo())

    dedicado = Dedicado(paquete=100, precio_mega=15, descuento=0.95)
    print(dedicado.costo())```

Herencia
Se refiere al modelado de una jerarquía de de objetos que tienen un comportamiento en común.
Tenemos una clase padre (superclase) que hereda ciertos comportamientos a sus clases hijas (subclase).

Sintaxis

class <clase_hija>(<clase_padre>):
	def __init__(self,<argumentos>)
		super().__init__(<argumentos>)
	<métodos propios de la subclase>	

Notas

  • Con el método super llamamos directamente a la clase padre podemos modificar así un método de la clase padre a la clase hijo (en este caso el constructor)
  • Si hay dos métodos con el mismo nombre (en el padre y en el hijo) prima el método de la clase hijo.

Si el metodo de area es base x altura (3x4)
Por qué Super(). toma la “habilidad” de multiplicar y multiplica lado x lado o sea 5x5, quiere decir que NO toma los parametros de Rectangulo, si no su habilidad de multiplicar dos valores?

Lo que hice fue crear herencia para agregar perifericos de PC

class Persona:
    def __init__(self, comp_name, age, city):
        self.comp_name = comp_name
        self.age = age
        self.city = city
    def presentation(self):
        return (f"{self.comp_name} tiene {self.age} años  y vive en {self.city}")
    
class Empleado(Persona):
    def __init__(self, compa_name, age, city, puesto, antiguedad, salario):
        super().__init__(compa_name, age, city)
        self.puesto = puesto
        self.antiguedad = antiguedad
        self.salario = salario

    def workinThings(self):
        return (f"Actualmente en el puesto de {self.puesto} con una antiguedad de {self.antiguedad} y cobrando unos {self.salario}")

if __name__=="__main__":
    Persona1 = Empleado("Lucas Yañez", 26, "San Juan", "programador", "3 meses", 120000)
    print(Persona1.presentation())
    print(Persona1.workinThings())

Solo como nota, incluso estaría padre resaltar que tanto perros como gatos tienen garras, así que podríamos agruparlos, después, con un decorador darle el método de retracción a los felinos.

class Peso:

def __init__(self, masa, gravedad ):
    self.masa = masa
    self.gravedad = gravedad
   


def calculo_peso(self):
    return self.masa * self.gravedad

class Fuerza(Peso):

def __init__(self,masa, aceleracion):
    super().__init__(masa, aceleracion)

if name == ‘main’:
objeto = Peso(masa=57,gravedad=9.8)
print(objeto.calculo_peso())

poderoso = Fuerza(masa=45, aceleracion=20)
print(poderoso.calculo_peso())

utiles escolares - con punta, lapiz , lapicero
- sin punta - borrador, sacapunta

Acá les muestro como la clase UberPool hereda de la clase Car (Sacado del Curso de POO)

Un ejemplo que se me ocurre puede ser para un programa de registro de estudiantes y profesores, donde, si bien ambos tienen nombre, contacto, matricula, etc. Cada uno tiene datos que el otro no, por ejemplo, los profesores tienen un salario, los alumnos tienen una cantidad de materias registradas.

Hola! Hice este programa para calcular el contenido calórico de un alimento y sus posibles beneficios en el caso de las frutas.
Cualquier sugerencia bienvenida.


class Alimento:

    def __init__(self, carbohidratos, proteinas, lipidos, fibra):
        self.carbohidratos = carbohidratos
        self.proteinas = proteinas
        self.lipidos = lipidos
        self.fibra = fibra

    def calculo_calorias(self):
        return self.carbohidratos * 4 + self.proteinas * 4 + self.lipidos * 9 + self.fibra * 2

class Fruta(Alimento):

    def __init__(self, carbohidratos, proteinas, lipidos, fibra, fitoquimico):
        super().__init__(carbohidratos, proteinas, lipidos, fibra)

        self.fitoquimico = fitoquimico
        self._fitoquimicos_de_instancia = None

    @property
    def fitoquimicos_de_instancia(self):
        return self._fitoquimicos_de_instancia

    @fitoquimicos_de_instancia.setter
    def fitoquimicos_de_instancia(self, luteina):
        if luteina in self.fitoquimico:
            self._fitoquimicos_de_instancia = luteina
            print('La luteína sirve como antioxidante preveniendo el daño celular')



palta = Fruta(1, 1, 10, 0, ['luteína', 'vitamina E'])
print(palta.fitoquimicos_de_instancia)
print(f'Las calorías de tu alimento son: {palta.calculo_calorias()}')
palta.fitoquimicos_de_instancia = 'luteina'

En un proyecto de modelado de colectores solares podr’ia tener primero una clase de Collector que tenga todo lo que todos los colectores tienen en com’un como el area de apertura. Y luego heredar de esta clase para cada tipo de tecnolog’ia; planos, fresenel o parabolico.

Reto:

De una vez se practica lo visto en la escuela de blockchain!

MI ejemplo con cheescake y carrotcake

<class cheescake():
    def __init__(self, harina, huevos, fresas):
        self.harina= harina
        self.huevos= huevos
        self.fresas= fresas
    def masa(self):
        return self.harina + self.huevos + self.fresas

 class carrotcake(cheescake):
    def __init__(self, carrots):
        super().__init__(carrots, carrots, carrots)

if __name__=='__main__':
    
    tarta_queso= cheescake(1,4,10)
    print(str(tarta_queso.masa()) + ' unidades de ingredientes necesitaremos para la cheescake')

    carrotcake= carrotcake(3)
    print('Se necesita ' + str(carrotcake.masa()) + ' unidades de ingredientes para la carrotcake' ) > 

QUE ES LA HERENCIA EN POO?

Es el mecanismo por el cual una clase permite heredar las características (atributos y métodos) de otra clase. La herencia permite que se puedan definir nuevas clases basadas de unas ya existentes a fin de reutilizar el código, generando así una jerarquía de clases dentro de una aplicación.

ejemplo

cuando el padre muere, los hijos reciben como herencia
la casa y otras propiedades que su padre había adquirido en vida. En el ámbito cultural y social, se refiere a un conjunto de tradiciones, costumbres, expresiones artísticas, formas de comunicación, etc, que se transmiten de una generación a otra.

Utilice algunos de los conocimientos en contabilidad que tengo y aplique la programacion orientada a objetos para el analisis de estados financieros XD

que mejoras le arian?

<code>
import pandas as pd
class MetodosFinancieros():

    info ={
        'Nombre de la empresa':None,
        'Ubicacion':None,
        'Periodo':None
    }
    
    Liquidez = {
    'capital neto':None, 
    'Razon de liquidez':None, 
    'Prubea de acido': None
    }

    Solvencia = {
        'Solvencia total': None,
        'Firmeza': None,
        'Independencia':None
    }

    Estabilidad = {
        'Origen de capital':None,
        'Inversion de capital':None,
        'Valor contable de capital':None
    }
    CicloEconomico = {
        'Utilidad del ejercicio':None,
        'Estudio de la utilidad':None,
        'Margen de ganacias por unidad':None
    }
    RazonesSimples = [Solvencia,Liquidez,Estabilidad]

    def __init__(self):
        pass

    def Info(self, Name = None, Ubicasion = None, Periodo = None):
        self.Info['Nombre de la empresa'] = Name
        self.Info['Ubicasion'] = Ubicasion
        self.Info['Periodo'] = Periodo

    #!metodos de Razones Simples
    #? metodos de liquidez

    def AnalisisLiquidez(self,ActivoCirculante = None, PasivoCirculante = None,Inventario = None):
        self.capitalNeto(ActivoCirculante,PasivoCirculante)
        self.razonLiquidez(ActivoCirculante, PasivoCirculante)
        self.pruebaAcido(ActivoCirculante, PasivoCirculante, Inventario)
        pass

    def capitalNeto(self, ActCir, PasCir):
        capitalNeto = ActCir - PasCir
        self.Liquidez['capital neto'] = capitalNeto
        print(capitalNeto)

    def razonLiquidez(self, ActCir, PasCir):
        RazonDeLiquidez = ActCir/PasCir
        self.Liquidez['Razon de liquidez'] = RazonDeLiquidez
        print(RazonDeLiquidez)

    def pruebaAcido(self, ActCir, PasCir,inventario):
        PruebaDeAcido = (ActCir - inventario)/PasCir
        self.Liquidez['Prubea de acido'] = PruebaDeAcido
        if PruebaDeAcido > 1:
            print('esta prueba de acido a sido superada ', PruebaDeAcido)
        else:
            print('la prueba de acido no ha sido superada ', PruebaDeAcido)
        
    def DateLiquidez(self):
        dataLiquidez = self.Liquidez
        series = pd.Series(dataLiquidez)
        return series

    #? metodos de solvencia 

    def AnalisisSolvencia(self, ANTR =None,DT=None,ANRF=None,PF=None,NP=None):
        self.solvenciaTotal(ANTR,DT)
        self.firmeza(ANRF,PF)
        self.independencia(NP,PF)

    def solvenciaTotal(sefl, ANTR, DT):
        solvenciaTotal = ANTR/DT
        sefl.Solvencia['Solvencia total'] = solvenciaTotal
        print('Solvencia total',solvenciaTotal)

    def firmeza(self,ANRF,PF):
        Firmeza = ANRF/PF
        self.Solvencia['Firmeza'] = Firmeza
        print(Firmeza)

    def independencia(self, NP,PF):
        Independencia = NP/PF 
        self.Solvencia['Independencia'] = Independencia
        print(Independencia)
    
    def DateSolvencia(self):
        dataSolvencia = self.Solvencia
        series = pd.Series(dataSolvencia)
        return series

    #?Analisis de la estabilidad 

class Estabilidad(MetodosFinancieros()):
    def AnalisisEstabilidad(self, ActivoFijo,CapitalContable,CapitalSocial,PasivoTotal):
        self.origenDeCapital(PasivoTotal,CapitalContable)
        self.inversionDeCapital(ActivoFijo,CapitalContable)
        self.valorContableDelCapital(CapitalContable, CapitalSocial)

        
    def origenDeCapital(self, PasivoTotal,CapitalContable):
        OrigenDeCapital = PasivoTotal/CapitalContable
        self.Estabilidad['Origen de capital'] = OrigenDeCapital
        print(OrigenDeCapital)

    def inversionDeCapital(self, ActivoFijo, CapitalContable):
        InversionDeCapital = ActivoFijo/CapitalContable
        self.Estabilidad['Inversion de capital'] = InversionDeCapital
        print(InversionDeCapital)

    def valorContableDelCapital(self, CapitalContable, CapitalSocial):
        ValorContableDelCapital = CapitalContable/CapitalSocial
        self.Estabilidad['Valor contable de capital'] = ValorContableDelCapital
        print(ValorContableDelCapital)

    def DataEstabilidad(self):
        dataOrigenCapital = self.Estabilidad
        series = pd.Series(dataOrigenCapital)
        return series 
    #? Ciclo economico 

    def AnalsisiCicloEconomico(self,utilidadDeEjercicio = None,CapitalSocial = None,PT = None,VentasNetas = None):
        self.utilidadDelEjercicio(utilidadDeEjercicio,CapitalSocial)
        self.estudioUtilidad(utilidadDeEjercicio,CapitalSocial, PT)
        self.margenGanaciaUnidad(utilidadDeEjercicio,VentasNetas)

    def utilidadDelEjercicio(self, utilidadDeEjercicio, CapitalSocial):
        estudioiUtilidad = utilidadDeEjercicio/CapitalSocial
        self.CicloEconomico['Utilidad del ejercicio'] = estudioiUtilidad
        print(estudioiUtilidad)

    def estudioUtilidad(self, utilidadDeEjercicio, CapitalSocial, PT):
        EstudioDeUtilidad = utilidadDeEjercicio / (CapitalSocial + PT)
        self.CicloEconomico['Estudio de la utilidad'] = EstudioDeUtilidad
        print(EstudioDeUtilidad)

    def margenGanaciaUnidad(self, UtilidadDeEjercicio, VentasNetas):
        MargenGanaciaUnidad = UtilidadDeEjercicio / VentasNetas
        self.CicloEconomico['Margen de ganacias por unidad'] = MargenGanaciaUnidad
        print(MargenGanaciaUnidad)

    def DataCicloEconomico(self):
        CicloEconomico = self.CicloEconomico
        series = pd.Series(CicloEconomico)
        return series 



    def razonesSimples(self):
        rS = self.RazonesSimples
        series = pd.Series(rS)
        return series 

    
    
    #!
a = MetodosFinancieros()
# a.capitalNeto(1622119, 240038)
# a.razonLiquidez(1622119, 240038)
# a.pruebaAcido(1622119, 240038 ,950000)

# deudadTotales = 1109500 + 240038 
# a.solvenciaTotal(2417986, deudadTotales)
# a.firmeza(548907,1109500)

a.DateLiquidez
a.DateSolvencia 

Hice un pequeño y muy básico ejemplo con lápices:

class lapiz:
  def __init__(self,material):
    self.material = material
  
  def pintar(self):
    print('Pintar de manera épica')

class lapiz_de_color(lapiz):
  def __init__(self,color):
    super().__init__('Madera')
    self.color = color

class lapiz_de_tinta(lapiz):
  def __init__(self,color_de_tinta):
    super().__init__('Plástico')
    self.color_de_tinta = color_de_tinta

lapiz_colorido = lapiz_de_color.pintar('Marrón')
lapiz_colorido

Se me ocurrió un unificador de facturas donde el metodo lo puedan utilizar diferentes áreas en una empresa:

Mi Código

class Car:
    def __init__(self,color,puertas,llantas,motor):
        self.color=color
        self.puertas=puertas
        self.llantas=llantas
        self.motor=motor


class audi(Car):
    def __init__(self,modelo,color,puertas,llantas,motor):
        super().__init__(color,puertas,llantas,motor)
        self.marca="audi"
        self.modelo=modelo

class chevrolet(Car):
    def __init__(self,modelo,color,puertas,llantas,motor):
        super().__init__(color,puertas,llantas,motor)
        self.marca="chevrolet"
        self.modelo=modelo
class ford(Car):
     def __init__(self,modelo,color,puertas,llantas,motor):
        super().__init__(color,puertas,llantas,motor)
        self.marca="ford"
        self.modelo=modelo
       
        

            
if __name__=="__main__":
    Audi_A4=audi("A4","rojo","4","4x4","6 cilindros")
    Audi_A4.marca="audi"
    print(f"marca: {Audi_A4.marca}, modelo: {Audi_A4.modelo}, color: {Audi_A4.color}, puertas: {Audi_A4.puertas}, llantas: {Audi_A4.llantas}, motor: {Audi_A4.motor}")

De Dragon Ball Z

class GuerreroZ:

	def __init__(self, name, type):
		self.name = name
		self.type = type

	def description(self):
		return f'{self.name} es un guerrero {self.type}'


class Piccolo(GuerreroZ):

	def __init__(self, technique):
		self.technique = technique
		super().__init__('Piccolo', 'Namekusein')

	def tecnica(self):
		return f'{self.name} utiliza la técnica {self.technique}'


class Broly(GuerreroZ):

	def __init__(self, technique):
		self.technique = technique
		super().__init__('Broly', 'Sayayin')

	def tecnica(self):
		return f'{self.name} utiliza la técnica {self.technique}'


if __name__ == '__main__':

	guerreroZ = Piccolo('Makankosapo')
	print(guerreroZ.description())
	print(guerreroZ.tecnica())
		

	guerreroZ = Broly('Ráfaga Meteórica')
	print(guerreroZ.description())
	print(guerreroZ.tecnica())

Heriencia de vehiculos

# Clase Vehiculo
class Vehicle:
    def __init__(self, medio_de_transporte, drive_type, passenger_capacity):
        # aereo, terreste, marino, 
        self.medio_de_transporte = medio_de_transporte
        self.drive_type = drive_type
        self.passenger_capacity = passenger_capacity
    
    def description(self):
        amount = 'pasajero' if self.passenger_capacity == 1 else 'pasajeros'
        return f'Soy un vehículo {self.medio_de_transporte} de propulsión {self.drive_type} y tengo la capacidad de transportar {self.passenger_capacity} {amount}.'
    
# Clase Cicla
class Bicycle(Vehicle):
    def __init__(self):
        super().__init__('terrestre', 'biológica', 1)
        
    def description(self):
        return super().description() + ' Soy un medio de transporte sano, ecológico, sostenible y económico.'

# Clase Motocicleta
class Motorcycle(Vehicle):
    def __init__(self):
        super().__init__('terrestre', 'termica', 2)
            
    def description(self):
        return super().description() + ' Soy un medio de transporte divertido, ideal para personas aventureras.'    
        
# Clase Carro
class Carro(Vehicle):
    def __init__(self, power_source, passenger_capacity, kind_of_car):
        super().__init__("terrestre", 'térmica', passenger_capacity)
        self.power_source = power_source
        self.kind_of_car = kind_of_car
        
    def description(self):
        return super().description() + f' Soy un carro tipo {self.kind_of_car} con motor de {self.power_source}.'

# Clase Sedan
class Sedan(Carro):    
    def __init__(self, power_source, passenger_capacity):
        super().__init__(power_source, passenger_capacity, 'sedan')
        
mi_sedan = Sedan('gasolina', 5)
mi_cicla = Bicycle()
mi_moto = Motorcycle()

print(mi_sedan.description())
print(mi_cicla.description())
print(mi_moto.description())

Reto:

class Dj:
    
    def __init__(self, nombre, edad, genero):
        self.nombre = nombre
        self.edad = edad
        self.genero = genero
        
    def pone_musica(self, musica = True):
        self.musica = musica
        if musica:
            print(f'{self.nombre} está poniendo música')
            
class Dj_electronica(Dj):
    
    def __init__(self, nombre, edad, genero = 'electronica'):
        super().__init__(nombre, edad, genero)
        
class Dj_crossover(Dj):
    
    def __init__(self, nombre, edad, genero = 'crossover'):
        super().__init__(nombre, edad, genero)
        
        
def run():
    
    dj_electronica = Dj_electronica('Samuel', '29', 'Electrónica')
    dj_crossover = Dj_crossover('Ronald', '34', 'Crossover')
    
    dj_electronica.pone_musica(True)
    dj_crossover.pone_musica(True)
    
if __name__ == '__main__':
    run()

Aquí les comparto mi clase futbolista ( no es del Granada):

class futbolista_primera:

def __init__(self, liga = 'Española', categoria = 'Primera'):
    self.liga = liga
    self.categoria = categoria

def tirar(self, lugar):
    print(f'El jugador tira a {lugar}')

class futbolista_segunda(futbolista_primera):

def __init__(self, liga='Española', categoria='Segunda'):
    super().__init__(liga, categoria)

if name == ‘main’:
Atleti = futbolista_primera()
print(Atleti.tirar(lugar = “derecha”))

Malaga = futbolista_segunda()
print(Malaga.tirar(lugar = "centro"))

El polimorfismo en la POO nos permite modificar el comportamiento de una superclase para adaptarlo a las necesidades de una subclase. Esto nos ayudará a crear una clase general con unas definiciones por defecto que luego podremos ir adaptando según las necesidades de la clase hija. Ejemplo:

class Vehiculo:

    def __init__(self, nombre):
        self.nombre = nombre

    def num_ruedas(self):
        pass

class Motocicleta(Vehiculo):
    def __init__(self):
        super().__init__('Motocicleta')

    def num_ruedas(self):
        return 2

if __name__ == "__main__":
    moto = Motocicleta()
    print(moto.num_ruedas())

En este caso tenemos una clase padre Vehículo con un método num_ruedas y una clase hija Motocicleta que heredará de Vehículo. Ya que según el vehículo que estemos creando tendrá un número de ruedas u otro, sobreescribimos el método num_ruedas para dar el resultado que buscamos.

Les dejo un link para aclarar dudas

https://ellibrodepython.com/herencia-en-python

MI RETO:

RESULTADO:

Hice este programita que tiene una Torre de x cantidad de pisos + una antena. Con la altura de cada uno de esos elementos nos da la altura total.
Y de una subclase (casa de dos pisos), que no tiene antena en el techo, entonces en vez del valor de la antena, le paso dos veces el valor del piso (son iguales)
Mi pregunta es: Donde debería codificar el encapsulamiento de los datos de la casa, ya que siempre van a ser dos pisos (a diferencia de los objetos Towers, que varían su cantidad de pisos?)

class Towers(): #Torres de edificio de x modulos de igual altura + una antena optica
    def __init__(self, modulos, altura_modulo, altura_antena):
        self.modulos = modulos
        self.altura_modulo = altura_modulo
        self.altura_antena = altura_antena

    def altura_total (self):
        return (self.modulos * self.altura_modulo) + self.altura_antena


class Dos_pisos(Towers): # casas de dos modulos de igual altura, sin antena optica 

    def __init_subclass__(self, modulos, altura_modulo):
        super().__init__(modulos, altura_modulo, altura_modulo)  # en vez del valor de una antena le paso el valor del segundo piso



torre = Towers(5, 100, 30) #en metros
print('La altura de la torre con la antena incluída es: ',torre.altura_total())

casa = Dos_pisos(2,5,5)
print('La altura total de la casa es: ',casa.altura_total())

Para saber de quien está heredando una clase específica se usa:

Cuadrado.__bases__

Para saber quienes están heredando a partir de una clase específica

Rectangulo.__subclasses__()

Mi aporte, tienes que ingresar una cantidad y te dice cuanto esquivale en tu moneda local, lo hice para soles peruanos y pesos mexicanos:

class TipodeCambio:
    def __init__(self, moneda, cantidad, valor_cambio=4.09):
        self.__moneda = moneda
        self.__cantidad = cantidad
        self.__valor_cambio = valor_cambio

    def monto(self):
        return (f'{self.__cantidad} dolares, equivale a {self.__cantidad * self.__valor_cambio} {self.__moneda}')

class Soles(TipodeCambio):
    def __init__(self, moneda, cantidad):
        super().__init__(moneda, cantidad)

class Pesos(TipodeCambio):
    def __init__(self, moneda, cantidad, valor_cambio=20.7):
        super().__init__(moneda, cantidad, valor_cambio=valor_cambio)

if __name__ == "__main__":
    soles = Soles(moneda = "Soles", cantidad=200)
    print(soles.monto())

    pesos_mexicanos = Pesos(moneda = "Pesos mexicanos",cantidad=100)
    print(pesos_mexicanos.monto())

Yo realicé 1 clase padre llamada persona que contiene nombre, edad y profesion
2 clases hijas
una clase “Signos” que registra los signos vitales de la persona
otra clase “cuenta” que regisra la cuenta bancaria de la persona

class Signos(Persona):

    def __init__(self,nombre,edad,profesion,temp=37,fc=70):
        super().__init__(nombre,edad,profesion)
        self._temp = temp
        self._fc = fc

    @property
    def temp(self):
        if self._temp <= 34:
            print(f'El paciente {self.nombre} tiene hipotermia, tome medidas necesarias\nTemperatura:{self._temp} \n\n')
            return self._temp
        elif self._temp >= 40:
            print('El paciente {self.nombre} tiene Fiebre, tome medidas necesarias\nTemperatura:{self._temp}\n\n')
            return self._temp
        else:
            print('El paciente {self.nombre} tiene una temperatura estable')
            return self._temp

    @temp.setter
    def temp(self,value):
        if value <= 34:
            print(f'El paciente {self.nombre} tiene hipotermia, tome medidas necesarias')
            self._temp = value
        elif value >= 40:
            print(f'El paciente {self.nombre} tiene Fiebre, tome medidas necesarias')
            self._temp = value
        else:
            print(f'El paciente {self.nombre} tiene una temperatura estable')
            self._temp = value

    @property
    def fc(self):
        if self._fc <= 50:
            print(f'El paciente {self.nombre} está hipocardico, tome medidas necesarias\nfrecuencia cardica:{self._fc}\n\n')
            return self._fc
        elif self._fc >= 120:
            print(f'El paciente {self.nombre} está taquicardico, tome medidas necesarias')
            return self._fc
        else:
            print(f'El paciente {self.nombre} tiene una frecuencia cardiaca estable')
            return self._fc

    @fc.setter
    def fc(self,value):
        if value <= 50:
            self._fc = value
            print(f'El paciente {self.nombre} está hipocardico, tome medidas necesarias\nfrecuencia cardica:{self._fc}')
        elif value >= 120:
            print(f'El paciente {self.nombre} está taquicardico, tome medidas necesarias')
            self._fc = value
        else:
            print(f'El paciente {self.nombre} tiene una frecuencia cardiaca estable')
            self._fc = value

class Cuenta(Persona):

    def __init__(self, nombre, edad, profesion,cuenta,cant) -> None:
        super().__init__(nombre, edad, profesion)
        self._cuenta = cuenta
        self._cant = cant

    @property
    def cuenta(self):
        print(f'El numero de cuenta de {self.nombre} es {self._cuenta}')
        return self._cuenta

    @cuenta.setter
    def cuenta(self, value):
        self._cuenta = value

    @property
    def cant(self):
        print(f'La cuenta numero {self._cuenta} tiene un total de {self._cant}')
        return self._cant

    @cant.setter
    def cant(self, value):
        self._cant += value
        print(f'La cuenta numero {self._cuenta} ahora tiene {self._cant}')


if __name__=='__main__':
    p1 = Persona('Sergio Mora',25,'Carpintero')
    pac1 = Signos(p1.nombre,p1.edad,p1.profesion,34,40)
    pac1.fc
    pac1.temp
    pac1.temp = 38
    pac1.fc = 65
    c1 =  Cuenta(p1.nombre,p1.edad,p1.profesion,'1111 7057 4207',452300)
    c1.cant
    c1.cant = -132700 

Elegir cantidad de puestos de un taxi que hereda de una clase Cars.

class Cars:
    def __init__(self, height, color, puestos):
        self.height  = height
        self.color   = color
        self.puestos = puestos

    def descripcion(self):
        description = "El vehículo es de tamaño {}, es de color {} y tiene {} puestos.".format(self.height, self.color, self.puestos)
        return description
    

class Taxi(Cars):
    def __init__(self, puestos):
        super().__init__('Mediano', 'Amarillo', puestos)
        

if __name__ == '__main__':
    carrito = Taxi(4)
    print(carrito.descripcion())

super() Es una funcion que nos permite obtener una referencia directa de una superclase, nnos permite llamar a su constructor Al inicializar una sublase debemos iniciañizar su constructor

super() Es una funcion que nos permite obtener una referencia directa de una superclase, nnos permite llamar a su constructor Al inicializar una sublase debemos iniciañizar su constructor

class Persona():
def init(self, nombre, edad, ciudad):

    self.nombre=nombre
    self.edad=edad
    self.ciudad=ciudad

def descripcion(self):
    print(f"\nNombre: {self.nombre}\nEdad: {self.edad}\nCiudad: {self.ciudad}")

class Empleado(Persona):

def __init__(self, salario, antiguedad, nombre_empleado, edad_empleado, ciudad_empleado):

    super().__init__(nombre_empleado, edad_empleado, ciudad_empleado)   
                                                                     
    self.salario=salario                                                
    self.antiguo=antiguedad

def descripcion(self):

    super().descripcion() #completa o añade instrucciones a un metodo de la clase padre

    print(f"Salario: {self.salario}\nAntiguedad: {self.antiguo}\n")

pedir_nombre_1=input("Introduzca el nombre: ")

while True:
try:
pedir_edad_1=int(input("ingrese su edad: "))
break
except ValueError:
print(“Ingrese una edad valida”)

pedir_ciudad_1=input("Digite la ciudad: ")

Persona_1=Persona(pedir_nombre_1, pedir_edad_1, pedir_ciudad_1)

Persona_1.descripcion()

Persona_2=Empleado(1500, 3, “Herman”, 22, “Bogotá”) #La clase empleado tiene dos parametros y la clase padre Persona tiene 3 parametros

Persona_2.descripcion()

Aquí mi humilse aporte, nótese que me gusta Gears of War

class Player():
    def __init__(self, nombre, status_vida, arma):
        self.nombre = nombre
        self.status_vida = status_vida
        self.arma = arma
    
    
    def disparar(self):
        print(f'{self.nombre} - Health: {self.status_vida} - Disparando {self.arma}')
    
    def correr(self):
        print(f'{self.nombre} - Health: {self.status_vida} -  Corriendo')


class Soldado_COG(Player):
    def __init__(self,  nombre, status_vida, arma):
        super(Soldado_COG, self).__init__(nombre, status_vida, arma)
    
    def Usar_Motocierra(self):
        print(f'{Marcus_Phoenix.nombre} - Health: {self.status_vida} -  Usando Motosierra')

class Locust(Player):
    def __init__(self, nombre, status_vida, arma):
        super(Locust, self).__init__(nombre, status_vida, arma)
    
    def Grito_Aturdidor(self):
        print(f'{Kantus.nombre} - Health: {self.status_vida} -  Lanzando grito aturdidor')
        

if __name__ == '__main__':
    Marcus_Phoenix = Soldado_COG('Marcus Phoenix', 'Vivo', 'Lancer')
    Kantus = Locust('Kantus', 'Vivo', 'Hummerbust')

Marcus_Phoenix.correr()
Kantus.correr()
Marcus_Phoenix.disparar()
Kantus.disparar()
Kantus.Grito_Aturdidor()
Marcus_Phoenix.Usar_Motocierra()
Kantus.status_vida = 'Muerto'
print(f'{Marcus_Phoenix.nombre} {Marcus_Phoenix.status_vida}')
print(f'{Kantus.nombre} {Kantus.status_vida}')    
class Rectangulo:

    def __init__(self, base, altura):
        self.base = base
        self.altura = altura

    def area(self):
        return self.base * self.altura

class Cuadrado(Rectangulo):

    def __init__(self, lado):
        super().__init__(lado, lado)


if __name__ == '__main__':
    rectangulo = Rectangulo(base=3, altura=4)
    print(rectangulo.area())

    cuadrado = Cuadrado(lado=5)
    print(cuadrado.area())

Dentro de la programación orientada a objetos, las clases son un pilar fundamental. Una clase es la descripción de un conjunto de objetos similares; consta de métodos y de datos que resumen las características comunes de dicho conjunto. … … Cada objeto creado a partir de la clase se denomina instancia de la clase.

La programación estructurada es un paradigma de programación basado en utilizar funciones o subrutinas, y únicamente tres estructuras de control: secuencia: ejecución de una sentencia tras otra. selección o condicional: ejecución de una sentencia o conjunto de sentencias, según el valor de una variable booleana.

Buenos días, tomando en cuenta la lección de herencia con Python; he hecho un código a modo de ejemplo, la organización política de Europa, el único lío que tengo es tratar de segregar a los países que NO son de la Eurozona

class Europe:
    def __init__(self,nameCountry,habitants,HDI,currency):
        self.nameCountry = nameCountry
        self.habitants = habitants
        self.HDI = HDI
        self.currency = currency

class europeanUnion(Europe):
    def __init__(self, nameCountry,habitants,HDI,currency,belongsEU,belongsEurozone):
        super().__init__(nameCountry,habitants,HDI,currency)
        self.belongsEU = belongsEU
        self.belongsEurozone = belongsEurozone


class CEI(Europe):
    def __init__(self, nameCountry, habitants, HDI, currency, belongsCEI, belongsFormerUSSR):
         super().__init__(nameCountry,habitants,HDI,currency)
         self.belongsCEI = belongsCEI
         self.belongsFormerUSSR


if __name__ == '__main__':

    print("1.  Unión Europea")
    print("2.  Comunidad de estados independientes (exURSS)")
    print("3.  Salir del programa")
    opcion =  int(input("Seleccione que tipo de organización pertenece a un estado europeo: "))
    
    if (opcion == 1):
        randomEU = europeanUnion("Germany",83190656,0.947,'Euro','yes','yes')

        randomEU.nameCountry = input("Ingrese el nombre del pais: ")
        randomEU.habitants   = int(input("Ingrese los habitantes del pais: "))
        randomEU.HDI         = float(input("Ingrese su IDH: "))
        randomEU.currency    = input("Ingrese la moneda: ")          

    elif (opcion == 2):
        pass
    elif (opcion == 3):
        print("Fin del programa")
    

Una puede ser:

Celulares que heredan de Aparatos Electrónicos los cuales comparten métodos como:

  • consumir_energia()

Conozcan los productos derivados del Máiz en Méxoco, al mismo tiempo que entendemos las clases, les dejo mi codigo que creo que tiene muchas mejoras, acepto comentarios jeje ❤️

class Maiz:
    def __init__(self, elotes=1):
        self.elotes = elotes
    
    def cosechar(self):
        if self.elotes == 0:
            return print("El alimento de ganado es la milpa de máiz ya sin elote, aquí tienes")
        else:
            return self.elotes
    
class Elote(Maiz):

    def __init__(self):
        super().__init__()

    def derivar(self, deseo):
        if deseo == "nixtamal":
            return Granos(2)
        elif deseo == "huitlacoche":
            return Huitlacoche(10)
        elif deseo == "granos":
            proceso = int(input(f"""
            Deseas elote cocido o molido?

            1- cocido
            2- Molido
            """))
            return Granos(proceso)
        elif deseo == "olote":
            return Olote()
        elif deseo == "harina":
            return Harina()


class Granos():
    def __init__(self,proceso):
        self.proceso = proceso
    
    def procesar(self):
        if self.proceso == 1:
            tamaño = input("¿Vaso grande o chico?")
            esquite = Esquite(tamaño)
            return esquite.servir()
        elif self.proceso == 2:
            return Masa()
        else:
            return print("Desconocemos ese metodo")

class Huitlacoche():
    def __init__(self, cantidad):
        self.cantidad = cantidad
    
    def procesar(self):
        return print(f'Ten {self.cantidad} hongos, listos para comer')

class Masa():
    def __init__(self):
        pass

    def tortillas(self):
        cantidad = int(input("¿Cuánto?"))
        return print(f"Ten {cantidad} tortillas")        
    def tamales(self):
        cantidad = int(input("¿Cuánto?"))
        return print(f"Ten {cantidad} tamales")        
    def gorditas(self):
        cantidad = int(input("¿Cuánto?"))
        return print(f"Ten {cantidad} gorditas")

class Olote(Elote):
    def __init__(self):
        pass
    def procesar(self):
        return print("El olote se usa como alimento de animales, aquí tienes")

class Esquite:
    def __init__(self, tamaño):
        self.tamaño = tamaño

    def servir(self):
        return print(f"Ten tu esquite {self.tamaño}")

class Harina:
    def __init__(self):
        pass
    def procesar(self):
        return print("Ten tu harina de maíz")

def derivados_elote():
    derivado = input("""
    Los productos derivados del elote son muy variados.

    Escribe la opción que deseas (texto):

        1 - Huitlacoche
        2 - Granos
        3 - Olote
        4 - Nixtamal
        5 - Harina
    """)

    elote = Elote()

    print(f" Pediste:{derivado}")

    return elote.derivar(derivado)






def run(opcion):
    if opcion == 1:
        maiz_sin_elote = Maiz(0)
        producto = maiz_sin_elote.cosechar()
        return producto
    else:
        producto = derivados_elote()
        final = producto.procesar()

        if isinstance(final,Masa):
            preparar = int(input("""
            ¿Quieres?

                1- Tortilla
                2- Tamal
                3- Gordita
            
            """))

            if preparar == 1:
                final.tortillas()
            elif preparar == 2:
                final.tamales()
            elif preparar == 3:
                final.gorditas()
            else:
                print("Producto derivado de la masa de granos de Maíz desconocido")


if __name__=="__main__":
    m_prima = int(input("""
    Qué producto deseas derivado del máiz?

    1 - Alimento para ganado
    2 - Elote
    """))
    run(m_prima)

Reto cumplido.
![](

![](

class SerVivo:

    def __init__(self, servivo, anios_vida):
        self.servivo = servivo
        self.anios_vida = anios_vida

    def reproducirse(self):
        return f'{self.servivo} tuvo hijitos.'

    def morir(self):
        return f'{self.servivo} ha muerto despues de {self.anios_vida} anios.'

class Perro(SerVivo):

    def __init__(self, nombre='Perro', anios_vida=20):
        super().__init__(nombre, anios_vida)

class Pollo(SerVivo):

    def __init__(self, nombre='Pollito', anios_vida=5):
        super().__init__(nombre, anios_vida)


if __name__ == '__main__':
    doris = SerVivo('Pescado', 2)
    print(doris.reproducirse())
    print(doris.morir())
    
    chawChaw = Perro()
    print(chawChaw.reproducirse())
    print(chawChaw.morir())

    pollo = Pollo()
    print(pollo.reproducirse())
    print(pollo.morir())

Una instrucción en un partido de futbol puede servir

Creo que un ejemplo que, seguramente, en algún momento tocará abordar es sobre métodos de pago
Un método de pago puede ser la clase padre mientras que de ésta se puede derivar clases como efectivo, tarjeta, paypal, cripto y, a su vez, tarjeta puede ser debito o credito

class equipoDeFutbol:
     def __init__(self,nombre,titulos):
         self.nombre= nombre
         self.titulos=titulos
     def equipoDeLaLigaEspañola(self):
         return  (f'{self.nombre} numero de titulos {self.titulos} ')

class RealMadrid(equipoDeFutbol):

     def __init__(self ,club , campeonatos):
        super().__init__(club ,campeonatos)

if __name__=='__main__':
    equiposdelaliga= equipoDeFutbol(nombre='BARCELONA', titulos=26)
    print(equiposdelaliga.equipoDeLaLigaEspañola())
   
    equipo= RealMadrid(club='REAL MADRID', campeonatos= 34)
    print(equipo.equipoDeLaLigaEspañola())

Hice una clase que se llama Campo de la cual heredan sus atributos y metodos las subclases Futbol y Tennis.

class Campo():
	"""Definicion de clase Deporte"""
	def __init__(self, nombre_deporte, largo, ancho, material):
		self.nombre_deporte = nombre_deporte
		self.largo = largo
		self.ancho = ancho
		self.material = material
	
	def descripcion(self):
		"""Metodo para describir"""
		return (f"Soy un campo de {self.nombre_deporte} y mido {self.largo} de largo y {self.ancho} de ancho y estoy hecho de {self.material}")
	
class Futbol(Campo):
	"""Define la clase Futbol"""
	def __init__(self, nombre_deporte, largo, ancho, material):
		"""Constructor"""
		super().__init__(nombre_deporte, largo, ancho, material)

class Tennis(Campo):
	"""Define la clase Tennis"""
	def __init__(self, nombre_deporte, largo, ancho, material):
		"""Constructor"""
		super().__init__(nombre_deporte, largo, ancho, material)


if __name__ == "__main__":
	campo_tennis = Tennis("Tennis", 23.76, 10.97, "Polvo de ladrillo")
	print(campo_tennis.descripcion())
	campo_futbol = Futbol("Futbol", 110, 75, "césped")
	print(campo_futbol.descripcion())

La clase padre es Telefono

UML

class Phone:
    def __init__(self,number,network,lada,owner,brand):
        self.number=number
        self.network=network
        self.lada=lada
        self.owner=owner
        self.brand=brand
        # ongoing call
        self.status=False

    def call(self,numero):
        if self.status == False:
            self.status = True
            print('calling to ', numero)
        else:
            print('there is an ongoing call')
    
    def endcall(self):
        self.status=False
        print('the call has been ended')

Una clase hijo es telefono de cada

class HomePhone(Phone):
    def __init__(self, number,network,lada,owner,brand,
    RegistroDeLLamadas,Inalambrico):
        super().__init__(number,network,lada,owner,brand)
        self.RegistroDeLLamadas=RegistroDeLLamadas
        self.Inalambrico=Inalambrico

    def ConsultarRegistroDeLlamadas(self):
        print('consultando registro de llamadas')
        for i in self.RegistroDeLLamadas:
            print('llamada del numero: ', i)

Otra clase hijo es smartphone (en esta clase implemente un decorador)

class SmartPhone(Phone):
    def __init__(self, number,network,lada,owner,brand,
    camera, DisplayTechnology,KeyBoard,Gama,Connectivity,
    ConnectionStatus=False):
        super().__init__(number,network,lada,owner,brand)
        self.camera= camera
        self.DisplayTechnology= DisplayTechnology
        self.KeyBoard= KeyBoard
        self.Gama= Gama
        self.Connectivity = Connectivity
        self.ConnectionStatus = ConnectionStatus
        
    
    def SendMessage(self,number):
        print('Sending a message to: ', number)

    def ConnectToWIFINetwork(self,SSID):
        if self.ConnectionStatus == False:
            self.ConnectionStatus=True
            print('connecting to ', SSID)
        else:
            print('you are already connected to: ',SSID)

    def DisconnectWIFINetwork(self):
        if self.ConnectionStatus == True:
            self.ConnectionStatus=False
            print('disconnecting  ')
        else:
            print('You are not connected to any wifi network')
    
    @property
    def DescriptionCamera(self):
        for key in self.camera:
            print(key, ' ', self.camera[key])

    @DescriptionCamera.setter
    def Description(self,camera):
        self.camera=camera```

Funcion principal



if name == ‘main’:

# Begining the Instance of the object called homephone
homephone=HomePhone(24123451212,'',222,'Carolina','Toshiba',
[241234,12341314,312413122],True)
#Checking the call log
homephone.CheckCallLog()

####################################
### Methods from the father class###
####################################
# calling to the number 3123411235
homephone.call(3123411235)
# trying to call but it returns a message because the phone is on an ongoing call
homephone.call(5123411235)
# end the call
homephone.endcall()

# Now the phone can make a phonecall
homephone.call(3123411235)



motog8plus=SmartPhone(1498314091,'4g',2121,'Armand',
'Motorola',{'Front Camera Hardware':'16MP', 'Front Camera Video Capture':'FHD (30 fps)'}
,{'Display Size':'6.8" Max Vision display','Display Technology':'IPS',
'Resolution':'HD+ (720x1640) | 264 ppi'},'Touch','High',{'Networks + Bands':
'LATAM 4G: LTE band 1/2/3/4/5/7/28/66 | 3G: WCDMA band 1/2/4/5/8 | 2G: GSM band 2/3/5/'})

motog8plus.ConnectToWIFINetwork('red_trabajo')

####################################
### Methods from the super class###
####################################

motog8plus.call(2341934491)
motog8plus.call(2341934491)
motog8plus.endcall()

####################################
### Methods from the child class###
####################################
motog8plus.ConnectToWIFINetwork('red_trabajo')
motog8plus.DisconnectWIFINetwork()

##############################################
### Applying decorators by using @property ###
##############################################
motog8plus.Description```