Python and Java - A Side by Side Comparison

There are three main language characteristics that make programmers more productive with Python than with Java.

Example

The classic "Hello, world!" program illustrates the relative verbosity of Java.

public class HelloWorld
{
    public static void main (String[] args)
    {
        System.out.println("Hello, world!");
    }
}

print "Hello, world!"

Example

In the following example, we initialize an integer to zero, then convert it to a string, then check to see if it is empty. Note the data declaration (highlighted), which is necessary in Java but not in Python. Notice also how verbose Java is, even in an operation as basic as comparing two strings for equality.

int    myCounter = 0;
String myString = String.valueOf(myCounter);
if (myString.equals("0")) ...

myCounter = 0
myString = str(myCounter)
if myString == "0": ...

// print the integers from 1 to 9
for (int i = 1; i < 10; i++) {
   System.out.println(i);
}

# print the integers from 1 to 9
for i in range(1,10):
    print i

Example

Your application has 15 classes. (More precisely, it has 15 top-level public classes.)

Example

In your application, method A calls B calls C calls D calls E calls F. You discover that F must throw exception SpecialException, and it must be caught by A.

The reason for this is that Java, virtually alone among object-oriented programming languages, uses checked exceptions — exceptions that must be caught or thrown by every method in which they might appear, or the code will fail to compile. Recently (as of June 2003) there seems to be an increasing amount of unhappiness with Java's use of checked exceptions. See Bruce Eckel's "Does Java need Checked Exceptions?" and Ron Waldhoff's "Java's checked exceptions were a mistake".

As chromatic, the Technical Editor of the O'Reilly Network, put it:

Example

Your application has an Employee class. When an instance of Employee is created, the constructor may be passed one, two, or three arguments.

If you are programming in Java, this means that you write three constructors, with three different signatures. If you are programming in Python, you write only a single constructor, with default values for the optional arguments.

public class Employee
{
    private String myEmployeeName;
    private int    myTaxDeductions = 1;
    private String myMaritalStatus = 
                           "single";

    //--------- constructor #1 ------
    public Employee(String EmployeName)
    {
        this(employeeName, 1);
    }

    //--------- constructor #2 ------
    public Employee(String EmployeName, 
                    int taxDeductions)
    {
       this(employeeName, taxDeductions,
                         "single");
    }

    //--------- constructor #3 ------
    public Employee(String EmployeName,
           int taxDeductions,
           String maritalStatus)
    {
       this.employeeName  = employeeName;
       this.taxDeductions = taxDeductions;
       this.maritalStatus = maritalStatus;
    }
...

class Employee():

    def __init__(self, 
        employeeName, taxDeductions=1, 
        maritalStatus="single"):
      
        self.employeeName    = employeeName
        self.taxDeductions   = taxDeductions
        self.maritalStatus   = maritalStatus
...

Example

In Why Python? Eric S. Raymond notes that:

In Why I Love Python Bruce Eckel notes that Java is not compact.

import java.io.*;

...

BufferedReader myFile =
    new BufferedReader(
        new FileReader(argFilename));

# open an input file
myFile = open(argFilename)

Example

Java's string-handling capabilities are surprisingly weak. (But they have improved considerably with the addition of the split method to the String class in Java 1.4.)

Example

Code to add an int to a Vector, and then retrieve it.

Prior to Java 1.5, a new Integer object had to be created and initialized from the int before it could be added to a Vector. In order to retrieve the value, the member of the Vector had to be cast back to an Integer, and then converted back to an int.

public Vector aList        = new Vector;
public int    aNumber      = 5;
public int    anotherNumber;

aList.addElement(new Integer(aNumber));
anotherNumber = 
      ((Integer)aList.getElement(0)).intValue();

aList = []
aNumber = 5


aList.append(aNumber)
anotherNumber = aList[0]

This clumsiness was eliminated in Java 1.5 with the introduction of generics (which allows you to "type" a container object) and autoboxing (which automates conversion between primitive types and their corresponding wrapper classes). With generics, it is possible to code ContainerType ( which reads as ContainerType restricted to objects of ContainedType).

public Vector aList = new Vector;
public int    aNumber      = 5;
public int    anotherNumber;

aList.addElement(aNumber);
anotherNumber = aList.getElement(0);

aList = []
aNumber = 5


aList.append(aNumber)
anotherNumber = aList[0]

Example

Verbosity is not just a matter of increasing the number of characters that must be typed — it is also a matter of increasing the number of places where mistakes can be made. The Java code on the left has 5 control characters: ( ) { } ; where the corresponding Python code has only one control character, the colon. (Or two, if you count indentation. See below.)

if ( a > b )
{
    a = b;
    b = c;
}

if  a > b :
    a = b
    b = c

Omitting or duplicating such characters is easy to do accidentally, and constitutes a severe error in the code. In my personal estimate, I spend 5 times as much time fixing such errors in Java as I do in Python. It really cuts into your productivity — and your creative energy — when you spend that much of your time just trying to satisfy the compiler.

Technically, Python has another control character that Java does not — indentation. But the requirement for correct indentation is the same in Java as it is in Python, because in both languages correct indentation is a practical requirement for human-readable code. The Python interpreter automatically enforces correct indentation, whereas the Java compiler does not. With Java, you need an add-on product such as the Jalopy code formatter to provide automated enforcement of indentation standards.

 |