Está en la página 1de 27

ANALISIS DEL LENGUAJE

PYTHON
INDICE:
INTRODUCCIÓN............................................PAG 1
PYTHON BÁSICO...........................................PAG 1
CONTROL DE FLUJO.....................................PAG 9
DEFINICIÓN DE FUNCIONES ......................PAG 12
MODULOS........................................................PAG 13
ENTRADA Y SALIDA DE FICHEROS .........PAG 16
MANEJO DE EXCEPCIONES ........................PAG 18
CLASES.............................................................PAG 20
LIBRERIAS INTERESANTES.........................PAG 24
REFERENCIAS BIBLIOGRÁFICAS...............PAG 26

Manual de Python hecho por:


Moisés Lorenzo León
ETSIT ULPGC

Se permite la copia, modificación y distribución libre


1. INTRODUCCIÓN

El nombre de Python proviene del espectáculo de la BBC “Monty Python Flying


Circus”, y fue creado por Guido van Rossum en el año 1990, influido por lenguajes
como ABC, TCL, Perl, Modula-3 o SmallTalk. Además ha sido usado de referencia
para nuevos lenguajes como Ruby o Boo, y dispone de varias diferentes
implementaciones como Cpython, Jython, IronPython y PyPy. En el año 91, el
código de Python fue publicado en internet y ya poseía capacidad de clases con
herencia, manejo de excepciones y funciones. Desde entonces, Python ha ido
avanzando a lo largo de los años, hasta el momento que se encuentra en la versión de
Python 2.5

La base de Python intenta hacer que el lenguaje sea fácilmente comprensible por los
programadores noveles, por lo que normalmente utiliza palabras en lugar de símbolos
(and en lugar de & y or en lugar de |)

Python utiliza un intérprete de comandos, pero permite la construcción de módulos


para su ejecución y también existe una versión para la compilación a lenguaje
máquina. Además posee paquetes especiales que permiten la integración e
intercambio con C++.

Para completar esta introducción, decir que Python es un lenguaje que se está
extendiendo a gran velocidad. Por ello, Python ya está usándose activamente en
aplicaciones como:

-Gestor de correo Mailman


-Herramienta de arqueología Carnarvon
-Sistema de ficheros de Gmail
-Aplicaciones de la NASA
-Aplicaciones de Youtube
-Plugins de Blender
-La distribución de Linux del proyecto “One Laptop per child”

Y muchos más.

2. PYTHON BÁSICO

Las variables de Python son generales. No hay que definir el tipo de la variable sino
que esta se inicializa al valor que se le indique. Python soporta los tipos de datos que
soportan casi todos los lenguajes, como enteros, flotantes, complejos, caracteres,
strings, etc. Normalmente las variables son utilizadas como listas escritas de forma
que se pueda trabajar con todos los datos como si se obtuvieran desde un vector.
Siempre es conveniente saber que variables hemos usado. Python no nos ofrece una
gran información sobre las variables usadas y por tanto, cuando hemos usado
muchas, podemos tener algún que otro problema. Para ello, se puede ejecutar el
comando globals().keys() que nos ofrecerá todas las variables creadas, además de
muchas que ha creado el propio interprete.

El manejo de números complejos puede ser utilizado con dos formatos. El primero de
ellos es mediante la notación habitual de Real + jComplejo. Sin embargo, para evitar
a veces confusiones, se puede utilizar la función Complex.

Ejemplo: Uso matemático de Python

>>> 2+2
4
>>> 3*4
12
>>> 9/4
2
>>> #El resto de la división se calcula mediante el símbolo %
>>> 9%4
1
>>> #La división entera siempre retorna el valor entero menor
>>> 11/4
2

>>> 1*2j
2j
>>> #Declaración de un numero complejo con notación real/compleja
>>> 1+2j
(1+2j)
>>> #Declaración mediante la función Complex
>>> complex(1,2)
(1+2j)
>>> #Se pueden hacer combinaciones de ambas notaciones
>>> (1+2j)+complex(3,1)
(4+3j)
>>> #También se pueden extraer los factores
>>> a=complex (2,3)
>>> a.real
2.0
>>> a.imag
3.0
>>> #En caso de no asignar el resultado a una variable, se puede utilizar el carácter _
>>> 2*4
8
>>> 4+_
12

Esto para trabajar con números. Sin embargo se puede trabajar de igual forma con las
cadenas de caracteres o los caracteres. Los caracteres o las cadenas de caracteres se
definen mediante los símbolos “ o ' independiente e indistintamente
Ejemplo: Uso de Python con caracteres

>>> "Universidad de Las Palmas de Gran Canaria"


'Universidad de Las Palmas de Gran Canaria'
>>> 'Universidad de Las Palmas de Gran Canaria'
'Universidad de Las Palmas de Gran Canaria'
>>> "Universidad de \
... Las Palmas de\
... Gran Canaria"
'Universidad de Las Palmas deGran Canaria'
>>> #Si se usa “”” se puede escribir literalmente el texto y cerrarlo con “””
>>> print """
... Menu:
... Opcion 1: Presionar a
... Opcion 2: Presionar b
... Opcion 3: Presionar c
... """

Menu:
Opcion 1: Presionar a
Opcion 2: Presionar b
Opcion 3: Presionar c

