Python - Curso Python Para Principiantes

Eugenia Bahit

Curso: Python para Principiantes

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/201 or+120/201/1 /1

®2012 Eugenia Bahit

Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual Atribución-NoComercial-Com&artirgual 3.0

Buenos Aires, Argentina

2

00

Tabla de Contenidos (índice)

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

"

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

/

Agregar un elemento al inal de la lista................................................................................................./1 Agregar varios elementos al inal de la lista........................................................................................./1 Agregar un elemento en una &osición determinada............................................................................./1 I>todos de eliminación....................................... ...................................................................................... /2 Eliminar el 7ltimo elemento de la lista.................................................................................................../2 Eliminar un elemento &or su )ndice......................................................................................................./2 Eliminar un elemento &or su valor......................................................................................................../2 I>todos de orden...................................................................................................................................... /3 rdenar una lista en reversa Linvertir ordenM......................................................................................../3 rdenar una lista en orma ascendente................................................................................................/3 rdenar una lista en orma descendente............................................................................................../3 I>todos de b7sueda.............................................................................................................................../9 Contar cantidad de a&ariciones elementos.........................................................................................../9 btener n7mero de )ndice..................................................................................................................../9 Ane5o 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......................................................................................................................./ Establecer una clave  valor &or deecto............................................................................................../ I>todos de retorno.................................................................................................................................... 0 btener el valor de una clave...............................................................................................................0 #aber si una clave e5iste en el diccionario...........................................................................................0 btener las claves  valores de un diccionario.....................................................................................0 btener las claves de un diccionario....................................................................................................0 btener los valores de un diccionario...................................................................................................1 btener la cantidad de elementos de un diccionario............................................................................1 El objeto *ile: trabajando con archi4os$2 #obre el ob!eto ?ile......................................... ........................................................................................... 3 Iodos de A&ertura...............................................................................................................................3 I>todos del b!eto ?ile.............................................................................................................................; 8ro&iedades del ob!eto ile.........................................................................................................................@ Cerrando archivos de orma automtica..................................................................................................../ 5n Paseo por los '#dulos de la librería est6ndar$$ Iódulos de sistema................................................................................................................................... Iódulo os.............................................................................................................................................  Archivos  directorios....................................................................................................................... El módulo os  las variables de entorno..........................................................................................0 os.&ath..................................... ........................................................................................................ 0 Iódulo ss.......................................... ................................................................................................. 1 todos del módulo ss..................................................................................................................1 Iódulo sub&rocess...................................... ......................................................................................... 2 Ca&turando la salida con 8o&en......................................................................................................2 Entradas  salidas ue &ueden ser ca&turadas con 8o&en.............................................................3 stdout.......................................................................................................................................... 3 stdin........................................... ................................................................................................. 3 stderr.......................................................................................................................................... 3 %tili:ando tuber)as &ara ca&turar la salida.......................................................................................3 Iódulos &ara el &rogramador....................................................................................................................; $ebuguear código con 8db..................................................................................................................; $ocumentar tu a&& con &doc..............................................................................................................@ Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0



8robar el código antes de enviarlo a &roducción con doctest.............................................................../ Iódulos ue resuelven necesidades uncionales...................................................................................... btener datos aleatorios...................................................................................................................... 6ra&ear un te5to................................................................................................................................100 Iódulos e nternet...................................................................................................................................101 Acceder al navegador 6eb.................................................................................................................101 Conectarse v)a ?=8............................................................................................................................101 Conectarse a un servidor ?=8.......................................................................................................101 -ntroducci#n a 'y178 y el lenguaje 178%3" Acerca de I#"....................................................................................................................................109 nstalación  coniguración de I#"................................................................................................109 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5is bsica de las sentencias #"...............................................................................................10/ Crear tablas en una base de datos................................................................................................10 nsertar datos en una tabla............................................................................................................10 #eleccionar registros.....................................................................................................................10 Iodiicar registros.........................................................................................................................110 Eliminar registros...........................................................................................................................110 Consultas avan:adas.........................................................................................................................111 "a clusula 6JE(E......................................................................................................................111 rdenando consultas* la clusula ($E( BD..............................................................................112 Alias de tablas  cam&os....................................................................................................................113 ?unciones del lengua!e #" de I#".............................................................................................113 Contar la cantidad de registros* C%N=LM.....................................................................................119 #umar totales* #%ILM....................................................................................................................119 Concatenar cadenas* CNCA=LM..................................................................................................119 Convertir a min7sculas  ma7sculas* "CA#ELM  %CA#ELM.........................................................119 (eem&la:ar datos* (E8"ACELM....................................................................................................119 btener los &rimeros o 7ltimos caracteres* "E?=LM  (4J=LM......................................................119 (edondear n7meros* (%N$LM....................................................................................................119 btener solo la echa de un cam&o $A=E=IE o =IE#=AI8* $A=ELM......................................11; btener una echa ormateada* $A=EO?(IA=LM.......................................................................11; btener el registro con el valor m5imo  m)nimo* IAPLM  INLM................................................11; &timi:ación de bases de $atos.............................................................................................................11; =odos los registros deben tener un $ 7nico.......................................................................................11; Crear )ndices en las tablas.................................................................................................................11@ ndica cules cam&os no &ueden ser nulos........................................................................................11@ %tili:a el motor nno$B.......................................................................................................................11@ Bases de datos relacionales....................................................................................................................11 Bases de datos en Python con 'y178   %2% ntroducción a bases de datos con 8thon..............................................................................................122 Conectarse a la base de datos  e!ecutar consultas................................................................................122 %na orma sim&le de acceder a bases de datos.................................................................................123 nsertar datos.................................................................................................................................123 #eleccionar todos los registros......................................................................................................123 #eleccionar solo registros coincidentes.........................................................................................123 Eliminar registros...........................................................................................................................129 Actuali:ar datos.............................................................................................................................129 Corriendo Python 9pps en la eb%2 ntroducción........................................... .................................................................................................. 12@ 8thon ba!o A&ache.................................................................................................................................12/ u> 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 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

,

3. Crear un controlador &ara la a&licación.....................................................................................12 9. Conigurar el
Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

&

01

Preparación del entorno de desarrollo

Comen:aremos instalando todo nuestro sistema' &ara crear un entorno de desarrollo &ro&icio' &ara traba!ar con 8thon. A tal in' nos valdremos de las siguientes herramientas  tecnolog)as* 1. #istema &erativo 4N%+"inu5* %buntu 11.10 Lo su&eriorM 2. 8thon 2./ 3. i8thon L#hell interactivo me!oradoM 9. Nin!a-$E L$E de desarrolloM ;. Ba:aar L#istema de Control de

$

Introducción al Sistema Operativo GNU/inu! Antes de comen:ar' intentaremos establecer una dierencia' entre los t>rmino G"inu5H  G4N%+"inu5H' a in de saber de u> estamos hablando con e5actitud' en cada caso.

8inu= es un >ernel es decir' el n7cleo de un #istema &erativo' mientras ue ?@5A8inu= el 1istema .perati4o )ue utilia el ernel 8inu= como n7cleo' creado' diundido  &romovido a trav>s del Proyecto ?@5 ' &or la *ree 1o+tDare *oundation ' organi:ación sin ines de lucro' undada &or (ichard #tallman' &rinci&al &recursor del #ot,are "ibre. El ernel "inu5' &arte undamental del #istema &erativo' ue desarrollado &or 8inus Tor4als' utili:ando como modelo a %NP. %na de las dierencias undamentales entre los n7cleos "inu5  %NP' es ue el &rimero' es #ot,are "ibre' mientras ue el segundo no lo es. 8or otra &arte' mientras e5iste un 7nico ernel "inu5 Lcon versiones dierentesM' e5isten decenas  hasta cientos de distribuciones ?@5A8inu= ' es decir' dierentes #istemas &erativos basados en el ernel "inu5' entre las cuales se destacan* ebian' 5buntu' ubuntu' *edora ' ?entoo' 1lac>Dare' Cent.1' 9rch8inu=' 9sturi=' entre otros cientos. Is inormación al res&ecto' &uede encontrarse en* •

