Programador Jr. para Python.

Primera parte.
Diciembre 2013.
Jos Luis Chiquete Vadi!ieso

"cceso a c#digo
$ c#digo de este curso puede ser descargado en
un archi!o comprimido desde%
https://drive.google.com/file/d/0B-tF2kZLbAXPbB!"#Z$%&'t(#c/edit)*sp+sh,ri-g

&emario 'i(

)ntroducci#n a engua*e Python.

Paabras reser!adas y espacio de nombres.

$+presiones y decaraciones.

&ipos de datos b,sicos y operadores.

$ntrada y saida est,ndar.

-u*o de $*ecuci#n.

.esti#n de e+cepciones.

/rientaci#n a ob*etos.

&emario 'ii(

0,s tipos de datos.

-unciones.

0#duos y paquetes.

Caso de estudio.

$scritura y ectura de archi!os.

INTRODUCCIN

12u es Python3

Lengua*e de programaci#n de ato ni!e

muti4prop#sito5 interacti!o e interpretado.

Creado por .uido Van 6ossum.

$s de c#digo abierto.

$ nombre es en honor a 70onty Python

-ying Circus8.

$n9ocado en a egibiidad de c#digo.

"tamente popuar.

"tamente portabe.

:Pias incuidas:.

1Por qu Python3

Python es un engua*e muy popuar.

$s muy simpe.

$s muti4pata9orma.

;e adecua a di!ersos paradigmas de programaci#n

'programaci#n 9unciona5 programaci#n orientada a
ob*etos5 programaci#n procesa5 etc.(

$s atamente e+tensibe.

0uchas apicaciones de primer ni!e utii<an Python

'=ender5 .ooge "pp $ngine5 D*ango5 etc.(.

>ndice &)/=$ de popuaridad de os engua*es de
programaci#n '/ctubre 2013(.
http://$$$.tiobe.com/i-de..php/co-te-t/p,peri-fo/tpci/i-de..html

)mpementaciones de Python

Cpython. $s a impementaci#n origina

escrita en C.

Jython. $s a impantaci#n de Python en a

m,quina !irtua de Ja!a.

)ronPython. $s a impementaci#n de
Python sobre .?$&

Pypy. $s una impementaci#n de Python

optimi<ada mediante un compiador :Just in
&ime:.

;L@" permite e*ecutar Python y otros

engua*es de script en "ndroid.

Python 2 y Python 3

Python 3 es una re!isi#n competa de engua*e

de programaci#n a partir de sugerencias y
me*ores pr,cticas.

La sinta+is de Python 3 no es compatibe con

!ersiones pre!ias de Python.

Python 2 y Python 3 as ramas actuaes

'current(.

Durante e curso se utii<ar, Python 2.A por

de9ecto5 pero se indicar,n as di9erencias entre
Python 2 y Python 3 cuando sea e caso.

)nstaaci#n

Pr,cticamente todas as distribuciones de

.?BCLinu+ y D=;D tienen una !ersi#n de
Python 2 pre4instaada.

0ac/; E tiene Python instaado de origen.

$ instaador para FindoGs debe ser

descargado de http%CCGGG.python.org

)nter9a< interacti!a de Python

Linu+ y 0ac /; E% $s necesario abrir una

termina de te+to y e*ecutar e comando python

$n FindoGs se seecciona Python 'Command

Line(.

)nter9a< interacti!a de Python

)nter9a< interacti!a de Python

Para sair de a inter9a< interacti!a se in!oca a

exit()

Lengua*e

$s un con*unto de cadenas de sHmboos con os

que se pueden crear mensa*e.

Consta de%

.ram,tica. &rata sobre a construcci#n de

engua*e.

;em,ntica. &rata sobre e signi9icado de engua*e.

0or9oogHa y sinta+is

L, &r,m/tic, co-st, de:

%orfolog0,: c1mo se co-str*2e- l,s -ot,cio-es 3g4-ero5

tiempos5 decli-,cio-es6.

7i-t,.is: c1mo se debe- escribir l,s -ot,cio-es 3orde-5

estr*ct*r,6.

Los le-g*,8es ,rtifici,les tie-e- *-, morfolog0, r0gid, 2

simplific,d,.

Lengua*es de programaci#n
Lengua*es arti9iciaes utii<ados para
ingresar !aores y dar instrucciones a
un sistema.

Lengua*es de ba*o y ato ni!e

Lengua*es de ba*o ni!e% Con*unto de

instrucciones que son interpretados
directamente por e CPB de os sistemas de
c#mputo 'ensambador5 engua*e m,quina(.

Lengua*es de ato ni!e% Con*unto de

instrucciones egibes para e ser humano que
son traducidas a instrucciones de ba*o ni!e 'C5
C/=/L5 Ja!a5 Per5 Python5 etc.(.

Lengua*es interpretados y
compiados

$n e caso de os engua*es compiados5 e

c#digo 9uente debe ser traducido a c#digo de
m,quina para ser e*ecutados 'C5 /b*ecti!e4C(.

Los engua*es interpretados e*ecutan e c#digo

indirectamente 7a !ueo8 '=";)C5 Per5 Python5
etc.(.

$n e caso de engua*es como Ja!a5 e c#digo

9uente es con!ertido en bytecode para ser
e*ecutado por una m,quina !irtua.

Python es...

Bn engua*e de ato ni!e.

Bn engua*e interpretado.

2ue soporta mItipes paradigmas

de programaci#n.

CaracterHsticas 'i(

7i-t,.is m*2 cl,r, 2 legible.

F*erte c,p,cid,d de i-trospecci1-.

9rie-t,ci1- , ob8etos i-t*itiv,.

:.presi1- del c1digo procedime-t,l.

Alt,me-te mod*l,r5 soport, p,;*etes

8er/r;*icos.

:-foc,do e- el *so de e.cepcio-es p,r, el

m,-e8o de errores.

CaracterHsticas 'ii(

(ipos de d,tos di-/micos de m*2 ,lto -ivel.

:.te-s, bibliotec, est/-d,r 37(L6 2 m1d*los de

terceros p,r, pr/ctic,me-te tod,s l,s t,re,s.

:.te-sio-es 2 m1d*los f/cilme-te escritos e- <5

< = = 3o >,v, p,r, >2tho-5 o. ?:( p,r,
@ro-P2tho-6.

@-tegr,ble de-tro de l,s ,plic,cio-es como *-,

i-terf,A de scripti-g.

$ Jen de Python

$ Jen de Python 'i(

=eo es me*or que 9eo.

$+pHcito es me*or que impHcito.

;impe es me*or que compe*o.

Compe*o es me*or que compicado.

Pano es me*or que anidado.

$scaso es me*or que denso.

La egibiidad cuenta.

Los casos especiaes no son tan especiaes

como para romper as regas.

$ Jen de Python 'ii(

"unque o pr,ctico e gana a a pure<a.

Los errores no deben pasar en siencio.

" menos que sean sienciados e+pHcitamente.

$n caso de ambigKedad5 resiste a tentaci#n a

adi!inar.

DeberHa haber una 44y pre9eribemente s#o

una44 manera ob!ia de hacer as cosas.

"unque esa manera no pare<ca ser tan ob!ia a

menos que seas Loands.

$ Jen de Python 'iii(

"hora es me*or que nunca.

"unque nunca es normamente me*or que

ahora :mismo:.

;i a impementaci#n es di9Hci de e+picar5 es

una maa idea.

;i a impementaci#n es 9,ci de e+picar5 podrHa

ser una buena idea.

Los $spacios de ?ombres son una magnH9ica

idea 44 MLagamos m,s de esosN

Las P$Ps de Python

"cr#nimo de :Python $nhancement Proposa:.

)niciati!as y propuestas de a comunidad para

me*orar e 9uncionamiento y uso de Python.

http%CCGGG.python.orgCde!CpepsC

La P$P4O es particuarmente interesante5 ya

que se re9iere a estio a utii<ar a codear en
Python.

$ntornos )ntegrados de Desarroo
')D$(

$s un con*unto de herramientas e inter9aces

que 9aciitan a programaci#n.

Componentes%

$ditor.

Depurador.

Compiador 'no es necesario para Python(.

)nter9a< de e*ecuci#n.

.estor de componentes.

Contro de !ersiones.

$*empos% $cipse5 Visua ;tudio5 ?et=eans

)D$ para Python

)DL$.

de!py para $cipse.

;P$.

=oa Constructor.

Vim.

$macs.

.edit.

Fing )D$.

Pomodo.

?in*a )D$.

6ecursos a utii<ar

Para e presente curso utii<aremos%

?in*a )D$ 'http%CCnin*a4ide.orgC(.

Bn editor de te+tos '!im5 gedit5 notepad(.

