Python Topics : Class Constructors & the Instantiation Process
Python's Class Constructors & the Instantiation Process
Getting to Know Python's Class Constructors
to construct an object of a given class, you just need to call the class with appropriate arguments 
>>> class SomeClass:
...     pass
...

>>> # Call the class to construct an object
>>> SomeClass()
<__main__.SomeClass object at 0x7fecf442a140>
in the above example calling the class constructor which
  • creates
  • initializes
  • returns a new object
triggers Python's internal instantiation process

Understanding Python's Instantiation Process
instantiation process is triggered when a new instance of a Python class is created
process runs through two separate steps
  • create a new instance of the target class
  • initialize the new instance with an appropriate initial state
Python classes have a special method called .__new__()
method is responsible for creating and returning a new empty object
.__init__() takes the resulting object along with the class constructor's arguments
.__init__() method takes the new object as its first argument, self
sets any required instance attribute to a valid state using the arguments passed to it
a Point class that implements a custom version of both methods 
# point.py

class Point:
    def __new__(cls, *args, **kwargs):
        print("1. Create a new instance of Point.")
        return super().__new__(cls)

    def __init__(self, x, y):
        print("2. Initialize the new instance of Point.")
        self.x = x
        self.y = y

    def __repr__(self) -> str:
        return f"{type(self).__name__}(x={self.x}, y={self.y})"
the .__new__() method takes the class as its first argument
the base object's .__new__() only takes a single argument
using cls as the name of this argument is a strong convention in Python
like using self to name the current instance is
the method also takes *args and **kwargs
allows passing an undefined number of initialization arguments to the underlying instance

a new Point instance by calling the parent class's .__new__() method with cls as an argument
the parent class is object

Object Initialization With .__init__()
Providing Custom Object Initializers
this initialization step is leaves new objects in a valid state 
>>> class Rectangle:
...     def __init__(self, width, height):
...         self.width = width
...         self.height = height
...

>>> rectangle = Rectangle(21, 42)
>>> rectangle.width
21
>>> rectangle.height
42
can run any transformation over the input arguments to properly initialize the instance attributes 
>>> class Rectangle:
...     def __init__(self, width, height):
...         if not (isinstance(width, (int, float)) and width > 0):
...             raise ValueError(f"positive width expected, got {width}")
...         self.width = width
...         if not (isinstance(height, (int, float)) and height > 0):
...             raise ValueError(f"positive height expected, got {height}")
...         self.height = height
...

>>> rectangle = Rectangle(-21, 42)
Traceback (most recent call last):
    ...
ValueError: positive width expected, got -21
inheritance 
>>> class Person:
...     def __init__(self, name, birth_date):
...         self.name = name
...         self.birth_date = birth_date
...

>>> class Employee(Person):
...     def __init__(self, name, birth_date, position):
...         super().__init__(name, birth_date)
...         self.position = position
...

>>> john = Employee("John Doe", "2001-02-07", "Python Developer")

>>> john.name
'John Doe'
>>> john.birth_date
'2001-02-07'
>>> john.position
'Python Developer'
Building Flexible Object Initializers
use optional arguments 
# greet.py

class Greeter:
    def __init__(self, name, formal=False):
        self.name = name
        self.formal = formal

    def greet(self):
        if self.formal:
            print(f"Good morning, {self.name}!")
        else:
            print(f"Hello, {self.name}!")
Object Creation With .__new__()
Providing Custom Object Creators
Typically only need a custom implementation of .__new__() when control is needed over the creation of a new instance at a low level
for a custom implementation of this method should follow a few steps
  1. create a new instance by calling super().__new__() with appropriate arguments
  2. customize the new instance according to your specific needs
  3. return the new instance to continue the instantiation process
class SomeClass:
    def __new__(cls, *args, **kwargs):
        instance = super().__new__(cls)
        # customize instance here...
        return instance
Subclassing Immutable Built-in Types
an immutable built-in data type's is set during creation
too late to change it during initialization
work around this issue by initializing the object at creation time with .__new__() instead of overriding .__init__() 
>>> class Distance(float):
...     def __new__(cls, value, unit):
...         instance = super().__new__(cls, value)
...         instance.unit = unit
...         return instance
...

