Manual Phyton

Introduccin al Phyton
Que podemos hacer con Python una vez que aprendamos su sintaxis y filosofa de
programacin?
Aplicaciones que se ejecutan en un servidor web (equivalentes a lo que se puede hacer con PHP,
ASP.Net, JSP, Ruby) Ms adelante cuando este ms avanzado con el lenguaje Python le ser muy til
solicitar una cuenta en Google App Engine y crear un sitio empleando como lenguaje de servidor el
Python. Tambin existen otras empresas de hosting que proveen como lenguaje de servidor el
Python. Y cuando necesitemos ser ms productivos en el desarrollo de sitios no podr faltar el
framework Django
Aplicaciones de escritorio con interfaces visuales accediendo a componentes escritos en .Net

(Microsoft), Qt, GTK, MFC, Swing (Java) etc.
Programas no visuales que tengan como objetivo sistematizar procesos de administracin del equipo
(backup peridicos, borrado de archivos recursivos, bsquedad de archivos o contenidos de los
mismos etc.)
Aplicaciones para celulares.
No podemos terminar con la introduccin de este lenguaje sin codificar el famoso problema que muestra el
'Hola Mundo':
print 'Hola Mundo'
Problema resuelto
Hola mundo
Definicin de variables
Una variable almacena un valor de cierto tipo. En Python podemos definir variables de tipo:
Numrica (entera)
Numrica (flotante)
Numrica (complejo)
Cadena de caracteres
Booleano
Para definir una variable en Python solo debemos asignarle el valor, en dicho momento se define el tipo de
variable segn el valor asignado (Python es un lenguaje sensible a maysculas y minsculas, por lo que
debemos respetar esta caracterstica):
Variable entera:
edad=21
Variable flotante:
altura=1.92
Variable compleja:
valor=5+3j
Cadena de caracteres (puede estar encerrada entre simples o dobles comillas):
nombre="Mario"
Booleano:
encontrado=False
Problema resuelto
Definir una variable de cada tipo y luego imprimirlas empleando la funcin print (como las estamos
mostrando en una pgina HTML podemos imprimir el elemento HTML br luego de cada variable):
dad=21
altura=1.92
valor=5+3j
nombre="Mario"
encontrado=False
print edad
print "<br>"
print altura
print "<br>"
print valor
print "<br>"
print nombre
print "<br>"
print encontrado
print "<br>"
Problema Propuesto
Definir una variable donde almacenar su nombre y en otra su edad, mostrar luego los valores almacenados
con la leyenda previa que indique que representa:
Ver solucin
nombre="ana"
edad=25
print "Nombre:"
print nombre
print "<br>"
print "Edad:"
print edad
Definicin de comentarios
En Python utilizamos el caracter # para indicar al intrprete que dicha lnea es un comentario y no la debe
procesar como una instruccin de Python.
Es muy comn utilizar comentarios para informar el objetivo del programa, su desarrollador, la lgica de los
algortmos empleados etc.
Veamos un progrma que utiliza comentarios:
# Definicin de tres variables enteras y una de tipo string
edad1=10
edad2=4
edad3=21
nombre="pedro"
Podemos en la misma lnea de cdigo agregar comentarios:

edad3=23
#mayor de edad
Problema resuelto
Confeccionar una pantalla de presentacin. Definir tres lneas de comentarios.

#Definicin de tres ttulos.
#Los ttulos deben ser de nivel h1.
#Cada uno en una lnea distinta.
print '<h1>Primer titulo</h1>'
print '<h1>Segundo titulo</h1>'
print '<h1>Tercer titulo</h1>'
Problema Propuesto
Confeccionar una pantalla de presentacin de un sitio. Definir varias lneas de comentarios indicando el
nombre del programa, el programador y la fecha de la ltima modificacin.
Ver solucin
#Programa:
Foro Movil
#Programador: Rodriguez Pablo
#Fecha de ltima modificacin: 22/07/2008
print '<h1>Pantalla principal</h1>'
Operadores matemticos
Python nos suministra los siguientes operadores matemticos para trabajar con nmeros enteros y flotantes:
+ suma
- resta
* multiplicacin
/ divisin de flotantes
// divisin de enteros
% resto de una divisin
** exponenciacin
Hay que tener en cuenta que si dividimos dos enteros con el smbolo / el resultado es un entero. Debe ser
alguno de los dos nmeros flotantes para que el resultado sea float.
Problema resuelto
Definir dos variables enteras e inicializarlas con los valores 7 y 2.5 respectivamente. Luego imprimir la
suma, resta, multiplicacin, resto de la divisin y el resultado de la divisin como entero y como flotante.
valor1=7
valor2=2.5
suma=valor1+valor2
print 'La suma es:'
print suma
print '<br>'
resta=valor1-valor2
print 'La resta es:'
print resta
print '<br>'
multiplicacion=valor1*valor2
print 'El producto es:'
print multiplicacion
print '<br>'
div1=valor1/valor2
print 'La divisin con resultado entero:'
print div1
print '<br>'
div2=valor1//valor2
print 'La divisin con resultado float:'

print div2
print '<br>'
resto=valor1%valor2
print 'El resto:'
print resto
print '<br>'
solucin:
La suma es: 9.5
La resta es: 4.5
El producto es: 17.5
La divisin con resultado entero: 2.8
La divisin con resultado float: 2.0
El resto: 2.0
Problema Propuesto
Mostrar el resultado de elevar el nmero 2 al cuadrado y al cubo.
Ver solucin
cuadrado=2**2
print 'Cuadrado:'
print cuadrado
print '<br>'
cubo=2**3
print 'Cubo:'
print cubo
Estructura condicional if
Igual que otros lenguajes cuando tenemos que tomar una decisin en nuestro programa debemos utilizar la
estructura if.
Algo muy importante en el lenguaje Python que no lo tienen otros lenguajes es que la indentacin es
obligatoria e indica las intrucciones contenidas en un if.
Analicemos el siguiente ejemplo:
nombre='juan'
edad=15
if edad<18:
print nombre
print ' es menor de edad.<br>'
print 'Fin del programa'
La estructura if contiene una condicin, si dicha condicin se verifica verdadera luego se ejecutan todas las
instrucciones que se encuentran indentadas (es decir corridas a derecha) Es muy comn utilizar una
indentacin de 4 espacios.
En nuestro ejemplo la instruccin:
se encuentra fuera de la estructura if.

Si la condicin se verifica verdadera luego se ejecutan las intrucciones:
print nombre
Es obligatorio luego de la condicin del if disponer los dos puntos
if edad<18:
Tambin similar a otros lenguajes la estructura condicional if tiene una segunda parte que es el else, dicha
seccin se ejecuta si la condicin se verifica falsa.
nombre='juan'
edad=15
print nombre
if edad<18:
else:
print ' es mayor de edad.<br>'
Nuevamente tener en cuenta que las instrucciones que se indiquen por el else deben estar corridas a derecha
(indentadas).
La palabra clave else requiere tambin los dos puntos
else:
Problema resuelto
Generar un nmero aleatorio comprendido entre 1 y 20. Luego mostrar si el valor generado tiene uno o dos
dgitos.
Para generar un valor aleatorio hay una librera que debemos importar (veremos ms adelante el concepto de
mdulos)
import random
Luego podemos llamar la funcin randint de dicho mdulo, esta funcin requiere dos valores enteros y nos
devuelve otro valor entero comprendido entre ellos (lo selecciona de forma aleatoria, es decir al azar)
x=random.randint(1,20)
import random
print x
print '<br>'
if x<10:
print 'El valor generado tiene un digito'
else:
print 'El valor generado tiene dos digitos'
solucin:
7
El valor generado tiene un digito
Problema Propuesto
Inicializar una variable con un valor entero comprendido entre 1 y 100. Generar luego un valor aleatorio
tambin comprendido entre 1 y 100. Mostrar un mensaje si el valor generado coincide con el valor de la
variable (en Python para ver si dos variable almacenan el mismo valor se utiliza el operador relacional == )
Solucion;
import random
elegido=25
print x
print '<br>'
if elegido==x:
print 'El valor generado coincide con la variable'
else:
print 'El valor generado no coincide con la variable'
Operadores relacionales
En Python contamos con los siguientes operadores relacionales:
== Igualdad
!= Desigualdad
< menor
<= menor o igual
> mayor
>=mayor o igual
Cuando disponemos una condicin en una estructura condicional debemos utilizar alguno de estos seis
operadores relacionales.
Toda condicin debe tener un operando o valor, luego un operador relacional y finalmente otro operando o
valor.
Todas estas condiciones son vlidas:
if edad==18:
if edad<=18:
if edad!=50:
if edad>=18:
if valor1<valor2:
if valor1>valor2:
Problema resuelto
Inicialzar dos variables con valores aleatorios comprendidos entre 1 y 10.
Mostrar un mensaje si los dos valores generados son iguales.
Mostrar un mensaje si el primer valor es menor a 5.
Mostrar otro mensaje si el segundo valor es mayor a 5.
import random
valor1=random.randint(1,10)
valor2=random.randint(1,10)
print 'Primer valor:'
print valor1
print '<br>'
print 'Segundo valor:'
print valor2
print '<br>'
if valor1==valor2:
print 'Los dos valores son iguales.<br>'
if valor1<5:
print 'El primer valor es inferior a 5.<br>'
if valor2>5:
print 'El segundo valor es superior a 5.<br>'
Solucin:
Primer valor: 6
Segundo valor: 10
El segundo valor es superior a 5.
Estructura condicional if anidada

En ocaciones cuando hay ms de dos caminos posibles es necesario implementar estructuras condicionales
anidadas, es decir por la rama del verdadero o falso (else:) disponemos otras estructuras condicionales.
Debemos tener cuidado con la indentacin del cdigo para evitar errores.
Veamos un ejemplo que requiere utilizar estructuras condicionales anidadas. Generaremos tres nmeros
aleatorios y luego imprimiremos el mayor de los tres:
import random
x1=random.randint(1,100)
print x1
print '-'
print x2
print '-'
print x3
print '<br>'
print 'El mayor es:'
if x1>x2:
if x1>x3:
print x1
else:
print x3
else:
if x2>x3:
print x2
else:
print x3
Como podemos observar por el bloque del verdadero del primer if tenemos otra estructura condicional
(debemos indentar cada estructura condicional):
if x1>x2:
if x1>x3:
print x1
else:
print x3
Problema resuelto
Generar un valor aleatorio entre 1 y 1000. Luego imprimir un mensaje indicando cuantos dgitos tiene.
import random
print x1
print '<br>'
if x1<10:
print 'Tiene 1 dgito'
else:
if x1<100:
print 'Tiene 2 dgitos'
else:
if x1<1000:
else:
solucin:
436
Tiene 3 dgitos
Problema Propuesto
Generar un valor aleatorio entre -10 y 10. Mostrar un mensaje si el valor generado es negativo, nulo o
positivo.
Para generar un valor aleatorio en ese rango debemos plantear la siguiente expresin:
x=-10+random.randint(0,20)
solucin;
import random
x=-10+random.randint(0,20)
print x
print '<br>'
if x<0:
print 'Numero negativo'
else:
if x==0:
print 'Numero nulo'
else:
print 'Numero positivo'
Operadores lgicos
En Python contamos con los siguientes peradores lgicos:
and
(y)
or
(o)
not
(no)
Los operadores lgicos nos permiten agrupar condiciones simples en una estructura condicional, esto nos
facilita la implementacin de algoritmos ms compactos y comprensibles.
Cuando unimos dos condiciones simples con el operador lgico 'and' ambas condiciones deben verificarse
como verdaderas para que la condicin compuesta se verifique verdadera. Por ejempo si tenemos que
mostrar un mensaje si la edad de una persona est comprendida entre 12 y 18 aos podemos plantearla con
una nica estructura condicional:
if edad>=12 and edad<=18:
print 'Edad comprendida entre 12 y 18'
Estamos diciendo si la variable 'edad' tiene un valor mayor o igual a 12 y adems la variable edad tiene un
valor menor o igual a 18 luego ejecutar la rama del verdadero.
La condicin anterior nos evita tener que implementar dos estructuras condicionales:
if edad>=12:
if edad<=18:
print 'Edad comprendida entre 12 y 18'
El operador lgico 'or' hace que con que alguna de las condiciones sea verdadera luego ejecute el bloque del
verdadero.
if x1<5 or x2<5:
Se ejecuta la rama del verdadero si al menos una de las dos variables es menor a 5.
El operador not invierte el valor de una condicin:
if not x1>x2:
Si x1 no es mayor a x2 luego ejecuta la rama del verdadero de la estructura condicional.

Podemos plantear condiciones con ms de dos condiciones simples:
if x1<0 or x2<0 or x3<0:
Si x1 o x2 o x3 tienen un valor inferior a cero luego se ejecuta la rama del verdadero del if.
Problema resuelto
Generar tres nmeros aleatorios y luego imprimir el mayor de los tres. Emplear condiciones compuestas
donde sea posible.
import random
print x1
print '-'
print x2
print '-'
print x3
print '<br>'
print 'El mayor es:'
if x1>x2 and x1>x3:
print x1
else:
if x2>x3:
print x2
else:
print x3
Resultado:
100 - 24 - 25
El mayor es: 100
Problema Propuesto
Generar 3 nmeros aleatorios entre 1 y 100. Mostrar un mensaje si todos son superiores a 10.
import random
print x1
print '-'
print x2
print '-'
print x3
print '
'
if x1>10 and x2>10 and x3>10:
print 'Todos los valores son superiores a 10'
Estructura condicional if-elif

Esta estructura condicional es una forma ms elegante de disponer estructuras condicionales anidadas.
Veamos como lo hacemos con estructuras condicionales anidadas y luego utilizando la sintaxis if/elif:
(problema: generar un nmero aleatorio entre 1 y 1000, luego imprimir la cantidad de dgitos del nmero
generado)
import random
print x
print '<br>'
if x<10:
else:
if x<100:
else:
if x<1000:
else:
Luego con la estructura condicional if/elif:

import random
print x
print '<br>'
if x<10:
elif x<100:
elif x<1000:
else:
Problema resuelto
Almacenar en una variable entera la nota de un alumno, luego mostrar un mensaje si est promocionado
(nota>=9), regular (nota>=4) o reprobado (nota<4)
nota=7
print 'Nota:'
print nota
print '<br>'
if nota>=9:
print 'Promocionado'
elif nota>=4:
print 'Regular'
else:
print 'Reprobado'
Resultado:
Nota: 7
Regular
Problema Propuesto
Generar un valor aleatorio comprendido entre 1 y 5. Luego mostrar en castellano el valor generado.
import random
if x==1:
print 'uno'
elif x==2:
print 'dos'
elif x==3:
print 'tres'
elif x==4:
print 'cuatro'
elif x==5:
print 'cinco'
Estructura repetitiva while

Las estructuras repetitivas nos permiten ejecutar un bloque de instrucciones varias veces, dependiendo de
una condicin.
La estructura while repite el bloque de instrucciones mientras la condicin se verifique verdadera.
Si queremos mostrar los nmeros del 1 al 100 con estructuras secuenciales el proceso es largo y engorroso,
utilizando una estructura repetitiva el algoritmo es muy compacto:
print 'Nmeros del 1 al 100:'
x=1
while x<=100:
print x
print '-'
x=x+1
print 'Fin'
Es importante recordar y remarcar que las instrucciones que se ejecutan en la estructura repetitiva while son
todas las que se encuentran indentadas a derecha (cuatro espacios ms a la derecha de la instruccin while)
La variable x se inicializa previo a la estructura while con el valor 1. La primera vez que se ejecuta la
condicin del while se verifica verdadera, ya que 1 es menor o igual a 100.
Dentro de la estructura repetitiva mostramos el contenido de la variable x, luego imprimimos un guin y
finalmente incrementamos la variable x con el valor actual ms uno.
La impresin de la cadena 'Fin' se ejecuta una vez finalizada la estructura repetitiva while.
Problema resuelto
Mostrar la tabla de multiplicar del 2 (del 2 al 20) empleando una estructura repetitiva while.
x=2
print 'Tabla del 2:'
while x<=20:
print x
print '<br>'
x=x+2
Resultado:
Tabla del 2: 2
4
6
8
10
12
14
16
18
20
Problema Propuesto
Generar un valor aleatorio entre 100 y 200. Luego mostrar los nmeros comprendidos entre 1 y el valor
generado.
import random
print 'Nmero final:'
print x
print '<br>'
cont=1
while cont<=x:
print cont
print '-'
cont=cont+1
solucin:
mport random
print 'Nmero final:'
print x
print '<br>'
cont=1
while cont<=x:
print cont
print '-'
cont=cont+1
Funciones
La estructura fundamental de programacin de los lenguajes estructurados son las funciones. Una funcin es
un conjunto de instrucciones que se la invoca mediante un nombre y que luego de ejecutado el algoritmo
puede retornar un valor.
Un programa estructurado no es ms que un conjunto de funciones que en conjunto resuelven un problema
complejo.
Veamos la sintaxis en Python para definir y llamar a una funcin:
def presentacion():
print 'Primer mensaje.<br>'
print 'Segundo mensaje.<br>'
def fin():
print 'Ultimo mensaje.'
presentacion()
fin()
Para definir una funcin utilizamos la palabra clave 'def' seguida por el nombre de la funcin, luego si no
tiene parmetros como este caso debe ir parntesis abiertos y cerrados y dos puntos. Seguidamente las
instrucciones de la funcin se indentan a derecha.
def presentacion():
print 'Primer mensaje.<br>'
print 'Segundo mensaje.<br>'
Una funcin se ejecuta cuando se la llama por su nombre:

presentacion()
Es importante notar que primero debemos declarar la funcin y luego llamarla.

Una funcin puede tener parmetros de entrada, por ejemplo si queremos una funcin que reciba dos enteros
y luego nos imprima el mayor, el algoritmo es el siguiente:
def imprimirmayor(valor1,valor2):
if valor1>valor2:
print valor1
else:
print valor2
imprimirmayor(4,5)
print '<br>'
x1=20
x2=30
imprimirmayor(x1,x2)
Los parmetros de la funcin se indican en la cabecera de la funcin separados por comas.

Cuando llamamos a la funcin estamos obligados a enviarle datos a los dos parmetros.
Podemos enviarle directamente los valores:
imprimirmayor(4,5)
O podemos enviarle variables previamente inicializadas:

x1=20
x2=30
imprimirmayor(x1,x2)
Como podemos notar con este ejemplo una funcin puede ser llamada ms de una vez (en este caso la
llamamos dos veces)
Problema resuelto
Confeccionar una funcin que reciba un entero y luego imprima la tabla de multiplicar de dicho valor (por
ejemplo si recibe un 3 luego debe mostrar del 3 hasta el 30 de 3 en 3)
def mostrartabla(num):
inicio=num
fin=num*10
while inicio<=fin:
print inicio
print '-'
inicio=inicio+num
mostrartabla(3)
Resultado:
3 - 6 - 9 - 12 - 15 - 18 - 21 - 24 - 27 - 30
Problema Propuesto
Desarrollar una funcin que reciba dos enteros y nos muestre todos los valores comprendidos entre ellos (el
segundo parmetro siempre debe ser mayor al primero)
def rangovalores(v1,v2):
inicio=v1
while inicio<=v2:
print inicio
print '<br>'
inicio=inicio+1
rangovalores(2,20)
Funciones con retorno de dato

Hay muchas situaciones donde queremos que la funcin luego de ejecutarse retorne un valor y se almacene
en una variable desde donde la llamamos.
Por ejemplo si necesitamos una funcin que reciba tres enteros y nos retorne el mayor la sintaxis ser la
siguiente:
def retornarmayor(x1,x2,x3):
if x1<x2 and x1<x3:
return x1
elif x2<x3:
return x2
else:
return x3
may=retornarmayor(4,5,3)
print may
Como podemos observar la instruccin return indica el valor devuelto por la funcin.
El valor retornado se almacena en una variable:
may=retornarmayor(4,5,3)
Podemos inclusive mostrar directamente el valor retornado por la funcin:

print retornarmayor(40,5,3)
O utilizarlo en una condicin:

if retornarmayor(40,5,3)<20:
print 'El valor devuelto es mayor a 20'
Problema resuelto
Confeccionar una funcin que reciba tres enteros y nos retorne la suma de dichos valores.
def sumar(x1,x2,x3):
su=x1+x2+x3
return su
total=sumar(10,30,42)
print total
Resultado:
82
Problema Propuesto
Desarrollar una funcin que reciba tres enteros y nos retorne la suma de los dos ms grandes.
Solucin:
def sumarmayores(x1,x2,x3):
if x1>x2 and x1>x3:
if x2>x3:
return x1+x2
else:
return x1+x3
elif x2>x3:
if x3>x1:
return x2+x3
else:
return x2+x1
else:
if x2>x1:
return x3+x2
else:
return x3+x1
print sumarmayores(100,200,30)
Estructura de datos tipo tupla

