Apunte Python PDF

Introduccion a Python
Gonzalo Soriano
gsoriano@f i.uba.ar
30 de junio de 2009
1.
1.1.
Lenguaje interpretado
Diferencias entre un lenguaje interpretado y uno compilado
Las computadoras entienden un solo lenguaje; binario (tambien llamado

lenguaje de m
aquina) por lo que al compilar un programa lo que hacemos es
traducir ese c
odigo que nosotros escribimos en un lenguaje de alto nivel a algo
que ella pueda interpretar.
Las principales ventajas de usar un lenguaje compilado son que:
Independencia del lenguaje: Una vez que compilamos el codigo fuente y
generamos el archivo binario, dejamos de depender del lenguaje en que se
implemento el programa. Si copiamos ese ejecutable a una computadora
que tenga una arquitectura igual a la maquina donde se lo compilo, este
puede correr sin necesidad del compilador.
Velocidad de ejecuci
on: Al traducir el codigo fuente al lenguaje nativo
de la computadora logramos que ella lo entienda directamente y pueda
ejecutarlo con mayor velocidad.
Permite optimizaciones del compilador: El compilador puede usar algoritmos que viendo porciones de nuestro codigo lo optimice mejorando su
velocidad de ejecuci
on.
Como todo, tambien tiene desventajas:
Dependencia de la plataforma: La independencia que logramos del lenguaje es a costa de una gran dependencia de la arquitectura en que se compilo
ese c
odigo fuente. Si nosotros cambiamos, por ejemplo, el sistema operativo vamos a tener que recompilar todo el programa para poder usarlo.
Lentitud en el desarrollo: Cualquier modificacion que se le haga al programa puede llevar a recompilar todo el programa, o por lo menos una gran
parte de el. Si estamos desarrollando un programa de gran envergadura y estamos en una etapa en la que se hacen y prueban modificaciones
constantemente podemos perder mucho tiempo recompilando todo hasta
encontrar la versi
on final.
Una alternativa a usar un lenguaje compilado, es usar un lenguaje interpretado. Las computadoras siguen entendiendo un u
nico lenguaje, pero ahora lo
que se hace es usar un lenguaje compilado para crear un interprete (tambien
conocido como m
aquina virtual ), el cual estara entre nuestro codigo fuente y
la computadora cumpliendo la funcion de todo interprete: traducir solo lo que
necesita de un lenguaje a otro. Aca surge la primer diferencia con un lenguaje
compilado; solo traduce lo que necesita en ese momento. Por este motivo es que
puede ser que una porci
on del codigo nunca sea traducida al lenguaje maquina.
Como contra, al traducir en el momento y no guardar esas traducciones, puede
suceder que una porci
on del c
odigo lo traduzca varias veces.
Las ventajas de un lenguaje interpretado son:
Independencia de la plataforma: Si queremos correr nuestro programa en
otra computadora, no tenemos que preocuparnos de que la plataforma
sea igual a la nuestra. Solo tenemos que asegurarnos que tenga instalado un interprete para esa plataforma. Y si en un futuro se crea una
nueva plataforma totalmente revolucionaria que tenga un interprete de
ese lenguaje nuestro programa no debera modificarse en una sola lnea y
seguir funcionando perfectamente.
Agilidad en el desarrollo: Como no tenemos que compilar el programa
para hacer pruebas (solo tenemos que correrlo sobre el interprete) es mas
r
apido para hacer pruebas y continuar con el desarrollo o buscar el error.
Este tipo de lenguajes tampoco es perfecto y, por supuesto, tambien tiene
desventajas:
Dependencia del lenguaje: Como en los lenguajes compilados la independencia del lenguaje creaba una dependencia de la plataforma; en este caso
pasa lo contrario. La independencia de la plataforma la tenemos porque
todo corre sobre la maquina virtual, por lo que sin interprete, no se puede
correr el programa.
Lentitud en la ejecuci
on: Como toda instruccion tiene que pasar por el
interprete, para que este la traduzca y luego se ejecute es, un poco, mas
lento que los programas compilados.
Algunos ejemplos de lenguajes compilados e interpretados:
Lenguajes compilados
Pascal
C/C++
Fortran
1.2.
Lenguajes interpretados
Python
Java
C#
Caractersticas de Python
Algunas de las caractersticas que podemos encontrar en Python son:

Agilidad en el desarrollo I: Es rapido para probar y continuar desarrollando gracias a que cuenta con un interprete que va ejecutando el codigo
a medida que lo escribimos en el. Es muy comodo para probar peque
nas
porciones de c
odigo.
2
Agilidad en el desarrollo II: rapido para programar la simplicidad del

lenguaje y por las herramientas que contamos.
Muy f
acil de entender lo que hace el programa, ya que el codigo es limpio
y elegante.
Es multiplataforma, por lo que el mismo codigo la mayora de las veces se
puede ejecutar en distintas computadoras y con distintos sistemas operativos sin modificaciones.
Cuenta con una gran cantidad de modulos con muchas funcionalidades
directamente en el standard.
Es un lenguaje fuertemente tipado pero de asignacion dinamica. Se puede
ver esta ventaja en el ordenamiento de un vector de strings, o enteros, es
lo mismo. Importa el algoritmo, no los tipos.
El principal objetivo que persigue este lenguaje es la facilidad, tanto de
lectura, como de dise
no.
1.2.1.
The Zeb of Python
Desde la versi
on 2.1.2 de Python, si tratamos de importar el modulo thisnos
muestra las 19 premisas de Python escritas por Tim Peters.
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases arent special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless youre Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, its a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- lets do more of those!
La traducci
on sera 1 :
1 http://es.wikipedia.org/wiki/Python
1. Bello es mejor que feo.

2. Explcito es mejor que implcito.
3. Simple es mejor que complejo.
4. Complejo es mejor que complicado.
5. Plano es mejor que anidado.
6. Ralo es mejor que denso.
7. La legibilidad cuenta.
8. Los casos especiales no son tan especiales como para quebrantar las reglas.
9. Aunque lo pr
actico gana a la pureza.
10. Los errores nunca deberan dejarse pasar silenciosamente.
11. A menos que hayan sido silenciados explcitamente.
12. Frente a la ambig
uedad, rechaza la tentacion de adivinar.
13. Debera haber una -y preferiblemente solo una- manera obvia de hacerlo.
14. Aunque esa manera puede no ser obvia al principio a menos que usted sea
Holandes
15. Ahora es mejor que nunca.
16. Aunque nunca es a menudo mejor que ya.
17. Si la implementaci
on es difcil de explicar, es una mala idea.
18. Si la implementaci
on es facil de explicar, puede que sea una buena idea.
19. Los espacios de nombres (namespaces) son una gran idea Hagamos mas
de esas cosas!
Si bien todas son buenas practicas de programacion, quiero destacar algunas:
Bello es mejor que feo.
Simple es mejor que complejo.
Complejo es mejor que complicado.
La legibilidad cuenta.
Los casos especiales no son tan especiales como para quebrantar las reglas.
Si la implementaci
on es difcil de explicar, es una mala idea.
2 Me
gusta m
as: Disperso es mejor que denso.
1.3.
Estructura de un programa en Python
La estructura de un programa en Python no es tan estricta como puede serlo

en Pascal o en C/C++, ya que no debe comenzar con ninguna palabra reservada, ni con un procedimiento o funcion en particular. Simplemente con escribir
un par de lneas de c
odigo ya podramos decir que tenemos un programa en
Python.
Lo que es importante destacar es la forma de identificar los distintos bloques de
c
odigo. En Pascal se defina un bloque de codigo usando las palabras reservadas
Begin y End; en C/C++ se define mediante el uso de las llaves ({ y }). Sin embargo, en Python, se utiliza la indentacion; es decir, la cantidad de espacios/tabs
que hay entre el comienzo de la lnea y el primer caracter distinto a ellos.
1.4.
Interprete Python
El interprete de Python es una herramienta muy u

til al momento de desarrollar, ya que se puede ir probando peque
nas porciones del codigo sin necesidad
de hacer todo el programa. Lo u
nico que hay que hacer para usarlo es tenerlo
instalado y correr el comando python en la consola.
Al hacer eso nos va a aparecer un shell que comenzara con >>>, en el cual
podremos escribir c
odigo y automaticamente se ira interpretando.
Cuando usamos una estructura selectiva o de repeticion generalmente vamos a
tener que escribir m
as de una lnea, por lo que el interprete no va a ejecutar ese
c
odigo hasta que se lo indiquemos dejando una lnea en blanco, es decir, con solo
un Enter. Para indicarnos que todava no va a ser interpretado va a cambiar el
prompt >>> por ....
Con los procedimientos y funciones hace algo similar, pero con la diferencia que
ese c
odigo se va a interpretar una vez que lo invoquemos, y no al terminar de
definirlo.
En el siguiente ejemplo vamos a abrir el interprete python.
$ python
Python 2.5.2 (r252:60911, Jan 4 2009, 17:40:26)
Type "help", "copyright", "credits" or "license" for more information.
>>>
Crear una lista de elementos que va a tener tres n
umeros, dos strings y una
sublista de dos enteros.
$ python
Python 2.5.2 (r252:60911, Jan 4 2009, 17:40:26)
>>> lista = [1, 2, "12", "34", [5, 6]]
Imprimir la lista por pantalla
$ python
Python 2.5.2 (r252:60911, Jan 4 2009, 17:40:26)
>>> lista = [1, 2, "12", "34", [5, 6]]
>>> print lista
[1, 2, 12, 34, [5, 6]]
5
Y ahora vamos a multiplicar todos los elementos de la lista por 2.

