PROGRAMACION ORIENTADA
A OBJETOS:
La programación
orientada a objetos (POO) es un paradigma de programación que organiza el
código en torno a objetos, que son instancias de clases, en lugar de centrarse
solo en lógica y funciones. Los objetos combinan datos (atributos) y
comportamiento (métodos), y la POO se basa en los principios de
encapsulamiento, abstracción, herencia y polimorfismo para crear software más
modular, reutilizable y fácil de mantener.
CONCEPTOS CLAVE
Clases y objetos: Una
clase es un plano o modelo que define las características (atributos) y
comportamientos (métodos) de un tipo de objeto, como un "Coche" o un
"Perro". Un objeto es una instancia específica de esa clase, como un "Coche
rojo" o un "Perro llamado Pancho".
Encapsulamiento: Este
principio agrupa los datos y los métodos que operan sobre esos datos dentro de
una única unidad (la clase), protegiendo la información interna de accesos no
autorizados y garantizando que solo se interactúe con el objeto a través de sus
métodos públicos.
Abstracción: Se enfoca
en los aspectos esenciales de un objeto, ocultando los detalles complejos. Por
ejemplo, para usar un coche, no necesitas conocer el funcionamiento interno del
motor, solo los controles básicos como el volante y los pedales.
Herencia: Permite que
una clase (clase hija o subclase) herede los atributos y métodos de otra clase
(clase padre o superclase). Esto promueve la reutilización del código, ya que
la clase hija puede extender o modificar el comportamiento de la clase padre
sin repetirlo.
Polimorfismo:
Significa "muchas formas". Permite que objetos de diferentes clases
respondan al mismo mensaje (llamada a un método) de manera distinta. Por
ejemplo, la acción de "hablar" podría ser diferente para un perro y
un gato, aunque ambos sean objetos de la clase "animal".
Declaración de clases
En el paradigma orientado
a objetos, una clase es una representación de algo en el mundo real. En Python,
el uso de clases es una constante en el desarrollo de programas.
EJEMPLO:
Class Persona():
Creando el constructor de
clase
Una clase se representa
mediante atributos y métodos. Los atributos de una clase representan sus
características, mientras que sus métodos representan su comportamiento.
Declarar un atributo en
una clase en Python es muy sencillo, solo debemos definir el nombre del
atributo en el método especial llamado __init__, este método define el
constructor de la clase, es decir es donde definimos como se creará una nueva
persona en nuestro programa.
Instanciación de objetos
Como vimos anteriormente,
las clases representan la estructura de un elemento en el mundo real, pero son
solo el modelo de estos elementos.
Siempre que necesitamos
crear algo basado en una clase, decimos que estamos "instanciando
objetos". El acto de instanciar un objeto significa que estamos creando la
representación de una clase en nuestro programa.
Declaración de métodos
Como vimos anteriormente,
una clase tiene atributos (que definen sus características) y métodos (que
definen sus comportamientos).
CODIGO
##################################################################
class Persona:
#creamos atributos del objeto persona con
el constructor __init__
def __init__(self, nombre, sexo,
dni,activo):
self.nombre = nombre
self.sexo = sexo
self.dni = dni
self.activo=activo
#metodo desactivar
def desactivar(self):
self.activo=False
print("la persona fue desactivada
del sistema")
if __name__ ==
"__main__":
#instanciado objetos
persona1 = Persona("Jose",
"M", "123457",True)
print(persona1.nombre)
persona1.desactivar()
##################################################################
class rectangulo():
def
__init__(self,base,altura):
self.base =
base
self.altura
=altura
def calcular_area(self):
return self.base *self.altura
def calcular_perimetro(self):
return 2 * (self.base + self.altura)
rec1=rectangulo(5,3)
print(f"area:{rec1.calcular_area()}")
print(f"perimetro{rec1.calcular_perimetro()}")
class Libro:
def
__init__(self,titulo,autor,editorial,anio_publicacion):
self.titulo=titulo
self.autor=autor
self.editorial=editorial
self.anio_publicacion=anio_publicacion
mi_libro=Libro('la comida','don
pedrito','planeta','1994')
print(mi_libro.__dict__)
QUE SIGNIFICA EL CODIGO:
if __name__ ==
"__main__":
en Python es un modismo
común que se utiliza para determinar si el archivo de script se está ejecutando
directamente o si se está importando como un módulo en otro archivo
Propósito y utilidad
El bloque de código que
se encuentra dentro de if __name__ == "__main__": solo se ejecuta
cuando el archivo se ejecuta directamente, y no cuando se importa. Esto es útil
para varios propósitos:
Reusabilidad de código:
Permite que un archivo contenga tanto funciones y clases reutilizables (que
pueden ser importadas por otros scripts) como código ejecutable que solo se
ejecutará cuando el archivo se inicie por sí mismo.
Pruebas unitarias: Es
común colocar el código de prueba dentro de este bloque, para que puedas
ejecutar pruebas al ejecutar el archivo, pero el código no se ejecutará si se
importa el módulo en un programa principal.
Ejemplos de uso: Puedes
incluir un ejemplo de cómo usar las funciones del módulo dentro del bloque if
__name__ == "__main__":
Es decir nos permite que
el código que ejecutamos en el script solo se ejecute ahí y no en otro script
vinculado, asi al importar el script actual no se ejecutara en el script
vinculado si no esta llamada de la función solicitada.
Encapsulamiento:
CODIGO
##################################################################
def __init__(self,nombre,edad):
self._nombre=nombre
self._edad=edad
@property
def
nombre(self):
return self._nombre
@nombre.setter
def nombre(self,nuevo_nombre):
self._nombre=nuevo_nombre
@property
def edad(self):
return self._edad
@edad.setter
def edad(self,nueva_edad):
self._edad=nueva_edad
def mostrar(self):
print(self.__dict__)
def
mayor_edad(self):
if self.edad>=18:
return True
else:
return False
Alumno1 =Alumno('javier',23)
Alumno1.mostrar()
print(Alumno1.mayor_edad())
No hay comentarios.:
Publicar un comentario