Hasta ahora hemos empleado variables que permiten almacenar un nico valor. En Python existen varias
estructuras de datos que permiten almacenar un conjunto de datos.
La primera que presentaremos es la tupla:
Una tupla es una coleccin de datos no necesariamente del mismo tipo que se los accede por medio de
subndices.
Definicin de una tupla:
tupla1=('juan',18,1.92)
Hemos definido una tupla de tres elementos. El primer elemento es de tipo cadena de caracteres, el segundo
un entero y finalmente un valor flotante.
Cada elemento de una tupla se los separa por una coma.
Para acceder a los elementos lo hacemos por medio del nombre de la tupla y un subndice numrico:
print tupla1[0]
Los elementos de la tupla comienzan a numerarse a partir de cero y utilizamos los corchetes para hacer
referencia al subndice.
Si queremos en algn momento saber la cantidad de elementos de una tupla debemos llamar la funcin len:
print len(tupla1) #imprime un 3
con dicha funcin podemos disponer una estructura repetitiva para imprimir todas las componentes de la
tupla con el siguiente algoritmo:
tupla1=('juan',18,1.92)
indice=0
while indice<len(tupla1):
print tupla1[indice]
indice=indice+1
Veremos en el prximo concepto que hay una estructura repetitiva que nos facilita recorrer los elementos de
una tupla.
Una vez definida la tupla no se pueden modificar los valores almacenados.
La funcin print puede recibir como parmetro una tupla y se encarga de mostrarla en forma completa:
print tupla1
De todos modos cuando tenemos que acceder a algn elemento de la tupla debemos hacerlo mediante un
subndice entre corchetes.
La caracterstica fundamental de una tupla es que una vez creada no podemos modificar sus elementos, ni
tampoco agregar o eliminar.
Problema resuelto
Definir dos tuplas que almacenen en una los nombres de los meses y en otra la cantidad de das que tiene
cada mes del ao. Luego mostrar el contenido almacenado en las mismas.
meses=('enero','febrero','marzo','abril','mayo','junio','julio','agosto','septiembre','octubre','noviembre','diciemb
re')
cantidaddias=(31,28,31,30,31,30,31,31,30,31,30,31)
indice=0
while indice<len(meses):
print meses[indice]
print ':'
print cantidaddias[indice]
print '<br>'
indice=indice+1
Resultado:
enero : 31
febrero : 28
marzo : 31
abril : 30
mayo : 31
junio : 30
julio : 31
agosto : 31
septiembre : 30
octubre : 31
noviembre : 30
diciembre : 31
Problema Propuesto
Definir una tupla que almacene 5 enteros. Implementar un algoritmo que imprima la suma de todos los
elementos.
Ver solucin
tupla1=(6,33,56,3,45)
suma=0
indice=0
while indice<len(tupla1):
suma=suma+tupla1[indice]
indice=indice+1
print 'El contenido de la tupla es:'
print tupla1
print '<br>'
print 'La suma es:'
print suma
Estructura repetitiva for in para recorrer una tupla

Para recorrer una tupla es muy comn utilizar la estructura repetitiva for.
Veamos con un ejemplo la sintaxis de esta estructura repetitiva:
tupla1=('juan',23,1.92)
for elemento in tupla1:
print elemento
print '<br>'
Como podemos ver la instruccin for requiere una variable (en este ejemplo llamada elemento), luego la
palabra clave in y por ltimo la tupla. El bloque del for se ejecuta tantas veces como elementos tenga la
tupla, y en cada vuelta del for la variable elemento almacena un valor de la tupla1.
Esta estructura repetitiva se adapta mucho mejor que el while para recorrer este tipo de estructuras de datos.
Problema resuelto
Definir una tupla con 5 valores enteros. Imprimir los valores mayores o iguales a 18.
tupla1=(45,34,2,56,1)
if elemento>=18:
print elemento
print '<br>'
Resultado:
45
34
56
Problema Propuesto
Definir una tupla con 10 edades de personas. Imprimir la cantidad de personas con edades superiores a 20.
tupla1=(45,78,3,56,3,45,34,2,56,1)
cantidad=0
if elemento>20:
cantidad=cantidad+1
print 'Cantidad de personas con edades superiores a 20:'
print cantidad
Porciones de tuplas
El lenguaje Python nos permite rescatar una "porcin" de una tupla, es decir un trozo de la misma.
Si tenemos la siguiente tupla:
tupla1=(1,7,20,40,51,3)
tupla2=tupla1[0:4]
print tupla2
El resultado es una tupla con cuatro valores:

(1,7,20,40)
Es decir indicamos como subndice un rango de valores, en este caso desde la posicin 0 hasta la posicin 4
sin incluirla.
Podemos no indicar alguno de los dos rangos:
tupla1=(1,7,20,40,51,3)
tupla2=tupla1[3:]
print tupla2
El resultado es una tupla con tres valores, desde la posicin 3 hasta el final de la tupla:
(40, 51, 3)
En caso de no indicar el primer rango:

tupla1=(1,7,20,40,51,3)
tupla2=tupla1[:2]
print tupla2
El resultado es una tupla con dos valores, desde el principio de la tupla hasta la posicin 2 sin incluirla:
(1, 7)
Problema resuelto
Definir una tupla con los nombres de los meses. Generar dos tuplas que almacenen los primeros 6 meses la
primera y los siguientes 6 meses la segunda.
meses=('enero','febrero','marzo','abril','mayo','junio','julio','agosto','septiembre','octubre','noviembre','diciemb
re')
tupla1=meses[:6]
tupla2=meses[6:]
print tupla1
print '<br>'
print tupla2
Resultado:
('enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio')
('julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre')
Problema Propuesto
Almacenar en una tupla 5 nombres. Luego generar un valor aleatorio entre 2 y 4. Copiar a una tupla el
nombre de la posicin indicada por el valor aleatorio y los nombres que se encuentran en la posicin anterior
y posterior.
Ver solucin
import random
nombre=('juan','ana','luis','carlos','roman')
ale=random.randint(1,3)
tresnombres=nombre[ale-1:ale+2]
print tresnombres
Estructura de datos tipo cadena de caracteres (string)

Una cadena de caracteres permite almacenar un conjunto de caracteres. Su funcionamiento es similar a una
tupla.
Para inicializar un string utilizamos el operador de asignacin.
nombre='Juan Pablo'
Podemos utilizar las comillas simples o dobles para su inicializacin:

mail='jose@gmail.com'
mail="jose@gmail.com"
Para conocer el largo de un string podemos utilizar la funcin len:

print len(mail)
Para acceder a un caracter particular del string lo hacemos indicando un subndice entre corchetes:
print mail[0]
#Imprimimos el primer caracter
El lenguaje Python nos permite rescatar una "porcin" de un string con la misma sintaxis que trabajamos las
tuplas:
nombre='Jose Maria'
print nombre[1:4] #ose
print nombre[:4] #Jose
print nombre[5:] #Maria
Los string son inmutables, es decir que no podemos modificar su contenido luego de ser inicializados:
titulo='Administracion'
titulo[0]='X' # Esto produce un error
Esto no significa que no podemos utilizar la variable para que referencie a otro string:
nombre='Jose'
print nombre
nombre='Ana'
print nombre
Para concatenar string Python permite utilizar el operador +.

Si tenemos tres string y queremos almacenar sus contenidos en un cuarto string podemos codificarlo de la
siguiente manera:
cadena1='uno'
cadena2='dos'
cadena3='tres'
total=cadena1+cadena2+cadena3
print total #unodostres
Tambin Python define el operador * para los string. El resultado de multiplicar un string por un entero es
otro string que repite el string original tantas veces como indica el nmero.
#si queremos un string con 80 caracteres de subrayado, la forma ms sencilla es
utilizar la siguiente expresin:
separador='_'*80
print separador
Los operadores relacionales definidos para los string son:

> Mayor
>= Mayor o igual
< Menor
<= Menor o igual
== Igual
!= Distinto
Si queremos saber si un string es mayor alfabticamente que otro utilizamos el operador >
nombre1='CARLOS'
nombre2='ANABEL'
if nombre1>nombre2:
print nombre1+' es mayor alfabticamente que '+nombre2
si queremos saber si dos variables tienes en mismo contenido:

nombre1='CARLOS'
nombre2='CARLOS'
if nombre1==nombre2:
print 'Las dos variables tienen el mismo contenido:'+nombre1
Problema resuelto
Elaborar una funcin que reciba un string y retorne la cantidad de vocales que tiene.
def cantidadvocales(cadena):
cant=0
for letra in cadena:
if letra=='a':
cant=cant+1
if letra=='e':
cant=cant+1
if letra=='i':
cant=cant+1
if letra=='o':
cant=cant+1
if letra=='u':
cant=cant+1
if letra=='A':
cant=cant+1
if letra=='E':
cant=cant+1
if letra=='I':
cant=cant+1
if letra=='O':
cant=cant+1
if letra=='U':
cant=cant+1
return cant
print 'Cantidad de vocales en la palabra Hola:'
print cantidadvocales('Hola')
print '<br>'
print 'Cantidad de vocales en la palabra Computadora:'
print cantidadvocales('Computadora')
Resultado:
Cantidad de vocales en la palabra Hola: 2
Cantidad de vocales en la palabra Computadora: 5
Problema Propuesto
Elaborar las siguientes funciones:
- Una funcin que reciba un string y nos retorne el primer caracter.
- Una funcin que reciba un apellido y un nombre, y nos retorne un nico string con el apellido y nombre
concatenados y separados por una coma.
- Una funcin que reciba dos string y nos retorne el que tiene menos caracteres.
Ver solucin
def primercaracter(cadena):
return cadena[0]
def concatenar(apellido,nombre):
return apellido+','+nombre
def menor(cadena1,cadena2):
if len(cadena1)<len(cadena2):
return cadena1
else:
return cadena2
cad='Hola Mundo'
print 'Primer caracter de '+cad+' es '+primercaracter(cad)
print '<br>'
nom='juan'
ape='rodriguez'
print 'Apellido y nombre concatenados:'+concatenar(ape,nom)
cad1='Hola'
cad2='Fin'
print '<br>'
print 'De: '+cad1+' y '+cad2+' tiene menos caracteres '+menor(cad1,cad2)
Estructura de datos tipo lista

Una lista es una coleccin de datos no necesariamente del mismo tipo que se los accede por medio de
subndices. La diferencia fundamental de una lista con una tupla es que podemos modificar la estructura
luego de haberla creado.
Hay varias formas de crear una lista, la primera y ms sencilla es enumerar sus elementos entre corchetes y
separados por coma:
lista1=['juan','ana','luis']
Para acceder a sus elementos lo hacemos indicando un subndice subndice:

print lista1[0]
Como decamos la diferencia con una tupla (son inmutables) es que podemos modificar la lista luego de
creada:
lista1=[10,15,20]
print lista1
print '<br>'
lista1[0]=700 # modificamos el valor almacenado en la primer componente de la lista.
print lista1
De forma similar a las tuplas y string la funcin len nos informa de la cantidad de elementos que contiene la
lista:
lista1=[10,15,20]
print len(lista1) # imprime un 3
Es muy comn emplear la estructura for in para recorrer y rescatar cada elemento de la lista, la variable
elemento almacena en cada ciclo del for un elemento de la lista1, comenzando por el primer valor:
lista1=['juan',23,1.92]
for elemento in lista1:
print elemento
print '<br>'
Si queremos saber si un valor se encuentra en una lista existe un operador llamado in:
lista1=[12,45,1,2,5,4,3,55]
if 1 in lista1:
print 'El valor 1 est contenido en la lista '
else:
print 'El valor 1 no est contenido en la lista '
print lista1
Python define los operadores + y * para listas, el primero genera otra lista con la suma de elementos de la
primer y segunda lista. El operador * genera una lista que repite tantas veces los elementos de la lista como
indica el valor entero seguido al operador *.
lista1=[2,4,6,8]
lista2=[10,12,14,16]
listatotal=lista1+lista2
print listatotal
Luego empleando el operador *:

lista1=['juan','carlos']
producto=lista1*3
print producto
El resultado de este algoritmo es:

['juan', 'carlos', 'juan', 'carlos', 'juan', 'carlos']
Tambin con listas podemos utilizar el concepto de porciones que nos brinda el lenguaje Python:
lista=[2,4,6,8,10]
print lista[2,4]
#[6, 8]
print lista[:3]
#[2, 4, 6]
print lista[3:]
#[8, 10]
Como vimos podemos modificar el contenido de elementos de la lista asignndole otro valor:
lista=[2,4,6]
lista[1]=10
print lista #[2, 10, 6]
Podemos borrar elementos de la lista utilizando la funcin del:

lista=[2,4,6]
del(lista[1])
print lista #[2, 6]
Adems podemos utilizar porciones para borrar un conjunto de elementos de la lista:

lista=[2,4,6]
del(lista[1:])
print lista #[2]
Tambin podemos aadir elementos a una lista:

lista=[5,10,11,12]
lista[1:1]=[6,7,8,9]
print lista #[5,6,7,8,9,10,11,12]
Problema resuelto
Definir una lista con edades de personas, luego borrar todos los elementos que sean menores a 18.
edades=[23,5,67,21,12,4,34]
indice=0
while indice<len(edades):
if edades[indice]<18:
del(edades[indice])
else:
indice=indice+1
print edades
Resultado:
[23, 67, 21, 34]
Problema Propuesto
Definir una lista con un conjunto de nombres, imprimir la cantidad de comienzan con la letra a:
nombres=['ariel','marcos','ana','luis','pedro','andres']
cant=0
for nom in nombres:
if nom[0]=='a':
cant=cant+1
print nombres
print '<br>'
print 'Cantidad de nombres que comienzan con a es:'
print cant
Indices negativos en tuplas, listas y string

Hemos visto que en Python accedemos a los elementos de una lista, tupla y string mediante un subndice que
comienza a numerarse a partir de cero:
tupla=(2,4,6,8,10)
print tupla[0]
# 2
lista=[2,4,6,8,10]
print lista[0]
# 2
cadena='hola'
print cadena[0]
# h
Si queremos acceder a la ltima componente podemos hacerlo:

tupla=(2,4,6,8,10)
print tupla[len(tupla)-1] # 10
Pero Pyton tiene integrado en el lenguaje el acceso de los elementos de la secuencia mediante ndices
negativos, por ejemplo si queremos acceder a la ltima componente luego podemos hacerlo con la siguiente
sintaxis:
tupla=(2,4,6,8,10)
print tupla[-1]
# 10
lista=[2,4,6,8,10]
print lista[-1]
# 10
cadena='hola'
print cadena[-1]
# a
Es mucho ms cmodo utilizar esta segunda forma para acceder a los elementos de una lista, tupla o cadena
de caracteres.
Si queremos imprimir los elementos de una tupla en forma inversa (es decir desde el ltimo elemento hasta
el primero) podemos hacerlo con el siguiente algoritmo:
tupla=(2,4,6,8,10)
indice=-1
for x in range(0,len(tupla)):
print tupla[indice] # 10 8 6 4 2
indice=indice-1
Problema resuelto
Inicializar una variable con un valor aleatorio comprendido entre 1 y 1000000, verificar si es capica, es
decir si se lee igual de izquierda a derecha como de derecha a izquierda.
import random
valor=random.randint(1,1000000)
print valor
print '<br>'
cadena=str(valor)
indice=-1
iguales=0
for x in range(0,len(cadena)/2):
if cadena[x]==cadena[indice]:
iguales=iguales+1
indice=indice-1
if iguales==(len(cadena)/2):
print 'Es capicua'
else:
print 'No es capicua'
Resultado:
561790
No es capica
Problema Propuesto
Definir una lista con una serie de elementos. Intercambiar la informacin del primero con el ltimo de la
lista.
Ver solucin
lista=['juan','ana','luis','pedro']
print lista
print '<br>'
aux=lista[0]
lista[0]=lista[-1]
lista[-1]=aux
print lista
Estructura de datos tipo diccionario

Las estructuras de datos vistas hasta ahora (tuplas y listas) utilizan un entero como subndice. La estructura
de datos tipo diccionario utiliza una clave para acceder a un valor. El subndice puede ser un entero, un
string etc.
Un diccionario vincula una clave y un valor.
Si queremos almacenar la cantidad de productos que tenemos en stock podemos implementar un diccionario
donde utilizamos como clave el nombre del producto y como valor la cantidad de productos disponibles.
Podemos definir un diccionario con la siguiente sintaxis:
productos={'manzanas':23,'peras':50,'papas':120}
Luego si queremos acceder a la cantidad de productos en stock utilizamos como subndice el nombre del
producto:
print productos['manzanas']
La lnea anterior produce como resultado el valor 23.

Mediante un diccionario asociamos para toda clave un valor.
Podemos borrar cualquier entrada dentro del diccionario empleando la siguiente sintaxis:
del(productos['manzana'])
Luego si imprimimos el diccionario en forma completa tenemos como resultado que ya no contiene la
entrada 'manzana':
print propductos
{'peras': 50, 'papas': 120}
Podemos modificar el valor asociado a una clave mediante una simple asignacin:
productos['papas']=5
Luego si imprimimos el diccionario obtenemos como resultado:
{'peras': 50, 'papas': 5}
Podemos conocer en cualquier momento la cantidad de pares clave-valor que contiene nuestro diccionario
mediante la funcin len:
print len(productos)
Con nuestro problema tenemos como resultado que nuestro diccionario tiene 2 elementos.
Problema resuelto
Crear un diccionario cuyas claves sean palabras en ingls y su valor almacena la palabra traducida al
castellano.
diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
print diccionario['house']
print '<br>'
print diccionario['red']
Resultado:
casa
rojo
Problema Propuesto
Crear un diccionario asociando nombres de paises y cantidades de habitantes. Imprimir luego el diccionario.
Ver solucin
paises={'argentina':40000000,'espaa':46000000,'brasil':190000000}
print paises
Formato de cadenas de caracteres (string)

Cuando tenemos que combinar cadenas de caracteres e incorporarle valores almacenados en otras variables
el lenguaje Python nos suministra una tcnica para incrustar valores dentro de la cadena.
Veamos mediante ejemplos cual es la sintaxis para plantear estos formatos de cadenas:
x1=10
x2=5
x3=20
print 'El contenido de la primer variable es %d, de la segunda %d y la tercera %d' %
(x1,x2,x3)
Si bien podemos utilizar el operador + para ir concatenando cadenas y variables esta tcnica hace que
nuestro programa sea ms legible sobre todo cuando tenemos que sustituir varias variables dentro de una
cadena.
Primero indicamos entre comillas la cadena y utilizamos el smbolo % para indicar el lugar donde se
sustituir el valor, debemos indicar luego del caracter % el tipo de dato (en nuestro ejemplo un valor decimal
(d))
Luego de la cadena debemos indicar una tupla con los valores o variables de donde se obtendrn los datos.
Entre la cadena de formato y la tupla debemos disponer el caracter % (aqu el caracter porcentaje tiene un
objetivo distinto que dentro de la cadena de formato)
Se especifican distintos caracteres para cada tipo de dato a sustituir:
x=10
g=10.2
cadena='juan'
print 'El valor entero %d el valor real %f y la cadena %s' % (x,g,cadena)
En el ejemplo propuesto vemos que podemos utilizar los caracteres de formato d (decimal), f (float) y s
(string).
Es importante el orden de los valores de la tupla ya que el lenguaje procesa los datos en forma secuencia, es
decir cada vez que debe sustituir un valor en la cadena extrae de la tupla el siguiente valor.
Cuando damos formato a una variable real (con coma) podemos disponer dos valores previos al caracter f:
g=20.5498
print 'El valor real es %10.2f' % (g)
El primer valor indica el largo total a reservar y el segundo la cantidad de decimales.

Podemos convertir el valor decimal a tipo octal o hexadecimal:
x=255
print 'Decimal %d en hexadecimal es %x y en octal %o' % (x,x,x)
#Decimal 255 en hexadecimal es ff y en octal 377
No es obligatorio que el formato de cadena se utilice siempre en un print, podemos almacenar el resultado
del formato en otra variable string (que podemos eventualmente almacenarla en una base de datos por
ejemplo).
vx=10
vy=90
resultado='(%d,%d)' % (vx,vy)
print resultado # (10,90)
Tambin podemos indicar un valor entero en el formato para los tipos de datos enteros y string:
x1=100
x2=1500
x3=5
print '<pre>'
print '%5d' % (x1)
print '%5d' % (x2)
print '%5d' % (x3)
print '</pre>'
El resultado por pantalla es:

100
1500
5
Es decir reserva en este caso 5 espacios para el entero y hace la alineacin a derecha.
Si indicamos un valor negativo los datos se alnean a izquierda:
animales=['perro','elefante','pez']
print '<pre>'
for elemento in animales:
print '%20s' % elemento
for elemento in animales:
print '%-20s' % elemento
print '</pre>'
El resultado de ejecutar el programa es:

perro
elefante
pez
perro
elefante
pez
Problema resuelto
Imprimir todos los nmeros desde el 1 hasta el 255 en decimal, octal y hexadecimal.
print '<pre>'
for num in range(1,256):
print '%3d %3o %3x' % (num,num,num)
print '</pre>'
Resultado:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
2
3
4
5
6
7
10
11
12
13
14
15
16
17
20
21
22
23
24
25
26
27
30
31
32
33
34
35
36
37
40
41
42
43
44
45
46
47
50
51
52
53
54
55
56
57
60
61
62
63
64
65
66
67
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f
10
11
12
13
14
15
16
17
18
19
1a
1b
1c
1d
1e
1f
20
21
22
23
24
25
26
27
28
29
2a
2b
2c
2d
2e
2f
30
31
32
33
34
35
36
37
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
70
71
72
73
74
75
76
77
100
101
102
103
104
105
106
107
110
111
112
113
114
115
116
117
120
121
122
123
124
125
126
127
130
131
132
133
134
135
136
137
140
141
142
143
144
145
146
147
150
151
152
153
154
155
156
157
160
161
162
163
164
165
166
167
170
171
172
38
39
3a
3b
3c
3d
3e
3f
40
41
42
43
44
45
46
47
48
49
4a
4b
4c
4d
4e
4f
50
51
52
53
54
55
56
57
58
59
5a
5b
5c
5d
5e
5f
60
61
62
63
64
65
66
67
68
69
6a
6b
6c
6d
6e
6f
70
71
72
73
74
75
76
77
78
79
7a
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
173
174
175
176
177
200
201
202
203
204
205
206
207
210
211
212
213
214
215
216
217
220
221
222
223
224
225
226
227
230
231
232
233
234
235
236
237
240
241
242
243
244
245
246
247
250
251
252
253
254
255
256
257
260
261
262
263
264
265
266
267
270
271
272
273
274
275
7b
7c
7d
7e
7f
80
81
82
83
84
85
86
87
88
89
8a
8b
8c
8d
8e
8f
90
91
92
93
94
95
96
97
98
99
9a
9b
9c
9d
9e
9f
a0
a1
a2
a3
a4
a5
a6
a7
a8
a9
aa
ab
ac
ad
ae
af
b0
b1
b2
b3
b4
b5
b6
b7
b8
b9
ba
bb
bc
bd
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
276
277
300
301
302
303
304
305
306
307
310
311
312
313
314
315
316
317
320
321
322
323
324
325
326
327
330
331
332
333
334
335
336
337
340
341
342
343
344
345
346
347
350
351
352
353
354
355
356
357
360
361
362
363
364
365
366
367
370
371
372
373
374
375
376
377
be
bf
c0
c1
c2
c3
c4
c5
c6
c7
c8
c9
ca
cb
cc
cd
ce
cf
d0
d1
d2
d3
d4
d5
d6
d7
d8
d9
da
db
dc
dd
de
df
e0
e1
e2
e3
e4
e5
e6
e7
e8
e9
ea
eb
ec
ed
ee
ef
f0
f1
f2
f3
f4
f5
f6
f7
f8
f9
fa
fb
fc
fd
fe
ff
Problema Propuesto
Almacenar en una lista los nombres de personas y en otra los sueldos que cobran cada uno. Hacer que para
el ndice cero de cada componente representen los datos de una persona y as sucesivamente.
Imprimir un nombre por lnea de la pantalla y hacer que los sueldos aparezcan correctamente alineados las
columnas de unidades, decenas, centenas etc.
Ver solucin
nombres=['juan','ana','luis']
sueldos=[1500.55,2700.00,910.66]
print '<pre>'
for indice in range(0,len(nombres)):
print '%-20s %10.2f' % (nombres[indice],sueldos[indice])
print '</pre>'
Asignaciones mltiples
Python permite asignaciones mltiples:
x1,x2,x3=1,2,3
print x1 # 1
print x2 # 2
print x3 # 3
Para entenderlo mejor podemos tambin utilizar esta sintaxis:

x1,x2,x3=(1,2,3)
print x1 # 1
print x2 # 2
print x3 # 3
Es decir lo que estamos haciendo inicializar cada una de las variables de la izquierda con las componentes
homlogas (de la misma posicin) de la tupla.
Esta caracterstica es til si tenemos que recuperar por ejemplo de una lista que contiene tuplas de dos
elementos que representan puntos en el plano (x,y):
puntos=[(10,2),(4,2),(9,3)]
for x,y in puntos:
print 'Coordenada x:%d y:%d' % (x,y)
print '<br>'
Cada vuelta del for se almacena en x e y los valores de la tupla a procesar.

Otra aplicacin muy til es si queremos intercambiar el valor de dos variables la forma ms simple es:
x=10
y=20
print
print
x,y =
print
print
x #
y #
y,x
x #
y #
10
20
20
10
En una asignacin pueden intervenir valores de distinto tipo (enteros, reales, string etc.):
nombre,edad,sueldo=('juan',32,1500.30)
print 'Nombre:%s Edad:%d Sueldo%10.2f' % (nombre,edad,sueldo)
# Nombre:juan Edad:32 Sueldo 1500.30
Podemos con esto hacer que una funcin retorne ms de un dato (por lo menos en apariencia), esto lo
logramos retornando una tupla:
def sumadiferencia(x1,x2):
suma=x1+x2
diferencia=x1-x2
return (suma,diferencia)
su,di=sumadiferencia(10,4)
print su # 14
print di # 6
Como vemos llamamos a una funcin y le asignamos el valor devuelto a dos variables.
Si queremos inicializar tres variables con el mismo valor la sintaxis que podemos utilizar es:
x1=x2=x3=10
print x1 # 10
print x2 # 10
print x3 # 10
Problema resuelto
En una lista se almacenan tuplas con el nombre de una persona y su edad. Mostrar el nombre de la persona
de mayor edad.
personas=[('juan',22),('ana',40),('carlos',15)]
may=-1
for nombre,edad in personas:
if edad>may:
nom=nombre
may=edad
print '%s tiene la edad mayor y es de %d' % (nom,may)
Resultado:
ana tiene la edad mayor y es de 40
Funciones con parmetros por defecto

Como habamos visto una funcin es una estructura de programacin que agrupa un conjunto de
instrucciones y resuelve un problema particular. Una funcin puede tener parmetros, los mismos almacenan
los valores que se le pasan cuando la llamamos.
En algunos casos si queremos que la funcin sea mas flexible podemos definir parmetros con valores por
defecto. Esto nos permite llamar a la funcin pudiendo o no pasar datos a dichos parmetros.
Veamos con un ejemplo este concepto, vamos a desarrollar una funcin que reciba un dato a imprimir, con la
posibilidad de indicarle el color de fuente y el color de fondo, en caso de no indicarle dichos valores la
funcin muestra el dato con color negro y fondo blanco.
def mostrartitulo(dato,colorletra='#000',colorfondo='#fff'):
print '<h1 style="color:'+colorletra+';backgroundcolor:'+colorfondo+'">'+dato+'</h1>'
mostrartitulo('Primer titulo')
mostrartitulo('Segundo titulo','#f00')
mostrartitulo('Tercer titulo','#f00','#000')
Como podemos ver para indicar a Python que un parmetro es por defecto debemos utilizar el operador de
asignacin en la declaracin de la cabecera de la funcin junto al valor que tomar dicho parmetro en caso
de no pasarlo desde donde la llamamos:
Cuando llamamos la funcin mostrartitulo podemos hacerlo de diferentes maneras:
La primer llamada es pasando un nico dato, es decir solo el ttulo que debe mostrar, en este caso el segundo
y tercer parmetro toman como valor el indicado en el declaracin:
colorletra='#000',colorfondo='#fff'
Podemos llamar a la funcin mostrartitulo pasando el primer parmetro y el segundo, lo que hace que el
tercer parmetro se inicialice con el indicado en la declaracin de la funcin:
En el ejemplo la tercer llamada a la funcin se hace pasando tres parmetros:

Como podemos ver los parmetros por defecto nos permiten implementar funciones ms generales, con esto
podemos hacer que las funciones sean tiles para mayor cantidad de situaciones.
Que pasa si queremos llamar la funcin indicando el primer y ltimo parmetro, esto solo se puede hacer si
al llamar la funcin indicamos que dato se le pasa a cada parmetro:
print '<h1 style="color:'+colorletra+';backgroundcolor:'+colorfondo+'">'+dato+'</h1>'
mostrartitulo(dato='Primer titulo',colorfondo='#00f')
Si bien se hace ms engorroso la llamada a la funcin al tener que indicar el nombre de cada parmetro junto
al valor, nos trae como beneficio que sea an ms flexible.
Problema resuelto
Confeccionar una funcin que reciba un dato a imprimir, con la posibilidad de indicarle el color de fuente y
el color de fondo, en caso de no indicarle dichos valores la funcin muestra el dato con color negro y fondo
blanco.
print '<h1 style="color:'+colorletra+';background-color:'+colorfondo+'">'+dato+'</h1>'
Resultado:
Primer titulo
Segundo titulo
Tercer titulo
Problema Propuesto
Confeccionar una funcin que reciba entre 2 y 5 enteros. La misma nos debe retornar la suma de dichos
valores.
Ver solucin
def sumar(v1,v2,v3=0,v4=0,v5=0):
s=v1+v2+v3+v4+v5
return s
print sumar(5,6)
print '<br>'
print sumar(1,2,3)
print '<br>'
x=sumar(1,2,3,4,5)
print x
Funciones con una cantidad variable de parmetros

Otra posibilidad en la declaracin de una funcin en Python es la definicin de una cantidad variable de
parmetros.
Para definir una cantidad variante de parmetros debemos antecederle el caracter astersco (*) al ltimo
parmetro de la funcin.
Supongamos que necesitemos implementar una funcin que le enviemos una serie de enteros y nos retorne
la suma de todos ellos (como mnimo le enviamos 2 y no hay un mximo de valores):
def sumar(x1,x2,*xn):
s=x1+x2
for valor in xn:
s=s+valor
return s
print
print
print
print
print
sumar(1,2)
'<br>'
sumar(1,2,3,4)
'<br>'
sumar(1,2,3,4,5,6,7,8,9,10)
Lo que en realidad el lenguaje Python hace es una tupla con todos los valores de los parmetros a partir del
tercero.
Luego nuestro algoritmo debe recorrer la tupla para procesar los elementos propiamente dichos, en nuestro
caso con un for in y los sumamos junto al primer y segundo parmetro.
Luego cuando hacemos la llamada a la funcin:
print sumar(1,2)
Si pasamos solo dos parmetros la tupla se inicializa vaca, por lo que el for in no ejecuta el bloque
contenido.
Si llamamos la funcin con 10 parmetros:
print sumar(1,2,3,4,5,6,7,8,9,10)
Luego la tupla se crea con 7 elementos.

Problema resuelto
Implementar una funcin que le enviemos una serie de enteros y nos retorne la suma de todos ellos (como
mnimo le enviamos 2 y no hay un mximo de valores):
def sumar(x1,x2,*xn):
s=x1+x2
for valor in xn:
s=s+valor
return s
print sumar(1,2)
print '<br>'
print sumar(1,2,3,4)
print '<br>'
print sumar(1,2,3,4,5,6,7,8,9,10)
Resultado:
3
10
55
Problema Propuesto
Confeccionar una funcin que le enve una serie de edades y me retorne la cantidad que son mayores a 18
(como mnimo se enva un entero a la funcin)
Ver solucin
def cantidadmayor18(ed1,*edades):
cant=0
if ed1>18:
cant=cant+1
for e in edades:
if e>18:
cant=cant+1
return cant
print 'Cantidad de personas mayores a 18:'
cant=cantidadmayor18(4,56,14,67,32,21)
print cant
Implementacin de mdulos
Cuando uno codifica un programa en Python lo almacena en un archivo con extensin *.py
Una vez instalado el Python en forma local podemos llamar un programa desde la lnea de comando del
sistema operativo.
Si tenemos un programa mnimo llamado: programa1.py
def holamundo():
print('Hola Mundo')
holamundo();
Luego desde la carpeta donde hemos instalado el Python debemos ejecutarlo con la siguiente sintaxis:
c:\Python25>python c:\pruebaspython\programa1.py
Luego de esto veremos en pantalla el mensaje 'Hola Mundo'

Este archivo en Python se lo llama mdulo.
Un programa pequeo puede estar formado por un nico mdulo, pero programas de mayor tamao deben
dividirse en distintos mdulos para facilitar su mantenimiento. Cada mdulo normalmente almacena un
conjunto de funciones relacionadas.
La sintaxis para llamar a una funcin que se encuentra en otro mdulo es la siguiente:
modulo1.py
def funcion1():
print 'Funcin 1'
modulo2.py
import modulo1
def funcion2():
modulo1.funcion1()
print 'Funcin 2'
funcion2()
Luego desde la lnea de comandos ejecutamos el modulo2.py:

c:\Python25>python c:\pruebaspython\modulo2.py
Y como resultado tenemos en pantalla

Funcin 1
Funcin 2
Veremos ms adelante que Python nos provee de una gran biblioteca de mdulos. Recordemos que ya hemos
estado utilizando la funcin randint que se encuentra en el mdulo random:
import random
print x
Funciones de uso comn (range - type - str - dir)

Como hemos visto en el punto anterior Python agrupa las funciones en mdulos que sern importados en el
caso que nuestro programa los necesite. Pero hay un pequeo grupo de funciones que Python las importa de
forma automtica, esto quiere decir que podemos hacer uso sin tener que hacer un import.
Funciones incorporadas en Python
range([inicio],fin,[paso])
La funcin range devuelve una lista de valores enteros, comienza con el valor pasado al parmetro
[inicio], en caso de omitir este parmetro comienza en cero y finaliza con el valor indicado en el
parmetro 'fin' sin incluirlo. En caso de indicar el parmetro [paso] la lista de valores crece segn
dicho nmero, sino se incrementa de a uno.
lista1=range(5,10)
print lista1 # [5, 6, 7, 8, 9]
lista2=range(10)
print lista2 # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
lista3=range(-5,5)
print lista3 # [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
lista4=range(1,10,3)
print lista4 # [1, 4, 7]
Es muy comn utilizar esta funcin para generar un contador con la estructura for in, por ejemplo si
queremos mostrar los nmeros del 1 al 10:
for x in range(1,11):
print x
print '-'
str(variable)
Convierte el contenido del parmetro a cadena y lo retorna. Funciona para cualquier tipo de dato
como puede ser un entero, real, tupla, lista etc.
Muy til cuando tenemos que generar un string a partir de un conjunto de variables heterogeneas.
x=10
y=2.5
fin=False
edades=(40,50)
print str(x) + str(y) + str(fin) + str(edades)
En el ejemplo concatenamos el contenido de cuatro variables de distinto tipo, para ello debemos
llevarlas a todas a tipo string.
type(variable)
Retorna el tipo de una variable.
x=10
print type(x) # <type 'int'>
y=2.5
print type(y) # <type 'float'>
fin=False
print type(fin) # <type 'bool'>
edades=(40,50)
print type(edades) # <type 'tuple'>
dir(variable)
Si pasamos como parmetro a la funcin dir un objeto luego nos devuelve todos los mtodos que
tiene definidos la clase de dicho objeto (veremos ms adelante en profundidad cada uno de los
mtodos de la clase lista y diccionario):
lista1=[2,4,6]
print dir(lista1) #['__add__', '__class__', '__contains__', '__delattr__',
# '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__',
# '__getattribute__', '__getitem__', '__getslice__', '__gt__',
# '__hash__', '__iadd__', '__imul__', '__init__', '__iter__',
# '__le__', '__len__', '__lt__', '__mul__', '__ne__',
'__new__',
# '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',
# '__rmul__', '__setattr__', '__setitem__', '__setslice__',
# '__str__', 'append', 'count', 'extend', 'index', 'insert',
# 'pop', 'remove', 'reverse', 'sort']
dic1={'juan':44,'ana':3}
print dir(dic1)
# ['__class__', '__cmp__', '__contains__', '__delattr__',
'__delitem__',
# '__doc__', '__eq__', '__ge__', '__getattribute__',
'__getitem__', '__gt__',
# '__hash__', '__init__', '__iter__', '__le__', '__len__',
'__lt__', '__ne__',
# '__new__', '__reduce__', '__reduce_ex__', '__repr__',

'__setattr__', '__setitem__',
# '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key',
'items', 'iteritems',
# 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem',
'setdefault', 'update', 'values']
Si le pasamos como parmetro el nombre de un mdulo la funcin dir nos retorna todas las funciones
definidas entre otros datos (recordemos que hemos estado utilizando la funcin randint para generar
un valor aleatorio y como podemos ver se encuentra listado al llamar a la funcin dir):
import random
print dir(random) # ['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random',
'SG_MAGICCONST',
# 'SystemRandom', 'TWOPI', 'WichmannHill',
'_BuiltinMethodType', '_MethodType',
# '__all__', '__builtins__', '__doc__', '__file__', '__name__',
'_acos', '_ceil',
# '_cos', '_e', '_exp', '_hexlify', '_inst', '_log', '_pi',
'_random', '_sin',
# '_sqrt', '_test', '_test_generator', '_urandom', '_warn',
'betavariate',
# 'choice', 'expovariate', 'gammavariate', 'gauss',
'getrandbits', 'getstate',
# 'jumpahead', 'lognormvariate', 'normalvariate',
'paretovariate', 'randint',
# 'random', 'randrange', 'sample', 'seed', 'setstate',
'shuffle', 'uniform',
# 'vonmisesvariate', 'weibullvariate']
Problema resuelto
Mediante la funcin dir obtener el contenido del mdulo zlib.
import zlib
print dir(zlib)
Problema Propuesto
Mostrar la tabla de multiplicar 5 (desde el 5 al 50), emplear la funcin range
Ver solucin
for valor in range(5,55,5):
print str(valor)+'-'
Funcin de uso comn (help)

La funcin help tiene por objetivo ayudar al programador dando informacin de documentacin definidas en
mdulos, funciones, clases etc.
Veamos que nos devuelve la funcin help si le pasamos como parmetro la funcin randint:
import random
help(random.randint) # Help on method randint in module random: randint(self, a, b)
# method of random.Random instance Return random integer in
# range [a, b], including both end points.
Podemos observar que nos informa el mdulo donde se almacena, sus parmetros y el objetivo de la misma.
Nosotros podemos crear cadenas de documentacin para nuestras funciones con la siguiente sintaxis:
def sumar(v1,v2):
"""El objetivo de esta funcion es realizar la
suma de los dos valores que recibe como
parametro y retornarlo."""
su=v1+v2
return su
help(sumar) # Help on function sumar in module __main__: sumar(v1, v2)
# El objetivo de esta funcion es realizar la suma de los
# dos valores que recibe como parametro y retornarlo.
El string que definamos inmediatamente despus de la cabecera se tomar como cadena de documentacin
de la funcin. Como en este caso nuestra cadena de documentacin ocupa varias lneas en Python podemos
encerrarla entre triples comillas y no deberemos indicar el caracter de continuacin de lnea (Si la cadena de
documentacin es una sola lnea podemos emplear una sola comillas al principio y al final)
Si utilizamos una sola comillas debemos indicar al final de cada lnea que contina:
def sumar(v1,v2):
"El objetivo de esta funcion es realizar la \
suma de los dos valores que recibe como \
parametro y retornarlo."
su=v1+v2
return su
Podemos crear cadenas de documentacin para definir objetivos del mismo.

Si tenemos un mdulo mnimo llamado: modulo1.py, podemos definir las siguientes cadenas de
documentacin
"cadena de documentacion del modulo"
def holamundo():
"cadena de documentacion de funcion"
print('Hola Mundo')
Problema resuelto
Llamar la funcin help para mostrar las cadenas de documentacin del mdulo random, de la funcin
randint, de una variable de tipo entera y de una variable de tipo lista.
import random
help(random)
print '<hr>'
help(random.randint)
print '<hr>'
x=4
help(x)
print '<hr>'
lista1=[1,2,3];
help(lista1)
Resultado:
Help on module random: NAME random - Random variable generators. FILE
/base/python_runtime/python_dist/lib/python2.5/random.py MODULE DOCS
http://www.python.org/doc/current/lib/module-random.html DESCRIPTION integers -------- uniform within
range sequences --------- pick random element pick random sample generate random permutation
distributions on the real line: ------------------------------ uniform normal (Gaussian) lognormal negative
exponential gamma beta pareto Weibull distributions on the circle (angles 0 to 2pi)
--------------------------------------------- circular uniform von Mises General notes on the underlying Mersenne
Twister core generator: * The period is 2**19937-1. * It is one of the most extensively tested generators in
existence. * Without a direct way to compute N steps forward, the semantics of jumpahead(n) are weakened
to simply jump to another distant state and rely on the large period to avoid overlapping sequences. * The
random() method is implemented in C, executes in a single Python step, and is, therefore, threadsafe.
CLASSES _random.Random(__builtin__.object) Random SystemRandom WichmannHill class
Random(_random.Random) | Random number generator base class used by bound module functions. | |
Used to instantiate instances of Random to get generators that don't | share state. Especially useful for multithreaded programs, creating | a different instance of Random for each thread, and using the jumpahead() |
method to ensure that the generated sequences seen by each thread don't | overlap. | | Class Random can also
be subclassed if you want to use a different basic | generator of your own devising: in that case, override the
following | methods: random(),
Conceptos de programacin orientada a objetos

Habamos dicho que Python nos permite combinar las metodologas de programacin Lineal, Estructurada y
Orientada a Objetos. A partir de este concepto mostraremos en forma sencilla la metodologa de
Programacin Orientada a Objetos.
Se irn introduciendo conceptos de objeto, clase, atributo, mtodo etc. y de todos estos temas se irn
planteando problemas resueltos.
Prcticamente todos los lenguajes desarrollados en los ltimos 15 aos implementan la posibilidad de
trabajar con POO (Programacin Orientada a Objetos)
El lenguaje Python tiene la caracterstica de permitir programar con las siguientes metodologas:
Programacin Lineal: Es cuando desarrollamos todo el cdigo sin emplear funciones.
Programacin Estructurada: Es cuando planteamos funciones que agrupan actividades a desarrollar y

luego dentro del programa llamamos a dichas funciones que pueden estar dentro del mismo archivo o
en una librera separada.
Programacin Orientada a Objetos: Es cuando planteamos clases y definimos objetos de las mismas
(Este es el objetivo de los prximos conceptos, aprender la metodologa de programacin orientada a
objetos y la sintaxis particular de Python para la POO)
Conceptos bsicos de Objetos

Un objeto es una entidad independiente con sus propios datos y programacin. Las ventanas, menes,
carpetas de archivos pueden ser identificados como objetos; el motor de un auto tambin es considerado un
objeto, en este caso, sus datos (atributos) describen sus caractersticas fsicas y su programacin (mtodos)
describen el funcionamiento interno y su interrelacin con otras partes del automvil (tambin objetos).
El concepto renovador de la tecnologa Orientacin a Objetos es la suma de funciones a elementos de datos,
a esta unin se le llama encapsulamiento. Por ejemplo, un objeto pgina contiene las dimensiones fsicas de
la pgina (ancho, alto), el color, el estilo del borde, etc, llamados atributos. Encapsulados con estos datos se
encuentran los mtodos para modificar el tamao de la pgina, cambiar el color, mostrar texto, etc. La
responsabilidad de un objeto pagina consiste en realizar las acciones apropiadas y mantener actualizados sus
datos internos. Cuando otra parte del programa (otros objetos) necesitan que la pagina realice alguna de
estas tareas (por ejemplo, cambiar de color) le enva un mensaje. A estos objetos que envan mensajes no les
interesa la manera en que el objeto pgina lleva a cabo sus tareas ni las estructuras de datos que maneja, por
ello, estn ocultos. Entonces, un objeto contiene informacin pblica, lo que necesitan los otros objetos para
interactuar con l e informacin privada, interna, lo que necesita el objeto para operar y que es irrelevante
para los otros objetos de la aplicacin.
Declaracin de una clase y creacin de objetos

La programacin orientada a objetos se basa en la programacin de clases; a diferencia de la programacin
estructurada, que est centrada en las funciones.
Una clase es un molde del que luego se pueden crear mltiples objetos, con similares caractersticas.
Un poco ms abajo se define una clase Persona y luego se crean dos objetos de dicha clase.
Una clase es una plantilla (molde), que define atributos (lo que conocemos como variables) y mtodos (lo
que conocemos como funciones).
La clase define los atributos y mtodos comunes a los objetos de ese tipo, pero luego, cada objeto tendr sus
propios valores y compartirn las mismas funciones.
Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al crear un objeto de una
clase, se dice que se crea una instancia de la clase o un objeto propiamente dicho.
Confeccionaremos nuestra primer clase para conocer la sintaxis en el lenguaje Python, luego definiremos
dos objetos de dicha clase.
Implementaremos una clase llamada Persona que tendr como atributo (variable) su nombre y dos mtodos
(funciones), uno de dichos mtodos inicializar el atributo nombre y el siguiente mtodo mostrar en la
pgina el contenido del mismo.
class Persona:
def inicializar(self,nom):
self.nombre=nom
def imprimir(self):
print 'Nombre:'
print self.nombre
print '<br>'
persona1=Persona()
persona1.inicializar('Juan')
persona1.imprimir()
persona2=Persona()
persona2.inicializar('Ana')
persona2.imprimir()
Siempre conviene buscar un nombre de clase lo ms prximo a lo que representa. La palabra clave para
declarar la clase es class, seguidamente el nombre de la clase y luego dos puntos.
Los mtodos de una clase se definen utilizando la misma sintaxis que para la definicin de funciones.
Como veremos todo mtodo tiene como primer parmetro el identificador self que tiene la referencia del
objeto que llam al mtodo.
Luego dentro del mtodo diferenciamos los atributos del objeto antecediendo el identificador self:
self.nombre=nom
Con la asignacin previa almacenamos en el atributo nombre el parmetro nom, los atributos siguen
existiendo cuando finaliza la ejecucin del mtodo. Por ello cuando se ejecuta el mtodo imprimir podemos
mostrar el nombre que cargamos en el primer mtodo.
Decamos que una clase es un molde que nos permite definir objetos. Ahora veamos cual es la sintaxis para
la definicin de objetos de la clase Persona:
persona1=Persona()
persona1.imprimir()
Definimos un objeto llamado persona1 y lo creamos asignndole el nombre de la clase.

Luego para llamar a los mtodos debemos anteceder el nombre del objeto el operador . y por ltimo el
nombre del mtodo.
En el caso que tenga parmetros se los enviamos (salvo el primer parmetro (self) que el mismo Python se
encarga de enviar la referencia del objeto que se cre):
Tambin podemos definir tantos objetos de la clase Persona como sean necesarios para nuestro algoritmo:
persona2=Persona()
persona2.imprimir()
Esto nos da una idea que si en una pgina WEB tenemos 2 menes, seguramente definiremos una clase
Menu y luego crearemos dos objetos de dicha clase.
Esto es una de las ventajas fundamentales de la Programacin Orientada a Objetos (POO), es decir
reutilizacin de cdigo (gracias a que est encapsulada en clases) es muy sencilla.
Problema resuelto
Confeccionar una clase llamada Persona. Definir un atributo donde se almacene su nombre. Luego definir
dos mtodos, uno que cargue el nombre y otro que lo imprima.
class Persona:
def inicializar(self,nom):
self.nombre=nom
def imprimir(self):
print 'Nombre:'
print self.nombre
print '<br>'
persona1=Persona()
persona1.imprimir()
persona2=Persona()
persona2.imprimir()
Resultado:
Nombre: Juan
Nombre: Ana
Problema Propuesto
Confeccionar una clase Empleado, definir como atributos su nombre y sueldo.
Definir un mtodo inicializar que lleguen como dato el nombre y sueldo. Plantear un segundo mtodo que
imprima el nombre, sueldo y un mensaje si debe o no pagar impuestos (si el sueldo supera a 3000 paga
impuestos)
Ver solucin
class Empleado:
def inicializar(self,nom,suel):
self.nombre=nom
self.sueldo=suel
def pagaimpuestos(self):
print 'Nombre:'
print self.nombre
print '<br>'
print 'Sueldo:'
print self.sueldo
print '<br>'
if self.sueldo>300:
print 'Debe pagar impuestos'
emp1=Empleado()
emp1.inicializar('Juan',3500)
emp1.pagaimpuestos()
Atributos de una clase

Ahora trataremos de concentrarnos en los atributos de una clase. Los atributos son las caractersticas,
cualidades, propiedades distintivas de cada clase. Contienen informacin sobre el objeto. Determinan la
apariencia, estado y dems particularidades de la clase. Varios objetos de una misma clase tendrn los
mismos atributos pero con valores diferentes.
Cuando creamos un objeto de una clase determinada, los atributos declarados por la clase son localizadas en
memoria y pueden ser modificados mediante los mtodos.
Plantearemos un nuevo problema para analizar detenidamente la definicin, sintaxis y acceso a los atributos.
Problema: Implementar una clase que muestre una lista de hipervnculos en forma horizontal (bsicamente
un men de opciones)
Lo primero que debemos pensar es que valores almacenar la clase, en este caso debemos cargar una lista de
direcciones web y los ttulos de los enlaces. Podemos definir dos listas paralelas que almacenen las
direcciones y los ttulos respectivamente.
Definiremos dos mtodos: cargaropcion y mostrar.
class Menu:
enlaces=[]
titulos=[]
def cargaropcion(self,en,tit):
self.enlaces.append(en)
self.titulos.append(tit)
def mostrar(self):
for indice in range(0,len(self.enlaces)):
print '<a href="'+self.enlaces[indice]+'">'+self.titulos[indice]+'</a>'
menu1=Menu()
menu1.cargaropcion('http://www.google.com.ar','Google')
menu1.cargaropcion('http://www.yahoo.com.ar','Yahoo')
menu1.cargaropcion('http://www.live.com.ar','Msn')
menu1.mostrar()
En este caso los atributos son de tipo listas y estamos obligados a definirlos dentro de la clase y previo a la
declaracin de los mtodos:
enlaces=[]
titulos=[]
Estamos definiendo dos listas vacas.

El mtodo cargaropcion recibe el enlace y el ttulo y los almacena al final de cada lista empleando el mtodo
append de la lista (tengamos en cuenta que Python administra las listas como objetos)
El mtodo que imprime todos los enlaces utiliza un for para recorrer las listas y acceder a cada elemento de
las listas y mostrarlos dentro de la pgina:
Luego creamos un objeto de la clase Menu y llamamos tantas veces al mtodo cargaropcion como opciones
tenga nuestro men:
menu1=Menu()
Finalmente llamamos al mtodo mostrar que imprime cada hipervnculo en la pgina:

menu1.mostrar()
Problema resuelto
Implementar una clase que muestre una lista de hipervnculos en forma horizontal (bsicamente un men de
opciones)
class Menu:
enlaces=[]
titulos=[]
def mostrar(self):
menu1=Menu()
menu1.mostrar()
Resultado:
Google Yahoo Msn
Problema Propuesto
Confeccionar una clase Menu. Permitir aadir la cantidad de opciones que necesitemos. Mostrar el men en
forma horizontal o vertical (segn que mtodo llamemos)
Ver solucin
class Menu:
enlaces=[]
titulos=[]
def mostrarhorizontal(self):
def mostrarvertical(self):
print '<a href="'+self.enlaces[indice]+'">'+self.titulos[indice]+'</a><br>'
menu1=Menu()
menu1.mostrarvertical()
Metodos de una clase

Los mtodos son como las funciones en los lenguajes estructurados, pero estn definidos dentro de una clase
y operan sobre los atributos de dicha clase.
Los mtodos tambin son llamados las responsabilidades de la clase. Para encontrar las responsabilidades de
una clase hay que preguntarse qu puede hacer la clase.
El objetivo de un mtodo es ejecutar las actividades que tiene encomendada la clase a la cual pertenece.
Los atributos de un objeto se modifican mediante llamadas a sus mtodos.
Confeccionaremos un nuevo problema para concentrarnos en la definicin y llamada a mtodos.
Problema:Confeccionar una clase CabeceraPagina que permita mostrar un ttulo, indicarle si queremos que
aparezca centrado, a derecha o izquierda.
Definiremos dos atributos, uno donde almacenar el ttulo y otro donde almacenar la ubicacin.
Ahora pensemos que mtodos o responsabilidades debe tener esta clase para poder mostrar la cabecera de la
pgina. Seguramente deber tener un mtodo que pueda inicializar los atributos y otro mtodo que muestre
la cabecera dentro de la pgina.
Veamos el cdigo de la clase CabeceraPagina
class CabeceraPagina:
def inicializar(self,tit,ubi):
self.titulo=tit
self.ubicacion=ubi
def graficar(self):
print '<div style="font-size:40px;text-align:'+self.ubicacion+'">'
print self.titulo
print '</div>'
cabecera=CabeceraPagina()
cabecera.inicializar('El blog del programador','center')
cabecera.graficar()
La clase CabeceraPagina tiene dos atributos donde almacenamos el texto que debe mostrar y la ubicacin
del mismo ('center', 'left' o 'right'), nos valemos de CSS para ubicar el texto en la pgina.
No es obligatorio en Python definir previo a los mtodos todos los atributos. Como vemos se definen e
inicializan al llamar al mtodo inicializar.
Ahora analicemos lo que ms nos importa en el concepto que estamos concentrados (mtodos de una clase):
self.titulo=tit
self.ubicacion=ubi
Un mtodo tiene un nombre, conviene utilizar verbos para la definicin de mtodos (mostrar, inicializar,
graficar etc.) y sustantivos para la definicin de atributos (color, enlace, titulo etc.)
Un mtodo debe tener como primer parmetro el identificador self, el mismo nos permite acceder a los
atributos de la clase, adems puede tener otros parmetros que inicializan atributos del objeto:
self.titulo=tit
self.ubicacion=ubi
Luego para llamar a los mtodos debemos crear un objeto de dicha clase:
cabecera.graficar()
Es importante notar que siempre que llamamos a un mtodo le antecedemos el nombre del objeto. El orden
de llamada a los mtodos es importante, no va a funcionar si primero llamamos a graficar y luego llamamos
al mtodo inicializar.
Problema resuelto
p>Confeccionar una clase CabeceraPagina que permita mostrar un ttulo, indicarle si queremos que aparezca
centrado, a derecha o izquierda.
self.titulo=tit
self.ubicacion=ubi
def graficar(self):
print self.titulo
print '</div>'
cabecera.graficar()
Resultado:
El blog del programador

Problema Propuesto
Confeccionar una clase CabeceraPagina que permita mostrar un ttulo, indicarle si queremos que aparezca
centrado, a derecha o izquierda, adems permitir definir el color de fondo y de la fuente.
Ver solucin
def inicializar(self,tit,ubi,colfondo,colfuente):
self.titulo=tit
self.ubicacion=ubi
self.colorfondo=colfondo
self.colorfuente=colfuente
def graficar(self):
print '<div style="font-size:40px;text-align:'+self.ubicacion+';backgroundcolor:'+self.colorfondo+';color:'+self.colorfuente+'">'
print self.titulo
print '</div>'
cabecera.inicializar('El blog del programador','center','#FF1A00','#CDEB8B')
cabecera.graficar()
Metodo constructor de una clase

El constructor es un mtodo especial de una clase. El objetivo fundamental del constructor es inicializar los
atributos del objeto que creamos.
Bsicamente el constructor remplaza al mtodo inicializar que habamos hecho en el concepto anterior.
Las ventajas de implementar un constructor en lugar del mtodo inicializar son:
1. El constructor es el primer mtodo que se ejecuta cuando se crea un objeto.
2. El constructor se llama automticamente. Es decir es imposible de olvidarse de llamarlo ya que se
llamar automticamente.
3. Quien utiliza POO (Programacin Orientada a Objetos) conoce el objetivo de este mtodo.
Otras caractersticas de los constructores son:
El constructor se ejecuta inmediatamente luego de crear un objeto y no puede ser llamado

nuevamente.
Un constructor no puede retornar dato.
Un constructor puede recibir parmetros que se utilizan normalmente para inicializar atributos.
El constructor es un mtodo opcional, de todos modos es muy comn definirlo.
Veamos la sintaxis del constructor:

def __init__([parmetros]):
[algoritmo]
Debemos definir un mtodo llamado __init__ (es decir utilizamos dos caracteres de subrayado, la palabra
init y seguidamente otros dos caracteres de subrayado).
Confeccionaremos el mismo problema del concepto anterior para ver el cambio que debemos hacer de ahora
en ms.
Problema:Confeccionar una clase CabeceraPagina que permita mostrar un ttulo, indicarle si queremos que
aparezca centrado, a derecha o izquierda.
def __init__(self,tit,ubi):
self.titulo=tit
self.ubicacion=ubi
def graficar(self):
print self.titulo
print '</div>'
cabecera=CabeceraPagina('El blog del programador','center')
cabecera.graficar()
Ahora podemos ver como cambi la sintaxis para la definicin del constructor:
self.titulo=tit
self.ubicacion=ubi
Veamos como se modifica la llamada al constructor cuando se crea un objeto:

cabecera.graficar()
Es decir el constructor se llama en la misma lnea donde creamos el objeto, por eso disponemos despus del
nombre de la clase los parmetros:
Generalmente todo aquello que es de vital importancia para el funcionamiento inicial del objeto se lo
pasamos mediante el constructor.
Problema resuelto
centrada, a derecha o izquierda. Utilizar un constructor para inicializar los dos atributos.
self.titulo=tit
self.ubicacion=ubi
def graficar(self):
print self.titulo
print '</div>'
cabecera.graficar()
Resultado:
El blog del programador
Problema Propuesto
centrado, a derecha o izquierda, adems permitir definir el color de fondo y de la fuente. Pasar los valores
que cargaran los atributos mediante un constructor.
Ver solucin
def __init__(self,tit,ubi,colfondo,colfuente):
self.titulo=tit
self.ubicacion=ubi
self.colorfondo=colfondo
self.colorfuente=colfuente
def graficar(self):
print '<div style="font-size:40px;text-align:'+self.ubicacion+';backgroundcolor:'+self.colorfondo+';color:'+self.colorfuente+'">'
print self.titulo
print '</div>'
cabecera=CabeceraPagina('El blog del programador','center','#FF1A00','#CDEB8B')
cabecera.graficar()
Llamada de mtodos dentro de la clase

Hasta ahora todos los problemas planteados hemos llamado a los mtodos desde donde definimos un objeto
de dicha clase, por ejemplo:
cabecera.graficar()
Utilizamos la sintaxis:
[nombre del objeto].[nombre del mtodo]
Es decir antecedemos al nombre del mtodo el nombre del objeto y el operador punto
Ahora bien que pasa si queremos llamar dentro de la clase a otro mtodo que pertenece a la misma clase, la
sintaxis es la siguiente:
self.[nombre del mtodo]
Es importante tener en cuenta que esto solo se puede hacer cuando estamos dentro de la misma clase.
Confeccionaremos un problema que haga llamadas entre mtodos de la misma clase.
Problema:Confeccionar una clase Tabla que permita indicarle en el constructor la cantidad de filas y
columnas. Definir otra responsabilidad que podamos cargar un dato en una determinada fila y columna.
Finalmente debe mostrar los datos en una tabla HTML.
class Tabla:
mat=[]
cantfilas=0
cantcolumnas=0
def __init__(self,fi,co):
self.cantfilas=fi
self.cantcolumnas=co
for f in range(0,fi):
self.mat.append([])
for c in range(0,co):
self.mat[f].append('')
def cargar(self,fi,col,valor):
self.mat[fi][col]=valor
def iniciotabla(self):
print '<table border="1">'
def iniciofila(self):
print '<tr>'
def mostrar(self,fi,co):
print '<td>'
print self.mat[fi][co]
print '</td>'
def finfila(self):
print '</tr>'
def fintabla(self):
print '</table>'
def graficar(self):
self.iniciotabla()
for f in range(0,self.cantfilas):
self.iniciofila()
for c in range(0,self.cantcolumnas):
self.mostrar(f,c)
self.finfila()
self.fintabla()
tabla1=Tabla(3,4)
tabla1.cargar(0,0,1)
tabla1.graficar()
Vamos por parte, primero veamos los tres atributos definidos,el primero se trata de una lista donde
almacenaremos todos los valores que contendr la tabla HTML y otros dos atributos que indican la
dimensin de la tabla HTML (cantidad de filas y columnas):
mat=[]
cantfilas=0
cantcolumnas=0
El constructor recibe como parmetros la cantidad de filas y columnas que tendr la tabla, adems creamos
la lista con tantas filas como indica el parmetro fi e insertamos una lista en cada componente (es decir que
cada componente de la lista es una lista que representa los elementos de la fila respectiva) Dentro de un for
interno agregamos string vacos a cada elemento de la lista interna:
self.cantfilas=fi
self.mat.append([])
Otro mtodo de vital importancia es el de cargar datos. Llegan como parmetro la fila, columna y dato a
almacenar:
Otro mtodo muy importante es el graficar:

def graficar(self):
self.iniciotabla()
self.iniciofila()
self.mostrar(f,c)
self.finfila()
self.fintabla()
El mtodo graficar debe hacer las salidas de datos dentro de una tabla HTML. Para simplificar el algoritmo
definimos otros cinco mtodos que tienen por objetivo hacer la generacin del cdigo HTML propiamente
dicho. As tenemos el mtodo iniciotabla que hace la salida de la marca table e inicializacin del atributo
border:
De forma similar los otros mtodos son:

print '<tr>'
print '<td>'
print '</td>'
def finfila(self):
print '</tr>'
def fintabla(self):
print '</table>'
Si bien podamos hacer todo esto en el mtodo graficar y no hacer estos cinco mtodos, la simplicidad del
cdigo aumenta a medida que subdividimos los algoritmos. Esto es de fundamental importancia con
algoritmos ms complejos./p>
Lo que nos importa ahora ver es como llamamos a mtodos que pertenecen a la misma clase:
def graficar(self):
self.iniciotabla()
self.iniciofila()
self.mostrar(f,c)
self.finfila()
self.fintabla()
Es decir le antecedemos la palabra self al nombre del mtodo a llamar. De forma similar a como accedemos
a los atributos de la clase.
Por ltimo debemos definir un objeto de la clase Tabla y llamar a los mtodos respectivos:
tabla1=Tabla(3,4)
tabla1.graficar()
Es importante notar que donde definimos un objeto de la clase Tabla no llamamos a los mtodos
iniciotabla(), iniciofila(), etc.
Problema resuelto
Confeccionar una clase Tabla que permita indicarle en el constructor la cantidad de filas y columnas. Definir
otra responsabilidad que podamos cargar un dato en una determinada fila y columna. Finalmente debe
mostrar los datos en una tabla HTML.
class Tabla:
mat=[]
cantfilas=0
cantcolumnas=0
self.cantfilas=fi
self.mat.append([])
print '<tr>'
print '<td>'
print '</td>'
def finfila(self):
print '</tr>'
def fintabla(self):
print '</table>'
def graficar(self):
self.iniciotabla()
self.iniciofila()
self.mostrar(f,c)
self.finfila()
self.fintabla()
tabla1=Tabla(3,4)
tabla1.graficar()
Resultado:
Problema Propuesto
Confeccionar una clase Tabla que permita indicarle en el constructor la cantidad de filas y columnas. Definir
otra responsabilidad que podamos cargar un dato en una determinada fila y columna adems de definir su
color de fuente. Finalmente debe mostrar los datos en una tabla HTML.
Ver solucin
class Tabla:
mat=[]
color=[]
cantfilas=0
cantcolumnas=0
self.cantfilas=fi
self.mat.append([])
self.color.append([])
self.color[f].append('')
def cargar(self,fi,col,valor,colorletra):
self.color[fi][col]=colorletra
print '<tr>'
print '<td style="color:'+self.color[fi][co]+'">'
print '</td>'
def finfila(self):
print '</tr>'
def fintabla(self):
print '</table>'
def graficar(self):
self.iniciotabla()
self.iniciofila()
self.mostrar(f,c)
self.finfila()
self.fintabla()
tabla1=Tabla(3,4)
tabla1.cargar(0,0,1,'#ff0000')
tabla1.cargar(1,0,5,'#00ff00')
tabla1.cargar(2,0,9,'#0000ff')
tabla1.graficar()
Herencia
Otra caracterstica que tiene que tener un lenguaje para considerarse orientado a objetos es la HERENCIA.
La herencia significa que se pueden crear nuevas clases partiendo de clases existentes, que tendr todas los
atributos y los mtodos de su 'superclase' o 'clase padre' y adems se le podrn aadir otros atributos y
mtodos propios.
En Python, a diferencia de otros lenguajes orientados a objetos (Java, C#), una clase puede derivar de varias
clases, es decir, Python permite la herencia mltiple.
Superclase o clase padre
Clase de la que desciende o deriva una clase. Las clases hijas (descendientes) heredan (incorporan)
automticamente los atributos y mtodos de la la clase padre.
Subclase
Clase desciendiente de otra. Hereda automticamente los atributos y mtodos de su superclase. Es una
especializacin de otra clase. Admiten la definicin de nuevos atributos y mtodos para aumentar la
especializacin de la clase.
Veamos algunos ejemplos tericos de herencia:
1) Imaginemos la clase Vehculo. Qu clases podran derivar de ella?
Vehiculo
Colectivo
Moto
Auto
FordK
Renault 9
Siempre hacia abajo en la jerarqua hay una especializacin (las subclases aaden nuevos atributos y
mtodos)
2) Imaginemos la clase Software. Qu clases podran derivar de ella?
Software
DeAplicacion
DeBase
ProcesadorTexto
PlanillaDeCalculo
SistemaOperativo
Word
Excel
Linux
WordPerfect
Lotus123
Windows
Si vemos que dos clase responden a la pregunta ClaseA "..es un.." ClaseB es posible que haya una relacin
de herencia.
Por ejemplo:
Auto "es un" Vehiculo
Circulo "es una" Figura
Mouse "es un" DispositivoEntrada
Suma "es una" Operacion
Ahora plantearemos el primer problema utilizando herencia en Python. Supongamos que necesitamos
implementar dos clases que llamaremos Suma y Resta. Cada clase tiene como atributo valor1, valor2 y
resultado. Los mtodos a definir son cargar1 (que inicializa el atributo valor1), carga2 (que inicializa el
atributo valor2), operar (que en el caso de la clase "Suma" suma los dos atributos y en el caso de la clase
"Resta" hace la diferencia entre valor1 y valor2, y otro mtodo mostrarresultado.
Si analizamos ambas clases encontramos que muchos atributos y mtodos son idnticos. En estos casos es
bueno definir una clase padre que agrupe dichos atributos y responsabilidades comunes.
La relacin de herencia que podemos disponer para este problema es:
Operacion
Suma
Resta
Solamente el mtodo operar es distinto para las clases Suma y Resta (esto hace que no lo podamos disponer
en la clase Operacion), luego los mtodos cargar1, cargar2 y mostrarresultado son idnticos a las dos clases,
esto hace que podamos disponerlos en la clase Operacion. Lo mismo los atributos valor1, valor2 y resultado
se definirn en la clase padre Operacion.
En Pyton la codificacin de estas tres clases es la siguiente:
class Operacion:
def cargar1(self,v1):
self.valor1=v1
self.valor2=v2
def imprimir(self):
print self.resultado
print '<br>'
class Suma(Operacion):
def operar(self):
self.resultado=self.valor1+self.valor2
class Resta(Operacion):
def operar(self):
self.resultado=self.valor1-self.valor2
s=Suma()
s.cargar1(10)
s.cargar2(20)
s.operar()
print 'La suma es:'
s.imprimir()
r=Resta()
r.cargar1(10)
r.cargar2(2)
r.operar()
r.imprimir()
Veamos como es la sintaxis para indicar que una clase hereda de otra:
Indicamos entre parntesis el nombre de la clase padre (con esto estamos indicando que todos los mtodos y
atributos de la clase Operacin son tambin mtodos de la clase Suma.
Luego la caracterstica que aade la clase Suma es el siguiente mtodo:
def operar(self):
El mtodo operar puede acceder a los atributos heredados.

Ahora podemos decir que la clase Suma tiene cuatro mtodos (tres heredados y uno propio) y 3 atributos
Si creamos un objeto de la clase Suma tenemos:
s=Suma()
s.cargar1(10)
s.cargar2(20)
s.operar()
print 'La suma es:'
s.imprimir()
Podemos llamar tanto al mtodo propio de la clase Suma "operar()" como a los mtodos heredados. Quien
utilice la clase Suma solo debe conocer que mtodos tiene (independientemente que pertenezcan a la clase
Suma o a una clase superior)
La lgica es similar para declarar la clase Resta:
def operar(self):
y la definicin de un objeto de dicha clase:

r=Resta()
r.cargar1(10)
r.cargar2(2)
r.operar()
r.imprimir()
La clase Operacin agrupa en este caso un conjunto de atributos y mtodos comunes a un conjunto de
subclases (Suma, Resta). No tiene sentido definir objetos de la clase Operacion.
El planteo de jerarquas de clases es una tarea compleja que requiere un perfecto entendimiento de todas las
clases que intervienen en un problema, cuales son sus atributos y responsabilidades.
Problema resuelto
Declarar una clase Operacion que defina los metodos para cargar dos valores y muestre el resultado. Luego
heredar de esta clase para definir los conceptos de suma y resta.
class Operacion:
self.valor1=v1
self.valor2=v2
def imprimir(self):
print self.resultado
print '<br>'
def operar(self):
def operar(self):
s=Suma()
s.cargar1(10)
s.cargar2(20)
s.operar()
print 'La suma es:'
s.imprimir()
r=Resta()
r.cargar1(10)
r.cargar2(2)
r.operar()
r.imprimir()
Resultado:
La suma es: 30
La resta es: 8
Mtodo especial __str__

Podemos hacer que se ejecute un mtodo definido por nosotros cuando pasamos un objeto a la funcin print
o cuando llamamos a la funcin str.
Que sucede cuando llamamos a la funcin print y le pasamos como parmetro un objeto?
class Persona:
def __init__(self,nom,ape):
self.nombre=nom
self.apellido=ape
per=Persona('Jose','Rodriguez')
print per
Nos muestra algo parecido a esto:

<__main__.Persona instance at 0xf9e0a60ec5872050>
Python nos permite redefinir el mtodo que se debe ejecutar. Esto se hace definiendo en la clase el mtodo
especial __str__
En el ejemplo anterior si queremos que se muestre el nombre y apellido separados por coma cuando
llamemos a la funcin print el cdigo que debemos implementar es el siguiente:
class Persona:
self.nombre=nom
self.apellido=ape
def __str__(self):
cadena=self.nombre+','+self.apellido
return cadena
per=Persona('Jose','Rodriguez')
print per
Como vemos debemos implementar el mtodo __str__ y retornar un string, este luego ser el que imprime la
funcin print:
def __str__(self):
return cadena
Esta caracterstica definida en Python nos permite crear programas muy legibles y flexibles.
El mtodo __str__ tambin se ejecuta si llamamos a la funcin str y pasamos como parmetro un objeto que
tiene definido dicho mtodo:
class Persona:
self.nombre=nom
self.apellido=ape
def __str__(self):
return cadena
per1=Persona('Jose','Rodriguez')
per2=Persona('Ana','Martinez')
print str(per1)+'-'+str(per2) # Jose,Rodriguez-Ana,Martinez
Problema resuelto
Crear una clase URL que permita inicializar la direccin que apunta y el texto que debe mostrar. Definir el
mtodo __str__ que genere un string con el elemento HTML de hipervnculo.
class URL:
def __init__(self,dir,men):
self.direccion=dir
self.mensaje=men
def __str__(self):
cadena='<a href="%s">%s</a>' % (self.direccion,self.mensaje)
return cadena
url1=URL('http://www.google.com.ar','Google')
url2=URL('http://www.yahoo.com.ar','Yahoo')
url3=URL('http://www.live.com','Live')
print url1
print url2
print url3
Resultado:
Google Yahoo Live
Redefinicin de los operadores matemticos con objetos

Python nos permite redefinir los operadores matemticos cuando planteamos una clase.
Los mtodos especiales que debemos implementar son los siguientes:
Para el operador +:
__add__(self,objeto2)
Para el operador -:
__sub__(self,objeto2)
Para el operador *:
__mul__(self,objeto2)
Para el operador /:
__div__(self,objeto2)
Veamos con un ejemplo la sintaxis para redefinir el operador +. Crearemos una clase Cliente de un banco y
redefiniremos el operador + para que nos retorne la suma de los depsitos de los dos clientes que estamos
sumando.
class Cliente:
def __init__(self,nom,mon):
self.nombre=nom
self.monto=mon
def __add__(self,objeto2):
s=self.monto+objeto2.monto
return s
cli1=Cliente('Ana',1200)
cli2=Cliente('Luis',1500)
print 'El total depositado es '
print cli1+cli2
Es muy importante tener en cuenta que debemos redefinir un operador matemtico siempre y cuando haga
nuestro programa ms legible.
Debemos redefinir los operadores +,-,*,/ etc. solo para las clases que con solo leer su nombre el
programador intuya que operacin implementara dicho operador.
Problema resuelto
Crear una clase Cliente de un banco y redefinir el operador + para que nos retorne la suma de los depsitos
de los dos clientes que estamos sumando.
class Cliente:
def __init__(self,nom,mon):
self.nombre=nom
self.monto=mon
def __add__(self,objeto2):
s=self.monto+objeto2.monto
return s
cli1=Cliente('Ana',1200)
cli2=Cliente('Luis',1500)
print 'El total depositado es '
print cli1+cli2
Resultado:
El total depositado es 2700
Redefinicin de los operadores relacionales con objetos

Python tambin nos permite redefinir los operadores relacionales cuando planteamos una clase.
Los mtodos especiales que podemos implementar son los siguientes:
Para el operador ==:
__eq__(self,objeto2)
Para el operador !=:

__ne__(self,objeto2)
Para el operador >:

__gt__(self,objeto2)
Para el operador >=:

__ge__(self,objeto2)
Para el operador <:

__lt__(self,objeto2)
Para el operador <=:

__le__(self,objeto2)
Es importante recordar que una redefinicin de un operador tiene sentido si ayuda y hace ms claro nuestro
algoritmo.
Veamos con un ejemplo la sintaxis para redefinir todos estos operadores relacionales. Crearemos una clase
Persona que tiene como atributo el nombre y la edad. El operador == retornar verdadero si las dos personas
tienen la misma edad, el operador > retornar True si la edad del objeto de la izquierda tiene una edad mayor
a la edad del objeto de la derecha del operador >, y as sucesivamente
class Persona:
def __init__(self,nom,ed):
self.nombre=nom
self.edad=ed
def __eq__(self,objeto2):
if self.edad==objeto2.edad:
return True
def
def
def
def
def
else:
return False
__ne__(self,objeto2):
if self.edad!=objeto2.edad:
return True
else:
return False
__gt__(self,objeto2):
if self.edad>objeto2.edad:
return True
else:
return False
__ge__(self,objeto2):
if self.edad>=objeto2.edad:
return True
else:
return False
__lt__(self,objeto2):
if self.edad<objeto2.edad:
return True
else:
return False
__le__(self,objeto2):
if self.edad<=objeto2.edad:
return True
else:
return False
per1=Persona('juan',22)
per2=Persona('ana',22)
if per1==per2:
print 'Las dos personas tienen la misma edad.'
else:
print 'No tienen la misma edad.'
Como pedemos observar planteamos un mtodo por cada operdor relacional:

return True
else:
return False
El mtodo recibe como referencia (self) la direccin del objeto ubicado a la izquierda del operador
relacionar y como parmetro (objeto2) la referencia del objeto ubicado a la derecha del operador. Solo nos
queda analizar el atributo edad de cada objeto y retornar True si los dos almacenan el mismo valor, en caso
contrario retornar False.
Problema resuelto
Crear una clase Persona que tenga como atributo el nombre y la edad. El operador == retornar verdadero si
las dos personas tienen la misma edad, el operador > retornar True si la edad del objeto de la izquierda tiene
una edad mayor a la edad del objeto de la derecha del operador >, y as sucesivamente
class Persona:
def __init__(self,nom,ed):
self.nombre=nom
self.edad=ed
return True
else:
return False
def __ne__(self,objeto2):
if self.edad!=objeto2.edad:
return True
else:
return False
def __gt__(self,objeto2):
if self.edad>objeto2.edad:
return True
else:
return False
def __ge__(self,objeto2):
if self.edad>=objeto2.edad:
return True
else:
return False
def __lt__(self,objeto2):
if self.edad<objeto2.edad:
return True
else:
return False
def __le__(self,objeto2):
if self.edad<=objeto2.edad:
return True
else:
return False
per1=Persona('juan',22)
per2=Persona('ana',22)
if per1==per2:
print 'Las dos personas tienen la misma edad.'
else:
print 'No tienen la misma edad.'
Resultado:
Las dos personas tienen la misma edad.
Problema Propuesto
Plantear una clase Rectangulo. Definir dos atributos (ladomenor y ladomayor). Redefinir el operador == de
tal forma que tengan en cuenta la superficie del rectngulo.
Ver solucin
class Rectangulo:
def __init__(self,lmen,lmay):
self.lmenor=lmen
self.lmayor=lmay
def retornarsuperficie(self):
return self.lmenor*self.lmayor
if self.retornarsuperficie()==objeto2.retornarsuperficie():
return True
else:
return False
rectangulo1=Rectangulo(10,10)
rectangulo2=Rectangulo(5,20)
if rectangulo1==rectangulo2:
print 'Los rectangulos tienen la misma superficie'
else:
print 'Los rectangulos no tienen la misma superficie'
Las cadenas tratadas como objetos

Ahora que hemos introducido los conceptos bsicos de objetos veamos ms profundo el concepto de
cadenas (string) en Python.
En Python todo es un objetos, por lo que cuando definimos una cadena estamos definiendo un objeto.
Como hemos visto toda clase tiene una serie de mtodos, veremos los mtodos principales que tiene la clase
que en Python administra una cadena.
Los mtodos:
capitalize()
Retorna otra cadena con el primer caracter en maysculas.
cadena='ana'
print cadena.capitalize() #Ana
print cadena #ana
Es importante notar que no se modifica el contenido de la variable 'cadena'. El mtodo capitalize()

retorna otra cadena con el primero en maysculas.
upper()
Retorna otra cadena con todos los caracteres convertidos a mayscula.
cadena1='ana'
cadena2=cadena1.upper()
print cadena2
lower()
Retorna otra cadena con todos los caracteres convertidos a minsculas.
cadena1='Ana'
cadena2=cadena1.lower()
print cadena2
isupper()
Retorna True si todos los caracteres de la cadena estn en maysculas.
cadena='ANA'
if cadena.isupper():
print 'La cadena '+cadena+' esta toda en mayusculas'
islower()
Retorna True si todos los caracteres de la cadena estn en minsculas.
#ANA
#ana
cadena1='ana'
if cadena.islower():
print 'La cadena '+cadena+' esta toda en minusculas'
isdigit()
Retorna verdadero si todos los caracteres de la cadena son dgitos.
cadena='120'
if cadena.isdigit():
print 'Todos los caracteres de la cadena son numeros'
Si al menos uno de los caracteres es distinto a un dgito retorna False. Inclusive si tiene el caracter
punto.
isalpha()
Retorna True si todos los caracteres son alfabticos.
cadena='Hola Mundo'
if cadena.isalpha():
print 'Todos los caracteres de la cadena son del alfabeticos'
else:
print 'No todos los caracteres de la cadena son del alfabeticos'
En el ejemplo superior ejecuta el bloque del else ya que la cadena contiene un caracter de espacio.
isspace()
Retorna verdadero si todos los caracteres de la cadena son espacios en blanco
cadena='
'
if cadena.isspace():
print 'Todos los caracteres de la cadena son espacios en blanco'
isalnum()
Retorna True si todos los caracteres de la cadena son nmeros o caracteres alfabticos.
cadena='cordoba2008'
if cadena.isalnum():
print 'Todos los caracteres son numeros o alfabeticos'
find('cadena',[inicio],[fin])
Retorna la posicin donde se encuentra el valor del primer parmetro en el string. Si no se encuentra
retorna -1. Podemos indicar como segundo y tercer parmetro a partir de que posicin y hasta que
posicin de la cadena hacer la bsqueda.
cadena='esto es una prueba y es solo eso'

pos=cadena.find('es')
print pos
#0
Retorna 0 ya que los dos primeros caracteres son la cadena 'es', es decir retorna la primera aparicin
del string.
pos=cadena.find('es',5)
print pos
#5
En este otro ejemplo comenzamos la bsqueda a partir de la posicin 5. Si no indicamos el tercer

parmetro la bsqueda la hace hasta el final de la cadena
rfind('cadena',[inicio],[fin])
Igual al mtodo find con la diferencia que la bsqueda comienza desde el final.

pos=cadena.rfind('es')
print pos #29
count('cadena',[inicio],[fin])
Retorna la cantidad de veces que la cadena se repite en el string.

cant=cadena.count('es')
print cant
#4
replace('cadena1','cadena2',[maximo])
Retorna un string remplazando todas las ocurrencias de cadena1 por cadena2. Podemos
eventuamente indicar la cantidad mxima de remplazos.
cadena1='esto es una prueba y es solo eso'

cadena2=cadena1.replace('es','ES')
print cadena2 #ESto ES una prueba y ES solo ESo
split('caracter separador',[maximo])
El mtodo split retorna una lista dividiendo el string por el caracter indicado en el primer parmetro.
Podemos pasar un segundo parmetro indicando la cantidad de trozos a general, el ltimo elemento
de la lista almacena el resto del string.

lista=cadena.split(' ')
print lista
#['esto', 'es', 'una', 'prueba', 'y', 'es', 'solo',
'eso']
print len(lista)
#8
lista=cadena.split(' ',2)
print lista
#['esto', 'es', 'una prueba y es solo eso']
print len(lista)
#3
rsplit('caracter separador',[maximo])
Semejante a split pero procesando desde el final del string. En caso de indicar maximo el primer
elemento de la lista almacena el trozo restante.

lista=cadena.rsplit(' ')
print lista
#['esto', 'es', 'una', 'prueba', 'y', 'es', 'solo',
'eso']
print len(lista)
#8
lista=cadena.rsplit(' ',2)
print lista
#['esto es una prueba y es', 'solo', 'eso']
print len(lista)
#3
splitlines()
Retorna una lista dividiendo el string con los retornos de carro contenidos en el mismo.
mensaje="""Primer linea
Segunda linea
Tercer linea
Cuarta linea"""
lista=mensaje.splitlines()
print lista #['Primer linea', ' Segunda linea', ' Tercer linea', ' Cuarta linea']
swapcase()
Retorna un string transformando los caracteres minsculas a maysculas y los maysculas a
minsculas.
cadena1='Sistema de Facturacion'
cadena2=cadena1.swapcase()
print cadena2
#sISTEMA DE fACTURACION
rjust(ancho,caracter de relleno)
Retorna un string justificado a derecha y rellenando el lado izquierdo con caracteres segn el
segundo parmetro. La nueva cadena toma un largo indicado segn el valor del primer parmetro.
cadena='200'
cadena2=cadena.rjust(5,'$')
print cadena2
#$$200
ljust(ancho,caracter de relleno)
Similar a rjust con la salvedad que se justifica a derecha el string.
cadena='200'
cadena2=cadena.ljust(5,'$')
print cadena2
#200$$
center(ancho,caracter de relleno)
El string original se centra.
cadena='200'
cadena2=cadena.center(5,'$')
print cadena2
#$200$
Problema resuelto
Confeccionar una funcin que reciba una lista de valores y los muestre en columna y justificados a derecha.
def mostrar(lista):
print '<pre>'
for v in lista:
print v.rjust(10,' ')
print '<br>'
print '<pre>'
l=['234','12','345534','234','1','45']
mostrar(l)
Resultado:
234
12
345534
234
1
45
Problema Propuesto
Confeccionar una funcin que reciba una oracin y retorne la palabra mayor alfabticamente
Ver solucin
def mayoralfa(cadena):
lista=cadena.split(' ')
mayor=lista[0]
for pa in lista:
if pa>mayor:
mayor=pa
return mayor
oracion='esto es una prueba y es'
print mayoralfa(oracion)
Las listas tratadas como objetos

