Python Para Principiantes

Eugenia Bahit

Curso: Python para Principiantes www.eugeniabahit.com www.eug eniabahit.com

Eugenia Bahit 2012. Creative Commons Atribución-NoComercial Atribución-NoComercial 3.0 – ¡Comparte el conocimiento en libertad!

Python para Principiantes de Eugenia Bahit se distribue ba!o una "icencia Creative Commons AtribuciónNoComercial-#in$erivadas 3.0 %n&orted. %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+, htt&*++,,, .saecreative.org+,or+120/3020 or+120/302020 20

@eugeniabahit

®2012 Eugenia Bahit Imagen Twitter – Follow Me

www.eugeniabahit.com ©

Buenos Aires, Argentina

Aha-Soft.com Creatie Commons !Attribution-Share A"i#e $.0 %n&orte'(

Bahit ,,,.eugeniabahit.com+cursos abahit.com+cursos2012 2012 Curso Python para Principiantes – Eugenia Bahit ,,,.eugeni Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual Atribución-NoComercial-Com&artirgual 3.0

2

Python para Principiantes de Eugenia Bahit se distribue ba!o una "icencia Creative Commons AtribuciónNoComercial-#in$erivadas 3.0 %n&orted. %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+, htt&*++,,, .saecreative.org+,or+120/3020 or+120/302020 20

@eugeniabahit

®2012 Eugenia Bahit Imagen Twitter – Follow Me

www.eugeniabahit.com ©

Buenos Aires, Argentina

Aha-Soft.com Creatie Commons !Attribution-Share A"i#e $.0 %n&orte'(


2

Descarga todos los ejemplos de este libro  los talleres del curso' ingresando en htt&*++curso-&thon.eugeniabahit.com+s htt&*++curso-&thon .eugeniabahit.com+sources.tar ources.tar.g4 .g4




00

Tabla de Contenidos (índice)

abla de Contenidos "#ndice$.........................................................................................................................% Preparaci&n del entorno de desarrollo.........................................................................................................' ntroducción al #istema 5&erativo 6N%+"inu7...........................................................................................10 nstalación de %buntu 6N%+"inu7 en 8indo,s....................................................................................10 nstalación de %buntu 6N%+"inu7 como 9nico #istema 5&erativo.......................................................11 nstalando :thon.......................................... ............................................................................................ 12 nstalación de un #hell interactivo me!orado..............................................................................................1 Nin!a-$E................................................. .................................................................................................. 1; nstalación de Ba4aar................................................................................................................................ 1 Estructura y elementos del lenguaje...........................................................................................................() Elementos del "engua!e............................................................................................................................ 20 ticos........................................................................................................................22 Comentarios......................................... ................................................................................................ 23 =i&os de datos com&le!os.....................................................................................................................2 =u&las............................................................ .................................................................................. 2 "istas........................................... .................................................................................................... 2 $iccionarios.............................................. ....................................................................................... 2; Estructuras de Control de ?lu!o.................................................................................................................2 dentación...................................... ....................................................................................................... 2 Encoding............................................. .................................................................................................. 2/ Asignación m9lti&le...............................................................................................................................2/ Estructuras de control de lu!o condicionales........................................................................................2 Estructuras de control iterativas............................................................................................................31 Bucle ,hile............................................. ......................................................................................... 31 Bucle or............................................ .............................................................................................. 32 *&dulos+ pa,uetes y namespaces.............................................................................................................. Creando módulos em&a@uetados..............................................................................................................3 m&ortando módulos enteros................................................................................................................3 Names&aces......................................... ................................................................................................ 3; Alias............................................. .................................................................................................... 3; m&ortar módulos sin utili4ar names&aces.......................................................................................3; -unciones deinidas por el usuario............................................................................................................./ $einiendo unciones............................................ ..................................................................................... 3 #obre los &armetros........................................................................................................................... 3 :armetros &or omisión...................................................................................................................3 e,ords como &armetros............................................................................................................3 :armetros arbitrarios.....................................................................................................................0 $esem&a@uetado de &armetros....................................................................................................0 "lamadas de retorno..................................................................................................................................1 #aber si una unción e7iste  &uede ser llamada..................................................................................2 "lamadas recursivas ................................................................................................................................. 3 Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

%

#obre la inalidad de las unciones ...........................................................................................................3 0ntroducci&n a la 1rientaci&n a 1bjetos.....................................................................................................%% :ensar en ob!etos...................................................................................................................................... ; D @u> es un ob!etoF............................................................................................................................; Ahora @u> me dices si describimos las cualidades de un ob!etoF......................................................; :ero algunos ob!etos' tambi>n se com&onen de otros ob!etos............................................................. D tambi>n ha ob!etos @ue com&arten caracter)sticas con otros ob!etos............................................. "os ob!etos' tambi>n tienen la ca&acidad de Ghacer cosasH.................................................................;0 5b!etos  ms ob!etos* la &arte di)cil...................................................................................................;1 Al &an' &an. D al vino' vino. "as cosas &or su nombre....................................................................;2 :rogramación 5rientada a 5b!etos...........................................................................................................;3 Elementos  Caracter)sticas de la :55...............................................................................................;3 Clases............................................... ............................................................................................... ;3 :ro&iedades........................................ ............................................................................................ ; I>todos........................................ ................................................................................................... ; 5b!eto........................................... ................................................................................................... ;; Jerencia* caracter)stica &rinci&al de la :55...................................................................................;; Accediendo a los m>todos  &ro&iedades de un ob!eto........................................................................; *todos principales del 1bjeto 3tring.......................................................................................................4) I>todos de ormato...................................................................................................................................; Convertir a ma9scula la &rimera letra.................................................................................................; Convertir una cadena a min9sculas......................................................................................................; Convertir una cadena a ma9sculas.....................................................................................................; Convertir ma9sculas a min9sculas  viceversa...................................................................................; Convertir una cadena en ?ormato =)tulo..............................................................................................; Centrar un te7to.................................................................................................................................... 0 Alinear te7to a la i4@uierda...................................................................................................................0 Alinear te7to a la derecha.....................................................................................................................0 (ellenar un te7to ante&oniendo ceros..................................................................................................0 I>todos de B9s@ueda...................................... ......................................................................................... 2 Contar cantidad de a&ariciones de una subcadena..............................................................................2 Buscar una subcadena dentro de una cadena.....................................................................................2 I>todos de rica...................................................................................................3 #aber si una cadena es alab>tica........................................................................................................ #aber si una cadena es num>rica........................................................................................................ #aber si una cadena contiene solo min9sculas.................................................................................... #aber si una cadena contiene solo ma9sculas...................................................................................; #aber si una cadena contiene solo es&acios en blanco.......................................................................; #aber si una cadena tiene ?ormato $e =)tulo......................................................................................; I>todos de #ustitución............................................................................................................................. $ar ormato a una cadena' sustituendo te7to dinmicamente............................................................ (eem&la4ar te7to en una cadena......................................................................................................... Eliminar caracteres a la i4@uierda  derecha de una cadena............................................................... Eliminar caracteres a la i4@uierda de una cadena................................................................................ Eliminar caracteres a la derecha de una cadena................................................................................../ I>todos de unión  división....................................................................................................................... %nir una cadena de orma iterativa....................................................................................................... :artir una cadena en tres &artes' utili4ando un se&arador................................................................... :artir una cadena en varias &artes' utili4ando un se&arador................................................................ :artir una cadena en en l)neas............................................................................................................. E!ercicio................................................ ..................................................................................................... /0 E!ercicio NK1.............................................. ........................................................................................... /0 E!ercicio NK2.............................................. ........................................................................................... /0 E!ercicio NK3.............................................. ........................................................................................... /0 *todos principales del objeto list............................................................................................................./( I>todos de agregado................................................................................................................................ /2 Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

4

Agregar un elemento al inal de la lista................................................................................................./2 Agregar varios elementos al inal de la lista........................................................................................./2 Agregar un elemento en una &osición determinada............................................................................./2 I>todos de eliminación....................................... ...................................................................................... /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...................................................................................................................................... / 5rdenar una lista en reversa Linvertir ordenM......................................................................................../ 5rdenar una lista en orma ascendente................................................................................................/ 5rdenar una lista en orma descendente............................................................................................../ I>todos de b9s@ueda.............................................................................................................................../; Contar cantidad de a&ariciones elementos.........................................................................................../; 5btener n9mero de )ndice..................................................................................................................../; Ane7o sobre listas  tu&las......................................................................................................................../ Conversión de ti&os............................................................................................................................../ Concatenación sim&le de colecciones................................................................................................../ todos de eliminación....................................... ...................................................................................... / todos de agregado  creación.............................................................................................................../ Co&iar un diccionario............................................................................................................................/ Crear un nuevo diccionario desde las claves de una secuencia.........................................................../ Concatenar diccionarios.......................................................................................................................0 Establecer una clave  valor &or deecto..............................................................................................0 I>todos de retorno.................................................................................................................................... 1 5btener el valor de una clave...............................................................................................................1 #aber si una clave e7iste en el diccionario...........................................................................................1 5btener las claves  valores de un diccionario.....................................................................................1 5btener las claves de un diccionario....................................................................................................1 5btener los valores de un diccionario...................................................................................................2 5btener la cantidad de elementos de un diccionario............................................................................2 El objeto -ile: trabajando con archi5os......................................................................................................) #obre el ob!eto ?ile......................................... ...........................................................................................  Iodos de A&ertura............................................................................................................................... I>todos del 5b!eto ?ile............................................................................................................................. :ro&iedades del ob!eto ile........................................................................................................................./ Cerrando archivos de orma automtica.................................................................................................... 6n Paseo por los *&dulos de la librer#a est7ndar.....................................................................................)' Iódulos de sistema...................................................................................................................................0 Iódulo os............................................................................................................................................. 0 Archivos  directorios.......................................................................................................................0 El módulo os  las variables de entorno..........................................................................................1 os.&ath..................................... ........................................................................................................ 1 Iódulo ss.......................................... ................................................................................................. 2 todos del módulo ss..................................................................................................................2 Iódulo sub&rocess...................................... ......................................................................................... 3 Ca&turando la salida con :o&en......................................................................................................3 Entradas  salidas @ue &ueden ser ca&turadas con :o&en............................................................. stdout..........................................................................................................................................  stdin........................................... .................................................................................................  stderr..........................................................................................................................................  %tili4ando tuber)as &ara ca&turar la salida....................................................................................... Iódulos &ara el &rogramador.................................................................................................................... $ebuguear código con :db.................................................................................................................. $ocumentar tu a&& con &doc............................................................................................................../ Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

8

:robar el código antes de enviarlo a &roducción con doctest............................................................... Iódulos @ue resuelven necesidades uncionales....................................................................................100 5btener datos aleatorios....................................................................................................................100 8ra&ear un te7to................................................................................................................................101 Iódulos e nternet...................................................................................................................................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#"....................................................................................................................................10; nstalación  coniguración de I#"................................................................................................10; niciar' reiniciar  detener el servidor I#".....................................................................................10 Administración de I#"..................................................................................................................10/ Conectarse  desconectarse al servidor........................................................................................10/ Comandos &ara administrar I#" dede el shell interactivo.......................................................10/ #obre el lengua!e #".............................................................................................................................10 =i&os de datos ms comunes LrecomendadosM..................................................................................10 #int7is bsica de las sentencias #"...............................................................................................10 Crear tablas en una base de datos................................................................................................10 nsertar datos en una tabla............................................................................................................110 #eleccionar registros.....................................................................................................................110 Iodiicar registros.........................................................................................................................111 Eliminar registros...........................................................................................................................111 Consultas avan4adas.........................................................................................................................112 "a clusula 8JE(E......................................................................................................................112 5rdenando consultas* la clusula 5($E( BD..............................................................................113 Alias de tablas  cam&os....................................................................................................................11 ?unciones del lengua!e #" de I#".............................................................................................11 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  (6J=LM......................................................11; (edondear n9meros* (5%N$LM....................................................................................................11; 5btener solo la echa de un cam&o $A=E=IE o =IE#=AI:* $A=ELM......................................11 5btener una echa ormateada* $A=EO?5(IA=LM.......................................................................11 5btener el registro con el valor m7imo  m)nimo* IAPLM  INLM................................................11 5&timi4ación de bases de $atos.............................................................................................................11 =odos los registros deben tener un $ 9nico.......................................................................................11 Crear )ndices en las tablas.................................................................................................................11/ ndica cules cam&os no &ueden ser nulos........................................................................................11/ %tili4a el motor nno$B.......................................................................................................................11/ Bases de datos relacionales....................................................................................................................11 Bases de datos en Python con *y39................................................ ........................................ ............ (22 ntroducción 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.................................................................................12 nsertar datos.................................................................................................................................12 #eleccionar todos los registros......................................................................................................12 #eleccionar solo registros coincidentes.........................................................................................12 Eliminar registros...........................................................................................................................12; Actuali4ar datos.............................................................................................................................12; Corriendo Python necesitamosF............................................................................................................................12 1. nstalación de modO,sgi en A&ache..........................................................................................12 2. Crear la estructura de directorios &ara nuestra a&licación.........................................................12 Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

/

3. Crear un controlador &ara la a&licación.....................................................................................12 . Conigurar el mails con ormato ?* desde Python...............................................................................( :a@uetes necesarios...............................................................................................................................13 Env)o de e-mail desde :thon.................................................................................................................13 Env)o de e-mails a m9lti&les destinatarios..........................................................................................13 Agregar una dirección de res&uesta dierente....................................................................................13

Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

)

01

Preparación del entorno de desarrollo

Comen4aremos instalando todo nuestro sistema' &ara crear un entorno de desarrollo &ro&icio' &ara traba!ar con :thon. A tal in' nos valdremos de las siguientes herramientas  tecnolog)as* 1. #istema 5&erativo 6N%+"inu7* %buntu 11.10 Lo su&eriorM 2. :thon 2./ 3. i:thon L#hell interactivo me!oradoM . Nin!a-$E L$E de desarrolloM ;. Ba4aar L#istema de Control de

'

Introducción 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 6inu@+ el 3istema 1perati5o ,ue utilia el Fernel inu@ como n9cleo' creado' diundido  &romovido a trav>s del Proyecto 6 ' &or la -ree 3otware -oundation ' organi4ación sin ines de lucro' undada &or (ichard #tallman' &rinci&al &recursor del #ot,are "ibre. El ernel "inu7' &arte undamental del #istema 5&erativo' ue desarrollado &or inus or5als' utili4ando como modelo a %NP. %na de las dierencias undamentales entre los n9cleos "inu7  %NP' es @ue el &rimero' es #ot,are "ibre' mientras @ue el segundo no lo es. :or otra &arte' mientras e7iste un 9nico ernel "inu7 Lcon versiones dierentesM' e7isten decenas  hasta cientos de distribuciones 6inu@ ' es decir' dierentes #istemas 5&erativos basados en el ernel "inu7' entre las cuales se destacan* Debian' 6buntu' Fubuntu' -edora ' entoo' 3lacAware' Cent13'
#itio 8eb de la -ree 3otware -oundation * ,,,.s.org

