INTRODUCCIN A

PYTHON
Se permte a reproduccn, dstrbucn y
comuncacn pbca de a obra as como
a generacn de obras dervadas, ncuso
con fnes comercaes.
Autor: ngel Luis Garca Garca (angeus78@gma.com)
ersi!n "el "ocu#ento: $%$%&
ersi!n P't(on: &%)%)
*ec(a: &+,$&,&$--
Antes "e na"a
Este manua pretende ntroducr a cuaquer persona, que haya programado en
cuaquer otro engua|e, en e desarroo de software con P't(on. Soo es una
ncacn, por o que se de|an conceptos en e camno, ya que de o contraro
se ttuara "TODO sobre Python".
Insprado en un ndo de horas estudando y programando en P't(on, este
texto est redactado para ser edo (y probado) de manera secuenca,
ntroducendo progresvamente os conceptos fundamentaes de engua|e en
os dversos temas. Puesto que no es o msmo andar e camno que conocer e
camno, se nsta a ector a que pruebe todos os e|empos que venen en e
documento. Y es que para aprender a desarroar "en cuaquer engua|e de
programacn" hay que embarrarse as manos, no hay otra forma.

.NDIC/
$% INTRODUCCIN
-% CARACT/R.0TICA0 PRINCIPAL/0
-%- I1PL/1/NTACION/0
-%& H/RRA1I/NTA0 D/ D/0ARROLLO
-%2 /R0ION/0
-%3 CO1PO0ICIN D/ PYTHON
-%+ *ILO0O*.A PYTHON
&% /L INT4RPR/T/ D/ PYTHON
&%- ID/NTI*ICADOR/0 Y D/CLARACION/0
&%& AYUDA
2% 1I PRI1/R *ICH/RO CON CDIGO *U/NT/
3% UNICOD/
3%- 0CRIPT0 PYTHON /N UNICOD/
+% *UNCION/0
+%- *UNCION/0 LA15DA
)% 1DULO0
)%- LOCALI6ACIN
)%& 1DULO0 /N LA LI5R/R.A /0TNDAR
)%2 PAC7AG/0
8% PALA5RA0 CLA/ Y *UNCION/0 INT/GRADA0
9% TIPO0 D/ DATO0 Y 0U0 OP/RADOR/0
9%- NON/
9%& 5OOL/ANO
9%2 N:1/RO0
9%3 0/CU/NCIA0
9%3%- LI0TA0
9%3%& TUPLA0
9%3%2 CAD/NA0
9%3%3 *OR1A0 D/ ACC/D/R A /L/1/NTO0 D/ 0/CU/NCIA0
9%3%+ OP/RACION/0 0O5R/ 0/CU/NCIA0
9%3%+%- /N LI0TA0
9%3%+%& /N CAD/NA0
9%+ TA5LA0 HA0HING ;DICCIONARIO0<
9%+%- OP/RACION/0
9%) *ICH/RO0
9%8 10 TIPO0 /N PYTHON
=% CON/R0ION/0 /NTR/ LI0TA0> TUPLA0 Y TA5LA0 HA0HING%
-$% *OR1AT/O D/ CAD/NA0
--% CONTROL D/ *LU?O
--%- I*
--%& @HIL/
--%2 *OR
-&% IT/RADOR/0
-2% PROGRA1ACIN ORI/NTADA A O5?/TO0
-3% 1AN/?O D/ /AC/PCION/0
-+% P/R0I0T/NCIA D/ O5?/TO0 CON cPicBle
-)% 0CRIPT0 /N PYTHON
-8% LOT/R.A0 /N PYTHON
-9% UNA AG/NDA
-=% TIPO0 D/ *ICH/RO0 PYTHON
&$% 1DULO0 10 I1PORTANT/0
&-% R/CUR0O0 DOCU1/NTAL/0 /N INT/RN/T
4
$% Intro"ucci!n
P't(on es un engua|e de programacn dseado por e hoands Gui"o Can
Rossu#, a fnaes de os 80. Aunque Gudo tene a tma paabra en
cuestones referentes a f|acn de drectrces y decsones fnaes sobre
P't(on (de hecho, a Gudo se e conoce como el benevolente dictador
vitalicio), este tmo es admnstrado y desarroado por a P't(on 0oDtEare
*oun"ation (PSF), tenendo cenca de cdgo aberto (PSFL) compatbe con
GPL de GNU a partr de a versn 2.1.1. La PSF tene adems, como ob|etvo,
fomentar e desarroo de a comundad P't(on (es una organzacn sn nmo
de ucro, creada en 2001).
Gudo traba|a desde 2005 en Googe (Mountan Vew). Ms nformacn en
http://www.python.org/-gudo/.
Cuando se ntroducen caracterstcas nuevas en e engua|e nos encontramos
con as P/P, que son as sgas en ngs de P't(on /n(ance#ent ProFosal,
esto es, en espao FroFuesta "e #eGora "e P't(on. Un PEP es un
documento de dseo que sumnstra nformacn a a comundad Python ben
descrbe una nueva caracterstca en Python. Por tanto un PEP srve para
proporconar una especfcacn tcnca precsa de una caracterstca y su
|ustfcacn.
E sto web de Python es www.python.org.
Python se usa en programacn de sstemas, ccuo numrco, desarroo web,
software para dspostvos mves (Symban, Androd), desarroo de
apcacones de escrtoro, educacn, smuacn, prototpados, GIS y un argo
etctera.
De as empresas ms destacadas que utzan Python se pueden nombrar
Googe, NASA, Facebook, US Natona Weather Servce, Core, Lockheed Martn,
Pxar, Industra Lght and Magc, etc.
Como software desarroado en Python cabe resatar Googe App Engne
(entorno Coud Computng de Googe), OpenERP, The Washngton Post (Python
+ D|ango), Facebook (a parte de gestn de mensa|es e nformacn en tempo
rea), Zope (servdor de apcacones), Pone (CMS |sstema de gestn de
contendos| utzado por a NASA, Canonca, etc), BtTorrent, etc.
Ms casos de xto en http://python.org/about/success/.
-% Caractersticas FrinciFales "e P't(on
Python es un engua|e de programacn de propsto genera, de muy ato nve
(esto es, un ato nve de abstraccn, con e uso de stas, tupas, dcconaros).
Python es un engua|e nterpretado (no es necesara compacn), dnmco (no
necesta dentfcar expctamente os tpos de datos para ncazar varabes,
de modo que os tpos se vadan durante a e|ecucn de programa) y
fuertemente tpado (no pueden mezcarse tpos, es necesaro hacer
conversones).
Python es un engua|e mutpataforma (Wndows, Mac, Lnux, etc),
mutparadgma (mperatvo, orentado a ob|etos y en menos medda funcona)
y con gestn automtca de memora.
Por tmo cabe destacar que Python es un engua|e de programacn con una
sntaxs cara y senca, fc de aprender, donde se pueden mezcar os
dferentes paradgmas de programacn de os que dspone, ampamente
documentado, extensbe, que ntenta obgar a desarroador de software a
programar de a manera correcta en e menor tempo posbe.
6
-%-% I#Fle#entaciones en P't(on
CPython (o Python) es a mpementacn de referenca. Interpreta,
"compa", y contene mduos codfcados en C estndar.
|ython es a mpementacn para a |VM (Mquna Vrtua |ava) accedendo a
as bbotecas de |ava.
IronPython es a mpementacn para e CRL de Mcrosoft, con e propsto de
acceder a framework de .NET.
PyPy es a mpementacn de Python escrta en Python (para rzar ms e rzo).
-%&% Herra#ientas Fara "esarrollar en
P't(on
Para programar en Python o nco que se necesta es e ntrprete de Python,
(se puede obtener de www.python.org) y e/os fchero/s de cdgo fuente
Python a e|ecutar. Por otra parte tenemos certas herramentas de desarroo
para utzar con Python, a saber:
ID/: Son as sgas de entorno de desarroo ntegrado. Es una apcacn
(entorno de programacn) para desarroar software que est compuesto
normamente por un edtor de cdgo, un compador un ntrprete,
herramentas auxares de desarroo (creacn de documentacn, tests,
empaquetado de software), un depurador y agunas veces un dseador de
nterfaces grfcas ncorporado. Se pueden nombrar IDLE, Eclipse con el plugin
pyDev, Aptana, NetBeans, Geany, pyScripter, Ninja IDE, Stani's Python Editor,
ing!are Python IDE, "o#odo, Pyragua, Eric$
GUI: Son as sgas de nterfaz grfca de usuaro. Son herramentas para crear
nterfaces grfcas, esto es, componentes grfcos con os cuaes e usuaro
nteraccona con a apcacn. Hay agunos IDE's que contenen GUI's
ntegrados. Las GUI's dependen de a pataforma grfca en a que traba|emos.
Por e|empo, para wxPython tenemos !%Designer, !%&or#Builder ' !%Glade$
Para G(", tene#os Glade, )t dispone de *on+ey Studio, etc$
/"itor: Es una apcacn para escrbr cdgo de programacn en e engua|e
deseado. Contene todas as herramentas de edcn necesaras, y agunas
veces caracterstcas propas de IDE's. Hay veces que cuesta dstngur entre un
IDE y un edtor por a cantdad de opcones que tene este tmo. Por e|empo
Editra, e#acs, Notepad,,, Sci(E.
RAD: Son as sgas de desarroo rpdo de apcacones. Dependendo de
autor srve para desgnar a as apcacones de desarroo de nterfaces grfcas
a os IDE's con GUI's ntegrados, o a as dos cosas. Es un trmno dado a
pataformas de desarroo como PowerBuder, Vsua Studo Deph, por poner
e|empos. De os ms destacados para Python tenemos B-A .onstructor y
SharpDevelop (para IronPython).
0(ell interactiCo: Es una apcacn que me|ora sustancamente e ntrprete
Python orgna, esto es, es un ntrprete con caracterstcas especaes, que
podran ncur a compettud de cdgo y e cooreado de msmo, navegacn
entre os namespaces, exportacn de cdgo, etc. Por e|empo Py.rust,
Drea#pie, PyShell, etc.
Lo mnimo que se le debe de pedir a cualquier IDE editor, para desarrollar en Python,
es la indentacin automtica, coloreado y completitud de cdigo.
Ms nformacn sobre herramentas para desarroar en Python en
ttp!""#i$i.pyton.org"moin"PytonEditors.
8
-%2% Las Cersiones "e P't(on
Actuamente en Python exsten dos versones actvas, a 2.XX y a 3.XX. En e
sto web de Python exste un gun de ayuda para eegr entre a 2 y a 3:
http://wk.python.org/mon/Python2orPython3
A dcembre de 2010 haba estabes as versones de 2.6, 2.7 y en desarroo a
3.2. E futuro es Python 3, e cua es ncompatbe con as versones 2.XX.
Entonces, cu eegr?. Pues depende de nuestras exgencas, y de os
mduos de extensn (aqueos que no estn en a dstrbucn de Python) que
utcemos (frameworks y dems). La mayora sguen sendo compatbes con
2.XX pero no con 3 (aunque esto est cambando). Este manua est hecho
pensando en Python 2.6.6.
-%3% Co#Fosici!n "e P't(on
A grandes rasgos podemos ver de qu est compuesta una apcacn Python:
PYTHON: L/NGUA?/ H 5I5LIOT/CA /0TNDAR + */D0L-S DE E1(ENSI/N
E engua|e y a bboteca estndar conforman a nstaacn de base.
E engua|e se compone de paabras cave (f, for, etc), funcones ntegradas
(abs, prnt, etc), tpos bscos (nmeros, secuencas, dcconaros, con|untos,
cadenas, fcheros, ...) y as regas sntctcas y semntcas que defnen su
estructura y e sgnfcado de sus eementos y expresones.
NOTA: Una funcn ntegrada es aquea no es necesara amara desde nngn
mduo, pues se puede acceder a ea por defecto, esto es, se carga
automtcamente.
La bboteca estndar es e con|unto de mduos, paquetes y frameworks que
estn en a nstaacn base de Python y que hay que decarar de manera
expcta en e cdgo. Por e|empo, para acceder a as funcones de sstema
operatvo en e que se encuentre nuestra nstaacn Python nvocaremos a
mduo os.
Los mduos de extensn, que pueden ser frameworks, mduos paquetes,
es software de terceros, que hay que nstaar por separado. Ms nformacn
sobre mduos de extensn en http://pyp.python.org/pyp. P'PI es e ndce
de paquetes de Python, esto es, un repostoro de software para e engua|e de
programacn Python.
10
-%+% *ilosoDa P't(on
Python est panteado para desarroar software a partr de unos prncpos de
programacn. Los usuaros de Python se referen a menudo a a *ilosoDa
P't(on que es bastante anoga a a fosofa de Unx. E cdgo que sgue os
prncpos de Python de egbdad y transparenca se dce que es "F't(onico".
Contraramente, e cdgo opaco u ofuscado es bautzado como "no pythonco"
("unpythonc" en ngs). Estos prncpos fueron famosamente descrtos por e
desarroador de Python Ti# Peters en /l 6en "e P't(on:
Beo es me|or que feo.
Expcto es me|or que mpcto.
Smpe es me|or que compe|o.
Compe|o es me|or que compcado.
Pano es me|or que andado.
Rao es me|or que denso.
La egbdad cuenta.
Los casos especaes no son tan especaes como para quebrantar as
regas.
Los errores nunca deberan de|arse pasar sencosamente.
A menos que hayan sdo sencados expctamente.
Frente a a ambgedad, rechazar a tentacn de advnar.
Debera haber una -y preferbemente so una- manera obva de hacero.
Aunque esa manera puede no ser obva a prncpo a menos que usted
sea Hoands.
Ahora es me|or que nunca.
Aunque nunca es a menudo me|or que ya.
S a mpementacn es dfc de expcar, es una maa dea.
S a mpementacon es fc de expcar, puede que sea una buena dea.
Los espacos de nombres (namespaces) son una gran dea Hagamos
ms de esas cosas!.
Estos prncpos son cas axomtcos en Python, mpementados adems en e
ntrprete Python. Para vsuazaros e|ecutar e ntrprete Python y escrbr:
mport ths
&% /l intIrFrete "e P't(on
Python, como se ha comentado, vene de sere en a mayora de dstrbucones
Lnux. Para Wndows hay que descargaro de su sto web. Convendra para
este tmo sstema ncur en a varabe de entorno path a ruta donde se
tenga nstaado Python (por e|empo c:\python26, s se tene nstaada a
versn 2.6 en a undad C).
E|ecutamos e ntrprete medante e comando F't(on.
Escrbmos nuestro prmer "Hoa mundo" con a funcn ntegrada Frint. Darse
cuenta que estamos vsuazando una cadena, medante comas dobes.
Tambn es vdo as comas smpes.
12
Podemos reazar operacones matemtcas n stu:
>>> 3 + 4
7
>>>
Asgnar vaores a una varabe cuaquera (a ser tpado dnmco, no es
necesaro decarar e tpo de varabe). Podemos vsuazaro con prnt.
>>> a = 57
>>> prnt a
57
>>>
Podemos vover a asgnar un vaor a dcha varabe, con otro tpo dferente.
>>> a = 'Aprendz de programador Python'
>>> prnt a
Aprendz de programador Python
>>>
No podemos mecar tpos s no es hacendo conversones. Intentaremos sumar
un nmero a una cadena.
>>> 'Hoa mundo' + 4
Traceback (most recent ca ast):
Fe "(stdn", ne 1, n <modue>
TypeError: cannot concatenate 'str' and 'nt' ob|ects
E mensa|e nos dce que hay error de tpo (TypeError), no pudendo concatenar
un tpo str (strng cadena) con otro tpo nt (entero). Esto se debe a que
Python es un engua|e fuertemente tpado. Ben, podemos souconaro
hacendo una conversn castng de nmero 4 para convertro a una cadena
con a funcn ntegrada str.
>>> 'Hoa mundo' + str('4')
'Hoa mundo4'
>>>
Pedmos nformacn a usuaro medante a funcn ntegrada raEJinFut.
>>> a = raw_nput("Introduce tu nombre: ")
Introduce tu nombre: ange
>>> prnt a
ange
>>>
Ahora vamos a cargar un mduo (brera) de a bboteca estndar para
obtener nformacn de a mquna en a que nos encontramos:
>>> mport sys
>>> prnt sys.patform
&%-% I"entiDica"ores ' "eclaraciones
Los dentfcadores son nombres ncos que srven para dstngur ago,
utzndose para desgnar varabes, funcones, cases y ob|etos. Comenzan
por una etra un gun ba|o, pudendo contener etras, guones ba|os
dgtos, pero nunca sgnos de puntuacn. Adems no pueden exstr
dentfcadores que contengan os caracteres K, L M (soo es vdo dentro de
cadenas).
Adems cabe descatar que os dentfcadores, paabras cave, atrbutos,
etctera, en Python son caseNsensitiCe, esto es, dntnguen entre mayscuas
y mnscuas.
La decaracn es a undad bsca de programacn. En Python, una
decaracn debe de estar toda en una nca nea. Por e|empo, prnt "Hoa
Mundo". Para "partr" una nea en mtpes neas, se utza O. Hay una
excepcn a esto tmo, y es que sempre se puede "partr" dentro de una
tupa, sta dcconaro, y en cadenas con trpe comas, sn necesdad de
utzar O.
Por tmo comentar en este apartado que ms de una decaracn puede
aparecer en una msma nea s estn separadas por punto y coma P.
14
&%& A'u"a
S queremos necestamos ayuda podemos obtenera de ntrprete
smpemente teceando (elF;<:
A contnuacn podemos nsertar a paabra de a cua queremos nformacn.
Por e|empo, s quero saber para qu srve a paabra cave Fass, ncamente
escrbo pass y pusar Enter:
S quero sar de a ayuda, pusar Enter sn ntroducr nngn texto. Tambn se
puede utzar hep(ob|eto) hep("nombre"). En e e|empo anteror podramos
haber utzado help23pass45. S creamos un case amada a y queremos
obtener nformacn sobre ea:
Para sar de ntrprete utzar Quit;<.
>>> qut()
C:\>
E e|ecutar ncamente e ntrprete de Python se utza para probar trozos de
cdgo, buscar ayuda, probar estructuras, expresones reguares, comprobar
que se han nstaado correctamente mduos y agunas otras cosas.
Evdentemente para escrbr programas necestamos otro tpo de operatva,
que es o que veremos a contnuacn.
16
2% 1i Fri#er Dic(ero con c!"igo Duente
P't(on
E cdgo a nterpretar por Python puede e|ecutarse dentro de propo
ntrprete en fcheros de texto pano con extensn %F'. Evdentemente
nuestras apcacones Python se guardarn en fcheros con dcha extensn.
Podemos crear varos fcheros .py de manera que tengamos nuestro cdgo
ordenado segn a |erarqua que ms nos convenga. Crear breras con
funcones y cases es una buena dea para e buen mantenmento de cdgo
en nuestras apcacones. Para traba|ar con fcheros de cdgo fuente es
necesaro un edtor de texto pano. Se pueden utzar edtores, de's rad's. S
se est empezando en Python o me|or es utzar un edtor norma (Gedt, Boc
de notas, etc) como mucho e de IDLE, que se puede encontrar en as
dstrbucones de Wndows de manera predetermnada, en Mac y Lnux. Una
vez que se tenga experenca se necesten herramentas ms potentes es
cuando habra que dar e paso con otras aternatvas de desarroo
anterormente comentadas.
Crear un fchero con cdgo Python es trva. Creamos un fchero con extensn
.py (script$py) que contenga e cdgo para mostrar un "Hoa Mundo".
E|ecutamos dcho scrpt con e comando python scrpt.py.
3% Unico"e
Unico"e es un sstema para representar caracteres de todos os dferentes
domas de mundo.
Antes de Uncode haba dferentes sstemas de codfcacn de caracteres para
cada doma, cada uno usando os msmos nmeros (0-255) para representar
os caracteres de ese engua|e. E probema radcaba cuando se quera
ntercambar documentos entre sstemas heterogneos, restutando dfc,
puesto que no haba manera de que un ordenador supera con certeza qu
esquema de codfcacn de caracteres haba usado e autor de documento,
donde os nmeros pueden sgnfcar muchas cosas (en |apons e carcter
codfcado 234 no es e msmo que e carcter codfcado ruso 234, n en
espao, que 234 es U).
Para resover este probema Uncode representa cada carcter como un
nmero de 2 bytes (de 0 a 65535). Cada nmero de 2 bytes representa un
nco carcter utzado en a menos un doma de mundo (os caracteres que
se usan en ms de un doma tenen e msmo cdgo numrco). Hay
exactamente un nmero por carcter, y exactamente un carcter por nmero.
Los datos de Uncode nunca son ambguos.
Evdentemente, os sstemas de codfcacn antguos sguen exstendo. Los
caracteres ngeses se codfcan en ASCII de 7 bts (0 a 127). Idomas europeos
occdentaes como e espao e francs utzan e ISO-8859-1 ( Latn-1), que
usa un ASCII extenddo (0 a 255), para representar caracteres especaes, como
a , as tdes (,,,,),por e|empo. Uncode usa os msmos caracteres que
e ASCII de 7 bts para os nmeros de 0 a 127, y os msmos caracteres que e
ISO-8859-1, de 128 a 255, y de ah en adeante se extende para otros
engua|es que usan e resto de os nmeros de 256 a 65535.
La verdadera venta|a de Uncode resde en su capacdad de amacenar
caracteres que no son ASCII, como a espaoa. Para crear una cadena
Uncode en ugar de una ASCII norma soo hay que aadr a etra u antes de a
cadena. Por e|empo:
>>> x= u'ange'
>>> prnt str(x)
ange
>>>
Python normamente converte e Uncode a ASCII cuando necesta hacer una
cadena norma partendo de una Uncode. En este e|empo, a funcn str
ntenta convertr una cadena Uncode en ASCII para poder mprmra a
contnuacn con prnt. Y s hacemos x = u'nge'?
>>> x = u'nge'
>>> prnt str(x)
Traceback (most recent ca ast):
18
Fe ("stdn)", ne 1, n (modue)
UncodeEncodeError: 'asc' codec cant encode character u'\xe1' n poston 0:
ordna not n range(128)
>>>
Vemos que da error, puesto que a cadena Uncode 6ngel contene carcteres
(a ) que no son ASCII. Es por eo que Python se que|a producendo un error
UncodeDecodeError.
Esta conversn que a funcn str (o hacen ms funcones en Python, y en
muchos ms casos) reaza de Uncode a ASCII se puede modfcar,
ahorrndonos errores de tpo:
Unico"eDeco"e/rror: RasciiR co"ec canRt "eco"e S'te $TMMM in
Fosition MM: or"inal not in range;-&9<
Lo que podemos hacer es decre a Python que cuando se encuentre en e caso
de que tenga que reazar una conversn, en vez de hacero a ASCII de 7 bts,
o haga a so-8859-1, que es e que contempa e doma espao. Cmo se
hace esto?
Hay que crear un fchero, amado sitecusto#iUe%F'. Este fchero puede estar
en cuaquer parte, sempre que e i#Fort pueda encontraro, pero
normamente se encuentra en e b/ste-packages de Python. S por e|empo se
utza Python 2.5, este fchero debera de crearse en c:\Python25\Lb\ste-
packages.
E contendo sera e sguente:
mport sys
sys.setdefautencodng('so-8859-1')
Python ntentar mportar stecustomze.py cada vez que arranque, de manera
que e|ecutar automtcamente cuaquer cdgo que ncuya. La funcn
setdefautencodng estabece a codfcacn por omsn. ste es e esquema
de codfcacn que Python ntentar usar cada vez que neceste convertr
automtcamente una cadena Uncode a una norma.
La codfcacn por omsn so se puede cambar durante e nco de Python;
no se puede hacer ms adeante. Es ms, estando en e ntrprete de Python
no puede e|ecutarse a sentenca sys.setdefautencodng('so-8859-1'), ya que
nos dr que no exste este atrbuto.
Ahora que e esquema de codfcacn por omsn ncuye todos os caracteres
que usa en a cadena, Python no tene probemas en autoconvertr a cadena e
mprmra.
>>> x = u'nge'
>>> prnt str(x)
nge
3%- 0criFts P't(on en Unico"e
En Python e nombre de varabes, funcones cases se deben de escrbr en
codfcacn ASCII, pero hay caracteres no ASCII que se pueden ncur en
fcheros fuente, como comentaros cadenas de caracteres (entre comas).
Imagnamos que creamos un scrpt de sguente tpo:
A e|ecutaro nos aparece o sguente:
E carcter 7%a8 corresponde a a 9 espaoa, e cua no pertenece a ASCII.
Para que funcone correctamente Python necesta saber que e scrpt ncudo
20
en e fchero no es ASCII. La manera ms senca es coocar un comentaro
especa en a prmera segunda nea de scrpt, ta que as:
V NWN co"ing: utDN9 NWN
S vovemos a probar e cdgo con a modfcacn, todo funcona como se
esperaba, ya que e estamos dcendo a Python que nterprete e scrpt de
fchero en Uncode.
Resutando:
C:\>python scrpt.py
Espaa
C:\>
Una cabecera de mduo tpca es:
#!/usr/bn/env python
# -*- codng: utf-8 -*-
+% *unciones en P't(on
En Python se pueden utzar funcones, como en a mayora de os engua|es de
programacn. Su sntaxs es a sguente:
"eD nombre_funcon;parmetros<:
<...cdgo...>
In"entaci!n "e c!"igo
Para defnr boques de cdgo en Python se utza a ndentacn (sangra) de
cdgo, en contra de otros engua|es, como C, que utzan as aves {} para
enmarcar un boque. La dentacn tene que ser unforme desde e prncpo,
as que s desde un prmer momento se utzan 4 espacos en banco por
e|empo, han de usarse sempre, ya que de o contraro e ntrprete de Python
nos anzar un error de ndentacn de cdgo. Ago mportante a destacar
sobre este tema es no mezcar sangras de espacos en banco con e carcter
tabuador (TAB), ya que podra dar error de ndentacn.
Una funcn puede devover vaores con a paabra cave return (s se omte,
devueve None). Los parmetros pasados por una funcn son sempre por
referenca, excepto os numrcos y cadenas. Se permte dar vaores por
defecto a os parmetros (para cuando stos se omten en e cuerpo de a
funcn), sempre y cuando aparezcan a fna de a sta de parmetros. Las
funcones pueden tener atrbutos.
Co#entarios
En Python se pueden nsertar comentaros de una nea, preceddos por e
carcter V, mutnea, con trpe comado smpe dobe.
# Esto es un comentaro.
'''
Esto es un comentaro con
varas neas.
'''
"""
Y esto
tambn
"""
Vovemos a nuestro fchero script$py, y escrbmos e cdgo sguente para ver
todos os conceptos hasta e momento:
22
Darse cuenta de a sangra que utzamos para enmcarcar e boque de cdgo
correspondente a cuerpo de a funcn.
Una lista es un tpo de dato en Python, que se ver ms adeante. F|arse en
que a funcn modfca a sta a por referenca, ya que dcha funcn aade
(mtodo append) e eemento "6" a dcha sta. Ahora a sta contene os 6
prmeros nmeros.
24
Aqu podemos observar varas cosas. Se ha utzado a funcn ntegrada
roun" para redondear e vaor de atrbuto iva de a funcon. Darse cuenta de
a funconadad de os atrbutos de funcones. S e ector se esfuerza
nteectuaemente un poco ms podr darse cuenta que podemos utzar os
atrbutos de funcones para emuar e tipo de dato estructura, que se da en
agunos engua|es de programacn, como C PowerBuder, y de que Python
carece.
La paabra reservada Fass se utza para representar a decaracn nua.
None
None se utza como vaor de retorno por defecto en funcones. Es un ob|eto
ntegrado de tpo None(ype. Es una constante que ndca a ausenca de un
vaor.
26
+%-% *unciones an!ni#as: la#S"a

La sntaxs para crear una funcn annma es:
la#S"a |sta_parmetros|: Expresn_devueta
De esta forma se crea una funcn annma, esto es, una funcn que no tene
dentfcador. E%presi'n:devuelta debe de ser una expresn, no una
decaracn (es decr, no "f xx:...", "prnt xxx", etctera) y adems no puede
contener mtpes neas. Esta funcn ntegrada forma parte de con|unto de
programacn funcona, |unto con fter(), map() y reduce().
)% 1!"ulos
Un mduo es una brera en Python, y normamente corresponde a un archvo
de programa. Un fchero con extensn %F' es un mduo. E nombre de fchero
%F' es e nombre de mduo. Cada archvo es un mduo y os mduos
mportan a otros mduos para reazar dstntas tareas de programacn. Para
mportar un mduo se utza paabra cave i#Fort.
i#Fort puede r en cuaquer parte de cdgo, aunque se recomenda ncuro
a prncpo de scrpt, para mayor cardad y menor ofuscamento de cdgo.
Vamos a probar este concepto medante un e|empo. Se crea e drectoro
dir:python, y dentro de , vamos a ncur 3 fcheros, con nombres ;ichero<$py,
;ichero=$py y ;ichero>$py, con e sguente contendo:
28
Vamos a crear un cuarto fchero, denomnado principal$py, que amar a as
dstntas funcones de os mduos anterormente creados.
Se puede mportar nombres especfcos dentro de un mduo, de manera que
no se mporta todo e mduo, medante:
Dro# <moduo> i#Fort <smboo>
Tambn se puede crear un aas a nombre de un mduo, medante:
i#Fort <moduo> as <aas_moduo>
O a a funcn case ncuda en e mduo, medante:
Dro# <moduo> i#Fort <smboo> as <aas_smboo>
Hay una tma forma de mportar mduos y es con a sntaxs:
Dro# <moduo> i#Fort W
Esta manera es ega pero extremadamente desaconse|abe, sobretodo s se
crea gran cantdad de cdgo, puesto que hace dfc su mantenmento. Por
e|empo:
from a1 mport *
from a2 mport *
.
from a20 mport *
..
..
..
f(x,y)
Error-----> En qu mduo est mpementada a funcn?
..
..
..
30
Davd Goodger en su obra .ode Li+e a Pythonista? Idio#atic Python, expresa
extraordnaramente ben a no utzacn de esta expresn:
(Dagobah, jungla, pantanos, y niebla.)
L!E" #Es mejor from module import * $ue los imports e%pl&citos'
()D*" +o, no mejor. ,s rpido, ms -cil, ms seductor.
L!E" Pero #cmo sabr. por $u. los imports e%pl&citos son mejores
$ue la -orma con el carcter comod&n'
()D*" /aberlo tu podrs cuando tu cdigo intentes leer seis meses
despu.s.
)%-% LocaliUaci!n "e #!"ulos
Cuando ncumos a decaracn i#Fort para a carga de mduo
correspondente no se e dce a Python donde buscar. Por defecto Python
buscar prmero en e drectoro donde tengamos e programa prncpa
donde resda e ntrprete Python. S no o encuentra ah, segudamente
buscar en a varabe de entorno PYTHONPATH. S tampoco tene xto,
buscar por as bbotecas estndar que venen en a dstrbucn base de
Python.
Una manera de ver as rutas por as cuaes Python ntenta cargar os mduos
medante i#Fort es cargando e mduo de sstema s's (en e ntrprete), y a
contnuacn e|ecutar s's%Fat(. Esto nos devover una sta con todas as
rutas a as que Python accede para buscar os mduos requerdos.
32
)%&% Lista"o "e #!"ulos en la liSrera
estXn"ar
E stado competo de a brera estndar para Python 2.6.6 se puede
encontrar en:
http://docs.python.org/reease/2.6.6/modndex.htm
)%2% PacBages
Un package (paquete) es un espaco de nombres (namespace) que se asgna a
un drectoro, e cua ncuye mduos y un mduo especa de ncazacn
denomnado JJinitJJ%F', que posbemente est vaco. Los
packages/drectoros se pueden andar, por o que se puede acceder a un
mduo va package.package.....moduo.smboo. Esto que parece ago
compcado en readad no o es. Y para entendero, que me|or que con un
e|empo.
Para eo vamos a crear un drectoro dir:python. Dentro de vamos a crear un
package (es decr, un drectoro), denomnado #i:pac+age, que se compondr
de otro package andado, amado nivel<, y dentro de , un mduo amado
script$py, que contendr una funcn que nos devover "Hoa Mundo". Esto es:
"irJF't(on
FrinciFal%F'
#iJFacBage
JJinitJJ%F'
niCel-
JJinitJJ%F'
scriFt%F'
E mduo prncpa (principal$py) que amar , medante e uso de espaco de
nombres, a a funcn que est en script$py, se guardar en dir:python, como
se puede observar. E fchero script$py tene e sguente cdgo:
def mensa|e():
prnt "Hoa Mundo"
Para amar a esta funcn habra que decarar en e mduo principal$py o
sguente:
Dro# #iJFacBage%niCel-%scriFt i#Fort mensa|e
mensa|e()
E ector debe de darse cuenta de as venta|as de utzar espacos de nombres.
Se pueden crear breras de cases y funcones |erarquzadas, frameworks y
dems estructuras de cdgo Python ( no Python). Todo competamente
organzado. Crear namespaces es una buena dea.
34
8% PalaSras claCe ' Dunciones integra"as
en P't(on
S queremos saber as paabras cave que tene nuestra versn actua de
Python podemos acceder a mduo Be'Eor", e cua recoge dcho con|unto de
vocabos. Ta que as:
mport keyword
prnt "Paabras cave", keyword.kwst
S nos ponemos ago ms puntosos, podemos me|orar a presentacn, ben
utzando e mduo FFrint, creando una presentacn por coumnas:
mport keyword
tab = '\t'
enter = '\n'
contador = 0
cadena = ''
for n keyword.kwst:
cadena += + tab
f contador == 5:
contador = 0
cadena += enter
ese:
contador += 1
prnt cadena
Devovendo as paabras cave (versn 2.6.6):
Python trae consgo certas funcones que venen de sere, tambn amadas
funcones ntegradas, esto es, no es necesaro cargaras desde nngn mduo,
como raEJinFut aSs. Dchas funcones dependen de a versn Python que
tengamos nstaada en nuestro sstema. Podemos encontrar as SuiltNin
*unctions en:
http://docs.python.org/brary/functons.htm
9% TiFos "e "atos ' sus oFera"ores
OFera"ores "e co#Faraci!n "eDini"os Fara cualQuier tiFo "e "ato
Son os habtuaes: Y, Z, Y[, Z[, [[ (guadad), \[ YZ (no gua a), is
(ob|eto dentdad), is not (ob|eto dentdad negada).
OFera"ores "e asignaci!n
a [ S asgna e ob|eto b a a etqueta a.
a H[ S equvae a a = a + b. Adems a N[ S> a W[ S> a ,[ S> a ,,[ S> a ][
S> a WW[ S.
prmero, segundo = |0:2| equvae a prmero=|0| y segundo = |1|.
Se permte a asgnacn mtpe:
a = b = c = 0
sta1 = sta2 = |1,2,3|
c1,c2,c3 = 'abc' equvae a c1='a', c2='b', c3='c'.
x,y=y,x ntercamba os vaores de x e y.
S se quere saber e tpo de dato de cuaquer ob|eto se puede utzar a
funcn ntegrada t'Fe en e ntrprete de Python. Por e|empo:
>>> type(3.4)
<type 'foat'>
>>>
Los tpos de datos ms mportantes (que no os ncos) en Python son:
None, booeano, nmero, secuenca (cadena, sta, tupa) y fchero.
36
9%-% None
None: Aunque en readad es una constante, a podemos cataogar aqu, cuyo
sgnfcado es "ausenca de vaor". None es o que devueve una funcn por
defecto. E tpo de None es en readad NoneType.
9%&% 5ooleano
5ooleano: Tpo booeano, de as gebras de Booe. Los vaores de este tpo
son True y *alse. Los operadores son an", or y not. La funcn ntegrada
Sool;expresn< converte un vaor a booeano. As Sool;< devueve Fase,
Sool;expresn< devueve True s expresn es certo y Fase en caso contraro.
Se consdera Fase a constante None, e nmero cero y as secuencas y
dcconaros vacos. Todo o dems se consdera True.
38
9%2% N^#eros
N^#eros: Los 4 tpos de nmeros ms mportantes son: int (se mpementa
como ong de C), long (mtado por os recursos de a mquna), Dloat (se
mpementa como doube de C) y co#FleT (nmero compe|o, representado
como un par de nmeros de punto fotante de dobe precsn a nve de
mquna), esto es, con parte rea e magnara).
E operador para e tpo numrco compe|o es a funcn ntegrada
compex(parte_rea, parte_magnara), que genera un tpo de dato compex. S
z es un compex, z.rea devueve a parte rea y z.mag devueve a parte
magnara.
Para e resto de nmeros, os operadores de castng (conversn) son:
int;x< devueve x convertdo a tpo nt.
long;x< devueve x convertdo a tpo ong.
Dloat;x< devueve x convertdo a tpo foat.
coerce;x,y< devueve a tupa (x,y), donde y es convertdo a msmo tpo que x.
Los operadores de nmeros son os que nos podemos encontrar en cuaquer
engua|e de programacn, a saber: -x, x + y, x - y, x * y, x / y (dvsn entera),
x % y (dvsn moduar), x**y (x eevado a y).
Adems, exsten otras funcones ntegradas para operacones matemtcas,
como:
aSs;x< devueve e vaor absouto de x.
FoE;x,y< devueve x**y.
"iC#o";x, y< devueve a tupa (x/y, x%y).
c#F;x,y< devueve -1 s x<y, 0 s x == y y 1 s x>y.
roun";x,y< redondea x con y poscones decmaes.
Se pueden encontrar ms funcones matemtcas en os mduos #at(,
c#at( y ran"o#. Tambn se encuentran enteros bnaros, hexadecmaes y
octaes. Hay un tpo de nmero, amado Deci#al, t para reseprentar
fraccones, que est en e mduo "eci#al.
9%3% 0ecuencias
Una secuenca es un tpo de dato que contene una sere de eementos, con un
orden, en donde se pueden acceder a os msmos para obtener su vaor
medante certos mecansmos.
Hay 2 tpos de secuencas, a saber, e tpo de secuenca mutabe, que est
compuesto por e tpo de dato sta, y as secuencas nmutabes, que estn
compuestas por e tpo de dato tupa y e tpo de dato cadena.
40
9%3%-% Listas
Una sta es un tpo de dato secuenca de case mutabe (se puede modfcar
una vez nstancada), donde sus eementos pueden ser heterognos
homogneos. Una sta en Python es de tpo list.
Lsta = || nstancamos una sta vaca.
Lsta = |1,2,4,5,6|
Lsta = |u'Ange Lus', 32, 'Lorca', |u'Ingenero Tcnco Informtca','Python'||
Como se puede observar una sta puede contener eementos de msmo tpo
dferentes. Una sta puede contener stas y cuaquer otro tpo de dato, ob|etos
ncudos.
Medante certos mtodos de a sta se pueden aadr emnar eementos de
a sta. Es por eo que se dce que a sta es una secuenca mutabe, ya que
despus de ser nstancada puede modfcarse.
9%3%&% TuFlas
Una tupa es un tpo de dato secuenca de case nmutabe (no se puede
modfcar una vez nstancada), donde sus eementos pueden ser heterogneos
homogneos. Una tupa en Python se defne como de tpo tuFle.
Tupa = () nstancamos una tupa vaca.
Tupa = (1,) una tupa con un eemento.
Tupa = (1,34)
Tupa = ("Hoa Mundo",2.3,|1,2,3|,('a',3))
A gua que as stas, os eementos de as tupas pueden ser de msmo
dferente tpo. Sn embargo as tupas son nmutabes, es decr, una vez
nstancadas (creadas) no se pueden modfcar, esto es, no se pueden emnar
aadr eementos a a tupa ya creada.
42
9%3%2% Ca"enas
En Python os tpos str y unico"e son tpos cadena. Una cadena es un tpo
nmutabe, ya que a gua que as tupas, una vez creada no se puede
modfcar.
Cadena = 'Hoa Mundo'
Cadena = "Hoa Mundo"
Las cadenas contenen caracteres afanumrcos.
9%3%3% *or#as "e acce"er a ele#entos "e
secuencias
Hay varas maneras de poder acceder a eementos de una secuenca (vdo
para stas, cadenas y tupas):
1) Acceso medante ndces.
secuenca = |'Hoa','Mundo','Python'|
secuenca|0| == 'Hoa'
secuenca|1| == 'Mundo'
secuenca|2| == 'Python'
La ndzacn comenza en a poscn 0, como se puede observar. ndces
negatvos sgnfca contar haca atrs desde e fna de a secuenca, as
tendremos que:
secuenca|-1| == 'Python'
secuenca|-2| == 'Mundo'
secuenca|-3| == 'Hoa'
S a secuenca contene secuencas podemos acceder a sus eementos
tambn medante ndzacn de a sguente manera:
secuenca|2||0| == 'P'
secuenca|2||1| == 'y'
secuenca|2||2| == 't'
secuenca|2||3| == 'h'
secuenca|2||4| == 'o'
secuenca|2||5| == 'n'
2) Acceso medante scng.
slicing sgnfca en ngs "rebanar", y en e dcconaro de a RAE, en su
segunda acepcn, rebanar es "cortar o dvdr ago de una parte a otra".
Ben, pues esta tcnca es exactamente o que hace. De o que se trata
es de obtener seccones de una secuenca. Esta forma de acceso es
tremendamente poderosa en Python.
E scng funcona de a sguente manera:
_n"ice "e co#ienUo:n"ice Din`
donde "ndce de comenzo" est ncudo e "ndce fn" est excudo. S
se omte e "ndce de comenzo" por defecto toma vaor 0. S se excuye
e "ndce fn" por defecto toma e ndce de tmo eemento de a
secuenca (que concde con en(secuenca)).
44
secuenca = (1,2,3,4,5)
secuenca|:| == (1,2,3,4,5) En este caso, puesto que se han omtdo
tanto os ndces de comenzo, como de fn, e scng da como resutado
una copa de a secuenca.
secuenca|1:| == (2,3,4,5) Aqu estamos obtenendo una tupa, desde
a poscn 1 hasta e tmo eemento de a secuenca.
secuenca|2:3| == (3,) Darse cuenta que estamos obtenendo e
eemento de a poscn 2 hasta a poscn 3 (e cua se excuye). Es por
eo que se obtene una tupa de un nco eemento.
secuenca|:4| == (1,2,3,4) Se excuye a poscn de "ndce fn" y puesto
que no hemos decararo e "ndce de comenzo", se toma por defecto 0.
En e scng hay un tercer eemento opcona, e "paso", y que srve para
ndcar satos en a secuenca. S no se decara, por defecto es 1. La
sntaxs es:
_n"ice "e co#ienUo:n"ice Din:Faso`
secuenca|::1| == secuenca|:| == (1,2,3,4,5)
secuenca|::&| == (1,3,5) Esta expresn o que dce es a partr de a
poscn de "ndce de comenzo" (ncudo), seeccona os eementos
que se encuentren a dos poscones de ongtud y as sucesvamente.
secuenca|:4:2| == (1,3) Ahora a expresn dce que a partr de a
"poscn de comenzo", y hasta a poscn 4 (excuda), obtenga todos
os eementos cada dos poscones y as sucesvamente.
secuenca|1::2| == (2,4) Obtenemos todos os nmeros pares.
Los ndces negatvos ndcan contar haca atrs, desde e fna de a
secuenca. La caracterstca de satos en e scng o contempa:
secuenca|::-1| == (5,4,3,2,1) Orden nverso.
secuenca|::-2| == (5, 3, 1) Orden nverso de nmeros mpares.
NOTA: S e paso es negatvo, se ntercamban os ndces de comenzo y
fn. Tener esto en cuenta, para no evarse mprevstos en e resutado.
secuenca|4:0:-1| == (5, 4, 3, 2)
secuenca|4:1:-1| == (5, 4, 3)
secuenca|4:2:-1| == (5, 4)
De todas formas, no hay que compcar as cosas en exceso s se pueden
hacer expctas.
3) Medante itera"ores y a estructura de contro de fu|o Dor, que veremos
ms adeante.
46
9%3%+% OFeraciones soSre secuencias
x in secuenca: Devueve True s x es un eemento de secuenca y Fase en
caso contraro.
x not in secuenca: Devueve True s x no es un eemento de secuenca y Fase
en caso contraro.
secuenca1 H secuenca2: Concatena secuencas de msmo tpo.
n W secuenca : Contanena a secuenca n veces.
secuenca.count;x<: Devueve e nmero de veces que est e eemento x en
a secuenca.
secuenca.in"eT;x<: Devueve e ndce de prmer eemento x de a secuenca
(e ndce ms pequeo).
len;secuenca<: Devueve e nmero de eementos de a secuenca.
#in;secuenca<: Devueve e eemento ms pequeo de a secuenca.
#aT;secuenca<: Devueve e eemento ms grande de a secuenca.
sorte";secuenca<: Devueve a secuenca ordenada.
reCerse";secuenca<: Devueve un terador de a secuenca en orden nverso.
E|empos:
En este e|empo o que se hace es acceder a prmer eemento de a sta y
contar os eementos "a" de dcho eemento, es decr, cuantas a's hay en a
paabra "Hoa".
48
9%3%+%- OFeraciones soSre listas
|| = x E eemento de a sta es reempazado por x.
|:|| = k E scng de a | en a sta se reempaza por k.
de |:|| Es o msmo que hacer |:|| = ||.
.append(x) Aade e eemento x a fna de a sta .
.extend(2) Aade a sta 2 a fna de a sta .
.nsert(,x) Inserta e eemento x en a poscn de a sta .
.reverse() Inverte e orden de os eementos de a sta .
.sort() Ordena a sta .
x = .pop() Devueve en x e tmo eemento de a sta , y emna de a sta
dcho tmo eemento (en otras paabras, saca e tmo eemento de a sta).
E|empos:
50
9%3%+%&% OFeraciones soSre ca"enas
Las cadenas en Python tenen una gran cantdad de mtodos, de os cuaes se
presentan os ms mportantes en cuanto a su uso:
cadena.strp() Devueve e contendo de cadena sn espacos en banco a
prncpo y a fna de a msma.
cadena.spt(sep) Devueve una sta de as paabras que hay en cadena,
usando como separador sep.
cadena.fnd(subcadena) Devueve e prmer ndce (y menor) de a cadena en
donde se encuentra subcadena.
Cadena.upper() Devueve una copa de a cadena con todas as etras en
mayscua.
Cadena.ower() Devueve una copa de a cadena con todas as etras en
mnscua.
Cadena.captaze() Devueve una copa de a cadena con a prmera etra en
mayscua y as restantes en mnscua.
Cadena.repace(antguo, nuevo) Devueve una copa de a cadena,
reempazando todos os eementos antguo por e eemento nuevo.
sep.|on(sec) Devueve una concatenacn de cadenas de a secuenca sec,
separadas por e separador sep.
Ms mtodos son center, decode, encode, endswth, sanum, sapha, sdgt,
stte, sower, supper, rfnd, rndex, rpartton, rstrp, |ust, r|ust, rspt,
sptnes, startswth, swapcase, tte, transate, zf.
E|empos:
52
9%+% TaSlas (as(ing ;"iccionarios<
Un dcconaro taba hashng es un tpo de dato donde cada eemento es un
par <cave:vaor>, sendo a cave unvoca para todo e dcconaro, y vaor
cuaquer tpo de dato, que puede repetrse. En Python os dcconaros son de
tpo "ict.
d = {} Dcconaro vaco.
d = {1:'Python, 2:'C++',3:'R',4:'Fortran',5:'|ava'}
d = {nombre:u'Ange Lus,apedo1:'Garca,apedo2:'Garca',edad: 32}
d = {1:'UMU','Insttuto':u'Mara Cegarra Sacedo'} Las caves pueden ser de
tpos dferentes. E nco requsto es que no puede haber dupcdades de
caves.
9%+%-% OFeraciones soSre "iccionarios
d|'x'| Devueve e vaor cuya cave es 'x'.
en(d) Devueve e nmero de caves de dcconaro.
de (d|'x'|) Emna e eemento cuya cave es x y su vaor d|'x'| de dcconaro.
d.copy() Devueve una copa de dcconaro d.
d.has_key(k) Devueve True s exste a cave k y Fase en caso contraro. Esta
expresn es equvaente a k n d.
d.get(k,x) Devueve e vaor de a cave k. S no exste devueve x.
d.setdefaut(k,x) Devueve e vaor de a cave k s exste. S no exste crea e
eemento k:x (cave k y vaor x) y devueve x.
d.cear() Emna todos os eementos de dcconaro.
d.poptem() Devueve y emna un eemento.
d.tems() Devueve una sta de de todos os eementos, donde cada eemento
es una tupa (cave, vaor).
d.keys() Devueve una sta con todas as caves.
d.vaues() Devueve una sta con todos os vaores.
En os dcconaros no exste ordenacn. Para terar sobre todos os eementos
de un dcconaro se pueden utzar varas tcncas, entre eas e uso de
teradores y de buces for, que veremos ms adeante.
E|empos:
54
9%)% *ic(eros
E tpo de dato fchero en Python es Dile. Se crean fcheros a partr de a funcn
ntegrada oFen;< su aas Dile;<. Tambn se pueden crear a partr de otros
mduos, como codecs.
Crear un fchero en Python es tan smpe como:
f = open(nombre_fchero, fag)
donde f es e mane|ador de fchero. nombre_fchero es una cadena que
dentfca e nombre de fchero y fag ndca e modo de apertura de fchero,
que puede ser r (ectura), w (escrtura), a (aadr a fna de fchero), r+
(random). Tambn cabe a posbdad de ndcar que se trata de un fchero
bnaro de un modo sn converson EOL (fn de nea), medante rb, wb, ab y
r+b respectvamente.
Hay varas formas de eer un fchero en Python (una vez aberto):
f.read(t) Lee a o sumo t bytes de fchero f y devueve e contendo en un
ob|eto cadena. S t se omte devueve e contendo de fchero hasta que
encuentre EOF (fn de fchero)
f.readne() Lee una nea entera de un fchero, donde e fna de nea es Enter
(\n), excepto que se egue a EOF (fn de fchero).
f.readnes() Lee hasta que encuentre EOF (fn de fchero) y devueve una sta
con as neas edas.
Y varas formas de escrbr un fchero:
f.wrte(cadena) Escrbe a cadena en e fchero f.
f.wrtenes(sta) Escrbe una sta de cadenas en e fchero f. No se aade EOL
(fn de nea).
Y fnamente, cerrar e fchero.
f.cose()
Hay otros mtodos estndar para e tratamento de fcheros (que encontramos
en a mayora de engua|es) como seek, te, truncate fush.
Pudera ser que se necestase abrr abrr un fchero con aguna codfcacn
especa. Para eo est e mduo codecs. Por e|empo, s se quere abrr un
fchero con codfcacn utf-8 se podra utzar:
f = codecs.open('nombre_fchero',"rb","utf-8")
Veamos ahora con e|empos o expuesto en e tratamento de fcheros.
56

9%8% 1Xs tiFos en P't(on
En Python hay ms tpos de datos, como con|untos (set y frozenset), y otros
que se pueden encontrar en mduos, como coectons, tme, datetme, array,
UserDct, UserLst, UserStrng, types, etc.
58
=% ConCersiones entre listas> tuFlas '
taSlas (as(ing
Se pueden hacer conversones entre os tpos de datos ms popuares de
Python, a saber, stas, tupas y dcconaros. Para eo se utzan as funcones
ntegradas "ict, list y tuFle. Para ver este punto que me|or que hacero con
un e|empo:
= |'Taer Cadum', 2011|
t = ('Unversdad de Murca','Python')
u = |(1,'Python'),(2,'wxPython')|
d = {1:'XML',2:'IronPython',3:'ReportLab'}
tuFle;< Devueve ('Taer Cadum',2011)
list;t< Devueve |'Unversdad de Murca','Python'|
"ict;u< Devueve {1:'Python',2:'wxPython'}
d.ite#s;< Devueve |(1,'XML'),(2,'IronPython'),(3,'ReportLab')|
d.Be's;< Devueve |1,2,3|
d.Calues;< Devueve |'XML','IronPython','ReportLab'|
Exste a funcn ntegrada str;< para convertr cuaquer parmetro en una
cadena, s es posbe. Por e|empo:
str;|1,2,3,4|< devueve "|1,2,3,4|"
-$% *or#ateo "e ca"enas
Normamente cuando se defnen cadenas que contenen varabes, para formar
otra cadena, puede utzarse e operador H para concatenar todo y obtener e
resutado deseado. Esta sera a prmera forma de crear cadenas con datos
varabes. Esto es:
>>> engua|e = 'Python'
>>> carac1 = 'mutparadgma'
>>> carac2 = 'mutpataforma'
>>> cadena = engua|e + ' es un engua|e ' + carac1 + ' y ' + carac2 + '.'
>>> cadena
'Python es un engua|e mutparadgma y mutpataforma.'
>>>
La segunda forma, ms eegante y efcente es utzar e operador ], de a
sguente manera:
cadena = '%s es un engua|e %s y %s.' % (engua|e,carac1,carac2)
% utza e fag s que corresponde a cadena (strng). %s converte cuaquer
tpo de argumento a cadena, ya que utza a funcn ntegrada str;<. Darse
cuenta de cmo se utza % y e paso de argumentos. Ms eegante y senco
de eer. E operador % tambn se utza para dar formato de sada a nmeros.
Una tercera forma es utzar e mduo string, e cua provee de un
mecansmo para susttur varabes en cadenas plantilla. Su utzacn es ta
como sgue:
mport strng
p = strng.Tempate('$engua|e es un angua|e $c1 y $c2.') Creamos a panta.
p.substtute({'engua|e:'Python', 'c1':'mutparadgma','c2':'mutpataforma'})
Devueve a cadena con as susttucones hechas en a panta:
'Python es un engua|e mutparadgma y mutpataforma.'
e mtodo substtute anza un error KeyError s no exste a cave
correspondente. S se quere gnorar esto se puede utzar safe_substtute en
su ugar. Por tmo cabe destacar que s se quere utzar en a panta e
carcter $, tene que r preceddo de $$.
Darse cuenta que as varabes a susttur comenzan con $. Los vaores a
susttur son provstos medante un dcconaro va substtute safe_substtute.
Una cuarta forma es utzar e mtodo de cadena Dor#at;<.
60
--% Control "e DluGo
En Python hay 3 estructuras bscas de contro de fu|o de programa, que estn
en a mayora de os engua|es de programacn que soportan e paradgma
mperatvo, a saber: a estructura condcona iD, y as estructuras de buces Dor
y E(ile.
--%-% /structura "e salto con"icional iD
La posbes sntaxs son:
iD condcn: <decaracn>
eliD condcn: <decaracn>
iD condcn: <decaracn>
else: <decaracn>
iD condcn:
<decaracones>
eliD condcn:
<decaracones>
iD condcn:
<decaracones>
else:
<decaracones>
/TFresi!n con"icional ;no "eclaraci!n<
resutado = (VaorSCerto iD condcn else VaorSFaso)
es equvaente a:
iD condcn:
resutado = VaorSCerto
else:
resutado = VaorSFata
NOTA: Los parntess no son obgatoros, aunque s recomendabes.
62
Veamos a contnuacn agunos e|empos:
--%&% /structura "e Sucle E(ile
La sntaxs es a sguente:
whe <condcn>:
<decaracones>
Para sar de buce est a paabra cave SreaB. Para forzar una nueva
teracn se utza a paabra cave continue.
64
--%2% /structura "e Sucle Dor
La sntaxs es:
for eemento n secuenca:
<decaracones>
Lo que hace es terar sobre a secuenca, asgnando cada eemento de a
msma a "eemento". Se puede utzar a funcn ntegrada range para terar
un nmero de veces. A gua que con E(ile, se utza SreaB para sar
ncondconamente de buce y continue para forzar una nueva teracn.
Veamos agunos e|empos:
-&% Itera"ores
Un terador enumera eementos de una coeccn. Es un ob|eto con un nco
mtodo, denomnado neTt;<, que devueve e sguente eemento o anza un
error de StopIteration. Se puede crear un terador medante a funcn
ntegrada iter;ob|eto<. Vamos a hacer agunos e|empos de esto:
66
-2% Progra#aci!n orienta"a a oSGetos
La progamacn orentada a ob|etos se basa en dos conceptos generaes, e de
clase y oSGeto, y 4 pares fundamentaes, a saber, (erencia, Foli#orDis#o,
encaFsulaci!n y aSstracci!n.
Python tene herenca mtpe, no tene pomorfsmo entenddo como
sobrecarga de mtodos (aunque haya formas de emuaro) y se puede
mpementar e encapsuamento y a abstraccn.
En Python todo es un ob|eto, y una case sempre hereda de ob|eto oSGect.
Una case se defne medante:
class nombre_case(ob|ect):
<decaracones>
Las cases tenen atrbutos de case, de msmo esto que suceda con as
funcones. Vamos a ver esto con un e|empo:
Normamente una case tene atrbutos y mtodos. En Python, un atrbuto se
puede decarar en cuaquer sto, aunque o propo sera en e mtodo __nt__,
que aunque no es e constructor, s que es e sto donde habra que poner e
cdgo que e|ecutara e constructor.
Los mtodos especaes se ncan y termnan con __. Los ms destacados son:
JJinitJJ Mtodo donde ncuramos todo que qusramos e|ecutar en e
constructor (no es e constructor).
JJ"elJJ Mtodo destructor.
Veamos e sguente e|empo:
68
Los atrbutos sempre tenen que r preceddos por selD. Esto se hace para
poder hacer referenca a eos. Los mtodos se defnen con "eD. En os
argumentos de os mtodos sempre tene que r selD como prmer argumento.
En e e|empo a case tene 2 atrbutos ncazados a None y 2 mtodos que no
hacen nada (pass). Adems se mpementa e destructor.
Un ob|eto es a nstancacn de una case. Vamos a crear un ob|eto.
Como se puede observar son pbcos tanto os atrbutos como os mtodos.
Podemos hacer atrbutos y mtodos ocutos medante e na#e #angling, que
es ncur JJ a prncpo de mtodo atrbuto.
Ahora soo son pbcos os mtodos, ocutando os atrbutos. Darse cuenta que
os mtodos especaes tambn evan __ a prncpo, por o que son ocutos.
70
Los atrbutos de una case se pueden ncazar en e momento de su
nstancacn, ta que as:
La encapsulacin se consdera una de as caracterstcas defntoras de a
orentacn a ob|etos.
Cuando una case exste (se defne), se crean ob|etos a partr de ea, y se usan
dchos ob|etos nvocando os mtodos necesaros. Es decr, creamos ob|etos
para usar os servcos que nos proporcona a case a travs de sus mtodos.
No necestamos saber cmo traba|a e ob|eto, n saber as varabes que usa, n
e cdgo que contene.
E ob|eto es una ca|a negra. NNZ 1o"elo cliente N serCi"or. Es decr, e ob|eto
es un servdor que proporcona servcos a os centes que o soctan.
La encapsuacn descrbe e hecho de que os ob|etos se usan como ca|as
negras. As, un ob|eto encapsua datos y mtodos, que estn dentro de ob|eto.
InterDaU F^Slica "e una clase: Es e con|unto de mtodos (mtodos de
servco) que srve para que os ob|etos de una case proporconen sus
servcos. Estos servcos son os que pueden ser nvocados por un cente.
1Ito"os "e soForte: Mtodos adconaes en un ob|eto que no defnen un
servco utzabe por un cente, pero que ayudan a otros mtodos en sus
tareas.
La encapsulacin es un mecansmo de contro. E estado (e con|unto de
propedades, atrbutos datos) de un ob|eto so debe ser modfcado por
medo de os mtodos de propo ob|eto.
E concepto de encapsuamento se apoya sobre e concepto de abstraccn.
En POO soo necestamos saber como nteracconar con os ob|etos, no
necestamos conocer os detaes de cmo est mpementada a case a partr
de a cua se nstanca e ob|eto. So necestamos conocer su nterfaz pbca.
La encaFsulaci!n es una Dor#a "e aSstracci!n%
La encaFsulaci!n es un #ecanis#o Fara lleCar a la FrXctica la
aSstracci!n%
E nve de abstraccn puede ser ba|o (en un ob|eto se manpuan datos y
mtodos ndvduamente), ato (en un ob|eto soo se usan sus mtodos de
servco).
Por tanto para poner en prctca a encapsuacn y abstraccn se hace
necesaro dsear una case de a manera correcta, a saber: todos os atrbutos
deben de ser ocutos, os mtodos prvados (o de soporte) tambn.
ncamente os mtodos son capaces de cambar e estado de atrbutos,
habendo un con|unto de eos que son pbcos.
72
La herenca en Python es muy senca. Lo vemos:
S queremos ncur en a segunda case, que hereda de a prmera, ago en su
__nt__ tenemos que tener en cuenta que segudamente hay que amar a
__nt__ padre, ya que de o contraro estamos hacendo overrde.
74
Python soporta herenca mtpe, de a sguente manera.
S a case que hereda de as dos anterores modfcamos su __nt__
evdentemente tenemos que amar ah a os __nt__ de as cases padres. La
herenca mtpe es muy pegrosa s no se mpementa con cudado, ya que se
puede hacer overrde de atrbutos mtodos con e msmo nombre.
76
-3% 1aneGo "e eTceFciones
En Python e mane|o de excepcones se trata con e boque try/except. La
sntaxs es a sguente:
tr':
<decaracones boque1>
eTceFt:
<decaracones boque2>
S as decaracones de boque1 dan como resutado agn tpo de error, se
sata ncondconamente a e|ecutar a decaracn de boque2.
Otro e|empo de uso de este mecansmo.
Hay ms opcones de mane|o de excepcones, como else, Dinall', as, Eit(,
tiFos "e eTceFciones, que se de|a a ector su estudo.
-+% cPicBle: Fersistencia "e oSGetos
En Python se pueden serazar ob|etos, esto es, guardar un ob|eto que resde
en memora, a dsco. Este proceso de serazacn se puede hacer medante un
mduo, amado cPicBle.
La serazacn de ob|etos se mpementa en otros engua|es con XML, Yam,
etc. Lo bueno que tene cPcke es que es bastante rpdo y muy fc de usar.
La sntaxs para hacer un ob|eto persstente es:
mport cPcke
cPicBle%"u#F;x, fchero<
donde x es e ob|eto a serazar y fchero e mane|ador de fchero.
S se quere cargar e ob|eto de fchero a memora:
x = cPicBle%loa";fchero<
Podramos crear una case genrca que o que haga sea serazarse y cargarse
a s msma. De esta manera podramos heredar de ea y daramos una
funconadad de serazacn a todas as cases que heredaran de ea. Dcha
case podra ser esta:
mport cPcke
cass persstenca(ob|ect):
def nombre_case(sef):
return str(sef).spt(' ')|0|.spt('.')|1|
def cargar(sef, nombre_fchero = None):
f nombre_fchero s None:
nombre_fchero = sef.nombre_case()
mane|ador_fchero = open(nombre_fchero,'r')
ob|eto = cPcke.oad(mane|ador_fchero)
mane|ador_fchero.cose()
return ob|eto
def savar(sef, ob|eto, nombre_fchero = None):
f nombre_fchero s None:
nombre_fchero = sef.nombre_case()
# Fchero que contendr e ob|eto.
mane|ador_fchero = open(nombre_fchero,'w')
# Vocamos e ob|eto de memora a fchero.
cPcke.dump(sef, mane|ador_fchero)
# Cerramos fchero.
mane|ador_fchero.cose()
78
-)% 0criFts en P't(on
En este apartado se presenta un e|empo de scrpt Python para contar
caracteres en fcheros de texto pasados como parmetro. Se puede ncur
fags, de manera que se puede confgurar s se quere contar caracteres
especaes. As, por e|empo, s queremos contar os caracteres que un fchero,
sn contar os espacos en banco, smpemente haremos: python scrpt.py
fchero.txt -SPACE, donde es e scrpt.py es e fchero que contene e scrpt y
fchero.txt e archvo a cua queremos contar os caracteres.
Fchero contarJcaracteres%F':
# -*- codng: utf-8 -*-
mport sys
# Decaramos agunas constantes.
FF = '\f' # Form Feed
LF = '\n' # Lne Feed
CR = '\r' # Carrage Return
TAB = '\t' # Tabuador
SPACE = ' ' # Banco
try:
excepcon = 0
sta_excepcon = ||
fchero = sys.argv|1|
opcones = sys.argv|2:|
f '-FF' n opcones: sta_excepcon.append(FF)
f '-LF' n opcones: sta_excepcon.append(LF)
f '-CR' n opcones: sta_excepcon.append(CR)
f '-TAB' n opcones: sta_excepcon.append(TAB)
f '-SPACE' n opcones: sta_excepcon.append(SPACE)
f = open(fchero,"r")
caracteres = f.read()
for n caracteres:
f n sta_excepcon: excepcon += 1
f.cose()
prnt "E fchero %s tene %d caracteres" \
%(fchero, en(caracteres) - excepcon)
except: prnt "Error a abrr e fchero."
Un e|empo de uso de este scrpt es e sguente:
80
-8% Progra#a "e loteras> en P't(on
A contnuacn se presenta un programa muy senco, escrto en Python, para
a generacn aeatora de combnacones para |uegos de azar. Se ha utzado
e mduo ran"o# para crear os nmeros pseudoaeatoros.
# -*- codng: utf-8 -*-
mport random, os
def combnacon(num_ee, tota_num, repetr = Fase,ordenar_resutado = True):
eementos = ||
f num_ee > tota_num and not repetr:
prnt "No puedes sacar ms vaores de os que ya tenes!"
return
aux = num_ee
whe aux > 0:
numero = nt(random.unform(1,tota_num))
f repetr:
eementos.append(numero)
aux = aux - 1
ese:
f eementos.count(numero) == 0:
eementos.append(numero)
aux = aux - 1

f ordenar_resutado:
eementos.sort()
prnt eementos
def menu():
prnt '''
================================
MENU PRINCIPAL
================================
Este programa genera combnacones
de |uegos de azar. Ege e |uego
que ms te guste.
1) Lotera prmtva
2) Euromones
9) Sar
'''
opcon = raw_nput("")
return opcon
def apcacon():
os.system('cs')
opcon = ""
whe opcon != "9":
opcon = menu()
f opcon == "1":
prnt ""
prnt "Combnacn para Lotera Prmtva: "
combnacon(6,49)
prnt ""
f opcon == "2":
prnt ""
prnt "Euromones"
prnt "Combnacn ganadora: "
combnacon(5,50)
prnt "Estreas: "
combnacon(2,9)
prnt ""
# E|ecutamos e programa.
apcacon()
-9% Una agen"a en P't(on
En este apartado vamos a ver como crear una agenda persona mnmasta, en
Python, que controa os ncks de personas repetdas, y que utza persstenca
de ob|etos para guardar en dsco.
# -*- codng: utf-8 -*-
# Creacn de una agenda smpe, en Python.
# Introduccn a Python.
# Defnmos un men prncpa.
def menu():
texto = u'''
AGENDA v0.0.1 - Taer CALDUM Febrero 2011
Agenda de contactos de personas.
Ege opcn:
1) Ata.
2) Ba|a.
3) Modfcacn.
4) Lstar.
5) Guardar.
0) Sar.
'''
prnt texto
opcon = raw_nput("Ege opcn: ")
#Devovemos opcn.
return opcon
# Defnmos una case para mpementar a persstenca.
mport cPcke
cass persstenca(ob|ect):
def nombre_case(sef):
return str(sef).spt(' ')|0|.spt('.')|1|
def cargar(sef, nombre_fchero = None):
f nombre_fchero s None:
nombre_fchero = sef.nombre_case()
mane|ador_fchero = open(nombre_fchero,'r')
ob|eto = cPcke.oad(mane|ador_fchero)
mane|ador_fchero.cose()
return ob|eto
def savar(sef, ob|eto, nombre_fchero = None):
f nombre_fchero s None:
nombre_fchero = sef.nombre_case()
# Fchero que contendr e ob|eto.
mane|ador_fchero = open(nombre_fchero,'w')
# Vocamos e ob|eto de memora a fchero.
cPcke.dump(sef, mane|ador_fchero)
# Cerramos fchero.
mane|ador_fchero.cose()
# Creamos una case agenda.
cass m_agenda(persstenca):
def __nt__(sef):
sef.__sta = ||
def ata(sef, persona):
nck = persona|0|.ower().strp()
for n sef.__sta:
f |0|.ower().strp() == nck:
prnt "%s ya exste" % (nck)
return
sef.__sta.append(persona)
prnt "Ata correcta"
82
def ba|a(sef, nck):
for n sef.__sta:
f |0|.ower().strp() == nck.ower().strp():
sef.__sta.remove()
prnt "%s se ha borrado" % (nck)
return
prnt "%s no exste" % (nck)

def modfcacon(sef, persona):
nck = persona|0|
for n sef.__sta:
f |0|.ower().strp() == nck.ower().strp():
sef.__sta.remove()
sef.__sta.append(persona)
prnt "%s se ha modfcado" % (nck)
return
prnt "%s no exste"

def sta(sef):
return sef.__sta

# Cargamos a agenda en memora.
agenda = m_agenda()
try: agenda = agenda.cargar()
except: pass
# Scrpt prncpa de a apcacn.
whe True:
opcon = menu()
# Samos
f opcon == '0':break
# Ata.
f opcon == '1':
buffer_ata = ||
for n |'Nck:','Nombre:','Apedos:','Tefono:'|:
dato = raw_nput()
buffer_ata.append(dato)
# Intentamos dar de ata.
agenda.ata(buffer_ata)
# Ba|a.
f opcon == '2':
nck = raw_nput('Nck:')
agenda.ba|a(nck)
# Modfcacn.
f opcon == '3':
buffer_modf = ||
for n |'Nck:','Nombre:','Apedos:','Tefono:'|:
dato = raw_nput()
buffer_modf.append(dato)
# Intentamos modfcar.
agenda.modfcacon(buffer_modf)
# Lstar.
f opcon == '4':
sta = agenda.sta()
for n sta: prnt
# Guardar.
f opcon == '5':
agenda.savar(agenda)


-=% TiFos "e Dic(eros P't(on
En Python exsten varos tpos de fcheros. E prmero y ms mportante, es e
de extensn %F' (fchero de cdgo fuente).
S en e drectoro donde estn os fcheros fuente .py de a apcacn se
encuentran adems fcheros con e msmo nombre y extensn %F'c, estos son
as versones "byte comped" de nuestos fcheros .py. S se modfcan os
fcheros fuente automtcamente se vueven a generar os fcheros .pyc, esto
es, no tenemos que hacer nada con os fcheros compados .pyc.
S se nvoca Python con a opcn No se genera cdgo optmzado en fcheros
%F'o (byte code optmzado). En este caso se goran os fcheros .pyc. Esta
opcn no hace mucho (emnar os assert).
Un programa no se e|ecuta ms rpdo s se ee desde fcheros .pyc .pyo que
cuando se ee de fcheros .py. Lo nco que es ms rpdo a usar .pyc .pyo
es a veocdad con a que se cargan.
Los fchero %F'" son en readad DLL's de Python.
S se quere e|ecutar cdgo Python en un entorno grfco de modo que a
consoa de texto no aparezca, podemos renombrar e fchero prncpa .py a
%F'E, y e|ecutaro. La consoa de texto no aparecer, soo a apcacn grfca.
84
&$% 1!"ulos #Xs i#Fortantes
No hay en Python un mduo ms mportante que otro, ya que dependendo de
nuestras exgencas habr agunos mprescndbes y otros ago ms vanos.
Sn embargo, es certo que hay mduos cuyo uso es muy comn. Pasamos a
enumeraros:
os: Mduo nterfaz con e sstema operatvo (Wndows, posx, Mac). En e
espaco de nombres os%Fat( encontramos mtodos para operacones de
nombres de rutas. E|empos:
os%s'ste#;comando< Lamada a sstema para e|ecutar comando.
os%startDile;f< Abre e fchero f con e programa asocado en e sstema.
re ! sre: Mduo de operacones de expresones reguares.
"ateti#e ' ti#e: Mduos de tratamento de tempo y fechas.
s(util: Mduo de operacones con fcheros de ato nve, taes como copa,
borrado (fcheros, drectoros).
s's: Mduo de parmetros y funcones especfcas de sstema. E|empos:
s's%FlatDor# Devueve e sstema operatvo.
s's%st"out> st"in> st"err Estndar entrada, sada, error.
s's%argC_-:` Devueve sta de parmetros en a nea de comandos.
#at( ' c#at(: Mduo de operacones matemtcas.
Se nsta a nove en Python (s ests eyendo esto, es que es as), que
nvestgue sobre estos mduos y haga pruebas sobre su funconamento. Hay
muchos ms, pero para empezar a ndagar, estn os ms mportantes.
En a web Cats @(o Co"e hay una recopacn de os 50 mduos de
extensn ms mportantes:
http://www.catswhocode.com/bog/python-50-modues-for-a-needs
&-% Recursos "ocu#entales en Internet
Python para todos: Manua de Python en espao de Ra Gonzez Duque.
Packt Pubshng: Edtora tcnca de nformtca, que ncuye una seccn para
bros sobre Python.
Proyecto de Documentacn de Python en casteano en Sourceforge.
Comundad de Python en Argentna. Enorme cantdad de recursos
documentaes de Python en casteano.
Sto web ofca de Python. Todo tpo de nformacn sobre Python, adems de
a tma versn de este software.
Comundad Pone. Comundad Pone en Espaa.
FreeTechBooks: Sto web donde podemos encontrar bros sobre Python
gratutos y onne.
OuckReferences: Guas de referencas rpdas de varos engua|es de
programacn. Ideaes para descargar e mprmras como ayuda rpda.
Rchard Gruet's Python page: Guas rpdas para Python, en varas versones.
Paneta Python: Aqu nos encontramos con toda a reacn de ugares web, de
prmer nve, en reacn con Python.
Atop: Notcas sobre Python.
IronPython URLs: Sto web que agrega artcuos, notcas y nks sobre
IronPython, a versn de Python escrta en C# para acceder a framework .NET
de Mcrosoft.
Cheat-Sheets.org: Guas de referenca rpda. Muttud de engua|es de
programacn.
Python portabe: Sto web en donde se nos presenta a forma en a que se
puede confgurar Python en un USB para e|ecutaro drectamente.
Dve nto Python 3: Gua de Python 3. Importante ya que Python 3 no es
compatbe con as versones 2.
Bog de a hstora de Python: Bog de Gudo.
Mundo Python: Bog de Python, tutoraes y formacn.
86
Python Lnks: Con|unto de nks sobre programacn en Python.
SOLAchemy: Pgna ofca de ORM ms potente de Python.
ActveState Code Recpes: Recetas de probemas resuetos en Python.
Python entre todos n 1: Revsta sobre Python de PyAr.
Pgna persona de Stephen Ferg: Sto persona de seor Stephen Ferg.
Introduccn a Tknter: Manua de framework grfco Tknter
ndce de paquetes para Python: Lugar donde se pueden encontrar e stado
ofca de paquetes dsponbes para Python (mduos de extensn).
Tutoraes de programacn y e|empos de cdgo fuente: Gran varedad de
engua|es de programacn, ncudo Python. Ver: E|empos de cdgo fuente
Python organzados por temas.
Tutoraes de Python
Herramentas de desarroo para Python: Lsta de herramentas para desarroar
en Python
Recursos documentaes para Python en espao: Matera, webs y bogs de
recursos documentaes sobre Python, en espao.
Tutoraes para Python - Centro de aprendza|e: Sto web, en ngs, en donde
podemos encontrar recursos para aprender Python, ncuyendo nvees bsco y
avanzado.
Tutora Python: Tutora, en espao, de Python. Creado por PyAr.
E bog de |esse Noer: Bog de programacn Python.
E bog de Mke Drsco: Bog de un gur de Python.
Pgna de Spnecho: Cdgo fuente de apcacones Python. Para aprender.
Lnux Ptanos: Sto web en donde encontrar temtca GNU y Python.
E bro de D|ango: E bro onne de D|ango. En ngs.
DABO: Sto de software Dabo, para crear de manera rpda apcacones de
escrtoro en Python y wxPython.
CAMELOT: Sto de software Cameot, para crear de manera rpda
apcacones de escrtoro en Python, Ot y SOLAchemy.
Tutora de szers: Tutora, en ngs, de uso de szers (agortmo de
posconamento de wdgets) en wxPython.
La web de Andrea Gavanna: Sto de Andrea Gavanna, uno de os
desarroadores de wdgets para wxPython.
Web de Andy Buka: Software de patrones de dseo y UML%

88