Programación orientada a objetos

Como muchos saben Python es un lenguaje multiparadigma; Esto quiere decir que podemos realizar con el mismo lenguaje programación estructurada, programación orientada a objetos y programación funcional.

Hasta el momento en el blog solo he usado programación estructurada ya que es mas fácil para realizar programas sencillos como los que he hecho hasta el momento pero me parece oportuno comenzar a practicar la programación orientada a objetos ó OOP por sus siglas en ingles.

Que mejor para desempolvar mis conocimientos sobre el tema que leyendo esta conversación que encontré en un blog muy interesante.

En la programación orientada a objetos, todo se reduce, como su nombre lo indica, a los objetos y sus relaciones entre ellos.

Los objetos tal como en el mundo real pueden ser, por ejemplo, una lampara, un carro, un perro. En la conversación hacen el ejemplo con un radio.

Un radio tiene, entre otras cosas, algo que permite seleccionar la emisora o frecuencia y algo para modificar el volumen, estas son las propiedades del objeto las cuales básicamente lo definen. Podríamos incluir otras propiedades como el ancho y el alto del radio o el color, la marca, y muchas mas; Pero para este ejemplo esas son las propiedades que nos interesan.

las propiedades tienen un valor. La frecuencia podría ser 97.9, el volumen = 50, el ancho=20 y así con todas las propiedades.

Cuando nosotros cambiamos la frecuencia de un radio o subimos el volumen, normalmente no estamos interesados en lo que ocurre al interior del objeto. Solo nos interesa saber que si presionamos un botón alguna acción va a ocurrir.

Los botones de subir y bajar volumen, o el de modificar la emisora podemos llamarlos como los métodos del objeto. Los métodos son el algo que realiza una tarea sobre el objeto, como modificar sus propiedades. Por ejemplo, Un método del objeto radio podría ser "subir volumen" y lo que hace es modificar la propiedad "volumen".

Los objetos son definidos por medio de clases, Las clases vienen siendo como una plantilla de objetos. Es decir, que si yo tengo la clase radio con sus atributos y métodos  puedo crear las radios que quiera con las mismas características.

Vamos a crear nuestra clase radio

class Radio:
        def __init__(self):
                self.volumen = 10
                self.frecuencia = 90 

Con esas lineas creamos la clase llamada Radio.

__init__  es un método especial. Este se ejecuta cuando se crea un objeto nuevo. Quiere decir que cuando creemos un objeto desde la clase radio, lo primero que se ejecuta va a ser el método __init__ el cual, a su vez, crea unos atributos llamados volumen y frecuencia y les asigna un valor.

Ahora vamos a crear un objeto. Ponemos el siguiente código:

class Radio:
        def __init__(self):
                self.volumen = 10
                self.frecuencia = 90 

mi_radio = Radio()
print mi_radio.volumen

Lo que hicimos fue crear el objeto mi_radio e imprimir el atributo volumen de ese objeto. Como en la clase radio le asigne un valor por defecto a volumen, muy seguramente la salida sera:

>> 10

También podría modificar las propiedades de mi objeto. Por ejemplo:

class Radio:
        def __init__(self):
                self.volumen = 10
                self.frecuencia = 90 
mi_radio = Radio()
mi_radio.volumen=45
mi_radio.frecuencia=97.9
print mi_radio.volumen
print mi_radio.frecuencia

y mi salida sera:

>> 45
>> 97.9

En esta caso modificamos las propiedades del objeto pero no tiene sentido modificar el código para modificar un atributo de un objeto. Lo correcto seria crear nuestro primer método que haces las veces de "botón" de nuestro radio. Así que vamos a crear un método que suba el volumen el cual quedaría de la siguiente manera:

class Radio:
        def __init__(self):
                self.volumen = 10
                self.frecuencia = 90 
        def subir_volumen(self):
                self.volumen +=1
mi_radio = Radio()
print mi_radio.volumen
mi_radio.subir_volumen()
print mi_radio.volumen

Esto nos daría como salida:

>> 10
>> 11

Lo cual es justo lo que queríamos  En vez de modificar directamente las propiedades, creamos un método que lo hiciera por nosotros.

Si quisiera elegir el volumen y la frecuencia (atributos) al momento de crear mi objeto, mi código seria el siguiente.

class Radio:
        def __init__(self,vol,frec):
                self.volumen = vol
                self.frecuencia = frec
        def subir_volumen(self):
                self.volumen +=1
mi_radio = Radio(20,94.9)
print mi_radio.volumen
print mi_radio.frecuencia

Mi salida seria:

>> 20
>> 94.9

Es bastante obvio que en el método __init__ le digo que al momento de crear un objeto Radio le tengo que pasar 2 argumentos tal como hice. Pero si al momento de crear el objeto no le pongo atributos daría un error, por lo que es conveniente ponerle unos valores por defecto a los atributos de la siguiente manera:

class Radio:
        def __init__(self,vol=10,frec=97.9):
                self.volumen = vol
                self.frecuencia = frec
        def subir_volumen(self):
                self.volumen +=1
mi_radio = Radio()
print mi_radio.volumen
print mi_radio.frecuencia

como no asigne nada a mi_radio = Radio() la salida sera

>> 10
>> 97.9

porque las asigne por defecto en la clase. También podría solo haber pasado un argumento así:

mi_radio = Radio(50)

y mi salida seria

>> 50
>> 97.9

Si quisiera solo asignar la frecuencia y dejar el volumen por defecto tendría que especificar el nombre del atributo

mi_radio = Radio(frec=104.9)

y la salida seria:

>> 10
>> 104.9

Ahora como ejercicio voy a modificar la clase Radio de tal manera que el método subir_volumen me permita escoger cuanto quiero subir y si no le digo cuanto, me suba 1.

class Radio:
        def __init__(self,vol=10,frec=97.9):
              self.volumen = vol
              self.frecuencia = frec
        def subir_volumen(self,aumento=1):
                self.volumen +=aumento
mi_radio = Radio()
mi_radio.subir_volumen(10)
print mi_radio.volumen

salida:
>> 20


Ahora vamos a observar otro método especial llamado __str__.
Si hacemos la prueba de imprimir un objeto por medio del siguiente código:

class Radio:
        def __init__(self,vol=10,frec=97.9):
              self.volumen = vol
              self.frecuencia = frec
        def subir_volumen(self,aumento=1):
                self.volumen +=aumento
mi_radio = Radio()
print mi_radio

nos va a salir esto:

>> <__main__.Radio instance at 0x011F4940>

Esto nos dice que "mi_radio" es una instanciación de la clase Radio.
Mediante el método __str__ podemos indicar que queremos mostrar en el momento que se le haga un print al objeto mi_radio o a cualquier instancia de la clase Radio.

Voy a poner el mismo ejemplo de la conversación:

class Radio:
        def __init__(self,vol=10,frec=97.9):
                self.volumen = vol
                self.frecuencia = frec
        def subir_volumen(self,aumento=1):
                self.volumen +=aumento
        def __str__(self):
                return "Volumen: " + str(self.volumen) + "\nFrecuencia: " + str(self.frecuencia)
mi_radio = Radio()
print mi_radio

Mi salida sera

>>Volumen: 10
>>Frecuencia: 97.9

____________________________________________________________

Vamos a practicar un poco. Voy a realizar una clase que me permita crear un punto con sus correspondientes coordenadas X y Y, si no le paso argumentos al momento de crear el objeto que me de un punto en (0,0). Ademas crear un método __str__ que me muestre las coordenadas del punto.

Codigo:

class punto:
    def __init__(self,x=0,y=0):
        self.x=x
        self.y=y
        
    def __str__(self):
        return '('+str(self.x)+','+str(self.y)+')'
    
a=punto(4,3)
print a

Ahora voy le voy a agregar un método que me sume otro punto a mi punto existente.

Codigo:

class punto:
    def __init__(self,x=0,y=0):
        self.x=x
        self.y=y
        
    def __str__(self):
        return '('+str(self.x)+','+str(self.y)+')'

    
    def sumarpuntos(self,b): 
        return punto(self.x+b.x,self.y+b.y)
        
    
a=punto(4,3)
b=punto(5,7)
c=a.sumarpuntos(b)

print c

Podría realizarlo de otra manera usando un método especial llamado __add__

Codigo:

class Punto:
    def __init__(self,x=0,y=0):
        self.x=x
        self.y=y
        
    def __str__(self):
        return '('+str(self.x)+','+str(self.y)+')'

    
    def __add__(self,b): 
        return Punto(self.x+b.x,self.y+b.y)
        
a=Punto(4,3)
b=Punto(5,7)
c=a+b
print c

Podría extender el código con una resta usando el método especial __sub__ de la misma manera que uso el __add__

El siguiente y ultimo ejemplo es crear un método que calcule la distancia entre dos puntos

Codigo:

import math
class Punto:
    def __init__(self,x=0,y=0):
        self.x=x
        self.y=y
        
    def __str__(self):
        return '('+str(self.x)+','+str(self.y)+')'

    
    def __add__(self,b): 
        return Punto(self.x+b.x,self.y+b.y)
    
    def distancia(self,b):
        c=(b.x-self.x,b.y-self.y)
        c=(c[0]**2)+(c[1]**2)
        c=math.sqrt(c)
        return c
    
a=Punto(4,8)
b=Punto(5,7)
c=a.distancia(b)