RVBurke » Blog Archive » Programación orientada a objetos ...€¦ · RVBurke » Blog Archive »...

RVBurke » Blog Archive » Programación orientada a objetos en Python

http://blog.rvburke.com/2006/11/22/programacion-orientada-a-objetos-en-python/[22/07/2013 11:49:40 a.m.]

RVBurkeArquitectura y técnica

Programación orientada a objetos en Pythonby pachi

Introducción a la programación orientadaa objetos

Este artículo es una introducción a la programaciónorientada a objetos (POO, o OOP por sus siglas eninglés), uno de los paradigmas de programación

estructurada más importante hoy en día.

El artículo usa el lenguaje Python para los distintos ejemplos, y explica laimplementación de la POO en ese lenguaje, aunque aborda conceptos generalesque son fácilmente trasladables a otros lenguajes.

Los fragmentos de código se señalan usando un estilo de texto diferente (anchofijo) y, cuando se utiliza el intérprete de python, se prefija cada línea con lossímbolos ‘>>>’.

Esta introducción presupone conocimientos básicos de programación y del lenguajepython.

Formas de pensar: paradigmas de programación

Uno de los elementos básicos a la hora de realizar un programa es la modelizacióndel problema que pretende resolver. Es preciso localizar las variables y losaspectos relevantes, así como comprender los pasos necesarios para obtener elresultado a partir de los datos iniciales, etc. Es decir, abstraer el problema,reduciendo sus detalles de forma que podamos trabajar con pocos elementos cadavez.

La algoritmia plantea la forma óptima de resolver problemas concretos, talescomo la ordenación de una lista de elementos, la búsqueda de un elemento en unconjunto, la manipulación de conjuntos de datos, etc. Sin embargo, noproporcionan un marco general, un enfoque, que nos permita plantear y formularlas soluciones a un problema de forma coherente.

Los paradigmas de programación llenan ese hueco, proporcionando guías tantosobre cómo realizar la abstracción de los datos como sobre el control de laejecución. Es decir, los paradigmas de programación son herramientasconceptuales para analizar, representar y abordar los problemas,

Informaciónwww.rvburke.com

blog.rvburke.com

Sobre este sitio…

Búsqueda

Categoríasarquitectura

arte

castellano

chiara

cuentos

english

espectáculos

estructuras

galego

gnome

libros

mercurial

OpenOffice

pascaline

programación

python

recetas

reminders

sociedad

software-libre

Archivo mensualApril 2011

January 2011

http://blog.rvburke.com/

http://www.python.org/

http://www.rvburke.com/


http://blog.rvburke.com/about/

http://blog.rvburke.com/category/arquitectura/

http://blog.rvburke.com/category/arte/

http://blog.rvburke.com/category/castellano/

http://blog.rvburke.com/category/chiara/

http://blog.rvburke.com/category/cuentos/

http://blog.rvburke.com/category/english/

http://blog.rvburke.com/category/espectaculos/

http://blog.rvburke.com/category/estructuras/

http://blog.rvburke.com/category/galego/

http://blog.rvburke.com/category/gnome/

http://blog.rvburke.com/category/libros/

http://blog.rvburke.com/category/mercurial/

http://blog.rvburke.com/category/openoffice/

http://blog.rvburke.com/category/pascaline/

http://blog.rvburke.com/category/programacion/

http://blog.rvburke.com/category/python/

http://blog.rvburke.com/category/recetas/

http://blog.rvburke.com/category/reminders/

http://blog.rvburke.com/category/sociedad/

http://blog.rvburke.com/category/software-libre/

http://blog.rvburke.com/2011/04/




presentando sistematizaciones alternativas o complementarias para pasardel espacio de los problemas al de las implementaciones de una solución.

Es muy recomendable y productivo comprender el enfoque de distintosparadigmas, puesto que presentan estrategias alternativas, incrementandonuestras herramientas disponibles y haciéndono reflexionar sobre muchas de lastareas que realizamos al crear un programa. Además, a menudo ocurre que unosproblemas se formulan de forma muy clara si se los analiza según una perspectivadeterminada, mientras que producen una gran complejidad vistos de otra manera.

Algunos paradigmas habituales

Algunas de las formas de pensar los problemas que ha llegado a sistematizarsecomo paradigmas de programación son:

La programación modular: Los programas se forman por partes separadasllamadas módulos. Estos funcionan de forma independiente entre sí, o serelacionan a través de interfaces bien definidas.La programación procedural: Un programa se compone de procedimientos(subrutinas, métodos o funciones) que son fragmentos de código quepueden llamarse desde cualquier punto de la ejecución de un programa,incluídos otros procedimientos o él mismo. (ej. ALGOL)La programación estructurada: Se puede expresar cualquier programautilizando únicamente tres estructuras de control: secuencial, condicional eiterativa. Los programas se componen de partes menores con un únicopunto de entrada, y se trata de aislarlos para evitar la complejidad queintroducen los efectos colaterales. (ej. Pascal, C, Ada)La programación imperativa: Un programa se puede definir en términosde estado, y de instrucciones secuenciales que modifican dicho estado. (ej.C, BASIC)La programación declarativa: Es posible expresar un programa a travésde condiciones, proposiciones o restricciones, a partir de los que se obtienela solución mediante reglas internas de control. (ej. PROLOG)La programación funcional: Se puede expresar un programa como unasecuencia de aplicación de funciones. Elude el concepto de estado delcómputo y no precisa de las estructuras de control de la programaciónestructurada. (ej. LISP, Haskell)La programación orientada a objetos: Los programas se definen entérminos de “clases de objetos” que se comunican entre sí mediante elenvío de mensajes. Es una evolución de los paradigmas de la programaciónprocedural, estructurada y modular, y se implementa en lenguajes comoJava, Smalltalk, Python o C++.

Programación multiparadigma

