What is the difference between Python 2 and Python 3?

Python is a versatile programming language that has undergone significant changes over the years. The most notable of these changes occurred with the release of Python 3. While Python 2 was widely used for many years, Python 3 introduced several improvements and changes that have made it the preferred choice for new projects. This article explores the key differences between Python 2 and Python 3, highlighting important changes with code examples.

Major Differences Between Python 2 and Python 3

Print Function

In Python 2, print is a statement, not a function. In Python 3, print became a function, which improves consistency and supports more complex usage.

Python 2:

print "Hello, World!"

Python 3:

print("Hello, World!")

Integer Division

In Python 2, dividing two integers performs integer division by default, which can lead to unexpected results for new programmers. Python 3 performs true division by default.

Python 2:

print 5 / 2  # Output: 2
print 5 // 2  # Output: 2 (floor division)

Python 3:

print(5 / 2)  # Output: 2.5
print(5 // 2)  # Output: 2 (floor division)

Unicode and Strings

Python 3 has a clearer distinction between bytes and strings. In Python 2, strings are ASCII by default and there is a separate unicode type. In Python 3, all strings are Unicode by default, and a new bytes type is introduced for binary data.

Python 2:

# ASCII string
s = "Hello"
# Unicode string
u = u"Hello"
print type(s)  # Output: <type 'str'>
print type(u)  # Output: <type 'unicode'>

Python 3:

# Unicode string
s = "Hello"
# Bytes
b = b"Hello"
print(type(s))  # Output: <class 'str'>
print(type(b))  # Output: <class 'bytes'>

Input Function

In Python 2, input() evaluates the input as Python code, which can be a security risk. raw_input() is used to take string input. In Python 3, input() always returns a string, making it safer and more intuitive.

Python 2:

# input() evaluates the input
num = input("Enter a number: ")  # User inputs '2 + 3', num becomes 5
# raw_input() for string input
name = raw_input("Enter your name: ")  # User inputs 'Alice', name becomes 'Alice'

Python 3:

# input() always returns a string
num = input("Enter a number: ")  # User inputs '2 + 3', num becomes '2 + 3'
# Convert string to integer if needed
num = int(num)

Iterating Over Dictionaries

In Python 2, dict.items(), dict.keys(), and dict.values() return lists. In Python 3, these methods return view objects, which provide a dynamic view on the dictionary’s entries, keys, and values.

Python 2:

d = {'a': 1, 'b': 2}
print d.items()  # Output: [('a', 1), ('b', 2)]
print d.keys()  # Output: ['a', 'b']
print d.values()  # Output: [1, 2]

Python 3:

d = {'a': 1, 'b': 2}
print(d.items())  # Output: dict_items([('a', 1), ('b', 2)])
print(d.keys())  # Output: dict_keys(['a', 'b'])
print(d.values())  # Output: dict_values([1, 2])
# Convert to list if needed
print(list(d.items()))  # Output: [('a', 1), ('b', 2)]

Exception Handling Syntax

Python 3 changed the syntax for catching exceptions, making it more consistent.

Python 2:

try:
    raise ValueError("An error occurred")
except ValueError, e:
    print "Caught an error:", e

Python 3:

try:
    raise ValueError("An error occurred")
except ValueError as e:
    print("Caught an error:", e)

xrange() vs range()

In Python 2, range() returns a list, and xrange() returns an iterator, which is more memory efficient for large ranges. In Python 3, range() behaves like xrange() and returns an immutable sequence type.

Python 2:

for i in range(5):
    print i  # Output: 0 1 2 3 4

for i in xrange(5):
    print i  # Output: 0 1 2 3 4

Python 3:

for i in range(5):
    print(i)  # Output: 0 1 2 3 4

Metaclass Syntax

The syntax for defining metaclasses has changed in Python 3, making it more explicit and readable.

Python 2:

class MyClass(object):
    __metaclass__ = MetaClass

Python 3:

class MyClass(metaclass=MetaClass):
    pass

Handling Binary Data

Python 3 makes a clear distinction between text and binary data. The open() function's mode for binary files requires an explicit b.

Python 2:

with open('file.txt', 'rb') as f:
    content = f.read()

Python 3:

with open('file.txt', 'rb') as f:
    content = f.read()

Here is a table outlining the key differences between Python 2 and Python 3:

Feature	Python 2	Python 3
Print Statement	print "Hello, World!"	print("Hello, World!")
Integer Division	5 / 2 returns 2	5 / 2 returns 2.5
	5 // 2 for integer division	5 // 2 for integer division
Unicode Support	Unicode literals: u"hello"	All strings are Unicode by default
	ASCII literals: "hello"	Byte strings: b"hello"
xrange	xrange() for lazy range	range() replaces xrange()
Exceptions	except Exception, e:	except Exception as e:
Iterators	.next() method	__next__() method
Syntax	No function annotations	Function annotations supported
	print, exec as statements	print(), exec() as functions
Libraries	Many libraries only support 2.x	Libraries support 3.x and later
Division Handling	Integer division with /	True division with /
		Integer division with //
Metaclasses	__metaclass__ attribute	metaclass keyword
Standard Library	Some modules deprecated or changed	Modernized and reorganized
Input Function	raw_input() for strings	input() for strings
	input() for evaluation	raw_input() removed
Relative Imports	Implicit relative imports allowed	Explicit relative imports only
Integer Types	int and long types	Unified int type
Division	1/2 returns 0	1/2 returns 0.5
Order of Dict	Arbitrary order of keys	Insertion order preserved
Syntax Error	Fewer syntax errors for string encodings	More strict with syntax errors
File Handling	file() function	Use open()
Error Handling	raise IOError, "message"	raise IOError("message")
Function Parameter Unpacking	Supported	Removed

These are some of the primary differences, although there are many other nuanced changes between Python 2 and Python 3. Python 3 is the future of the language with continued development and improvements, whereas Python 2 has reached the end of its life and is no longer maintained.

Python FAQ

Conclusion

The transition from Python 2 to Python 3 involved significant changes aimed at improving the language's consistency, readability, and performance. Python 3's enhancements make it a more robust and modern language, which is why it is now the recommended version for all new projects. Understanding these differences is crucial for developers migrating from Python 2 to Python 3 and for those starting new projects in Python.

With Python 2 reaching its end of life on January 1, 2020, it's important for developers to embrace Python 3 to benefit from ongoing improvements and community support.