Además:

• El paso de mensajes agrupa las operaciones que actúan sobre ese dato dentro de una función que responde a diferentes mensajes despachando a otras funciones dependiendo del mensaje recibido.

• La función que representa al dato encapsula su estado interno junto con las operaciones que lo manipulan en una única unidad sintáctica que oculta sus detalles de implementación.

En conclusión:

La programación orientada a objetos (también llamada OOP, del inglés Object-Oriented Programming) es un método para organizar programas que reúne muchas de las ideas vistas hasta ahora.

Al igual que las funciones en las abstracciones de datos, los objetos imponen barreras de abstracción entre el uso y la implementación de los datos.

Al igual que los diccionarios y funciones de despacho, los objetos responden a peticiones que otros objetos les hacen en forma de mensajes para que se comporten de determinada manera.

Los objetos tienen un estado interno local al que no se debería acceder directamente desde el exterior de los mismos, sino únicamente por medio de las operaciones que proporciona el objeto.

A efectos prácticos, por tanto, los objetos son datos abstractos.

El sistema de objetos de Python proporciona una sintaxis cómoda para promover el uso de estas técnicas de organización de programas.

Gran parte de esta sintaxis es compartida con otros lenguajes de programación orientados a objetos.

Ese sistema de objetos ofrece algo más que simple comodidad:

• Proporciona una nueva metáfora para diseñar programas en los que varios agentes independientes interactúan dentro del ordenador.

• Cada objeto agrupa (encapsula) el estado local y el comportamiento de una manera que abstrae la complejidad de ambos.

• Los objetos se comunican entre sí y se obtienen resultados útiles como consecuencia de su interacción.

• Los objetos no sólo transmiten mensajes, sino que también comparten el comportamiento con otros objetos del mismo tipo y heredan características de otros tipos relacionados.

El paradigma de la programación orientada a objetos tiene su propio vocabulario que apoya la metáfora del objeto.

Por ejemplo, si importamos el módulo math usando import obtenemos un objeto al que se puede acceder a través de su nombre, de forma que los elementos que contiene el módulo se convierten en atributos del objeto math.

Entre ellos, hay atributos que representan variables y otros que representan funciones:

>>> import math
>>> math.pi
3.141592653589793
>>> math.cos(3)
-0.9899924966004454

Podemos usar docstrings para documentar tanto la propia clase como los métodos de la misma:

class Deposito:
    """
    Un depósito del banco.
    """

    def __init__(self, fondos):
        """Crea un depósito con una cantidad de fondos."""
        self.fondos = fondos

    def retirar(self, cantidad):
        """Retira una cantidad de dinero del depósito."""
        if cantidad > self.fondos:
            return 'Fondos insuficientes'
        self.fondos -= cantidad
        return self.fondos

    def ingresar(self, cantidad):
        """Ingresa una cantidad de dinero en el depósito."""
        self.fondos += cantidad
        return self.fondos

    def saldo(self):
        """Devuelve el saldo del depósito."""
        return self.fondos

• Por convenio, el docstring de una clase siempre se escribe usando el estilo multilínea, al igual que pasa con los módulos.

La definición de una clase es una estructura sintáctica que crea un espacio de nombres y determina su propio ámbito.

Esa definición está formada por un bloque de sentencias que se ejecutarán dentro de ese ámbito en el momento en que el intérprete ejecute la definición:

Todas las definiciones que se realicen directamente en el ámbito de la clase como consecuencia de ejecutar su bloque de sentencias, serán locales a la clase y se almacenarán en el espacio de nombres de la clase, ya que, durante la ejecución del bloque de sentencias, el espacio de nombres actual es el espacio de nombres de la clase.

Los elementos así definidos y almacenados directamente en el espacio de nombres de la clase se denominan miembros o atributos de la clase.

Las funciones que son miembros de una clase se denominan métodos de la clase.

Por ejemplo, las funciones __init__, retirar, ingresar y saldo pertenecen a la clase Deposito y sólo existen dentro de ella (son locales a la clase), porque sus definiciones se almacenan en el espacio de nombres de la clase.

Ese espacio de nombres es un marco que se almacena en la pila mientras se ejecuta la definición de la clase, y que formará parte del entorno mientras dure esa ejecución.

Cuando se termina de ejecutar la definición de la clase, se saca ese marco de la pila y se convierte en un objeto que almacena en forma de atributos a los miembros de esa clase.

