多个编程语言Multiple languages-2

。。。。。。

创造一门语言    
    
    使用Jython，在你的程序内部创造一种解释（interpreted）语言是极其简单的。考虑 《Thinking in Java》第二版第八章greenhouse控制器的那个例子。那种情形下你会希望最终用户——也就是管理greenhouse的那个人——能够通过配置来控制整个系统，于是一个简单的脚本语言就成了理想的解决方案。
    要创建这个语言，我们只需简单的写一组Python类，每个类的构造函数会把它自己添加到一个（静态的）master链表。公共的数据和行为会被factor到叫作Event的基类。每个Event对象都会包括一个action字符串（for simplicity——实际应用中，你应该安排一些functionality）和运行该事件（event）的设定时间。构造函数初始化这些成员变量，然后把新创建的Event对象添加到一个叫作events（在类的内部定义，但是位于所有方法的外部，所以它是静态的）的静态链表.

#:interpreter:GreenHouseLanguage.py
 
class Event:
  events = [] # static
  def __init__(self, action, time):
    self.action = action
    self.time = time
    Event.events.append(self)
  # Used by sort(). This will cause
  # comparisons to be based only on time:
  def __cmp__ (self, other):
    if self.time < other.time: return -1
    if self.time > other.time: return 1
    return 0
  def run(self):
    print "%.2f: %s" % (self.time, self.action)
 
class LightOn(Event):
  def __init__(self, time):
    Event.__init__(self, "Light on", time)
 
class LightOff(Event):
  def __init__(self, time):
    Event.__init__(self, "Light off", time)
 
class WaterOn(Event):
  def __init__(self, time):
    Event.__init__(self, "Water on", time)
 
class WaterOff(Event):
  def __init__(self, time):
    Event.__init__(self, "Water off", time)
 
class ThermostatNight(Event):
  def __init__(self, time):
    Event.__init__(self,"Thermostat night", time)
 
class ThermostatDay(Event):
  def __init__(self, time):
    Event.__init__(self, "Thermostat day", time)
 
class Bell(Event):
  def __init__(self, time):
    Event.__init__(self, "Ring bell", time)
 
def run():
  Event.events.sort();
  for e in Event.events:
    e.run()
 
# To test, this will be run when you say:
# python GreenHouseLanguage.py
if __name__ == "__main__":
  ThermostatNight(5.00)
  LightOff(2.00)
  WaterOn(3.30)
  WaterOff(4.45)
  LightOn(1.00)
  ThermostatDay(6.00)
  Bell(7.00)
  run()
##~

    每个派生类的构造函数都要调用基类的构造函数，基类的构造函数把新建的对象加入到链表。run()函数给整个链表排序，它自动的使用Event类所定义的__cmp__()方法只根据时间来进行比较。上面的例子，只是打印链表的内容，但是在实际系统中，它会等待每个事件设定的时间，然后运行那个事件。
    __main__函数这部分对这些类做了一下简单的测试。
    上面的文件现在已经是一个模块了，它可以被包括进（included）另外一个Python程序，用以定义那个程序所包含的所有类。但是，我们不用普通的Python程序，我们使用Java的Jython。这其实是非常简单的：你只需引入一些Jython类，创建一个PythonInterpreter对象，然后cause the Python files to be loaded：

//- interpreter:GreenHouseController.java
package interpreter;
import org.python.util.PythonInterpreter;
import org.python.core.*;
import junit.framework.*;
 
public class
GreenHouseController extends TestCase  {
  PythonInterpreter interp =
    new PythonInterpreter();
  public void test() throws PyException  {
    System.out.println(
      "Loading GreenHouse Language");
    interp.execfile("GreenHouseLanguage.py");
    System.out.println(
      "Loading GreenHouse Script");
    interp.execfile("Schedule.ghs");
    System.out.println(
      "Executing GreenHouse Script");
    interp.exec("run()");
  }
  public static void
  main(String[] args) throws PyException  {
    junit.textui.TestRunner.run(GreenHouseController.class);
  }
} ///:~

    PythonInterpreter对象是一个完整的Python解释器，它可以从Java程序接受命令。其中一个命令是execfile()，这个命令告诉解释器去执行它所找到的特定文件所包含的所有语句。通过执行GreenHouseLanguage.py，那个文件里所有的类都会被加载到PythonInterpreter对象，于是解释器就“拥有了” greehouse控制器语言。Schedule.ghs是由最终用户创建的用来控制greenhouse的文件。下面是一个例子：

