Presentacion de Python

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
-ola ,undo en Python

#!/usr/bin/env python print "Hola Mundo" # "Hola Mundo" print "hola", "mundo" # "hola mundo" print "Hola" + "Mundo" # "HolaMundo"
.aracter/sticas de Python I
,uy legible y elegante
0imple y poderoso

Imposible escribir c!digo o$uscado ,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.
.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
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
Cdigo en C/Java if (x " if (y " f1( # $ f!( # $
Cdigo en Python if x: if y: f1( f!(
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
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 ... ;o o$rece strong typing
Python es un lenguaje de scripting:
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*
Python %s. =ython
Python

=ython

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 Implementaci!n de Python en =a%a Permite acceder a todas las APIs de =a%a
P. . Podemos producir 0(ing GFIs desde Python
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 ;o hay nada mejor para este tipo de aplicaciones "ue el %iejo .
Aplicaciones "ue re"uieren alta capacidad de computo
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
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
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.ial 6 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( +
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 +
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!
Identi$icadores
Los identi$icadores sir%en para nombrar %ariables2 $unciones y m!dulos

Palabras reser%adas:
Deben empezar con un car+cter no num9rico y contener letras2 n6meros y #G# Python es case sensiti%e 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
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
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=
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
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
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
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=
.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, >
.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,step6 2 donde los campos start y step son opcionales. Ptart es N y step es S por de$ecto.
.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
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/
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=
.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
,+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 :
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&
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
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
,!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
,!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 test 1 lo hace disponible como the7est . &e$erir a objecto x como >the7est&x>.
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!
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
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
Pa"uetes I?
.omo en =a%a el c!digo de un pa"uete puede recogerse en un &Xip:

import Xipfile a>Xipfile&,y]ipYile(=mipa.Ha(e&Xip=, =5=, Xipfile&]N,G-OYJ@7Oa&5ritepy(=pa.Ha(eGexample= a&.lose( ^]
888 888 888 888 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 ^]
,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 &&&
,+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 #'=
?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
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 P i.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
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( exe.ute( nos permite en%iar una sentencia 0VL a la ED fet.hone( recuperar una $ila fet.hall( recuperar todas las $ilas D.@racle 'http://(((.zope.org/Products/D.@racle/* creado por Mope ,y0VLdb 'http://source$orge.net/projects/mys"lCpython*

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

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

,y0VLCpython.e8eCN.W.K.(inLKCpyK.L.e8e para :indo(s ,y0VLCpythonCN.W.KCS.iLXR.rpm para Linu8
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= #
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(
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
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
Programaci!n de e8presiones regulares II

# .onse(uir el titulo del do.umento H7MJ tmat.h > re&sear.h(r=Ztitle8(&[D Z/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
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
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(
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/*
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"
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 (
L. 0entient Library
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
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
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
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
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
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/
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
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
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
jemplo .@&EA: IDL

// .orba/exampleGe.ho&idl module Oxample " interfa.e O.ho " strin( e.hoPtrin((in strin( mes( # $# $#
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(
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
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 0olamente para :indo(s2 usa directamente la API de :indo(s
Python(in 'http://(((.python.org/(indo(s/python(in/*
PyGB\ 'http://(((.pygt<.org/* PyVt 'http://(((.ri%erban<computing.co.u</py"t/*
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
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(
jemplo de GFI con Pm(
jemplo (8Python I
#!/usr/bin/env python # (ui/ (8Python0emana 0ID .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
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
Fn poco de =ython
Do(nload =ython de:
http://(((.jython.org/do(nload.html Fsa Li$tC@$$ =a%aCInstaller: http://li$to$$.source$orge.net/ http://(((.jython.org/applets/inde8.html http://(((.jython.org/docs/useja%a.html
Para instalar simplemente ejecutar: Kava Kython%!1
Algunos ejemplos de =ython en:
Documentaci!n b+sica sobre =ython disponible en:
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
.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
&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/ http://source$orge.net/projects/mys"lCpython http://(((.mys"l.com/do(nloads/mys"lCQ.N.html http://omniorb.source$orge.net/ ,!dulo modZpython para Apache: http://(((.modpython.org http://(((.(8python.org/do(nload.phpAbinaries http://(((.jython.org/do(nload.html
,!dulo de bases de datos ,y0VLdb N.W.K:
Ease de datos ,y0VL Q.N:
omni@&Epy
0er%idor Apache K.N 'http://httpd.apache.org/*
(8Python K.Q:
=ython K.S

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

Presentacion de Python

Cargado por

Copyright:

Formatos disponibles

Universidad de Deusto . . . .

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

Universidad de Deusto . . . . ESIDE

-ola ,undo en Python

Universidad de Deusto . . . . ESIDE

,uy legible y elegante

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

Universidad de Deusto . . . . ESIDE

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

Universidad de Deusto . . . . ESIDE

Python usa tabulaci!n 'o espaciado* para mostrar estructura de blo"ues

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

Cdigo en Python if x: if y: f1( f!(

Universidad de Deusto . . . . ESIDE

Python %s. Perl

Universidad de Deusto . . . . ESIDE

Python %s. =a%a

=a%a es un lenguaje de programaci!n muy completo "ue o$rece:

Python es un lenguaje de scripting:

Eueno para prototipos pero malo para grandes sistemas

Puede cascar en tiempo de ejecuci!n

Universidad de Deusto . . . . ESIDE

Python %s. =ython

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

Aplicaciones "ue re"uieren alta capacidad de computo

Universidad de Deusto . . . . ESIDE

Eajar %ersi!n de Python de http://(((.python.org/do(nload/

rpm %iv python!&'%!&'&'%pydotor(&i')*&rpm

Universidad de Deusto . . . . ESIDE

Fsando Python desde l/nea comando

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

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

+ python blo:ue&py ABuiCn eresD EFo eres -ie(o!

Universidad de Deusto . . . . ESIDE

Los identi$icadores sir%en para nombrar %ariables2 $unciones y m!dulos

?ariables y $unciones delimitadas por GG corresponden a s/mbolos impl/citamente de$inidos:

Universidad de Deusto . . . . ESIDE

;um9ricos 'integer2 long integer2 $loatingCpoint2 and comple8*

Universidad de Deusto . . . . ESIDE

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

Universidad de Deusto . . . . ESIDE

Bipos de datos III

l m!dulo strin( de la Python library de$ine m9todos para manipulaci!n de strings:

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

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

Universidad de Deusto . . . . ESIDE

Universidad de Deusto . . . . ESIDE

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

Para aadir un elemento a una lista:

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

OOO items.append'TTT* OOO items HCS2 Q2 R2 TTTI OOO items.pop'* TTT