Python for Java programmers
This is hardly a complete comparison,
but it quickly expresses the most basic points, so if you have Java in your head, you can convert it to simpler Python.
Index:
Comments
# starts a Python comment to the end of the line, as // starts one in
Java.
Types
Python data is typed
23 # int
23.0 # float (Java double)
7.3 + 23.5j # complex: note j suffix, not i for the imaginary part.
False
# The boolean type is called bool, and the literals are
capitalized, unlike in Java.
"Hello" # string
'H' # ALSO a string. There is no separate character
type.
As long as they are paired, either quote form " or ' may be used to
enclose string literals. Python also has the special form with
triple quotes that allows for multiline strings with embedded " and '.
s = "Hi"
t = 'there'
twoLines = '''I'm
here!'''
While data is typed, variable names have no fixed type. The
artificial sequence
x = 1
x="hello"
is legal. There are no type declaratons. All data in Python
are objects. All assignments implicitly involve pointers,
but there is no notation for pointers. Hence y=x makes y an alias
for x. With mutable objects you get into the same problems with
aliases as in Java. In Python numbers and strings are immutable,
so they have no problems with aliases.
String Concatenation
String concatenation is + as in Java, but Python does not do implict
conversions to string type (str). It must be explicit:
Java:
int x = 3
String s = "The answer is " + x;
Python:
x = 3
s = "The answer is " + str(x)
Assignments
and arithmetic
Assignment and most arithmetic operands are like Java. Python
does not have operators ++ or --. Python does have the **
exponentiation operator of Basic. The value of b ** n is bn.
Unlike Java, there cannot be integer overflow in Python. (This
is very handy when using big numbers for cryptography.) If an
operation creates a number that is too big for normal storage in a
machine word, a multword format is implicily created. In versions 2.X
of Python the display of integer literals indicates their underlying
storage format: An L for Long appended to an integer stored in
multiple words. (In version 3.X, the L is omitted, as an
unnecessary exposure of the implementation.)
In Python 2.X the / operator is even trickier than in Java, since you
cannot tell necessarily by static analysis whether both operands are
int's causing integer arithmetic to be done. You can also
use // which always means the result is integral. (In
Python 3.X the / operator is reinterpreted to always mean floaing point
arithmenic, so there is never any ambiguity.)
The result of 7 // 3 is 2. The result of 7.3 // 3.1 is 2.0.
Python has a tuple type, and assignment in tuples is element by
element, so using tuples, you can do multiple assignements and have
functions return multiple results.
Compare:
Java code to swap values of x and y values:
temp = x
x= y
y = temp
Python swap: Parentheses around the group of comma separated
elements is optional. The entire right-hand side is evaluated
before the assignment is made, as with any assignment.
y, x = x, y
Statement syntax
Line break delimit statements in Python. Semicolons are only used
if you want multiple statements on one line.
A statement automatically continues over multiple lines until
delimiters are matched: (...), [...], or {....}. Often a
naturally long statement without such separated delimiters can have an
extra set of parentheses added, allowing the statement to be split up
readably on several lines. If including matching delimiters does
not make sense, you
can end a line with \
and then the next line is a continuation line. This is best
avoided, if possible, since it is hard to read, and an invisible blank
after the \ means the \ is not at the end of the line, causing a nasty
syntax error. (Program editors that automatically strip trailing
blanks, like idle, avoid this error.)
While blocks in Java are enclosed in braces {...}, blocks in Python
always come after a heading ending in a colon, and are then
consistently indented underneath.
For instance function definitions have a heading and body:
Functions
Java:
/** javadoc comments.... */
public static int square(int x) {
return x*x;
}
Python:
def square(x):
""" Python function documentation
- string indented just inside heading
"""
return x*x
Note, since Python is not staticly typed, ther is no declared return
type (though documentation comments are helpful!). Python
functions always do actually return something. Python has a
special object None, used much like null in Java. If no data is
specified in a return statement, or there is no return statement (like
in a Java void function), Python returns None.
Instance methods are discussed and illustrated in the sample code files for defining classes, listed under Classes.
Function Signature
variations
Like Java, Python allows a sequential substitution of actual parameters
for formal parameters. Python does NOT have overloading of method
names, but it has a very rich variety of other options for function
signatures. The main feature we will use is keyword parameterswith
default values. You will see these in library functions, so it is
good to understand the usage even if you do not write such
functions. Consider the heading of a function definition with
keyword parameters:
def f(x, y, z=0, goSlow=False):
...
The uninitialized parameters are at the far left. Calls to this
function must have a parameter list starting with values for all
the uninitialized parameters.
f(1, 2) # x:1, y:2, z:0, goSlow:False
and may extend, without names, part or all the way sequentially into
the keyword parameters
f(1,2, 3) # x:1, y:2, z:3, goSlow:False
Further actual parameters may be added, with keyword=value, in any
order and with any subset of the parameters that have not already been
given a value:
f(1,2, goSlow=True) # x:1, y:2, z:0,
goSlow:True
f(1,2, goSlow=True, z=3) # x:1, y:2, z:3, goSlow:True
CAUTION: The default
parameter values are evaluated at function definition
time, not at execution time. Do NOT use a mutable initializer
that you intend to modify inside the function unless you WANT the
effect to be remembered on the next function call using the default
parameter (highly
unlikely).
if Statement
Java
if (x > 3) {
x -= 2;
System.out.println(x);
}
y = x;
Python
if x > 3:
x -= 2
print x
y = x
There are no parentheses needed around a condition, but there must be a
colon afterward before the indented block. The indentation that
is good formatting in Java is REQUIRED in Python.
The indentation rule makes an extra keyword useful: elif is like else if in Java.
if x > 0:
print 'positive'
elif x < 0:
print 'negative'
else:
print 'zero'
The elif construct avoids the
the extra levels of indentation that would be needed in Python with
if x > 0:
print 'positive'
else:
if x < 0:
print 'negative'
else:
print 'zero'
while
The syntax changes for while
are like for if.
Java:
int x = 11;
while (x != 0) {
System.out.println(x);
x /= 2;
}
Python:
x = 11
while x != 0:
print x
x /= 2
Boolean result
operators
The comparison operator for numbers are the same as Java. For
built-in types == is like the Java equals method. Python uses is to mean "is the exact same object
at the same address"
if thisAlias is thatAlias:
....
Java's boolean operators &&, ||, ! are replaced in Python by the words: and, or, not. The condition
not (x is y)
is better writen with the operator combination "is not":
x is not y
Outside of a for statement, in
is a boolean operator used for membership in a collection type.
x in
collection
and its negation
x not
in collection
A primary type of collection is discussed next:
Lists
Lists in Python correspond semantically something somewhere between a
Java array and an ArrayList. They can grow, and they can
reference elements like x[i].
Literals and some basic operations can be stated much more neatly than
in Java:
x = [1, 3, 5] # a list
y = [8, 5]
z = x + y # concatenates: [1, 3, 5, 8, 5]
w = y * 3 # repeated concatenation! [8, 5, 8, 5, 8, 5]
y.append(-3) # mutates y to [8, 5, -3], like ArrayList add method.
if 3 in z:
....
The + and * operations also work with strings.
For-Loops
Suppose words is a Java or
Python list containing elements like "yes", "no", "maybe", then
Java:
for (String w: words) {
w = w.toUppercase();
System.out.println(w);
}
Python:
for w in words:
w = w.upper()
print w
Like in Java, this for-loop syntax works for anything with an
iterator. That includes lists, tuples, sets, .... Also in
Python, strings have an iterator that returns one character at a
time.
This iterator syntax is the only option in Python for
statements. Java has another for-loop format, commonly used
to iterate through an arithmetic sequence. This can be
approximated using Python's range
function. The range function can have 1, 2 or 3 paramters:
range(5) returns [0, 1, 2, 3, 4] #
range(n) returns [0, 1, ... n-1]
range(2, 5) returns [2, 3, 4] # range(k, n) returns [k, k+1, ... n-1]
range(2, 9, 3) returns [2, 5, 8] # range(k, n, d) returns [k, k+d,
k+2d, ... stopping BEFORE n]
range(3, 0, -1) returns [3, 2, 1] # smart enough to know what BEFORE n
means with d negative
Java:
for (int i = 2; i < 9; i +=3)
System.out.println(i);
Python:
for i in range(2, 9, 3):
print i
A Java for-loop with any other format, like
for (int i = 1; i < 17; i *= 2)
System.out.println(i);
would need to be converted to a while loop in Python:
i = i
while i < 17:
print i
i *= 2
The statements continue and break work as in Java. Python
has no switch statement or do while.
Sometimes an empty statement is needed. In Java it is a simple
semicolon. In Python it is pass.
A do-nothing function would be:
def placeHolder():
pass
Assert
Java:
assert x !=0 : "May not divide by 0";
Python: The colon becomes a comma
assert x !=0, "May not divide by 0"
The string is optional for both Java and Python. The default for
enabling assert is backwards for Java and Python: By default
Python checks assert statements. Assertions are turned off if
optimization is explicitly requested.
String
Formatting
In both cases fs ends up as "Format with 3 and Hello embedded."
Java:
int x = 3;
String s = "Hello";
String fs = String.format("Format with %s and %s embedded.", x, s);
Python:
x = 3
s = "Hello"
fs = "Format with {0} and {1} embedded.".format(x, s);
In Python 2.7 and 3.1+ you can leave out sequential numbering inside
the braces. Both Java and Python have many fancier options.
Indexing and
slices
Java:
String s= "Compute";
char c = s.charAt(2); // 'm'
String sub1 = s.substring(1, 4); // "omp"
String sub2 = s.substring(3); // "pute"
Python:
s = "Compute"
c = s[2] # "m"
sub1 = s[1:4] # "omp"
sub2 = s[3:] # "pute"
The notation wih the colon between square brackets is called a slice. The same notation works
with other sequences - lists and tuples:
x = [1, 3, 5, 7, 9]
y = x[1:4] # [3, 5, 7]
Java has something like a slice called a view, but in Java the view
mutates as the larger collection changes. Python makes a shallow
copy
when a slice is used in an expression.
The len functon gives the length or size of any collection/sequence
type, corresponding to length or size fields or methods in Java.
len([1, 5]) # 2
len('abc') # 3
Python has a convenient piece of syntactic sugar allowing negative
indices to reference elements. In a sequence s, s[-k] for
positive k
is translated into s[len(s) - k]. In particular, s[-1] is the last
element of the sequence - very handy.
Dictionaries/Mappings
Java:
Map<String, String> map = new
HashMap<String, String>();
map.put("Jose", "773-000-1234");
map.put("Mary", "312-555-9999");
System.out.println(map.get('Jose'));
for (String key : map.keySet()) {
System.out.println(key);
System.out.println(map.get(key));
}
Python:
map = dict() # untyped - does not
require String and String
map['Jose'] = '773-000-1234' # only require immutable key
map['Mary'] = '312-555-9999'
print map['Jose']
for key in map:
print key
print map[key]
As in Java, Python allows the get method to read a dictionary.
There is a difference from the access via square brackets: If 'Andy' were not a key in
map, trying to read
map['Andy']
would cause an exception, while
map.get('Andy')
would return None,
First Class Objects
First class objects can be assigned to variables and passed as
parameters. Java is limited. In Python everything is a
first class object: In particular we will use this feature for
functions and classes. (If you want to look way beyond this
course, you see modules, code blocks, parse trees, tracebacks, ... are
all objects.)
For example, in mod.py the ZMod function defines and returns a new function.
Classes
Class Use
Java:
List stuff = new ArrayList(); //
avoiding generics used in practice
stuff.add("Hello")
if (stuff instanceof List)
System.out.println("right type")
Python:
stuff = list() # no new
stuff.append("Hello") # same dot syntax.
if isinstance(stuff, list): # isinstance(object, class)
print 'right type'
# if more than one type is OK in isinstance, give a tuple of types:
isinstance(stuff, (list, tuple, set))
Class Definition
See comments and samples code in animalW.py.
We will be writing several classes for mathematical objects that define
operators. See mod26A.py, first,
and the more robust and complicated mod26.py.
The generalization is mod.py. Python allows multiple inheritance like C++ and unlike Java.
Static Methods (advanced)
Pure functions, not tied to object instances are generally just
funtions outside a class in Python, whereas they must be static methods
inside a class in Java. If you want a function to be associated
with a class, but not require instances in Python, you can use a
decorator to turn a method into a static method.
Java:
class Foo {
static int count = 0; // one value for whole class
static int incCount() {
count++;
return count;
}
}
Python:
class Foo:
count=0 # one value for whole class
@staticmethod
def incCount(): # no self parameter
Foo.count += 1
return Foo.count
Python requires dot notation with the class name or an instance any
time a static method like incCount or a class variable like count is
used.
Python also has a related, more advanced concept of a class method,
that can be overridden by subclasses. This has no analog in Java.
Documentation
Both the Java and Python libraries have standard documentation,
available standalone or on the Internet, hyperlinked and with
search.... Python has additional interactive features in its
Shell. The dir function, applied to an object or class, displays all the methods and fields associated with that object or class.
dir(list)
That is fine if you just forget the precise name of a method. You
can get more information with the help function, applied to a specific
function or method (without the parentheses, so it refers to the
function object, but does not call it), like
help(list.append)
It can also be applied to a class or module or the string name of a module (though you may get a lot displayed!).
help('doctest')
help(list)
Just in Python
Some features that are not necessary, but handy.
List Comprehensions
In math we can write
{(x, x2) for x in {0, 1, 2, 3, 4}}
meaning
{(0, 0), (1, 1), (2, 4), (3, 9), (4, 16)}
In Python 2.7 and 3.X, you can use the same notation (except using
x**2). In Python 2.6 (and later) you can have the corresponding
notation for lists, by enclosing in square brackets:
[(x, x*x) for x in [0, 1, 2, 3, 4]]
or
[(x, x*x) for x in range(5)]
which generate
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16)]
This is a very handy notation, and way more efficient that the
alternate approach with a for loop doing repeated appends:
result = []
for x in range(5):
result.append((x, x*x))
I will likely expect you to read list comprehensions, as in bases.py, but you can still
write with an explicit for-loop if you do not like the syntax.
Doctests
See the comments in
recursiveTuples2.py for a doctest
introduction. See a serious use of them in mod26A.py. Then
mod26.py has an extra set of doctests at the end illustrating how to
check expected exceptions. This is a great feature of Python for
simple tests. To test clearly and completely, you
can write your own code instead if you prefer.