#itio 6eb de la *ree 1o+tDare *oundation * ,,,.s.org

•

#itio 6eb del Proyecto ?@5* ,,,.gnu.org

•

#itio 6eb del ernel 8inu=* htt&*++,,,.ernel.org+

•

#itio 6eb de la 8inu= *oundation * htt&*++,,,.linu5oundation.org+

•

ntroduccion al sot,are libre L%niversitat bierta de CatalunaM

•

#istema o&erativo gnu linu5 basico L%niversitat bierta de CatalunaM

Instalación de Ubuntu GNU/Linu en !indo"s #i eres usuario de 6indo,s  deseas conservar tu #istema &erativo actual' puedes descargar 5buntu indoDs -nstaller desde el sitio 6eb oicial de Canonical Lem&resa ue desarrolla  mantiene %buntuM en la siguiente %("* htt&*++,,,.ubuntu.com+do,nload+ubuntu+,indo,s-installer

5buntu indoDs -nstaller se instalar desde el &ro&io I# 6indo,sQ como si uese un #ot,are ms' &ermiti>ndote iniciar tu ordenador con %buntu o I# 6indo,sQ seg7n Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

F

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

Instalación de Ubuntu GNU/Linu co#o $nico %iste#a &'erati(o 8ara instalar %buntu como 7nico #istema &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. 8ara &rocesadores de un solo n7cleo' selecciona la versión 10.09 "=#. 8ara &rocesadores ms modernos' &uedes seleccionar la 7ltima 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 @9 bits' elige la de 32-bits. 8ulsa el botón G#tart do,nloadH  aguarda a ue se descargue el archivo. 3. %na ve: descargado el archivo' &odrs uemarlo en un C$+$<$ o un 8endrive %#B. En el &aso 2 de la %(" de descarga' selecciona C$ o %#B stic seg7n tus &reerencias  el #istema &erativo desde el cual hars la co&ia L6indo,s o IacM. 8ulsa el botón Gsho, me ho,H  sigue las instrucciones de uemado. 9. A continuación' salta al &aso 9 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.


%3

Instalando P"t#on %na ve: ue haas instalado tu distribución 4N%+"inu5' a tendrs 8thon instalado en tu sistema. 8ara com&robarlo' abres una terminal L&resiona Alt S ?9  luego escribe en el cam&o de b7s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 8thon. Para salir del 1hell interacti4o pulsa las teclas Ctrl H  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* Actuali:a la lista de los re&ositorios* eugenia@cochito:~$ udo a&tget u&date

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

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

1.BGE 8.1 C.'9@.1 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 4N%+"inu5 basadas en $ebian. Alternativamente' &uedes utili:ar


%%

el comando aptitude en ve: de a&t-get. update: o&ción de a&t-get ue sincroni:a los archivos del )ndice de &auetes con los re&ositorios oiciales Ldicho de otra orma' obtiene un )ndice de actuali:acionesM upgrade: o&ción de a&t-get ue actuali:a el sistema. install: es la o&ción de a&t-get ue indica ue se instalarn uno o ms &auetes


%2

Instalación de un S#ell interactivo me$orado 8thon trae &or deecto su &ro&io #hell interactivo' el cul nos &ermite escribir código 8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 n7meros de l)nea' sangrado automtico' etc.

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

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


%"

Nin$a%I&' Nin!a-$E es un Entorno ntegrado de $esarrollo 1 ue nos &ermitir' crear &roectos en 8thon' al tiem&o de ir e!ecutando nuestros códigos  corrigiendo eventuales errores ue >stos' &uedan &resentar.

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

2M #incroni:a el )ndice de actuali:aciones* 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 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

%/

Instalación de aaar Ba:aar es un sistema de control de versiones distribuido' ue nos &ermitir ir manteniendo el control cambios sobre nuestros archivos' centrali: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 utili:ar 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 reali:ar coniguraciones es&eciales' a sea tanto &ara continuar desarrollndolas como &ara e!ecutarlas-. 8ara 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 7nico re&ositorio centrali:ado administrado &or un solo res&onsable.

•

istribuidos (recomendados: donde e5iste 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 1CI distribuidos &odemos destacar e5celentes alternativas ?P8 L#ot,are "ibreM' como es el caso de -entre otros-' ?it Lde "inus =orvalds' creador del ernel "inu5 en el ue se basa el #istema &erativo 4N%+"inu5M' 'ercurial Ldesarrollado en 8thon  CM o el magn)ico Baaar ' nacido a &artir de 4N%Arch  desarrollado )ntegramente en 8thon &or Iartin 8ool' con el &atrocinio de Canonical  elegido en este curso .

%na gran 4entaja de los 1CI es ue permiten a 4arios programadores trabajar simult6neamente sobre los mismos archi4os' im&idiendo ue el traba!o de uno' &ise al traba!o de otro. "os #C< &ueden utili:arse tanto a trav>s de l)nea de comandos' como de a&licaciones Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

%

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' e5iste un determinado comando Lgeneralmente' similar en la maor)a de los #C
%na ve: instalado Ba:aar' 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 ve: clonado el re&ositorio' debers agregar unas l)neas al archivo de coniguración de Ba:aar. 8ara 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&la:a 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

8ara guardar el archivo &ulsa las teclas Ctrl S  LenterM  &ara salir' &ulsa Ctrl S P.


%,

02

'structura " elementos del len*ua$e

$entro de los lenguajes in+orm6ticos ' 8thon' &ertenece al gru&o de los lenguajes de programaci#n  &uede ser clasiicado como un lenguaje interpretado ' de alto ni4el ' multiplata+orma ' de tipado din6mico  multiparadigma . A dierencia de la maor)a de los lengua!es de &rogramación' Python nos pro4ee de reglas de estilos ' a in de &oder escribir código uente ms legible  de manera estandari:ada. 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.


%&

?8.19G-. 8enguaje in+orm6tico: es un idioma artiicial' utili:ado &or ordenadores' cuo in es transmitir inormación de algo a alguien. "os lengua!es inormticos' &ueden clasiicarse en* aM lengua!es de &rogramación L8thon' 8J8' 8earl' C' etc.MR bM lengua!es de es&eciicación L%I"MR cM lengua!es de consulta L#"MR dM lengua!es de marcas LJ=I"' PI"MR eM lengua!es de transormación LP#"=MR M &rotocolos de comunicaciones LJ==8' ?=8MR entre otros. 8enguaje de programaci#n: es un lengua!e inormtico' diseUado &ara e5&resar órdenes e instrucciones &recisas' ue deben ser llevadas a cabo &or una com&utadora. El mismo &uede utili:arse &ara crear &rogramas ue controlen el com&ortamiento )sico o lógico de un ordenador. Est com&uesto &or una serie de s)mbolos' reglas sintcticas  semnticas ue deinen la estructura del lengua!e. 8enguajes de alto ni4el: son auellos cua caracter)stica &rinci&al' consiste en una estructura sintctica  semntica legible' acorde a las ca&acidades cognitivas humanas. A dierencia de los lengua!es de ba!o nivel' son inde&endientes de la aruitectura del hard,are' motivo &or el cual' asumen maor &ortabilidad. 8enguajes interpretados: a dierencia de los com&ilados' no reuieren de un com&ilador &ara ser e!ecutados sino de un int>r&rete. %n int>r&rete' act7a 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 8thon' 8J8' (ub' "is&' entre otros. Tipado din6mico: 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' seg7n el valor declarado. 'ultiplata+orma: signiica ue &uede ser inter&retado en diversos #istemas &erativos como 4N%+"inu5' 6indo,s' Iac #' #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 en*ua$e Como en la maor)a de los lengua!es de &rogramación de alto nivel' en 8thon se com&one de una serie de elementos ue alimentan su estructura. Entre ellos' &odremos encontrar los siguientes*

)ariables %na variable es un es&acio &ara almacenar datos modiicables' en la memoria de un ordenador. En 8thon' una variable se deine con la sinta5is* 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 ve:' el ti&o de datos de la variable. E5iste un ti&o de GvariableH' denominada constante' la cual se utili:a &ara deinir valores i!os' ue no reuieran ser modiicados.