Los paradigmas de programación son idealizaciones, y, como tales, no siempre sepresentan de forma totalmente ‘pura’, ni siempre resultan incompatibles entre sí.Cuando se entremezclan diversos paradigmas se produce lo que se conoce comoprogramación multiparadigma.

El uso de distintos modelos, según se adapten mejor a las diversas partes de unproblema o a nuestra forma de pensamiento, resulta también más natural ypermite expresar de forma más clara y concisa nuestras ideas.

November 2010

May 2010

March 2010

December 2009

November 2009

September 2009

May 2009

December 2008

November 2008

October 2008

September 2008

June 2008

May 2008

April 2008

March 2008

February 2008

January 2008

December 2007

November 2007

October 2007

September 2007

June 2007

May 2007

April 2007

March 2007

February 2007

December 2006

November 2006

October 2006

September 2006

August 2006

June 2006

BlogsAcotalanorma

AnArchitecture

ARQtipo

Ingeniería ysostenibilidad

Planet Gnome

































http://acotalanorma.blogspot.com/

http://anarchitecture.blogspot.com/

http://www.arqtipo.com/

http://www.ison21.es/

http://www.ison21.es/

http://planet.gnome.org/



Algunos lenguajes, como Haskell o Prolog están diseñados para encajarperfectamente en la visión de un paradigma particular, mientras que otros, comopython , se adaptan especialmente bien a la programación multiparadigma y dangran libertad a la hora de resolver un problema, al no imponen un mismo patrónpara todos los casos.

Tipos de datos

Una forma de almacenar y representar una fecha en un programa podría ser lasiguiente:

d = 14m = "Noviembre"a = 2006def dime_fecha(dia, mes, anho): return "%i de %s de %i del calendario gregoriano" % (dia, mes, anho)print dime_fecha(d, m, a)

para obtener la siguiente salida:

"14 de Noviembre de 2006"

En este ejemplo, para representar y manipular lo que conceptualmenteentendemos como una fecha, se utilizan las variables d, m y a como almacenes dedatos, y un procedimiento o función, de nombre dime_fecha, para realizar larepresentación de la fecha almacenada.

Las variables permiten almacenar tipos de datos concretos como los enteros (d ya) o las cadenas de texto (m), y la función realiza su trabajo devolviendo otro tipoconcreto, una cadena de texto.

Uno de los problemas de este enfoque es que no refleja demasiado bien elconcepto fecha que usamos como modelo mental al implementarlo como unconjunto de tres variables no relacionadas entre sí (d, m y a). Es decir, las tresvariables tienen una unidad conceptual en nuestra mente, que no se refleja en laforma de expresar el problema. De la misma manera, la función dime_fechadesconoce igualmente la relación entre sus parámetros, que podría ser totalmentearbitraria.

Esta situación, que puede parecer una cuestión de ‘estilo’, implica un riesgo deproblemas de sincronización entre variables ‘relacionadas’, dispersión en distintaspartes del código de manipulaciones que son relevantes al conjunto, pérdida delvalor semántico de cada variable que puede dar lugar a errores al transformar elcódigo…

Un ejemplo de desconexión semántica entre la implementación y el concepto esque d puede ser cualquier valor entero, mientras que un día tiene un valor situadoentre 1 y 31, m es una cadena de texto dentro de un número limitado deopciones, o a no puede tomar valores negativos. Por supuesto que esto se podríasolucionar con código que hiciese comprobaciones adicionales, pero en este casoqueremos resaltar cómo un programa es un modelo aproximado a un problema ycómo sería preferible que la implementación pudiese representar de forma másajustada el comportamiento del modelo elegido.

Una posible solución sería disponer de un tipo de datos que represente de formamás adecuada el concepto de fecha y que nos permita manipular fechas de la

WebsitesBelén Orta

COAM

De Mecánica

ETSAM

Milla, Mira yNavarro,Arquitectos

Monserrat Boix

MetaRSS 2.0 Feed

Atom Feed

Comments RSSFeed

Log in

http://haskell.org/

http://pauillac.inria.fr/~diaz/gnu-prolog/


http://www.belenorta.es/

http://www.coam.org/

http://www.demecanica.com/

http://www.aq.upm.es/

http://mmn-arquitectos.com/



http://montserratboix.nireblog.com/

http://blog.rvburke.com/feed/

http://blog.rvburke.com/feed/atom/

http://blog.rvburke.com/comments/feed/

http://blog.rvburke.com/comments/feed/

http://blog.rvburke.com/wp-login.php



misma manera que manipulamos números enteros, números reales o cadenas detexto, independientemente de la implementación interna que los sustente.

Clases y objetos

Al enunciar algunos tipos de paradigmas hemos visto que la programaciónorientada a objetos define los programas en términos de “clases deobjetos” que se comunican entre sí mediante el envío de mensajes. En esteapartado aclararemos qué se entiende en ese contexto por clases y objetos.

Las clases surgen de la generalización de los tipos de datos y permiten unarepresentación más directa de los conceptos necesarios para lamodelización de un problema permitiendo definir nuevos tipos al usuario.

Las clases permiten agrupar en un nuevo tipo los datos y lasfuncionalidades asociadas a dichos datos, favoreciendo la separación entre losdetalles de la implementación de las propiedades esenciales para su uso. A estacualidad, de no mostrar más que la información relevante, ocultando el estado ylos métodos internos de la clase, es conocida como “encapsulación”, y es unprincipio heredado de la programación modular.

Un aspecto importante en el uso de clases es que no se manipulan directamente(salvo en lo que se conoce como metaprogramación), sino que sirven para ladefinición nuevos tipos. Una clase define propiedades y comportamiento quese muestran en los entes llamados objetos (o instancias de una clase). Laclase actúa como molde de un conjunto de objetos, de los que se dice quepertenecen a la clase.

