Python R2


Herencia Múltiple en Python

Posted in Python por Arturo Elias Antón en 26 agosto 2008
Tags: ,

En Python permite la herencia múltiple, es decir, una clase puede heredar de muchas clases. Dejando de lado de si esto es bueno o malo.  Podríamos tener una clase  A y que hereda de B y C todas sus características.
Por ejemplo podríamos tener la clase de los anfibios que heredan de los terrestres y los acuáticos. O podríamos tener la clase  celular que hereda de teléfono y mp3 y cámara de fotos.

Un ejemplo en codigo seria  herenciaMul.py

#!/usr/bin/python
# Nombre de Fichero : herenciaMul.py
class Camara:
    "Clsase camara de fotos"
    def __init__(self):
        pass
    def sacarFotos(self):
        pass

class Telefono:
    "Clase Telefono"
    def __init__(self):
        pass
    def llamar(self):
        pass

class ReproductorMp3:
    "Clase Reproductor Mp3"
    def __init__(self):
        pass
    def play(self):
        pass

class Celular(Telefono,Camara,ReproductorMp3):
    pass



cel = Celular()

luego podremos ver en el interprete python que cel tiene todos los metodos de Camara Telefono ReproductorMp3

>>> dir(cel)
['__doc__', '__init__', '__module__', 'llamar', 'play', 'sacarFotos']

En caso de que dos métodos se llamen igual prevalecerá el de la clase padre puesta más a la izquierda.

En la próxima entrada hablare del polimorfismo en python

Herencia en python

Posted in Python por Arturo Elias Antón en 26 agosto 2008
Tags: , , , ,

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

Posted in Python por Arturo Elias Antón en 25 agosto 2008
Tags: , , ,

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.

¿Como armo una función en python?

No siempre nuestro programa es un programa tan corto como para que quepa todo prolijamente en un bloque de sentencias. También a veces queremos ejecutar un código varias veces. En otras palabras queremos funciones y procedimientos.

  • Una función: es una subrutina que al término de su ejecución devuelve un valor.
  • Un procedimiento: es una subrutina que no  retornar valor alguno al termino de su ejecución.

Las funciones y los procedimientos nos sirven para empezar a modular nuestro código.  Y también nos servirá para reutilizar nuestro código.

La verdad que en python no hay mayor diferencia entre la definición de un procedimiento y la de una función son iguales, ya que las dos se definen con la palabra reservada “def”.

Declaración de Funciones

Las funciones son declaradas, como ya dijimos, en primer lugar por la palabra reservada “def”. Luego el nombre de la función seguido de los parámetros, separados por comas, que recibirá dicha función, si esta no recibe parámetros irán los paréntesis vacíos. Por ultimo van los dos puntos.
El bloque contenido en la función debe terminar con un return. Ya que, para que sea función, esta tiene que devolver un valor.

La función no define el tipo del valor de retorno. Las funciones de Python no especifican el tipo de su valor de retorno.

Un ejemplo de una función sin parámetros seria este:

def fx():
print “hola soy la funcion fx”
return 1

Un ejemplo de una función con parámetros seria este:

def fx(a,b):
      c = a+b
      return  c

Declaración de Procedimiento

Es exactamente igual que el de las funciones, pero sin el return al final de su bloque de código. De hecho los procedimientos al no agregarle return al final del bloque de código, los emulamos en python, con funciones que siempre devolverán None.

Un ejemplo de procedimiento sin parámetros es:

def pr():
      print “hola soy el procedimiento pr”

Un ejemplo de procedimiento con parámetros es:

def pr(a,b):
      print a+b

Parámetros con valores por defecto.

En python podremos darle a los parámetros un valor por defecto si es que el usuario de la función o procedimiento no pasa ese parámetro.

Esto se haría así:

def fx(a=0,b=0):
	return a+b

La salida de la función fx al invocarla es:

>>> fx(1)
1
>>> fx(1,2)
3
>>> fx(b=2)
2

Como vemos python también soporta el pasaje de parámetros por nombre.

La salida del procedimiento seria:

>>> pr(4,5)
a= 4
b= 5
>>> pr(4)
a= 4
b= 2
>>> pr(b=5)
a= 1
b= 5
>>> pr()
a= 1
b= 2

Un ejemplo integrador.

Un ejemplo de un programa que usa funciones y procedimientos es fx_pr.py donde intentaremos, por medio de lo que ya sabemos, resolver cuadráticas con raíces reales.

