Introduccion a Python

Gonzalo Sorianogsoriano@fi.uba.ar

30 de junio de 2009

1. Lenguaje interpretado

1.1. Diferencias entre un lenguaje interpretado y uno com-pilado

Las computadoras entienden un solo lenguaje; binario (tambien llamadolenguaje de maquina) por lo que al compilar un programa lo que hacemos estraducir ese codigo que nosotros escribimos en un lenguaje de alto nivel a algoque ella pueda interpretar.Las principales ventajas de usar un lenguaje compilado son que:

Independencia del lenguaje: Una vez que compilamos el codigo fuente ygeneramos el archivo binario, dejamos de depender del lenguaje en que seimplemento el programa. Si copiamos ese ejecutable a una computadoraque tenga una arquitectura igual a la maquina donde se lo compilo, estepuede correr sin necesidad del compilador.

Velocidad de ejecucion: Al traducir el codigo fuente al lenguaje nativode la computadora logramos que ella lo entienda directamente y puedaejecutarlo con mayor velocidad.

Permite optimizaciones del compilador: El compilador puede usar algo-ritmos que viendo porciones de nuestro codigo lo optimice mejorando suvelocidad de ejecucion.

Como todo, tambien tiene desventajas:

Dependencia de la plataforma: La independencia que logramos del lengua-je es a costa de una gran dependencia de la arquitectura en que se compiloese codigo fuente. Si nosotros cambiamos, por ejemplo, el sistema opera-tivo vamos a tener que recompilar todo el programa para poder usarlo.

Lentitud en el desarrollo: Cualquier modificacion que se le haga al progra-ma puede llevar a recompilar todo el programa, o por lo menos una granparte de el. Si estamos desarrollando un programa de gran envergadu-ra y estamos en una etapa en la que se hacen y prueban modificacionesconstantemente podemos perder mucho tiempo recompilando todo hastaencontrar la version final.

1

Una alternativa a usar un lenguaje compilado, es usar un lenguaje interpre-tado. Las computadoras siguen entendiendo un unico lenguaje, pero ahora loque se hace es usar un lenguaje compilado para crear un interprete (tambienconocido como maquina virtual), el cual estara entre nuestro codigo fuente yla computadora cumpliendo la funcion de todo interprete: traducir solo lo quenecesita de un lenguaje a otro. Aca surge la primer diferencia con un lenguajecompilado; solo traduce lo que necesita en ese momento. Por este motivo es quepuede ser que una porcion del codigo nunca sea traducida al lenguaje maquina.Como contra, al traducir en el momento y no guardar esas traducciones, puedesuceder que una porcion del codigo lo traduzca varias veces.Las ventajas de un lenguaje interpretado son:

Independencia de la plataforma: Si queremos correr nuestro programa enotra computadora, no tenemos que preocuparnos de que la plataformasea igual a la nuestra. Solo tenemos que asegurarnos que tenga instal-ado un interprete para esa plataforma. Y si en un futuro se crea unanueva plataforma totalmente revolucionaria que tenga un interprete deese lenguaje nuestro programa no deberıa modificarse en una sola lınea yseguir funcionando perfectamente.

Agilidad en el desarrollo: Como no tenemos que compilar el programapara hacer pruebas (solo tenemos que correrlo sobre el interprete) es masrapido para hacer pruebas y continuar con el desarrollo o buscar el error.

Este tipo de lenguajes tampoco es perfecto y, por supuesto, tambien tienedesventajas:

Dependencia del lenguaje: Como en los lenguajes compilados la indepen-dencia del lenguaje creaba una dependencia de la plataforma; en este casopasa lo contrario. La independencia de la plataforma la tenemos porquetodo corre sobre la maquina virtual, por lo que sin interprete, no se puedecorrer el programa.

Lentitud en la ejecucion: Como toda instruccion tiene que pasar por elinterprete, para que este la traduzca y luego se ejecute es, un poco, maslento que los programas compilados.

Algunos ejemplos de lenguajes compilados e interpretados:

Lenguajes compilados Lenguajes interpretadosPascal PythonC/C++ JavaFortran C#

1.2. Caracterısticas de Python

Algunas de las caracterısticas que podemos encontrar en Python son:

Agilidad en el desarrollo I: Es rapido para probar y continuar desarrol-lando gracias a que cuenta con un interprete que va ejecutando el codigoa medida que lo escribimos en el. Es muy comodo para probar pequenasporciones de codigo.

2

Agilidad en el desarrollo II: rapido para programar la simplicidad dellenguaje y por las herramientas que contamos.

Muy facil de entender lo que hace el programa, ya que el codigo es limpioy elegante.

Es multiplataforma, por lo que el mismo codigo la mayorıa de las veces sepuede ejecutar en distintas computadoras y con distintos sistemas opera-tivos sin modificaciones.

Cuenta con una gran cantidad de modulos con muchas funcionalidadesdirectamente en el standard.

Es un lenguaje fuertemente tipado pero de asignacion dinamica. Se puedever esta ventaja en el ordenamiento de un vector de strings, o enteros, eslo mismo. Importa el algoritmo, no los tipos.

El principal objetivo que persigue este lenguaje es la facilidad, tanto delectura, como de diseno.

1.2.1. The Zeb of Python

Desde la version 2.1.2 de Python, si tratamos de importar el modulo ”this”nosmuestra las 19 premisas de Python escritas por Tim Peters.

>>> import thisThe 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 aren’t 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 you’re Dutch.Now is better than never.Although never is often better than *right* now.If the implementation is hard to explain, it’s a bad idea.If the implementation is easy to explain, it may be a good idea.Namespaces are one honking great idea -- let’s do more of those!

La traduccion serıa 1:

1http://es.wikipedia.org/wiki/Python

3

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

7. La legibilidad cuenta.

8. Los casos especiales no son tan especiales como para quebrantar las reglas.

9. Aunque lo practico gana a la pureza.

10. Los errores nunca deberıan dejarse pasar silenciosamente.

11. A menos que hayan sido silenciados explıcitamente.

12. Frente a la ambiguedad, rechaza la tentacion de adivinar.