Trasladando estos conceptos a los números enteros (tipo int), se puede decir quelas variables que almacenan números enteros son objetos o instancias de la claseint o que pertenecen a la clase int.

En términos más abstractos, podemos pensar en las clases como definiciones y enlos objetos como expresiones concretas de dichas definiciones.

Fisonomía de una clase

En python, el esquema para la definición de una clase es el siguiente:

class NombreClase: <instrucción_1> ... <instrucción_n>

en donde class es una palabra reservada que indica la declaración de una clase,NombreClase una etiqueta que da nombre a la clase y, los dos puntos, queseñalan el inicio del bloque de instrucciones de la clase.

El cuerpo de instrucciones de la clase puede contener tanto asignaciones de datoscomo definiciones de funciones. Este bloque de instrucciones se encuentra en elnuevo espacio de nombres con el nombre de la clase, que se genera, a su vez,con la creación de cada objeto. En ambos casos, en el espacio de nombres de laclase y del objeto, es posible acceder a los elementos que lo integran usando eloperador punto, como en el caso de los espacios de nombres de un módulo (e.j.math.pi, objeto.dato, objeto.funcion()).

Si la primera instrucción del cuerpo de la clase es una cadena de texto, ésta se



usa como cadena de documentación de la clase.

Nuestro ejemplo podría reescribirse en términos de una clase así:

class Fecha: "Ejemplo de clase para representar fechas" dia = 14 mes = "Noviembre" anho = 2006 def dime_fecha(self): return "%i de %s de %i" % (Fecha.dia, Fecha.mes, Fecha.anho)

mi_fecha = Fecha()print mi_fecha.dia, mi_fecha.mes, mi_fecha.anhoprint mi_fecha.dime_fecha()

En el fragmento de código anterior definimos la clase Fecha y ella asignamosvalores a las etiquetas dia, mes y anho (atributos de la clase), y definimos unafunción (un método de la clase), dime_fecha.

Fuera de la definición de la clase creamos (instanciamos) un objeto pertenecientea la clase Fecha. Esta instanciación se realiza utilizando la notación de llamada afunción, y podemos entenderla como una llamada a una función que devuelve unobjeto de la clase Fecha. El objeto obtenido es asignado a la etiqueta mi_fecha.

En la siguientes instrucciones mostramos por pantalla los valores de laspropiedades dia, mes y anho y el resultado de la llamada al método dime_fecha,usando el operador punto para acceder a las propiedades y métodos del objetomi_fecha, ya que, como hemos mencionado antes, forman parte del espacio denombres del objeto.

La llamada al método dime_fecha no incluye ningún parámetro, pero podemoscomprobar que, de forma contradictoria, la declaración del método indica uno,self. Este parámetro es añadido automáticamente por el intérprete en lasllamadas a los métodos de una clase, y contiene una referencia al objeto querecibe la señal (el que recibe una llamada a un método). self permite acceder alas propiedades y métodos de un objeto concreto y aclararemos su significado yuso más adelante. Por ahora nos basta saber que es necesario incluir self comoprimer parámetro de los métodos definidos en una clase y que no espreciso incluir el parámetro implícito self al realizar llamadas a un métodoa través del objeto al que pertenece.

En realidad, en el ejemplo anterior, la llamada mi_fecha.dime_fecha() es unaforma más cómoda de escribir (azúcar sintáctico) Fecha.dime_fecha(mi_fecha), loque explica la presencia del parámetro.

Un paseo entre objetos

Hasta el momento hemos visto cómo las clases definen los datos (o estado) ycomportamiento de los objetos a través de atributos (o propiedades) y métodos.

Ahora vamos a hacer un recorrido, utilizando una sesión interactiva del intérpretey las capacidades de introspección de python, para explicar el uso y elcomportamiento de los objetos.

Veremos algunas características de los objetos:



1. Identidad. Los objetos se diferencian entre sí, de forma que dos objetos,creados a partir de la misma clase y con los mismos parámetros deinicialización, son entes distintos.

2. Definen su comportamiento (y operar sobre sus datos) a través demétodos, equivalentes a funciones.

3. Definen o reflejan su estado (datos) a través de propiedades o atributos,que pueden ser tipos concretos u otros objetos.

Pasamos a ver una sesión interactiva del intérprete:

>>> mi_fecha = Fecha()

>>> mi_fecha_2 = Fecha()

>>> mi_fecha is mi_fecha_2

False

>>> print mi_fecha

<__main __.Fecha instance at 0x00B184B8>

>>> print mi_fecha_2

<__main __.Fecha instance at 0x00B18328>

Vemos que tanto mi_fecha como mi_fecha_2 son instancias de la clase Fecha (en elmódulo __main__) y cada una tiene su propio espacio de memoria independiente.

>>> print mi_fecha.dime_fecha()

14 de Noviembre de 2006

>>> print mi_fecha.dia

14

>>> print mi_fecha_2.dia

14

>>> Fecha.dia = 16

>>> print Fecha.dia

16


16


16

>>> mi_fecha.dia = 30

>>> print Fecha.dia

16


30


16

Este último experimento observamos cómo, pese a que mi_fecha y mi_fecha_2 sondos instancias distintas de la clase Fecha, ambas hacen referencia a través de suatributo dia al mismo valor de la clase Fecha.dia. Sin embargo, cuando se produceuna asignación a ese atributo (a esa etiqueta, en realidad) en uno de los objetosvemos cómo, a partir de entonces, ese objeto dispone de un valor 'individual'asociado al atributo.

Ese comportamiento revela la existencia de atributos (o estado) compartidos



por todas las instancias de una clase y de atributos (o estado) ligados auna instancia particular. Los primeros se sitúan en el espacio de nombres de laclase, y vemos cómo se pueden hacer asignaciones en la sesión interactivaanterior, o lecturas, en el método dime_fecha del ejemplo anterior. Los segundosse sitúan en el espacio de nombres de cada objeto, y ahí es donde resulta útil elparámetro self.

