Aprende Python en 5 días (IV)

En el anterior capítulo sobre programación en Python introducíamos los objetos y nos emplazábamos a este nuevo capitulo donde los íbamos a ver en profundidad.

En primer lugar es importante diferenciar entre la programación estructurada (la que veníamos usando hasta ahora) y la programación orientada a objetos o programación funcional. Esta última, emplea objetos y clases para modelar el mundo físico de forma que nuestro programa interactúa con estos objetos a través de métodos para llegar a la solución de nuestro problema.

Concretamente, llamamos objeto a una entidad que agrupa una serie de estados (atributos) y posee una serie de funcionalidades específicas (métodos). En las clases definimos al objeto, así como sus atributos y métodos.

Veamos un ejemplo para entender este nuevo concepto de forma más sencilla:

class Car:
    """Abstraccion del objeto físico coche."""
    def __init__(self, fuel, buen_estado=True):
        self.fuel = fuel
        self.buen_estado = buen_estado

    def arrancar(self):
        if (self.buen_estado) and (self.fuel > 0):
            print "Arranca"
        else:
            print "No arranca..."

    def repostar(self, litros):
        self.fuel = self.fuel + litros

Si nos vamos ahora a una terminal para usar esta clase:

>>> from car import Car
>>> a = Car(5)
>>> a.arrancar()
Arranca
>>> b = Car(5, False)
>>> b.arrancar()
No arranca...
>>> c = test.Car(0)
>>> c.arrancar()
No arranca...
>>> c.repostar(5)
>>> c.arrancar()
Arranca

Como ves la sintaxis es clara: un class con dentro diferentes funciones. Esas funciones son nuestros métodos. Otro detalle que seguramente te ha llamado la atención es el método __init__. dicho método es una convención de Python y es el método que se llama siempre que creamos un nuevo objeto, como por ejemplo Car(5), que es equivalente a llamar al método __init__ de Car. Como ves, en dicho método es muy habitual fijar ciertos valores del objeto (atributos).

Verás que hacemos un uso importante de una nueva palabra reservada 'self' que no hace más que referenciar al propio objeto. Dicho valor se debe pasar siempre a cada atributo, aunque a la hora de llamar al método no se mencione.

También me gustaría resaltar una nueva característica interesante (que podemos emplear en cualquier función o método, aunque no usemos programación orientada a objetos). Estoy hablando de prefijar un valor de entrada a la función, de forma que si no se establece de forma específica en la llamada que se desea emplear otro valor, se toma el valor por defecto. Este comportamiento lo puedes ver en el método __init__ con el parámetro buen_estado=True.

Entorno de desarrollo

Ahora que ya tenemos todos los conocimientos base necesarios es hora de pegarnos con el lenguaje de programación para explorar sus muchas características y aplicaciones que lógicamente son inabarcables en un curso (ya sea de 5, 10 o 300 días).

Para ello vamos primero a montar un entorno de desarrollo más potente que el que explicamos en la primera entrada de este curso. Aunque sobre este tema volveré más adelante en una entrada del blog totalmente independiente a este curso, vamos a usar una primera aproximación a dicho entorno para tener en el próximo y último capítulo de este curso, el terreno preparado para embarcarnos en el uso de librerías empleando para ello una aplicación 100% real.

Doy por supuesto que ya tienes instalado un editor tipo Sublime Text, Atom, Notepad++, etc... Si no es así, te repito como hice el primer día que aunque no es obligatorio, es más que recomendado.

Vamos a usar bastante la terminal/consola a partir de ahora. Empezamos instalando 'pip', la herramienta a través de la cual instalaremos todas las demás librerías que necesitemos.

Para ello, primero nos aseguramos de que nuestra actual versión de Python es superior a la 2.7.9 o 3.4 ya que para estos casos, pip viene instalado por defecto Para ello ejecutamos el siguiente código dentro de Python:

>>> import sys
>>> sys.version
'2.7.10 (default, Aug 20 2015, 19:58:32) \n[GCC 4.2.1 Compatible Apple LLVM 6.1.0 (clang-602.0.53)]'
>>>

En mi caso, tengo la versión 2.7.10 por lo que tengo ya instalado pip. En caso contrario deberemos acudir a la web de pip y seguir las instrucciones.

Una vez tenemos pip instalado en nuestro ordenador, es el momento de instalar virtualenv. Es muy habitual, cuando programamos en cualquier lenguaje de programación, recurrir para ciertos aspectos en código desarrollado por terceros. Este código puede venir empaquetado en librerías que instalamos en nuestro equipo. Al ser nuestro código dependiente de estas librerías 'extras' es indispensable tener un control sobre ellas (control de dependencias). Gracias a esta herramienta vamos a ser capaces de montar mini-proyectos sin problemas de dependencias ya que nos va a generar entornos aislados del resto del sistema en los cuales podemos saber fácilmente y en todo momento que librerías hemos instalado. Para instalarlo, en la terminal (fuera de Python), escribimos:

pip install virtualenv

Una vez instalado, crearemos una carpeta en nuestra carpeta de usuario que llamaremos test_project en la que desarrollaremos nuestro mini-proyecto.

$ virtualenv test_project
New python executable in test_project/bin/python2.7
Also creating executable in test_project/bin/python
Installing setuptools, pip, wheel...done.
$ cd test_project
$ source bin/activate
(test_project) $

Tras aplicar estos comandos, veremos como la terminal/consola cambia un poco, anteponiendo al lugar donde escribimos '(test_project)'. Eso significa que estamos dentro del entorno virtual que virtualenv ha creado para nosotros en test_project. Concretamente, el cambio a ese entorno lo hace 'source bin/activate'

Ahora instalaremos una librería, concretamente la muy utilizada 'requests'. Para ello:

$ pip install requests
Collecting requests
  Using cached requests-2.8.1-py2.py3-none-any.whl
Installing collected packages: requests
Successfully installed requests-2.8.1

Ya tenemos instalada la librería requests y lista para usarse. Cualquier información que quieras saber de esta librería deberás recurrir a su página web: Página oficial proyecto Requests, aunque ta te adelanto que en la próxima entrada, será una de las librerías que empleemos.

Con requests, podemos hacer llamadas a servicios/urls ya sean de Internet o en nuestro propio entorno. En nuestro caso vamos a consumir los datos de una API (Application Programming Interface o interfaz de programación de aplicaciones en español) muy geek y apropiada para los tiempos que corren: SWAPI.

Entramos en Python y escribimos:

>>> import requests
>>> url = 'http://swapi.co/api/'
>>> my_data = requests.get( url + 'people/1')
>>> luke_data = my_data.json()
>>> print luke_data['height']
172
>>> exit()

¿Fácil verdad? En este caso, estamos empleando una web que nos sirve los datos de una forma muy apropiada (API) para tratarlos, pero me parece muy adecuado este ejemplo para mostrar el universo nuevo de posibilidades que se nos abre para elevar nuestra programación a otro nivel.

Antes de acabar, me he dejado en el tintero un poco cómo manejar las dependencias con pip y virtualenv:

(test_project) $ pip freeze > requirements.txt

Esta sencilla sentencia, nos creará el archivo requirements.txt que contiene todas las dependencias de nuestro proyecto. En la siguiente entrada aprenderemos el proceso contrario; instalar todas las dependencias desde el fichero requirements.txt

Por último, para salir de nuestro entorno virtual creado por virtualenv, tan solo tenemos que escribir en la terminal 'deactivate'.

En el próximo y último capítulo desarrollaremos una aplicación en la que vamos a poner en práctica todos los conceptos que hemos aprendido hasta ahora y en la que usaremos varias librerías para dotarla de su potencial.

Como siempre te digo, si te ha gustado esta entrada, no te olvides de compartirla en tus redes social y usar los comentarios para cualquier duda que te surja.

¡Hasta la próxima semana!