>>> #En cuanto a operaciones, se pueden concatenar y repetir con símbolos matemáticos
>>> palabra = 'Py' + 'thon'
>>> palabra
'Python'
>>> palabra*3
'PythonPythonPython'
>>> (palabra+' ') * 3
'Python Python Python '
>>> #El trabajo con las cadenas es muy flexible
>>> 'Py'+'thon'
'Python'
>>> palabra = 'Py' + 'thon'
>>> palabra
'Python'
>>> #Se puede repetir una secuencia como una multiplicación
>>> palabra*3
'PythonPythonPython'
>>> #Incluso hacer una operación un poco mas compleja
>>> (palabra+' ') * 3
'Python Python Python '
>>> #Seleccionar las partes de la cadena
>>> palabra[2]
't'
>>> palabra [4]
'o'
>>> palabra [5]
'n'
>>> #Si se sale de rango hay error
>>> palabra [6]
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
IndexError: string index out of range
>>> #Se puede seleccionar un rango
>>> palabra [:2]
'Py'
>>> palabra [2:]
'thon'
>>> palabra [2:4]
'th'
>>> #Para calcular la longitud de la cadena
>>> len (palabra)
6

Una de las opciones más potentes de Python es el uso de listas. Las listas pueden ser
de cualquier tipo y una misma lista puede tener diferentes tipos de dato. El uso de las
listas es igual a como se ha visto en las cadenas de caracteres. Lo podemos ver en el
siguiente ejemplo

Ejemplo: Listas y uso de listas

>>> receta = ['pan', 'carne', 'agua', 10, 50, 100]


>>> receta
['pan', 'carne', 'agua', 10, 50, 100]
>>> receta [1]
'carne'
>>> receta [0]
'pan'
>>> #Se puede seleccionar también con números negativos
>>> receta [-1]
100
>>> #Si se trata de acceder a un numero que no existe salta un error
>>> receta [6]
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
IndexError: list index out of range
>>> #Se pueden subseleccionar elementos
>>> receta [:3]
['pan', 'carne', 'agua']
>>> receta [3:]
[10, 50, 100]
>>> receta [2:5]
['agua', 10, 50]
>>> #No se pueden insertar datos si hay diferentes tipos de datos
>>> a[6]='plato'
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
TypeError: 'complex' object does not support item assignment
>>> #Además se puede hacer composiciones muchas mas complejas
>>> print """ Para la receta se pueden utilizar
... %d gramos de %s,
... %d trozos de %s y
... %d mililitros de %s """ % (receta[3],receta[0],receta[4],receta[1],receta[5],receta[2])
Para la receta se pueden utilizar
10 gramos de pan,
50 trozos de carne y
100 mililitros de agua

a) Opciones de listas y tratamiento como pilas y colas


Una de las opciones que nos permite Python es hacer varias operaciones
básicas con las listas y darles el tratamiento por ejemplo de pilas o colas. Para ello,
define una serie de funciones fácilmente comprensibles

Append (x) Count (x) Extend (L)


Index(x) Insert(i,x) Pop()
Sort() Remove(x) Reverse()

Para comprender más el significado de estas funciones, consultar las referencias.

Ejemplo: Listas como pilas y como colas

>>> a=[1,2,3,4,5,6,7,8]
>>> #Uso de listas como pilas (LIFO)
>>> a.append(9)
>>> print a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a.pop()
9
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]
>>> #Uso de listas como colas (FIFO)
>>> a.append(9)
>>> a.pop(0)
1
>>> a
[2, 3, 4, 5, 6, 7, 8, 9]

b) Funciones filter, map y reduce

Estas otras tres funciones pueden ser bastante interesantes llegado el caso, pues nos
permite un trabajo con listas mucho mas potente.
La función filter(f,x), siendo f una función y x una secuencia, nos permite filtrar y
devolver una secuencia resultado de una función específica, en lugar de introducir a
mano todos los elementos y organizar la función con bucles

Ejemplo: Función filter


>>> #Uso de función con filter
>>> #función que calcula los números impares
>>>def f(x): return x%2 != 0
...
>>> filter (f, range (2, 15))
[3, 5, 7, 9, 11, 13]
La función map (f,x) llama a la función f con cada uno de los elementos de una
secuencia y devuelve una lista con cada valor de la función

Ejemplo: Función map


>>> #Uso de la función map
>>> #Retornar el doble de los valores
>>> def g(x): return 2*x
...
>>> map (g,range(1,10))
[2, 4, 6, 8, 10, 12, 14, 16, 18]

Por último la función reduce(f,x) calcula la función primero con los dos elementos de
la lista y el resultado con el siguiente elemento, y así hasta el final

Ejemplo: función reduce

>>> #Uso de la función reduce


>>> #Retornar la suma de los elementos de una lista
>>> def suma (x,y): return x+y
...
>>> reduce (suma, range(1,11))
55

c)Listas autodefinidas

Cuando las listas son pequeñas, pueden introducirse a mano sin necesitar mucho
tiempo. Sin embargo cuando las listas llevan un gran numero de elementos, se hace
tedioso e inseguro introducir a mano los elementos, ya que nos podemos saltar
alguno, introducir alguno erróneo, etc, y eso haría que nuestros programas fallasen
sin saber muy bien por qué. Python da la oportunidad de utilizar listas autodefinidas
para solucionar este problema

Ejemplo: Listas autodefinidas

>>> #Ejemplo de declaración de listas autodefinidas y su uso


>>> a=[x for x in range(1,20)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> b=[2*x for x in range(1,20)]
>>> b
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38]
>>> c = [b[x]+a[x] for x in range (0, 19)]
>>> #Hay que recordar que en este caso usamos este rango porque a la hora de hacer referencia se empieza en 0
>>> c
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57]

