Universidad de Deusto

. . . .
ESIDE
Python: descubre el poder del
lenguaje scripting de moda en la
comunidad open source
Dr. Diego Lz. de Ipia Gz. de Artaza
http://paginaspersonales.deusto.es/dipina
Universidad de Deusto
. . . .
ESIDE
l otro lenguaje de programaci!n
"ue empieza con #P#

Python $ue creado por Guido %an &ossum '

http://(((.python.org/)guido/*

Da este nombre al lenguaje inspirado por el

popular grupo c!mico brit+nico ,onty Python

Guido cre! Python durante unas

%acaciones de na%idad en las "ue 'al
parecer* se estaba aburriendo
Universidad de Deusto
. . . .
ESIDE
-ola ,undo en Python
#!/usr/bin/env python
print "Hola Mundo" # "Hola Mundo"
print "hola", "mundo" # "hola mundo"
print "Hola" + "Mundo" # "HolaMundo"
Universidad de Deusto
. . . .
ESIDE
.aracter/sticas de Python I

,uy legible y elegante

Imposible escribir c!digo o$uscado

0imple y poderoso

,inimalista: todo a"uello innecesario no hay "ue escribirlo '12

32 42 #5n#*

,uy denso: poco c!digo hace mucho

0oporta objetos y estructuras de datos de alto ni%el: strings2

listas2 diccionarios2 etc.

,6ltiples ni%eles de organizar c!digo: $unciones2 clases2

m!dulos2 y pa"uetes

Python standard library '

http://(((.python.org/doc/current/lib/lib.html* contiene un sin$/n
de clases de utilidad

0i hay +reas "ue son lentas se pueden reemplazar por plugins

en . o .772 siguiendo la API para e8tender o empotrar Python
en una aplicaci!n2 o a tra%9s de herramientas como 0:IG2 sip
o Pyre8.
Universidad de Deusto
. . . .
ESIDE
.aracter/sticas de Python II

De scripting

;o tienes "ue declarar constantes y %ariables antes de utilizarlas

;o re"uiere paso de compilaci!n/lin<age

La primera %ez "ue se ejecuta un script de Python se compila y

genera bytecode "ue es luego interpretado

Alta %elocidad de desarrollo y buen rendimiento

.!digo interoperable 'como en =a%a >(rite once run e%ery(here>*

0e puede utilizar en m6ltiples plata$orma 'm+s a6n "ue =a%a*

Puedes incluso ejecutar Python dentro de una =?, '=ython*

@pen source

&az!n por la cual la Python Library sigue creciendo y creciendo

De prop!sito general

Puedes hacer en Python todo lo "ue puedes hacer con .A o =a%a2 o

m+s
Universidad de Deusto
. . . .
ESIDE
Peculiaridades sint+cticas

Python usa tabulaci!n 'o espaciado* para mostrar

estructura de blo"ues

Babula una %ez para indicar comienzo de blo"ue

DesCtabula 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
Universidad de Deusto
. . . .
ESIDE
Python %s. Perl

Los dos est+n basados en un buen

entendimiento de las herramientas necesarias
para resol%er problemas

