Used to be "JPython", more recently changed to "jython".
An implementation of the PythonLanguage as one of the OtherLanguagesForTheJavaVm.
from the site ... (some from an older site)
Jython is an implementation of the high-level, dynamic, object-oriented PythonLanguage written in 100% Pure Java, and seamlessly integrated with the Java platform. It thus allows you to run Python on any Java platform. Jython is freely available for both commercial and non-commercial use and is distributed with source code. Jython is complementary to Java and is especially suited for the following tasks:
- Embedded scripting - Java programmers can add the JPython libraries to their system to allow end users to write simple or complicated scripts that add functionality to the application. Since JPython is certified 100% Pure Java, it can be added to an application without fear of compromising its ability to run on all Java platforms.
- Interactive experimentation - Jython provides an interactive interpreter that can be used to interact with Java packages or with running Java applications. This allows programmers to experiment and debug any Java system using Jython.
- Rapid application development - PythonLanguage programs are typically 2-10X shorter than the equivalent Java program. This translates directly to increased programmer productivity. The seamless interaction between PythonLanguage and Java allows developers to freely mix the two languages both during development and in shipping products.
JimHugunin began JPython in 1997. He left JPython development in '99. (He later began IronPython, in 2003.)
- "The Story of Jython", by Jim Hugunin
BarryWarsaw
? succeeded Hugunin, moving Jython onto
SourceForge and certified-
OpenSource licensing. From about 2000 FinnBock
? and then SamuelePedroni
? took over development. For some time Jython was an important Python implementation and one of the most successful of the JVM languages. But development stalled at some point after 2001. (Pedroni switched his focus to
PyPy.) By mid-2007, the stable version of Jython was still at 2.1 while CPython had reached 2.5. The missed point-releases include considerable changes to core Python (including an overhaul of the object model) so Jython not only missed those features but also saw its compatibility with CPython decline. In relative terms, it lost some or all of its lead in maturity over other JVM languages including
JayRuby,
GroovyLanguage and
ScalaLanguage. As of August 2007, Jython may finally be escaping its stall; Jython 2.2 has reached RC3.
Strengths:
- Ability to use a scripting language from within Java. This alone makes it worthwhile!
- Excellent ability to invoke JavaLanguage objects from Python code. This means that you have easy access to all those Java libraries. In fact, it's often EASIER to call Java objects from the Python side than from the Java side! The only time it gets annoying is when there are multiple methods with the same name but multiple signatures. That's called "method overloading", grasshopper.
- Pretty darn easy to invoke PythonLanguage objects from Java code. This less used, but vitally important for complete integration.
- All the "obvious" conversions are performed for you. Strings, numbers, arrays, and things like that are typically converted for you with little effort. A java.lang.String just becomes a Python string (and vice-versa) with no need to "convert". With fancier objects you'll need to make some effort.
- Python interpreter can easily be embedded in Java. The existence of "exec" (or its equivalent) in PerlLanguage, PythonLanguage, LispLanguage, etc. makes it quite easy to make things user-scriptable (at runtime). Now you can do it for JavaLanguage too, only the user scripts get written in Python.
Weaknesses:
- Class loading is weak. For example, if you change a script, you either need to run it with a new class loader or restart the application that will exec the script. Furthermore, reload is shallow, so if any imported scripts change, they also need to be recompiled and run under a new class loader.
- Jython programs run much more slowly than CPython ones.
- Jython lags several "point" versions behind CPython, plus it doesn't have all the same libraries and functionality as CPython.
- Java arrays are a problem. Use the jarray module for Java array support.
Q.Has Jython any benefits against the BeanShell? -- Reasonable question actually. BeanShell, RhinoInterpreter and JavaPython all began around 1997, making them "first-generation" JVM languages. (Where clearly Java was the zeroth-generation JVM language. :) ) How do they, or used they, to compare?
CategoryPython CategoryJava CategoryProgrammingLanguage
Java Python