Herencia en python

La herencia es un recurso de los lenguajes de programación para definir una nueva clase de objetos como una extensión de clases previamente definidas. La nueva clase hereda los métodos y propiedades de la clase anterior.
Mediante la herencia podremos tener una mejor especificación de nuestros objetos, partiendo de objetos básicos. Cuanto más básicos sea el objeto más abstracto será. Por este motivo al proceso de subir por el árbol de objetos se lo llama abstracción y al proceso de bajar por el árbol de objetos se lo llama especificación.

                     ---------
                     |persona|
                     ---------
			 |
	     --------------------------
	     |			      |
	 ----------                ---------
         |empleado|                |cliente|
	 ----------                ---------
             |
    -------------------
    |                 |
------------      ---------
|secretaria|      |gerente|
------------      ---------

Python permite hacer esto de forma sencilla. Veamoslo en el archivo herencia.py

#!/usr/bin/python
# Nombre de Fichero : herencia.py
class Persona:
    "Clsase base Persona"
    def __init__(self,pNombre,pEdad):
        self.edad = pEdad
        self.nombre = pNombre
    def getNombre(self):
        return self.nombre
    def getEdad(self):
        return self.edad

class Cliente(Persona):
    "Clase cliente que hereda de Persona"
    pass

class Empleado(Persona):
    "Clase Empleado que hereda de Persona"
    def __init__(self,pNombre,pEdad,pSueldo=500):
        Persona.__init__(self,pNombre,pEdad)
        self.sueldo = pSueldo

    def getSueldo(self):
        return self.sueldo

class Secretaria(Empleado):
    "Clase Secretaria que hereda de Empleado"
    def __init__(self,pNombre,pEdad):
        Empleado.__init__(self,pNombre,pEdad,1000)

class Gerente(Empleado):
    "Clase Gerente que hereda de Empleado"
    def __init__(self,pNombre,pEdad):
        Empleado.__init__(self,pNombre,pEdad,5000)

p = Persona("Pedro",35)
c = Cliente("Sandra",27)
g = Gerente("Santiago",53)
s = Secretaria("Lucia",29)
e = Empleado("Diego",20,400)

despues podran jugar con estos objetos en el interprete haciendo por ejemplo:

>>> dir(p)
['__doc__', '__init__', '__module__', 'edad', 'getEdad', 'getNombre',
'nombre']
>>> dir(c)
['__doc__', '__init__', '__module__', 'edad', 'getEdad', 'getNombre',
 'nombre']
>>> dir(g)
['__doc__', '__init__', '__module__', 'edad', 'getEdad', 'getNombre',
'getSueldo', 'nombre', 'sueldo']
>>> dir(s)
['__doc__', '__init__', '__module__', 'edad', 'getEdad', 'getNombre',
'getSueldo', 'nombre', 'sueldo']
>>> dir(e)
['__doc__', '__init__', '__module__', 'edad', 'getEdad', 'getNombre',
'getSueldo', 'nombre', 'sueldo']
>>> g.getSueldo();
5000
>>> s.sueldo
1000
>>> e.getNombre
<bound method Empleado.getNombre of
<__main__.Empleado instance at 0x00C94AF8>>
>>> e.getNombre()
'Diego'
>>> e.sueldo
400

En la próxima entrada veremos la herencia múltiple.

Intro de objetos en python

Como dijimos al comienzo python es un lenguaje orientado a objetos. Esto significa que soporta herencia, polimorfismo y encapsulamiento. Para lograr esto python nos deja crear los objetos por medio de las clases. Las clases no son los objetos en si, sino son una descripción de cómo van a ser los objetos.
Al instanciar los objetos tendremos referencias a ellos y nunca tendremos a los objetos mismos. Esto pude parecer muy teórico, pero en el día a día se hace notar.
Para definir una clases python nos facilita la palabra reservada “class”. Dentro de una clase definiremos los métodos. Estos métodos serán definidos como definimos las funciones y los procedimientos por medio de “def”.
Adentro de cada una de las clases podremos reverenciarnos a la instancia de cada uno por medio de “self”, una especie de “yo mismo”, self es una referencia al mismo objeto (en otros lenguajes es this).
A cada metodo que cremos dentro de una clase tendremos que ponerle como primer parámetro a self.
Dentro de cada clase se podra crear un costructor creando un metodo “def __init__(self):”

#!/usr/bin/python
# Nombre de Fichero : vehiculo.py

class Vehiculo:
    "clase vehiculo"
    def __init__(self):
        self.ruedas = 0;
        self.pos = 0;
        self.combustible = 0;

    def andar(self,metros):
        if self.combustible >= metros:
            self.pos = self.pos + metros
            self.combustible = self.combustible - metros
            return metros
        else:
            return 0

    def cantRuedas(self):
        return self.ruedas

    def cargarCombustible(self,litros):
        self.combustible = self.combustible + litros

p = Vehiculo();