Por tanto, ese objeto acaba almacenando el espacio de nombres de la clase y representando a dicha clase dentro del programa.

Recordemos que durante la definición de una función no se ejecuta su cuerpo, sino que simplemente se crea la ligadura entre el nombre de la función y la propia función.

Por tanto, al ejecutar la definición de una clase no se ejecutan los cuerpos de sus métodos.

Por ejemplo, en el código anterior:

class Deposito:
    def __init__(self, fondos):
        self.fondos = fondos

    def retirar(self, cantidad):
        if cantidad > self.fondos:
            return 'Fondos insuficientes'
        self.fondos -= cantidad
        return self.fondos

    def ingresar(self, cantidad):
        self.fondos += cantidad
        return self.fondos

    def saldo(self):
        return self.fondos

En la línea 10 tendríamos el siguiente entorno:

En general, no importa el orden en el que aparecen las definiciones dentro de la clase, salvo excepciones.

Ya sabemos que el cuerpo de una función (y recordemos que, aquí, las funciones se llaman métodos) no se ejecuta cuando se define la función, sino cuando se la llama. Por tanto, si un método usa a otro, no importará el orden en el que se hayan definido.

Por ejemplo, en el código anterior, los miembros se podrían haber definido en cualquier otro orden (retirar después de saldo, ingresar antes de __init__…, da igual).

En cambio, si hacemos una definición a partir de otra, el orden sí importará. Por ejemplo, aquí sí es importante que hola se defina antes que saludo:

class Prueba:
    def hola(self):
        print("Hola")

    saludo = hola

Como se dijo anteriormente, con las clases ocurre lo siguiente:

• Al entrar en la definición de la clase, se crea un nuevo espacio de nombres en forma de marco en la pila, que contiene las definiciones que se van creando durante la ejecución de la clase.

• Al salir de la definición de la clase, se saca el marco de la pila y con él se crea un objeto que acaba almacenando ese espacio de nombres, de forma que las ligaduras que contiene se convierten en atributos del objeto.

Ese objeto «clase» permanecerá en memoria mientras exista, al menos, una referencia que apunte a él.

Si ejecutamos la anterior definición en el Pythontutor, observamos que se crea en memoria un objeto que, como cualquier otro objeto, contiene su propio espacio de nombres representado con una estructura similar al diccionario de despacho que creábamos antes a mano, el cual almacena los miembros de la clase como atributos del objeto, asociando el nombre de cada operación con la función (mejor dicho, con el método) correspondiente.

Ese objeto representa a la clase en la memoria durante la ejecución del programa, y se liga al nombre de la clase en el espacio de nombres actual (que normalmente será el marco global).

Como las clases son objetos, debemos usar el operador punto (.) para acceder a un miembro de una clase, indicando la referencia a la clase (normalmente, su nombre) y el nombre del miembro al que se desea acceder:

>>> Deposito.retirar
<function Deposito.retirar at 0x7f6f04885160>

En realidad, todo lo que hemos dicho hasta ahora sobre la creación de clases y el acceso a sus miembros, es esencialmente el mismo mecanismo que se usa en la creación y uso de módulos.

Sin embargo, hay que tener cuidado, ya que las clases no funcionan exactamente igual que los módulos en lo que se refiere al entorno, como veremos luego en un apartado posterior.

Python es considerado un lenguaje orientado a objetos puro, ya que en Python todos los datos son objetos.

Por ejemplo, en Python:

• El tipo int es una clase.

• El entero 5 es un objeto, instancia de la clase int.

Java es un lenguaje orientado a objetos híbrido, ya que un programa Java manipula objetos pero también manipula otros datos llamados primitivos, que no son instancias de ninguna clase sino que pertenecen a un tipo primitivo del lenguaje.

Por ejemplo, en Java:

• El tipo String es una clase, por lo que la cadena "Hola" es un objeto, instancia de la clase String.

• El tipo int es un tipo primitivo del lenguaje, por lo que el número 5 no es ningún objeto, sino un dato primitivo.

En Python podemos instanciar una clase (creando así un nuevo objeto) llamando a la clase como si fuera una función, del mismo modo que hacíamos con la implementación funcional que hemos estado usando hasta ahora:

dep = Deposito(100)

Lo que ocurre al ejecutar este código es lo siguiente:

1. Se crea en el montículo un objeto, instancia de la clase Deposito, que contiene su propio espacio de nombres representado por una estructura con forma de diccionario.