//:! interpreter:Schedule.ghs
Bell(7.00)
ThermostatDay(6.00)
WaterOn(3.30)
LightOn(1.00)
ThermostatNight(5.00)
LightOff(2.00)
WaterOff(4.45)
///:~
 
    这就是interpreter设计模式所要达到的目的：使你的程序的配置对于最终用户来说尽可能的简单。使用Jython你几乎可以毫不费力的达到这个效果。
    PythonInterpreter还有一个可供使用的方法是exec()，通过它你可以向解释器发送命令。上例中，run()函数就是通过exec().被调用的。
 记住，要运行这个程序，你必须到http://jython.sourceforge.net下载并运行Jython（实际上，你只需要把jython.jar放到你的CLASSPATH就可以了）。上面这些做好以后，它就可以像其它Java程序那样运行了。

控制解释器Controlling the interpreter
    
    前面的例子只是创建解释器并且让它运行外部脚本。本章的剩余部分，我们会讲述更为复杂的与Ｐｙｔｈｏｎ交互的方法。要在Java范围内对PythonInterpreter施加更多的控制，最简单的方法就是，发送数据给解释器，然后再从它取回数据（pull data back out）。

提交数据Putting data in
    为了向你的Python程序插入数据，PythonInterpreter类有一个看似简单的方法：set( ).。实际上，set( )可以接受不同类型的数据并且对它们进行转换。下面的例子是一个关于set( )不同用法的相当全面的练习，一道给出的那些注释提供了相当完整的解释。

//- interpreter:PythonInterpreterSetting.java
// Passing data from Java to python when using
// the PythonInterpreter object.
package interpreter;
import org.python.util.PythonInterpreter;
import org.python.core.*;
import java.util.*;
import com.bruceeckel.python.*;
import junit.framework.*;
 
