Java

Python

package (directory)

package (directory) with _ _init_ _.py

class source file

module source file

class

class or module (depending on the kind of class it is in java)

strongly typed

strongly typed (objects have a specific type, always. More about this.

boolean, byte, char, short, int, long, float, double (primitive types)

bool, int, str(length 1), int, int, long, float, float (simple types)

Strings are Unicode

strings can be unicode, see UnicodeStrings

BigInteger class

long simple type

BigDecimal class

decimal.Decimal

structured exception handling

structured exception handling

reflection / introspection

reflection / introspection on steroids

iterators (better in Jdk 1.5)

iterators, but better and more generic

Java

Python

javac compiler

python compiler/interpreter

java byte code interpreter

python compiler/interpreter

java JIT compiler

Psyco JIT compiler

fully Unicode aware by default

fully Unicode aware if you program to it

write once source, run anywhere

write once run anywhere

object serialization mechanism

marshal and pickle modules

mark-and-sweep garbage collector

reference counting garbage collector with cycle detection

available on many platforms

available on even more platforms

easy multithreading

fairly easy multithreading, but has the sometimes dreaded GIL

XML / XSL processing

XML / XSL processing through various implementations

JNI Java Native Interface

Python C/C++ Extension API (much better!)

JRE Java Runtime classes (rt.jar)

Python standard library (arguably more diverse, although in Jdk1.5 things are improving for Java)

AWT/Swing/SWT GUI toolkits

Tk (standard), wxWindows, MFC, Mac, Gtk, Qt GUI toolkits

Various very good IDEs availble

various IDEs such as Wing IDE, Blackadder, Komodo, PyDev (Eclipse plugin)

J2EE standard

no real corresponding standard, but a lot of APIs from J2EE can readily be found in the Python standard library; see also PEAK, a project to bring other J2EE features to Python

J2EE JSP/Servlet dynamic web pages

Lots of free tools available, no real standard.

J2EE Web Application Server such as Websphere or JBoss

Lots of free tools available, no real standard.

RMI and CORBA

My own Pyro, OmniOrb

JAR

EGG

comp.lang.java.* newsgroups

comp.lang.python and comp.lang.python.announce newsgroups

Java

Python

static typing

dynamic typing (more about this)

variable assignment with typed objects

name binding to typed objects

interfaces

abstract base classes or mixins; also, frameworks such as Twisted, Zope and PyProtocols offer tools for interface declaration, introspection and adaptation.

pointers (sort of)

true object references

{...} code blocks

indentation signifies code blocks; whitespace is relevant; no {...} or BEGIN...END needed

Available through standard packages

Very high level data structures built-in (lists, tuples, sets, maps)

3rd-party support (Apache Commons), albeit more difficult to use

complex number datatype

not present

functions

not present

operator overloading

not possible

multiple inheritance with well-defined Method Resolution Order

Late binding standard (Methods are virtual by default). Methods may be resolved at compile time (early) if declared final or static.

late binding

not present

meta classes

much weaker form of closures are achieved by anonymous classes

lambda functions (unnamed function objects)

not present

list comprehensions such as [x*2 for x in range(5)] gives the list [0, 2, 4, 6, 8]

not present

generators (functions that save state between different results)

Collections API. Generic collections are still typed, but if the collection is unconstrained, it may hold any type (note that the Java compiler does issue warnings; this is not the standard way of doing things in Java)

not needed in Python; most collections (data structures) are built-in, and generic. That is, collections can hold objects of any type.

public, private, protected, package level access

public by default, weak private(is about equivalent with protected) by single leading underscore (e.g. obj._foo), strong private(is practically equivalent with private) by double leading underscores

Java

Python

no real analogy (although there is BeanShell)

interactive interpreter shell

Always compiled to bytecode

Always compiled to bytecode; not always saved to a file

JIT compiler for better performance

not available in standard Python, but there's Psyco Psyco].

applets in browsers

no analogy

Many J2EE enterprise standards

lacking enterprise standards, but many powerful implementations exist, and a lot of APIs are already present (and standardized) in the Python standard library

Prior to late 2006, Java was proprietary. Now licensed under the OSI-approved CDDL and FSF-approved GPL. Most standard, proprietary libraries are deprecated, although some some still exist.

Python is free (BSD-style, GPL-compatible licensing) and open source technology

Generally good raw performance

Slower performance, but please read PythonSpeed where some of the issues related to speed are discussed

good multithreading

often good multithreading but beware of the GIL