$ python
Python 2.5.2 (r252:60911, Jan 4 2009, 17:40:26)
>>> lista = [1, 2, "12", "34", [5, 6]]
>>> print lista
[1, 2, 12, 34, [5, 6]]
>>> for elemento in lista:
...
print elemento*2
Ahora tenemos que dejar una lnea en blanco para que el interprete ejecute
nuestro c
odigo.
$ python
Python 2.5.2 (r252:60911, Jan 4 2009, 17:40:26)
>>> lista = [1, 2, "12", "34", [5, 6]]
>>> print lista
[1, 2, 12, 34, [5, 6]]
...
print elemento*2
...
2
4
1212
3434
[5, 6, 5, 6]
>>>
Vemos que al multiplicar un n
umero por 2, nos devuelve el doble del valor
original. Lo mismo hace con el resto de los datos, si multiplicamos una cadena
de caracteres nos repite la misma secuencia de caracteres y los concatena. Para
una lista, crea una lista igual y tambien la concatena a la primera.
Para salir del interprete solo hay que escribir exit(), o en linux apretar Control+
D. Si ahora queremos hacer un programa que haga exactamente lo mismo, podramos crear un archivo llamado ejemplo.py y que su contenido sea:
lista = [1, 2, "12", "34", [5, 6]]

print lista
for elemento in lista:
print elemento*2
Para ejecutarlo tendramos que hacer:
$python ejemplo.py
Y la salida sera:
$python ejemplo.py
[1, 2, 12, 34, [5, 6]]
2
4
1212
3434
[5, 6, 5, 6]
Para leer valores ingresados desde el teclado podemos usar la funcion raw_input,
la cual puede recibir una cadena de caracteres a imprimir, lee el valor ingresado
y lo retorna como un string.
>>> variable = raw_input("Ingrese algo: ")
Ingrese algo: 7540
>>> print variable
7540
>>> variable = raw_input()
40
>>> variable = raw_input()
Esta cadena la guardo en variable
>>> print variable
Esta cadena la guardo en variable
>>>
1.4.1.
Comentarios
Hay dos reglas que no se deben olvidar nunca:

1. Todos los programas tienen errores, y un codigo que se entienda ayuda a
encontrarlos.
2. Todos los programas sufren modificaciones a lo largo de su vida, al menos
todos aquellos que tienen exito.
Por cualquiera de estas razones es conveniente escribir un codigo claro, legible
y ayudarlo con comentarios para facilitar estas tareas. Lo cual no significa que
a partir de ahora vayan a escribir mas lneas de comentarios que de codigo, ya
que tambien hay que saber que escribir.
Al momento de hacer un comentario hay que pensar en cuanta informacion nueva estas aportando, o cuanto mas legible queda el codigo para quien lo tenga
que leer y mantener.
La forma de hacer comentarios en Python es anteponiendo el #, de esa forma, desde ese car
acter hasta el fin de la lnea se obviaran todos los caracteres
al momento de ejecutar el c
odigo. Por ejemplo, si tomamos el codigo anterior:
# Cargo una lista que tiene elementos de distintos tipos.

lista = [1, 2, "12", "34", [5, 6]]
# Imprimo la lista por pantalla.
print lista
7
# A todo elemento de la lista lo multiplico por 2 y lo imprimo.

print elemento*2 # Esto tambi
en es un comentario
# Y esto.
El ejemplo anterior es muy basico, pero tiene dos objetivos:
1. Mostrar como se hace un comentario en Python
2. Mostrar que tipo de comentarios NO se deben hacer.
Los comentarios del ejemplo son los llamados comentarios duplicadores del
c
odigo, ya que lo u
nico que hacen es decir que hace el programa lnea por
lnea sin aportar nada nuevo. Si los comentarios son solo una traduccion del
lenguaje que est
an usando a su lenguaje nativo, dejan de ser u
tiles y para colmo
agregamos algo m
as que hay que mantener. Si el codigo cambia de forma que
los comentarios queden desactualizados (cosa que es muy com
un que pase con
este tipo de comentarios) hay que mantenerlos para que no confundan a quien
lo lee.
Un comentario es u
til cuando indicamos algo que no es evidente. Por ejemplo,
si vemos el siguiente c
odigo es difcil entender lo que hace esa lnea.
mult = mat[1][2]*mat[0][1]*mat[2][0]-mat[2][2]*mat[0][1]*mat[1][0]+ \
mat[1][1]*mat[0][0]*mat[2][2]+mat[0][2]*mat[1][0]*mat[2][1]- \
mat[0][2]*mat[1][1]*mat[2][0]-mat[1][2]*mat[2][1]*mat[0][0]
Sin embargo, si a esa lnea le agregamos un comentario, podemos darnos cuenta
f
acilmente lo que hace.
# Calculo el determinante de una matriz de 3x3.
mult = mat[1][2]*mat[0][1]*mat[2][0]-mat[2][2]*mat[0][1]*mat[1][0]+ \
mat[1][1]*mat[0][0]*mat[2][2]+mat[0][2]*mat[1][0]*mat[2][1]- \
mat[0][2]*mat[1][1]*mat[2][0]-mat[1][2]*mat[2][1]*mat[0][0]
2.
2.1.
Tipos de datos y como manipularlos

Tipos soportados
Python es un lenguaje fuertemente tipado, pero a la vez tiene la caracterstica de tipado din
amico. Es de fuertemente tipado ya que no se permite
usar una variable de un tipo determinado como si fuera de otro, por ejemplo,
no se le puede sumar un string a un entero o flotante. Y es tipado dinamico ya
que una misma variable, a lo largo de su existencia, puede ser de distintos tipos.
Por ejemplo, podemos tener una variable del tipo string, y en la lnea siguiente,
a esa variable asignarle un n
umero.
Si bien se le puede asignar a una variable valores de distinto tipo, es conveniente
respetar el tipo que se le asigna en una primer instancia y usar siempre ese.
Algunos de los tipos soportados son:
Tipo: Booleano (bool). Solo puede tomar los valores T rue y F alse.
Ejemplo:
>>> boolean = True

>>> boolean = False
>>> print True and False
False
>>> print True or False
True
>>> print not True
False
>>> print not False
True
>>> type(boolean)
<type bool>
Funciones disponibles:
>>> dir(True)
[__abs__, __add__, __and__, __class__, __cmp__, __coerce__,
__delattr__, __div__, __divmod__, __doc__, __float__, __floordiv__,
__getattribute__, __getnewargs__, __hash__, __hex__, __index__,
__init__, __int__, __invert__, __long__, __lshift__, __mod__,
__mul__, __neg__, __new__, __nonzero__, __oct__, __or__, __pos__,
__pow__, __radd__, __rand__, __rdiv__, __rdivmod__, __reduce__,
__reduce_ex__, __repr__, __rfloordiv__, __rlshift__, __rmod__,
__rmul__, __ror__, __rpow__, __rrshift__, __rshift__, __rsub__,
__rtruediv__, __rxor__, __setattr__, __str__, __sub__, __truediv__,
__xor__]
Tipo: Enteros corto (int)
Ejemplo:
>>> entero = 5
>>> type(entero)
<type int>
>>> dir(5)
__xor__]
Tipo: Entero largo (long). Se le agrega una L al final para diferenciarlo de
los enteros cortos.
Ejemplo:
>>> entero = 5L
>>> type(entero)
<type long>
>>> dir(5L)
__xor__]
Tipo: Complejo (complex)
Ejemplo:
>>> complejo = 3 + 5j
>>> complejo += 1 - 2j
>>> print complejo
(4+3j)
>>> complejo *= 1 - 2j
>>> print complejo
(10-5j)
>>> type(complejo)
<type complex>
>>> dir(5+3j)
[__abs__, __add__, __class__, __coerce__, __delattr__, __div__,
__divmod__, __doc__, __eq__, __float__, __floordiv__, __ge__,
__getattribute__, __getnewargs__, __gt__, __hash__, __init__,
__int__, __le__, __long__, __lt__, __mod__, __mul__, __ne__,
__neg__, __new__, __nonzero__, __pos__, __pow__, __radd__,
__rdiv__, __rdivmod__, __reduce__, __reduce_ex__, __repr__,
__rfloordiv__, __rmod__, __rmul__, __rpow__, __rsub__, __rtruediv__,
__setattr__, __str__, __sub__, __truediv__, conjugate, imag, real]
Tipo: Real o flotante (f loat)
Ejemplo:
>>> real = 3.5
>>> type(real)
<type float>
10
>>> dir(3.5)
[__abs__, __add__, __class__, __coerce__, __delattr__, __div__,
__divmod__, __doc__, __eq__, __float__, __floordiv__, __ge__,
__getattribute__, __getformat__, __getnewargs__, __gt__, __hash__,
__init__, __int__, __le__, __long__, __lt__, __mod__, __mul__,
__ne__, __neg__, __new__, __nonzero__, __pos__, __pow__, __radd__,
__rdiv__, __rdivmod__, __reduce__, __reduce_ex__, __repr__,
__rfloordiv__, __rmod__, __rmul__, __rpow__, __rsub__, __rtruediv__,
__setattr__, __setformat__, __str__, __sub__, __truediv__]
Tipo: Cadena de caracteres o String (string)
Ejemplo:
>>> cadena = "esta es una cadena de caracteres"
>>> type(cadena)
<type str>
>>> dir("cadena")
[__add__, __class__, __contains__, __delattr__, __doc__, __eq__,
__ge__, __getattribute__, __getitem__, __getnewargs__, __getslice__,
__gt__, __hash__, __init__, __le__, __len__, __lt__, __mod__,
__mul__, __ne__, __new__, __reduce__, __reduce_ex__, __repr__,
__rmod__, __rmul__, __setattr__, __str__, capitalize, center,
count, decode, encode, endswith, expandtabs, find, index,
isalnum, isalpha, isdigit, islower, isspace, istitle, isupper,
join, ljust, lower, lstrip, partition, replace, rfind, rindex,
rjust, rpartition, rsplit, rstrip, split, splitlines, startswith,
strip, swapcase, title, translate, upper, zfill]
Tipo: Unicode (unicode)
Ejemplo:
>>> cadena = u"esta cadena es de tipo Unicode"
>>> type(cadena)
<type unicode>
>>> dir(u"cadena unicode")
count, decode, encode, endswith, expandtabs, find, index, isalnum,
isalpha, isdecimal, isdigit, islower, isnumeric, isspace, istitle,
isupper, join, ljust, lower, lstrip, partition, replace, rfind,
rindex, rjust, rpartition, rsplit, rstrip, split, splitlines,
startswith, strip, swapcase, title, translate, upper, zfill]
Tipo: Listas (list). Una lista es un vector de elementos que no necesariamente tienen que ser todos del mismo tipo.
Ejemplo:
11
>>> lista = ["Elemento1", "Elemento2", 3, 4, 3.5, u"Unicode String", type(5),

5L, [1, 2, 3]]
>>> type(lista)
<type list>
>>> dir([])
[__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]
Tipo: Tuplas (tuple). Las tuplas son listas inmutables. Es decir, listas que
una vez que se crean, no se pueden modificar.
Ejemplo:
>>> tupla = ("Elemento1", "Elemento2", 3, 4, 3.5, u"Unicode String", type(5),
5L, [1, 2, 3])
>>> type(tupla)
<type tuple>
>>> dir(())
__gt__, __hash__, __init__, __iter__, __le__, __len__, __lt__,
__rmul__, __setattr__, __str__]
Tipo: Diccionarios o Hash0 s (dict). Los diccionarios son estructuras a las
que se le puede asignar una clave y un valor asociado para ella. Esa clave puede
ser de cualquier tipo inmutable, por ejemplo: strings, n
umeros enteros, n
umeros
complejos, n
umeros reales, booleanos y tuplas; pero no listas ni diccionarios ya
que son mutables. Adem
as, no es necesario que todas las claves sean del mismo
tipo.
Ejemplo:
>>> dic = {"clave": "valor", "clave2": 5, 1:3, 2.5:u"otro valor", 3+5j:7L,
"lista": [1,2,3], "dict":{1:2, 2:3, 4:5}, "y ahora una tupla":(1,2,2),
(1,2,3,4):"la clave es una tupla"}
>>> print dic
{2.5: uotro valor, 1: 3, y ahora una tupla: (1, 2, 2), clave2: 5, (3+5j): 7L,
clave: valor, dict: {1: 2, 2: 3, 4: 5}, lista: [1, 2, 3],
(1, 2, 3, 4): la clave es una tupla}
>>> type(dic)
<type dict>
12
>>> dir({})
[__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]
2.1.1.
Conversi
on entre tipos
Para convertir a un n
umero entero se puede usar la funcion int(n), a la
cual se le puede pasar un string o un float, pero no un string que sea un float.
>>> int("12")
12
>>> int(12.3)
12
>>> int(12.7)
12
>>> int("12.3")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 12.3
A esta funci
on tambien se le puede pasar un n
umero como string y una base
(int(n, base)) y convierte ese valor n que se encuentra en la base base a
decimal.
>>> int("10", 2)
2
>>> int("10", 16)
16
>>> int("a", 16)
10
>>> int("af65b", 16)
718427
>>> int("1101", 2)
13
As como pudimos pasar a enteros, tambien podemos pasar a n
umeros
flotantes, pero no tenemos tantas alternativas como antes. Para eso podemos
usar la funci
on f loat(string) que recibe una cadena de caracteres y retorna un
float.
>>> float("12")
12.0
>>> float("12.5723")
12.5723
>>> float("12.7")
12.699999999999999
13
>>> float("1e")
ValueError: invalid literal for float(): 1e
>>>
Tambien se le puede pasar un n
umero entero y lo convierte a flotante:
>>> float(12)
12.0
Para convertir cualquier variable a string podemos usar la funcion str() que
recibe cualquier cosa y hace su mejor intento para convertirla. A diferencia del
resto, esta funci
on nunca va a fallar por no saber como convertir algo. Puede
pasar que con alg
un tipo en particular no nos devuelva el resultado que queremos, pero seguro que nos va a devolver una representacion de lo que le pasamos
en string.
>>> str(5)
5
>>> str(5.4)
5.4
>>> str(5L)
5
>>> str(True)
True
>>> str()
>>> str([1, 2, 3, "uno"])

