Download 8531_2.A.Capitulo_In..

Lenguajes Interpretados
Francisco Bórquez
Departamento de Informática
Universidad Técnica Federico Santa María
1er SEM,2010
Departamento de Informática
Universidad Técnica Federico Santa María
Script/Guión
• Si en alguna ocasión has escrito un guion largo
para un intérprete de órdenes (o shell script),
puede que conozcas esta sensación:
• Te encantaría añadir una característica más, pero
ya es tan lento, tan grande, tan complicado...O la
característica involucra una llamada al sistema u
otra función accesible sólo desde C.
• El problema en sí no suele ser tan complejo como
para transformar el guion en un programa en C.
Igual el programa requiere cadenas de longitud
variable u otros tipos de datos (como listas
ordenadas de nombres de archivo) fáciles en sh,
pero tediosas en C.
• O quizá no tienes tanta soltura con C.
Departamento de Informática
Lenguajes de Programación ILI-153
2
Script/Guión
• Otra situación: Quizá tengas que trabajar
con bibliotecas de C diversas y el ciclo
normal en C de escribir-compilar-probarrecompilar es demasiado lento.
• Necesitas desarrollar software con más
velocidad.
• Posiblemente has escrito un programa al
que vendría bien un lenguaje de extensión
y no quieres diseñar un lenguaje, escribir y
depurar el intérprete y adosarlo a la
aplicación.
Departamento de Informática
Lenguajes de Programación ILI-153
3
Lenguajes Scripting
• Típicamente un lenguaje usado para programas
cortos para manejar otros programas.
• Interpretado, tipado dinámico, permisivo en la
semántica
• Usualmente minimalista en las declaraciones
• Usualmente compuesto por un conjunto rico de
operaciones con strings (el último dato no tipado)
• Fácil de interactuar con interfaces de Sistema
Operativo, archivos y manipulación de archivos
• Control de estructuras especializado:
– regular expressions – expresiones regulares (Perl)
– dictionaries - diccionarios (Python)
Departamento de Informática
Lenguajes de Programación ILI-153
Python: un híbrido moderno
• Un lenguaje de scripting y prototipado
• Equilibrado entre extensibles y
poderosas pre construidas estructuras
de datos
• Genealogía:
– Setl (NYU, J.Schwartz et al. 1969-1980)
– ABC (Amsterdam, Meertens et al. 1980-)
– Python (Van Rossum et all. 1996-)
• Una comunidad open-source muy
activa
Departamento de Informática
Lenguajes de Programación ILI-153
Python
• Python es un lenguaje de programación
fácil de aprender y potente. Dispone de
eficaces estructuras de datos de alto nivel
y una solución de programación orientada
a objetos simple pero eficaz.
• La elegante sintaxis de Python, su gestión
de tipos dinámica y su naturaleza
interpretada hacen de él el lenguaje ideal
para guiones (scripts) y desarrollo rápido
de aplicaciones en muchas áreas y en la
mayoría de las plataformas.
Departamento de Informática
Lenguajes de Programación ILI-153
Python
• fue creado por Guido van Rossum
(http://www.python.org/~guido/)
• Da este nombre al lenguaje inspirado
por el popular grupo cómico británico
del espectáculo de la BBC ”Monty
Python's Flying Circus'' (el circo
ambulante de Monty Python)
• Guido creó Python durante unas
vacaciones de navidad en las que (al
parecer) se estaba aburriendo
Departamento de Informática
Lenguajes de Programación ILI-153
7
Casos de éxito de Python
- BitTorrent (http://bitconjurer.org/BitTorrent/), sistema P2P que
ofrece mayor rendimiento que eMule
- ZOPE (www.zope.org) es un servidor de aplicaciones para
construir y gestionar contenido, intranets, portales, y
aplicaciones propietarias
- Google usa Python internamente, lo mismo que Yahoo para su
sitio para grupos
- Red Hat Linux utiliza Python para la instalación, configuración,
y gestión de paquetes.
- Más historias de éxito de Python en: http://pbf.strakt.com/
success
Departamento de Informática
Lenguajes de Programación ILI-153
Hola Mundo en Python
• Al igual que otros lenguajes de scripting se
ocupa el sha-bang(#!) para hacer el script
ejecutable.
#!/usr/bin/env
python
print "Hola Mundo”
bien usamos el modo interactivo:
>>>print "Hola Mundo"
# "Hola Mundo"
>>>print "hola", "mundo"
# "hola mundo"
>>>print "Hola" + "Mundo"
# "HolaMundo"
Departamento de Informática
Lenguajes de Programación ILI-153
Características de Python
• Muy legible y elegante
– Imposible escribir código ofuscado
• Simple y poderoso
– Minimalista: todo aquello innecesario no hay que escribirlo (;, {, },
'\n')
– Muy denso: poco código hace mucho
– Soporta objetos y estructuras de datos de alto nivel: strings, listas,
diccionarios, etc.
– Múltiples niveles de organizar código: funciones, clases, módulos,
y paquetes
• Python standard library (http://www.python.org/doc/current/lib/lib.html)
contiene clases de utilidad
– Si hay áreas que son lentas se pueden reemplazar por plugins en
C o C++, siguiendo la API para extender o empotrar Python en una
aplicación, o a través de herramientas como SWIG, sip o Pyrex.
Departamento de Informática
Lenguajes de Programación ILI-153
Características de Python II
• De scripting
– No se tiene que declarar constantes y variables antes de
utilizarlas
– No requiere paso de compilación/enlazador
– La primera vez que se ejecuta un script de Python se compila y
genera bytecode que es luego interpretado
– Alta velocidad de desarrollo y buen rendimiento
• Código interoperable (como en Java "write once run
everywhere")
– Se puede utilizar en múltiples plataforma (más aún que Java)
– Puedes incluso ejecutar Python dentro de una JVM (Jython)
• Open Source
– Razón por la cual la Python Library sigue creciendo y creciendo
• De propósito general
– Puedes hacer en Python todo lo que puedes hacer con C# o
Java, o más
Departamento de Informática
Lenguajes de Programación ILI-153
Peculiaridades sintácticas
• Python usa tabulación (o espaciado) para mostrar estructura
de bloques
– Tabula una vez para indicar comienzo de bloque
– Des-tabula para indicar el final del bloque
Departamento de Informática
Lenguajes de Programación ILI-153
Prototyping
• Enfocada en la programación experimental o
prototipos:
–
–
–
–
–
–
Interactiva (como LISP, ML, etc).
Mínima traducción a bytecode (como Java)
Tipado dinámico (como LISP, SETL, APL)
Funciones de alto orden (LISP)
Recolector de basura, sin punteros (LISP, etc.)
Tratamiento uniforme de estructuras indexadas
(como SETL)
– Estructuras asociativas pre construidas (como
SETL)
– Sintaxis liviana, identación es importante (de ABC)
Departamento de Informática
Lenguajes de Programación ILI-153
Nada se puede entender sin OOP
• Modelo simple de módulos y clases
• Herencia de implementación
• No declaraciones de tipo, si herencia de
interfaces
• Herencia múltiple
• Sin información escondida
• Modelo simple de visibilidad
• Mecanismo “tosco” de sobrecarga de
operadores
• Anidamiento limitado:
– ambito preconstruido, ámbito global, ámbito
local
Departamento de Informática
Lenguajes de Programación ILI-153
Python vs. Perl
• Los dos están basados en un buen
entendimiento de las herramientas
necesarias para resolver problemas
– Perl está basado en awk (Alfred Aho, Peter Weinberger, y
Brian Kernighan), sed y shell scripting y su misión es
hacer las tareas de administradores de
sistemas más sencillas (ej. Tratamiento de
texto)
– Python está basado e inspirando por OOP
(Object oriented programming)
• Guido van Rossum diseñó un lenguaje simple,
poderoso, y elegante orientado a la creación de
sistemas a partir de componentes
Departamento de Informática
Lenguajes de Programación ILI-153
Python vs. Java
• Java es un lenguaje de programación muy
completo que ofrece:
–
–
–
–
Amplio abanico de tipos de datos
Soporte para threads
Strong typing
Y mucho más ...
• Python es un lenguaje de scripting:
– No ofrece strong typing
• Bueno para prototipos pero malo para grandes sistemas
– Puede tener caidas inesperadas en tiempo de ejecución
– Todo lo que puedes hacer con Java también lo
puedes hacer con Python
• Incluso puedes acceder a través de Python a las API de
Java si usas Jython (http://www.jython.org)
Departamento de Informática
Lenguajes de Programación ILI-153
Python vs. Jython
• Python
– También llamado Cpython
– Implementación del lenguaje Python en C
– Python C API permite extender Python con
librerías realizadas en C
– Partes que requieren mayor rendimiento en
Python están implementadas en C o C++ y
tan sólo contienen una pequeña capa de
Python encima
• Jython
– Implementación de Python en Java
– Permite acceder a todas las APIs de Java
• P.E. Podemos producir Swing GUIs desde Python
Departamento de Informática
Lenguajes de Programación ILI-153
¿Para qué [no] es útil?
• Python no es el lenguaje perfecto, no es bueno para:
– Programación de bajo nivel (system-programming), como
programación de drivers y kernels
• Python es de demasiado alto nivel, no hay control directo sobre
memoria y otras tareas de bajo nivel
– Aplicaciones que requieren alta capacidad de computo
• No hay nada mejor para este tipo de aplicaciones que el viejo C
• Python es ideal:
– Como lenguaje sticky/pegamento para combinar varios
componentes juntos (filosofía modular de UNIX-pipes)
– Para llevar a cabo prototipos de sistema
– Para la elaboración de aplicaciones cliente
– Para desarrollo web y de sistemas distribuidos
– Para el desarrollo de tareas científicas, en los que hay que
simular y prototipar rápidamente
Departamento de Informática
Lenguajes de Programación ILI-153
Usando Python desde línea comando
• Para arrancar el intérprete (Python interactivo) ejecutar:
$ python
Python 2.3.3 (#1, Dec 30 2003, 08:29:25)
[GCC 3.3.1 (cygwing special)] on cygwin
Type "help", "copyright", "credits" or "license" for more
information.
>>>
• Un comando simple:
>>> print "Hola Mundo"
Hola Mundo
>>>
• Para salir del intérprete Ctrl-D o Ctrl-Z (depende SO) o:
>>> import sys
>>> sys.exit()
$
Departamento de Informática
Lenguajes de Programación ILI-153
Ejecutando programa script.py
• Python desde script:
– Guardar siguientes sentencias en archivo:
script.py
#!/usr/bin/env python
print “Hola Mundo!”
– Ejecutar el script desde línea de comando:
$ python script.py
Hola Mundo!
$chmod +x script.py
$./script.py
Hola Mundo!
Departamento de Informática
Lenguajes de Programación ILI-153
Sentencias y bloques
• Las sentencias acaban en nueva línea, no en ;
• Los bloques son indicados por tabulación que
sigue a una sentencia acabada en ':'.
bloque.py
name = "Diego1" # asignación de valor a variable
if name == "Diego":
print “Hola Diego"
else:
print "¿Quién eres?"
print "¡No eres Diego!"
$ python bloque.py
¿Quién eres?
¡No eres Diego!
Departamento de Informática
Lenguajes de Programación ILI-153
Identificadores
• Los identificadores sirven para nombrar variables,
funciones y módulos
– Deben empezar con un carácter no numérico y
contener letras, números y '_‘
– Python es case sensitive
• Palabras reservadas:
– and elif global or assert else if pass break except
import print class exec in raise continue finally is return
def for lambda try del from not while
• Variables y funciones delimitadas por __
corresponden a símbolos implícitamente definidos:
__name__ nombre de función
__doc__ documentación sobre una función
__init__() constructor de una clase
Departamento de Informática
Lenguajes de Programación ILI-153
Tipos de datos I
• Numéricos (integer, long integer,
floating-point, and complex)
>>> x = 4
>>> int (x)
4
>>> long(x)
4L
>>> float(x)
4.0
>>> complex (4, .2)
(4+0.2j)
Departamento de Informática
Lenguajes de Programación ILI-153
Tipos de datos II
• Strings, delimitados por un par de (', " ,"""). Dos string juntos sin
delimitador se unen
>>> print "Hi" "there"
Hithere
– Los códigos de escape se expresan a través de '\':
>>>print '\n‘
– Raw strings (sin procesar string “en bruto”)
>>> print r'\n\\' # no se 'escapa' \n
– Es lo mismo ' que ", p.e. "\\[foo\\]" r'\[foo\]‘
>>> len('La vida es mucho mejor con Python.')
>>> 34
>>> 'La vida es mucho mejor con Python.'.upper()
'LA VIDA ES MUCHO MEJOR CON PYTHON.'
>>> "La vida es mucho mejor con Python".find("Python")
27
>>> 'La vida es mucho mejor con Python'.replace('Python', 'Jython')
'La vida es mucho mejor con Jython’
Departamento de Informática
Lenguajes de Programación ILI-153
Tipos de datos III
• El módulo string de la Python library define
métodos para manipulación de strings:
>>> import string
>>> s1 = 'La vida es mejor con Python'
>>> string.find(s1, 'Python')
21
• '%' es el operador de formateo de cadenas:
>>> region = ‘Tarapaca'
>>> "La capital de %s es %s" % (provincia, “Iquique")
'La capital de Tarapaca es Iquique'
– Los caracteres de formateo son los mismos que
en C, p.e. d, f, x
– Los String son “inmutables” y Python no tiene tipo
char
Departamento de Informática
Lenguajes de Programación ILI-153
Tipos de datos IV
• Listas []
– Indexadas por un entero comienzan en 0 (soporta
indexación negativa):
>>> meses = ["Enero", "Febrero"]
>>> print meses[0]
Enero
>>> #de atrás para adelante -1 feberero -2 enero
print meses[-2]
Enero
>>> meses.append("Marzo")
>>> print meses
['Enero', 'Febrero', 'Marzo']
– Más (+) es el operador de concatenación:
>>> print meses+meses
['Enero', 'Febrero', 'Marzo', 'Enero', 'Febrero‘,'Marzo']
Departamento de Informática
Lenguajes de Programación ILI-153
Tipos de datos IV
•
Las listas pueden contener cualquier tipo de objetos Python:
>>> meses.append (meses)
>>> print meses
['Enero', 'Febrero', 'Marzo', ['Enero', 'Febrero', 'Marzo' ]]
>>> meses.append(1)
['Enero', 'Febrero', 'Marzo', ['Enero', 'Febrero', 'Marzo' ], 1]
•
Para añadir un elemento a una lista:
>>> items = [4, 6]
>>> items.insert(0, -1)
>>> items
[-1, 4, 6]
•
Para usar una lista como una pila, se pueden usar append y pop:
>>>
>>>
>>>
555
>>>
items.append(555)
items [-1, 4, 6, 555]
items.pop()
items [-1, 4, 6]
• Lista por comprensión:
mylist = [x*x for x in range(3)]
Departamento de Informática
Lenguajes de Programación ILI-153
Funciones para listas
•
•
•
•
•
•
•
•
•
•
•
len ( l i s t )
del l i s t [ x : y ]
l i s t . extend ( l )
list.insert(i,x)
l i s t . remove ( x )
l i s t . count ( x )
list.sort()
l i s t . reverse ( )
l i s t . append ( x ) # Pi l a y Cola
l i s t . pop ( ) # Pi l a
l i s t . pop ( 0 ) # Cola
Departamento de Informática
Lenguajes de Programación ILI-153
28
Slicing
– Dos puntos (:) es el operador de rodajas o Slice,
– permite trabajar con una porción de la lista, el elemento indicado
por el segundo parámetro no se incluye:
>>> print meses[1:2]
['Febrero']
• Slicing/rodajas:
– s[m:n]
• del m-avo componente, al final pero excluir el n-avo
– s [m:]
• del m-avo al final,
– s[:n]
• del comienzo, al final pero excluir el n-avo
– s[:]
• todos los componentes
– s*4
• repeticiones
Departamento de Informática
Lenguajes de Programación ILI-153
Tipos de datos V
• Tuplas (), lo mismo que listas, pero con pares de valores , e.j. (1, 2)
• Diccionarios {} arrays asociativos o mapas, indexados por una clave,
la cual puede ser cualquier objeto Python, aunque normalmente es
una tupla:
>>> mydict = {"altura" : "media", "habilidad" : "intermedia",
"salario" : 1000 }
>>> print mydict
{altura': 'media', 'habilidad': 'intermedia', 'salario': 1000}
>>> print mydict["habilidad"]
intermedia
– Puedes comprobar la existencia de una clave en un diccionario usando
has_key:
if mydict.has_key('altura'):
print 'Nodo encontrado'
– Lo mismo se podría hacer:
if 'altura' in mydict:
print 'Nodo encontrado'
Departamento de Informática
Lenguajes de Programación ILI-153
Como se ve?
• Iteradores pre construidos:
–
–
for c in name: # c enlazado a cada caracter de name
for course in courses:
rulers = { 'france':
['chirac',
1995, 7],
# mapeo general
'us'
:
['clinton', 1996, 4],
'peru'
:
['fujimori', 1998, 0],
'romania' : ['illiescu', 2000, 5]}
for country in rulers.keys():
# iteradores pre construidos
[pres, elected, term] = rulers[country]
# asignacion
if 2002 - elected <= term:
print country, ":", pres,"has %d years to go" % (term (2002 - elected))
else:
print country, ":", pres, "esta fuera de la oficina"
Departamento de Informática
Lenguajes de Programación ILI-153
Simple interactive model
$
python pres.py
# carga y ejecuta
france: chirac has 0 years to go
us: clinton esta fuera de la oficina
romania: illiescu has 3 years to go
peru: fujimori esta fuera de la oficina
• También podemos escribir
$
python
>>> import pres
# carga, ejecuta, continua
Departamento de Informática
Lenguajes de Programación ILI-153
Diccionarios
• Mapas asociativos de propósito General
dominios (claves) de tipos arbitrarios
• Entregandolo por clave:
>>rulers [‘peru’]
[‘fujimori’, 1998, 0]
• asignación / modificación
>>> rulers ["peru"][2]=10
//ver 2.2
>>> rulers ["mexico"] = ["fox", 2000, 6]
>>> rulers ["pakistan"] = [ ]
#no requiere consistencia tipo
Departamento de Informática
Lenguajes de Programación ILI-153
Operadores
• Operadores matemáticos, bit-a-bit y
relacionales: igual que C y Java
• Tiene operadores matemáticos
extendidos a strings (i.e. ’a’ + ’b’ --> ’ab’ o
’a’ * 3 --> ’aaa’)
• Nuevos operadores matemáticos: power
(**) y floor divition (//)
• Operadores booleanos: "or," "and," "not“
• Operadores relacionales: ==, >, <, =
Departamento de Informática
Lenguajes de Programación ILI-153
34
Operadores
• Operador funcional: lambda
• Operadores de membresía e identidad:
in, not in, is, not is
• Operadores de subíndice, rango, tupla,
lista, diccionario, etc: x[], x[:],
(e1,e2...), [e1,e2...],
{key:dat,...}, etc
• Precedencia: lambda, lógicos,
membresía/identidad, relacionales, bita-bit, matemáticos, subíndice, rango,
tupla, lista, diccionario, etc.
Departamento de Informática
Lenguajes de Programación ILI-153
35
Control de Flujo
• Sacados del paradigma imperativo
• Definidos por el bloque de indentación y el
operador :
– if se puede utilizar con elif y else
– while se puede utilizar con else
– for funciona sobre sequencias, como listas,
strings,diccionarios, etc. Es similar a un
foreach (Perl).
• También existen los saltos incondicionales
implícitos mediante break y continue
– break nos sirve para salir de un bucle
– continue para seguir con la siguiente iteracion
Departamento de Informática
Lenguajes de Programación ILI-153
36
Control de Flujo
q = 4
h = 5
if q < h :
print "primer test pasado"
else:
print "segundo test pasado"
>>> python condicional.py
primer test pasado
Departamento de Informática
Lenguajes de Programación ILI-153
Control de Flujo: bucles
• while es sentencia de repetición. Ejecuta un bloque
de código hasta que una condición es falsa.
• Por ejemplo:
reply = 'repite'
while reply == 'repite':
print 'Hola'
reply = raw_input('Introduce "repite" para
hacerlo de nuevo: ')
Hola
Introduce "repite" para hacerlo de nuevo:
repite
Hola
Introduce "repite" para hacerlo de nuevo:
adiós
Departamento de Informática
Lenguajes de Programación ILI-153
Control de flujo
def fun(number = 23):
running = True
while running:
guess = int(raw_input("Ingrese un numero: " ))
if guess == number:
print "Correcto!"
running = False
elif guess < number :
print "Incorrecto , es mayor"
else:
print "Incorrecto , es menor"
else:
print "Termino el Loop."
print "Termino el programa"
raw_input ("Pulse enter para salir: " )
Departamento de Informática
Lenguajes de Programación ILI-153
39
While con salto incondicional
>>> while True:
s = raw_input ("Ingrese String : " )
if s == “quit" :
break
if len(s) > 3:
continue
print "Tiene que ser mas largo"
Departamento de Informática
Lenguajes de Programación ILI-153
40
Control de Flujo: bucles
• for se utiliza para iterar sobre los
miembros de una secuencia (for acepta
else)
– Se puede usar sobre cualquier tipo de datos
que sea una secuencia (lista, tupla,
diccionario)
for x in range(1,5):
print x
1 2 3 4
• La función range genera una secuencia
descrita por ([start,] end [,step]), donde los
campos start y step son opcionales. Start
es 0 y step es 1 por defecto.
Departamento de Informática
Lenguajes de Programación ILI-153
Control de Flujo: bucles
• Iteradores sobre colecciones:
for x in L:
• Iteradores sobre diccionarios:
for k in mydict.keys( ):
• Iteradores explícitos:
for x in [1, 1, 2, 3, 5, 8, 13]:
• Iteradores numéricos
for x in range (1,100):
Ej.
complex = { "uno" : 10.23+2j , " dos" :1.32+43j }
for i,j in complex.items() :
print i ,"= ",j
Departamento de Informática
Lenguajes de Programación ILI-153
Funciones
• Una definición de función es una
sentencia ejecutable.
• Objetos de primera clase que se ligan
en el espacio de nombres, definidos por
el bloque de indentación y el operador :
• Los parámetros son variables y pueden
tener valores por defecto
• Puede retornar más de un valor
Departamento de Informática
Lenguajes de Programación ILI-153
43
Funciones
def intersect (seq1, seq2):
# sin info de tipo
res = [ ]
# inicializando lista
for x in seq1:
# iterando sobre la lista
if x in seq2: # miembro pre construido
res.append (x)
return res
• Nombres asignados son locales en vez de
declararlos globales
Departamento de Informática
Lenguajes de Programación ILI-153
Funciones
def fib(n):
"""La serie de Fibonacci hasta n"""
a, b = 0, 1
while b < n:
print b,
a, b = b, a+b
>>> print fib.__doc__
La serie de Fibonacci hasta n
>>>fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
Departamento de Informática
Lenguajes de Programación ILI-153
45
Funciones
• Una función se declara usando la palabra clave def
def myfunc(a,b):
sum = a + b
return sum
>>> print myfunc (5,6)
11
• A una función se le pueden asignar parámetros por
defecto:
def myfunc(a=4,b=6):
sum = a + b
return sum
>>>print myfunc()
10
>>>print myfunc(b=8)
12
Departamento de Informática
Lenguajes de Programación ILI-153
Ejemplo de Valores por Defecto
def ask_ok(prompt, retries=4, complaint='Yes or no,
please!'):
while True:
ok = raw_input(prompt)
if ok in ('y', 'ye', 'yes'): return True
if ok in ('n', 'no', 'nop', 'nope'): return False
retries = retries - 1
if retries < 0: raise IOError, 'refusenik user'
print complaint
• Podemos llamarla
>>>ask_ok('Hola: ')
>>>ask_ok('Chao: ',complaint='en gringo yes/no')
>>>ask_ok('Prompt ',1,"nada")
Departamento de Informática
Lenguajes de Programación ILI-153
47
Funciones: n° párametros variable
• Listas de argumentos y argumentos basados en palabras
clave:
def testArgLists_1(*args, **kwargs):
print 'args:', args
print 'kwargs:', kwargs
>>>testArgLists_1('aaa', 'bbb', arg1='ccc', arg2='ddd')
args: ('aaa', 'bbb')
kwargs: {'arg1': 'ccc', 'arg2': 'ddd'}
def testArgLists_2(arg0, *args, **kwargs):
print 'arg0: "%s"' % arg0
print 'args:', args
print 'kwargs:', kwargs
>>>testArgLists_2('un primer argumento', 'aaa', 'bbb',
arg1='ccc’, arg2='ddd')
arg0: "un primer argumento"
args: ('aaa', 'bbb')
kwargs: {'arg1': 'ccc', 'arg2': 'ddd‘}
Departamento de Informática
Lenguajes de Programación ILI-153
Módulos
• Un módulo es una colección de métodos en un archivo
que acaba en .py. El nombre del archivo determina el
nombre del módulo en la mayoría de los casos.
• E.j. modulo.py:
def one(a):
print "in one"
def two (c):
print "in two“
• Uso de un módulo:
>>> import modulo
>>> dir(modulo) # lista contenidos módulo
['__builtins__', '__doc__', '__file__', '__name__',
'one', 'two']
>>> modulo.one(2)
in one
Departamento de Informática
Lenguajes de Programación ILI-153
Módulos
• Son nombres de espacios (namespaces),
unidades de encapsulamiento
• Son objetos pueden ser accesados sus
componentes
• Pueden ser inspeccionados dinámicamente:
__dict__ provee el diccionario para el módulo
claves son los strings para las entidades.
P.e. Si tuvieramos módulo fibo en espacio de trabajo
for attr in fibo.__dict__.keys ( ):
print attr,
#coma para que no retorne carro
if attr [0:2] == "__":
# convención de nombre pre construido
print attr, "built-in name"
Departamento de Informática
Lenguajes de Programación ILI-153
Módulos II
• import hace que un módulo y su contenido
sean disponibles para su uso.
• Algunas formas de uso son:
import test
• Importa modulo test. Referir a x en test con "test.x".
from test import x
• Importa x de test. Referir a x en test con "x".
from test import *
• Importa todos los objetos de test. Referir a x en test
con "x".
import test as theTest
• Importa test; lo hace disponible como theTest.
Referir a objecto x como "theTest.x".
Departamento de Informática
Lenguajes de Programación ILI-153
¿Dónde se buscan los módulos?
1. Variable sys.path, automáticamente
inicializada al directorio actual (¡no es lo
mismo que el directorio del script!)
2. En las ubicaciones descritas en la
variable de entorno PYTHONPATH
3. Ubicación dependiente de la instalación
del intérprete (en SO Unix esta es,
usualmente, .:/usr/local/lib/python)
Departamento de Informática
Lenguajes de Programación ILI-153
52
Clases y herencia
• Notaciones estándar: super clases, clases
derivadas, self (como this en otros lenguajes),
despacho dinámico
• Cada clase y cada objeto es un namespace
(unidad de encapsulamiento) con un diccionario
• Para ubicar una operación, buscar en el diccionario
del objeto (tabla de despacho). Si no lo encuentra,
examina las superclases.
• Operador de sobrecarga se usa a través de los
sgtes operadores predefinidos:
__init__
__del__
__add__
__repr__
constructor
destructor
operador “+”
printing, representación en salida
Departamento de Informática
Lenguajes de Programación ILI-153
Python Orientado a Objetos
•
•
•
•
class classname: sentencias
class classname(base-classes): sentencias
unaInstancia = MyClass()
def miMetodo(self,sgteParam):sentencias
•
•
•
•
__init__ is constructor method
__name__ is classname identifier string
__bases__ is tuple of base class objects
__doc__ is the docstring
Departamento de Informática
Lenguajes de Programación ILI-153
Python Class Example
#!/usr/local/bin/python
class Fred: # define la clase
x = 42.0
def bill(self): # primer argumento es siempre referencia al mismo objeto
print “Hola desdeBill\n" + str( Fred.x )
#------------------------------------------------------------------------------------------------f = Fred()
# instancia a Fred
f.bill()
# invoca el método bill
Departamento de Informática
Lenguajes de Programación ILI-153
Miembros de Datos creados implícitamente
class Number:
def __init__ (self, start):
self.data = start;
# es definida la data
def __add__ (self, other): # numero + numero
return Number (self.data + other.data)
def __repr__ (self):
return ‘self.data’
# convierte a string
• nota: no hay manera de sobrecargar
(Number + integer) etc.
Departamento de Informática
Lenguajes de Programación ILI-153
Algunas clases pueden ser una coleccion
class collection:
def __getitem__ (self, i):
return self.data[i] #la data es indexable
>>> X=collection()
>>> X.data = [1, 2, 3]
>>> for item in X:
print item
Departamento de Informática
Lenguajes de Programación ILI-153
Clases y métodos son objetos
class widget:
def doit (self, message):
print message
Gizmo1 = widget ( );
Gizmo2 = widget ( );
def factory (aClass, *args): # class parameter
return apply (aClass, args);
thing = factory (widget);
doer = thing.doit;
doer (“show it”); #el mismo ya esta enlazado
Departamento de Informática
Lenguajes de Programación ILI-153
Clases
• Una clase contiene una colección de métodos. Cada
método contiene como primer parámetro (self) que hace
referencia a un objeto. self equivalente a this en C++
class PenguinPen:
def __init__(self):
self.penguinCount = 0
def add (self, number = 1):
""" Add penguins to the pen. The default number is 1 """
self.penguinCount = self.penguinCount + number
def remove (self, number = 1):
""" Remove one or more penguins from the pen """
self.penguinCount = self.penguinCount - number
def population (self):
""" How many penguins in the pen- """
return self.penguinCount
penguinPen = PenguinPen()
penguinPen.add(5)
# Tux y su familia
print penguinPen.population()
$ python PenguinPen.py
5
Departamento de Informática
Lenguajes de Programación ILI-153
Más clases/Herencia
class Basic:
def __init__(self, name):
self.name = name
def show(self):
print 'Basic -- name: %s' % self.name
class Special(Basic): # entre paréntesis la clase base
def __init__(self, name, edible):
Basic.__init__(self, name) # se usa Basic para referir a
self.upper = name.upper() # clase base
self.edible = edible
def show(self):
Basic.show(self)
print 'Special -- upper name: %s.' % self.upper,
if self.edible:
print "It's edible."
else:
print "It's not edible."
def edible(self):
return self.edible
Departamento de Informática
Lenguajes de Programación ILI-153
Probando clases
>>>obj1 = Basic('Manzana')
>>>obj1.show()
Basic -- name: Manzana
>>>obj2 = Special('Naranja', 1)
>>>obj2.show()
Basic -- name: Naranja
Special -- upper name: NARANJA.
It's edible.
Departamento de Informática
Lenguajes de Programación ILI-153
Herencia Múltiple
• Colisión de nombres de resuelve con depthfirst, de izquierda a derecha.
• Esto es:
– 1. La misma clase (DerivedClassName).
– 2. La primera superclase, hacia la izquierda
(Base1).
– 3. Recursivamente sobre las superclases de la
superclase.
– 4. La segunda superclase ...
Departamento de Informática
Lenguajes de Programación ILI-153
62
#!/usr/local/bin/python
#-------------------------------------------------------------
class Startibartfast:
def hello(self):
print "Hello from Startibartfast's hello method"
class Ford( Startibartfast, Arthur ):
x = 42.0
def prefect(self):
print "Hello from prefect\n" + str( Ford.x )
#------------------------------------------------------------f = Ford()
f.prefect()
#------------------------------------------------------------class Arthur:
def hello(self):
print "Hello from Arthur's hello method\n"
return None
def doSomething(self, a ):
print "this is Arthur's doSomething method\n" + str(a)
return None
#-------------------------------------------------------------
f.hello()
f.doSomething( 12345.001 )
> python test02.py
Hello from prefect
42.0
Hello from Slartibartfast's hello method
this is Arthur's doSomething method
12345.001
Departamento de Informática
Lenguajes de Programación ILI-153
Errores y excepciones
• Se identifican dos cursos excepcionales de
ejecución en Python: Errores de sintaxis y
excepciones.
• Los errores de sintaxis ocurren (de modo
obvio) cuando el intérprete detecta problemas
en la sintaxis del código.
• Las excepciones ocurren debido a algún
problema generado por la ejecución del código.
• Ejemplos típicos: división por cero
– (ZeroDivisionError), nombres no definidos
– (NameError), errores de conversión de tipos
– (TypeError), etc.
• Se tratan de un modo similar a Java.
Departamento de Informática
Lenguajes de Programación ILI-153
Excepciones
•
•
•
•
Se pueden generar con raise NombreDeError.
Sintácticamente se tratan con cláusulas try.
Se capturan con bloques except.
Acepta una cláusula final else para especificar un
bloque de código que deba ejecutarse después del
try, con o sin excepciones.
Departamento de Informática
Lenguajes de Programación ILI-153
Cláusulas except
• except NombreDeError: para especificar qué
hacer en caso de un error tipo TipoDeError.
• except NombreDeError, (errno, strerror):
igual que la anterior, pero dentro del bloque se
puede utilizar las variables errno y strerror
que contienen un número de error y un
mensaje de error, respectivamente.
• except (ErrorUno, ErrorDos, ErrorTres):
permite camputrar error de tipo ErrorUno,
ErrorDos y ErrorTres en un mismo bloque.
• except: sólo se puede usar como última
cláusula except en una sentencia try, y sirve
de comodín la excepciones no capturadas
anteriormente.
Departamento de Informática
Lenguajes de Programación ILI-153
Excepciones en Python
try:
statement(s)
except [expression [, target]]:
statement(s)
[else:
statement(s) ]
[finally:
statement(s) ]
• Target es el nombre del identificador
opcional de la excepcion
• ZeroDivisionError; TypeError
Departamento de Informática
Lenguajes de Programación ILI-153
Ejemplo
import sys
try :
f = open("myfile.txt","r")
s = f.readline()
i = int(s.strip())
except IOError,(errno,strerror):
print " I/O error(%s) : %s " % (errno,strerror)
except ValueError :
print " Could not conver t data to an integer. "
except :
print " Unexpected error : " , sys.excinfo( ) [ 0 ]
raise
raw_input("Ingrese enter para continuar")
Departamento de Informática
Lenguajes de Programación ILI-153
Excepciones
•
Cada vez que un error ocurre se lanza una excepción, visualizándose un
extracto de la pila del sistema. E.j. si variable a no ha sido enlazada(ligada):
>>> print a
Traceback (most recent call last):
File "<pyshell#77>", line 1, in <module>
print a
NameError: name 'a' is not defined
• Para capturar la excepción se usa except:
>>> try:
fh=open("new.txt", "r")
except IOError, e:
print e
[Errno 2] No such file or directory: 'new.txt’
•
Puedes lanzar tu propia excepción usando el comando raise:
raise MyException
raise SystemExitModules
Departamento de Informática
Lenguajes de Programación ILI-153
Excepciones, etc.
• internamente, interador implementado como
i = 0;
try:
while 1: # tipo no boleano
item = getitem(self, i)
i = i +1
except IndexError:# eventualmente i muy largo
pass
# sentencia null
except:
# todas las otras
excepciones
print "unexpected chaos!"
Departamento de Informática
Lenguajes de Programación ILI-153
Excepciones personalizadas
class E(RuntimeError):
def __init__(self, msg):
self.msg = msg
def getMsg(self):
return self.msg
try:
raise E('mi mensaje de error')
except E, obj:
print 'Msg:', obj.getMsg()
Msg: mi mensaje de error
Departamento de Informática
Lenguajes de Programación ILI-153
Paquetes I
• Un paquete es una manera de organizar un conjunto de
módulos como una unidad. Los paquetes pueden a su
vez contener otros paquetes.
• Para aprender como crear un paquete consideremos el
siguiente contenido de un paquete:
package_example/
package_example/__init__.py
package_example/module1.py
package_example/module2.py
• Y estos serían sus contenidos:
# __init__.py
# Exponer definiciones de módulos en
este paquete.
from module1 import class1
from module2 import class2
Departamento de Informática
Lenguajes de Programación ILI-153
Paquetes II
• # module1.py
class class1:
def __init__(self):
self.description = 'class #1'
def show(self):
print self.description
• # module2.py
class class2:
def __init__(self):
self.description = 'class #2'
def show(self):
print self.description
Departamento de Informática
Lenguajes de Programación ILI-153
Paquetes III
• # testpackage.py
import package_example
c1 = package_example.class1()
c1.show()
c2 = package_example.class2()
c2.show()
• Visualizaría:
class #1
class #2
• La localización de los paquetes debe
especificarse o bien a través de la variable de
entorno PYTHONPATH o en código del script
mediante sys.path
Departamento de Informática
Lenguajes de Programación ILI-153
Paquetes IV
•
>>>
>>>
>>>
>>>
>>>
Como en Java el código de un paquete puede
recogerse en un .zip:
import zipfile
a=zipfile.PyZipFile('mipackage.zip', 'w', zipfile.ZIP_DEFLATED)
a.writepy('package_example')
a.close()
^Z # ^D depende de SO
• Luego lo puedes importar y usar insertando su path en
sys.path o alternativamente añadiendo a la variable de
entorno PYTHONPATH una referencia al nuevo .zip
creado:
$ mkdir prueba; cp mipackage.zip prueba
$ export PYTHONPATH=/home/dipina/examples/prueba/mipackage.zip
>>> import sys # esta y la siguiente no hacen falta si se ha
inicializado PYTHONPATH
>>> sys.path.insert(0, '/home/dipina/examples/prueba/mipackage.zip')
>>> import package_example
>>> class1 = package_example.module1.class1()
>>> class1.show()
class #1
>>> ^Z
Departamento de Informática
Lenguajes de Programación ILI-153
Manejo de archivos
•
Leer un archivo
fh = open("holamundo.py") #crea objeto de tipo archivo
for line in fh.readlines() : # lee todas las líneas
print line,
fh.close()
$ python leerarchivo.py
#!/usr/bin/python
print "Hola mundo“
•
Escribir un archivo
fh = open("out.txt", "w")
fh.write ("estamos escribiendo ...\n")
fh.close()
$ python escribirarchivo.py
$ cat out.txt
estamos escribiendo ...
•
Nota: existe el modulo pickle se utiliza para la serialización de objetos (objetos
persistentes).
Departamento de Informática
Lenguajes de Programación ILI-153
Más sobre print
• stdout en Python es sys.stdout, stdin es
sys.stdin:
import sys
class PrintRedirect:
def __init__(self, filename):
self.filename = filename
def write(self, msg):
f = file(self.filename, 'a')
f.write(msg)
f.close()
sys.stdout
print 'Log
print 'Log
print 'Log
= PrintRedirect('tmp.log')
message #1'
message #2'
message #3'
Departamento de Informática
Lenguajes de Programación ILI-153
Variables globales en Python
•
Usar identificador global para referirse a variable global:
NAME = "Manzana"
def show_global():
name = NAME
print '(show_global) nombre: %s' % name
def set_global():
global NAME
NAME = 'Naranja'
name = NAME
print '(set_global) nombre: %s' % name
>>>show_global()
(
show_global) nombre: Manzana
>>>set_global()
(set_global) nombre: Naranja
>>>show_global()
(show_global) nombre: Naranja
Departamento de Informática
Lenguajes de Programación ILI-153
Expresiones Regulares
• Patrones de búsqueda y reemplazo para
strings
• Forma simple y resumida de tratar con texto
• Pequeño lenguaje embebido en Python
• El uso indiscriminado puede llevar a poca
legibilidad
• Una expresión regular se compone de:
– Caracteres: se representan a sí mismos
– Metacaracteres: representan reglas
• Similar a la idea de un BNF pero más sencillo!
Departamento de Informática
Lenguajes de Programación ILI-153
Expresiones Regulares
• Cada construcción calza con un patrón
dado, en una posición específica. A las
construcciones que sólo registran una
posición (no calzan con caracteres) les
llaman anchor.
• Las construcciones en general son
voraces: Calzan lo más que pueden.
Pero también son poco previsoras:
Calzan en la primera oportunidad,
aunque hayan calces “mejores” más
adelante.
Departamento de Informática
Lenguajes de Programación ILI-153
Metacaracteres
Departamento de Informática
Lenguajes de Programación ILI-153
Otros Modificadores
Departamento de Informática
Lenguajes de Programación ILI-153
Algunas ER
(.*)blog(.*)\.com$
# dominios .com que contengan blog
pagina\s{1,8}(\d+)
# palabra pagina, multiples espacios y un numero
0x[0-9ABCDEF]*
# numero hexadecimal
linux+
# ’linux’ y muchas ’x’
ˆbegin (.*) end$
# linea que parta con ’begin ’ y termine con ’ end’
Departamento de Informática
Lenguajes de Programación ILI-153
Uso de Expresiones Regulares
• Las ER al ser parte de un mini-lenguaje
(lenguaje regular), debe ser compilado o
interpretado para utilizarlo
• Perl interpreta las expresiones regulares
para su fácil uso
• Python (como C y otros) deben compilar la
expresión
• Hay que importar la biblioteca re
• Se usa compile() para crear el objeto ER
>>>import re
>>> p = re.compile('ab*')
>>>print p
<_sre.SRE_Pattern object at 0x01266808>
Departamento de Informática
Lenguajes de Programación ILI-153
Funciones para Expresiones Regulares
• search(pat,str ) : busca en un string por el patrón, retorna
un MatchObject
• match(pat,str) : intenta calzar el patrón partiendo del
principio del string. Retorna un MatchObject.
• split (pat, str ) : divide el string dependiendo del patrón.
Retorna una lista de strings.
• findall (pat, str ) : retorna una lista de todos los calces.
• sub(pat,rep, str ) : reemplaza lo calzado con un string
rep, o con una función rep. En este último caso, la función
recibe un parámetro MatchObject.
• subn(pat,rep,str ) : igual que el anterior pero devuelve
además el número de elementos reemplazados (doble
retorno).
• Se puede utilizar la versión orientada a objetos mediante
métodos del objeto re. Corresponden a las mismas
funciones sin el parametro pat. Es más eficiente
Departamento de Informática
Lenguajes de Programación ILI-153
Ejemplo de uso de ER
import re
def checkMatch (myMatch):
if myMatch:
print "Si calza!"
else:
print "No calza! "
match1=re.search ("^From " , "From John Lock : " )
match2=re.compile ( "^From" ).search ( "To Jacob " )
match3=re.search ( "From" , "Desde From From" )
match4=re.match ( "From" , "Desde From From" )
checkMatch (match1);checkMatch (match2)
checkMatch (match3);checkMatch (match4 )
str1=re.split("\W+" , "4 8 15 16 23 42" )
str2,n=re.subn ( "-" , " " , "Archivo-de-prueba 2" )
print str1 , "\n" , str2 , " ( " ,n , " subs ) “
• Si calza!
• No calza!
• Si calza!
• No calza!
• ['4', '8', '15', '16', '23', '42']
• Archivo de prueba 2 ( 2 subs )
Departamento de Informática
Lenguajes de Programación ILI-153
MatchObject
• Objeto que representa un calce.
• Usado para tratamiento avanzado de
calces.
• Algunos Métodos:
m.start() # donde empieza el calce
m.end() # donde termina
m.span() # tupla (m.start(),m.end())
• Algunos Atributos:
.re # objeto ER
.string # string original
.pos # posicion inicial de busqueda
.endpos # posicion final de busqueda
Departamento de Informática
Lenguajes de Programación ILI-153
Ejemplo
import re, urllib, sys
if len(sys.argv) <= 4:
print "Usage: procesaUrl <url-a-procesar> <palabraareemplazar> <nueva-palabra> <archivo-html-a-crear>"
sys.exit(0)
print sys.argv[1]
s = (urllib.urlopen(sys.argv[1])).read() # lee el contenido de una url
# reemplaza todas las ocurrencias de "sys.argv[2]" por " sys.argv[3]"
t = re.sub(sys.argv[2], sys.argv[3], s)
backupFile = open(sys.argv[4], "w")
backupFile.write(t)
backupFile.close()
print 'archivo ' + sys.argv[4] + ' escrito con contenido de
url: ' + sys.argv[1] + ' al reemplazar palabra ' + sys.argv
[2] + ' con palabra ' + sys.argv[3]
Departamento de Informática
Lenguajes de Programación ILI-153
Ejemplo
# conseguir el titulo del documento HTML
tmatch = re.search(r'<title>(.*?)</title>', s, re.IGNORECASE)
if tmatch:
title = tmatch.group(1)
print 'Titulo de pagina ' + sys.argv[1] + ' es: ' + title
# extraer lista de enlaces url:
pat = re.compile(r'(http://[\w-]*[.\w-]+)')
addrs = re.findall(pat, s)
print 'La lista de enlaces encontrados en esta pagina es: '
for enlace in addrs:
print enlace
Departamento de Informática
Lenguajes de Programación ILI-153
More Information on Python
• Python in a Nutshell , Alex Martelli,
Pub. O’Reilly
• Python Cookbook, Alex Martelli, Anna
Martelli Ravenscroft and David Ascher,
Pub. O’Reilly
• http://www.python.org
• http://docs.python.org/tutorial/
Departamento de Informática
Lenguajes de Programación ILI-153
Fin
Departamento de Informática
Universidad Técnica Federico Santa María
91