Run the interpreter and then enter in the following expressions:

>>> 44 / 11
4
>>> 324 / 101
3
>>> 324.0 / 101.0
3.207920792079208
>>> 324.0 / 101
3.207920792079208
>>> import sys
>>> sys.executable
'C:\jython2.5.0\jython.bat'
>>> sys.platform
'java1.6.0_03'
>>> sys.version_info
(2, 5, 0, 'final', 0)
>>>

How It Works

As shown in this example, the Jython interpreter appears and acts like the Python interpreter. This is just what you'd expect, because Jython is supposed to be an implementation of the Python language on top of the Java platform.

Math operations should work mostly the same as with Python. ("Mostly the same" means that some floating-point operations will create slightly different results.) Also blockquote that this example is using Jython 2.5.

On the same platform, you can see the differences when you run the same expressions with the python command, the C-Python interpreter. For example:

>>> 44 / 11
4
>>> 324 / 101
3
>>> 324.0 /101.0
3.2079207920792081
>>> 324.0 / 101
3.2079207920792081
>>> import sys
>>> sys.executable
'C:\Python31\pythonw.exe'
>>> sys.platform
win32
>>> sys.version_info
(3, 1, 0, 'final', 0)
>>>

Enter the following simple script and name the file jysys.py:

import sys

print('Python sys.path:')
print(sys.path)

print('Script arguments are:')
print(sys.argv)

When you run this script with jython, you should see output like the following:

Python sys.path:
['', ' C:\jython2.5.0\LIB','__classpath__', '__pyclasspath__/',
'C:\jython2.5.0\LIB\site-packages']
Script arguments are:
['']

The file paths will differ depending on where you installed Jython.

How It Works

The sys.path property holds a very small number of directories, especially when compared to the standard C-Python distribution. For example, you can run the same script with the python interpreter as shown here:

Python sys.path:
['C:\Python31\Lib\idlelib', C:\Windows\system32\python31.zip',
'C:\Python31\DLLs', 'C:\Python31\lib', 'C:\Python31\lib\plat-win',
'C:\Python31', 'C:\Python31\lib\site-packages']

In this case, blockquote the larger number of directories in the sys.path property.

Insert the following lines into the previous jysys.py script. The new line is marked in bold.

#! /usr/bin/env jython

import sys

print('Python sys.path:')
print(sys.path)

print('Script arguments are:')
print(sys.argv)

Save this new file under the name jysys, with no extension. Use the chmod command to add execute permissions, as shown in the following example:

$ chmod a+x jysys

You can then run this new command:

$ ./jysys 1 2 3 4
Python sys.path:
['', ' C:\jython2.5.0\LIB','__classpath__', '__pyclasspath__/',
'C:\jython2.5.0\LIB\site-packages']
Script arguments are:
['./jysys', '1', '2', '3', '4']

How It Works

The shebang comment works the same for Jython as it does for all other scripting languages. The only quirk with Jython is that the jython command itself is a script that calls the java command.

In the next section, you learn more about how the java command runs Jython scripts.

Enter the following script and name the file jystring.py:

import sys
from java.lang import StringBuffer, System


sb = StringBuffer(100)   # Preallocate StringBuffer size for performance.

sb.append('The platform is: ')
sb.append(sys.platform) # Python property
sb.append(' time for an omelette.')

