Está en la página 1de 137

Eugenia Bahit

Curso:
Python para
Principiantes
Eugenia Bahit 2012. Creative Commons Atribucin-NoComercial 3.0 Comparte el conocimiento en libertad!
www.eugeniabahit.com
www.detodoprogramacion.com
Python para Principiantes de Eugenia Bahit se distribue ba!o una "icencia Creative Commons Atribucin-
NoComercial-#in$erivadas 3.0 %n&orted.
Comparte el conocimiento
Eres libre de:
Copiar' distribuir compartir este libro
Bajo las siguientes condiciones:
(econocer res&etar la autor)a de la obra
No hacer uso comercial de ella
No alterar el contenido
htt&*++,,,.sa-ecreative.org+,or.+120/302002120
@eugeniabahit
2012 Eugenia Bahit www.eugeniabahit.com Buenos Aires, Argentina
Imagen Twitter Follow Me Aha-Soft.com Creatie Commons !Attribution-Share A"i#e $.0 %n&orte'(
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
2
www.detodoprogramacion.com
Descarga todos los ejemplos de
este libro los talleres del curso'
ingresando en
htt&*++curso-&thon.eugeniabahit.com+sources.tar.g4
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0

www.detodoprogramacion.com
Tabla de
Contenidos
(ndice)

