Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions
Privacy Policy




Chapter 24. Creating or Extending Data Types

When we use an operator, like + or *, what happens depends on the types of the objects involved. When we say c*2, the value depends on the type of c. If c is numeric, then 2 may have to be converted to the same type as c, and the answer will be a number. If, however, c is a sequence, the result is a new sequence.







(8, 0, 8, 0)

The selection of appropriate behavior is accomplished by the relatively simple mechanism of “special method names” within Python. Each class of objects, either built-in or created by a programmer, can provide the required special method names to create the intimate relationship between the class, the built-in functions and the mathematical operators.

If you provide special methods, you can make your class behave like a built-in class. Your class can participate seamlessly with built-in Python functions like str, len, repr. Your class can also participate with the usual mathematical operators like + and *. Additionally, your class could also use the collection operators in a manner similar to a map or list.

The special method names are similar in principle to operator overloading provided in C++. Similar considerations apply: you should make the operator behave in way that parallels the mathematical sense of the symbol.

Additionally, we can extend built-in classes. We do this by extending some of the special methods to do additional or different things.

Semantics of Special Methods

Python has a number of language features that interact with the built-in data types. For example, objects of all built-in types can be converted to strings. You can use the built-in str function to perform these conversions. The str function invokes the __str__ special method of the given object. In effect, str(a) is evaluated as a.__str__().

When you create your own class, however, a built-in function like str or cmp can't easily determine how to perform these functions on your new class. Your class must supply the specially-named method function that the built-in str function can use to successfully convert your classes values to strings.

In the section called “Special Method Names” we introduced a few special method names. We looked at __init__, which is evaluated implicitly when an object is created. We looked at __str__, which is used by the str function and __cmp__, which is evaluated by the cmp function.

A huge number of Python features work through these special method names. When you provide appropriate special methods for your class, it behaves more like a built-in class.

You may be suspicious that the special method name __str__ matches the built-in function str. There is no simple, obvious rule. Many of the built-in functions invoke specially-named methods of the class that are similar. The operators and other special symbols, however, can't have a simple rule for pairing operators with special methods. You'll have to actually read the documentation for built-in functions (Library Reference, section 2.1) and special method names (Language Reference, section 3.3) to understand all of the relationships.

Categories of Special Method Names. The special methods fall into several broad categories. The categories are defined by the kind of behavior your class should exhibit.

Basic Object Behaviors

A number of special method names make your object behave like oher built-in objects. These special methods make your class respond to str, repr, cmp and comparison operators. This also includes methods that allow your object to respond to the hash function, which allows instances of your class to be a key to a mapping.

Numeric Behaviors

These special methods allow your class to respond to the artithmetic operators: +, -, *, /, %, **, <<, >>, and , or and not . When you implement these special methods, your class will behave like the built-in numeric types.

Container Behaviors

If your new class is a container or collection, there are a number of methods required so that your class can behave like the built-in collection types (sequence, set, mapping).

Iterator Behavior

An iterator has a unique protcol. The for statement requires an __iter__ method to locate an iterator for an object. It then requires a next method on the iterator.

Attribute Handling Behavior

Some special methods customize how your class responds to the . operator for manpulating attributes. For example, when you evaluate object.attr. This is commonly used when attribute manipulation is more complex than simply locating an attribute that was defined by __init__.

Function Behavior

You can make your object behave like a function. When you define the method __call__, your object is callable, and can be used as if it was a function.

Statement Interaction

There are a few special methods required by statements. The for statement requires an __iter__ method to locate an iterator for an object. It then requires a next method on the iterator. The with statement requires __enter__ and __exit__ methods.

  Published under the terms of the Open Publication License Design by Interspire