Introducción a la programación en Python (día 2)

Introducción a la programación
Internet Solutions
www.codesyntax.com
Azitain industrialdea, 3-K
E-20600 Eibar
Tel.: +34 943821780
en Python
Aitzol Naberan - @aitzol

Referencias
● Presentaciones
● Día 1: http://goo.gl/gegzzv
● Día 2: http://goo.gl/1ZyrY3
● Repositorio de ejercicios
● http://goo.gl/ddlp2K

Indice
3.Programación Orientada a Objetos
1.Clases
2.Herencia
3.Herencia múltiple
4.Módulos
5.Logging y debugging
6.UnitTesting
7.Entornos virtuales y gestión de paquetes
8.Librerías de terceros (referencias)

Clases
Python es un lenguaje totalmente orientado a objetos: puedes definir tus
propias clases, heredar de tus clases o de las clases predefinidas, e
instanciar objetos de las clases definidas
Definición de clases
●Las clases en se definen con la palabra reservada class
●Como sucede con las funciones, las interfaces no se definen por separado
>>> class MiClase:
... """Clase que no hace mas que demostrar la sintaxis"""
... pass
...

Clases
El método __init__()
●El método __init__() es llamado justamente después de que la instancisa de la clase se
haya creado
●No puede ser considerado como el constructor de la clase, ya que el objeto ya se ha
creado (existe una referencia en memoria)
●Por tanto en cuanto se llama a __init__() ya tenemos una referencia del objeto
●El primer argumento de todos los métodos de clase, incluyendo __init__(), es siempre una
referencia al objeto actual de la clase
●Por convención se le llama self, pero no es una palabra reservada en Python
>>> class MiClase:
... """Clase para demostración"""
... def __init__(self, n):
... self.n = n
...

Clases
Instanciar clases
●Instanciar objetos de una clase es sencillo, simplemente se llama a la clase como si
fuera una función
● los argumentos serán los que necesite __init__()
>>> f = MiClase(100)
>>> f
<__main__.MiClase object at 0x7fe8d4f8f9e8>
>>> f.__class__
<class '__main__.MiClase'>
>>> f.__doc__
'Clase para demostración'
●Podemos conocer la clase a la que pertenece la instancia accediendo a __class__
●Podemos consultar el docstring de la clase accediendo a __doc__

Nota
Sobre _nombre, __nombre y __nombre__
●Los objetos que contiene barras bajas al inicio o al final del nombre adquieren un
significado especial
●De la guía de estilos PEP8
● Nombres que comienzan con _ : débil indicador de uso interno
● Nombres que comienzan con __:al nombrar un atributo en una clase,se invoca el
“namemangling”(dentro de la clase FooBar,__boo se convierte en _FooBar__boo;
véase abajo)
● Nombres que comienzan y terminan con __ :objetos o atributos “mágicos” que
habitan en el namespace controlado por el usuario. Usarlos siempre como están
documentados

Clases
Variables de instancia
>>> class MiClase:
... self.n = n
... def multiplica(self, p):
... self.n *= p
●self.n es una variable de instancia
●No tiene nada que ver con el n pasado a __init__
●self.n es global para la instancia, lo que quiere decir que puede ser accedido desde
otros métodos de la clase
●Las variables de instancia no se definen, se les da un valor en __init__()

Clases
Variables de clase
>>> class MiClase:
... variable_de_clase = 7
... self.n = n
... self.n *= p
●Las variables de clase se comparten entre todas las instancias de la clase
●En el ejemplo variable_de_clase es un atributo de clase.
●Generalmente, las variables de instancia son para datos únicos relativos a la instancia,
y las variables de clase son comunes para todas las instancias.

Clases
Variables de clase
●Crear variables de clase con tipos mutables puede generar resultados inesperados
>>> class Dog:
... tricks = []
... def __init__(self, name):
... self.name = name
... def add_trick(self, trick):
... self.tricks.append(trick)
...
>>> a = Dog('Fido')
>>> b = Dog('Buddy')
>>> a.add_trick('roll over')
>>> b.add_trick('play dead')
>>> a.tricks
['roll over', 'play dead']
●Al usar un tipo mutable para la variable de clase, las modificaciones que hace una
instancia se ven reflejadas en las otras instancias
●Si no es ese el funcionamiento que buscamos, deberíamos crear la variable tricks dento
de la instancia

Clases
Variables privadas
●Las variables privadas, no existen en Python
●La convención aceptada es que un nombre que comience por un guión bajo debería
considerarse como parte no pública
●Debería considerarse detalle de implementación sujeto a cambios