PEP $: 4ariables %tili:ar nombres descri&tivos  en min7sculas. 8ara 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 < -ncorrecto: *i;aia6le < 12

12 >

*iaia6le <

12 >

*i;aia6le<12 >

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

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

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


%F

*i'os de datos %na variable Lo constanteM &uede contener valores de diversos ti&os. Entre ellos* Cadena de te5to LstringM* *i;cadena < '/ola undo' *i;cadena;*ultilinea < ''' ta e una cadena de aia linea '''

N7mero entero* edad < 3

N7mero entero octal* edad < 043

N7mero entero he5adecimal* edad < 0#23

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

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

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


23

&eradores Aritm>ticos Entre los o&eradores aritm>ticos ue 8thon utili:a' &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 5n ejemplo sencillo con 4ariables y operadores aritm0ticos: *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


2%

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 e5&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 -ncorrecto: a < 1 J dad de aMa


22

=i&os de datos com&le!os 8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 sinta5is  &or la orma en la cual los datos &ueden ser mani&ulados.

*u'las %na tu&la es una 4ariable )ue permite almacenar 4arios datos inmutables Lno &ueden ser modiicados una ve: 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)

tra 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

Listas %na lista es similar a una tu&la con la dierencia undamental de ue &ermite modiicar los datos una ve: 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 n7mero 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 N son inmutables* &ermiten modiicar los datos una ve: 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)

+iccionarios Iientras ue a las listas  tu&las se accede solo  7nicamente &or un n7mero de )ndice' los diccionarios &ermiten utili:ar 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


2/

'structuras de Control de +lu$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

Identación 8ara hablar de estructuras de control de lu!o en 8thon' es im&rescindible &rimero' hablar de identación.

K7u0 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. 8ero 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


2

Encoding 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 es ms ue ue una una directi4a )ue se coloca al inicio de un archi4o Python a +in de indicar al sistema la codi+icaci#n de caracteres utiliada en el archi4o J  coding: utf,- 

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

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

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

Asignación #$lti'le tra de las venta!as ue 8thon nos &rovee' es la de &oder asignar en una sola instrucción' m7lti&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 m7lti&le de variables' tambi>n &uede darse utili:ando como valores' el Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 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

 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 de control de lu-o condicionales “[...] Los condicionales nos permiten comprobar comprobar condiciones y hacer que nuestr nuestro o progra programa ma se compor comporte te de una una forma forma u otra, otra, que que ejecut ejecute e un fragmento de código u otro, dependiendo dependiendo de esta condición [...]” Cita tetual del libro “!ython para "odos” de #a$l %on&'le& (uque ) http*++mundogee.net+tutorial-python+ 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. 8a e4aluaci#n de condiciones' solo puede arrojar 1 de 2 resultados* 4erdadero o +also L=rue o ?alseM. En la vida diaria' actuamos de acuerdo a la evaluación de condiciones' de manera mucho /erde, cru&ar cru&ar la ms recuente de lo ue en realidad creemos* Si el sem'foro est' en /erde, calle. Sino Sino,, esperar a que el sem'foro se ponga en /erde. A veces' tambi>n evaluamos lu& y 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.

8ara de 8ara descr scribi ibirr la eva evalua luació ción n a rea reali: li:ar ar sob sobre re una condició condición' n' se uti utili: li:an an operadores relacionales Lo de com&araciónM* %PER8&%RES RE;8<(%=8;ES 0&E <%*P8R8<(>=5 <%*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 utili:an 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 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 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' cru:ar 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


2F

Estructuras de control 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 8thon se dis&one de dos estructuras c)clicas* •

El bucle Dhile

•

El bucle +or

"as veremos en detalle a continuación.

Bucle "hile 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 7ltima l)nea* anio .< 1

8odr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 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

"3

8ero u> sucede si el valor ue condiciona la iteración no es num>rico  no &uede incrementarseF En ese caso' &odremos utili:ar 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 te5to 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 te5to en &antalla.

Bucle or El bucle or' en 8thon' es auel ue nos &ermitir iterar sobre una variable com&le!a' del ti&o lista o tu&la* 8or 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

8or 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. tra orma de iterar con el bucle or' &uede emular a ,hile* 8or 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)


"%

03

,ódulospa.uetes " namespaces

En 8thon' cada uno de nuestros archivos .& se denominan m#dulos. Estos módulos' a la ve:' &ueden ormar &arte de pa)uetes. %n &auete' es una car&eta ue contiene archivos .&. 8ero' &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.


"2

Creando módulos empa.uetados En 8thon' cada uno de nuestros archivos .& se denominan m#dulos. Estos módulos' a la ve:' &ueden ormar &arte de pa)uetes. %n &auete' es una car&eta ue contiene archivos .&. 8ero' &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 ve:' 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&%

I#'ortando #ódulos enteros El contenido de cada módulo' &odr ser utili:ado a la ve:' &or otros módulos. 8ara ello' es necesario importar los m#dulos ue se uieran utili:ar. 8ara im&ortar un módulo' se utili:a 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 est6ndar ' ue tambi>n &ueden ser im&ortados.

Na#es'aces 8ara acceder Ldesde el módulo donde se reali:ó la im&ortaciónM' a cualuier elemento del módulo im&ortado' se reali:a mediante el namespace' seguido de un &unto L.M  el nombre del elemento ue se desee obtener. En 8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

Alias Es &osible tambi>n' abreviar los names&aces mediante un GaliasH. 8ara 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 utili:ado 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

I#'ortar #ódulos sin utili.ar na#es'aces En 8thon' es &osible tambi>n' im&ortar de un módulo solo los elementos ue se desee utili:ar. 8ara ello se utili:a 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


"/

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. 8ara 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

8ero ¿qué sucede si los elementos importados desde módulos diferentes tienen los mismos nombres? En estos casos' habr ue pre4enir +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 reali:arse al comien:o del documento' en orden alab>tico de &auetes  módulos. 8rimero deben im&ortarse los módulos &ro&ios de 8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 utili:ar 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

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


"

04

+unciones deinidas por el usuario

%na unción' es la orma de agru&ar e5&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.


",

&einiendo unciones En 8thon' la deinición de unciones se reali:a 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 8thon' la deinición de la unción inali:a con dos &untos L*M  el algoritmo ue la com&one' ir identado con 9 es&acios* def *i;funcion05

J aKuM el algoit*o

%na unción' no es e!ecutada hasta tanto no sea invocada. 8ara 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

%obre los 'ar#etros %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 utili:ados &or >sta' dentro de su algoritmo' a modo de 4ariables de 6mbito 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%&.

ar#etros 'or o#isión En 8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.

e"ords co#o 'ar#etros En 8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 )

ar#etros arbitrarios Al igual ue en otros lengua!es de alto nivel' es &osible ue una unción' es&ere recibir un n7mero arbitrario -desconocido- de argumentos. Estos argumentos' llegarn a la unción en orma de tu&la. 8ara 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 )

+ese#'a3uetado de 'ar#etros 8uede 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 ve: 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 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

"F

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 8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 din6mica ' 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 . 8ara conseguir llamar a una unción de manera dinmica' 8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


/3

&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

%aber si una unción eiste  'uede ser lla#ada $urante una llamada de retorno' el nombre de la unción' &uede no ser el indicado. Entonces' siem&re ue se deba reali:ar una llamada de retorno' es necesario com&robar ue >sta e5ista  &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 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

/%

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 recursivas 1e denomina llamada recursi4a (o recursi4idad a a)uellas +unciones )ue en su algoritmo hacen re+erencia sí misma "as llamadas recursivas suelen ser mu 7tiles en casos mu &untuales' &ero debido a su gran actibilidad de caer en iteraciones ininitas' deben e5tremarse las medidas &reventivas adecuadas ' solo utili:arse cuando sea estrictamente necesario  no e5ista una orma alternativa viable' ue resuelva el &roblema evitando la recursividad. 8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 inalidad de las unciones %na unción' &uede tener cualuier ti&o de algoritmo  cualuier cantidad de ellos ' utili:ar cualuiera de las caracter)sticas vistas hasta ahora. No obstante ello' una buena pr6ctica indica )ue la +inalidad de una +unci#n debe ser realiar una Nnica acci#n reutiliable y por lo tanto tan gen0rica como sea posible .


/2

05

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

En 8thon todo es un Gob!etoH  debe ser mani&ulado - entendido- como tal. 8ero 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 8ensar en ob!etos' &uede resultar -al inicio- una tarea di)cil. #in embargo' di)cil no signiica com&le!o. 8or 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.

4 53u6 es un ob-eto7 8ues' como di!e antes' es Gsim&leH. lvidemos los ormalismos' la inormtica  todo lo ue nos rodea. #im&lemente' olvida todo  conc>ntrate en lo ue sigue. "o e5&licar> de manera Gsim&leH*

5n objeto es Ouna cosa . D' si una cosa es un sustantivo' entonces un objeto es un sustanti4o. Iira a tu alrededor  encontrars decenas' cientos de ob!etos. =u ordenador' es un ob!eto. =7' 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 53u6 #e dices si describi#os las cualidades de un ob-eto7 $escribir un ob!eto' es sim&lemente mencionar sus cualidades. 8as cualidades son adjeti4os. #i no sabes ue es un ad!etivo' estamos !odidos L muchoM. 8ero' &odemos decir ue un adjeti4o es una cualidad del sustanti4o . 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


//

El objeto es eo Ahora' imagina ue te encuentras rente a un niUo de 2 aUos LniUo* ob!eto ue ®unta cosas ue t7 das &or entendidas de orma im&l)citaM. D cada ve: 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 inali:aste 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. K7u0 es verdeF %n color.

–

El ob!eto es grande. K7u0 es grandeF %n tamaUo.

–

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

Estos sustantivos ue res&onden a la ®unta del niUo' &ueden &asar a ormar &arte de una locuci#n adjeti4a 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.

8odemos 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 sustanti4o )ue posee atributos cuyas cualidades lo describen
9TG-B5T. (locuci#n adjeti4a

C598-9 E8 9TG-B5T. (adjeti4o

Les deM color

Les deM tamaUo

4rande

Les deM as&ecto

?eo

ero algunos ob-etos, ta#bi6n se co#'onen de otros ob-etos888 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 ve: de res&onder a cómo es el ob!etoF res&onden a OKc#mo est6 compuesto el objetoL o incluso' a7n ms sim&le OK7u0 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 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

/

–

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 e5tensa

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 a:ul

–

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 te5tura rugosa

8ongmoslo ms grico* .BQET. (sustanti4o

LelM b!eto

9TG-B5T.;.BQET. (sustanti4o

9TG-B5T.1 (locuci#n adjeti4a

C598-9E1 E 8.1 9TG-B5T.1 (adjeti4o

Ltiene algunasM antenas

LdeM color LdeM longitud

Ltiene unM o!o

LdeM orma LdeM color LdeM tamaUo

val a:ul grande

Ltiene unos cuantosM &elos

LdeM color LdeM te5tura

?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 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

4 ta#bi6n ha2 ob-etos 3ue co#'arten caracter9sticas con otros ob-etos #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 e5tensa

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 a:ul

–

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 te5tura rugosa

(nue4as 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 e5actamente 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 nue4o objeto es un sub;tipo del objeto original . Ahora s)' a com&licarnos a7n ms.

Los ob-etos, ta#bi6n tienen la ca'acidad de :hacer cosas; Da describimos las cualidades de nuestros ob!etos. 8ero 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 reali:ar acciones. "as acciones' son verbos. Es decir' ue &ara conocer las ca&acidades de un ob!eto' debes ®untarte OK7u0 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


/F

–

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 reali:ar las mismas acciones ue >ste. #encillo' ciertoF Ahora s)' com&liu>monos del todo *M

&b-etos  #s ob-etos< la 'arte di9cil #i entendiste todo lo anterior' ahora viene la &arte di)cil. 

3

Al 'an, 'an8 4 al (ino, (ino8 Las cosas 'or su no#bre 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

.bjeto

%n elemento

Jablamos de GatributosH Lo cualidadesM

Propiedades

%n elemento

Jablamos de GaccionesH ue &uede reali:ar el ob!eto

'0todos

%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

%na caracter)stica

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


%

Pro*ramación Orientada a Ob$etos "a 8rogramación rientada a b!etos L8 u 8 &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' G8ensar 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.

Ele#entos  =aracter9sticas de la && "os elementos de la 8' &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 8' &odremos encontrar a*

=lases "as clases son los modelos sobre los cules se construirn nuestros ob!etos. 8odemos tomar como e!em&lo de clases' el grico ue hicimos en la &gina  de este documento. En 8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:


2

&a

cla Oo: &a

PEP $: clases El nombre de las clases se deine en singular' utili:ando CamelCase.

ro'iedades "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.

>6todos "os m>todos son GuncionesH Lcomo las ue vimos en el ca&)tulo anteriorM' solo ue Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

"

t>cnicamente se denominan m>todos'  re&resentan acciones &ro&ias ue &uede reali:ar 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.

&b-eto "as clases &or s) mismas' no son ms ue modelos ue nos servirn &ara crear ob!etos en concreto. 8odemos decir ue una clase' es el ra:onamiento abstracto de un ob!eto' mientras ue el ob!eto' es su materiali:ació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< caracter9stica 'rinci'al de la && Como comentamos en el t)tulo anterior' algunos ob!etos com&arten las mismas Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

/

&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

Accediendo a los #6todos  'ro'iedades de un ob-eto %na ve: creado un ob!eto' es decir' una ve: hecha la instancia de clase' es &osible Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0



acceder a su m>todos  &ro&iedades. 8ara ello' 8thon utili:a una sinta5is 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()


,

06

,0todos principales del Ob$eto Strin*

Como comentamos en el ca&)tulo anterior' en 8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.


&

,0todos de ormato Convertir a ma"1scula la primera letra

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

Convertir una cadena a min1sculas

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

Convertir una cadena a ma"1sculas

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

Convertir ma"1sculas a min1sculas " viceversa

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

Convertir una cadena en +ormato Título

'0todo: titleLM Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

$

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

Centrar un te!to

'0todo: 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 <<<<<<<<<<
2linear te!to a la i.uierda

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

2linear te!to a la derec#a

'0todo: 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 <<<<<<<<<<<<<<<<<<<<<<
3ellenar un te!to anteponiendo ceros

'0todo: :illLlongitudM Getorna: una co&ia de la cadena rellena con ceros a la i:uierda hasta alcan:ar la longitud inal indicada


F

+++ nu*eo;factua < 1- +++ &int t(nu*eo;factua) Jfill0425 000000001-


,3

,0todos de 1s.ueda Contar cantidad de apariciones de una subcadena

'0todo: 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

'0todo: 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


,%

,0todos de 4alidación Saber si una cadena comiena con una subcadena determinada

'0todo: 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 inalia con una subcadena determinada

'0todo: 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 alanum0rica

'0todo: 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


,2

Saber si una cadena es alab0tica

'0todo: 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 num0rica

'0todo: 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 min1sculas

'0todo: 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


,"

ue

Saber si una cadena contiene solo ma"1sculas

'0todo: 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

'0todo: 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 +ormato &e Título

'0todo: istitleLM Getorna: =rue o ?alse +++ cadena < 'e&e Gillo' +++ &int cadena istitle05 ue +++ cadena < 'e&e gillo' +++ &int cadena istitle05 Dale


,/

,0todos de Sustitución &ar ormato a una cadena- sustitu"endo te!to din5micamente

'0todo: 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

3eemplaar te!to en una cadena

'0todo: re&laceLGsubcadena a buscarH' Gsubcadena &or la cual reem&la:arHM Getorna: la cadena reem&la:ada +++ 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.uierda " derec#a de una cadena

'0todo: 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.uierda de una cadena

'0todo: lstri&L\GcaracterH]M Getorna: la cadena sustituida


,

+++ cadena < 'YYYeugenia6ahitco*' +++ &int cadena lstrip0A. 5 eugenia6ahitco* +++ cadena < ' YYYeugenia6ahitco*' YYYeugenia 6ahitco*' +++ &int cadena lstrip05 YYYeugenia6ahitco*

'liminar caracteres a la derec#a de una cadena

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

'


,,

,0todos de unión " división Unir una cadena de orma iterativa

'0todo: !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 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 nu*eo;factua b 000002-0000 (?H: 2-)

Partir una cadena en tres partes- utiliando un separador

'0todo: &artitionLGse&aradorHM Getorn Get orna: a: 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eugenia6ahi 'htt&:55YYYeugenia6ahitco*' t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 varias partes- utiliando un separador

'0todo: 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

'0todo: s&litlinesLM Getorna: una lista donde cada elemento es una racción de la l a cadena divida en l)neas


,&

+++ 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"


,$

'$ercicio E-ercicio N@1 Crear un m#dulo para 4alidaci#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5imo 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  n7merosH Nombre de usuario vlido' retorna =rue

E-ercicio N@2 Crear un m#dulo para 4alidaci#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 min7sculas' ma7sculas' n7meros  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

E-ercicio N@ Crear un módulo ue solicite al usuario el ingreso de un nombre de usuario  contraseUa  ue los valide utili:ando los módulos generados en los dos e!ercicios anteriores.

9yuda: &ara contar la cantidad de caracteres de una cadena' en 8thon se utili:a la unción incor&orada* len(cadena)


,F

07

,0todos 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.


&3

,0todos de a*re*ado 2*re*ar un elemento al inal de la lista

'0todo: 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"

2*re*ar varios elementos al inal de la lista

'0todo: e5tendLotraOlistaM +++ 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"

2*re*ar un elemento en una posición determinada

'0todo: 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"


&%

,0todos de eliminación 'liminar el 1ltimo elemento de la lista

'0todo: &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

'0todo: &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 valor

'0todo: 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"


&2

,0todos de orden Ordenar una lista en reversa (invertir orden)

'0todo: 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 orma ascendente

'0todo: 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 orma descendente

'0todo: 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"


&"

,0todos de b1s.ueda Contar cantidad de apariciones elementos

'0todo: 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 n1mero de índice

'0todo: inde5Lelemento\' indiceOinicio' indiceOin]M +++ no*6e;*aculino inde60*iguel5 1 +++ no*6e;*aculino inde60*iguel 2 G5 4


&/

2ne!o sobre listas " tuplas =on(ersión de ti'os En el con!unto de las unciones integradas de 8thon' &odemos encontrar dos unciones ue nos &ermiten convertir listas en tu&las  viceversa. Estas unciones &ueden ser mu 7tiles 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)

=oncatenación si#'le de colecciones A dierencia de otros lengua!es' en 8thon es mu sim&le unir varias colecciones de un mismo ti&o. #im&lemente' se reuiere utili:ar 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)

)alor #i#o  #9ni#o 8odemos obtener adems' el valor m5imo  m)nimo tanto de listas como de tu&las*


&

+++ 10 +++  +++ 1 +++ 8 +++ 1

ma60tuplaN5

*a#(tu&la1) min0tupla45

*a#(lita3) *in(lita1)

=ontar ele#entos 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

,0todos principales del ob$eto dict


&&

,0todos de eliminación 4aciar un diccionario

'0todo: 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

,0todos de a*re*ado " creación Copiar un diccionario

'0todo: 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 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 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

=rear un nue(o diccionario desde las cla(es de una secuencia '0todo: dict.romesLsecuencia\' 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

=oncatenar diccionarios 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

Establecer una cla(e  (alor 'or deecto '0todo: 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


&F

,0todos de retorno &btener el (alor de una cla(e '0todo: getLclave\' Gvalor 5 deecto si la clave no e5isteH]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

%aber si una cla(e eiste en el diccionario '0todo: 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 las cla(es  (alores de un diccionario '0todo: iteritemsLM 9lias: itemsLM diccionaio < NcoloN: NoaN, N*acaN: NaaN, NtalleN: NNQ fo cla"e "alor in diccionario.iteritems05 : &int 'l alo de la clae I e I' I (clae, alo) 0alida* l alo de la clae colo e oa l alo de la clae *aca e aa l alo de la clae talle e 

&btener las cla(es de un diccionario '0todo: esLM


$3

+++ 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 los (alores de un diccionario '0todo: 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 la cantidad de ele#entos de un diccionario 8ara contar los elementos de un diccionario' al igual ue con las listas  tu&las' se utili:a la unción integrada len() +++ diccionaio < NcoloN: NoaN, N*acaN: NaaN, NtalleN: NNQ +++ len0diccionario5 3


%$ 09

'l ob$eto +ile6 traba$ando con arc#ivos

8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 &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 utili:ado 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.


$2

Sobre el ob$eto +ile 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 4ariable un 4alor 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. 8a +unci#n integrada open05' recibe dos par6metros* –

El &rimero de ellos' es la ruta hacia el archi4o ue se desea abrir

–

D el segundo' el modo en el cual abrirlo

>odos de A'ertura El modo de apertura de un archi4o ' 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. 8or e!em&lo' &odemos uerer abrir un archivo &ara leerlo' &ara escribirlo' &ara leerlo  escribirlo' &ara crearlo si no e5iste  luego escribir en >l' etc. Es necesario saber' ue cada 4e )ue abrimos un archi4o estamos creando un Opuntero' el cu6l se posicionar6 dentro del archi4o en un lugar determinado Lal comien:o o al inalM  este puntero podr6 mo4erse 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* -ndicador 'odo de apertura r #olo lectura rb #olo lectura en modo binario

5bicaci#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 e5iste. Crea el archivo si no e5iste.


Ab

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



$"

A+

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


Ab+

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


a

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

#i el archivo e5iste' al inal de >ste. #i el archivo no e5iste' al comien:o.

ab

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


a+

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


ab+

AUadido Lagregar contenidoM  lectura en modo #i el archivo e5iste' al inal de >ste. binario. #i el archivo no e5iste' al comien:o. Crea el archivo si >ste no e5iste.


$/

,0todos del Ob$eto +ile El ob!eto ile' entre sus m>todos ms recuentes' dis&one de los siguientes* '0todo seeB0byte5

escripci#n

5so

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


$

Propiedades del ob$eto ile #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 te5to

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

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#ivos de orma autom5tica $esde la versión 2.;' 8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 inali:a' 8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 utili:a un alias &ara el ob!eto ile' lo ue &ermite acceder al ob!eto ile' !ustamente' &or el alias indicado.


$&

10

Un Paseo por los ,ódulos de la librería est5ndar

8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+modinde5.html. En este ca&)tulo' veremos algunos de ellos ue se destacan a sea &or la recuencia de uso como &or sus &restaciones.


$$

,ódulos de sistema Entre los módulos de sistema ue 8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.

>ódulo os El módulo os nos &ermite acceder a uncionalidades de&endientes del #istema &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  directorios 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. escripci#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): 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

'0todo 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.


$F

El #ódulo os  las (ariables de 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)

os8'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* escripci#n (uta absoluta $irectorio base #aber si un directorio e5iste Conocer 7ltimo acceso a un directorio Conocer tamaUo del directorio

'0todo 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


F3

>ódulo ss El módulo % es el encargado de &roveer variables  uncionalidades' directamente relacionadas con el int>r&rete.

)ariables del #ódulo ss Entre las variables ms destacadas &odemos encontrar las siguientes* Iariable

escripci#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 8thon

sys.ma6int

(etorna el n7mero &ositivo entero maor' so&ortado &or 8thon

sys.platform

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

sys."ersion

(etorna el n7mero de versión de 8thon con inormación adicional

>6todos del #ódulo ss Entre los m>todos ms destacados del módulo %' &odemos encontrar los siguientes* '0todo

escripci#n

sys.e6it05

?or:ar 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 utili:a &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


F%

>ódulo 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 7til' &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 archi4os 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.

=a'turando la salida con o'en El mane!o  ca&tura de las salidas' &uede resultar un &oco com&le!o. 8or eso' intentaremos e5&licarlo &aso a &aso a in de evitar conusiones.


F2

"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 8o&en no es tratada' el &roceso uedar abierto. 8or 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' 8o&en no es un m>todo de u6&oce' sino' un ob!eto. Cómo tal' la orma correcta de iniciar un &roceso con 8o&en' ser entonces' crear un ob!eto 8o&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.

Entradas  salidas 3ue 'ueden ser ca'turadas con o'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 utili:a como reerencia a los errores &roducidos en la salida de un &rograma.

Utili.ando tuber9as 'ara ca'turar la salida o&en nos &ermite ca&turar tanto la entrada como la salida estndar o su error. 8ara Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

F"

eectuar dicha ca&tura' tanto stdout como stdin +o stderr se pasan como argumentos cla4e a Popen El 4alor de dichos argumentos deber6 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 utili:ado una tuber)aM. 8or lo tanto' deben ser cerrados una ve: 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


F/

,ódulos para el pro*ramador +ebuguear código con db El módulo &d6 nos sirve &ara controlar &aso a &aso' la e!ecución de nuestros &rogramas. d6 se utili:a solo &ara debuguear  su utilidad consiste en &ermitirnos conocer el lugar e5acto  el &or u>' nuestro scri&t alla. magina ue tienes un archivo ue genera errores  no logras descubrir la solución. 8uedes 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 comen:ar a e!ecutar tu archivo l)nea &or l)nea' es&erando tu res&uesta. 8or e!em&lo' en el código anterior' tras la e!ecución del archivo' la &antalla se lim&iar  d6 comen:ar 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


F

8ero 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

+ocu#entar tu a'' con 'doc Con tan solo colocar los docstrings corres&ondientes en cada módulo +o unción de tu 8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". 8ara ello' debers e!ecutar* pydoc ,A nombredelmodulo tra alternativa' es iniciar un servidor 6eb local' ue te &ermita navegar &or la documentación de tu a&&. 8ara ello' sim&lemente e!ecuta pydoc ,p n Ldonde n' es el n7mero del &uerto &or el cual acceders. 8or e!em&lo' pydoc ,p -3-3 inicia el servidor en htt&:55localhot:80805M. Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

F,

robar el código antes de en(iarlo a 'roducción con doctest El módulo doctet de 8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 automati:ar 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 te5to 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

8ara 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 ,"


F&

%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

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


F$

,ódulos .ue uncionales

resuelven

necesidades

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

escripci#n (etorna un n7mero aleatorio entero entre a  b

random.choice0ecuencia5

(etorna cualuier dato aleatorio de secuencia

random.shuffle0ecuencia5

(etorna una me:cla 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


FF

!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 te5to e5tenso' obteniendo una lista con cada l)nea de te5to conservando la longitud deseada* te#tYa&Ya&(te#to, 80)

(etorna una lista donde cada elemento ser una l)nea de te5to' 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


%33

,ódulos e Internet Acceder al na(egador !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

=onectarse (9a * El módulo ftplib de la librer)a estndar de 8thon' nos &rovee de los m>todos necesarios &ara crear clientes ?=8 de orma r&ida  sencilla.

=onectarse a un ser(idor * 8ara 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 ?=8' 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 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

%3%

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

escripci#n #e conecta al servidor ?=8

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

#e loguea en el servidor

'$P.close05

?inali:a la cone5ión

'$P.setpas"06ool5

Establece la cone5ió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


%32

11

Introducción a ,"S7 " el len*ua$e S7

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


%3"

2cerca de ,"S7 I#" es un ser4idor de Bases de atos 178 L#tructured uer "anguageM ue se distribue en dos versiones* •

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

•

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

En este curso' utili:aremos la versión estndar licenciada ba!o la 4N% 4eneral 8ublic "icense L48"M. 8uedes descargar el manual completo de 'y178 en el siguiente enlace* htt&*++do,nloads.msl.com+docs+reman-;.0-es.a9.&d

Instalación  coniguración de >%CL 8ara 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 utili:arla recuentemente. %na ve: ue inalice la instalación' e!ecuta el siguiente comando a in de securi:ar 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#". 8or su&uesto' res&onde ue s)* Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

%3/

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 reali:ados sur!an eectoM. Entonces' res&onde s)' &or 7ltima ve:* Eeload &iilege ta6le noY` [5n" !

Iniciar, reiniciar  detener el ser(idor >%CL 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

8ara 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&la:ando o&cion &or to&' tat o etat seg7n si deseas &arar' iniciar o reiniciar el servidor.


%3

Ad#inistración de >%CL %na ve: ue comencemos a utili:ar bases de datos' necesitars &oder acceder a las o&ciones de administración de las mismas. 8or lo tanto' te recomiendo tener siem&re a mano este ca&)tulo' &ara &oder consultarlo con recuencia.

=onectarse  desconectarse al ser(idor 8ara 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 #. 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.

=o#andos 'ara ad#inistrar >%CL dede el shell 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 C.'9@.

E1CG-PC-@

shoA databasesU

Iuestra todas las bases de datos creadas en el servidor

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

ndicar ue vas a comen:ar a utili:ar la base de datos elegida

create database nombredeladbU

Crear una nueva base de datos

Cuit

#alir del shell interactivo


%3,

Sobre el len*ua$e S7 178 -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 8thon. Como todo lenguaje in+orm6tico' &osee su &ro&ia sinta=is' tipos de datos  elementos. En este curso' abordaremos los conceptos b6sicos sobre 178 ue nos &ermitan desarrollar a&licaciones de media com&le!idad' sin &roundi:ar en el lengua!e en s)' sino solo en auellos aspectos mínimamente necesarios relacionados con 'y178 .

*i'os de datos #s co#unes Dreco#endados "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#". Tipo de dato nteo T*eo deci*al

enominaci#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

%intis bsica de las sentencias %CL %na sentencia #" Ldenominada “query” en la !erga inormticaM' es una instrucci#n escrita en lengua!e #".

%3&

=rear tablas en una base de datos #inta5is*
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^ )

E5&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 te5to de longitud variable' con una longitud m5ima de 12; caracteres deci&cion UÔU,

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

Crear un cam&o &recio de ti&o num>rico de longitud m5ima 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


%3$

Insertar datos en una tabla #inta5is* (=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)

E5&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' 239.@;  verdadero' res&ectivamente en cada uno de los cam&os indicados

%eleccionar registros #inta5is* SE;E<$ 'R%*

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

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

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

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

&oducto, &ecio

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

&oducto

$e la tabla &roductos


%3F

>odiicar registros #inta5is* 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

E5&licación* HB

&oducto

Actuali:ar la tabla &roductos A

en;toc < DBÂ,

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

 el cam&o &recio a 0

Eli#inar registros #inta5is* &E;E$E 'R%* ta6la

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

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

Eliminar todos los registros de la tabla &roductos


%%3

=onsultas a(an.adas #i bien no veremos au) consultas realmente com&le!as' a ue el curso se basa en el lengua!e de &rogramación 8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.

La clusula !?EFE "as sentencias en #"' se com&onen de cl6usulas. D /E es una de ellas. "a cl6usula DERE nos &ermite +iltrar registros en una sentencia #". Esta clusula' unciona de orma similar a la com&aración de e5&resiones en 8thon' utili:ando 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

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

=%$ (negaciFn)

%R (o)


%%%

&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

&rdenando consultas< la clusula &F+EF B4 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


%%2

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
Alias de tablas  ca#'os tra &osibilidad ue nos da el lengua!e #"' es utili:ar 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

unciones del lengua-e %CL de >%CL Es &osible tambi>n' utili:ar diversas unciones &ro&ias del lengua!e #" -a sea estandar o de I#"- a in de &oder obtener los datos con cierto ormato.
%%"

=ontar la cantidad de registros< =&UN*D A^C DEO

<%O=$0producto5

&oducto

BA Cantidad

%u#ar totales< %U>D A^C DEO

SO*0precio5

&oducto

BA otal

=oncatenar cadenas< =&N=A*D 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.

=on(ertir a #in$sculas  #a$sculas< L=A%ED  U=A%ED A^C

O<8SE0producto5 ;<8SE0descripcion5

DEO

&oducto

Fee#'la.ar datos< FELA=ED A^C DEO

REP;8
&oducto

BA Heci&cion

(eem&la:a `n` &or `br+`

&btener los 'ri#eros o $lti#os caracteres< LE*D  FIG?*D A^C DEO

;E'$0producto G35

&oducto

Fedondear n$#eros< F&UN+D A^C DEO

R%O=&0precio 25

&oducto

(etornar los &recios con 2 decimales


%%/

&btener solo la echa *I>E%*A>< +A*ED A^C DEO

de

un

ca#'o

+A*E*I>E

o

&8$E0campodatetime5

ta6la

&btener una echa or#ateada< +A*E&F>A*D A^C DEO

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

ta6la

&btener el registro con el (alor #i#o  #9ni#o< >AHD  >IND 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 #EI8(E debes seguir' al momento de crear nuevas tablas  escribir sentencias #".

*odos los registros deben tener un I+ $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 n7mero incremental' ue te servir &ara o&timi:ar tus consultas  contar con un cam&o ue te &ermita reconocer el registro como 7nico. 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 utili:arlo e cualuier clusula 6JE(E.


%%

=rear 9ndices en las tablas =odas las tablas deben tener un )ndice. El )ndice se asigna a uno o ms cam&os'  es utili:ado &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  actuali:ación de registros' &uesto ue la base de datos' deber actuali:ar los )ndices cada ve: 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.

KCu6ndo agregar índicesL Cuando vaas a utili:ar una combinación de cam&os en la clusula 6JE(E. 8or 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 m7lti&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

)

Indica cules ca#'os no 'ueden ser nulos #" 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) )

Utili.a el #otor Inno+B El motor de bases de datos nno$B' te &ermitir crear tablas relaciones o&timi:ando su rendimiento. Al momento de crear tus tablas' indica ue utili:ar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 ve:' 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. 8ara 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 ve: 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. 8odr)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 8a principal di+erencia radica en )ue debemos indicar )ue este campo debe ser tratado como una cla4e +or6nea 8ara ello' utili:amos la siguiente sinta5is* 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 Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0

%%F

reerencia' deber indicarse como 8rimar e. "uego' &odremos obtener' desde la base de datos' el Gob!etoH &roducto' incluendo los datos a los cules hace reerencia. 8ara ello' utili:aremos 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)

utili:ando 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. 8odr)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?
8ero en este caso' deber)amos modiicar la sinta5is 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 reali:ar esta unión interna se base en la condición de igualdad del valor de los mismo Lcam&o orneo  &rimario res&ectivamenteM.


%23

12

ases de datos en P"t#on con ,"S7


%2%

Introducción a bases de datos con P"t#on En 8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 B;9P-' PEP 2/F* htt&*++,,,.&thon.org+dev+&e&s+&e&-029+. Esto' signiica ue inde&endientemente de la base de datos ue utilicemos' los m>todos  &rocesos de cone5ión' lectura  escritura de datos' desde 8thon' siem&re sern los mismos' ms all del conector. En nuestro caso &articular' utili:aremos I#"' &ara lo cual' vamos a traba!ar con el módulo 'y178db. A dierencia de los módulos de la librer)a estndar de 8thon' I#"db debe ser instalado manualmente. 8ara ello' e!ecutaremos el siguiente comando* udo a&tget intall python,mysCldb

Conectarse a la base de datos " e$ecutar consultas 8ara conectarnos a la base de datos  e!ecutar cualuier consulta' el &rocedimiento consiste en* 1. Abrir la cone5ión  crear un &untero 2. E!ecutar la consulta 3. =raer los resultados Lsi de una selección se trataM o hacer eectiva la escritura Lcuando se inserta' actuali:a o eliminan datosM 9. Cerrar el &untero  la cone5ión

)os resultados de una consulta de selección, se reci!en en una tupla, cuyos elementos, son otras tuplas, conteniendo el alor de cada campo seleccionado de la ta!la, en el orden 0ue han sido seleccionados.


%22

Una or#a si#'le de acceder a bases de datos 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 datos dato < aY;in&ut('Hato: ') Kue% < '?AE ?O 6 (62) =B^A (NIN)' I dato un;Kue%(Kue%)

%eleccionar todos los registros Kue% < 'A^C 61, 62 DEO 6 OEHE U 62 HAC' eult < un;Kue%(Kue%) &int eult

%eleccionar solo registros coincidentes 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

Eli#inar 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%)

Actuali.ar datos 61 < aY;in&ut('?H: ') 62 < aY;in&ut('ueo alo: ') Kue% < 'HB 6 A 62

%2/

13

Corriendo P"t#on 2pps en la 8eb

En este ca&)tulo' nos concentraremos en a&render' como servir a&licaciones 8thon en la 6eb' corriendo ba!o A&ache' &ero sin utili:ar un rame,or' a ue el ob!etivo de este curso es entender el &roceso de ra:onamiento &ara obtener la res&uesta a Gcómo resolver necesidades &untualesH.


%2

Introducción E5isten en el mercado' varios rame,ors ue nos &ermiten crear a&licaciones 8thon robustas' de manera r&ida  servirlas a trav>s de nternet' en un sitio 6eb tradicional. Algunos de ellos' &oseen una aruitectura &articular' como es el caso de $!ango' ue utili:a un &atrón aruitectónico denominado I<= Lmodel-vie,-tem&lateM' basado en Iste* es decir' del controlador. tro rame,or mu robusto tambi>n' es 6eb28' uien se caracteri:a &or tener una curva de a&rendi:a!e menor ue la de $!ango. #in embargo' &ara crear a&licaciones 8thon con estos rame,ors' algunos reuisitos deben ser tenidos en cuenta* •

•

•

8ara crear a&licaciones escalables  mantenibles' ue guarden un diseUo aruitectónico coherente' es im&rescindible tener un e5celente 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 sinta5is  &seudo-lengua!e &ro&ios' los cuales demandan invertir un tiem&o considerable en a&render a utili:arlos. 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 utili:arlosH Les como a&render a utili:ar un nuevo sot,areM. D esto' insume much)simo tiem&o &ara ue el a&rendi:a!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. 8or 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 robuste: del desarrollo.

8ero 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 8thon a trav>s de la 6eb.

-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 2pac#e Como si de una receta de cocina se tratara' vamos a a&render c#mo ser4ir aplicaciones eb con Python utiliando el ser4idor 9pache . No es mucha la bibliogra)a ue &uede encontrarse al res&ecto' &ero s)' lo es bastante conusa  hasta incluso contradictoria. 8or eso' en este curso' nos vamos a &ro&oner mantener el es&)ritu de sim&licidad de 8thon' encontrando la manera sim&le de hacerlo.

5Cu6 necesita#os7 En &rinci&io' necesitamos hacer ue A&ache' incor&ore un so&orte &ara servir archivos 8thon. 8ara ello' necesitaremos habilitarle un módulo' ue brinde este so&orte. E5isten varios módulos de A&ache ue brindan so&orte &ara correr archivos 8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' utili:ando el módulo Lhtt&*++docs.&thon.org+release+2./+ho,to+,ebservers.htmlWmod-,sgiM el cula utili:aremos en este curso.

18 Instalación de #od"sgi en A'ache 8ara 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

28 =rear la estructura de directorios 'ara nuestra a'licación 8rimero' es im&ortante saber' como va a uncionar nuestra a&licación  cómo va a interactuar v)a 6eb. $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 di4idir su ar)uitectura en dos partes * 1M $estinada al almacena!e de nuestra a&licación 8thon &ura Lser un directorio &rivado' no servidoM 2M $estinada a servir la a&licación Ldirectorio &7blico 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 8thon' mientras ue en &u6lic;ht*l' estarn todos los archivos estticos  ser el 7nico directorio al ue se &ueda acceder mediante el navegador 6eb. A&rovecharemos este &aso' &ara crear una car&eta' destinada a almacenar los logs de errores  accesos a nuestra 6eb A&&* mBdir 5ho*e5%o5cuo&%thon5tun5&%thonYe65 logs

8 =rear un controlador 'ara la a'licación =odas las &eticiones reali:adas &or el usuario Les decir' las %( a las cules el usuario acceda &or el navegadorM' sern mane!adas &or un 7nico 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 corres&ond ientes seg7n la %( solicitada. $icho módulo' solo se encargar de deinir una unción' ue act7e con cada &etición del debe ber6 r6 se serr un una a +u +unc nci# i#n n 1 1??- application 46lida . Es usua us uari rio. o. Es Esta ta u unc nció ión' n' de Esto to signiica ue* 1. $e $ebe ber r llam llamar arse se application 2. $eber $eber reci recibir bir dos dos &arm &armetr etros* os* en"iron' del módulo os' ue &rovee un diccionario de la lass &e &etitici cion ones es J= J==8 =8 es est tnd ndar ar  ot otra rass va vari riab able less de en ento torn rno' o'  la u unc nció ión n startresponse' de 6# 6#4 4'' en enca carg rgad ada a de en entr treg egar ar la re res& s&ue uest sta a J= J==8 =8 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 ad Is adel elan ante te'' ve vere remo moss co como mo cr crea earr un &pplication 'S() Controller ' mu much cho o m mss &otente. 2 *ront Controller – 8atrón de diseUo* htt&*++en.,ii&edia.org+,ii+?rontOControllerO&attern Curso Python para Principiantes – Eugenia Bahit Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual Atribución-NoComercial-Com&artirgual 3.0

%2$

8 =onigurar el )irtual?ost En la buena coniguración de nuestro =itual/ot' estar la clave &ara correr nuestra a&licación 8thon a trav>s de la 6eb. Iientras ue el Hocu*entEoot de nu nues estr tro o sit itio io 6eb eb'' ser er  la ca car& r&et eta a &7 &7bl blic ica' a' &u6lic;ht*l' una variable del =itual/ot' ser la encargada de redirigir todas las &eticiones &7blicas 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 ve: 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 ve: conigurado nuestro
Agregar Agregar un nueo nueo hostname a nuestro nuestro 3etc3hosts 3etc3hosts nos permitirá seguir seguir tra!a"ando normalmente normalmente con nuestro nuestro localhost, sin 0ue nuestras aplicaciones aplicaciones Python interfieran con otras, ya sean we!s estáticas en 564L o dinámicas en P5P u otro lengua"e.


%2F

Utiliando en"iron para mane$ar peticiones del usuario El dicci diccionar onario io 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 6#4 Controller mucho ms &otente' ue nos &ermita hacer s,itch de la &etición' &ara saber a u> módulo llamar. 8ara 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 8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' Ahor a' todos nuestro nuestross im&or im&orts ts los &odr &odremos emos hacer con el namespace absoluto' desde *%&%thona&&. 8or 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, a&&lication(enion, tat;e&one): tat;e&one): peticion / en"iron1RE[OES$OR(1:

if peticion.startsAith01Mcontacto15 : out&ut < contactofo*ulaio() 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

%"3

%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.

escarga el ejemplo de este capítulo ' ingresando en* htt&*++curso-&thon.eugeniabahit.com+sources+&thon-,eb.tar.g:


%"%

14

'nviando e%mails con ormato 9T, desde P"t#on


%"2

Pa.uetes necesarios 8ara &oder enviar e-mail desde nuestro servidor Lu ordenador localM' en &rimer lugar' es necesario contar con un 'T9 Ls de nternet' solo ser necesario entonces' instalar end*ail* udo a&tget intall end*ail

'nvío de e%mail desde P"t#on 8ara enviar e-mails desde 8thon' >ste nos &rovee smt&lib' otro módulo de la librer)a estndar de 8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 m0todo sendmail del ob!eto #I=8.

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 8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 reali:amos el env)o* *t&end*ail(e*itente, detinataio, e*ail)


%"/

Python - Curso Python Para Principiantes

Recommend Documents