d) La sentencia del
La sentencia del se utiliza para eliminar elementos de una lista, o una
lista completa.

Ejemplo: Sentencia del


>>> #Uso de la secuencia del
>>> a=[x for x in range (1, 20)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> del a[0]
>>> a
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> del a[5:9]
>>> a
[2, 3, 4, 5, 6, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> del a[10:]
>>> a
[2, 3, 4, 5, 6, 11, 12, 13, 14, 15]
>>> del a[:3]
>>> a
[5, 6, 11, 12, 13, 14, 15]
>>> del a
>>> a
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
NameError: name 'a' is not defined

e) Tuplas, conjuntos y diccionarios


Estos tres tipos también son una parte fundamental del lenguaje Python,
ya que permiten un mejor uso de las listas y extienden sus posibilidades.
Una tupla es muy parecido a una lista, solo que estas se pueden anidar y separar. Son
muy útiles sobre todo cuando se quieren dar por ejemplo coordenadas

Ejemplo: Uso de tuplas

>>> #Uso de tuplas como coordenadas,


>>> x=22.4, 34.5, 12.9
>>> x
(22.4, 34.5, 12.9)
>>> x
(22.4, 34.5, 12.9)
>>> y=12.8, 32.7, 44.7
>>> y
(12.8, 32.7, 44.7)
>>> z=x,y
>>> z
((22.4, 34.5, 12.9), (12.8, 32.7, 44.7))
>>> z[0]
(22.4, 34.5, 12.9)
>>> z[1]
(12.8, 32.7, 44.7)

Los conjuntos son elementos desordenados sin ningún duplicado que normalmente se
usan para la comprobación y el borrado de los mismos. Nos ayudan a mantener los
elementos de diferentes tipos separados para su uso

Ejemplo: Uso de conjuntos

>>> #Ejemplos de conjuntos. El primero es de búsqueda y el siguiente de operaciones con conjuntos


>>> frutas = set (['manzana', 'higo pico', 'mandarina'])
>>> plantas = set (['tabaiba', 'cardon', 'bejeque'])
>>> 'manzana' in frutas
True
>>> 'cardon' in plantas
True
>>> 'higo pico' in plantas
False
>>> a=set('supercalifragilisticoespialidoso')
>>> b=set('abracadabra')
>>> a
set(['a', 'c', 'e', 'd', 'g', 'f', 'i', 'l', 'o', 'p', 's', 'r', 'u', 't'])
>>> b
set(['a', 'r', 'b', 'c', 'd'])
>>> a-b
set(['e', 'g', 'f', 'i', 'l', 'o', 'p', 's', 'u', 't'])
>>> a & b #and
set(['a', 'c', 'r', 'd'])
>>> a | b #or
set(['a', 'c', 'b', 'e', 'd', 'g', 'f', 'i', 'l', 'o', 'p', 's', 'r', 'u', 't'])
>>> a ^ b #xor
set(['b', 'e', 'g', 'f', 'i', 'l', 'o', 'p', 's', 'u', 't'])

Los diccionarios son otra de las grandes herramientas de Python. Ofrece definir los
elementos mediante una clave o key y a la hora de hacer referencia esto es mucho
mas claro, evita errores y el código queda mucho más legible. En lugar de definirse
con corchetes como las listas, se definen mediante llaves, aunque sí se referencian
con corchetes.

Ejemplo: Diccionarios

>>> telefonos = {'ana':652947583, 'pedro':6385927583, 'juan': 628394756, 'maria':623774135}


>>> telefonos
{'juan': 628394756, 'pedro': 6385927583L, 'ana': 652947583, 'maria': 623774135}
>>> telefonos['juan']
628394756
>>> telefonos['laura']
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
KeyError: 'laura'
>>> telefonos['laura']=654882761
>>> telefonos
{'laura': 654882761, 'juan': 628394756, 'pedro': 6385927583L, 'ana': 652947583, 'maria': 623774135}
>>> telefonos.keys()
['laura', 'juan', 'pedro', 'ana', 'maria']
>>> telefonos.values()
[654882761, 628394756, 6385927583L, 652947583, 623774135]
>>> telefonos.has_key('javier')
False
>>> for k,l in telefonos.iteritems():
... print k,l
...
laura 654882761
juan 628394756
pedro 6385927583
ana 652947583
maria 623774135

3. Control de flujo

Como todos los lenguajes modernos, Python tiene estructuras típicas de control de
flujo, como las estructuras if, los bucles y algunas otras sentencias que sirven para
controlar el transcurso de los programas. Para agrupar las diferentes estructuras no se
utilizan palabras reservadas para definir los límites de la estructura, sino que se
utilizará el sangrado para ello. Esto tiene la ventaja de que se puede leer mucho mejor
el código, pero como gran desventaja es que para los programadores noveles puede
ser un problema y pueden tener muchos errores de ejecución debido a esto.

a) Sentencias if
Las sentencias if son casi idénticas al resto de los lenguajes. Vemos
algunos ejemplos de ellas

Ejemplo: Estructuras if

>>> x=int (raw_input ("Introducir un numero: "))


>>> #Esta opción nos muestra un cuadro en el que tenemos que introducir un numero (introducimos el 4)
>>> if x >= 0:
... if x == 0:
... print 'Cero'
... elif x == 1:
... print 'Uno'
... elif x == 2:
... print 'Dos'
... else:
... print 'Mas de dos'
...
Mas de dos

Cabe reseñar que la estructura de las sentencias if se forma con el estilo:

if_stmt: "if" expresion ":" cuerpo


("elif" expresion ":" cuerpo)*
["else" ":" cuerpo]
b) Sentencias for/while
Al igual que el resto de lenguajes, los bucles son parte fundamental del
lenguaje Python. Los bucles en Python son normalmente usados para el recorrido en
las listas, aunque también puede ser usados con valores. Para usar los valores se
utiliza la sentencia range que lo que hace es crear una lista de números. Veamos los
ejemplos

Ejemplo: Sentencia range

>>> range (1, 10)


[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range (1, 10, 2)
[1, 3, 5, 7, 9]
>>> range (0, 10 ,2)
[0, 2, 4, 6, 8]
>>> range (-10, 10, 2)
[-10, -8, -6, -4, -2, 0, 2, 4, 6, 8]
>>> range (-10, -20, 2)
[]
>>> range (-10, -20, -2)
[-10, -12, -14, -16, -18]
>>> range (-10, 10, 3)
[-10, -7, -4, -1, 2, 5, 8]

Ejemplo: Sentencia for

x= ['Universidad' , 'de' , 'las' , 'Palmas' , 'de' , 'Gran', 'Canaria']


>>> x
['Universidad', 'de', 'las', 'Palmas', 'de', 'Gran', 'Canaria']
>>> #Se pueden usar las listas completas
>>> for a in x:
... print a
...
Universidad
de
las
Palmas
de
Gran
Canaria
>>> #O se pueden usar partes de las listas
>>> for a in x[:4]:
... print a
...
Universidad
de
las
Palmas
>>> for a in x[3:]:
... print a
...
Palmas
de
Gran
Canaria
>>> #también se puede crear una lista numérica para recorrerla
>>> for a in range (0,10):
... print a
...
0
1
2
3
4
5
6
7
8
9

La sentencia que define los bucles for es la siguiente:


for_stmt: "for" variable_local "in" lista ":" cuerpo
["else" ":" cuerpo]

Ejemplo: Sentencias while


>>> while a != 10:
... print a
... a=a+1
...
0
1
2
3
4
5
6
7
8
9

La definición de la sentencia while se hace de la forma


while_stmt: "while" expresion ":" cuerpo
["else" ":" cuerpo]

c) Sentencias break, continue y pass

La sentencia break se utiliza como en otros lenguajes para detener un bucle cuando se
desee dentro del propio bucle.

La sentencia continue se utiliza para pasar a la siguiente iteración de un bucle sin que
se llegue al final del bucle, de forma que no se ejecute la última parte del bucle.
La sentencia pass no hace nada, sino que se usa para rellenar aquellos huecos de
bucles o sentencias if que no tengan nada.

4. Definición de funciones

Esta claro que en todos los lenguajes modernos pueden crear funciones de forma que
puedan llamar a una serie de líneas de código desde cualquier parte del código de
nuestro programa. Esto tiene la ventaja de no tener que escribir varias veces el mismo
código, sobre todo si este código es repetitivo y muy largo. En Python es posible
definir funciones que devuelvan un valor. Veamos el ejemplo de la declaración de
funciones

Ejemplo: Definición de funciones


def Confirmar (indicador, intentos = 4):
... while True:
... respuesta = raw_input (indicador)
... if respuesta in ('s', 'si'):
... return True
... elif respuesta in ('n', 'no'):
... return False
... if intentos < 0:
... print 'Usuario rechazado'
... return False
...

>>> Confirmar ('Salir?')

Esta función por ejemplo nos pediría confirmación de alguna operación. En caso de
responder 'si' se saldría del programa con un True. En caso de responder 'no' se
saldría del programa pero con un False.

Al igual que ADA, por ejemplo, se puede definir una función e introducir una palabra
clave, o el valor directo de los parámetros, o bien combinarlos ambos. Veamos un
ejemplo

Ejemplo: función con palabras clave


>>> def Animal (raza, peso, tamano, edad):
... print " Se trata de un", raza,
... print " que pesa aproximadamente ", peso, " kilos."
... print " Mide ", tamano, " centimetros, y tiene ", edad, " años"
...

>>> #Se puede llamar sin palabra clave