p.cargarCombustible(50)
print "Andar 60 anduvo ->" + str(p.andar(60))
print "Andar 20 anduvo ->" + str(p.andar(20))
print "Andar 30 anduvo ->" + str(p.andar(30))
print "Andar 30 anduvo ->" + str(p.andar(30))

Pueden y deben documentar cada clase. Gracias a dios esto es muy simple en python ya que solo debemos agregar un string debajo de la definición de class X:. En nuestro caso justo debajo de la “class vehiculo:” pusimos “Clase vehiculo” .
Despues de ejecutar el programita en el interprete de python nos tendra que dar esto:

>>>
Andar 60 anduvo ->0
Andar 20 anduvo ->20
Andar 30 anduvo ->30
Andar 30 anduvo ->0

Luego en ele interprete mismo prueben ejecutar esto para ver todos sus metodos:

>>> dir(p)
['__doc__', '__init__', '__module__', 'andar', 'cantRuedas',
'cargarCombustible', 'combustible', 'pos', 'ruedas']

Y para ver el comentario que hicimos nosotros para esta clase

>>> p.__doc__
'clase vehiculo'

Prueben con otros objetos del entorno y descubrirán cosas lindas 😉 wiiiii.

Por poner un ejemplo

>>> import math
>>> dir (math)
['__doc__', '__name__', 'acos', 'asin', 'atan', 'atan2',
'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs',
'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin',
'sinh', 'sqrt', 'tan', 'tanh']

En la próxima entrada veremos la herencia.

Capturando errores en python

A esta altura, estarán poniéndole complejidad al código con el que estén jugando, y habran tenido la necesidad de capturar, los errores que ejecutó su código.
Obviamente los errores de sintaxis los detecta el intérprete antes de la ejecución del código. Pero los errores de tipo exception los detecta en tiempo de ejecución.
Las exception son errores que ocurren cuando el programa ejecuta una operación invalida, por ejemplo intenta dividir por cero. Es preciso saber que tipo de errores son esperados o no, ya que si nosotros esperamos todo como BaseException podemos tener problemas no deseados. Por este motivo tenemos que tener la jerarquía de errores bien presente. Esto lo ilustra muy bien Darío Ocles esto hay  en el link (http://phpython.blogspot.com/2007/07/jerarqua-de-las-excepciones-en-python.html).

La jerarquía de errores es:

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- Exception
      +-- GeneratorExit
      +-- StopIteration
      +-- StandardError
      |    +-- ArithmeticError
      |    |    +-- FloatingPointError
      |    |    +-- OverflowError
      |    |    +-- ZeroDivisionError
      |    +-- AssertionError
      |    +-- AttributeError
      |    +-- EnvironmentError
      |    |    +-- IOError
      |    |    +-- OSError
      |    |         +-- WindowsError (Windows)
      |    |         +-- VMSError (VMS)
      |    +-- EOFError
      |    +-- ImportError
      |    +-- LookupError
      |    |    +-- IndexError
      |    |    +-- KeyError
      |    +-- MemoryError
      |    +-- NameError
      |    |    +-- UnboundLocalError
      |    +-- ReferenceError
      |    +-- RuntimeError
      |    |    +-- NotImplementedError
      |    +-- SyntaxError
      |    |    +-- IndentationError
      |    |         +-- TabError
      |    +-- SystemError
      |    +-- TypeError
      |    +-- ValueError
      |    |    +-- UnicodeError
      |    |         +-- UnicodeDecodeError
      |    |         +-- UnicodeEncodeError
      |    |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
	   +-- ImportWarning
	   +-- UnicodeWarning

Try:

Try lo que hace es probar con un cierto bloque de código y si  produce una exception la podremos capturar con except.

Su sintaxis es

try_stmt ::= try1_stmt | try2_stmt try1_stmt ::= «try» «:» suite («except» [expression [«,» target]] «:» suite)+ [«else» «:» suite] [«finally» «:» suite] try2_stmt ::= «try» «:» suite «finally» «:» suite

Un ejemplo seria mejorar el if.py de la entrada anterior a try.py

#!/usr/bin/python
# Nombre de Fichero : try.py

b= True
try:
    varIn = int(input("Un numero por favor: "))
except (RuntimeError, TypeError, NameError):
    print "No es un numero"
    b = False

if b:
    if varIn == 4:
        print "el numero es cuatro"
    elif varIn > 4:
        print "el numero es mayor que cuatro"
    else:
        print "el numero es menor que cuatro"

Raise Exception:

Nosotros podremos crear una excepción mediante el modulo exceptions y luego podremos ejecutar esta exception por medio de raise para ccapturarla con except.

Un ejemplo de esto podría ser:

import exceptions
import sys

errorPropio = exceptions.Exception
try:
    numero = input("numero: ")
    if numero  1: # en este caso no podrmos dividir por 1
        print (10/numero)

    else:
        raise errorPropiom,"Error"
except NameError:
    print str(sys.exc_type) + ":" +  str(sys.exc_value)

En este ejemplo solo espera la exception que creamos nosotros. Sino vea que pasa cuando ponemos 0.