Laboratorio 6: Python |
1) Instalar Jpython
java jython_21
2) Ejecutar Jython
En el directori donde hayamos instalado
jython escribir:
jython.bat
Números
----------------------------------------------------------
>>2+2
>>4 * 2.5 * 3.3
>> width = 20
>> height = 5*9
>> width * height
>> tax = 17.5 / 100
Strings
--------------------------------------------------------
>>'terrance'
>> "filip"
>> cadena = 'terrance'
>> cadena[2]
>> cadena[0:2]
>> cadena[2:4]
>> cadena [1:]
>> cadena [-1:]
>>cadena + ' added'
Listas
----------------------------------------------------------
>> a= ['terrance,'filip','buba',100,1234]
>> a
>> a[0]
>> a[-2]
>> a[0:2] = [1,12]
>> len(a)
Tuplas
-------------------------------------------------------------
>> t = 'terrance','filip','homer'
>>t
>>t[0]
Diccionarios
---------------------------------------------------------------
>> tel = {'terrance':5550,'filip':666, 'homer':777}
>> tel
>> tel ['homer']
>> tel.keys()
>> tel.has_key('homer')
Condicionales
--------------------------------------------------------------------
>> x = int(raw_input("Enter a number: "))
>> if x <0:
... x = 0
... print 'Negative changed to zero'
elif x==0:
print 'Zero'
elif x==1:
print 'Single'
else:
print 'More'
Iteradores
-----------------------------------------------------------------------
>> x=0
>> while x<5:
print x
x = x +1
>> a = ['cat','window','defenestrate']
>> for x in a:
print x, len(x)
>> range(10)
>> range(5,10)
>> a = ['a','b','c','d','e']
>> for i in range(len(a)):
print i,a[i]
>>> for x in range(9,1,-1):
... print x
>> def fib(n):
a,b = 0,1
while b<n:
print b
a,b= b, a+b
>> fib(2000)
>> fib
>> f = fib
>> f(100)
# Comentarios: Funciones como valores de primera clase.
Funciones Lambda (funciones anonimas):
-----------------------------------------------------------
>> identidad = lambda x: x
>> identidad(1)
>> def make_incrementor(n):
return lambda x,incr = n: x+incr
>> x = make_incrementor(2)
>> x(3)
>>eval("2+2") => 4 ## para expresiones
>>exec("for x in list: f(x)") ## para comandos
>>execfile("file.py")
>> def incr(x):
return x +1
>> map(incr,[1,2,3])
>> map(len, ["one", [2, 3]])
>> reduce(lambda x,y: x+y, numbers)
>> filter(lambda x: x%2 == 0, numbers)
Crear un fichero .py con nuestras funciones
funciones.py (Modulo)
>> import funciones
>> funciones.myfuncion(x)
>> from funciones import *
>> from funciones import myfuncion
>> dir(funciones)
Recomendación: Para poder importar de un fichero, es necesario que en el mismo directorio haya un fichero llamado __init__.py con al menos esta información:
__all__ = []
>> while 1:
try:
x = int(raw_input("Please enter a number:"))
break
except ValueError:
print "Fallo"
raise 'fallo'
En python no todo son objetos, los "built-in types" no son objetos.
>>class Cosa:
name='cosa'
def getName(self):
return self.name
def setName(self,nam):
self.name= nam
>> c = Cosa()
>> c.name
>> c.getName()
>> c.setName('pepe')
>> c.getName()
Constructores:
------------------------------------------------------------------------------
>> class Cosa:
name='cosa'
def __init__(self,x):
self.name=x
>> c = Cosa('buba')
>> c.name
Metodos como valores de primera clase:
-------------------------------------------------------------------
>> x = c.getName
Herencia
---------------------------------------------------
class DerivedClass(BaseClass):
Herencia Multiple
-------------------------------------------------------
class DerivedClass(Base1,Base2,Base3):
Ocultamiento de informacion
----------------------------------------------------------------------------------
>>class Mia:
__privada = 'hola'
publica = 'adios'
>> c = Mia()
>> c.publica
>> c.privada
Ejemplo: Granja de Animales
>>> class Animal:
... def habla(self):
...
print 'soy una animal'
...
>>> class Perro(Animal):
... def habla(self):
...
print 'soy un perro'
...
>>> class Gato(Animal):
... def habla(self):
...
print 'soy un gato'
...
>>> a = Animal()
>>> p = Perro()
>>> g = Gato()
>>> granja = [a,p,g]
>>> len(granja)
3
>>> for i in granja:
... i.habla()
...
soy una animal
soy un perro
soy un gato
Serialización:
>>> class Cosa:
... def __init__(self,x):
... self.x = x
...
>>> c = Cosa("pedro")
>>> c.x
'pedro'
>>> import pickle
>>> f = open('pedro.obj','w')
>>> pickle.dump(c,f)
>>> f.close()
>>> s = open('pedro.obj','r')
>>> cos = pickle.load(s)
>>> cos.x
'pedro'
Python scripting Java (jython) & Python compiling to Java bytecodes (jythonc)
>> from java.util import Random
>> r = Random()
>>> r.nextInt()
-790940041
>>> for i in range(5):
... print r.nextDouble()
...
0.23347681506123852
0.8526595592189546
0.3647833839988137
0.3384865260567278
0.5514469740469587
| Java Types | Allowed Python Types |
|---|---|
| char | String (must have length 1) |
| boolean | Integer (true = nonzero) |
| byte, short, int, long | Integer or Float |
| float, double | Float |
| java.lang.String, byte[] | String |
| java.lang.Class | Class or JavaClass (only if class subclasses from exactly one Java class; mutiple inheritance from more than one Java class is now illegal) |
| Foo[] | Array (must contain objects of class or subclass of Foo) |
| java.lang.Object | String->java.lang.String, all others unchanged |
| org.python.core.PyObject | All unchanged |
| Foo | Instance->Foo (if Instance is subclass of Foo); JavaInstance -> Foo (if JavaInstance is instance of Foo or subclass) |
Herencia
------------------------------- --------------
from java import awt
class SpamListener(awt.event.ActionListener):
def actionPerformed(self,event):
if event.getActionCommand() == "Spam":
print 'Spam and eggs!'
f = awt.Frame("Subclassing Example")
b = awt.Button("Spam")
b.addActionListener(SpamListener())
f.add(b, "Center")
f.pack()
f.setVisible(1)
Ejemplo de AWT
---------------------------------------------------
>> from java.awt import *
>> f = Frame("HOLA")
>> b = Button("HOMER")
>> f.add(b)
>> f.pack()
>> f.show()
>> for i in range(1,400):
f.setSize(i,i)
>> f.dispose()
Utilizando nuestras propias clases
---------------------------------------------------
En el directorio del Jython, debemos modificar el fichero jython.bat para incluirle
en el classpath la ruta a nuestras clases.
Si incluimos en este classpath el . (directorio actual) podremos dejar en este directorio nuestras clases. Si hemos
empaquetado nuestras clases en un fichero jar, meteremos este fichero en el classpath.
Vamos a crear una clase Animal en Java:
package animales;
public class Animal
{
public void habla()
{
System.out.println("Soy un animal");
}
}
1) La compilamos: javac -d . Animal.java
2) copiamos el directorio animales al directorio jython.
3) Ya podemos utilizarla en el interprete Jython.
>> from animales import Animal
>> a = Animal()
>> a.habla()
>>
>>> class Perro(Animal):
... def habla(self):
... print 'soy un perro'
...
>>> class Gato(Animal):
... def habla(self):
... print 'soy un gato'
...
>>> a = Animal()
>>> p = Perro()
>>> g = Gato()
>>> granja = [a,p,g]
>>> len(granja)
3
>>> for i in granja:
... i.habla()
El ejemplo funcionara correctamente heredando de una clase java.
Compilando Programas Python
-----------------------------------------------------
class Figura:
def paint(self):
print "pintando figura ..."
Guardar esta clase en el fichero Figura.py
En la linea de comandos escribir
jythonc -C d:\jdk1.2.2\bin\javac Figura.py
Para mas informacion ver documentacion online de Jython.
Programación funcional en python
(I) (II)
Ejercicios (OPTATIVOS)
1. Implementar los bots del laboratorio de Java en Jython. Utilizando el API creada en Java.
2. Implementar un prototipo ligero del servidor de IRC en jython (sin Java).