2. Se invoca al método __init__ sobre el objeto recién creado (ya hablaremos de ésto más adelante).

3. La expresión Deposito(100) devuelve una referencia al nuevo objeto, que representa, a grandes rasgos, la posición de memoria donde se encuentra almacenado el objeto (su identidad).

4. Esa referencia es la que se almacena en la variable dep. O sea: en la variable no se almacena el objeto en sí, sino una referencia al objeto.

En este ejemplo, 0x7fba5a16d978 es la dirección de memoria donde está almacenado el objeto al que hace referencia la variable dep (es decir, su identidad):

>>> dep
<__main__.Deposito object at 0x7fba5a16d978>

Cuando una variable contiene una referencia a un objeto, decimos que la variable se refiere al objeto o que apunta al objeto.

Aunque actualmente las referencias representan direcciones de memoria, eso no quiere decir que vaya a ser siempre así. Ese es un detalle de implementación basada en una decisión de diseño del intérprete que puede cambiar en posteriores versiones del mismo.

Esa decisión, en la práctica, es una cuestión que no nos afecta (o no debería, al menos) a la hora de escribir nuestros programas.

Un objeto tiene existencia propia e independiente y permanecerá en la memoria siempre que haya al menos una referencia que apunte a él (en caso contrario, el recolector de basura lo eliminará).

De hecho, un objeto puede tener varias referencias apuntándole.

Por ejemplo, si hacemos:

dep1 = Deposito(100)
dep2 = dep1

tendremos dos variables que contienen la misma referencia y, por tanto, se refieren (o apuntan) al mismo objeto.

En ese caso, decimos que dep1 y dep2 son idénticas, porque las identidades de los objetos a los que apuntan son iguales, cosa que podemos comprobar usando id o is:

>>> id(dep1) == id(dep2)
True
>>> dep1 is dep2
True

No olvidemos que las variables no contienen al objeto en sí mismo, sino una referencia a éste.

Recordemos que en Python todos los tipos son clases.

Para saber la clase a la que pertenece el objeto, se usa la función type o el atributo __class__ del objeto:

>>> type(dep)
<class '__main__.Deposito'>
>>> dep.__class__
<class '__main__.Deposito'>

Se nos muestra que la clase del objeto dep es __main__.Deposito, que representa la clase Deposito definida en el módulo __main__.

Esto demuestra que el objeto recuerda su clase (la clase que se usó para instanciarlo) porque lo guarda en un atributo.

Otra forma de comprobar si un objeto es instancia de una clase determinada es usar la función isinstance(obj, cls), que devuelve True si el objeto obj es instancia de la clase cls:

>>> isinstance(4, int)
True
>>> isinstance('hola', float)
False

Por ejemplo, para acceder al atributo fondos (que aquí es una variable de instancia) de un objeto dep de la clase Deposito, se usaría la expresión dep.fondos:

>>> dep = Deposito(100)
>>> dep.fondos
100

Y podemos cambiar el valor de la variable de instancia mediante asignación:

>>> dep.fondos = 400
>>> dep.fondos
400

Por supuesto, dos objetos distintos pueden tener valores distintos en sus atributos, ya que cada atributo pertenece a un objeto determinado:

>>> dep1 = Deposito(100)
>>> dep2 = Deposito(400)
>>> dep1.fondos          # el atributo fondos del objeto dep1 vale 100
100
>>> dep2.fondos          # el atributo fondos del objeto dep2 vale 400
400

En Python es posible acceder directamente al estado interno de un objeto (o, lo que es lo mismo, al valor de sus atributos) desde el exterior del mismo, cosa que, en principio, podría considerarse una violación del principio de ocultación de información y del concepto mismo de abstracción de datos.

Incluso es posible cambiar directamente el valor de un atributo desde fuera del objeto, o crear atributos nuevos dinámicamente, haciendo simplemente una asignación.

Todo esto puede resultar chocante para un programador de otros lenguajes, pero en la práctica resulta útil al programador por la naturaleza dinámica del lenguaje Python y por el estilo de programación que promueve.

Como cualquier variable en Python, un atributo empieza a existir en el momento en el que se le asigna un valor:

>>> dep.otro
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Deposito' object has no attribute 'otro'
>>> dep.otro = 'hola'
>>> dep.otro
'hola

Por tanto, en Python, los atributos de un objeto se crean en tiempo de ejecución mediante una simple asignación.