public class
PythonInterpreterSetting extends TestCase  {
  PythonInterpreter interp =
    new PythonInterpreter();
  public void test() throws PyException  {
    // It automatically converts Strings
    // into native Python strings:
    interp.set("a", "This is a test");
    interp.exec("print a");
    interp.exec("print a[5:]"); // A slice
    // It also knows what to do with arrays:
    String[] s = { "How", "Do", "You", "Do?" };
    interp.set("b", s);
    interp.exec("for x in b: print x[0], x");
    // set() only takes Objects, so it can't
    // figure out primitives. Instead,
    // you have to use wrappers:
    interp.set("c", new PyInteger(1));
    interp.set("d", new PyFloat(2.2));
    interp.exec("print c + d");
    // You can also use Java's object wrappers:
    interp.set("c", new Integer(9));
    interp.set("d", new Float(3.14));
    interp.exec("print c + d");
    // Define a Python function to print arrays:
    interp.exec(
      "def prt(x): \n" +
      "  print x \n" +
      "  for i in x: \n" +
      "    print i, \n" +
      "  print x.__class__\n");
    // Arrays are Objects, so it has no trouble
    // figuring out the types contained in arrays:
    Object[] types = {
      new boolean[]{ true, false, false, true },
      new char[]{ 'a', 'b', 'c', 'd' },
      new byte[]{ 1, 2, 3, 4 },
      new int[]{ 10, 20, 30, 40 },
      new long[]{ 100, 200, 300, 400 },
      new float[]{ 1.1f, 2.2f, 3.3f, 4.4f },
      new double[]{ 1.1, 2.2, 3.3, 4.4 },
    };
    for(int i = 0; i < types.length; i++) {
      interp.set("e", types[i]);
      interp.exec("prt(e)");
    }
    // It uses toString() to print Java objects:
    interp.set("f", new Date());
    interp.exec("print f");
    // You can pass it a List
    // and index into it...
    List x = new ArrayList();
    for(int i = 0; i < 10; i++)
        x.add(new Integer(i * 10));
    interp.set("g", x);
    interp.exec("print g");
    interp.exec("print g[1]");
    // ... But it's not quite smart enough
    // to treat it as a Python array:
    interp.exec("print g.__class__");
    // interp.exec("print g[5:]); // Fails
    // If you want it to be a python array, you
    // must extract the Java array:
    System.out.println("ArrayList to array:");
    interp.set("h", x.toArray());
    interp.exec("print h.__class__");
    interp.exec("print h[5:]");
    // Passing in a Map:
    Map m = new HashMap();
    m.put(new Integer(1), new Character('a'));
    m.put(new Integer(3), new Character('b'));
    m.put(new Integer(5), new Character('c'));
    m.put(new Integer(7), new Character('d'));
    m.put(new Integer(11), new Character('e'));
    System.out.println("m: " + m);
    interp.set("m", m);
    interp.exec("print m, m.__class__, " +
      "m[1], m[1].__class__");
    // Not a Python dictionary, so this fails:
    //! interp.exec("for x in m.keys():" +
    //!   "print x, m[x]");
    // To convert a Map to a Python dictionary,
    // use com.bruceeckel.python.PyUtil:
    interp.set("m", PyUtil.toPyDictionary(m));
    interp.exec("print m, m.__class__, " +
      "m[1], m[1].__class__");
    interp.exec("for x in m.keys():print x,m[x]");
  }
  public static void
  main(String[] args) throws PyException  {
    junit.textui.TestRunner.run(
      PythonInterpreterSetting.class);
  }
} ///:~

    对于Java来说，大多数时候真正的对象（real objects）和基本类型（primitive types）之间的差别总会带来麻烦。一般而言，如果你传递给set( ),方法的是一个通常的对象（regular object），它是知道如何处理的，但是如果你想传入一个基本类型（primitive type）的对象，就必须得作转换。一种做法是创建一个“Py”类型，比如PyInteger和PyFloat，但实际上你也可以使用Java自带的对象外覆类比如Integer和Float，这些可能更容易记住。
    上面程序的前一部分你会看到有一个exec( )含有以下的Python语句：
    pint a[5:]
    索引语句里的那个分号表明这是一个Python切片（slice），所谓切片就是从一个原始数组里产生出某一范围内的元素。在这里，它产生出一个包含从第5号元素开始直到原来数组最后一个元素的新数组。你也可以用“a[3:5]”产生第3号到第5号元素，或者用“a[:5]”产生第0号到第5号元素。在这个语句里使用切片的原因是为了保证Java的String确实被转换成了一个Python字符串，而Python字符串是可以被当作一个字符数组来对待的。
    你会看到我们是能够用exec( ),来创建一个Python函数的（虽然有点别扭）。prt( )函数打印整个数组，然后（to make sure it’s a real Python array）遍历数组的每一个元素并且把它打印出来。最后，它打印数组的类名称，我们可以据此看看发生是什么转换（Python不仅有运行时刻信息，它还有与Java的反射相当的东西）。prt( )函数用以打印来自Java的基本类型的数组。
    尽管可以使用set( )把一个Java的ArrayList传入解释器，而且你也能把它当作数组那样进行索引，但是试图从它产生一个切片是不会成功的。为了把它完全转换成一个数组，一种方法是简单的利用toArray( )从中取出一个Java数组，然后再把它传给解释器。set( )方法会把它转换成一个PyArray ——Jython提供的一个类——它可以被当作一个Python数组来处理（你也可以显式的创建一个PyArray，但是似乎没有这个必要）。
    最后，我们创建了一个Map并且把它直接传给了解释器。虽然可以对While it is possible to do simple things like index into the resulting object，但它并不是一个真正的Python字典（dictionary），所以你不能调用像keys( )那样的方法。并没有直接了当的方法可以把一个Java的Map转换成一个Python字典，于是我就写了一个叫做toPyDictionary( )的小程序并且把它作为com.bruceeckel.python.PyUtil的一个静态方法。它还包括一些从Python数组提取数据到Java List和从Python字典提取数据到Java Map的一些小程序。

//- com:bruceeckel:python:PyUtil.java
// PythonInterpreter utilities
package com.bruceeckel.python;
import org.python.util.PythonInterpreter;
import org.python.core.*;
import java.util.*;
 
public class PyUtil {
  /** Extract a Python tuple or array into a Java
  List (which can be converted into other kinds
  of lists and sets inside Java).
  @param interp The Python interpreter object
  @param pyName The id of the python list object
  */
  public static List
  toList(PythonInterpreter interp, String pyName){
    return new ArrayList(Arrays.asList(
      (Object[])interp.get(
        pyName, Object[].class)));
  }
  /** Extract a Python dictionary into a Java Map
  @param interp The Python interpreter object
  @param pyName The id of the python dictionary
  */
  public static Map
  toMap(PythonInterpreter interp, String pyName){
    PyList pa = ((PyDictionary)interp.get(
      pyName)).items();
    Map map = new HashMap();
    while(pa.__len__() != 0) {
      PyTuple po = (PyTuple)pa.pop();
      Object first = po.__finditem__(0)
        .__tojava__(Object.class);
      Object second = po.__finditem__(1)
        .__tojava__(Object.class);
      map.put(first, second);
    }
    return map;
  }
  /** Turn a Java Map into a PyDictionary,
  suitable for placing into a PythonInterpreter
  @param map The Java Map object
  */
  public static PyDictionary
  toPyDictionary(Map map) {
    Map m = new HashMap();
    Iterator it = map.entrySet().iterator();
    while(it.hasNext()) {
      Map.Entry e = (Map.Entry)it.next();
      m.put(Py.java2py(e.getKey()),
        Py.java2py(e.getValue()));
    }
    // PyDictionary constructor wants a Hashtable:
    return new PyDictionary(new Hashtable(m));
  }
} ///:~