>>> in_miles = Distance(42.0, "Miles")
>>> in_miles
42.0
>>> in_miles.unit
'Miles'
>>> in_miles + 42.0
84.0

>>> dir(in_miles)
['__abs__', '__add__', ..., 'real', 'unit']>>> class Distance(float):
...     def __new__(cls, value, unit):
...         instance = super().__new__(cls, value)
...         instance.unit = unit
...         return instance
...

>>> in_miles = Distance(42.0, "Miles")
>>> in_miles
42.0
>>> in_miles.unit
'Miles'
>>> in_miles + 42.0
84.0

>>> dir(in_miles)
['__abs__', '__add__', ..., 'real', 'unit']
Returning Instances of a Different Class
returning an object of a different class is a requirement which can raise the need for a custom implementation of .__new__()
Python skips the initialization step entirely
class has the responsibility of taking the newly created object into a valid state before using it 
# pets.py

from random import choice

class Pet:
    def __new__(cls):
        other = choice([Dog, Cat, Python])
        instance = super().__new__(other)
        print(f"I'm a {type(instance).__name__}!")
        return instance

    def __init__(self):
        print("Never runs!")

class Dog:
    def communicate(self):
        print("woof! woof!")

class Cat:
    def communicate(self):
        print("meow! meow!")

class Python:
    def communicate(self):
        print("hiss! hiss!")
.__new__ returns a random instance of a Dog, Cat or Python
can use Pet class as a factory for pet objects 
>>> from pets import Pet

>>> pet = Pet()
I'm a Dog!
>>> pet.communicate()
woof! woof!
>>> isinstance(pet, Pet)
False
>>> isinstance(pet, Dog)
True

>>> another_pet = Pet()
I'm a Python!
>>> another_pet.communicate()
hiss! hiss!
Allowing Only a Single Instance in Your Classes
an example of coding a Singleton class with a .__new__() method
allows the creation of only one instance at a time
.__new__() checks the existence of previous instances cached on a class attribute 
>>> class Singleton(object):
...     _instance = None
...     def __new__(cls, *args, **kwargs):
...         if cls._instance is None:
...             cls._instance = super().__new__(cls)
...         return cls._instance
...

>>> first = Singleton()
>>> second = Singleton()
>>> first is second
True
Partially Emulating collections.namedtuple
the namedtuple() function allows you to create subclasses of tuple with the additional feature of having named fields for accessing the items in the tuple 
# named_tuple.py

'''
                imports itemgetter() from the operator module
 function allows retrieving items using their index in the containing sequence
'''
    from operator import itemgetter

'''
 first arg is the derived call type's name
 number of field names
'''
    def named_tuple_factory(type_name, *fields):
# defines a local variable to hold the number of named fields provided
    num_fields = len(fields)
                # defines a nested class called NamedTuple, which inherits from the built-in tuple class
    class NamedTuple(tuple):
'''
 .__slots__ is a class attribute
  attribute defines a tuple for holding instance attributes
  tuple saves memory by acting as a substitute for the instance's dictionary, .__dict__, 
  which would otherwise play a similar role
'''
        __slots__ = ()
# create the object
        def __new__(cls, *args):
# validate the argument        
            if len(args) != num_fields:
                raise TypeError(
                    f"{type_name} expected exactly {num_fields} arguments,"
                    f" got {len(args)}"
                )
# instantiate the object                
            cls.__name__ = type_name
            for index, field in enumerate(fields):
                setattr(cls, field, property(itemgetter(index)))
            return super().__new__(cls, args)

        def __repr__(self):
            return f"""{type_name}({", ".join(repr(arg) for arg in self)})"""

    return NamedTuple
from the terminal 
>>> from named_tuple import named_tuple_factory

>>> Point = named_tuple_factory("Point", "x", "y")

>>> point = Point(21, 42)
>>> point
Point(21, 42)
>>> point.x
21
>>> point.y
42
>>> point[0]
21
>>> point[1]
42

>>> point.x = 84
Traceback (most recent call last):
    ...
AttributeError: can't set attribute

>>> dir(point)
['__add__', '__class__', ..., 'count', 'index', 'x', 'y']
index