Laboratorio 6: Python

Iniciando el interprete JPython


1) Instalar Jpython
        java jython_21
2) Ejecutar Jython
       En el directori donde hayamos instalado jython escribir:
      jython.bat
 

1. Tipos de datos

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

2. Comandos y expresiones

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

3. Funciones

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

4. Programación funcional:

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

5. Modulos

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__ = []

 

6. Excepciones

>> while 1:
            try:
                    x = int(raw_input("Please enter a number:"))
                    break
            except ValueError:
                    print "Fallo"
raise 'fallo'

7. Clases

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'

 

 

8. Interoperabilidad

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