13. Deberıa haber una -y preferiblemente solo una- manera obvia de hacerlo.

14. Aunque esa manera puede no ser obvia al principio a menos que usted seaHolandes

15. Ahora es mejor que nunca.

16. Aunque nunca es a menudo mejor que ya.

17. Si la implementacion es difıcil de explicar, es una mala idea.

18. Si la implementacion es facil de explicar, puede que sea una buena idea.

19. Los espacios de nombres (namespaces) son una gran idea ¡Hagamos masde 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 implementacion es difıcil de explicar, es una mala idea.2Me gusta mas: Disperso es mejor que denso.

4

1.3. Estructura de un programa en Python

La estructura de un programa en Python no es tan estricta como puede serloen Pascal o en C/C++, ya que no debe comenzar con ninguna palabra reserva-da, ni con un procedimiento o funcion en particular. Simplemente con escribirun par de lıneas de codigo ya podrıamos decir que tenemos un programa enPython.Lo que es importante destacar es la forma de identificar los distintos bloques decodigo. En Pascal se definıa un bloque de codigo usando las palabras reservadasBegin y End; en C/C++ se define mediante el uso de las llaves ({ y }). Sin em-bargo, en Python, se utiliza la indentacion; es decir, la cantidad de espacios/tabsque hay entre el comienzo de la lınea y el primer caracter distinto a ellos.

1.4. Interprete Python

El interprete de Python es una herramienta muy util al momento de desar-rollar, ya que se puede ir probando pequenas porciones del codigo sin necesidadde hacer todo el programa. Lo unico que hay que hacer para usarlo es tenerloinstalado y correr el comando python en la consola.Al hacer eso nos va a aparecer un shell que comenzara con >>>, en el cualpodremos escribir codigo y automaticamente se ira interpretando.Cuando usamos una estructura selectiva o de repeticion generalmente vamos atener que escribir mas de una lınea, por lo que el interprete no va a ejecutar esecodigo hasta que se lo indiquemos dejando una lınea en blanco, es decir, con soloun Enter. Para indicarnos que todavıa no va a ser interpretado va a cambiar elprompt >>> por ....Con los procedimientos y funciones hace algo similar, pero con la diferencia queese codigo se va a interpretar una vez que lo invoquemos, y no al terminar dedefinirlo.

En el siguiente ejemplo vamos a abrir el interprete python.

$ pythonPython 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 numeros, dos strings y unasublista de dos enteros.

$ pythonPython 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

$ pythonPython 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.

$ pythonPython 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 ejecutenuestro codigo.

$ pythonPython 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...2412123434[5, 6, 5, 6]>>>

Vemos que al multiplicar un numero por 2, nos devuelve el doble del valororiginal. Lo mismo hace con el resto de los datos, si multiplicamos una cadenade caracteres nos repite la misma secuencia de caracteres y los concatena. Parauna 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, po-drıamos crear un archivo llamado ejemplo.py y que su contenido sea:

lista = [1, 2, "12", "34", [5, 6]]print listafor elemento in lista:

print elemento*2

Para ejecutarlo tendrıamos que hacer:

$python ejemplo.py

Y la salida serıa:

6

