Python como POO (Ptos Extra)

Python es totalmente copatible para la creacion de programas orientado a objetos, ya que nosotros podemos definir nuestras propias clases, heredarlas, e hacer instancias de clases que hayamos definido.


En Python las clases se definen con la palabra reservada class despues ponemos el nombre de la clase, luego dos puntos y ponemos el cuerpo de la clase, llamado tambien indentado.


Ejemplo:

class Ejemplo     #1
   pass           #2

En este ejemplo el nombre de la clase es Ejemplo, no hereda otra clase, si se fijan las clases inician con Mayúscula al igual que java.
Esta clase no se le definen atributos pero no puede estar sin nada por lo tanto ponemos la funcion pass, equivalente en otros lenguajes como C, usar {}


El metodo __init__

import math
class Complejo:
      def __init__(self, real, imaginario):
          self.real = real
          self.img = imaginario
      def abs(self):
          print math.sqrt((self.real * self real) + (self.img * self.img))

Las clases de python tienen algo semejante a un contructor: el metodo __init__, se llama luego de crear una instancia de la clase.
No se le puede llamar completamente un costructor ya que, actua como uno, pero el objeto ya se ha construido cuando se llama este metodo y ya tiene una referencia valida a la nueva instancia de la clase. es lo mas parecido a un contructor en python.


La primera variable de cada metodo es siempre la referencia a la instancia actual de la clase.
Por reglas del lenguaje, se le llama self, en el metodo __init__, self hace referencia al objeto que recien se creo, en otros metodos se refiere a la instancia cuyo metodo ha sido llamado.


Los metodos __init__ puede tomar cantidades de argumentos tambien se pueden definir con valores de defecto.


self es como si fuera la palabra reservada this en c++ o java, pero en python no es una palabra reservada, sino una convencion, esta no se especifica al invocar el metodo ya que Python lo agrega automaticamente.


Para crear un objeto en python, lo que se necesita es invocar a la clase como si fuera una funcion, con los argumentos que defina el metodo __init__ y el valor que retornara sera el objeto que recien se creo.

import math
class Complejo:
      def __init__(self, real, imaginario):
          self.real = real
          self.img = imaginario
      def abs(self):
          print math.sqrt((self.real * self real) + (self.img * self.img))

def main():
      numero = comlejo(3,4) 
      numero.abs()

if __name__ == '__main__':
     main()

En la linea 10, se crea el objeto y se inicializa haciendo el llamado al metodo __init__ pasando con los valores real=3 e imaginario =4
En la linea 11, convocamos el metod abs de la clase Complejo.


Borrado
Es importante decir que los objetos se borran automaticamente sin necesidad de liberar de forma explicita en las instancias, ya que cuando las variables a las que se asignan salen del codigo.


Operadores
Cuando utilizamos muchos operadores podemos usarlos como clases definidas, reutilizando el mismo operador pero con numeros diferentes, Python decide como usar el operador.

• __add__(self,other)
• __sub__(self,other)
• __mul__(self,other)
• __floordiv__(self,other)
• __mod__(self,other)
• __divmod__(self,other)
• __pow__(self,other)
• __and__(self,other)
• __xor__(self,other)
• __or__(self,other)

Ejemplo con el código anterior:

import math
class Complejo:
      def __init__(self, real, imaginario):
          self.real = real
          self.img = imaginario
      def abs(self):
          print math.sqrt((self.real * self real) + (self.img * self.img))
      def __add__(self, otro):
          print complejo(self.real + otro.real, self.img + otro.img)
      def __sub__(self, otro):
          print complejo(self.real + otro.real, self.img + otro.img)
      def mostrar(self):
          print self.real
          print self.img

def main():
      complejo1 = complejo(3,4)
      complejo2 = complejo(3,4)
      complejo3 = complejo1 + complejo2
      complejo4 = complejo1 - complejo2
      complejo3.mostrar()
      complejo4.mostrar()

if __name__ == '__main__':
     main()

Herencia

• principal propiedad de las clases.
• Nos permite crear nuevas clases apartir de existentes.
• Conserva las propiedades de la clase original añadiendo nuevas.

Ejemplo de Python con clases heredadas.

class Animal:
    def __init__(self):
       print "Animal creado"
    def quiensoy(self):
       print "Animal"
    def comer(self):
       print "Estoy comiendo"

class Perro(Animal):
    def __init__(self):
       Animal.__init__(self)
       print "Perro Creado"
    def quiensoy(self):
       print "Perro"
    def ladrar(self):
       print "Woof Woof!"
def main():
     d = Perro()
     d.quiensoy()
     d.comer()
     d.ladrar()

if __name__ == '__main__':
    main()

Referencias
Python para todos, Raul Gonzalez Duque
Aprenda a Pensar como programador de Python, Allen Downey
Diapositivas de Jesse Padilla Agudelo aqui


Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.