Antes de proseguir, podemos escudriñar qué símbolos son accesibles y quécontienen los espacios de nombres de la clase Fecha y de los objetos mi_fecha ymi_fecha_2. Usamos la función dir para lo primero, y el atributo __dict__ para losegundo, ya que en python los espacios de nombres se implementan comodiccionarios:

>>> dir(Fecha)

['__doc__', '__module__', 'anho', 'dia', 'dime_fecha', 'mes']

>>> dir(fecha3)


>>> dir(fecha4)


En los tres podemos acceder a los mismos símbolos. Sin embargo...

>>> Fecha.__dict__

{'__module__': '__main__', 'anho': 2006, 'dime_fecha': x00B176F0>, 'dia': 14,

'mes': 'Noviembre', '__doc__': 'Ejemplo de clase para representar fechas'}

>>> mi_fecha_2.__dict__

{}

>>> mi_fecha.__dict__

{'dia': 30}

El espacio de nombres de la clase es el que alberga los nombres de los atributos ymétodos indicados en la declaración de la clase, además de los atributosespeciales __doc__, que contiene la cadena de documentación y __module__, quecontiene el nombre del módulo al que pertenece la clase. Esos símbolos sonaccesibles también para los objetos pertenecientes a la clase (tal como nosindicaba dir()).

Podemos ver también que el espacio de nombres del objeto mi_fecha_2 seencuentra vacío, mientras que el del objeto mi_fecha contiene el atributo día. Estose debe a que anteriormente realizamos una asignación al atributo dia del objetomi_fecha (dándole el valor 30). El espacio de nombres recoge esa versiónparticular del atributo, que no aparece en el otro objeto, puesto que accede alatributo de clase.

A los atributos compartidos por todos los objetos de una clase se los denominaatributos de clase, cuando se desea diferenciarlos de los atributos quepertenecen a cada instancia en particular.

Acceso individualizado a objetos: self

Ahora que hemos visto cómo usar atributos de clase para compartir datos entretodos los objetos de una misma clase, también nos interesa conocer cómo utilizar



atributos comunes a una clase pero que puedan tomar valores distintos para cadauno de los objetos.

Retomamos ahora el misterioso parámetro self que vimos estaba presente comoprimer parámetro de todos los métodos de una clase. En su momento yacomentamos que self contiene una referencia al objeto que recibe la señal(el objeto cuyo método es llamado), por lo que podemos usar esa referenciapara acceder al espacio de nombres del objeto, es decir, a sus atributosindividuales.

>>> class F:... i = 5... def dime_i(self):... return F.i... def dime_mi_i(self):... return self.i...>>> a = F()>>> a.dime_i()5>>> a.dime_mi_i()5>>> a.i = 6>>> a.dime_i()5>>> a.dime_mi_i()6>>> a.i6

En este ejemplo el método dime_i usa el atributo de clase y retorna su valor, 5,mientras que el método dime_mi_i usa una referencia al objeto y devuelve el valor6, el asignado al atributo del objeto a. Así accedemos selectivamente al atributode clase i o al atributo de instancia i.

Algo que puede aclarar algo más la naturaleza del parámetro self, es recordarque, cuando hacemos una llamada a un método un_metodo de un objeto un_objetoperteneciente a la clase UnaClase, el intérprete traduce la expresiónun_objeto.un_metodo() como UnaClase.un_metodo(un_objeto).

El uso de self responde a la forma particular en que python implementa elsoporte de objetos, aunque lenguajes como Java o C++ utilizan mecanismossimilares con la palabra reservada this. En python self no es una palabrareservada y cualquier etiqueta usada como primer parámetro valdría igualmente,aunque se desaconseja totalmente el uso de otras etiquetas, por tratarse de unaconvención muy arraigada en el lenguaje que hace el código más legible, facilitael resaltado de sintaxis, etc.

El método de inicialización __init__

Hemos visto ya cómo definir y usar atributos de clase y de instancia. Pero enpython no es necesaria la declaración de variables, por lo que cualquier atributo alque se realice una asignación en el código se convierte en un atributo deinstancia:

>>> a = F()

>>> a.i = 6



>>> a.atr = 3

>>> print a.atr

3

>>> a.__dict__

{'i': 6, 'atr': 3}

Una funcionalidad muy conveniente que hemos visto en la declaración de atributosde clase es la de realizar su inicialización en el cuerpo de la clase. Para poderinicializar los atributos de una instancia existe un método especial que permiteactuar sobre la inicialización del objeto. Dicho método se denomina __init__ (condos guiones bajos al principio y al final) y admite cualquier número deparámetros, siendo el primero la referencia al objeto que es incializado (self, porconvención), que nos permite realizar las asignaciones a atributos de la instancia.Este método se ejecuta siempre que se crea un nuevo objeto de la clase, tras laasignación de memoria y con los atributos de clase inicializados, y se correspondeparcialmente con el concepto de constructor de la clase existente en otroslenguajes.

Con la referencia que nos proporciona self podemos inicializar atributos deinstancia, con valores predeterminados si lo deseamos, como en cualquierdefinición de función:

class Clase: def __init__(self, x=2): self.x = x self.a = x**2 self.b = x**3 self.c = 999 def dime_datos(self): return "Con x=%i obtenemos: a=%i, b=%i, c=%i" % (self.x, self.a, self.b, self.c)a1 = Clase(2)a1.dime_datos()a2 = Clase(3)a2.dime_datos()

Salida:

Con x=2 obtenemos: a=4, b=8, c=999

Con x=3 obtenemos: a=9, b=27, c=999

Propiedades y Atributos

Aunque en la terminología general de la programación orientada a objetos atributoy propiedad se pueden utilizar como sinómimos, en python se particulariza el usode propiedades para un tipo especial de atributos cuyo acceso se produce através de llamadas a funciones.