#!/usr/bin/python
# Nombre : fx_pr.py
import math

def determinante(a,b,c):
    return (b*b)-(4*a*c)

def cuadratica(a,b,c):
    det = determinante(a,b,c)
    if det < 0:
        print "tiene raices imaginarias"
    else:
        print "La rais 1 es " + str((b + math.sqrt(det))/(2*a))
        print "La rais 2 es " + str((b - math.sqrt(det))/(2*a))

cuadratica(3,9,6)

comentare este programita: la sentencia import importa la librería o math para luego usar su metodo sqrt. Luego hay una funcion que me calcula el determinante y un procedimiento que me calcula y me imprime en pantalla las raices

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.

Empezando a caminar en Python.

Posted in Python por Arturo Elias Antón en 25 agosto 2008
Tags: ,

Antes de empezar a programar en python diré que los bloques de sentencia se diferencian por su tabulación, dando una buena legibilidad al los programas escritos en Python.
Ahora si Empezaremos a ver como se escriben las sentencias de control de flujo de nuestros programas en python.

If – Elif – Else:
La sentencia if se utiliza para comprobar una condición, si esta es verdadera entonces procesaremos un bloque de sentencias u otro bloque de sentencias alternativas. La cláusula else y elif es opcional.

Su sintaxis es

if_stmt ::= “if” expression “:” suite ( “elif” expression “:” suite )* [“else” “:” suite]

Un ejemplo de if seria if.py:

#!/usr/bin/python
# Nombre : if.py
varIn = input("Un numero por favor: ")
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"

La primer línea es un comentario especial para que los sistemas tipo UNIX sepan que este es un script python y lo ejecuten con dicho interprete
La segunda línea es un comentario mono – línea.
La tercera línea se le asigna a la variable varIn el valor que devuelve input. Luego viene la sentencia if con su expresión boleana (varIn==4). Luego después de un tab viene la impresión como la habíamos echo ya en hola mundo. elif es si hay otra opción en este caso que varIn sea mayor que 4 y por ultimo else que significa que si no es ninguna de todas las opciones ejecute este bloque de sentencias.

While:
La sentencia while se utiliza para repetir cierto bloque de sentencias mientras una condición suceda
Su sintaxis es
while_stmt ::= “while” expression “:” suite [“else” “:” suite]
Un ejemplo de while seria while.py:

#!/usr/bin/python
# Nombre : while.py

i=1
while i <= 10:
	print i
	i=i+1

La sentencia while repetira el bloque hasta que (i<=10). Este programa imprime del 1 al 10.

For:
La sentencia for se utiliza para repetir cierto bloque de sentencias una cantidad de veces. También nos sirve para recorrer listas
Su sintaxis es
for_stmt ::= “for” target_list “in” expression_list “:” suite [“else” “:” suite]

Un ejemplo de for seria for.py

#!/usr/bin/python
# Nombre : for.py
for i in range(1,11):
	print i

La sentencia for repetira el bloque 10 veces ya que la función range traerá la lista [1,2,3,4,5,6,7,8,9,10].  Este programa imprime del 1 al 10.

¿Que es Python?

Posted in Python por Arturo Elias Antón en 22 agosto 2008
Tags: ,

Para empezar Python es un lenguaje de programación orientado a objetos e interpretado. Es un lenguaje que tiene una leve curva de aprendizaje ya que hereda muchas características de su antecesor el lenguaje ABC. Además es un lenguaje extensible por medio del lenguaje C y fácil de embeber en otras tecnologías como.NET (IronPython) y JAVA (jython).
Python tiene un montón de características de otros lenguajes como listas por comprensión, lambda, map (), filter (), reduce () y otras mas.
Los beneficios de Python son muchos por nombrar algunos de diremos estos: Consistencia, Escalabilidad, Flexibilidad, Intérprete interactivo, Multiplataforma y Fácil de implementar.
Para empezar a programar en este lenguaje haremos el famoso hola mundo.
Crearemos un archivo de texto “Hola.py” y pondremos:

print “Hola Mundo!!!”

Luego lo ejecutamos como

Python Hola.py

Y listo nuestro primer programa python jejeje no es emocionante 🙂

El print fue corregido despues del comentario de Anonimo
no se quien sos jeje pero muchas gracias 😉

« Página anterior