In the olden days of yore, print was a statement. With version 3.1, it has reached the major leagues and is now a bonafide function — specifically, print().

The following no longer return lists, but instead return views and iterators:

The long data type has been renamed to int (basically the only integral type is now int). It works in roughly the same manner as the long type did. Integers no longer have a limit, and as such, sys.maxint has been deprecated. In addition, when dividing numbers such as 2/4, you will be given a float. If you want to have the results truncated, you can still use 2//4.

Unicode and 8-bit strings have been replaced with text and binary data. All text is considered to be Unicode, but the encoded Unicode is now presented as strictly binary data. Hence, text is stored in str, whereas data is stored in bytes. If you should ever try to mix these two data types, it will result in the raising of a TypeError. If you want to mix str and bytes, you must convert them. If you wanted to, for instance, convert a byte to a str, you would use bytes.decode(). To go from a str to a byte, you would likewise use str.encode().

Another change is how you work with literals. The use of u"..." literals for Unicode text has been removed entirely, while the use of b"..." literals for binary data is still usable.

There are many changes to Unicode and 8-bit — far more than I could cover here. See the section on Unicode and 8-bit at the What's New page here: http://docs.python.org/dev/py3k/whatsnew/3.1.html.

The use of raise exception has been replaced. You no longer write it as raise Exception, "I take exception to that!" Instead you would use the following:

exception("I take exception to that!")

Similarly, if you wish to catch an exception, you write it in the following manner:

try:
a=int("hotdog")
except ValueError as oops:
print("ValueError has occurred ", oops)

This would return the result:

ValueError has occurred  invalid literal for int() with base 10: 'hotdog'

Other changes to exceptions exist as well. For instance, all exception objects use the __traceback__ attribute to store the value of the traceback. Additionally, the StandardError was removed.

Old-style classes have been removed entirely from Python 3.1. This leaves us with a simple, single object model based on new-style classes. Definitions for these classes are similar to their previous versions, however, object is now implicitly a superclass.

There are several changes that have been made to the way comparison operators work in Python 3.1. For starters, comparisons have to make logical sense now. For example, you cannot use 0>none. In past versions this would have returned False, but since you cannot compare zero to nothing, it now returns an error.

The function cmp() and the method __cmp__() have both been removed.

As for Operators, they have experienced the following changes:

There are many syntax changes in Python 3.1. Again, this list is too much to cover in the limited space we have here, but the following changes are some of the more important ones.

The keywords as, with, True, False, and None have become reserved words.

When working with Metaclasses, it is important to note that the old method

Class Example:
    __metaclass__ = Apple
...

is no longer valid. Instead you would write:

Class Example(metaclass=Apple):
...

In addition, the module-global __metaclass__ variable has been removed.

The old method for writing list comprehensions was to use:

[for var in example1, example2, example 3]

This has now changed to:

[for var in (example1, example2, example3)]

The old standby <> has been removed and replaced with !=.

Both string literals and integer literals have been changed. String literals no longer accept the leading u and U, while integer literals no longer accept the leading l or L.

The keyword exec() has been removed, though it still functions as a function.

The following modules have been removed from Python 3.1. Note that this is not a complete list:

In addition, the following modules have been renamed:

To make things simpler, Python 3.1 has also gathered some similar modules and grouped them into a single package. They are listed below:

The following builtins were removed:

In addition, raw_input() has been changed to input().

While not an end all be all to converting your Python 2x code to 3x, the 2to3 tool can certainly help in many areas. Basically, what the program does is take your existing code and apply a set of fixers to it, transforming old code into new. For instance, if you were to run 2to3 on the following code:

print "Hi, my name is James and I am a Pythonaholic"

It would convert it to:
print("Hi, my name is James and I am a Pythonaholic")

Pretty nifty right? There are, of course, many caveats for using the tool. First and foremost, the code you run it against must work properly, so you will want to rigorously test your Python 2x code to ensure there are no errors. Next, you must note that 2to3 will not fix everything; there are some things it has not been programmed to convert. For these things, 2to3 will print a warning, which you will need to manually change.

For more information on using 2to3 and documentation on its fixers, visit the Python documentation at http://docs.python.org/dev/py3k/library/2to3.html#to3-reference.