Ahora veremos ms profundamente el concepto de listas en Python y los mtodos que provee su clase.
Los mtodos:
append(elemento)
El mtodo append aade un elemento al final de la lista.
lista=['juan','ana','luis']
lista.append('carlos')
print lista #['juan', 'ana', 'luis', 'carlos']
extend(elementos)
El mtodo extend procesa la secuencia de elementos del parmetro y los aade uno a uno a la lista.
La diferencia con el mtodo append es que append siempre aade un nico elemento a la lista y
extend aade tantos elementos como tenga la secuencia.
lista.extend(['uno','dos'])
print lista #['juan', 'ana', 'luis', 'uno', 'dos']
Ahora la lista tiene 5 elementos, es decir se aadieron 2 nuevas componentes a la lista.

En cambio si utilizamos append el resultado es:
lista.append(['uno','dos'])
print lista #['juan', 'ana', 'luis', ['uno', 'dos']]
Ahora la lista tiene cuatro elementos y el ltimo elemento es una lista tambin.
insert(posicin,elemento)
El mtodo insert aade un elemento en la posicin que le indicamos en el primer parmetro.
lista.insert(0,'carlos')
print lista #['carlos', 'juan', 'ana', 'luis']
En este ejemplo insertamos la cadena 'carlos' al principio de la lista, ya que pasamos la posicin 0, no
se borra el elemento que se encuentra en la posicin 0 sino se desplaza a la segunda posicin.
Si indicamos una posicin que no existe porque supera a la posicin del ltimo elemento se inserta al
final de la lista.
pop([posicion]
El mtodo pop si lo llamamos sin parmetro nos retorna y borra la informacin del ltimo nodo de la
lista. Si en cambio pasamos un entero este indica la posicin del cual se debe extraer.
lista=['juan','ana','luis','marcos']
elemento=lista.pop()
print elemento
#marcos
print lista
#['juan', 'ana', 'luis']
print lista.pop(1)
#ana
print lista
#['juan', 'luis']
remove(elemento)
Borra el primer nodo que coincide con la informacin que le pasamos como parmetro.
lista=['juan','ana','luis','marcos','ana']
lista.remove('ana')
print lista
#['juan', 'luis', 'marcos', 'ana']
count(elemento)
Retorna la cantidad de veces que se repite la informacin que le pasamos como parmetro.
print lista.count('ana') #2
index(elemento,[inicio],[fin])
Retorna la primera posicin donde se encuentra el primer parmetro en la lista. Podemos
eventualmente indicarle a partir de que posicin empezar a buscar y en que posicin terminar la
bsqueda.
Si no lo encuentra en la lista genera un error: ValueError: list.index(x): x not in list
print lista.index('ana') #1
sort()
Ordena la lista de menor a mayor.
lista.sort()
print lista
#['ana', 'ana', 'juan', 'luis', 'marcos']
reverse()
Invierte el orden de los elementos de la lista.
lista.reverse()
print lista
#['ana', 'marcos', 'luis', 'ana', 'juan']
Si necesitamos borrar un nodo de la lista debemos utilizar el comando del que provee Python:
del lista[2]
print lista
#['juan', 'ana', 'marcos']
Podemos utilizar el concepto de porciones para borrar un conjunto de elementos de la lista:

Si queremos borrar los elementos de la posicin 2 hasta la 3:
lista=['juan','ana','carlos','maria','pedro']
del lista[2:4]
print lista # ['juan', 'ana', 'pedro']
Si queremos borrar desde la 2 hasta el final:

del lista[2:]
print lista # ['juan', 'ana']
Si queremos borrar todos desde el principio hasta la posicin 3 sin incluirla:

del lista[:3]
print lista # ['maria', 'pedro']
Si queremos ir borrando de a uno de por medio:

del lista[::2]
print lista # ['ana', 'maria']
Si necesitamos modificar el contenido de un nodo de la lista debemos utilizar el operador de asignacin:

lista[2]='xxxxx'
print lista
#['juan', 'ana', 'xxxxx', 'marcos']
Problema resuelto
Crear una lista con 30 valores aleatorios comprendidos entre 1 y 300.
Efectuar las siguientes operaciones (Luego de cada operacin mostrar el estado de la lista):
- Borrar el primer y ltimo elemento de la lista.
- Insertar un elemento al final con la suma de todos los elementos actuales.
- Insertar un elemento entre el primero y el segundo elemento de la lista con el valor 125.
import random
lista=[]
lista.append(valor)
print lista
print '<br>'
del lista[0]
del lista[-1]
print lista
print '<br>'
suma=0
for x in range(1,len(lista)):
suma=suma+lista[x]
lista.append(suma)
print lista
print '<br>'
lista.insert(1,125)
print lista
RESULTADO:
[289, 288, 168, 110, 297, 288, 80, 256, 88, 165, 44, 266, 211, 40, 185, 124, 47, 213, 221, 39, 211, 209, 205,
232, 125, 285, 116, 195, 295, 106, 171, 101, 66, 74, 24, 240, 80, 10, 40, 218, 38, 193, 221, 45, 12, 143, 176,
64, 24]
[288, 168, 110, 297, 288, 80, 256, 88, 165, 44, 266, 211, 40, 185, 124, 47, 213, 221, 39, 211, 209, 205, 232,
125, 285, 116, 195, 295, 106, 171, 101, 66, 74, 24, 240, 80, 10, 40, 218, 38, 193, 221, 45, 12, 143, 176, 64]
[288, 168, 110, 297, 288, 80, 256, 88, 165, 44, 266, 211, 40, 185, 124, 47, 213, 221, 39, 211, 209, 205, 232,
125, 285, 116, 195, 295, 106, 171, 101, 66, 74, 24, 240, 80, 10, 40, 218, 38, 193, 221, 45, 12, 143, 176, 64,
6737]
[288, 125, 168, 110, 297, 288, 80, 256, 88, 165, 44, 266, 211, 40, 185, 124, 47, 213, 221, 39, 211, 209, 205,
232, 125, 285, 116, 195, 295, 106, 171, 101, 66, 74, 24, 240, 80, 10, 40, 218, 38, 193, 221, 45, 12, 143, 176,
64, 6737]
Problema Propuesto
Crear una lista con 10 valores aleatorios comprendidos entre 1 y 5.
- Insertar un nodo al final de la lista con el mayor elemento de la lista.
- Insertar un nodo al principio de la lista con la suma de los primeros 5 nodos.
- Imprimir la cantidad de veces que se repite la informacin del segundo nodo en la lista.
Ver solucin
import random
lista=[]
lista.append(valor)
print lista
print '<br>'
mayor=lista[0]
for valor in lista:
if valor>mayor:
mayor=valor
lista.insert(0,mayor)
print lista
print '<br>'
print lista.count(lista[1])
Los diccionarios tratados como objetos

Habamos visto la estructura de datos tipo diccionario que utiliza una clave para acceder a un valor. El
subndice puede ser un entero, un string etc. Un diccionario vincula una clave y un valor.
Los diccionarios en Python tambin son objetos y como tales tienen una serie de mtodos que nos permiten
administrarlos:
keys()
Retorna una lista con todas las claves del diccionario.
lista=diccionario.keys()
print lista # ['house', 'window', 'bed', 'red']
values()
Retorna una lista con todos los valores almacenados en el diccionario.
lista=diccionario.values()
print lista # ['casa', 'ventana', 'cama', 'rojo']
items()
Retorna una lista que contiene en cada nodo una tupla con la clave y valor del diccionario.
lista=diccionario.items()
print lista # [('house', 'casa'), ('window', 'ventana'), ('bed', 'cama'),
('red', 'rojo')]
pop(clave,[valor])
Extrae el valor de la clave que pasamos como parmetro y borra el elemento del diccionario. Genera
un error si no se encuentra dicha clave, salvo que se inicialice un segundo parmetro que ser el dato
que retornar.
valor=diccionario.pop('window')
print valor # ventana
print diccionario #{'house': 'casa', 'bed': 'cama', 'red': 'rojo'}
Si no encuentra la clave en el diccionario y hemos indicado un segundo parmetro al mtodo pop