>>> Animal ('perro',20,60,2)
Se trata de un perro que pesa aproximadamente 20 kilos.
Mide 60 centimetros, y tiene 2 años
>>> #Se puede llamar con unos con palabra clave y otros no
>>> Animal ('perro', edad=2, tamano=60, peso=20)
Se trata de un perro que pesa aproximadamente 20 kilos.
Mide 60 centimetros, y tiene 2 años
>>> #Sin embargo una vez se usa una palabra clave se debe usar en el resto de argumentos
>>> Animal (raza='perro',2,60,20)
Traceback ( File "<interactive input>", line 1
SyntaxError: non-keyword arg after keyword arg (<interactive input>, line 1)

Tras las primeras versiones de Python, se decidió introducir una característica de Lisp
que permite crear pequeñas funciones anónimas mediante la palabra lambda que
después permite ir ejecutando ese pequeño código

Ejemplo: Funciones lambda

>>> f=lambda x: x+1


>>> f(1)
2
>>> f(3)
4
>>> g=lambda x: x+x
>>> g(4)
8
>>> g(10)
20

5. Módulos

Al no ser Python un lenguaje como C o ADA, en el que se tiene que


crear un fichero que contenga al código para compilarlo, Python ofrece la posibilidad
de ir probando pequeñas líneas de código en el intérprete de comandos. Sin embargo,
cuando salimos de Python, esas pequeñas líneas se eliminan, y si queremos ejecutar
de nuevo lo mismo o enviarlo a alguien, no podríamos. Es por ello que Python
incorpora la capacidad de guardar módulos para poder guardar aquellas funciones que
hayamos hecho y después ejecutarlas en el intérprete.
Los módulos se crean en cualquier editor de textos (las distribuciones de interpretes
de Python suelen traer un pequeño editor, pero vale cualquiera. Aun así siempre es
preferible uno con sangrado automático para evitar errores), siempre con la extensión
“.py” y después son importados desde la línea de códigos para hacer referencia a
ellos.

Hay que remarcar que si se hace un uso de un modulo y hay que cambiarlo, se debe
volver a importar el modulo de la forma reload(nombre) o de la forma

del(nombre)
import(nombre)
Ejemplo: Uso de módulos

#Ejemplo de como definir módulos


#modulo ejemplo.py

def Suma(x,y): #Sumaremos dos listas de igual tamano


resultado =[]
for a in x:
for b in x:
if a == b:
resultado.append(x[a]+y[b])
elif a != b:
pass
else:
pass
print resultado

def Resta (x,y): #Restaremos dos listas de distinto tamano


resultado =[]
for a in x:
for b in x:
if a == b:
resultado.append(x[a]-y[b])
elif a != b:
pass
else:
pass
return resultado

>>> import ejemplo


>>> x=[a for a in range (0,10)]
>>> y=[3*b for b in range (0,10)]
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> y
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
>>> ejemplo.Suma(x,y)
[0, 4, 8, 12, 16, 20, 24, 28, 32, 36]
>>> ejemplo.Resta(x,y)
[0, -2, -4, -6, -8, -10, -12, -14, -16, -18]
>>> #El return dentro de la función nos proporciona la siguiente utilidad
>>> a=ejemplo.Suma(x,y)
[0, 4, 8, 12, 16, 20, 24, 28, 32, 36]
>>> a
>>> a=ejemplo.Resta(x,y)
>>> a
[0, -2, -4, -6, -8, -10, -12, -14, -16, -18]

En el caso de no querer estar llamando continuamente al modulo para llamar a la


función, sino simplemente llamar a la función, existe la posibilidad de hacer lo
siguiente
Ejemplo: Uso de módulos sin hacer la referencia en cada función
>>> from ejemplo import Suma
>>> Suma(x,y)
[0, 4, 8, 12, 16, 20, 24, 28, 32]
>>> Resta(x,y) #Ocasiona un error al haberlo llamado sin importarlo
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
NameError: name 'Resta' is not defined
>>> from ejemplo import Resta
>>> Resta(x,y)
[0, -2, -4, -6, -8, -10, -12, -14, -16]
>>> del Suma
>>> del Resta
>>> from ejemplo import * #Con un asterisco se pueden importar todas las funciones de un modulo
>>> Suma(x,y)
[0, 4, 8, 12, 16, 20, 24, 28, 32]
>>> Resta(x,y)
[0, -2, -4, -6, -8, -10, -12, -14, -16]

Una de las herramientas que podemos usar con los módulos es la sentencia dir(). Esta
nos permite explorar los módulos de forma que sepamos lo que contiene cada uno.
Hagamos un dir() al modulo creado

>>> import ejemplo


>>> dir (ejemplo)
['Resta', 'Suma', '__builtins__', '__doc__', '__file__', '__name__']

Vemos que aparte de nuestras funciones, existe también '__builtins__' que contiene
los paquetes de construcción del modulo. '__doc__' que contiene la documentación
del módulo. '__file__' que nos especifica el fichero del modulo. Y por ultimo
'__name__' que nos proporciona el nombre del modulo.

a) Paquetes

Los paquetes son también de gran utilidad en Python. Agrupa una serie de módulos
de forma que haciendo referencia a ese paquete se pueda obtener el modulo deseado.
Por ejemplo, en caso de tener una serie de ficheros “.py” y querer agruparlos en un
paquete, se podría hacer la siguiente asignación de directorios

#Implementación de un paquete
Python/
__init__.py
Ejemplos/
__init__.py
ejemplo1.py
ejemplo2.py
ejemplo3.py
Ficheros/
__init__.py
fichero1.py
fichero2.py
fichero3.py

>>> #La llamada a uno de los paquetes seria por ejemplo


>>> import Python.Ejemplos.ejemplo2
>>> #Y la referencia también se haría
>>> Python.Ejemplos.ejemplo2()

Vemos que en cada directorio existe el archivo __init__.py. Este archivo es


obligatorio ponerlo aunque solo sea un fichero vacío, ya que con este, Python trata al
directorio como un paquete. Sin embargo es muy útil incluir dentro de cada uno de
esos ficheros la sentencia __all__=[“ejemplo1”,”ejemplo2”,”ejemplo3”] (este es
para el directorio de ejemplos), ya que con esto conseguiríamos que al ejecutar la
sentencia >>>from Python.Ejemplos import * nos importase los tres módulos en
conjunto.

6. Entrada y salida de ficheros

Python puede trabajar con ficheros externos, tanto escribirlos como leerlos y además
con algunas opciones que le dan bastante potencia.
A la hora de abrir un fichero se haría por ejemplo lo siguiente:

>>> f=open('C:\prueba.txt', 'r')


>>> print f
<open file 'C:\prueba.txt', mode 'r' at 0x00E41218>

