Python - Curso Python para Principiantes

Eugenia Bahit
Curso:
Python para
Principiantes
Atribución-NoComercial 3.0 – ¡Comparte el conocimiento en libertad!

Eugenia Bahit 2012. Creative Commons Atribución-NoComercial
Python para Principiantes de Eugenia Bahit se distribue ba!o una "icencia Creative Commons Atribución-
NoComercial-#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 Buenos Aires, Argentina
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
Tabla de
00 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
<ariables......................................... ........................................
.................................................................................
.......................................................
....................
........ 1
=i&os de datos......................................
datos..............................................................................
............................................................................
..........................................
.............
.............
........ 20
&eradores Aritm>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

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 <alidación...............................................................................................................................@2
#aber si una cadena comien:a con una subcadena determinada........................................................@2
#aber si una cadena inali:a con una subcadena determinada............................................................@2
#aber si una cadena es alanum>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

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................................................................................................../;
<alor m5imo  m)nimo........................................................................................................................./;
Contar elementos....................................... .......................................................................................... /@
'0todos principales del objeto dict&&
I>todos de eliminación....................................... ...................................................................................... /
<aciar un diccionario............................................................................................................................./
I>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
<ariables del módulo ss.................................................................................................................1
I>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..............................................................................................................@

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/

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 <irtualJost............................................................................................................12
%tili:ando environ &ara mane!ar &eticiones del usuario...........................................................................130
En4iando e;mails con +ormato <T'8 desde Python%"2
8auetes necesarios...............................................................................................................................133
Env)o de e-mail desde 8thon.................................................................................................................133
Env)o de e-mails a m7lti&les destinatarios..........................................................................................13;
Agregar una dirección de res&uesta dierente....................................................................................13;

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 &
Preparación del
01 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 <ersiones distribuidoM

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

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.

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

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

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*

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

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 <ersiones L#C<M &ueden agru&arse en dos ti&os*

• 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

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<M.
8ara instalar Baaar en tu ordenador ' e!ecuta el siguiente comando*