ser dicho valor el que retorne:
valor=diccionario.pop('love','clave no encontrada')
print valor # clave no encontrada
has_key(clave)
Retorna True si la clave se encuentra en el diccionario, False en caso contrario.
if diccionario.has_key('love'):
print 'Si tiene la clave buscada'
else:
print 'No existe la clave buscada'
clear()
Elimina todos los elementos del diccionario.
diccionario.clear()
print diccionario
# {}
copy()
Se genera una copia idntica del diccionario actual en otra parte de memoria.
diccionario1={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
diccionario2=diccionario1.copy()
print diccionario2 #{'house': 'casa', 'window': 'ventana', 'red': 'rojo', 'bed':
'cama'}
diccionario1['house']='xxxxx'
print diccionario2 #{'house': 'casa', 'window': 'ventana', 'red': 'rojo', 'bed':

'cama'}
Es importante hacer notar que no es lo mismo:

diccionario2=diccionario1
Con la asignacin anterior no se esta creando un segundo diccionario sin se tiene dos variables que
referencian al mismo objeto.
popitem()
Retorna un elemento del diccionario y lo elimina. Como no hay un sentido de orden en el diccionario
se extrae uno al azar.
elemento=diccionario.popitem()
print elemento
print diccionario
Para saber cual se extrajo se debe ejecutar el algoritmo.
update(diccionario2)
Modifica el diccionario actual agregando los elementos del diccionario2, si una clave est repetida se
modifica su valor.
diccionario1={'uno':'1','dos':'2','tres':'3333'}
diccionario2={'tres':'3','cuatro':'4','cinco':'5'}
diccionario1.update(diccionario2)
print diccionario1 #{'cuatro': '4', 'cinco': '5', 'dos': '2', 'tres': '3', 'uno':
'1'}
Adems seguimos contando con el comando del para borrar elementos del diccionario:
del diccionario['house']
print diccionario #{'window': 'ventana', 'bed': 'cama', 'red': 'rojo'}
El cambio o agregado de un valor al diccionario se hace mediante la asignacin:

diccionario['red']='colorado'
diccionario['blue']='azul'
print diccionario # {'house': 'casa', 'window': 'ventana', 'bed': 'cama', 'red':
'colorado','blue': 'azul'}
La cantidad de elementos mediante la funcin len:

print len(diccionario) # 4
Problema resuelto
Definir un diccionario para almacenar el nombre de un usuario como clave y su mail como valor.
Crear una funcin que almacene la clave y su mail siempre y cuando no haya otro nombre de usuario igual
en el diccionario
def sumarusuario(dic,usu,valor):
if not dic.has_key(usu):
dic[usu]=valor
diccionario={}
sumarusuario(diccionario,'juan','juan@hotmail.com')
sumarusuario(diccionario,'ana','ana@yahoo.com')
sumarusuario(diccionario,'luis','luis@gmail.com')
sumarusuario(diccionario,'luis','luis@hotmail.com')
print diccionario
Resultado:
{'luis': 'luis@gmail.com', 'juan': 'juan@hotmail.com', 'ana': 'ana@yahoo.com'}
Problema Propuesto
Crear un diccionario con 3 elementos (almacenar como clave el nombre de una fruta y como valor su
precio). Luego hacer las siguientes operaciones:
- Agregar un cuarto elemento.
- Imprimer la cantidad de elementos del diccionario.
- Borrar un elemento del diccionario.
- Imprimir todas las claves.
- Imprimir todos los valores.
- Imprimir claves y valores.
- Borrar el diccionario.
Ver solucin
frutas={'manzanas':1.60,'peras':1.90,'bananas':0.95}
print frutas
print '
'
frutas['naranjas']=2.50
print len(frutas)
print '<br>'
del frutas['naranjas']
for x in frutas.keys():
print x
print '<br>'
for x in frutas.values():
print x
print '<br>'
for (clave,valor) in frutas.items():
print clave+' '+str(valor)+' - '
print '<br>'
frutas.clear()
print frutas
Instalacin de Python en su computadora

