There are a number of special methods that permit close integration between our classes and Python.Standard Library Reference calls thembasic. A better term might befoundational oressential. These special methods form a foundation for building classes that seamlesslyintegrate with other Python features.

For example, weneed string representations of a given object's value. The base class,object, has a default implementation of__repr__() and__str__() that provides string representations of an object. Sadly, these default representations are remarkably uninformative. We'll almost always want to override one or both of these default definitions. We'll also look at__format__(), which is a bit more sophisticated but serves the same purpose.

We'll also look at other conversions, specifically__hash__(),__bool__(), and__bytes__(). These methods will convert an object into a number, a true/false value, or a string of bytes...

Python hastwo string representations of an object. These areclosely aligned with the built-in functionsrepr(),str(),print(), and thestring.format() method.

Let's look at the default implementations first.

The following is a simple class hierarchy...

The__format__() method is used bystring.format() as well as theformat() built-in function. Bothof these interfaces are used to get presentable string versions of a given object.

Thefollowing are the two ways in which arguments will be presented to__format__():

Note that something equivalent to"{0!r}".format() or"{0!s}".format() doesn't use the__format__() method. These use__repr__() or__str__() directly.

With a specification of"", a sensible response isreturn str(self). This provides an obvious consistency between the various string representations...

The built-inhash() function invokes the__hash__() method of a given object. This hash is a calculation which reduces a (potentially complex) value to a small integer value. Ideally, a hash reflects all the bits of the source value. Other hash calculations—often used for cryptographic purposes—can produce very large values.

Python includes two hash libraries. The cryptographic-quality hash functions are inhashlib. Thezlib module has two high-speed hash functions:adler32() andcrc32(). For relatively simple values, we don't use either of these. For large, complex values, these algorithms can be of help.

Thehash() function (and the associated__hash__() method) is used to create a small integer key that is used to work with collections such asset,frozenset, anddict. These collections use the hash value of animmutable object to rapidly locate the object in the collection.

Immutability is important here; we'll mention it many times. Immutable objects don't change...

Python has apleasant definition of falsity. The reference manual lists a large number of values that will test as equivalent toFalse. This includes things such asFalse,0,'',(),[], and{}. Most other objects will test as equivalent toTrue.

Often, we'll want to check for an object being "not empty" with a simple statement as follows:

if some_object:    process( some_object )

Under the hood, this is the job of thebool() built-in function. This function depends on the__bool__() method of a given object.

The default__bool__() method returnsTrue. We can see this with the following code:

>>> x = object()>>> bool(x)True

For most classes, this is perfectly valid. Most objects are not expected to beFalse. For collections, however, this is not appropriate. An empty collection should be equivalent toFalse. A nonempty collection can returnTrue. We might want to add a method like this to ourDeck objects.

If we're wrapping a list, we might have something...

There are relatively few occasions to transform an object into bytes. We'll look at this in detail inPart 2,Persistence and Serialization.

In the mostcommon situation, an application can create a string representation, and the built-in encoding capabilities of the Python IO classes will be used to transform the string into bytes. This works perfectly for almost all situations. The main exception would be when we're defining a new kind of string. In that case, we'd need to define the encoding of that string.

Thebytes() functiondoes a variety of things, depending on the arguments:

Python has sixcomparison operators. These operators havespecial method implementations. According to the documentation, the mapping works as follows:

We'll return to comparison operators again when looking at numbers inChapter 7,Creating Numbers.

There's an additional rule regarding what operators are actually implemented that's relevant here. These rules are based on the idea that the object's class on the left defines the required special method. If it doesn't, Python can try an alternative operation by changing the order.

The__del__() method has a rather obscure use case.

The intent is to give an object a chance to do any cleanup or finalization just before the object is removed from memory. This use case is handled much more cleanly by context manager objects and thewith statement. This is the subject ofChapter 5,Using Callables and Contexts. Creating a context is much more predictable than dealing with__del__() and the Python garbage collection algorithm.

In the case where a Python object has a related OS resource, the__del__() method is a last chance to cleanly disentangle the resource from the Python application. As examples, a Python object that conceals an open file, a mounted device, or perhaps a child subprocess might all benefit from having the resource released as part of__del__() processing.

The__del__() method is not invoked at any easy-to-predict time. It's not always invoked when the object is deleted by adel statement, nor is it always invoked when an object is deleted...

One usecase for the__new__() method is to initialize objects that are otherwise immutable. The__new__() method is where our code can build an uninitialized object. Thisallows processing before the__init__() method is called to set the attribute values of the object.

The__new__() method is used to extend the immutable classes where the__init__() method can't easily be overridden.

The following is a class that does not work. We'll define a version offloat that carries around information on units:

class Float_Fail( float ):    def __init__( self, value, unit ):        super().__init__( value )        self.unit = unit

We're trying (improperly) to initialize an immutable object.

The following is what happens when we try to use this class definition:

>>> s2 = Float_Fail( 6.5, "knots" )Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: float() takes at most 1 argument (2 given)

From this, we see...

The other use case for the__new__() method as a part of a metaclass is to control how a classdefinition is built. This is distinct from how__new__() controls building an immutable object, shown previously.

A metaclass builds a class. Once a class object has been built, the class object is used to build instances. The metaclass of all class definitions istype. Thetype() function is used to create class objects.

Additionally, thetype() function can be used as a function to reveal the class of an object.

The following is a silly example of building a new, nearly useless class directly withtype() as a constructor:

Useless= type("Useless",(),{})

Once we've created this class, we can create objects of thisUseless class. However, they won't do much because they have no methods or attributes.

We can use this newly-mintedUseless class to create objects, for what little it's worth. The following is an example:

>>> Useless()<__main__.Useless object...

We've looked at a number ofbasic special methods, which are essential features of any class that we design. These methods are already part of every class, but the defaults we inherit from the object may not match our processing requirements.

We'll almost always have a need to override__repr__(),__str__(), and__format__(). The default implementations of these methods aren't very helpful at all.

We rarely need to override__bool__() unless we're writing our own collection. That's the subject ofChapter 6,Creating Containers and Collections.

We often need to override the comparison and__hash__() methods. The definitions are suitable for simple immutable objects but not at all appropriate for mutable objects. We may not need to write all the comparison operators; we'll look at the@functools.total_ordering decorator inChapter 8,Decorators and Mixins – Cross-cutting Aspects.

The other twobasic special method names,__new__() and__del__(), are for more specialized purposes. Using...