Objects in Python

• Special methods (dunders)
  • Foundational
  • Iterators
  • Compariable classes
  • Serializable classes
  • Classes with computed attributes
  • Classes that are callable
  • Classes that act like sets
  • Classes that act like dictionaries
  • Classes that act like numbers
  • Classes that can be used in a with block
  • Esoteric behavior
• Design Patterns

As I learn more about Pythons idioms reflect on its unique approach to object based programming. In combination with duck typing its approach to objects feels distrubingly flexible.

Everything in Python is an object.

Special methods (dunders)⌗

Filed under Special Method Names in the docs, defines the special traits a class can implement that are invoked by special syntax, such as arithmetic operations.

Python will raise an exception (AttributeError or TypeError), if a class fails to provide appropriate method/s.

Foundational⌗

Iterators⌗

for x in seq:
    print(x)

Python will call seq.__iter__() to create an iterator, then call the __next__() method on that iterator to get each value of x. When the __next__() method raises a StopIteration exception, the for loop ends gracefully.

Compariable classes⌗

If you define a __lt__() method but no __gt__() method, Python will use the __lt__() method with operands swapped.

However, methods will not be combined. For example, if you define a __lt__() method and a __eq__() method and try to test whether x <= y, Python will not call __lt__()and __eq__() in sequence. It will only call the __le__() method.

Serializable classes⌗

With the pickle module, Python supports serializing and deserializing objects. All of the native datatypes support pickling. If you create a custom class that you want to be able to pickle, checkout the pickle protocol to see when and how the following special methods are called.

To recreate a serialized object, Python first needs to create a new object that looks like the serialized object, and then set the values of all the attributes on the new object. The __getnewargs__() method controls how the object is created, then the __setstate__() method controls how the attribute values are restored.

Classes with computed attributes⌗

Tips:

• If defined __getattribute__() will always be called for every reference to any attribute or method name (except for special dunders)
• __getattr__() on the other hand will only be called only after looking for the attribute in the normal places
• __dir__() is useful if you use either of the __getattr*__() traits, as dir(x) only lists regular attributes and methods, by overriding __dir__() can register dynamic attributes to the list of available attributes.

Classes that are callable⌗

The zipfile module takes this approach to define a class that can decrypt an encrypted zip file with a given password. The zip decryption algorithm requires you to store state during decryption. Defining the decryptor as a class allows you to maintain this state within a single instance of the decryptor class. The state is initialized in the __init__() method and updated as the file is decrypted. But since the class is also callable like a normie function, you can pass the instance as the first argument of the map() function.

Stateful functions if you will.

# excerpt from zipfile.py
class _ZipDecrypter:
    def __init__(self, pwd):
        self.key0 = 305419896
        self.key1 = 591751049
        self.key2 = 878082192
        for p in pwd:
            self._UpdateKeys(p)

    def __call__(self, c):
        assert isinstance(c, int)
        k = self.key2 | 2
        c = c ^ (((k * (k^1)) >> 8) & 255)
        self._UpdateKeys(c)
        return c

# sample usage
zd = _ZipDecrypter(pwd)
bytes = zef_file.read(12)
h = list(map(zd, bytes[0:12]))

Classes that act like sets⌗

If you have a class that is a container for values, it’s may make sense to enquire if it “contains” a certain value and leverage Python’s x in s syntax.

Classes that act like dictionaries⌗

Going beyond just the “in” operator, classes can also act as full blown dictionaries:

Classes that act like numbers⌗

The classical operator overload example, most languages including Python provide syntax for working with numeric types, adding +, subtracting -, modulo %, bitwise XOR ^ and so on.

These overloads handle a huge number of scenarios, but fails to provide comprehensive coverage of all scenarios.

>>> from fractions import Fraction
>>> x = Fraction(1, 3)
>>> 1 / x
Fraction(3, 1)

In the above, the built-in integer has no concept of how to handle a Fraction, that is 1.__truediv__(x)

There is a second set of arithmetic special methods with reflected operands. Given an arithmetic operation that takes two operands (x / y), there are two ways to go about it:

1. Tell x to divide itself by y, or
2. Tell y to divide itself into x

The set of special methods (such as __truediv__(y)) above take the first approach: given x / y, they provide a way for x to say “I know how to divide myself by y”.

The following set of special methods tackle the second approach: they provide a way for y to say “I know how to be the denominator and divide myself into x”.

Python also support numeric syntax for mutating values in-place (e.g. x += y), which depending on your class may need to be handled:

Finally there are several unary operations that number types can perform on themselves:

Classes that can be used in a with block⌗

A with block defines a runtime context; you enter the context when you execute the with statement, and you exit the context after you execute the last statement in the block.

This is exactly how the file idiom works:

# excerpt from io.py:
def _checkClosed(self, msg=None):
    '''Internal: raise an ValueError if file is closed
    '''
    if self.closed:
        raise ValueError('I/O operation on closed file.'
                         if msg is None else msg)

def __enter__(self):
    '''Context management protocol.  Returns self.'''
    self._checkClosed()
    return self

def __exit__(self, *args):
    '''Context management protocol.  Calls close()'''
    self.close()

Context manager tips:

• The file object defines both an __enter__() and an __exit__() method. The __enter__() method checks that the file is open; if it’s not, the _checkClosed() method raises an exception.
• The __enter__() method should almost always return self — this is the object that the with block will use to dispatch properties and methods.
• After the with block, the file object automatically closes. How? In the __exit__() method, it calls self.close().

Esoteric behavior⌗

Design Patterns⌗

https://python-patterns.guide/gang-of-four/composition-over-inheritance/