Ahora a llegado el momento de instalar Python en su equipo. Debemos descargar el instalador del sitio
oficial de Python.
Aqu seguiremos los pasos para instalar la versin para Windows python-2.5.2. Descarguemos la versin
para el procesasor x86.
Tenemos en nuestro equipo el archivo para hacer la instalacin local de Python python-2.5.2.msi. Lo
ejecutamos
El primer dilogo nos pregunta si se instala solo para nosotros o para todos los usuarios del equipo (podemos
dejar la opcin seleccionada para todos los usuarios) y presionamos 'Next'.
El segundo formulario del wizard nos permite seleccionar la unidad donde se instala el lenguaje. Dejemos
por defecto la que nos propone el instalador: c:\Python25\
El tercer paso nos permite seleccionar o suprimir distintos mdulos que vienen con Python (extensiones,
documentacin etc.), dejaremos por defecto que instale todos.
Finalmente ya tenemos instalado el lenguaje Python en nuestro equipo.
Ahora para codificar los programas utilizaremos un editor que se instala junto con el lenguaje Python, desde
el men de opciones podemos acceder al editor llamado: IDLE.
En realidad lo primero que aparece es una ventana llamada Python Shell donde podemos ejecutar
instrucciones en forma unitaria:
Por ejemplo escribamos:
print 'Hola Mundo'
Pero nuestro objetivo fundamental es la creacin de programas o mdulos completos en Python, para esto
seleccionamos en esta ventana desde el men de opciones File -> New Window.
Ahora s tenemos el editor que suministra Python para codificar nuestros programas.
Escribamos una aplicacin muy sencilla:
import random
def mostrarnumeros():
for x in range(7):
print valor
mostrarnumeros()
La grabamos en nuestro disco duro (por ejemplo prueba1.py) y desde el men de opciones seleccionamos
Run -> Run Module, si hemos tipeado correctamente el programa tendremos el resultado en la ventana
"Python Shell".
En los conceptos siguientes veremos temas que no pueden ser ejecutados directamente en el sitio PythonYa,
por lo que tener el lenguaje Python en forma local en su equipo se hace indispensable para probarlos.
Creacin, carga y lectura de archivos de texto

Python cuenta con una clase llamada file que nos permite crear, escribir y leer datos de un archivo de texto.
Para crear un objeto de la clase file debemos utilizar la funcin open. Cuando llamamos a dicha funcin le
pasamos como primer parmetro el nombre del archivo de texto y el modo de apertura del mismo:
open(nombre del archivo,modo)
Si el archivo de texto se encuentra en la misma carpeta que nuestro programa no necesitamos indicar el path
(camino). Los modos de apertura del archivo de texto pueden ser:
'r' Abre el archivo para lectura (debe existir el archivo)
'w' Crea el archivo y lo abre para escribir
'a' Abre el archivo para escribir. Se crea si el archivo no existe. Solo podemos agregar datos al final
Creacin de un archivo de texto

El siguiente algoritmo crea en disco un archivo de texto llamado 'datos.txt' y no graba datos. Si queremos
luego de ejecutar el programa podemos verificar la existencia del archivo en la misma carpeta donde
almacenamos nuestro programa.
Cuando lo grabamos el archivo fuente en Python debemos darle un nombre al programa (por ejemplo
texto1.py)
def creaciontxt():
archi=open('datos.txt','w')
archi.close()
creaciontxt()
Creamos una funcin llamada creaciontxt donde primero llamamos a la funcin open pasando como
parmetros el nombre del archivo de texto a crear y el modo de apertura ('w')
La funcin open retorna la referencia del objeto file. Luego llamamos al mtodo close de la clase file. Si
luego queremos ver si se a creado el archivo de textos podemos hacerlo desde algun explorador de archivos,
en la carpeta donde se encuentra nuestro programa en Python veremos un archivo llamado 'datos.txt' que
tiene un tamao de 0 bytes.
Grabacin de lneas en el archivo de texto
def creartxt():
archi.close()
def grabartxt():
archi=open('datos.txt','a')
archi.write('Linea 1\n')
archi.close()
creartxt()
grabartxt()
La funcin creartxt es similar al ejemplo anterior, y la funcin grabartxt tiene por objetivo abrir el archivo en
modo de agregado. Cada vez que grabamos un string en el archivo de texto insertamos un salto de lnea '\n'.
Finalmente liberamos el archivo llamando al mtodo close.
Para ver el contenido de nuestro archivo de texto debemos utilizar un editor de texto (bloc de notas o el
mismo entorno del Idle nos puede servir para ver el contenido de un archivo txt)
Lectura lnea a lnea de un archivo de texto
La clase file tiene un mtodo llamado readline() que retorna toda una lnea del archivo de texto y deja
posicionado el puntero de archivo en la siguiente lnea. Cuando llega al final del archivo readline retorna un
string vaco.
def creartxt():
archi.close()
def grabartxt():
archi.close()
def leertxt():
archi=open('datos.txt','r')
linea=archi.readline()
while linea!="":
print linea
archi.close()
creartxt()
grabartxt()
leertxt()
Luego de de abrir el archivo para lectura procedemos a leer la primer lnea:

El while se repite mientras el mtodo readline() no retorne un string vaco. Dentro del while procedemos a
imprimir la lnea que acabamos de leer y leemos la siguiente (el mtodo readline() retorna el contenido de
toda la lnea inclusive el salto de lnea \n):
while linea!="":
print linea
Podemos leer todo el contenido de un archivo de texto y almacenarlo en una lista (esto tiene sentido si el
archivo de texto no es muy grande):
def creartxt():
archi.close()
def grabartxt():
archi.close()
def leertxtenlista():
lineas=archi.readlines()
print lineas
archi.close()
creartxt()
grabartxt()
leertxtenlista()
Utilizamos el mtodo readlines() en lugar de readline(). El mtodo readlines() retorna una lista con cada
lnea del archivo de texto.
Recordemos que podemos procesar luego cada elemento de la lista recorrindola con una estructura
repetitiva:
def leertxtenlista():
lineas=archi.readlines()
for li in lineas:
print li
archi.close()
Captura de excepciones
Cuando nuestra aplicacin genera un error que Python no puede resolver podemos disponer un cdigo que
se ejecute para dichas situaciones.
Errores como tratar de abrir un archivo que no existe, acceder a un elemento de una lista que no existe,
dividir por cero etc. genera un error que hace que nuestro programa se detenga y no contine su ejecucin.
Pero con Python podemos preveer estas situaciones y definir un algoritmo que se ejecutar exepcionalmente
cuando ocurra dicho error.
Si ejecutamos el siguiente cdigo el programa se detendr informndonos que se produjo un error y no

