Python para Principiantes

Eugenia Bahit
Curso: Python para Principiantes

www.eugeniabahit.com www.detodoprogramacion.com
Eugenia Bahit 2012. Creative Commons Atribucin-NoComercial 3.0 Comparte el conocimiento en libertad!
Python para Principiantes de Eugenia Bahit se distribu e ba!o una "icencia Creative Commons AtribucinNoComercial-#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 Creati e 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
www.detodoprogramacion.com
Descarga todos los ejemplos de este libro los talleres del curso' ingresando en
htt&*++curso-& thon.eugeniabahit.com+sources.tar.g4
00
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
#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 ma 9scula la &rimera letra.................................................................................................;1 Convertir una cadena a min9sculas...................................................................................................... ;1 Convertir una cadena a ma 9sculas..................................................................................................... ;1 Convertir ma 9sculas 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 ma 9sculas...................................................................................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' sustitu endo 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
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 s s........................................................................................................................................... 12 <ariables del mdulo s s................................................................................................................. 12 I>todos del mdulo s s.................................................................................................................. 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/
: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 ma 9sculas* "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
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
01
2. : thon 2./
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 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
'
Introduccin al Sistema Operati o !"#$%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 Catalun aM #istema o&erativo gnu linu7 basico L%niversitat 5bierta de Catalun aM
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
(;
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&erati o

: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.
((
Instalando P't(on
%na ve4 @ue ha as 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
(2
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
Instalacin de un S(ell interacti o 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*
(%
"in)a*I+,
Nin!a-3$E es un Entorno 3ntegrado de $esarrollo 1 @ue nos &ermitirB' crear &ro ectos 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
(4
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 va an e-ectuando en los archivos -&re-erentemente automBtico-' &ermitir el establecimiento de tags -eti@uetas- @ue a uden 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
(8
grB-icas. En este curso' nos centraremos en el uso &or medio de l)nea de comandos. "os #C<' en su ma or)a - a rasgos generales- cuentan con un con!unto de -uncionalidades' las cuales' &ara cada una' e7iste un determinado comando Lgeneralmente' similar en la ma or)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@!! 228 82 935ho*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:5 67(56(anch56(anch conf
Iueve el cursor hasta la siguiente l)nea
&ulsa las teclas Ctrl S C*
&a(ent;location < )ft&:55tu_usuario@!! 228 82 935ho*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@!! 228 82 935ho*e5tu_usuario5&u6lic5t(un: &a(ent;location < )ft&:55tu_usuario@!! 228 82 935ho*e5tu_usuario5&u6lic5t(un: &a(ent;location < )ft&:55tu_usuario@!! 228 82 935ho*e5tu_usuario5&u6lic5t(un:
(eem&la4a la &alabra GparentH de la segunda l)nea' &or GpushH de -orma tal @ue el archivo' se vea como sigue*
la de la tercera' &or G pullH
&a(ent;location < )ft&:55tu_usuario@!! 228 82 935ho*e5tu_usuario5&u6lic5t(un: push;location < )ft&:55tu_usuario@!! 228 82 935ho*e5tu_usuario5&u6lic5t(un: pull;location < )ft&:55tu_usuario@!! 228 82 935ho*e5tu_usuario5&u6lic5t(un:
:ara guardar el archivo &ulsa las teclas Ctrl S 5 LenterM
&ara salir' &ulsa Ctrl S P.
(/
02
,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 ma or)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.
()
B:13<G01
:enguaje in.orm7tico:es un idioma arti-icial' utili4ado &or ordenadores' cu o -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 cu a 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 ma or &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 cu as 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.
('
,lementos del %engua)e

Como en la ma or)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 variable.
un valor' el cual de-ine a la ve4' el ti&o de datos de la
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 < *i;4a(ia6le < 12 12 > *i4a(ia6le < 12 > *i;4a(ia6le<12 >
PEP ): constantes %tili4ar nombres descri&tivos &alabras &or guiones ba!os.

Ejemplo: 0?;CO@A$B@$C < 12
en ma 9sculas se&arando
: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.
2;
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 < -438 28
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.
2(
5&eradores Aritm>ticos
Entre los o&eradores aritm>ticos @ue : thon utili4a' &odemos encontrar los siguientes*
Smbolo . 2 2 G GG 5 55 I Significado Au*a Ee)ta @egaciFn 0ulti&licaciFn C#&onente Hi4i)iFn Hi4i)iFn ente(a 0Fdulo Ejemplo a a a a a a a a < < < < < < < < 10 . 8 12 2 28 - G 8 2 GG 3 12 8 5 2 12 8 5 2 2- I 4 Resultado a a a a a a a a e) e) e) e) e) e) e) e) 18 8 28 38 8 ! 28 ! 0 3
PEP ): operadores #iem&re colocar un es&acio en blanco' antes o&erador
des&u>s de un
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)
22
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 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
se e7&resan de
En los comentarios' &ueden incluirse &alabras @ue nos a uden 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
=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, 2 8, 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" &(int *i;tu&la[3:" &(int *i;tu&la[:2" J He4uel4e: (18, 2 8, Not(o datoN) J He4uel4e: (Not(o datoN, 28) 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" &(int *i;tu&la[22" J Aalida: 28 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
2%
*i;li)ta < [Ncadena de te#toN, 18, 2 8, 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" &(int *i;li)ta[1:4" &(int *i;li)ta[22" J Aalida: 18 J He4uel4e: [18, 2 8, Not(o datoN" J Aalida: ot(o dato
"as lista N5 son inmutables* &ermiten modi-icar los datos una ve4 creados*
*i;li)ta[2" < 3 8 J el te(ce( ele*ento aho(a e) 3 8
"as listas' a di-erencia de las tu&las' &ermiten agregar nuevos valores*

*i;li)ta a&&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
24
,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 ma or 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)
28
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 valor concreto a cada una*
+++ &(int a )t(ing +++ &(int 6 18 +++ &(int c $(ue
asignBndoles un
"a asignacin m9lti&le de variables' tambi>n &uede darse utili4ando como valores' el
2/
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)
2)
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 te tual 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.
2'
"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 ma or 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
Estructuras 'e contro" iterati as

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) ?nfo(*e) ?nfo(*e) ?nfo(*e) ?nfo(*e) ?nfo(*e) ?nfo(*e) ?nfo(*e) ?nfo(*e) ?nfo(*e) ?nfo(*e) ?nfo(*e) del del del del del del del del del del del del aXo aXo aXo aXo aXo aXo aXo aXo aXo aXo aXo aXo 2001 2002 2003 2004 2008 200! 2002008 2009 2010 2011 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 L anio V< 2012M siem&re se estar)a cum&liendo.
: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' inclu e 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)
03
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.
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
"a instruccin i*&o(t seguida de no*6(e;del;&aKuete no*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
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 &(int &(int &(int C1 C2 CA1 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
04
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.
+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*
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
'
)aluda((mensaje/ 9uen da 2 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 uno 2 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*
%;
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 / H descuento + 432 &(int calcula((@@datos) importe + 4G33I
%lamadas de retorno
En : thon' es &osible Lal igual @ue en la gran ma or)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
%(
&(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 ;aura 5 &(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 'acundo 5
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"('âu(a') el)e: (etu(n 'DunciFn no encont(ada' &(int lla*ada;de;(eto(no('funcion') no*6(e;de;la;funcion < 'funcion'
%2
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 recursi as
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 .
05
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.
%%
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 ma or 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
%4
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 ma or &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$ LelM 5b!eto <!G0B6!1 "locuci&n adjeti5a$ Les deM color Les deM tamaUo Les deM as&ecto C6<:0D<D DE: <!G0B6!1 "adjeti5o$ <erde 6rande ?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*
%8
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$ Ltiene algunasM antenas LelM 5b!eto Ltiene unM o!o Ltiene unos cuantosM &elos <!G0B6!13 "locuci&n adjeti5a$ LdeM color LdeM longitud LdeM -orma LdeM color LdeM tamaUo LdeM color LdeM te7tura C6<:0D<DE3 DE :13 <!G0B6!13 "adjeti5o$ <ioleta e7tensa 5val a4ul grande ?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 ob eto?! con la -rase El ob eto es"""! S ad!etivo Latributos de-inidos &or cualidadesM 2M "os @ue res&onden a la &regunta #u tiene el ob eto?! con la -rase El ob eto
%/
tiene"""! S sustantivo Latributos de-inidos &or las cualidades de otro ob!etoM <eBmoslo a9n' mBs grB-icamente* Objeto color tamao aspecto antenas ojos pelos Pelo
Antena
color
longitud Ojo
color
textura
forma
color
tamao
<iendo el grB-ico anterior' tenemos lo siguiente* 2n ob eto )sustanti/o. al cual hemos descrito con tres atributos )adjeti/os. y otros tres atributos$ob eto )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 ob eto, 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.
%)
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.
%'
Objeto color tamao aspecto antenas ojos pelos Pelo
Nuevo Objeto Pie Pie color
Antena
longitud Ojo
color
textura
forma
color
dedos Dedo
forma
color
tamao
longitud
forma
color
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
4;
El nuevo ob!eto LademBsM puede saltar #i com&letamos el grB-ico anterior con las acciones' obtendremos lo siguiente* Objeto Flotar color tamao aspecto antenas ojos pelos Pelo
Nuevo Objeto Pie Pie
Saltar color
Antena
longitud Ojo
color
textura
forma
color
dedos Dedo
forma
color
tamao
longitud
forma
color
#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.
4(
A" &an, &an. < a" ino, ino. -as cosas &or su nombre
Cuando en el documento... Jablamos de Gob!etoH Jablamos de GatributosH Lo cualidadesM Jablamos de GaccionesH @ue &uede reali4ar el ob!eto Jablamos de Gatributos-ob!etoH <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 Jablamos de ob!etos @ue son sub-ti&os Lo am&liacinM de otros En la programaci&n se denomina... 1bjeto Propiedades *2todos Composici&n Polimor.ismo R con respecto a la programaci&n orientada a objetos es... %n elemento %n elemento %n elemento %na t>cnica %na caracter)stica
?erencia
%na caracter)stica
Ahora' &asemos a un marco un &oco mBs Gacad>micoH.
42
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 veremos a continuacin. / caracter)sticas @ue
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:
&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() o3o) < O3o() &elo) < ,elo()
J &(o&iedad co*&ue)ta &o( el o63eto o63eto Bntena J &(o&iedad co*&ue)ta &o( el o63eto o63eto O3o 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
4%
t>cnicamente se denominan m>todos' 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))
re&resentan acciones &ro&ias @ue &uede reali4ar
/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 et colo( &(int et ta*anio &(int et a)&ecto et colo( < '(o)a' &(int et colo(
EerenciaC caracter@stica &rinci&a" 'e "a 811

Como comentamos en el t)tulo anterior' algunos ob!etos com&arten las mismas
44
&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
48
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 o63eto ot(a;&(o&iedad < '@ue4o 4alo(' 4a(ia6le < o63eto *etodo() &(int 4a(ia6le &(int o63eto ot(o;*etodo()
4/
06
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 cu o 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.
4)
M2todos de 1ormato
Con ertir a ma'3scula la primera letra *2todo: ca&itali4eLM Getorna: una co&ia de la cadena con la &rimera letra en ma 9sculas
+++ cadena < '6ien4enido a *i a&licaciFn' +++ &(int cadena capitaliJe05 Uien4enido a *i a&licaciFn
Con ertir una cadena a min3sculas *2todo: lo,erLM Getorna: una co&ia de la cadena en min9sculas
+++ cadena < '/ola 0undo' +++ &(int cadena loAer05 hola *undo
Con ertir una cadena a ma'3sculas *2todo: u&&erLM Getorna: una co&ia de la cadena en ma 9sculas
+++ cadena < '/ola 0undo' +++ &(int cadena upper05 /O^B 0a@HO
Con ertir ma'3sculas a min3sculas ' ice ersa *2todo: s,a&caseLM Getorna: una co&ia de la cadena convertidas las ma 9sculas en min9sculas
+++ cadena < '/ola 0undo' +++ &(int cadena sAapcase05 hO^B *a@HO
viceversa
Con ertir una cadena en Formato Ttulo *2todo: titleLM

4'
Getorna: una co&ia de la cadena convertida

+++ cadena < 'hola *undo' +++ &(int cadena title05 /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 cadena center0G32 / 5 <<<<<<<<<<<Uien4enido a *i a&licaciFn<<<<<<<<<<<< +++ &(int cadena center0G32 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 cadena ljust0G32 / 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 cadena rjust0G32 / 5 <<<<<<<<<<<<<<<<<<<<<<<Uien4enido a *i a&licaciFn +++ &(int cadena rjust0G32 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
8;
+++ nu*e(o;factu(a < 18-8 +++ &(int )t((nu*e(o;factu(a) Jfill0425 0000000018-8
8(
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 cadena count0 a 5 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 cadena find0 mi 5 13 +++ &(int cadena find0 mi 2 32 435 21
82
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 cadena startsAith0 9ien"enido 5 $(ue +++ &(int cadena startsAith0 aplicaciKn 5 Dal)e +++ &(int cadena startsAith0 aplicaciKn 2 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 +++ &(int cadena endsAith0 $(ue +++ &(int cadena endsAith0 Dal)e +++ &(int cadena endsAith0 $(ue *i a&licaciFn' ca&itali7e() aplicaciKn 5 9ien"enido 5 9ien"enido 2 32 435
Saber si una cadena es al1anum2rica *2todo: isalnumLM Getorna: =rue o ?alse

+++ cadena < '&e&eg(illo -8' +++ &(int cadena isalnum05 Dal)e +++ cadena < '&e&eg(illo' +++ &(int cadena isalnum05 $(ue +++ cadena < '&e&eg(illo-8' +++ &(int cadena isalnum05 $(ue
Saber si una cadena es al1ab2tica *2todo: isal&haLM Getorna: =rue o ?alse

+++ cadena < '&e&eg(illo -8' +++ &(int cadena isalpha05 Dal)e +++ cadena < '&e&eg(illo' +++ &(int cadena isalpha05 $(ue +++ cadena < '&e&eg(illo-8' +++ &(int cadena isalpha05 Dal)e
Saber si una cadena es num2rica *2todo: isdigitLM Getorna: =rue o ?alse

+++ cadena < '&e&eg(illo -8' +++ &(int cadena isdigit05 Dal)e +++ cadena < '-884' +++ &(int cadena isdigit05 $(ue +++ cadena < '-8 84' +++ &(int cadena isdigit05 Dal)e +++ cadena < '-8 84' +++ &(int cadena isdigit05 Dal)e
Saber si una cadena contiene solo min3sculas *2todo: islo,erLM Getorna: =rue o ?alse
+++ cadena < '&e&e g(illo' +++ &(int cadena isloAer05 $(ue +++ cadena < ',e&e G(illo' +++ &(int cadena isloAer05 Dal)e +++ cadena < ',e&eg(illo' +++ &(int cadena isloAer05 Dal)e +++ cadena < '&e&eg(illo-8' +++ &(int cadena isloAer05
8%
$(ue
Saber si una cadena contiene solo ma'3sculas *2todo: isu&&erLM Getorna: =rue o ?alse
+++ cadena < ',C,C GE?^Ô' +++ &(int cadena isupper05 $(ue +++ cadena < ',e&e G(illo' +++ &(int cadena isupper05 Dal)e +++ cadena < ',e&eg(illo' +++ &(int cadena isupper05 Dal)e +++ cadena < ',C,CGE?^Ô' +++ &(int cadena isupper05 $(ue
Saber si una cadena contiene solo espacios en blanco *2todo: iss&aceLM Getorna: =rue o ?alse
+++ cadena < '&e&e g(illo' +++ &(int cadena isspace05 Dal)e +++ cadena < ' ' +++ &(int cadena isspace05 $(ue
Saber si una cadena tiene Formato +e Ttulo *2todo: istitleLM Getorna: =rue o ?alse
+++ cadena < ',e&e G(illo' +++ &(int cadena istitle05 $(ue +++ cadena < ',e&e g(illo' +++ &(int cadena istitle05 Dal)e
84
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 cadena format0 en Python 5 6ien4enido a *i a&licaciFn en ,%thon +++ cadena < '?*&o(te 6(uto: $O0Q . ?=B: $O1Q < ?*&o(te neto: O2Q' +++ &(int cadena format04332 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 cadena format0bruto/4332 i"a/242 neto/4245 ?*&o(te 6(uto: $100 . ?=B: $21 < ?*&o(te neto: 121 +++ &(int cadena format0bruto/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
+++ +++ YYY +++ YYY cadena < ' YYY eugenia6ahit co* &(int cadena strip05 eugenia6ahit co* &(int cadena strip01 15 eugenia6ahit co* '
,liminar caracteres a la i.0uierda de una cadena *2todo: lstri&L\GcaracterH]M Getorna: la cadena sustituida
88
+++ cadena < 'YYY eugenia6ahit co*' +++ &(int cadena lstrip0 A. 5 eugenia6ahit co* +++ cadena < ' YYY eugenia6ahit co*' +++ &(int cadena lstrip05 YYY eugenia6ahit co*
,liminar caracteres a la derec(a de una cadena *2todo: rstri&L\GcaracterH]M Getorna: la cadena sustituida
+++ cadena < 'YYY eugenia6ahit co* +++ &(int cadena rstrip0 5 YYY eugenia6ahit co* '
8/
M2todos de unin ' di isin

#nir una cadena de 1orma iterati a *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(o join0formato.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&:55YYY eugenia6ahit co*' partition0 AAA. 5 +++ &(int tu&la (Nhtt&:55N, NYYY N, Neugenia6ahit co*N) +++ &(otocolo, )e&a(ado(, do*inio < tu&la ++++ &(int ',(otocolo: O0QPnHo*inio: O1Q' fo(*at(&(otocolo, do*inio) ,(otocolo: htt&:55 Ho*inio: eugenia6ahit co*
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' split0 2 +++ &(int :e%Yo(d) [N&%thonN, NguiaN, Ncu()oN, Ntuto(ialN" 5
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
8)
+++ te#to < '''înea 1 înea 2 înea 3 înea 4 ''' +++ &(int te#to splitlines05 [Nînea 1N, Nînea 2N, Nînea 3N, Nînea 4N" +++ te#to < 'înea 1Pnînea 2Pnînea 3' +++ &(int te#to splitlines05 [Nînea 1N, Nînea 2N, Nînea 3N"
8'
,)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' ma 9sculas' 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)
/;
07
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.
/(
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) append0 Eose 5 +++ &(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) e6tend07 Eose 2 ?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 RicBy 5 +++ &(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"
/2
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"e0 Eose 5 +++ &(int no*6(e);*a)culino) [NEic:%N, NBl4a(oN, NHa4idN, NZacintoN, NEic:%N, NZo)eN, NZo)eN"
M2todos de orden
Ordenar una lista en re ersa (in ertir 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"
/%
M2todos de b3s0ueda
Contar cantidad de apariciones elementos *2todo: countLelementoM
+++ +++ 2 +++ +++ 2 no*6(e);*a)culino) < ['Bl4a(o', '0iguel', 'Cdga(do', 'Ha4id', '0iguel'" no*6(e);*a)culino) count0 *iguel 5 no*6(e);*a)culino) < ('Bl4a(o', '0iguel', 'Cdga(do', 'Ha4id', '0iguel') no*6(e);*a)culino) count0 *iguel 5
Obtener n3mero de ndice *2todo: inde7Lelemento\' indiceOinicio' indiceO-in]M

+++ no*6(e);*a)culino) inde60 *iguel 5 1 +++ no*6(e);*a)culino) inde60 *iguel 2 22 G5 4
/4
4ne&o sobre listas ' tuplas

Con ersi)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 ha a sido declarada como lista sea necesario convertirla en una coleccin inmutable.
+++ +++ (1, +++ [1, +++ +++ [1, +++ (1, tu&la < (1, 2, 3, 4) tu&la 2, 3, 4) list0tupla5 2, 3, 4" li)ta < [1, 2, 3, 4" li)ta 2, 3, 4" tuple0lista5 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*
+++ +++ +++ +++ [1, +++ +++ +++ +++ +++ (1, li)ta1 < li)ta2 < listaF / li)ta3 2, 3, 4, tu&la1 < tu&la2 < tu&la3 < tuplaN / tu&la4 2, 3, 4, [1, 2, 3, 4" [3, 4, 8, !, -, 8" lista4 + lista2 3, 4, 8, !, -, 8" (1, 2, 3, 4, 8) (4, !, 8, 10) (3, 8, -, 9) tupla4 + tupla2 + tuplaF 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*
/8
+++ 10 +++ 8 +++ 1 +++ 8 +++ 1
ma60tuplaN5 *a#(tu&la1) min0tupla45 *a#(li)ta3) *in(li)ta1)
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
//
08
M2todos principales del ob)eto dict
/)
M2todos de eliminacin
6aciar un diccionario *2todo: clearLM
+++ dicciona(io < O'colo(': '4ioleta', 'talle': 'cA', '&(ecio': 1-4 28Q +++ &(int dicciona(io ONcolo(N: N4ioletaN, N&(ecioN: 1-4 28, NtalleN: NcANQ +++ dicciona(io.clear05 +++ &(int dicciona(io OQ
M2todos de agregado ' creacin

Copiar un diccionario *2todo: co& LM
+++ dicciona(io < O'colo(': '4ioleta', +++ (e*e(a < dicciona(io.copy05 +++ dicciona(io ONcolo(N: N4ioletaN, N&(ecioN: 1-4 28, +++ (e*e(a ONcolo(N: N4ioletaN, N&(ecioN: 1-4 28, +++ dicciona(io clea(() +++ dicciona(io OQ +++ (e*e(a ONcolo(N: N4ioletaN, N&(ecioN: 1-4 28, +++ *u)culo)a < (e*e(a +++ (e*e(a ONcolo(N: N4ioletaN, N&(ecioN: 1-4 28, +++ *u)culo)a ONcolo(N: N4ioletaN, N&(ecioN: 1-4 28, +++ (e*e(a clea(() +++ (e*e(a OQ +++ *u)culo)a OQ +++ 'talle': 'cA', '&(ecio': 1-4 28Q NtalleN: NcANQ NtalleN: NcANQ
NtalleN: NcANQ NtalleN: NcANQ NtalleN: NcANQ
Crear un nue o 'iccionario 'es'e "as c"a es 'e una secuencia

*2todo: dict.-rom.e sLsecuencia\' valor &or de-ecto]M
/'
+++ )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': 'âco)te'Q +++ dicciona(io1.update0diccionario25 +++ dicciona(io1 ONcolo(N: N4e(deN, N&(ecioN: 48, N*a(caN: Nâco)teN, NtalleN: N0NQ
Estab"ecer una c"a e : a"or &or 'efecto

*2todo: setde-aultLGclaveH\' None^valorO&orOde-ecto]M
'i la cla e no e1iste, la crea con el alor por defecto. 'iempre retorna el alor para la cla e pasada como parmetro.
+++ (e*e(a < O'colo(': '(o)a', '*a(ca': 'da(a'Q +++ cla4e < (e*e(a setdefault0 talle 2 O 5 +++ cla4e NaN +++ (e*e(a ONcolo(N: N(o)aN, N*a(caN: Nda(aN, NtalleN: NaNQ +++ (e*e(a2 < (e*e(a co&%() +++ (e*e(a2 ONcolo(N: N(o)aN, N*a(caN: Nda(aN, NtalleN: NaNQ +++ cla4e < (e*e(a2 setdefault0 estampado 5 +++ cla4e +++ (e*e(a2 ONcolo(N: N(o)aN, Ne)ta*&adoN: @one, N*a(caN: Nda(aN, NtalleN: NaNQ +++ cla4e < (e*e(a2 setdefault0 marca 2 ;acoste 5 +++ cla4e Nda(aN +++ (e*e(a2 ONcolo(N: N(o)aN, Ne)ta*&adoN: @one, N*a(caN: Nda(aN, NtalleN: NaNQ
);
M2todos de retorno
1btener e" a"or 'e una c"a e
*2todo: getLclave\' Gvalor 7 de-ecto si la clave no e7isteH]M
+++ (e*e(a get0 color 5 N(o)aN +++ (e*e(a get0 stocB 5 +++ (e*e(a get0 stocB 2 N)in )toc:N
sin stocB 5
Saber si una c"a e e.iste en e" 'iccionario

*2todo: hasO.e LclaveM
+++ e#i)te < (e*e(a has.Bey0 precio 5 +++ e#i)te Dal)e +++ e#i)te < (e*e(a has.Bey0 color 5 +++ e#i)te $(ue
1btener "as c"a es : 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"a es 'e un 'iccionario

*2todo: .e sLM
)(
+++ 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 la -uncin integrada len() tu&las' se utili4a
+++ dicciona(io < ONcolo(N: N(o)aN, N*a(caN: Nda(aN, NtalleN: NaNQ +++ len0diccionario5 3
)2
09
,l ob)eto File8 traba)ando con arc(i os
: 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 ma or &ro-undidad.
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 r rb r+ rb+ A #olo lectura #olo lectura en modo binario "ectura "ectura escritura escritura en modo binario *odo de apertura 6bicaci&n del puntero Al inicio del archivo Al inicio del archivo Al inicio del archivo Al inicio del archivo Al inicio del archivo
#olo escritura. #obreescribe el archivo si e7iste. Crea el archivo si no e7iste. #olo escritura en modo binario. #obreescribe el archivo si e7iste. Crea el archivo si no e7iste.
Ab
Al inicio del archivo
)%
A+
Escritura lectura. #obreescribe el archivo si e7iste. Crea el archivo si no e7iste. Escritura lectura en modo binario. #obreescribe el archivo si e7iste. Crea el archivo si no e7iste. AUadido Lagregar contenidoM. Crea el archivo si >ste no e7iste. AUadido en modo binario Lagregar contenidoM. Crea el archivo si >ste no e7iste. AUadido Lagregar contenidoM lectura. Crea el archivo si >ste no e7iste.
Al inicio del archivo
Ab+ a ab a+ ab+
Al inicio del archivo #i el archivo e7iste' al -inal de >ste. #i el archivo no e7iste' al comien4o. #i el archivo e7iste' al -inal de >ste. #i el archivo no e7iste' al comien4o. #i el archivo e7iste' al -inal de >ste. #i el archivo no e7iste' al comien4o.
AUadido Lagregar contenidoM lectura en modo #i el archivo e7iste' al -inal de >ste. binario. #i el archivo no e7iste' al comien4o. Crea el archivo si >ste no e7iste.
)4
M2todos del Ob)eto File

El ob!eto -ile' entre sus m>todos mBs -recuentes' dis&one de los siguientes*
*2todo seeB0byte5 Descripci&n Iueve el &untero hacia el b te indicado "ee todo el contenido de un archivo. #i se le &asa la longitud de b tes' leerB solo el contenido hasta la longitud indicada. "ee una l)nea del archivo. "ee todas las l)neas de un archivo (etorna la &osicin actual del &untero 6so
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
a(chi4o < o&en('(e*e(a) t#t', '(') contenido < archi"o.read05 &(int contenido
readline07bytes:5 readlines05
a(chi4o < o&en('(e*e(a) t#t', '(') linea1 < archi"o.readline05 &(int linea1 a(chi4o < o&en('(e*e(a) t#t', '(') fo( linea in archi"o.readlines05: &(int linea 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) a(chi4o < o&en('(e*e(a) t#t', '(.') contenido < a(chi4o (ead() final;de;a(chi4o < a(chi4o tell() archi"o.Arite01=ue"a linea15 a(chi4o )ee:(final;de;a(chi4o) nue4o;contenido < a(chi4o (ead() &(int nue4o;contenido J @ue4a linea a(chi4o < o&en('(e*e(a) t#t', '(.') contenido < a(chi4o (ead() final;de;a(chi4o < a(chi4o tell() 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 a(chi4o < o&en('(e*e(a) t#t', '(') contenido < a(chi4o (ead() archi"o.close05 &(int contenido
tell05
Arite0cadena5
Escribe cadena dentro del archivo
#ecuencia serB cual@uier Aritelines0secuencia5 iterable cu os elementos serBn escritos uno &or l)nea
close05
Cierra un archivo
)8
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
+++ +++ +++ +++ QQQ +++ +++
a(chi4o < o&en('(e*e(a) t#t', '(.') contenido < a(chi4o (ead() no*6(e < archi"o.name *odo < archi"o.mode encoding < archi"o.encoding a(chi4o clo)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
)/
Cerrando arc(i os 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(chi4o clo)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.
))
10
#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.
)'
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
Archi os : '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 #aber si se &uede acceder a un archivo o directorio Conocer el directorio actual Cambiar de directorio de traba!o Cambiar al directorio de traba!o ra)4 Cambiar los &ermisos de un archivo o directorio Cambiar el &ro&ietario de un archivo o directorio Crear un directorio Crear directorios recursivamente Eliminar un archivo Eliminar un directorio Eliminar directorios recursivamente (enombrar un archivo Crear un enlace simblico o) getcAd() o) chdir(nue4o;&ath) o) chroot() o) chmod(&ath, &e(*i)o)) o) choAn(&ath, &e(*i)o)) o) mBdir(&ath[, *odo") o) mBdirs(&ath[, *odo") o) remo"e(&ath) o) rmdir(&ath) o) remo"edirs(&ath) o) rename(actual, nue4o) o) symlinB(&ath, no*6(e;de)tino) *2todo o) access(&ath, *odo;de;acce)o)
Para ver al mdulo os trabajando con funcionalidades del sistema de archi os y directorios, e"ecutar python os.e6amples de la carpeta )ou(ce) de este cap2tulo.
';
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"iron ite(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 (uta absoluta $irectorio base #aber si un directorio e7iste Conocer 9ltimo acceso a un directorio Conocer tamaUo del directorio #aber si una ruta es* 2na ruta absoluta 2n archi/o 2n directorio 2n enlace simblico 2n punto de montaje o) path.isabs(&ath) o) path.isfile(&ath) o) path.isdir(&ath) o) path.islinB(&ath) o) path.ismount(&ath) *2todo o) path.abspath(&ath) o) path.basename(&ath) o) path.e6ists(&ath) o) path.getatime(&ath) o) path.getsiJe(&ath)
Para conocer ms so!re os.path, isitar la documentacin oficial en http#33docs.python.org3li!rary3os.path.html
'(
D)'u"o s:s
El mdulo )%) es el encargado de &roveer variables relacionadas con el int>r&rete. -uncionalidades' directamente
2ariab"es 'e" m)'u"o s:s

Entre las variables mBs destacadas &odemos encontrar las siguientes*
Iariable Descripci&n (etorna una lista con todos los argumentos &asados &or l)nea de comandos. sys.arg" Al e!ecutar* &%thon *odulo &% a(g1 a(g2 )%) a(g retornarB una lista* [N*odulo &%N, Na(g1N, Na(g2N" sys.e6ecutable sys.ma6int sys.platform sys."ersion (etorna el &ath absoluto del binario e!ecutable del int>r&rete de : thon (etorna el n9mero &ositivo entero ma or' so&ortado &or : thon (etorna la &lata-orma sobre la cuBl se estB e!ecutando el int>r&rete (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 sys.e6it05 sys.getdefaultencoding05 Sys.getfilesystemencoding05 Descripci&n ?or4ar la salida del int>r&rete (etorna la codi-icacin de caracteres &or de-ecto (etorna la codi-icacin de caracteres @ue se utili4a &ara convertir los nombres de archivos unicode en nombres de archivos del sistema (etorna el tamaUo del ob!eto &asado como &arBmetro. El segundo argumento Lo&cionalM es retornado cuando el ob!eto no devuelve nada.
Sys.getsiJeof0o63ect[, default"5
4s informacin so!re el mdulo sys, puede o!tenerse en http#33docs.python.org3li!rary3sys.html
'2
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 educati os, 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.
'
"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
'%
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
'4
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 î*&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 )tdout clo)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 s c C
(ne#t) e3ecuta el cFdigo *o)t(ado % )alta a la )iguiente lMnea de tu a(chi4o ()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 (continue) e3ecuta el a(chi4o ha)ta encont(a( un &unto de Kuie6(e (Kuit) a6andona( el de6ugge(
'8
: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 )tdout clo)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.
'/
8robar e" c)'igo antes 'e en iar"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:
')
$(%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-& thontesteando-codigo-doctest-comentarios+
''
Mdulos 0ue 1uncionales

1btener 'atos a"eatorios
resuel en
necesidades
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 random.randint0a, 65 random.choice0)ecuencia5 random.shuffle0)ecuencia5 random.sample0)ecuencia, n5 Descripci&n (etorna un n9mero aleatorio entero entre a (etorna una me4cla de los elementos de una secuencia (etorna n elementos aleatorios de secuencia b (etorna cual@uier dato aleatorio de secuencia
import random # !enerar n+meros aleatorios entre ,---- y ----li)ta < [" fo( n in (ange(0, 80): li)ta a&&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
(;;
/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 < _ô(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
(;(
Mdulos e Internet
Acce'er a" na ega'or /eb
Abrir una %(" en una nueva &estaUa del navegador*
import AebbroAser AebbroAser.open.neA.tab('htt&:55YYY eugenia6ahit co*')
4s so!re AebbroAser en http#33docs.python.org3li!rary3we!!rowser.html urllib2 es otro mdulo interesante para manipular peticiones 566P e interactuar a tra s 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 ser i'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!! 228 82 93N, 21, 2999) ft& login(N*iu)e(N, N*icla4eN) # Conectarse en la instancia a FTP ft& < D$,(N!! 228 82 93N, N*iu)e(N, N*icla4eN)
"a clase D$,' se com&one -entre otros- de los siguientes m>todos*

(;2
*2todo '$P.connect0ho)t[, &ue(to, ti*eout") '$P.login0u)e(, &a))5 '$P.close05 '$P.set.pas"06ool5 '$P.getAelcome05 '$P.dir05 '$P.cAd0&ath5 '$P.mBd0&ath5 '$P.pAd05 '$P.rmd0&ath5 '$P.storlines01S$%R de)tino12 open0localfile2 1r15 '$P.rename0actual, nue4o5 '$P.delete0filena*e5 '$P.retrlines01RE$R a(chi4o;(e*oto15
Descripci&n #e conecta al servidor ?=: #e loguea en el servidor ?inali4a la cone7in Establece la cone7in en modo &asivo si el &arBmetro es =rue. (etorna el mensa!e de bienvenida del servidor (etorna un listado de archivos la car&eta actual Crea un nuevo directorio (etorna el directorio de traba!o actual Elimina el directorio &ath "ee local-ile lo escribe en destino directorios de
Cambia el directorio de traba!o actual a &ath
(enombra el archivo GactualH &or GnuevoH Elimina un archivo "ee archivoOremoto retorna su contenido
J 2G2 coding: utf28 2G2 from ftplib import '$P ftp / '$P05 ft& connect(N!! 228 82 93N, 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*&le t#tN, o&en(Nft&;e#a*&le) &%N, N(N)) ft& rename(Ne#a*&le t#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
(;
11
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".
(;%
4cerca de M'S9%
I #N" es un ser5idor de Bases de Datos 39: L#tructured Nuer "anguageM @ue se distribu e 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.m [email protected]+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)*
(;4
Hi)alloY (oot login (e*otel%` [g5n" !
"a siguiente &regunta serB si deseas eliminar la base de datos de &rueba ella. =ambi>n res&onde @ue s)*
Ee*o4e te)t data6a)e and acce)) to it` [g5n" !
el acceso a
?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" ser i'or D:SHEn ocasiones necesitarBs iniciar' reiniciar o detener el servidor de bases de datos' I #N". "as opciones dis&onibles son*
stop start restart detiene el )e(4ido( inicia el )e(4ido( (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.
(;8
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" ser i'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"" interacti o

"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
shoA databasesU use nombre.de.la.base.de.datosU create database nombre.de.la.dbU Cuit
DE3CG0PC0TC
Iuestra todas las bases de datos creadas en el servidor 3ndicar @ue vas a comen4ar a utili4ar la base de datos elegida Crear una nueva base de datos #alir del shell interactivo
(;/
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
Cnte(o @T*e(o deci*al Uooleano Decha Decha % ho(a Decha % ho(a auto*Stica /o(a BXo Cadena de longitud fi3a Cadena de longitud 4a(ia6le UloKue de te#to de g(an longitud 4a(ia6le
Denominaci&n
(=$0=5 &E<(*8;0=2 &5 9%%; &8$E &8$E$(*E $(*ES$8*P $(*E !E8R0&5 <D8R0=5 V8R<D8R0=5 9;%9
Especi.icaciones
@ < cantidad de dMgito) @ < cantidad de dMgito) totale) H < cantidad de deci*ale)
Ejemplo
?@$(8) HCC?0B^(10, 2) UOO^ HB$C HB$C$?0C $?0CA$B0, $?0C
H < cantidad de dMgito) (2 o 4) @ < longitud de la cadena W ent(e 0 % 288 @ < longitud *S#i*a de la cadena W ent(e 0 % !8832
gCBE(4) C/BE(2) =BEC/BE(100) UÔU
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.
(;)
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ÔU, &(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ÔU,
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
(;'
Insertar 'atos en una tab"a

#inta7is*
(=SER$ (=$% no*6(e;de;la;ta6la(ca*&o1, ca*&o2, ca*&o10 =BâCA(dato1, dato2, dato10 )U )
E!em&lo*
?@ACE$ ?@$O &(oducto)(&(oducto, &(ecio, en;)toc:) =BâCA(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 &roductos
enOstoc. de la tabla
=BâCA(NUol)a de do(*i( &a(a alta *ontaXaN, 234 !8, $EaC)h
Con los valores GBolsa de dormir &ara alta montaUaH' 230.2; res&ectivamente en cada uno de los cam&os indicados
verdadero'
Se"eccionar registros
#inta7is*
SE;E<$ 'R%* ca*&o1, ca*&o2, ca*&o10 ta6lah
E!em&lo*
AC^CC$ DEO0 &(oducto, &(ecio &(oducto)h
E7&licacin*
AC^CC$ &(oducto, &(ecio
#eleccionar los cam&os &roducto

DEO0 &(oducto)h
&recio
$e la tabla &roductos
((;
Do'ificar registros
#inta7is*
OP&8$E SE$ ta6la ca*&o1 < 4alo(, ca*&o2 < 4alo(, ca*&o10 < 4alo(h
E!em&lo*
a,HB$C AC$ &(oducto) en;)toc: < DBÂC, &(ecio < 0h
E7&licacin*
a,HB$C &(oducto)
Actuali4ar la tabla &roductos
AC$
en;)toc: < DBÂC,
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
(((
Consu"tas a an6a'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 igual Kue *a%o( o igual Kue W WQ V< *eno( Kue di)tinto Kue *eno( o igual Kue
9E$SEE= n4 8=& n2 (S =O;;X$ROEX'8;SE (=(4alo(1, 4alo(2, 4a
ent(e n1 % n2 e) nulo > e) 4e(dade(o > e) fal)o contiene
:or su&uesto' tambien admite operadores l&gicos*

8=& (%) =%$ (negaciFn) %R (o)
((2
<eamos algunos e!em&los* #eleccionar &roductos donde &recio sea menor @ue 1000*
AC^CC$ DEO0 SDERE &(oducto, &(ecio &(oducto) precio W 4333U
Aumentar el 10Z del &recio de los &roductos' @ue actualmente se encuentren entre 1;0 200*
a,HB$C AC$ SDERE &(oducto) &(ecio < (&(ecio G 1 10) precio 9E$SEE= 4G3 8=& 233U
#eleccionar &roductos donde enOstoc. no sea -also

AC^CC$ DEO0 SDERE &(oducto, &(ecio &(oducto) en.stocB (S =%$ '8;SEU
Eliminar &roductos cu os &recios sean 100' 200 +o 300 &roducto sea nulo*
HC^C$C DEO0 SDERE 8=& %R &(oducto) precio (=04332 2332 F335 0en.stocB (S '8;SE producto (S =O;;5U
ademBs' enOstoc. sea -also o
Iodi-icar enOstoc. a verdadero donde &recio sea menor @ue ;0

a,HB$C AC$ SDERE 8=& &(oducto) en;)toc: < $EaC precio W G3 en.stocB (S =%$ =O;;U
&roducto no sea nulo*
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 &(oducto) &(ecio UC$iCC@ 1 B@H 80
DEO0 i/CEC
((
B@H %R&ER 9!
en;)toc: ?A @O$ DBÂC 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 &(oducto) &(ecio UC$iCC@ 1 B@H 80 en;)toc: ?A @O$ DBÂC precio &ES<2 producto 8S<U
DEO0 i/CEC B@H %R&ER 9!
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 de)c(i&cion &(ecio &(oducto) 8S 1=ombre del Producto12 8S &etalles2 8S (mporte 8S p
DEO0 i/CEC B@H %R&ER 9!
&(ecio UC$iCC@ 1 B@H 80 en;)toc: ?A @O$ DBÂC 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:SHEs &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.
((%
Contar "a canti'a' 'e registrosC C1%+3!(

AC^CC$ DEO0 <%O=$0producto5 &(oducto)h BA Cantidad
Sumar tota"esC S%D!(

AC^CC$ DEO0 SO*0precio5 &(oducto)h BA $otal
Concatenar ca'enasC C1+CA3!(

AC^CC$ DEO0 &(oducto, <%=<8$01OS& 12 precio2 1.,15 &(oducto)h BA ,(ecio
Ntese @ue las cadenas de caracteres deben encerrarse entre comillas sim&les o&erador de concatenacin &ara esta -uncin' es la coma.
@ue el
Con ertir a min0scu"as : ma:0scu"asC -CASE!( : %CASE!(

AC^CC$ DEO0 O<8SE0producto52 ;<8SE0descripcion5 &(oducto)h
Ieem&"a6ar 'atosC IE8-ACE!(

AC^CC$ DEO0 REP;8<E0descripcion2 1Pn12 1WbrMQ15 &(oducto)h BA He)c(i&cion
(eem&la4a àn` &or `bbr+c`
1btener "os &rimeros o 0"timos caracteresC -EG3!( : II*E3!(

AC^CC$ DEO0 ;E'$0producto2 G35 &(oducto)h
Ie'on'ear n0merosC I1%+4!(

AC^CC$ DEO0 R%O=&0precio2 25 &(oducto)h
(etornarB los &recios con 2 decimales
((4
1btener so"o "a fecha 3IDES3AD8C 4A3E!(

AC^CC$ DEO0 &8$E0campo.datetime5 ta6lah
'e
un
cam&o
4A3E3IDE
1btener una fecha formatea'aC 4A3EJG1IDA3!(

AC^CC$ DEO0 &8$E.'%R*8$0campo.fecha2 1YdMYmMY!15 ta6lah
1btener e" registro con e" a"or m7.imo : m@nimoC DAK!( : DI+!(
AC^CC$ DEO0 *8)0precio5 &(oducto)h
(etorna el &roducto con el &recio mBs caro
AC^CC$ DEO0
*(=0precio5 &(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 e cual@uier clBusula 8JE(E.
lo &odrBs seleccionar en un #E"EC= o utili4arlo
((8
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 ha an sido creados. KCu7ndo agregar #ndicesL Cuando va as 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ÔU, (=&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 a udarB 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ÔU =%$ =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)(
((/
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ÔU @O$ @a^^, ?@HCc(&(ecio, en;)toc:) ) E=?(=E/(nno&9U
Aprende ms so!re el lengua"e '9L, gratis en :;ey+ata
(()
-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)*
categoria
producto
categoriaUid categoria activa
productoUid categoriaUid &roducto &recio descri&cion
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 < 0 0 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
(('
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ÔU, '%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 $cla e fornea% o $foreign $ey% (en ingls&. Para poder utilizar cla es 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 (cla e fornea& mientras 0ue PK es una Primary Key (cla e 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
(2;
re-erencia' deberB indicarse como :rimar Ce . "uego' &odremos obtener' desde la base de datos' el Gob!etoH &roducto' inclu endo los datos a los cuBles hace re-erencia. :ara ello' utili4aremos la siguiente consulta*
AC^CC$ DEO0 &(oducto G, catego(ia G &(oducto ?@@CE ZO?@ catego(ia aA?@G(catego(ia;id)
Con AC^CC$ &(oducto G, catego(ia G 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ÔU, '%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$ DEO0 &(oducto G, catego(ia G &(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.
(2(
12
-ases de datos en P't(on con M'S9%
(22
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 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 e!ecutar cual@uier consulta' el &rocedimiento
)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.
(2
%na forma sim&"e 'e acce'er a bases 'e 'atos

i*&o(t 0%Ae^d6 HU;/OA$ HU;aACE HU;,BAA HU;@B0C < < < < Nlocalho)tN N(ootN N*%)Kl(ootN NaN
def (un;Kue(%(Kue(%<NN): dato) < [HU;/OA$, HU;aACE, HU;,BAA, HU;@B0C" conn < 0%Ae^d6 connect(Gdato)) cu()o( < conn cu()o(() cu()o( e#ecute(Kue(%) if Kue(% data el)e: conn data # Conectar a la base de datos # Crear un cursor # Ejecutar una consulta
u&&e(() )ta(t)Yith(NAC^CC$N): < cu()o( fetchall() # Traer los resultados de un select co**it() < @one # Hacer efectiva la escritura de datos # Cerrar el cursor # Cerrar la cone i!n
cu()o( clo)e() conn clo)e() (etu(n data
Insertar 'atos
dato < (aY;in&ut('Hato: ') Kue(% < '?@ACE$ ?@$O 6 (62) =BâCA (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
(2%
(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(%)
(24
13
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.
(28
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..
(2/
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 interactuar v)a 8eb. $ebemos tener un directorio destinado a montar toda la aplicaci&n *
mBdir 5ho*e5%o5cu()o2&%thon5t(un:5python,Aeb
cmo va a
$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
(2)
$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
(2'
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(ôg 5ho*e5%o5cu()o2&%thon5t(un:5&%thon2Ye65log)5e((o() log Cu)to*ôg 5ho*e5%o5cu()o2&%thon5t(un:5&%thon2Ye65log)5acce)) log co*6ined VHi(ecto(% 5+ O&tion) DolloYA%*în:) 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 siguiente l)nea* 427.3.3.4 python,Aeb all) agregamos la
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 nue o 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.
( ;
#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 &ath a&&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 &ath a&&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 < contacto fo(*ula(io() elif peticion.startsAith01Mgracias15: out&ut < contacto g(acia)() el)e: out&ut < default default;&age() )ta(t;(e)&on)e(N200 OjN, [(NContent2$%&eN, Nte#t5ht*lh cha()et<utf28N)") (etu(n out&ut
( (
%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
( 2
14
,n iando e*mails con 1ormato ;TM% desde P't(on
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
,n o 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)f o(g+' destinatario < '0a*a de Gnucita Veugenia6ahit@g*ail co*+' 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)
( %
''' 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)f o(g+' de)tinata(io < '0a*a de Gnucita Veugenia6ahit@g*ail co*+' 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: 1 0 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&li6 A0$,(Nlocalho)tN)
D reali4amos el env)o*
)*t& )end*ail((e*itente, de)tinata(io, e*ail)
( 4
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: 1 0 Content2t%&e: te#t5ht*l Au63ect: I) I) ''' I ((e*itente, de)tinata(io, a)unto, *en)a3e)
( 8
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

Python para Principiantes

Cargado por

Copyright:

Formatos disponibles

Python para Principiantes

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Python para Principiantes

Cargado por

Copyright:

Formatos disponibles

Eugenia Bahit

Curso: Python para Principiantes

Eres libre de: Copiar' distribuir compartir este libro

2012 Eugenia Bahit

Buenos Aires, Argentina

Tabla de Contenidos (ndice)

Preparacin del entorno de desarrollo

Introduccin al Sistema Operati o !"#$%inu&

Insta"aci)n 'e %buntu *+%,-inu. en /in'ows

Insta"aci)n 'e %buntu *+%,-inu. como 0nico Sistema 1&erati o

Actuali4a el #istema 5&erativo*

Instalacin de un S(ell interacti o me)orado

2M #incroni4a el )ndice de actuali4aciones*

Iueve el cursor hasta la siguiente l)nea

&ulsa las teclas Ctrl S C*

&a(ent;location < )ft&:55tu_usuario@!! 228 82 935ho*e5tu_usuario5&u6lic5t(un:

la de la tercera' &or G pullH

:ara guardar el archivo &ulsa las teclas Ctrl S 5 LenterM

&ara salir' &ulsa Ctrl S P.

,structura ' elementos del lengua)e

,lementos del %engua)e

Cada variable' tiene un nombre variable.

un valor' el cual de-ine a la ve4' el ti&o de datos de la

PEP ): constantes %tili4ar nombres descri&tivos &alabras &or guiones ba!os.

:ara imprimir un 5alor en pantalla' en : thon' se utili4a la &alabra clave &(int*

"o anterior' im&rimirB el valor de la variable miOvariable en &antalla.

3i&os 'e 'atos

N9mero entero octal*

N9mero entero he7adecimal*

Booleano Lverdadero + ?alsoM*

PEP ): operadores #iem&re colocar un es&acio en blanco' antes o&erador

6n ejemplo sencillo con 5ariables y operadores aritm2ticos:

=i&os de datos com&le!os

*i;li)ta < [Ncadena de te#toN, 18, 2 8, Not(o datoN, 28"

"as listas' a di-erencia de las tu&las' &ermiten agregar nuevos valores*

%n diccionario &ermite eliminar cual@uier entrada*

Al igual @ue las listas' el diccionario &ermite modi-icar los valores

,structuras de Control de Flu)o

%na estructura de control' entonces' se de-ine de la siguiente -orma*

J 2G2 coding: utf,- 2G2

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

:roduciendo la siguiente salida*

contenido de una tu&la*

5 tambi>n' de una lista*

Estructuras 'e contro" 'e f"u5o con'iciona"es

D &ara evaluar mBs de una condicin simultBneamente' se utili4an operadores l&gicos*

#i semB-oro esta en verde' cru4ar la calle. #ino' es&erar.

#i la com&ra es ma or a Y100' obtengo un descuento del 10Z

Estructuras 'e contro" iterati as

"as veremos en detalle a continuacin.

"a iteracin anterior' generarB la siguiente salida*

#i miras la 9ltima l)nea*

:or cada color en miOtu&la' im&rimir color

Mdulos/ pa0uetes ' namespaces

Creando mdulos empa0uetados

"os &a@uetes' a la ve4' tambi>n &ueden contener otros sub-&a@uetes*

D los mdulos' no necesariamente' deben &ertenecer a un &a@uete*

Im&ortan'o m)'u"os enteros

def i;funcion(no6(e, a&ellido): no6(e;co&leto < nombre, apellido &(int no6(e;co&leto

if no6(e;de;la;funcion in local)(): if calla6le(local)()[no6(e;de;la;funcion"): &(int local)()[no*6(e;de;la;funcion"('Dacundo') el)e: &(int 'DunciFn no encont(ada'

+++ nue(o;factu(a < 18-8 +++ &(int )t((nue(o;factu(a) Jfill0425 0000000018-8

ma60tuplaN5 a#(tu&la1) min0tupla45 a#(li)ta3) *in(li)ta1)