Introduccin a Python o

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 (tambin llamado e lenguaje de mquina) por lo que al compilar un programa lo que hacemos es a traducir ese cdigo que nosotros escribimos en un lenguaje de alto nivel a algo o que ella pueda interpretar. Las principales ventajas de usar un lenguaje compilado son que: Independencia del lenguaje: Una vez que compilamos el cdigo fuente y o 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 mquina donde se lo compil, ste a o e puede correr sin necesidad del compilador. Velocidad de ejecucin: Al traducir el cdigo fuente al lenguaje nativo o o 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 cdigo lo optimice mejorando su o velocidad de ejecucin. o Como todo, tambin tiene desventajas: e 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 cdigo fuente. Si nosotros cambiamos, por ejemplo, el sistema operao tivo vamos a tener que recompilar todo el programa para poder usarlo. Lentitud en el desarrollo: Cualquier modicacin que se le haga al prograo ma puede llevar a recompilar todo el programa, o por lo menos una gran parte de l. Si estamos desarrollando un programa de gran envergadue ra y estamos en una etapa en la que se hacen y prueban modicaciones constantemente podemos perder mucho tiempo recompilando todo hasta encontrar la versin nal. o

Una alternativa a usar un lenguaje compilado, es usar un lenguaje interpretado. Las computadoras siguen entendiendo un unico lenguaje, pero ahora lo que se hace es usar un lenguaje compilado para crear un interprete (tambin e conocido como mquina virtual ), el cual estar entre nuestro cdigo fuente y a a o la computadora cumpliendo la funcin de todo interprete: traducir solo lo que o necesita de un lenguaje a otro. Ac surge la primer diferencia con un lenguaje a compilado; solo traduce lo que necesita en ese momento. Por este motivo es que puede ser que una porcin del cdigo nunca sea traducida al lenguaje mquina. o o a Como contra, al traducir en el momento y no guardar esas traducciones, puede suceder que una porcin del cdigo lo traduzca varias veces. o o 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 deber modicarse en una sola l a nea y seguir funcionando perfectamente. Agilidad en el desarrollo: Como no tenemos que compilar el programa para hacer pruebas (solo tenemos que correrlo sobre el intrprete) es ms e a rpido para hacer pruebas y continuar con el desarrollo o buscar el error. a Este tipo de lenguajes tampoco es perfecto y, por supuesto, tambin tiene e 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 ejecucin: Como toda instruccin tiene que pasar por el o o interpret, para que ste la traduzca y luego se ejecute es, un poco, ms e e a lento que los programas compilados. Algunos ejemplos de lenguajes compilados e interpretados: Lenguajes compilados Pascal C/C++ Fortran Lenguajes interpretados Python Java C#

1.2.

Caracter sticas de Python

Algunas de las caracter sticas que podemos encontrar en Python son: Agilidad en el desarrollo I: Es rpido para probar y continuar desarrola lando gracias a que cuenta con un interprete que va ejecutando el cdigo o a medida que lo escribimos en l. Es muy cmodo para probar pequeas e o n porciones de cdigo. o 2

Agilidad en el desarrollo II: rpido para programar la simplicidad del a lenguaje y por las herramientas que contamos. Muy fcil de entender lo que hace el programa, ya que el cdigo es limpio a o y elegante. Es multiplataforma, por lo que el mismo cdigo la mayor de las veces se o a puede ejecutar en distintas computadoras y con distintos sistemas operativos sin modicaciones. Cuenta con una gran cantidad de mdulos con muchas funcionalidades o directamente en el standard. Es un lenguaje fuertemente tipado pero de asignacin dinmica. Se puede o a 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 diseo. n 1.2.1. The Zeb of Python

Desde la versin 2.1.2 de Python, si tratamos de importar el mdulo thisnos o o 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 traduccin ser 1 : o a
1 http://es.wikipedia.org/wiki/Python

1. Bello es mejor que feo. 2. Expl cito es mejor que impl cito. 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 prctico gana a la pureza. a 10. Los errores nunca deber dejarse pasar silenciosamente. an 11. A menos que hayan sido silenciados expl citamente. 12. Frente a la ambigedad, rechaza la tentacin de adivinar. u o 13. Deber haber una -y preferiblemente slo una- manera obvia de hacerlo. a o 14. Aunque esa manera puede no ser obvia al principio a menos que usted sea Holands e 15. Ahora es mejor que nunca. 16. Aunque nunca es a menudo mejor que ya. 17. Si la implementacin es dif de explicar, es una mala idea. o cil 18. Si la implementacin es fcil de explicar, puede que sea una buena idea. o a 19. Los espacios de nombres (namespaces) son una gran idea Hagamos ms a de esas cosas! Si bien todas son buenas prcticas de programacin, quiero destacar algunas: a o 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 implementacin es dif de explicar, es una mala idea. o cil
2 Me