Este comportamiento contrasta con el de otros lenguajes de programación (como Java, por ejemplo), donde los atributos de un objeto vienen determinados de antemano por la clase a la que pertenece y siempre son los mismos.

Así, en Java, dos objetos de la misma clase siempre tendrán las mismas variables de instancia, definidas por la clase (aunque la misma variable de instancia podrá tener valores distintos en los dos objetos, naturalmente).

Ese comportamiento dinámico de Python a la hora de crear atributos permite resultados interesantes imposibles de conseguir en Java, como que dos objetos distintos de la misma clase puedan poseer distintos atributos:

>>> dep1 = Deposito(100)
>>> dep2 = Deposito(400)
>>> dep1.uno = 'hola'       # el atributo uno sólo existe en dep1
>>> dep2.otro = 'adiós'     # el atributo otro sólo existe en dep2
>>> dep1.uno
'hola'
>>> dep2.uno
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Deposito' object has no attribute 'uno'
>>> dep2.otro
'adiós'
>>> dep1.otro
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Deposito' object has no attribute 'otro'

Supongamos que tenemos el objeto dep de la clase Deposito.

Si hacemos:

>>> dep.fondos
100

el intérprete devolverá el valor del atributo fondos que encuentra en el objeto dep, ya que el objeto contiene un atributo con ese nombre.

En cambio, si hacemos:

>>> dep.retirar
<bound method Deposito.retirar of <__main__.Deposito object at 0x7f65736d4a90>>

el intérprete buscará primero el atributo retirar en el objeto dep y, al no encontrarlo allí, pasa a buscarlo en la clase Deposito. Ahí sí lo encuentra, así que devuelve su valor, que en este caso es un método.

Por tanto, lo anterior es casi equivalente a hacer:

Deposito.retirar

Pero no es exactamente igual, ya que en el primer caso nos devuelve un método, mientras que en el segundo caso nos devuelve una función:

>>> dep.retirar
<bound method Deposito.retirar of <__main__.Deposito object at 0x7f65736d4a90>>
>>> Deposito.retirar
<function __main__.Deposito.retirar(self, cantidad)>

Esto no nos pilla de sorpresa, ya que sabíamos que retirar es un método para el objeto dep pero es una función para la clase Deposito.

Ya tenemos que retirar es un método para el objeto dep y que, por tanto, dep.retirar nos devuelve ese método.

Pero, ¿qué ocurre cuando se invoca a un método sobre un objeto?

No es lo mismo hacer:

dep.retirar

que hacer:

dep.retirar()

ya que en el primer caso obtenemos el valor del atributo (que es un método), pero en el segundo caso estamos invocando al método sobre el objeto.

Supongamos que o es una instancia de la clase C, que m es un método almacenado como un atributo de la clase C y que o no contiene ningún atributo que se llame m.

La ejecución del método m con argumentos a_1, a_2, \ldots, a_n sobre el objeto o tiene esta forma:

Pues bien: el intérprete de Python lo traduce por una llamada a función con esta forma:

Es decir: el intérprete llama a la función m definida en la clase C y le pasa automática e implícitamente el objeto o como primer argumento (el resto de los argumentos originales irían a continuación de o).

Esto nos vuelve a demostrar que los métodos no son más que una forma especial de función.

No olvidemos que quien almacena los métodos es la clase, no el objeto.

Por ejemplo, hacer:

>>> dep.retirar(25)

equivale a hacer:

>>> Deposito.retirar(dep, 25)

De hecho, el intérprete traduce el primer código al segundo automáticamente.

Esto facilita la implementación del intérprete, ya que todo se convierte en llamadas a funciones.

Para la clase Deposito, retirar es una función, mientras que, para el objeto dep, retirar es un método.

Aunque son la misma cosa, el intérprete los trata de forma distinta según el contexto.

El método saldo de la clase Deposito recibe un argumento self que, durante la llamada al método, contendrá el objeto sobre el que se ha invocado dicho método:

def saldo(self):
    return self.fondos

En este caso, contendrá el objeto del que se desea conocer los fondos que posee.

Por tanto, dentro de saldo, accedemos a los fondos del objeto usando la expresión self.fondos, y ese es el valor que retorna el método.

Dentro del programa, la expresión dep.saldo() se traducirá como Deposito.saldo(dep).

Es importante recordar que el parámetro self se pasa automáticamente durante la llamada al método y, por tanto, no debemos pasarlo nosotros o se producirá un error por intentar pasar más parámetros de los requeridos por el método.