"[1, 2, 3, uno]"
>>> str([1, 2, 3, "uno", 5.7])
"[1, 2, 3, uno, 5.7000000000000002]"
>>> str((1, 2, 3, "uno", 5.7))
"(1, 2, 3, uno, 5.7000000000000002)"
>>> str({1:"uno", 2:"dos", 3:"tres"})
"{1: uno, 2: dos, 3: tres}"
Una alternativa para insertar valores en un string es, al que en C, indicando en la cadena donde queremos que vaya con un % y despues pasar todos los
par
ametros juntos. Al igual que en C, cuando marcamos la posicion donde queremos que se ingrese alg
un valor, tambien vamos a tener que indicar el tipo de
ese par
ametro; y ellos pueden ser:
14
Indicador
%c
%s
%d o %i o %u 0 %ld 0 %lu
%nd
%.nd
%f
%.nf
%e
%.ne
%g
%x
Tipo:
Solo un caracter.
Cadena de caracteres.
Entero con signo.
Entero con signo ocupando n3 espacios.
Entero con signo ocupando n lugares, completando con 0.
Float o real.
Float o real con solo n decimales.
Float o double, con notacion cientfica.
Float o double, con notacion cientfica, con solo n decimales.
Coma flotante, usando la notacion que requiera menor espacio.
Hexadecimal.
Algunos ejemplos:
>>> print "%c" % s
s
>>> print "%c" % ss
TypeError: %c requires int or char
>>> print "%s" % ss
ss
>>> "%d" % 5
5
>>> "%d" % -5
-5
>>> "%0.2d" % 5
05
>>> "%5d" % 5
5
>>> 5 5 5 5 5 0005 0005
5 5 5 5 5 0005 0005
>>> " %d %i %s %ld %lu %0.4d %4d" % (5, 5, 5, 5, 5, 5, 5)
5 5 5 5 5 0005
5
>>> " %d %i %s %ld %lu %0.4d %4d" % (-5, -5, -5, -5, -5, -5, -5)
-5 -5 -5 -5 -5 -0005
-5
>>> " %d %i %s %ld %lu %0.4d %4d" % (5L, 5L, 5L, 5L, 5L, 5L, 5L)
5 5 5 5 5 0005
5
>>> "%f" % -5
-5.000000
>>> "%.2f" % -5.345
-5.34
>>> "%x" % 123
7b
>>> "%x" % -123
-7b
>>>
Adem
as se pueden mezclar con los siguientes caracteres:
15
Car
acter
\n
\r
\t
\v
\a
\\
\"
\
Descripci
on
Caracter fin de lnea.
Caracter retorno del carro.
Caracter tabulador horizontal.
Caracter tabulador vertical.
Timbre.
Barra invertida.
Comillas.
Apostrofe.
Algunos ejemplos:
>>> print "Algoritmos \r mundo"
mundotmos
>>> print "\a"
>>> print "Hola\tmundo"
Hola mundo
>>> print "Hola\vmundo"
Hola
mundo
>>> print "\\"
\
>>> print "\"
>>> print "\""