Comprobamos que hemos abierto con modo 'r' que implica solo lectura. también es
posible abrir de modo 'w' de escritura, 'a' para añadir datos al final del fichero, y
después también hay posibilidad de escribir modo 'b' para datos binarios. Si ahora
queremos leer el fichero que acabamos de abrir lo haríamos de forma:

>>> f.read()
'Este es el contenido de un fichero de prueba'

También podríamos leer hasta que se comprueba que se encuentra el carácter \n de


nueva línea para leer línea a línea. Cada vez que se ejecuta el comando readline() se
lee la siguiente línea.

>>> f.readline()
'primera línea de fichero\n'
>>> f.readline()
'segunda línea de fichero'
>>> f.readline()
''

Siguiendo con las opciones de lectura, la opción tell indica en número de bytes la
posición en la que se encuentra el desplazamiento del fichero que vamos recorriendo
>>> f=open ("C:\prueba.txt", 'r')
>>> f.tell()
0L
>>> f.readline()
'primera línea de fichero\n'
>>> f.tell()
26L
>>> f.readline()
'segunda línea de fichero\n'
>>> f.tell()
52L

Si queremos modificar esa posición para situarnos en algún sitio exacto, podemos
usar la opción seek(desplazamiento, origen) siendo la opción desplazamiento
obligatoria mientras que el origen es opcional, ya que si no se pone se supondrá el
origen el inicio del fichero. Si se escribe un 1 será la posición actual, y si se escribe
un 2 será el fin del fichero

>>> f=open ("c:\prueba.txt", 'r')


>>> f
<open file 'c:\prueba.txt', mode 'r' at 0x00E41218>
>>> f.tell()
0L
>>> f.readline()
'primera línea de fichero\n'
>>> f.tell()
26L
>>> f.seek(5)
>>> f.readline()
'ra línea de fichero\n'
>>> f.seek(-10,2)
>>> f.tell()
91L
>>> f.readline()
'de fichero'

Por supuesto, cuando no se quiera seguir utilizando el fichero se utilizara la directiva


close

>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
ValueError: I/O operation on closed file

En caso de querer utilizar cadenas de caracteres es muy sencillo hacer las


operaciones. Cuando se utilizan números se pueden hacer cambios con la directiva
int() para transformar las strings a numero. Sin embargo si queremos guardar datos
mas complejos, como diccionarios o tuplas, existe una directiva muy potente llamada
pickle() que introduce cualquier dato complejo en un fichero. Esto se puede ver en el
siguiente ejemplo
>>> x={'nombre': 'juan', 'telefono': 3342563}
>>> x
{'nombre': 'juan', 'telefono': 3342563}
>>> f=open("C:\prueba2.txt",'w')
>>> import pickle
>>> pickle.dump(x,f)
>>> f.readline()
'em(inst.__dict__, key, value) in a\n'
>>> y=pickle.load(f)
>>> y
{'nombre': 'juan', 'telefono': 3342563}

Para mas usos de los ficheros y del modulo pickle, leer las bibliotecas de los módulos.

7. Manejo de excepciones

Otra de las opciones del lenguaje Python es controlar las excepciones y los errores de
ejecución. Para ello, se ofrecen unas directivas que capturan las excepciones, o las
elevan. Por ejemplo, veamos el error que se produce en la siguiente sentencia:

>>> x=int(raw_input("Introduce un numero: "))


Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'a'

Comprobamos que se eleva la excepción ValueError. En caso de querer capturar la


excepción y seguir pidiendo el número se hace lo siguiente:

>>> while True:


... try:
... x= int (raw_input("Introduce un numero: "))
... break
... except ValueError:
... print "Eso no es un numero. Inténtalo de nuevo"
...
Eso no es un numero. Inténtalo de nuevo
Eso no es un numero. Inténtalo de nuevo
>>> x
4

Observamos que la sentencia try se utiliza para después declarar las excepciones. Se
pueden utilizar varias excepciones en cadena e incluso se puede utilizar una
excepción genérica para los casos que no se hayan contemplado. Por ejemplo

>>> while True:


... try:
... x= int (raw_input("Introduce un numero: "))
... y=1/x
... z=x+1
... break
... except ZeroDivisionError:
... print "No puedes dividir por cero"
... except ValueError:
... print "Debes utilizar un numero"
... except:
... "Error desconocido. Inténtalo de nuevo"
...
Debes utilizar un numero
Debes utilizar un numero
No puedes dividir por cero

Cuando salta una excepción también se puede acompañar de los argumentos que se
desee. así podemos tener más datos del error que se ha producido. Vemos el siguiente
ejemplo:

>>> try:
... raise Exception ('Nombre', 'Incorrecto')
... except Exception, inst:
... print inst
... x,y=inst
... print 'Error debido a un ', x, y
...
('Nombre', 'Incorrecto')
Error debido a un Nombre Incorrecto

En caso de no querer hacer nada después de que salte la excepción sino determinar
que salto una excepción, lo mejor es relanzarla de la forma:

>>> try:
... raise NameError, 'Error grave'
... except NameError:
... print 'Ha saltado una excepción'
... raise
...
Ha saltado una excepción
Traceback (most recent call last):
File "<interactive input>", line 2, in <module>
NameError: Error grave

También se pueden definir las propias excepciones. Para ello se crean la clase base y
las diferentes clases derivadas de cada una de las excepciones. Veremos eso en el
próximo tema.

Por ultimo, se puede generar una acción de limpieza que se ejecute tanto si se ejecuta
la excepción como si no. Esto se haría de la forma:

>>> try:
... raise KeyboardInterrupt
... finally:
... print 'Adios, nos vamos del programa'
...
Adios, nos vamos del programa
Traceback (most recent call last):
File "<interactive input>", line 2, in <module>
KeyboardInterrupt

8. Clases

Al igual que los lenguajes más modernos, el lenguaje Python introduce opciones de
trabajar con clases. Esto proporciona una gran potencia de los nuevos lenguajes, y
que permite muchas variantes en los programas. Vemos como podemos definir una
clase

>>> class Ejemplo:


... "Clase ejemplo"
... #Definimos las variables
... numero=1
... #Definimos las funciones
... def f(self):
... return 'Hola mundo'
... def g(self,x):
... print x
...
>>> a=Ejemplo()
>>> a.f()
'Hola mundo'
>>> a.g(a.numero)
1

Cuando una clase define un método __init__, se puede obtener una nueva instancia
que permite una mayor flexibilidad de trabajo con las clases. Por ejemplo:

>>> class Complejo:


... def __init__ (self, Real, Imag):
... self.r = Real
... self.i = Imag
...
>>> x = Complejo (2.0, 5.0)
>>> x.r, x.i
(2.0, 5.0)

a) Objetos instancias y objetos métodos

Otra de las posibilidades que tiene Python es utilizar los objetos instancias y objetos
métodos.
Recordamos que la instanciación es llevar a una variable la declaración de una clase
(Ej: x = Clase()). Python proporciona que se pueda crear una variable dentro de la
clase y hacerla desaparecer con la misma rapidez. Son los llamados objetos
instancias. Estos objetos son bastante peligrosos pues si se hace mala referencia a
ellos pueden hacer que una clase crezca de manera ilimitada.
Ejemplo:

>>> class MiClase:


... i=1
... def f(self):
... print "Hola Mundo"
...
>>> x=MiClase()
>>> x
<__main__.MiClase instance at 0x00E39E90>
>>> x.contador = 1
>>> x
<__main__.MiClase instance at 0x00E39E90>
>>> while x.contador < 10:
... x.contador = x.contador * 2
...
>>> print x.contador
16
>>> del x.contador
>>> x.contador
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
AttributeError: MiClase instance has no attribute 'contador'

En cuanto a los objetos método, normalmente se llaman de la forma clase.metodo. En


este caso, podemos hacer referenciar a un objeto un método, de forma que después
podamos llamar al objeto y se referencie directamente a ese método.

Ejemplo:

>>> xmetodo = x.f


>>> i=1
>>> while i<10:
... xmetodo()
... i=i+1
...
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo

b) Herencia
Python ofrece el potencial de la herencia que también ofrecen otros lenguajes.
Recordamos que herencia es crear una clase derivada de una clase padre, de forma
que la clase derivada mantiene las instancias y los atributos de la clase padre. Veamos
un fácil ejemplo:

>>> class Tabaiba:


... especie = 'planta'
... def leer(self, especie):
... print especie
...
>>> class TabaibaDulce(Tabaiba):
... tipo = 'dulce'
... def leerdulce (self, especie, tipo):
... print especie, tipo
...
>>> class TabaibaAmarga(Tabaiba):
... tipo = 'amarga'
... def leeramarga(self, especie, tipo):
... print especie, tipo
...
>>> x=Tabaiba()
>>> y=TabaibaDulce()
>>> z=TabaibaAmarga()
>>> x.leer(x.especie)
planta
>>> y.leerdulce(y.especie,y.tipo)
planta dulce
>>> z.leeramarga(z.especie, z.tipo)
planta amarga

Cabe destacar que Python también ofrece herencia de múltiples clases padres. Un
ejemplo sería:

>>> class LuchaCanaria:


... movimiento='maña: '
... def leer (self,movimiento):
... print movimiento
...
>>> class Cogida:
... tipo='cogida de '
... def leer (self, tipo):
... print tipo
...
>>> class Muslo:
... zona = 'muslo'
... def leer (self, zona):
... print zona
...
>>> class Cogidademuslo(LuchaCanaria, Cogida, Muslo):
... x=LuchaCanaria()
... y=Cogida()
... z=Muslo()
... def leertodo(self,movimiento,tipo,zona):
... print movimiento,tipo,zona
...
>>> h=Cogidademuslo()
>>> h.leertodo(h.x.leer(h.movimiento),h.y.leer(h.tipo), h.z.leer(h.zona))
maña:
cogida de
muslo
None None None

Vemos que en este caso, lo que se pasa a h.leertodo son las funciones de imprimir,
por lo que nos viene en diferentes líneas. Cabe resaltar una cosa: Si existen varias
funciones llamadas iguales en las diferentes clases, hay que hacer referencia a que
clase procede (en el ejemplo h.x.leer, h.y.leer, ...), pero si solo existe una función, se
puede llamar directamente. Sin embargo, en caso de quererlo todo en una línea, lo
que hacemos es pasarle los parámetros directamente

>>> h.leertodo(h.movimiento,h.tipo,h.zona)
maña: cogida de muslo

c)Variables públicas y privadas

Al igual que en otros lenguajes, Python proporciona la posibilidad de declarar


variables de tipo privado. Para ello, las variables deben declararse con dos guiones
bajos al inicio del nombre. El resto de variables públicas se declaran de forma
natural. Por ejemplo:

>>> class Potaje:


... __potaje='que rico'
... comer ='ñam'
... def leer(self,var1,var2):
... print var1, var2
...
>>> p.leer(p.comer,p.__potaje)
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
AttributeError: Potaje instance has no attribute '__potaje'