puede continuar:
y=0
x=10/y
print 'esta linea nunca se ejecuta'
Utilizando excepciones podemos capturar el error y continuar la ejecucin del programa:

y=0
try:
x=10/y
except ZeroDivisionError:
print 'No existe la division por cero'
print 'Esta linea si se ejecuta'
La estructura try/except requiere que indiquemos el tipo de excepcin a capturar, en este caso cuando se trata
de dividir por cero Python genera una excepcin llamada ZeroDivisionError. Para capturar dicha excepcin
debemos disponerla seguido de la palabra clave except.
Si se produce la excepcin se ejecutan las instrucciones que dispongamos en las lneas siguientes al except.
Cuando se captura una excepcin el programa no se detiene y continua con las intrucciones siguientes al
bloque try/except.
Veamos otro ejemplo de intentar acceder a un elemento que no existe en una lista:
lista1=['juan','ana','carlos']
try:
print lista1[5]
except IndexError:
print 'Intenta acceder a un elemento no existente a la lista'
lista1 almacena 3 elementos y tratamos de acceder al de la posicin 5. Python en este situacin genera una
excepcin de tipo IndexError, como disponemos el acceso dentro de la contruccin try/except y captura el
tipo de excepcin IndexError el programa no se detiene y ejecuta la instruccin seguida de la lnea except
IndexError.
Un tema de aplicacin muy comn donde se utilizan las excepciones es con el tratamiento de archivos, hay
muchas situaciones que pueden generar excepciones en estos casos como puede ser que no se pueda abrir un
archivo porque no existe, no lo pueda crear porque la unidad de amacenamiento est llena, el archivo se
encuentra bloqueado por otro programa etc.
El cdigo para crear, grabar y leer un archivo capturando las excepciones queda de la siguiente manera:
def creartxt():
try:
archi.close()
except IOError:
print 'No se pudo crear el archivo'
def grabartxt():
try:
archi.close()
except IOError:
print 'No se pudo abrir el archivo'
def leertxt():
try:
archi=open('noexiste.txt','r')
while linea!="":
print linea
archi.close()
except IOError:
print 'El archivo no existe'
creartxt()
grabartxt()
leertxt()
La excepcin cumple un doble cometido en estas situaciones, primero mostramos mensajes que nosotros
definimos y no los que Python muestra por defecto cuando se genera un error y por otro lado podemos
continuar con la ejecucin de nuestro algoritmo sin que se detenga.
Podemos disponer varios capturas de excepciones para un bloque try:
try:
print lista1[0]
z=10/0
except IndexError:
print 'Division por cero no permitida'
En este bloque try capturamos las excepciones de tipo: IndexError y ZeroDivisionError. Como podemos ver
la que se dispara es la de ZeroDivisionError. Pero podemos generar el otro tipo de excepcin modificando la
lnea de impresin del elemento de la lista:
print lista1[5]
Si hacemos este cambio se ejecuta la seccin seguida a 'except IndexError:'. Una vez disparada dicha
excepcin no continua con las instrucciones del bloque del try, es decir no generar la excepcin de divisin
por cero, pero si continuar con el flujo del algoritmo.
Si no queremos tratar los errores en forma independiente podemos agrupar excepciones:
try:
print lista1[0]
z=10/0
except (IndexError,ZeroDivisionError):
print 'Se produjo un error'
Debemos indicar entre parntesis todas las excepciones a capturar y como se procede con ellas, en este caso
solo se muestra un mensaje 'Se produjo un error'.
Otra parte opcional de un bloque try es la del else. Este bloque se ejecuta si no se produce la excepcin:
try:
print lista1[0]
z=10/5
else:
print z
Este programa muestra el primer elemento de la lista, luego procede a inicializar la variable z con el valor
10/5 y seguidamente ejecuta la seccin del else ya que no se a generado excepciones.
Podemos tratar de imprimir una componente que no exista de la lista y veremos que no se ejecuta el bloque
del else.
Hemos visto que podemos capturar distintas excepciones en forma independiente:

except IndexError:
print 'Division por cero no permitida'
En forma conjunta:
Inclusive Python nos permite disponer un bloque try except para la captura de cualquier tipo de excepcin
(si bien esto no es lo ms recomendable ya que es difcil emprender una accin para todos los tipos de
errores que pueden generarse):
try:
print lista1[0]
z=10/0
except:
Otra seccin que puede tener un bloque try except es finally.

finally permite disponer un bloque de cdigo que se ejecutar siempre, indistintamente se produzca o no la
excepcin. El objetivo de esta seccin es generalmente utilizado para liberar recursos como puede ser cerrar
la conexin con una base de datos o cerrar un archivo.
try:
z=10/0
print 'Esto no se ejecuta'
except:
finally:
print 'Siempre se ejecuta'
Problema resuelto
Definir una diccionario donde se debe almacenar los nombres de frutas como clave y su precio como valor.
Tratar de acceder a una clave inexistente y capturar la excepcin KeyError que se produce en estos casos.
frutas={'naranjas':1.5,'manzanas':2.3,'peras':1.5}
try:
print frutas['sandias']
except KeyError:
print 'No existe dicha fruta'
Resultado:
No existe dicha fruta
Google App Engine utilizando Python

El servicio de Google App Engine nos permite obtener una cuenta para crear nuestras aplicaciones web
utilizando los servidores y tecnologa de Google. Y como ventaja despus de haber estudiado Python Google
App Engine nos facilita crear un sitio utilizando como lenguaje de servidor el Python.
Actualmente nos suministra 500 MB para el almacenamiento de nuestras pginas y base de datos, todo esto
en forma gratuita.
El primer paso es registrarnos en Google para obtener una cuenta y esto lo podemos hacer desde aqu
Si tarda un poco la asignacin de la cuenta no es tan importante ya que todo el desarrollo lo hacemos
en forma local en nuestro equipo. Finalizado el proyecto lo debemos cargar en los servidores de
Google.
Para trabajar en forma local debemos tener instalado el lenguaje Python en su versin 2.5 o superior.
Tambin tenemos que tener instalado el kid de desarrollo que nos provee Google y ejecuta nuestra
aplicacin en forma local, podemos descargar la ltima actualizacin del mismo desde aqu.
Luego de instalar el Python 2.5 o superior debemos proceder a instalar el kid de desarrollo que nos provee
Google. Cuando lo instalamos nos sugiere donde se instala el software (podemos dejar el que nos propone
por defecto): c:\Archivo de programa\Google\google_appengine\
Ya tenemos todo para comenzar a experimentar con Python y el framework que nos provee Google para el
desarrollo de aplicaciones web.
Si ya dispone la cuenta suministrada por Google desde el panel de administracin podemos crear una
aplicacin presionando el botn "Create an Application".
Debemos seleccionar un nombre para nuestra aplicacin que correr como un subdominio de appspot.com,
como podrn comprobar muchos de los nombres ms comunes ya han sido tomados por otros usuarios.
Seleccionado un nombre disponible (podemos comprobar disponibilidad presionando el botn "Check
Availability") asignamos un ttulo y aceptamos los trminos del servicio. Ya estamos en condiciones de subir
nuestra aplicacin (tengamos en cuenta que todava no hemos desarrollado ni el 'Hola Mundo')
Hola mundo con Google App Engine

Primero debemos crear un directorio donde se instal el Google App Engine, normalmente en: c:\Archivo de
programa\Google\google_appengine\
Este nombre debe coincidir con el que obtuvimos desde el panel de control de nuestra cuenta de Google App
Engine (yo tomar como nombre tutorialya)
Para utilizar los servidores de Google deberemos crear un archivo de configuracin llamado app.yaml y que
deberemos localizar en el directorio que acabamos de crear.
El archivo app.yaml tiene una estructura similar a:
application: tutorialya
version: 1
runtime: python
api_version: 1
handlers:
- url: /.*
script: tutorialya.py
Del ejemplo anterior deber modificar la propiedad de application con el nombre de aplicacin que gestion
desde su panel de control del Google App Engine. Lo mismo pasa con la propiedad script.
Ahora que tenemos nuestro directorio donde se alojar nuestro sitio en forma local y el archivo de
configuracin app.yaml debemos crear el archivo Python principal y lo llamaremos igual que el nombre de
la carpeta y con extensin *.py y debe coincidir con la propiedad script del archivo app.yaml (en mi caso yo
lo llam tutorialya.py).
Para codificar nuestra aplicacin Google cre un framework propio llamado webapp y que se instala
automticamente con nuestra aplicacin.
Luego nuestra aplicacin mnima utilizando dicho framework es:
import wsgiref.handlers
from google.appengine.ext import webapp
class HolaMundo(webapp.RequestHandler):
def get(self):
self.response.out.write('<html><head></head>')
self.response.out.write('<body>')
self.response.out.write('<h1>Hola Mundo</h1>')
self.response.out.write('</body>')
def main():
application = webapp.WSGIApplication([('/', HolaMundo)],
debug=True)
wsgiref.handlers.CGIHandler().run(application)
if __name__ == '__main__':
main()
Despus nos detendremos en la forma de codificar utilizando este framework, por ahora solo nos interesa
ver aparecer el 'Hola mundo' en el navegador.
Ya tenemos codificado el archivo *.yaml y *.py, ahora queda iniciar nuestro servidor y peticionar la pgina.
Como servidor web no utilizaremos el Apache, sino un servidor creado con Python que viene incluido con el
Google App Engine. Para activar este servidor debemos ir a la lnea de comandos de nuestro sistema
operativo hasta la carpeta (c:\Archivo de programa\Google\google_appengine\) y desde all arrancar el
servidor indicando el nombre de nuestra aplicacin:
c:\Archivo de programa\Google\google_appengine>dev_appserver.py tutorialya/
Tener en cuenta de pasar como parmetro al programa dev_appserver.py el nombre de la carpeta que hemos
creado para nuestro proyecto (en mi caso la llam tutorialya)
Si tenemos correctamente creado el archivo *.yaml deber mostrar un mensaje que el servidor web est
esperando peticiones en el puerto 8080. Luego desde el navegador debemos llamar nuestra aplicacin con la
siguiente sintaxis:
http://localhost:8080
Si codificamos correctamente la aplicacin deberemos tener el mensaje 'Hola Mundo'.
Subir nuestra aplicacin Hola mundo a internet

Si ya tenemos nuestra aplicacin ejecutndose en forma correcta localmente:
http://localhost:8080
Ahora para que la puedan acceder todos en internet debemos seguir los siguientes pasos:
El primer paso es registrarnos en Google si todava no lo hemos hecho para obtener una cuenta y esto
lo podemos hacer desde aqu
Si ya dispone la cuenta suministrada por Google desde el panel de administracin podemos crear una
aplicacin presionando el botn "Create an Application".
Debemos seleccionar un nombre para nuestra aplicacin que correr como un subdominio de
appspot.com.
Seleccionado un nombre disponible (podemos comprobar disponibilidad presionando el botn
"Check Availability") asignamos un ttulo y aceptamos los trminos del servicio. Ya estamos en
condiciones de subir nuestra aplicacin
Controlar que nuestro archivo app.yaml tiene una estructura similar a:
application: tutorialya
version: 1
runtime: python
api_version: 1
handlers:
- url: /.*
script: tutorialya.py
Del ejemplo anterior deber modificar la propiedad de application con el nombre de aplicacin que
gestion desde su panel de control del Google App Engine. Lo mismo pasa con la propiedad script.
Desde la lnea de comandos del sistema operativo ejecutar el siguiente programa en Python que tiene
por objetivo hacer el upload de todo nuestro proyecto a la cuenta que tenemos asignada en Google
App Engine:
c:\Archivo de programa\Google\google_appengine>appcfg.py update tutorialya/
En ese momento se nos solicitar nuestro mail y clave.
Ya tenemos en el servidor almacenado nuestro sitio, solo nos falta llamarlo para verlo correr en la
web.
http://tutorialya.appspot.com/
Recordar de remplazar el nombre tutorialya con el nombre con el que crearon su aplicacin desde el
panel del Google App Engine.
Recuperar el dato de un text (App Engine)

Realizaremos una aplicacin que muestre un formulario con un control de tipo text y cuando se presione el
botn submit mostraremos el dato ingresado en otra pgina.
import cgi
class Formulario1(webapp.RequestHandler):
def get(self):
self.response.out.write("""
<html>
<head></head>
<body>
<form method="post" action="procformulario1">
Ingrese su nombre:<input type="text" name="nombre" size="20"><br>
<input type="submit" value="Ok">
</form>
</body>
""")
class ProcFormulario1(webapp.RequestHandler):
def post(self):
self.response.out.write("<html><head></head><body>")
self.response.out.write(cgi.escape(self.request.get('nombre')))
self.response.out.write("</body></body>")
def main():
application = webapp.WSGIApplication([('/', Formulario1),
('/procformulario1', ProcFormulario1)],
debug=True)
if __name__ == '__main__':
main()
El programa se inicia al ser verdadera la condicin:

if __name__ == '__main__':
main()
Los mdulos son objetos y todos los mdulos tienen un atributo llamado __name__. El valor del __name__
de un mdulo depende de cmo est usndolo. Si se importa el mdulo, luego la propiedad __name__ es el
nombre del fichero del mdulo, sin el directorio de la ruta ni la extensin del archivo. Pero tambin puede
ejecutar el mdulo directamente como si fuera un programa, en cuyo caso __name__ tendr un valor
especial predefinido __main__.
El if se verifica como verdadero y llama a la funcin main().
En la funcin main debemos crear un objeto de la clase WSGIApplication y pasar como parmetro una lista
con elementos de tipo tupla que asocian una URL y la clase que procesa dicha peticin.
Cuando hacemos referencia a la raiz de nuestro sitio:
http://localhost:8080/
El servidor ejecuta Formulario1 segn la tupla indicada con: ('/', Formulario1)

De forma similar cuando se presiona el botn submit del formulario se llama:
http://localhost:8080/procformulario1
y mediante la asociacin ('/procformulario1', ProcFormulario1) se ejecutar el cdigo de la clase

ProcFormulario.
Todas las pginas de nuestro sitio deben ser mapeadas en la lista:
debug=True)
El segundo parmetro del constructor de la clase WSGIApplication es el modo de ejecucin, normalmente el

parmetro debug lo inicializamos en true mientras estamos depurando nuestra aplicacin, cuando la
finalizamos y la subimos al servidor el parmetro debug le asignamos False.
La clase WSGIApplication se encuentra en el mdulo webapp que se encuentra en el paquete
google.appengine.ext:
La clase Formulario1 hereda de la clase RequestHandler que se encuentra en el paquete webapp. Para
generar la pgina solo debemos reescribir el mtodo get que ser el que genere la pgina web. Para generar
el contenido de la pgina llamamos al mtodo write. La clase RequestHandler contiene un atributo llamado
response y este un atributo out que es el que contiene el mtodo write, es decir cada vez que queremos
imprimir en la pgina debemos disponer el siguiente cdigo:
self.response.out.write("Hola Mundo")
Si se trata de generar un bloque grande de HTML podemos utilizar la caracterstica de Python de definir un
String de varias lneas encerrndolas entre triple comillas:
<html>
<head></head>
<body>
<form method="post" action="procformulario1">
Ingrese su nombre:<input type="text" name="nombre" size="20"><br>
<input type="submit" value="Ok">
</form>
</body>
""")
Como vemos no es necesario escapar con el caracter '\' las comillas dobles cuando usamos triple comillas.
Podemos llamar tantas veces al mtodo write como se necesite, todos los string se almacenan en un archivo
de memoria que es el que se enviar al navegador que hizo la peticin.
Una vez que la pgina que contiene el formulario se muestra en el navegador el operador ingresa el nombre
y al presionar el botn submit el navegador procede a enviar el dato ingresado al servidor.
En la propiedad action del formulario hemos indicado quien procesar el dato en el servidor:
action="\procformulario1\"
Recordemos que tenemos mapeada dicha url :

debug=True)
Es decir que la clase ProcFormulario1 recibe el dato. Esta clase tambin hereda de RequestHandler pero
debe redefinir el mtodo post. Luego procedemos de forma similar a la otra clase para crear una pgina en
forma dinmica llamando al mtodo write, con la salvedad que para recuperar el dato cargado en el
formulario procedemos a llamar al mtodo get del objeto request que contiene la clase:
def post(self):
self.response.out.write(cgi.escape(self.request.get('nombre')))
Formulario HTML - control radio (App Engine)

Realizaremos una aplicacin que muestre un formulario con dos controles de tipo text, luego dos controles
de tipo radio que indiquen si queremos sumar o restar los valores ingresados en los controles text.
import cgi
def get(self):
<html>
<head></head>
<body>
<form action="procformulario1" method="post">
Ingrese primer valor:
<input type="text" name="valor1">
<br>
Ingrese segundo valor:
<br>
<input type="radio" name="radio1" value="suma">sumar
<br>
<input type="radio" name="radio1" value="resta">restar
<br>
<input type="submit" value="operar">
</form>
</body>
</html>
""")
def post(self):
v1=int(self.request.get('valor1'))
operacion=self.request.get('radio1')
if operacion=="suma":
resultado=v1+v2
else:
resultado=v1-v2
self.response.out.write("El resultado de la " + operacion + " es " +
str(resultado))
def main():
debug=True)
if __name__ == '__main__':
main()
En la pgina principal del sitio asociamos la clase que despliega el formulario HTML:
('/', Formulario1)
Luego la clase que procesa los datos ingresados en el formulario es ProcFormulario1, en esta primero
rescatamos los dos valores ingresados en los controles text y procedemos a convertilos a entero:
Rescatamos la propiedad value del control radio seleccionado:

operacion=self.request.get('radio1')
Y mediante un if verificamos si tenemos que sumar o restar los contenidos de los text:
if operacion=="suma":
resultado=v1+v2
else:
resultado=v1-v2
Por ltimo procedemos a imprimir el resultado de la operacin:

self.response.out.write("El resultado de la " + operacion + " es " +
str(resultado))
Formulario HTML - control select (App Engine)

Veamos el control HTML de tipo select. Este tipo de control el funcionamiento es similar al de un conjunto
de controles de tipo radio.
Confeccionaremos el mismo problemas del concepto anterior es decir cargar dos nmeros y posteriormente
mediante un control de tipo select seleccionar si queremos sumarlos o restarlos (solo una de estas
operaciones se puede elegir)
La sintaxis del control de tipo select es:
<select name="operacion">
<option value="suma">Sumar</option>
<option value="resta">Restar</option>
</select>
Es importante notar que la sintaxis es bastante distinta a los controles de tipo text y radio.
El elemento select tiene definido la propiedad name mediante la cual rescataremos el valor seleccionado en
el servidor.
El elemento select contiene un conjunto de elementos option. Cada elemento option tiene definido la
propiedad value. El que quede seleccionado el control select rescata su propiedad value.
Luego el programa en Python utilizando Google App Engine:
import cgi
def get(self):
<html>
<head></head>
<body>
<br>
<br>
<select name="operacion">
</select>
<br>
</form>
</body>
</html>
""")
def post(self):
op=self.request.get('operacion')
if op=="suma":
resultado=v1+v2
else:
resultado=v1-v2
self.response.out.write("El resultado de la " + op + " es " + str(resultado))
def main():
debug=True)
if __name__ == '__main__':
main()
De forma similar como venimos trabajando en una clase desplegamos el formulario HTML (Formulario1) y
otra clase procesa el contenido del formulario (ProcFormulario1).
En la pgina que procesamos los datos del formulario rescatamos los valores de los controles text y los
convertimos a entero:
Seguidamente rescatamos la propiedad name de la opcin seleccionada del control select:

op=self.request.get('operacion')
Mediante un if verificamos si tenemos que sumar o restar:

if op=="suma":
resultado=v1+v2
else:
resultado=v1-v2
Por ltimo mostramos el resultado:

self.response.out.write("El resultado de la " + op + " es " + str(resultado))
Formulario HTML - control select con seleccin mltiple (App

Engine)
Veamos una variante del control select la cual permite seleccionar varias opciones de su contenido. Para esto
debemos agregar la propiedad multiple cuando lo definimos:
<select name="operacion" multiple>
Con este simple cambio podemos seleccionar ms de un elemento del interior del control select.
Confeccionaremos el mismo problema anterior, solo que ahora podremos seleccionar las dos operaciones en
forma simultanea:
import cgi
def get(self):
<html>
<head></head>
<body>
<br>
<br>
<select name="operacion" multiple>
</select>
<br>
</form>
</body>
</html>
""")
def post(self):
operaciones=self.request.get_all('operacion')
for op in operaciones:
if op=="suma":
resultado=v1+v2
self.response.out.write("El resultado de la " + op + " es " + str(resultado) +
"<br>")
if op=="resta":
resultado=v1-v2
"<br>")
def main():
debug=True)
if __name__ == '__main__':
main()
Para recuperar la lista de valores seleccionados del control select debemos llamar al mtodo get_all del
objeto request en lugar de get:
operaciones=self.request.get_all('operacion')
Luego mediante una estructura repetitiva recorremos la lista de valores devuelto y comparamos con los
valores posibles:
for op in operaciones:
if op=="suma":
resultado=v1+v2
"<br>")
if op=="resta":
resultado=v1-v2
"<br>")
Formulario HTML - control checkbox (App Engine)