El método ingresar tiene otro argumento además del self, que es la cantidad a ingresar:

def ingresar(self, cantidad):
    self.fondos += cantidad
    return self.fondos

En este caso, self contendrá el objeto en el que se desea ingresar la cantidad deseada.

Dentro del método ingresar, la expresión self.fondos representa el valor del atributo fondos del objeto self.

Por tanto, lo que hace el método es incrementar el valor de dicho atributo en el objeto self, sumándole la cantidad indicada en el parámetro.

Por ejemplo, la expresión dep.ingresar(35) se traducirá como Deposito.ingresar(dep, 35). Por tanto, en la llamada al método, self valdrá dep y cantidad valdrá 35.

Por ejemplo: en el siguiente código, al invocar al método uno sobre el objeto a de la clase A, se tienen los siguientes entornos antes y durante la invocación del método:

class A:
    def uno(self):
        print('Soy uno')

a = A()
a.uno()

El entorno del método no incluye a la propia clase A ni al objeto sobre el que se invoca el método.

Como otro ejemplo, si recordamos la clase Deposito:

class Deposito:
    def __init__(self, fondos):
        self.fondos = fondos

    def retirar(self, cantidad):
        if cantidad > self.fondos:
            return 'Fondos insuficientes'
        self.fondos -= cantidad
        return self.fondos

    def ingresar(self, cantidad):
        self.fondos += cantidad
        return self.fondos

    def saldo(self):
        return self.fondos

dep = Deposito(100)
dep.ingresar(200)

Durante la ejecución del método ingresar (digamos, en la línea 12 del código anterior), la situación en la memoria sería:

Y, por tanto, el entorno estaría formado por el marco de ingresar y el marco global, en ese orden.

En consecuencia, ni la clase Deposito ni el objeto sobre el que se invoca el método (dep o self, que son el mismo) están en el entorno del método ingresar.

Por ejemplo: en la clase Deposito, tenemos:

class Deposito:
    def __init__(self, fondos):
        self.fondos = fondos
    # ...

Ese método __init__ se encarga de crear el atributo fondos del objeto que se acaba de crear (y que recibe a través del parámetro self), asignándole el valor del parámetro fondos.

¡Cuidado! No confudir la expresión self.fondos con fondos. La primera se refiere al atributo fondos del objeto self, mientras que la segunda se refiere al parámetro fondos.

Cuando se crea un nuevo objeto de la clase Deposito, llamando a la clase como si fuera una función, se debe indicar entre paréntesis (como argumento) el valor del parámetro que luego va a recibir el método __init__ (en este caso, los fondos iniciales):

dep = Deposito(100)

La ejecución de este código produce el siguiente efecto:

1. Se crea en memoria una instancia de la clase Deposito.

2. Se invoca el método __init__ sobre el objeto recién creado, de forma que el parámetro self recibe una referencia a dicho objeto y el parámetro fondos toma el valor 100, que es el valor del argumento en la llamada a Deposito(100).

   En la práctica, esto equivale a decir que la expresión Deposito(100) se traduce a ref.__init__(100), donde ref es una referencia al objeto recién creado.

3. La expresión Deposito(100) devuelve la referencia al objeto.

4. Esa referencia es la que se almacena en la variable dep.

En resumen: la expresión C(a_1,a_2,\ldots,a_n) usada para crear una instancia de la clase C lleva a cabo las siguientes acciones:

1. Crea en memoria una instancia de la clase C y guarda en una variable temporal (llamémosla ref, por ejemplo) una referencia al objeto recién creado.

2. Invoca a ref.__init__(a_1,a_2,\ldots,a_n)

3. Devuelve ref.

En consecuencia, los argumentos que se indican al instanciar una clase se enviarán al método __init__ de la clase, lo que significa que tendremos que indicar tantos argumentos (y del tipo apropiado) como espere el método __init__.

En caso contrario, tendremos un error:

>>> dep = Deposito()  # no indicamos ningún argumento cuando se espera uno
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __init__() missing 1 required positional argument: 'fondos'
>>> dep = Deposito(1, 2)  # mandamos dos argumentos cuando se espera sólo uno
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __init__() takes 2 positional arguments but 3 were given

Es importante tener en cuenta, además, que el constructor __init__ no debe devolver ningún valor (o, lo que es lo mismo, debe devolver None), o de lo contrario provocará un error de ejecución.