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.
Programación Orientada a Objetos
Lo que aprenderás sobre programación orientada a objetos y algoritmos con Python
Programación Orientada a Objetos
Tipos de datos abstractos y clases, Instancias
Decomposición
Abstracción
Funciones: base de los decoradores
Setters, getters y decorador property
Encapsulación, getters and setters
Herencia
Polimorfismo
Complejidad algorítmica
Introducción a la complejidad algorítmica
Conteo abstracto de operación
Notación asintótica
Clases de complejidad algorítmica
Algoritmos de búsqueda y ordenación
Búsqueda lineal
Búsqueda binaria
Ordenamiento de burbuja
Ordenamiento por inserción
Ordenamiento por mezcla
Ambientes virtuales
Ambientes virtuales
Graficado
¿Por qué graficar?
Graficado simple
Algoritmos de optimización
Introducción a la optimización
El problema del morral
Conclusiones
Aún no tienes acceso a esta clase
Crea una cuenta y continúa viendo este curso
Crear cuenta
Si ya tienes una cuenta,
Iniciar sesión
Herencia
9/25Recursos
Aportes 411
Preguntas 32
Ordenar por:
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:
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:
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
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```
¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.