$python ejemplo.py[1, 2, ’12’, ’34’, [5, 6]]2412123434[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 ingresadoy lo retorna como un string.

>>> variable = raw_input("Ingrese algo: ")Ingrese algo: 7540>>> print variable7540>>> variable = raw_input()40>>> variable = raw_input()Esta cadena la guardo en variable>>> print variableEsta 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 aencontrarlos.

2. Todos los programas sufren modificaciones a lo largo de su vida, al menostodos aquellos que tienen exito.

Por cualquiera de estas razones es conveniente escribir un codigo claro, legibley ayudarlo con comentarios para facilitar estas tareas. Lo cual no significa quea partir de ahora vayan a escribir mas lıneas de comentarios que de codigo, yaque tambien hay que saber que escribir.Al momento de hacer un comentario hay que pensar en cuanta informacion nue-va estas aportando, o cuanto mas legible queda el codigo para quien lo tengaque leer y mantener.

La forma de hacer comentarios en Python es anteponiendo el #, de esa for-ma, desde ese caracter hasta el fin de la lınea se obviaran todos los caracteresal momento de ejecutar el codigo. 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.for elemento in lista:

print elemento*2 # Esto tambien 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 delcodigo, ya que lo unico que hacen es decir que hace el programa lınea porlınea sin aportar nada nuevo. Si los comentarios son solo una traduccion dellenguaje que estan usando a su lenguaje nativo, dejan de ser utiles y para colmoagregamos algo mas que hay que mantener. Si el codigo cambia de forma quelos comentarios queden desactualizados (cosa que es muy comun que pase coneste tipo de comentarios) hay que mantenerlos para que no confundan a quienlo lee.Un comentario es util cuando indicamos algo que no es evidente. Por ejemplo,si vemos el siguiente codigo es difıcil entender lo que hace esa lı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 cuentafacilmente 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. Tipos de datos y como manipularlos

2.1. Tipos soportados

Python es un lenguaje fuertemente tipado, pero a la vez tiene la carac-terıstica de tipado dinamico. Es de fuertemente tipado ya que no se permiteusar 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 yaque 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 numero.Si bien se le puede asignar a una variable valores de distinto tipo, es convenienterespetar 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 True y False.Ejemplo:

8

>>> boolean = True>>> boolean = False>>> print True and FalseFalse>>> print True or FalseTrue>>> print not TrueFalse>>> print not FalseTrue>>> 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 final para diferenciarlo delos enteros cortos.Ejemplo:

9

>>> 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 flotante (float)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 necesaria-mente 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 queuna 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’>

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 lasque se le puede asignar una clave y un valor asociado para ella. Esa clave puedeser de cualquier tipo inmutable, por ejemplo: strings, numeros enteros, numeroscomplejos, numeros reales, booleanos y tuplas; pero no listas ni diccionarios yaque son mutables. Ademas, no es necesario que todas las claves sean del mismotipo.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: u’otro 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. Conversion entre tipos

Para convertir a un numero entero se puede usar la funcion int(n), a lacual 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 funcion tambien se le puede pasar un numero como string y una base(int(”n”, base)) y convierte ese valor ”n” que se encuentra en la base base adecimal.

>>> 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 numerosflotantes, pero no tenemos tantas alternativas como antes. Para eso podemosusar la funcion float(string) que recibe una cadena de caracteres y retorna unfloat.

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

Tambien se le puede pasar un numero entero y lo convierte a flotante:

>>> float(12)12.0

Para convertir cualquier variable a string podemos usar la funcion str() querecibe cualquier cosa y hace su mejor intento para convertirla. A diferencia delresto, esta funcion nunca va a fallar por no saber como convertir algo. Puedepasar que con algun tipo en particular no nos devuelva el resultado que quere-mos, pero seguro que nos va a devolver una representacion de lo que le pasamosen 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, indican-do en la cadena donde queremos que vaya con un % y despues pasar todos losparametros juntos. Al igual que en C, cuando marcamos la posicion donde quer-emos que se ingrese algun valor, tambien vamos a tener que indicar el tipo deese parametro; y ellos pueden ser:

14

Indicador Tipo:%c Solo un caracter.%s Cadena de caracteres.%d o %i o %u 0 %ld 0 %lu Entero con signo.%nd Entero con signo ocupando n3 espacios.%.nd Entero con signo ocupando n lugares, completando con 0.%f Float o real.%.nf Float o real con solo n decimales.%e Float o double, con notacion cientıfica.%.ne Float o double, con notacion cientıfica, con solo n decimales.%g Coma flotante, usando la notacion que requiera menor espacio.%x Hexadecimal.

Algunos ejemplos:

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

Ademas se pueden mezclar con los siguientes caracteres:

15

Caracter Descripcion\n Caracter fin de lınea.\r Caracter retorno del carro.\t Caracter tabulador horizontal.\v Caracter tabulador vertical.\a 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 podemosusar la funcion join() de la siguiente forma:

>>> " ".join(("Algoritmos", "y", "Programacion", "I"))’Algoritmos y Programacion I’>>> "".join(["Algoritmos", "y", "Programacion", "I"])’AlgoritmosyProgramacionI’>>> " ".join(["Algoritmos", "y", "Programacion", "I"])’Algoritmos y Programacion I’>>>> "##separador##".join(["Algoritmos", "y", "Programacion", "I"])’Algoritmos##separador##y##separador##Programacion##separador##I’

Y como sucede generalmente, si hay una funcion que va en un sentido existeotra que va en el sentido inverso. Para parsear un string y obtener una listapodemos usar la funcion split. Por defecto el separador es el espacio, por lo quesi le pasamos una oracion, 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 respectodel inicio o el rango que se desea obtener. Para indicar un rango se pone primerola posicion del comienzo, despues un separador que sera el : y por ultimo laposicion del final. Si no se le pasa la posicion donde comienza el rango, asumeque ese valor es 0; y si la posicion que no se le pasa es la del final, asume que eshasta el final del string.

>>> "Hola mundo"[2]’l’>>> "Hola mundo"[2:4]’la’>>> "Hola mundo"[2:3]’l’>>> "Hola mundo"[0:4]’Hola’>>> "Hola mundo"[:4]’Hola’>>> "Hola mundo"[5:]’mundo’

Ası como podemos saber la posicion desde el inicio de la cadena de carac-teres, tambien podemos indicar la posicion respecto del ultimo caracter:

Cadena de caracteres: H o l a m u n d oPosicion desde el inicio: 0 1 2 3 4 5 6 7 8 9Posicion desde el final: -10 -9 -8 -7 -6 -5 -4 -3 -2 -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 posi-ciones para las listas y tuplas.

>>> [3, 5, 1, 7, 15, 11][4]15>>> [3, 5, 1, 7, 15, 11][-2]

17

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

Una forma muy sencilla de crear una lista con valores consecutivos es usandola funcion range([piso], techo); que puede recibir uno o dos parametros. Si sele pasa un solo parametro la funcion devuelve una lista que tendra todos losnumeros que sean iguales o mayores a 0 y menores a ese numero.

>>> range(3)[0, 1, 2]>>> range(-1)[]

En cambio, si se le pasan dos parametros nos va a devolver una lista quetendra todos los numeros que sean iguales o mayores al primero y menores alsegundo.

>>> 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 estecaso 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 travesde la funcion keys().

>>> {1:"uno", 2:"dos", 3:"tres"}.keys()[1, 2, 3]

Y si podemos obtener sus claves, tambien podemos obtener los valores asociadosa 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 utiles para conocer un poco mas lo queusamos.

Otra herramienta de Python muy util es la de poder averiguar informacionsobre lo que usamos en tiempo de ejecucion, aunque tambien para eso podemosusar el interprete.Las funciones que vamos a usar son dir(), __doc__ y help().La funcion dir() nos da informacion de como manipular ese objeto. Por ejemplo,si a esta funcion le pasamos un string nos muestra las funciones que le podemosaplicar:

>>> 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 funcion __doc__ nos da informacion de como usar una funcion en particular.Para poder conseguir esa informacion primero alguien la tiene que cargar, yeso se hace escribiendo un comentario que comience y termine con tres comillasdobles(""").Por ejemplo, si queremos conocer un poco mas la funcion find() de un stringpodrı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]. Optionalarguments start and end are interpreted as in slice notation.

Return -1 on failure.

Y por ultimo, nos queda la funcion help() que al invocarla nos muestra lasfunciones para manipular esa variable con una descripcion similar a la que nosda __doc__

>>> help("string")

Help on module string:

NAMEstring - A collection of string operations (most are no longer used).

FILE/usr/lib/python2.5/string.py

MODULE DOCShttp://www.python.org/doc/current/lib/module-string.html

DESCRIPTIONWarning: most of the code you see here isn’t normally used nowadays.Beginning with Python 1.6, many of these functions are implemented asmethods on the standard string object. They used to be implemented bya 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

FUNCTIONSatof(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 givenbase, which defaults to 10. The string s must consist of oneor more digits, possibly preceded by a sign. If base is 0, itis chosen from the leading characters of s, 0 for octal, 0x or0X for hexadecimal. If base is 16, a preceding 0x or 0X isaccepted.

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]. Optionalarguments 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 paracontrolar el flujo del codigo que se va a ejecutar.

3.1.1. if

La estructura selectiva if es similar a las vistas, pero a diferencia de Pascal oC, ya no se marca el bloque de ejecucion con un Begin ... end o unas { ... }sino que se utiliza la indentacion.

Pascal

if (condicion) thenaccion;

o

21

if (condicion) thenbegin

accion1;accion2;...accionN;

end;

C

if (condicion)accion;

o

if (condicion){

accion1;accion2;...accionN;

}

Python

if (condicion):accion1;accion2;...accionN;

A diferencia de Pascal y C, en Python no hay diferencia entre poner una solaaccion o varias. Ademas, es obligatorio que las acciones esten todas equidistantesdel comienzo de la lınea y a su vez, que esa distancia sea mayor que la distanciadel inicio al if .

>>> if 3<4:... print 1... print 2

File "<stdin>", line 3print 2

^IndentationError: unindent does not match any outer indentation level>>> if 3<4:... print 0

File "<stdin>", line 2print 0

^IndentationError: expected an indented block

Otra diferencia es que para comparar si un valor se encuentra dentro de unrango se puede hacer de una forma mas sencilla:Pascal

22

if 3 > 2 and 2 > 1 thenwriteln(’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ıa de los lenguajes, la estructura de seleccion if no solo nosda 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 lacondicion sea falsa.

if a > b:print "a es mayor que b"

else:print "b es mayor que a"

Muchas veces si la condicion es falsa queremos evaluar otras condiciones, porlo 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, mas comprensible, Python nosda 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, tambien se puede puede preguntar si unvalor esta en una lista. Con los lenguajes que vimos hasta el momento, parasaber si un elemento pertenece a una lista tenıamos que recorrerla toda (o porlo menos hasta encontrarlo) y fijarnos uno por uno si es lo que buscabamos. EnPython 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 asignara el valor1 si la condicion es verdadera y valor2 en casocontrario.Por ejemplo:

>>> num = 5>>> espar = True if (num % 2 == 0) else False>>> print esparFalse>>> num = 6>>> espar = True if (num % 2 == 0) else False>>> print esparTrue

3.1.2. case

En Python no existe una estructura como serıan el case en Pascal o el switchen C y es porque no se lo usa tanto. Ademas, podemos usar los if anidados paraobtener una estructura aun mas potente que un simple discriminador de valoresde una unica variable.

3.1.3. for

Aquı se encuentra la estructura con mayor diferencia entre los 3 lenguajesvistos en el curso. Por un lado, en Pascal tenemos una estructura que es muysimple de entender, casi como uno lo dirıa, pero muy limitada:

for variable_iteracion:=valor_inicial to valor_final dobegin

24

accion1;accion2;...accionN;

end;

Por otro lado, en C esta misma estructura es mucho mas potente, pero acosta de sacrificar un poco de legibilidad:

for (condicion inicial; condicion de corte; modificacion de la variable){

accion1;accion2;...accionN;

}

Por lo que Python adopto una tercer forma tratando capturar lo mejor decada una de ellas; siempre priorizando la claridad del codigo.

for elemento in lista:accion1accion2...accionN

Por lo que ahora, recorrer todos los elementos de una lista y trabajar conellos (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]]>>> for elemento in lista:... print elemento*2...2412123434[5, 6, 5, 6]>>>

¿Y que pasa si quiero hacer un for para que simplemente muestre losprimeros 50 enteros no negativos, o los numeros del 20 al 30?. La respuestaesta unas cuantas hojas antes: range().Para imprimir los primeros 50 numeros enteros no negativos:

for i in range(50):print i

Para imprimir los numeros 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 listaque tiene todos los valores comprendidos entre el piso (0 si no se lo pasamos) yel techo (sin incluir este ultimo).

List comprehensions:

List comprehensions o la comprension de listas es una estructura para construiruna lista a partir de los elementos de otra. A esos elementos podemos aplicarlesuna funcion que me devuelva algun elemento, como multiplicarlos por 2, y/ofiltrarlos con un if para que solo pasen los que cumplen con alguna condicionen particular.Por ejemplo, si queremos una lista que tenga el cuadrado de los primeros 16numeros 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 elementosimpares:

>>> 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 unasegunda lista tambien podrı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 loselementos 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 quevimos), pero tengan en cuenta que no siempre el codigo queda mas legible yentendible para el proximo que lo tenga que leer.

26

3.1.4. while

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

while <condicion>:accion1accion2...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:aLa letra es menor a g, ingrese otra:cLa letra es menor a g, ingrese otra:dLa letra es menor a g, ingrese otra:z>>>

Obviamente se pueden usar las mismas condiciones que en un if : Preguntarsi un valor esta en una lista:

>>> lista = [3, 2, 5, 7, 1, 9]>>> while 7 in lista:... # Saco el ultimo elemento de la lista... lista = lista[:-1]...>>> print lista[3, 2, 5]>>>

O que un valor se encuentre dentro de un rango.

>>> num = int(raw_input("Ingrese un numero: "))Ingrese un numero: 5>>> while 1 < num < 10:... num = int(raw_input("Ingrese un numero: "))...Ingrese un numero: 7Ingrese un numero: 4

27

Ingrese un numero: 9Ingrese un numero: 2Ingrese un numero: 15>>>

3.1.5. repeat

Ası como no existe un equivalente para el case, tampoco existe otro para elrepeat de Pascal o el do while de C, y, supongo, que los motivos son similares.

4. Programacion modular

4.1. Procedimientos y funciones

Una de las premisas de Python era que ”La legibilidad cuenta”, y el uso deprocedimientos y funciones ayudan mucho en que un codigo sea legible.En Python no existen los procedimientos: son todas funciones. Incluso, aunquenosotros no devolvamos ningun valor, Python lo hara por nosotros.La forma de devolver valores es, al igual que en C, usando la palabra reservadareturn y el valor a retornar. Y de igual forma, una vez que se ejecuta esa sen-tencia, no se ejecuta ninguna sentencia mas de esa funcion; sin importar si estadentro de un ciclo o todavıa no hayamos hecho nada.La definicion de una funcion comienza usando la palabra reservada def, y con-tinua dejando un espacio, poniendo el nombre de la funcion4, los parametrosentre parentesis5 y un dos puntos para terminar la lınea. En las lıneas que lesiguen va el codigo de la funcion, que, al igual que para las estructuras de con-trol, la forma en que se indica el bloque de codigo que se tiene que ejecutar eshaciendo uso de la indentacion.

def nombre_funcion(param1, param2, ... , paramN):sentencia1sentencia2...sentenciaN

Donde una de esas sentencias puede tener el return.Por ejemplo, si ahora queremos hacer la funcion que calcula el factorial de unnumero harıamos algo por el estilo:

def factorial(n):for i in range(1,n):

n *= ireturn n

Y la forma de usarla es igual que en el resto de los lenguajes, invocamos lafuncion y el resultado podemos asignarselo a una variable o no.

4Tiene que cumplir las mismas reglas para las variables, puede empezar con cualquier letray el y despues le puede seguir cualquier caracter alfanumerico mas el .

5Los parentesis son obligatorios por mas que no se pasen parametros

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 recur-sividad podrıamos hacer:

def factorial_rec(n):if n == 0:

return 1else:

return n*factorial_rec(n-1)

# Esta lınea ya esta fuera de la funcion y pertenece al bloque principal.print factorial_rec(5)

Si ahora quisieramos hacer una funcion que haga la busqueda binaria sobreuna 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 pasara si ahora queremos hacer una busqueda binaria sobre una listade strings?.

>>> binaria(["Algoritmos", "Programacion", "Y"], "Y")2>>> binaria(["Algoritmos", "Programacion", "Y"], "esta no esta")-1

Como se puede ver en los ejemplos anteriores, en ningun momento pusimosel tipo de los parametros que recibe la funcion por lo que en Python no es nece-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 puedendefinir valores por defecto para los parametros de una funcion. Es decir, si no sele pasa un valor, ese parametro toma el valor que definio el programador en elmomento que escribio el codigo. La forma de hacerlo es igual que en C, simple-mente hay que ponerle el signo igual seguido del valor por defecto y, en caso deque la funcion reciba algun otro parametro despues de el tambien debe tener unvalor por defecto. Es decir, los parametros que tienen valores por defecto solopueden ocupar las ultimas posiciones.

>>> def imprimir_parametros(param1, param2, param3=5, param4="es el cuarto parametro", param5=False):... 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 paramet-ros hasta el que nosotros que tome un valor distinto del default, podemos indi-carlo 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 pasarlelos parametros 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, di-jimos que eran todas funciones ya que siempre retornaban algun valor, perovemos en imprimir_parametros que en ningun momento se hace un return;entonces era mentira lo que habıamos dicho?. Obviamente, no. Pero entonces,¿que devuelve si no tiene un return?. La respuesta es simple; nada. Pero el valornada, que en Python se llama None. Este valor es el equivalente al null de C onill de Pascal.

30

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

Tambien podrıamos hacer un procedimiento que pida el ingreso de algundato, verifique que se encuentre algunos valores posibles y nos devuelva la opcionelegida.

>>> 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?.gError!!!Seguro que quiere salir?.gError!!!Seguro que quiere salir?.sError!!!Seguro que quiere salir?.S>>> print opcionS>>> opcion = confirmar("Seguro que quiere salir?.", msg_error="Error. Las opciones validas son: S y N.")Seguro que quiere salir?.gError. Las opciones validas son: S y N.Seguro que quiere salir?.sError. Las opciones validas son: S y N.Seguro que quiere salir?.S>>> print opcionS>>> def Menu():... print "1. Opcion 1"... print "2. Opcion 2"... print "3. Opcion 3"... confirmar("", ["1", "2", ""3], "Error!!!!, Las opciones validas son: " + str(range(1,4)))...>>> Menu()1. Opcion 12. Opcion 23. Opcion 3gError!!!!, Las opciones validas son: [1, 2, 3]sError!!!!, Las opciones validas son: [1, 2, 3]5

31

Error!!!!, Las opciones validas son: [1, 2, 3]1>>>

Una cosa que puede ser muy util es asignarle una funcion a una variable,ya que tambien existe el tipo de dato funcion. La forma de hacerlo es similara como asignamos el valor de otra variable, a la izquierda ponemos la variable,luego el signo igual y por ultimo 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 fun-cion a una variable, despues usar esa variable como si llamaramos a la mismafuncion.La utilidad de esta funcionalidad no es usar la misma funcion con otro nombrepara confundir aun mas a quien tenga que leer el codigo, sino, poder elegir entiempo de ejecucion que funcion invocar. Por ejemplo, si queremos hacer unafuncion que haga la busqueda binaria en una lista ordenada en forma ascendentepodrıamos usar la funcion que escribimos antes:

def binaria(lista_enteros, clave):min = 0max = len(lista_enteros) - 1centro = (min + max) / 2while (lista_enteros[centro] != clave) and (min < max):

if lista_enteros[centro] > clave:max = centro -1

else:min = centro + 1

centro = (min + max) / 2if lista_enteros[centro] == clave:

return centroelse:

return -1

Ahora supongamos que queremos hacer una busqueda sobre una lista queesta ordenada en forma descendente, entonces ya no nos servirıa nada de lo quetenemos y tendrıamos que copiar el mismo codigo cambiando solamente el signo

32

mayor por un menor y tendrıamos dos funciones casi iguales que solo diferirıanen un solo caracter.Si vamos a tener que usar las dos busquedas, serıa conveniente que busquemosuna alternativa que encapsule lo que puede cambiar y mantenga el resto sinmodificaciones. Para lograr esto podrıamos pasarle a la busqueda una funcionque compare el valor central y la clave e indique si el valor que buscamos seencuentra a la derecha o izquierda.

def mayor(n1, n2):if n1 > n2:

return Trueelse:

return False

def menor(n1, n2):if n1 < n2:

return Trueelse:

return False

def binaria(cmp, lista, clave):"""Binaria es una funcion que busca en una lista la clave pasada. Es un requisito

de la busqueda binaria que la lista se encuentre ordenada, pero no si el ordenes ascendente o descendente. Por este motivo es que tambien recibe una funcionque le indique en que sentido ir.Si la lista esta ordenada en forma ascendente la funcion que se le pasa tieneque ser verdadera cuando el primer valor es mayor que la segundo; y falso encaso contrario.Si la lista esta ordenada en forma descendente la funcion que se le pasa tieneque ser verdadera cuando el primer valor es menor que la segundo; y falso encaso contrario."""

min = 0max = len(lista) - 1centro = (min + max) / 2while (lista[centro] != clave) and (min < max):

if cmp(lista[centro], clave):max = centro -1

else:min = centro + 1

centro = (min + max) / 2if lista[centro] == clave:

return centroelse:

return -1

Entonces, si ahora queremos buscar el numero 8 en una lista ordenada as-cendentemente, vamos a tener que pasarle el nombre de la funcion que tiene queusar 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 retornala posicion numero 7; pero que pasara si en lugar de pasarle la funcion mayorle 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 sermenor que 8, en la primer iteracion va a descartar la segunda parte de la listay se quedara solo con la primera. Por ese motivo es que nunca va a encontrar el8 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 debıa pasar, si el numero no se encuentra en la lista, retorna -1.Y si ahora buscamos algunos valores en una lista ordenada descendentemente,pasandole la funcion 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 estan 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 pasabamos una lista ordenada en forma ascendente yla funcion menor, si ahora le pasamos una lista ordenada en forma descendentey la mayor, la busqueda no va a poder encontrar la clave por mas que exista.Ahora que probamos la funcion vemos que efectivamente hace lo que deberıahacer, pero, ¿que es ese texto que esta entre """ y para que sirve?. Eso es uncomentario de mas de una lınea llamado docstring y sirve para documentarlas funciones, entre otras cosas.Pero no es la primera vez que nos topamos con este tipo de documentacion, yaque antes lo usamos sin saber como estaba hecho o como se llamaba. La formade usarlo es a traves de __doc__ y help():

>>> print binaria.__doc__Binaria es una funcion que busca en una lista la clave pasada. Es un requisitode la busqueda binaria que la lista se encuentre ordenada, pero no si el ordenes ascendente o descendente. Por este motivo es que tambien recibe una funcionque le indique en que sentido ir.Si la lista esta ordenada en forma ascendente la funcion que se le pasa tiene

34

que ser verdadera cuando el primer valor es mayor que la segundo; y falso encaso contrario.Si la lista esta ordenada en forma descendente la funcion que se le pasa tieneque ser verdadera cuando el primer valor es menor que la segundo; y falso encaso contrario.>>> help(binaria)Help on function binaria in module __main__:

binaria(cmp, lista, clave)Binaria es una funcion que busca en una lista la clave pasada. Es un requisitode la busqueda binaria que la lista se encuentre ordenada, pero no si el ordenes ascendente o descendente. Por este motivo es que tambien recibe una funcionque le indique en que sentido ir.Si la lista esta ordenada en forma ascendente la funcion que se le pasa tieneque ser verdadera cuando el primer valor es mayor que la segundo; y falso encaso contrario.Si la lista esta ordenada en forma descendente la funcion que se le pasa tieneque ser verdadera cuando el primer valor es menor que la segundo; y falso encaso contrario.

(END)

4.2. Uso de modulos externos

Ası como en Pascal usando la clausula Uses y en C el #include, podıamosusar codigo que no pertenecıa al archivo que estabamos codificando, en Pythonpodemos hacer lo mismo usando la clausula import y poniendo a continuacionel nombre del modulo. Por ejemplo, si queremos importar el modulo datetime6:

import datetime

Para usarlo simplemente tenemos que poner el nombre del modulo, un puntoy la funcion que queramos usar. En este caso, dentro del modulo datetime vamosa usar la funcion 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 oalgo en particular de ese modulo, en lugar de traerlo todo. Para eso tendrıamosque poner en primer lugar la clausula from, luego el nombre del modulo y acontinuacion la clausula import todo lo que queremos importar separada porcomas.Por ejemplo, del modulo datetime podrıamos traer las clases7 date y time.Despues, para usarlo simplemente lo hacemos llamando lo que importamos sinel nombre del modulo.

6El modulo datetime sirve para el manejo de fechas y horas.7Por ahora, no presten demasiada atencion al hecho de que sean clases, no vamos a cambiar

al paradigma de Programacion Orientada a Objetos (POO).

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 siguientecodigo:

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 moduloy 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, porlo que al apagar la computadora, o simplemente con cerrar el programa y volvera abrirlo perdimos todos los datos que nos tenıamos. La alternativa para estosiguen siendo los archivos.

5.1. Uso de archivos

Para poder usar un archivo vamos a tener que hacer los mismos pasos quesiempre, pero de una forma distinta a la de Pascal e igual a la de C. Vamos anecesitar una variable de tipo archivo, a la cual le vamos a asignar un archivofısico y lo vamos a abrir de una forma particular. Una vez que hayamos hechotodos estos pasos, y si no hubo problema en ninguno de ellos, vamos a poderleer 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, selo asignamos a uno fısico y elegimos el modo de apertura, que si no le indicamosnada, tomara por defecto el de lectura.El modo de apertura puede ser cualquier combinacion de:

Modo Descripcion’r’ Lectura: el archivo debe existir. Similar al

reset de Pascal.’w’ Escritura: no es necesario que el archivo ex-

ista, pero si existe lo sobre escribe. Similar alrewrite de Pascal.

’a’ Append: Solo agrega al final y no es necesarioque el archivo exista. Similar al append de Pas-cal.

’b’ Binario.’+’ Permite lectura y escrituras simultaneas.

La primitiva del lenguaje para abrir y asignar un archivo es open, la cualpuede recibir uno o dos parametros. El primero es obligatorio, y correspondea la ubicacion relativa o absoluta del archivo fısico. El segundo paramemetroindica el modo de apertura y es opcional. Si no se lo pasamos asumira que loqueremos abrir en modo Lectura.Supongamos que estamos en un escenario en el que solo tenemos un archivo quese 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.txtfallo la aplicacion que dice "IOError: No existe el archivo o directorio: f1.txt".A continuacion lo intentamos abrir en modo escritura, que, como dijimos antes,si no existe lo crea; y eso fue lo que paso. El archivo no existıa, pero igualno tuvimos problemas para abrirlo. Aunque recuerden que si el archivo existeestarıamos borrandolo completamente.Una vez que abrimos el archivo f1.txt, vamos a abrir el archivo f2.txt (elunico que existıa) de igual forma a como habıamos abierto el primero para verque 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 elarchivo no existe, e intentamos primero abrirlo para lectura y despues paraescritura 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 despuespara lectura.

5.1.2. Cierre de archivos

Para cerrar un archivo solo tenemos que indicarselo poniendo la variableseguida de un punto y la primitiva close(). La unica restriccion es que lavariable 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 sigu-iente texto:ejemplo.txt

Python was created in the early 1990s by Guido van Rossum at StichtingMathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlandsas a successor of a language called ABC. Guido remains Python’sprincipal author, although it includes many contributions from others.

In 1995, Guido continued his work on Python at the Corporation forNational Research Initiatives (CNRI, see http://www.cnri.reston.va.us)in Reston, Virginia where he released several versions of thesoftware.

In May 2000, Guido and the Python core development team moved toBeOpen.com to form the BeOpen PythonLabs team. In October of the sameyear, the PythonLabs team moved to Digital Creations (now ZopeCorporation, see http://www.zope.com). In 2001, the Python SoftwareFoundation (PSF, see http://www.python.org/psf/) was formed, anon-profit organization created specifically to own Python-relatedIntellectual Property. Zope Corporation is a sponsoring member ofthe PSF.

All Python releases are Open Source (see http://www.opensource.org forthe Open Source Definition). Historically, most, but not all, Pythonreleases have also been GPL-compatible.

Para leer un archivo podemos usar la primitiva read(), la cual puede recibirun parametro que indique la cantidad de caracteres a leer. Si no se pasa eseparametro el interprete leera todo el archivo y lo retornara.

>>> arch = open("ejemplo.txt")>>> cadena = arch.read(15)

38

>>> # Imprimo los primeros 15 caracteres del archivo.... print cadenaPython was crea>>> # Leo otros 7 caracteres y dejo el cursor del archivo en la siguiente posicion.... cadena = arch.read(7)>>> print cadenated in>>> # Ahora leo el resto del archivo.... cadena = arch.read()>>> print cadenathe early 1990s by Guido van Rossum at StichtingMathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlandsas a successor of a language called ABC. Guido remains Python’sprincipal author, although it includes many contributions from others.

In 1995, Guido continued his work on Python at the Corporation forNational Research Initiatives (CNRI, see http://www.cnri.reston.va.us)in Reston, Virginia where he released several versions of thesoftware.

In May 2000, Guido and the Python core development team moved toBeOpen.com to form the BeOpen PythonLabs team. In October of the sameyear, the PythonLabs team moved to Digital Creations (now ZopeCorporation, see http://www.zope.com). In 2001, the Python SoftwareFoundation (PSF, see http://www.python.org/psf/) was formed, anon-profit organization created specifically to own Python-relatedIntellectual Property. Zope Corporation is a sponsoring member ofthe PSF.

All Python releases are Open Source (see http://www.opensource.org forthe Open Source Definition). Historically, most, but not all, Pythonreleases have also been GPL-compatible.

>>>

La unica condicion que tenemos para usar este metodo es que el archivo lohayamos 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(),tambien puede recibir un parametro que indique la cantidad maxima de bytes

39

a leer. Si no se le pasa ningun parametro, lee toda la lınea.

>>> arch = open("ejemplo.txt")>>> linea = arch.readline()>>> print lineaPython was created in the early 1990s by Guido van Rossum at Stichting

>>> linea = arch.readline(7)>>> print lineaMathema>>>

Pero no es necesario que leamos de a una sola lınea, sino que tambien pode-mos leer todas las lıneas del archivo y guardarlas en una lista haciendo uso dela 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 Centrum (CWI, see http://www.cwi.nl) in the Netherlands\n’, "as a successor of a language called ABC. Guido remains Python’s\n", ’principal author, although it includes many contributions from others.\n’, ’\n’, ’In 1995, Guido continued his work on Python at the Corporation for\n’, ’National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)\n’, ’in Reston, Virginia where he released several versions of the\n’, ’software.\n’, ’\n’, ’In May 2000, Guido and the Python core development team moved to\n’, ’BeOpen.com to form the BeOpen PythonLabs team. In October of the same\n’, ’year, the PythonLabs team moved to Digital Creations (now Zope\n’, ’Corporation, see http://www.zope.com). In 2001, the Python Software\n’, ’Foundation (PSF, see http://www.python.org/psf/) was formed, a\n’, ’non-profit organization created specifically to own Python-related\n’, ’Intellectual Property. Zope Corporation is a sponsoring member of\n’, ’the PSF.\n’, ’\n’, ’All Python releases are Open Source (see http://www.opensource.org for\n’, ’the Open Source Definition). Historically, most, but not all, Python\n’, ’releases have also been GPL-compatible.\n’]>>>

Otra forma de leer el archivo por lıneas es usando la estructura for yquedarıa casi como lo dirıamos en castellano: "Para cada lınea del archivo:".Por ejemplo, si queremos imprimir la cantidad de caracteres de cada lınea po-drıamos hacer:

>>> arch = open("ejemplo.txt")>>> for linea in arch:... print len(linea)...716965711677162101657163696367679171

40

7040>>>

Como se puede ver, en el archivo hay lıneas que aparentemente no tienenningun caracter, y sin embargo, si vemos los numeros encontramos lıneas con0 caracteres. Eso se debe a que en todas las lıneas podemos encontrar siempreel caracter de fin de lınea que se representa por el \n, pero al momento deimprimirlo 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 decaracteres y la segunda para escribir una lista de strings, uno a continuacion delotro. Es importante destacar que en ningun caso se escribe algun caracter queno figure en los strings, como por ejemplo, caracteres de fin de lınea.El uso de writelines es equivalente a recorrer la lista y hacerle un write acada elemento.Pero el costo de escribir algo en el disco es mucho mayor a escribirlo en memoriapor lo que, al igual que en C, se usa un buffer, que no es mas que una porcionde memoria para ir guardando en forma temporal los datos y cuando alcanzanun tamano considerable se lo manda a escribir al disco. Otra forma de asegu-rarse que se haga la escritura es usando la primitiva flush, la cual guarda en eldisco el contenido del buffer 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 lınea. ", "2. Segundo string con fin de lınea.\n", "3. Tercero con/\n.\n", "4. y ultimo."])>>> arch2.flush()>>> arch2.close()>>> arch2 = open("ejemplo2.txt", "r+a")>>> strfile = arch2.read()>>> print strfileEs la primer cadenaSeguida de la segunda con un fin de linea1. 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 tambien 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 linea1. 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 tambien con un \n al finalde 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 Pascal, en Python tambien podemossaltar a distintas posiciones mediante la primitiva seek(pos) la cual recibe,como mınimo un parametro que indica la posicion a la que nos queremos mover.Opcionalmente puede recibir un segundo parametro:

Valor del parametro Significado0 La posicion es desde el inicio del archivo y

debe ser mayor o igual a 01 La posicion es relativa a la posicion actual;

puede ser positiva o negativa.2 La posicion es desde el final del archivo, por

lo que debe ser negativa.

>>> arch = open("ejemplo.txt")>>> # Voy a la posicion numero 30 del archivo... arch.seek(30)>>> print arch.read(7)y 1990s>>> # Me muevo 5 posiciones para atras desde mi posicion actual.... arch.seek(-5,1)>>> print arch.read(7)1990s b>>> # Me muevo a la posicion numero 12, comenzando a contar desde el final.... arch.seek(-12,2)>>> print arch.read(10)compatible>>>

Y ası como podemos movernos en un archivo, tambien podemos averiguarnuestra posicion usando la primitiva tell().

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

Tambien se le pueden hacer distintas como por ejemplo el nombre, el modo enque esta abierto, si esta cerrado, entre otros. Usar help() para mas informacion.

>>> arch.name’ejemplo.txt’>>> arch.mode’r’>>> arch.closedFalse

6. Anexo I

6.1. Licencia: GPL

Python posee una licencia de codigo abierto, denominada Python SoftwareFoundation License, que es compatible con la licencia GPL a partir de la version2.1.1, e incompatible en ciertas versiones anteriores. Esta licencia no obliga aliberar el codigo fuente al distribuir los archivos binarios8.Para mas informacion pueden tipear license() en el interprete Python.

6.2. Peps (Python Enhancement Proposal o Propuestasde Mejora de Python)

Las Peps son propuestas para mejorar Python, pero no solo a nivel de nuevasimplementaciones sino tambien de como usarlo.Por ejemplo, la numero 8: http://www.python.org/dev/peps/pep-0008/ pro-pone un estilo de codigo a seguir para los que programen en Python, el cual sepuede respetar o no, pero es una convencion para que sea mas legible el codigoy cometer menos errores.La numero 20 comenta el Zen de Python que vimos antes y la 257 comentacomo hacer buena documentacion para las funciones (docstring).Por lo que se puede ver en http://www.python.org/dev/peps/, las mismasestan divididas en las siguientes categorıas:

Meta-PEPs (PEPs about PEPs or Processes)

Other Informational PEPs

Accepted PEPs (accepted; may not be implemented yet)

Open PEPs (under consideration)8http://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 nosea ası, es probable que la herramienta de gestion de paquetes de tu distribucionlo tenga disponible.Si no usas linux, tienen que buscar la version para su sistema operativo enhttp : //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 11.1. Diferencias entre un lenguaje interpretado y uno compilado . . . 11.2. Caracterısticas de Python . . . . . . . . . . . . . . . . . . . . . . 2

1.2.1. The Zeb of Python . . . . . . . . . . . . . . . . . . . . . . 31.3. Estructura de un programa en Python . . . . . . . . . . . . . . . 51.4. Interprete Python . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.4.1. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . 7

2. Tipos de datos y como manipularlos 82.1. Tipos soportados . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.1.1. Conversion entre tipos . . . . . . . . . . . . . . . . . . . . 132.1.2. Algunas funciones utiles para conocer un poco mas lo que

usamos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3. Estructuras de control 213.1. Equivalencias de estructuras de control entre Python, Pascal y C 21

3.1.1. if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.1.2. case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.1.3. for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.1.4. while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.1.5. repeat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4. Programacion modular 284.1. Procedimientos y funciones . . . . . . . . . . . . . . . . . . . . . 284.2. Uso de modulos externos . . . . . . . . . . . . . . . . . . . . . . . 35

5. Persistencia de datos 365.1. Uso de archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

5.1.1. Apertura de archivos . . . . . . . . . . . . . . . . . . . . . 375.1.2. Cierre de archivos . . . . . . . . . . . . . . . . . . . . . . 385.1.3. Lectura de archivos . . . . . . . . . . . . . . . . . . . . . . 385.1.4. Escritura de archivos . . . . . . . . . . . . . . . . . . . . . 415.1.5. Moverse en un archivo . . . . . . . . . . . . . . . . . . . . 425.1.6. Interrogando un archivo . . . . . . . . . . . . . . . . . . . 43

6. Anexo I 436.1. Licencia: GPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436.2. Peps (Python Enhancement Proposal o Propuestas de Mejora de

Python) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436.3. Donde bajarlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446.4. Referencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

45