En este tutorial, aprenderá sobre la programación orientada a objetos (OOP) en Python y su concepto fundamental con la ayuda de ejemplos.
Video: Programación orientada a objetos en Python
Programación orientada a objetos
Python es un lenguaje de programación de múltiples paradigmas. Es compatible con diferentes enfoques de programación.
Uno de los enfoques populares para resolver un problema de programación es la creación de objetos. Esto se conoce como programación orientada a objetos (OOP).
Un objeto tiene dos características:
- atributos
- comportamiento
Tomemos un ejemplo:
Un loro puede ser un objeto, ya que tiene las siguientes propiedades:
- nombre, edad, color como atributos
- cantar, bailar como comportamiento
El concepto de POO en Python se centra en la creación de código reutilizable. Este concepto también se conoce como DRY (Don't Repeat Yourself).
En Python, el concepto de POO sigue algunos principios básicos:
Clase
Una clase es un plano para el objeto.
Podemos pensar en la clase como un dibujo de un loro con etiquetas. Contiene todos los detalles sobre el nombre, colores, tamaño, etc. Basándonos en estas descripciones, podemos estudiar sobre el loro. Aquí, un loro es un objeto.
El ejemplo de clase de loro puede ser:
clase Parrot: pase
Aquí, usamos la classpalabra clave para definir una clase Parrot vacía. A partir de la clase, construimos instancias. Una instancia es un objeto específico creado a partir de una clase particular.
Objeto
Un objeto (instancia) es una instanciación de una clase. Cuando se define la clase, solo se define la descripción del objeto. Por lo tanto, no se asigna memoria ni almacenamiento.
El ejemplo de objeto de la clase loro puede ser:
obj = Loro ()
Aquí, obj es un objeto de clase Parrot.
Supongamos que tenemos detalles de loros. Ahora, vamos a mostrar cómo construir la clase y los objetos de los loros.
Ejemplo 1: creación de clases y objetos en Python
class Parrot: # class attribute species = "bird" # instance attribute def __init__(self, name, age): self.name = name self.age = age # instantiate the Parrot class blu = Parrot("Blu", 10) woo = Parrot("Woo", 15) # access the class attributes print("Blu is a ()".format(blu.__class__.species)) print("Woo is also a ()".format(woo.__class__.species)) # access the instance attributes print("() is () years old".format( blu.name, blu.age)) print("() is () years old".format( woo.name, woo.age))
Salida
Blu es un pájaro Woo también es un pájaro Blu tiene 10 años Woo tiene 15 años
En el programa anterior, creamos una clase con el nombre Parrot. Luego, definimos atributos. Los atributos son una característica de un objeto.
Estos atributos se definen dentro del __init__método de la clase. Es el método de inicialización que se ejecuta por primera vez tan pronto como se crea el objeto.
Luego, creamos instancias de la clase Parrot. Aquí, blu y woo son referencias (valor) a nuestros nuevos objetos.
Podemos acceder al atributo de clase usando __class__.species. Los atributos de clase son los mismos para todas las instancias de una clase. De manera similar, accedemos a los atributos de la instancia usando blu.namey blu.age. Sin embargo, los atributos de instancia son diferentes para cada instancia de una clase.
Para obtener más información sobre clases y objetos, vaya a Clases y objetos de Python
Métodos
Los métodos son funciones definidas dentro del cuerpo de una clase. Se utilizan para definir los comportamientos de un objeto.
Ejemplo 2: crear métodos en Python
class Parrot: # instance attributes def __init__(self, name, age): self.name = name self.age = age # instance method def sing(self, song): return "() sings ()".format(self.name, song) def dance(self): return "() is now dancing".format(self.name) # instantiate the object blu = Parrot("Blu", 10) # call our instance methods print(blu.sing("'Happy'")) print(blu.dance())
Salida
Blu canta 'Happy' Blu está bailando ahora
En el programa anterior, definimos dos métodos, es decir sing()y dance(). Estos se denominan métodos de instancia porque se llaman en un objeto de instancia, es decir blu.
Herencia
Inheritance is a way of creating a new class for using details of an existing class without modifying it. The newly formed class is a derived class (or child class). Similarly, the existing class is a base class (or parent class).
Example 3: Use of Inheritance in Python
# parent class class Bird: def __init__(self): print("Bird is ready") def whoisThis(self): print("Bird") def swim(self): print("Swim faster") # child class class Penguin(Bird): def __init__(self): # call super() function super().__init__() print("Penguin is ready") def whoisThis(self): print("Penguin") def run(self): print("Run faster") peggy = Penguin() peggy.whoisThis() peggy.swim() peggy.run()
Output
Bird is ready Penguin is ready Penguin Swim faster Run faster
In the above program, we created two classes i.e. Bird (parent class) and Penguin (child class). The child class inherits the functions of parent class. We can see this from the swim() method.
Again, the child class modified the behavior of the parent class. We can see this from the whoisThis() method. Furthermore, we extend the functions of the parent class, by creating a new run() method.
Additionally, we use the super() function inside the __init__() method. This allows us to run the __init__() method of the parent class inside the child class.
Encapsulation
Using OOP in Python, we can restrict access to methods and variables. This prevents data from direct modification which is called encapsulation. In Python, we denote private attributes using underscore as the prefix i.e single _ or double __.
Example 4: Data Encapsulation in Python
class Computer: def __init__(self): self.__maxprice = 900 def sell(self): print("Selling Price: ()".format(self.__maxprice)) def setMaxPrice(self, price): self.__maxprice = price c = Computer() c.sell() # change the price c.__maxprice = 1000 c.sell() # using setter function c.setMaxPrice(1000) c.sell()
Output
Selling Price: 900 Selling Price: 900 Selling Price: 1000
In the above program, we defined a Computer class.
We used __init__() method to store the maximum selling price of Computer. We tried to modify the price. However, we can't change it because Python treats the __maxprice as private attributes.
As shown, to change the value, we have to use a setter function i.e setMaxPrice() which takes price as a parameter.
Polymorphism
Polymorphism is an ability (in OOP) to use a common interface for multiple forms (data types).
Suppose, we need to color a shape, there are multiple shape options (rectangle, square, circle). However we could use the same method to color any shape. This concept is called Polymorphism.
Example 5: Using Polymorphism in Python
class Parrot: def fly(self): print("Parrot can fly") def swim(self): print("Parrot can't swim") class Penguin: def fly(self): print("Penguin can't fly") def swim(self): print("Penguin can swim") # common interface def flying_test(bird): bird.fly() #instantiate objects blu = Parrot() peggy = Penguin() # passing the object flying_test(blu) flying_test(peggy)
Output
Parrot can fly Penguin can't fly
In the above program, we defined two classes Parrot and Penguin. Each of them have a common fly() method. However, their functions are different.
Para usar el polimorfismo, creamos una interfaz común, es decir, una flying_test()función que toma cualquier objeto y llama al fly()método del objeto . Por lo tanto, cuando pasamos los objetos blu y peggy en la flying_test()función, se ejecutó de manera efectiva.
Puntos clave para recordar:
- La programación orientada a objetos hace que el programa sea fácil de entender y eficiente.
- Dado que la clase se puede compartir, el código se puede reutilizar.
- Los datos están seguros y protegidos con la abstracción de datos.
- El polimorfismo permite la misma interfaz para diferentes objetos, por lo que los programadores pueden escribir código eficiente.