class ClaseC(object): def __init__(self): self.__b = 0 def __get_b(self): return self.__b def __set_b(self, valor): if valor > 10: self.__b = 0 else: self.__b = valor



b = property(__get_b, __set_b, 'Propiedad b')

c1 = ClaseC()print c1.b# b es 0c1.b = 5print c1.b# b es 5c2 = ClaseC()print c2.b# b es 0c2.b = 12print c2.b#b es 0

En este ejemplo se define la propiedad b, cuyo comportamiento es: cuando serealiza una asignación, toma el valor entregado si es menor que 10, o 0 en casocontrario, y lo almacena en un atributo privado __b. Cuando se produce la lecturade b, devuelve el valor guardado en el atributo privado.

En Python, para poder usar propiedades en una clase es necesario hacerla derivarde la clase object de ahí que aparezca al lado del nombre de la clase ClaseC. Enun apartado posterior se explicará en qué consiste la derivación de clases.

La signatura de la función property, que define una propiedad de la clase es lasiguiente:nombre_propiedad = property(get_f, set_f, del_f, doc)

donde get_f es la función llamada cuando se produce la lectura del atributo; set_fla función llamada cuando se produce una asignación al atributo; del_f la funciónllamada cuando se elimina el atributo, y doc es una cadena de documentación dela propiedad.

Las propiedades resultan muy útiles para realizar la validación de los valoresasignados, la transformación o cálculo de valores devueltos y, además, dotan degran flexibilidad a la hora de escribir el código, puesto que es posible empezarusando atributos y luego sustituirlo por una propiedad que realice funcionesadicionales, a medida que el código lo requiera y simplemente cambiando elcódigo de la clase, sin afectar al código cliente de la clase.

Herencia y derivación de clases

Vemos que el uso de clases hace más adecuada la representación de conceptos ennuestros programas. Además, es posible generar una clase nueva a partir deotra, de la que recibe su comportamiento y estado (métodos y atributos),adaptándolos o ampliándolos según sea necesario.

De una clase que representase el concepto de vehículo podríamos derivar otraspara representar automóviles, bicicletas, barcos o aviones, donde cada uno deellos mantiene atributos y métodos comunes (peso, color, velocidad máxima,número de pasajeros), mientras que otros son exclusivos (número de ruedas,número de hélices, número de reactores, altitud máxima de vuelo...).

En términos matemáticos podemos expresarlo diciendo que es posible establecerrelaciones de pertenencia entre clases. Si tenemos una clase A y de elladerivamos una clase B, podemos decir que "B es una A", o que "B es unaespecialización de A".



En la terminología de la POO se dice que "B hereda de A", "B es una clasederivada de A", "A es la clase base de B", "A es superclase de B" o "A es clasemadre de B".

Esto facilita la reutilización del código, puesto que se pueden implementar loscomportamientos y datos básicos en una clase base y especializarlos en las clasesderivadas.

En un programa hipotético que trabajase con formas geométricas, podríamostener una clase base Forma y clases derivadas de ella como Triangulo, Cuadrado,Circulo... En la clase base podríamos definir un método dibuja que representa lafigura en pantalla, y un método area y otro perímetro que calculan el área y elperímetro, respectivamente.

En el lenguaje python, para expresar que una clase deriva, desciende o esheredera de otra u otras clases se añade tras el nombre, en la declaración de laclase, una tupla con los nombres de las clases base.

El siguiente ejemplo crea una ClaseA y de ella deriva una ClaseB que inicializa unatributo adicional, cambia el comportamiento de un método y hereda los atributosde la clase madre:

class ClaseA: def __init__(self, x): self.a = x self.b = 2 * x def muestra(self): print "a=%i, b=%i" % (self.a, self.b)

class ClaseB(ClaseA): def __init__(self, x, y): ClaseA.__init__(self, x) self.c = 3 * (x + y) + self.b def muestra(self): print "a=%i, b=%i, c=%i" % (self.a, self.b, self.c)

print "Objeto A"a = ClaseA(2)print a.__dict__a.muestra()

print "ObjetoB"b = ClaseB(2, 3)print b.__dict__b.muestra()

Este código al ejecutarse devuelve:

Objeto A

{'a': 2, 'b': 4}

a=2, b=4

ObjetoB

{'a': 2, 'c': 19, 'b': 4}

a=2, b=4, c=19

La clase ClaseA muestra funcionalidades que ya hemos ido viendo en estaintroducción (atributos de instancia a y b, método muestra). La clase ClaseB sedeclara como descendiente de la ClaseA, por lo que hereda sus métodos y



atributos y modifica algo el comportamiento de la clase madre. Por una parte, ensu método de inicialización llama al método de la clase madre con los parámetrosdeseados, y, posteriomente, añade un nuevo atributo de instancia que no existeen la clase madre. Por otro lado, redefine un método existente en ClaseA,cambiando la implementación.

Esta última técnica, en la que un mismo nombre se asocia a comportamientosdistintos se conoce como polimorfismo, y se habla de que el método se hasobrecargado, es decir, se le asignan distintos significados en función de sucontexto. El polimorfismo también alude a la posibilidad de utilizar, en un contextoen el que se espera una clase dada, cualquier clase derivada.

La clase object

Desde la versión 2.2 de python , se ha establecido una clase base llamada objectde la que se aconseja derivar todas las clases. Esto permite aprovechar una seriede características sólo existentes en las "nuevas clases" (como la definición depropiedades), que se describen en la documentación de python.

En el ejemplo sobre el uso de propiedades se introdujo la herencia sin explicarla,

derivando la clase de object. Ahora debería estar más clara la razón .

Jerarquías de clases

La herencia permite establecer relaciones entre clases, y, estas relaciones depertenencia pueden ser a varios niveles, y ramificarse en lo que se denominanjerarquías de clases.