La inter9a< interacti!a de Python.

La Hnea de comando 'sHmboo de sistema o

una termina(.

?in*a4)D$

CaracterHsticas de ?in*a4)D$

$s de c#digo abierto.

Ligero y 9,ci de usar.

Corre en Linu+5 FindoGs y 0ac/; E 'hay que instaar

pre!iamente E2uart<
http%CC+quart<.macos9orge.orgCandingC (.

Capa< de generar proyectos distribuidos en di!ersos

archi!os.

Cuenta con corrector sint,ctico y de estio 'P$P4O( y

sugerencias de optimi<aci#n de c#digo para Python 3.

Con9iguraci#n de ?in*a4)D$

$n FindoGs es necesario indicare a ?in*a4)D$

a ocai<aci#n de archi!o e*ecutabe de
Python.

-unciones y comandos de
?in*a4)D$

CtrQ?% Crea un nue!o archi!o.

CtrQ/% "brir un archi!o.

CtrQ;% .uardar e archi!o actua.

CtrQ-R% $*ecuta e archi!o actua.

;hi9tQCtrQ-R% Detiene a e*ecuci#n de

intrprete.

Ventanas de she interacti!o

Ventana de c#digo

Ventana de e*ecuci#n

Loa 0undo

$n a inter9a< interacti!a.

Como script.

$*ecutabe.
print "Hola Mundo"

Loa 0undo en a )nter9a<
)nteracti!a

Bn script de Python

Bn script es un archi!o de te+to con c#digo de

Python5 e cua normamente tiene a
e+tensi#n .py

"gunos editores de te+to cuentan con

reconocimiento de a sinta+is de Python y
utii<an coores para identi9icar sus
componentes.

$ script holamundo.py

$*ecutando un script

FindoGs%

Bna !e< instaado Python5 FindoGs reacionar, os archi!os

con e+tensi#n .py a intrprete de Python y os e*ecutara a
hacer dobe cicS sobre eos en e gestor de archi!os.

D?)E5

$s necesario aTadir a ruta a intrprete de Python insertando

a Hnea #! /usr/bin/python y asignare os permisos de
e*ecuci#n. FindoGs pasa por ato esta Hnea.

;i no se cuenta con os permisos de e*ecuci#n5 e script se

puede e*ecutar in!ocando a intrprete de Python% python
<nombre del archivo>

Permisos de e*ecuci#n en D?)E

$*ecutando holamundo.py desde
termina

$*ecutando holamundo.py desde
?in*a4)D$

" oprimir Ctrl+F en ?in*a4)D$ e script se e*ecuta de

esta manera%

$*ecutando holamundo.py desde
un entorno gr,9ico

Bna !e< que se e dan os permisos de e*ecuci#n

en D?)E5 tambin es posibe e*ecutar e script
dando dobe cicS en e gestor de archi!os.

$ script se e*ecutar, en una termina de te+to5

pero una !e< terminado e script5 a termina se
cerrar, inmediatamente.

Para que a termina no se cierre5 habr, que

indicar a script que espere hasta que a teca de
retorno de carro sea presionada.

;cript holamundo.py con ra!"input()

Codi9icaci#n en Python 2

Python 2 utii<a por de9ecto una codi9icaci#n

";C))5 por o que despegar caracteres
especiaes como a :T: y os acentos generan un
mensa*e de error.

Python 3 utii<a a codi9icaci#n B&-4O por

de9ecto.

Para de9inir a codi9icaci#n se debe incuir a

Hnea% # #$# codin%& <codi'icaci(n> #$#

$n e caso de te+tos en casteano se

recomienda a codi9icaci#n ut'#).

$ script holaninos.py

PALABRAS RESERVADAS Y ESPACIO DE
NOMBRES

Paabras reser!adas de Python

Las paabras reser!adas 'SeyGords(

corresponden a os nombres de as
decaraciones que e intrprete de Python
incuye por de9ecto.

$ istado de paabras reser!adas puede ser

consutado ingresando help(*+ey!ords*) desde
a inter9a< interacti!a.

?o se deben utii<ar dichas paabras para

asignar nombres a otros ob*etos.

Paabras reser!adas de Python 2.A

Paabras reser!adas de Python 3.3

$ espacio de nombres

Python es un engua*e de muy ato ni!e en e que

todos sus eementos son ob*etos5 incuyendo os tipos
de datos b,sicos.

$ espacio de nombres 'name space( de intrprete de