sb.append('
')    # Newline
sb.append('Home directory: ')
sb.append( System.getProperty('user.home') )

sb.append('
')    # Newline
sb.append('Some numbers: ')
sb.append(44.1)
sb.append(', ')
sb.append(42)
sb.append(' ')

# Try appending a tuple.
tup=( 'Red', 'Green', 'Blue', 255, 204, 127 )
sb.append(tup)

print(sb.toString())

# Treat java.util.Properties as Python dictionary.
props = System.getProperties()

print('User home directory:', props['user.home'])

When you run this script, you should see the following output:

$ jython jystring.py
The platform is: java1.6.0_03 time for an omelette.
Home directory: /Users/James
Some numbers: 44.1, 42 ('Red', 'Green', 'Blue', 255, 204, 127)
User home directory: /Users/James

Note that your output will depend on where your home directory is located and which version of Java you have installed.

How It Works

This script imports the Java StringBuffer class and then calls a specific constructor for the class:

from java.lang import StringBuffer

sb = StringBuffer(100)

The Jython interpreter converts the value 100 from a Python number to a Java number.

You can pass literal text strings as well as Python properties to the StringBuffer append method:

sb.append('The platform is: ')
sb.append(sys.platform) # Python property

This example shows that Jython will correctly convert Python properties into Java strings for use in a Java object. You can also pass the data returned by a Java method:

sb.append( System.getProperty('user.home') )

In this case, the System.getProperty method returns an object of the Java type Object. Again, Jython properly handles this case, as Jython does with numbers:

sb.append(44.1)

sb.append(42)

You can even append a Python tuple:

tup=( 'Red', 'Green', 'Blue', 255, 204, 127 )
sb.append(tup)

The preceding example shows that Jython does the right thing when converting the tuple to a Java text string.

In addition to converting Python types to Java types, Jython works the other way as well. You can pass a Java String object, returned by the toString method, to the Python print function:

print sb.toString()

This shows how you can treat Java strings as Python strings. You can also treat Java hash maps and hash tables as Python dictionaries, as shown in the following example:

props = System.getProperties()

print('User home directory:', props['user.home'])

The Java System.getProperties method returns an object of type java.util.Properties, which Jython automatically converts into a Python dictionary.

Data type conversions as shown by this example are just what you'd expect when you integrate Java and Python. Jython does a lot of work under the covers, though. Java has a class hierarchy, as does Python. A large part of Jython is an attempt to merge these two large hierarchies together. Ultimately, you tend to get the best of both worlds.

For example, Python has the ability to pass named properties to a constructor. This proves especially useful when you work with APIs such as Swing for user interfaces. The Swing API has many, many classes. Each class supports a large number of properties on objects. Working with Java alone, you can call only the constructors that have been defined, and the parameters must be placed in a particular order. With Python, though, you can pass named properties to the object's constructor and set as many properties as needed within one call.

The following example shows this technique.

Enter the following script and name the file jyswing.py:

from java.lang import System
from javax.swing import JFrame, JButton, JLabel
from java.awt import BorderLayout

# Exit application
def exitApp(event):
    System.exit(0)

# Use a tuple for size
frame = JFrame(size=(500,100))

# Use a tuple for RGB color values.
frame.background = 127,255,127


button = JButton(label='Push to Exit', actionPerformed=exitApp)
label = JLabel(text='A Pythonic Swing Application',
    horizontalAlignment=JLabel.CENTER)

frame.contentPane.add(label, BorderLayout.CENTER)
frame.contentPane.add(button, BorderLayout.WEST)

frame.setVisible(1)

When you run this script, you should see a window like the one shown in Figure 21-1.

Figure 21.1. Figure 21-1

Click the button to exit the application.

How It Works

This script shows how you can use Jython with the complex Swing APIs. Although this example is almost all calls to Java APIs, it is much shorter than the corresponding Java program would be. That's because of the handy built-in features that come with Python, such as support for tuples and setting properties.

The script starts by importing several classes in the AWT and Swing APIs. The JFrame class acts as a top-level window in an application. You can create a JFrame widget with the following statements:

frame = JFrame(size=(500,100))

The size property on a JFrame widget is an instance of another Java class, java.awt.Dimension. In this example, you can make a Dimension object from a tuple and then pass this object to set the size property of the JFrame.

You can use the Python support for tuples and the Jython-provided integration with Java APIs to set colors as well:

frame.background = 127,255,127

This sets the background color to a light green.

Jython makes it easy to create interactive widgets on the screen. For example, the following code creates a JButton widget and sets the widget to call the function exitApp when the user clicks the button:

def exitApp(event):
    System.exit(0)

button = JButton(label='Push to Exit', actionPerformed=exitApp)

In this case, the exitApp function calls the Java method System.exit to exit the Java engine and therefore quit the application. Jython enables you to set Java properties to Python functions, such as exitApp in this example. In Java, you would need to make a class that implements the methods in the java.awt.event.ActionListener interface and then pass in an instance of this class as the action listener for the JButton. The Jython approach makes this much easier.

The example also creates a JLabel widget, which displays a text message, an image, or both. The jyswing.py script sets the horizontal alignment so that the text displays in the center of the widget's bounds:

label = JLabel(text='A Pythonic Swing Application',
    horizontalAlignment=JLabel.CENTER)

In this example, the value JLabel.CENTER is a constant on the JLabel class.

Enter the following Java program and name the file JyScriptRunner.java:

package jython;


import java.util.Properties;

import org.python.util.PythonInterpreter;
import org.python.core.PySystemState;


/**
 * Runs Jython scripts.
 */
public class JyScriptRunner {

    private PythonInterpreter interp;

/**
     * Initializes the Jython interpreter.
     */
    public void initialize(String pythonHome) {
        Properties props = new Properties();

       props.put("python.home", pythonHome);

       PythonInterpreter.initialize(
           System.getProperties(),
           props,
            new String[0]);

        interp = new PythonInterpreter(null, new PySystemState());

    }

    /**
     * Runs the given script.
     */
    public void run(String fileName) {
       interp.execfile(fileName);
    }


    public static void main(String[] args) {
        String fileName = args[0];

       JyScriptRunner runner = new JyScriptRunner();

        String pythonHome = System.getProperty("python.home");

       runner.initialize(pythonHome);

       runner.run(fileName);
    }
}

Because this is a Java program, you will need to compile the program with a command like the following:

$ javac -classpath ./jython.jar JyScriptRunner.java

When you run this Java program, you will see output like the following:

$ java -cp ./jython.jar:. 
    -Dpython.home="c:/jython2.5" 
   jython.JyScriptRunner jystring.py
The platform is: java1.6.0_03 time for an omelette.
Home directory: c:/jython2.5
Some numbers: 44.1, 42 ('Red', 'Green', 'Blue', 255, 204, 127)
User home directory: /Users/jamesp

This example runs the jystring.py example script. You will need to change the -Dpython.home setting to the location where you have installed Jython. Also change the ./jython.jar to the location where you have the file jython.jar.

How It Works

The program expects the caller to pass two values: the setting for the python.home system property and the name of a script to execute. You must have the jython.jar located in the current directory (or change the command line to refer to the location of your jython.jar file).

The JyScriptRunner class includes a main method, called when you run the program. The main method extracts the system property python.home as well as the file name from the command line (held in the args array). The main method then instantiates a JyScriptRunner object.

The main method initializes the JyScriptRunner object and then calls the run method to execute the script. Any errors encountered in the Jython script will result in exceptions that stop the program.

This is probably about the simplest Jython interpreter you can create. In your applications, you'll likely want to control the location of the Python home directory, perhaps placing this under an application directory.