幸福的联姻：Java 和 Python

幸福的联姻：Java 和 Python
本文节录自《 Learning Python 》一书第十章〈Frameworks and Applications〉

JPython 是最近出现的一个 Python 分支，由 Jim Hugunin 先生完全以 Java 撰写完成。对于 Python 和 Java 阵营来说，JPython 的出现相当令人兴奋，Python 使用者相当高兴他们现有的 Python 知识可以应用到 Java 的开发环境中；Java 的使用者也很高兴他们能够使用 Python 当作描述语言（scripting language）来操作 Java  系统、测试链接库、并在直译环境中学习 Java 链接库。

你可以在 http://www.jpython.org/ 取得 JPython，其授权方式类似于 CPython（为了有别于 Java 版的 JPython，原先版本的 Python 改叫 CPython ）。

JPython 安装好之后，包含了：
l jpython：JPython 的直译环境。
l jpythonc：用来将 JPython 程序编译成 Java 的 bytecode 。产生出来的程序就和一般的 Java 类别档没有两样，可以用来产生 applet、servlet、bean 等。
l 一套程序模块：提供标准的 Python 链接库给 JPython 的使用者。
l 一些范例程序：用来展示 JPython 的多重风貌。

JPython 的使用方式和 Python 很类似，请看下面的例子：

~/book> jpython
JPython 1.0.3 on java1.2beta4
Copyright 1997-1998 Corporation for National Research Initiatives
>>> 2 + 3
5

事实上，JPython 和 CPython 的运作方式几乎一样。想知道两者有何真正的差异，最新的资料可以从 http://www.python.org/jpython/differences.html 取得。其中最大的差异在：
l JPython 目前比 CPython 慢。有多慢？这会因 Java 虚拟机器和 JPython 测试程序的不同而有异。不过，JPython 的作者已经承诺未来会做最佳化，使得 JPython 的速度会和 CPython一样快，甚至更快。
l JPython 欠缺一些内建模块或链接库模块。比方说，不能使用 os.system() ，因为这会造成 Java 和底层 OS 互动的困扰。有一些 CPython 所具备的大型延伸模块（比方说，Tkinter）也在 JPython 中付之阙如，因为 Java 环境原本就不具备这些工具（比方说 Tk/Tcl ）。 

透过 JPython，Python 程序员可以使用 Java 链接库 JPython 可以让 Python 程序员天衣无缝地使用 Java 链接库，而这是 CPython 做不到的。请看下面的程序 jpythondemo.py 和其执行结果。

from pawt import swing
import java

def exit(e): java.lang.System.exit(0)