Clases
Algunas observaciones
●Los atributos de tipo instancia sobrescriben métodos con el mismo nombre
● Importante evitar este tipo de colisiones, ya que generan errores difíciles de
localizar
>>> class A(object):
... def p(self):
... print 'method'
... def __init__(self):
... self.p = 'attr'
...
>>> a = A()
>>> a.p()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object is not callable

Clases
Algunas observaciones
Los atributos son accesibles tanto desde los métodos de la clase como por usuarios
externos. En Python no podemos esconder los datos, todo se basa en convención.
●Usar directamente los atributos de datos desde clientes externos puede ser peligroso
●Los métodos pueden llamar a otros métodos de la instancia usando el argumento self:
>>> class MiClase:
... atributo = 7
... self.n = n
... self.n *= p
... def multiplicaYSuma(self, p):
... self.multiplica(p)
... self.n += p
...
>>> mc = MiClase(5)
>>> mc.n = 9
>>> mc.n
9

Herencia
Sintaxis de clase derivada
>>> class MiClase(ClaseDerivada):
... """Clase para demostración de herencia"""
... <declaracion1>
... .
... .
... <declaracionn>
●Las clases derivadas pueden redefinir métodos de su clase base
●Un método de la clase base puede terminar llamando a otro método de la clase derivada
que lo haya redefinido
>>> class ClaseBase:
... def f1(self):
... return self.imprimeDonde()
... def imprimeDonde(self):
... return "ClaseBase"
...
>>> class ClaseHija(ClaseBase):
... def imprimeDonde(self):
... return "ClaseHija"
...
>>> hija = ClaseHija()
>>> hija.f1()
'ClaseHija'

Herencia múltiple
●La herencia múltiple permite a las clases de Python heredar de más de una clase
●Ello permite heredar los métodos de diferentes clases
●Para ello hay que indicar las clases de las que se quiere heredar como si se tratara
de herencia simple.
>>> class Clase1:
... def metodo1(self):
... return 'metodo1'
>>> class Clase2:
... return 'metodo1'
>>> class Clase3(Clase1, Clase2):
... pass
>>> c = Class3()
>>> c.metodo1()
'metodo1'
>>> c.metodo2()
'metodo2'
Herencia

Herencia múltiple: el orden de los factores...
●El orden en el que se ejecuta la herencia es importante, dado que determina los
que heredarán las clases hijas:
>>> class Clase1:
... return 'metodoclase1'
>>> class Clase2:
... return 'metodoclase2'
... pass
>>> c = Clase3()
>>> c.metodo1()
'metodoclase1'
... pass
>>> c = Clase4()
>>> c.metodo1()
'metodoclase2'
Herencia

Crear la clase Persona
Ejercicio 7
La clase persona guardara el nombre, apellido y ciudad de nacimiento. Contendrá
También un metodo imprimir que mostrará estos datos
Tiempo: 15 min

Modulos
Librería estándar
● La librería estándar de python es un conjunto de módulos que ya vienen instalados
en una instalación estándar
● Contiene módulos con todo tipo de propósitos
● La referencia completa de la librería estándar
https://docs.python.org/3/py-modindex.html
● Módulos útiles:
● argparse → para creación de scripts para su llamada desde línea de comandos, con
soporte de parámetros
● configparser → parseador de archivos en formato ini
● csv → tratamiento de archivos csv
● datetime → fechas, horas, calendario
● email → preparación y envío de e-mails
● json → codificación/decodificación en formato JSON
● os → funciones del sistema operativo
● pickle → persistencia de objetos
● re → expresiones regulares
● sqlite3 → base de datos sqlite3
● subprocess → gestión de procesos
● tarfile → compresión de archivos (TAR)
● urllib → peticiones HTTP (web)
● zipfile → compresión de archivos (ZIP)

Sentencia import
Modulos
●No todos los módulos están disponibles en el namespace por defecto
●Para incorporar nuevos símbolos al namespace tenemos que utilizar la sentencia
import
●Formas básicas de import
● import modulo
>>> import sys
>>> sys.path
●from modulo import (metodo|atributo)
>>> from sys import path
>>> path
●from modulo import *
>>> from sys import *
>>> ps1
'>>> '
●Para poder importar un módulo este tiene que estar en el PYTHONPATH
●PYTHONPATH es una lista con rutas a directorios donde se buscan módulos