Un ejemplo de clásico para visualizar las jerarquías de clases es el que podríaservir para modelizar el conjunto de empleados de una empresa. En ella apareceuna clase base Empleado, que dispone de los atributos nombre y departamento; de elladescienden las subclases Gestor (atributo adicional informes) y Trabajador (atributoadicional proyectos), y de esta última derivan las clases Comercial (atributoadicional participación) e Ingeniero (atributo original area).

Gráficamente podría representarse de la siguiente manera:




En el diagrama se puede ver en negrita los atributos que implementa cada clase,y en gris los que hereda de clases madre. El código (básico de inicialización) delas clases podría ser el siguiente:

class Empleado: def __init__(self, nombre, departamento="general"): self.nombre = nombre self.departamento = departamento

class Gestor(Empleado): def __init__(self, nombre): Empleado.__init__(self, nombre) self.informes = []

class Trabajador(Empleado): def __init__(self, nombre): Empleado.__init__(self, nombre) self.proyectos = []

class Comercial(Trabajador): def __init__(self, nombre, participacion=0.1): Trabajador.__init__(self, nombre) self.departamento = "ventas" self.participacion = participacion

class Ingeniero(Trabajador): def __init__(self, nombre, area="mecánica"): Trabajador.__init__(self, nombre) self.departamento = "ingeniería" self.area = area

Naturalmente, cada una de las clases tendría sus propios métodos que definiríancomportamientos propios de cada clase o subclase, que no se han detallado en elejemplo.

Una alternativa a la herencia es la composición, en el que una clase se compone



de otras clases internas, y que puede ser una mejor alternativa en muchos casos.

Encapsulación y grados de privacidad

Uno de los principios que guían la POO, heredados de la programación modular,es el de encapsulación. Hemos visto cómo se puede agrupar comportamiento ydatos gracias al uso de objetos, pero hasta el momento, tanto los atributos comolos métodos que se definen en las clases correspondientes se convierten enmétodos y atributos visibles para los usuarios de la clase (la API de la clase).

Se dice que un método o atributo es público si es accesible desde el exterior dela clase, mientras que se denomina privado en caso contrario.

Es deseable poder señalar qué métodos y atributos no deben utilizarse fuera de laclase para evitar exponer excesivamente los detalles de la implementación de unaclase o un objeto.

Python utiliza para ello convenciones a la hora de nombrar métodos y atributos,de forma que se señale su carácter privado, para su exclusión del espacio denombres, o para indicar una función especial, normalmente asociada afuncionalidades estándar del lenguaje.

_nombre

Los nombres que comienzan con un único guión bajo indican de forma débil unuso interno. Además, estos nombres no se incorporan en el espacio de nombresde un módulo al importarlo con "from ... import *".

__nombre

Los nombres que empiezan por dos guiones bajos indican su uso privado en laclase.

Por ejemplo, en la definición de clase siguiente:

class ClaseA: def __init__(self, a) self.__a = a self.x = self.__a**2 + 2 self.y = self.__a**3 + 3

el atributo __a es de uso interno de la clase y no se exporta directamente. Acontinuación podemos ver cómo trata los atributos 'privados' python:

>>> a = ClaseA(2)

>>> dir(a)

['_ClaseA__a', '__doc__', '__init__', '__module__', 'x', 'y']

>>> a.__dict__

{'x':6, 'y':11, '_ClaseA__a':2}

Todavía es posible acceder a __a, pero el nombre es transformado a '_ClaseA__a',que lo señala como un atributo de uso privado.

__nombre__

Los nombres que empiezan y acaban con dos guiones bajos indican atributos"mágicos", de uso especial y que residen en espacios de nombres que puede



manipular el usuario. Solamente deben usarse en la manera que se describe en ladocumentación de python y debe evitarse la creación de nuevos atributos de estetipo.

Algunos ejemplos de nombres "singulares" de este tipo son:__init__, método de inicialización de objetos__del__, método de destrucción de objetos__doc__, cadena de documentación de módulos, clases...__class__, nombre de la clase__str__, método que devuelve una descripción de la clase como cadena de texto__repr__, método que devuelve una representación de la clase como cadena detexto__module__, módulo al que pertenece la claseSe puede consultar la lista de atributos de este tipo y su descripción detallada enla documentación de python.

Resúmen final

La programación orientada a objetos enuncia la posibilidad de escribir unprograma como un conjunto de clases de objetos capaces de almacenar su estado,y que interactúan entre sí a través del envío de mensajes.

Las técnicas más importantes utilizadas en la programación orientada a objetosson:

Abstracción: Los objetos pueden realizar tareas, interactuar con otrosobjetos, o modificar e informar sobre su estado sin necesidad de comunicarcómo se realizan dichas acciones.Encapsulación (u ocultación de la información): los objetos impiden lamodificación de su estado interno o la llamada a métodos internos por partede otros objetos, y solamente se relacionan a través de una interfaz claraque define cómo se relacionan con otros objetos.Polimorfismo: comportamientos distintos pueden estar asociados al mismonombreHerencia: los objetos se relacionan con otros estableciendo jerarquías, y esposible que unos objetos hereden las propiedades y métodos de otrosobjetos, extendiendo su comportamiento y/o especializándolo. Los objetos seagrupan así en clases que forman jerarquías.

Las clases definen el comportamiento y estado disponible que se concreta en losobjetos.

Los objetos se caracterizan por:

Tener identidad. Se diferencian entre sí.Definir su comportamiento a través de métodos.Definir o reflejar su estado a través de propiedades y atributos.

Gracias a la amable aportación de Óscar Carballal ahora es posibledescargar una versión en PDF del artículo

http://blog.rvburke.com/wp-content/uploads/2006/11/Introducci�n-a-la-programaci�n-orientada-a-objetos.pdf



"Programación orientada a objetos en Python" was published on November 22nd, 2006 and is listed in

castellano , pascaline , programación , python .

Follow comments via the RSS Feed | Leave a comment | Trackback URL

