What's new in Python 3

Backports

Python 2.6's whole purpose in life is to make the move to version 3 as easy as possible, so many Python 3.0 features were backported to Python 2.6.

Resource management using with is an important new feature in Python 2.6. A resource (file, socket, mutex, …) is automatically bound when entering and released when exiting the with block. This idiom will remind C++ programmers of "Resource Acquisition Is Initialization" (RAII), wherein a resource is bound to an object. The with statement acts like try … finally from the user's point of view, in that both the try block and the finally block are always executed. All of this happens without explicit exception handling.

How does all of this work? In a with block, you can use any object provided by the context management protocol – that is, which has internal __enter()__ and __exit()__ methods. When entering the with block, the __enter()__ method is automatically called, as is __exit()__ when exiting the block.

The file object comes complete with these methods (Listing 2). Resource management is easy to code, however. A classic application would be to protect a code block against simultaneous access. Listing 3 has placeholders for the code block. The locked class objects prevent competitive access in the with block by using myLock to synchronize the block.

Listing 2

With Block with File

01 with open('/etc/passwd', 'r') as file:
02     for line in file:
03        print line,
04 # file is closed

Listing 3

Protecting a Code Block

01 with locked(myLock):
02             # Code here executes with myLock held.  The lock is
03             # guaranteed to be released when the block is left
04 class locked:
05     def __init__(self, lock):
06         self.lock = lock
07     def __enter__(self):
08         self.lock.acquire()
09     def __exit__(self, type, value, tb):
10         self.lock.release()

If this is too much work for you, you can use the contextmanager decorator from the new contextlib [2] library to benefit from its resource management functionality. Many other applications are listed in the Python Enhancement Proposal (PEP) 0343 [3].

Abstractions

The biggest syntactic extension to Python 2.6 is probably the introduction of abstract base classes. Whether an object could be used in a context previously depended on the object's properties and not on its formal interface specification. This idiom is known as duck typing, from a James Whitcomb Riley poem ("When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.").

If a class contains an abstract method, it becomes an abstract base class and cannot be instantiated. Derivative classes can only be created if they implement these abstract methods. Abstract base classes in Python act in a similar way to abstract base classes in C++, in that abstract methods are specifically allowed to contain an implementation.

Besides abstract methods, Python also uses abstract properties. Python uses abstract base classes in the numbers [4] and collections [5] modules. That still leaves the question: When does a class become an abstract class? The class needs the ABCMeta metaclass. The methods can then be declared as @abstractmethod, and the properties as @abstactproperty using the corresponding decorators. In addition to this, the use of abstract base classes means the entry of static typing into a language that uses dynamic typing. In the example in Figure 2, the Cygnus class cannot be instantiated because it does not implement the abstract quack() method.

Figure 2: Failure to instantiate.

Multiple Processors

Python's response to multi-processor architectures is the new multiprocessing [6] library. This module imitates the well-known Python threading module, but instead of a thread, it creates a process, and it does this independently of the platform. The multiprocessing module became necessary because CPython, the standard Python implementation, could only run one thread in its interpreter. This behavior is dictated by the Global Interpreter Lock (GIL) [7].

Class decorators [8] round out the list in Python; from now on, you can decorate classes as well as functions.

Python 3.0 also has a new I/O library [9]. The string data type gained a new format() [10] method for improved string formatting. At the same time, the previous format operator, %, is deprecated in Python 3.1.

Buy this article as PDF

Express-Checkout as PDF
Price $2.95
(incl. VAT)

Buy Linux Magazine

SINGLE ISSUES
 
SUBSCRIPTIONS
 
TABLET & SMARTPHONE APPS
Get it on Google Play

US / Canada

Get it on Google Play

UK / Australia

Related content

  • Optimizing Python

    The trick to optimization is to save time in the right places.

  • Boo

    Hooked on Python's "wrist-friendly" syntax? Enamored of .NET architecture but equally appreciative of C#'s strong typing? Boo offers the best of three worlds.

  • Dotnet Scripting with Boo

    Boo is a scripting language tailor-made for Mono and .NET. This haunting mixture of Python and C# may be just what you need to get started with the .NET framework.

  • Workspace: EasyGUI

    If you need to add graphical elements to Python script, EasyGUI can help beginners and experts alike.

  • Practical Python in Linux

    We’ll introduce you to Python, an easy-to-learn scripting language, and also help you get started creating your own practical Python scripts.

comments powered by Disqus

Direct Download

Read full article as PDF:

042-045_python.pdf (408.84 kB)

News

njobs Europe
What:
Where:
Country:
Njobs Netherlands Njobs Deutschland Njobs United Kingdom Njobs Italia Njobs France Njobs Espana Njobs Poland
Njobs Austria Njobs Denmark Njobs Belgium Njobs Czech Republic Njobs Mexico Njobs India Njobs Colombia