Modulos
Módulos
● Un módulo es cualquier elemento que se puede importar desde python.
● Un módulo puede ser un archivo y también puede ser una carpeta.
● Para que una carpeta se convierta en modulo se necesita que ésta contenga
un archivo llamado __init__.py
● Ejercicio 1:
● Crear un archivo llamado modulo.py con un único método llamado método que
devuelva un número.
● Desde la consola, importar el módulo modulo.py y llamar al método
● Ejercicio 2:
● Crear una carpeta llamada modulocarpeta, con 2 archivos py llamados metodo1.py
metodo2.py cada una con un método.
● Desde la consola importar los archivos del módulo y llamar a los métodos.

Ejercicio 8
Ejercicios con la librería estándar: crear archivos en un directorio
Crearemos 10 ficheros de texto dentro del directorio actual
Tiempo: 15 min

Ejercicios con la librería estándar: Recorrer un directorio y renombrar archivos
●El modulo os nos será util
●Sobretodo dos de sus funciones listdir y rename
Ejercicio 9
Renombraremos los ficheros creados en el anterior ejercicio
Tiempo: 20 min
Tips

Ejercicio 10
Ejercicios con la librería estándar: Imprimir fechas y horas en varios formatos
Utilizaremos el módulo datetime para trabajar con fechas
●Para una lista de opciones de formateo
●https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior
Tiempo: 20 min
Tips

Ejercicio 11
Ejercicios con la librería estándar: Crear una base de datos y ejecutar consultas SQL
● Crear una base de datos y ejecutar consultas SQL. En python todas las librerías de
acceso a base de datos siguen lo que se llama el DB-API, que es una especificación
para que el trabajo con cualquier tipo de base de datos sea igual.
● Aquí vamos a usar sqlite por estar incluida en la librería estándar, pero si instalamos
los módulos para mysql, postgres u Oracle, funcionaríamos de la misma forma.
● El DB-API nos da la forma para evitar SQL-INJECTION, utilizando variables al
hacer las consultas, y dejando al módulo hacer el casting adecuado (pasar a string,
integer, o lo que sea). En este ejemplo, vemos que usamos el signo ? para indicar
una variable
Tiempo: 30 min
Tips
● Tendremos que usar el modulo sqlite3
● Crear una tabla: 'CREATE TABLE curso (id int, titulo text, dia text, lugar text)'
● Insertar un dato :NSERT INTO curso values (?, "Curso Python", "20141119",
"Arrasate")'
, (i,)
●Documentación del módulo: https://docs.python.org/3.2/library/sqlite3.html

Ejercicio 12
Ejercicios con la librería estándar: Descargar la portada de una web y escribirla en
un archivo.
● Descargar la portada de una web y escribirla en un archivo.
● En la librería estándar tenemos el módulo urllib que nos permite conectarnos
a la web
● Para un uso avanzado, se recomienda instalar el módulo requests y trabajar con él
pues permite un funcionamiento sencillo y también permite lanzar las peticiones POST
(simular envíos de formularios).
Tiempo: 30 min
Tips
●Documentación urllib:https://docs.python.org/3/library/urllib.html

● Logear lo que está pasando en una aplicación es una forma muy habitual de seguir
los flujos del programa y también sirve para saber el valor de variables o imprimir en
información útil.
● Para ello, la librería estándar de python dispone del módulo logging. Por defecto
los mensajes van al “error estándar”, en python a “sys.stderr”
● Lo habitual es conectar el módulo logging para escribir en un archivo de log:
>>> logging.basicConfig(filename='ejemplo.log', level=logging.INFO)
>>> logging.info('Mensaje de error')
>>> fp = open('example.log', 'r')
>>> fp.read()
'INFO:root:Mensaje de errorn'
>>> fp.close()
>>>
Logging

● Muchas veces, aunque logeemos mensajes de error y valores de variables
necesitamos hacer un debugging en directo.
● Para ello, en la librería estándar tenemos un módulo, pdb, que nos ayuda en ello.
● En cualquier punto del programa podemos escribir una sentencia y cuando el código
llegue a esa sentencia se parará y saltara la consola para que podamos inspeccionar
la ejecución.
import urllib
url = 'http://www.euskadinnova.net/'
sock = urllib.request.urlopen(url)
import pdb
pdb.set_trace()
sock.status
fp = open('euskadiinnova.html', 'w')
fp.write(str(sock.read()))
fp.close()
logging.basicConfig(filename='ejemplo.log', level=logging.INFO)
logging.info('Mensaje de error')
fp = open('example.log', 'r')
fp.read()
fp.close()
Debugging