Programación orientada a objetos en Python: 31 Comments1. Just D wrote,

Grandísimo artículo! Felicitaciones.Licenciás tus cosas bajo Creative Commons?

Saludos.

Link | December 6th, 2006 at 1:11 pm

2. NKT wrote,

Realmente muy interesante articulo. Me ha resuelto mucha de las dudas quetenia en cuanto a la jerarquia de clases en python (viniendo desde C++).

Link | February 28th, 2007 at 1:01 pm

3. Jose Fabrega wrote,

Me parece que este articulo es de gran ayuda, para todo el que se inicia enla programacion con python, por tal motivo lo recomiendo abiertamente.

Link | August 16th, 2007 at 10:32 pm

4. henry wrote,

buen articulo, sirve para aprender mucho y sacarlo de problemas. aunquefalto algo mas de relacion entre clases

Link | October 16th, 2007 at 12:00 am

5. Gonzalo Sanchez wrote,

Me gusto mucho tu articulo sobre POO, buen material has puesto y con muybuena capacidad de sistensis, te he linkeado desde mi blog, espero que note moleste.El blog trata de programacion de video juegos usando python y pygame.la direccion del blog es http://www.creatusjuegos.blogspot.com


6. pachi wrote,

Gracias por vuestros comentarios, y me alegro de que os resulte útil.


7. lopz wrote,

hola

Muy muy interesante, al fin entendí esto de las clases en python, meparecía un lio explicado de otra forma, sigue con el blog y a ver si te pones

http://blog.rvburke.com/category/castellano/

http://blog.rvburke.com/category/pascaline/

http://blog.rvburke.com/category/programacion/

http://blog.rvburke.com/category/python/

http://blog.rvburke.com/2006/11/22/programacion-orientada-a-objetos-en-python/feed/

http://blog.rvburke.com/2006/11/22/programacion-orientada-a-objetos-en-python/trackback/

http://locademiaz.blogspot.com/

http://www.hapiio.com/

http://www.creatusjuegos.blogspot.com/

http://www.creatusjuegos.blogspot.com/


http://tekkenbolivia.net/



una de python+pygtk o threads

saludos!

Link | March 14th, 2008 at 8:39 pm

8. jhuss blog · Programación orientada a objetos en Python wrote,

[...] si alguno de esos temas parece interesante, pues visite el siguientearticulo del blog de RVBurke, Programación orientada a objetos en Python[...]

Link | March 24th, 2008 at 7:20 pm

9. weoz wrote,

Buenas me gustaria saber donde puedo encotrar mas info sobre este temaen español..

gracias es que aun no entiendo muy bien los conceptps

Link | May 5th, 2008 at 10:11 pm

10. Eydolina wrote,

Estuve leyendo un poco y me agrado la información es muy concreta..gracias…..:p

Link | June 11th, 2008 at 4:01 pm

11. The Machine wrote,

WOW, excelente. Muy buen articulo, felicitaciones. Si pudieras colocar otrode GUI en Python sería fenomenal.

Link | August 15th, 2008 at 7:58 am

12. ingemar wrote,

muy buen aporte para la comunidad, te felicito esta muy especifico yconcreto tambien tiene buen uso en la parte tecnica.

sigue asi…..

Link | September 2nd, 2008 at 10:51 pm

13. cejota wrote,

Hola, muy buen articulo.

No encontre muchos en español que traten estos temas claramente.

Seria mucho pedir, si pudieras ampliar o hacer uno nuevo, sobre el uso denamespaces y modulos?

me enfrento al problema de tener directorios donde reparto las clases(modelos), las aplicaciones (scripts o clases donde tengo la logica) y config(datos especificos de la instalacion, entorno, y ubicacion en el SO de files),en config esta todos los datos especificos que pueden cambiar de maquina a

http://jhuss.com/2008/03/24/programacion-orientada-a-objetos-en-python/

http://www.gavelix.com.ve/

http://www.cjd-total.com.ar/



maquina o usuario a usuario, mas un directorio de “datos”, que serian lossources de lo que voy a procesar.

el caso es que necesitaria poder cargar esa config (digamos que es un xml)pero lo primero que llamo es a una aplicacion, que deberia poder levantarlos datos que necesite del xml.

lo ideal seria tener un bootstrap, un punto comun de entrada donde carguela config de entorno, y ahi vaya a la aplicacion, en donde ya sabra de dondecargar las clases y datos necesarios.

podrias orientarme como se hace esto en python? uso por trabajo unframework en php que esta armado asi y ahi basta con poner el string delentorno deseado para que busque ese file .Ejemplo si $user = claudioentonces config::env::$user.xml y busca en config/user/claudio.xml oimport(‘config/env/’.$user.’.php’);

saludos

Link | April 13th, 2009 at 5:59 am

14. pachi wrote,

Gracias por tu comentario cejota. Por ahora no tengo mucho tiempo paracontinuar esta serie de programación, pero tendré en cuenta tu sugerenciasi algún día la retomo.

En Python tienes mucha facilidad para hacer lo que preguntas, al serbastante sencilla la organización de espacios de nombres y poder pasar deatributos a módulos o a clases sin necesitar cambios grandes en el código.

No comprendo bien tu problema, pero si se trata de cargar distintosentornos en función de una “clave” tienes muchas formas de hacerlo. Buscaen la red por “dispatching”.

Link | April 13th, 2009 at 1:15 pm

15. airus wrote,

Está muy buena la introducción.

Link | June 15th, 2009 at 2:38 pm

16. Javier Albornoz wrote,

¡Felicitaciones por el excelente trabajo!

Es muy didáctico y por esta razón le estoy recomendando a mis estudiantesque visiten su espacio para que se documenten en el tema.

Link | July 7th, 2009 at 11:27 pm

17. adriana wrote,

excelente trabajo, felicidades el articulo es claro y preciso para lo quenecesitaba