gusta ms: Disperso es mejor que denso. a

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 funcin en particular. Simplemente con escribir o un par de l neas de cdigo ya podr o amos decir que tenemos un programa en Python. Lo que es importante destacar es la forma de identicar los distintos bloques de cdigo. En Pascal se den un bloque de cdigo usando las palabras reservadas o a o Begin y End; en C/C++ se dene mediante el uso de las llaves ({ y }). Sin embargo, en Python, se utiliza la indentacin; es decir, la cantidad de espacios/tabs o que hay entre el comienzo de la l nea y el primer carcter distinto a ellos. a

1.4.

Interprete Python

El interprete de Python es una herramienta muy util al momento de desar rollar, ya que se puede ir probando pequeas porciones del cdigo sin necesidad n o de hacer todo el programa. Lo unico 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 comenzar con >>>, en el cual a podremos escribir cdigo y automticamente se ir interpretando. o a a Cuando usamos una estructura selectiva o de repeticin generalmente vamos a o tener que escribir ms de una l a nea, por lo que el interprete no va a ejecutar ese cdigo hasta que se lo indiquemos dejando una l o nea en blanco, es decir, con solo un Enter. Para indicarnos que todav no va a ser interpretado va a cambiar el a prompt >>> por .... Con los procedimientos y funciones hace algo similar, pero con la diferencia que ese cdigo se va a interpretar una vez que lo invoquemos, y no al terminar de o denirlo. 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 nmeros, dos strings y una u sublista de dos enteros. $ python Python 2.5.2 (r252:60911, Jan 4 2009, 17:40:26) Type "help", "copyright", "credits" or "license" for more information. >>> 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) Type "help", "copyright", "credits" or "license" for more information. >>> 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) Type "help", "copyright", "credits" or "license" for more information. >>> 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 l nea en blanco para que el interprete ejecute nuestro cdigo. o $ python Python 2.5.2 (r252:60911, Jan 4 2009, 17:40:26) Type "help", "copyright", "credits" or "license" for more information. >>> lista = [1, 2, "12", "34", [5, 6]] >>> print lista [1, 2, 12, 34, [5, 6]] >>> for elemento in lista: ... print elemento*2 ... 2 4 1212 3434 [5, 6, 5, 6] >>> Vemos que al multiplicar un nmero por 2, nos devuelve el doble del valor u 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 tambin la concatena a la primera. e 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, podr amos 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 tendr amos que hacer:

$python ejemplo.py Y la salida ser a:

$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 funcin raw_input, o 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 cdigo que se entienda ayuda a o encontrarlos. 2. Todos los programas sufren modicaciones a lo largo de su vida, al menos todos aquellos que tienen xito. e Por cualquiera de estas razones es conveniente escribir un cdigo claro, legible o y ayudarlo con comentarios para facilitar estas tareas. Lo cual no signica que a partir de ahora vayan a escribir ms l a neas de comentarios que de cdigo, ya o que tambin hay que saber que escribir. e Al momento de hacer un comentario hay que pensar en cuanta informacin nueo va estas aportando, o cuanto ms legible queda el cdigo para quien lo tenga a o que leer y mantener. La forma de hacer comentarios en Python es anteponiendo el #, de esa forma, desde ese carcter hasta el n de la l a nea se obviaran todos los caracteres al momento de ejecutar el cdigo. Por ejemplo, si tomamos el cdigo anterior: o o

# 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. for elemento in lista: print elemento*2 # Esto tambin es un comentario e # Y esto. El ejemplo anterior es muy bsico, pero tiene dos objetivos: a 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 cdigo, ya que lo unico que hacen es decir que hace el programa l o nea por l nea sin aportar nada nuevo. Si los comentarios son solo una traduccin del o lenguaje que estn usando a su lenguaje nativo, dejan de ser utiles y para colmo a agregamos algo ms que hay que mantener. Si el cdigo cambia de forma que a o los comentarios queden desactualizados (cosa que es muy comn que pase con u este tipo de comentarios) hay que mantenerlos para que no confundan a quien lo lee. Un comentario es util cuando indicamos algo que no es evidente. Por ejemplo, si vemos el siguiente cdigo es dif entender lo que hace esa l o cil nea. 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 l nea le agregamos un comentario, podemos darnos cuenta fcilmente lo que hace. a # 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 caracter stica de tipado dinmico. Es de fuertemente tipado ya que no se permite a 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 otante. Y es tipado dinmico ya a 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 l nea siguiente, a esa variable asignarle un nmero. u 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> Funciones disponibles: >>> dir(5) [__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: Entero largo (long). Se le agrega una L al nal para diferenciarlo de los enteros cortos. Ejemplo:

>>> entero = 5L >>> type(entero) <type long> Funciones disponibles: >>> dir(5L) [__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: Complejo (complex) Ejemplo: >>> complejo = 3 + 5j >>> complejo += 1 - 2j >>> print complejo (4+3j) >>> complejo *= 1 - 2j >>> print complejo (10-5j) >>> type(complejo) <type complex> Funciones disponibles: >>> 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 otante (f loat) Ejemplo: >>> real = 3.5 >>> type(real) <type float> Funciones disponibles:

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> Funciones disponibles: >>> 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> Funciones disponibles: >>> dir(u"cadena unicode") [__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, 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> Funciones disponibles: >>> 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 modicar. Ejemplo: >>> tupla = ("Elemento1", "Elemento2", 3, 4, 3.5, u"Unicode String", type(5), 5L, [1, 2, 3]) >>> type(tupla) <type tuple> Funciones disponibles: >>> dir(()) [__add__, __class__, __contains__, __delattr__, __doc__, __eq__, __ge__, __getattribute__, __getitem__, __getnewargs__, __getslice__, __gt__, __hash__, __init__, __iter__, __le__, __len__, __lt__, __mul__, __ne__, __new__, __reduce__, __reduce_ex__, __repr__, __rmul__, __setattr__, __str__] Tipo: Diccionarios o Hash 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, nmeros enteros, nmeros u u complejos, nmeros reales, booleanos y tuplas; pero no listas ni diccionarios ya u que son mutables. Adems, no es necesario que todas las claves sean del mismo a 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> Funciones disponibles: 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. Conversin entre tipos o

Para convertir a un n mero entero se puede usar la funcin int(n), a la u o cual se le puede pasar un string o un oat, pero no un string que sea un oat. >>> 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 funcin tambin se le puede pasar un nmero como string y una base o e u (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, tambin podemos pasar a n meros e u otantes, pero no tenemos tantas alternativas como antes. Para eso podemos usar la funcin f loat(string) que recibe una cadena de caracteres y retorna un o oat. >>> float("12") 12.0 >>> float("12.5723") 12.5723 >>> float("12.7") 12.699999999999999 13

>>> float("1e") Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: invalid literal for float(): 1e >>> Tambin se le puede pasar un nmero entero y lo convierte a otante: e u >>> float(12) 12.0 Para convertir cualquier variable a string podemos usar la funcin str() que o recibe cualquier cosa y hace su mejor intento para convertirla. A diferencia del resto, esta funcin nunca va a fallar por no saber cmo convertir algo. Puede o o pasar que con algn tipo en particular no nos devuelva el resultado que quereu mos, pero seguro que nos va a devolver una representacin de lo que le pasamos o 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 despus pasar todos los e parmetros juntos. Al igual que en C, cuando marcamos la posicin donde quera o emos que se ingrese algn valor, tambin vamos a tener que indicar el tipo de u e ese parmetro; y ellos pueden ser: a

14

Indicador %c %s %d o %i o %u 0 %ld 0 %lu %nd %.nd %f %.nf %e %.ne %g %x Algunos ejemplos:

Tipo: Solo un carcter. a 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 notacin cient o ca. Float o double, con notacin cient o ca, con solo n decimales. Coma otante, usando la notacin que requiera menor espacio. o Hexadecimal.

>>> print "%c" % s s >>> print "%c" % ss Traceback (most recent call last): File "<stdin>", line 1, in <module> 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 >>> Adems se pueden mezclar con los siguientes caracteres: a 15

Carcter a \n \r \t \v \a \\ \" \ Algunos ejemplos:

Descripcin o Carcter n de l a nea. Carcter retorno del carro. a Carcter tabulador horizontal. a Carcter tabulador vertical. a Timbre. Barra invertida. Comillas. Apstrofe. o

>>> 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 funcin join() de la siguiente forma: o >>> " ".join(("Algoritmos", "y", "Programacin", "I")) o Algoritmos y Programacin I o >>> "".join(["Algoritmos", "y", "Programacin", "I"]) o AlgoritmosyProgramacinI o >>> " ".join(["Algoritmos", "y", "Programacin", "I"]) o Algoritmos y Programacin I o >>>> "##separador##".join(["Algoritmos", "y", "Programacin", "I"]) o Algoritmos##separador##y##separador##Programacin##separador##I o Y como sucede generalmente, si hay una funcin que va en un sentido existe o otra que va en el sentido inverso. Para parsear un string y obtener una lista podemos usar la funcin split. Por defecto el separador es el espacio, por lo que o si le pasamos una oracin, nos la separar por palabras. o a >>> "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] Tambin se puede obtener partes de un string indicando su posicin respecto e o del inicio o el rango que se desea obtener. Para indicar un rango se pone primero la posicin del comienzo, despus un separador que ser el : y por ultimo la o e a posicin del nal. Si no se le pasa la posicin donde comienza el rango, asume o o que ese valor es 0; y si la posicin que no se le pasa es la del nal, asume que es o hasta el nal 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 posicin desde el inicio de la cadena de carac o teres, tambin podemos indicar la posicin respecto del ultimo carcter: e o a Cadena de caracteres: Posicin desde el inicio: o Posicin desde el nal: o >>> "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, tambin se le pueden especicar rangos y posie ciones para las listas y tuplas. >>> [3, 5, 1, 7, 15, 11][4] 15 >>> [3, 5, 1, 7, 15, 11][-2] 17 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

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 funcin range([piso], techo); que puede recibir uno o dos parmetros. Si se o a le pasa un solo parmetro la funcin devuelve una lista que tendr todos los a o a nmeros que sean iguales o mayores a 0 y menores a ese nmero. u u

>>> range(3) [0, 1, 2] >>> range(-1) [] En cambio, si se le pasan dos parmetros nos va a devolver una lista que a tendr todos los nmeros que sean iguales o mayores al primero y menores al a u segundo. >>> range(3,7) [3, 4, 5, 6] >>> range(-7,-1) [-7, -6, -5, -4, -3, -2] Otras funciones utiles 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 travs e de la funcin keys(). o >>> {1:"uno", 2:"dos", 3:"tres"}.keys() [1, 2, 3] Y si podemos obtener sus claves, tambin podemos obtener los valores asociados e a esas claves. Para esto tendremos que hacer uso de la funcin values() o >>> {1:"uno", 2:"dos", 3:"tres"}.values() [uno, dos, tres] 2.1.2. Algunas funciones utiles para conocer un poco ms lo que a usamos.

Otra herramienta de Python muy util es la de poder averiguar informacin o sobre lo que usamos en tiempo de ejecucin, aunque tambin para eso podemos o e usar el interprete. Las funciones que vamos a usar son dir(), __doc__ y help(). La funcin dir() nos da informacin de como manipular ese objeto. Por ejemplo, o o si a esta funcin le pasamos un string nos muestra las funciones que le podemos o aplicar: >>> dir("string") [__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] La funcin __doc__ nos da informacin de como usar una funcin en particular. o o o Para poder conseguir esa informacin primero alguien la tiene que cargar, y o eso se hace escribiendo un comentario que comience y termine con tres comillas dobles("""). Por ejemplo, si queremos conocer un poco ms la funcin find() de un string a o podr amos 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 ultimo, nos queda la funcin help() que al invocarla nos muestra las o funciones para manipular esa variable con una descripcin similar a la que nos o 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.
3.1.

Estructuras de control
Equivalencias de estructuras de control entre Python, Pascal y C

Al igual que los lenguajes vistos, en Python tambin existen estructuras para e controlar el ujo del cdigo que se va a ejecutar. o 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 ejecucin con un Begin ... end o unas { ... } o sino que se utiliza la indentacin. o Pascal if (condicin) then o accin; o o 21

if (condicin) then o begin accin1; o accin2; o ... accinN; o end; C if (condicin) o accin; o o if (condicin) o { accin1; o accin2; o ... accinN; o } Python if (condicin): o accin1; o accin2; o ... accinN; o A diferencia de Pascal y C, en Python no hay diferencia entre poner una sola accin o varias. Adems, es obligatorio que las acciones estn todas equidistantes o a e del comienzo de la l nea 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 ms sencilla: a 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 mayor de los lenguajes, la estructura de seleccin if no solo nos a o da la posibilidad de elegir que cdigo ejecutar si una condicin es verdadera, o o sino que tambin podemos elegir otra porcin de cdigo para el caso de que la e o o condicin sea falsa. o if a > b: print "a es mayor que b" else: print "b es mayor que a" Muchas veces si la condicin es falsa queremos evaluar otras condiciones, por o lo que anidamos este tipo de estructuras poniendo if s en los else s. if mes == 1 and dia <= 31: print "Fecha OK" else: if mes == 2 and dia <= 28: print "Fecha OK" else: if mes == 3 and dia < 31: print "Fecha OK" ... Para que esto quede mas compacto y, tal vez, ms comprensible, Python nos a da la posibilidad de expresar los else if poniendo simplemente elif : if mes == 1 and dia <= 31: 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, tambin se puede puede preguntar si un e valor esta en una lista. Con los lenguajes que vimos hasta el momento, para saber si un elemento pertenece a una lista ten amos que recorrerla toda (o por lo menos hasta encontrarlo) y jarnos uno por uno si es lo que buscbamos. En a 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 el valor1 si la condicion es verdadera y valor2 en caso a 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 ser el case en Pascal o el switch an en C y es porque no se lo usa tanto. Adems, podemos usar los if anidados para a obtener una estructura an ms potente que un simple discriminador de valores u a de una unica 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 dir pero muy limitada: a, for variable_iteracion:=valor_inicial to valor_final do begin 24

accion1; accin2; o ... accionN; end; Por otro lado, en C esta misma estructura es mucho ms potente, pero a a costa de sacricar un poco de legibilidad: for (condicin inicial; condicin de corte; modificacin de la variable) o o o { accion1; accion2; ... accionN; } Por lo que Python adopt una tercer forma tratando capturar lo mejor de o cada una de ellas; siempre priorizando la claridad del cdigo. o for elemento in lista: accion1 accin2 o ... 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 ms fcil. a a >>> lista = [1, 2, "12", "34", [5, 6]] >>> print lista [1, 2, 12, 34, [5, 6]] >>> for elemento in lista: ... print elemento*2 ... 2 4 1212 3434 [5, 6, 5, 6] >>> Y qu pasa si quiero hacer un f or para que simplemente muestre los e primeros 50 enteros no negativos, o los nmeros del 20 al 30?. La respuesta u esta unas cuantas hojas antes: range(). Para imprimir los primeros 50 nmeros enteros no negativos: u for i in range(50): print i Para imprimir los nmeros que van del 20 al 30: u

25

for i in range(20, 31): print i Recordemos que cuando invocamos la funcin range nos devuelve una lista o que tiene todos los valores comprendidos entre el piso (0 si no se lo pasamos) y el techo (sin incluir este ultimo). List comprehensions: List comprehensions o la comprensin de listas es una estructura para construir o una lista a partir de los elementos de otra. A esos elementos podemos aplicarles una funcin que me devuelva algn elemento, como multiplicarlos por 2, y/o o u ltrarlos con un if para que solo pasen los que cumplen con alguna condicin o en particular. Por ejemplo, si queremos una lista que tenga el cuadrado de los primeros 16 nmeros podemos hacer: u >>> 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 tambin podr e amos 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 ultimo, vamos a ver como podr amos 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 util (no en los ejemplos que vimos), pero tengan en cuenta que no siempre el cdigo queda ms legible y o a entendible para el prximo que lo tenga que leer. o

26

3.1.4.

while

La estructura que conserva ms similitudes a las vistas en Pascal o C es el a while. while <condicin>: o 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 La letra es menor a g, ingrese otra: c La letra es menor a g, ingrese otra: d La letra es menor a g, ingrese otra: 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 ltimo elemento de la lista u lista = lista[:-1] print lista 2, 5]

O que un valor se encuentre dentro de un rango. >>> num = int(raw_input("Ingrese un nmero: ")) u Ingrese un nmero: 5 u >>> while 1 < num < 10: ... num = int(raw_input("Ingrese un nmero: ")) u ... Ingrese un nmero: 7 u Ingrese un nmero: 4 u 27

Ingrese un nmero: 9 u Ingrese un nmero: 2 u Ingrese un nmero: 15 u >>> 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.

Programacin modular o
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 cdigo sea legible. o En Python no existen los procedimientos: son todas funciones. Incluso, aunque nosotros no devolvamos ningn valor, Python lo har por nosotros. u a 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 ms de esa funcin; sin importar si esta a o dentro de un ciclo o todav no hayamos hecho nada. a La denicin de una funcin comienza usando la palabra reservada def, y cono o tinua dejando un espacio, poniendo el nombre de la funcin4 , los parmetros o a entre parntesis5 y un dos puntos para terminar la l e nea. En las l neas que le siguen va el cdigo de la funcin, que, al igual que para las estructuras de cono o trol, la forma en que se indica el bloque de cdigo que se tiene que ejecutar es o haciendo uso de la indentacin. o 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 funcin que calcula el factorial de un o nmero har u amos 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 funcin y el resultado podemos asignrselo a una variable o no. o a
4 Tiene

y el

que cumplir las mismas reglas para las variables, puede empezar con cualquier letra y despus le puede seguir cualquier carcter alfanumrico ms el . e a e a 5 Los parntesis son obligatorios por ms que no se pasen parmetros e a a

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 podr amos hacer: def factorial_rec(n): if n == 0: return 1 else: return n*factorial_rec(n-1) # Esta lnea ya esta fuera de la funcin y pertenece al bloque principal. o print factorial_rec(5) Si ahora quisieramos hacer una funcin que haga la bsqueda binaria sobre o u una lista de enteros podr amos 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 ... centro = (min + max) / 2 ... 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 si ahora queremos hacer una bsqueda binaria sobre una lista a u de strings?. >>> binaria(["Algoritmos", "Programacin", "Y"], "Y") o 2 >>> binaria(["Algoritmos", "Programacin", "Y"], "esta no esta") o -1 Como se puede ver en los ejemplos anteriores, en ningn momento pusimos u el tipo de los parmetros que recibe la funcin por lo que en Python no es necea o sario 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 denir valores por defecto para los parmetros de una funcin. Es decir, si no se a o le pasa un valor, ese parmetro toma el valor que deni el programador en el a o momento que escribi el cdigo. La forma de hacerlo es igual que en C, simpleo o mente hay que ponerle el signo igual seguido del valor por defecto y, en caso de que la funcin reciba algn otro parmetro despus de l tambin debe tener un o u a e e e valor por defecto. Es decir, los parmetros que tienen valores por defecto solo a pueden ocupar las ultimas 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) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: imprimir_parametros() takes at least 2 arguments (1 given) >>> Pero a diferencia de C, en Python no es necesario pasarle todos los parmeta ros hasta el que nosotros que tome un valor distinto del default, podemos indicarlo igualando el nombre del parmetro formal a un valor o una variable: a >>> 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 recin, ni siquiera es necesario pasarle e los parmetros en orden: a >>> 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 algn valor, pero u vemos en imprimir_parametros que en ningn momento se hace un return; u entonces era mentira lo que hab amos dicho?. Obviamente, no. Pero entonces, qu devuelve si no tiene un return?. La respuesta es simple; nada. Pero el valor e 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 >>> Tambin podr e amos hacer un procedimiento que pida el ingreso de algn u dato, verique que se encuentre algunos valores posibles y nos devuelva la opcin o 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!!! Seguro que quiere salir?.g 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 vlidas a Seguro que quiere salir?.g Error. Las opciones vlidas son: S y N. a Seguro que quiere salir?.s Error. Las opciones vlidas son: S y N. a Seguro que quiere salir?.S >>> print opcion S >>> def Menu(): ... print "1. Opcin 1" o ... print "2. Opcin 2" o ... print "3. Opcin 3" o ... confirmar("", ["1", "2", ""3], "Error!!!!, Las opciones vlidas son: " + str(range a ... >>> Menu() 1. Opcin 1 o 2. Opcin 2 o 3. Opcin 3 o g Error!!!!, Las opciones vlidas son: [1, 2, 3] a s Error!!!!, Las opciones vlidas son: [1, 2, 3] a 5 31

Error!!!!, Las opciones vlidas son: [1, 2, 3] a 1 >>> Una cosa que puede ser muy util es asignarle una funcin a una variable, o ya que tambin existe el tipo de dato funcin. La forma de hacerlo es similar e o a como asignamos el valor de otra variable, a la izquierda ponemos la variable, luego el signo igual y por ultimo el nombre de la funcin. o

>>> 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 funcin a una variable, despus usar esa variable como si llamramos a la misma o e a funcin. o La utilidad de esta funcionalidad no es usar la misma funcin con otro nombre o para confundir an ms a quien tenga que leer el cdigo, sino, poder elegir en u a o tiempo de ejecucin que funcin invocar. Por ejemplo, si queremos hacer una o o funcin que haga la bsqueda binaria en una lista ordenada en forma ascendente o u podr amos usar la funcin que escribimos antes: o

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 centro = (min + max) / 2 if lista_enteros[centro] == clave: return centro else: return -1 Ahora supongamos que queremos hacer una bsqueda sobre una lista que u esta ordenada en forma descendente, entonces ya no nos servir nada de lo que a tenemos y tendr amos que copiar el mismo cdigo cambiando solamente el signo o 32

mayor por un menor y tendr amos dos funciones casi iguales que solo diferir an en un solo carcter. a Si vamos a tener que usar las dos bsquedas, ser conveniente que busquemos u a una alternativa que encapsule lo que puede cambiar y mantenga el resto sin modicaciones. Para lograr esto podr amos pasarle a la bsqueda una funcin u o 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 funcin que busca en una lista la clave pasada. Es un requisito o de la bsqueda binaria que la lista se encuentre ordenada, pero no si el orden u es ascendente o descendente. Por este motivo es que tambin recibe una funcin e o que le indique en que sentido ir. Si la lista esta ordenada en forma ascendente la funcin que se le pasa tiene o 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 funcin que se le pasa tiene o que ser verdadera cuando el primer valor es menor que la segundo; y falso en caso contrario.""" min = 0 max = len(lista) - 1 centro = (min + max) / 2 while (lista[centro] != clave) and (min < max): if cmp(lista[centro], clave): max = centro -1 else: min = centro + 1 centro = (min + max) / 2 if lista[centro] == clave: return centro else: return -1 Entonces, si ahora queremos buscar el nmero 8 en una lista ordenada asu cendentemente, vamos a tener que pasarle el nombre de la funcin que tiene que o 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 posicin ya que nos retorna o la posicin nmero 7; pero que pasar si en lugar de pasarle la funcin mayor o u a o 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 iteracin va a descartar la segunda parte de la lista o y se quedar solo con la primera. Por ese motivo es que nunca va a encontrar el a 8 en la lista. Y si ahora buscamos el 123 con la funcin que corresponde?. o >>> binaria(mayor, [1,2,3,4,5,6,7,8,9], 123) -1 Como deb pasar, si el nmero no se encuentra en la lista, retorna -1. a u Y si ahora buscamos algunos valores en una lista ordenada descendentemente, pasndole la funcin menor?. a o >>> 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 estn en la lista nos informa la posicin en que se encuentran, a o 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 pasbamos una lista ordenada en forma ascendente y a la funcin menor, si ahora le pasamos una lista ordenada en forma descendente o y la mayor, la bsqueda no va a poder encontrar la clave por ms que exista. u a Ahora que probamos la funcin vemos que efectivamente hace lo que deber o a hacer, pero, qu es ese texto que esta entre """ y para qu sirve?. Eso es un e e comentario de ms de una l a nea llamado docstring y sirve para documentar las funciones, entre otras cosas. Pero no es la primera vez que nos topamos con este tipo de documentacin, ya o que antes lo usamos sin saber como estaba hecho o como se llamaba. La forma de usarlo es a travs de __doc__ y help(): e >>> print binaria.__doc__ Binaria es una funcin que busca en una lista la clave pasada. Es un requisito o de la bsqueda binaria que la lista se encuentre ordenada, pero no si el orden u es ascendente o descendente. Por este motivo es que tambin recibe una funcin e o que le indique en que sentido ir. Si la lista esta ordenada en forma ascendente la funcin que se le pasa tiene o 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 funcin que se le pasa tiene o valor es menor que la segundo; y falso en

__main__:

binaria(cmp, lista, clave) Binaria es una funcin que busca en una lista la clave pasada. Es un requisito o de la bsqueda binaria que la lista se encuentre ordenada, pero no si el orden u es ascendente o descendente. Por este motivo es que tambin recibe una funcin e o que le indique en que sentido ir. Si la lista esta ordenada en forma ascendente la funcin que se le pasa tiene o 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 funcin que se le pasa tiene o que ser verdadera cuando el primer valor es menor que la segundo; y falso en caso contrario. (END)

4.2.

Uso de mdulos externos o

As como en Pascal usando la clusula U ses y en C el #include, pod a amos usar cdigo que no pertenec al archivo que estbamos codicando, en Python o a a podemos hacer lo mismo usando la clusula import y poniendo a continuacin a o el nombre del mdulo. Por ejemplo, si queremos importar el mdulo datetime 6 : o o import datetime Para usarlo simplemente tenemos que poner el nombre del mdulo, un punto o y la funcin que queramos usar. En este caso, dentro del mdulo datetime vamos o o a usar la funcin que se encuentra en date y se llama today(). o >>> import datetime >>> print datetime.date.today() 2009-06-24 >>> Pero a diferencia de Pascal y C, ac podemos elegir importar una funcin o a o algo en particular de ese mdulo, en lugar de traerlo todo. Para eso tendr o amos que poner en primer lugar la clusula from, luego el nombre del mdulo y a a o continuacin la clusula import todo lo que queremos importar separada por o a comas. Por ejemplo, del mdulo datetime podr o amos traer las clases7 date y time. Despus, para usarlo simplemente lo hacemos llamando lo que importamos sin e el nombre del mdulo. o
mdulo datetime sirve para el manejo de fechas y horas. o ahora, no presten demasiada atencin al hecho de que sean clases, no vamos a cambiar o al paradigma de Programacin Orientada a Objetos (POO). o
7 Por 6 El

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 cdigo: o 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, tambin podemos importar solo una funcin de ese mdulo e o o 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 dinmica, por a lo que al apagar la computadora, o simplemente con cerrar el programa y volver a abrirlo perdimos todos los datos que nos ten amos. 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 f sico 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 l. e

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 f sico y elegimos el modo de apertura, que si no le indicamos nada, tomar por defecto el de lectura. a El modo de apertura puede ser cualquier combinacin de: o Modo r w Descripcin o 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 nal y no es necesario que el archivo exista. Similar al append de Pascal. Binario. Permite lectura y escrituras simultaneas.

b +

La primitiva del lenguaje para abrir y asignar un archivo es open, la cual puede recibir uno o dos parmetros. El primero es obligatorio, y corresponde a a la ubicacin relativa o absoluta del archivo f o sico. El segundo parmemetro a indica el modo de apertura y es opcional. Si no se lo pasamos asumir que lo a 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") Traceback (most recent call last): File "<stdin>", line 1, in <module> 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") Traceback (most recent call last): File "<stdin>", line 1, in <module> 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 la aplicacin que dice "IOError: No existe el archivo o directorio: f1.txt". o o A continuacin lo intentamos abrir en modo escritura, que, como dijimos antes, o si no existe lo crea; y eso fue lo que pas. El archivo no exist pero igual o a, no tuvimos problemas para abrirlo. Aunque recuerden que si el archivo existe estar amos borrndolo completamente. a Una vez que abrimos el archivo f1.txt, vamos a abrir el archivo f2.txt (el unico que exist de igual forma a como hab a) amos 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 despus para e escritura nos va a tirar un error similar al que hab amos tenido al abrir f1.txt, 37

por lo que en este caso es conveniente abrirlo primero para escritura y despus e para lectura. 5.1.2. Cierre de archivos

Para cerrar un archivo solo tenemos que indicrselo poniendo la variable a seguida de un punto y la primitiva close(). La unica restriccin es que la o 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 parmetro que indique la cantidad de caracteres a leer. Si no se pasa ese a parmetro el interprete leer todo el archivo y lo retornar. a a a >>> 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 posicin. o ... 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 unica condicin que tenemos para usar este mtodo es que el archivo lo o e hayamos abierto en modo lectura. >>> arch2 = open("ejemplo2.txt", "w") >>> arch2.read() Traceback (most recent call last): File "<stdin>", line 1, in <module> IOError: [Errno 9] Bad file descriptor >>> arch3 = open("ejemplo3.txt", "a") >>> arch3.read() Traceback (most recent call last): File "<stdin>", line 1, in <module> IOError: [Errno 9] Bad file descriptor Otra primitiva que podemos usar es readline(), que al igual que read(), tambin puede recibir un parmetro que indique la cantidad mxima de bytes e a a 39

a leer. Si no se le pasa ningn parmetro, lee toda la l u a nea. >>> arch = open("ejemplo.txt") >>> 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 l nea, sino que tambin podee mos leer todas las l neas del archivo y guardarlas en una lista haciendo uso de la primitiva readlines().

>>> arch = open("ejemplo.txt") >>> 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 l neas es usando la estructura for y quedar casi como lo dir a amos en castellano: "Para cada l nea del archivo:". Por ejemplo, si queremos imprimir la cantidad de caracteres de cada l nea podr amos hacer: >>> arch = open("ejemplo.txt") >>> 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 l neas que aparentemente no tienen ningn carcter, y sin embargo, si vemos los nmeros encontramos l u a u neas con 0 caracteres. Eso se debe a que en todas las l neas podemos encontrar siempre el carcter de n de l a nea 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 continuacin del o otro. Es importante destacar que en ningn caso se escribe algn carcter que u u a no gure en los strings, como por ejemplo, caracteres de n de l nea. 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 ms que una porcin a o de memoria para ir guardando en forma temporal los datos y cuando alcanzan un tamao considerable se lo manda a escribir al disco. Otra forma de asegun rarse que se haga la escritura es usando la primitiva flush, la cual guarda en el disco el contenido del buer y lo vac a. >>> 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 lnea. ", "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 lnea. 2. Segundo string con fin de lnea. 3. Tercero con/ . 4. y ltimo. u >>> arch2.write("Esto lo estoy agregando.\n.") >>> arch2.writelines("Y estas dos lneas tambin con un \\n al final\n de cada una.\n") e >>> 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 lnea. 2. Segundo string con fin de lnea. 3. Tercero con/ . 4. y ltimo.Esto lo estoy agregando. u 41

.Y estas dos lneas tambin con un \n al final e de cada una. >>> Otra forma de asegurarse que se escriba lo que hay en el disco es cerrndolo. a 5.1.5. Moverse en un archivo

Al igual que en los archivos binarios de P ascal, en P ython tambin podemos e saltar a distintas posiciones mediante la primitiva seek(pos) la cual recibe, como m nimo un parmetro que indica la posicin a la que nos queremos mover. a o Opcionalmente puede recibir un segundo parmetro: a Valor del parmetro a 0 1 2 Signicado La posicin es desde el inicio del archivo y o debe ser mayor o igual a 0 La posicin es relativa a la posicin actual; o o puede ser positiva o negativa. La posicin es desde el nal del archivo, por o lo que debe ser negativa.

>>> arch = open("ejemplo.txt") >>> # Voy a la posicin nmero 30 del archivo o u ... arch.seek(30) >>> print arch.read(7) y 1990s >>> # Me muevo 5 posiciones para atrs desde mi posicin actual. a o ... arch.seek(-5,1) >>> print arch.read(7) 1990s b >>> # Me muevo a la posicin nmero 12, comenzando a contar desde el final. o u ... arch.seek(-12,2) >>> print arch.read(10) compatible >>> Y as como podemos movernos en un archivo, tambin podemos averiguar e nuestra posicin usando la primitiva tell(). o

>>> arch.seek(30) >>> arch.tell() 30L >>> arch.seek(-5,1) >>> arch.tell() 25L >>> arch.seek(-12,2) >>> arch.tell() 1132L >>> print arch.read(10) 42

compatible >>> arch.tell() 1142L >>> 5.1.6. Interrogando un archivo

Tambin se le pueden hacer distintas como por ejemplo el nombre, el modo en e que esta abierto, si esta cerrado, entre otros. Usar help() para ms informacin. a o

>>> arch.name ejemplo.txt >>> arch.mode r >>> arch.closed False

6.
6.1.

Anexo I
Licencia: GPL

Python posee una licencia de cdigo abierto, denominada Python Software o Foundation License, que es compatible con la licencia GPL a partir de la versin o 2.1.1, e incompatible en ciertas versiones anteriores. Esta licencia no obliga a liberar el cdigo fuente al distribuir los archivos binarios8 . o Para ms informacin pueden tipear license() en el interprete Python. a o

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 tambin de como usarlo. e Por ejemplo, la nmero 8: http://www.python.org/dev/peps/pep-0008/ prou pone un estilo de cdigo a seguir para los que programen en Python, el cual se o puede respetar o no, pero es una convencin para que sea ms legible el cdigo o a o y cometer menos errores. La nmero 20 comenta el Zen de Python que vimos antes y la 257 comenta u como hacer buena documentacin para las funciones (docstring). o Por lo que se puede ver en http://www.python.org/dev/peps/, las mismas estn divididas en las siguientes categor a as: 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 gestin de paquetes de tu distribucin , o o lo tenga disponible. Si no usas linux, tienen que buscar la versin para su sistema operativo en o 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. Caracter sticas 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 8 8 13 19 21 21 21 24 24 27 28

2. Tipos de datos y como manipularlos 2.1. Tipos soportados . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.1. Conversin entre tipos . . . . . . . . . . . . . . . . . . . . o 2.1.2. Algunas funciones utiles para conocer un poco ms lo que a usamos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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 . . . . . . . .

de control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

entre Python, Pascal y C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4. Programacin modular o 28 4.1. Procedimientos y funciones . . . . . . . . . . . . . . . . . . . . . 28 4.2. Uso de mdulos externos . . . . . . . . . . . . . . . . . . . . . . . 35 o 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