udo a&tget intall 67
%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*
(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*
;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.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %,
'structura "
02 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.

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %$
'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
-ncorrecto: i=aia6le < 12 > *iaia6le < 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.

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 23
&eradores Aritm>ticos
Entre los o&eradores aritm>ticos ue 8thon utili:a' &odemos encontrar los siguientes*
Símbolo Significado Ejemplo Resultado

. Au*a a < 10 .  a e 1
 Eeta a < 12  - a e 
 egaciFn a <  a e 
 ulti&licaciFn a < -   a e 3
 #&onente a < 2  3 a e 8
5 HiiiFn a < 12 5 2 a e !2
55 HiiiFn entea a < 12 5 2 a e !0
I Fdulo a < 2- I 4 a e 3
PEP $: operadores
#iem&re colocar un es&acio en blanco' antes  des&u>s de un
o&erador
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

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 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" J Heuele: (1, 28, Noto datoN)

&int *i;tu&la[3:" J Heuele: (Noto datoN, 2)
&int *i;tu&la[: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" J Aalida: 2

&int *i;tu&la[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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 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" J Aalida: 1

&int *i;lita[1:4" J Heuele: [1, 28, Noto datoN"
&int *i;lita[2" 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

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 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 eses ms ue una directi4a )ue se coloca al

ue una
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

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

Atribución-NoComercial-Com&artirgual 3.0 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

ms recuente de lo ue en realidad creemos* Si el sem'foro est' en /erde,
/erde, cru&ar
cru&ar la
Sino,, esperar a que el sem'foro se ponga en /erde. A veces' tambi>n evaluamos
calle. Sino
ms de una condición &ara e!ecutar una determinada acción* 0i llega la factura de la lu& y
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:an operadores
li:an
relacionales Lo de com&araciónM*
%PER8&%RES RE;8<(%=8;ES 0&E <%*P8R8<(>=5

<%*P8R8<(>=5

Símbolo Significado Ejemplo Resultado
<< ?gual Kue  << - Dalo
< Hitinto Kue oo < ede =edadeo
V eno Kue 8 V 12 =edadeo
+ a%o Kue 12 + - Dalo
V< eno o igual Kue 12 V< 12 =edadeo
+< a%o o igual Kue 4 +<  Dalo
D &ara evaluar ms de una condición simultneamente' se utili:an operadores l#gicos *
%PER8&%RES ;>?(<%S

%perador Ejemplo Resultado@
and (%)  << - and - V 12 0 % 0 Dalo
9 V 12 and 12 + - 1 % 1 =edadeo
9 V 12 and 12 + 1 1 % 0 Dalo
o (o) 12 << 12 o 1 V - 1 o 0 =edadeo
- +  o 9 V 12 1 o 1 =edadeo
#o 4 << 4 #o 9 + 3 1 o 1 Dalo
(o e#clu%ente) 4 << 4 #o 9 V 3 1 o 0 =edadeo
LXM 1 indica resultado verdadero de la condición' mientras ue 0' indica also.

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.
<eamos algunos e!em&los*
#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

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

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 del aXo 2001
?nfo*e del aXo 200
?nfo*e del aXo 200!
?nfo*e del aXo 200-
#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.

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

fo anio in ange(2001, 2013):
&int '?nfo*e del BXo', t(anio)

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 "%
,ódulos-
03 pa.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.

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

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 "/
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 <S4, COAB;2 as <S2
&int C1
&int C2
&int CA1
&int 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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 "
+unciones
04 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.

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 "&
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<N/olaN):


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

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<N/olaN):
&int mifuncion05
#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

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

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 .

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 /2
Introducción a la
05 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- &reguntas.
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.

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 //
– El objeto es eo
Ahora' imagina ue te encuentras rente a un niUo de 2 aUos LniUo* ob!eto ue &regunta
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 &regunta* -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 &regunta 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
<emoslo ms gricamente*

.BQET. 9TG-B5T. C598-9 E8 9TG-B5T.
(sustanti4o (locuci#n adjeti4a (adjeti4o
Les deM color <erde
LelM b!eto 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 &regunta' 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*

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 &regunta
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*

C598-9E1 E 8.1
.BQET. 9TG-B5T.;.BQET. 9TG-B5T.1
9TG-B5T.1
(sustanti4o (sustanti4o (locuci#n adjeti4a
(adjeti4o
LdeM color <ioleta
Ltiene algunasM antenas
LdeM longitud e5tensa
LdeM orma val
LelM b!eto Ltiene unM o!o LdeM color a:ul
LdeM tamaUo grande
LdeM color ?ucsia
Ltiene unos cuantosM &elos
LdeM te5tura rugosa
Entonces' &odemos deducir ue un objeto puede tener dos tipos de atributos *
1M "os ue res&onden a la &regunta “¿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 &regunta “¿#ué tiene el obeto?! con la rase “El obeto

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
<emoslo a7n' ms gricamente*
Objeto
color tamaño aspecto antenas ojos pelos
Antena Pelo
color longitud color textura
Ojo
forma color
tamaño
<iendo el grico anterior' tenemos lo siguiente* 2n obeto )sustanti/o al cual hemos

descrito con tres atributos )adjeti/os y otros tres atributos$obeto )sustanti/os los
cu'les son a la /e&, otros tres objetos )sustanti/os con sus atributos )adjeti/os
correspondientes. 30imple, no4 5hora, compliquemos todo un poco.
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.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 /&
– 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
<eamos todas las caracter)sticas de este nuevo' en un grico como lo hicimos antes.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 /$
Objeto
Antena Pelo
Nuevo Objeto
Pie
Pie
Ojo
forma color 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 &reguntarte OK7u0 puede hacer
el objetoL  la res&uesta a esta &regunta' 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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 /F
– El nuevo ob!eto LademsM puede saltar
#i com&letamos el grico anterior con las acciones' obtendremos lo siguiente*
Objeto → Flotar
→ Saltar Antena Pelo

Nuevo Objeto
Pie
Pie
Ojo
forma color 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. <iste ue esto de G&ensando en
ob!etosH viene a colación de la &rogramación orientada a ob!etosF Bueno' la &arte di)cil es
ue en la &rogramación' todo lo ue acabamos de ver' se denomina de una orma
&articular. 8ero' la e5&licación es la misma ue te di antes.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 3
Al 'an, 'an8 4 al (ino, (ino8 Las cosas 'or su no#bre
En la programaci#n R con respecto a la programaci#n
Cuando en el documento
se denomina 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
'0todos %n elemento
el ob!eto
Jablamos de Gatributos-ob!etoH Composici#n %na t>cnica
<emos ue los ob!etos relacionados entre
s)' tienen nombres de atributos iguales L&or
Polimor+ismo %na caracter)stica
e!em&lo* color  tamaUoM  sin embargo'
&ueden tener valores dierentes
Jablamos de ob!etos ue son sub-ti&os Lo
<erencia %na caracter)stica
am&liaciónM de otros
Ahora' &asemos a un marco un &oco ms Gacad>micoH.

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 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() J &o&iedad co*&ueta &o el o6eto o6eto Bntena
oo < Oo() J &o&iedad co*&ueta &o el o6eto o6eto Oo
&elo < elo() 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

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*
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*
colo < 'ede'
ta*anio < 'gande'
a&ecto < 'feo'
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

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. <ale aclarar' ue
en 8thon' cuando una clase no hereda de ninguna otra debe hacerse heredar de
object' ue es la clase &rinci&al de 8thon' ue deine un ob!eto.
cla Bntena(o6ect):
colo < ''
longitud < ''
cla elo(o6ect):
colo < ''
te#tua < ''
cla Oo(o6ect):
fo*a < ''
colo < ''
ta*anio < ''
cla O6eto(o6ect):
colo < ''
ta*anio < ''
a&ecto < ''
oo < Oo()
&elo < elo()
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

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()

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 ,
,0todos
06 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.

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

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

+++ &int cadena sAapcase05
hO^B *HO
Convertir una cadena en +ormato Título
'0todo: titleLM

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
<<<<<<<<<<<Uienenido a *i a&licaciFn<<<<<<<<<<<<
+++ &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

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

+++ &int cadena rjust0G3 /5
<<<<<<<<<<<<<<<<<<<<<<<Uienenido a *i a&licaciFn
+++ &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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 F
+++ nu*eo;factua < 1-
+++ &int t(nu*eo;factua) Jfill0425
000000001-

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

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

+++ &int cadena find0mi5
13
+++ &int cadena find0mi 3 435
1

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

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


+++ &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
+++ cadena < '&e&egillo -'

+++ &int cadena isalnum05
Dale
+++ cadena < '&e&egillo'
ue
+++ cadena < '&e&egillo-'
ue

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 ,2
Saber si una cadena es alab0tica
'0todo: isal&haLM

+++ &int cadena isalpha05
Dale
+++ cadena < '&e&egillo'
ue
Dale
Saber si una cadena es num0rica
'0todo: isdigitLM

+++ &int cadena isdigit05
Dale
+++ cadena < '-84'
ue
+++ cadena < '- 84'
Dale
+++ cadena < '-84'
Dale
Saber si una cadena contiene solo min1sculas
'0todo: islo,erLM
+++ cadena < '&e&e gillo'

+++ &int cadena isloAer05
ue
+++ cadena < 'e&e Gillo'
Dale
+++ cadena < 'e&egillo'
Dale

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 ,"
ue
Saber si una cadena contiene solo ma"1sculas
'0todo: isu&&erLM
+++ cadena < ' GE?^Ô'

+++ &int cadena isupper05
ue
Dale
+++ cadena < 'e&egillo'
Dale
+++ cadena < 'GE?^Ô'
ue
Saber si una cadena contiene solo espacios en blanco
'0todo: iss&aceLM
+++ 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

+++ &int cadena istitle05
ue
+++ cadena < 'e&e gillo'
+++ &int cadena istitle05
Dale

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 ,/
,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
'liminar caracteres a la i.uierda de una cadena
'0todo: lstri&L\GcaracterH]M

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 ,
+++ cadena < 'YYYeugenia6ahitco*'
+++ &int cadena lstrip0A. 5
eugenia6ahitco*
+++ cadena < ' YYYeugenia6ahitco*'
YYYeugenia 6ahitco*'
+++ &int cadena lstrip05
'liminar caracteres a la derec#a de una cadena
'0todo: rstri&L\GcaracterH]M
+++ cadena < 'YYYeugenia6ahitco*

'YYYeugenia6ahitco* '
+++ &int cadena rstrip0 5

Atribución-NoComercial-Com&artirgual 3.0 ,,
,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
Getorna:
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

Atribución-NoComercial-Com&artirgual 3.0 ,&
+++ 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"

Atribución-NoComercial-Com&artirgual 3.0 ,$
'$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)

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 ,F
,0todos
07 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.

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

[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

[NEic%N, NBlaoN, NHaidN, NdgadoN, NZacintoN, NZoeN, NEic%N, NZoeN,
NZoeN, NGeadoN"

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

[NEic%N, NBlaoN, NHaidN, NZacintoN, NEic%N, NZoeN, NZoeN"

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 &2
,0todos de orden
Ordenar una lista en reversa (invertir orden)
'0todo: reverseLM
+++ no*6e;*aculino re"erse05

[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

[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

[NEic%N, NEic%N, NZoeN, NZoeN, NZacintoN, NHaidN, NBlaoN"

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 &"
,0todos de b1s.ueda
Contar cantidad de apariciones elementos
'0todo: countLelementoM
+++ no*6e;*aculino < ['Blao', 'iguel', 'dgado', 'Haid', 'iguel'"

+++ no*6e;*aculino count0*iguel5
2
+++ no*6e;*aculino < ('Blao', 'iguel', 'dgado', 'Haid', 'iguel')
+++ no*6e;*aculino count0*iguel5
2
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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 &/
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.
+++ tu&la < (1, 2, 3, 4)

+++ tu&la
(1, 2, 3, 4)
+++ list0tupla5
[1, 2, 3, 4"
+++ lita < [1, 2, 3, 4"
+++ lita
[1, 2, 3, 4"
+++ tuple0lista5
(1, 2, 3, 4)
=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 < [1, 2, 3, 4"

+++ lita2 < [3, 4, , !, -, 8"
+++ listaF / lista4 + lista2
+++ lita3
[1, 2, 3, 4, 3, 4, , !, -, 8"
+++ tu&la1 < (1, 2, 3, 4, )
+++ tu&la2 < (4, !, 8, 10)
+++ tu&la3 < (3, , -, 9)
+++ tuplaN / tupla4 + tupla2 + tuplaF
+++ tu&la4
(1, 2, 3, 4, , 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*

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 &
+++ ma60tuplaN5
10
+++ *a#(tu&la1)

+++ min0tupla45
1
+++ *a#(lita3)
8
+++ *in(lita1)
1
=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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 &,
,0todos
08 principales del
ob$eto dict

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 &&
,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', 'talle': 'A', '&ecio': 1-42Q

+++ e*ea < diccionaio .copy05
+++ diccionaio
+++ e*ea
+++ diccionaioclea()
+++ diccionaio
Q
+++ e*ea
+++ *uculoa < e*ea
+++ e*ea
+++ *uculoa
+++ e*eaclea()
+++ e*ea
Q
+++ *uculoa
Q
+++
=rear un nue(o diccionario desde las cla(es de una

secuencia
'0todo: dict.romesLsecuencia\' valor &or deecto]M

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

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

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

+++ 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()

+++ len0diccionario5
3

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 $%
'l ob$eto +ile6
09 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.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 $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 &regunta “¿para qué estamos abriendo este archi%o?! . "as res&uestas a esta
&regunta &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 5bicaci#n del puntero

r #olo lectura Al inicio del archivo
rb #olo lectura en modo binario Al inicio del archivo
r+ "ectura  escritura Al inicio del archivo
rb+ "ectura  escritura en modo binario Al inicio del archivo
#olo escritura.
A #obreescribe el archivo si e5iste. Al inicio del archivo
Crea el archivo si no e5iste.
#olo escritura en modo binario.
Ab #obreescribe el archivo si e5iste. Al inicio del archivo

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 $"
Escritura  lectura.
A+ #obreescribe el archivo si e5iste. Al inicio del archivo
Escritura  lectura en modo binario.
Ab+ #obreescribe el archivo si e5iste. Al inicio del archivo
a AUadido Lagregar contenidoM. #i el archivo e5iste' al inal de >ste.
Crea el archivo si >ste no e5iste. #i el archivo no e5iste' al comien:o.
ab AUadido en modo binario Lagregar contenidoM. #i el archivo e5iste' al inal de >ste.
a+ AUadido Lagregar contenidoM  lectura. #i el archivo e5iste' al inal de >ste.
AUadido Lagregar contenidoM  lectura en modo
ab+ #i el archivo e5iste' al inal de >ste.
binario.
#i el archivo no e5iste' al comien:o.
Crea el archivo si >ste no e5iste.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 $/
,0todos del Ob$eto +ile
El ob!eto ile' entre sus m>todos ms recuentes' dis&one de los siguientes*
'0todo escripci#n 5so

achio < o&en('e*eat#t', '')
contenido < achioead()
seeB0byte5 Iueve el &untero hacia el J el &unteo Kueda
bte indicado J al final del docu*ento
archi"o.seeB035
"ee todo el contenido de un

archivo. achio < o&en('e*eat#t', '')
read0bytes:5 #i se le &asa la longitud de contenido < archi"o.read05
btes' leer solo el contenido &int contenido
hasta la longitud indicada.
achio < o&en('e*eat#t', '')
readline0bytes:5 "ee una l)nea del archivo. linea1 < archi"o.readline05
&int linea1
readlines05 "ee todas las l)neas de un achio < o&en('e*eat#t', '')

fo linea in archi"o.readlines05:
archivo &int linea
achio < o&en('e*eat#t', '')
(etorna la &osición actual del linea1 < achioeadline()
tell05 *a < achioead( archi"o.tell05  2)
&untero if archi"o.tell05 + 0:
achioee(0)
achio < o&en('e*eat#t', '.')
final;de;achio < achiotell()
Arite0cadena5 Escribe cadena dentro del archi"o.Arite01=ue"a linea15
archivo achioee(final;de;achio)
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', '.')
final;de;achio < achiotell()
#ecuencia ser cualuier lista / 1;ínea 4n1 1;ínea 21:
archi"o.Aritelines0lista5
Aritelines0secuencia5 iterable cuos elementos achioee(final;de;achio)
sern escritos uno &or l)nea &int achioeadline()
J ^Mnea 1
&int achioeadline()
J ^Mnea 2
close05 Cierra un archivo achio < o&en('e*eat#t', '')
archi"o.close05
&int contenido

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 $
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
+++ 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
QQQ 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

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

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 $&
Un Paseo por los
10 ,ó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.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 $$
,ó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. <eremos a continuación' los m>todos ms
destacados de este módulo.
escripci#n '0todo
#aber si se &uede acceder a un archivo o directorio oaccess(&ath, *odo;de;acceo)
Conocer el directorio actual ogetcAd()
Cambiar de directorio de traba!o ochdir(nueo;&ath)
Cambiar al directorio de traba!o ra): ochroot()
Cambiar los &ermisos de un archivo o directorio ochmod(&ath, &e*io)
Cambiar el &ro&ietario de un archivo o directorio ochoAn(&ath, &e*io)
Crear un directorio omBdir(&ath[, *odo")
Crear directorios recursivamente omBdirs(&ath[, *odo")
Eliminar un archivo oremo"e(&ath)
Eliminar un directorio ormdir(&ath)
Eliminar directorios recursivamente oremo"edirs(&ath)
(enombrar un archivo orename(actual, nueo)
Crear un enlace simbólico 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.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 $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 '0todo
(uta absoluta opath.abspath(&ath)
$irectorio base opath.basename(&ath)
#aber si un directorio e5iste opath.e6ists(&ath)
Conocer 7ltimo acceso a un directorio opath.getatime(&ath)
Conocer tamaUo del directorio opath.getsiJe(&ath)
#aber si una ruta es*
2na ruta absoluta opath.isabs(&ath)
2n archi/o opath.isfile(&ath)
2n directorio opath.isdir(&ath)
2n enlace simbólico opath.islinB(&ath)
2n punto de montaje 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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 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*
sys.arg" &%thon *odulo&% ag1 ag2
%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
(etorna la codiicación de caracteres ue se utili:a &ara
Sys.getfilesystemencoding05 convertir los nombres de archivos unicode en nombres
de archivos del sistema
(etorna el tamaUo del ob!eto &asado como &armetro.
Sys.getsiJeof0o6ect[, default"5 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

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

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

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

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

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 (ne#t) eecuta el cFdigo *otado % alta a la iguiente lMnea de tu achio
s (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
c (continue) eecuta el achio hata enconta un &unto de Kuie6e
C (Kuit) a6andona el de6ugge

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

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$ python suma.py ,"
%ing:
u*a;do;nu*eo(2, 10)
#&ecting:
3
o

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

testeando-codigo-doctest-comentarios+

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 F$
,ódulos .ue resuelven necesidades
uncionales
&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*
random.randint0a, 65 (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

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

,ó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*

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %3%
'$P.connect0hot[, &ueto, ti*eout") #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

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

Introducción a
11 ,"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 #".

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %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 &reguntar si deseas modiicar esa contraseUa. #alvo ue desees

modiicarla' ingresa n*
Change the oot &aYod` [5n" n
Ahora la &regunta' ser si deseas eliminar usuarios anónimos. (es&onde ue s)*
Ee*oe anon%*ou ue` [5n" !
"uego' te &reguntar si desees desabilitar el acceso remoto al usuario root de I#".

8or su&uesto' res&onde ue s)*

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %3/
HialloY oot login e*otel%` [5n" !
"a siguiente &regunta 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 &reguntar 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.

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %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 enominaci#n Especi+icaciones Ejemplo
nteo (=$0=5  < cantidad de dMgito ?()
 < cantidad de dMgito
T*eo deci*al &E<(*8;0= &5 totale HC?B^(10, 2)
H < cantidad de deci*ale
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 BE(4)
4)
Cadena de longitud  < longitud de la cadena W
fia <D8R0=5
ente 0 % 2 C/BE(2)
Cadena de longitud  < longitud *S#i*a de la

aia6le
V8R<D8R0=5
cadena W ente 0 % !32 =BEC/BE(100)
UloKue de te#to de
gan longitud 9;%9 UÔU
aia6le
%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 #". <eremos au)' el ti&o de sentencias ms habituales.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %3&
=rear tablas en una base de datos
#inta5is*
<RE8$E $89;E no*6e;de;la;ta6la 0
no*6e;del;ca*&o ?O;H;HBO,
no*6e;de;oto;ca*&o ?O;H;HBO
5U
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
Crear un cam&o llamado &roducto' de ti&o cadena de te5to de longitud variable' con una
longitud m5ima de 12; caracteres
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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %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<$ ca*&o1, ca*&o2, ca*&o10
'R%* ta6la
E!em&lo*
A^C &oducto, &ecio
DEO &oducto
E5&licación*
A^C &oducto, &ecio
#eleccionar los cam&os &roducto  &recio
$e la tabla &roductos

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %3F
>odiicar registros
#inta5is*
OP&8$E ta6la
SE$ ca*&o1 < alo,
ca*&o2 < alo,
ca*&o10 < alo
E!em&lo*
HB &oducto
A en;toc < DBÂ,
&ecio < 0
E5&licación*
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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %%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 W *eno Kue
/ igual Kue WQ ditinto Kue
+< *a%o o igual Kue V< *eno o igual Kue
9E$EE= n4 8=& n2 ente n1 % n2

(S =O;;X$ROEX'8;SE e nulo > e edadeo > e falo
(=(alo1, alo2, a) contiene
8or su&uesto' tambien admite operadores l#gicos *

8=& (%) =%$ (negaciFn) %R (o)

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %%%
<eamos algunos e!em&los*
#eleccionar &roductos donde &recio sea menor ue 1000*
A^C &oducto,
&ecio
DEO &oducto
DERE precio W 4333U
Aumentar el 10Z del &recio de los &roductos' ue actualmente se encuentren entre 1;0 
200*
A &ecio < (&ecio  110)
DERE precio 9E$EE= 4G3 8=& 233U
#eleccionar &roductos donde enOstoc no sea also

&ecio
DERE 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^
DERE precio (=0433 233 F335
8=& 0enstocB (S '8;SE
%R producto (S =O;;5U
Iodiicar enOstoc a verdadero donde &recio sea menor ue ;0  &roducto no sea nulo*
A en;toc < E
DERE precio W G3
8=& 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*
deci&cion,
&ecio
/E &ecio U 1 BH 0

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %%2
BH en;toc ?A O DBÂ
%R&ER 9! precio &ES<U
=ambi>n es &osible' ordenar los resultados de la consulta' &or ms de un cam&o*

deci&cion,
&ecio
/E &ecio U 1 BH 0
%R&ER 9! precio &ES<

producto 8S<U
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 8S 1=ombre del Producto1
deci&cion 8S &etalles
&ecio 8S (mporte
DEO &oducto 8S p
/E &ecio U 1 BH 0

%R&ER 9! precio &ES<

producto 8S<U
/ó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. <eremos auellas de
uso ms recuente.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %%"
=ontar la cantidad de registros< =&UN*D
A^C <%O=$0producto5 BA Cantidad
%u#ar totales< %U>D

A^C SO*0precio5 BA otal
=oncatenar cadenas< =&N=A*D

<%=<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
Fee#'la.ar datos< FELA=ED

A^C REP;8<E0descripcion 1n1 1WbrMQ15 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 ;E'$0producto G35
Fedondear n$#eros< F&UN+D

A^C R%O=&0precio 25
(etornar los &recios con 2 decimales

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %%/
&btener solo la echa de un ca#'o +A*E*I>E o
*I>E%*A>< +A*ED
A^C &8$E0campodatetime5
DEO ta6la
&btener una echa or#ateada< +A*E&F>A*D

A^C &8$E'%R*8$0campofecha 1YdMYmMY!15
DEO ta6la
&btener el registro con el (alor #i#o  #9ni#o< >AHD 

>IND
A^C *8)0precio5
(etorna el &roducto con el &recio ms caro
A^C *(=0precio5
(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.
id (=$0445 =%$ =O;; 8O$%(=<RE*E=$ PR(*8R! E! ,
&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.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %%
=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*
id ?(11) O ^^ BO;?CE E?BE j,
&ecio HC?B^(10, 2),
en;toc UOO^,
(=&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.
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*

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %%&
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 productoUid
categoria categoriaUid
activa &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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %%$
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 ^^,
'%RE(?= E! 0categoriaid5
RE'ERE=<ES categoria0categoriaid5
) E=?(=E/(nno&9U
uando el campo de una tabla hace referencia a la

clave primaria de otra tabla , se denomina $clae
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 <nico con soporte
para éstas.
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

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 &oducto, categoia

DEO &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 ^^,
'%RE(?= E! 0'categoria5
EDECA categoia(categoia;id)
) G?<?nnoHU
8ero en este caso' deber)amos modiicar la sinta5is de nuestra consulta*
A^C &oducto, categoia

DEO &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.

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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %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 B;9P-' ue &uedes leer en la 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.

Una or#a si#'le de acceder a bases de datos
i*&ot %A^d6
HU;/OA < NlocalhotN

HU;AE < NootN
HU;BAA < N*%KlootN
HU;B < NaN
def un;Kue%(Kue%<NN):
dato < [HU;/OA, HU;AE, HU;BAA, HU;B"
conn < %A^d6connect(dato) # Conectar a la base de datos
cuo < conncuo() # Crear un cursor
cuoe#ecute(Kue%) # 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() # Cerrar el cursor

conncloe() # 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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %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
Actuali.ar datos
61 < aY;in&ut('?H: ')
62 < aY;in&ut('ueo alo: ')
Kue% < 'HB 6 A 62<NIN /E 61 < Ii' I (62, int(61))

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %2/
Corriendo
13 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.

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %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 I<C
Lmodel-vie,-controllerM &ero ue &rescinde del motor de >ste* 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. .

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %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.htmlWmod-
&thonM ue &ueden &revenirse' utili:ando el módulo modAsgi
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

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %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
usua
us uari
rio.
o. Es
Esta
ta u
unc
nción' de
ión' debe
ber6
r6 se
serr un
una
a +u
+unc
nci#
i#n
n 1
1?-?- application 46lida . Es 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
adaa de enentr
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<utf8N)")
# &etorno el contenido HTL
etun out&ut
Is ad
Is adelelan
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

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

1M Jab
Jabilit
ilitamo
amoss el sit
sitio
io 6eb*
6eb* sudo a2ensite python,Aeb
2M (e
(eca
carg
rgam
amos
os A&ach
A&ache*
e* sudo ser"ice apache2 reload
3M Jabilit
Jabilitamo
amoss el sitio
sitio en nuestr
nuestro
o host*
host* sudo nano MetcMhosts  all) agregamos la
siguiente l)nea* 427.3.3.4 python,Aeb
A &artir de ahora' si abrimos nuestro navegador 6eb e ingresamos la url htt&*++&thon-,eb

veremos la rase* Bienvenido a mi Python9pp.
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.

Atribución-NoComercial-Com&artirgual 3.0 %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?. <ali>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'
Ahora' 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. <ali>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<utf8N)")
etun out&ut

Atribución-NoComercial-Com&artirgual 3.0 %"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:

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %"%
'nviando e%mails
14 con ormato
9T, desde
P"t#on

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %"2
Pa.uetes necesarios
8ara &oder enviar e-mail desde nuestro servidor Lu ordenador localM' en &rimer lugar' es
necesario contar con un 'T9 L<ail "ranspor 5gent o GAgente de trans&orte de correoHM.
%no de los I=A ms &o&ulares &ara sistemas %NP-"ie' es sin dudas' el amoso
sendmail .
8ara de!ar nuestro servidor u ordenador local' listo &ara enviar mensa!es de correo
electrónico a trav>s 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*

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
<ontent,type te6tMhtml
Subject Ys
I

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %""
''' 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)

Com&arte el conocimiento* Creative Commons Atribución-NoComercial-Com&artirgual 3.0 %"/

Python - Curso Python para Principiantes

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Python - Curso Python para Principiantes

Uploaded by

Copyright:

Available Formats

Eugenia Bahit

Atribución-NoComercial 3.0 – ¡Comparte el conocimiento en libertad!

Eres libre de:

Bajo las siguientes condiciones:

®2012 Eugenia Bahit Buenos Aires, Argentina

Curso Python para Principiantes – Eugenia Bahit

Curso Python para Principiantes – Eugenia Bahit

Curso Python para Principiantes – Eugenia Bahit

Curso Python para Principiantes – Eugenia Bahit

Curso Python para Principiantes – Eugenia Bahit

Curso Python para Principiantes – Eugenia Bahit

Comen:aremos instalando todo nuestro sistema' &ara crear un entorno de desarrollo

1. #istema &erativo 4N%+"inu5* %buntu 11.10 Lo su&eriorM

Curso Python para Principiantes – Eugenia Bahit

8inu= es un >ernel es decir' el n7cleo de un #istema &erativo' mientras ue

Is inormación al res&ecto' &uede encontrarse en*

Instalación de Ubuntu GNU/Linu en !indo"s

#i eres usuario de 6indo,s  deseas conservar tu #istema &erativo actual' puedes

5buntu indoDs -nstaller se instalar desde el &ro&io I# 6indo,sQ como si uese un

Curso Python para Principiantes – Eugenia Bahit

Instalación de Ubuntu GNU/Linu co#o $nico %iste#a

Curso Python para Principiantes – Eugenia Bahit

Actuali:a la lista de los re&ositorios*

Actuali:a el #istema &erativo*

1.BGE 8.1 C.'9@.1

Curso Python para Principiantes – Eugenia Bahit

Curso Python para Principiantes – Eugenia Bahit

Curso Python para Principiantes – Eugenia Bahit

8ara instalar Nin!a-$E en tu ordenador' desde la terminal' e!ecuta los siguientes

1M Agrega el 88A de Nin!a-$E*

2M #incroni:a el )ndice de actuali:aciones*

Curso Python para Principiantes – Eugenia Bahit

"as venta!as &rinci&ales de utili:ar un #C<' son*

"os #istemas de Control de <ersiones L#C<M &ueden agru&arse en dos ti&os*

%na gran 4entaja de los 1CI es ue permiten a 4arios

Curso Python para Principiantes – Eugenia Bahit

8ara instalar Baaar en tu ordenador ' e!ecuta el siguiente comando*

A continuación' debers ingresar tu contraseUa.

Iueve el cursor hasta la siguiente l)nea  &ulsa las teclas Ctrl S *

Curso Python para Principiantes – Eugenia Bahit

Curso Python para Principiantes – Eugenia Bahit

8enguaje de programaci#n: es un lengua!e inormtico' diseUado &ara e5&resar

8enguajes interpretados: a dierencia de los com&ilados' no reuieren de un

Tipado din6mico: un lengua!e de ti&ado dinmico es auel cuas variables' no

'ultiplata+orma: signiica ue &uede ser inter&retado en diversos #istemas

'ultiparadigma: ace&ta dierentes &aradigmas Lt>cnicasM de &rogramación' tales

C#digo +uente: es un con!unto de instrucciones  órdenes lógicas' com&uestos de

Curso Python para Principiantes – Eugenia Bahit

%na variable es un es&acio &ara almacenar datos modiicables' en la memoria de un

no*6e;de;la;aia6le < alo;de;la;aia6le

Ejemplo: ?;COAB < 12

8ara imprimir un 4alor en pantalla ' en 8thon' se utili:a la &alabra clave &int*

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

Curso Python para Principiantes – Eugenia Bahit

*i;cadena < '/ola undo'

N7mero entero octal*

edad < 043

N7mero entero he5adecimal*

edad < 0#23

&ecio < -4328

Booleano Lverdadero + ?alsoM*

edadeo < ue

Curso Python para Principiantes – Eugenia Bahit

i;lita[2" < 38 J el tece eleento ahoa e 38

i&ote;a;&aga < total;co&a

i;lita < [NZuanN, NBntonioN, NedoN, N/einioN"

i;tu&la < (NoaN, NedeN, NceleteN, NaailloN)