"
>>>
Si lo que queremos es juntar todas las palabras de una lista o tupla podemos
usar la funci
on join() de la siguiente forma:
>>> " ".join(("Algoritmos", "y", "Programaci
on", "I"))
Algoritmos y Programaci
on I
>>> "".join(["Algoritmos", "y", "Programaci
on", "I"])
AlgoritmosyProgramaci
onI
>>> " ".join(["Algoritmos", "y", "Programaci
on", "I"])
Algoritmos y Programaci
on I
>>>> "##separador##".join(["Algoritmos", "y", "Programaci
on", "I"])
Algoritmos##separador##y##separador##Programaci
on##separador##I
Y como sucede generalmente, si hay una funcion que va en un sentido existe
otra que va en el sentido inverso. Para parsear un string y obtener una lista
podemos usar la funci
on split. Por defecto el separador es el espacio, por lo que
si le pasamos una oraci
on, nos la separara por palabras.
>>> "Hola mundo".split()
[Hola, mundo]
>>> "Hola mundo".split(",")
[Hola mundo]
>>> "Hola,mundo,".split(",")
16
[Hola, mundo, ]
>>> "Hola,mundo".split(",")
[Hola, mundo]
>>> "Hola mundo
".split()
[Hola, mundo]
Tambien se puede obtener partes de un string indicando su posicion respecto
del inicio o el rango que se desea obtener. Para indicar un rango se pone primero
la posici
on del comienzo, despues un separador que sera el : y por u
ltimo la
posici
on del final. Si no se le pasa la posicion donde comienza el rango, asume
que ese valor es 0; y si la posicion que no se le pasa es la del final, asume que es
hasta el final del string.
>>> "Hola
l
>>> "Hola
la
>>> "Hola
l
>>> "Hola
Hola
>>> "Hola
Hola
>>> "Hola
mundo
mundo"[2]
mundo"[2:4]
mundo"[2:3]
mundo"[0:4]
mundo"[:4]
mundo"[5:]
As como podemos saber la posicion desde el inicio de la cadena de caracteres, tambien podemos indicar la posicion respecto del u
ltimo caracter:
Cadena de caracteres:
Posici
on desde el inicio:
Posici
on desde el final:
H
0
-10
o
1
-9
l
2
-8
a
3
-7
4
-6
m
5
-5
u
6
-4
n
7
-3
d
8
-2
o
9
-1
>>> "Hola mundo"[-1]

o
>>> "Hola mundo"[:-1]
Hola mund
>>> "Hola mundo"[0:4]
Hola
>>> "Hola mundo"[0:-6]
Hola
>>> "Hola mundo"[:-6]
Hola
>>> "Hola mundo"[:4]
Hola
Al igual que con los strings, tambien se le pueden especificar rangos y posiciones para las listas y tuplas.
>>> [3, 5, 1, 7, 15, 11][4]
15
>>> [3, 5, 1, 7, 15, 11][-2]
17
15
>>>
[5,
>>>
[5,
>>>
[5,
>>>
15
>>>
15
>>>
(5,
>>>
(5,
[3, 5, 1,
1]
[3, 5, 1,
1, 7, 15]
[3, 5, 1,
1, 7, 15]
(3, 5, 1,
7, 15, 11][1:3]
7, 15, 11][1:5]
7, 15, 11][1:-1]
7, 15, 11)[4]
(3, 5, 1, 7, 15, 11)[-2]

(3, 5, 1, 7, 15, 11)[1:3]
1)
(3, 5, 1, 7, 15, 11)[1:5]
1, 7, 15)
Una forma muy sencilla de crear una lista con valores consecutivos es usando
la funci
on range([piso], techo); que puede recibir uno o dos parametros. Si se
le pasa un solo par
ametro la funcion devuelve una lista que tendra todos los
n
umeros que sean iguales o mayores a 0 y menores a ese n
umero.
>>> range(3)
[0, 1, 2]
>>> range(-1)
[]
En cambio, si se le pasan dos parametros nos va a devolver una lista que
tendr
a todos los n
umeros que sean iguales o mayores al primero y menores al
segundo.
>>> range(3,7)
[3, 4, 5, 6]
>>> range(-7,-1)
[-7, -6, -5, -4, -3, -2]
Otras funciones u
tiles son las que convierten a listas (list()) o tuplas (tuple()),
y pueden hacerlo desde una lista, una tupla, un string o un diccionario (en este
caso solo obtendremos sus claves).
>>> tuple((1, 2, 3))
(1, 2, 3)
>>> tuple([1,2,3,4])
(1, 2, 3, 4)
>>> tuple("")
()
>>> tuple("Hola mundo.")
(H, o, l, a, , m, u, n, d, o, .)
>>> tuple({1:"uno", 2:"dos", 3:"tres"})
(1, 2, 3)
>>> list((1, 2, 3))
18
[1, 2, 3]
>>> list([1,2,3,4])
[1, 2, 3, 4]
>>> list("Hola mundo.")
[H, o, l, a, , m, u, n, d, o, .]
>>> list({1:"uno", 2:"dos", 3:"tres"})
[1, 2, 3]
Otra forma de obtener una lista con todas las claves de un diccionario es a traves
de la funci
on keys().
>>> {1:"uno", 2:"dos", 3:"tres"}.keys()
[1, 2, 3]
Y si podemos obtener sus claves, tambien podemos obtener los valores asociados
a esas claves. Para esto tendremos que hacer uso de la funcion values()
>>> {1:"uno", 2:"dos", 3:"tres"}.values()
[uno, dos, tres]
2.1.2.
Algunas funciones u
tiles para conocer un poco m
as lo que
usamos.
Otra herramienta de Python muy u

til es la de poder averiguar informacion
sobre lo que usamos en tiempo de ejecucion, aunque tambien para eso podemos
usar el interprete.
Las funciones que vamos a usar son dir(), __doc__ y help().
La funci
on dir() nos da informacion de como manipular ese objeto. Por ejemplo,
si a esta funci
on le pasamos un string nos muestra las funciones que le podemos
aplicar:
>>> dir("string")
count, decode, encode, endswith, expandtabs, find, index,
isalnum, isalpha, isdigit, islower, isspace, istitle, isupper,
join, ljust, lower, lstrip, partition, replace, rfind, rindex,
rjust, rpartition, rsplit, rstrip, split, splitlines, startswith,
strip, swapcase, title, translate, upper, zfill]
La funci
on __doc__ nos da informacion de como usar una funcion en particular.
Para poder conseguir esa informacion primero alguien la tiene que cargar, y
eso se hace escribiendo un comentario que comience y termine con tres comillas
dobles(""").
Por ejemplo, si queremos conocer un poco mas la funcion find() de un string
podramos hacer:
>>> print "string".find.__doc__
S.find(sub [,start [,end]]) -> int
19
Return the lowest index in S where substring sub is found,

such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
Y por u
ltimo, nos queda la funcion help() que al invocarla nos muestra las
funciones para manipular esa variable con una descripcion similar a la que nos
da __doc__
>>> help("string")
Help on module string:
NAME
string - A collection of string operations (most are no longer used).
FILE
/usr/lib/python2.5/string.py
MODULE DOCS
http://www.python.org/doc/current/lib/module-string.html
DESCRIPTION
Warning: most of the code you see here isnt normally used nowadays.
Beginning with Python 1.6, many of these functions are implemented as
methods on the standard string object. They used to be implemented by
a built-in module called strop, but strop is now obsolete itself.
Public module variables:
...
CLASSES
__builtin__.object
Template
class Template(__builtin__.object)
| A string class for supporting $-substitutions.
|
| Methods defined here:
|
| __init__(self, template)
|
| safe_substitute(self, *args, **kws)
|
| substitute(self, *args, **kws)
|
| ...
20
FUNCTIONS
atof(s)
atof(s) -> float
Return the floating point number represented by the string s.
atoi(s, base=10)
atoi(s [,base]) -> int
Return the integer represented by the string s in the given
base, which defaults to 10. The string s must consist of one
or more digits, possibly preceded by a sign. If base is 0, it
is chosen from the leading characters of s, 0 for octal, 0x or
0X for hexadecimal. If base is 16, a preceding 0x or 0X is
accepted.
atol(s, base=10)
atol(s [,base]) -> long
...
find(s, *args)
find(s, sub [,start [,end]]) -> in
Return the lowest index in s where substring sub is found,
such that sub is contained within s[start,end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
...
3.
Estructuras de control
3.1.
Equivalencias de estructuras de control entre Python,

Pascal y C
Al igual que los lenguajes vistos, en Python tambien existen estructuras para
controlar el flujo del c
odigo que se va a ejecutar.
3.1.1.
if
La estructura selectiva if es similar a las vistas, pero a diferencia de Pascal o

C, ya no se marca el bloque de ejecucion con un Begin ... end o unas { ... }
sino que se utiliza la indentaci
on.
Pascal
if (condici
on) then
acci
on;
o
21
if (condici
on) then
begin
acci
on1;
acci
on2;
...
acci
onN;
end;
C
if (condici
on)
acci
on;
o
if (condici
on)
{
acci
on1;
acci
on2;
...
acci
onN;
}
Python
if (condici
on):
acci
on1;
acci
on2;
...
acci
onN;
A diferencia de Pascal y C, en Python no hay diferencia entre poner una sola
acci
on o varias. Adem
as, es obligatorio que las acciones esten todas equidistantes
del comienzo de la lnea y a su vez, que esa distancia sea mayor que la distancia
del inicio al if .
>>> if 3<4:
...
print 1
...
print 2
File "<stdin>",
print 2
^
IndentationError:
>>> if 3<4:
... print 0
File "<stdin>",
print 0
^
IndentationError:
line 3
unindent does not match any outer indentation level
line 2
expected an indented block
Otra diferencia es que para comparar si un valor se encuentra dentro de un

rango se puede hacer de una forma mas sencilla:
Pascal
22
if 3 > 2 and 2 > 1 then

writeln(2 esta entre 3 y 1.);
C
if ((3 > 2) && (2 > 1))
printf("2 esta entre 3 y 1.");
Python
if 3 > 2 and 2 > 1:
print "2 esta entre 3 y 1."
o
if 3 > 2 > 1:
print "2 esta entre 3 y 1."
Como la mayora de los lenguajes, la estructura de seleccion if no solo nos
da la posibilidad de elegir que codigo ejecutar si una condicion es verdadera,
sino que tambien podemos elegir otra porcion de codigo para el caso de que la
condici
on sea falsa.
if a > b:
print "a es mayor que b"
else:
print "b es mayor que a"
Muchas veces si la condici
on es falsa queremos evaluar otras condiciones, por
lo que anidamos este tipo de estructuras poniendo if 0 s en los else0 s.
if mes == 1 and dia <= 31:
print "Fecha OK"
else:
print "Fecha OK"
else:
if mes == 3 and dia < 31:
print "Fecha OK"
...
Para que esto quede mas compacto y, tal vez, mas comprensible, Python nos
da la posibilidad de expresar los else if poniendo simplemente elif :
print "Fecha OK"
elif mes == 2 and dia <= 28:
print "Fecha OK"
elif mes == 3 and dia < 31:
print "Fecha OK"
...
23
Y como si todo esto fuera poco, tambien se puede puede preguntar si un

valor esta en una lista. Con los lenguajes que vimos hasta el momento, para
saber si un elemento pertenece a una lista tenamos que recorrerla toda (o por
lo menos hasta encontrarlo) y fijarnos uno por uno si es lo que buscabamos. En
Python es tan sencillo como preguntar si un elemento esta en una lista:
>>> l = range(-7,-1)
>>> if -2 in l:
...
print "OK"
... else:
...
print "No OK"
...
OK
>>> if 2 in l:
...
print "OK"
... else:
...
print "No OK"
...
No OK
Otra forma de usar el if es como se usa el operador ? en C.
variable = valor1 if condicion else valor2
que le asignar
a el valor1 si la condicion es verdadera y valor2 en caso
contrario.
Por ejemplo:
>>> num =
>>> espar
>>> print
False
>>> num =
>>> espar
>>> print
True
3.1.2.
5
= True if (num % 2 == 0) else False
espar
6
= True if (num % 2 == 0) else False
espar
case
En Python no existe una estructura como seran el case en Pascal o el switch

en C y es porque no se lo usa tanto. Ademas, podemos usar los if anidados para
obtener una estructura a
un m
as potente que un simple discriminador de valores
de una u
nica variable.
3.1.3.
for
Aqu se encuentra la estructura con mayor diferencia entre los 3 lenguajes

vistos en el curso. Por un lado, en Pascal tenemos una estructura que es muy
simple de entender, casi como uno lo dira, pero muy limitada:
for variable_iteracion:=valor_inicial to valor_final do
begin
24
accion1;
acci
on2;
...
accionN;
end;
Por otro lado, en C esta misma estructura es mucho mas potente, pero a
costa de sacrificar un poco de legibilidad:
for (condici
on inicial; condici
on de corte; modificaci
on de la variable)
{
accion1;
accion2;
...
accionN;
}
Por lo que Python adopt
o una tercer forma tratando capturar lo mejor de
cada una de ellas; siempre priorizando la claridad del codigo.
accion1
acci
on2
...
accionN
Por lo que ahora, recorrer todos los elementos de una lista y trabajar con
ellos (por ejemplo imprimir el doble de cada uno) es mas facil.
>>> lista = [1, 2, "12", "34", [5, 6]]
>>> print lista
[1, 2, 12, 34, [5, 6]]
...
print elemento*2
...
2
4
1212
3434
[5, 6, 5, 6]
>>>
Y que pasa si quiero hacer un f or para que simplemente muestre los
primeros 50 enteros no negativos, o los n
umeros del 20 al 30?. La respuesta
esta unas cuantas hojas antes: range().
Para imprimir los primeros 50 n
umeros enteros no negativos:
for i in range(50):
print i
Para imprimir los n
umeros que van del 20 al 30:
25
for i in range(20, 31):

print i
Recordemos que cuando invocamos la funcion range nos devuelve una lista
que tiene todos los valores comprendidos entre el piso (0 si no se lo pasamos) y
el techo (sin incluir este u
ltimo).
List comprehensions:
List comprehensions o la comprension de listas es una estructura para construir
una lista a partir de los elementos de otra. A esos elementos podemos aplicarles
una funci
on que me devuelva alg
un elemento, como multiplicarlos por 2, y/o
filtrarlos con un if para que solo pasen los que cumplen con alguna condicion
en particular.
Por ejemplo, si queremos una lista que tenga el cuadrado de los primeros 16
n
umeros podemos hacer:
>>> lista = [ i**2 for i in range(16)]
>>> print lista
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225]
Ahora supongamos que queremos tener solo el cuadrado de los elementos
impares:
>>> cuad_impares = [ i**2 for i in range(16) if (i%2 == 1)]
>>> print cuad_impares
[1, 9, 25, 49, 81, 121, 169, 225]
Si ahora queremos combinar todas las letras de una lista con las letra de una
segunda lista tambien podramos usar list comprehensions:
>>> l1 = ["a", "b", "c"]
>>> l2 = ["d", "e"]
>>> l = [ e1+e2 for e1 in l1 for e2 in l2]
>>> print l
[ad, ae, bd, be, cd, ce]
Y por u
ltimo, vamos a ver como podramos sumar el cuadrado de todos los
elementos pares de una lista con todos los impares de la misma lista.
>>> l = range(5)
>>> [e1**2 + e2**2 for e1 in l if (e1 % 2 == 0) for e2 in l if (e2 % 2 == 1)]
[1, 9, 5, 13, 17, 25]
Y podemos ver que
(1, 9, 5, 13, 17, 25) = (02 + 12 , 02 + 32 , 22 + 12 , 22 + 12 , 22 + 32 , 42 + 12 , 42 + 32 )
El uso de list comprehensions puede ser muy u
til (no en los ejemplos que
vimos), pero tengan en cuenta que no siempre el codigo queda mas legible y
entendible para el pr
oximo que lo tenga que leer.
26
3.1.4.
while
La estructura que conserva mas similitudes a las vistas en Pascal o C es el

while.
while <condici
on>:
accion1
accion2
...
accionN
Por ejemplo:
>>> print "Ingrese una letra:"
Ingrese una letra:
>>> letra = raw_input()
a
>>> while letra < g:
...
print "La letra es menor a g, ingrese otra:"
...
letra = raw_input()
...
La letra es menor a g, ingrese otra:
a
c
d
z
>>>
Obviamente se pueden usar las mismas condiciones que en un if : Preguntar
si un valor esta en una lista:
>>>
>>>
...
...
...
>>>
[3,
>>>
lista = [3, 2, 5, 7, 1, 9]
while 7 in lista:
# Saco el
ultimo elemento de la lista
lista = lista[:-1]
print lista
2, 5]
O que un valor se encuentre dentro de un rango.

>>> num = int(raw_input("Ingrese un n
umero: "))
Ingrese un n
umero: 5
>>> while 1 < num < 10:
...
num = int(raw_input("Ingrese un n
umero: "))
...
Ingrese un n
umero: 7
Ingrese un n
umero: 4
27
Ingrese un n
umero: 9
Ingrese un n
umero: 2
Ingrese un n
umero: 15
>>>
3.1.5.
repeat
As como no existe un equivalente para el case, tampoco existe otro para el

repeat de Pascal o el do while de C, y, supongo, que los motivos son similares.
4.
4.1.
Programaci
on modular
Procedimientos y funciones
Una de las premisas de Python era que La legibilidad cuenta, y el uso de

procedimientos y funciones ayudan mucho en que un codigo sea legible.
En Python no existen los procedimientos: son todas funciones. Incluso, aunque
nosotros no devolvamos ning
un valor, Python lo hara por nosotros.
La forma de devolver valores es, al igual que en C, usando la palabra reservada
return y el valor a retornar. Y de igual forma, una vez que se ejecuta esa sentencia, no se ejecuta ninguna sentencia mas de esa funcion; sin importar si esta
dentro de un ciclo o todava no hayamos hecho nada.
La definici
on de una funci
on comienza usando la palabra reservada def, y continua dejando un espacio, poniendo el nombre de la funcion4 , los parametros
entre parentesis5 y un dos puntos para terminar la lnea. En las lneas que le
siguen va el c
odigo de la funci
on, que, al igual que para las estructuras de control, la forma en que se indica el bloque de codigo que se tiene que ejecutar es
haciendo uso de la indentaci
on.
def nombre_funcion(param1, param2, ... , paramN):
sentencia1
sentencia2
...
sentenciaN
Donde una de esas sentencias puede tener el return.
Por ejemplo, si ahora queremos hacer la funcion que calcula el factorial de un
n
umero haramos algo por el estilo:
def factorial(n):
for i in range(1,n):
n *= i
return n
Y la forma de usarla es igual que en el resto de los lenguajes, invocamos la
funci
on y el resultado podemos asignarselo a una variable o no.
4 Tiene
que cumplir las mismas reglas para las variables, puede empezar con cualquier letra
y despu
es le puede seguir cualquier car
acter alfanum
erico m
as el .
5 Los par
entesis son obligatorios por m
as que no se pasen par
ametros
y el
28
# Calculo el factorial de 5 y guardo el resultado en la varaible fac_5.

fac_5 = factorial(5)
# Calculo el factorial de 10 sin guardarlo en ninguna variable.
factorial(10)
Y si en lugar de quererlo hacer iterativo lo quisieramos hacer usando recursividad podramos hacer:
def factorial_rec(n):
if n == 0:
return 1
else:
return n*factorial_rec(n-1)
# Esta l
nea ya esta fuera de la funci
on y pertenece al bloque principal.
print factorial_rec(5)
Si ahora quisieramos hacer una funcion que haga la b
usqueda binaria sobre
una lista de enteros podramos hacer:
>>> def binaria(lista_enteros, clave):
...
min = 0
...
max = len(lista_enteros) - 1
...
centro = (min + max) / 2
...
while (lista_enteros[centro] != clave) and (min < max):
...
if lista_enteros[centro] > clave:
...
max = centro -1
...
else:
...
min = centro + 1
...
...
if lista_enteros[centro] == clave:
...
return centro
...
else:
...
return -1
...
>>> binaria([1,2,3,4,5,6,7,8,9], 3)
2
>>> binaria([1,2,3,4,5,6,7,8,9], -5)
-1
Y que pasar
a si ahora queremos hacer una b
usqueda binaria sobre una lista
de strings?.
>>> binaria(["Algoritmos", "Programaci
on", "Y"], "Y")
2
>>> binaria(["Algoritmos", "Programaci
on", "Y"], "esta no esta")
-1
Como se puede ver en los ejemplos anteriores, en ning
un momento pusimos
el tipo de los par
ametros que recibe la funcion por lo que en Python no es necesario copiar funciones solo para cambiar el tipo de uno de ellos.
29
Otra ventaja de Python respecto a Pascal es que, al igual que en C, se pueden

definir valores por defecto para los parametros de una funcion. Es decir, si no se
le pasa un valor, ese par
ametro toma el valor que definio el programador en el
momento que escribi
o el c
odigo. La forma de hacerlo es igual que en C, simplemente hay que ponerle el signo igual seguido del valor por defecto y, en caso de
que la funci
on reciba alg
un otro parametro despues de el tambien debe tener un
valor por defecto. Es decir, los parametros que tienen valores por defecto solo
pueden ocupar las u
ltimas posiciones.
>>> def imprimir_parametros(param1, param2, param3=5, param4="es el cuarto parametro", par

...
print param1, param2, param3, param4, param5
...
>>> imprimir_parametros(1,2,3,4,5)
1 2 3 4 5
>>> imprimir_parametros(1,2,3, 4)
1 2 3 4 False
>>> imprimir_parametros(1,2,3)
1 2 3 es el cuarto parametro False
>>> imprimir_parametros(1,2)
1 2 5 es el cuarto parametro False
>>> imprimir_parametros(1)
TypeError: imprimir_parametros() takes at least 2 arguments (1 given)
>>>
Pero a diferencia de C, en Python no es necesario pasarle todos los parametros hasta el que nosotros que tome un valor distinto del default, podemos indicarlo igualando el nombre del parametro formal a un valor o una variable:
>>> imprimir_parametros(1,2, param5="Este el parametro5")
1 2 5 es el cuarto parametro Este el parametro5
>>>
Incluso, haciendo uso de lo que vimos recien, ni siquiera es necesario pasarle
los par
ametros en orden:
>>> imprimir_parametros(param5=1, param3=2, param1=3, param2=4, param4=5)
3 4 2 5 1
>>>
Cuando comenzamos a hablar de procedimientos y funciones en Python, dijimos que eran todas funciones ya que siempre retornaban alg
un valor, pero
vemos en imprimir_parametros que en ning
un momento se hace un return;
entonces era mentira lo que habamos dicho?. Obviamente, no. Pero entonces,
que devuelve si no tiene un return?. La respuesta es simple; nada. Pero el valor
nada, que en Python se llama None. Este valor es el equivalente al null de C o
nill de Pascal.
30
>>> resultado = imprimir_parametros(1,2,3,4,5)

1 2 3 4 5
>>> print resultado
None
>>>
Tambien podramos hacer un procedimiento que pida el ingreso de alg
un
dato, verifique que se encuentre algunos valores posibles y nos devuelva la opcion
elegida.
>>> def confirmar(msg, opciones_validas=["S", "N"], msg_error="Error!!!"):

...
aux = raw_input(msg)
...
while not aux in opciones_validas:
...
print msg_error
...
aux = raw_input(msg)
...
return aux
...
>>> opcion = confirmar("Seguro que quiere salir?.")
Seguro que quiere salir?.g
Error!!!
Error!!!
Seguro que quiere salir?.s
Error!!!
Seguro que quiere salir?.S
>>> print opcion
S
>>> opcion = confirmar("Seguro que quiere salir?.", msg_error="Error. Las opciones v
alidas
Error. Las opciones v
alidas son: S y N.
Seguro que quiere salir?.s
Error. Las opciones v
alidas son: S y N.
Seguro que quiere salir?.S
>>> print opcion
S
>>> def Menu():
...
print "1. Opci
on 1"
...
print "2. Opci
on 2"
...
print "3. Opci
on 3"
...
confirmar("", ["1", "2", ""3], "Error!!!!, Las opciones v
alidas son: " + str(range
...
>>> Menu()
1. Opci
on 1
2. Opci
on 2
3. Opci
on 3
g
Error!!!!, Las opciones v
alidas son: [1, 2, 3]
s
5
31

1
>>>
Una cosa que puede ser muy u
til es asignarle una funcion a una variable,
ya que tambien existe el tipo de dato funcion. La forma de hacerlo es similar
a como asignamos el valor de otra variable, a la izquierda ponemos la variable,
luego el signo igual y por u
ltimo el nombre de la funcion.
>>> def sumar(num1, num2):

...
return num1+num2
...
>>> print sumar(1,2)
3
>>> type(sumar)
<type function>
>>> variable = sumar
>>> type(variable)
<type function>
>>> print variable(1,2)
3
En el ejemplo anterior podemos ver como al asignarle el nombre de la funci
on a una variable, despues usar esa variable como si llamaramos a la misma
funci
on.
La utilidad de esta funcionalidad no es usar la misma funcion con otro nombre
para confundir a
un m
as a quien tenga que leer el codigo, sino, poder elegir en
tiempo de ejecuci
on que funcion invocar. Por ejemplo, si queremos hacer una
funci
on que haga la b
usqueda binaria en una lista ordenada en forma ascendente
podramos usar la funci
on que escribimos antes:
def binaria(lista_enteros, clave):

min = 0
max = len(lista_enteros) - 1
while (lista_enteros[centro] != clave) and (min < max):
if lista_enteros[centro] > clave:
max = centro -1
else:
min = centro + 1
if lista_enteros[centro] == clave:
return centro
else:
return -1
Ahora supongamos que queremos hacer una b
usqueda sobre una lista que
esta ordenada en forma descendente, entonces ya no nos servira nada de lo que
tenemos y tendramos que copiar el mismo codigo cambiando solamente el signo
32
mayor por un menor y tendramos dos funciones casi iguales que solo diferiran
en un solo car
acter.
Si vamos a tener que usar las dos b
usquedas, sera conveniente que busquemos
una alternativa que encapsule lo que puede cambiar y mantenga el resto sin
modificaciones. Para lograr esto podramos pasarle a la b
usqueda una funcion
que compare el valor central y la clave e indique si el valor que buscamos se
encuentra a la derecha o izquierda.
def mayor(n1, n2):
if n1 > n2:
return True
else:
return False
def menor(n1, n2):
if n1 < n2:
return True
else:
return False
def binaria(cmp, lista, clave):
"""Binaria es una funci
on que busca en una lista la clave pasada. Es un requisito
de la b
usqueda binaria que la lista se encuentre ordenada, pero no si el orden
es ascendente o descendente. Por este motivo es que tambi
en recibe una funci
on
que le indique en que sentido ir.
Si la lista esta ordenada en forma ascendente la funci
on que se le pasa tiene
que ser verdadera cuando el primer valor es mayor que la segundo; y falso en
caso contrario.
Si la lista esta ordenada en forma descendente la funci
que ser verdadera cuando el primer valor es menor que la segundo; y falso en
caso contrario."""
min = 0
max = len(lista) - 1
while (lista[centro] != clave) and (min < max):
if cmp(lista[centro], clave):
max = centro -1
else:
min = centro + 1
if lista[centro] == clave:
return centro
else:
return -1
Entonces, si ahora queremos buscar el n
umero 8 en una lista ordenada ascendentemente, vamos a tener que pasarle el nombre de la funcion que tiene que
usar para comparar, la lista y la clave.
>>> binaria(mayor, [1,2,3,4,5,6,7,8,9], 8)
33
7
Vemos en el ejemplo anterior que nos da bien la posicion ya que nos retorna
la posici
on n
umero 7; pero que pasara si en lugar de pasarle la funcion mayor
le pasamos la de menor?.
>>> binaria(menor, [1,2,3,4,5,6,7,8,9], 8)
-1
Como piensa que la lista esta ordenada en forma descendente y 5 va a ser
menor que 8, en la primer iteracion va a descartar la segunda parte de la lista
y se quedar
a solo con la primera. Por ese motivo es que nunca va a encontrar el
8 en la lista.
Y si ahora buscamos el 123 con la funcion que corresponde?.
>>> binaria(mayor, [1,2,3,4,5,6,7,8,9], 123)
-1
Como deba pasar, si el n
umero no se encuentra en la lista, retorna -1.
Y si ahora buscamos algunos valores en una lista ordenada descendentemente,
pas
andole la funci
on menor?.
>>> binaria(menor, [9,8,7,6,5,4,3,2,1], 8)
1
>>> binaria(menor, [9,8,7,6,5,4,3,2,1], 2)
7
>>> binaria(menor, [9,8,7,6,5,4,3,2,1], 123)
-1
Si los valores est
an en la lista nos informa la posicion en que se encuentran,
pero si no existen nos devuelve un -1.
>>> binaria(mayor, [9,8,7,6,5,4,3,2,1], 2)
-1
Al igual que cuando le pas
abamos una lista ordenada en forma ascendente y
la funci
on menor, si ahora le pasamos una lista ordenada en forma descendente
y la mayor, la b
usqueda no va a poder encontrar la clave por mas que exista.
Ahora que probamos la funci
on vemos que efectivamente hace lo que debera
hacer, pero, que es ese texto que esta entre """ y para que sirve?. Eso es un
comentario de m
as de una lnea llamado docstring y sirve para documentar
las funciones, entre otras cosas.
Pero no es la primera vez que nos topamos con este tipo de documentacion, ya
que antes lo usamos sin saber como estaba hecho o como se llamaba. La forma
de usarlo es a traves de __doc__ y help():
>>> print binaria.__doc__
Binaria es una funci
de la b
en recibe una funci
on
34
que ser verdadera cuando el primer

caso contrario.
Si la lista esta ordenada en forma
que ser verdadera cuando el primer
caso contrario.
>>> help(binaria)
Help on function binaria in module
valor es mayor que la segundo; y falso en

descendente la funci
valor es menor que la segundo; y falso en
__main__:
binaria(cmp, lista, clave)

Binaria es una funci
de la b
en recibe una funci
on
que ser verdadera cuando el primer valor es mayor que la segundo; y falso en
caso contrario.
Si la lista esta ordenada en forma descendente la funci
que ser verdadera cuando el primer valor es menor que la segundo; y falso en
caso contrario.
(END)
4.2.
Uso de m
odulos externos
As como en Pascal usando la clausula U ses y en C el #include, podamos

usar c
odigo que no perteneca al archivo que estabamos codificando, en Python
podemos hacer lo mismo usando la clausula import y poniendo a continuacion
el nombre del m
odulo. Por ejemplo, si queremos importar el modulo datetime 6 :
import datetime
Para usarlo simplemente tenemos que poner el nombre del modulo, un punto
y la funci
on que queramos usar. En este caso, dentro del modulo datetime vamos
a usar la funci
on que se encuentra en date y se llama today().
>>> import datetime
>>> print datetime.date.today()
2009-06-24
>>>
Pero a diferencia de Pascal y C, aca podemos elegir importar una funcion o
algo en particular de ese m
odulo, en lugar de traerlo todo. Para eso tendramos
que poner en primer lugar la clausula from, luego el nombre del modulo y a
continuaci
on la cl
ausula import todo lo que queremos importar separada por
comas.
Por ejemplo, del m
odulo datetime podramos traer las clases7 date y time.
Despues, para usarlo simplemente lo hacemos llamando lo que importamos sin
el nombre del m
odulo.
6 El
m
odulo datetime sirve para el manejo de fechas y horas.
ahora, no presten demasiada atenci
on al hecho de que sean clases, no vamos a cambiar
al paradigma de Programaci
on Orientada a Objetos (POO).
7 Por
35
>>> from datetime import date, time

>>> print date.today()
2009-06-24
>>> print time(1, 23, 32)
01:23:32
>>>
Si nosotros tenemos un archivo llamado ejemplo.py que tiene el siguiente
c
odigo:
def imprimir(param):
print param
def sumar(n1, n2):
return n1+n2
y queremos importarlo a otro archivo y usarlo:
>>> import ejemplo
>>> ejemplo.imprimir("123")
123
>>> print ejemplo.sumar(2,3)
5
>>>
Como dijimos, tambien podemos importar solo una funcion de ese modulo
y usarla como si estuviera en el nuestro.
>>> from ejemplo import sumar
>>> print sumar(4, 5)
9
>>>
5.
Persistencia de datos
Pero todo lo que vimos por el momento se guarda en memoria dinamica, por
lo que al apagar la computadora, o simplemente con cerrar el programa y volver
a abrirlo perdimos todos los datos que nos tenamos. La alternativa para esto
siguen siendo los archivos.
5.1.
Uso de archivos
Para poder usar un archivo vamos a tener que hacer los mismos pasos que
siempre, pero de una forma distinta a la de Pascal e igual a la de C. Vamos a
necesitar una variable de tipo archivo, a la cual le vamos a asignar un archivo
fsico y lo vamos a abrir de una forma particular. Una vez que hayamos hecho
todos estos pasos, y si no hubo problema en ninguno de ellos, vamos a poder
leer y, dependiendo del modo en que lo abrimos, escribir en el.
36
5.1.1.
Apertura de archivos
Al igual que en C, en Python en el mismo momento que abrimos el archivo, se

lo asignamos a uno fsico y elegimos el modo de apertura, que si no le indicamos
nada, tomar
a por defecto el de lectura.
El modo de apertura puede ser cualquier combinacion de:
Modo
r
w
b
+
Descripci
on
Lectura: el archivo debe existir. Similar al
reset de Pascal.
Escritura: no es necesario que el archivo exista, pero si existe lo sobre escribe. Similar al
rewrite de Pascal.
Append: Solo agrega al final y no es necesario
que el archivo exista. Similar al append de Pascal.
Binario.
Permite lectura y escrituras simultaneas.
La primitiva del lenguaje para abrir y asignar un archivo es open, la cual

puede recibir uno o dos par
ametros. El primero es obligatorio, y corresponde
a la ubicaci
on relativa o absoluta del archivo fsico. El segundo paramemetro
indica el modo de apertura y es opcional. Si no se lo pasamos asumira que lo
queremos abrir en modo Lectura.
Supongamos que estamos en un escenario en el que solo tenemos un archivo que
se llama f2.txt y queremos trabajar con los archivos f1.txt, f.txt y f3.txt.
>>> file = open("f1.txt")
IOError: [Errno 2] No such file or directory: f1.txt
>>> file = open("f1.txt", "w")
>>> file2 = open("f2.txt")
>>> file3 = open("f3.txt", "r+w")
IOError: [Errno 2] No such file or directory: f3.txt
>>> file3 = open("f3.txt", "w+r")
>>>
Podemos ver que cuando intentamos abrir en modo lectura el archivo f1.txt
fall
o la aplicaci
on que dice "IOError: No existe el archivo o directorio: f1.txt".
A continuaci
on lo intentamos abrir en modo escritura, que, como dijimos antes,
si no existe lo crea; y eso fue lo que paso. El archivo no exista, pero igual
no tuvimos problemas para abrirlo. Aunque recuerden que si el archivo existe
estaramos borr
andolo completamente.
Una vez que abrimos el archivo f1.txt, vamos a abrir el archivo f2.txt (el
u
nico que exista) de igual forma a como habamos abierto el primero para ver
que el problema estaba en la inexistencia de aquel y no en la forma de abrirlo.
Ahora, intentemos abrir en modo lecto-escritura combinando r y w. Si el
archivo no existe, e intentamos primero abrirlo para lectura y despues para
escritura nos va a tirar un error similar al que habamos tenido al abrir f1.txt,
37
por lo que en este caso es conveniente abrirlo primero para escritura y despues
para lectura.
5.1.2.
Cierre de archivos
Para cerrar un archivo solo tenemos que indicarselo poniendo la variable

seguida de un punto y la primitiva close(). La u
nica restriccion es que la
variable sea de tipo archivo, si cerramos un archivo cerrado este sigue cerrado;
y si cerramos uno abierto, el mismo cambia de estado.
>>> type(file2)
<type file>
>>> file2.close()
>>> file2.close()
>>> file2.close()
>>>
5.1.3.
Lectura de archivos
Supongamos que tenemos un archivo llamado ejemplo.txt y tiene el siguiente texto:

ejemplo.txt
Python was created in the early 1990s by Guido van Rossum at Stichting
Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
as a successor of a language called ABC. Guido remains Pythons
principal author, although it includes many contributions from others.
In 1995, Guido continued his work on Python at the Corporation for
National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
in Reston, Virginia where he released several versions of the
software.
In May 2000, Guido and the Python core development team moved to
BeOpen.com to form the BeOpen PythonLabs team. In October of the same
year, the PythonLabs team moved to Digital Creations (now Zope
Corporation, see http://www.zope.com). In 2001, the Python Software
Foundation (PSF, see http://www.python.org/psf/) was formed, a
non-profit organization created specifically to own Python-related
Intellectual Property. Zope Corporation is a sponsoring member of
the PSF.
All Python releases are Open Source (see http://www.opensource.org for
the Open Source Definition). Historically, most, but not all, Python
releases have also been GPL-compatible.
Para leer un archivo podemos usar la primitiva read(), la cual puede recibir
un par
ametro que indique la cantidad de caracteres a leer. Si no se pasa ese
par
ametro el interprete leer
a todo el archivo y lo retornara.
>>> arch = open("ejemplo.txt")
>>> cadena = arch.read(15)
38
>>> # Imprimo los primeros 15 caracteres del archivo.

... print cadena
Python was crea
>>> # Leo otros 7 caracteres y dejo el cursor del archivo en la siguiente posici
on.
... cadena = arch.read(7)
>>> print cadena
ted in
>>> # Ahora leo el resto del archivo.
... cadena = arch.read()
>>> print cadena
the early 1990s by Guido van Rossum at Stichting
Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
as a successor of a language called ABC. Guido remains Pythons
principal author, although it includes many contributions from others.
In 1995, Guido continued his work on Python at the Corporation for
National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
in Reston, Virginia where he released several versions of the
software.
In May 2000, Guido and the Python core development team moved to
BeOpen.com to form the BeOpen PythonLabs team. In October of the same
year, the PythonLabs team moved to Digital Creations (now Zope
Corporation, see http://www.zope.com). In 2001, the Python Software
Foundation (PSF, see http://www.python.org/psf/) was formed, a
non-profit organization created specifically to own Python-related
Intellectual Property. Zope Corporation is a sponsoring member of
the PSF.
All Python releases are Open Source (see http://www.opensource.org for
the Open Source Definition). Historically, most, but not all, Python
releases have also been GPL-compatible.
>>>
La u
nica condici
on que tenemos para usar este metodo es que el archivo lo
hayamos abierto en modo lectura.
>>> arch2 = open("ejemplo2.txt", "w")
>>> arch2.read()
IOError: [Errno 9] Bad file descriptor
>>> arch3 = open("ejemplo3.txt", "a")
>>> arch3.read()
IOError: [Errno 9] Bad file descriptor
Otra primitiva que podemos usar es readline(), que al igual que read(),
tambien puede recibir un par
ametro que indique la cantidad maxima de bytes
39
a leer. Si no se le pasa ning

un parametro, lee toda la lnea.
>>> linea = arch.readline()
>>> print linea
Python was created in the early 1990s by Guido van Rossum at Stichting
>>> linea = arch.readline(7)
>>> print linea
Mathema
>>>
Pero no es necesario que leamos de a una sola lnea, sino que tambien podemos leer todas las lneas del archivo y guardarlas en una lista haciendo uso de
la primitiva readlines().

>>> lineas = arch.readlines()
>>> print lineas
[Python was created in the early 1990s by Guido van Rossum at Stichting\n, Mathematisch
>>>
Otra forma de leer el archivo por lneas es usando la estructura for y
quedara casi como lo diramos en castellano: "Para cada lnea del archivo:".
Por ejemplo, si queremos imprimir la cantidad de caracteres de cada lnea podramos hacer:
>>> for linea in arch:
...
print len(linea)
...
71
69
65
71
1
67
71
62
10
1
65
71
63
69
63
67
67
9
1
71
40
70
40
>>>
Como se puede ver, en el archivo hay lneas que aparentemente no tienen
ning
un car
acter, y sin embargo, si vemos los n
umeros encontramos lneas con
0 caracteres. Eso se debe a que en todas las lneas podemos encontrar siempre
el car
acter de fin de lnea que se representa por el \n, pero al momento de
imprimirlo no lo vemos.
5.1.4.
Escritura de archivos
Para escribir en un archivo podemos usar las las primitivas write(string)

y writelines(lista_strings), que la primera es para escribir una cadena de
caracteres y la segunda para escribir una lista de strings, uno a continuacion del
otro. Es importante destacar que en ning
un caso se escribe alg
un caracter que
no figure en los strings, como por ejemplo, caracteres de fin de lnea.
El uso de writelines es equivalente a recorrer la lista y hacerle un write a
cada elemento.
Pero el costo de escribir algo en el disco es mucho mayor a escribirlo en memoria
por lo que, al igual que en C, se usa un buffer, que no es mas que una porcion
de memoria para ir guardando en forma temporal los datos y cuando alcanzan
un tama
no considerable se lo manda a escribir al disco. Otra forma de asegurarse que se haga la escritura es usando la primitiva flush, la cual guarda en el
disco el contenido del buffer y lo vaca.
>>> arch2 = open("ejemplo2.txt", "w")
>>> arch2.write("Es la primer cadena")
>>> arch2.write("Seguida de la segunda con un fin de linea\n")
>>> arch2.writelines(["1. Primero de la lista sin fin de l
nea. ", "2. Segundo string con
>>> arch2.flush()
>>> arch2.close()
>>> arch2 = open("ejemplo2.txt", "r+a")
>>> strfile = arch2.read()
>>> print strfile
Es la primer cadenaSeguida de la segunda con un fin de linea
1. Primero de la lista sin fin de l
nea. 2. Segundo string con fin de l
nea.
3. Tercero con/
.
4. y
ultimo.
>>> arch2.write("Esto lo estoy agregando.\n.")
>>> arch2.writelines("Y estas dos l
neas tambi
en con un \\n al final\n de cada una.\n")
>>> arch2.flush()
>>> arch2 = open("ejemplo2.txt", "r")
>>> print arch2.read()
Es la primer cadenaSeguida de la segunda con un fin de linea
1. Primero de la lista sin fin de l
nea. 2. Segundo string con fin de l
nea.
3. Tercero con/
.
4. y
ultimo.Esto lo estoy agregando.
41
.Y estas dos l
neas tambi
en con un \n al final
de cada una.
>>>
Otra forma de asegurarse que se escriba lo que hay en el disco es cerrandolo.
5.1.5.
Moverse en un archivo
Al igual que en los archivos binarios de P ascal, en P ython tambien podemos

saltar a distintas posiciones mediante la primitiva seek(pos) la cual recibe,
como mnimo un par
ametro que indica la posicion a la que nos queremos mover.
Opcionalmente puede recibir un segundo parametro:
Valor del par
ametro
0
1
2
Significado
La posicion es desde el inicio del archivo y
debe ser mayor o igual a 0
La posicion es relativa a la posicion actual;
puede ser positiva o negativa.
La posicion es desde el final del archivo, por
lo que debe ser negativa.

>>> # Voy a la posici
on n
umero 30 del archivo
... arch.seek(30)
>>> print arch.read(7)
y 1990s
>>> # Me muevo 5 posiciones para atr
as desde mi posici
on actual.
... arch.seek(-5,1)
1990s b
>>> # Me muevo a la posici
on n
umero 12, comenzando a contar desde el final.
... arch.seek(-12,2)
compatible
>>>
Y as como podemos movernos en un archivo, tambien podemos averiguar
nuestra posici
on usando la primitiva tell().
>>> arch.seek(30)
>>> arch.tell()
30L
>>> arch.seek(-5,1)
>>> arch.tell()
25L
>>> arch.seek(-12,2)
>>> arch.tell()
1132L
42
compatible
>>> arch.tell()
1142L
>>>
5.1.6.
Interrogando un archivo
Tambien se le pueden hacer distintas como por ejemplo el nombre, el modo en

que esta abierto, si esta cerrado, entre otros. Usar help() para mas informacion.
>>> arch.name
ejemplo.txt
>>> arch.mode
r
>>> arch.closed
False
6.
6.1.
Anexo I
Licencia: GPL
Python posee una licencia de codigo abierto, denominada Python Software

Foundation License, que es compatible con la licencia GPL a partir de la version
2.1.1, e incompatible en ciertas versiones anteriores. Esta licencia no obliga a
liberar el c
odigo fuente al distribuir los archivos binarios8 .
Para m
as informaci
on pueden tipear license() en el interprete Python.
6.2.
Peps (Python Enhancement Proposal o Propuestas

de Mejora de Python)
Las P eps son propuestas para mejorar Python, pero no solo a nivel de nuevas
implementaciones sino tambien de como usarlo.
Por ejemplo, la n
umero 8: http://www.python.org/dev/peps/pep-0008/ propone un estilo de c
odigo a seguir para los que programen en Python, el cual se
puede respetar o no, pero es una convencion para que sea mas legible el codigo
y cometer menos errores.
La n
umero 20 comenta el Zen de Python que vimos antes y la 257 comenta
como hacer buena documentacion para las funciones (docstring).
Por lo que se puede ver en http://www.python.org/dev/peps/, las mismas
est
an divididas en las siguientes categoras:
Meta-PEPs (PEPs about PEPs or Processes)
Other Informational PEPs
Accepted PEPs (accepted; may not be implemented yet)
Open PEPs (under consideration)
8 http://www.python.org/psf/license/
43
Finished PEPs (done, implemented in code repository)

Deferred, Abandoned, Withdrawn, and Rejected PEPs
6.3.
Donde bajarlo
Si usas linux es probable que lo tengas instalado, y en caso de que esto no

sea as, es probable que la herramienta de gestion de paquetes de tu distribucion
lo tenga disponible.
Si no usas linux, tienen que buscar la version para su sistema operativo en
http : //www.python.org/download/.
6.4.
Referencias
http://www.python.org/dev/peps/
http://es.wikipedia.org/wiki/Python
http://www.python.org/
http://diveintopython.org/index.html
http://mundogeek.net/
44
Indice
1. Lenguaje interpretado
1.1. Diferencias entre un lenguaje interpretado y
1.2. Caractersticas de Python . . . . . . . . . .
1.2.1. The Zeb of Python . . . . . . . . . .
1.3. Estructura de un programa en Python . . .
1.4. Interprete Python . . . . . . . . . . . . . .
1.4.1. Comentarios . . . . . . . . . . . . .
uno compilado
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
2
3
5
5
7
2. Tipos de datos y como manipularlos

2.1. Tipos soportados . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.1. Conversi
on entre tipos . . . . . . . . . . . . . . . . . . . .
2.1.2. Algunas funciones u
tiles para conocer un poco mas lo que
usamos. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
3. Estructuras de control
3.1. Equivalencias de estructuras
3.1.1. if . . . . . . . . . . .
3.1.2. case . . . . . . . . .
3.1.3. for . . . . . . . . . .
3.1.4. while . . . . . . . . .
3.1.5. repeat . . . . . . . .
21
21
21
24
24
27
28
de control
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
entre Python, Pascal y C

. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
8
8
13
4. Programaci
on modular
28
4.1. Procedimientos y funciones . . . . . . . . . . . . . . . . . . . . . 28
4.2. Uso de m
odulos externos . . . . . . . . . . . . . . . . . . . . . . . 35
5. Persistencia de datos
5.1. Uso de archivos . . . . . . . . .
5.1.1. Apertura de archivos . .
5.1.2. Cierre de archivos . . .
5.1.3. Lectura de archivos . . .
5.1.4. Escritura de archivos . .
5.1.5. Moverse en un archivo .
5.1.6. Interrogando un archivo
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
36
36
37
38
38
41
42
43
6. Anexo I
43
6.1. Licencia: GPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.2. Peps (Python Enhancement Proposal o Propuestas de Mejora de
Python) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.3. Donde bajarlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.4. Referencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
45

Apunte Python PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apunte Python PDF

Cargado por

Copyright:

Formatos disponibles

Introduccion a Python

Las computadoras entienden un solo lenguaje; binario (tambien llamado

Algunas de las caractersticas que podemos encontrar en Python son:

Agilidad en el desarrollo II: rapido para programar la simplicidad del

The Zeb of Python

1. Bello es mejor que feo.

Estructura de un programa en Python

La estructura de un programa en Python no es tan estricta como puede serlo

El interprete de Python es una herramienta muy u

Y ahora vamos a multiplicar todos los elementos de la lista por 2.

lista = [1, 2, "12", "34", [5, 6]]

Hay dos reglas que no se deben olvidar nunca:

# Cargo una lista que tiene elementos de distintos tipos.

# A todo elemento de la lista lo multiplico por 2 y lo imprimo.

Tipos de datos y como manipularlos

>>> boolean = True

>>> lista = ["Elemento1", "Elemento2", 3, 4, 3.5, u"Unicode String", type(5),

>>> str([1, 2, 3, "uno"])

>>> print "\""

>>> "Hola mundo"[-1]

(3, 5, 1, 7, 15, 11)[-2]

Otra herramienta de Python muy u

Return the lowest index in S where substring sub is found,

Equivalencias de estructuras de control entre Python,

La estructura selectiva if es similar a las vistas, pero a diferencia de Pascal o

unindent does not match any outer indentation level

expected an indented block

Otra diferencia es que para comparar si un valor se encuentra dentro de un

if 3 > 2 and 2 > 1 then

Y como si todo esto fuera poco, tambien se puede puede preguntar si un

En Python no existe una estructura como seran el case en Pascal o el switch

Aqu se encuentra la estructura con mayor diferencia entre los 3 lenguajes

for i in range(20, 31):

La estructura que conserva mas similitudes a las vistas en Pascal o C es el

O que un valor se encuentre dentro de un rango.

As como no existe un equivalente para el case, tampoco existe otro para el

Una de las premisas de Python era que La legibilidad cuenta, y el uso de

# Calculo el factorial de 5 y guardo el resultado en la varaible fac_5.

Otra ventaja de Python respecto a Pascal es que, al igual que en C, se pueden

>>> def imprimir_parametros(param1, param2, param3=5, param4="es el cuarto parametro", par

>>> resultado = imprimir_parametros(1,2,3,4,5)

>>> def confirmar(msg, opciones_validas=["S", "N"], msg_error="Error!!!"):

Error!!!!, Las opciones v

>>> def sumar(num1, num2):

def binaria(lista_enteros, clave):

que ser verdadera cuando el primer

valor es mayor que la segundo; y falso en

binaria(cmp, lista, clave)

As como en Pascal usando la clausula U ses y en C el #include, podamos

>>> from datetime import date, time

Al igual que en C, en Python en el mismo momento que abrimos el archivo, se

La primitiva del lenguaje para abrir y asignar un archivo es open, la cual

Para cerrar un archivo solo tenemos que indicarselo poniendo la variable

Supongamos que tenemos un archivo llamado ejemplo.txt y tiene el siguiente texto:

>>> # Imprimo los primeros 15 caracteres del archivo.

a leer. Si no se le pasa ning

>>> arch = open("ejemplo.txt")

Para escribir en un archivo podemos usar las las primitivas write(string)

Al igual que en los archivos binarios de P ascal, en P ython tambien podemos

>>> arch = open("ejemplo.txt")

Tambien se le pueden hacer distintas como por ejemplo el nombre, el modo en

Python posee una licencia de codigo abierto, denominada Python Software

Peps (Python Enhancement Proposal o Propuestas