Perl est+ basado en a(<2 sed2 and shell scripting y

su misi!n es hacer las tareas de administradores de
sistemas m+s sencillas

Python est+ basado e inspirando por @@P '@bjectC

oriented programming*

Guido %an &ossum dise! un lenguaje simple2 poderoso2 y

elegante orientado a la creaci!n de sistemas a partir de
componentes
Universidad de Deusto
. . . .
ESIDE
Python %s. =a%a

=a%a es un lenguaje de programaci!n muy completo

"ue o$rece:

Amplio abanico de tipos de datos

0oporte para threads

0trong typing

D mucho m+s ...

Python es un lenguaje de scripting:

;o o$rece strong typing

Eueno para prototipos pero malo para grandes sistemas

Puede cascar en tiempo de ejecuci!n

Bodo lo "ue puedes hacer con =a%a tambi9n lo puedes

hacer con Python

Incluso puedes acceder a tra%9s de Python a las API de =a%a si

usas =ython 'http://(((.jython.org*
Universidad de Deusto
. . . .
ESIDE
Python %s. =ython

Python

Bambi9n llamado .python

Implementaci!n del lenguaje Python en .

Python . API permite e8tender Python con librer/as

realizadas en .

Partes "ue re"uieren mayor rendimiento en Python

est+n implementadas en . o .77 y tan s!lo
contienen una pe"uea capa de Python encima

=ython

Implementaci!n de Python en =a%a

Permite acceder a todas las APIs de =a%a

P.. Podemos producir 0(ing GFIs desde Python

Universidad de Deusto
. . . .
ESIDE
GPara "u9 HnoI es 6tilJ

Python no es el lenguaje per$ecto2 no es bueno para:

Programaci!n de bajo ni%el 'systemCprogramming*2 como

programaci!n de dri%ers y <ernels

Python es de demasiado alto ni%el2 no hay control directo sobre

memoria y otras tareas de bajo ni%el

Aplicaciones "ue re"uieren alta capacidad de computo

;o hay nada mejor para este tipo de aplicaciones "ue el %iejo .

Python es ideal:

.omo lenguaje >pegamento> para combinar %arios componentes

juntos

Para lle%ar a cabo prototipos de sistema

Para la elaboraci!n de aplicaciones cliente

Para desarrollo (eb y de sistemas distribuidos

Para el desarrollo de tareas cient/$icas2 en los "ue hay "ue

simular y prototipar r+pidamente
Universidad de Deusto
. . . .
ESIDE
Instalar Python

Eajar %ersi!n de Python de

http://(((.python.org/do(nload/

Para :indo(s ejecutar instalador

Para Linu82 usar rpms disponibles en:

http://(((.python.org/K.L.L/rpms.html

rpm %iv
python!&'%!&'&'%pydotor(&i')*&rpm
Universidad de Deusto
. . . .
ESIDE
Fsando Python desde l/nea
comando

Para arrancar el int9rprete 'Python interacti%o* ejecutar:

+ python
,ython !&'&' (#1, -e. '/ !//', /):!0:!1
2344 '&'&1 (.y(5in( spe.ial6 on .y(5in
7ype "help", ".opyri(ht", ".redits" or "li.ense" for more
information&
888

Fn comando simple:
888 print "Hola Mundo"
Hola Mundo
888

Para salir del int9rprete .trlCD 'en Linu8* o .trlCM 'en Linu8* o:
888 import sys
888 sys&exit(
+
Universidad de Deusto
. . . .
ESIDE
jecutando programa
holamundo.py

Python desde script:

Guardar siguientes sentencias en $ichero: holamundo&py

#!/usr/bin/env
python print "Hello 9orld"

jecutar el script desde l/nea de comando:

+ python hello5orld&py
Hello 9orld
+
Universidad de Deusto
. . . .
ESIDE
0entencias y blo"ues

Las sentencias acaban en nue%a l/nea2 no en #

Los blo"ues son indicados por tabulaci!n "ue sigue a una sentencia
acabada en #:#. .j. 'blo:ue&py*:
# .omentarios de l;nea se indi.an .on .ar<.ter =#=
name > "-ie(o1" # asi(na.i?n de valor a variable
if name >> "-ie(o":
print "@upa -ie(o"
else:
print "ABuiCn eresD"
print "EFo eres -ie(o!"
+ python blo:ue&py
ABuiCn eresD
EFo eres -ie(o!
Universidad de Deusto
. . . .
ESIDE
Identi$icadores

Los identi$icadores sir%en para nombrar %ariables2

$unciones y m!dulos

Deben empezar con un car+cter no num9rico y contener

letras2 n6meros y #G#

Python es case sensiti%e

Palabras reser%adas:

and elif (lobal or assert else if pass breaH

ex.ept import print .lass exe. in raise
.ontinue finally is return def for lambda try
del from not 5hile

?ariables y $unciones delimitadas por GG corresponden

a s/mbolos impl/citamente de$inidos:

GGnameGG nombre de $unci!n

GGdo.GG documentaci!n sobre una $unci!n

GGinitGG( constructor de una clase

Universidad de Deusto
. . . .
ESIDE
Bipos de datos I

;um9ricos 'integer2 long integer2 $loatingCpoint2 and

comple8*
888 x > I
888 int (x
I
888 lon((x
IJ
888 float(x
I&/
888 .omplex (I, &!
(I+/&!K
Universidad de Deusto
. . . .
ESIDE
Bipos de datos II

0trings2 delimitados por un par de '=2 " 2"""*

Dos string juntos sin delimitador se unen

888 print "Hi" "there"
Hithere

Los c!digos de escape se e8presan a tra%9s de #5#:

888print =Ln=

&a( strings
888 print r=LnLL= # no se =es.apa= Ln

Lo mismo = "ue ", p&e& "LL2fooLL6" r=L2fooL6=

Algunos de los m9todos "ue se pueden aplicar a un string son:

888 len(=Ja vida es mu.ho meKor .on ,ython&=
888 'I
888 =Ja vida es mu.ho meKor .on ,ython&=&upper(
=J@ MN-@ OP MQ4HR MOSRT 4RF ,U7HRF=
888 "Ja vida es mu.ho meKor .on ,ython"&find(",ython"
!V
888 "Ja vida es mu.ho meKor .on ,ython"&find(=,erl=
%1
888 =Ja vida es mu.ho meKor .on ,ython=&repla.e(=,ython=, =Sython=
=Ja vida es mu.ho meKor .on Sython=
Universidad de Deusto
. . . .
ESIDE
Bipos de datos III

l m!dulo strin( de la Python library de$ine

m9todos para manipulaci!n de strings:
888 import strin(
888 s1 > =Ja vida es meKor .on ,ython=
888 strin(&find(s1, =,ython=
!1

=W= es el operador de $ormateo de cadenas:

888 provin.ia > =@raba=
888 "Ja .apital de Ws es Ws" W (provin.ia,
"3asteiX"
=Ja .apital de @raba es 3asteiX=

Los caracteres de $ormateo son los mismos "ue en .2 p.e. d2 f2 x

Universidad de Deusto
. . . .
ESIDE
Bipos de datos I?

Listas 26

Inde8adas por un entero comienzan en N:

888 meses > 2"Onero", "Yebrero"6
888 print meses2/6
Onero
888 meses&append("MarXo"
888 print meses
2=Onero=, =Yebrero=, =MarXo=6

Dos puntos ':* es el operador de rodajas2 permite trabajar con una

porci!n de la lista2 el elemento indicado por el segundo par+metro no se
incluye:
888 print meses21:!6
2=Yebrero=6

,+s '7* es el operador de concatenaci!n:

888 print meses+meses
2=Onero=, =Yebrero=, =MarXo=, =Onero=, =Yebrero=,
=MarXo=6
Universidad de Deusto
. . . .
ESIDE
Bipos de datos I?

Las listas pueden contener cual"uier tipo de objetos Python:

888 meses&append (meses
888 print meses
2=Onero=, =Yebrero=, =MarXo=, 2=Onero=, =Yebrero=, =MarXo= 66
888 meses&append(1
2=Onero=, =Yebrero=, =MarXo=, 2=Onero=, =Yebrero=, =MarXo= 6, 16

Para aadir un elemento a una lista:

OOO items P HQ2 RI
OOO items.insert'N2 CS*
OOO items
HCS2 Q2 RI

Para usar una lista como una pila2 se pueden usar append y pop:
OOO items.append'TTT*
OOO items HCS2 Q2 R2 TTTI
OOO items.pop'*
TTT
OOO items HCS2 Q2 RI
Universidad de Deusto
. . . .
ESIDE
Bipos de datos ?

Buplas (2 lo mismo "ue listas2 pero no se pueden modi$icar2 e.j. (1,

!

Diccionarios "$ arrays asociati%os o mapas2 inde8ados por una cla%e2 la

cual puede ser cual"uier objeto Python2 aun"ue normalmente es una
tupla:
888 mydi.t > ""altura" : "media", "habilidad" : "intermedia",
"salario" : 1/// $
888 print mydi.t
"altura=: =media=, =habilidad=: =intermedia=, =salario=: 1///$
888 print mydi.t2"habilidad"6
intermedia

Puedes comprobar la e8istencia de una cla%e en un diccionario usando

hasGHey:
if mydi.t&hasGHey(=altura=:
print =Fodo en.ontrado=

Lo mismo se podr/a hacer:

if =altura= in mydi.t:
print =Fodo en.ontrado=
Universidad de Deusto
. . . .
ESIDE
.ontrol de $lujo: condicionales

.j. 'condicional.py*
: > I
h > 1
if : Z h :
print "primer test pasado"
else:
print "se(undo test pasado"
888 python .ondi.ional&py
primer test pasado

@peradores booleanos: >or2> >and2> >not>

@peradores relacionales: >>, 8, Z, >

Universidad de Deusto
. . . .
ESIDE
.ontrol de $lujo: bucles

for se utiliza para iterar sobre los miembros de una

secuencia

0e puede usar sobre cual"uier tipo de datos "ue sea una

secuencia 'lista2 tupla2 diccionario*

j. bu.le&py
for x in ran(e(1,1:
print x
+ python bu.le&py
1 ! ' I

La $unci!n range crea una secuencia descrita por

(2start,6 end 2,step62 donde los campos
start y step son opcionales. Ptart es N y step
es S por de$ecto.
Universidad de Deusto
. . . .
ESIDE
.ontrol de $lujo: bucles

5hile es otra sentencia de repetici!n. jecuta un blo"ue de

c!digo hasta "ue una condici!n es $alsa.

breaH nos sir%e para salir de un bucle

Por ejemplo:
reply > =repite=
5hile reply >> =repite=:
print =Hola=
reply > ra5Ginput(=Nntrodu.e "repite" para
ha.erlo de nuevo: =

Hola
Nntrodu.e "repite" para ha.erlo de nuevo:
repite
Hola
Nntrodu.e "repite" para ha.erlo de nuevo: adi?s
Universidad de Deusto
. . . .
ESIDE
Uunciones

Fna $unci!n se declara usando la palabra cla%e def

# fun.ionsimple&py
def myfun.(a,b:
sum > a + b
return sum
print myfun. (1,*
+ python fun.ionsimple&py
11

A una $unci!n se le pueden asignar par+metros por de$ecto:

# fun.ionvaloresdefe.to&py
def myfun.(a>I,b>*:
sum > a + b
return sum
print myfun.(
print myfun.(b>) # a es I, sobrees.ribir b a )
+ python fun.ion&py
1/
1!
Universidad de Deusto
. . . .
ESIDE
Uunciones

Listas de argumentos y argumentos basados en palabras cla%e:

# fun.ionar(umentosvariablesy.on.lave&py
def test@r(JistsG1([ar(s, [[H5ar(s:
print =ar(s:=, ar(s
print =H5ar(s:=, H5ar(s
test@r(JistsG1(=aaa=, =bbb=, ar(1>=...=, ar(!>=ddd=
def test@r(JistsG!(ar(/, [ar(s, [[H5ar(s:
print =ar(/: "Ws"= W ar(/
print =ar(s:=, ar(s
print =H5ar(s:=, H5ar(s
print =>= [ I/
test@r(JistsG!(=un primer ar(umento=, =aaa=, =bbb=, ar(1>=...=,
ar(!>=ddd=

?isualizar/a:
ar(s: (=aaa=, =bbb=
H5ar(s: "=ar(1=: =...=, =ar(!=: =ddd=$
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
ar(/: "un primer ar(umento"
ar(s: (=aaa=, =bbb=
H5ar(s: "=ar(1=: =...=, =ar(!=: =ddd=$
Universidad de Deusto
. . . .
ESIDE
.lases

Fna clase contiene una colecci!n de m9todos. .ada m9todo contiene como primer
par+metro 'self* "ue hace re$erencia a un objeto

self e"ui%alente a this en .77

# .lasepin(uinos&py
.lass ,en(uin,en:
def GGinitGG(self:
self&pen(uin4ount > /
def add (self, number > 1:
""" @dd pen(uins to the pen& 7he default number is 1 """
self&pen(uin4ount > self&pen(uin4ount + number
def remove (self, number > 1:
""" Temove one or more pen(uins from the pen """
self&pen(uin4ount > self&pen(uin4ount % number
def population (self:
""" Ho5 many pen(uins in the penD """
return self&pen(uin4ount
pen(uin,en > ,en(uin,en(
pen(uin,en&add(1 # 7ux y su familia
print pen(uin,en&population(
+ python ,en(uin,en&py
1
Universidad de Deusto
. . . .
ESIDE
,+s clases
# .lasesheren.ia&py
.lass \asi.:
def GGinitGG(self, name:
self&name > name
def sho5(self:
print =\asi. %% name: Ws= W self&name
.lass Ppe.ial(\asi.: # entre parCntesis la .lase base
def GGinitGG(self, name, edible:
\asi.&GGinitGG(self, name # se usa \asi. para referir a
self&upper > name&upper( # .lase base
self&edible > edible
def sho5(self:
\asi.&sho5(self
print =Ppe.ial %% upper name: Ws&= W self&upper,
if self&edible:
print "Nt=s edible&"
else:
print "Nt=s not edible&"
def edible(self:
return self&edible
Universidad de Deusto
. . . .
ESIDE
Probando clases
obK1 > \asi.(=ManXana=
obK1&sho5(
print =>= [ '/
obK! > Ppe.ial(=FaranKa=, 1
obK!&sho5(

?isualizar/a:
\asi. %% name: ManXana
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
\asi. %% name: FaranKa
Ppe.ial %% upper name: F@T@FS@& Nt=s edible&
Universidad de Deusto
. . . .
ESIDE
8cepciones

.ada %ez "ue un error ocurre se lanza una e8cepci!n2 %isualiz+ndose

un e8tracto de la pila del sistema. .j. ex.ep.ion&py:
#!/usr/bin/python
print a
+ print ex.eption&py
7ra.eba.H (innermost last: Yile "ex.eption&py", line !, in
D print a FameOrror: a

Para capturar la e8cepci!n se usa ex.ept:

try:
fh>open("ne5&txt", "r"
ex.ept NROrror, e:
print e
+ python ex.ep.ion&py
2Orrno !6 Fo su.h file or dire.tory: =ne5&txt=

Puedes lanzar tu propia e8cepci!n usando el comando raise:

raise MyOx.eption
raise PystemOxitModules
Universidad de Deusto
. . . .
ESIDE
8cepciones personalizadas
# ex.ep.ionpersonaliXada&py
.lass O(TuntimeOrror:
def GGinitGG(self, ms(:
self&ms( > ms(
def (etMs((self:
return self&ms(
try:
raise O(=mi mensaKe de error=
ex.ept O, obK:
print =Ms(:=, obK&(etMs((

?isualizar/a:
Ms(: mi mensaKe de error
Universidad de Deusto
. . . .
ESIDE
,!dulos

Fn m!dulo es una colecci!n de m9todos en un $ichero "ue

acaba en &py. l nombre del $ichero determina el nombre del
m!dulo en la mayor/a de los casos.

.j. modulo&py:
def one(a:
print "in one"
def t5o (.:
print "in t5o"

Fso de un m!dulo:
888 import modulo
888 dir(modulo # lista .ontenidos m?dulo
2=GGbuiltinsGG=, =GGdo.GG=, =GGfileGG=, =GGnameGG=,
=one=, =t5o=6
888 modulo&one(!
in one
Universidad de Deusto
. . . .
ESIDE
,!dulos II

import hace "ue un m!dulo y su contenido sean

disponibles para su uso.

Algunas $ormas de uso son:

import test

Importa modulo test. &e$erir a x en test con >test&x>.

from test import x

Importa x de test. &e$erir a x en test con >x>.

from test import [

Importa todos los objetos de test. &e$erir a x en test

con >x>.
import test as the7est

Importa test1 lo hace disponible como the7est. &e$erir

a objecto x como >the7est&x>.
Universidad de Deusto
. . . .
ESIDE
Pa"uetes I

Fn pa"uete es una manera de organizar un conjunto de

m!dulos como una unidad. Los pa"uetes pueden a su %ez
contener otros pa"uetes.

Para aprender como crear un pa"uete consideremos el

siguiente contenido de un pa"uete:
pa.Ha(eGexample/
pa.Ha(eGexample/GGinitGG&py
pa.Ha(eGexample/module1&py
pa.Ha(eGexample/module!&py

D estos ser/an sus contenidos:

# GGinitGG&py
# Oxponer defini.iones de m?dulos en este pa:uete&
from module1 import .lass1
from module! import .lass!
Universidad de Deusto
. . . .
ESIDE
Pa"uetes II
# module1&py
.lass .lass1:
def GGinitGG(self:
self&des.ription > =.lass #1=
def sho5(self:
print self&des.ription
# module!&py
.lass .lass!:
def GGinitGG(self:
self&des.ription > =.lass #!=
def sho5(self:
print self&des.ription
Universidad de Deusto
. . . .
ESIDE
Pa"uetes III
# testpa.Ha(e&py
import pa.Ha(eGexample
.1 > pa.Ha(eGexample&.lass1(
.1&sho5(
.! > pa.Ha(eGexample&.lass!(
.!&sho5(

?isualizar/a:
.lass #1
.lass #!

La localizaci!n de los pa"uetes debe especi$icarse o bien a

tra%9s de la %ariable de entorno ,U7HRF,@7H o en c!digo del
script mediante sys&path
Universidad de Deusto
. . . .
ESIDE
Pa"uetes I?

.omo en =a%a el c!digo de un pa"uete puede recogerse en un &Xip:

888 import Xipfile
888 a>Xipfile&,y]ipYile(=mipa.Ha(e&Xip=, =5=, Xipfile&]N,G-OYJ@7O-
888 a&5ritepy(=pa.Ha(eGexample=
888 a&.lose(
888 ^]

Luego lo puedes importar y usar insertando su path en sys&path o

alternati%amente aadiendo a la %ariable de entorno ,U7HRF,@7H una
re$erencia al nue%o .zip creado:
+ mHdir prueba# .p mipa.Ha(e&Xip prueba
+ export ,U7HRF,@7H>/home/dipina/examples/prueba/mipa.Ha(e&Xip
888 import sys # esta y la si(uiente no ha.en falta si se ha
ini.ialiXado ,U7HRF,@7H
888 sys&path&insert(/, =/home/dipina/examples/prueba/mipa.Ha(e&Xip=
888 import pa.Ha(eGexample
888 .lass1 > pa.Ha(eGexample&module1&.lass1(
888 .lass1&sho5(
.lass #1
888 ^]
Universidad de Deusto
. . . .
ESIDE
,anejo de $icheros

Leer un $ichero 'leerfi.hero&py*

fh > open("holamundo&py" # open .rea un obKeto 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"

scribir un $ichero 'es.ribirfi.hero&py*

fh > open("out&txt", "5"
fh&5rite ("estamos es.ribiendo &&&Ln"
fh&.lose(
+ python es.ribirfi.hero&py
+ .at out&txt
estamos es.ribiendo &&&
Universidad de Deusto
. . . .
ESIDE
,+s sobre print

print (printredire.t&py*

stdout en Python es sys&stdout, stdin es sys&stdin:

import sys
.lass ,rintTedire.t:
def GGinitGG(self, filename:
self&filename > filename
def 5rite(self, ms(:
f > file(self&filename, =a=
f&5rite(ms(
f&.lose(
sys&stdout > ,rintTedire.t(=tmp&lo(=
print =Jo( messa(e #1=
print =Jo( messa(e #!=
print =Jo( messa(e #'=
Universidad de Deusto
. . . .
ESIDE
?ariables globales en Python

Fsar identi$icador (lobal para re$erirse a %ariable global:

# variable(lobal&py
F@MO > "ManXana"
def sho5G(lobal(:
name > F@MO
print =(sho5G(lobal nombre: Ws= W name
def setG(lobal(:
(lobal F@MO
F@MO > =FaranKa=
name > F@MO
print =(setG(lobal nombre: Ws= W name
sho5G(lobal(
setG(lobal(
sho5G(lobal(

Lo cual %isualizar/a:
(sho5G(lobal nombre: ManXana
(setG(lobal nombre: FaranKa
(sho5G(lobal nombre: FaranKa
Universidad de Deusto
. . . .
ESIDE
0erializaci!n de objetos

,i.Hle: Python @bject 0erialization

l m!dulo pi.Hle implementa un algoritmo para la serializaci!n y

deserializaci!n de objetos Python

Para serializar una jerar"u/a de objetos2 creas un Pi.Hler2 y luego

llamas al m9todo dump(

Para deserializar creas un Qnpi.Hler e in%ocas su m9todo load(

method.

l m!dulo shelve de$ine diccionarios persistentes2 las cla%es

tienen "ue ser strings mientras "ue los %alores pueden ser
cual"uier objeto "ue se puede serializar con pi.Hle
import shelve
d > shelve&open(filename # abre un fi.hero
d2Hey6 > data # (uarda un valor baKo Hey
data > d2Hey6 # lo re.upera
del d2Hey6 # lo borra
Universidad de Deusto
. . . .
ESIDE
Programaci!n de ED en
Python

Lo "ue es =DE. en =a%a es DE API en Python

In$ormaci!n detallada en: http://(((.python.org/topics/database/

Para conectarnos a una base de datos usamos el m9todo .onne.t del

m!dulo de base de datos utilizado "ue de%uel%e un objeto de tipo
cone.tion

l objeto .onne.tion tiene el m9todo .ursor( "ue sir%e para

recuperar un cursor de la ED

@tros m9todos de$inidos en .onne.tion son .lose(2 .ommit(2

rollba.H(2 .ursor(

l objeto cursor de$ine entre otros los siguientes m9todos:

exe.ute( nos permite en%iar una sentencia 0VL a la ED

fet.hone( recuperar una $ila

fet.hall( recuperar todas las $ilas

-ay %arios m!dulos "ue implementan el est+ndar DECAPI:

D.@racle 'http://(((.zope.org/Products/D.@racle/* creado por Mope

,y0VLdb 'http://source$orge.net/projects/mys"lCpython*

,y0VLCpython.e8eCN.W.K.(inLKCpyK.L.e8e para :indo(s

,y0VLCpythonCN.W.KCS.iLXR.rpm para Linu8

tc.
Universidad de Deusto
. . . .
ESIDE
jemplo programaci!n ED en
Python con ,y0VL I

.reamos una base de datos de nombre deusto a la "ue podemos hacer login con
usuario deusto y pass(ord deusto, a travCs del si(uiente PBJ:
4TO@7O -@7@\@PO deusto#
3T@F7 @J7OT, POJO47,NFPOT7,Q,-@7O,-OJO7O,4TO@7O,-TR,
RF deusto&[
7R deusto_=W=
N-OF7NYNO- \U =deusto=#
3T@F7 @J7OT, POJO47,NFPOT7,Q,-@7O,-OJO7O,4TO@7O,-TR,
RF deusto&[
7R deusto_lo.alhost
N-OF7NYNO- \U =deusto=#
Qse deusto#
4TO@7O 7@\JO OMOF7RP(N- int(11 FR7 FQJJ ,TNM@TU `OU,
FRM\TO M@T4H@T(!1/, JR4@JN]@4NRF M@T4H@T(!1/, YO4H@ bi(int(!/,
-OP4TN,4NRF M@T4H@T(!1/#
NFPOT7 NF7R OMOF7RP M@JQOP (/, =POM@F@ OPN-O=, =OPN-O%-OQP7R=, /,
=4harla sobre ,ython=#
Universidad de Deusto
. . . .
ESIDE
jemplo programaci!n ED en
Python con ,y0VL II
# db/a..esodbeventos&py
import MyPBJdb, time, strin(, Gmys:l, Gmys:lGex.eptions
def exe.utePBJ4ommand(.ursor, .ommand:
result > ""
.ommand > strin(&strip(.ommand
if len(.ommand:
try:
.ursor&exe.ute(.ommand # OKe.uta el .omando
if strin(&lo5er(.ommand&starts5ith(=sele.t=:
# si es una sele.t &&&
lines > .ursor&fet.hall( # re.uperar todos los
resultados
for line in lines:
for .olumn in line:
if .olumn >> Fone:
result > result + =null =
else:
result > result + str(.olumn + = =
result > result + =Ln=
ex.ept Gmys:lGex.eptions&,ro(rammin(Orror, e:
print e
sys&exit(
return result
Universidad de Deusto
. . . .
ESIDE
jemplo programaci!n ED en
Python con ,y0VL III
if GGnameGG >> =GGmainGG=:
db>MyPBJdb&.onne.t(host>"lo.alhost",user>"deusto", pass5d>"deusto",
db>"deusto"
.ursor > db&.ursor(
exe.utePBJ4ommand(.ursor, "update eventos set fe.ha>" + str(time&time
([1///
results > exe.utePBJ4ommand(.ursor, "sele.t [ from eventos"
print results
print results&split( # .rear una lista y la visualiXa
del .ursor

?isualizando lo siguiente:
+ python a..esodbeventos&py
/ POM@F@ OPN-O OPN-O%-OQP7R 1/V)0/111**1/ 4harla sobre ,ython
2=/=, =POM@F@=, =OPN-O=, =OPN-O%-OQP7R=, =1/V)0/111**1/=, =4harla=,
=sobre=, =,ython=6
Universidad de Deusto
. . . .
ESIDE
Programaci!n de e8presiones
regulares I

A tra%9s del m!dulo re2 Python permite el uso de e8presiones

regulares similares a como se hace en Perl 'una raz!n m+s para
mo%erse de Perl a Python*
# re(ex/pro.esaQrl4onTe&py
import re, urllib, sys
if len(sys&ar(v Z> I:
print "Qsa(e: pro.esaQrl Zurl%a%pro.esar8 Zpalabra%a%
reemplaXar8 Znueva%palabra8 Zfi.hero%html%a%.rear8"
sys&exit(/
print sys&ar(v216
s > (urllib&urlopen(sys&ar(v216&read( # lee el .ontenido de
una url
# reemplaXa todas las o.urren.ias de "@rtaXa" por "artaXa"
t > re&sub(sys&ar(v2!6, sys&ar(v2'6, s
ba.HupYile > open(sys&ar(v2I6, "5"
ba.HupYile&5rite(t
ba.HupYile&.lose(
print =Yi.hero = + sys&ar(v2I6 + = es.rito .on .ontenido de
url: = + sys&ar(v216 + = al reemplaXar palabra = + sys&ar(v
2!6 + = .on palabra = + sys&ar(v2'6
Universidad de Deusto
. . . .
ESIDE
Programaci!n de e8presiones
regulares II
# .onse(uir el titulo del do.umento H7MJ
tmat.h > re&sear.h(r=Ztitle8(&[DZ/title8=, s, re&N3FRTO4@PO
if tmat.h:
title > tmat.h&(roup(1
print =7itulo de pa(ina = + sys&ar(v216 + = es: = + title
# extraer lista de enla.es url:
pat > re&.ompile(r=(http://2L5%6[2&L5%6+=
addrs > re&findall(pat, s
print =Ja lista de enla.es en.ontrados en esta pa(ina es: =
for enla.e in addrs:
print enla.e
Universidad de Deusto
. . . .
ESIDE
Programaci!n de sistemas

Por poder se puede incluso lle%ar a cabo la programaci!n de

sistemas en Python: programaci!n de API de :indo(s '
http://(((.python.org/(indo(s/inde8.html* y F;IY 'm!dulo
os*

l m!dulo os nos da acceso a:

l entorno del proceso: (et.5d(2 (et(id(2 (etpid(

.reaci!n de $icheros y descriptores: .lose(2 dup(2 dup!(2

fstat(2 open(2 pipe(2 stat(, so.Het(

Gesti!n de procesos: exe.le(2 exe.v(2 Hill(2 forH(2

system(

Gesti!n de memoria mmap(

l m!dulo threadin( permite la creaci!n de threads en

Python

0iguiente transparencia muestra como usar m!dulo

threadin( para recuperar el contenido de %arias urls
Universidad de Deusto
. . . .
ESIDE
jemplo threads
#!/usr/bin/env python
import threadin( # threadin(/eKemplothreadin(&py
import urllib
.lass Yet.hQrl7hread(threadin(&7hread:
def GGinitGG(self, url, filename:
threadin(&7hread&GGinitGG(self
self&url > url
self&filename > filename
def run(self:
print self&(etFame(, "Yet.hin( ", self&url
f > open(self&(etFame(+self&filename, "5"
.ontent > urllib&urlopen(self&url&read(
f&5rite(.ontent
f&.lose(
print self&(etFame(, "Paved in ", (self&(etFame(+self&filename
urls > 2 (=http://555&python&or(=, =index&html=,
(=http://pa(inaspersonales&deusto&es/dipina=, =index&html= 6
# Te.uperar el .ontenido de las urls en diferentes threads
for url, file in urls:
t > Yet.hQrl7hread(url, file
t&start(
Universidad de Deusto
. . . .
ESIDE
Programaci!n de .GIs

Pasos para desarrollar .GIs en Python:

Instalar Apache K.N2 disponible en:

http://httpd.apache.org/do(nload.cgi

Instalar modZpython L.S.Kb:

http://httpd.apache.org/modules/pythonCdo(nload.cgi

.on$igurar Apache aadiendo a httpd&.onf las siguientes l/neas2

para dar soporte a .GIs en Python y P0Ps 'Python 0er%er Pages*:
Z-ire.tory "Zdir%donde%(uardar%python%s.ripts8"8
@ddHandler modGpython &py
,ythonHandler modGpython&publisher
,ython-ebu( Rn
Z/-ire.tory8
Z-ire.tory "Zdir%donde%(uardar%pa(inas%psp8"8
@ddHandler modGpython &psp
,ythonHandler modGpython&psp
,ython-ebu( Rn
Z/-ire.tory8

Fsar el m!dulo .(i de la Python Library para programar y

seguir documentaci!n de modGpython 'http://
(((.modpython.org/li%e/current/docChtml/*
Universidad de Deusto
. . . .
ESIDE
jemplo .GI I
# .(i%bin/python/holamundo&py
# metodos de ayuda del 43N
def Gformat@sH7MJ(re:, .ontent:
re:&.ontentGtype > "text/html"
return "Zhtml8Zhead8Ztitle8Hola Mundo ,ython
43NZ/title8Z/head8Zbody8Zh18OKemplo ,ython de 43NZ/h18Zp8" +
.ontent + "Z/p8Z/body8Z/html8"
def Gusa(e(:
return "Qso: -ebes espe.ifi.ar un parametro de nombre a:uienb,
para saber a :uien saludar, e&K: http://lo.alhost:)/)//.(i%
bin/python/holamundo&py/diHolaD:uien>-ie(o"
Universidad de Deusto
. . . .
ESIDE
jemplo .GI II
# cni.o mCtodo pcbli.o :ue se puede invo.ar al :ue hay :ue pasar
obli(atoriamente un parametro
def diHola(re:, :uien>"":
if not :uien:
return Gformat@sH7MJ(re:, Gusa(e(
return Gformat@sH7MJ(re:, "EHola " + :uien + "!"
# si no se espe.ifi.a un metodo en la url se invo.a index por defe.to,
# es de.ir http://lo.alhost:)/)//.(i%bin/python/holamundo&py
def index(re:, [[params:
params,assedPtr > ""
if params:
for param in params:
params,assedPtr +> (param + "Ln"
return Gformat@sH7MJ(re:, "Qni.o metodo publi.o en 43N es
diHolaZbr8,arametros re.ibidos: " + params,assedPtr + "Zbr8" + Gusa(e
(
Universidad de Deusto
. . . .
ESIDE
L. 0entient Library
Universidad de Deusto
. . . .
ESIDE
jemplo P0P

Python 0er%er Pages es la %ersi!n Python de =0Ps o A0Ps

Permite la inserci!n de c!digo Python en un documento -B,L

Fsa los mismos c!digos de escape "ue los =0Ps

0e permite su uso a tra%9s de modGpython de Apache

http://(((.onlamp.com/pub/a/python/KNNQ/NK/KR/pythonZser%erZpages.htm
l
Z!d .(i%bin/psp/holamundo&psp %%8
Zhtml8
ZW
if form&hasGHey(=nombre=:
saludo > =Hola, Ws!= W form2=nombre=6&.apitaliXe(
else:
saludo > =Hola mundo!=
# end
W8
Zh18ZW> saludo W8Z/h18
Zp8Qsa parametro =nombre= para re.ibir un saludo, e&(&
holamundo&pspDnombre>-ie(oZ/p8
Z/html8
Universidad de Deusto
. . . .
ESIDE
Programaci!n en Y,L con 0AY

0oporte para 0AY en Python es o$recido por el

m!dulo xml&sax de la Python Library

De$ine K m9todos:

maHeGparser(2parserGlist6

.rea y de%uel%e un objeto P@e eMJTeader object

parse(filenameGorGstream, handler2,
errorGhandler6

.rea un parser 0AY parser y lo usa para procesar el

documento a tra%9s de un handler

l m!dulo xml&sax&xmlreader de$ine readers

para 0AY

l m!dulo xml&sax&handler de$ine manejadores

de e%entos para 0AY: start-o.ument2
end-o.ument2 starOlement2 endOlement
Universidad de Deusto
. . . .
ESIDE
jemplo procesamiento 0AY I
# xml/Olement4ounterP@e&py
# OKe.utar: python Olement4ounterP@e&py 4artelera&xml
import sys
from xml&sax import maHeGparser, handler
.lass Olement4ounter(handler&4ontentHandler:
def GGinitGG(self:
self&Gelems > /
self&Gattrs > /
self&GelemGtypes > "$
self&GattrGtypes > "$
def startOlement(self, name, attrs:
self&Gelems > self&Gelems + 1
self&Gattrs > self&Gattrs + len(attrs
self&GelemGtypes2name6 > self&GelemGtypes&(et(name, / + 1
for name in attrs&Heys(:
self&GattrGtypes2name6 > self&GattrGtypes&(et(name, / + 1

Universidad de Deusto
. . . .
ESIDE
jemplo procesamiento 0AY II
def end-o.ument(self:
print "7here 5ere", self&Gelems, "elements&"
print "7here 5ere", self&Gattrs, "attributes&"
print "%%%OJOMOF7 7U,OP"
for pair in self&GelemGtypes&items(:
print "W!/s Wd" W pair
print "%%%@77TN\Q7O 7U,OP"
for pair in self&GattrGtypes&items(:
print "W!/s Wd" W pair

parser > maHeGparser(
parser&set4ontentHandler(Olement4ounter(
parser&parse(sys&ar(v216
Universidad de Deusto
. . . .
ESIDE
Procesando Y,L con D@,

Python pro%ee el m!dulo xml&dom&minidom "ue es

una implementaci!n sencilla de D@,

l m9todo parse a partir de un $ichero crea un

objeto D@,2 el cual tiene todos los m9todos y
atributos est+ndar de D@,: has4hildFodes(2
.hildFodes2 (etOlements\y7a(Fame(

Para m+s in$ormaci!n sobre procesamiento Y,L en

Python ir a: http://py8ml.source$orge.net/topics/

La distribuci!n PyY,L2 "ue no %iene en la distribuci!n por

de$ecto de Python2 permite procesamiento un poco m+s
so$isticado

http://py8ml.source$orge.net/topics/
Universidad de Deusto
. . . .
ESIDE
jemplo D@, I
# xml/eKemplo-RM&py
# OKe.utar: python eKemplo-RM&py 4artelera&xml
#!/usr/bin/env python
import xml&dom&minidom, sys
.lass ,eli.ula:
def GGinitGG(self, .odi(o, titulo, dire.tor, a.tores:
self&.odi(o > .odi(o
self&titulo > titulo
self&dire.tor > dire.tor
self&a.tores > a.tores
def GGreprGG(self:
return "4odi(o: " + str(self&.odi(o + " % titulo: " +
self&titulo + " % dire.tor: " + self&dire.tor + " % a.tores: " +
self&a.tores

.lass ,eli.ula-RM,arser:
def GGinitGG(self, filename:
self&dom > xml&dom&minidom&parse(filename
self&peli.ulas > 26


Universidad de Deusto
. . . .
ESIDE
jemplo D@, II
def (et,eli.ulas(self:
if not self&peli.ulas:
peli.ulaFodes > self&dom&(etOlements\y7a(Fame(",eli.ula"
num,elis > len(peli.ulaFodes
for i in ran(e(num,elis:
peli.ula > peli.ulaFodes&item(i
# Te.uperar los attributes de .ada nodo ,eli.ula
peli@ttribs > peli.ula&attributes
.odi(o > peli@ttribs&(etFamedNtem(".odi(o"&nodeMalue
titulo > peli@ttribs&(etFamedNtem("titulo"&nodeMalue
dire.tor > peli@ttribs&(etFamedNtem("dire.tor"&nodeMalue
a.tores > peli@ttribs&(etFamedNtem("a.tores"&nodeMalue
self&peli.ulas&append(,eli.ula
(.odi(o,titulo,dire.tor,a.tores
return self&peli.ulas
if GGnameGG >> =GGmainGG=:
dom,arser > ,eli.ula-RM,arser(sys&ar(v216
for peli in dom,arser&(et,eli.ulas(:
print peli
Universidad de Deusto
. . . .
ESIDE
Programaci!n distribuida:
.@&EA con omni@&Epy

Desde Python se puede usar tanto .@&EA 'omni@&Epy* como

ser%icios (eb '0@APpy disponible en
http://py(ebs%cs.source$orge.net/*

n este curso nos concentramos s!lo en .@&EA:

Do(nload omni@&Epy de: http://omniorb.source$orge.net/

Desarrollada por Duncan Grisby en AB[B Labs .ambridge

Easada en la @&E para .77: omni@&E

Descomprimir y compilar en Linu8 o simplemente descomprimir en

:indo(s

Las siguientes %ariables de entorno son necesarias:

,U7HRF,@7H>ZomniRT\py%install%dir8/lib/python#
ZomniRT\py%install%dir8LlibLx)*G5in'!

,@7H>+,@7H:>ZomniRT\py%install%dir8/bin/x)*G5in'!

J-GJN\T@TUG,@7H>ZomniRT\py%install%
dir8LlibLZplatform8

Para compilar IDL usar: omniidl %bpython Zfi.hero%idl%a%

.ompilar8
Universidad de Deusto
. . . .
ESIDE
jemplo .@&EA: IDL
// .orba/exampleGe.ho&idl
module Oxample "
interfa.e O.ho "
strin( e.hoPtrin((in strin( mes(#
$#
$#
Universidad de Deusto
. . . .
ESIDE
jemplo .@&EA: ser%idor
#!/usr/bin/env python
import sysfrom omniRT\ import 4RT\@, ,ortablePerver
# Nmport the stubs and sHeletons for the Oxample module
import Oxample, OxampleGG,R@
# -efine an implementation of the O.ho interfa.e
.lass O.hoGi (OxampleGG,R@&O.ho:
def e.hoPtrin((self, mes(:
print "e.hoPtrin(( .alled 5ith messa(e:", mes(
return mes(
# Nnitialise the RT\
orb > 4RT\@&RT\Ginit(sys&ar(v, 4RT\@&RT\GN-
# Yind the root ,R@
poa > orb&resolveGinitialGreferen.es("Toot,R@"
# 4reate an instan.e of O.hoGie
i > O.hoGi(# 4reate an obKe.t referen.e, and impli.itly a.tivate the obKe.te
o > ei&Gthis(
# ,rint out the NRT
print orb&obKe.tGtoGstrin((eo
# @.tivate the ,R@
poaMana(er > poa&G(etGtheG,R@Mana(er(
poaMana(er&a.tivate(
# Overythin( is runnin( no5, but if this thread drops out of the end
# of the file, the pro.ess 5ill exit& orb&run( Kust blo.Hs until the
# RT\ is shut do5n
orb&run(
Universidad de Deusto
. . . .
ESIDE
jemplo .@&EA: ser%idor
#!/usr/bin/env pythonimport sys
# Nmport the 4RT\@ module
from omniRT\ import 4RT\@
# Nmport the stubs for the Oxample module
import Oxample
# Nnitialise the RT\
orb > 4RT\@&RT\Ginit(sys&ar(v, 4RT\@&RT\GN-
# 3et the NRT of an O.ho obKe.t from the .ommand line (5ithout
# .he.Hin( that the ar(uments are sensible!
ior > sys&ar(v216
# 4onvert the NRT to an obKe.t referen.e
obK > orb&strin(GtoGobKe.t(ior
# Farro5 referen.e to an Oxample::O.ho obKe.te
o > obK&Gnarro5(Oxample&O.ho
if eo is Fone:
print "RbKe.t referen.e is not an Oxample::O.ho"
sys&exit(1
# NnvoHe the e.hoPtrin( operation
messa(e > "Hello from ,ython"
result > eo&e.hoPtrin((messa(e
print "N said =Ws=& 7he obKe.t said =Ws=&" W (messa(e,result
Universidad de Deusto
. . . .
ESIDE
Programaci!n de GFIs I

B<inter es la GFI tool<it "ue por de$ecto %iene con

Python 'http://(((.python.org/doc/current/lib/moduleC
B<inter.html*

Easada en Bcl/t<2 no tiene apariencia nati%a

s lenta pero su uso es muy sencillo

Pm( 'Python meta (idgets* 'http://pm(.source$orge.net/*

.omponentes m+s elaborados encima de B<inter

8isten otras tool<its para generaci!n de GFIs:

(8Python 'http://(((.(8python.org/*

Apariencia nati%a2 basado en (8:indo(s 'multipla$orma*2 muy

r+pida

Python(in 'http://(((.python.org/(indo(s/python(in/*

0olamente para :indo(s2 usa directamente la API de :indo(s

PyGB\ 'http://(((.pygt<.org/*

PyVt 'http://(((.ri%erban<computing.co.u</py"t/*
Universidad de Deusto
. . . .
ESIDE
jemplo B<inter I
# (ui/tHinter5at.h&py
from 7Hinter import [
import time, sys
.lass Ptop9at.h(Yrame:
""" Nmplements a stop 5at.h frame 5id(et& """

def GGinitGG(self, parent>Fone, [[H5:
Yrame&GGinitGG(self, parent, H5
self&Gstart > /&/
self&Gelapsedtime > /&/
self&Grunnin( > /
self&timestr > Ptrin(Mar(
self&maHe9id(ets(
def maHe9id(ets(self:
""" MaHe the time label& """
l > Jabel(self, textvariable>self&timestr
self&Gset7ime(self&Gelapsedtime
l&pa.H(fill>e, expand>FR, pady>!, padx>!

def Gupdate(self:
""" Qpdate the label 5ith elapsed time& """
self&Gelapsedtime > time&time( % self&Gstart
self&Gset7ime(self&Gelapsedtime
self&Gtimer > self&after(1/, self&Gupdate

def Gset7ime(self, elap:
""" Pet the time strin( to Minutes:Pe.onds:Hundreths """
minutes > int(elap/*/
se.onds > int(elap % minutes[*/&/
hse.onds > int((elap % minutes[*/&/ % se.onds[1//
self&timestr&set(=W/!d:W/!d:W/!d= W (minutes, se.onds, hse.onds
Universidad de Deusto
. . . .
ESIDE
jemplo B<inter II
def Ptart(self:
""" Ptart the stop5at.h, i(nore if runnin(& """
if not self&Grunnin(:
self&Gstart > time&time( % self&Gelapsedtime
self&Gupdate(
self&Grunnin( > 1

def Ptop(self:
""" Ptop the stop5at.h, i(nore if stopped& """
if self&Grunnin(:
self&afterG.an.el(self&Gtimer
self&Gelapsedtime > time&time( % self&Gstart
self&Gset7ime(self&Gelapsedtime
self&Grunnin( > /

def Teset(self:
""" Teset the stop5at.h& """
self&Gstart > time&time(
self&Gelapsedtime > /&/
self&Gset7ime(self&Gelapsedtime


if GGnameGG >> =GGmainGG=: root > 7H(
s5 > Ptop9at.h(root
s5&pa.H(side>7R,
\utton(root, text>=Ptart=, .ommand>s5&Ptart&pa.H(side>JOY7
\utton(root, text>=Ptop=, .ommand>s5&Ptop&pa.H(side>JOY7
\utton(root, text>=Teset=, .ommand>s5&Teset&pa.H(side>JOY7
\utton(root, text>=Buit=, .ommand>sys&exit(/&pa.H(side>JOY7
root&mainloop(
Universidad de Deusto
. . . .
ESIDE
jemplo de GFI con Pm(
Universidad de Deusto
. . . .
ESIDE
jemplo (8Python I
#!/usr/bin/env python
# (ui/(8Python0emana0ID.py
GGauthorGG > "-ie(o Npifa Zdipina_eside&deusto&es8"
import 5x
.lass Yrame(5x&Yrame:
"""4lase frame :ue visualiXa una ima(en&"""
def GGinitGG(self, ima(e, parent>Fone, id>%1,
pos>5x&-efault,osition, title>=EHola, semaneros
OPN-O!=:
"""4rea un Yrame y visualiXa ima(en&"""
temp > ima(e&4onvert7o\itmap(
siXe > temp&3et9idth(, temp&3etHei(ht(
5x&Yrame&GGinitGG(self, parent, id, title, pos, siXe
self&bmp > 5x&Ptati.\itmap(parent>self, id>%1,
bitmap>temp
Universidad de Deusto
. . . .
ESIDE
jemplo (8Python II
.lass @pp(5x&@pp:
"""4lase apli.a.i?n&"""
def RnNnit(self:
5x&Nnit@llNma(eHandlers(
ima(e > 5x&Nma(e(=semanaeside&Kp(=, 5x&\N7M@,G7U,OGS,O3
self&frame > Yrame(ima(e
self&frame&Pho5(
self&Pet7op9indo5(self&frame
return 7rue
def main(:
app > @pp(
app&MainJoop(
if GGnameGG >> =GGmainGG=:
main(

A tra%9s del programa 5x,ythonLdemoLdemo&py se pueden %er demos de

todas las capacidades de (8Python y lo "ue es m+s importante %ienen
acompaadas de c!digo $uente
Universidad de Deusto
. . . .
ESIDE
Fn poco de =ython

Do(nload =ython de:

http://(((.jython.org/do(nload.html

Para instalar simplemente ejecutar: Kava Kython%!1

Fsa Li$tC@$$ =a%aCInstaller: http://li$to$$.source$orge.net/

Algunos ejemplos de =ython en:

http://(((.jython.org/applets/inde8.html

Documentaci!n b+sica sobre =ython disponible en:

http://(((.jython.org/docs/useja%a.html
Universidad de Deusto
. . . .
ESIDE
jemplo =ython: EuttonDemo
# http://555&Kython&or(/applets/button&html
from Kava import a5t, applet
.lass \utton-emo(applet&@pplet:
def init(self:
self&b1 > a5t&\utton(=-isable middle button=,
a.tion,erformed>self&disable
self&b! > a5t&\utton(=Middle button=
self&b' > a5t&\utton(=Onable middle button=, enabled>/,
a.tion,erformed>self&enable
self&add(self&b1
self&add(self&b!
self&add(self&b'
def enable(self, event:
self&b1&enabled > self&b!&enabled > 1
self&b'&enabled > /
def disable(self, event:
self&b1&enabled > self&b!&enabled > /
self&b'&enabled > 1
Universidad de Deusto
. . . .
ESIDE
.asos de 98ito de Python

EitBorrent 'http://bitconjurer.org/EitBorrent/*2 sistema PKP "ue

o$rece mayor rendimiento "ue e,ule

PyGlobus2 permite la programaci!n de Grid .omputing 'http://

(((Citg.lbl.go%/gtg/projects/pyGlobus/*

M@P '(((.zope.org* es un ser%idor de aplicaciones para

construir y gestionar contenido2 intranets2 portales2 y
aplicaciones propietarias

Industrial Light [ ,agic usa Python en el proceso de

producci!n de gr+$icos por ordenador

Google usa Python internamente2 lo mismo "ue Dahoo para su

sitio para grupos

&ed -at Linu8 utiliza Python para la instalaci!n2 con$iguraci!n2

y gesti!n de pa"uetes.

,+s historias de 98ito de Python en: http://pb$.stra<t.com/

success
Universidad de Deusto
. . . .
ESIDE
&ecursos utilizados

.ompilador de Python K.L.L y documentaci!n:

http://(((.python.org/K.L.L/

8tensiones para :indo(s:

https://source$orge.net/projects/py(inLK/

,!dulo de bases de datos ,y0VLdb N.W.K:

http://source$orge.net/projects/mys"lCpython

Ease de datos ,y0VL Q.N:

http://(((.mys"l.com/do(nloads/mys"lCQ.N.html

omni@&Epy

http://omniorb.source$orge.net/

0er%idor Apache K.N 'http://httpd.apache.org/*

,!dulo modZpython para Apache: http://(((.modpython.org

(8Python K.Q:

http://(((.(8python.org/do(nload.phpAbinaries

=ython K.S

http://(((.jython.org/do(nload.html