Link | July 15th, 2009 at 1:16 am


http://hotmail/



18. Pato wrote,

Muy buen artículo. Estoy empezando con python y me ha dado una buenabase que no encontraba en otros manuales. Saludos desde Quito-Ecuador.

Link | July 30th, 2009 at 7:12 pm

19. Introduccion a la programación orientada a objetos con python :Blogde Alex Vera wrote,

[...] visitar: Programación orientada a objetos en Python [...]

Link | October 26th, 2009 at 8:10 am

20. wozgeass wrote,

buen articulo…

Link | November 8th, 2009 at 3:58 am

21. Daniel wrote,

wao… pues no dejo de sorprenderme con este lenguaje, viniendo de java oc++ uno queda como sin piso, es sencillo, facil, sin embargo la forma dehacer programas como uno tiene la idea en java por lo menos, quedaefimera o dispersa en python y en mi caso me siento perdido …. :S graciaspor el artículo serguiré leyendo.

ciao

Link | November 28th, 2009 at 11:02 am

22. pachi wrote,

Daniel, algo que te puede hacer sentir más cómodo en python es pensarque algunas de las exigencias de Java o C++ pueden ser parte de loscomentarios en lugar de código. Por ejemplo, en el caso de los atributos deuna clase, que suele resultar “raro” no tener que declararlos en elconstructor, se pueden documentar en la docstring de la clase y listo.

Link | November 28th, 2009 at 12:15 pm

23. pizte wrote,

Por fin un manual en español de clases! Debo reconocer que me resultatodavía bastante abstracto el tema de orientación a objetos, pero poco apoco le estoy cogiendo el truco, y este “miniHOWTO” ha sido un granavance.

Felicitaciones por este buen trabajo. No te has enredado con explicacionesinnecesarias que suelen venir en los manuales y lo has explicado de formabastante gráfica.

Para los que estáis preguntando por la programación de GUI’s en Python, enla página de PyGTK http://pygtk.org/tutorial.html tienen un manualtraducido al español, que aunque no está muy actualizado (data de 2005,para GTK+ 2.4, ahora estamos en la 2.16) pero sirve perfectamente paraempezar a hacer cosas útiles, ya que los cambios entre versiones no han

http://alexvera.net/2009/10/introduccion-a-la-programacion-orientada-a-objetos-con-python/

http://alexvera.net/2009/10/introduccion-a-la-programacion-orientada-a-objetos-con-python/

http://wozgeass.wordpress.com/


http://pygtk.org/tutorial.html



sido demasiado drásticos y todavía hay compatibilidad de funciones.

Un saludo!

P.D: Esta explicación de clases es lo que le falta al “superlibro” de laUniversidad Jaume I http://marmota.act.uji.es/MTP/pdf/python.pdfpara que sea el libro perfecto jeje


24. mateu wrote,

muchas gracias ha sido una definicion muy clara y práctica.

Link | January 15th, 2010 at 11:36 pm

25. m[cun] wrote,

Muy interesante tu articulo lo agradezco.

Debo decirte que tienes un error en el primer ejemplo llamas a la funciónprint fecha(d, m, a) y por supuesto da una excepción ya que no estadeclarada.la llamada correcta debe serprint dime_fecha(d, m, a) solo por si algún despistado abandona la guía alno funcionarle el 1º articulo saludos y gracias nuevamente

Link | September 13th, 2010 at 9:07 pm

26. pachi wrote,

Muchas gracias m[cun] por tus comentarios. He corregido la errata queindicas.

Link | September 13th, 2010 at 10:46 pm

27. Germán wrote,

Pachi,

Muchísimas gracias por este artículo!

Estoy comenzando a programar en Python, vengo del Fortran 77, y se mehacía una ensalada de definiciones en la cabeza esto de POO. Gracias a tuartículo, ahora las cosas están mucho más claras!

Un fuerte abrazo,Germán.


28. Heber wrote,

Excelente, estoy apenas llegando a este lenguaje por pura afición y esto delas clases y los objetos no es fácil, pero luego de leer se me ha aclaradoalgo el panorama. Gracias.

Link | January 6th, 2012 at 2:23 am

http://marmota.act.uji.es/MTP/pdf/python.pdf

http://sisiam.blogspot.com/


http://gracca.tk/



29. gabo wrote,

Excelente, Graciasel planeta es mejor con tutoriales como estos.

Link | February 9th, 2012 at 8:44 am

30. Albeiro wrote,

Me ha resultado muy útil el tutorial, me ha permitido entender bien elasunto de clases y objetos


31. Introducción a la programación orientada a objetos | CódigoRockiano wrote,

[...] bien menciona Rafael Villar Burke en su blog, la algoritmia consiste enla búsqueda de soluciones a un problema concreto, pero no nos [...]

Link | January 24th, 2013 at 10:34 pm

Leave Your Comment

Name (required)

E-mail (will not be published) (required)

Website

Your Comments

RVBurke is proudly powered by WordPress .

This blog is protected by Dave 's Spam Karma 2 : 664 Spams eaten and counting...

Omit Needless Elements theme courtesy of WordPress Design & Blog Consulting

https://twitter.com/albeirochoa

http://codigorockiano.com.ar/introduccion-a-la-programacion-orientada-a-objetos/

http://codigorockiano.com.ar/introduccion-a-la-programacion-orientada-a-objetos/


http://www.wordpress.org/

http://unknowngenius.com/blog/

http://unknowngenius.com/blog/wordpress/spam-karma/

http://www.wordpressdiva.com/themes/33/omit-needless-elements.html

http://www.creativeblogging.com/

RVBurke » Blog Archive » Programación orientada a objetos ...€¦ · RVBurke » Blog Archive »...

Documents

Transcript of RVBurke » Blog Archive » Programación orientada a objetos ...€¦ · RVBurke » Blog Archive »...