Python contiene as re9erencias entre os ob*etos
e+istentes en a memoria '!aores5 9unciones5 cases5
etc.( y os nombres a os que se encuentran igados.

;i un ob*eto no est, igado a menos a un nombre5

dicho ob*eto es destruido autom,ticamente.

$ intrprete de Python tiene un espacio de nombres

principa5 pero cada 9unci#n5 m#duo y ob*eto tiene su
propio espacio de nombres.

$ operador de asignaci#n ,

Para crear un ob*eto de cuaquier tipo s#o es

necesario igar a ste con un identi9icador
mediante e operador de asignaci#n :,:.

Desde un en9oque de programaci#n

procedimenta5 este tipo de asignaci#n se
comporta de 9orma muy simiar a a creaci#n
!ariabes.

Bn identi9icador siempre debe ser de9inido

antes de ser utii<ado.

$ operador de asignaci#n ,

La 9unci#n dir()

Cuando se e*ecuta dir() sin ningIn

par,metro5 ste despiega os nombres
contenidos en e espacio de nombres
principa.

;inta+is para nombres

Los nombres deben empe<ar con un gui#n ba*o

:U: o una etra de a9abeto.

Despus de primer car,cter5 se pueden utii<ar

etras5 nImeros yCo guiones ba*os.

?o se permiten caracteres especiaes como

:T:5 :V:5 :4:5 etc.

;e pueden utii<ar mayIscuas5 pero Python es

sensibe a mayIscuas.

;inta+is para nombres

La 9unci#n id()

Cada ob*eto cuenta con un identi9icador interno

que corresponde a a posici#n en a que se
encuentra amacenado en a memoria.

La 9unci#n id() permite conocer este

identi9icador interno por medio de nombre.

La correcta identi9icaci#n de os ob*etos es

importante5 ya que un mismo ob*eto puede
tener m,s de un nombre.

La 9unci#n id()

La decaraci#n del
$ comando del 9unciona de a siguiente manera%

Desiga a identi9icador de un ob*eto en e espacio de

nombres.

Bna !e< que e nombre de identi9icador es desigado5

ya no es posibe in!ocaro por ese nombre.

$n caso de que e ob*eto no est igado a otros

identi9icadores en e espacio de nombres5 e intrprete
de Python podrHa destruir a ob*eto por medio de
:recoector de basura:.

$ modo en e que un ob*eto se comporta a ser

descartado !arHa dependiendo de tipo de ob*eto. $ste
tema se discutir, m,s adeante.

La decaraci#n del

EXPRESIONES Y DECLARACIONES

$+presiones
Bna e+presi#n es una combinaci#n de !aores5
operadores y !ariabes.

1 Q 1

:a<u: Q : ro*o:

print :Loa:

Decaraciones ';tatements(

$s una unidad de c#digo que e intrprete de

Python puede e*ecutar.

0Itipes e+presiones en una Hnea

$ intrprete de Python permite e*ecutar

mItipes e+presiones en una soa Hnea
separ,ndoas por punto y comas :-:

?o se recomienda usar este recurso5 ya que se

corre e riesgo de o9uscar e c#digo
innecesariamente.

$+presiones en entorno interacti!o

La inter9a< interacti!a e!aIa as e+presiones

tan pronto como son ingresadas y en su caso5
despiega e resutado.

$+presiones con e intrprete

;i esas mismas e+presiones as guardamos en

un archi!o amado expresiones.py y o
e*ecutamos ste eer, e archi!o y reai<ar, una
e!auaci#n Hnea por Hnea en orden
descendente5 pero no despegar, e resutado
de cada e+presi#n.

$ script expresiones.py

TIPOS DE DATOS BSICOS Y
OPERADORES

&ipos de datos b,sicos

?Imeros

$nteros 'int5 lon%(

Decimaes '2@5 R0(

Le+adecimaes '0+1O5 0+3c(

/ctaes '0305 0A@(

=inarios'0b110015 0b111100(

De punto 9otante ''loat(

Compe*os 'complex(

3 Q @W*5 1*

Cadenas de te+to 'str(

$ncerradas entre comias :: o ap#stro9es XX

XLoa 0undoX

:Vamos a 0cDonadXs:

Vaores booeanos'bool(

&rueC-ase

&ipos en Python

&ipos din,micos% ?o es necesario de9inir

pre!iamente e tipo de una !ariabe.

-uertemente tipado% ?o se pueden reai<ar

operaciones con tipos distintos.

-unciones reati!as a tipos de datos

type() regresa e tipo de dato de una !ariabe.

str() trans9orma en una cadena de caracteres e

contenido de una !ariabe.

int() trans9orma en un tipo entero e contenido de una

!ariabe.

'loat() trans9orma en un nImero de punto 9otante e

contenido de una !ariabe.

complex() trans9orma en un nImero compe*o e

contenido de una !ariabe.

bool() trans9orma en un !aor booeano e contenido

de una !ariabe. Cuaquier !aor distinto de . es /rue

$*empo de uso de tipos

$*empo de uso de tipos

/peradores aritmticos
:- P2tho- 2 l,s divisio-es e-tre e-teros d,- por
res*lt,do v,lores e-teros5 mie-tr,s ;*e e- P2tho- B
l,s divisio-es e-tre e-teros d,- como res*lt,do
v,lores de p*-to flot,-te.
Operador Descripcin Ejemplo
Q ;uma + Y 1 Q 2 V + es 3
4 6esta + Y 2 4 1 V + es 1
4 ?egati!o + Y 42 V + es 42
D 0utipicaci#n + Y 1 D 2 V + es 2
DD $+ponente + Y 2 DD 3 V + es O
C Di!isi#n + Y 1.0 C 2 V + es 0.W D
CC Di!isi#n entera + Y 1.0 CC 2 V+ es 0.0
Z 0#duo + Y 1.0 Z 2 V+ es 1

/peradores de asignaci#n
Operador Descripcin Ejemplo
Y "signaci#n simpe + Y y
QY ;uma + QY y equi!ae a + Y + Q y
4Y 6esta + 4Y y equi!ae a + Y + 4 y
DY 0utipicaci#n + DY y equi!ae a + Y + D y
DDY $+ponente + DDY y equi!ae a + Y + DD y
CY Di!isi#n + CY y equi!ae a + Y + C y
CCY Di!isi#n entera + CCY y equi!ae a + Y + CC y
ZY 0#duo + ZY y equi!ae a + Y + Z y

6egas de precedencia

Los operadores se apegan a a siguiente rega de

precedencia siguiendo una secuencia de i<quierda
a derecha%

Parntesis

$+ponente

0utipicaci#n

Di!isi#n

;uma

;ustracci#n

/peradores de bit
Operador Descripcin Ejemplo
a = 23 = 0b10111
b = 1 = 0b1110
[ "?D a [ b es 0b00110 Y R
\ /6 a \ b es 0b11111 Y 31
] E/6 a ] b es 0b11001 Y 2W
^^ 0o!er + bits a a derecha a __ 1 es 0b101110 Y @R
__ 0o!er + bits a a i<quierda a ^^ 1 es 0b1011 Y 11

/peradores de cadena
Operador Descripcin Ejemplo
Q Concatenaci#n a Y 8Loa8 b Y 80undo8
c Y a Q b V c es 7Loa0undo8
D 6epetici#n a Y 8Loa8
b Y c D 3 V c es 7LoaLoaLoa8

/peradores de reaci#n
Operador E!al"a
YY a YY b V 1a igua a b3
NY a NY b V 1a distinta de b3
^ a ^ b V1a mayor que b3
_ a _ b V1a menor que b3
^Y a ^Y b V1a mayor o igua que b3
_Y a _Y b V1a menor o igua que b3

/peradores =ooeanos
Operador E!al"a
or a or b V 1;e cumpen a o b3
and a and b V 1;e cumpe a y b3
not not a V 1no es "3

/perador de identidad
Operador E!al"a
is a is b Vequi!ae a id'a( YY id'b(
is not a is not b Vequi!ae a id'a( NY id'b(

$ operador is e!aIa si un identi9icador se

re9iere e+actamente a mismo ob*eto.

ENTR#D# $ %#&ID# E%T'ND#R

print

print despiega en una termina de te+to a

in9ormaci#n que se e indica.

$n Python 2 se e*ecuta como una paabra reser!ada

: print :5 mientras que en Python 3 se utii<a como
una 9unci#n : print () :

Cuando print incuye una e+presi#n5 sta es

e!auada antes de ser despegada.

print puede despegar !arios !aores separados por

comas.

$n Python 25 si se de*a una coma a 9ina5 e siguiente

despiegue de print se har, en a misma Hnea.

print en Python 2

print() en Python 3

Python 2.A es una !ersi#n de transici#n5

por o que acepta ambas sinta+is.

print y print() en Python 2.A

Para os acances de este curso se usar, a

sinta+is de Python 2.

Python 2.A es una !ersi#n :de transici#n:5

por o que acepta ambas sinta+is.

Despiegue con 9ormato

Para despegar datos en un 9ormato especH9ico

se utii<a e car,cter sobre4escritura 0 seguido
de uno de os siguientes caracteres.

Despus de a cadena se aTade otro 0 y os

!aores a despegar entre parntesis separados
por comas. ;i s#o es un !aor5 no es necesario
e parntesis.
s cadena de (e)(o
d en(ero
o oc(al
) *e)adecima
+ p,n(o +lo(an(e
e -,n(o +lo(an(e en +orma(o e)ponencial

Despiegue con 9ormato

Cuando se utii<a 0s5 equi!ae a apicar a

9unci#n str() a !aor a despegar.

Para despegar e signo de porcenta*e :01 se

utii<a 00.

Despiegue con 9ormato

Para despegar e signo de porcenta*e :01 se

utii<a 00.

Despiegue de ci9ras signi9icati!as

Para despegar un nImero especH9ico de ci9ras

signi9icati!as de un !aor de punto 9otante5 se
aTade un punto :.: y e nImero de ci9ras a
despegarse despus de signo 0 y antes de
car,cter ' o e.

Caracteres de escape
%ec,encia #ccin
.n retorno
.( tabuador
.)EE car,cter ";C)) he+adecima
./ ap#stro9e
.0 comias
.. diagona in!ertida

La 9unci#n eval()

eval() es una 9unci#n de Python que reai<a a

e!auaci#n de una cadena de te+to como si
9uera una e+presi#n.

Cuando una cadena de te+to no contenga una

e+presi#n !,ida5 eval() generar, un mensa*e
de error.
!al "#$adna d t%to&'

La 9unci#n eval()

La 9unci#n ra!"input()

La 9unci#n por de9ecto para eer a entrada est,ndar es

ra!"input()

ra!"input() ee a entrada est,ndar hasta que se introduce

un retorno de carro _$?&$6^.

$ contenido capturado es de!ueto a intrprete como una

cadena de caracteres.

La cadena de caracteres resutante puede ser amacenada

en memoria mediante a asignaci#n de un nombre.

La 9unci#n ra!"input()

La 9unci#n ra!"input(( permite despegar una

cadena de te+to antes de pedir e ingreso de
caracteres de a siguiente 9orma%
ra!"input(_cadena^)

La 9unci#n input()

input() 9unciona de 9orma simiar a ra!"input()5

pero a di9erencia de sta5 input() e!aIa e
contenido de o que se ingresa de 9orma simiar a
e*ecutar% eval(ra!"input()).

De ese modo5 input() puede regresar !aores de

di!ersos tipos5 en !e< de s#o cadenas de te+to.

La des!enta*a de input() es que os contenidos

que se ingresen deben de ser sint,cticamente
correctos o se generaran errores.

ra!"input() !s input()

La 9unci#n input() en Python 3

Debido a os probemas que e uso de input()

a estio de Python 2 podrHa ocasionar5 a
9unci#n input() en Python 3 se comporta como
ra!"input() a estio de Python 2.

La 9unci#n ra!"input() 9ue descontinuada en

Python 3.

(L)*O DE E*EC)CI+N

)ndentaci#n

$n Python a indentaci#n impica una e*ecuci#n

anidada.

Por con!enci#n se utii<an cuatro espacios para

indentar.

?unca se usan tabuadores en a indentaci#n.

Para mayor re9erencia ir a P$PO.

Comentarios

Los comentarios son porciones de te+to que no

son incuidos en e 9u*o de e*ecuci#n de un script
y sir!en para documentar a c#digo.

Cuaquier te+to despus de car,cter :#: y hasta

e retorno de carro es considerado como un
comentario.

"gunas especi9icaciones de e*ecuci#n de Python

tambin se coocan como si 9ueran comentarios.

Los comentarios de !arias Hneas deben estar

encerrados entre tripes comias o ap#stro9es y
son conocidos como docstrin%s.

$ script hola"comentado.py

Documentaci#n de c#digo

Los docstrings que se incuyen a principio de a

un m#duo o de9inici#n de una 9unci#n o case
son reconocidos por Python para generaci#n
autom,tica de a documentaci#n de c#digo
'P$P 2WA(.

Condicionaes

Cuando a e*ecuci#n de cierto boque de c#digo

depende de una condici#n #gica en particuar
que sea de car,cter booeanos 'Tr,eC1alse(5
podemos utii<ar os !arios tipos de estructuras
que i9 permite utii<ar.

" continuaci#n se presentan agunos

diagramas y script que e*empi9ican e uso de
as condicionaes en Python.

Condiciona i'

$ script i'"simple.py

Condiciona i'... else

$ script i'"else.py

Condiciona i'... eli'... else

$ script i'"eli'"else.py

6ecursi!idad con !hile

Python cuenta con a decaraci#n

!hile para e*ecutar un boque de
c#digo recursi!amente mientras
se cumpa una condici#n
determinada.

Cuando dicha condici#n no se

de5 e 9u*o de e*ecuci#n
continuar, sin e*ecutar e boque
dentro de !hile.

$ script !hile.py

)nterrupci#n de 9u*o #gico

$n ciertas circunstancias es necesario interrumpir e 9u*o

#gico de un programa. Python cuenta con os siguientes
recursos para hacero.

La decaraci#n brea+

La decaraci#n continue

La 9unci#n exit()
Dichos recursos se pueden utii<ar en cuaquier boque de
c#digo. Para iustrar su apicaci#n se utii<ar,n con !hile.

&erminaci#n de buce actua con
continue

$s posibe terminar un subproceso de manera

prematura con continue.

&erminaci#n de buce actua con
continue

$s posibe terminar un subproceso de manera

prematura con continue.

$ script !hile"continue.py

6uptura de buce con brea+

$s posibe terminar e buce con brea+.

$ script !hile"brea+.py

&erminaci#n de a e*ecuci#n con exit()

$ intrprete termina a e*ecuci#n de scritp a

ser in!ocada a 9unci#n exit()

$ script !hile"exit.py

)teraciones

Bna de as grandes 9ortae<as de Python es su

capacidad de generar muy di!ersos modos de
reai<ar iteraciones de 9orma din,mica a partir
de di!ersos tipos de datos.
'or _iterador^ in _ob*eto iterabe^&

La 9orma m,s conocida de iterar es por medio

de uso de a 9unci#n ran%e()

La 9unci#n ran%e()

Para de9inir rangos numricos se usa a 9unci#n

ran%e().

ran%e (n2 m2 s) cumpe% rango ^Y n and rango

_ m en incrementos de s

ran%e (n2 m) cumpe% rango ^Y n and rango _

m en incrementos de 1

ran%e (m) cumpe% rango ^Y 0 and rango _ m

en incrementos de 1

$ script 'or"simple.py

ran%e() en Python 3

La 9unci#n ran%e() en Python 2 crea una ista

de nImeros5 o cua puede consumir
demasiados recursos cuando se trata de una
iteraci#n con nImeros grandes.

La 9unci#n xran%e() en ugar de crear una ista5

genera un :iterador: a a !e<5 o que hace m,s
e9iciente e uso de recursos.

$n Python 3 a 9unci#n ran%e() 9unciona como

xran%e() a estio de Python 2.

,ESTI+N DE EXCEPCIONES

.esti#n de e+cepciones

Debido a o din,mico que puede ser Python5 es muy

comIn que e intrprete se tope con mItipes 9uentes
de error.

Bna de as caracterHsticas m,s poderosas de engua*e

es a gesti#n de e+cepciones.

Con Python no s#o es posibe identi9icar y rastrear os

errores5 sino tomar acciones correcti!as y pre!enti!as.

$rrores sint,cticos

Los errores sint,cticos son os m,s comunes

cuando se escribe c#digo.

Bn error sint,ctico ocurre cuando e intrprete

encuentra una e+presi#n que no est, bien
9ormada 'rompe as regas de sinta+is(.

$+cepciones

Las e+cepciones son errores #gicos que

detienen a e*ecuci#n de programa aIn cuando
a sinta+is de c#digo sea correcta.

$ script excepcion"probable.py

$ script excepcion"probable.py e*empi9ica

c#digo susceptibe a que ocurran errores de
di!ersos tipos.

$ c#digo tiene una sinta+is correcta.

Desencadenando una e+cepci#n

" e*ecutar error"probable.py5 se pro!oca una e+cepci#n a ingresar

una cadena de te+to sin estar encerrada entre parntesis o ap#stro9es.

Debido a que se utii<a a 9unci#n input()5 e intrprete e!auar, como

una e+presi#n aqueo que se ingrese.

$ error ocurre debido a que e intrprete identi9ica a a cadena de

caracteres como un nombre e cua no est, de9inido en e espacio de
nombres.

$ intrprete detiene a e*ecuci#n y despiega un mensa*e.

"natomHa de un mensa*e de error

Bn mensa*e de error de Python se di!ide en 2

componentes%

La ruta de rastreo de error.

La in9ormaci#n sobre e error.

6astreo de error

Debido a que Python es atamente moduar5 un

error puede desencadenarse en cierto punto5
pero ocurrir en otro.

Cuando ocurre un error5 Python despiega a

ruta. $sta ruta puede impicar a !arios m#duos.

La ruta !a en orden descendente desde e

punto5 pasando por !arios puntos intermedios
hasta e punto en e que se desencaden# e
error.

6uta de error

$n e caso que se e*empi9ica5 Python indica que

e error se desencaden# en a Hnea A de
excepcion"probable.py y despiega a Hnea en
cuesti#n.

$ error ocurri# cuando e intrprete intent#

e*ecutar a e+presi#n5 por o que en este caso no
hay mayor in9ormaci#n de a ruta5 pero se de*a
e!idencia de error.

)n9ormaci#n de error

La in9ormaci#n de error se da en una soa

Hnea.

)ndica e tipo de error que ocurri#.

Despiega un mensa*e que e+pica o que

ocurri#.

&ipos de e+cepciones

Python es capa< de identi9icar muy di!ersos

tipos de error a os que corresponden sendas
e+cepciones capaces de tratar con cada uno
de eos.

;e pueden consutar os di!ersos tipos de

e+cepciones en a siguiente iga%
http%CCdocs.python.orgC2CibraryCe+ceptions.htm

Posibes tipos de e+cepciones en e
script excepcion"probable.py

?ame$rror

Vaue$rror

Posibes tipos de e+cepciones en e
script excepcion"probable.py

&ype$rror

;ynta+$rror

6ecursos de captura de e+cepciones

Python cuenta con una serie de recursos que

permiten a captura y gesti#n de e+cepciones5 os
cuaes se e*ecutan dependiendo de ciertas
condiciones.

;i a e+cepci#n no es capturada5 sta correr, hasta

sus Itimas consecuencias.

Los recursos de gesti#n y captura de e+cepciones

son%

try

except

else

+inall2

Deimitaci#n de c#digo con try

Cuando se identi9ica una secci#n de c#digo

susceptibe de errores5 sta puede ser deimitada
con a e+presi#n try.

Cuaquier e+cepci#n que ocurra dentro de esta

secci#n de c#digo podr, ser capturada y gestionada.

$n e caso de script excepcion"probable.py se

puede obser!ar por os mensa*es de error que e
segmento comprendido entre as Hneas A y ` es e
que se debe deimitar.

.esti#n de e+cepciones con except
---
---
tr./
#$0di1o 2u$pti3l d rror2&
%$pt/
#$0di1o&
---
---

La e+presi#n except es a encargada de

gestionar as e+cepciones que se capturan.

;i se utii<a except sin mayores par,metros5

sta e*ecutar, e c#digo que contiene para
todas as e+cepciones que ocurran.

$ script excepcion"basica.py

$ script excepcion"basica.py

$ script excepcion"basica.py representa a

9orma m,s sencia de capturar una e+cepci#n.

$ c#digo susceptibe de error 9ue deimitado

con try.

Cuando ocurre a e+cepci#n5 except a captura5

pero no hace nada en absouto. ;impemente
permite que e programa continIe.

La e+presi#n pass

La e+presi#n pass no reai<a ningIn tipo de acci#n.

;in embargo5 permite que un boque de c#digo no
quede en banco y se genere un error.

$n e script excepcion"basica.py5 pass es utii<ado

para que a e+cepci#n sea atrapada5 pero no se
reai<a ninguna acci#n.

La e+presi#n pass puede ser utii<ada en 9unciones y

mtodos como se !er, m,s adeante.

$ script excepcion"simple.py

Bso de :banderas:

$ script excepcion"simple.py e!anta una

:bandera: cambiando e !aor de ob*eto
ocurre"error 'de tipo booeano( en caso de
que ocurra una e+cepci#n.

$ uso de :banderas: es muy comIn y permite

cambiar e comportamiento en a e*ecuci#n de
un programa en caso de que ocurran ciertas
condiciones especH9icas.

.esti#n de e+cepciones por tipo de
error.
La e+presi#n except puede ser utii<ada de 9orma
ta que e*ecute c#digo dependiendo de tipo de
error que ocurra de una 9orma muy simiar a eli'.
---
---
tr./
#$0di1o 2u$pti3l d rror2&
%$pt #ErrorTipo4&/
#$0di1o4&
%$pt# ErrorTipo5&/
#$0di1o5&
%$pt "#ErrorTipo6&7 #ErrorTipo8&'/
#$0di1o6&
%$pt/
#$0di1o8&
---
---

$ script
excepciones"identi'icadas.py

$ script
excepciones"identi'icadas.py

Captura de descripciones de error

except tiene a capacidad de capturar a

descripci#n de error como un ob*eto de tipo str.

$sta descripci#n puede ser asignada a un

nombre para ser despegada.

Cuando se usa except sin par,metros5 no es

posibe recuperar e mensa*e de descripci#n.
---
---
tr./
#$0di1o 2u$pti3l d rror2&
%$pt #TipodError& a2 #no93r&/
#$0di1o&
---
---

La e+presi#n as

$+isten agunos casos en os que

sint,cticamente no es posibe utii<ar e
operador de asignaci#n , para igar un nombre
a un ob*eto en e espacio de nombres.

La e+presi#n as actIa de 9orma idntica a

operador ,5 pero con una estructura sint,ctica
distinta como es e caso de except para
capturar a descripci#n de error.

$ script excepciones"descritas.py

$ script excepciones"descritas.py

Bso de else

;e utii<a else en e caso de que dentro de

segmento de c#digo deimitado por try no
ocurra ninguna e+cepci#n.
---
---
tr./
#$0di1o 2u$pti3l d rror2&
%$pt/
#$0di1o4&
---
---
l2/
#$0di1o5&
---
---

Bso de 'inally

La e+presi#n 'inally e*ecuta e c#digo dentro de

sta ya sea que ocurra a e+cepci#n o no.

$ste comportamiento es muy Iti sobre todo

cuando se hacen operaciones de escritura
archi!os5 bases de datos o cone+iones de red
que pueden corromperse si no se cierran
adecuadamente independientemente de si
ocurre una e+cepci#n o no.

Bso de 'inally
--
---
tr./
#$0di1o 2u$pti3l d rror2&
%$pt/
#$0di1o4&
---
---
l2/
#$0di1o5&
---
---
:inall./
#$0di1o6&
---
---


$ script excepciones"atrapadas.py

$ script excepciones"atrapadas.py

Le!antar e+cepciones con raise

$n ciertas ocasiones es posibe identi9icar una

situaci#n en a que cierta condici#n pro!ocar,
un error. $n ese caso se puede e!antar una
e+cepci#n antes de que e error ocurra y emitir
un mensa*e correspondiente.

La e+presi#n raise puede e!antar esa

e+cepci#n.
rai2 #TipodError&"#9n2a;&'

$ script raise.py

$ script raise.py

$!auando resutados con assert

La e+presi#n assert es Iti cuando se conoce

e resutado esperado de un programa.

La e+presi#n assert e!anta una e+cepci#n de

tipo 3ssertion4rror si una condici#n no es
!erdadera.
a22rt"#$ondi$i0n&'

$ script assert.py

ORIENTACI+N A OB*ETOS

Python est, orientado a ob*etos

&odos os eementos de Python son ob*etos5

incuyendo os que podrHan ser datos de tipos
b,sicos como os nImeros 'int5 'loat5
complex(5 as cadenas de caracteres 'str( y os
booeanos 'bool(.

Los tipos b,sicos est,n diseTados para

comportarse de ta 9orma que un programador
no requiera de utii<ar e paradigma de
programaci#n de ob*etos en o absouto.

Cases y tipos

$n Python os tipos de datos en reaidad son

cases.

Bna case es e :prototipo: que ostenta as

caracterHsticas iniciaes y de9ine e
comportamiento que adquirir,n os ob*etos que
se :instanciar,n: de sta.

Cuando e intrprete de Python e!aIa una

decaraci#n5 ste in9iere e tipo de dato de que
se trata a partir de su sinta+is e instancia de
esta case un ob*eto en e que amacena e dato
obtenido.

La 9unci#n isinstance()

Para !aidar si un ob*eto es una instancia de

una case5 se utii<a a 9unci#n isinstance()5 a
cua de!o!erHa un !aor /rue en caso de que
asH 9uera.

$*empo de creaci#n de ob*etos.

$ intrprete crea a un ob*eto de case

int que contiene un !aor de 5 y un
ob*eto de case str que contiene a
te+to :6ola :.

La case str de9ine un comportamiento

especH9ico cuando se encuentra con e
operador $ y un ob*eto de tipo int.

$ resutado es un nue!o ob*eto de tipo

str que contiene a te+to :6ola 6ola
6ola :.

$ ob*eto nue!o es despegado.

&odos os ob*etos son desechados tan

pronto como son utii<ados.

Persistencia de os ob*etos

$n este caso5 ocurre ago muy simiar a o

anterior5 pero e ob*eto no es destruido
inmediatamente.

Bn ob*eto puede ser igado a un nombre en e

espacio de nombres mediante e operador de
asignaci#n , o a e+presi#n as.

$ ob*eto perdurar, hasta que sea eiminada

toda re9erencia a ste en e espacio de
nombres5 o hasta que e intrprete se cierre.

Comportamiento y contenido en os
ob*etos.

Los ob*etos adquieren os comportamientos

propios de a case de a que 9ueron instanciados.
" stos se es denominan :mtodos:.

Los ob*etos pueden amacenar datos en incuso a

otros ob*etos. " stos se es aman :atributos:.

&anto mtodos como atributos tienen un nombre

por e cua pueden ser accedidos e in!ocados con
a siguiente sinta+is que utii<a a punto '.( como
:operador de atributo:.
#o3;to&-#atri3uto&
#o3;to&-#9<todo&"#par=9tro2&'

)n!ocando a un mtodo

$n os ob*etos de tipo str5 e+iste e mtodo

denominado __mul""()5 que es e encargado
de comportamiento de este tipo de ob*etos
ante e operador $

)ntrospecci#n

)ntrospecci#n es a capacidad que tiene Python

de obtener in9ormaci#n y documentaci#n de un
ob*eto a partir de c#digo y os comentarios de
dicho c#digo 'mediante as docstrings(.

Las 9unciones dir() y help() son herramientas

que ayudan a usuario a encontrar in9ormaci#n
Iti en e entorno interacti!o.

La 9unci#n dir()

La 9unci#n dir() e*ecuta un istado de os

mtodos y atributos que contiene un ob*eto.

La 9unci#n help()

La 9unci#n help() despiega a in9ormaci#n

sobre a estructura y documentaci#n de un
ob*eto en e entorno interacti!o.

help() tambin despiega agunos otros datos a

partir de ciertas paabras ca!e en 9ormato de
cadena de te+to como 1+ey!ords15
1modules1 o 1topics15 etc.

;i se usa help() sobre un ob*eto de tipo str5 es

posibe que se obtenga un error si su contenido
no coincide con aguna paabra ca!e como as
mencionadas.

$*empo% help(str)

?a!egaci#n dentro de help()

Debido a que e contenido despegado por

help() generamente se e+tiende m,s a, de a
capacidad de a pantaa5 a e*ecutar a 9unci#n5
e entorno interacti!o cambia a un modo de
ectura en e cua uno se puede trasadar a o
argo de te+to de ayuda con as tecas de
<arriba>5 <aba7o>5 <avp8%>5 <rep8%>5
<inicio> y <'in>.

Para sair de modo de ectura s#o es

necesario ingresar a teca 9.

3'% TI-O% DE D#TO%

&ipos predeterminados de Python

Debido a que os tipos de datos en Python son

equiparabes a as cases5 e+tenderos no s#o
posibe5 sino muy comIn.

Python cuenta con un con*unto de tipos

predeterminados que e intrprete adquiere por
de9ecto.
NOT#4 Con9orme a os acances de este curso5
se enumerar,n a mayorHa de os tipos5 pero
agunos de stos no ser,n estudiados.

Casi9icaci#n de tipos.

&ipo booeanos '!istos pre!iamente(.

&ipos numricos '!istos pre!iamente(.

&ipos secuenciaes.

&ipos de coecci#n.

&ipos mapeados.

&ipos de archi!o.

&ipos de datos secuenciaes.

Listas list

&upas tuple

Cadenas de te+to str

"rchi!os 'ile

&e+to unicode unicode 'no se cubrir,(

"rrego de bytes bytearray 'no se cubrir,(

xran%e 'no se cubrir,(

bu''er 'no se cubrir,(

&ipos de datos de con*untos.

Con*untos set

'ro:enset

Listas
De9inidas entre corchetes 7;7 7<8

;eparadas por comas.

Los eementos de una ista tambin pueden ser una

ista o cuaquier ob*eto.

$*empos%

;=a:ul>2 5.?2 =verde>2 @A2 /rue<

;1super'icie12 1perBmetro12 ;1base12 1altura1<<

;;=helic(ptero>2 =millas>2 ?5.<2 ;=autobCs2 =+il(metros>2

D?.2 False<<

)nde+ado de eementos en istas

La posici#n de un eemento de a ista

corresponde a un nImero a partir de 0 de
i<quierda a derecha o a partir de 41 de derecha
e i<quierda.

0odi9icaci#n de eementos en istas

$s posibe modi9icar os contenidos de un

eemento de una ista mediante e operador de
asignaci#n :,: 5 sin embargo5 no se pueden
aTadir eementos por este procedimiento.
#li2ta&>#?ndi$&@ A #!alor&

$iminaci#n de un eemento de a
ista

Para desigar un eemento de una ista se

utii<a a decaraci#n del.
dl #li2ta&>#?ndi$&@

Concatenaci#n y mutipicaci#n de
istas

$s posibe concatenar una ista con e operador

:+: .

$ operador :5: repite y concatena una ista e

nImero de !eces que se indique.

"gunas 9unciones para istas

len(<lista>) da e tamaTo de a ista.

max(<lista>) despiega e eemento mayor de

a ista.

min(<lista>) despiega e eemento menor de a

ista.

sum(<lista>) despiega a suma de a ista.

"gunas 9unciones para istas

"gunos mtodos de as istas

<lista>.append(valor) aTade un !aor a 9ina de

a ista.

<lista>.insert(posici(n2 valor) aTade un !aor

en a posici#n indicada5 despa<ando e resto de
os eementos de a ista.

<lista>.remove( valor) eimina e primer

eemento que sea igua a !aor indicado.

<lista>.reverse( ) in!ierte e orden de a ista.

<lista>.sort( ) ordena de 9orma ascendente os

eementos de a ista.

<lista>.pop( ) eimina e Itimo eemento de a

ista y regresa su !aor.

"gunos mtodos de as istas

$9ecto de espe*o '"iasing(

Debido a que as estructuras de datos son ob*etos5

cuando utii<amos e operador de asignaci#n :,:5 no
se crea una nue!a ista con un nombre distinto a a
ista origina5 sino que se e da otro nombre a a ista
'aias(.

$9ecto de espe*o a asignar
nombres a istas
'"ias(

:6ebanado: de istas

$s posibe e+traer eementos de una ista dentro de un

rango.

<lista nueva> = <lista>(<ndice_inicial>:<ndice_final>)

El resultado del rebanado ser una nueva lista de

elementos ue van del ndice inicial al anterior al
ndice final.

:6ebanado: de istas

Es posible copiar hasta cierto nivel una lista

mediante el !rebanado!.

6ebanado de istas que contienen
otros ob*etos

$ rebanado en as istas no es e+hausti!o5 por

o que os ob*etos dentro de as ista siguen
su9riendo de e9ecto espe*o.

" este rebanado no e+hausti!o se e ama

:shaoG copy:.

0,s adeante se discutir, e tema de :deep

copy:.

6ebanado de istas que contienen
otros ob*etos

$ script 'or"lista.py

Bso de 'or con istas

&upas
De9inidas entre parntesis 7(7 7)8

;eparadas por comas.

Las tupas pueden ser inde+adas como as istas.

?o pueden cambiar sus !aores.

?o es posibe eiminar un eemento de a tupa con del.

?o cuentan con os mtodos de as istas.

Los operadores :+: y :$: pueden ser utii<ados.

$s posibe :rebanar: as tupas.

$s posibe usar a 9unci#n len() en as tupas.

&upas

Diccionarios
Los diccionarios son istas en a que os Hndices
en !e< de ser numricos5 corresponden a un
identi9icador de tipo cadena de caracteres.

De9inidas entre a!es 7E7 7F8

;eparadas por comas.

-ormato% 6Iden(i+icador7 4 6obje(o7

$ identi9icador es inmutabe y representa un

mapeo de os ob*etos.

?o pueden ser concatenados.

)nde+ado de diccionarios

" di9erencia de as istas5 e inde+ado de un

diccionario no corresponde a una secuencia de
nImeros5 sino a con*unto de os identi9icadores.

Los identi9icadores de os diccionarios pueden ser

de cuaquier tipo.

0odi9icaci#n de eementos en
diccionarios

$s posibe modi9icar os contenidos de un

eemento de un diccionario mediante e
operador de asignaci#n :,: 5 sin embargo5 no
se pueden aTadir eementos por este
procedimiento.

Los identi9icadores no pueden modi9icarse.

#di$$ionario&>#idnti:i$ador&@ A #!alor&

"dici#n de eementos a un
diccionario

Para aTadir un eemento se hace o siguiente%

#di$$ionario&>#idnti:i$ador nu!o&@ A #!alor&

$iminaci#n de un eemento de un
diccionario

Para eiminar un eemento de un diccionario se

utii<a a decaraci#n del.
dl #di$$ionario&>#idnti:i$ador&@

-unciones para diccionarios

len (<lista>) da e nImero de eementos en e

diccionario.

$s posibe usar max() y min() para identi9icar e

identi9icador de mayor !aor como cadena de
caracteres.

"gunos mtodos de diccionarios

<diccionario>.items() regresa os eementos de

un diccionario como una ista de de tupas.

<diccionario>.+eys() regresa os identi9icadores

de un diccionario como una ista.

<diccionario>.iteritems() regresa un iterador

conteniendo cada eemento de diccionario como
una tupa.

<diccionario>.iter+eys() regresa un iterador

conteniendo cada identi9icador de diccionario.

<diccionario>.itervalues() regresa un iterador

conteniendo cada !aor de diccionario.

0todos de diccionarios en Python 3
$n Python 3 os siguientes mtodos 9ueron
descartados.

iteritems()

iter+eys()

itervalues()

$ script 'or"diccionarios.py

$ script 'or"diccionarios.py

Cadenas de caracteres

Las cadenas de caracteres son estructuras de

datos que contienen caracteres.

Los eementos de una cadena de caracteres

pueden ser inde+ados.

Los eementos de a cadena no pueden modi9icarse

mediante e operador :=:

Los eementos de a cadena no pueden modi9icarse

mediante del.

Las cadenas pueden concatenarse y mutipicarse.

Las cadenas pueden ser :rebanadas:.

$s posibe usar len() para conocer e tamaTo de a

cadena.

Cadenas de caracteres

"gunos mtodos de as cadenas

<cadena>.upper() trans9orma en mayIscuas

todos os eementos de a cadena.

<cadena>.lo!er() trans9orma en minIscuas

todos os eementos de a cadena.

<cadena>.capitali:e() trans9orma e primer

car,cter de una cadena en mayIscuas.

<cadena>.isdi%it() regresa un !aor !erdadero

si a cadena est, compuesta s#o por dHgitos.

"gunos mtodos de as cadenas

$ script 'or"cadena.py

Con*untos

" di9erencia de as estructuras de datos pre!ias5 as

coecciones de datos que no se encuentran ordenadas y
cuyos eementos no se repiten.

$ste tipo de datos est,n diseTados para a*ustarse a a

teorHa de con*untos.

?o son inde+abes5 ni rebanabes.

;#o soportan a 9unci#n len()

Los con*untos se crean mediante e comando set()

<nuevo_set> = set(<lista>)

"gunos mtodos para con*untos

<set"D>.issubset(<set"?>) !eri9ica si <set"D> es subcon*unto

de _set"?>

<set"D>.issuperset(<set"?>) !eri9ica si <set"?> es

subcon*unto de <set"D>

<set"D>.union(<set"?>) regresa a uni#n entre <set"D> y

<set"?>

<set"D>.intersection(<set"?>) regresa a intersecci#n entre

<set"D> y <set"?>

<set"D>.di''erence(<set"?>) regresa os eementos que est,n

en <set"D> pero no en <set"?>

<set"D>.symmetricdi''erence(<set"?>) regresa os
eementos que est,n en <set"D> o en <set"?>2 pero no en
ambos.

<set>.copy() hace un shallo! copy de <set>

"gunos mtodos para con*untos

"gunos mtodos para con*untos

<set>.add(<elemento>) aTade <elemento> a <set>

<set>.remove(<elemento>) eimina <elemento> de

<set>5 marca un error en caso de que <elemento> no
estu!iera contenido en <set>

<set>.discard(<elemento>) trata de eiminar

<elemento> de <set> sin marcar error si no o
encuentra.

<set>.pop() eimina un eemento arbitrariamente de

<set>.

<set>.clear() eimina todos os eementos de <set>.

"gunos mtodos para con*untos

$ e*empo de animaes domsticos

$ tipo 'ro:enset

$ tipo 'ro:enset es simiar a tipo set5 pero su

contenido es inmutabe.

Los ob*etos de tipo 'ro:enset no cuentan con

mtodos que os modi9iquen.

"gunos mtodos para 'ro:enset

<'ro:enset"D>.issubset(<set"?>) !eri9ica si <'ro:enset"D>

es subcon*unto de _set"?>

<'ro:enset"D>.issuperset(<set"?>) !eri9ica si <set"?> es

subcon*unto de <'ro:enset"D>

<'ro:enset"D>.union(<set"?>) regresa a uni#n entre

<'ro:enset"D> y <set"?>

<'ro:enset"D>.intersection(<set"?>) regresa a intersecci#n

entre <'ro:eset"D> y <set"?>

<'ro:enset"D>.di''erence(<set"?>) regresa os eementos

que est,n en <'ro:enset"D> pero no en <set"?>

<'ro:enset"D>.symmetricdi''erence(<set"?>) regresa os
eementos que est,n en <'ro:enset"D> o en <set"?>2 pero no
en ambos.

<'ro:enset>.copy() hace un shallo! copy de <'ro:enset>

"gunos e*empos con 'ro:enset

$ operador in

$ operador in se utii<a para e!auar si un

ob*etos est, contenido dentro de una
estructura. $ resutado de este operador es un
!aor booeano.

$ script poli%lota.py

$ script poli%lota.py

1UNCIONE%

De9inici#n de 9unciones

Las 9unciones son una serie de argumentos y

e+presiones que pueden ser in!ocadas durante
a e*ecuci#n de un programa.

;e utii<a a decaraci#n de' para crear una

9unci#n.

$n Python5 as 9unciones tambin son ob*etos.

def C-ombreDf*-ci1-E3C,rg*me-tosE6:
Cc1digoE

Bna 9unci#n b,sica

La 9unci#n m,s simpe que se pude hacer es

una que no hace absoutamente nada.

$n este caso utii<aremos a e+presi#n pass.

Los comentarios contenidos en a primera

docstring anidada en a 9unci#n ser,
identi9icada como a descripci#n de sta a
e*ecutar help('uncion).

Bna 9unci#n b,sica

-unciones y 9u*o de e*ecuci#n

$ intrprete de Python sigue un orden inea a

interpretar e c#digo de un script.

Las 9unciones pueden ser in!ocadas s#o una

!e< que son de9inidas.

"rgumentos y par,metros en as
9unciones

" de9inir una 9unci#n es posibe designar

:argumentos: cuyos !aores podrHan ser
ingresados a in!ocar a dicha 9unci#n.

" os argumentos se es puede asignar !aores

iniciaes que pueden ser reempa<ados a ser
in!ocados. $n caso de no asignar un !aor5 se
utii<ar, e !aor inicia.

" os datos ingresados a in!ocar una 9unci#n

se es ama :par,metros:.

Deben e+istir tantos par,metros como

argumentos de9inidos en una 9unci#n.

$ script 'uncion"con"parametros.py

ambito ';cope(.

Cada ob*eto contiene su propio espacio de

nombres.

" espacio de nombres de cada entidad se e

conoce como :,mbito:.

$sta di9erenciaci#n de espacios de nombres

e!ita coisiones entre 2 nombres idnticos en
,mbitos distintos.

$ ,mbito de una 9unci#n e+iste hasta que a

9unci#n termina de e*ecutarse.

ambito goba y oca.

ambito goba corresponde a espacio de

nombres principa de intrprete de Python.

ambito oca corresponde a espacio de

nombres reacionado a un ob*eto.

" in!ocar un nombre en una 9unci#n5 e

intrprete hace una bIsqueda desde e ,mbito
oca hacia e ,mbito goba y utii<a a
re9erencia a primer nombre que coincida.

$n caso de no encontrar agIn nombre se

generar, una e+cepci#n de tipo Game4rror
indicando que e nombre no est, de9inido.

ambito oca y goba

Las 9unciones %lobals() y locals()

La 9unci#n %lobals() regresa un diccionario que

contiene a su !e< e contenido de espacio de
nombres principa.

La 9unci#n locals() regresa un diccionario que

contiene a su !e< e contenido de espacio de
nombres de a 9unci#n en a que se encuentra.

;i se e*ecuta locals() en e ,mbito principa5 e

diccionario resutante ser, idntico a de
%lobals().

$ script locals"%lobals.py

$ script locals"%lobals.py

La decaraci#n %lobal

;i quisiramos que un nombre dentro de una

9unci#n sea goba podemos utii<ar a
decaraci#n %lobal.
def C-ombreDf*-ci1-E36:
glob,l C-ombreE
C-ombreE + Cob8etoE
Cc1digoE

$ script circulo.py

-unciones con un nImero arbitrario
de par,metros

$n ocasiones se requiere que una 9unci#n

pueda aceptar un nImero indeterminado de
par,metros.

$+isten dos maneras de hacero%

)ngresar os par,metros como una tupa.

)ngresar os par,metros como un diccionario.

-unciones que aceptan par,metros
como tupas 'args(

Para indicar a intrprete que a 9unci#n puede

aceptar una tupa en un argumento5 se incuye
un asterisco 1$1 como pre9i*o de argumento.

;i a 9unci#n requiere de otros argumentos5

stos deben ser de9inidos antes de insertar e
argumento con par,metros mItipes.
def C-ombreDf*-ci1-E3C,rg*me-tosDopcio-,lesE5 FC,rgsE6:
Cc1digoE

$ script promedio.py

$ script promedio.py

-unciones que aceptan par,metros
como diccionarios 'SGargs(

Para indicar a intrprete que a 9unci#n puede

aceptar un diccionario en un argumento5 se
incuye un asterisco '$$( como pre9i*o de
argumento.
def C-ombreDf*-ci1-E3C,rg*me-tosDopcio-,lesE FFCk$,rgsE6:
Cc1digoE

$ script super'icies.py

$ script super'icies.py

Vaores de retorno de as 9unciones

Las 9unciones pueden regresar ob*etos con a

e+presi#n return.

La e+presi#n return 9unciona de modo simiar a

brea+.
def C-ombreDf*-ci1-E3C,rg*me-tosE6
...
...
C-ombreE + Cob8etoE
...
...
ret*r- C-ombreE

$ script calculo.py

3DU&O% $ -#8UETE%

0#duos

Python cuenta con una gran bibioteca de

m#duos.

Los m#duos se pueden consutar e*ecutando

help(1modules1) en a inter9a< interacti!a.

Los m#duos pueden contener 9unciones y

!aores5 cases y ob*etos.

0todos de importaci#n 'i(

import <module> carga e m#duo

seeccionado.

Para in!ocar un componente de m#duo se

e*ecuta <modulo>.<componente>

0todos de importaci#n 'ii(

'rom <modulo> import <componente> carga

e componente seeccionado de m#duo.

$ nombre de componente queda amacenado

en e ,mbito goba.

)mportaci#n de un m#duo

" importar un m#duo5 e intrprete de Python busca

en os siguientes directorios en e orden
especi9icado%

La ruta desde a que se e*ecuta e script de Python.

Las rutas prede9inidas por de9ecto por e intrprete de

Python.

" encontrar e primer m#duo con e nombre

indicado5 e intrprete o e*ecuta de principio a 9in.

$ intrprete crea un espacio de nombres propio de

m#duo e cua reaciona a os ob*etos creados
durante su e*ecuci#n.

"rchi!os .pyc

" importar un m#duo5 Python genera un

archi!o :compiado: con e+tensi#n .pyc

Los archi!os .pyc contienen o que se conoce

como bytecode que optimi<a a e*ecuci#n de
m#duo en cuesti#n.

;i e m#duo ha cambiado5 Python genera un

nue!o archi!o .pyc a ser importado
nue!amente.

$mpame en e espacio de nombres
a importar

Pre!enci#n de empames con a
e+presi#n as

6ecarga de un m#duo

La e+presi#n import s#o se puede utii<ar una

!e< sin tener que cerrar e intrpreteCentorno.

$n caso de querer recargar un m#duo se

utii<a a 9unci#n reload().

-unciones intrHnsecas 'buit4in
9unctions(

$ intrprete de Python a iniciar importa e

m#duo ""builtin""5 e cua contiene as
9unciones intrHnsecas de engua*e.

Las 9unciones intrHnsecas no deben con9undirse

con as :SeyGords: de Python.

Creaci#n de m#duos propios

Cuaquier script de Python que de9ina

cases5 ob*etos5 9unciones yCo !aores es
susceptibe de ser un m#duo en Python.

$n modo interacti!o5 os m#duos deben

estar en e directorio desde e que se est,
e*ecutando a inter9a< de Python o en as
rutas prede9inidas por e sistema.

$ script cuenta"di%itos.py

$*empo de un m#duo de Python

$ m#duo cuenta"di%itos de9ine as 9unciones

di%ito"en"conteo() y pro%rama().

"dem,s hay una Hnea a 9ina de m#duo que

manda a e*ecutar a a 9unci#n pro%rama()

" importarse e m#duo por primera !e<5 ste

se e*ecuta5 pero no cuando se importa por
segunda !e<.

Con9iguraci#n de rutas

$ m#duo sys de Pyhton contiene !arias 9unciones

y !ariabes de entorno de e*ecuci#n de Python.

Bna de estas !ariabes es e :path: de python5 e

cua de9ine as rutas dentro de sistema de archi!os
a os que Python puede recurrir para buscar
archi!os.

sys.path es donde se guarda e !aor de a ruta

como una ista de cadenas de te+to.

Para incuir una ruta de bIsqueda es necesario

aTadira mediante a instrucci#n%
2.2-patB-appnd"#ruta&'

$*empo de uso de un m#duo
propio

$*ecuci#n de un archi!o .py como
un script o como un m#duo

Cuando un archi!o es cargado como un

m#duo5 a !ariabe interna ""name"" adquiere
e nombre de m#duo.

Cuando un archi!o es cargado como un script5

a !ariabe interna ""name"" adquiere e
nombre 1""main""1.

De ese modo5 es posibe de9inir si e 9u*o

dentro de archi!o se e*ecuta o no5
dependiendo si es un m#duo o un script.

$ script cuenta"di%itos"mod.py

$ script modulo"cuenta"di%itos.py
Al ser e8ec*t,do e- l, l0-e, de com,-do:
Al ser import,do e- el e-tor-o i-ter,ctivo:

Paquetes

" un grupo de m#duos se e ama paquete.

Los paquetes son una estructura de

subdirectorios *er,rquicos.

$n cada subdirectorio debe haber un archi!o

""init"".py e cua puede ser!ir para iniciai<ar
os !aores de os m#duos ocai<ados en dicho
subdirectorio.

$s posibe de*ar archi!os ""init"".py !acHos.

$structura de os paquetes

$n FindoGs5 e paquete mail se ocai<a en

C&HIython?JHKibHemail

$structura de os paquetes

" su !e<5 e paquete mail.mime se ocai<a en

C&HIython?JHKibHemailHmime

)n!ocaci#n de m#duos dentro de
paquetes

"cceso a a introspecci#n de m#duos
y paquetes
$s posibe acceder a a in9ormaci#n de un
m#duo importado o de uno de sus
componentes mediante a 9unci#n help()
Blp"#9odulo&'
Blp"#9odulo&-#$o9ponnt&'

)ntrospecci#n de m#duos y paquetes

$*empo de uso de help()

.esti#n de proyectos con ?in*a4)D$

?in*a4)D$ cuenta con a 9uncionaidad de crear

proyectos5 os cuaes son una serie de archi!os
moduares.

"gunos ata*os reati!os a os proyectos son%

CtrQ;hi9tQ?% Crea un nue!o proyecto.

CtrQ;hi9tQ/% "bre un proyecto.

CtrQ;hi9tQ;% .uarda un proyecto.

-R% Corre un proyecto.

C#%O DE E%TUDIO

Contro escoar
?ombre de Pia str
Primer "peido str
;egundo "peido str
;emestre int
Promedio 9oat
" Corriente boo
)na 2$ula d2a raliCar l $ontrol 2$olar d 2u2
alu9no2 $on lo2 2i1uint2 $a9po2-

Contro escoar
Por l 9o9nto 20lo $unta $on la in:or9a$i0n d D
alu9no2/
Nombre -rimer
#pellido
%e9,ndo
#pellido
Carrera %emes(re -romedio #l
Corrien(e
$duardo ;,nche< 6amos ;istemas R A.W &rue
"berto Dur,n 0onteano Derecho 2 R.3 &rue
JoaquHn "usencio /!era "ctuarHa 2 W.2 -ase
$miiano 6enterHa "dministraci#n @ O.A &rue
Patricio "yaa "rriaga ;istemas W O.0 &rue

Contro escoar
La 2$ula $unta $on D $arrra2/
;istemas
Derecho
"ctuarHa
"rquitectura
"dministraci#n

Contro $scoar

Lay que crear un sistema que genere una ista de os

aumnos con todos sus datos.

Lay que crear un sistema de atas de nue!os

aumnos.

Lay que !aidar cada campo%

2ue os semestres sean positi!os.

2ue e nombre y primer apeido no estn !acHos.

Pedir con9irmaci#n en caso de de*ar !acHo e campo de

segundo apeido.

2ue as carreras sean as indicadas.

2ue e promedio sea mayor o igua que 0 y menor o igua a

10.

2ue cada dato corresponda a su tipo.

0#duo datos.py

0#duo valida.py

0#duo listado.py

0#duo altas.py

""init"".py

&raba*o a reai<ar

$ c#digo contiene pocos comentarios.

"naice y reaice comentarios a c#digo.

"cceso a c#digo

Puede descargar todo e c#digo de este curso5 incuyendo

e subdirectorio caso desde%
https%CCdocs.googe.comC9ieCdC0=4t-2SJLb"EP?0dJE1JL
&BJqBS$Cedit3uspYsharing

$ c#digo de caso de uso se encuentra en e subdirectorio

caso.

$ contenido puede ser abierto en e directorio como un

proyecto de ?)?J"4)D$.

&ambin pueden modi9icar sys.path indicando a direcci#n

donde se encuentre e importando e directorio como un
m#duo%
i9port 2.2
2.2-patB-appnd""#ruta&"'
i9port $a2o

E%CRITUR#:&ECTUR# DE
#RC;I<O%

.esti#n de archi!os de te+to

Los archi!os en Python pertenecen a tipo 'ile.

Para crear un ob*eto de tipo 9ie se utii<a a

9unci#n open().
<archivo> = open(<nombre_archivo>, <modo>)

0odos de acceder a archi!os

1r1 es e modo de ectura.

1!1 es un modo de escritura. $n caso de e+istir

un archi!o5 ste es sobreescrito.

1a1 es un modo de escritura. $n caso de e+istir

un archi!o5 comien<a a escribir a 9ina de ste.

1b1 permite escritura en modo binario.

1L1 de9ine satos de Hnea uni!ersaes para e

modo de ectura.

;e utii<a e signo de :Q: para combinar modos.

"gunos mtodos para archi!os

<'ile>.read() ee e archi!o competo.

<'ile>.readline() ee una Hnea de archi!o.

<'ile>.readlines() regresa una ista de todas as Hneas

de archi!o.

<'ile>.!rite(<cadena>) escribe una <cadena> en e

archi!o.

<'ile>.tell() regresa a posici#n de puntero en e archi!o.

<'ile>.see+(<ran%o>2 <posici(n>) mue!e e puntero.

<'ile>.close() cierra e archi!o.

$scrituraCectura de archi!os.

$ archi!o texto.txt

La e+presi#n !ith

$s posibe crear un proceso :saniti<ado: con

!ith.

Lo anterior permite a ciertos ob*etos como os de

tipo 'ile un comportamiento muy simiar a utii<ar
'inally.

$n este caso5 incuso cuando ocurra una

e+cepci#n5 e archi!o se cerrar,
autom,ticamente5 e!itando posibe corrupci#n de
os archi!os.
EitB opn" #ar$Bi!o&7 #9odo&' a2 #no93r&/

6e!isitando e caso de uso

" partir de caso de uso estudiado con

anticipaci#n se eer,n y escribir,n os datos de
os aumnos en e archi!o%

datos.txt

;e modi9icar,n os m#duos%

""init"".py

datos.py

listado.py

datos.txt

datos.py

""init"".py

listado.py

9pe- @-tellige-ceG
http://ope-i-tellige-ce.m.
i-foHope-i-tellige-ce.m.
=I23II6 BI'J-'00
Alg*-os derechos reserv,dos. :st, obr, p*ede ser modific,d,5 redistrib*id, 2
comerci,liA,d, b,8o los t4rmi-os de l, lice-ci, Atrib*ci1- 2.I %4.ico 3<< BK 2.I6
http://cre,tivecommo-s.org/lice-ses/b2/2.I/m./