下面是（黑盒）单元测试的代码：

//- com:bruceeckel:python:Test.java
package com.bruceeckel.python;
import org.python.util.PythonInterpreter;
import java.util.*;
import junit.framework.*;
 
public class Test extends TestCase  {
  PythonInterpreter pi =
    new PythonInterpreter();
  public void test1() {
    pi.exec("tup=('fee','fi','fo','fum','fi')");
    List lst = PyUtil.toList(pi, "tup");
    System.out.println(lst);
    System.out.println(new HashSet(lst));
  }
  public void test2() {
    pi.exec("ints=[1,3,5,7,9,11,13,17,19]");
    List lst = PyUtil.toList(pi, "ints");
    System.out.println(lst);
  }
  public void test3() {
    pi.exec("dict = { 1 : 'a', 3 : 'b', " +
      "5 : 'c', 9 : 'd', 11 : 'e'}");
    Map mp = PyUtil.toMap(pi, "dict");
    System.out.println(mp);
  }
  public void test4() {
    Map m = new HashMap();
    m.put("twas", new Integer(11));
    m.put("brillig", new Integer(27));
    m.put("and", new Integer(47));
    m.put("the", new Integer(42));
    m.put("slithy", new Integer(33));
    m.put("toves", new Integer(55));
    System.out.println(m);
    pi.set("m", PyUtil.toPyDictionary(m));
    pi.exec("print m");
    pi.exec("print m['slithy']");
  }
  public static void main(String args[]) {
    junit.textui.TestRunner.run(Test.class);
  }
} ///:~

下一小节我们会讲述（数据）提取工具的用法。

取出数据Getting data out
    存在很多种不同的方法从PythonInterpreter提取数据。如果你只是调用get( )方法，把对象标识符作为一个字符串传给它，它会返回一个PyObject（由org.python.core所提供的支持类的一部分）。可以用__tojava__( )方法对它进行“cast”，但是还有比这更好的方法：

1. Py类有一些很方便的方法，比如py2int( )，可以接受一个PyObjec并且把它转换成若干不同的类型。
2. get( )有一个重载过的版本可以接受预期的Java Class对象作为第二个参数，并且产生出一个具有其运行时刻类型（run-time type）的对象（所以说在你的Java代码里你仍然需要对得到的结果进行一次cast）。

      使用第二种方法，从PythonInterpreter取出一个数组是非常简单的。这一点显得尤为有用，因为Python对字符串和文件处理都异常的出色，所以通常你会希望把结果作为一个字符串数组提出出来。例如，你可以使用Python的glob( )函数对文件名进行通配符扩展（wildcard expansion），就像接下来的例子所展示的那样：

//- interpreter:PythonInterpreterGetting.java
// Getting data from the PythonInterpreter object.
package interpreter;
import org.python.util.PythonInterpreter;
import org.python.core.*;
import java.util.*;
import com.bruceeckel.python.*;
import junit.framework.*;
 