Observamos que entonces solo se puede hacer referencia a esta variable privada en el
interior de la clase

>>> class Potaje:


... __potaje='que rico'
... comer ='ñam'
... def leer(self,var1):
... print var1, self.__potaje
...
>>> p=Potaje()
>>> p.leer(p.comer)
ñam que rico

Por ultimo comentar sobre las clases dos cosas más. La primera es que puede crearse
una clase que funcione como un record en ADA o como un struct en C. Un ejemplo
sería:
>>> class Agenda:
... pass
...
>>> juan=Agenda()
>>> juan.nombre='Juan'
>>> juan.telefono='928663557'
>>> print "%s: %s" % (juan.nombre, juan.telefono)
Juan: 928663557

La otra cosa a comentar es recordar del capitulo anterior que las excepciones también
son clases. así que, podemos definir nuestras propias excepciones de la siguiente
forma:

>>> class ErrorTipo(Error):


... def __init__ (self, expresion, mensaje):
... self.expresion=expresion
... self.mensaje=mensaje

>>> err_type=ErrorTipo('Atencion','Error en el tipo de datos')


>>> try:
... raise err_type
... except ErrorTipo:
... print err_type.expresion,err_type.mensaje
...
Atencion Error en el tipo de datos

Con esto queda explicado Python básico. A continuación, el último tema se va a


dedicar a librerías de gran uso que nos pueden ser de utilidad al estar programando en
Python.

9. librerías interesantes

a) Modulo os
El modulo os nos proporciona intercambio de datos con el sistema operativo. Por
ejemplo:

>>> import os
>>> os.getcwd()
'C:\\Python25'
>>> os.mkdir('C:\Python25\Ejemplosmios')
>>> os.chdir('C:\Python25\Ejemplosmios')
>>> os.getcwd()
'C:\\Python25\\Ejemplosmios'

b) Patrones de cadenas
Si queremos buscar patrones en diferentes cadenas de caracteres, el modulo re nos
permite hacerlo. Por ejemplo:
>>> import re
>>> re.findall(r'\bq[a-z]*','de que quieres que me queje')
['que', 'quieres', 'que', 'queje']

c) Modulo random
El modulo random nos permite hacer elecciones aleatorias en nuestros programas.
Por ejemplo:

>>> import random


>>> random.choice(['manzana','pera','piña'])
'piña'
>>> random.sample(xrange(100),10) #Muestreamos diez veces de un rango de 100 números
[64, 10, 29, 61, 91, 90, 83, 13, 34, 52]
>>> random.randrange(6) #Muestreamos una vez de un rango de 6
3

d) Acceso a internet
Si queremos acceder a internet, hay dos módulos básicos. Uno es el de obtener la
URL y otro es para enviar correo electrónico. Por ejemplo:

>>>import urllib2
>>> for línea in urllib2.urlopen('http://www.iuma.ulpgc.es/users/jmiranda'):
... if 'Javier' in línea:
... print línea
...
<TITLE>Javier Miranda's Ada Corner</TITLE>
<META NAME="description" CONTENT="Javier Miranda's Ada Corner">
<H1 ALIGN="CENTER">Javier Miranda's Ada Corner</H1>
<LI><B>Author:</B> Javier Miranda
Javier Miranda was born in 1965 in Canary Islands (Spain). He studied
Javier Miranda

>>> import smtplib


>>> servidor = smtplib.SMTP('localhost')
>>> servidor.sendmail('moises@ejemplo.org', 'lector@ejemplo.org',
"""To: lector@ejemplo.org
From: moises@ejemplo.org

Hola.
""")
>>> server.quit()

e) Fecha y hora
también existe un paquete que permite trabajar con fechas y horas. Por ejemplo

>>> from datetime import date


>>> ahora=date.today()
>>> ahora
datetime.date(2007, 5, 14)
>>> import time
>>> time.ctime()
'Mon May 14 23:40:46 2007'
>>> time.localtime()
(2007, 5, 16, 17, 25, 58, 2, 136, 1)
f) Compresion de datos
Por ultimo vamos a ver un modulo que comprime y descomprime datos. Se trata del
modulo zlib, aunque existen algunos más. Un ejemplo de este módulo sería:

>>> import zlib


>>> cadena ='Cadena cadena cadena cadena'
>>> len (cadena)
27
>>> compresion=zlib.compress(cadena)
>>> len (compresion)
18
>>> zlib.decompress(compresion)
'Cadena cadena cadena cadena'

Con esto terminamos el manual básico del lenguaje Python. Para más información, se
agrega el apartado 10 con páginas de referencia donde aprender todo sobre este
lenguaje.

10. Referencias bibliográficas

Manual completo más mucha informacion:


http://pyspanishdoc.sourceforge.net
Toda la documentación:
http://docs.python.org/
Colección completa de librerías de Python
http://www.python.org/pypi/
Libro “Dive into Python”
http://almacen.gulic.org/diveintopython-5.4-es/toc/
Otra introducción a Python
http://users.servicios.retecal.es/tjavier/archivos/IntroduccionPython.pdf
introducción a Python muy útil
http://es.tldp.org/Tutoriales/Python/tut.pdf
Más Python
http://users.servicios.retecal.es/tjavier/python/intpython/index.html
Pagina de la librería Pygame que permite crear juegos en Python
http://www.pygame.org
librerías de Python
http://docs.python.org/lib/lib.html
Pagina de las librerías RDFLib para Python para trabajar los RDF
http://rdflib.net
Distribuciones del intérprete
http://python.org/download/