•

#itio 8eb del Proyecto 6* ,,,.gnu.org

•

#itio 8eb del Fernel inu@* htt&*++,,,.ernel.org+

•

#itio 8eb de la inu@ -oundation * htt&*++,,,.linu7oundation.org+

•

ntroduccion 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 instalar desde el &ro&io I# 8indo,sQ como si uese un #ot,are ms' &ermiti>ndote iniciar tu ordenador con %buntu o I# 8indo,sQ seg9n Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

(;

eli!as. :ara instalar %buntu 8indo,s nstaller' sigue las instrucciones de los pasos 2 y  de la 6G de descarga ' las cuales &odrs visuali4ar &ulsando el botón G#ho, me ho,H de cada uno de los &asos.

Insta"aci)n 'e %buntu *+%inu como nico Sistema &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 versión de %buntu @ue deseas descargar. :ara &rocesadores de un solo n9cleo' selecciona la versión 10.0 "=#. :ara &rocesadores ms modernos' &uedes seleccionar la 9ltima versión Lversión @ue a&arece seleccionada &or deecto en el des&legable de versionesM. #i tienes dudas sobre si elegir la versión &ara 32 o  bits' elige la de 32-bits. :ulsa el botón G#tart do,nloadH  aguarda a @ue se descargue el archivo. 3. %na ve4 descargado el archivo' &odrs @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 hars la co&ia L8indo,s o IacM. :ulsa el botón Gsho, me ho,H  sigue las instrucciones de @uemado. . A continuación' salta al &aso  del sitio de descarga Lel 3 es solo &ara &robar %buntu sin instalarloMR &ulsa el botón Gsho, me ho,H  sigue las instrucciones &ara instalar %buntu en tu ordenador.


((

Instalando P'ton %na ve4 @ue haas instalado tu distribución 6N%+"inu7' a tendrs :thon instalado en tu sistema. :ara com&robarlo' abres una terminal L&resiona Alt S ?  luego escribe en el cam&o de b9s@ueda gnome-terminalM  escribe &thon como se muestra a continuación* 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 vers 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 undo' /ola undo +++

#i en lugar del #hell interactivo' ves un mensa!e de error similar a G&thon* orden no encontradaH' debers seguir los siguientes &asos &ara instalarlo* Actuali4a la lista de los re&ositorios* eugenia@cochito:~$ udo a&tget u&date

Actuali4a el #istema 5&erativo* eugenia@cochito:~$ udo a&tget u&gade

nstala :thon* eugenia@cochito:~$ udo a&tget intall &%thon2-

31BGE 13 C1*<D13 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&ción 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&ción de a&t-get @ue actuali4a el sistema. install: es la o&ción de a&t-get @ue indica @ue se instalarn uno o ms &a@uetes


(

Instalación de un Sell interactio meorado :thon trae &or deecto su &ro&io #hell interactivo' el cul nos &ermite escribir código :thon  e!ecutarlo. #in embargo' tenemos la o&ción de contar con un #hell interactivo me!orado' @ue entre otras venta!as sobre el shell nativo' &odemos encontrar n9meros de l)nea' sangrado automtico' etc.

iPython' es el #hell interactivo @ue elegiremos. :ara instalarlo' e!ecuta la siguiente orden desde una terminal* eugenia@cochito:~$ udo a&tget intall i&%thon

:ara e!ecutar el nuevo shell interactivo' solo debers escribir el comando i&thon*


(%

"ina*I+, Nin!a-$E es un Entorno ntegrado de $esarrollo 1 @ue nos &ermitir' crear &roectos en :thon' al tiem&o de ir e!ecutando nuestros códigos  corrigiendo eventuales errores @ue >stos' &uedan &resentar.

:ara instalar Nin!a-$E en tu ordenador' desde la terminal' e!ecuta los siguientes comandos* 1M Agrega el ::A de Nin!a-$E* udo a&tadde&oito% &&a:ninaidedeelo&e5dail%

2M #incroni4a el )ndice de actuali4aciones* udo a&tget u&date

3M nstala Nin!a-$E* udo a&tget intall ninaide 1 htt&*++es.,ii&edia.org+,ii+EntornoOdeOdesarrolloOintegrado Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

(4

Instalación de -a.aar Ba4aar es un sistema de control de versiones distribuido' @ue nos &ermitir ir manteniendo el control cambios sobre nuestros archivos' centrali4ndolos en un re&ositorio. %n (e&ositorio es un es&acio destinado a almacenar inormación digital. En nuestro caso' lo @ue se almacenar en ese re&ositorio' sern los archivos -código 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 centraliado de' &rinci&almente' el código uente de la a&licación as) como scri&ts de construcción -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 desarrollndolas 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 automtico-' &ermitir el establecimiento de tags -eti@uetas- @ue auden a identiicar dierentes releases -versiones-.

"os #istemas de Control de
Centraliados: un 9nico re&ositorio centrali4ado administrado &or un solo res&onsable.

•

Distribuidos "recomendados$: donde e7iste un re&ositorio central @ue cada usuario &odr 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 P L#ot,are "ibreM' como es el caso de -entre otros-' it Lde "inus =orvalds' creador del ernel "inu7 en el @ue se basa el #istema 5&erativo 6N%+"inu7M' *ercurial Ldesarrollado en :thon  CM o el magn)ico Baaar ' nacido a &artir de 6N%Arch  desarrollado )ntegramente en :thon &or Iartin :ool' con el &atrocinio de Canonical  elegido en este curso .

%na gran 5entaja de los 3CI es @ue permiten a 5arios programadores trabajar simult7neamente sobre los mismos archi5os' im&idiendo @ue el traba!o de uno' &ise al traba!o de otro. "os #C< &ueden utili4arse tanto a trav>s de l)nea de comandos' como de a&licaciones Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

(8

gr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
%na ve4 instalado Ba4aar' debers clonar el repositorio central Ldesde el servidor del cursoM a tu ordenador local* 67 6anch ft&:55 tu_usuario @!!2282935ho*e5 tu_usuario 5&u6lic5tun

A continuación' debers ingresar tu contraseUa. %na ve4 clonado el re&ositorio' debers agregar unas l)neas al archivo de coniguración de Ba4aar. :ara ello' abre el archivo de coniguración 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 * &aent;location < ft&:55 tu_usuario @!!2282935ho*e5tu_usuario 5&u6lic5tun

A continuación' &ulsa tres veces' las teclas Ctrl S % &ara &egar Ltres vecesM la l)nea @ue cortaste anteriormente. $ebers ver lo siguiente* &aent;location < ft&:55 tu_usuario @!!2282935ho*e5tu_usuario 5&u6lic5tun &aent;location < ft&:55 tu_usuario @!!2282935ho*e5tu_usuario 5&u6lic5tun &aent;location < ft&:55 tu_usuario @!!2282935ho*e5tu_usuario 5&u6lic5tun

(eem&la4a la &alabra G parent H de la segunda l)nea' &or G pushH  la de la tercera' &or G pull H de orma tal @ue el archivo' se vea como sigue* &aent;location < ft&:55 tu_usuario @!!2282935ho*e5tu_usuario 5&u6lic5tun ;location < ft&:55 tu_usuario @!!2282935ho*e5tu_usuario 5&u6lic5tun push ;location < ft&:55 tu_usuario @!!2282935ho*e5tu_usuario 5&u6lic5tun pull

: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 &rogramación' Python nos pro5ee de reglas de estilos ' a in de &oder escribir código uente ms legible  de manera estandari4ada. Estas reglas de estilo' son deinidas a trav>s de la Python Enhancement Proposal J ) "PEP )$ ' la cual iremos viendo a lo largo del curso.


()

13r&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 &rogramación inter&retado son :thon' :J:' (ub' "is&' entre otros. ipado din7mico: un lengua!e de ti&ado dinmico 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!ecución' 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 &rogramación' tales como la orientación a ob!etos' as&ectos' la &rogramación im&erativa  uncional. C&digo uente: es un con!unto de instrucciones  órdenes lógicas' com&uestos de algoritmos @ue se encuentran escritos en un determinado lengua!e de &rogramación' las cuales deben ser inter&retadas o com&iladas' &ara &ermitir la e!ecución del &rograma inormtico.


('

,lementos del %enguae Como en la maor)a de los lengua!es de &rogramación de alto nivel' en :thon se com&one de una serie de elementos @ue alimentan su estructura. Entre ellos' &odremos encontrar los siguientes*

ariab"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;aia6le < alo;de;la;aia6le

Cada variable' tiene un nombre  un valor' el cual deine a la ve4' el ti&o de datos de la variable. E7iste un ti&o de GvariableH' denominada constante' la cual se utili4a &ara deinir valores i!os' @ue no re@uieran ser modiicados.

PEP ): 5ariables %tili4ar nombres descri&tivos  en min9sculas. :ara nombres com&uestos' se&arar las &alabras &or guiones ba!os. Antes  des&u>s del signo V' debe haber uno L solo unM es&acio en blanco Correcto: *i;aia6le < 12 i=aia6le < 0ncorrecto: *i;aia6le < 12

12 >

*iaia6le <

12 >

*i;aia6le<12 >

PEP ): constantes %tili4ar nombres descri&tivos  en ma9sculas se&arando &alabras &or guiones ba!os. Ejemplo: ?;COAB < 12

:ara imprimir un 5alor en pantalla ' en :thon' se utili4a la &alabra clave &int* *i;aia6le < 1 &int *i;aia6le

"o anterior' im&rimir 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 undo' *i;cadena;*ultilinea < ''' ta e una cadena de aia linea '''

N9mero entero* edad < 3

N9mero entero octal* edad < 043

N9mero entero he7adecimal* edad < 0#23

N9mero real* &ecio < -4328

Booleano Lverdadero + ?alsoM* edadeo < ue falo < Dale

E7isten adems' otros ti&os de datos ms com&le!os' @ue veremos ms adelante.


2(

5&eradores Aritm>ticos Entre los o&eradores aritm>ticos @ue :thon utili4a' &odemos encontrar los siguientes* Símbolo

Significado

Ejemplo

Resultado

.     5 55 I

Au*a Eeta egaciFn ulti&licaciFn #&onente HiiiFn HiiiFn entea Fdulo

a a a a a a a a

a a a a a a a a

< < < < < < < <

10 .  12   -   2  3 12 5 2 12 5 2 2- I 4

e e e e e e e e

1   3 8 !2 !0 3

PEP ): operadores #iem&re colocar un es&acio en blanco' antes  des&u>s de un o&erador 6n ejemplo sencillo con 5ariables y operadores aritmticos: *onto;6uto < 1- taa;intee < 12 *onto;intee < *onto;6uto  taa;intee 5 100 taa;6onificacion <  i*&ote;6onificacion < *onto;6uto  taa;6onificacion 5 100 *onto;neto < (*onto;6uto  i*&ote;6onificacion) . *onto;intee


22

Comentarios %n archivo' no solo &uede contener código uente. =ambi>n &uede incluir comentarios Lnotas @ue como &rogramadores' indicamos en el código &ara &oder com&renderlo me!orM. "os comentarios &ueden ser de dos ti&os* de una sola l)nea o multi-l)nea  se e7&resan de la siguiente manera* # Esto es un comentario de una sola línea

*i;aia6le < 1 ! este es un comentario de "arias líneas

*i;aia6le < 1 *i;aia6le < 1

# Este comentario es de una línea tambin

En los comentarios' &ueden incluirse &alabras @ue nos auden a identiicar adems' 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 código deben se&ararse con dos es&acios en blanco. "uego del s)mbolo W debe ir un solo es&acio en blanco. Correcto: a < 1 J dad de aMa 0ncorrecto: a < 1 J dad de aMa


2

=i&os de datos com&le!os :thon' &osee adems de los ti&os a vistos' 3 ti&os ms 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, 1, 28, Noto datoN, 2)

#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: 1

=ambi>n se &uede acceder a una &orción 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 Heuele: (1, 28, Noto datoN) J Heuele: (Noto datoN, 2) J Heuele: (Ncadena de te#toN, 1)

5tra orma de acceder a la tu&la de orma inversa Lde atrs hacia adelanteM' es colocando un )ndice negativo* &int *i;tu&la[1" &int *i;tu&la[2"

J Aalida: 2 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, 1, 28, Noto datoN, 2"

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[2"

J Aalida: 1 J Heuele: [1, 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ueo 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 < Nclae;1N: alo;1, Nclae;2N: alo;2, P Nclae;-N: alo;-Q &int *i;diccionaio[Nclae;2N" J Aalida: alo;2

%n diccionario &ermite eliminar cual@uier entrada* del(*i;diccionaio[Nclae;2N")

Al igual @ue las listas' el diccionario &ermite modiicar los valores *i;diccionaio[Nclae;1N" < Nueo =aloN


24

,structuras de Control de Fluo %na estructura de control' es un blo@ue de código @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 identación.

K9u es la identaci&nL En un lengua!e inormtico' la identación 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ormticos' re@uieren una identación. o 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 código uente. :ero en el caso de Python+ la identaci&n es obligatoria ' a @ue de ella' de&ender su estructura.

PEP ): identaci&n %na identación de % "cuatro$ espacios en blanco ' indicar @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icaciónM 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 ms @ue una directi5a ,ue se coloca al inicio de un archi5o Python+ a in de indicar al sistema+ la codiicaci&n de caracteres utiliada en el archi5o. J  coding: utf,- 

ut- &odr)a ser cual@uier codiicación de caracteres. #i no se indica una codiicación de caracteres' :thon &odr)a &roducir un error si encontrara caracteres Ge7traUosH* &int 'n el RSgaa encontL un RandT'

:roducir un error de sinta7is* A%nta#o: onBAC?? chaacte[" En cambio' indicando el encoding corres&ondiente' el archivo se e!ecutar con >7ito* J  coding: utf8  &int 'n el RSgaa encontL un RandT'

:roduciendo la siguiente salida* n el RSgaa encontL un RandT

Asignaci)n m"ti&"e 5tra de las venta!as @ue :thon nos &rovee' es la de &oder asignar en una sola instrucción' m9lti&les variables* a, 6, c < NtingN, 1, ue

En una sola instrucción' estamos declarando tres variables* a' b  c  asignndoles un valor concreto a cada una* +++ &int a ting +++ &int 6 1 +++ &int c ue

"a asignación m9lti&le de variables' tambi>n &uede darse utili4ando como valores' el Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

2/

contenido de una tu&la* +++ mitupla / 01hola mundo1 23445 +++ te6to anio / mitupla +++ &int te#to hola *undo +++ &int anio 2011

5 tambi>n' de una lista* +++ milista / 18rgentina1 19uenos 8ires1: +++ pais pro"incia / milista +++ &int &ai Bgentina +++ &int &oincia 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 código u otro, dependiendo de esta condición [...]” 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 ms condiciones se cum&len' &ara decir @u> acción 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 evaluación de condiciones' de manera mucho ms 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 ms de una condición &ara e!ecutar una determinada acción* 0i llega la factura de la lu& y tengo dinero, pagar la boleta.

:ara describir la evaluación a reali4ar sobre una condición' se utili4an operadores relacionales Lo de com&araciónM* %PER8&%RES RE;8<(%=8;ES 0&E <%*P8R8<(>=5

 Símbolo

Significado

Ejemplo

Resultado

<< < V + V< +<

?gual Kue Hitinto Kue eno Kue a%o Kue eno o igual Kue a%o o igual Kue

 << oo < ede 8 V 12 12 + 12 V< 12 4 +< 

Dalo =edadeo =edadeo Dalo =edadeo Dalo

D &ara evaluar ms de una condición simultneamente' se utili4an operadores l&gicos * %PER8&%RES ;>?(<%S

 %perador

Ejemplo

and (%)

 << - and - V 12 0 % 0 9 V 12 and 12 + 1 % 1 9 V 12 and 12 + 1 1 % 0 12 << 12 o 1 V - 1 o 0 - +  o 9 V 12 1 o 1 4 << 4 #o 9 + 3 1 o 1 4 << 4 #o 9 V 3 1 o 0

o (o) #o (o e#clu%ente)

Resultado@

Dalo =edadeo Dalo =edadeo =edadeo Dalo =edadeo

LXM 1 indica resultado verdadero de la condición' mientras @ue 0' indica also. Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

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.
#i semoro esta en verde' cru4ar la calle. #ino' es&erar. if e*afoo << ede: &int 'Cu7a la calle' ele: &int '&ea'

#i gasto hasta Y100' &ago con dinero en eectivo. #ino' si gasto ms 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 efectio' elif co*&a + 100 and co*&a V 300: &int 'ago con taeta de dL6ito' ele: &int 'ago con taeta 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  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 código' de manera re&etida' mientras se cum&la una condición. En :thon se dis&one de dos estructuras c)clicas* •

El bucle while

•

El bucle or

"as veremos en detalle a continuación.

Buc"e whi"e Este bucle' se encarga de e!ecutar una misma acción Gmientras @ueH una determinada condición se cum&la* Iientras @ue aUo sea menor o igual a 2012' im&rimir la rase Gnormes del AUo a1oH J  coding: utf8  anio < 2001 Ahile anio V< 2012: &int '?nfo*e del BXo', t(anio) anio .< 1

"a iteración anterior' generar 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 200 200! 2002008 2009 2010 2011 2012

#i miras la 9ltima l)nea* anio .< 1

:odrs notar @ue en cada iteración' 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 condición L anio V< 2012M siem&re se estar)a cum&liendo. Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

(

:ero u> sucede si el valor @ue condiciona la iteración no es num>rico  no &uede incrementarseF En ese caso' &odremos utili4ar una estructura de control condicional' anidada dentro del bucle'  renar la e!ecución 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 ser 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' seguir e!ecutndose hasta @ue el usuario' ingrese un te7to en &antalla.

Buc"e for El bucle or' en :thon' es a@uel @ue nos &ermitir 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, Ne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!ecución Les decir' se declaran dinmicamente durante el bucleM' asumiendo como valor' el de cada elemento de la lista Lo tu&laM en cada iteración. 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 Gnormes del AUo a1oH J  coding: utf8  fo anio in ange(2001, 2013): &int '?nfo*e del BXo', t(anio)


2

03

Módulos/ pa0uetes ' namespaces

En :thon' cada uno de nuestros archivos .& se denominan m&dulos. Estos módulos' 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 instrucción. $e hecho' &uede estar com&letamente vac)o.




Creando módulos empa0uetados En :thon' cada uno de nuestros archivos .& se denominan m&dulos. Estos módulos' 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 instrucción. $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 módulos' 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 módulo' &odr ser utili4ado a la ve4' &or otros módulos. :ara ello' es necesario importar los m&dulos @ue se @uieran utili4ar. :ara im&ortar un módulo' se utili4a la instrucción import' seguida del nombre del &a@uete Lsi a&licaM ms el nombre del módulo Lsin el .&M @ue se desee im&ortar. J  coding: utf8  import *odulo # importar un módulo que no pertenece a un paquete import &aKuete*odulo1 # importar un módulo que está dentro de un paquete import &aKueteu6&aKuete*odulo1


%

"a instrucción i*&ot seguida de no*6e;del;&aKueteno*6e;del;*odulo, nos &ermitir hacer uso de todo el código @ue dicho módulo 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 módulo donde se reali4ó la im&ortaciónM' a cual@uier elemento del módulo 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 módulo* &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&ortación' se asigna la &alabra clave as seguida del alias con el cul 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 módulos im&ortados' el names&ace utili4ado ser el alias indicado durante la im&ortación* &int m.COAB ;1 &int pm.COAB ;1 &int psm.COAB;1

Im&ortar m)'u"os sin uti"i6ar names&aces En :thon' es &osible tambi>n' im&ortar de un módulo solo los elementos @ue se desee utili4ar. :ara ello se utili4a la instrucción fo* seguida del names&ace' ms la instrucción i*&ot seguida del elemento @ue se desee im&ortar* from &aKuete*odulo1 import COAB;1


4

En este caso' se acceder directamente al elemento' sin recurrir a su names&ace* &int <%=S$8=$E4

Es &osible tambi>n' im&ortar ms de un elemento en la misma instrucción. :ara ello' cada elemento ir se&arado &or una coma L'M  un es&acio en blanco* from &aKuete*odulo1 import COAB;1  COAB;2

:ero ¿qué sucede si los elementos importados desde módulos diferentes tienen los mismos nombres? En estos casos' habr @ue pre5enir allos+ utiliando alias para los elementos* from &aKuete*odulo1 import COAB;1 as <4, COAB;2 as <2 from &aKueteu6&aKuete*odulo1 import COAB;1 as
&int &int &int &int

C1 C2 CA1 CA2

PEP ): importaci&n "a im&ortación de módulos debe reali4arse al comien4o del documento' en orden alab>tico de &a@uetes  módulos. :rimero deben im&ortarse los módulos &ro&ios de :thon. "uego' los módulos de terceros  inalmente' los módulos &ro&ios de la a&licación. 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 módulo' sin utili4ar su names&ace &ero tam&oco alias. Es decir' @ue todos los elementos im&ortados se acceder con su nombre original* fo* &aKuete*odulo1 import @ &int COAB;1 &int COAB;2

M1D1: Abrir una terminal e iniciar el shell interactivo Lint>r&reteM de :thon. A continuación' im&ortar el módulo thi* import this


8

04

Funciones de1inidas por el usuario

%na unción' 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 unción' al correr el archivo' el algoritmo no ser e!ecutado si no se ha hecho una reerencia a la unción @ue lo contiene.


/

+e1iniendo 1unciones En :thon' la deinición de unciones se reali4a mediante la instrucción def ms un nombre de unción descri&tivo -&ara el cul' 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inición de la unción inali4a con dos &untos L*M  el algoritmo @ue la com&one' ir identado con  es&acios* def *i;funcion05

J aKuM el algoit*o

%na unción' no es e!ecutada hasta tanto no sea invocada. :ara invocar una unción' sim&lemente se la llama &or su nombre* def *i;funcion(): &int '/ola undo' funcion05

Cuando una unción' haga un retorno de datos ' >stos' &ueden ser asignados a una variable* def funcion(): return '/ola undo' frase / funcion05

&int fae

Sobre "os &ar7metros %n &armetro es un valor @ue la unción es&era recibir cuando sea llamada LinvocadaM' a in de e!ecutar acciones en base al mismo. %na unción &uede es&erar uno o ms &armetros L@ue irn se&arados &or una comaM o ninguno. def *i;funcion 0nombre apellido5 : J algoit*o

Los parámetros, se indican entre los paréntesis, a modo de variables, a fin de poder utilizarlos como tales, dentro de la misma función.

"os &armetros @ue una unción es&era' sern utili4ados &or >sta' dentro de su algoritmo' a modo de 5ariables de 7mbito local . Es decir' @ue los &armetros sern variables locales' a las cules solo la unción &odr 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 unción' 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 función, 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 más a!a"o# $ Keywords como parámetros%&.

8ar7metros &or omisi)n En :thon' tambi>n es &osible' asignar valores &or deecto a los &armetros de las unciones. Esto signiica' @ue la unción &odr ser llamada con menos argumentos de los @ue es&era* def aluda(no*6e, mensaje/1Dola1 ): &int *enae, no*6e aluda(Ne&e GilloN)

# Imprime: Hola epe !rillo

PEP ): -unciones A la deinición de una unción la deben anteceder dos l)neas en blanco. Al asignar &armetros &or omisión' 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 unción' &asndole los argumentos es&erados' como &ares de clae<alo* def aluda(no*6e, *enae

'

aluda(mensaje/9uen día nombre/uancho )

8ar7metros arbitrarios Al igual @ue en otros lengua!es de alto nivel' es &osible @ue una unción' es&ere recibir un n9mero arbitrario -desconocido- de argumentos. Estos argumentos' llegarn a la unción en orma de tu&la. :ara deinir argumentos arbitrarios en una unción' se antecede al &armetro un asterisco LXM* def ecoe;&aa*eto;a6itaio(&aa*eto;fio, @arbitrarios): &int &aa*eto;fio # "os parámetros 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 41 1arbitrario 21 1arbitrario F1 )

'i una función espera reci!ir parámetros fi"os y ar!itrarios, los arbitrarios siempre deben suceder a los fijos.

Es &osible tambi>n' obtener &armetros arbitrarios como &ares de claveVvalor. En estos casos' al nombre del &armetro deben &recederlo dos astericos LXXM* def ecoe;&aa*eto;a6itaio(&aa*eto;fio, a6itaio, @@BAords ): &int &aa*eto;fio 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 clae in Yod: &int 'l alo de', clae, 'e', Yod[clae" 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 cla"e2/"alor dos )

4esem&a;ueta'o 'e &ar7metros :uede ocurrir adems' una situación inversa a la anterior. Es decir' @ue la unción es&ere una lista i!a de &armetros' &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 deber &receder al nombre de la lista o tu&la @ue es &asada como &armetro durante la llamada a la unción* Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

%;

def calcula(i*&ote, decuento): etun i*&ote  (i*&ote  decuento 5 100) datos / 4G33 43: &int calcula( @datos )

El mismo caso &uede darse cuando los valores a ser &asados como &armetros a una unción' se encuentren dis&onibles en un diccionario. A@u)' debern &asarse a la unción' &recedidos de dos asteriscos LXXM* def calcula(i*&ote, decuento): etun i*&ote  (i*&ote  decuento 5 100) datos / Hdescuento 43 importe 4G33I &int calcula( @@datos )

%lamadas de retorno En :thon' es &osible Lal igual @ue en la gran maor)a de los lengua!es de &rogramaciónM' llamar a una unción dentro de otra' de orma i!a  de la misma manera @ue se la llamar)a' desde uera de dicha unción* def funcion(): etun '/ola undo' def aluda(no*6e, *enae
#in embargo' es &osible @ue se desee realiar dicha llamada+ de manera din7mica ' es decir' desconociendo el nombre de la unci&n a la @ue se desear llamar. A este ti&o de acciones' se las denomina llamadas de retorno . :ara conseguir llamar a una unción de manera dinmica' :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 mbito local' mientras @ue el de glo6al()' retorna lo &ro&io &ero a nivel global. def funcion(): etun '/ola undo' def lla*ada;de;etono(func<''): """Llamada de retorno a nivel global"""

etun globals05func:05


%(

&int lla*ada;de;etono( funcion) # Llamada de retorno a nivel local

nombredelafuncion / funcion &int locals05nombre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 niel glo6al''' etun glo6al()[func" 0;aura5 &int lla*ada;de;etono('funcion') J ^la*ada de etono a niel 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 unción' &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 callable0locals05nombredelafuncion:5 : &int local()[no*6e;de;la;funcion"('*ile')

El o&erador in' nos &ermitir conocer si un elemento se encuentra dentro de una colección' mientras @ue la unción calla6le() nos de!ar saber si esa unción &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' Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

%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 unción' llamarse a s) misma' de igual orma @ue lo hace cuando llama a otra unción. def uga(intento<1): e&ueta < aY;in&ut('_He KuL colo e una naana` ') if e&ueta < 'naana': if intento V 3: &int 'PnDallate ?ntLntalo de nueo' intento .< 1 jugar0intento5

# "lamada recursi$a

ele: &int 'Pnedite' ele: &int 'PnGanate' uga()

Sobre la 1inalidad de las 1unciones %na unción' &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 realiar una Nnica acci&n+ reutiliable y por lo tanto+ tan genrica como sea posible .


%

05

Introducción a la Orientación a Obetos

En :thon todo es un Gob!etoH  debe ser mani&ulado - entendido- como tal. :ero u> es un ob!etoF $e @u> hablamos cuando nos reerimos a Gorientación a ob!etosF En este ca&)tulo' haremos una introducción @ue res&onder a estas - muchas otras- ®untas. Nos enocaremos &rimero' en cuestiones de conce&tos bsicos' &ara luego' ir introduci>ndonos de a &oco' en &rinci&ios teóricos elementalmente necesarios' &ara im&lementar la orientación a ob!etos en la &rctica.


%%

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 &rogramación. 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ormtica  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 cosa . D' si una cosa es un sustantivo' entonces un objeto es un sustanti5o. Iira a tu alrededor  encontrars 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 ciertoF Entonces' de ahora en ms' 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 ®untarnos Kc&mo es el objetoL =oda res&uesta @ue comience &or Gel ob!eto esH' seguida de un ad!etivo' ser 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 ®unta 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 ®unta* -Hu> es...FH' seguido del ad!etivo con el cul 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. K9u es verdeF %n color.

–

El ob!eto es grande. K9u es grandeF %n tamaUo.

–

El ob!eto es eo. K9u es eoF %n as&ecto.

Estos sustantivos @ue res&onden a la ®unta del niUo' &ueden &asar a ormar &arte de una locuci&n adjeti5a @ue es&ecii@ue con maor &recisión' las descri&ciones anteriores* –

El ob!eto es de color verde.

–

El ob!eto es de tamaño 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.
<G0B61 "locuci&n adjeti5a$

C6<0D
Les deM color

Les deM tamaUo

6rande

Les deM as&ecto

?eo

8ero a"gunos ob5etos, tambi>n se com&onen 'e otros ob5etos... Adems de cualidades Llocución ad!etiva seguida de un ad!etivoM' los objetos Otienen otras cosas . Estas Gotras cosasH' son a@uellas G&seudo-cualidadesH @ue en ve4 de res&onder a cómo es el ob!etoF res&onden a OKc&mo est7 compuesto el objetoL o incluso' a9n ms sim&le OK9u tiene el objetoL. "a res&uesta a esta ®unta' estar dada &or la rase Gel ob!eto tiene...H' seguida de un adverbio de cantidad Luno' varios' muchos' algunos' unas cuantasM  un sustantivo. Algunos e!em&los* Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

%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&ondern a la ®unta GCómo 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. Cómo son esas antenasF –

"as antenas son de color violeta

–

"as antenas son de longitud e7tensa

El ob!eto tiene un o!o. Cómo 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.  Cómo son esos &elosF –

"os &elos son de color ucsia

–

"os &elos son de te7tura rugosa

:ongmoslo ms grico* 1BQE1 "sustanti5o$

LelM 5b!eto

<G0B61>1BQE1 "sustanti5o$

<G0B613 "locuci&n adjeti5a$

C6<0D
Ltiene algunasM antenas

LdeM color LdeM longitud

Ltiene unM o!o

LdeM orma LdeM color LdeM tamaUo

5val a4ul grande

Ltiene unos cuantosM &elos

LdeM color LdeM te7tura

?ucsia rugosa

Entonces' &odemos deducir @ue un objeto puede tener dos tipos de atributos * 1M "os @ue res&onden a la ®unta “¿Cómo 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 ®unta “¿#ué tiene el obeto?! con la rase “El obeto Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

%/

tiene"""! S sustantivo Latributos deinidos &or las cualidades de otro ob!etoM

color

tamaño

aspecto

antenas

ojos

pelos Pelo

Antena

color

longitud

color

textura

Ojo

forma

color

tamaño

< 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. Cómo son esas antenasF –

"as antenas son de color violeta

–

"as antenas son de longitud e7tensa

El nuevo ob!eto tiene un o!o. Cómo 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. Cómo 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. Cómo es ese &ieF –

El &ie es de orma rectangular

–

El &ie es de color amarillo

–

El &ie tiene 3 dedos. Cómo son esos dedosF –

"os dedos son de longitud mediana

–

"os dedos son de orma alargada

–

"os dedos son de color amarillo


%'

Objeto

color

tamaño

aspecto

antenas

Pie

color

Pelo

longitud

Pie

color

pelos

Antena

Nuevo Objeto

forma

ojos

color

textura

Ojo

dedos

forma

color

tamaño

Dedo

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. Est claro adems' @ue el ob!eto original  el nuevo ob!eto' son dos ob!etos dierentes ciertoF No obstante' el nue5o objeto es un sub>tipo del objeto original . Ahora s)' a com&licarnos a9n ms.

os ob5etos, tambi>n tienen "a ca&aci'a' 'e hacer cosas 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' Gcules 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 ®untarte OK9u puede hacer el objetoL  la res&uesta a esta ®unta' estar 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 LademsM puede saltar

#i com&letamos el grico anterior con las acciones' obtendremos lo siguiente* Objeto

color

Nuevo Objeto

tamaño

aspecto

→ Flotar

antenas

color

Pelo

longitud

Pie

color

pelos

Antena

→ Saltar

Pie

forma

ojos

color

textura

Ojo

dedos

forma

color

tamaño

Dedo

longitud

forma

color

#i observas el grico anterior' notars @ue el nuevo ob!eto' no solo tiene los mismos atributos @ue el ob!eto original' sino @ue adems' tambi>n &uede reali4ar las mismas acciones @ue >ste. #encillo' ciertoF Ahora s)' com&li@u>monos del todo *M

b5etos : m7s ob5etos "a &arte 'ifci" #i entendiste todo lo anterior' ahora viene la &arte di)cil. 

4(

A" &an, &an. < a" ino, ino. as cosas &or su nombre Cuando en el documento...

En la programaci&n se denomina...

R con respecto a la programaci&n orientada a objetos es...

Jablamos de Gob!etoH

1bjeto

%n elemento

Jablamos de GatributosH Lo cualidadesM

Propiedades

%n elemento

Jablamos de GaccionesH @ue &uede reali4ar el ob!eto

*todos

%n elemento

Jablamos de Gatributos-ob!etoH

Composici&n

%na t>cnica

Polimorismo

%na caracter)stica

Jablamos de ob!etos @ue son sub-ti&os Lo am&liaciónM de otros

?erencia

%na caracter)stica

Ahora' &asemos a un marco un &oco ms Gacad>micoH.


42

Programación Orientada a Obetos "a :rogramación 5rientada a 5b!etos L:55 u 55: &or sus siglas en ingl>sM' es un paradigma de programaci&n .

Paradigma: teoría cuyo núcleo central )...* suministra la base y modelo para resolver problemas )...* +efinición de la eal Academia -spaola, igésimo tercera edición

Cómo 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ormtico. Bsicamente' este &aradigma se com&one de  elementos  / caracter)sticas @ue veremos a continuación.

E"ementos : Caractersticas 'e "a 8 "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 cules 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 cules se construirn nuestros ob!etos. :odemos tomar como e!em&lo de clases' el grico @ue hicimos en la &gina  de este documento. En :thon' una clase se deine con la instrucción cla seguida de un nombre gen>rico &ara el ob!eto. class O6eto:

&a

class Bntena:

&a

class elo:


4

&a

cla Oo: &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 Oo(): fo*a < '' colo < '' ta*anio < '' cla O6eto(): colo < '' ta*anio < '' a&ecto < '' antena < Bntena() oo < Oo() &elo < elo()

J &o&iedad co*&ueta &o el o6eto o6eto Bntena J &o&iedad co*&ueta &o el o6eto o6eto Oo J &o&iedad co*&ueta &o el o6eto o6eto elo

PEP ): propiedades "as &ro&iedades se deinen de la misma orma @ue las variables La&lican las mismas reglas de estiloM.

D>to'os "os m>todos son GuncionesH Lcomo las @ue vimos en el ca&)tulo anteriorM' solo @ue Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

4%

t>cnicamente se denominan m>todos'  re&resentan acciones &ro&ias @ue &uede reali4ar el ob!eto L no otroM* cla O6eto(): colo < 'ede' ta*anio < 'gande' a&ecto < 'feo' antena < Bntena() oo < Oo() &elo < elo() def flota(self):

&a

/otar 0ue el primer parámetro de un método, siempre de!e ser elf.

b5eto "as clases &or s) mismas' no son ms @ue modelos @ue nos servirn &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 materiali4ación. A la acción de crear ob!etos' se la denomina Ginstanciar una claseH  dicha instancia' consiste en asignar la clase' como valor a una variable* cla O6eto(): colo < 'ede' ta*anio < 'gande' a&ecto < 'feo' antena < Bntena() oo < Oo() &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

erencia caracterstica &rinci&a" 'e "a 8 Como comentamos en el t)tulo anterior' algunos ob!etos com&arten las mismas Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

44

&ro&iedades  m>todos @ue otro ob!eto'  adems agregan nuevas &ro&iedades  m>todos. A esto se lo denomina herencia* una clase @ue hereda de otra.
def flota(elf): &a

cla Hedo(o6ect): longitud < '' fo*a < '' colo < '' cla ie(o6ect): fo*a < '' colo < '' dedo < Hedo() # Nue$o&beto s( )ereda de otra clase: &beto

cla ueoO6eto(O6eto): &ie < ie() def alta(elf): &a

Acce'ien'o a "os m>to'os : &ro&ie'a'es 'e un ob5eto %na ve4 creado un ob!eto' es decir' una ve4 hecha la instancia de clase' es &osible Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

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 cul se desea acceder* o6eto < iClae() &int o6eto&o&iedad o6etoota;&o&iedad < 'ueo alo' aia6le < o6eto*etodo() &int aia6le &int o6eto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' &odr ser tratada como un subti&o del ob!eto string' el cul dis&one de m>todos @ue son heredados &or dicho subti&o. En este ca&)tulo' veremos los m>todos ms recuentes del ob!eto string.


4)

M2todos de 1ormato Conertir a ma'3scula la primera letra

*todo: ca&itali4eLM Getorna: una co&ia de la cadena con la &rimera letra en ma9sculas +++ cadena < '6ienenido a *i a&licaciFn' +++ &int cadena capitaliJe05 Uienenido a *i a&licaciFn

Conertir una cadena a min3sculas

*todo: lo,erLM Getorna: una co&ia de la cadena en min9sculas +++ cadena < '/ola undo' +++ &int cadena loAer05 hola *undo

Conertir una cadena a ma'3sculas

*todo: u&&erLM Getorna: una co&ia de la cadena en ma9sculas +++ cadena < '/ola undo' +++ &int cadena upper05 /O^B HO

Conertir ma'3sculas a min3sculas ' iceersa

*todo: s,a&caseLM ma9sculas en min9sculas  viceversa Getorna: una co&ia de la cadena convertidas las ma9sculas +++ cadena < '/ola undo' +++ &int cadena sAapcase05 hO^B *HO

Conertir una cadena en Format Formato o Título

*todo: titleLM Bahit ,,,.eugeniabahit.com+cursos abahit.com+cursos2012 2012 Curso Python para Principiantes – Eugenia Bahit ,,,.eugeni Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual Atribución-NoComercial-Com&artirgual 3.0

4'

Getorna: una co&ia de la cadena convertida +++ cadena < 'hola *undo' +++ &int cadena title05 /ola undo

Centrar un te&to

*todo: centerLlongitud\' Gcaracter de rellenoH]M Getorna: una co&ia de la cadena centrada +++ cadena < '6ienenido a *i a&licaciFn'ca&itali7e() +++ &int cadena center0G3 /5 <<<<<<<<<<
4linear te&to a la i.0uierda

*todo: l!ustLlongitud\' Gcaracter de rellenoH]M Getorna: una co&ia de la cadena alineada a la i4@uierda +++ cadena < '6ienenido a *i a&licaciFn'ca&itali7e() +++ &int cadena ljust0G3 /5 Uienenido a *i a&licaciFn<<<<<<<<<<<<<<<<<<<<<<<

4linear te&to a la dereca

*todo: r!ustLlongitud\' Gcaracter de rellenoH]M Getorna: una co&ia de la cadena alineada a la derecha +++ cadena < '6ienenido a *i a&licaciFn'ca&itali7e() +++ &int cadena rjust0G3 /5 <<<<<<<<<<<<<<<<<<<<<<
5ellenar un te&to anteponiendo ceros

*todo: 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 < 1- +++ &int t(nu*eo;factua) Jfill0425 000000001-


8(

M2todos de -3s0ueda Contar cantidad de apariciones de una subcadena

*todo: countLGsubcadenaH\' &osicionOinicio' &osicionOin]M Getorna: un entero re&resentando la cantidad de a&ariciones de subcadena dentro de cadena +++ cadena < '6ienenido a *i a&licaciFn'ca&itali7e() +++ &int cadena count0a5 3

-uscar una subcadena dentro de una cadena

*todo: indLGsubcadenaH\' &osicionOinicio' &osicionOin]M Getorna: un entero re&resentando la &osición donde inicia la subcadena dentro de cadena. #i no la encuentra' retorna -1 +++ cadena < '6ienenido a *i a&licaciFn'ca&itali7e() +++ &int cadena find0mi5 13 +++ &int cadena find0mi 3 435 1


82

M2todos de 6alidación Saber si una cadena comien.a con una subcadena determinada

*todo: starts,ithLGsubcadenaH\' &osicionOinicio' &osicionOin]M Getorna: =rue o ?alse +++ cadena < '6ienenido a *i a&licaciFn'ca&itali7e() +++ &int cadena startsAith09ien"enido5 ue +++ &int cadena startsAith0aplicaciKn5 Dale +++ &int cadena startsAith0aplicaciKn 4L5 ue

Saber si una cadena 1inali.a con una subcadena determinada

*todo: ends,ithLGsubcadenaH\' &osicionOinicio' &osicionOin]M Getorna: =rue o ?alse +++ cadena < '6ienenido a *i a&licaciFn'ca&itali7e() +++ &int cadena endsAith0aplicaciKn5 ue +++ &int cadena endsAith09ien"enido5 Dale +++ &int cadena endsAith09ien"enido 3 435 ue

Saber si una cadena es al1anum2rica

*todo: isalnumLM Getorna: =rue o ?alse +++ cadena < '&e&egillo -' +++ &int cadena isalnum05 Dale +++ cadena < '&e&egillo' +++ &int cadena isalnum05 ue +++ cadena < '&e&egillo-' +++ &int cadena isalnum05 ue


8

Saber si una cadena es al1ab2tica

*todo: isal&haLM Getorna: =rue o ?alse +++ cadena < '&e&egillo -' +++ &int cadena isalpha05 Dale +++ cadena < '&e&egillo' +++ &int cadena isalpha05 ue +++ cadena < '&e&egillo-' +++ &int cadena isalpha05 Dale

Saber si una cadena es num2rica

*todo: isdigitLM Getorna: =rue o ?alse +++ cadena < '&e&egillo -' +++ &int cadena isdigit05 Dale +++ cadena < '-84' +++ &int cadena isdigit05 ue +++ cadena < '- 84' +++ &int cadena isdigit05 Dale +++ cadena < '-84' +++ &int cadena isdigit05 Dale

Saber si una cadena contiene solo min3sculas

*todo: 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-' +++ &int cadena isloAer05


8%

ue

Saber si una cadena contiene solo ma'3sculas

*todo: isu&&erLM Getorna: =rue o ?alse +++ cadena < ' 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 < 'GE?^Ô' +++ &int cadena isupper05 ue

Saber si una cadena contiene solo espacios en blanco

*todo: 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 Título

*todo: 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 Sustitución +ar 1ormato a una cadena/ sustitu'endo te&to din7micamente

*todo: ormatLXargs' XX,argsM Getorna: la cadena ormateada +++ cadena < '6ienenido a *i a&licaciFn 0Q' +++ &int cadenaformat0en Python5 6ienenido a *i a&licaciFn en %thon +++ cadena < '?*&ote 6uto: $0Q . ?=B: $1Q < ?*&ote neto: 2Q' +++ &int cadenaformat0433 24 4245 ?*&ote 6uto: $100 . ?=B: $21 < ?*&ote neto: 121 +++ cadena < '?*&ote 6uto: $6utoQ . ?=B: $iaQ < ?*&ote neto: netoQ' +++ &int cadenaformat0bruto/433 i"a/24 neto/4245 ?*&ote 6uto: $100 . ?=B: $21 < ?*&ote neto: 121 +++ &int cadenaformat0bruto/433 i"a/433 @ 24 M 433 neto/433 @ 24 M 433 + 4335 ?*&ote 6uto: $100 . ?=B: $21 < ?*&ote neto: 121

5eempla.ar te&to en una cadena

*todo: 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 'ti*ado A no*6e a&ellido:' replace0buscar reemplaJarpor5 ti*ado A Zuan Le7:

,liminar caracteres a la i.0uierda ' dereca de una cadena

*todo: stri&L\GcaracterH]M Getorna: la cadena sustituida +++ cadena < ' YYYeugenia6ahitco* +++ &int cadena strip05 YYYeugenia6ahitco* +++ &int cadena strip01 15 YYYeugenia6ahitco*

'

,liminar caracteres a la i.0uierda de una cadena

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

*todo: rstri&L\GcaracterH]M Getorna: la cadena sustituida +++ cadena < 'YYYeugenia6ahitco* +++ &int cadena rstrip0 5 YYYeugenia6ahitco*

'


8/

M2todos de unión ' diisión #nir una cadena de 1orma iteratia

*todo: !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 00000', '0000 (?H: ', ')') +++ nu*eo < '2-' +++ nu*eo;factua < nu*eo join0formatonumerofactura5 +++ &int nu*eo;factua b 000002-0000 (?H: 2-)

Partir una cadena en tres partes/ utili.ando un separador

*todo: &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: 0QPnHo*inio: 1Q'fo*at(&otocolo, do*inio) otocolo: htt&:55 Ho*inio: eugenia6ahitco*

Partir una cadena en arias partes/ utili.ando un separador

*todo: 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 5 +++ &int e%Yod [N&%thonN, NguiaN, NcuoN, NtutoialN"

Partir una cadena en en líneas

*todo: s&litlinesLM Getorna: una lista donde cada elemento es una racción 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 módulo' deber cum&lir con los siguientes criterios de aceptaci&n * • • •

•

•

•

El nombre de usuario debe contener un m)nimo de  caracteres  un m7imo de 12 El nombre de usuario debe ser alanum>rico Nombre de usuario con menos de  caracteres' retorna el mensa!e GEl nombre de usuario debe contener al menos  caracteresH Nombre de usuario con ms de 12 caracteres' retorna el mensa!e GEl nombre de usuario no &uede contener ms 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 vlido' retorna =rue

E5ercicio +F2 Crear un m&dulo para 5alidaci&n de contraseSas. $icho módulo' deber cum&lir con los siguientes criterios de aceptaci&n * • •

• • •

"a contraseUa debe contener un m)nimo de  caracteres %na contraseUa debe contener letras min9sculas' ma9sculas' n9meros  al menos 1 carcter no alanum>rico "a contraseUa no &uede contener es&acios en blanco ContraseUa vlida' retorna =rue ContraseUa no vlida' retorna el mensa!e G"a contraseUa elegida no es seguraH

E5ercicio +F$ Crear un módulo @ue solicite al usuario el ingreso de un nombre de usuario  contraseUa  @ue los valide utili4ando los módulos generados en los dos e!ercicios anteriores.


/;

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

*todo: a&&endLGnuevo elementoHM +++ no*6e;*aculino < ['Blao', 'Zacinto', 'iguel', 'dgado', 'Haid'" +++ no*6e;*aculino append0ose5 +++ &int no*6e;*aculino [NBlaoN, NHaidN, NdgadoN, NZacintoN, NZoeN, NEic%N, NZoeN"

4gregar arios elementos al 1inal de la lista

*todo: e7tendLotraOlistaM +++ no*6e;*aculino e6tend0ose ?erardo:5 +++ &int no*6e;*aculino [NBlaoN, NHaidN, NdgadoN, NZacintoN, NZoeN, NEic%N, NZoeN, NZoeN, NGeadoN"

4gregar un elemento en una posición determinada

*todo: insertL&osición' Gnuevo elementoHM +++ no*6e;*aculino insert03 RicBy5 +++ &int no*6e;*aculino [NEic%N, NBlaoN, NHaidN, NdgadoN, NZacintoN, NZoeN, NEic%N, NZoeN, NZoeN, NGeadoN"


/2

M2todos de eliminación ,liminar el 3ltimo elemento de la lista

*todo: &o&LM Getorna: el elemento eliminado +++ no*6e;*aculino pop05 NGeadoN +++ &int no*6e;*aculino [NEic%N, NBlaoN, NHaidN, NdgadoN, NZacintoN, NZoeN, NEic%N, NZoeN, NZoeN"

,liminar un elemento por su índice

*todo: &o&L)ndiceM Getorna: el elemento eliminado +++ no*6e;*aculino pop0F5 NdgadoN +++ &int no*6e;*aculino [NEic%N, NBlaoN, NHaidN, NZacintoN, NZoeN, NEic%N, NZoeN, NZoeN"

,liminar un elemento por su alor

*todo: removeLGvalorHM +++ no*6e;*aculino remo"e0ose5 +++ &int no*6e;*aculino [NEic%N, NBlaoN, NHaidN, NZacintoN, NEic%N, NZoeN, NZoeN"


/

M2todos de orden Ordenar una lista en reersa (inertir orden)

*todo: reverseLM +++ no*6e;*aculino re"erse05 +++ &int no*6e;*aculino [NZoeN, NZoeN, NEic%N, NZacintoN, NHaidN, NBlaoN, NEic%N"

Ordenar una lista en 1orma ascendente

*todo: sortLM +++ no*6e;*aculino sort05 +++ &int no*6e;*aculino [NBlaoN, NHaidN, NZacintoN, NZoeN, NZoeN, NEic%N, NEic%N"

Ordenar una lista en 1orma descendente

*todo: 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, NHaidN, NBlaoN"


/%

M2todos de b3s0ueda Contar cantidad de apariciones elementos

*todo: countLelementoM +++ +++ 2 +++ +++ 2

no*6e;*aculino < ['Blao', 'iguel', 'dgado', 'Haid', 'iguel'" no*6e;*aculino count0*iguel5 no*6e;*aculino < ('Blao', 'iguel', 'dgado', 'Haid', 'iguel') no*6e;*aculino count0*iguel5

Obtener n3mero de índice

*todo: inde7Lelemento\' indiceOinicio' indiceOin]M +++ no*6e;*aculino inde60*iguel5 1 +++ no*6e;*aculino inde60*iguel 2 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!ecución' &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 colección 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* +++ lita1 < +++ lita2 < +++ listaF / +++ lita3 [1, 2, 3, 4, +++ tu&la1 < +++ tu&la2 < +++ tu&la3 < +++ tuplaN / +++ tu&la4 (1, 2, 3, 4,

[1, 2, 3, 4" [3, 4, , !, -, 8" lista4 + lista2

3, 4, , !, -, 8" (1, 2, 3, 4, ) (4, !, 8, 10) (3, , -, 9)

tupla4 + tupla2 + tuplaF

, 4, !, 8, 10, 3, , -, 9)

a"or m7imo : mnimo :odemos obtener adems' el valor m7imo  m)nimo tanto de listas como de tu&las*


/8

+++ 10 +++  +++ 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 unción 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 eliminación 6aciar un diccionario

*todo: clearLM +++ diccionaio < 'colo': 'ioleta', 'talle': 'A', '&ecio': 1-42Q +++ &int diccionaio NcoloN: NioletaN, N&ecioN: 1-42, NtalleN: NANQ +++ diccionaio .clear05 +++ &int diccionaio Q

M2todos de agregado ' creación Copiar un diccionario

*todo: co&LM +++ diccionaio < 'colo': 'ioleta', +++ e*ea < diccionaio .copy05 +++ diccionaio NcoloN: NioletaN, N&ecioN: 1-42, +++ e*ea NcoloN: NioletaN, N&ecioN: 1-42, +++ diccionaioclea() diccionaioclea() +++ diccionaio Q +++ e*ea NcoloN: NioletaN, N&ecioN: 1-42, +++ *uculoa < e*ea +++ e*ea NcoloN: NioletaN, N&ecioN: 1-42, +++ *uculoa NcoloN: NioletaN, N&ecioN: 1-42, +++ e*eaclea() e*eaclea() +++ e*ea Q +++ *uculoa Q +++

'talle': 'A', '&ecio': 1-42Q NtalleN: NANQ NtalleN: NANQ

NtalleN: NANQ NtalleN: NANQ NtalleN: NANQ

Crear un nueo 'iccionario 'e 'es s'e "as c"aes 'e una secuencia *todo: dict.romesLsec dict.romesLsecuencia\' uencia\' valor &or deecto]M


/'

+++ ecuencia < ['colo', 'talle', '*aca'" +++ diccionaio1 < dict.fromBeys0secuencia5 +++ diccionaio1 NcoloN: one, N*acaN: one, NtalleN: oneQ +++ diccionaio2 < dict.fromBeys0secuencia 1"alor 6 defecto15 +++ diccionaio2 NcoloN: Nalo # defectoN, N*acaN: Nalo # defectoN, NtalleN: Nalo # defectoNQ

Concatenar 'iccionarios I>todo* u&dateLdiccionarioM +++ diccionaio1 < 'colo': 'ede', '&ecio': 4Q +++ diccionaio2 < 'talle': '', '*aca': 'âcote'Q +++ diccionaio1 .update0diccionario25 +++ diccionaio1 NcoloN: NedeN, N&ecioN: 4, N*acaN: NâcoteN, NtalleN: NNQ

Estab"ecer una c"ae : a"or &or 'efecto *todo: 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 parámetro.

+++ e*ea < 'colo': 'oa', '*aca': 'aa'Q +++ clae < e*ea setdefault0talle O5 +++ clae NN +++ e*ea NcoloN: NoaN, N*acaN: NaaN, NtalleN: NNQ +++ e*ea2 < e*eaco&%() +++ e*ea2 NcoloN: NoaN, N*acaN: NaaN, NtalleN: NNQ +++ clae < e*ea2 setdefault0estampado5 +++ clae +++ e*ea2 NcoloN: NoaN, Neta*&adoN: one, N*acaN: NaaN, NtalleN: NNQ +++ clae < e*ea2 setdefault0marca ;acoste5 +++ clae NaaN +++ e*ea2 NcoloN: NoaN, Neta*&adoN: one, N*acaN: NaaN, NtalleN: NNQ


);

M2todos de retorno btener e" a"or 'e una c"ae *todo: 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 sin stocB5 Nin tocN

Saber si una c"ae eiste en e" 'iccionario *todo: 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

btener "as c"aes : a"ores 'e un 'iccionario *todo: iteritemsLM
btener "as c"aes 'e un 'iccionario *todo: esLM


)(

+++ diccionaio < NcoloN: NoaN, N*acaN: NaaN, NtalleN: NNQ +++ clae < diccionaio .Beys05 +++ clae [NcoloN, N*acaN, NtalleN"

btener "os a"ores 'e un 'iccionario *todo: valuesLM +++ diccionaio < NcoloN: NoaN, N*acaN: NaaN, NtalleN: NNQ +++ aloe < diccionaio ."alues05 +++ aloe [NoaN, NaaN, NN"

btener "a canti'a' 'e e"ementos 'e un 'iccionario :ara contar los elementos de un diccionario' al igual @ue con las listas  tu&las' se utili4a la unción integrada len() +++ diccionaio < NcoloN: NoaN, N*acaN: NaaN, NtalleN: NNQ +++ 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 módulo 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 -ms sim&le-' es el @ue nos &ermite traba!ar con archivos' mani&ulando su lectura  escritura a nivel de la a&licación  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 unción integrada open05' la cul est 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 ' est relacionado con el ob!etivo inal @ue res&onde a la ®unta “¿para qué estamos abriendo este archi%o?! . "as res&uestas a esta ®unta &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 5e ,ue abrimos un archi5o estamos creando un Opuntero' 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 &osición' mediante el nNmero de byte corres&ondiente. Este &untero' se crear -en inicio- de&endiendo del modo de a&ertura indicado' el cul ser indicado a la unción o&en() como una string en su segundo &armetro. Entre los modos de apertura posibles ' &odemos encontrar los siguientes* 0ndicador *odo de apertura r #olo lectura rb #olo lectura en modo binario

6bicaci&n del puntero Al inicio del archivo Al inicio del archivo

r+

"ectura  escritura

Al inicio del archivo

rb+

"ectura  escritura en modo binario


A

#olo escritura. #obreescribe el archivo si e7iste. Crea el archivo si no e7iste.


Ab

#olo escritura en modo binario. #obreescribe el archivo si e7iste. Crea el archivo si no e7iste.



)%

A+

Escritura  lectura. #obreescribe el archivo si e7iste. Crea el archivo si no e7iste.


Ab+

Escritura  lectura en modo binario. #obreescribe el archivo si e7iste. Crea el archivo si no e7iste.


a

AUadido Lagregar contenidoM. Crea el archivo si >ste no e7iste.

#i el archivo e7iste' al inal de >ste. #i el archivo no e7iste' al comien4o.

ab

AUadido en modo binario Lagregar contenidoM. Crea el archivo si >ste no e7iste.


a+

AUadido Lagregar contenidoM  lectura. Crea el archivo si >ste no e7iste.


ab+

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 ms recuentes' dis&one de los siguientes* *todo seeB0byte5

Descripci&n

6so

Iueve el &untero hacia el bte indicado

achio < o&en('e*eat#t', '') contenido < achioead() J el &unteo Kueda J al final del docu*ento archi"o.seeB035

read0bytes:5

readline0bytes:5 readlines05

tell05

"ee todo el contenido de un archivo. achio < o&en('e*eat#t', '') #i se le &asa la longitud de contenido < archi"o.read05 btes' leer solo el contenido &int contenido hasta la longitud indicada. "ee una l)nea del archivo.

achio < o&en('e*eat#t', '') linea1 < archi"o.readline05 &int linea1

< o&en('e*eat#t', '') "ee todas las l)neas de un achio fo linea in archi"o.readlines05: archivo &int linea

(etorna la &osición actual del &untero

achio < o&en('e*eat#t', '') linea1 < achioeadline() *a < achioead( archi"o.tell05  2) if archi"o.tell05 + 0: achioee(0) achio < o&en('e*eat#t', '.') contenido < achioead() final;de;achio < achiotell()

Arite0cadena5

Escribe cadena dentro del archi"o.Arite01=ue"a linea15 achioee(final;de;achio) archivo

nueo;contenido < achioead() &int nueo;contenido J uea linea achio < o&en('e*eat#t', '.') contenido < achioead() final;de;achio < achiotell()

#ecuencia ser cual@uier Aritelines0secuencia5 iterable cuos elementos sern escritos uno &or l)nea

close05

Cierra un archivo

lista / 1;ínea 4n1 1;ínea 21: archi"o.Aritelines0lista5

achioee(final;de;achio) &int achioeadline() J ^Mnea 1 &int achioeadline() J ^Mnea 2 achio < o&en('e*eat#t', '') contenido < achioead() archi"o.close05

&int contenido


)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icación de caracteres de un archivo de te7to

+++ +++ +++ +++

QQQ

achio < o&en('e*eat#t', '.') contenido < achioead() no*6e < archi"o.name *odo < archi"o.mode encoding < archi"o.encoding achiocloe() if archi"o.closed : &int 'l achio e ha ceado coecta*ente' ele: &int 'l achio &e*anece a6ieto'

+++ +++     l achio 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 versión 2.;' :thon incor&ora una manera GeleganteH de traba!ar con archivos de orma tal' @ue se cierren de orma automtica 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chio:

contenido < achioead()

&int achiocloed # *rue

Cuando una estructura Yith inali4a' :thon' automticamente 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 Módulos de la librería est7ndar

:thon nos &rovee de un gran abanico de módulos @ue integran su librer)a estndar' 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.


)'

Módulos de sistema Entre los módulos de sistema @ue :thon nos &rovee a trav>s de su librer)a estndar' &odemos destacar tres* os' sys'  subprocess Jaremos una breve reseUa de cada uno de ellos' a continuación.

D)'u"o os El módulo os nos &ermite acceder a uncionalidades de&endientes del #istema 5&erativo. #obre todo' a@uellas @ue nos reieren inormación sobre el entorno del mismo  nos &ermiten mani&ular la estructura de directorios L&ara leer  escribir archivos' ver ca&)tulo M. Geerencia oicial: htt&*++docs.&thon.org+librar+os.html

Archios : 'irectorios El módulo os nos &rovee de varios m>todos &ara traba!ar de orma &ortable con las uncionalidades del sistema o&erativo. todos ms destacados de este módulo. 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 simbólico

*todo oaccess(&ath, *odo;de;acceo)

ogetcAd() ochdir(nueo;&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, nueo) osymlinB(&ath, no*6e;detino)

Para ver al módulo 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 módulo os tambi>n nos &rovee de un diccionario con las variables de entorno relativas al sistema. #e trata del diccionario enion* i*&ot o fo aia6le, alo in os.en"ironiteite*(): &int 'I: I' I (aia6le, alo)

os.&ath El módulo o tambi>n nos &rovee del submódulo &ath Los.pathM el cual nos &ermite acceder a ciertas uncionalidades relacionadas con los nombres de las rutas de archivos  directorios. Entre ellas' las ms 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

*todo opath.abspath(&ath)

opath.basename(&ath) opath.e6ists(&ath) opath.getatime(&ath) opath.getsiJe(&ath)

#aber si una ruta es* 2na ruta absoluta 2n archi/o 2n directorio 2n enlace simbólico 2n punto de montaje

opath.isabs(&ath) opath.isfile(&ath) opath.isdir(&ath) opath.islinB(&ath) opath.ismount(&ath)

Para conocer más so!re os.path, isitar la documentación oficial en http#33docs.python.org3li!rary3os.path.html


'(

D)'u"o s:s El módulo % es el encargado de &roveer variables  uncionalidades' directamente relacionadas con el int>r&rete.

ariab"es 'e" m)'u"o s:s Entre las variables ms destacadas &odemos encontrar las siguientes* Iariable

Descripci&n (etorna una lista con todos los argumentos &asados &or l)nea de comandos. Al e!ecutar*

&%thon *odulo&% ag1 ag2

sys.arg"

%ag retornar una lista* [N*odulo&%N, Nag1N, Nag2N" sys.e6ecutable

(etorna el &ath absoluto del binario e!ecutable del int>r&rete de :thon

sys.ma6int

(etorna el n9mero &ositivo entero maor' so&ortado &or :thon

sys.platform

(etorna la &lataorma sobre la cul se est e!ecutando el int>r&rete

sys."ersion

(etorna el n9mero de versión de :thon con inormación adicional

D>to'os 'e" m)'u"o s:s Entre los m>todos ms destacados del módulo %' &odemos encontrar los siguientes* *todo

Descripci&n

sys.e6it05

?or4ar la salida del int>r&rete

sys.getdefaultencoding05

(etorna la codiicación de caracteres &or deecto

Sys.getfilesystemencoding05

(etorna la codiicación de caracteres @ue se utili4a &ara convertir los nombres de archivos unicode en nombres de archivos del sistema

Sys.getsiJeof0o6ect[, default"5

(etorna el tamaUo del ob!eto &asado como &armetro. El segundo argumento Lo&cionalM es retornado cuando el ob!eto no devuelve nada.

4ás información so!re el módulo sys, puede o!tenerse en http#33docs.python.org3li!rary3sys.html


'2

D)'u"o sub&rocess El módulo u6&oce es a@uel @ue nos &ermite traba!ar de orma directa con órdenes del sistema o&erativo.

-l módulo 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 módulo desaconsejando su uso para órdenes que puedan comprometer el sistema!

Entre

los

m>todos ms 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&erar 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 &armetro' call necesitar recibir una lista donde el &rimer elemento ser el comando  el segundo' sus argumentos. %n e!em&lo de ello' es el siguiente código encargado de hacer un listado de archi5os y directorios * fo* u6&oce i*&ot call co*ando;%;agu*ento < 1ls1 1,lha1: call(co*ando;%;agu*ento)

El módulo u6&oce tambi>n nos &rovee del submódulo Popen' el cul 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' recibir 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 @uedar 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, NlhaN"

A dierencia de call' :o&en no es un m>todo de u6&oce' sino' un ob!eto. Cómo tal' la orma correcta de iniciar un &roceso con :o&en' ser entonces' crear un ob!eto :o&en &ara &oder acceder a sus m>todos'  as) evitar' @ue el &roceso @uede abierto en e!ecución. $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 / Popen01ls1 1,lha1:5 proceso.Aait05

#i e!ecutamos el código 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 estndar en sistemas %NP-"ie. Es la encargada de almacenar la salida de un &rograma. stdin

nomenclatura corres&ondiente a la entrada estndar en sistemas %NP-lie. Es la encargada de enviar inormación 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 estndar o su error. :ara Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

'%

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 estndar o error de nuestro código' debemos &asarle a o&en' tdout  tde como argumentos claves' con ? como valor de cada uno de ellos' &ara lo cual' tambi>n debemos im&ortar ?* fo* u6&oce i*&ot P(PE, o&en &oceo < o&en([NlN, NlhaN", stdout/P(PE , stderr/P(PE)

Al ca&turar la salida estndar en una tuber)a' a no ser necesario &oner en es&era al &roceso' &uesto @ue directamente ser 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, NlhaN", 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, NlhaN", tdout<?, tde<?) 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 &oduo el iguiente eo:PnI' I errorencontrado

Para conocer más so!re subprocess, ingresar en http#33docs.python.org3li!rary3su!process.html


'4

Módulos para el programador 4ebuguear c)'igo con 8'b El módulo &d6 nos sirve &ara controlar &aso a &aso' la e!ecución 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. magina @ue tienes un archivo @ue genera errores  no logras descubrir la solución. :uedes im&ortar el módulo &d6  hacer una llamada a pdb.Pdb05.settrace05 en la l)nea' a &artir de la cul' deseas @ue tu scri&t comience a Gcaminar &aso a &asoH &ara as)' descubrir el error* J  coding: utf8  import pdb

fo* u6&oce i*&ot call, o&en, ? J î*&ia la &antalla call('clea') pdb.Pdb05.settrace05

&oceo < o&en([NlN, NlhaN", tdout<?, tde<?) 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 &oduo 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chio&%' d6 comen4ar a e!ecutar tu archivo l)nea &or l)nea' es&erando tu res&uesta. :or e!em&lo' en el código anterior' tras la e!ecución del archivo' la &antalla se lim&iar  d6 comen4ar a actuar' mostrndote la l)nea @ue sigue* + &oceo < o&en([NlN, NlhaN", tdout<?, tde<?) (d6)

d6 estar es&erando tu orden &ara continuar. Entre las órdenes ms usuales' &uedes indicar* n s c C

(ne#t) eecuta el cFdigo *otado % alta a la iguiente lMnea de tu achio (te&) te *otaS &ao a &ao el ca*ino ecoido hata &ode eecuta la iguiente lMnea de tu achio (continue) eecuta el achio 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 código de tu archivo' e!ecutando alguna instrucción* + litado < &oceotdoutead() (d6) n + 5ho*e5eugenia5Cuo5%thon &aa inci&iante5Fdulo 5ouce5u6&oce;e#a*&le5e#a*&le&%(13)V*odule+() + &oceotdoutcloe()

0Pdb5 listado.upper05 1$%$8; 42n&R)R)R,) 2 EO?E=(8 EO?E=(8 N3 2342,37,37 47FN .n&R)R)R,) EO?E=(8 EO?E=(8 N3 2342,37,37 47FN ..n,R,R,R,, 4 EO?E=(8 EO?E=(8 N2T 2342,37,37 23N- E)8*P;ES.P!n1

(d6)

Puedes o!tener más información 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 módulo +o unción de tu :thon a&&' e!ecutar en la termina pydoc tuapp ser suiciente &ara acceder a toda la documentación* ~$ pydoc tienda /el& on &acage tienda: =8*E

tienda '(;E

5ho*e5eugenia5&%thona&&5tienda5;;init;;&% P8<8?E <%=$E=$S

;;*ain;; ad*initacion (&acage) 6ucado (&acage) coe (&acage)

Alternativamente' tambi>n &uedes obtener la documentación en ormato J=I". :ara ello' debers e!ecutar* pydoc ,A nombredelmodulo 5tra alternativa' es iniciar un servidor 8eb local' @ue te &ermita navegar &or la documentación de tu a&&. :ara ello' sim&lemente e!ecuta pydoc ,p n Ldonde n' es el n9mero del &uerto &or el cual acceders. :or e!em&lo' pydoc ,p -3-3 inicia el servidor en htt&:55localhot:80805M. Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

'/

8robar e" c)'igo antes 'e eniar"o a &ro'ucci)n con 'octest El módulo doctet de :thon' nos &ermite indicar ragmentos de código en los comentarios de nuestros módulos' @ue emulen instrucciones del int>r&rete interactivo' e!ecutndolas de orma tal' @ue &odamos automati4ar las &ruebas de nuestra a&licación. 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  &i*e u*ando 6  egundo u*ando et:

QQQ sumardosnumeros02G 435 FG QQQ sumardosnumeros0F3 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 unción* +++ u*a;do;nu*eo(2, 10)

D deba!o' esto GsimulandoH el resultado @ue arro!ar)a en el int>r&rete interactivo. Esto' ser inter&retado &or doctet' como Gel resultado es&eradoH* 3

:ara correr los test' solo bastar con e!ecutar* ~$ &%thon *odulo&% 

D obtendremos un resultado similar a* eugenia@cochito:~5&%thona&&5doctet;e#a*&le$ %ing: u*a;do;nu*eo(2, 10) #&ecting: 3 o

python suma.py ,"


')

%ing: u*a;do;nu*eo(30, 20) #&ecting: 0 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 más so!re doctest, isita http#33docs.python.org3li!rary3doctest.html

ectura complementaria: htt&*++,,,.maestrosdel,eb.com+editorial+guia-&thontesteando-codigo-doctest-comentarios+


''

Módulos 0ue 1uncionales

resuelen

necesidades

btener 'atos a"eatorios Con el módulo random de la librer)a estndar de :thon' es &osible obtener datos aleatorios. Entre los m>todos de los cules dis&one' se destacan los siguientes* *todo random.randint0a, 65

Descripci&n (etorna un n9mero aleatorio entero entre a  b

random.choice0ecuencia5

(etorna cual@uier dato aleatorio de secuencia

random.shuffle0ecuencia5

(etorna una me4cla de los elementos de una secuencia

random.sample0ecuencia, n5

(etorna n elementos aleatorios de secuencia

import random # !enerar n+meros aleatorios entre ,---- y -----

lita < [" fo n in ange(0, 0): litaa&&end(random.randint0NTTTT 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.sample0lista G5 # reordenar los elementos de una lista

*uee < ['Bna', 'Ueati7', 'Ca*ila', 'Ca*en', 'Helia', 'Hoa', '*ile'" random.shuffle0mujeres5

Para conocer más so!re random, ingresar en http#33docs.python.org3li!rary3random.html


(;;

/ra&ear un teto El módulo 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 ser una l)nea de te7to' de longitud no su&erior a los 0 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 ui ut Yii oci6u uci&iantu, Kuo dicit iden incideint id uo *undi lo6oti efo*idan eu, legi*u eneit definie6a an eo u it tincidunt incou&te definitione*, i *utat affet &eci&it cu, ei*od conectetue ignifeu*Kue eu &e ?n uu latine eKuide* doloe uo no falli ii intellega*, ut fugit eitu &laceat &e Ya& < te6tArap.Arap0te6to L35 fo linea in Ya&: &int linea

Para conocer más so!re te6tArap ingresar en http#33docs.python.org3li!rary3te1twrap.html


(;(

Módulos 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*')

4ás so!re AebbroAser en http#33docs.python.org3li!rary3we!!rowser.html

urllib2 es otro módulo interesante para manipular peticiones 566P e interactuar a traés de 7nternet# http#33docs.python.org3li!rary3urlli!8.html

Conectarse a G38 El módulo ftplib de la librer)a estndar de :thon' nos &rovee de los m>todos necesarios &ara crear clientes ?=: de orma r&ida  sencilla.

Conectarse a un seri'or G38 :ara conectarse a un servidor D, el módulo ft&li6 nos &rovee de la clase D El m>todo constructor de la clase D Lm>todo ;;init;;()M' recibe como &armetros al host' usuario' clave' de orma tal @ue &asando estos &armetros 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 métodos connect y login

ft& < D() ft&connect(N!!228293N, 21, 999) ft&login(N*iueN, N*iclaeN) # Conectarse en la instancia a FTP

ft& < D(N!!228293N, N*iueN, N*iclaeN)

"a clase D' se com&one -entre otros- de los siguientes m>todos* Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

(;2

*todo '$P.connect0hot[, &ueto, ti*eout")

Descripci&n #e conecta al servidor ?=:

'$P.login0ue, &a5

#e loguea en el servidor

'$P.close05

?inali4a la cone7ión

'$P.setpas"06ool5

Establece la cone7ión en modo &asivo si el &armetro es =rue.

'$P.getAelcome05

(etorna el mensa!e de bienvenida del servidor

'$P.dir05

(etorna un listado de archivos  directorios de la car&eta actual

'$P.cAd0&ath5

Cambia el directorio de traba!o actual a &ath

'$P.mBd0&ath5

Crea un nuevo directorio

'$P.pAd05

(etorna el directorio de traba!o actual

'$P.rmd0&ath5

Elimina el directorio &ath

'$P.storlines01S$%R detino1 open0localfile 1r15

"ee localile  lo escribe en destino

'$P.rename0actual, nueo5

(enombra el archivo GactualH &or GnuevoH

'$P.delete0filena*e5

Elimina un archivo

'$P.retrlines01RE$R achio;e*oto15

"ee archivoOremoto  retorna su contenido

J  coding: utf8  from ftplib import '$P

ftp / '$P05 ft&connect(N!!228293N, 21, 999) ft&login(NueN, N&aN) &int ft& getAelcome () ft&mBd(NnueodiN) ft&cAd(Nnueodi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chio < ft& retrlines(NEE e#a*&le&%N) &int achio ft&close()

Para conocer más so!re ftplib, ingresar en http#33docs.python.org3li!rary3ftpli!.html


(;

11

Introducción a M'S9% ' el lenguae S9%

En este ca&)tulo haremos una introducción a conce&tos elementales sobre bases de datos' I#"  el lengua!e de consulta #".


(;%

4cerca de M'S9% I#" es un ser5idor de Bases de Datos 39 L#tructured uer "anguageM @ue se distribue en dos versiones* •

%na versión 6:" L#ot,are "ibreM

•

5tra versión &rivativa' llamada I#" AB

En este curso' utili4aremos la versión estndar 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.a.&d

Insta"aci)n : configuraci)n 'e D:SH :ara instalar I#"' &or l)nea de comandos' escribe* udo a&tget intall mysCl,ser"er mysCl,client

$urante la instalación' el sistema te &edir @ue ingreses una contraseUa &ara la administración de I#". Asigna una contraseUa @ue &uedas recordar cilmente  mantenla a salvo a @ue debers utili4arla recuentemente. %na ve4 @ue inalice la instalación' e!ecuta el siguiente comando a in de securi4ar el servidor I#" Lesta coniguración' es vlida tambi>n' &ara servidores de &roducciónM* udo mysClsecureinstallation

A continuación' el sistema te &edir @ue ingreses la contraseUa actual &ara administración de I#" Lla del usuario root de I#"M. =en en cuenta @ue la contraseUa no ser mostrada mientras escribes* nte cuent &aYod fo oot (ente fo none):

A continuación' te ®untar si deseas modiicar esa contraseUa. #alvo @ue desees modiicarla' ingresa n* Change the oot &aYod` [5n" n

Ahora la ®unta' ser si deseas eliminar usuarios anónimos. (es&onde @ue s)* Ee*oe anon%*ou ue` [5n" !

"uego' te ®untar si desees desabilitar el acceso remoto al usuario root de I#". :or su&uesto' res&onde @ue s)* Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

(;4

HialloY oot login e*otel%` [5n" !

"a siguiente ®unta ser si deseas eliminar la base de datos de &rueba  el acceso a ella. =ambi>n res&onde @ue s)* Ee*oe tet data6ae and acce to it` [5n" !

?inalmente' te ®untar 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 &iilege ta6le noY` [5n" !

Iniciar, reiniciar : 'etener e" seri'or D:SH En ocasiones necesitars iniciar' reiniciar o detener el servidor de bases de datos' I#". "as opciones dis&onibles son* stop

detiene el eido

start

inicia el eido

restart

einicia el eido

:ara iniciar' reiniciar o detener el servidor' debe rs ejecutar el siguiente comando ' seguido de la o&ción 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' necesitars &oder acceder a las o&ciones de administración 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 debers e!ecutar el siguiente comando* *%Kl u oot &

A continuación' debers ingresar la contraseUa del root de I#" Lno es la del root del #5. Es la @ue hemos conigurado durante la instalación de I#"M. "as u  & signiican usuario  &ass,ord res&ectivamente. =e a&arecer un shell interactivo &ara I#"* 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 necesitars &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*<D1

DE3CG0PC0T

shoA databasesU

Iuestra todas las bases de datos creadas en el servidor

use nombredelabasededatosU

ndicar @ue vas a comen4ar a utili4ar la base de datos elegida

create database nombredeladbU

Crear una nueva base de datos

Cuit

#alir del shell interactivo


(;/

Sobre el lenguae S9% 39 -siglas de 0tructured ;uery Language -' es el lenguaje de consultas a bases de datos' @ue nos &ermitir crear' modiicar' consultar  eliminar tanto bases de datos como sus tablas  registros' desde el shell interactivo de I#"  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 ms comunes' ace&tados &or versiones la versión ;.0.3 o su&erior' de I#". ipo de dato nteo T*eo deci*al

Denominaci&n (=$0=5 &E<(*8;0= &5

Especiicaciones

Ejemplo

 < cantidad de dMgito

?()

 < cantidad de dMgito totale H < cantidad de deci*ale

HC?B^(10, 2)

Uooleano

9%%;

UOO^

Decha

&8$E

HB

Decha % hoa

&8$E$(*E

HB?

Decha % hoa auto*Stica

$(*ES$8*P

?AB

/oa

$(*E

?

BXo

!E8R0&5

H < cantidad de dMgito (2 o 4)

BE(4)

Cadena de longitud fia

 < longitud de la cadena W ente 0 % 2

C/BE(2)

Cadena de longitud aia6le

V8R
 < longitud *S#i*a de la cadena W ente 0 % !32

=BEC/BE(100)

UloKue de te#to de gan longitud aia6le

9;%9

UÔU

Sint7is b7sica 'e "as sentencias SH %na sentencia #" Ldenominada “query” en la !erga inormticaM' es una instrucci&n escrita en lengua!e #".

(;)

Crear tab"as en una base 'e 'atos #inta7is*
no*6e;del;ca*&o ?O;H;HBO, no*6e;de;oto;ca*&o ?O;H;HBO

E!em&lo* CEB BU^ &oducto( &oducto =BEC/BE(12), deci&cion UÔU, &ecio HC?B^(!, 2), en;toc UOO^ )

E7&licación* CEB BU^ &oducto

Crear una nueva tabla llamada G&roductosH &oducto =BEC/BE(12),

Crear un cam&o llamado &roducto' de ti&o cadena de te7to de longitud variable' con una longitud m7ima de 12; caracteres deci&cion UÔU,

Crear un cam&o llamado descri&ción' de ti&o blo@ue de te7to de gran longitud &ecio HC?B^(!, 2),

Crear un cam&o &recio de ti&o num>rico de longitud m7ima de  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^A(dato1, dato2, dato10) U

E!em&lo* ?AE ?O &oducto(&oducto, &ecio, en;toc) =B^A(NUola de do*i &aa alta *ontaXaN, 234!, E)

E7&licación* ?AE ?O &oducto(&oducto, &ecio, en;toc)

nsertar un nuevo registro en los cam&os &roducto' &recio  enOstoc de la tabla &roductos =B^A(NUola de do*i &aa alta *ontaXaN, 234!, E)

Con los valores GBolsa de dormir &ara alta montaUaH' 23.;  verdadero' res&ectivamente en cada uno de los cam&os indicados

Se"eccionar registros #inta7is* SE;E<$ 'R%*

ca*&o1, ca*&o2, ca*&o10 ta6la

E!em&lo* A^C DEO

&oducto, &ecio &oducto

E7&licación* A^C

&oducto, &ecio

#eleccionar los cam&os &roducto  &recio DEO

&oducto

$e la tabla &roductos


((;

Do'ificar registros #inta7is* OP&8$E SE$

ta6la ca*&o1 < alo, ca*&o2 < alo, ca*&o10 < alo

E!em&lo* HB A

&oducto en;toc < DBÂ, &ecio < 0

E7&licación* HB

&oducto

Actuali4ar la tabla &roductos A

en;toc < DBÂ,

Iodiicar el cam&o enOstoc &or also &ecio < 0

 el cam&o &recio a 0

E"iminar registros #inta7is* &E;E$E 'R%* ta6la

E!em&lo* H^ DEO &oducto

E7&licación* H^ DEO &oducto

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 &rogramación :thon  no' en el lengua!e de consulta #"' haremos un r&ido &aseo' &or las o&ciones dis&onibles en #" &ara sentencias ms com&le!as @ue las anteriores.

a c"7usu"a /EE "as sentencias en #"' se com&onen de cl7usulas. D /E es una de ellas. "a cl7usula DERE nos &ermite iltrar registros en una sentencia #". Esta clusula' unciona de orma similar a la com&aración de e7&resiones en :thon' utili4ando los siguientes operadores de comparaci&n * Q /

+<

*a%o Kue igual Kue *a%o o igual Kue

9E$EE= n4 8=& n2 (S =O;;X$ROEX'8;SE (=(alo1, alo2, a)

W WQ

V<

*eno Kue ditinto Kue *eno o igual Kue

ente n1 % n2 e nulo > e edadeo > e falo contiene

:or su&uesto' tambien admite operadores l&gicos * 8=& (%)

=%$ (negaciFn)

%R (o)


((2

&oducto, &ecio

DEO

&oducto

DERE

precio W 4333U

Aumentar el 10Z del &recio de los &roductos' @ue actualmente se encuentren entre 1;0  200* HB A DERE

&oducto &ecio < (&ecio  110)

precio 9E$EE= 4G3 8=& 233U

#eleccionar &roductos donde enOstoc no sea also A^C DEO DERE

&oducto, &ecio &oducto

enstocB (S =%$ '8;SEU

Eliminar &roductos cuos &recios sean 100' 200 +o 300  adems' enOstoc sea also o &roducto sea nulo* H^ DEO DERE 8=& %R

&oducto

precio (=0433 233 F335 0enstocB (S '8;SE producto (S =O;;5U

Iodiicar enOstoc a verdadero donde &recio sea menor @ue ;0  &roducto no sea nulo* HB A DERE 8=&

&oducto en;toc < E

precio W G3 enstocB (S =%$ =O;;U

r'enan'o consu"tas "a c"7usu"a 4E B< Es &osible adems' ordenar los resultados de una consulta' en orma ascendente LBACM o descendente LHACM* A^C

&oducto, deci&cion, &ecio

DEO

&oducto

/E

&ecio U 1 BH 0


((

BH

en;toc ?A O DBÂ

%R&ER 9!

precio &ES
=ambi>n es &osible' ordenar los resultados de la consulta' &or ms de un cam&o* A^C

&oducto, deci&cion, &ecio

DEO

&oducto

/E BH

&ecio U 1 BH 0 en;toc ?A O DBÂ

%R&ER 9!

precio &ES< producto 8S
A"ias 'e tab"as : cam&os 5tra &osibilidad @ue nos da el lengua!e #"' es utili4ar alias &ara el nombre de los cam&os  las tablas. Estos alias se asignan mediante la &alabra clave reservada' 8S* A^C

&oducto deci&cion &ecio

8S 1=ombre del Producto1 8S &etalles 8S (mporte

DEO

&oducto

8S p

/E BH

&ecio U 1 BH 0 en;toc ?A O DBÂ

%R&ER 9!

precio &ES< producto 8S
/ótese 0ue los alias que contengan caracteres e"tra#os, de!en ser encerrados entre comillas simples

Gunciones 'e" "engua5e SH 'e D:SH Es &osible tambi>n' utili4ar diversas unciones &ro&ias del lengua!e #" -a sea estandar o de I#"- a in de &oder obtener los datos con cierto ormato.
((%

Contar "a canti'a' 'e registros C%+3!( A^C DEO

<%O=$0producto5

&oducto

BA Cantidad

Sumar tota"es S%D!( A^C DEO

SO*0precio5

&oducto

BA otal

Concatenar ca'enas C+CA3!( A^C

&oducto,

DEO

&oducto

<%=<8$01OS& 1 precio 1.,15

BA ecio

Nótese @ue las cadenas de caracteres deben encerrarse entre comillas sim&les  @ue el o&erador de concatenación &ara esta unción' es la coma.

Conertir a minscu"as : ma:scu"as CASE!( : %CASE!( A^C

O<8SE0producto5 ;<8SE0descripcion5

DEO

&oducto

eem&"a6ar 'atos E8ACE!( A^C DEO

REP;8
&oducto

BA Heci&cion

(eem&la4a `n` &or `br+`

btener "os &rimeros o "timos caracteres EG3!( : I*3!( A^C DEO

;E'$0producto G35

&oducto

e'on'ear nmeros %+4!( A^C DEO

R%O=&0precio 25

&oducto

(etornar los &recios con 2 decimales


((4

btener so"o "a fecha 3IDES3AD8 4A3E!( A^C DEO

'e

un

cam&o

4A3E3IDE

o

&8$E0campodatetime5

ta6la

btener una fecha formatea'a 4A3EJGDA3!( A^C DEO

&8$E'%R*8$0campofecha 1YdMYmMY!15

ta6la

btener e" registro con e" a"or m7imo : mnimo DAK!( : DI+!( A^C DEO

*8)0precio5

&oducto

(etorna el &roducto con el &recio ms caro A^C DEO

*(=0precio5

&oducto

(etorna el &roducto con el &recio ms barato

Optimi.ación de bases de +atos A continuación' encontrars una lista de conse!os @ue #EI:(E debes seguir' al momento de crear nuevas tablas  escribir sentencias #".

3o'os "os registros 'eben tener un I4 nico 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&letar automticamente' con un n9mero incremental' @ue te servir &ara o&timi4ar tus consultas  contar con un cam&o @ue te &ermita reconocer el registro como 9nico. CEB BU^ &oducto(

id (=$0445 =%$ =O;; 8O$%(=
)

&oducto =BEC/BE(12)

El cam&o id' ser como cual@uier otro  lo &odrs seleccionar en un #E"EC= o utili4arlo e cual@uier clusula 8JE(E.


((8

Crear n'ices en "as tab"as =odas las tablas deben tener un )ndice. El )ndice se asigna a uno o ms cam&os'  es utili4ado &or #" &ara iltrar registros de orma ms r&ida. $ebes crear )ndices con &recaución' a @ue de la misma orma @ue se aceleran las consultas' se retrasa la inserción  actuali4ación de registros' &uesto @ue la base de datos' deber actuali4ar los )ndices cada ve4 @ue se agreguen o modii@uen datos. Cuando una consulta es e!ecutada' I#" tratar de encontrar &rimero la res&uesta en los cam&os )ndice'  lo har en el orden @ue los )ndices haan sido creados.

KCu7ndo agregar #ndicesL Cuando vaas a utili4ar una combinación de cam&os en la clusula 8JE(E. :or e!em&lo' si iltrars 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* CEB BU^ &oducto( id ?(11) O ^^ BO;?CE E?BE j, &oducto =BEC/BE(12), &ecio HC?B^(10, 2), en;toc UOO^, deci&cion UÔU, (=&E)0precio enstocB5

)

In'ica cu7"es cam&os no &ue'en ser nu"os #" te da la &osibilidad de indicar @u> cam&os no &ueden estar nulos. ndicar @ue un cam&o no debe estar nulo' te audar a no almacenar registros deectuosos en tu base de datos. CEB BU^ &oducto( id ?(11) O ^^ BO;?CE E?BE j, &oducto =BEC/BE(12) =%$ =O;; , &ecio HC?B^(10, 2) =%$ =O;; , en;toc UOO^, deci&cion UÔU =%$ =O;; , ?H(&ecio, en;toc) )

%ti"i6a e" motor Inno4B El motor de bases de datos nno$B' te &ermitir crear tablas relaciones o&timi4ando su rendimiento. Al momento de crear tus tablas' indica @ue utili4ars el motor nno$B* CEB BU^ &oducto(


((/

id ?(11) O ^^ BO;?CE E?BE j, &oducto =BEC/BE(12) O ^^, &ecio HC?B^(10, 2) O ^^, en;toc UOO^, deci&cion UÔU O ^^, ?H(&ecio, en;toc)

) E=?(=E/(nno&9U

Aprende más so!re el lengua"e '9L , gratis en :;ey+ata


(()

-ases de datos relacionales As) como en la orientación a ob!etos' algunas clases se relacionan con otras' a sea a trav>s de la herencia o la com&osición' cuando nuestros ob!etos deben guardar un almac>n de datos' esa relación' debe conservarse tambi>n en la base de datos de nuestra a&licación. #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 sern necesarias* class Categoia(o6ect):

categoia;id < 0 categoia < '' actia < ue class oducto(o6ect):

&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 * CEB BU^ categoia( categoia;id ?(11) O ^^ BO;?CE E?BE j, categoia =BEC/BE(2) O ^^, actia UOO^ ) E=?(=E/(nno&9U


(('

CEB BU^ &oducto( &oducto;id ?(11) O ^^ BO;?CE E?BE j, categoriaid (=$0445 =%$ =O;;

&oducto =BEC/BE(2) O ^^, &ecio HC?B^(-, 2) O ^^, deci&cion UÔU,

'%RE(?= E! 0categoriaid5 RE'ERE=
uando el campo de una tabla hace referencia a la clave primaria de otra tabla , se denomina $clae foránea% o $foreign $ey% (en inglés&. Para poder utilizar claes foráneas, 4y'9L necesita utilizar s2 o s2, el motor %nno&' ya 0ue es el
Como &odrs 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 ms 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* DOE?G j (no*6e;de;la;clae;foanea) EDECA ta6la;elacionada(no*6e;de;la;clae;&i*aia)

En lengua!e humano' esto se leer)a como sigue* DOE?G j (Dj) la cla"e forZnea e ' EDECA BU^B(j) Kue hace referencia a la ta6la $89;80a taL del ca*&o P5

(K es una (oreign Key (clae foránea& 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 deber indicarse como ?oreign e mientras @ue el cam&o al cul hace Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

(2;

reerencia' deber indicarse como :rimar e. "uego' &odremos obtener' desde la base de datos' el Gob!etoH &roducto' incluendo los datos a los cules hace reerencia. :ara ello' utili4aremos la siguiente consulta* A^C DEO

&oducto, categoia &oducto ?E ZO? categoia A?G(categoia;id)

Con A^C &oducto, categoia estamos seleccionando todos los cam&os de la tabla &roducto  todos los cam&os de la tabla categoria. Iientras @ue con DEO &oducto ?E ZO? categoia A?G(categoia;id)' estamos diciendo @ue* DEO &oducto ?E ZO? categoia

$esde la tabla &oducto unida internamente a la tabla categoia A?G(categoia;id)

utili4ando el cam&o categoia;id Cómo comentamos anteriormente' una ? no necesariamente debe llevar el mismo nombre @ue la clave &rimaria a la cul hace reerencia. :odr)amos' &or e!em&lo' haber creado nuestra tabla &oducto de la siguiente manera* CEB BU^ &oducto( &oducto;id ?(11) O ^^ BO;?CE E?BE j, 'categoria (=$0445 =%$ =O;;

&oducto =BEC/BE(2) O ^^, &ecio HC?B^(-, 2) O ^^, deci&cion UÔU, '%RE(?= E! 0'categoria5

EDECA categoia(categoia;id) ) G?
:ero en este caso' deber)amos modiicar la sinta7is de nuestra consulta* A^C DEO

&oducto, categoia &oducto ?E ZO? categoia

%= producto.'categoria / categoria.categoriaid

Es decir' @ue a no &odemos indicarle @ue utilice el cam&o homónimo en ambas tablas' sino' @ue &ara reali4ar esta unión interna se base en la condición de igualdad del valor de los mismo Lcam&o orneo  &rimario res&ectivamenteM.


(2(

12

-ases de datos en P'ton con M'S9%


(22

Introducción a bases de datos con P'ton En :thon' el acceso a bases de datos se encuentra deinido a modo de estndar en las es&eciicaciones de @ue &uedes leer en la DB>todos  &rocesos de cone7ión' lectura  escritura de datos' desde :thon' siem&re sern los mismos' ms all del conector. conector. En nuestro caso &articular' utili4aremos I#"' &ara lo cual' vamos a traba!ar con el módulo *y39db. A dierencia de los módulos de la librer)a estndar de :thon' I#"db debe ser instalado manualmente. :ara ello' e!ecutaremos el siguiente comando* udo a&tget intall python,mysCldb

Conectarse a la base de datos ' eecutar consultas :ara conectarnos a la base de datos  e!ecutar cual@uier consulta' el &rocedimiento consiste en* 1. Abr Abrir ir la con cone7i e7ión ón  crear crear un un &unter &untero o 2. E! E!ec ecut utar ar la la cons consul ulta ta 3. =rae raerr los result resultado adoss Lsi de una selecció selección n se tra trataM taM o hac hacer er eectiv eectiva a la escritu escritura ra Lcuando se inserta' actuali4a o eliminan datosM . Cer Cerra rarr el &unt &untero ero  la cone cone7ió 7ión n

)os resultados resultados de una consulta consulta de de selección, se reci!en en una tupla, 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 %A^d6 HU;/OA HU;AE HU;BAA HU;B

< < < <

NlocalhotN NootN N*%KlootN NaN

def un;Kue%(Kue%
# Conectar a la base de datos # Crear un cursor # Ejecutar una consulta

if Kue%u&&e()tatYith(NA^CN): data < cuofetchall() # Traer los resultados de un select ele: connco**it() # Hacer efectiva la escritura de datos data < one cuocloe() conncloe()

# Cerrar el cursor # Cerrar la conei!n

etun data

Insertar 'atos dato < aY;in&ut('Hato: ') Kue% < '?AE ?O 6 (62) =B^A (NIN)' I dato un;Kue%(Kue%)

Se"eccionar to'os "os registr registros os Kue% < 'A^C 61, 62 DEO 6 OEHE U 62 HAC' eult < un;Kue%(Kue%) &int eult

Se"eccionar so"o registr registros os coinci'entes citeio < aY;in&ut('?ngee citeio de 6TKueda: ') Kue% < 'A^C 61, 62 DEO 6 /E 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% < 'H^ DEO 6 /E 62 < NIN' I citeio un;Kue%(Kue%)

Actua"i6ar 'atos 61 < aY;in&ut('?H: ') 62 < aY;in&ut('ueo alo: ') Kue% < 'HB 6 A 62

(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 Gcómo resolver necesidades &untualesH.


(28

Introducción E7isten en el mercado' varios rame,ors @ue nos &ermiten crear a&licaciones :thon robustas' de manera r&ida  servirlas a trav>s de nternet' en un sitio 8eb tradicional. Algunos de ellos' &oseen una ar@uitectura &articular' como es el caso de $!ango' @ue utili4a un &atrón ar@uitectónico denominado I<= Lmodel-vie,-tem&lateM' basado en Iste* 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@uitectónico coherente' es im&rescindible tener un e7celente dominio de la &rogramación orientada a ob!etos  am&lios conocimientos sobre &atrones ar@uitectónicos  &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&licación liviana' a @ue el consumo de recursos  el rendimiento' no estar com&ensado &or la robuste4 del desarrollo.

:ero ms all 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 -cómo 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+ utiliando el ser5idor
=Hu> necesitamos? En &rinci&io' necesitamos hacer @ue A&ache' incor&ore un so&orte &ara servir archivos :thon. :ara ello' necesitaremos habilitarle un módulo' @ue brinde este so&orte. E7isten varios módulos de A&ache @ue brindan so&orte &ara correr archivos :thon. %no de los ms &o&ulares es el módulo modpython' @ue sin embargo' &resenta algunos &roblemas Ldescri&tos en htt&*++docs.&thon.org+release+2./+ho,to+,ebservers.htmlWmodmodAsgi &thonM @ue &ueden &revenirse' utili4ando el módulo 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&tget 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&licación  cómo va a interactuar v)a 8eb. $ebemos tener un directorio destinado a montar toda la aplicaci&n * mBdir 5ho*e5%o5cuo&%thon5tun5 python,Aeb

$entro de este directorio' vamos a di5idir su ar,uitectura en dos partes * 1M $estinada al almacena!e de nuestra a&licación :thon &ura Lser un directorio &rivado' no servidoM 2M $estinada a servir la a&licación Ldirectorio &9blico servidoM en el cul solo almacenaremos archivos estticos mBdir 5ho*e5%o5cuo&%thon5tun5&%thonYe65 mypythonapp mBdir 5ho*e5%o5cuo&%thon5tun5&%thonYe65 publichtml


(2)

$entro de nuestro directorio *%&%thona&&' almacenaremos entonces' todos los módulos  &a@uetes de nuestra a&licación :thon' mientras @ue en &u6lic;ht*l' estarn todos los archivos estticos  ser 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o&%thon5tun5&%thonYe65 logs

$. Crear un contro"a'or &ara "a a&"icaci)n =odas las &eticiones reali4adas &or el usuario Les decir' las %( a las cules el usuario acceda &or el navegadorM' sern mane!adas &or un 9nico archivo' @ue estar almacenado en nuestro directorio *%&%thona&&. echo NJ  coding: utf8 N + *%&%thona&&5 controller.py

Este archivo contolle&% actuar como un &seudo DontContolle2' siendo el encargado de mane!ar todas las &eticiones del usuario' haciendo la llamada a los módulos corres&ondientes seg9n la %( solicitada. $icho módulo' solo se encargar de deinir una unción' @ue act9e con cada &etición del usuario. Esta unción' deber7 ser una unci&n =30 application 57lida . Esto signiica @ue* 1. $eber llamarse application 2. $eber recibir dos &armetros* en"iron' del módulo os' @ue &rovee un diccionario de las &eticiones J==: estndar  otras variables de entorno'  la unción startresponse' de 8#6' 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&+Uienenido a *i V6+%thonB&&V56+V5&+' # $nicio una res%uesta al navegador

tat;e&one(N200 OjN, [(NContent%&eN, Nte#t5ht*l chaet
etun out&ut

Is adelante' veremos como crear un &pplication 'S() Controller ' mucho ms &otente. 2 -ront Controller – :atrón de diseUo* htt&*++en.,ii&edia.org+,ii+?rontOControllerO&attern Curso Python para Principiantes – Eugenia Bahit ,,,.eugeniabahit.com+cursos2012 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

(2'

L. Configurar e" irtua"ost En la buena coniguración de nuestro =itual/ot' estar la clave &ara correr nuestra a&licación :thon a trav>s de la 8eb. Iientras @ue el Hocu*entEoot de nuestro sitio 8eb' ser la car&eta &9blica' &u6lic;ht*l' una variable del =itual/ot' ser la encargada de redirigir todas las &eticiones &9blicas del usuario' hacia nuestro DontContolle. D la variable @ue se encargue de esto' ser el alias AG?Aci&tBlia* udo nano 5etc5a&ache25iteaaila6le5&%thonYe6

%na ve4 all)' escribimos el contenido del nuevo virtual host* V=itual/ot :80+ Aeea*e &%thonYe6 &ocumentRoot MhomeMyoMcurso,pythonMtrunBMpython,AebMpublichtml S?(Script8lias M MhomeMyoMcurso,pythonMtrunBMpython,AebMmypythonappMcontroller.py

oôg 5ho*e5%o5cuo&%thon5tun5&%thonYe65log5eolog Cuto*ôg 5ho*e5%o5cuo&%thon5tun5&%thonYe65log5accelog co*6ined VHiecto% 5+ O&tion DolloYA%*în BlloYOeide Bll V5Hiecto%+ V5=itual/ot+

%na ve4 conigurado nuestro
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 estáticas en 564L o dinámicas en P5P u otro lengua"e.


(;

#tili.ando en"iron para manear peticiones del usuario El diccionario enion del módulo o' nos &rovee de la %( solicitada &or el usuario' a trav>s de la clave EA;E?. ndonos de ella' &odremos crear una A&&lication 8#6 Controller mucho ms &otente' @ue nos &ermita hacer s,itch de la &etición' &ara saber a @u> módulo 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&licación en nuestro controller.&' &ara @ue :thon bus@ue all) nuestros módulos* fo* % i*&ot &ath &atha&&end(N5ho*e5%o5cuo&%thon5tun5&%thonYe65N)

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 módulos' corres&ondientes a cada una de las secciones de nuestro sitio. ndonos de la clave (E%E#=O%( 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&%thonYe65N) fo* *%&%thona&&itioYe6 i*&ot contacto, default def a&&lication(enion, tat;e&one): peticion / en"iron1RE[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, [(NContent%&eN, Nte#t5ht*l chaet

((

%mportante: siempre, tras hacer un cam!io a tu aplicación, 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 ser el retornado &or la unción fo*ulaio() del módulo contacto del &a@uete itioYe6 #i en cambio' ingresramos en htt&*++&thon-a&&+gracias' ver)amos el contenido retornado &or la unción gacia() del mismo módulo. D si la %( solicitada no uese ni una ni otra' siem&re se mostrar el contenido retornado &or la unción default;&age() del módulo default del &a@uete itioYe6

6en en cuenta 0ue ningún print de tu app será tenido en cuenta. 6odas las funciones de tu app, tendrán 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 *< Ls de nternet' solo ser necesario entonces' instalar end*ail* udo a&tget 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 módulo de la librer)a estndar de :thon' @uien nos &ermitir enviar mensa!es de correo electrónico' incluso' en ormato J=I". #olo necesitaremos* •

Crear un objeto smtplib.S*$P el cul recibir como &armetro de su m>todo constructor' el host LlocalhostM

•

Crear un mensa!e de correo

•

Enviar el mensa!e mediante una llamada al mtodo sendmail del ob!eto #I=:.

Is cil es mirando el código* J  coding: utf8  import smtplib

remitente < 'Hede gnucita Ve6ahit@*e*6effog+' destinatario < 'a*a de Gnucita Veugenia6ahit@g*ailco*+' asunto < '*al /^ eniado dede %thon' mensaje < '''/olaV65+ V65+

te e un V6+e*ailV56+ eniando dede V6+%thonV56+ ''' email / 'rom Ys $o Ys *(*E,Version 4.3
I


(%

''' I (e*itente, detinataio, aunto, *enae) t%:

*t& < smtplib.S*$P01localhost15 *t&.sendmail0remitente destinatario email5 &int 'Coeo eniado' e#ce&t: &int '''o: el *enae no &udo enia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

m&ortamos el módulo 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 < 'a*a de Gnucita Veugenia6ahit@g*ailco*+' aunto < '*al /^ eniado dede %thon' *enae < '''/olaV65+ V65+ te e un V6+e*ailV56+ eniando dede V6+%thonV56+ '''

A continuación' generamos el e-mail con todos los datos deinidos anteriormente* e*ail < '''Do*: I o: I ?=eion: 10 Contentt%&e: te#t5ht*l Au6ect: I I ''' I (e*itente, detinataio, aunto, *enae)

D inalmente' creamos un ob!eto smt&* *t& < *t&li6A(NlocalhotN)

D reali4amos el env)o* *t&end*ail(e*itente, detinataio, e*ail)


(4

Python Para Principiantes

Recommend Documents