La programación orientada a objetos se basa en la definición de clases; a diferencia de la programación estructurada, que está centrada en las funciones.
Una clase es un molde del que luego se pueden crear múltiples objetos, con similares características.
Un poco más abajo se define una clase Persona y luego se crean dos objetos de dicha clase.
Una clase es una plantilla (molde), que define atributos (lo que conocemos como variables) y métodos (lo que conocemos como funciones).
La clase define los atributos y métodos comunes a los objetos de ese tipo, pero luego, cada objeto tendrá sus propios valores y compartirán las mismas funciones.
Debemos declarar una clase antes de poder crear objetos (instancias) de esa clase. Al crear un objeto de una clase, se dice que se crea una instancia de la clase o un objeto propiamente dicho.
Implementaremos una clase llamada Persona que tendrá como atributo (variable) su nombre y dos métodos (funciones), uno de dichos métodos inicializará el atributo nombre y el siguiente método mostrará en la pantalla el contenido del mismo.
Definir dos objetos de la clase Persona.
class Persona:
def inicializar(self,nom):
self.nombre=nom
def imprimir(self):
print("Nombre",self.nombre)
# bloque principal
persona1=Persona()
persona1.inicializar("Pedro")
persona1.imprimir()
persona2=Persona()
persona2.inicializar("Carla")
persona2.imprimir()
Siempre conviene buscar un nombre de clase lo más próximo a lo que representa. La palabra clave para declarar la clase es class, seguidamente el nombre de la clase y luego dos puntos.
Los métodos de una clase se definen utilizando la misma sintaxis que para la definición de funciones.
Como veremos todo método tiene como primer parámetro el identificador self que tiene la referencia del objeto que llamó al método.
Luego dentro del método diferenciamos los atributos del objeto antecediendo el identificador self:
self.nombre=nom
Con la asignación previa almacenamos en el atributo nombre el parámetro nom, los atributos siguen existiendo cuando finaliza la ejecución del método. Por ello cuando se ejecuta el método imprimir podemos mostrar el nombre que cargamos en el primer método.
Decíamos que una clase es un molde que nos permite definir objetos. Ahora veamos cual es la sintaxis para la creación de objetos de la clase Persona:
# bloque principal
persona1=Persona()
persona1.inicializar("Pedro")
persona1.imprimir()
persona2=Persona()
persona2.inicializar("Carla")
persona2.imprimir()
Definimos un objeto llamado persona1 y lo creamos asignándole el nombre de la clase con paréntesis abierto y cerrado al final (como cuando llamamos a una función)
Luego para llamar a los métodos debemos disponer luego del nombre del objeto el operador . y por último el nombre del método (función)
En el caso que tenga parámetros se los enviamos (salvo el primer parámetro (self) que el mismo Python se encarga de enviar la referencia del objeto que se creó):
persona1.inicializar("Pedro")
También podemos definir tantos objetos de la clase Persona como sean necesarios para nuestro algoritmo:
persona2=Persona()
persona2.inicializar("Carla")
persona2.imprimir()
La declaración de clases es una de las ventajas fundamentales de la Programación Orientada a Objetos (POO), es decir reutilización de código (gracias a que está encapsulada en clases) es muy sencilla.
Implementar una clase llamada Alumno que tenga como atributos su nombre y su nota. Definir los métodos para inicializar sus atributos, imprimirlos y mostrar un mensaje si está regular (nota mayor o igual a 4)
Definir dos objetos de la clase Alumno.
class Alumno:
def inicializar(self,nombre,nota):
self.nombre=nombre
self.nota=nota
def imprimir(self):
print("Nombre:",self.nombre)
print("Nota:",self.nota)
def mostrar_estado(self):
if self.nota>=4:
print("Regular")
else:
print("Libre")
# bloque principal
alumno1=Alumno()
alumno1.inicializar("diego",2)
alumno1.imprimir()
alumno1.mostrar_estado()
alumno2=Alumno()
alumno2.inicializar("ana",10)
alumno2.imprimir()
alumno2.mostrar_estado()
Declaramos la clase Alumno y definimos sus tres métodos, en el método inicializar llegan como parámetros a parte del self el nombre y nota del alumno:
def inicializar(self,nombre,nota):
self.nombre=nombre
self.nota=nota
No hay problema que los atributos se llamen iguales a los parámetros ya que siempre hay que anteceder la palabra "self" al nombre del atributo:
self.nombre=nombre
Tener en cuenta que cuando se crean los atributos en el método inicializar luego podemos acceder a los mismos en los otros métodos de la clase, por ejemplo en el método mostrar_estado verificamos el valor almacenado en el atributo nota:
def mostrar_estado(self):
if self.nota>=4:
print("Regular")
else:
print("Libre")
Decimos que una clase es un molde que nos permite crear luego objetos de dicha clase, en este problema el molde Alumno lo utilizamos para crear dos objetos de dicha clase:
# bloque principal
alumno1=Alumno()
alumno1.inicializar("diego",2)
alumno1.imprimir()
alumno1.mostrar_estado()
alumno2=Alumno()
alumno2.inicializar("ana",10)
alumno2.imprimir()
alumno2.mostrar_estado()
Es fundamental la definición de objetos de una clase para que haya tenido sentido la declaración de dicha clase.
ejercicio188.py
class Persona:
def inicializar(self,nombre,edad):
self.nombre=nombre
self.edad=edad
def imprimir(self):
print("Nombre",self.nombre)
print("Edad",self.edad)
def mayor_edad(self):
if self.edad>=18:
print("Es mayor de edad")
else:
print("No es mayor de edad")
# bloque principal
persona1=Persona()
persona1.inicializar("diego",40)
persona1.imprimir()
persona1.mayor_edad()
ejercicio189.py
class Triangulo:
def inicializar(self):
self.lado1=int(input("Ingrese primer lado:"))
self.lado2=int(input("Ingrese segundo lado:"))
self.lado3=int(input("Ingrese tercer lado:"))
def imprimir(self):
print("Valores de los lados del triangulo")
print("Lado 1",self.lado1)
print("Lado 2",self.lado2)
print("Lado 3",self.lado3)
def lado_mayor(self):
print("Lado mayor")
if self.lado1>self.lado2 and self.lado1>self.lado3:
print(self.lado1)
else:
if self.lado2>self.lado3:
print(self.lado2)
else:
print(self.lado3)
def es_equilatero(self):
if self.lado1==self.lado2 and self.lado1==self.lado3:
print("El triangulo es equilatero")
else:
print("El triangulo no es equilatero")
# bloque principal
triangulo1=Triangulo()
triangulo1.inicializar()
triangulo1.imprimir()
triangulo1.lado_mayor()
triangulo1.es_equilatero()