public class
PythonInterpreterGetting extends TestCase {
  PythonInterpreter interp =
    new PythonInterpreter();
  public void test() throws PyException  {
    interp.exec("a = 100");
    // If you just use the ordinary get(),
    // it returns a PyObject:
    PyObject a = interp.get("a");
    // There's not much you can do with a generic
    // PyObject, but you can print it out:
    System.out.println("a = " + a);
    // If you know the type it's supposed to be,
    // you can "cast" it using __tojava__() to
    // that Java type and manipulate it in Java.
    // To use 'a' as an int, you must use
    // the Integer wrapper class:
    int ai= ((Integer)a.__tojava__(Integer.class))
      .intValue();
    // There are also convenience functions:
    ai = Py.py2int(a);
    System.out.println("ai + 47 = " + (ai + 47));
    // You can convert it to different types:
    float af = Py.py2float(a);
    System.out.println("af + 47 = " + (af + 47));
    // If you try to cast it to an inappropriate
    // type you'll get a runtime exception:
    //! String as = (String)a.__tojava__(
    //!   String.class);
   
    // If you know the type, a more useful method
    // is the overloaded get() that takes the
    // desired class as the 2nd argument:
    interp.exec("x = 1 + 2");
    int x = ((Integer)interp
      .get("x", Integer.class)).intValue();
    System.out.println("x = " + x);
   
    // Since Python is so good at manipulating
    // strings and files, you will often need to
    // extract an array of Strings. Here, a file
    // is read as a Python array:
    interp.exec("lines = " +
      "open('PythonInterpreterGetting.java')" +
      ".readlines()");
    // Pull it in as a Java array of String:
    String[] lines = (String[])
      interp.get("lines", String[].class);
    for(int i = 0; i < 10; i++)
      System.out.print(lines[i]);
   
    // As an example of useful string tools,
    // global expansion of ambiguous file names
    // using glob is very useful, but it's not
    // part of the standard Jython package, so
    // you'll have to make sure that your
    // Python path is set to include these, or
    // that you deliver the necessary Python
    // files with your application.
    interp.exec("from glob import glob");
    interp.exec("files = glob('*.java')");
    String[] files = (String[])
      interp.get("files", String[].class);
    for(int i = 0; i < files.length; i++)
      System.out.println(files[i]);
   
    // You can extract tuples and arrays into
    // Java Lists with com.bruceeckel.PyUtil:
    interp.exec(
      "tup = ('fee', 'fi', 'fo', 'fum', 'fi')");
    List tup = PyUtil.toList(interp, "tup");
    System.out.println(tup);
    // It really is a list of String objects:
    System.out.println(tup.get(0).getClass());
    // You can easily convert it to a Set:
    Set tups = new HashSet(tup);
    System.out.println(tups);
    interp.exec("ints=[1,3,5,7,9,11,13,17,19]");
    List ints = PyUtil.toList(interp, "ints");
    System.out.println(ints);
    // It really is a List of Integer objects:
    System.out.println((ints.get(1)).getClass());
   
    // If you have a Python dictionary, it can
    // be extracted into a Java Map, again with
    // com.bruceeckel.PyUtil:
    interp.exec("dict = { 1 : 'a', 3 : 'b'," +
      "5 : 'c', 9 : 'd', 11 : 'e' }");
    Map map = PyUtil.toMap(interp, "dict");
    System.out.println("map: " + map);
    // It really is Java objects, not PyObjects:
    Iterator it = map.entrySet().iterator();
    Map.Entry e = (Map.Entry)it.next();
    System.out.println(e.getKey().getClass());
    System.out.println(e.getValue().getClass());
  }
  public static void
  main(String[] args) throws PyException  {
    junit.textui.TestRunner.run(
      PythonInterpreterGetting.class);
  }
} ///:~

    最后两个例子展示了从Python的垫片（tuples）和链表（lists）中提取数据到Java Lists，以及从Python 字典中提取数据到Java Maps。上述两种情况都需要用到比标准Jython库所提供的更多的处理方法，所以我又写了一些小程序放在com.bruceeckel.pyton里。PyUtil: toList( )是用来从一个Python序列产生一个List，toMap( )用来从Python字典产生出一个Map。PyUtil所提供的方法使得在Java和Python之间来回传递重要的数据结构变得更为简单。

多个解释器Multiple interpreters
    很有必要再提一下，你可以在一个程序里声明多个PythonInterpreter对象，每个对象有它自己的名字空间：

//- interpreter:MultipleJythons.java
// You can run multiple interpreters, each
// with its own name space.
package interpreter;
import org.python.util.PythonInterpreter;
import org.python.core.*;
import junit.framework.*;
 
public class MultipleJythons extends TestCase  {
  PythonInterpreter
    interp1 =  new PythonInterpreter(),
    interp2 =  new PythonInterpreter();
  public void test() throws PyException {
    interp1.set("a", new PyInteger(42));
    interp2.set("a", new PyInteger(47));
    interp1.exec("print a");
    interp2.exec("print a");
    PyObject x1 = interp1.get("a");
    PyObject x2 = interp2.get("a");
    System.out.println("a from interp1: " + x1);
    System.out.println("a from interp2: " + x2);
  }
  public static void
  main(String[] args) throws PyException  {
    junit.textui.TestRunner.run(MultipleJythons.class);
  }
} ///:~

    当运行程序的时候你会看到，每个PythonInterpreter所包含的a的值是不同的。

。。。。。。


                        目录

发表于 @ 2005年02月21日 15:16:00|评论(loading...)|编辑