● Commandos del debugger:
Debugging
● n → next, ejecutar siguiente línea
● s → step, ejecutado justo antes de la ejecución de una función, lleva la ejecución
dentro de la función, para debuggear la función
● c → continue, sale de la sesión y sigue ejecutando.
● q → salir de la sesión levantando una excepción
● up → ir al método al que nos ha llamado (efecto contrario al s)
● p <nombre_variable> → imprimir el valor de una variable

Virtualenv
Entornos virtuales
●Cuando estamos desarrollando distintos proyectos es común que tengamos distintas
dependencias
●El problema viene cuando estas dependencias son excluyentes
●Para lidiar con este problema tenemos los entornos virtuales
●Un entorno virtual es un entorno totalmente independiente de otros entornos.
● Independiente de otros entornos virtuales
● Independiente
● Cada entorno virtual tiene su propio interprete Python
● Cada entorno virtual instala sus dependencias
●Los entornos virtuales en Python se gestionan con virtualenv
● Es necesario instalar este software en el sistema
● En Linux podemos usar el gestor de paquetes
● En windows es un proceso algo manual

Virtualenv
Crear entornos virtuales
●Para crear entornos virtutales (no es una shell de Python)
$> virtualenv nuevoentorno
New python executable in nuevoentorno/bin/python
Installing setuptools, pip...done.
●Este comando creará un entorno virtual nuevo llamado nuevoentorno
●Esto es lo que nos creará
nuevoentorno/
bin/
include/
lib/
local/
●En el directorio bin tendremos los ejecutables necesarios para interactuar con el
entorno virtual
●En el directorio include se encuentran algunos archivos de cabecera de C (ficheros.h)
necesarios para compilar algunas librerías
●En el directorio lib se encuentra una copia de Python (copia local para el entorno virtual

Virtualenv
Activar entornos virtuales
●Para activar el entorno virtual utilizaremos el comando source de linux
$> cd nuevoentorno
$> source bin/activate
(nuevoentorno) $>
●El cambio de promt de la shell indica que se ha activado el entorno virtual
Desactivar entornos virtuales
●Para desactivar el entorno virtual utilizaremos el comando deactivate
(nuevoentorno) $> deactivate
$>
●Nuevamente el cambio de prompt indica que se ha desactivado el entorno virtual

pip
Instalar paquetes
●Python incorpora un gestor de paquetes llamado pip
●Conceptualmente es similar a los gestores de paquetes que integran casi todas las
distribuciones Linux modernas
●Al crear un entorno virtual, se creará también una copia de pip que trabajará dentro
del entorno virtual
(nuevoentorno) $> pip install requests
Downloading/unpacking requests
Downloading requests2.4.3py2.
py3noneany.
whl (459kB): 459kB downloaded
Installing collected packages: requests
Successfully installed requests
Cleaning up...
(nuevoentorno) $> pip search feedparser
feedcache Wrapper
for Mark Pilgrim's FeedParser module which
caches feed content.
. . . #Se ha cortado la respuesta
(nuevoentorno) $> pip uninstall requests
Uninstalling requests:
. . . #Se ha cortado la respuesta

pip
Repositorio de paquetes
●¿Dónde encuentra pip los paquetes?
●Hay un repositorio central de paquetes llamado pypi
● https://pypi.python.org/pypi
●Por defecto pip busca el paquete en ese repositorio, pero se puede configurar para que
busque en otros sitios, por ejemplo, un repositorio privado de nuestra propiedad

Ejercicio
Trabajar con entornos virtuales
El objetivo de este ejercicio es crear nuestro propio entorno virtual. Una vez creado
instalaremos el framework de desarrollo web Django en este entorno virtual. Comprobar
que Django está disponible dentro del entorno virtual, y que no esta disponible para la
instalación general del sistema
Tiempo: 15 min

Librerías de terceros
Machine learning
● Scikit-learn: http://scikit-learn.org/stable/
Cálculo científico
●Ipython Notebook: http://ipython.org/notebook.html
●SciPi: http://www.scipy.org
Visualización
●Kivy: http://kivy.org/#home
●https://wiki.python.org/moin/GuiProgramming
Sistemas
●http://docs.python-guide.org/en/latest/scenarios/admin/
Desarrollo web
●Django: https://www.djangoproject.com
●Pyramid: http://www.pylonsproject.org
●Flask:http://flask.pocoo.org

Aitzol Naberan
anaberan@codesyntax.com
@aitzol

Introducción a la programación en Python (día 2)

Más contenido relacionado

La actualidad más candente (20)

Similar a Introducción a la programación en Python (día 2) (20)

Último (15)

Introducción a la programación en Python (día 2)