Otra forma de hacer selecciones mltiples es utilizar un conjunto de controles de tipo checkbox. Cada
control de tipo checkbox es independiente.
Resolvamos el problema del concepto anterior empleando dos controles de tipo checkbox:
import cgi
def get(self):
<html>
<head></head>
<body>
<br>
<br>
<input type="checkbox" name="check1" value="suma">sumar
<br>
<input type="checkbox" name="check2" value="resta">restar
<br>
</form>
</body>
</html>
""")
def post(self):
su=self.request.get('check1')
if su=="suma":
resultado=v1+v2
self.response.out.write("El resultado de la " + su + " es " + str(resultado) +
"<br>")
re=self.request.get('check2')
if re=="resta":
resultado=v1-v2
self.response.out.write("El resultado de la " + re + " es " + str(resultado) +
"<br>")
def main():
debug=True)
if __name__ == '__main__':
main()
Cada checkbox lo recuperamos en forma independiente:

su=self.request.get('check1')
if su=="suma":
resultado=v1+v2
self.response.out.write("El resultado de la " + su + " es " + str(resultado) +
"<br>")
Si se encuentra seleccionado el mtodo get retorna el valor de la propiedad value del control HTML, en caso
de no estar seleccionado retorna un string vaco.
Formulario HTML - control textarea (App Engine)

Otro control de uso comn es el textarea, a diferencia de un control de tipo "text" nos permite ingresar
muchas lneas de texto.
Confeccionaremos una pgina que solicite el ingreso del nombre de una persona y en un control de tipo
textarea permitiremos ingresar un comentario. En la pgina que procesa los datos mostraremos los datos
cargados en los dos controles:
import cgi
def get(self):
<html>
<head></head>
<body>
Ingrese su nombre:
<input type="text" name="nombre"><br>
Comentarios<br>
<textarea name="comentarios" rows="10" cols="40"></textarea><br>
<input type="submit" value="enviar"><br>
</form>
</body>
</html>
""")
def post(self):
nom=cgi.escape(self.request.get('nombre'))
self.response.out.write("Nombre:"+ nom + "<br>")
com=cgi.escape(self.request.get('comentarios'))
self.response.out.write("Comentarios:"+ com + "<br>")
def main():
debug=True)
if __name__ == '__main__':
main()
La funcin escape del mdulo cgi tiene por objetivo convertir a entidades los caracteres <, > etc., con esto si
se ingresa una marca HTML esta se mostrar y no la interpretar el navegador.
Recuperamos cada dato y lo mostramos en la pgina HTML:
self.response.out.write("Nombre:"+ nom + "<br>")
com=cgi.escape(self.request.get('comentarios'))
self.response.out.write("Comentarios:"+ com + "<br>")
Alta y listado de una base de datos (App Engine)

El almacenamiento de datos utilizando la infraestructura de Google es bastante distinta a las metodologas
de MySql, Oracle, Sql Server etc.
Google utiliza una tecnologa llamada 'Bigtable', bsicamente es un sistema de almacenamiento distribuido
que permite escalar de forma muy sencilla, evitando que por ejemplo las consultas de tablas con millones de
registros se resientan.
Para hacer uso de esta tecnologa debemos importar el paquete db:

from google.appengine.ext import db
Desarrollaremos una aplicacin que permita almacenar el nombre de usuario y su clave. Luego
imprimiremos todos los registros almacenados.
import cgi
def get(self):
<html>
<head></head>
<body>
Ingrese su nombre:
Ingrese su clave:
<input type="password" name="clave"><br>
</form>
</body>
</html>
""")
class TablaUsuarios(db.Model):
nombre=db.StringProperty()
clave=db.StringProperty()
def post(self):
cla=cgi.escape(self.request.get('clave'))
usuario=TablaUsuarios()
usuario.nombre=nom
usuario.clave=cla
usuario.put()
self.response.out.write("<a href=\"listadousuarios\">Listado</a>")
class ListadoUsuarios(webapp.RequestHandler):
def get(self):
usuarios=db.GqlQuery("select * from TablaUsuarios")
for usu in usuarios:
self.response.out.write("Nombre:" + usu.nombre +"<br>")
self.response.out.write("Clave:" + usu.clave +"<br>")
self.response.out.write("<hr>")
self.response.out.write("<a href=\"\\\">Principal</a>")
def main():
('/procformulario1', ProcFormulario1),
('/listadousuarios', ListadoUsuarios)],
debug=True)
if __name__ == '__main__':
main()
Veamos todo lo que debemos agregar:
Debemos importar el paquete db:
Debemos declarar una clase que representa una tabla. Esta clase debe heredar de la clase Model
contenida en el paquete db. Definimos dos atributos de tipo StringProperty. StringProperty es una
clase contenida en el paquete db y que encapsula el manejo de un campo de cadena de caracteres:
class TablaUsuarios(db.Model): nombre=db.StringProperty() clave=db.StringProperty()
Para efectuar el alta de un registro en la tabla:
def post(self):
usuario.nombre=nom
usuario.clave=cla
usuario.put()
self.response.out.write("<a href=\"listadousuarios\">Listado</a>")
Creamos un objeto de la clase Tablausuarios:

Inicializamos los atributos nombre y clave con los datos extraidos del formulario.
usuario.nombre=nom
usuario.clave=cla
Llamamos al mtodo put que confirma los datos previamente cargados:

usuario.put()
Para obtener un listado de todos los registros almacenados:
class ListadoUsuarios(webapp.RequestHandler):
def get(self):
Creamos un objeto de la clase GqlQuery pasando como parmetro al constructor los datos a
recuperar:
Mediante un for recorremos la lista de usuarios y los imprimimos:

Como esta aplicacin requiere tres pginas luego debemos registrarlas cuando creamos un objeto de la clase
WSGIApplication:
def main():
('/listadousuarios', ListadoUsuarios)],
debug=True)
Consulta de datos (App Engine)

Confeccionaremos una aplicacin que nos permita ingresar el nombre de usuario y nos recupere y muestre
su clave. Tener en cuenta los datos cargados en el concepto anterior.
import cgi
def get(self):
<html>
<head></head>
<body>
Ingrese nombre de usuario:
</form>
</body>
</html>
""")
def post(self):
usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
usu=usuario.fetch(1)
if len(usu)>0:
self.response.out.write("Clave:" + usu[0].clave +"<br>")
else:
self.response.out.write("No existe un usuario con dicho nombre<br>")
def main():
],
debug=True)
if __name__ == '__main__':
main()
Creamos un formulario para ingresar el nombre de usuario a buscar:
def get(self):
<html>
<head></head>
<body>
Ingrese nombre de usuario:
</form>
</body>
</html>
""")
El botn submit hace que se ejecute la clase ProcFormulario1:

def post(self):
if len(usu)>0:
self.response.out.write("Clave:" + usu[0].clave +"<br>")
else:
Primero generamos una consulta a la tabla y le pasamos como parmetro en el campo nombre el valor
rescatado del formulario, debemos utilizar los dos puntos y un uno para indicar que dicho espacio ser
remplazado por el segundo parmetro:
La clase GqlQuery tiene un mtodo llamado fetch que retorna todos los registros generados en la consulta.
Al mtodo fetch le pasamos la cantidad de registros que queremos rescatar y por ltimo accedemos a la
primer componente de la lista siempre y cuando la cantidad de elementos sea mayor a cero.
Borrado de datos (App Engine)

Confeccionaremos una aplicacin que nos permita ingresar el nombre de usuario y efecte su borrado..
Tener en cuenta los datos cargados en conceptos anterioriores.
import cgi
def get(self):
<html>
<head></head>
<body>
Ingrese nombre de usuario a borrar:
</form>
</body>
</html>
""")
def post(self):
if len(usu)>0:
usu[0].delete()
self.response.out.write("Se borro el usuario<br>")
else:
def main():
],
debug=True)
if __name__ == '__main__':
main()
Si lo comparamos con la consulta es prcticamente igual con la salvedad donde en lugar de mostrarlo
procedemos a borrarlo:
if len(usu)>0:
usu[0].delete()
self.response.out.write("Se borro el usuario<br>")
else:
El mtodo delete borrar el registro.
Modificacin de datos (App Engine)

Trabajaremos nuevamente con el problema de usuarios. Dispondremos un formulario que solicite la carga
del nombre de un usuario y pasaremos a un segundo formulario donde mostraremos los datos actuales de
dicho usuario. En una tercer pgina procedemos a modificar los datos ingresados.
import cgi
def get(self):
<html>
<head></head>
<body>
<form action="formulario2" method="post">
Ingrese nombre de usuario a modificar:
<input type="submit" value="Buscar"><br>
</form>
</body>
</html>
""")
def post(self):
if len(usu)>0:
<html>
<head></head>
<body>
Nombre actual:
""")
self.response.out.write("<input type=\"text\" name=\"nombre\"
value=\""+usu[0].nombre+"\"><br>")
self.response.out.write("Clave actual:")
self.response.out.write("<input type=\"text\" name=\"clave\"
value=\""+usu[0].clave+"\"><br>")
self.response.out.write("<input type=\"hidden\" name=\"nombreoculto\"
value=\""+usu[0].nombre+"\">")
<input type="submit" value="Modificar"><br>
</form>
</body>
</html>
""")
else:
def post(self):
nomoculto=cgi.escape(self.request.get('nombreoculto'))
usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nomoculto)
if len(usu)>0:
usu[0].nombre=nom
usu[0].clave=cla
usu[0].put()
else:
def main():
('/formulario2', Formulario2),
],
debug=True)
if __name__ == '__main__':
main()
El segundo formulario debemos inicializar los atributos value de los dos controles text para que aparezcan
cargados inicialmente con los datos actuales.
Por otro lado tambin es necesario definir un campo oculto donde almacenar el nombre de usuario actual, ya
que si lo modifica no sabremos cual buscar:
def post(self):
if len(usu)>0:
<html>
<head></head>
<body>
Nombre actual:
""")
</form>
</body>
</html>
""")
else:
La tercer pgina recupera el usuario que ingres en el primer formulario, pero rescatado del campo oculto.
Procedemos seguidamente a modificar los datos rescatados de la tabla y confirmamos los nuevos datos
llamando al mtodo put:
def post(self):
if len(usu)>0:
usu[0].nombre=nom
usu[0].clave=cla
usu[0].put()
else:
Listado, Alta, Baja y Modificacin (App Engine)

Ahora plantearemos todos los conceptos vistos para el manejo de una tabla de datos utilizando el Google
App Engine.
Mostraremos un listado con una tabla con todos los nombres de usuarios y claves, dos hipervnculos uno
para poder borrar el usuario y otro para poder modificar el registro. Por ltimo dispondremos un
hipervnculo para llamar a un formulario de alta de usuario.
import cgi
class Listado(webapp.RequestHandler):
def get(self):
self.response.out.write("<table border=\"1\">")
self.response.out.write("<tr>")
self.response.out.write("<td>Usuario</td><td>Clave</td><td>Borrar</td><td>Modificar&l
t;/td>")
self.response.out.write("</tr>")
self.response.out.write("<td>" + usu.nombre +"</td>")
self.response.out.write("<td>" + usu.clave +"</td>")
self.response.out.write("<td><a href=\"baja?nombre="+usu.nombre+"\">Borra?
</a>"+"</td>")
self.response.out.write("<td><a
href=\"formulariomodificacion?nombre="+usu.nombre+"\">Modifica?</a>"+"</td>")
self.response.out.write("<td colspan=\"4\"><a
href=\"formularioalta\">Alta</a></td>")
self.response.out.write("</table>")
self.response.out.write("</body></html>")
class FormularioAlta(webapp.RequestHandler):
def get(self):
<html>
<head></head>
<body>
<form action="alta" method="post">
Ingrese su nombre:
Ingrese su clave:
<input type="submit" value="Alta"><br>
</form>
</body>
</html>
""")
class Alta(webapp.RequestHandler):
def post(self):
usuario.nombre=nom
usuario.clave=cla
usuario.put()
self.redirect("/")
class Baja(webapp.RequestHandler):
def get(self):
if len(usu)>0:
usu[0].delete()
self.redirect("/")
class FormularioModificacion(webapp.RequestHandler):
def get(self):
if len(usu)>0:
<html>
<head></head>
<body>
<form action="modificacion" method="post">
Nombre actual:
""")
</form>
</body>
</html>
""")
else:
class Modificacion(webapp.RequestHandler):
def post(self):
if len(usu)>0:
usu[0].nombre=nom
usu[0].clave=cla
usu[0].put()
self.redirect("/")
def main():
application = webapp.WSGIApplication([('/', Listado),
('/formularioalta',FormularioAlta ),
('/alta',Alta ),
('/baja', Baja),
('/formulariomodificacion',
FormularioModificacion),
('/modificacion', Modificacion),
],
debug=True)
if __name__ == '__main__':
main()
En la funcin main() debemos inicializar la lista que vincula las URL de las pginas y las clases que se
ejecutan:
def main():
application = webapp.WSGIApplication([('/', Listado),
('/formularioalta',FormularioAlta ),
('/alta',Alta ),
('/baja', Baja),
('/formulariomodificacion',
FormularioModificacion),
('/modificacion', Modificacion),
],
debug=True)
La clase Listado es la que muestra la raiz del sitio y tiene por objetivo crear una tabla HTML con todos los
usuarios almacenados en la TablaUsuarios. Adems de imprimir cada registro disponemos un hipervnculo
pasando como parmetro el nombre de usuario a borrar o modificar:
class Listado(webapp.RequestHandler):
def get(self):
self.response.out.write("<table border=\"1\">")
self.response.out.write("<td>Usuario</td><td>Clave</td><td>Borrar</td><td>Modificar&l
t;/td>")
self.response.out.write("<td>" + usu.nombre +"</td>")
self.response.out.write("<td>" + usu.clave +"</td>")
self.response.out.write("<td><a href=\"baja?nombre="+usu.nombre+"\">Borra?
</a>"+"</td>")
self.response.out.write("<td><a
href=\"formulariomodificacion?nombre="+usu.nombre+"\">Modifica?</a>"+"</td>")
self.response.out.write("<td colspan=\"4\"><a
href=\"formularioalta\">Alta</a></td>")
self.response.out.write("</table>")
self.response.out.write("</body></html>")
La clase FormularioAlta muestra los dos controles text y el botn submit, cuando se presiona dicho botn se
procede a llamar a la URL alta:
class FormularioAlta(webapp.RequestHandler):
def get(self):
<html>
<head></head>
<body>
<form action="alta" method="post">
Ingrese su nombre:
Ingrese su clave:
<input type="submit" value="Alta"><br>
</form>
</body>
</html>
""")
La clase Alta inicializa un objeto de la clase TablaUsuarios, procede a registrar los datos y mediante el
mtodo redirect redirige a la raiz del sitio (es decir la clase Listado):
class Alta(webapp.RequestHandler):
def post(self):
usuario.nombre=nom
usuario.clave=cla
usuario.put()
self.redirect("/")
Cuando se presiona el hipervnculo "Borra?" en el listado se ejecuta la clase Baja y recibe como parmetro
en el hipervnculo el nombre de usuario a borrar. Recuperamos el registro, llamamos al mtodo delete y
redirigimos nuevamente a la pgina de listado:
class Baja(webapp.RequestHandler):
def get(self):
if len(usu)>0:
usu[0].delete()
self.redirect("/")
Cuando se presiona el hipervnculo "Modificacin?" se ejecuta la clase FormularioModificacion, en este

recuperamos el nombre de usuario e inicializamos los controles text y el campo oculto:
class FormularioModificacion(webapp.RequestHandler):
def get(self):
if len(usu)>0:
<html>
<head></head>
<body>
<form action="modificacion" method="post">
Nombre actual:
""")
</form>
</body>
</html>
""")
else:
Cuando se presiona el botn modificacin del formulario anterior se ejecuta la clase Modificacion donde se
procede a modificar el nombre y clave del usuario. Por ltimo se redirige a la raiz del sitio:
class Modificacion(webapp.RequestHandler):
def post(self):
if len(usu)>0:
usu[0].nombre=nom
usu[0].clave=cla
usu[0].put()
self.redirect("/")

Manual Phyton

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Manual Phyton

Hochgeladen von

Copyright:

Verfügbare Formate

Introduccin al Phyton

Aplicaciones de escritorio con interfaces visuales accediendo a componentes escritos en .Net

Aplicaciones para celulares.

Cadena de caracteres (puede estar encerrada entre simples o dobles comillas):

Podemos en la misma lnea de cdigo agregar comentarios:

Confeccionar una pantalla de presentacin. Definir tres lneas de comentarios.

print 'La divisin con resultado float:'

se encuentra fuera de la estructura if.

Es obligatorio luego de la condicin del if disponer los dos puntos

Estructura condicional if anidada

print 'Edad comprendida entre 12 y 18'

Si x1 no es mayor a x2 luego ejecuta la rama del verdadero de la estructura condicional.

Estructura condicional if-elif

Luego con la estructura condicional if/elif:

Estructura repetitiva while

Una funcin se ejecuta cuando se la llama por su nombre:

Es importante notar que primero debemos declarar la funcin y luego llamarla.

Los parmetros de la funcin se indican en la cabecera de la funcin separados por comas.

O podemos enviarle variables previamente inicializadas:

Funciones con retorno de dato

Podemos inclusive mostrar directamente el valor retornado por la funcin:

O utilizarlo en una condicin:

Estructura de datos tipo tupla

Estructura repetitiva for in para recorrer una tupla

El resultado es una tupla con cuatro valores:

En caso de no indicar el primer rango:

Estructura de datos tipo cadena de caracteres (string)

Podemos utilizar las comillas simples o dobles para su inicializacin:

Para conocer el largo de un string podemos utilizar la funcin len:

#Imprimimos el primer caracter

Para concatenar string Python permite utilizar el operador +.

Los operadores relacionales definidos para los string son:

si queremos saber si dos variables tienes en mismo contenido:

Estructura de datos tipo lista

Para acceder a sus elementos lo hacemos indicando un subndice subndice:

Luego empleando el operador *:

El resultado de este algoritmo es:

Podemos borrar elementos de la lista utilizando la funcin del:

Adems podemos utilizar porciones para borrar un conjunto de elementos de la lista:

Tambin podemos aadir elementos a una lista:

Indices negativos en tuplas, listas y string

Si queremos acceder a la ltima componente podemos hacerlo:

Estructura de datos tipo diccionario

La lnea anterior produce como resultado el valor 23.

Luego si imprimimos el diccionario obtenemos como resultado:

{'peras': 50, 'papas': 5}

Formato de cadenas de caracteres (string)

El primer valor indica el largo total a reservar y el segundo la cantidad de decimales.

El resultado por pantalla es:

El resultado de ejecutar el programa es:

Para entenderlo mejor podemos tambin utilizar esta sintaxis:

Cada vuelta del for se almacena en x e y los valores de la tupla a procesar.

Funciones con parmetros por defecto

Cuando llamamos la funcin mostrartitulo podemos hacerlo de diferentes maneras:

En el ejemplo la tercer llamada a la funcin se hace pasando tres parmetros:

Funciones con una cantidad variable de parmetros

Luego la tupla se crea con 7 elementos.

Luego de esto veremos en pantalla el mensaje 'Hola Mundo'

Luego desde la lnea de comandos ejecutamos el modulo2.py:

Y como resultado tenemos en pantalla

Funciones de uso comn (range - type - str - dir)

# '__new__', '__reduce__', '__reduce_ex__', '__repr__',

Funcin de uso comn (help)

# 'new', 'reduce', '__reduce_ex', 'repr__',

Mtodo especial str