!abla de Contenidos "#ndice$......................................................................................................................... %
Preparaci&n del entorno de desarrollo......................................................................................................... '
3ntroduccin al #istema 5&erativo 6N%+"inu7........................................................................................... 10
3nstalacin de %buntu 6N%+"inu7 en 8indo,s.................................................................................... 10
3nstalacin de %buntu 6N%+"inu7 como 9nico #istema 5&erativo.......................................................11
3nstalando :thon...................................................................................................................................... 12
3nstalacin de un #hell interactivo me!orado.............................................................................................. 10
Nin!a-3$E................................................................................................................................................... 1;
3nstalacin de Ba4aar................................................................................................................................ 12
Estructura y elementos del lenguaje........................................................................................................... ()
Elementos del "engua!e............................................................................................................................ 20
<ariables............................................................................................................................................... 20
=i&os de datos...................................................................................................................................... 21
5&eradores Aritm>ticos........................................................................................................................ 22
Comentarios......................................................................................................................................... 23
=i&os de datos com&le!os..................................................................................................................... 20
=u&las.............................................................................................................................................. 20
"istas............................................................................................................................................... 20
$iccionarios..................................................................................................................................... 2;
Estructuras de Control de ?lu!o................................................................................................................. 22
3dentacin............................................................................................................................................. 22
Encoding............................................................................................................................................... 2/
Asignacin m9lti&le............................................................................................................................... 2/
Estructuras de control de -lu!o condicionales........................................................................................ 21
Estructuras de control iterativas............................................................................................................ 31
Bucle ,hile...................................................................................................................................... 31
Bucle -or.......................................................................................................................................... 32
*&dulos+ pa,uetes y namespaces..............................................................................................................
Creando mdulos em&a@uetados.............................................................................................................. 30
3m&ortando mdulos enteros................................................................................................................ 30
Names&aces......................................................................................................................................... 3;
Alias................................................................................................................................................. 3;
3m&ortar mdulos sin utili4ar names&aces....................................................................................... 3;
-unciones de.inidas por el usuario............................................................................................................. /
$e-iniendo -unciones................................................................................................................................. 3A
#obre los &arBmetros........................................................................................................................... 3A
:arBmetros &or omisin................................................................................................................... 31
Ce,ords como &arBmetros............................................................................................................ 31
:arBmetros arbitrarios..................................................................................................................... 00
$esem&a@uetado de &arBmetros.................................................................................................... 00
"lamadas de retorno.................................................................................................................................. 01
#aber si una -uncin e7iste &uede ser llamada..................................................................................02
"lamadas recursivas ................................................................................................................................. 03
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%
00
www.detodoprogramacion.com
#obre la -inalidad de las -unciones ........................................................................................................... 03
0ntroducci&n a la 1rientaci&n a 1bjetos..................................................................................................... %%
:ensar en ob!etos...................................................................................................................................... 0;
D E@u> es un ob!etoF............................................................................................................................ 0;
Ahora E@u> me dices si describimos las cualidades de un ob!etoF......................................................0;
:ero algunos ob!etos' tambi>n se com&onen de otros ob!etos.............................................................02
D tambi>n ha ob!etos @ue com&arten caracter)sticas con otros ob!etos.............................................0A
"os ob!etos' tambi>n tienen la ca&acidad de Ghacer cosasH.................................................................;0
5b!etos mBs ob!etos* la &arte di-)cil................................................................................................... ;1
Al &an' &an. D al vino' vino. "as cosas &or su nombre....................................................................;2
:rogramacin 5rientada a 5b!etos........................................................................................................... ;3
Elementos Caracter)sticas de la :55............................................................................................... ;3
Clases.............................................................................................................................................. ;3
:ro&iedades.................................................................................................................................... ;0
I>todos........................................................................................................................................... ;0
5b!eto.............................................................................................................................................. ;;
Jerencia* caracter)stica &rinci&al de la :55................................................................................... ;;
Accediendo a los m>todos &ro&iedades de un ob!eto........................................................................;2
*2todos principales del 1bjeto 3tring....................................................................................................... 4)
I>todos de -ormato................................................................................................................................... ;1
Convertir a ma9scula la &rimera letra................................................................................................. ;1
Convertir una cadena a min9sculas...................................................................................................... ;1
Convertir una cadena a ma9sculas..................................................................................................... ;1
Convertir ma9sculas a min9sculas viceversa................................................................................... ;1
Convertir una cadena en ?ormato =)tulo.............................................................................................. ;1
Centrar un te7to.................................................................................................................................... 20
Alinear te7to a la i4@uierda................................................................................................................... 20
Alinear te7to a la derecha..................................................................................................................... 20
(ellenar un te7to ante&oniendo ceros.................................................................................................. 20
I>todos de B9s@ueda............................................................................................................................... 22
Contar cantidad de a&ariciones de una subcadena.............................................................................. 22
Buscar una subcadena dentro de una cadena..................................................................................... 22
I>todos de <alidacin............................................................................................................................... 23
#aber si una cadena comien4a con una subcadena determinada........................................................23
#aber si una cadena -inali4a con una subcadena determinada............................................................23
#aber si una cadena es al-anum>rica................................................................................................... 23
#aber si una cadena es al-ab>tica........................................................................................................ 20
#aber si una cadena es num>rica........................................................................................................ 20
#aber si una cadena contiene solo min9sculas.................................................................................... 20
#aber si una cadena contiene solo ma9sculas................................................................................... 2;
#aber si una cadena contiene solo es&acios en blanco.......................................................................2;
#aber si una cadena tiene ?ormato $e =)tulo...................................................................................... 2;
I>todos de #ustitucin............................................................................................................................. 22
$ar -ormato a una cadena' sustituendo te7to dinBmicamente............................................................22
(eem&la4ar te7to en una cadena......................................................................................................... 22
Eliminar caracteres a la i4@uierda derecha de una cadena...............................................................22
Eliminar caracteres a la i4@uierda de una cadena................................................................................22
Eliminar caracteres a la derecha de una cadena.................................................................................. 2/
I>todos de unin divisin....................................................................................................................... 2A
%nir una cadena de -orma iterativa....................................................................................................... 2A
:artir una cadena en tres &artes' utili4ando un se&arador...................................................................2A
:artir una cadena en varias &artes' utili4ando un se&arador................................................................2A
:artir una cadena en en l)neas............................................................................................................. 2A
E!ercicio..................................................................................................................................................... /0
E!ercicio NK1......................................................................................................................................... /0
E!ercicio NK2......................................................................................................................................... /0
E!ercicio NK3......................................................................................................................................... /0
*2todos principales del objeto list............................................................................................................. /(
I>todos de agregado................................................................................................................................ /2
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
4
www.detodoprogramacion.com
Agregar un elemento al -inal de la lista................................................................................................. /2
Agregar varios elementos al -inal de la lista......................................................................................... /2
Agregar un elemento en una &osicin determinada............................................................................. /2
I>todos de eliminacin............................................................................................................................. /3
Eliminar el 9ltimo elemento de la lista................................................................................................... /3
Eliminar un elemento &or su )ndice....................................................................................................... /3
Eliminar un elemento &or su valor........................................................................................................ /3
I>todos de orden...................................................................................................................................... /0
5rdenar una lista en reversa Linvertir ordenM........................................................................................ /0
5rdenar una lista en -orma ascendente................................................................................................ /0
5rdenar una lista en -orma descendente.............................................................................................. /0
I>todos de b9s@ueda............................................................................................................................... /;
Contar cantidad de a&ariciones elementos........................................................................................... /;
5btener n9mero de )ndice.................................................................................................................... /;
Ane7o sobre listas tu&las........................................................................................................................ /2
Conversin de ti&os.............................................................................................................................. /2
Concatenacin sim&le de colecciones.................................................................................................. /2
<alor mB7imo m)nimo......................................................................................................................... /2
Contar elementos................................................................................................................................. //
*2todos principales del objeto dict............................................................................................................ /)
I>todos de eliminacin............................................................................................................................. /1
<aciar un diccionario............................................................................................................................. /1
I>todos de agregado creacin............................................................................................................... /1
Co&iar un diccionario............................................................................................................................ /1
Crear un nuevo diccionario desde las claves de una secuencia.........................................................../1
Concatenar diccionarios....................................................................................................................... A0
Establecer una clave valor &or de-ecto.............................................................................................. A0
I>todos de retorno.................................................................................................................................... A1
5btener el valor de una clave............................................................................................................... A1
#aber si una clave e7iste en el diccionario........................................................................................... A1
5btener las claves valores de un diccionario..................................................................................... A1
5btener las claves de un diccionario.................................................................................................... A1
5btener los valores de un diccionario................................................................................................... A2
5btener la cantidad de elementos de un diccionario............................................................................ A2
El objeto -ile: trabajando con archi5os...................................................................................................... )
#obre el ob!eto ?ile.................................................................................................................................... A0
Iodos de A&ertura............................................................................................................................... A0
I>todos del 5b!eto ?ile............................................................................................................................. A2
:ro&iedades del ob!eto -ile......................................................................................................................... A/
Cerrando archivos de -orma automBtica.................................................................................................... AA
6n Paseo por los *&dulos de la librer#a est7ndar..................................................................................... )'
Idulos de sistema................................................................................................................................... 10
Idulo os............................................................................................................................................. 10
Archivos directorios....................................................................................................................... 10
El mdulo os las variables de entorno.......................................................................................... 11
os.&ath............................................................................................................................................. 11
Idulo ss........................................................................................................................................... 12
<ariables del mdulo ss................................................................................................................. 12
I>todos del mdulo ss.................................................................................................................. 12
Idulo sub&rocess............................................................................................................................... 13
Ca&turando la salida con :o&en...................................................................................................... 13
Entradas salidas @ue &ueden ser ca&turadas con :o&en.............................................................10
stdout.......................................................................................................................................... 10
stdin............................................................................................................................................ 10
stderr.......................................................................................................................................... 10
%tili4ando tuber)as &ara ca&turar la salida....................................................................................... 10
Idulos &ara el &rogramador.................................................................................................................... 12
$ebuguear cdigo con :db.................................................................................................................. 12
$ocumentar tu a&& con &doc.............................................................................................................. 1/
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
8
www.detodoprogramacion.com
:robar el cdigo antes de enviarlo a &roduccin con doctest...............................................................1A
Idulos @ue resuelven necesidades -uncionales.................................................................................... 100
5btener datos aleatorios.................................................................................................................... 100
8ra&ear un te7to................................................................................................................................ 101
Idulos e 3nternet................................................................................................................................... 102
Acceder al navegador 8eb................................................................................................................. 102
Conectarse v)a ?=:............................................................................................................................ 102
Conectarse a un servidor ?=:....................................................................................................... 102
0ntroducci&n a *y39: y el lenguaje 39:................................................................................................. (;%
Acerca de I#N".................................................................................................................................... 10;
3nstalacin con-iguracin de I#N"................................................................................................ 10;
3niciar' reiniciar detener el servidor I#N"..................................................................................... 102
Administracin de I#N".................................................................................................................. 10/
Conectarse desconectarse al servidor........................................................................................ 10/
Comandos &ara administrar I#N" dede el shell interactivo.......................................................10/
#obre el lengua!e #N"............................................................................................................................. 10A
=i&os de datos mBs comunes LrecomendadosM.................................................................................. 10A
#intB7is bBsica de las sentencias #N"............................................................................................... 10A
Crear tablas en una base de datos................................................................................................ 101
3nsertar datos en una tabla............................................................................................................ 110
#eleccionar registros..................................................................................................................... 110
Iodi-icar registros......................................................................................................................... 111
Eliminar registros........................................................................................................................... 111
Consultas avan4adas......................................................................................................................... 112
"a clBusula 8JE(E...................................................................................................................... 112
5rdenando consultas* la clBusula 5($E( BD..............................................................................113
Alias de tablas cam&os.................................................................................................................... 110
?unciones del lengua!e #N" de I#N"............................................................................................. 110
Contar la cantidad de registros* C5%N=LM..................................................................................... 11;
#umar totales* #%ILM.................................................................................................................... 11;
Concatenar cadenas* C5NCA=LM.................................................................................................. 11;
Convertir a min9sculas ma9sculas* "CA#ELM %CA#ELM.........................................................11;
(eem&la4ar datos* (E:"ACELM.................................................................................................... 11;
5btener los &rimeros o 9ltimos caracteres* "E?=LM (36J=LM......................................................11;
(edondear n9meros* (5%N$LM.................................................................................................... 11;
5btener solo la -echa de un cam&o $A=E=3IE o =3IE#=AI:* $A=ELM......................................112
5btener una -echa -ormateada* $A=EO?5(IA=LM.......................................................................112
5btener el registro con el valor mB7imo m)nimo* IAPLM I3NLM................................................112
5&timi4acin de bases de $atos............................................................................................................. 112
=odos los registros deben tener un 3$ 9nico....................................................................................... 112
Crear )ndices en las tablas................................................................................................................. 11/
3ndica cuBles cam&os no &ueden ser nulos........................................................................................ 11/
%tili4a el motor 3nno$B....................................................................................................................... 11/
Bases de datos relacionales.................................................................................................................... 111
Bases de datos en Python con *y39:.................................................................................................... (22
3ntroduccin a bases de datos con :thon.............................................................................................. 123
Conectarse a la base de datos e!ecutar consultas................................................................................123
%na -orma sim&le de acceder a bases de datos................................................................................. 120
3nsertar datos................................................................................................................................. 120
#eleccionar todos los registros...................................................................................................... 120
#eleccionar solo registros coincidentes......................................................................................... 120
Eliminar registros........................................................................................................................... 12;
Actuali4ar datos............................................................................................................................. 12;
Corriendo Python <pps en la =eb............................................................................................................ (28
3ntroduccin............................................................................................................................................. 12/
:thon ba!o A&ache................................................................................................................................. 12A
ENu> necesitamosF............................................................................................................................ 12A
1. 3nstalacin de modO,sgi en A&ache.......................................................................................... 12A
2. Crear la estructura de directorios &ara nuestra a&licacin.........................................................12A
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/
www.detodoprogramacion.com
3. Crear un controlador &ara la a&licacin..................................................................................... 121
0. Con-igurar el <irtualJost............................................................................................................ 130
%tili4ando environ &ara mane!ar &eticiones del usuario........................................................................... 131
En5iando e>mails con .ormato ?!*: desde Python...............................................................................(
:a@uetes necesarios............................................................................................................................... 130
Env)o de e-mail desde :thon................................................................................................................. 130
Env)o de e-mails a m9lti&les destinatarios.......................................................................................... 132
Agregar una direccin de res&uesta di-erente.................................................................................... 132
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
)
www.detodoprogramacion.com
Preparacin del
entorno de
desarrollo
Comen4aremos instalando todo nuestro sistema' &ara crear un entorno de desarrollo
&ro&icio' &ara traba!ar con :thon. A tal -in' nos valdremos de las siguientes herramientas
tecnolog)as*
1. #istema 5&erativo 6N%+"inu7* %buntu 11.10 Lo su&eriorM
2. :thon 2./
3. i:thon L#hell interactivo me!oradoM
0. Nin!a-3$E L3$E de desarrolloM
;. Ba4aar L#istema de Control de <ersiones distribuidoM
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
'
01
www.detodoprogramacion.com
Introduccin al Sistema Operatio !"#$%inu&
Antes de comen4ar' intentaremos establecer una di-erencia' entre los t>rmino G"inu7H
G6N%+"inu7H' a -in de saber de @u> estamos hablando con e7actitud' en cada caso.
:inu@+ es un Aernel+ es decir' el n9cleo de un #istema 5&erativo' mientras @ue
BC6D:inu@+ el 3istema 1perati5o ,ue utiliEa el Fernel :inu@ como n9cleo' creado'
di-undido &romovido a trav>s del Proyecto BC6' &or la -ree 3o.tware -oundation'
organi4acin sin -ines de lucro' -undada &or (ichard #tallman' &rinci&al &recursor del
#o-t,are "ibre.
El Cernel "inu7' &arte -undamental del #istema 5&erativo' -ue desarrollado &or :inus
!or5als' utili4ando como modelo a %N3P. %na de las di-erencias -undamentales entre los
n9cleos "inu7 %N3P' es @ue el &rimero' es #o-t,are "ibre' mientras @ue el segundo no lo
es.
:or otra &arte' mientras e7iste un 9nico Cernel "inu7 Lcon versiones di-erentesM' e7isten
decenas hasta cientos de distribuciones BC6D:inu@' es decir' di-erentes #istemas
5&erativos basados en el Cernel "inu7' entre las cuales se destacan* Debian' 6buntu'
Fubuntu' -edora' Bentoo' 3lacAware' Cent13' <rch:inu@' <sturi@' entre otros
cientos.
IBs in-ormacin al res&ecto' &uede encontrarse en*
#itio 8eb de la -ree 3o.tware -oundation* ,,,.-s-.org
#itio 8eb del Proyecto BC6* ,,,.gnu.org
#itio 8eb del Fernel :inu@* htt&*++,,,..ernel.org+
#itio 8eb de la :inu@ -oundation* htt&*++,,,.linu7-oundation.org+
3ntroduccion al so-t,are libre L%niversitat 5bierta de CatalunaM
#istema o&erativo gnu linu7 basico L%niversitat 5bierta de CatalunaM
Insta"aci)n 'e %buntu *+%,-inu. en /in'ows
#i eres usuario de 8indo,s deseas conservar tu #istema 5&erativo actual' puedes
descargar 6buntu =indows 0nstaller desde el sitio 8eb o-icial de Canonical Lem&resa
@ue desarrolla mantiene %buntuM en la siguiente %("*
htt&*++,,,.ubuntu.com+do,nload+ubuntu+,indo,s-installer
6buntu =indows 0nstaller se instalarB desde el &ro&io I# 8indo,sQ como si -uese un
#o-t,are mBs' &ermiti>ndote iniciar tu ordenador con %buntu o I# 8indo,sQ seg9n
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;
www.detodoprogramacion.com
eli!as.
:ara instalar %buntu 8indo,s 3nstaller' sigue las instrucciones de los pasos 2 y de
la 6G: de descarga' las cuales &odrBs visuali4ar &ulsando el botn G#ho, me ho,H de
cada uno de los &asos.
Insta"aci)n 'e %buntu *+%,-inu. como 0nico Sistema
1&eratio
:ara instalar %buntu como 9nico #istema 5&erativo' sigue los siguientes &asos*
1. ingresa en htt&*++,,,.ubuntu.com+do,nload+ubuntu+do,nload
2. En el &aso 1' selecciona la versin de %buntu @ue deseas descargar. :ara
&rocesadores de un solo n9cleo' selecciona la versin 10.00 "=#. :ara
&rocesadores mBs modernos' &uedes seleccionar la 9ltima versin Lversin @ue
a&arece seleccionada &or de-ecto en el des&legable de versionesM. #i tienes
dudas sobre si elegir la versin &ara 32 o 20 bits' elige la de 32-bits. :ulsa el
botn G#tart do,nloadH aguarda a @ue se descargue el archivo.
3. %na ve4 descargado el archivo' &odrBs @uemarlo en un C$+$<$ o un :endrive
%#B. En el &aso 2 de la %(" de descarga' selecciona C$ o %#B stic. seg9n
tus &re-erencias el #istema 5&erativo desde el cual harBs la co&ia L8indo,s o
IacM. :ulsa el botn Gsho, me ho,H sigue las instrucciones de @uemado.
0. A continuacin' salta al &aso 0 del sitio de descarga Lel 3 es solo &ara &robar
%buntu sin instalarloMR &ulsa el botn Gsho, me ho,H sigue las instrucciones
&ara instalar %buntu en tu ordenador.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
((
www.detodoprogramacion.com
Instalando P't(on
%na ve4 @ue haas instalado tu distribucin 6N%+"inu7' a tendrBs :thon instalado en tu
sistema.
:ara com&robarlo' abres una terminal L&resiona Alt S ?0 luego escribe en el cam&o de
b9s@ueda gnome-terminalM escribe &thon como se muestra a continuacin*
eugenia@cochito:~$ python
Python 2.7.2+ (default, Oct 4 2011, 20:03:08)
[GCC 4!1" on linu#2
$%&e 'hel&', 'co&%(ight', 'c(edit)' o( 'licen)e' fo( *o(e info(*ation
+++
"o @ue verBs en &antalla' es el #hell interactivo de :thon. Para salir del 3hell
interacti5o+ pulsa las teclas Ctrl H D.
eugenia@cochito:~$ &%thon
,%thon 2-2. (default, Oct 4 2011, 20:03:08)
[GCC 4!1" on linu#2
$%&e 'hel&', 'co&%(ight', 'c(edit)' o( 'licen)e' fo( *o(e info(*ation
+++ &(int '/ola 0undo1'
/ola 0undo1
+++
#i en lugar del #hell interactivo' ves un mensa!e de error similar a G&thon* orden no
encontradaH' deberBs seguir los siguientes &asos &ara instalarlo*
Actuali4a la lista de los re&ositorios*
eugenia@cochito:~$ )udo a&t2get u&date
Actuali4a el #istema 5&erativo*
eugenia@cochito:~$ )udo a&t2get u&g(ade
3nstala :thon*
eugenia@cochito:~$ )udo a&t2get in)tall &%thon2-
31BGE :13 C1*<CD13
sudo: te convierte en su&er usuario. Tnico usuario @ue tiene
&ermisos &ara instalar &a@uetes en tu sistema o&erativo.
apt>get: es la utilidad &ara mane!ar &a@uetes en distribuciones
6N%+"inu7 basadas en $ebian. Alternativamente' &uedes utili4ar
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(2
www.detodoprogramacion.com
el comando aptitude en ve4 de a&t-get.
update: o&cin de a&t-get @ue sincroni4a los archivos del )ndice
de &a@uetes con los re&ositorios o-iciales Ldicho de otra -orma'
obtiene un )ndice de actuali4acionesM
upgrade: o&cin de a&t-get @ue actuali4a el sistema.
install: es la o&cin de a&t-get @ue indica @ue se instalarBn uno
o mBs &a@uetes
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(
www.detodoprogramacion.com
Instalacin de un S(ell interactio me)orado
:thon trae &or de-ecto su &ro&io #hell interactivo' el cuBl nos &ermite escribir cdigo
:thon e!ecutarlo. #in embargo' tenemos la o&cin de contar con un #hell interactivo
me!orado' @ue entre otras venta!as sobre el shell nativo' &odemos encontrar n9meros de
l)nea' sangrado automBtico' etc.
iPython' es el #hell interactivo @ue elegiremos. :ara instalarlo' e!ecuta la siguiente orden
desde una terminal*
eugenia@cochito:~$ )udo a&t2get in)tall i&%thon
:ara e!ecutar el nuevo shell interactivo' solo deberBs escribir el comando i&thon*
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(%
www.detodoprogramacion.com
"in)a*I+,
Nin!a-3$E es un Entorno 3ntegrado de $esarrollo
1
@ue nos &ermitirB' crear &roectos en
:thon' al tiem&o de ir e!ecutando nuestros cdigos corrigiendo eventuales errores @ue
>stos' &uedan &resentar.
:ara instalar Nin!a-3$E en tu ordenador' desde la terminal' e!ecuta los siguientes
comandos*
1M Agrega el ::A de Nin!a-3$E*
)udo a&t2add2(e&o)ito(% &&a:nin3a2ide2de4elo&e()5dail%
2M #incroni4a el )ndice de actuali4aciones*
)udo a&t2get u&date
3M 3nstala Nin!a-3$E*
)udo a&t2get in)tall nin3a2ide
1 htt&*++es.,i.i&edia.org+,i.i+EntornoOdeOdesarrolloOintegrado
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(4
www.detodoprogramacion.com
Instalacin de -a.aar
Ba4aar es un sistema de control de versiones distribuido' @ue nos &ermitirB ir
manteniendo el control cambios sobre nuestros archivos' centrali4Bndolos en un
re&ositorio.
%n (e&ositorio es un es&acio destinado a almacenar in-ormacin digital. En nuestro caso'
lo @ue se almacenarB en ese re&ositorio' serBn los archivos -cdigo -uente' tarballs'
binarios' etc- de las a&licaciones e!ercicios @ue iremos codeando a lo largo del curso.
"as venta!as &rinci&ales de utili4ar un #C<' son*
Es&acio de almacenamiento centraliEado de' &rinci&almente' el cdigo -uente de
la a&licacin as) como scri&ts de construccin -en el caso de a&licaciones @ue
re@uieran ser com&iladas o sim&lemente' necesiten reali4ar con-iguraciones
es&eciales' a sea tanto &ara continuar desarrollBndolas como &ara e!ecutarlas-.
:ara ser e-ectivos' deben llevar un control hist&rico de cambios @ue se vaan
e-ectuando en los archivos -&re-erentemente automBtico-' &ermitir el
establecimiento de tags -eti@uetas- @ue auden a identi-icar di-erentes releases
-versiones-.
"os #istemas de Control de <ersiones L#C<M &ueden agru&arse en dos ti&os*
CentraliEados:
un 9nico re&ositorio centrali4ado administrado &or un solo res&onsable.
Distribuidos "recomendados$:
donde e7iste un re&ositorio central @ue cada usuario &odrB clonar &ara obtener su
&ro&io re&ositorio -local- e interactuar con con otros re&ositorios locales.
Entre los 3CI distribuidos &odemos destacar e7celentes alternativas BP: L#o-t,are
"ibreM' como es el caso de -entre otros-' Bit Lde "inus =orvalds' creador del Cernel "inu7
en el @ue se basa el #istema 5&erativo 6N%+"inu7M' *ercurial Ldesarrollado en :thon
CM o el magn)-ico BaEaar' nacido a &artir de 6N%Arch desarrollado )ntegramente en
:thon &or Iartin :ool' con el &atrocinio de Canonical elegido en este curso.
%na gran 5entaja de los 3CI es @ue permiten a 5arios
programadores trabajar simult7neamente sobre los mismos
archi5os' im&idiendo @ue el traba!o de uno' &ise al traba!o de
otro.
"os #C< &ueden utili4arse tanto a trav>s de l)nea de comandos' como de a&licaciones
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(8
www.detodoprogramacion.com
grB-icas. En este curso' nos centraremos en el uso &or medio de l)nea de comandos.
"os #C<' en su maor)a - a rasgos generales- cuentan con un con!unto de
-uncionalidades' las cuales' &ara cada una' e7iste un determinado comando
Lgeneralmente' similar en la maor)a de los #C<M.
:ara instalar BaEaar en tu ordenador' e!ecuta el siguiente comando*
)udo a&t2get in)tall 67(
%na ve4 instalado Ba4aar' deberBs clonar el repositorio central Ldesde el servidor del
cursoM a tu ordenador local*
67( 6(anch )ft&:55tu_usuario@!!22882935ho*e5tu_usuario5&u6lic5t(un:
A continuacin' deberBs ingresar tu contraseUa.
%na ve4 clonado el re&ositorio' deberBs agregar unas l)neas al archivo de con-iguracin
de Ba4aar. :ara ello' abre el archivo de con-iguracin con el editor Nano*
nano t(un:567(56(anch56(anchconf
Iueve el cursor hasta la siguiente l)nea &ulsa las teclas Ctrl S C*
&a(ent;location < )ft&:55tu_usuario@!!22882935ho*e5tu_usuario5&u6lic5t(un:
A continuacin' &ulsa tres veces' las teclas Ctrl S % &ara &egar Ltres vecesM la l)nea @ue
cortaste anteriormente. $eberBs ver lo siguiente*
&a(ent;location < )ft&:55tu_usuario@!!22882935ho*e5tu_usuario5&u6lic5t(un:
&a(ent;location < )ft&:55tu_usuario@!!22882935ho*e5tu_usuario5&u6lic5t(un:
&a(ent;location < )ft&:55tu_usuario@!!22882935ho*e5tu_usuario5&u6lic5t(un:
(eem&la4a la &alabra GparentH de la segunda l)nea' &or GpushH la de la tercera' &or GpullH
de -orma tal @ue el archivo' se vea como sigue*
&a(ent;location < )ft&:55tu_usuario@!!22882935ho*e5tu_usuario5&u6lic5t(un:
push;location < )ft&:55tu_usuario@!!22882935ho*e5tu_usuario5&u6lic5t(un:
pull;location < )ft&:55tu_usuario@!!22882935ho*e5tu_usuario5&u6lic5t(un:
:ara guardar el archivo &ulsa las teclas Ctrl S 5 LenterM &ara salir' &ulsa Ctrl S P.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(/
www.detodoprogramacion.com
,structura '
elementos del
lengua)e
$entro de los lenguajes in.orm7ticos' :thon' &ertenece al gru&o de los lenguajes de
programaci&n &uede ser clasi-icado como un lenguaje interpretado' de alto ni5el'
multiplata.orma' de tipado din7mico multiparadigma. A di-erencia de la maor)a de
los lengua!es de &rogramacin' Python nos pro5ee de reglas de estilos' a -in de &oder
escribir cdigo -uente mBs legible de manera estandari4ada. Estas reglas de estilo' son
de-inidas a trav>s de la Python Enhancement Proposal CJ ) "PEP )$ ' la cual iremos
viendo a lo largo del curso.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
()
02
www.detodoprogramacion.com
B:13<G01
:enguaje in.orm7tico:es un idioma arti-icial' utili4ado &or ordenadores' cuo -in es
transmitir in-ormacin de algo a alguien. "os lengua!es in-ormBticos' &ueden
clasi-icarse en* aM lengua!es de &rogramacin L:thon' :J:' :earl' C' etc.MR bM
lengua!es de es&eci-icacin L%I"MR cM lengua!es de consulta L#N"MR dM lengua!es de
marcas LJ=I"' PI"MR eM lengua!es de trans-ormacin LP#"=MR -M &rotocolos de
comunicaciones LJ==:' ?=:MR entre otros.
:enguaje de programaci&n: es un lengua!e in-ormBtico' diseUado &ara e7&resar
rdenes e instrucciones &recisas' @ue deben ser llevadas a cabo &or una
com&utadora. El mismo &uede utili4arse &ara crear &rogramas @ue controlen el
com&ortamiento -)sico o lgico de un ordenador. EstB com&uesto &or una serie de
s)mbolos' reglas sintBcticas semBnticas @ue de-inen la estructura del lengua!e.
:enguajes de alto ni5el: son a@uellos cua caracter)stica &rinci&al' consiste en una
estructura sintBctica semBntica legible' acorde a las ca&acidades cognitivas
humanas. A di-erencia de los lengua!es de ba!o nivel' son inde&endientes de la
ar@uitectura del hard,are' motivo &or el cual' asumen maor &ortabilidad.
:enguajes interpretados: a di-erencia de los com&ilados' no re@uieren de un
com&ilador &ara ser e!ecutados sino de un int>r&rete. %n int>r&rete' act9a de manera
casi id>ntica a un com&ilador' con la salvedad de @ue e!ecuta el &rograma
directamente' sin necesidad de generar &reviamente un e!ecutable. E!em&lo de
lengua!es de &rogramacin inter&retado son :thon' :J:' (ub' "is&' entre otros.
!ipado din7mico: un lengua!e de ti&ado dinBmico es a@uel cuas variables' no
re@uieren ser de-inidas asignando su ti&o de datos' sino @ue >ste' se auto-asigna en
tiem&o de e!ecucin' seg9n el valor declarado.
*ultiplata.orma: signi-ica @ue &uede ser inter&retado en diversos #istemas
5&erativos como 6N%+"inu7' 8indo,s' Iac 5#' #olaris' entre otros.
*ultiparadigma: ace&ta di-erentes &aradigmas Lt>cnicasM de &rogramacin' tales
como la orientacin a ob!etos' as&ectos' la &rogramacin im&erativa -uncional.
C&digo .uente: es un con!unto de instrucciones rdenes lgicas' com&uestos de
algoritmos @ue se encuentran escritos en un determinado lengua!e de &rogramacin'
las cuales deben ser inter&retadas o com&iladas' &ara &ermitir la e!ecucin del
&rograma in-ormBtico.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
('
www.detodoprogramacion.com
,lementos del %engua)e
Como en la maor)a de los lengua!es de &rogramacin de alto nivel' en :thon se
com&one de una serie de elementos @ue alimentan su estructura. Entre ellos' &odremos
encontrar los siguientes*
2ariab"es
%na variable es un es&acio &ara almacenar datos modi-icables' en la memoria de un
ordenador. En :thon' una variable se de-ine con la sinta7is*
no*6(e;de;la;4a(ia6le < 4alo(;de;la;4a(ia6le
Cada variable' tiene un nombre un valor' el cual de-ine a la ve4' el ti&o de datos de la
variable.
E7iste un ti&o de GvariableH' denominada constante' la cual se utili4a &ara de-inir valores
-i!os' @ue no re@uieran ser modi-icados.
PEP ): 5ariables
%tili4ar nombres descri&tivos en min9sculas. :ara nombres
com&uestos' se&arar las &alabras &or guiones ba!os. Antes
des&u>s del signo V' debe haber uno L solo unM es&acio en
blanco
Correcto: *i;4a(ia6le < 12
0ncorrecto: 0i=a(ia6le < 12 > *i4a(ia6le < 12 > *i;4a(ia6le<12 >
*i;4a(ia6le < 12
PEP ): constantes
%tili4ar nombres descri&tivos en ma9sculas se&arando
&alabras &or guiones ba!os.
Ejemplo: 0?;CO@A$B@$C < 12
:ara imprimir un 5alor en pantalla' en :thon' se utili4a la &alabra clave &(int*
*i;4a(ia6le < 18
&(int *i;4a(ia6le
"o anterior' im&rimirB el valor de la variable miOvariable en &antalla.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
2;
www.detodoprogramacion.com
3i&os 'e 'atos
%na variable Lo constanteM &uede contener valores de diversos ti&os. Entre ellos*
Cadena de te7to LstringM*
*i;cadena < '/ola 0undo1'
*i;cadena;*ultilinea < '''
C)ta e) una cadena
de 4a(ia) linea)
'''
N9mero entero*
edad < 38
N9mero entero octal*
edad < 043
N9mero entero he7adecimal*
edad < 0#23
N9mero real*
&(ecio < -43828
Booleano Lverdadero + ?alsoM*
4e(dade(o < $(ue
fal)o < Dal)e
E7isten ademBs' otros ti&os de datos mBs com&le!os' @ue veremos mBs adelante.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
2(
www.detodoprogramacion.com
5&eradores Aritm>ticos
Entre los o&eradores aritm>ticos @ue :thon utili4a' &odemos encontrar los siguientes*
Smbolo Significado Ejemplo Resultado
. Au*a a < 10 . 8 a e) 18
2 Ee)ta a < 12 2 - a e) 8
2 @egaciFn a < 28 a e) 28
G 0ulti&licaciFn a < - G 8 a e) 38
GG C#&onente a < 2 GG 3 a e) 8
5 Hi4i)iFn a < 128 5 2 a e) !28
55 Hi4i)iFn ente(a a < 128 5 2 a e) !0
I 0Fdulo a < 2- I 4 a e) 3
PEP ): operadores
#iem&re colocar un es&acio en blanco' antes des&u>s de un
o&erador
6n ejemplo sencillo con 5ariables y operadores aritm2ticos:
*onto;6(uto < 1-8
ta)a;inte(e) < 12
*onto;inte(e) < *onto;6(uto G ta)a;inte(e) 5 100
ta)a;6onificacion < 8
i*&o(te;6onificacion < *onto;6(uto G ta)a;6onificacion 5 100
*onto;neto < (*onto;6(uto 2 i*&o(te;6onificacion) . *onto;inte(e)
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
22
www.detodoprogramacion.com
Comentarios
%n archivo' no solo &uede contener cdigo -uente. =ambi>n &uede incluir comentarios
Lnotas @ue como &rogramadores' indicamos en el cdigo &ara &oder com&renderlo me!orM.
"os comentarios &ueden ser de dos ti&os* de una sola l)nea o multi-l)nea se e7&resan de
la siguiente manera*
# Esto es un comentario de una sola lnea
*i;4a(ia6le < 18
! este es un comentario
de "arias lneas
*i;4a(ia6le < 18
*i;4a(ia6le < 18 # Este comentario es de una lnea tambi#n
En los comentarios' &ueden incluirse &alabras @ue nos auden a identi-icar ademBs' el
subti&o de comentario*
J $%&% e)to e) algo &o( hace(
J '()*E e)to e) algo Kue de6e co((egi()e
J ))) e)to ta*6iLn, e) algo Kue de6e co((egi()e
PEP ): comentarios
Comentarios en la misma l)nea del cdigo deben se&ararse con
dos es&acios en blanco. "uego del s)mbolo W debe ir un solo
es&acio en blanco.
Correcto:
a < 18 J Cdad de 0a(Ma
0ncorrecto:
a < 18 J Cdad de 0a(Ma
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
2
www.detodoprogramacion.com
=i&os de datos com&le!os
:thon' &osee ademBs de los ti&os a vistos' 3 ti&os mBs com&le!os' @ue admiten una
colecci&n de datos. Estos ti&os son*
=u&las
"istas
$iccionarios
Estos tres ti&os' &ueden almacenar colecciones de datos de diversos ti&os se
di-erencian &or su sinta7is &or la -orma en la cual los datos &ueden ser mani&ulados.
3u&"as
%na tu&la es una 5ariable ,ue permite almacenar 5arios datos inmutables Lno &ueden
ser modi-icados una ve4 creadosM de ti&os di-erentes*
*i;tu&la < (Ncadena de te#toN, 18, 28, Not(o datoN, 28)
#e &uede acceder a cada uno de los datos mediante su )ndice corres&ondiente' siendo 0
LceroM' el )ndice del &rimer elemento*
&(int *i;tu&la[1" J Aalida: 18
=ambi>n se &uede acceder a una &orcin de la tu&la' indicando Lo&cionalmenteM desde el
)ndice de inicio hasta el )ndice de -in*
&(int *i;tu&la[1:4" J He4uel4e: (18, 28, Not(o datoN)
&(int *i;tu&la[3:" J He4uel4e: (Not(o datoN, 28)
&(int *i;tu&la[:2" J He4uel4e: (Ncadena de te#toN, 18)
5tra -orma de acceder a la tu&la de -orma inversa Lde atrBs hacia adelanteM' es colocando
un )ndice negativo*
&(int *i;tu&la[21" J Aalida: 28
&(int *i;tu&la[22" J Aalida: ot(o dato
-istas
%na lista es similar a una tu&la con la di-erencia -undamental de @ue &ermite modi-icar los
datos una ve4 creados
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
2%
www.detodoprogramacion.com
*i;li)ta < [Ncadena de te#toN, 18, 28, Not(o datoN, 28"
A las listas se accede igual @ue a las tu&las' &or su n9mero de )ndice*
&(int *i;li)ta[1" J Aalida: 18
&(int *i;li)ta[1:4" J He4uel4e: [18, 28, Not(o datoN"
&(int *i;li)ta[22" J Aalida: ot(o dato
"as lista N5 son inmutables* &ermiten modi-icar los datos una ve4 creados*
*i;li)ta[2" < 38 J el te(ce( ele*ento aho(a e) 38
"as listas' a di-erencia de las tu&las' &ermiten agregar nuevos valores*
*i;li)taa&&end(N@ue4o HatoN)
4iccionarios
Iientras @ue a las listas tu&las se accede solo 9nicamente &or un n9mero de )ndice'
los diccionarios &ermiten utili4ar una clave &ara declarar acceder a un valor*
*i;dicciona(io < ONcla4e;1N: 4alo(;1, Ncla4e;2N: 4alo(;2, P
Ncla4e;-N: 4alo(;-Q
&(int *i;dicciona(io[Ncla4e;2N" J Aalida: 4alo(;2
%n diccionario &ermite eliminar cual@uier entrada*
del(*i;dicciona(io[Ncla4e;2N")
Al igual @ue las listas' el diccionario &ermite modi-icar los valores
*i;dicciona(io[Ncla4e;1N" < N@ue4o =alo(N
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
24
www.detodoprogramacion.com
,structuras de Control de Flu)o
%na estructura de control' es un blo@ue de cdigo @ue &ermite agru&ar instrucciones de
manera controlada. En este ca&)tulo' hablaremos sobre dos estructuras de control*
Estructuras de control condicionales
Estructuras de control iterativas
I'entaci)n
:ara hablar de estructuras de control de -lu!o en :thon' es im&rescindible &rimero' hablar
de identacin.
K9u2 es la identaci&nL En un lengua!e in-ormBtico' la identacin es lo @ue la sangr)a al
lengua!e humano escrito La nivel -ormalM. As) como &ara el lengua!e -ormal' cuando uno
redacta una carta' debe res&etar ciertas sangr)as' los lengua!es in-ormBticos' re@uieren
una identacin.
Co todos los lenguajes de programaci&n+ necesitan de una identaci&n' aun@ue s)' se
estila im&lementarla' a -in de otorgar maor legibilidad al cdigo -uente. :ero en el caso
de Python+ la identaci&n es obligatoria' a @ue de ella' de&enderB su estructura.
PEP ): identaci&n
%na identacin de % "cuatro$ espacios en blanco' indicarB @ue
las instrucciones identadas' -orman &arte de una misma
estructura de control.
%na estructura de control' entonces' se de-ine de la siguiente -orma*
inicio de la e)t(uctu(a de cont(ol+
e#&(e)ione)
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
28
www.detodoprogramacion.com
Enco'ing
El encoding Lo codi-icacinM es otro de los elementos del lengua!e @ue no &uede omitirse
a la hora de hablar de estructuras de control.
El encoding no es mBs @ue una directi5a ,ue se coloca al
inicio de un archi5o Python+ a .in de indicar al sistema+ la
codi.icaci&n de caracteres utiliEada en el archi5o.
J 2G2 coding: utf,- 2G2
ut--A &odr)a ser cual@uier codi-icacin de caracteres. #i no se indica una codi-icacin de
caracteres' :thon &odr)a &roducir un error si encontrara caracteres Ge7traUosH*
&(int 'Cn el RSga(a encont(L un RandT'
:roducirB un error de sinta7is* A%nta#C((o(: @on2BAC?? cha(acte(["
En cambio' indicando el encoding corres&ondiente' el archivo se e!ecutarB con >7ito*
J 2G2 coding: utf28 2G2
&(int 'Cn el RSga(a encont(L un RandT'
:roduciendo la siguiente salida*
Cn el RSga(a encont(L un RandT
Asignaci)n m0"ti&"e
5tra de las venta!as @ue :thon nos &rovee' es la de &oder asignar en una sola
instruccin' m9lti&les variables*
a, 6, c < N)t(ingN, 18, $(ue
En una sola instruccin' estamos declarando tres variables* a' b c asignBndoles un
valor concreto a cada una*
+++ &(int a
)t(ing
+++ &(int 6
18
+++ &(int c
$(ue
"a asignacin m9lti&le de variables' tambi>n &uede darse utili4ando como valores' el
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
2/
www.detodoprogramacion.com
contenido de una tu&la*
+++ mi.tupla / 01hola mundo12 23445
+++ te6to2 anio / mi.tupla
+++ &(int te#to
hola *undo
+++ &(int anio
2011
5 tambi>n' de una lista*
+++ mi.lista / 718rgentina12 19uenos 8ires1:
+++ pais2 pro"incia / mi.lista
+++ &(int &ai)
B(gentina
+++ &(int &(o4incia
Uueno) Bi(e)
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
2)
www.detodoprogramacion.com
Estructuras 'e contro" 'e f"u5o con'iciona"es
[...] Los condicionales nos permiten comprobar condiciones y hacer que
nuestro programa se comporte de una forma u otra, que ejecute un
fragmento de cdigo u otro, dependiendo de esta condicin [...]

Cita tetual del libro !ython para "odos de #a$l %on&'le& (uque
)http*++mundogee,.net+tutorial-python+.
"as estructuras de control condicionales' son a@uellas @ue nos &ermiten evaluar si una o
mBs condiciones se cum&len' &ara decir @u> accin vamos a e!ecutar. :a e5aluaci&n de
condiciones' solo puede arrojar 1 de 2 resultados* 5erdadero o .also L=rue o ?alseM.
En la vida diaria' actuamos de acuerdo a la evaluacin de condiciones' de manera mucho
mBs -recuente de lo @ue en realidad creemos* Si el sem'foro est' en /erde, cru&ar la
calle. Sino, esperar a que el sem'foro se ponga en /erde. A veces' tambi>n evaluamos
mBs de una condicin &ara e!ecutar una determinada accin* 0i llega la factura de la lu& y
tengo dinero, pagar la boleta.
:ara describir la evaluacin a reali4ar sobre una condicin' se utili4an operadores
relacionales Lo de com&aracinM*
%PER8&%RES RE;8<(%=8;ES 0&E <%*P8R8<(>=5
2222222222222222222222222222222222222222222222222222222222
Smbolo Significado Ejemplo Resultado
<< ?gual Kue 8 << - Dal)o
1< Hi)tinto Kue (o3o 1< 4e(de =e(dade(o
V 0eno( Kue 8 V 12 =e(dade(o
+ 0a%o( Kue 12 + - Dal)o
V< 0eno( o igual Kue 12 V< 12 =e(dade(o
+< 0a%o( o igual Kue 4 +< 8 Dal)o
D &ara evaluar mBs de una condicin simultBneamente' se utili4an operadores l&gicos*
%PER8&%RES ;>?(<%S
2222222222222222222222222222222222222222222222222222222222
%perador Ejemplo Resultado@
and (%) 8 << - and - V 12 0 % 0 Dal)o
9 V 12 and 12 + - 1 % 1 =e(dade(o
9 V 12 and 12 + 18 1 % 0 Dal)o
o( (o) 12 << 12 o( 18 V - 1 o 0 =e(dade(o
- + 8 o( 9 V 12 1 o 1 =e(dade(o
#o( 4 << 4 #o( 9 + 3 1 o 1 Dal)o
(o e#clu%ente) 4 << 4 #o( 9 V 3 1 o 0 =e(dade(o
LXM 1 indica resultado verdadero de la condicin' mientras @ue 0' indica -also.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
2'
www.detodoprogramacion.com
"as estructuras de control de -lu!o condicionales' se de-inen mediante el uso de tres
&alabras claves reservadas' del lengua!e* if LsiM' elif Lsino' siM else LsinoM.
<eamos algunos e!em&los*
#i semB-oro esta en verde' cru4ar la calle. #ino' es&erar.
if )e*afo(o << 4e(de:
&(int 'C(u7a( la calle'
el)e:
&(int 'C)&e(a('
#i gasto hasta Y100' &ago con dinero en e-ectivo. #ino' si gasto
mBs de Y100 &ero menos de Y300' &ago con tar!eta de d>bito.
#ino' &ago con tar!eta de cr>dito.
if co*&(a V< 100:
&(int ',ago en efecti4o'
elif co*&(a + 100 and co*&(a V 300:
&(int ',ago con ta(3eta de dL6ito'
el)e:
&(int ',ago con ta(3eta de c(Ldito'
#i la com&ra es maor a Y100' obtengo un descuento del 10Z
i*&o(te;a;&aga( < total;co*&(a
if total;co*&(a + 100:
ta)a;de)cuento < 10
i*&o(te;de)cuento < total;co*&(a G ta)a;de)cuento 5 100
i*&o(te;a;&aga( < total;co*&(a W i*&o(te;de)cuento
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
;
www.detodoprogramacion.com
Estructuras 'e contro" iteratias
A di-erencia de las estructuras de control condicionales' las iterativas Ltambi>n llamadas
c)clicas o buclesM' nos &ermiten e!ecutar un mismo cdigo' de manera re&etida' mientras
se cum&la una condicin.
En :thon se dis&one de dos estructuras c)clicas*
El bucle while
El bucle .or
"as veremos en detalle a continuacin.
Buc"e whi"e
Este bucle' se encarga de e!ecutar una misma accin Gmientras @ueH una determinada
condicin se cum&la*
Iientras @ue aUo sea menor o igual a 2012' im&rimir la -rase
G3n-ormes del AUo a1oH
J 2G2 coding: utf28 2G2
anio < 2001
Ahile anio V< 2012:
&(int '?nfo(*e) del BXo', )t((anio)
anio .< 1
"a iteracin anterior' generarB la siguiente salida*
?nfo(*e) del aXo 2001
?nfo(*e) del aXo 2002
?nfo(*e) del aXo 2003
?nfo(*e) del aXo 2004
?nfo(*e) del aXo 2008
?nfo(*e) del aXo 200!
?nfo(*e) del aXo 200-
?nfo(*e) del aXo 2008
?nfo(*e) del aXo 2009
?nfo(*e) del aXo 2010
?nfo(*e) del aXo 2011
?nfo(*e) del aXo 2012
#i miras la 9ltima l)nea*
anio .< 1
:odrBs notar @ue en cada iteracin' incrementamos el valor de la variable @ue condiciona
el bucle LanioM. #i no lo hici>ramos' esta variable siem&re ser)a igual a 2001 el bucle se
e!ecutar)a de -orma in-inita' a @ue la condicin Lanio V< 2012M siem&re se estar)a
cum&liendo.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(
www.detodoprogramacion.com
:ero ENu> sucede si el valor @ue condiciona la iteracin no es num>rico no &uede
incrementarseF En ese caso' &odremos utili4ar una estructura de control condicional'
anidada dentro del bucle' -renar la e!ecucin cuando el condicional de!e de cum&lirse'
con la &alabra clave reservada brea.*
Yhile $(ue:
no*6(e < (aY;in&ut('?ndiKue )u no*6(e: ')
if no*6(e:
breaB
El bucle anterior' inclue un condicional anidado @ue veri-ica si la variable nombre es
verdadera Lsolo serB verdadera si el usuario ti&ea un te7to en &antalla cuando el nombre
le es solicitadoM. #i es verdadera' el bucle &ara Lbrea.M. #ino' seguirB e!ecutBndose hasta
@ue el usuario' ingrese un te7to en &antalla.
Buc"e for
El bucle -or' en :thon' es a@uel @ue nos &ermitirB iterar sobre una variable com&le!a' del
ti&o lista o tu&la*
:or cada nombre en miOlista' im&rimir nombre
*i;li)ta < [NZuanN, NBntonioN, N,ed(oN, N/e(*inioN"
for no*6(e in *i;li)ta:
&(int no*6(e
:or cada color en miOtu&la' im&rimir color
*i;tu&la < (N(o)aN, N4e(deN, Ncele)teN, Na*a(illoN)
for colo( in *i;tu&la:
&(int colo(
En los e!em&los anteriores' nombre color' son dos variables declaradas en tiem&o de
e!ecucin Les decir' se declaran dinBmicamente durante el bucleM' asumiendo como valor'
el de cada elemento de la lista Lo tu&laM en cada iteracin.
5tra -orma de iterar con el bucle -or' &uede emular a ,hile*
:or cada aUo en el rango 2001 a 2013' im&rimir la -rase
G3n-ormes del AUo a1oH
J 2G2 coding: utf28 2G2
fo( anio in (ange(2001, 2013):
&(int '?nfo(*e) del BXo', )t((anio)
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
2
www.detodoprogramacion.com
Mdulos/
pa0uetes '
namespaces
En :thon' cada uno de nuestros archivos .& se denominan m&dulos. Estos mdulos' a
la ve4' &ueden -ormar &arte de pa,uetes. %n &a@uete' es una car&eta @ue contiene
archivos .&. :ero' &ara @ue una car&eta &ueda ser considerada un &a@uete' debe
contener un archivo de inicio llamado ..init...py. Este archivo' no necesita contener
ninguna instruccin. $e hecho' &uede estar com&letamente vac)o.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0

03
www.detodoprogramacion.com
Creando mdulos empa0uetados
En :thon' cada uno de nuestros archivos .& se denominan m&dulos. Estos mdulos' a
la ve4' &ueden -ormar &arte de pa,uetes. %n &a@uete' es una car&eta @ue contiene
archivos .&. :ero' &ara @ue una car&eta &ueda ser considerada un &a@uete' debe
contener un archivo de inicio llamado ..init...py. Este archivo' no necesita contener
ninguna instruccin. $e hecho' &uede estar com&letamente vac)o.

[\\ paCuete
]\\ __init__.py
]\\ *odulo1&%
]\\ *odulo2&%
[\\ *odulo3&%
"os &a@uetes' a la ve4' tambi>n &ueden contener otros sub-&a@uetes*

[\\ paCuete
]\\ __init__.py
]\\ *odulo1&%
[\\ subpaCuete
]\\ __init__.py
]\\ *odulo1&%
[\\ *odulo2&%
D los mdulos' no necesariamente' deben &ertenecer a un &a@uete*

]\\ modulo4.py
[\\ &aKuete
]\\ __init__.py
]\\ *odulo1&%
[\\ )u6&aKuete
]\\ __init__.py
]\\ *odulo1&%
[\\ *odulo2&%
Im&ortan'o m)'u"os enteros
El contenido de cada mdulo' &odrB ser utili4ado a la ve4' &or otros mdulos. :ara ello' es
necesario importar los m&dulos @ue se @uieran utili4ar. :ara im&ortar un mdulo' se
utili4a la instruccin import' seguida del nombre del &a@uete Lsi a&licaM mBs el nombre
del mdulo Lsin el .&M @ue se desee im&ortar.
J 2G2 coding: utf28 G2G
import *odulo # importar un mdulo que no pertenece a un paquete
import &aKuete*odulo1 # importar un mdulo que est dentro de un paquete
import &aKuete)u6&aKuete*odulo1
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%
www.detodoprogramacion.com
"a instruccin i*&o(t seguida de no*6(e;del;&aKueteno*6(e;del;*odulo, nos
&ermitirB hacer uso de todo el cdigo @ue dicho mdulo contenga.
Python tiene sus propios m&dulos' los cuales -orman &arte de
su librer#a de m&dulos est7ndar' @ue tambi>n &ueden ser
im&ortados.
+ames&aces
:ara acceder Ldesde el mdulo donde se reali4 la im&ortacinM' a cual@uier elemento del
mdulo im&ortado' se reali4a mediante el namespace' seguido de un &unto L.M el
nombre del elemento @ue se desee obtener. En :thon' un names&ace' es el nombre @ue
se ha indicado luego de la &alabra i*&o(t' es decir la ruta Lnames&aceM del mdulo*
&(int modulo.<%=S$8=$E.4
&(int paCuete.modulo4.<%=S$8=$E.4
&(int paCuete.subpaCuete.modulo4.<%=S$8=$E.4
A"ias
Es &osible tambi>n' abreviar los names&aces mediante un GaliasH. :ara ello' durante la
im&ortacin' se asigna la &alabra clave as seguida del alias con el cuBl nos re-eriremos
en el -uturo a ese names&ace im&ortado*
i*&o(t *odulo as *
i*&o(t &aKuete*odulo1 as &*
i*&o(t &aKuete)u6&aKuete*odulo1 as &)*
"uego' &ara acceder a cual@uier elemento de los mdulos im&ortados' el names&ace
utili4ado serB el alias indicado durante la im&ortacin*
&(int m.CO@A$B@$C ;1
&(int pm.CO@A$B@$C ;1
&(int psm.CO@A$B@$C;1
Im&ortar m)'u"os sin uti"i6ar names&aces
En :thon' es &osible tambi>n' im&ortar de un mdulo solo los elementos @ue se desee
utili4ar. :ara ello se utili4a la instruccin f(o* seguida del names&ace' mBs la instruccin
i*&o(t seguida del elemento @ue se desee im&ortar*
from &aKuete*odulo1 import CO@A$B@$C;1
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
4
www.detodoprogramacion.com
En este caso' se accederB directamente al elemento' sin recurrir a su names&ace*
&(int <%=S$8=$E.4
Es &osible tambi>n' im&ortar mBs de un elemento en la misma instruccin. :ara ello' cada
elemento irB se&arado &or una coma L'M un es&acio en blanco*
from &aKuete*odulo1 import CO@A$B@$C;12 CO@A$B@$C;2
:ero qu sucede si los elementos importados desde mdulos diferentes tienen los
mismos nombres? En estos casos' habrB @ue pre5enir .allos+ utiliEando alias para los
elementos*
from &aKuete*odulo1 import CO@A$B@$C;1 as <4, CO@A$B@$C;2 as <2
from &aKuete)u6&aKuete*odulo1 import CO@A$B@$C;1 as <S4, CO@A$B@$C;2 as <S2
&(int C1
&(int C2
&(int CA1
&(int CA2
PEP ): importaci&n
"a im&ortacin de mdulos debe reali4arse al comien4o del
documento' en orden al-ab>tico de &a@uetes mdulos.
:rimero deben im&ortarse los mdulos &ro&ios de :thon.
"uego' los mdulos de terceros -inalmente' los mdulos &ro&ios
de la a&licacin.
Entre cada blo@ue de im&orts' debe de!arse una l)nea en blanco.
$e -orma alternativa L&ero mu &oco recomendadaM' tambi>n es &osible im&ortar todos los
elementos de un mdulo' sin utili4ar su names&ace &ero tam&oco alias. Es decir' @ue
todos los elementos im&ortados se accederB con su nombre original*
f(o* &aKuete*odulo1 import @
&(int CO@A$B@$C;1
&(int CO@A$B@$C;2
M!1D1: Abrir una terminal e iniciar el shell interactivo Lint>r&reteM
de :thon. A continuacin' im&ortar el mdulo thi)*
import this
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
8
www.detodoprogramacion.com
Funciones
de1inidas por el
usuario
%na -uncin' es la -orma de agru&ar e7&resiones sentencias LalgoritmosM @ue realicen
determinadas acciones' &ero @ue >stas' solo se e!ecuten cuando son llamadas. Es decir'
@ue al colocar un algoritmo dentro de una -uncin' al correr el archivo' el algoritmo no serB
e!ecutado si no se ha hecho una re-erencia a la -uncin @ue lo contiene.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/
04
www.detodoprogramacion.com
+e1iniendo 1unciones
En :thon' la de-inicin de -unciones se reali4a mediante la instruccin def mBs un
nombre de -uncin descri&tivo -&ara el cuBl' a&lican las mismas reglas @ue &ara el nombre
de las variables- seguido de &ar>ntesis de a&ertura cierre. Como toda estructura de
control en :thon' la de-inicin de la -uncin -inali4a con dos &untos L*M el algoritmo @ue
la com&one' irB identado con 0 es&acios*
def *i;funcion05+
J aKuM el algo(it*o
%na -uncin' no es e!ecutada hasta tanto no sea invocada. :ara invocar una -uncin'
sim&lemente se la llama &or su nombre*
def *i;funcion():
&(int '/ola 0undo'
funcion05
Cuando una -uncin' haga un retorno de datos' >stos' &ueden ser asignados a una
variable*
def funcion():
return '/ola 0undo'
frase / funcion05
&(int f(a)e
Sobre "os &ar7metros
%n &arBmetro es un valor @ue la -uncin es&era recibir cuando sea llamada LinvocadaM' a
-in de e!ecutar acciones en base al mismo. %na -uncin &uede es&erar uno o mBs
&arBmetros L@ue irBn se&arados &or una comaM o ninguno.
def *i;funcion0nombre2 apellido5:
J algo(it*o
Los parmetros, se indican entre los parntesis, a
modo de variables, a fin de poder utilizarlos como
tales, dentro de la misma funcin.
"os &arBmetros @ue una -uncin es&era' serBn utili4ados &or >sta' dentro de su algoritmo'
a modo de 5ariables de 7mbito local. Es decir' @ue los &arBmetros serBn variables
locales' a las cuBles solo la -uncin &odrB acceder*
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
)
www.detodoprogramacion.com
def *i;funcion(no*6(e, a&ellido):
no*6(e;co*&leto < nombre, apellido
&(int no*6(e;co*&leto
#i @uisi>ramos acceder a esas variables locales' -uera de la -uncin' obtendr)amos un
error*
def *i;funcion(no*6(e, a&ellido):
no*6(e;co*&leto < no*6(e, a&ellido
&(int no*6(e;co*&leto
&(int no*6(e # Retornar el error: NameError: name 'nombre' is not defined
Al llamar a una funcin, siempre se le deben pasar
sus argumentos en el mismo orden en el que los
espera. Pero esto puede evitarse, haciendo uso del
paso de argumentos como keywords (er ms a!a"o#
$Keywords como parmetros%&.
8ar7metros &or omisi)n
En :thon' tambi>n es &osible' asignar valores &or de-ecto a los &arBmetros de las
-unciones. Esto signi-ica' @ue la -uncin &odrB ser llamada con menos argumentos de los
@ue es&era*
def )aluda((no*6(e, mensaje/1Dola1):
&(int *en)a3e, no*6(e
)aluda((N,e&e G(illoN) # Imprime: Hola epe !rillo
PEP ): -unciones
A la de-inicin de una -uncin la deben anteceder dos l)neas en
blanco.
Al asignar &arBmetros &or omisin' no debe de!arse es&acios en
blanco ni antes ni des&u>s del signo V.
9e:wor's como &ar7metros
En :thon' tambi>n es &osible llamar a una -uncin' &asBndole los argumentos
es&erados' como &ares de cla4e)<4alo(*
def )aluda((no*6(e, *en)a3e<N/olaN):
&(int *en)a3e, no*6(e
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
'
www.detodoprogramacion.com
)aluda((mensaje/9uen da2 nombre/Euancho)
8ar7metros arbitrarios
Al igual @ue en otros lengua!es de alto nivel' es &osible @ue una -uncin' es&ere recibir un
n9mero arbitrario -desconocido- de argumentos. Estos argumentos' llegarBn a la -uncin
en -orma de tu&la.
:ara de-inir argumentos arbitrarios en una -uncin' se antecede al &arBmetro un asterisco
LXM*
def (eco((e(;&a(a*et(o);a(6it(a(io)(&a(a*et(o;fi3o, @arbitrarios):
&(int &a(a*et(o;fi3o
# "os parmetros arbitrarios se corren como tuplas
fo( a(gu*ento in a(6it(a(io):
&(int a(gu*ento
(eco((e(;&a(a*et(o);a(6it(a(io)(NDi#edN, 1arbitrario 412 1arbitrario 212
1arbitrario F1)
'i una funcin espera reci!ir parmetros fi"os y
ar!itrarios, los arbitrarios siempre deben suceder a
los fijos.
Es &osible tambi>n' obtener &arBmetros arbitrarios como &ares de claveVvalor. En estos
casos' al nombre del &arBmetro deben &recederlo dos astericos LXXM*
def (eco((e(;&a(a*et(o);a(6it(a(io)(&a(a*et(o;fi3o, Ga(6it(a(io), @@BAords):
&(int &a(a*et(o;fi3o
fo( a(gu*ento in a(6it(a(io):
&(int a(gu*ento
# "os ar#umentos arbitrarios tipo cla$e% se recorren como los diccionarios
fo( cla4e in :Yo(d):
&(int 'Cl 4alo( de', cla4e, 'e)', :Yo(d)[cla4e"
(eco((e(;&a(a*et(o);a(6it(a(io)('Di#ed', 'a(6it(a(io 1', 'a(6it(a(io 2',
'a(6it(a(io 3', cla"e4/"alor uno2
cla"e2/"alor dos)
4esem&a;ueta'o 'e &ar7metros
:uede ocurrir ademBs' una situacin inversa a la anterior. Es decir' @ue la -uncin es&ere
una lista -i!a de &arBmetros' &ero @ue >stos' en ve4 de estar dis&onibles de -orma
se&arada' se encuentren contenidos en una lista o tu&la. En este caso' el signo asterisco
LXM deberB &receder al nombre de la lista o tu&la @ue es &asada como &arBmetro durante
la llamada a la -uncin*
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%;
www.detodoprogramacion.com
def calcula((i*&o(te, de)cuento):
(etu(n i*&o(te 2 (i*&o(te G de)cuento 5 100)
datos / 74G332 43:
&(int calcula((@datos)
El mismo caso &uede darse cuando los valores a ser &asados como &arBmetros a una
-uncin' se encuentren dis&onibles en un diccionario. A@u)' deberBn &asarse a la -uncin'
&recedidos de dos asteriscos LXXM*
def calcula((i*&o(te, de)cuento):
(etu(n i*&o(te 2 (i*&o(te G de)cuento 5 100)
datos / Hdescuento+ 432 importe+ 4G33I
&(int calcula((@@datos)
%lamadas de retorno
En :thon' es &osible Lal igual @ue en la gran maor)a de los lengua!es de &rogramacinM'
llamar a una -uncin dentro de otra' de -orma -i!a de la misma manera @ue se la llamar)a'
desde -uera de dicha -uncin*
def funcion():
(etu(n '/ola 0undo'
def )aluda((no*6(e, *en)a3e<N/olaN):
&(int *en)a3e, no*6(e
&(int mi.funcion05
#in embargo' es &osible @ue se desee realiEar dicha llamada+ de manera din7mica' es
decir' desconociendo el nombre de la .unci&n a la @ue se desearB llamar. A este ti&o de
acciones' se las denomina llamadas de retorno.
:ara conseguir llamar a una -uncin de manera dinBmica' :thon dis&one de dos
-unciones nativas* locals05 globals05
Ambas -unciones' retornan un diccionario. En el caso de local)()' >ste diccionario se
com&one -!ustamente- de todos los elementos de Bmbito local' mientras @ue el de
glo6al)()' retorna lo &ro&io &ero a nivel global.
def funcion():
(etu(n '/ola 0undo'
def lla*ada;de;(eto(no(func<''):
"""Llamada de retorno a nivel global"""
(etu(n globals057func:05
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%(
www.detodoprogramacion.com
&(int lla*ada;de;(eto(no(funcion)
# Llamada de retorno a nivel local
nombre.de.la.funcion / funcion
&(int locals057nombre.de.la.funcion:05
#i se tienen @ue &asar argumentos en una llamada retorno' se lo &uede hacer
normalmente*
def funcion(nombre):
(etu(n '/ola ' . no*6(e
def lla*ada;de;(eto(no(func<''):
'''^la*ada de (eto(no a ni4el glo6al'''
(etu(n glo6al)()[func"0;aura5
&(int lla*ada;de;(eto(no('funcion')
J ^la*ada de (eto(no a ni4el local
no*6(e;de;la;funcion < 'funcion'
&(int local)()[no*6(e;de;la;funcion"0'acundo5
Saber si una funci)n e.iste : &ue'e ser ""ama'a
$urante una llamada de retorno' el nombre de la -uncin' &uede no ser el indicado.
Entonces' siem&re @ue se deba reali4ar una llamada de retorno' es necesario com&robar
@ue >sta e7ista &ueda ser llamada.
if nombre.de.la.funcion in local)():
if callable0locals057nombre.de.la.funcion:5:
&(int local)()[no*6(e;de;la;funcion"('C*il)e')
El o&erador in' nos &ermitirB conocer si un elemento se encuentra dentro de una
coleccin' mientras @ue la -uncin calla6le() nos de!arB saber si esa -uncin &uede
ser llamada.
def funcion(no*6(e):
(etu(n '/ola ' . no*6(e
def lla*ada;de;(eto(no(func<''):
if func in glo6al)():
if calla6le(glo6al)()[func"):
(etu(n glo6al)()[func"('^au(a')
el)e:
(etu(n 'DunciFn no encont(ada'
&(int lla*ada;de;(eto(no('funcion')
no*6(e;de;la;funcion < 'funcion'
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%2
www.detodoprogramacion.com
if no*6(e;de;la;funcion in local)():
if calla6le(local)()[no*6(e;de;la;funcion"):
&(int local)()[no*6(e;de;la;funcion"('Dacundo')
el)e:
&(int 'DunciFn no encont(ada'
%lamadas recursias
3e denomina llamada recursi5a "o recursi5idad$+ a a,uellas .unciones ,ue en su
algoritmo+ hacen re.erencia s# misma.
"as llamadas recursivas suelen ser mu 9tiles en casos mu &untuales' &ero debido a su
gran -actibilidad de caer en iteraciones in-initas' deben e7tremarse las medidas
&reventivas adecuadas ' solo utili4arse cuando sea estrictamente necesario no e7ista
una -orma alternativa viable' @ue resuelva el &roblema evitando la recursividad.
:thon admite las llamadas recursivas' &ermitiendo a una -uncin' llamarse a s) misma'
de igual -orma @ue lo hace cuando llama a otra -uncin.
def 3uga((intento<1):
(e)&ue)ta < (aY;in&ut('_He KuL colo( e) una na(an3a` ')
if (e)&ue)ta 1< 'na(an3a':
if intento V 3:
&(int 'PnDalla)te1 ?ntLntalo de nue4o'
intento .< 1
jugar0intento5 # "lamada recursi$a
el)e:
&(int 'Pn,e(di)te1'
el)e:
&(int 'PnGana)te1'
3uga(()
Sobre la 1inalidad de las 1unciones
%na -uncin' &uede tener cual@uier ti&o de algoritmo cual@uier cantidad de ellos '
utili4ar cual@uiera de las caracter)sticas vistas hasta ahora. No obstante ello' una buena
pr7ctica+ indica ,ue la .inalidad de una .unci&n+ debe ser realiEar una Nnica acci&n+
reutiliEable y por lo tanto+ tan gen2rica como sea posible.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%
www.detodoprogramacion.com
Introduccin a la
Orientacin a
Ob)etos
En :thon todo es un Gob!etoH debe ser mani&ulado - entendido- como tal. :ero ENu>
es un ob!etoF E$e @u> hablamos cuando nos re-erimos a Gorientacin a ob!etosF En este
ca&)tulo' haremos una introduccin @ue res&onderB a estas - muchas otras- &reguntas.
Nos en-ocaremos &rimero' en cuestiones de conce&tos bBsicos' &ara luego' ir
introduci>ndonos de a &oco' en &rinci&ios tericos elementalmente necesarios' &ara
im&lementar la orientacin a ob!etos en la &rBctica.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%%
05
www.detodoprogramacion.com
Pensar en ob)etos
:ensar en ob!etos' &uede resultar -al inicio- una tarea di-)cil. #in embargo' di-)cil no
signi-ica com&le!o. :or el contrario' &ensar en ob!etos re&resenta la maor sim&licidad @ue
uno &odr)a es&erar del mundo de la &rogramacin. Pensar en objetos+ es simple...
aun@ue lo sim&le' no necesariamente signi-i@ue sencillo.
< =;u> es un ob5eto?
:ues' como di!e antes' es Gsim&leH. 5lvidemos los -ormalismos' la in-ormBtica todo lo
@ue nos rodea. #im&lemente' olvida todo conc>ntrate en lo @ue sigue. "o e7&licar> de
manera Gsim&leH*
6n objeto es Ouna cosaP. D' si una cosa es un sustantivo' entonces un objeto es un
sustanti5o.
Iira a tu alrededor encontrarBs decenas' cientos de ob!etos. =u ordenador' es un ob!eto.
=9' eres un ob!eto. =u llave es un ob!eto. El cenicero Lese @ue tienes -rente a ti cargado de
colillas de cigarrilloM' es otro ob!eto. =u mascota tambi>n es un ob!eto.
(uando pensamos en $o!"etos%, todos los sustantivos
son objetos.
#encillo EciertoF Entonces' de ahora en mBs' solo conc>ntrate en &ensar la vida en
ob!etos Lal menos' hasta terminar de leer este documentoM.
Ahora =;u> me 'ices si 'escribimos "as cua"i'a'es 'e un
ob5eto?
$escribir un ob!eto' es sim&lemente mencionar sus cualidades. :as cualidades son
adjeti5os. #i no sabes @ue es un ad!etivo' estamos !odidos L muchoM. :ero' &odemos
decir @ue un adjeti5o es una cualidad del sustanti5o.
Entonces' &ara describir Gla manera de serH de un ob!eto' debemos &reguntarnos Kc&mo
es el objetoL =oda res&uesta @ue comience &or Gel ob!eto esH' seguida de un ad!etivo'
serB una cualidad del ob!eto.
Algunos e!em&los*
El objeto es verde
El objeto es grande
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%4
www.detodoprogramacion.com
El objeto es -eo
Ahora' imagina @ue te encuentras -rente a un niUo de 2 aUos LniUo* ob!eto @ue &regunta
cosas @ue t9 das &or entendidas de -orma im&l)citaM. D cada ve4 @ue le dices las
cualidades de un ob!eto al molesto niUo-ob!eto' >ste te &regunta* -HENu> es...FH' seguido
del ad!etivo con el cuBl -inali4aste tu -rase. Entonces' tu le res&ondes diciendo Ges un+unaH
seguido de un sustantivo. =e lo muestro con un e!em&lo*
El ob!eto es verde. K9u2 es verdeF %n color.
El ob!eto es grande. K9u2 es grandeF %n tamaUo.
El ob!eto es -eo. K9u2 es -eoF %n as&ecto.
Estos sustantivos @ue res&onden a la &regunta del niUo' &ueden &asar a -ormar &arte de
una locuci&n adjeti5a @ue es&eci-i@ue con maor &recisin' las descri&ciones anteriores*
El ob!eto es de color verde.
El ob!eto es de tamao grande.
El ob!eto es de aspecto -eo.
:odemos decir entonces - todo esto' gracias al molesto niUo-ob!eto-' @ue una cualidad'
es un atributo Lderivado de Gcualidad atribuible a un ob!etoHM @ue entonces' un objeto es
un sustanti5o ,ue posee atributos+ cuyas cualidades lo describen.
<eBmoslo mBs grB-icamente*
1BQE!1
"sustanti5o$
<!G0B6!1
"locuci&n adjeti5a$
C6<:0D<D DE: <!G0B6!1
"adjeti5o$
LelM 5b!eto
Les deM color <erde
Les deM tamaUo 6rande
Les deM as&ecto ?eo
8ero a"gunos ob5etos, tambi>n se com&onen 'e otros
ob5etos...
AdemBs de cualidades Llocucin ad!etiva seguida de un ad!etivoM' los objetos Otienen
otras cosasP. Estas Gotras cosasH' son a@uellas G&seudo-cualidadesH @ue en ve4 de
res&onder a Ecmo es el ob!etoF res&onden a OKc&mo est7 compuesto el objetoLP o
incluso' a9n mBs sim&le OK9u2 tiene el objetoLP.
"a res&uesta a esta &regunta' estarB dada &or la -rase Gel ob!eto tiene...H' seguida de un
adverbio de cantidad Luno' varios' muchos' algunos' unas cuantasM un sustantivo.
Algunos e!em&los*
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%8
www.detodoprogramacion.com
El ob!eto tiene algunas antenas
El ob!eto tiene un o!o
El ob!eto tiene unos cuantos &elos
"os com&onentes de un ob!eto' tambi>n integran los atributos de ese ob!eto. #olo @ue
estos atributos' son algo &articulares* son otros objetos ,ue poseen sus propias
cualidades. Es decir' @ue estos Gatributos-ob!etoH tambi>n res&onderBn a la &regunta
GECmo es+son ese+esos+esasFH seguido del atributo-ob!eto LsustantivoM.
Am&liemos el e!em&lo &ara @ue se entienda me!or*
El ob!eto tiene algunas antenas. ECmo son esas antenasF
"as antenas son de color violeta
"as antenas son de longitud e7tensa
El ob!eto tiene un o!o. ECmo es ese o!oF
El o!o es de -orma oval
El o!o es de color a4ul
El o!o es de tamaUo grande
El ob!eto tiene unos cuantos &elos. ECmo son esos &elosF
"os &elos son de color -ucsia
"os &elos son de te7tura rugosa
:ongBmoslo mBs grB-ico*
1BQE!1
"sustanti5o$
<!G0B6!1>1BQE!1
"sustanti5o$
<!G0B6!13
"locuci&n adjeti5a$
C6<:0D<DE3 DE :13
<!G0B6!13
"adjeti5o$
LelM 5b!eto
Ltiene algunasM antenas
LdeM color
LdeM longitud
<ioleta
e7tensa
Ltiene unM o!o
LdeM -orma
LdeM color
LdeM tamaUo
5val
a4ul
grande
Ltiene unos cuantosM &elos
LdeM color
LdeM te7tura
?ucsia
rugosa
Entonces' &odemos deducir @ue un objeto puede tener dos tipos de atributos*
1M "os @ue res&onden a la &regunta Cmo es el obeto?! con la -rase El obeto
es"""! S ad!etivo Latributos de-inidos &or cualidadesM
2M "os @ue res&onden a la &regunta #u tiene el obeto?! con la -rase El obeto
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%/
www.detodoprogramacion.com
tiene"""! S sustantivo Latributos de-inidos &or las cualidades de otro ob!etoM
<eBmoslo a9n' mBs grB-icamente*
<iendo el grB-ico anterior' tenemos lo siguiente* 2n obeto )sustanti/o. al cual hemos
descrito con tres atributos )adjeti/os. y otros tres atributos$obeto )sustanti/os. los
cu'les son a la /e&, otros tres objetos )sustanti/os. con sus atributos )adjeti/os.
correspondientes. 30imple, no4 5hora, compliquemos todo un poco.
< tambi>n ha: ob5etos ;ue com&arten caracter@sticas con
otros ob5etos
#esulta ser, que nuestro 6bjeto, es pr'cticamente igual a un nue/o objeto. 7s decir, que
el nue/o objeto que estamos /iendo, tiene absolutamente todas las caracter8sticas que
nuestro primer objeto, es decir, tiene los mismos atributos. !ero tambi9n, tiene algunas
m's. !or ejemplo, este nue%o obeto, adem's de los atributos de nuestro primer objeto,
tiene un pie. 7s decir, que las caracter8sticas de nuestro nue/o objeto, ser'n todas las
del objeto original, m's una nue/a* pie.
#epasemos las caracter8sticas de nuestro nue/o objeto*
El nuevo ob!eto es de color verde.
El nuevo ob!eto es de tamaUo grande.
El nuevo ob!eto es de as&ecto -eo.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%)
Objeto
color tamao aspecto antenas ojos pelos
Antena
color longitud
Pelo
textura color
color forma tamao
Ojo
www.detodoprogramacion.com
El nuevo ob!eto tiene algunas antenas. ECmo son esas antenasF
"as antenas son de color violeta
"as antenas son de longitud e7tensa
El nuevo ob!eto tiene un o!o. ECmo es ese o!oF
El o!o es de -orma oval
El o!o es de color a4ul
El o!o es de tamaUo grande
El nuevo ob!eto tiene unos cuantos &elos. ECmo son esos &elosF
"os &elos son de color -ucsia
"os &elos son de te7tura rugosa
"nue5as caracter#sticas$
El nuevo ob!eto tiene un &ie. ECmo es ese &ieF
El &ie es de -orma rectangular
El &ie es de color amarillo
El &ie tiene 3 dedos. ECmo son esos dedosF
"os dedos son de longitud mediana
"os dedos son de -orma alargada
"os dedos son de color amarillo
<eamos todas las caracter)sticas de este nuevo' en un grB-ico como lo hicimos antes.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
%'
www.detodoprogramacion.com
Con mucha -acilidad' &odemos observar como nuestro nuevo ob!eto es una es&ecie de
Gob!eto original am&liadoH. Es decir @ue el nuevo ob!eto' es e7actamente igual al ob!eto
original Lcom&arte todos sus atributosM &ero &osee nuevas caracter)sticas.
EstB claro ademBs' @ue el ob!eto original el nuevo ob!eto' son dos ob!etos di-erentes
EciertoF No obstante' el nue5o objeto es un sub>tipo del objeto original.
Ahora s)' a com&licarnos a9n mBs.
-os ob5etos, tambi>n tienen "a ca&aci'a' 'e Ahacer cosasB
Da describimos las cualidades de nuestros ob!etos. :ero de lo @ue no hemos hablado' es
de a@uellas cosas @ue los ob!etos G&ueden hacerH' es decir' GcuBles son sus ca&acidadesH.
"os ob!etos tiene la ca&acidad de reali4ar acciones. "as acciones' son verbos. Es decir'
@ue &ara conocer las ca&acidades de un ob!eto' debes &reguntarte OK9u2 puede hacer
el objetoLP la res&uesta a esta &regunta' estarB dada &or todas a@uellas @ue
comiencen &or la -rase Gel ob!eto &uedeH seguida de un verbo en in-initivo.
Algunos e!em&los*
El ob!eto original puede -lotar
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
4;
forma color dedos
Dedo
longitud forma color
Nuevo Objeto
Pie
Pie
Objeto
color tamao aspecto antenas ojos pelos
Antena
color longitud
Pelo
textura color
color forma tamao
Ojo
www.detodoprogramacion.com
El nuevo ob!eto LademBsM puede saltar
#i com&letamos el grB-ico anterior con las acciones' obtendremos lo siguiente*
#i observas el grB-ico anterior' notarBs @ue el nuevo ob!eto' no solo tiene los mismos
atributos @ue el ob!eto original' sino @ue ademBs' tambi>n &uede reali4ar las mismas
acciones @ue >ste. #encillo' ciertoF
Ahora s)' com&li@u>monos del todo *M
1b5etos : m7s ob5etosC "a &arte 'if@ci"
#i entendiste todo lo anterior' ahora viene la &arte di-)cil. E<iste @ue esto de G&ensando en
ob!etosH viene a colacin de la &rogramacin orientada a ob!etosF Bueno' la &arte di-)cil es
@ue en la &rogramacin' todo lo @ue acabamos de ver' se denomina de una -orma
&articular. :ero' la e7&licacin es la misma @ue te di antes.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
4(
forma color dedos
Dedo
longitud forma color
Nuevo Objeto
Pie
Pie
Objeto
color tamao aspecto antenas ojos pelos
Antena
color longitud
Pelo
textura color
color forma tamao
Ojo
Flotar
Saltar
www.detodoprogramacion.com
A" &an, &an. < a" ino, ino. -as cosas &or su nombre
Cuando en el documento...
En la programaci&n
se denomina...
R con respecto a la programaci&n
orientada a objetos es...
Jablamos de Gob!etoH 1bjeto %n elemento
Jablamos de GatributosH Lo cualidadesM Propiedades %n elemento
Jablamos de GaccionesH @ue &uede reali4ar
el ob!eto
*2todos %n elemento
Jablamos de Gatributos-ob!etoH Composici&n %na t>cnica
<emos @ue los ob!etos relacionados entre
s)' tienen nombres de atributos iguales L&or
e!em&lo* color tamaUoM sin embargo'
&ueden tener valores di-erentes
Polimor.ismo %na caracter)stica
Jablamos de ob!etos @ue son sub-ti&os Lo
am&liacinM de otros
?erencia %na caracter)stica
Ahora' &asemos a un marco un &oco mBs Gacad>micoH.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
42
www.detodoprogramacion.com
Programacin Orientada a Ob)etos
"a :rogramacin 5rientada a 5b!etos L:55 u 55: &or sus siglas en ingl>sM' es un
paradigma de programaci&n.
Paradigma: teora cuyo ncleo central )...*
suministra la base y modelo para resolver problemas
)...* +efinicin de la ,eal Academia -spa.ola,
igsimo tercera edicin
Cmo tal' nos enseUa un m>todo -&robado estudiado- el cual se basa en las
interacciones de ob!etos Ltodo lo descrito en el t)tulo anterior' G:ensar en ob!etosHM &ara
resolver las necesidades de un sistema in-ormBtico.
BBsicamente' este &aradigma se com&one de 2 elementos / caracter)sticas @ue
veremos a continuacin.
E"ementos : Caracter@sticas 'e "a 811
"os elementos de la :55' &ueden entenderse como los materiales! @ue necesitamos
&ara diseUar &rogramar un sistema' mientras @ue las caracter#sticas' &odr)an asumirse
como las herramientas! de las cuBles dis&onemos &ara construir el sistema con esos
materiales.
Entre los elementos principales de la :55' &odremos encontrar a*
C"ases
"as clases son los modelos sobre los cuBles se construirBn nuestros ob!etos. :odemos
tomar como e!em&lo de clases' el grB-ico @ue hicimos en la &Bgina A de este documento.
En :thon' una clase se de-ine con la instruccin cla)) seguida de un nombre gen>rico
&ara el ob!eto.
class O63eto:
&a))
class Bntena:
&a))
class ,elo:
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
4
www.detodoprogramacion.com
&a))
cla)) O3o:
&a))
PEP ): clases
El nombre de las clases se de-ine en singular' utili4ando
CamelCase.
8ro&ie'a'es
"as &ro&iedades' como hemos visto antes' son las caracter)sticas intr)nsecas del ob!eto.
[stas' se re&resentan a modo de variables' solo @ue t>cnicamente' &asan a denominarse
G&ro&iedadesH*
cla)) Bntena():
colo( < ''
longitud < ''
cla)) ,elo():
colo( < ''
te#tu(a < ''
cla)) O3o():
fo(*a < ''
colo( < ''
ta*anio < ''
cla)) O63eto():
colo( < ''
ta*anio < ''
a)&ecto < ''
antena) < Bntena() J &(o&iedad co*&ue)ta &o( el o63eto o63eto Bntena
o3o) < O3o() J &(o&iedad co*&ue)ta &o( el o63eto o63eto O3o
&elo) < ,elo() J &(o&iedad co*&ue)ta &o( el o63eto o63eto ,elo
PEP ): propiedades
"as &ro&iedades se de-inen de la misma -orma @ue las variables
La&lican las mismas reglas de estiloM.
D>to'os
"os m>todos son G-uncionesH Lcomo las @ue vimos en el ca&)tulo anteriorM' solo @ue
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
4%
www.detodoprogramacion.com
t>cnicamente se denominan m>todos' re&resentan acciones &ro&ias @ue &uede reali4ar
el ob!eto L no otroM*
cla)) O63eto():
colo( < '4e(de'
ta*anio < 'g(ande'
a)&ecto < 'feo'
antena) < Bntena()
o3o) < O3o()
&elo) < ,elo()
def flota((self):
&a))
/otar 0ue el primer parmetro de un mtodo, siempre
de!e ser )elf.
1b5eto
"as clases &or s) mismas' no son mBs @ue modelos @ue nos servirBn &ara crear ob!etos
en concreto. :odemos decir @ue una clase' es el ra4onamiento abstracto de un ob!eto'
mientras @ue el ob!eto' es su materiali4acin. A la accin de crear ob!etos' se la denomina
Ginstanciar una claseH dicha instancia' consiste en asignar la clase' como valor a una
variable*
cla)) O63eto():
colo( < '4e(de'
ta*anio < 'g(ande'
a)&ecto < 'feo'
antena) < Bntena()
o3o) < O3o()
&elo) < ,elo()
def flota(()elf):
&(int 12
et / %bjeto05
&(int etcolo(
&(int etta*anio
&(int eta)&ecto
etcolo( < '(o)a'
&(int etcolo(
EerenciaC caracter@stica &rinci&a" 'e "a 811
Como comentamos en el t)tulo anterior' algunos ob!etos com&arten las mismas
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
44
www.detodoprogramacion.com
&ro&iedades m>todos @ue otro ob!eto' ademBs agregan nuevas &ro&iedades
m>todos. A esto se lo denomina herencia* una clase @ue hereda de otra. <ale aclarar' @ue
en :thon' cuando una clase no hereda de ninguna otra+ debe hacerse heredar de
object' @ue es la clase &rinci&al de :thon' @ue de-ine un ob!eto.
cla)) Bntena(o63ect):
colo( < ''
longitud < ''
cla)) ,elo(o63ect):
colo( < ''
te#tu(a < ''
cla)) O3o(o63ect):
fo(*a < ''
colo( < ''
ta*anio < ''
cla)) O63eto(o63ect):
colo( < ''
ta*anio < ''
a)&ecto < ''
antena) < Bntena()
o3o) < O3o()
&elo) < ,elo()
def flota(()elf):
&a))
cla)) Hedo(o63ect):
longitud < ''
fo(*a < ''
colo( < ''
cla)) ,ie(o63ect):
fo(*a < ''
colo( < ''
dedo) < Hedo()
# Nue$o&b'eto s( )ereda de otra clase: &b'eto
cla)) @ue4oO63eto(O63eto):
&ie < ,ie()

def )alta(()elf):
&a))
Acce'ien'o a "os m>to'os : &ro&ie'a'es 'e un ob5eto
%na ve4 creado un ob!eto' es decir' una ve4 hecha la instancia de clase' es &osible
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
48
www.detodoprogramacion.com
acceder a su m>todos &ro&iedades. :ara ello' :thon utili4a una sinta7is mu sim&le* el
nombre del ob!eto' seguido de &unto la &ro&iedad o m>todo al cuBl se desea acceder*
o63eto < 0iCla)e()
&(int o63eto&(o&iedad
o63etoot(a;&(o&iedad < '@ue4o 4alo('
4a(ia6le < o63eto*etodo()
&(int 4a(ia6le
&(int o63etoot(o;*etodo()
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
4/
www.detodoprogramacion.com
M2todos
principales del
Ob)eto String
Como comentamos en el ca&)tulo anterior' en :thon' todo es un ob!eto &or tanto'
cual@uier variable cuo valor sea de ti&o string' &odrB ser tratada como un subti&o del
ob!eto string' el cuBl dis&one de m>todos @ue son heredados &or dicho subti&o.
En este ca&)tulo' veremos los m>todos mBs -recuentes del ob!eto string.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
4)
06
www.detodoprogramacion.com
M2todos de 1ormato
Conertir a ma'3scula la primera letra
*2todo: ca&itali4eLM
Getorna: una co&ia de la cadena con la &rimera letra en ma9sculas
+++ cadena < '6ien4enido a *i a&licaciFn'
+++ &(int cadenacapitaliJe05
Uien4enido a *i a&licaciFn
Conertir una cadena a min3sculas
*2todo: lo,erLM
Getorna: una co&ia de la cadena en min9sculas
+++ cadena < '/ola 0undo'
+++ &(int cadenaloAer05
hola *undo
Conertir una cadena a ma'3sculas
*2todo: u&&erLM
Getorna: una co&ia de la cadena en ma9sculas
+++ cadena < '/ola 0undo'
+++ &(int cadenaupper05
/O^B 0a@HO
Conertir ma'3sculas a min3sculas ' iceersa
*2todo: s,a&caseLM
Getorna: una co&ia de la cadena convertidas las ma9sculas en min9sculas viceversa
+++ cadena < '/ola 0undo'
+++ &(int cadenasAapcase05
hO^B *a@HO
Conertir una cadena en Formato Ttulo
*2todo: titleLM
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
4'
www.detodoprogramacion.com
Getorna: una co&ia de la cadena convertida
+++ cadena < 'hola *undo'
+++ &(int cadenatitle05
/ola 0undo
Centrar un te&to
*2todo: centerLlongitud\' Gcaracter de rellenoH]M
Getorna: una co&ia de la cadena centrada
+++ cadena < '6ien4enido a *i a&licaciFn'ca&itali7e()
+++ &(int cadenacenter0G32 /5
<<<<<<<<<<<Uien4enido a *i a&licaciFn<<<<<<<<<<<<
+++ &(int cadenacenter0G32 5
Uien4enido a *i a&licaciFn
4linear te&to a la i.0uierda
*2todo: l!ustLlongitud\' Gcaracter de rellenoH]M
Getorna: una co&ia de la cadena alineada a la i4@uierda
+++ cadena < '6ien4enido a *i a&licaciFn'ca&itali7e()
+++ &(int cadenaljust0G32 /5
Uien4enido a *i a&licaciFn<<<<<<<<<<<<<<<<<<<<<<<
4linear te&to a la derec(a
*2todo: r!ustLlongitud\' Gcaracter de rellenoH]M
Getorna: una co&ia de la cadena alineada a la derecha
+++ cadena < '6ien4enido a *i a&licaciFn'ca&itali7e()
+++ &(int cadenarjust0G32 /5
<<<<<<<<<<<<<<<<<<<<<<<Uien4enido a *i a&licaciFn
+++ &(int cadenarjust0G32 5
Uien4enido a *i a&licaciFn
5ellenar un te&to anteponiendo ceros
*2todo: 4-illLlongitudM
Getorna: una co&ia de la cadena rellena con ceros a la i4@uierda hasta alcan4ar la
longitud -inal indicada
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
8;
www.detodoprogramacion.com
+++ nu*e(o;factu(a < 18-8
+++ &(int )t((nu*e(o;factu(a)Jfill0425
0000000018-8
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
8(
www.detodoprogramacion.com
M2todos de -3s0ueda
Contar cantidad de apariciones de una subcadena
*2todo: countLGsubcadenaH\' &osicionOinicio' &osicionO-in]M
Getorna: un entero re&resentando la cantidad de a&ariciones de subcadena dentro de
cadena
+++ cadena < '6ien4enido a *i a&licaciFn'ca&itali7e()
+++ &(int cadenacount0a5
3
-uscar una subcadena dentro de una cadena
*2todo: -indLGsubcadenaH\' &osicionOinicio' &osicionO-in]M
Getorna: un entero re&resentando la &osicin donde inicia la subcadena dentro de
cadena. #i no la encuentra' retorna -1
+++ cadena < '6ien4enido a *i a&licaciFn'ca&itali7e()
+++ &(int cadenafind0mi5
13
+++ &(int cadenafind0mi2 32 435
21
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
82
www.detodoprogramacion.com
M2todos de 6alidacin
Saber si una cadena comien.a con una subcadena determinada
*2todo: starts,ithLGsubcadenaH\' &osicionOinicio' &osicionO-in]M
Getorna: =rue o ?alse
+++ cadena < '6ien4enido a *i a&licaciFn'ca&itali7e()
+++ &(int cadenastartsAith09ien"enido5
$(ue
+++ &(int cadenastartsAith0aplicaciKn5
Dal)e
+++ &(int cadenastartsAith0aplicaciKn2 4L5
$(ue
Saber si una cadena 1inali.a con una subcadena determinada
*2todo: ends,ithLGsubcadenaH\' &osicionOinicio' &osicionO-in]M
Getorna: =rue o ?alse
+++ cadena < '6ien4enido a *i a&licaciFn'ca&itali7e()
+++ &(int cadenaendsAith0aplicaciKn5
$(ue
+++ &(int cadenaendsAith09ien"enido5
Dal)e
+++ &(int cadenaendsAith09ien"enido2 32 435
$(ue
Saber si una cadena es al1anum2rica
*2todo: isalnumLM
Getorna: =rue o ?alse
+++ cadena < '&e&eg(illo -8'
+++ &(int cadenaisalnum05
Dal)e
+++ cadena < '&e&eg(illo'
+++ &(int cadenaisalnum05
$(ue
+++ cadena < '&e&eg(illo-8'
+++ &(int cadenaisalnum05
$(ue
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
8
www.detodoprogramacion.com
Saber si una cadena es al1ab2tica
*2todo: isal&haLM
Getorna: =rue o ?alse
+++ cadena < '&e&eg(illo -8'
+++ &(int cadenaisalpha05
Dal)e
+++ cadena < '&e&eg(illo'
+++ &(int cadenaisalpha05
$(ue
+++ cadena < '&e&eg(illo-8'
+++ &(int cadenaisalpha05
Dal)e
Saber si una cadena es num2rica
*2todo: isdigitLM
Getorna: =rue o ?alse
+++ cadena < '&e&eg(illo -8'
+++ &(int cadenaisdigit05
Dal)e
+++ cadena < '-884'
+++ &(int cadenaisdigit05
$(ue
+++ cadena < '-8 84'
+++ &(int cadenaisdigit05
Dal)e
+++ cadena < '-884'
+++ &(int cadenaisdigit05
Dal)e
Saber si una cadena contiene solo min3sculas
*2todo: islo,erLM
Getorna: =rue o ?alse
+++ cadena < '&e&e g(illo'
+++ &(int cadenaisloAer05
$(ue
+++ cadena < ',e&e G(illo'
+++ &(int cadenaisloAer05
Dal)e
+++ cadena < ',e&eg(illo'
+++ &(int cadenaisloAer05
Dal)e
+++ cadena < '&e&eg(illo-8'
+++ &(int cadenaisloAer05
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
8%
www.detodoprogramacion.com
$(ue
Saber si una cadena contiene solo ma'3sculas
*2todo: isu&&erLM
Getorna: =rue o ?alse
+++ cadena < ',C,C GE?^^O'
+++ &(int cadenaisupper05
$(ue
+++ cadena < ',e&e G(illo'
+++ &(int cadenaisupper05
Dal)e
+++ cadena < ',e&eg(illo'
+++ &(int cadenaisupper05
Dal)e
+++ cadena < ',C,CGE?^^O'
+++ &(int cadenaisupper05
$(ue
Saber si una cadena contiene solo espacios en blanco
*2todo: iss&aceLM
Getorna: =rue o ?alse
+++ cadena < '&e&e g(illo'
+++ &(int cadenaisspace05
Dal)e
+++ cadena < ' '
+++ &(int cadenaisspace05
$(ue
Saber si una cadena tiene Formato +e Ttulo
*2todo: istitleLM
Getorna: =rue o ?alse
+++ cadena < ',e&e G(illo'
+++ &(int cadenaistitle05
$(ue
+++ cadena < ',e&e g(illo'
+++ &(int cadenaistitle05
Dal)e
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
84
www.detodoprogramacion.com
M2todos de Sustitucin
+ar 1ormato a una cadena/ sustitu'endo te&to din7micamente
*2todo: -ormatLXargs' XX.,argsM
Getorna: la cadena -ormateada
+++ cadena < '6ien4enido a *i a&licaciFn O0Q'
+++ &(int cadenaformat0en Python5
6ien4enido a *i a&licaciFn en ,%thon
+++ cadena < '?*&o(te 6(uto: $O0Q . ?=B: $O1Q < ?*&o(te neto: O2Q'
+++ &(int cadenaformat04332 242 4245
?*&o(te 6(uto: $100 . ?=B: $21 < ?*&o(te neto: 121
+++ cadena < '?*&o(te 6(uto: $O6(utoQ . ?=B: $Oi4aQ < ?*&o(te neto: OnetoQ'
+++ &(int cadenaformat0bruto/4332 i"a/242 neto/4245
?*&o(te 6(uto: $100 . ?=B: $21 < ?*&o(te neto: 121
+++ &(int cadenaformat0bruto/4332 i"a/433 @ 24 M 4332 neto/433 @ 24 M 433 + 4335
?*&o(te 6(uto: $100 . ?=B: $21 < ?*&o(te neto: 121
5eempla.ar te&to en una cadena
*2todo: re&laceLGsubcadena a buscarH' Gsubcadena &or la cual reem&la4arHM
Getorna: la cadena reem&la4ada
+++ 6u)ca( < 'no*6(e a&ellido'
+++ (ee*&la7a(;&o( < 'Zuan ,L(e7'
+++ &(int 'C)ti*ado A( no*6(e a&ellido:'replace0buscar2 reemplaJar.por5
C)ti*ado A( Zuan ,L(e7:
,liminar caracteres a la i.0uierda ' derec(a de una cadena
*2todo: stri&L\GcaracterH]M
Getorna: la cadena sustituida
+++ cadena < ' YYYeugenia6ahitco* '
+++ &(int cadenastrip05
YYYeugenia6ahitco*
+++ &(int cadenastrip01 15
YYYeugenia6ahitco*
,liminar caracteres a la i.0uierda de una cadena
*2todo: lstri&L\GcaracterH]M
Getorna: la cadena sustituida
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
88
www.detodoprogramacion.com
+++ cadena < 'YYYeugenia6ahitco*'
+++ &(int cadenalstrip0A. 5
eugenia6ahitco*
+++ cadena < ' YYYeugenia6ahitco*'
+++ &(int cadenalstrip05
YYYeugenia6ahitco*
,liminar caracteres a la derec(a de una cadena
*2todo: rstri&L\GcaracterH]M
Getorna: la cadena sustituida
+++ cadena < 'YYYeugenia6ahitco* '
+++ &(int cadenarstrip0 5
YYYeugenia6ahitco*
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
8/
www.detodoprogramacion.com
M2todos de unin ' diisin
#nir una cadena de 1orma iteratia
*2todo: !oinLiterableM
Getorna: la cadena unida con el iterable Lla cadena es se&arada &or cada uno de los
elementos del iterableM
+++ fo(*ato;nu*e(o;factu(a < ('@b 000020', '20000 (?H: ', ')')
+++ nu*e(o < '2-8'
+++ nu*e(o;factu(a < nu*e(ojoin0formato.numero.factura5
+++ &(int nu*e(o;factu(a
@b 0000202-820000 (?H: 2-8)
Partir una cadena en tres partes/ utili.ando un separador
*2todo: &artitionLGse&aradorHM
Getorna: una tu&la de tres elementos donde el &rimero es el contenido de la cadena
&revio al se&arador' el segundo' el se&arador mismo el tercero' el contenido de la
cadena &osterior al se&arador
+++ tu&la < 'htt&:55YYYeugenia6ahitco*'partition0AAA.5
+++ &(int tu&la
(Nhtt&:55N, NYYYN, Neugenia6ahitco*N)
+++ &(otocolo, )e&a(ado(, do*inio < tu&la
++++ &(int ',(otocolo: O0QPnHo*inio: O1Q'fo(*at(&(otocolo, do*inio)
,(otocolo: htt&:55
Ho*inio: eugenia6ahitco*
Partir una cadena en arias partes/ utili.ando un separador
*2todo: s&litLGse&aradorHM
Getorna: una lista con todos elementos encontrados al dividir la cadena &or un se&arador
+++ :e%Yo(d) < '&%thon, guia, cu()o, tuto(ial'split02 5
+++ &(int :e%Yo(d)
[N&%thonN, NguiaN, Ncu()oN, Ntuto(ialN"
Partir una cadena en en lneas
*2todo: s&litlinesLM
Getorna: una lista donde cada elemento es una -raccin de la cadena divida en l)neas
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
8)
www.detodoprogramacion.com
+++ te#to < '''^inea 1
^inea 2
^inea 3
^inea 4
'''
+++ &(int te#tosplitlines05
[N^inea 1N, N^inea 2N, N^inea 3N, N^inea 4N"
+++ te#to < '^inea 1Pn^inea 2Pn^inea 3'
+++ &(int te#tosplitlines05
[N^inea 1N, N^inea 2N, N^inea 3N"
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
8'
www.detodoprogramacion.com
,)ercicio
E5ercicio +F1
Crear un m&dulo para 5alidaci&n de nombres de usuarios. $icho mdulo' deberB
cum&lir con los siguientes criterios de aceptaci&n*
El nombre de usuario debe contener un m)nimo de 2 caracteres un mB7imo de 12
El nombre de usuario debe ser al-anum>rico
Nombre de usuario con menos de 2 caracteres' retorna el mensa!e GEl nombre de
usuario debe contener al menos 2 caracteresH
Nombre de usuario con mBs de 12 caracteres' retorna el mensa!e GEl nombre de
usuario no &uede contener mBs de 12 caracteresH
Nombre de usuario con caracteres distintos a los al-anum>ricos' retorna el mensa!e
GEl nombre de usuario &uede contener solo letras n9merosH
Nombre de usuario vBlido' retorna =rue
E5ercicio +F2
Crear un m&dulo para 5alidaci&n de contraseSas. $icho mdulo' deberB cum&lir con
los siguientes criterios de aceptaci&n*
"a contraseUa debe contener un m)nimo de A caracteres
%na contraseUa debe contener letras min9sculas' ma9sculas' n9meros al menos
1 carBcter no al-anum>rico
"a contraseUa no &uede contener es&acios en blanco
ContraseUa vBlida' retorna =rue
ContraseUa no vBlida' retorna el mensa!e G"a contraseUa elegida no es seguraH
E5ercicio +F$
Crear un mdulo @ue solicite al usuario el ingreso de un nombre de usuario contraseUa
@ue los valide utili4ando los mdulos generados en los dos e!ercicios anteriores.
<yuda: &ara contar la cantidad de caracteres de una cadena' en :thon se utili4a la
-uncin incor&orada* len(cadena)
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/;
www.detodoprogramacion.com
M2todos
principales del
ob)eto list
En este ca&)tulo' veremos los m>todos @ue &osee el ob!eto lista. Algunos de ellos'
tambi>n se encuentran dis&onibles &ara las tuplas.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/(
07
www.detodoprogramacion.com
M2todos de agregado
4gregar un elemento al 1inal de la lista
*2todo: a&&endLGnuevo elementoHM
+++ no*6(e);*a)culino) < ['Bl4a(o', 'Zacinto', '0iguel', 'Cdga(do', 'Ha4id'"
+++ no*6(e);*a)culino)append0Eose5
+++ &(int no*6(e);*a)culino)
[NBl4a(oN, NHa4idN, NCdga(doN, NZacintoN, NZo)eN, NEic:%N, NZo)eN"
4gregar arios elementos al 1inal de la lista
*2todo: e7tendLotraOlistaM
+++ no*6(e);*a)culino)e6tend07Eose2 ?erardo:5
+++ &(int no*6(e);*a)culino)
[NBl4a(oN, NHa4idN, NCdga(doN, NZacintoN, NZo)eN, NEic:%N, NZo)eN, NZo)eN,
NGe(a(doN"
4gregar un elemento en una posicin determinada
*2todo: insertL&osicin' Gnuevo elementoHM
+++ no*6(e);*a)culino)insert032 RicBy5
+++ &(int no*6(e);*a)culino)
[NEic:%N, NBl4a(oN, NHa4idN, NCdga(doN, NZacintoN, NZo)eN, NEic:%N, NZo)eN,
NZo)eN, NGe(a(doN"
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/2
www.detodoprogramacion.com
M2todos de eliminacin
,liminar el 3ltimo elemento de la lista
*2todo: &o&LM
Getorna: el elemento eliminado
+++ no*6(e);*a)culino)pop05
NGe(a(doN
+++ &(int no*6(e);*a)culino)
[NEic:%N, NBl4a(oN, NHa4idN, NCdga(doN, NZacintoN, NZo)eN, NEic:%N, NZo)eN,
NZo)eN"
,liminar un elemento por su ndice
*2todo: &o&L)ndiceM
Getorna: el elemento eliminado
+++ no*6(e);*a)culino)pop0F5
NCdga(doN
+++ &(int no*6(e);*a)culino)
[NEic:%N, NBl4a(oN, NHa4idN, NZacintoN, NZo)eN, NEic:%N, NZo)eN, NZo)eN"
,liminar un elemento por su alor
*2todo: removeLGvalorHM
+++ no*6(e);*a)culino)remo"e0Eose5
+++ &(int no*6(e);*a)culino)
[NEic:%N, NBl4a(oN, NHa4idN, NZacintoN, NEic:%N, NZo)eN, NZo)eN"
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/
www.detodoprogramacion.com
M2todos de orden
Ordenar una lista en reersa (inertir orden)
*2todo: reverseLM
+++ no*6(e);*a)culino)re"erse05
+++ &(int no*6(e);*a)culino)
[NZo)eN, NZo)eN, NEic:%N, NZacintoN, NHa4idN, NBl4a(oN, NEic:%N"
Ordenar una lista en 1orma ascendente
*2todo: sortLM
+++ no*6(e);*a)culino)sort05
+++ &(int no*6(e);*a)culino)
[NBl4a(oN, NHa4idN, NZacintoN, NZo)eN, NZo)eN, NEic:%N, NEic:%N"
Ordenar una lista en 1orma descendente
*2todo: sortLreverseV=rueM
+++ no*6(e);*a)culino)sort0re"erse/$rue5
+++ &(int no*6(e);*a)culino)
[NEic:%N, NEic:%N, NZo)eN, NZo)eN, NZacintoN, NHa4idN, NBl4a(oN"
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/%
www.detodoprogramacion.com
M2todos de b3s0ueda
Contar cantidad de apariciones elementos
*2todo: countLelementoM
+++ no*6(e);*a)culino) < ['Bl4a(o', '0iguel', 'Cdga(do', 'Ha4id', '0iguel'"
+++ no*6(e);*a)culino)count0*iguel5
2
+++ no*6(e);*a)culino) < ('Bl4a(o', '0iguel', 'Cdga(do', 'Ha4id', '0iguel')
+++ no*6(e);*a)culino)count0*iguel5
2
Obtener n3mero de ndice
*2todo: inde7Lelemento\' indiceOinicio' indiceO-in]M
+++ no*6(e);*a)culino)inde60*iguel5
1
+++ no*6(e);*a)culino)inde60*iguel2 22 G5
4
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/4
www.detodoprogramacion.com
4ne&o sobre listas ' tuplas
Conersi)n 'e ti&os
En el con!unto de las -unciones integradas de :thon' &odemos encontrar dos -unciones
@ue nos &ermiten convertir listas en tu&las viceversa.
Estas -unciones &ueden ser mu 9tiles cuando &or e!em&lo' una variable declarada como
tu&la' necesita ser modi-icada en tiem&o de e!ecucin' &ara lo cual' debe convertirse en
una lista &uesto @ue las tu&las' son inmutables. "o mismo sucede en el caso contrario*
una variable @ue haa sido declarada como lista sea necesario convertirla en una
coleccin inmutable.
+++ tu&la < (1, 2, 3, 4)
+++ tu&la
(1, 2, 3, 4)
+++ list0tupla5
[1, 2, 3, 4"
+++ li)ta < [1, 2, 3, 4"
+++ li)ta
[1, 2, 3, 4"
+++ tuple0lista5
(1, 2, 3, 4)
Concatenaci)n sim&"e 'e co"ecciones
A di-erencia de otros lengua!es' en :thon es mu sim&le unir varias colecciones de un
mismo ti&o. #im&lemente' se re@uiere utili4ar el o&erador suma LSM &ara lograrlo*
+++ li)ta1 < [1, 2, 3, 4"
+++ li)ta2 < [3, 4, 8, !, -, 8"
+++ listaF / lista4 + lista2
+++ li)ta3
[1, 2, 3, 4, 3, 4, 8, !, -, 8"
+++ tu&la1 < (1, 2, 3, 4, 8)
+++ tu&la2 < (4, !, 8, 10)
+++ tu&la3 < (3, 8, -, 9)
+++ tuplaN / tupla4 + tupla2 + tuplaF
+++ tu&la4
(1, 2, 3, 4, 8, 4, !, 8, 10, 3, 8, -, 9)
2a"or m7.imo : m@nimo
:odemos obtener ademBs' el valor mB7imo m)nimo tanto de listas como de tu&las*
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/8
www.detodoprogramacion.com
+++ ma60tuplaN5
10
+++ *a#(tu&la1)
8
+++ min0tupla45
1
+++ *a#(li)ta3)
8
+++ *in(li)ta1)
1
Contar e"ementos
Al igual @ue &ara contar caracteres en una string' dis&onemos de la -uncin integrada
len() &ara conocer la cantidad de elementos en una lista o en una tu&la*
+++ len0listaF5
10
+++ len(li)ta1)
4
+++ len(tu&la2)
4
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
//
www.detodoprogramacion.com
M2todos
principales del
ob)eto dict
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/)
08
www.detodoprogramacion.com
M2todos de eliminacin
6aciar un diccionario
*2todo: clearLM
+++ dicciona(io < O'colo(': '4ioleta', 'talle': 'cA', '&(ecio': 1-428Q
+++ &(int dicciona(io
ONcolo(N: N4ioletaN, N&(ecioN: 1-428, NtalleN: NcANQ
+++ dicciona(io.clear05
+++ &(int dicciona(io
OQ
M2todos de agregado ' creacin
Copiar un diccionario
*2todo: co&LM
+++ dicciona(io < O'colo(': '4ioleta', 'talle': 'cA', '&(ecio': 1-428Q
+++ (e*e(a < dicciona(io.copy05
+++ dicciona(io
ONcolo(N: N4ioletaN, N&(ecioN: 1-428, NtalleN: NcANQ
+++ (e*e(a
ONcolo(N: N4ioletaN, N&(ecioN: 1-428, NtalleN: NcANQ
+++ dicciona(ioclea(()
+++ dicciona(io
OQ
+++ (e*e(a
ONcolo(N: N4ioletaN, N&(ecioN: 1-428, NtalleN: NcANQ
+++ *u)culo)a < (e*e(a
+++ (e*e(a
ONcolo(N: N4ioletaN, N&(ecioN: 1-428, NtalleN: NcANQ
+++ *u)culo)a
ONcolo(N: N4ioletaN, N&(ecioN: 1-428, NtalleN: NcANQ
+++ (e*e(aclea(()
+++ (e*e(a
OQ
+++ *u)culo)a
OQ
+++
Crear un nueo 'iccionario 'es'e "as c"aes 'e una
secuencia
*2todo: dict.-rom.esLsecuencia\' valor &or de-ecto]M
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
/'
www.detodoprogramacion.com
+++ )ecuencia < ['colo(', 'talle', '*a(ca'"
+++ dicciona(io1 < dict.fromBeys0secuencia5
+++ dicciona(io1
ONcolo(N: @one, N*a(caN: @one, NtalleN: @oneQ
+++ dicciona(io2 < dict.fromBeys0secuencia2 1"alor 6 defecto15
+++ dicciona(io2
ONcolo(N: N4alo( # defectoN, N*a(caN: N4alo( # defectoN, NtalleN: N4alo( #
defectoNQ
Concatenar 'iccionarios
I>todo* u&dateLdiccionarioM
+++ dicciona(io1 < O'colo(': '4e(de', '&(ecio': 48Q
+++ dicciona(io2 < O'talle': '0', '*a(ca': '^aco)te'Q
+++ dicciona(io1.update0diccionario25
+++ dicciona(io1
ONcolo(N: N4e(deN, N&(ecioN: 48, N*a(caN: N^aco)teN, NtalleN: N0NQ
Estab"ecer una c"ae : a"or &or 'efecto
*2todo: setde-aultLGclaveH\' None^valorO&orOde-ecto]M
'i la clae no e1iste, la crea con el alor por defecto.
'iempre retorna el alor para la clae pasada como
parmetro.
+++ (e*e(a < O'colo(': '(o)a', '*a(ca': 'da(a'Q
+++ cla4e < (e*e(asetdefault0talle2 O5
+++ cla4e
NaN
+++ (e*e(a
ONcolo(N: N(o)aN, N*a(caN: Nda(aN, NtalleN: NaNQ
+++ (e*e(a2 < (e*e(aco&%()
+++ (e*e(a2
ONcolo(N: N(o)aN, N*a(caN: Nda(aN, NtalleN: NaNQ
+++ cla4e < (e*e(a2setdefault0estampado5
+++ cla4e
+++ (e*e(a2
ONcolo(N: N(o)aN, Ne)ta*&adoN: @one, N*a(caN: Nda(aN, NtalleN: NaNQ
+++ cla4e < (e*e(a2setdefault0marca2 ;acoste5
+++ cla4e
Nda(aN
+++ (e*e(a2
ONcolo(N: N(o)aN, Ne)ta*&adoN: @one, N*a(caN: Nda(aN, NtalleN: NaNQ
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
);
www.detodoprogramacion.com
M2todos de retorno
1btener e" a"or 'e una c"ae
*2todo: getLclave\' Gvalor 7 de-ecto si la clave no e7isteH]M
+++ (e*e(aget0color5
N(o)aN
+++ (e*e(aget0stocB5
+++ (e*e(aget0stocB2 sin stocB5
N)in )toc:N
Saber si una c"ae e.iste en e" 'iccionario
*2todo: hasO.eLclaveM
+++ e#i)te < (e*e(ahas.Bey0precio5
+++ e#i)te
Dal)e
+++ e#i)te < (e*e(ahas.Bey0color5
+++ e#i)te
$(ue
1btener "as c"aes : a"ores 'e un 'iccionario
*2todo: iteritemsLM <lias: itemsLM
dicciona(io < ONcolo(N: N(o)aN, N*a(caN: Nda(aN, NtalleN: NaNQ
fo( cla"e2 "alor in diccionario.iteritems05:
&(int 'Cl 4alo( de la cla4e I) e) I)' I (cla4e, 4alo()
0alida*
Cl 4alo( de la cla4e colo( e) (o)a
Cl 4alo( de la cla4e *a(ca e) da(a
Cl 4alo( de la cla4e talle e) a
1btener "as c"aes 'e un 'iccionario
*2todo: .esLM
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
)(
www.detodoprogramacion.com
+++ dicciona(io < ONcolo(N: N(o)aN, N*a(caN: Nda(aN, NtalleN: NaNQ
+++ cla4e) < dicciona(io.Beys05
+++ cla4e)
[Ncolo(N, N*a(caN, NtalleN"
1btener "os a"ores 'e un 'iccionario
*2todo: valuesLM
+++ dicciona(io < ONcolo(N: N(o)aN, N*a(caN: Nda(aN, NtalleN: NaNQ
+++ 4alo(e) < dicciona(io."alues05
+++ 4alo(e)
[N(o)aN, Nda(aN, NaN"
1btener "a canti'a' 'e e"ementos 'e un 'iccionario
:ara contar los elementos de un diccionario' al igual @ue con las listas tu&las' se utili4a
la -uncin integrada len()
+++ dicciona(io < ONcolo(N: N(o)aN, N*a(caN: Nda(aN, NtalleN: NaNQ
+++ len0diccionario5
3
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
)2
www.detodoprogramacion.com
,l ob)eto File8
traba)ando con
arc(ios
:thon nos &ermite traba!ar en dos niveles di-erentes con res&ecto al sistema de archivos
directorios. %no de ellos' es a trav>s del mdulo os' @ue como su nombre lo indica' nos
-acilita el traba!o con todo el sistema de archivos directorios' a nivel del &ro&ios #istema
5&erativo. El segundo nivel -mBs sim&le-' es el @ue nos &ermite traba!ar con archivos'
mani&ulando su lectura escritura a nivel de la a&licacin tratando a cada archivo como
un ob!eto.
En talleres anteriores' hemos utili4ado el ob!eto -ile m>todos como (ead()'
(eadline)() clo)e(). En este ca&)tulo' nos en-ocaremos en este segundo nivel de
traba!o' con el -in de conocer al ob!eto ?ile en maor &ro-undidad.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
)
09
www.detodoprogramacion.com
Sobre el ob)eto File
Al igual @ue sucede con otras variables' mani&ular una de ellas como un ob!eto ?ile' es
&osible' cuando a >sta' se le asigna como valor un archivo.
Para asignar a una 5ariable un 5alor de tipo .ile' solo es necesario recurrir a la -uncin
integrada open05' la cuBl estB destinada a la a&ertura de un archivo.
:a .unci&n integrada open05' recibe dos par7metros*
El &rimero de ellos' es la ruta hacia el archi5o @ue se desea abrir
D el segundo' el modo en el cual abrirlo
Do'os 'e A&ertura
El modo de apertura de un archi5o' estB relacionado con el ob!etivo -inal @ue res&onde
a la &regunta para qu estamos abriendo este archi%o?!. "as res&uestas a esta
&regunta &ueden ser varias. :or e!em&lo' &odemos @uerer abrir un archivo &ara leerlo'
&ara escribirlo' &ara leerlo escribirlo' &ara crearlo si no e7iste luego escribir en >l' etc.
Es necesario saber' @ue cada 5eE ,ue abrimos un archi5o estamos creando un
OpunteroP' el cu7l se posicionar7 dentro del archi5o en un lugar determinado Lal
comien4o o al -inalM este puntero podr7 mo5erse dentro de ese archivo' eligiendo su
nueva &osicin' mediante el nNmero de byte corres&ondiente.
Este &untero' se crearB -en inicio- de&endiendo del modo de a&ertura indicado' el cuBl
serB indicado a la -uncin o&en() como una string en su segundo &arBmetro. Entre los
modos de apertura posibles' &odemos encontrar los siguientes*
0ndicador *odo de apertura 6bicaci&n del puntero
r
#olo lectura Al inicio del archivo
rb
#olo lectura en modo binario Al inicio del archivo
r+
"ectura escritura Al inicio del archivo
rb+
"ectura escritura en modo binario Al inicio del archivo
A
#olo escritura.
#obreescribe el archivo si e7iste.
Crea el archivo si no e7iste.
Al inicio del archivo
Ab
#olo escritura en modo binario.
#obreescribe el archivo si e7iste.
Crea el archivo si no e7iste.
Al inicio del archivo
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
)%
www.detodoprogramacion.com
A+
Escritura lectura.
#obreescribe el archivo si e7iste.
Crea el archivo si no e7iste.
Al inicio del archivo
Ab+
Escritura lectura en modo binario.
#obreescribe el archivo si e7iste.
Crea el archivo si no e7iste.
Al inicio del archivo
a
AUadido Lagregar contenidoM.
Crea el archivo si >ste no e7iste.
#i el archivo e7iste' al -inal de >ste.
#i el archivo no e7iste' al comien4o.
ab
AUadido en modo binario Lagregar contenidoM.
Crea el archivo si >ste no e7iste.
#i el archivo e7iste' al -inal de >ste.
#i el archivo no e7iste' al comien4o.
a+
AUadido Lagregar contenidoM lectura.
Crea el archivo si >ste no e7iste.
#i el archivo e7iste' al -inal de >ste.
#i el archivo no e7iste' al comien4o.
ab+
AUadido Lagregar contenidoM lectura en modo
binario.
Crea el archivo si >ste no e7iste.
#i el archivo e7iste' al -inal de >ste.
#i el archivo no e7iste' al comien4o.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
)4
www.detodoprogramacion.com
M2todos del Ob)eto File
El ob!eto -ile' entre sus m>todos mBs -recuentes' dis&one de los siguientes*
*2todo Descripci&n 6so
seeB0byte5
Iueve el &untero hacia el
bte indicado
a(chi4o < o&en('(e*e(a)t#t', '(')
contenido < a(chi4o(ead()
J el &unte(o Kueda
J al final del docu*ento
archi"o.seeB035
read07bytes:5
"ee todo el contenido de un
archivo.
#i se le &asa la longitud de
btes' leerB solo el contenido
hasta la longitud indicada.
a(chi4o < o&en('(e*e(a)t#t', '(')
contenido < archi"o.read05
&(int contenido
readline07bytes:5
"ee una l)nea del archivo.
a(chi4o < o&en('(e*e(a)t#t', '(')
linea1 < archi"o.readline05
&(int linea1
readlines05
"ee todas las l)neas de un
archivo
a(chi4o < o&en('(e*e(a)t#t', '(')
fo( linea in archi"o.readlines05:
&(int linea
tell05
(etorna la &osicin actual del
&untero
a(chi4o < o&en('(e*e(a)t#t', '(')
linea1 < a(chi4o(eadline()
*a) < a(chi4o(ead(archi"o.tell05 G 2)
if archi"o.tell05 + 80:
a(chi4o)ee:(80)
Arite0cadena5
Escribe cadena dentro del
archivo
a(chi4o < o&en('(e*e(a)t#t', '(.')
contenido < a(chi4o(ead()
final;de;a(chi4o < a(chi4otell()
archi"o.Arite01=ue"a linea15
a(chi4o)ee:(final;de;a(chi4o)
nue4o;contenido < a(chi4o(ead()
&(int nue4o;contenido
J @ue4a linea
Aritelines0secuencia5
#ecuencia serB cual@uier
iterable cuos elementos
serBn escritos uno &or l)nea
a(chi4o < o&en('(e*e(a)t#t', '(.')
contenido < a(chi4o(ead()
final;de;a(chi4o < a(chi4otell()
lista / 71;nea 4Pn12 1;nea 21:
archi"o.Aritelines0lista5
a(chi4o)ee:(final;de;a(chi4o)
&(int a(chi4o(eadline()
J ^Mnea 1
&(int a(chi4o(eadline()
J ^Mnea 2
close05
Cierra un archivo
a(chi4o < o&en('(e*e(a)t#t', '(')
contenido < a(chi4o(ead()
archi"o.close05
&(int contenido
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
)8
www.detodoprogramacion.com
Propiedades del ob)eto 1ile
#e &ueden acceder a las siguientes &ro&iedades del ob!eto -ile*
closed* retorna verdadero si el archivo se ha cerrado. $e lo contrario' -also.
mode* retorna el modo de a&ertura.
name* retorna el nombre del archivo
encoding* retorna la codi-icacin de caracteres de un archivo de te7to
+++ a(chi4o < o&en('(e*e(a)t#t', '(.')
+++ contenido < a(chi4o(ead()
+++ no*6(e < archi"o.name
+++ *odo < archi"o.mode
QQQ encoding < archi"o.encoding
+++ a(chi4oclo)e()
+++ if archi"o.closed:
&(int 'Cl a(chi4o )e ha ce((ado co((ecta*ente'
el)e:
&(int 'Cl a(chi4o &e(*anece a6ie(to'

Cl a(chi4o )e ha ce((ado co((ecta*ente
+++ no*6(e
N(e*e(a)t#tN
+++ *odo
N(.N
+++ encoding
@one
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
)/
www.detodoprogramacion.com
Cerrando arc(ios de 1orma autom7tica
$esde la versin 2.;' :thon incor&ora una manera GeleganteH de traba!ar con archivos de
-orma tal' @ue se cierren de -orma automBtica sin necesidad de invocar al m>todo
clo)e(). #e trata de un blo@ue Aith*
Aith o&en('(e*e(a)t#t', '(') as a(chi4o:
contenido < a(chi4o(ead()
&(int a(chi4oclo)ed
# *rue
Cuando una estructura Yith -inali4a' :thon' automBticamente invoca al m>todo
clo)e()' como se &uede ver en el valor de la &ro&iedad clo)ed
Como tambi>n se de!a ver en el e!em&lo' la sentencia Yith utili4a un alias &ara el ob!eto
-ile' lo @ue &ermite acceder al ob!eto -ile' !ustamente' &or el alias indicado.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
))
www.detodoprogramacion.com
#n Paseo por los
Mdulos de la
librera est7ndar
:thon nos &rovee de un gran abanico de mdulos @ue integran su librer)a estBndar' como bien
&uede verse en el manual o-icial* htt&*++docs.&thon.org+modinde7.html. En este ca&)tulo' veremos
algunos de ellos @ue se destacan a sea &or la -recuencia de uso como &or sus &restaciones.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
)'
10
www.detodoprogramacion.com
Mdulos de sistema
Entre los mdulos de sistema @ue :thon nos &rovee a trav>s de su librer)a estBndar'
&odemos destacar tres* os' sys' subprocess Jaremos una breve reseUa de cada
uno de ellos' a continuacin.
D)'u"o os
El mdulo os nos &ermite acceder a -uncionalidades de&endientes del #istema 5&erativo.
#obre todo' a@uellas @ue nos re-ieren in-ormacin sobre el entorno del mismo nos
&ermiten mani&ular la estructura de directorios L&ara leer escribir archivos' ver ca&)tulo
1M. Ge.erencia o.icial: htt&*++docs.&thon.org+librar+os.html
Archios : 'irectorios
El mdulo os nos &rovee de varios m>todos &ara traba!ar de -orma &ortable con las
-uncionalidades del sistema o&erativo. <eremos a continuacin' los m>todos mBs
destacados de este mdulo.
Descripci&n *2todo
#aber si se &uede acceder a un archivo o directorio
o)access(&ath, *odo;de;acce)o)
Conocer el directorio actual
o)getcAd()
Cambiar de directorio de traba!o
o)chdir(nue4o;&ath)
Cambiar al directorio de traba!o ra)4
o)chroot()
Cambiar los &ermisos de un archivo o directorio
o)chmod(&ath, &e(*i)o))
Cambiar el &ro&ietario de un archivo o directorio
o)choAn(&ath, &e(*i)o))
Crear un directorio
o)mBdir(&ath[, *odo")
Crear directorios recursivamente
o)mBdirs(&ath[, *odo")
Eliminar un archivo
o)remo"e(&ath)
Eliminar un directorio
o)rmdir(&ath)
Eliminar directorios recursivamente
o)remo"edirs(&ath)
(enombrar un archivo
o)rename(actual, nue4o)
Crear un enlace simblico
o)symlinB(&ath, no*6(e;de)tino)
Para ver al mdulo os trabajando con
funcionalidades del sistema de archios y directorios,
e"ecutar python os.e6amples de la carpeta
)ou(ce) de este cap2tulo.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
';
www.detodoprogramacion.com
E" m)'u"o os : "as ariab"es 'e entorno
El mdulo os tambi>n nos &rovee de un diccionario con las variables de entorno relativas
al sistema. #e trata del diccionario en4i(on*
i*&o(t o)
fo( 4a(ia6le, 4alo( in os.en"ironite(ite*)():
&(int 'I): I)' I (4a(ia6le, 4alo()
os.&ath
El mdulo o) tambi>n nos &rovee del submdulo &ath Los.pathM el cual nos &ermite
acceder a ciertas -uncionalidades relacionadas con los nombres de las rutas de archivos
directorios. Entre ellas' las mBs destacadas se describen en la siguiente tabla*
Descripci&n *2todo
(uta absoluta
o)path.abspath(&ath)
$irectorio base
o)path.basename(&ath)
#aber si un directorio e7iste
o)path.e6ists(&ath)
Conocer 9ltimo acceso a un directorio
o)path.getatime(&ath)
Conocer tamaUo del directorio
o)path.getsiJe(&ath)
#aber si una ruta es*
2na ruta absoluta
o)path.isabs(&ath)
2n archi/o
o)path.isfile(&ath)
2n directorio
o)path.isdir(&ath)
2n enlace simblico
o)path.islinB(&ath)
2n punto de montaje
o)path.ismount(&ath)
Para conocer ms so!re os.path, isitar la
documentacin oficial en
http#33docs.python.org3li!rary3os.path.html
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
'(
www.detodoprogramacion.com
D)'u"o s:s
El mdulo )%) es el encargado de &roveer variables -uncionalidades' directamente
relacionadas con el int>r&rete.
2ariab"es 'e" m)'u"o s:s
Entre las variables mBs destacadas &odemos encontrar las siguientes*
Iariable Descripci&n
sys.arg"
(etorna una lista con todos los argumentos &asados &or l)nea de comandos.
Al e!ecutar*
&%thon *odulo&% a(g1 a(g2
)%)a(g retornarB una lista*
[N*odulo&%N, Na(g1N, Na(g2N"
sys.e6ecutable
(etorna el &ath absoluto del binario e!ecutable del int>r&rete de :thon
sys.ma6int
(etorna el n9mero &ositivo entero maor' so&ortado &or :thon
sys.platform
(etorna la &lata-orma sobre la cuBl se estB e!ecutando el int>r&rete
sys."ersion
(etorna el n9mero de versin de :thon con in-ormacin adicional
D>to'os 'e" m)'u"o s:s
Entre los m>todos mBs destacados del mdulo )%)' &odemos encontrar los siguientes*
*2todo Descripci&n
sys.e6it05
?or4ar la salida del int>r&rete
sys.getdefaultencoding05
(etorna la codi-icacin de caracteres &or de-ecto
Sys.getfilesystemencoding05
(etorna la codi-icacin de caracteres @ue se utili4a &ara
convertir los nombres de archivos unicode en nombres
de archivos del sistema
Sys.getsiJeof0o63ect[, default"5
(etorna el tamaUo del ob!eto &asado como &arBmetro.
El segundo argumento Lo&cionalM es retornado cuando
el ob!eto no devuelve nada.
4s informacin so!re el mdulo sys, puede
o!tenerse en http#33docs.python.org3li!rary3sys.html
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
'2
www.detodoprogramacion.com
D)'u"o sub&rocess
El mdulo )u6&(oce)) es a@uel @ue nos &ermite traba!ar de -orma directa con rdenes
del sistema o&erativo.
-l mdulo subprocess se presenta en este cap2tulo
solo con fines educatios, mostrando e"emplos !sicos
y sencillos. Por lo tanto, se recomienda tener mucho
cuidado en el uso de este mdulo desaconsejando su
uso para rdenes que puedan comprometer el
sistema!
Entre los m>todos mBs comunes de )u6&(oce))' &odemos encontrar
)u6&(oce)).call05. Este m>todo' suele ser 9til' &ara e!ecutar rdenes sencillas'
como &or e!em&lo' limpiar la pantalla*
f(o* )u6&(oce)) i*&o(t call
call01clear15
El m>todo call' es&erarB recibir como &rimer argumento' el comando a ser e!ecutado'
como se mostr en el e!em&lo anterior. #in embargo' si el comando re@uiere argumentos'
como &rimer &arBmetro' call necesitarB recibir una lista donde el &rimer elemento serB el
comando el segundo' sus argumentos. %n e!em&lo de ello' es el siguiente cdigo
encargado de hacer un listado de archi5os y directorios*
f(o* )u6&(oce)) i*&o(t call
co*ando;%;a(gu*ento) < 71ls12 1,lha1:
call(co*ando;%;a(gu*ento))
El mdulo )u6&(oce)) tambi>n nos &rovee del submdulo Popen' el cuBl nos &ermite'
no solo e!ecutar rdenes al igual @ue call' sino mantener un me!or control sobre las
salidas.
Ca&turan'o "a sa"i'a con 8o&en
El mane!o ca&tura de las salidas' &uede resultar un &oco com&le!o. :or eso'
intentaremos e7&licarlo &aso a &aso a -in de evitar con-usiones.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
'
www.detodoprogramacion.com
"o &rimero @ue debemos tener en cuenta' es @ue ,o&en Lal igual @ue callM' como &rimer
argumento' recibirB el comando a ser e!ecutado o una lista de dos elementos' donde el
&rimero sea el comando el segundo' la lista de argumentos. Jasta a@u)' no ha
di-erencia con call #in embargo' si la salida del &roceso abierto con :o&en no es
tratada' el &roceso @uedarB abierto.
:or e!em&lo' el siguiente c&digo ,uedar#a en ejecuci&n*
f(o* )u6&(oce)) i*&o(t ,o&en
,o&en([Nl)N, N2lhaN"
A di-erencia de call' :o&en no es un m>todo de )u6&(oce))' sino' un ob!eto. Cmo tal'
la -orma correcta de iniciar un &roceso con :o&en' serB entonces' crear un ob!eto :o&en
&ara &oder acceder a sus m>todos' as) evitar' @ue el &roceso @uede abierto en
e!ecucin. $e esta -orma' creamos el ob!eto luego' llamamos al m>todo Aait05 de
,o&en' el cual espera a ,ue el proceso .inalice.
f(o* )u6&(oce)) i*&o(t ,o&en
proceso / Popen071ls12 1,lha1:5
proceso.Aait05
#i e!ecutamos el cdigo anterior' al igual @ue sucede con call' la salida obtenida es
directamente &lasmada en &antalla. Es a@u) donde entra en !uego' el mane!o de las
salidas @ue ,o&en nos &ermite hacer.
Entra'as : sa"i'as ;ue &ue'en ser ca&tura'as con 8o&en
stdout
nomenclatura corres&ondiente a la salida estBndar en sistemas %N3P-"i.e. Es la
encargada de almacenar la salida de un &rograma.
stdin
nomenclatura corres&ondiente a la entrada estBndar en sistemas %N3P-li.e. Es la
encargada de enviar in-ormacin a un &rograma.
stderr
al igual @ue las anteriores' se utili4a como re-erencia a los errores &roducidos en la salida
de un &rograma.
%ti"i6an'o tuber@as &ara ca&turar "a sa"i'a
,o&en nos &ermite ca&turar tanto la entrada como la salida estBndar o su error. :ara
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
'%
www.detodoprogramacion.com
e-ectuar dicha ca&tura' tanto stdout como stdin +o stderr se pasan como
argumentos cla5e a Popen El 5alor de dichos argumentos+ deber7 ser un archivo o
una tuber#a @ue -uncione como tal. D &ara esto' ,o&en' tambi>n nos &rovee de una
tuber)a &ara ca&turar dichas entradas salidas' llamada P(PE.
$e esta -orma' si @uisi>ramos ca&turar la salida estBndar o error de nuestro cdigo'
debemos &asarle a ,o&en' )tdout )tde(( como argumentos claves' con ,?,C como
valor de cada uno de ellos' &ara lo cual' tambi>n debemos im&ortar ,?,C*
f(o* )u6&(oce)) i*&o(t P(PE, ,o&en
&(oce)o < ,o&en([Nl)N, N2lhaN", stdout/P(PE, stderr/P(PE)
Al ca&turar la salida estBndar en una tuber)a' a no serB necesario &oner en es&era al
&roceso' &uesto @ue directamente serB ca&turado &or la tuber)a' &ermiti>ndonos acceder
a la lectura tanto de )tdout como de )tde((' como si se tratara de cual@uier otro
archivo*
&(oce)o < ,o&en([Nl)N, N2lhaN", stdout/P(PE, stderr/P(PE)
e((o(;econt(ado < proceso.stderr.read05
li)tado < proceso.stdout.read05
Ca&turando la salida' como bien se &uede ver en el e!em&lo' )tdout )tde((' son
tratados como archivos Lde hecho' lo son a @ue hemos utili4ado una tuber)aM. :or lo
tanto' deben ser cerrados una ve4 le)dos*
&(oce)o < ,o&en([Nl)N, N2lhaN", )tdout<,?,C, )tde((<,?,C)
e((o(;econt(ado < &(oce)o)tde(((ead()
proceso.stderr.close05
li)tado < &(oce)o)tdout(ead()
proceso.stdout.close05
"uego' &odremos mani&ular dichas lecturas' como cual@uier string*
if not error.encontrado:
&(int listado
el)e:
&(int 'Ae &(odu3o el )iguiente e((o(:PnI)' I error.encontrado
Para conocer ms so!re subprocess, ingresar en
http#33docs.python.org3li!rary3su!process.html
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
'4
www.detodoprogramacion.com
Mdulos para el programador
4ebuguear c)'igo con 8'b
El mdulo &d6 nos sirve &ara controlar &aso a &aso' la e!ecucin de nuestros &rogramas.
,d6 se utili4a solo &ara debuguear su utilidad consiste en &ermitirnos conocer el lugar
e7acto el &or @u>' nuestro scri&t -alla.
3magina @ue tienes un archivo @ue genera errores no logras descubrir la solucin.
:uedes im&ortar el mdulo &d6 hacer una llamada a pdb.Pdb05.set.trace05 en la
l)nea' a &artir de la cuBl' deseas @ue tu scri&t comience a Gcaminar &aso a &asoH &ara as)'
descubrir el error*
J 2G2 coding: utf28 2G2
import pdb
f(o* )u6&(oce)) i*&o(t call, ,o&en, ,?,C
J ^i*&ia( la &antalla
call('clea(')
pdb.Pdb05.set.trace05
&(oce)o < ,o&en([Nl)N, N2lhaN", )tdout<,?,C, )tde((<,?,C)
e((o(;encont(ado < &(oce)o)tde(((ead()
&(oce)o)tde((clo)e()
li)tado < &(oce)o)tdout(ead()
&(oce)o)tdoutclo)e()
if not e((o(;encont(ado:
&(int li)tado
el)e:
&(int 'Ae &(odu3o el )iguiente e((o(:PnI)' I e((o(;encont(ado
A &artir de la l)nea donde &d6,d6())et;t(ace() se encuentra' al e!ecutar &%thon
tu;a(chi4o&%' ,d6 comen4arB a e!ecutar tu archivo l)nea &or l)nea' es&erando tu
res&uesta. :or e!em&lo' en el cdigo anterior' tras la e!ecucin del archivo' la &antalla se
lim&iarB ,d6 comen4arB a actuar' mostrBndote la l)nea @ue sigue*
2+ &(oce)o < ,o&en([Nl)N, N2lhaN", )tdout<,?,C, )tde((<,?,C)
(,d6)
,d6 estarB es&erando tu orden &ara continuar. Entre las rdenes mBs usuales' &uedes
indicar*
n (ne#t) e3ecuta el cFdigo *o)t(ado % )alta a la )iguiente lMnea de tu a(chi4o
s ()te&) te *o)t(a(S &a)o a &a)o el ca*ino (eco((ido
ha)ta &ode( e3ecuta( la )iguiente lMnea de tu a(chi4o
c (continue) e3ecuta el a(chi4o ha)ta encont(a( un &unto de Kuie6(e
C (Kuit) a6andona( el de6ugge(
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
'8
www.detodoprogramacion.com
:ero no solo un comando' &uede ser ordenado a ,d6 =ambi>n es &osible' Gde&urarH el
cdigo de tu archivo' e!ecutando alguna instruccin*
2+ li)tado < &(oce)o)tdout(ead()
(,d6) n
+ 5ho*e5eugenia5Cu()o)5,%thon &a(a ,(inci&iante)50Fdulo
85)ou(ce)5)u6&(oce));e#a*&le)5e#a*&le)&%(13)V*odule+()
2+ &(oce)o)tdoutclo)e()
0Pdb5 listado.upper05
1$%$8; 42RPn&RS)RS)R,) 2 EO?E=(8 EO?E=(8 N23R 2342,37,37 47+FN .Pn&RS)RS)R,) -
EO?E=(8 EO?E=(8 N23R 2342,37,37 47+FN ..Pn,RS,RS,R,, 4 EO?E=(8 EO?E=(8 N2T
2342,37,37 23+N- E)8*P;ES.P!Pn1
(,d6)
Puedes o!tener ms informacin so!re Pdb
ingresando en http#33docs.python.org3li!rary3pd!.html
4ocumentar tu a&& con &:'oc
Con tan solo colocar los docstrings corres&ondientes en cada mdulo +o -uncin de tu
:thon a&&' e!ecutar en la termina pydoc tu.app serB su-iciente &ara acceder a toda la
documentacin*
~$ pydoc tienda
/el& on &ac:age tienda:
=8*E
tienda
'(;E
5ho*e5eugenia5&%thona&&)5tienda5;;init;;&%
P8<R8?E <%=$E=$S
;;*ain;;
ad*ini)t(acion (&ac:age)
6u)cado( (&ac:age)
co(e (&ac:age)
Alternativamente' tambi>n &uedes obtener la documentacin en -ormato J=I". :ara ello'
deberBs e!ecutar* pydoc ,A nombre.del.modulo
5tra alternativa' es iniciar un servidor 8eb local' @ue te &ermita navegar &or la
documentacin de tu a&&. :ara ello' sim&lemente e!ecuta pydoc ,p n Ldonde n' es el
n9mero del &uerto &or el cual accederBs. :or e!em&lo' pydoc ,p -3-3 inicia el servidor
en htt&:55localho)t:80805M.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
'/
www.detodoprogramacion.com
8robar e" c)'igo antes 'e eniar"o a &ro'ucci)n con 'octest
El mdulo docte)t de :thon' nos &ermite indicar -ragmentos de cdigo en los
comentarios de nuestros mdulos' @ue emulen instrucciones del int>r&rete interactivo'
e!ecutBndolas de -orma tal' @ue &odamos automati4ar las &ruebas de nuestra a&licacin.
import doctest
def )u*a(;do);nu*e(o)(a, 6):
'''Au*a do) nT*e(o) % (eto(na )u (e)ultado
B(gu*ento):
a 22 &(i*e( )u*ando
6 22 )egundo )u*ando
$e)t:
QQQ sumar.dos.numeros02G2 435
FG
QQQ sumar.dos.numeros0F32 235
G3
'''
(etu(n a . 6
if ;;na*e;; << ';;*ain;;':
doctest.testmod05
#i vemos el te7to deba!o de G=est*H' luce como el int>r&rete interactivo.
A@u) esto invocando a la -uncin*
+++ )u*a(;do);nu*e(o)(28, 10)
D deba!o' esto GsimulandoH el resultado @ue arro!ar)a en el int>r&rete interactivo. Esto'
serB inter&retado &or docte)t' como Gel resultado es&eradoH*
38
:ara correr los test' solo bastarB con e!ecutar*
~$ &%thon *odulo&% 24
D obtendremos un resultado similar a*
eugenia@cochito:~5&%thona&&)5docte)t;e#a*&le)$ python suma.py ,"
$(%ing:
)u*a(;do);nu*e(o)(28, 10)
C#&ecting:
38
o:
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
')
www.detodoprogramacion.com
$(%ing:
)u*a(;do);nu*e(o)(30, 20)
C#&ecting:
80
o:
1 ite*) had no te)t):
;;*ain;;
1 ite*) &a))ed all te)t):
2 te)t) in ;;*ain;;)u*a(;do);nu*e(o)
2 te)t) in 2 ite*)
2 passed and 3 failed.
$est passed.
Para sa!er ms so!re doctest, isita
http#33docs.python.org3li!rary3doctest.html
:ectura complementaria: htt&*++,,,.maestrosdel,eb.com+editorial+guia-&thon-
testeando-codigo-doctest-comentarios+
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
''
www.detodoprogramacion.com
Mdulos 0ue resuelen necesidades
1uncionales
1btener 'atos a"eatorios
Con el mdulo random de la librer)a estBndar de :thon' es &osible obtener datos
aleatorios. Entre los m>todos de los cuBles dis&one' se destacan los siguientes*
*2todo Descripci&n
random.randint0a, 65
(etorna un n9mero aleatorio entero entre a b
random.choice0)ecuencia5
(etorna cual@uier dato aleatorio de secuencia
random.shuffle0)ecuencia5
(etorna una me4cla de los elementos de una
secuencia
random.sample0)ecuencia, n5
(etorna n elementos aleatorios de secuencia
import random
# !enerar n+meros aleatorios entre ,---- y -----
li)ta < ["
fo( n in (ange(0, 80):
li)taa&&end(random.randint0NTTTT2 TTTTT5)
# Ele#ir un n+mero al a.ar
nu*e(o;al;a7a( < random.choice0lista5
# Ele#ir / n+meros al a.ar
nu*e(o);al;a7a( < random.sample0lista2 G5
# reordenar los elementos de una lista
*u3e(e) < ['Bna', 'Ueat(i7', 'Ca*ila', 'Ca(*en', 'Helia', 'Ho(a', 'C*il)e'"
random.shuffle0mujeres5
Para conocer ms so!re random, ingresar en
http#33docs.python.org3li!rary3random.html
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;;
www.detodoprogramacion.com
/ra&ear un te.to
El mdulo te6tArap' entre muchas otras -uncionalidades' a trav>s del m>todo Y(a&()'
nos &ermite :rapear un te7to e7tenso' obteniendo una lista con cada l)nea de te7to
conservando la longitud deseada*
te#tYa(&Y(a&(te#to, 80)
(etorna una lista donde cada elemento serB una l)nea de te7to' de longitud no su&erior a
los A0 caracteres.
import te6tArap
te#to < _^o(e* i&)u* ad hi) )c(i&ta 6landit &a(tiendo, eu* fa)tidii accu*)an
eu(i&idi) in, eu* li6e( hend(e(it an eui ut Yi)i 4oci6u) )u)ci&iantu(, Kuo
dicit (iden) incide(int id euo *undi lo6o(ti) (efo(*idan) eu, legi*u)
)en)e(it definie6a) an eo) Cu )it tincidunt inco((u&te definitione*, 4i)
*utat affe(t &e(ci&it cu, ei(*od con)ectetue( )ignife(u*Kue eu &e( ?n u)u
latine eKuide* dolo(e) euo no falli 4i(i) intellega*, ut fugit 4e(itu)
&lace(at &e(f
Y(a&) < te6tArap.Arap0te6to2 L35
fo( linea in Y(a&):
&(int linea
Para conocer ms so!re te6tArap ingresar en
http#33docs.python.org3li!rary3te1twrap.html
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;(
www.detodoprogramacion.com
Mdulos e Internet
Acce'er a" naega'or /eb
Abrir una %(" en una nueva &estaUa del navegador*
import AebbroAser
AebbroAser.open.neA.tab('htt&:55YYYeugenia6ahitco*')
4s so!re AebbroAser en
http#33docs.python.org3li!rary3we!!rowser.html
urllib2 es otro mdulo interesante para manipular
peticiones 566P e interactuar a tras de 7nternet#
http#33docs.python.org3li!rary3urlli!8.html
Conectarse @a G38
El mdulo ftplib de la librer)a estBndar de :thon' nos &rovee de los m>todos
necesarios &ara crear clientes ?=: de -orma rB&ida sencilla.
Conectarse a un seri'or G38
:ara conectarse a un servidor D$,, el mdulo ft&li6 nos &rovee de la clase D$, El
m>todo constructor de la clase D$, Lm>todo ;;init;;()M' recibe como &arBmetros al
host' usuario' clave' de -orma tal @ue &asando estos &arBmetros durante la instancia a
?=:' se ahorra el uso de los m>todos connect(ho)t, &o(t, ti*eout)
login(u)e(, &a))).
from ftplib import '$P
# Conectarse con los mtodos connect y login
ft& < D$,()
ft&connect(N!!2288293N, 21, 2999)
ft&login(N*iu)e(N, N*icla4eN)
# Conectarse en la instancia a FTP
ft& < D$,(N!!2288293N, N*iu)e(N, N*icla4eN)
"a clase D$,' se com&one -entre otros- de los siguientes m>todos*
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;2
www.detodoprogramacion.com
*2todo Descripci&n
'$P.connect0ho)t[, &ue(to, ti*eout")
#e conecta al servidor ?=:
'$P.login0u)e(, &a))5
#e loguea en el servidor
'$P.close05
?inali4a la cone7in
'$P.set.pas"06ool5
Establece la cone7in en modo &asivo si el
&arBmetro es =rue.
'$P.getAelcome05
(etorna el mensa!e de bienvenida del servidor
'$P.dir05
(etorna un listado de archivos directorios de
la car&eta actual
'$P.cAd0&ath5
Cambia el directorio de traba!o actual a &ath
'$P.mBd0&ath5
Crea un nuevo directorio
'$P.pAd05
(etorna el directorio de traba!o actual
'$P.rmd0&ath5
Elimina el directorio &ath
'$P.storlines01S$%R de)tino12
open0localfile2 1r15
"ee local-ile lo escribe en destino
'$P.rename0actual, nue4o5
(enombra el archivo GactualH &or GnuevoH
'$P.delete0filena*e5
Elimina un archivo
'$P.retrlines01RE$R a(chi4o;(e*oto15
"ee archivoOremoto retorna su contenido
J 2G2 coding: utf28 2G2
from ftplib import '$P
ftp / '$P05
ft&connect(N!!2288293N, 21, 2999)
ft&login(Nu)e(N, N&a))N)
&(int ft&getAelcome()
ft&mBd(Nnue4o2di(N)
ft&cAd(Nnue4o2di(N)
&(int ft&pAd()
ft&storlines(NA$OE e#a*&let#tN, o&en(Nft&;e#a*&le)&%N, N(N))
ft&rename(Ne#a*&let#tN, Ne#a*&le&%N)
ft&dir()
a(chi4o < ft&retrlines(NEC$E e#a*&le&%N)
&(int a(chi4o
ft&close()
Para conocer ms so!re ftplib, ingresar en
http#33docs.python.org3li!rary3ftpli!.html
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;
www.detodoprogramacion.com
Introduccin a
M'S9% ' el
lengua)e S9%
En este ca&)tulo haremos una introduccin a conce&tos elementales sobre bases de datos'
I#N" el lengua!e de consulta #N".
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;%
11
www.detodoprogramacion.com
4cerca de M'S9%
I#N" es un ser5idor de Bases de Datos 39: L#tructured Nuer "anguageM @ue se
distribue en dos versiones*
%na versin 6:" L#o-t,are "ibreM
5tra versin &rivativa' llamada I#N" AB
En este curso' utili4aremos la versin estBndar licenciada ba!o la 6N% 6eneral :ublic
"icense L6:"M. :uedes descargar el manual completo de *y39: en el siguiente enlace*
htt&*++do,nloads.ms@l.com+docs+re-man-;.0-es.a0.&d-
Insta"aci)n : configuraci)n 'e D:SH-
:ara instalar I#N"' &or l)nea de comandos' escribe*
)udo a&t2get in)tall mysCl,ser"er mysCl,client
$urante la instalacin' el sistema te &edirB @ue ingreses una contraseUa &ara la
administracin de I#N". Asigna una contraseUa @ue &uedas recordar -Bcilmente
mantenla a salvo a @ue deberBs utili4arla -recuentemente.
%na ve4 @ue -inalice la instalacin' e!ecuta el siguiente comando a -in de securi4ar el
servidor I#N" Lesta con-iguracin' es vBlida tambi>n' &ara servidores de &roduccinM*
)udo mysCl.secure.installation
A continuacin' el sistema te &edirB @ue ingreses la contraseUa actual &ara administracin
de I#N" Lla del usuario root de I#N"M. =en en cuenta @ue la contraseUa no serB
mostrada mientras escribes*
Cnte( cu((ent &a))Yo(d fo( (oot (ente( fo( none):
A continuacin' te &reguntarB si deseas modi-icar esa contraseUa. #alvo @ue desees
modi-icarla' ingresa n*
Change the (oot &a))Yo(d` [g5n" n
Ahora la &regunta' serB si deseas eliminar usuarios annimos. (es&onde @ue s)*
Ee*o4e anon%*ou) u)e()` [g5n" !
"uego' te &reguntarB si desees desabilitar el acceso remoto al usuario root de I#N".
:or su&uesto' res&onde @ue s)*
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;4
www.detodoprogramacion.com
Hi)alloY (oot login (e*otel%` [g5n" !
"a siguiente &regunta serB si deseas eliminar la base de datos de &rueba el acceso a
ella. =ambi>n res&onde @ue s)*
Ee*o4e te)t data6a)e and acce)) to it` [g5n" !
?inalmente' te &reguntarB si deseas recargar las tablas de &rivilegios Lesto es &ara
asegurar @ue todos los cambios reali4ados sur!an e-ectoM. Entonces' res&onde s)' &or
9ltima ve4*
Eeload &(i4ilege ta6le) noY` [g5n" !
Iniciar, reiniciar : 'etener e" seri'or D:SH-
En ocasiones necesitarBs iniciar' reiniciar o detener el servidor de bases de datos'
I#N".
"as opciones dis&onibles son*
stop detiene el )e(4ido(
start inicia el )e(4ido(
restart (einicia el )e(4ido(
:ara iniciar' reiniciar o detener el servidor' deberBs ejecutar el siguiente comando'
seguido de la o&cin deseada*
sudo MetcMinit.dMmysCl o&cion;de)eada
"gicamente reem&la4ando o&cion &or )to&' )ta(t o (e)ta(t seg9n si deseas &arar'
iniciar o reiniciar el servidor.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;8
www.detodoprogramacion.com
A'ministraci)n 'e D:SH-
%na ve4 @ue comencemos a utili4ar bases de datos' necesitarBs &oder acceder a las
o&ciones de administracin de las mismas. :or lo tanto' te recomiendo tener siem&re a
mano este ca&)tulo' &ara &oder consultarlo con -recuencia.
Conectarse : 'esconectarse a" seri'or
:ara conectarte deberBs e!ecutar el siguiente comando*
*%)Kl 2u (oot 2&
A continuacin' deberBs ingresar la contraseUa del root de I#N" Lno es la del root del
#5. Es la @ue hemos con-igurado durante la instalacin de I#N"M.
"as 2u 2& signi-ican usuario &ass,ord res&ectivamente.
=e a&arecerB un shell interactivo &ara I#N"*
mysClQ
All) &odremos escribir los comandos necesarios &ara administrar el servidor de bases de
datos.
Coman'os &ara a'ministrar D:SH- 'e'e e" she"" interactio
"a siguiente tabla describe los comandos de uso -recuente @ue necesitarBs &ara
administrar el servidor de bases de datos desde el shell interactivo.
Es una buena idea' im&rimir esta tabla &ara tenerla siem&re a mano *M
C1*<CD1 DE3CG0PC0TC
shoA databasesU Iuestra todas las bases de datos creadas en el servidor
use nombre.de.la.base.de.datosU 3ndicar @ue vas a comen4ar a utili4ar la base de datos elegida
create database nombre.de.la.dbU Crear una nueva base de datos
Cuit #alir del shell interactivo
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;/
www.detodoprogramacion.com
Sobre el lengua)e S9%
39: -siglas de 0tructured ;uery Language-' es el lenguaje de consultas a bases de
datos' @ue nos &ermitirB crear' modi-icar' consultar eliminar tanto bases de datos como
sus tablas registros' desde el shell interactivo de I#N" tambi>n desde :thon.
Como todo lenguaje in.orm7tico' &osee su &ro&ia sinta@is' tipos de datos
elementos.
En este curso' abordaremos los conceptos b7sicos sobre 39: @ue nos &ermitan
desarrollar a&licaciones de media com&le!idad' sin &ro-undi4ar en el lengua!e en s)' sino
solo en a@uellos aspectos m#nimamente necesarios relacionados con *y39:.
3i&os 'e 'atos m7s comunes !recomen'a'os(
"a siguiente tabla' muestra los ti&os de datos mBs comunes' ace&tados &or versiones la
versin ;.0.3 o su&erior' de I#N".
!ipo de dato Denominaci&n Especi.icaciones Ejemplo
Cnte(o (=$0=5 @ < cantidad de dMgito) ?@$(8)
@T*e(o deci*al &E<(*8;0=2 &5
@ < cantidad de dMgito)
totale)
H < cantidad de deci*ale)
HCC?0B^(10, 2)
Uooleano 9%%; UOO^
Decha &8$E HB$C
Decha % ho(a &8$E$(*E HB$C$?0C
Decha % ho(a
auto*Stica
$(*ES$8*P $?0CA$B0,
/o(a $(*E $?0C
BXo !E8R0&5
H < cantidad de dMgito) (2 o
4)
gCBE(4)
Cadena de longitud
fi3a
<D8R0=5
@ < longitud de la cadena W
ent(e 0 % 288
C/BE(2)
Cadena de longitud
4a(ia6le
V8R<D8R0=5
@ < longitud *S#i*a de la
cadena W ent(e 0 % !8832
=BEC/BE(100)
UloKue de te#to de
g(an longitud
4a(ia6le
9;%9 U^OU
Sint7.is b7sica 'e "as sentencias SH-
%na sentencia #N" Ldenominada query en la !erga in-ormBticaM' es una instrucci&n
escrita en lengua!e #N". <eremos a@u)' el ti&o de sentencias mBs habituales.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;)
www.detodoprogramacion.com
Crear tab"as en una base 'e 'atos
#inta7is*
<RE8$E $89;E no*6(e;de;la;ta6la0
no*6(e;del;ca*&o $?,O;HC;HB$O,
no*6(e;de;ot(o;ca*&o $?,O;HC;HB$O
5U
E!em&lo*
CECB$C $BU^C &(oducto)(
&(oducto =BEC/BE(128),
de)c(i&cion U^OU,
&(ecio HCC?0B^(!, 2),
en;)toc: UOO^
)h
E7&licacin*
CECB$C $BU^C &(oducto)
Crear una nueva tabla llamada G&roductosH
&(oducto =BEC/BE(128),
Crear un cam&o llamado &roducto' de ti&o cadena de te7to de longitud variable' con una
longitud mB7ima de 12; caracteres
de)c(i&cion U^OU,
Crear un cam&o llamado descri&cin' de ti&o blo@ue de te7to de gran longitud
&(ecio HCC?0B^(!, 2),
Crear un cam&o &recio de ti&o num>rico de longitud mB7ima de 2 dig)tos de los cuales'
solo 2 &ueden ser decimales
en;)toc: UOO^
Crear un cam&o llamado GenOstoc.H del ti&o booleano
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;'
www.detodoprogramacion.com
Insertar 'atos en una tab"a
#inta7is*
(=SER$ (=$%
no*6(e;de;la;ta6la(ca*&o1, ca*&o2, ca*&o10)
=B^aCA(dato1, dato2, dato10)U
E!em&lo*
?@ACE$ ?@$O
&(oducto)(&(oducto, &(ecio, en;)toc:)
=B^aCA(NUol)a de do(*i( &a(a alta *ontaXaN, 234!8, $EaC)h
E7&licacin*
?@ACE$ ?@$O
&(oducto)(&(oducto, &(ecio, en;)toc:)
3nsertar un nuevo registro en los cam&os &roducto' &recio enOstoc. de la tabla
&roductos
=B^aCA(NUol)a de do(*i( &a(a alta *ontaXaN, 234!8, $EaC)h
Con los valores GBolsa de dormir &ara alta montaUaH' 230.2; verdadero'
res&ectivamente en cada uno de los cam&os indicados
Se"eccionar registros
#inta7is*
SE;E<$ ca*&o1, ca*&o2, ca*&o10
'R%* ta6lah
E!em&lo*
AC^CC$ &(oducto, &(ecio
DEO0 &(oducto)h
E7&licacin*
AC^CC$ &(oducto, &(ecio
#eleccionar los cam&os &roducto &recio
DEO0 &(oducto)h
$e la tabla &roductos
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
((;
www.detodoprogramacion.com
Do'ificar registros
#inta7is*
OP&8$E ta6la
SE$ ca*&o1 < 4alo(,
ca*&o2 < 4alo(,
ca*&o10 < 4alo(h
E!em&lo*
a,HB$C &(oducto)
AC$ en;)toc: < DB^AC,
&(ecio < 0h
E7&licacin*
a,HB$C &(oducto)
Actuali4ar la tabla &roductos
AC$ en;)toc: < DB^AC,
Iodi-icar el cam&o enOstoc. &or -also
&(ecio < 0h
el cam&o &recio a 0
E"iminar registros
#inta7is*
&E;E$E 'R%* ta6lah
E!em&lo*
HC^C$C DEO0 &(oducto)h
E7&licacin*
HC^C$C DEO0 &(oducto)h
Eliminar todos los registros de la tabla &roductos
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(((
www.detodoprogramacion.com
Consu"tas aan6a'as
#i bien no veremos a@u) consultas realmente com&le!as' a @ue el curso se basa en el
lengua!e de &rogramacin :thon no' en el lengua!e de consulta #N"' haremos un
rB&ido &aseo' &or las o&ciones dis&onibles en #N" &ara sentencias mBs com&le!as @ue
las anteriores.
-a c"7usu"a /EEIE
"as sentencias en #N"' se com&onen de cl7usulas. D i/CEC es una de ellas. "a
cl7usula SDERE nos &ermite .iltrar registros en una sentencia #N".
Esta clBusula' -unciona de -orma similar a la com&aracin de e7&resiones en :thon'
utili4ando los siguientes operadores de comparaci&n*
Q *a%o( Kue W *eno( Kue
/ igual Kue WQ di)tinto Kue
+< *a%o( o igual Kue V< *eno( o igual Kue
9E$SEE= n4 8=& n2 ent(e n1 % n2
(S =O;;X$ROEX'8;SE e) nulo > e) 4e(dade(o > e) fal)o
(=(4alo(1, 4alo(2, 4a) contiene
:or su&uesto' tambien admite operadores l&gicos*
8=& (%) =%$ (negaciFn) %R (o)
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
((2
www.detodoprogramacion.com
<eamos algunos e!em&los*
#eleccionar &roductos donde &recio sea menor @ue 1000*
AC^CC$ &(oducto,
&(ecio
DEO0 &(oducto)
SDERE precio W 4333U
Aumentar el 10Z del &recio de los &roductos' @ue actualmente se encuentren entre 1;0
200*
a,HB$C &(oducto)
AC$ &(ecio < (&(ecio G 110)
SDERE precio 9E$SEE= 4G3 8=& 233U
#eleccionar &roductos donde enOstoc. no sea -also
AC^CC$ &(oducto,
&(ecio
DEO0 &(oducto)
SDERE en.stocB (S =%$ '8;SEU
Eliminar &roductos cuos &recios sean 100' 200 +o 300 ademBs' enOstoc. sea -also o
&roducto sea nulo*
HC^C$C
DEO0 &(oducto)
SDERE precio (=04332 2332 F335
8=& 0en.stocB (S '8;SE
%R producto (S =O;;5U
Iodi-icar enOstoc. a verdadero donde &recio sea menor @ue ;0 &roducto no sea nulo*
a,HB$C &(oducto)
AC$ en;)toc: < $EaC
SDERE precio W G3
8=& en.stocB (S =%$ =O;;U
1r'enan'o consu"tasC "a c"7usu"a 1I4EI B<
Es &osible ademBs' ordenar los resultados de una consulta' en -orma ascendente LBACM o
descendente LHCACM*
AC^CC$ &(oducto,
de)c(i&cion,
&(ecio
DEO0 &(oducto)
i/CEC &(ecio UC$iCC@ 1 B@H 80
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
((
www.detodoprogramacion.com
B@H en;)toc: ?A @O$ DB^AC
%R&ER 9! precio &ES<U
=ambi>n es &osible' ordenar los resultados de la consulta' &or mBs de un cam&o*
AC^CC$ &(oducto,
de)c(i&cion,
&(ecio
DEO0 &(oducto)
i/CEC &(ecio UC$iCC@ 1 B@H 80
B@H en;)toc: ?A @O$ DB^AC
%R&ER 9! precio &ES<2
producto 8S<U
A"ias 'e tab"as : cam&os
5tra &osibilidad @ue nos da el lengua!e #N"' es utili4ar alias &ara el nombre de los
cam&os las tablas. Estos alias se asignan mediante la &alabra clave reservada' 8S*
AC^CC$ &(oducto 8S 1=ombre del Producto12
de)c(i&cion 8S &etalles2
&(ecio 8S (mporte
DEO0 &(oducto) 8S p
i/CEC &(ecio UC$iCC@ 1 B@H 80
B@H en;)toc: ?A @O$ DB^AC
%R&ER 9! precio &ES<2
producto 8S<U
/tese 0ue los alias que contengan caracteres
e"tra#os, de!en ser encerrados entre comillas
simples
Gunciones 'e" "engua5e SH- 'e D:SH-
Es &osible tambi>n' utili4ar diversas -unciones &ro&ias del lengua!e #N" -a sea estandar
o de I#N"- a -in de &oder obtener los datos con cierto -ormato. <eremos a@uellas de
uso mBs -recuente.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
((%
www.detodoprogramacion.com
Contar "a canti'a' 'e registrosC C1%+3!(
AC^CC$ <%O=$0producto5 BA Cantidad
DEO0 &(oducto)h
Sumar tota"esC S%D!(
AC^CC$ SO*0precio5 BA $otal
DEO0 &(oducto)h
Concatenar ca'enasC C1+CA3!(
AC^CC$ &(oducto,
<%=<8$01OS& 12 precio2 1.,15 BA ,(ecio
DEO0 &(oducto)h
Ntese @ue las cadenas de caracteres deben encerrarse entre comillas sim&les @ue el
o&erador de concatenacin &ara esta -uncin' es la coma.
Conertir a min0scu"as : ma:0scu"asC -CASE!( : %CASE!(
AC^CC$ O<8SE0producto52
;<8SE0descripcion5
DEO0 &(oducto)h
Ieem&"a6ar 'atosC IE8-ACE!(
AC^CC$ REP;8<E0descripcion2 1Pn12 1WbrMQ15 BA He)c(i&cion
DEO0 &(oducto)h
(eem&la4a `an` &or `bbr+c`
1btener "os &rimeros o 0"timos caracteresC -EG3!( : II*E3!(
AC^CC$ ;E'$0producto2 G35
DEO0 &(oducto)h
Ie'on'ear n0merosC I1%+4!(
AC^CC$ R%O=&0precio2 25
DEO0 &(oducto)h
(etornarB los &recios con 2 decimales
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
((4
www.detodoprogramacion.com
1btener so"o "a fecha 'e un cam&o 4A3E3IDE o
3IDES3AD8C 4A3E!(
AC^CC$ &8$E0campo.datetime5
DEO0 ta6lah
1btener una fecha formatea'aC 4A3EJG1IDA3!(
AC^CC$ &8$E.'%R*8$0campo.fecha2 1YdMYmMY!15
DEO0 ta6lah
1btener e" registro con e" a"or m7.imo : m@nimoC DAK!( :
DI+!(
AC^CC$ *8)0precio5
DEO0 &(oducto)h
(etorna el &roducto con el &recio mBs caro
AC^CC$ *(=0precio5
DEO0 &(oducto)h
(etorna el &roducto con el &recio mBs barato
Optimi.acin de bases de +atos
A continuacin' encontrarBs una lista de conse!os @ue #3EI:(E debes seguir' al
momento de crear nuevas tablas escribir sentencias #N".
3o'os "os registros 'eben tener un I4 0nico
Cuando crees tablas' as)gnales un cam&o id de ti&o autonum>rico incremental
establ>celo como )ndice &rimario. Cuando agregues registros' este cam&o se com&letarB
automBticamente' con un n9mero incremental' @ue te servirB &ara o&timi4ar tus consultas
contar con un cam&o @ue te &ermita reconocer el registro como 9nico.
CECB$C $BU^C &(oducto)(
id (=$0445 =%$ =O;; 8O$%.(=<RE*E=$ PR(*8R! RE!,
&(oducto =BEC/BE(128)
)h
El cam&o id' serB como cual@uier otro lo &odrBs seleccionar en un #E"EC= o utili4arlo
e cual@uier clBusula 8JE(E.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
((8
www.detodoprogramacion.com
Crear @n'ices en "as tab"as
=odas las tablas deben tener un )ndice. El )ndice se asigna a uno o mBs cam&os' es
utili4ado &or #N" &ara -iltrar registros de -orma mBs rB&ida. $ebes crear )ndices con
&recaucin' a @ue de la misma -orma @ue se aceleran las consultas' se retrasa la
insercin actuali4acin de registros' &uesto @ue la base de datos' deberB actuali4ar los
)ndices cada ve4 @ue se agreguen o modi-i@uen datos.
Cuando una consulta es e!ecutada' I#N" tratarB de encontrar &rimero la res&uesta en
los cam&os )ndice' lo harB en el orden @ue los )ndices haan sido creados.
KCu7ndo agregar #ndicesL Cuando vaas a utili4ar una combinacin de cam&os en la
clBusula 8JE(E. :or e!em&lo' si -iltrarBs a menudo' los datos de la tabla &roducto &or su
cam&o &recio enOstoc.' @ue &recio enOstoc. sean un )ndice de m9lti&les cam&os*
CECB$C $BU^C &(oducto)(
id ?@$(11) @O$ @a^^ Ba$O;?@CEC0C@$ ,E?0BEg jCg,
&(oducto =BEC/BE(128),
&(ecio HCC?0B^(10, 2),
en;)toc: UOO^,
de)c(i&cion U^OU,
(=&E)0precio2 en.stocB5
)h
In'ica cu7"es cam&os no &ue'en ser nu"os
#N" te da la &osibilidad de indicar @u> cam&os no &ueden estar nulos. 3ndicar @ue un
cam&o no debe estar nulo' te audarB a no almacenar registros de-ectuosos en tu base de
datos.
CECB$C $BU^C &(oducto)(
id ?@$(11) @O$ @a^^ Ba$O;?@CEC0C@$ ,E?0BEg jCg,
&(oducto =BEC/BE(128) =%$ =O;;,
&(ecio HCC?0B^(10, 2) =%$ =O;;,
en;)toc: UOO^,
de)c(i&cion U^OU =%$ =O;;,
?@HCc(&(ecio, en;)toc:)
)h
%ti"i6a e" motor Inno4B
El motor de bases de datos 3nno$B' te &ermitirB crear tablas relaciones o&timi4ando su
rendimiento. Al momento de crear tus tablas' indica @ue utili4arBs el motor 3nno$B*
CECB$C $BU^C &(oducto)(
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
((/
www.detodoprogramacion.com
id ?@$(11) @O$ @a^^ Ba$O;?@CEC0C@$ ,E?0BEg jCg,
&(oducto =BEC/BE(128) @O$ @a^^,
&(ecio HCC?0B^(10, 2) @O$ @a^^,
en;)toc: UOO^,
de)c(i&cion U^OU @O$ @a^^,
?@HCc(&(ecio, en;)toc:)
) E=?(=E/(nno&9U
Aprende ms so!re el lengua"e '9L, gratis en
:;ey+ata
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(()
www.detodoprogramacion.com
-ases de datos relacionales
As) como en la orientacin a ob!etos' algunas clases se relacionan con otras' a sea a
trav>s de la herencia o la com&osicin' cuando nuestros ob!etos deben guardar un
almac>n de datos' esa relacin' debe conservarse tambi>n en la base de datos de
nuestra a&licacin.
#i te -i!as el siguiente es@uema' &uede entenderse como dos ob!etos con sus &ro&iedades
a la ve4' como dos tablas' relacionadas entre s)*
El ob!eto &roducto' se relaciona directamente con el ob!eto categor)a. Esto signi-ica @ue
nuestros &roductos' &ertenecen a una categor)a determinada. #e relacionan a trav>s del
cam&o-&ro&iedad' categoriaOid.
:ara crear bases de datos relacionales' primero debemos crear nuestros modelos' a
-in de obtener las relaciones @ue serBn necesarias*
class Catego(ia(o63ect):
catego(ia;id < 0h
catego(ia < ''
acti4a < $(ue
class ,(oducto(o63ect):
&(oducto;id < 0
catego(ia < Catego(ia()
&(oducto < ''
&(ecio < 00
de)c(i&cion < ''
%na ve4 @ue tenemos los modelos' &odemos &asar a crear las tablas*
CECB$C $BU^C catego(ia(
catego(ia;id ?@$(11) @O$ @a^^ Ba$O;?@CEC0C@$ ,E?0BEg jCg,
catego(ia =BEC/BE(28) @O$ @a^^,
acti4a UOO^
) E=?(=E/(nno&9U
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(('
categoria producto
categoriaUid
categoria
activa
productoUid
categoriaUid
&roducto
&recio
descri&cion
www.detodoprogramacion.com
CECB$C $BU^C &(oducto(
&(oducto;id ?@$(11) @O$ @a^^ Ba$O;?@CEC0C@$ ,E?0BEg jCg,
categoria.id (=$0445 =%$ =O;;2
&(oducto =BEC/BE(288) @O$ @a^^,
&(ecio HCC?0B^(-, 2) @O$ @a^^,
de)c(i&cion U^OU,
'%RE(?= RE! 0categoria.id5
RE'ERE=<ES categoria0categoria.id5
) E=?(=E/(nno&9U
(uando el campo de una tabla hace referencia a la
clave primaria de otra tabla, se denomina $clae
fornea% o $foreign $ey% (en ingls&. Para poder
utilizar claes forneas, 4y'9L necesita utilizar s2 o
s2, el motor %nno&' ya 0ue es el <nico con soporte
para stas.
Como &odrBs observar' el cam&o de la tabla &roducto' @ue hace re-erencia a la clave
&rimaria de la tabla categor)a' se llama igual LcategoriaOidM. :odr)a tener un nombre
di-erente' &ero mBs adelante lo veremos. Este campo+ debe ser creado en la tabla+
como cual,uier campo comNn. :a principal di.erencia+ radica en ,ue debemos
indicar ,ue este campo+ debe ser tratado como una cla5e .or7nea.
:ara ello' utili4amos la siguiente sinta7is*
DOEC?G@ jCg (no*6(e;de;la;cla4e;fo(anea)
ECDCEC@CCA ta6la;(elacionada(no*6(e;de;la;cla4e;&(i*a(ia)
En lengua!e humano' esto se leer)a como sigue*
DOEC?G@ jCg (Dj)
la cla"e forZnea e) 'R
ECDCEC@CCA $BU^B(,j)
Kue hace referencia a la ta6la $89;80a t(a4L) del ca*&o PR5
(K es una (oreign Key (clae fornea& mientras 0ue
PK es una Primary Key (clae primaria&
Esto signi-ica @ue siem&re @ue debamos relacionar un cam&o con otro' el cam&o
relacionado deberB indicarse como ?oreign Ce mientras @ue el cam&o al cuBl hace
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(2;
www.detodoprogramacion.com
re-erencia' deberB indicarse como :rimar Ce.
"uego' &odremos obtener' desde la base de datos' el Gob!etoH &roducto' incluendo los
datos a los cuBles hace re-erencia. :ara ello' utili4aremos la siguiente consulta*
AC^CC$ &(oductoG, catego(iaG
DEO0 &(oducto ?@@CE ZO?@ catego(ia aA?@G(catego(ia;id)
Con AC^CC$ &(oductoG, catego(iaG estamos seleccionando todos los cam&os
de la tabla &roducto todos los cam&os de la tabla categoria. Iientras @ue con DEO0
&(oducto ?@@CE ZO?@ catego(ia aA?@G(catego(ia;id)' estamos diciendo @ue*
DEO0 &(oducto ?@@CE ZO?@ catego(ia
$esde la tabla &(oducto unida internamente a la tabla catego(ia
aA?@G(catego(ia;id)
utili4ando el cam&o catego(ia;id
Cmo comentamos anteriormente' una ?C no necesariamente debe llevar el mismo
nombre @ue la clave &rimaria a la cuBl hace re-erencia. :odr)amos' &or e!em&lo' haber
creado nuestra tabla &(oducto de la siguiente manera*
CECB$C $BU^C &(oducto(
&(oducto;id ?@$(11) @O$ @a^^ Ba$O;?@CEC0C@$ ,E?0BEg jCg,
'R.categoria (=$0445 =%$ =O;;2
&(oducto =BEC/BE(288) @O$ @a^^,
&(ecio HCC?0B^(-, 2) @O$ @a^^,
de)c(i&cion U^OU,
'%RE(?= RE! 0'R.categoria5
ECDCEC@CCA catego(ia(catego(ia;id)
) C@G?@C<?nnoHUh
:ero en este caso' deber)amos modi-icar la sinta7is de nuestra consulta*
AC^CC$ &(oductoG, catego(iaG
DEO0 &(oducto ?@@CE ZO?@ catego(ia
%= producto.'R.categoria / categoria.categoria.id
Es decir' @ue a no &odemos indicarle @ue utilice el cam&o homnimo en ambas tablas'
sino' @ue &ara reali4ar esta unin interna se base en la condicin de igualdad del valor de
los mismo Lcam&o -orBneo &rimario res&ectivamenteM.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(2(
www.detodoprogramacion.com
-ases de datos
en P't(on con
M'S9%

Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(22
12
www.detodoprogramacion.com
Introduccin a bases de datos con P't(on
En :thon' el acceso a bases de datos se encuentra de-inido a modo de estBndar en las
es&eci-icaciones de DB><P0' @ue &uedes leer en la PEP 2%'*
htt&*++,,,.&thon.org+dev+&e&s+&e&-0201+. Esto' signi-ica @ue inde&endientemente de la
base de datos @ue utilicemos' los m>todos &rocesos de cone7in' lectura escritura de
datos' desde :thon' siem&re serBn los mismos' mBs allB del conector.
En nuestro caso &articular' utili4aremos I#N"' &ara lo cual' vamos a traba!ar con el
mdulo *y39:db.
A di-erencia de los mdulos de la librer)a estBndar de :thon' I#N"db debe ser
instalado manualmente. :ara ello' e!ecutaremos el siguiente comando*
)udo a&t2get in)tall python,mysCldb
Conectarse a la base de datos ' e)ecutar
consultas
:ara conectarnos a la base de datos e!ecutar cual@uier consulta' el &rocedimiento
consiste en*
1. Abrir la cone7in crear un &untero
2. E!ecutar la consulta
3. =raer los resultados Lsi de una seleccin se trataM o hacer e-ectiva la escritura
Lcuando se inserta' actuali4a o eliminan datosM
0. Cerrar el &untero la cone7in
)os resultados de una consulta de seleccin, se
reci!en en una tupla, cuyos elementos, son otras
tuplas, conteniendo el alor de cada campo
seleccionado de la ta!la, en el orden 0ue han sido
seleccionados.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(2
www.detodoprogramacion.com
%na forma sim&"e 'e acce'er a bases 'e 'atos
i*&o(t 0%Ae^d6
HU;/OA$ < Nlocalho)tN
HU;aACE < N(ootN
HU;,BAA < N*%)Kl(ootN
HU;@B0C < NaN
def (un;Kue(%(Kue(%<NN):
dato) < [HU;/OA$, HU;aACE, HU;,BAA, HU;@B0C"
conn < 0%Ae^d6connect(Gdato)) # Conectar a la base de datos
cu()o( < conncu()o(() # Crear un cursor
cu()o(e#ecute(Kue(%) # Ejecutar una consulta
if Kue(%u&&e(())ta(t)Yith(NAC^CC$N):
data < cu()o(fetchall() # Traer los resultados de un select
el)e:
connco**it() # Hacer efectiva la escritura de datos
data < @one
cu()o(clo)e() # Cerrar el cursor
connclo)e() # Cerrar la conei!n
(etu(n data
Insertar 'atos
dato < (aY;in&ut('Hato: ')
Kue(% < '?@ACE$ ?@$O 6 (62) =B^aCA (NI)N)' I dato
(un;Kue(%(Kue(%)
Se"eccionar to'os "os registros
Kue(% < 'AC^CC$ 61, 62 DEO0 6 OEHCE Ug 62 HCAC'
(e)ult < (un;Kue(%(Kue(%)
&(int (e)ult
Se"eccionar so"o registros coinci'entes
c(ite(io < (aY;in&ut('?ng(e)e c(ite(io de 6T)Kueda: ')
Kue(% < 'AC^CC$ 61, 62 DEO0 6 i/CEC 62 < NI)N' I c(ite(io
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(2%
www.detodoprogramacion.com
(e)ult < (un;Kue(%(Kue(%)
&(int (e)ult
E"iminar registros
c(ite(io < (aY;in&ut('?ng(e)e c(ite(io &- eli*ina( coincidencia): ')
Kue(% < 'HC^C$C DEO0 6 i/CEC 62 < NI)N' I c(ite(io
(un;Kue(%(Kue(%)
Actua"i6ar 'atos
61 < (aY;in&ut('?H: ')
62 < (aY;in&ut('@ue4o 4alo(: ')
Kue(% < 'a,HB$C 6 AC$ 62<NI)N i/CEC 61 < Ii' I (62, int(61))
(un;Kue(%(Kue(%)
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(24
www.detodoprogramacion.com
Corriendo
P't(on 4pps en
la :eb

En este ca&)tulo' nos concentraremos en a&render' como servir a&licaciones :thon en la
8eb' corriendo ba!o A&ache' &ero sin utili4ar un -rame,or.' a @ue el ob!etivo de este
curso es entender el &roceso de ra4onamiento &ara obtener la res&uesta a Gcmo resolver
necesidades &untualesH.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(28
13
www.detodoprogramacion.com
Introduccin
E7isten en el mercado' varios -rame,or.s @ue nos &ermiten crear a&licaciones :thon
robustas' de manera rB&ida servirlas a trav>s de 3nternet' en un sitio 8eb tradicional.
Algunos de ellos' &oseen una ar@uitectura &articular' como es el caso de $!ango' @ue
utili4a un &atrn ar@uitectnico denominado I<= Lmodel-vie,-tem&lateM' basado en I<C
Lmodel-vie,-controllerM &ero @ue &rescinde del motor de >ste* es decir' del controlador.
5tro -rame,or. mu robusto tambi>n' es 8eb2:' @uien se caracteri4a &or tener una
curva de a&rendi4a!e menor @ue la de $!ango.
#in embargo' &ara crear a&licaciones :thon con estos -rame,or.s' algunos re@uisitos
deben ser tenidos en cuenta*
:ara crear a&licaciones escalables mantenibles' @ue guarden un diseUo
ar@uitectnico coherente' es im&rescindible tener un e7celente dominio de la
&rogramacin orientada a ob!etos am&lios conocimientos sobre &atrones
ar@uitectnicos &atrones de diseUoR
Como todo marco de traba!o' &oseen sus &ro&ios m>todos as) como una sinta7is
&seudo-lengua!e &ro&ios' los cuales demandan invertir un tiem&o considerable en
a&render a utili4arlos. Es decir' no se re@uiere Ga&render a &rogramar un nuevo
lengua!eH ni mucho menos Ga&render a &rogramar con ellosH' sino @ue &or el
contrario' lo necesario es Ga&render a utili4arlosH Les como a&render a utili4ar un
nuevo so-t,areM. D esto' insume much)simo tiem&o &ara @ue el a&rendi4a!e sea
-ruct)-ero el a&rovechamiento del -rame,or.' bene-iciosoR
#on -rame,or.s mu robustos' &ensados &ara el desarrollo de grandes
a&licaciones. :or ello' debe considerarse la &osibilidad de &rescindir de ellos'
cuando lo @ue se necesite' sea una a&licacin liviana' a @ue el consumo de
recursos el rendimiento' no estarB com&ensado &or la robuste4 del desarrollo.
:ero mBs allB de todo lo anterior' la me!or -orma de entender un -rame,or.' es
com&render el lengua!e en el @ue han sido desarrollados la -orma en la @ue >stos' han
logrado llegar a resolver una necesidad* servir a&licaciones :thon a trav>s de la 8eb.
-n este cap2tulo, nos concentraremos en aprender,
como servir aplicaciones Python en la *eb
corriendo bajo +pache pero sin utili,ar un
framewor$ ya 0ue el objetivo de este curso es
entender el proceso de ra,onamiento para obtener la
respuesta a -cmo resolver necesidades puntuales..
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(2/
www.detodoprogramacion.com
P't(on ba)o 4pac(e
Como si de una receta de cocina se tratara' vamos a a&render c&mo ser5ir aplicaciones
=eb con Python+ utiliEando el ser5idor <pache.
No es mucha la bibliogra-)a @ue &uede encontrarse al res&ecto' &ero s)' lo es bastante
con-usa hasta incluso contradictoria. :or eso' en este curso' nos vamos a &ro&oner
mantener el es&)ritu de sim&licidad de :thon' encontrando la manera sim&le de hacerlo.
=Hu> necesitamos?
En &rinci&io' necesitamos hacer @ue A&ache' incor&ore un so&orte &ara servir archivos
:thon. :ara ello' necesitaremos habilitarle un mdulo' @ue brinde este so&orte.
E7isten varios mdulos de A&ache @ue brindan so&orte &ara correr archivos :thon. %no
de los mBs &o&ulares es el mdulo mod.python' @ue sin embargo' &resenta algunos
&roblemas Ldescri&tos en htt&*++docs.&thon.org+release+2./+ho,to+,ebservers.htmlWmod-
&thonM @ue &ueden &revenirse' utili4ando el mdulo mod.Asgi
Lhtt&*++docs.&thon.org+release+2./+ho,to+,ebservers.htmlWmod-,sgiM el cula utili4aremos
en este curso.
1. Insta"aci)n 'e mo'Jwsgi en A&ache
:ara habilitar modO,sgi en A&ache' basta con instalar el &a@uete liba&ache2-mod-,sgi*
)udo a&t2get in)tall libapache2,mod,Asgi
2. Crear "a estructura 'e 'irectorios &ara nuestra a&"icaci)n
:rimero' es im&ortante saber' como va a -uncionar nuestra a&licacin cmo va a
interactuar v)a 8eb.
$ebemos tener un directorio destinado a montar toda la aplicaci&n*
mBdir 5ho*e5%o5cu()o2&%thon5t(un:5python,Aeb
$entro de este directorio' vamos a di5idir su ar,uitectura en dos partes*
1M $estinada al almacena!e de nuestra a&licacin :thon &ura LserB un directorio
&rivado' no servidoM
2M $estinada a servir la a&licacin Ldirectorio &9blico servidoM en el cuBl solo
almacenaremos archivos estBticos
mBdir 5ho*e5%o5cu()o2&%thon5t(un:5&%thon2Ye65mypythonapp
mBdir 5ho*e5%o5cu()o2&%thon5t(un:5&%thon2Ye65public.html
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(2)
www.detodoprogramacion.com
$entro de nuestro directorio *%&%thona&&' almacenaremos entonces' todos los mdulos
&a@uetes de nuestra a&licacin :thon' mientras @ue en &u6lic;ht*l' estarBn todos
los archivos estBticos serB el 9nico directorio al @ue se &ueda acceder mediante el
navegador 8eb.
A&rovecharemos este &aso' &ara crear una car&eta' destinada a almacenar los logs de
errores accesos a nuestra 8eb A&&*
mBdir 5ho*e5%o5cu()o2&%thon5t(un:5&%thon2Ye65logs
$. Crear un contro"a'or &ara "a a&"icaci)n
=odas las &eticiones reali4adas &or el usuario Les decir' las %(3 a las cuBles el usuario
acceda &or el navegadorM' serBn mane!adas &or un 9nico archivo' @ue estarB almacenado
en nuestro directorio *%&%thona&&.
echo NJ 2G2 coding: utf28 2G2N + *%&%thona&&5controller.py
Este archivo cont(olle(&% actuarB como un &seudo D(ontCont(olle(
2
' siendo el
encargado de mane!ar todas las &eticiones del usuario' haciendo la llamada a los mdulos
corres&ondientes seg9n la %(3 solicitada.
$icho mdulo' solo se encargarB de de-inir una -uncin' @ue act9e con cada &eticin del
usuario. Esta -uncin' deber7 ser una .unci&n =3B0 application 57lida. Esto
signi-ica @ue*
1. $eberB llamarse application
2. $eberB recibir dos &arBmetros* en"iron' del mdulo os' @ue &rovee un diccionario
de las &eticiones J==: estBndar otras variables de entorno' la -uncin
start.response' de 8#63' encargada de entregar la res&uesta J==: al
usuario.
def application(en"iron, start.response):
# "enero la salida HT#L a mostrar al usuario
out&ut < 'V&+Uien4enido a *i V6+,%thonB&&V56+111V5&+'
# $nicio una res%uesta al navegador
)ta(t;(e)&on)e(N200 OjN, [(NContent2$%&eN, Nte#t5ht*lh cha()et<utf28N)")
# &etorno el contenido HT#L
(etu(n out&ut
IBs adelante' veremos como crear un &pplication 'S() Controller' mucho mBs
&otente.
2 -ront Controller :atrn de diseUo* htt&*++en.,i.i&edia.org+,i.i+?rontOControllerO&attern
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(2'
www.detodoprogramacion.com
L. Configurar e" 2irtua"Eost
En la buena con-iguracin de nuestro =i(tual/o)t' estarB la clave &ara correr nuestra
a&licacin :thon a trav>s de la 8eb.
Iientras @ue el Hocu*entEoot de nuestro sitio 8eb' serB la car&eta &9blica'
&u6lic;ht*l' una variable del =i(tual/o)t' serB la encargada de redirigir todas las
&eticiones &9blicas del usuario' hacia nuestro D(ontCont(olle(. D la variable @ue se
encargue de esto' serB el alias iAG?Ac(i&tBlia)*
)udo nano 5etc5a&ache25)ite)2a4aila6le5&%thon2Ye6
%na ve4 all)' escribimos el contenido del nuevo virtual host*
V=i(tual/o)t G:80+
Ae(4e(@a*e &%thon2Ye6
&ocumentRoot MhomeMyoMcurso,pythonMtrunBMpython,AebMpublic.html
SS?(Script8lias M MhomeMyoMcurso,pythonMtrunBMpython,AebMmypythonappMcontroller.py
C((o(^og 5ho*e5%o5cu()o2&%thon5t(un:5&%thon2Ye65log)5e((o()log
Cu)to*^og 5ho*e5%o5cu()o2&%thon5t(un:5&%thon2Ye65log)5acce))log co*6ined
VHi(ecto(% 5+
O&tion) DolloYA%*^in:)
BlloYO4e((ide Bll
V5Hi(ecto(%+
V5=i(tual/o)t+
%na ve4 con-igurado nuestro <irtualJost*
1M Jabilitamos el sitio 8eb* sudo a2ensite python,Aeb
2M (ecargamos A&ache* sudo ser"ice apache2 reload
3M Jabilitamos el sitio en nuestro host* sudo nano MetcMhosts all) agregamos la
siguiente l)nea* 427.3.3.4 python,Aeb
A &artir de ahora' si abrimos nuestro navegador 8eb e ingresamos la url htt&*++&thon-,eb
veremos la -rase* Bienvenido a mi Python<pp.
Agregar un nueo hostname a nuestro 3etc3hosts nos
permitir seguir tra!a"ando normalmente con nuestro
localhost, sin 0ue nuestras aplicaciones Python
interfieran con otras, ya sean we!s estticas en 564L
o dinmicas en P5P u otro lengua"e.
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(;
www.detodoprogramacion.com
#tili.ando en"iron para mane)ar peticiones del
usuario
El diccionario en4i(on del mdulo o)' nos &rovee de la %(3 solicitada &or el usuario' a
trav>s de la clave ECeaCA$;aE?. <ali>ndonos de ella' &odremos crear una A&&lication
8#63 Controller mucho mBs &otente' @ue nos &ermita hacer s,itch de la &eticin' &ara
saber a @u> mdulo llamar.
:ara ello a -in de &oder mane!ar im&orts absolutos evitando inconvenientes' &rimero
debemos crear un archivo ..init...py en *%&%thona&& luego' agregar el &ath de
nuestra a&licacin en nuestro controller.&' &ara @ue :thon bus@ue all) nuestros mdulos*
f(o* )%) i*&o(t &ath
&atha&&end(N5ho*e5%o5cu()o2&%thon5t(un:5&%thon2Ye65N)
Ahora' todos nuestros im&orts los &odremos hacer con el namespace absoluto' desde
*%&%thona&&. :or e!em&lo*
f(o* *%&%thona&&*i;&aKuete i*&o(t *i;*odulo
Nuestra a&&' &odr)a &or e!em&lo' tener un &a@uete llamado )itioYe6. $entro de este
&a@uete' &odr)a tener varios mdulos' corres&ondientes a cada una de las secciones de
nuestro sitio. <ali>ndonos de la clave (EN%E#=O%(3 de environ' &odr)amos hacer un
s,itch como el @ue sigue*
f(o* )%) i*&o(t &ath
&atha&&end(N5ho*e5eugenia56o((ado(5&%thon2Ye65N)
f(o* *%&%thona&&)itioYe6 i*&o(t contacto, default
def a&&lication(en4i(on, )ta(t;(e)&on)e):
peticion / en"iron71RE[OES$.OR(1:
if peticion.startsAith01Mcontacto15:
out&ut < contactofo(*ula(io()
elif peticion.startsAith01Mgracias15:
out&ut < contactog(acia)()
el)e:
out&ut < defaultdefault;&age()
)ta(t;(e)&on)e(N200 OjN, [(NContent2$%&eN, Nte#t5ht*lh cha()et<utf28N)")
(etu(n out&ut
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
((
www.detodoprogramacion.com
%mportante: siempre, tras hacer un cam!io a tu
aplicacin, debes reiniciar +pache para que los
cambios se vean reflejados de manera correcta# sudo
ser"ice apache2 restart
Al ingresar a htt&*++&thon-a&&+contacto' el contenido mostrado serB el retornado &or la
-uncin fo(*ula(io() del mdulo contacto del &a@uete )itioYe6
#i en cambio' ingresBramos en htt&*++&thon-a&&+gracias' ver)amos el contenido retornado
&or la -uncin g(acia)() del mismo mdulo.
D si la %(3 solicitada no -uese ni una ni otra' siem&re se mostrarB el contenido retornado
&or la -uncin default;&age() del mdulo default del &a@uete )itioYe6
6en en cuenta 0ue ningn print de tu app ser
tenido en cuenta. 6odas las funciones de tu app,
tendrn 0ue hacer un return del contenido 0ue
desees mostrar al usuario, para 0ue el Application
='>7 (ontroller, se encargue de entregarlos a ='>7
y ste, de mostrarlos al usuario.
Descarga el ejemplo de este cap#tulo' ingresando en*
htt&*++curso-&thon.eugeniabahit.com+sources+&thon-,eb.tar.g4
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(2
www.detodoprogramacion.com
,niando e*mails
con 1ormato
;TM% desde
P't(on

Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(
14
www.detodoprogramacion.com
Pa0uetes necesarios
:ara &oder enviar e-mail desde nuestro servidor Lu ordenador localM' en &rimer lugar' es
necesario contar con un *!< L<ail "ranspor 5gent o GAgente de trans&orte de correoHM.
%no de los I=A mBs &o&ulares &ara sistemas %N3P-"i.e' es sin dudas' el -amoso
sendmail.
:ara de!ar nuestro servidor u ordenador local' listo &ara enviar mensa!es de correo
electrnico a trav>s de 3nternet' solo serB necesario entonces' instalar )end*ail*
)udo a&t2get in)tall )end*ail
,no de e*mail desde P't(on
:ara enviar e-mails desde :thon' >ste nos &rovee smt&lib' otro mdulo de la librer)a
estBndar de :thon' @uien nos &ermitirB enviar mensa!es de correo electrnico' incluso'
en -ormato J=I".
#olo necesitaremos*
Crear un objeto smtplib.S*$P el cuBl recibirB como &arBmetro de su m>todo
constructor' el host LlocalhostM
Crear un mensa!e de correo
Enviar el mensa!e mediante una llamada al m2todo sendmail del ob!eto #I=:.
IBs -Bcil es mirando el cdigo*
J 2G2 coding: utf28 2G2
import smtplib
remitente < 'He)de gnucita Ve6ahit@*e*6e(f)fo(g+'
destinatario < '0a*a de Gnucita Veugenia6ahit@g*ailco*+'
asunto < 'C2*al /$0^ en4iado de)de ,%thon'
mensaje < '''/ola1V6(5+ V6(5+
C)te e) un V6+e2*ailV56+ en4iando de)de V6+,%thonV56+
'''
email / 'rom+ Ys
$o+ Ys
*(*E,Version+ 4.3
<ontent,type+ te6tMhtml
Subject+ Ys
I)
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(%
www.detodoprogramacion.com
''' I ((e*itente, de)tinata(io, a)unto, *en)a3e)
t(%:
)*t& < smtplib.S*$P01localhost15
)*t&.sendmail0remitente2 destinatario2 email5
&(int 'Co((eo en4iado'
e#ce&t:
&(int '''C((o(: el *en)a3e no &udo en4ia()e
Co*&(ue6e Kue )end*ail )e encuent(a in)talado en )u )i)te*a'''
As) de sim&le' enviamos un e-mail con :thon*
i*&o(t )*t&li6
3m&ortamos el mdulo smt&lib.
"uego' de-inimos las variables necesarias &ara el env)o del mensa!e Lremitente'
destinatario' asunto mensa!e -en -ormato J=I"-M*
(e*itente < 'He)de gnucita Ve6ahit@*e*6e(f)fo(g+'
de)tinata(io < '0a*a de Gnucita Veugenia6ahit@g*ailco*+'
a)unto < 'C2*al /$0^ en4iado de)de ,%thon'
*en)a3e < '''/ola1V6(5+ V6(5+
C)te e) un V6+e2*ailV56+ en4iando de)de V6+,%thonV56+
'''
A continuacin' generamos el e-mail con todos los datos de-inidos anteriormente*
e*ail < '''D(o*: I)
$o: I)
0?0C2=e()ion: 10
Content2t%&e: te#t5ht*l
Au63ect: I)
I)
''' I ((e*itente, de)tinata(io, a)unto, *en)a3e)
D -inalmente' creamos un ob!eto smt&*
)*t& < )*t&li6A0$,(Nlocalho)tN)
D reali4amos el env)o*
)*t&)end*ail((e*itente, de)tinata(io, e*ail)
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(4
www.detodoprogramacion.com
En@o 'e e-mai"s a m0"ti&"es 'estinatarios
:ara enviar un e-mail a m9lti&les destinatarios' solo serB necesario generar una lista con
los destinatarios*
de)tinata(io) < [N,e()ona B V*ailde&e()onaB+N, N,e()ona U V*ailde&e()onaU+N"
Agregar una 'irecci)n 'e res&uesta 'iferente
Cuando generamos el e-mail' es necesario saber' @ue todo ti&o de cabeceras vBlidas'
&ueden agregarse. 3ncluso (e&l-=o*
e*ail < '''D(o*: I)
$o: I)
Reply,$o+ noreply\algundominio.com
0?0C2=e()ion: 10
Content2t%&e: te#t5ht*l
Au63ect: I)
I)
''' I ((e*itente, de)tinata(io, a)unto, *en)a3e)
Curso Python para Principiantes Eugenia Bahit ,,,.eugeniabahit.com+cursos2012
Com&arte el conocimiento* Creative Commons Atribucin-NoComercial-Com&artir3gual 3.0
(8
www.detodoprogramacion.com

Juegos, Revistas, Cursos, Software, Sistemas Operativos, Antivirus y
ms Gratis para el Conocimiento...!
www.detodoprogramas.com
Vistanos y comprubalo



Material para los amantes de la Programacin Java,
C/C++/C#,Visual.Net, SQL, Python, Javascript, Oracle, Algoritmos,
CSS, Desarrollo Web, Joomla, jquery, Ajax y Mucho Mas
www.detodoprogramacion.com
Visitanos

Libros Universitarios, Contabilidad, Matemticas, obras literarias,
Administracin, ingeniera y mas