frame = swing.JFrame('Swing Example', visible=1)
button = swing.JButton(This is a Swinging button!', actionPerformed=exit)
frame.contentPane.add(button)
frame.pack()

透过这个简单的程序，你可以看出，写一个用 Java Swing 来当 GUI 的 Python 程序相当简单。第一行先引入（import）Swing 的package（pawt 表示目前 Swing 模块的所在位置，可以是在 java.awt.swing、或 com.sun.java.swing、或 javax.swing）。第二行引入 java package，因为待会程序中会用到 java.lang.System.exit()。第四行建立一个 JFrame 对象，并设定此 JFrame 组件的 visible 属性为「真」。第五行建立一个 JButton 对象，设定其标示文字，并指定按键被按下时必须执行的函式为 exit()。最后两行把此 JButton 对象放到 JFrame 对象中，再将 JFrame 的大小调到刚好。

有经验的 Java 程序员可能会对 jpythondemo.py 程序中的某些部分感到有些吃惊，因为它和对等的 Java 程序有些差异。为了要让 JPython 中使用 Java 链接库和 CPython 中一样简单， JPython 在背后做了许多事，比方说，当 JPython 引入（import）一个 Java package ，就会主动地往下追踪适当的 package ，然后透过 Java Reflection API 找出 package 的内容、类别和 method 的 signature。JPython 也会实时进行 Python 和 Java 之间的型态转换。比方说：在 jpythondemo.py 程序中，按键的文字「This is a Swinging example!」是 Python 的字符串，在呼叫 JButton 的 constructor 之前，JPython 会先找出正确的 constructor（透过参数来判断），然后自动将 Python 的字符串转成 Java 的字符串。JPython 内部甚至用了更精巧的方式来允许你在 JButton 的 constructor 中方便地使用「actionPerformed=exit」当作参数。这种作法是 Java 所没有的，因为 Java 不允许 function（或 method）当作参数。在 JPython 中，你不用像 Java 需要为了提供 actionPerformed method 而建立一个 ActionListener 类别（当然你也可以在 JPython 中使用 Java 的方式，如果你不嫌啰唆的话）。

JPython as a Java Scripting Language
JPython 越来越受欢迎，因为它允许程序员去探究不断出现、形形色色的 Java 链接库。大家也发现 JPython 可以帮助在 Java 中嵌入 Python 当作描述语言（scripting language），来让最终使用者量身打造、测试、或进行其它程序设计工作。关于这方面更进一步的资料，在 JPython 软件的demo/embed 次目录中有更详细的说明。

一个真正的 JPython/Swing 范例：grapher.py
grapher.py 程序（外观如下图）允许使用者用图形的方式来观察数学函数的图形。本程序也用到 Swing GUI 套件。画面上有两个文字字段需要填入 Python 程序。在上面的字段中填入任意的Python 程序，在此引入（import）所需要的模块，并定义相关函数。第二个字段（标式示「Expression:」）中填入 Python 的计算式（比方说 sin(x)），而非填入 Python 叙述。绘图时每个水瓶坐标 x 值都会代入此计算式。

使用者可以自行控制绘出的图形是线状图或实心图，也可以决定绘图点数、颜色。而且，还可以把设定存到磁盘中，下次再叫出来（透过 pickle 模块）。下面就是 grapher.py 的程序代码：

from pawt import swing, awt, colors, GridBag
RIGHT = swing.JLabel.RIGHT
APPROVE_OPTION = swing.JFileChooser.APPROVE_OPTION
import java.io
import pickle, os

default_setup = """from math import *def squarewave(x,order):
total = 0.0
    for i in range(1, order*2+1, 2):
        total = total + sin(x*i/10.0)/(float(i))    
return total
"""

default_expression = "squarewave(x, order=3)" class Chart(awt.Canvas):
color = colors.darkturquoise
style = 'Filled'

    def getPreferredSize(self):
    return awt.Dimension(600,300)

def paint(self, graphics):
        clip = self.bounds
        graphics.color = colors.white
        graphics.fillRect(0, 0, clip.width, clip.height)
       

        width = int(clip.width * .8)
        height = int(clip.height * .8)
        x_offset = int(clip.width * .1)
        y_offset = clip.height - int(clip.height * .1)

        N = len(self.data); xs = [0]*N; ys = [0]*N

        xmin, xmax = 0, N-1
        ymax = max(self.data)        
        ymin = min(self.data)

        zero_y = y_offset - int(-ymin/(ymax-ymin)*height)
        zero_x = x_offset + int(-xmin/(xmax-xmin)*width)

        for i in range(N):            
            xs[i] = int(float(i)*width/N) + x_offset
            ys[i] = y_offset - int((self.data[i]-ymin)/(ymax-ymin)*height)
        graphics.color = self.color
        if self.style == "Line":
            graphics.drawPolyline(xs, ys, len(xs))
        else:
            xs.insert(0, xs[0]); ys.insert(0, zero_y)
            xs.append(xs[-1]); ys.append(zero_y)
            graphics.fillPolygon(xs, ys, len(xs))

        # draw axes
        graphics.color = colors.black
        graphics.drawLine(x_offset,zero_y, x_offset+width, zero_y)
        graphics.drawLine(zero_x, y_offset, zero_x, y_offset-height)

        # draw labels         leading = graphics.font.size
        graphics.drawString("%.3f" % xmin, x_offset, zero_y+leading)
        graphics.drawString("%.3f" % xmax, x_offset+width, zero_y+leading)
        graphics.drawString("%.3f" % ymin, zero_x-50, y_offset)
        graphics.drawString("%.3f" % ymax, zero_x-50, y_offset-height+leading)

class GUI:
def __init__(self):
        self.numelements = 100
        self.frame = swing.JFrame(windowClosing=self.do_quit)

        # build menu bar
        menubar = swing.JMenuBar()
        file = swing.JMenu("File")
        file.add(swing.JMenuItem("Load", actionPerformed = self.do_load))
        file.add(swing.JMenuItem("Save", actionPerformed = self.do_save))
        file.add(swing.JMenuItem("Quit", actionPerformed = self.do_quit))
        menubar.add(file)        
        self.frame.JMenuBar = menubar

        # create widgets
        self.chart = Chart(visible=1)
        self.execentry = swing.JTextArea(default_setup, 8, 60)
        self.evalentry = swing.JTextField(default_expression,
            actionPerformed = self.update)

        # create options panel
        optionsPanel = swing.JPanel(awt.FlowLayout(
            alignment=awt.FlowLayout.LEFT))

        # whether the plot is a line graph or a filled graph
        self.filled = swing.JRadioButton("Filled",
            actionPerformed=self.set_filled)
        optionsPanel.add(self.filled)
        self.line = swing.JRadioButton("Line",
            actionPerformed=self.set_line)
        optionsPanel.add(self.line)        
        styleGroup = swing.ButtonGroup()
        styleGroup.add(self.filled)
        styleGroup.add(self.line)

        # color selection
        optionsPanel.add(swing.JLabel("Color:", RIGHT))
        colorlist = filter(lambda x: x[0] != '_', dir(colors))
        self.colorname = swing.JComboBox(colorlist)
        self.colorname.itemStateChanged = self.set_color
        optionsPanel.add(self.colorname)

        # number of points
        optionsPanel.add(swing.JLabel("Number of Points:", RIGHT))
        self.sizes = [50, 100, 200, 500]
        self.numpoints = swing.JComboBox(self.sizes)
        self.numpoints.selectedIndex = self.sizes.index(self.numelements)
        self.numpoints.itemStateChanged = self.set_numpoints
        optionsPanel.add(self.numpoints)

        # do the rest of the layout in a GridBag
        self.do_layout(optionsPanel)
    def do_layout(self, optionsPanel):
        bag = GridBag(self.frame.contentPane, fill='BOTH',
            weightx=1.0, weighty=1.0)
        bag.add(swing.JLabel("Setup Code: ", RIGHT))
        bag.addRow(swing.JScrollPane(self.execentry), weighty=10.0)
        bag.add(swing.JLabel("Expression: ", RIGHT))
        bag.addRow(self.evalentry, weighty=2.0)
        bag.add(swing.JLabel("Output: ", RIGHT))
        bag.addRow(self.chart, weighty=20.0)
        bag.add(swing.JLabel("Options: ", RIGHT))
        bag.addRow(optionsPanel, weighty=2.0)
        self.update(None) 
        self.frame.visible = 1
        self.frame.size = self.frame.getPreferredSize()

        self.chooser = swing.JFileChooser()
        self.chooser.currentDirectory = java.io.File(os.getcwd())

def do_save(self, event=None):
    self.chooser.rescanCurrentDirectory()
        returnVal = self.chooser.showSaveDialog(self.frame)
        if returnVal == APPROVE_OPTION:
            object = (self.execentry.text,  self.evalentry.text,
                self.chart.style,
                self.chart.color.RGB,
                self.colorname.selectedIndex,
                self.numelements)
            file = open(os.path.join(self.chooser.currentDirectory.path,
                self.chooser.selectedFile.name), 'w')
            pickle.dump(object, file)
            file.close()

    def do_load(self, event=None):
        self.chooser.rescanCurrentDirectory()    
        returnVal = self.chooser.showOpenDialog(self.frame)
        if returnVal == APPROVE_OPTION:
            file = open(os.path.join(self.chooser.currentDirectory.path,
                self.chooser.selectedFile.name))
             (setup, each, style, color,
            colorname, self.numelements) = pickle.load(file)
            file.close()
            self.chart.color = java.awt.Color(color)
            self.colorname.selectedIndex = colorname
            self.chart.style = style
            self.execentry.text = setup
            self.numpoints.selectedIndex = self.sizes.index(self.numelements)
            self.evalentry.text = each
            self.update(None)

    def do_quit(self, event=None):
        import sys
        sys.exit(0)
    def set_color(self, event):
        self.chart.color = getattr(colors, event.item)
        self.chart.repaint()

    def set_numpoints(self, event):
        self.numelements = event.item
        self.update(None)

def set_filled(self, event):
    self.chart.style = 'Filled'
        self.chart.repaint()

    def set_line(self, event):
        self.chart.style = 'Line'
        self.chart.repaint()

def update(self, event):
    context = {}
        exec self.execentry.text in context
        each = compile(self.evalentry.text, '<input>', 'eval')
        numbers = [0]*self.numelements
        for x in xrange(self.numelements):
            context['x'] = float(x)
            numbers[x] = eval(each, context)
        self.chart.data = numbers
        if self.chart.style == 'Line':
            self.line.setSelected(1)
        else:
            self.filled.setSelected(1)
        self.chart.repaint()
GUI()

本程序的逻辑相当直观。透过命名良好的类别名称和 method 名称，你可以轻易地了解整个程序的概观。这个程序大部分都可以用 Java 写出来（不过需要更长的程序代码）。然而，粗体字的部分可以显示出使用 Python 所带来的威力：在此模块顶端，定义了设定字段和计算式字段的默认值，前者引入数学模块的函数并定义了一个名为 squarewave（方波）的函数；后者 以特定次序的参数呼叫此方波函数（随着参数变大，结果图形会越来越像方波，呼应此函数的名称）。 如果你已经安装好 Java、Swing、以及 JPython，你不妨试试其它的设定和计算式。

在本范例中，使用 JPython 而不用 Java 的最大利基在于 update()：单纯地以设定字段的程序为参数来呼叫 Python 标准的 exec()，然后每个坐标以编译好的计算式 字段程序来呼叫 eval。使用者可以在此二字段上自由地使用 Python。

JPython 仍有相当大的进步空间，Jim Hugunin 正持续地改进、最佳化 Python 和 Java 之间的接口。JPython 是 Python 的第二个实作版本，JPython 的出现也迫使 Guido van Rossum（译者注：他是Python 的创始者）必须厘清 Python 语言和实作的不同。幸运地，在这部分，Jim 和 Guido 似乎彼此观念颇能一致。