tel: +48 728 438 076
email: piotr.hyzy@eviden.com

Początek¶

Kilka zasad¶

1. W razie problemów => chat, potem SMS i telefon, NIE mail
2. Materiały szkoleniowe
3. Wszystkie pytania są ok
4. Reguła Vegas
5. Słuchawki
6. Kamerki
7. Chat
8. Zgłaszamy wyjścia na początku danego dnia, także pożary, wszystko na chacie
9. By default mute podczas wykład
10. Przerwy (praca 08:30 - 16:30)
    • blok 08:30 - 10:00
    • kawowa 10:00 - 10:15 (15')
    • blok 10:15 - 11:45
    • kawowa 11:45 - 12:00
    • blok 12:00 - 13:30
    • obiad 13:30 - 14:00
    • blok 14:00 - 15:15
    • kawowa 15:15 - 15:30
    • blok 15:30 - 16:30
11. wszystkie czasy są plus/minus 10'
12. Jak zadawać pytanie? 1) przerwanie 2) pytanie na chacie 3) podniesienie wirtualnej ręki
13. IDE => dowolne
14. Każde ćwiczenie w osobnym pliku/Notebooku
15. Nie zapraszamy innych osób
16. Zaczynamy punktualnie
17. Ćwiczenia w dwójkach, rotacje, ask for help

Rundka - sprawdzenie mikrofonów¶

Advanced OOP¶

Class & Object Attributes¶

Example 1 (Primitives)¶

from typing import Any

class Person:
    phone = None

    def __init__(self, name: str) -> None:
        self.name = name

        self.name

    def foo(self):
        return int(5)

p1 = Person('John')
p2 = Person('Alice')

p1.phone = 98765
print('p2.phone =', p2.phone)
print('p1.phone =', p1.phone)

print('p1.__dict__ =', p1.__dict__)
print('p2.__dict__ =', p2.__dict__)

print('Person.__dict__ =', Person.__dict__)

p2.phone = None
p1.phone = 98765
p1.__dict__ = {'name': 'John', 'phone': 98765}
p2.__dict__ = {'name': 'Alice'}
Person.__dict__ = {'__module__': '__main__', 'phone': None, '__init__': <function Person.__init__ at 0x1044e6de0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

Example 2 (List)¶

class Person:
    phones = []

    db = dict()

    def __init__(self, name):
        self.name = name

p1 = Person('Jan')
p2 = Person('Anna')

p1.phones.append(98765)

print('p1.phones =', p1.phones)
print('p2.phones =', p2.phones)


print('p1.__dict__ =', p1.__dict__)
print('p2.__dict__ =', p2.__dict__)
print('Person.__dict__ =', Person.__dict__)

p1.phones = [98765, 98765]
p2.phones = [98765, 98765]
p1.__dict__ = {'name': 'Jan'}
p2.__dict__ = {'name': 'Anna'}
Person.__dict__ = {'__module__': '__main__', 'phones': [98765, 98765], '__init__': <function Person.__init__ at 0x10aae9440>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

Example 3 (Replace List)¶

class Person:
    phones = []

    def __init__(self, name):
        self.name = name

p1 = Person('Jan')
p2 = Person('Anna')
p1.phones = [98765]
print('p2.phones =', p2.phones)
print('p1.phones =', p1.phones)
print('p1.__dict__ =', p1.__dict__)
print('p2.__dict__ =', p2.__dict__)
print('Person.__dict__ =', Person.__dict__)

p2.phones = []
p1.phones = [98765]
p1.__dict__ = {'name': 'Jan', 'phones': [98765]}
p2.__dict__ = {'name': 'Anna'}
Person.__dict__ = {'__module__': '__main__', 'phones': [], '__init__': <function Person.__init__ at 0x10aae9580>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

@staticmethod Decorator¶

The @staticmethod decorator in Python is used to define a method that belongs to a class but does not require access to the instance (self) or class (cls) itself. This means that a static method can be called on the class or instance, but it cannot modify the instance or class state.

• No self or cls argument: A static method does not take self (instance reference) or cls (class reference) as the first parameter.
• Called on class or instance: You can call a static method using either the class or an instance of the class.

Static methods are useful when you need a method that logically belongs to a class but does not need to modify or access class-specific data.

class Person:

    phone = None

    def __init__(self, name):
        self.name = name

    def foo(self):
        print(self.__dict__)

    @classmethod
    def boo(cls):
        print(cls.__dict__)

p1 = Person('John')
p1.phone=123


p1.foo()
p1.boo()

{'name': 'John', 'phone': 123}
{'__module__': '__main__', 'phone': None, '__init__': <function Person.__init__ at 0x10ab5d4e0>, 'foo': <function Person.foo at 0x10ab5d940>, 'boo': <classmethod(<function Person.boo at 0x10ab5da80>)>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

class MyClass:
    @staticmethod
    def foo():
        print('metoda statyczna')

a = MyClass()
a.foo()
MyClass.foo()

metoda statyczna
metoda statyczna

class MyClass:
    @staticmethod
    def greet(name):
        return f"Hello, {name}!"

# Calling on the class
print(MyClass.greet("Alice"))  # Outputs: Hello, Alice!

Hello, Alice!

# Calling on an instance
obj = MyClass()
print(obj.greet("Bob"))  # Outputs: Hello, Bob!

Hello, Bob!

Exercise: Implement Point.get_distance¶

Create a class Point that represents a point in a 2D space with x and y coordinates. Implement a static method get_distance that takes two Point objects and calculates the Euclidean distance between them.

Example:

p1 = Point(0, 0)
p2 = Point(3, 4)
print(Point.get_distance(p1, p2))  # Outputs: 5.0

The formula for Euclidean distance is:

#### Solution 1
from math import sqrt

class Point:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

    @staticmethod
    def get_distance(a: 'Point', b: 'Point'):
        return sqrt((a.x-b.x)**2 + (a.y-b.y)**2)

p1 = Point(0, 0)
p2 = Point(3, 4)
print(Point.get_distance(p1, p2))  # Outputs: 5.0

5.0

### Solution 2

from dataclasses import dataclass  # pip install dataclasses on Python 3.6 or ealier
from math import sqrt

@dataclass
class Point:
    x: float
    y: float

    @staticmethod
    def get_distance(a, b):
        return sqrt((a.x-b.x)**2 + (a.y-b.y)**2)


p1 = Point(0, 0)
p2 = Point(3, 4)
print(Point.get_distance(p1, p2))  # Outputs: 5.0

5.0

### Solution 3

from pydantic import BaseModel  # pip install dataclasses on Python 3.6 or ealier
from math import sqrt

class Point(BaseModel):
    x: float
    y: float

    @staticmethod
    def get_distance(a, b):
        return sqrt((a.x-b.x)**2 + (a.y-b.y)**2)


p1 = Point(x=5, y=7)
p2 = Point(x=1, y=4)
print(Point.get_distance(p1, p2))  # Outputs: 5.0

5.0

Special Methods¶

class Foo:
    def __init__(self):
        print('Constructor')

    def __str__(self):
        return 'Foo'

    def __len__(self):
        return 5

    def __getitem__(self, key):
        if key >= 5:
            raise IndexError
        return key + 2

f = Foo()

g = Foo()

print(f)

print(len(f))
print(len(g))

print(f[2])
print(f[6])

Constructor
Constructor
Foo
5
5
4

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[60], line 11
      8 print(len(g))
     10 print(f[2])
---> 11 print(f[6])

Cell In[58], line 13, in Foo.__getitem__(self, key)
     11 def __getitem__(self, key):
     12     if key >= 5:
---> 13         raise IndexError
     14     return key + 2

IndexError: 

1. __init__(self):

   • Called when an instance of the class is created. It's the constructor method.
   • Example: f = Foo() will call __init__ and print 'Constructor'.

2. __str__(self):

   • Called by str() or print() to provide a readable, string representation of an object.
   • Example: print(str(f)) will print 'Foo!!!'.

3. __len__(self):

   • Called by len() to return the length of an object.
   • Example: len(f) will return 5.

4. __getitem__(self, key):

   • Called when accessing elements using square brackets (e.g., f[key]).
   • Example: f[3] will return 5 because the method adds 2 to the key. If the key is 5 or greater, it raises an IndexError.

getattr¶

The __getattr__ method in Python is invoked as a "last resort" when an attribute is not found in an instance or class namespace. If you try to access an attribute that doesn't exist, Python will first look in the instance's __dict__, then the class's __dict__, and if the attribute is still not found, it will call the __getattr__ method (if it is defined).

class Bar:
    class_attr = "This is a class attribute"

    def __init__(self):
        self.instance_attr = 42  # This is an instance attribute

    def __getattr__(self, name):
        # This is only called if the attribute isn't found in the instance or class
        return f"'{name}' attribute not found, returning from __getattr__"

# Creating an instance
b = Bar()

# Accessing instance attribute
print(b.instance_attr)

42

# accesing instance method
print(b.__init__)

<bound method Bar.__init__ of <__main__.Bar object at 0x104797800>>

# Accessing class attribute
print(b.class_attr)

This is a class attribute

# Accessing a non-existent attribute
print(b.non_existent_attr)  # Outputs "'non_existent_attr' attribute not found, returning from __getattr__"

'non_existent_attr' attribute not found, returning from __getattr__

Breakdown of the attribute search:¶

1. obj.instance_attr: Found in the instance, so it returns the value 42.
2. obj.class_attr: Not found in the instance, but found in the class, so it returns "This is a class attribute".
3. obj.non_existent_attr: Not found in either the instance or the class, so Python calls __getattr__, which returns the custom message.

This demonstrates how Python looks for an attribute first in the instance, then in the class, and finally resorts to __getattr__ if it isn't found.

setattr¶

The __setattr__ method is another special method in Python that is called every time an attribute is set on an object. Unlike __getattr__ or __getattribute__, which deal with retrieving attributes, __setattr__ is triggered whenever you attempt to assign a value to an attribute, whether the attribute exists or not.

Here's an example demonstrating how __setattr__ works:

class MyClass:
    def __init__(self):
        # Setting an instance attribute in the normal way
        # Since __setattr__ is used for any assignment, even in __init__ it is called
        self.instance_attr = 42

    def __setattr__(self, name, value):
        # This will be called for every attribute assignment
        print(f"__setattr__ called for setting '{name}' to {value}")
        # Using the default behavior by calling the parent class's __setattr__
        super().__setattr__(name, value)

# Creating an instance of MyClass
obj = MyClass()

__setattr__ called for setting 'instance_attr' to 42

# Setting an existing attribute
obj.instance_attr = 100  # This will trigger __setattr__

__setattr__ called for setting 'instance_attr' to 100

# Setting a new attribute
obj.new_attr = "Hello"  # This will also trigger __setattr__

__setattr__ called for setting 'new_attr' to Hello

Example with Custom Logic in setattr¶

You can customize the behavior of setattr to implement checks, logging, or other special behaviors when setting attributes:

class MyClass:
    def __init__(self):
        self.instance_attr = 42

    def __setattr__(self, name, value):
        if name == "instance_attr" and value < 0:
            raise ValueError(f"Cannot set '{name}' to a negative value!")
        print(f"Setting attribute '{name}' to {value}")
        super().__setattr__(name, value)

# Creating an instance of MyClass
obj = MyClass()

# Setting an attribute with a valid value
obj.instance_attr = 100  # Outputs: Setting attribute 'instance_attr' to 100

Setting attribute 'instance_attr' to 42
Setting attribute 'instance_attr' to 100

# Attempting to set a negative value (triggers a custom check)
try:
    obj.instance_attr = -1  # This will raise a ValueError
except ValueError as e:
    print(e)

Cannot set 'instance_attr' to a negative value!

Conclusion:¶

• __setattr__ is triggered for every attribute assignment.
• You can customize __setattr__ to handle specific logic, such as validation or logging, when setting attributes.
• Always use super().__setattr__ to perform the actual assignment inside the method to avoid infinite recursion.

Exercise: Implement the Record Class¶

Your task is to implement a class Record that allows access to its internal data through both attribute-style access (using . notation) and dictionary-style access (using [] notation).

Requirements:¶

1. Attribute Access:

   • You should be able to access data using attribute-style syntax, e.g., obj.key.
   • You should be able to assign values using the same attribute-style syntax, e.g., obj.key = value.

2. Dictionary Access:

   • You should be able to access data using dictionary-style syntax, e.g., obj['key'].
   • You should be able to assign values using dictionary-style syntax, e.g., obj['key'] = value.

3. Data Storage:

   • The class should store all data internally in a way that supports both attribute and dictionary-style access seamlessly.

4. Ensure:

   • Both attribute-style and dictionary-style access refer to the same underlying data.
   • Attribute access for internal mechanisms (like the storage of data itself) should not cause recursive behavior.

Example Usage:¶

r = Record()

# Dictionary-style access
r['name'] = "Alice"
print(r['name'])  # Outputs: Alice

# Attribute-style access
r.age = 30
print(r.age)  # Outputs: 30

# Both access styles should refer to the same underlying data
print(r['age'])  # Outputs: 30
r['city'] = "New York"
print(r.city)  # Outputs: New York

Solution¶

### Solution 1a (With Custom _data Dictionary):

class Record:
    def __init__(self):
        self._data = {}

    def __getattr__(self, attr):
        return self._data[attr]

    def __setattr__(self, attr, value):
        if attr == '_data':
            super().__setattr__(attr, value)
        else:
            self._data[attr] = value

    def __getitem__(self, item):
        return self._data[item]

    def __setitem__(self, item, value):
        self._data[item] = value



r = Record()

# Dictionary-style access
r['name'] = "Alice"
print(r['name'])  # Outputs: Alice

# Attribute-style access
r.age = 30
print(r.age)  # Outputs: 30

# Both access styles should refer to the same underlying data
print(r['age'])  # Outputs: 30
r['city'] = "New York"
print(r.city)  # Outputs: New York

Alice
30
30
New York

# Solution 1b (With Cleaner Initialization):
class Record:
    def __init__(self):
        super().__setattr__('_data', {})  # Directly setting _data during initialization

    def __getattr__(self, attr):
        return self._data[attr]

    def __setattr__(self, attr, value):
        self._data[attr] = value

    def __getitem__(self, item):
        return self._data[item]

    def __setitem__(self, item, value):
        self._data[item] = value


r = Record()

# Dictionary-style access
r['name'] = "Alice"
print(r['name'])  # Outputs: Alice

# Attribute-style access
r.age = 30
print(r.age)  # Outputs: 30

# Both access styles should refer to the same underlying data
print(r['age'])  # Outputs: 30
r['city'] = "New York"
print(r.city)  # Outputs: New York

Alice
30
30
New York

# Solution 2 (Preferred - Inheriting from dict):
class Record(dict):
    def __getattr__(self, attr):
        return self[attr]

    def __setattr__(self, attr, value):
        self[attr] = value


r = Record()

# Dictionary-style access
r['name'] = "Alice"
print(r['name'])  # Outputs: Alice

# Attribute-style access
r.age = 30
print(r.age)  # Outputs: 30

# Both access styles should refer to the same underlying data
print(r['age'])  # Outputs: 30
r['city'] = "New York"
print(r.city)  # Outputs: New York

Alice
30
30
New York

### Solution 3  (Pseudo dict):

class Record:
    def __getitem__(self, item):
        return self.__dict__[item]

    def __setitem__(self, item, value):
        self.__dict__[item] = value

r = Record()

# Dictionary-style access
r['name'] = "Alice"
print(r['name'])  # Outputs: Alice

# Attribute-style access
r.age = 30
print(r.age)  # Outputs: 30

# Both access styles should refer to the same underlying data
print(r['age'])  # Outputs: 30
r['city'] = "New York"
print(r.city)  # Outputs: New York

Alice
30
30
New York

getattribute¶

The __getattribute__ method in Python is similar to __getattr__ in that it deals with attribute access, but it has an important difference:

• __getattribute__ is called immediately whenever any attribute is accessed, regardless of whether it exists or not. It is the first method that Python checks when an attribute is accessed.
• __getattr__, on the other hand, is only called after Python fails to find the attribute through normal means (i.e., it isn't found in the instance or class namespace).

Here's an example using __getattribute__:

class Foo:
    class_attr = "This is a class attribute"

    def __init__(self):
        self.instance_attr = 42

    def __getattribute__(self, name):
        # This will be called for every attribute access, including existing ones
        print(f"__getattribute__ called for: {name}")
        return super().__getattribute__(name)  # Default behavior to avoid infinite recursion

# Creating an instance of Foo
f = Foo()

# Accessing instance attribute
print(f.instance_attr)  # This will trigger __getattribute__ before returning 42

__getattribute__ called for: instance_attr
42

print(f.class_attr)

__getattribute__ called for: class_attr
This is a class attribute

print(f.non_existent_attr)  # This triggers __getattribute__ and then raises AttributeError

__getattribute__ called for: non_existent_attr

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[86], line 1
----> 1 print(f.non_existent_attr)  # This triggers __getattribute__ and then raises AttributeError

Cell In[81], line 9, in Foo.__getattribute__(self, name)
      7 def __getattribute__(self, name):
      8     print(f"__getattribute__ called for: {name}")
----> 9     return super().__getattribute__(name)

AttributeError: 'Foo' object has no attribute 'non_existent_attr'

Key points:¶

• __getattribute__ is always called first, even if the attribute exists in the instance or class. You can think of it as the "first-glance" method for attribute access.
• If you override __getattribute__, you need to be cautious and make sure to call the base class’s __getattribute__ method (via super()) to avoid infinite recursion.
• It gives you fine-grained control over attribute access but can be tricky to use if not handled properly.

In contrast, __getattr__ is only called as a fallback when an attribute cannot be found.

Callable Classes¶

In Python, callable classes are classes that behave like functions, meaning you can "call" an instance of the class as if it were a function. This is done by defining the __call__ method in the class.

__call__ Method:¶

• The __call__ method allows an instance of a class to be called like a regular function.
• When you write obj(), Python internally calls obj.__call__().

class MyCallableClass:
    def __init__(self, *args, **kwargs):
        print(f"Init: Called with arguments: {args} and keyword arguments: {kwargs}")

    def __call__(self, *args, **kwargs):
        print(f"Call: Called with arguments: {args} and keyword arguments: {kwargs}")

# Creating an instance
obj = MyCallableClass('a', 'b', x=4)

Init: Called with arguments: ('a', 'b') and keyword arguments: {'x': 4}

# Calling the instance as if it were a function
obj(1, 2, 3, name="Alice")

Call: Called with arguments: (1, 2, 3) and keyword arguments: {'name': 'Alice'}

Decorator Definition¶

import functools

def shouter(func):
    print('wywolanie dekorowania funkcji')
    @functools.wraps(func)  # takes care of func.__doc__ and func.__name__
    def wrapper(*args, **kwargs):
        print('Before foo')
        result = func(*args, **kwargs)
        print('After foo')
        return result
    return wrapper

class Shouter:
    def __init__(self, func):
        print('Shouter.__init__')
        self.func = func

    def __call__(self, *args, **kwargs):

@shouter # => shouter(foo) => wrapper
def foo(a):
    '''Docstring'''
    print("Message:", a)
    return 42

@Shouter # => Shouter(foo) => self = Shouter(foo)
def foo(a):
    '''Docstring'''
    print("Message:", a)
    return 42

wywolanie dekorowania funkcji
Shouter.__init__

result = foo(a="Inside")  # delegates to wrapper()

Before foo
Message: Inside
After foo

### Supress exc eptionw ith use classic function decorator
def suppress_exceptions(func):
    @functools.wraps(func)  # takes care of func.__doc__ and func.__name__
    # wrapper definition starts
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception:
            return None
    # wrapper definiton ends
    return wrapper

Exercise: Implement SuppressExceptions Class¶

Your task is to implement a class SuppressExceptions that can be used as a decorator to wrap any function or method. The purpose of this decorator is to suppress all exceptions that may occur during the execution of the wrapped function and return None in case an exception occurs. If no exception is raised, the function should behave normally and return its result.

Requirements:¶

1. Class Structure:

   • Implement a class SuppressExceptions with an __init__ and __call__ method.
   • The __init__ method should accept the function to be decorated.
   • The __call__ method should execute the function with the provided arguments, suppress any exceptions, and return None if an exception is raised.

2. Functionality:

   • The class should allow the decorated function to be called with any number of positional (*args) and keyword arguments (**kwargs).
   • If an exception occurs while calling the decorated function, it should catch the exception and return None without raising the exception.

3. Exception Handling:

   • Suppress all types of exceptions, not just specific ones.

4. Expected Behavior:

   • When applied as a decorator to a function, it should print the args and kwargs passed to the function, execute the function, and handle exceptions accordingly.

Example Usage:¶

@SuppressExceptions
def foo(a, b):
    return a / b

# Testing the decorated function
print(foo(4, 2))  # Outputs: 2.0
print(foo(4, 0))  # Outputs: None (due to ZeroDivisionError)
print(foo(4, b=0))  # Outputs: None (due to ZeroDivisionError)

Hints:¶

• Use a try-except block inside the __call__ method to catch any exceptions and return None.
• Ensure the function arguments (*args and **kwargs) are passed correctly to the decorated function.

### Supress exc eptionw ith use classic function decorator
def suppress_exceptions(func):
    @functools.wraps(func)  # takes care of func.__doc__ and func.__name__
    # wrapper definition starts
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception:
            return None
    # wrapper definiton ends
    return wrapper

class SuppressExceptions:
    def __init__(self, func):
        functools.wraps(func)(self)
        self.func = func

    def __call__(self, *args, **kwargs):
        try:
            # print('args =', args)
            # print('kwargs =', kwargs)
            return self.func(*args, **kwargs)
        except Exception:
            return None

@SuppressExceptions # foo = SupressException(foo)
def foo(a, b):
    '''
    doc string
    '''
    return a / b

# Testing the decorated function
print(foo(4, 2))  # Outputs: 2.0
print(foo(4, 0))  # Outputs: None (due to ZeroDivisionError)
print(foo(4, b=0))  # Outputs: None (due to ZeroDivisionError)

print(foo.__doc__)

2.0
None
None

    doc string
    

Exercise: Implement SuppressExceptionsEx Class¶

Your task is to implement a class-based parameterized decorator named SuppressExceptionsEx that allows you to:

1. Specify the type of exception you want to catch (defaults to catching all exceptions).
2. Specify the return value in case the specified exception occurs (defaults to None if not specified).

The decorator should be able to wrap any function, suppress the specified exception, and return the specified value when that exception is raised.

Requirements:¶

1. Class Structure:

   • Implement a class SuppressExceptionsEx that accepts the following parameters:
     • exception: The type of exception to catch (e.g., ZeroDivisionError). If not provided, it should catch all exceptions.
     • value_on_exception: The value to return if the specified exception occurs (defaults to None if not provided).
   • The __init__ method should store these parameters.
   • The __call__ method should decorate a function and handle exceptions based on the provided parameters.

2. Decorator Functionality:

   • When applying the decorator, if the specified exception occurs, it should return the value_on_exception.
   • If another type of exception occurs, it should propagate that exception as usual.
   • The function should accept and work with any number of positional (*args) and keyword arguments (**kwargs).

Example Usage:¶

@SuppressExceptionsEx(exception=ZeroDivisionError, value_on_exception=0.0)
def egg(a, b):
    return a / b

# Test cases
print(egg(4, 2))  # Outputs: 2.0
print(egg(4, 0))  # Outputs: 0.0 (ZeroDivisionError is caught)
print(egg("a", "b"))  # Raises TypeError (since we're not catching TypeError)

Hints:¶

• Use a try-except block inside the __call__ method to handle the specified exception and return the desired value.
• Ensure that the decorator works with multiple types of exceptions if no specific exception is provided.
• Be mindful of how you pass arguments (*args, **kwargs) to the wrapped function.

class SuppressExceptionsEx:
    def __init__(self, exception=Exception, value_on_exception=None):
        self.exception = exception
        self.value_on_exception = value_on_exception

    def __call__(self, func):
        def wrapper(*args, **kwargs):
            try:
                # print('args =', args)
                # print('kwargs =', kwargs)
                return func(*args, **kwargs)
            except self.exception:
                return self.value_on_exception
        return wrapper

@SuppressExceptionsEx(exception=ZeroDivisionError, value_on_exception=0.0) # => SuppressExceptionsEx(exception=ZeroDivisionError, value_on_exception=0.0)(egg)
def egg(a, b):
    return a / b

print(egg(4, 2))  # Outputs: 2.0
print(egg(4, 0))  # Outputs: 0.0 (ZeroDivisionError is caught)

2.0
0.0

@SuppressExceptionsEx()
def egg(a, b):
    return a / b

print(egg(4, 2))  # Outputs: 2.0
print(egg(4, 0))  # Outputs: None (ZeroDivisionError is caught)
print(egg("a", "b"))  # Outputs: None (TypeError is caught)

2.0
None
None

@property¶

The @property decorator in Python provides a way to manage attributes with getter and setter methods in a clean, readable way, allowing you to treat method calls like attribute access. It helps to encapsulate logic for getting and setting attributes while keeping a user-friendly interface.

Example: Vector Class¶

Consider a Vector class representing a vector in a 2D space. Initially, we store the x and y components as well as the length of the vector. However, this leads to a broken Single Source of Truth issue — modifying the vector's coordinates (x or y) doesn’t update the length automatically.

from math import sqrt

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.length = sqrt(self.x**2 + self.y**2)  # Problem: length doesn't update when x or y changes

v = Vector(3, 4)
print(v.x, v.y, v.length)

3 4 5.0

# example of monkey patching
v.length = 10

print(v.x, v.y, v.length)

3 4 10

In this example, v.length = 10 sets a new length, but x and y don't adjust accordingly. This violates the Single Source of Truth, where the length should always be derived from the x and y values.

Fixing with Getter and Setter Methods¶

A better approach is to calculate the length dynamically based on the current x and y values, and update x and y when the length is modified. Here's a version using explicit getter and setter methods:

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def get_length(self):
        return sqrt(self.x**2 + self.y**2)

    def set_length(self, new_length):
        factor = new_length / self.get_length()
        self.x *= factor
        self.y *= factor

v = Vector(3, 4)
print(v.x, v.y, v.get_length())

3 4 5.0

v.set_length(10)

print(v.x, v.y, v.get_length())

6.0 8.0 10.0

Using @property for a Cleaner Interface¶

We can make the class interface cleaner by using the @property decorator. It allows us to treat the length as a regular attribute while still having control over how it is calculated and updated. With @property, you can access length as if it were a simple attribute, but behind the scenes, it is computed dynamically. The setter allows you to update x and y when the length is changed.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    @property
    def length(self):
        return sqrt(self.x**2 + self.y**2)

    @length.setter
    def length(self, new_length):
        factor = new_length / self.length
        self.x *= factor
        self.y *= factor

v = Vector(3, 4)
print(v.x, v.y, v.length)

3 4 5.0

v.length = 10
print(v.x, v.y, v.length)

6.0 8.0 10.0

Benefits of @property:¶

• Encapsulation: Encapsulates the logic of getting and setting attributes, keeping the interface clean.
• Single Source of Truth: Ensures the vector's length is always consistent with x and y.
• Intuitive Usage: Users of the class can interact with the object as if length were a simple attribute.

Inheriting from Immutable Types¶

In Python, immutable types like tuple, int, str, etc., cannot be modified once created. However, it’s possible to inherit from these types and extend their functionality. This chapter explores how to create custom classes that inherit from immutable types and the considerations for memory efficiency and initialization.

Memory-Consuming Point¶

When defining a class in Python, each instance has a __dict__ attribute that stores all the instance’s attributes. This can consume a significant amount of memory, especially when creating many objects with only a few attributes.

Consider the following Point class:

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(2, 3)

print(p.__dict__)
print(p.__dict__.__sizeof__())
print(p.__sizeof__())

{'x': 2, 'y': 3}
280
16

Reducing Memory Overhead with __slots__¶

To save memory, you can define __slots__ in the class. This tells Python to allocate space for a fixed set of attributes, avoiding the overhead of a __dict__ for each instance.

class Point:
    __slots__ = ['x', 'y']  # No __dict__ will be created, saving memory

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(2, 3)

# print(p.__dict__)
# print(p.__dict__.__sizeof__())
print(p.__sizeof__())

32

Inheriting from tuple¶

Inheriting from immutable types like tuple allows you to extend the behavior of these types, but it comes with limitations. Since tuple is immutable, you cannot modify its elements after creation.

Consider this attempt to create a Point class by inheriting from tuple:

class Point(tuple):
    def __init__(self, x, y):
        self[0] = x  # Attempting to modify a tuple element
        self[1] = y

p = Point(2, 3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[137], line 6
      3         self[0] = x  # Attempting to modify a tuple element
      4         self[1] = y
----> 6 p = Point(2, 3)

TypeError: tuple expected at most 1 argument, got 2

This will raise a TypeError because tuples are immutable and cannot be modified

Creating Immutable Objects with __new__¶

When inheriting from immutable types, you need to override the __new__ method rather than __init__. The __new__ method is responsible for creating new instances of immutable types before they are initialized.

class Point(tuple):

    def __new__(cls, x, y):
        return super().__new__(cls, (x,y))

    @property
    def x(self):
        return self[0]

    @property
    def y(self):
        return self[1]

p = Point(2, 3)

print(type(p))
p[0]
p.x

print(p.__sizeof__())

<class '__main__.Point'>
40

Inheriting from int¶

Inheriting from other immutable types, like int, follows a similar approach. You can use the __new__ method to create new instances and add extra attributes. Let’s look at an example where we create an integer class with additional metadata

class IntegerWithMeta(int):
    def __new__(cls, value, meta):
        self = super().__new__(cls, value)  # Create an integer object
        self.meta = meta  # Attach metadata to the object
        return self

two = IntegerWithMeta(2, 'kg')

print(two)
print(type(two))
print(two.__dict__)

2
<class '__main__.IntegerWithMeta'>
{'meta': 'kg'}

three = IntegerWithMeta(3, 'g')

print(two < three)

True

In this example:

• IntegerWithMeta inherits from int.
• The __new__ method creates the integer object and attaches additional metadata (e.g., 'kg' for kilograms) to it.
• You can still use this class like a regular integer, but with the added ability to store and access extra data (meta).

Conclusion¶

Inheriting from immutable types in Python requires careful use of the __new__ method to create objects. You cannot modify these objects after creation, but you can extend their functionality and add additional attributes like metadata. By using immutability effectively, you can ensure that certain objects remain unchanged throughout their lifetime, while still making them more useful and feature-rich.

Exercise: Implement a Point3D¶

Your task is to create a class Point3D that represents a point in 3D space. The point should be immutable, and you should define x, y, and z as properties to access the coordinates. Additionally, implement a method distance_from_origin that returns the Euclidean distance of the point from the origin (0, 0, 0).

Requirements:¶

1. Inherit from tuple to make the point immutable.
2. Create x, y, and z as properties to access the coordinates.
3. Implement a method distance_from_origin that computes the Euclidean distance from the origin.
4. Ensure that the class is immutable and inherits from tuple.

Example Usage:¶

p = Point3D(3, 4, 5)

# Access the x, y, z coordinates
print(p.x)  # Outputs: 3
print(p.y)  # Outputs: 4
print(p.z)  # Outputs: 5

# Calculate the distance from the origin
print(p.distance_from_origin())  # Outputs: 7.071 (approximately)

# Check immutability (should raise a TypeError if modification is attempted)
try:
    p.x = 10  # This should raise an error because the object is immutable
except AttributeError as e:
    print(e)  # Outputs: "can't set attribute"

# Check inheritance
print(isinstance(p, tuple))  # Outputs: True (Point3D should inherit from tuple)

Hint:¶

• Use sqrt(x**2 + y**2 + z**2) to calculate the Euclidean distance in 3D.
• Try accessing p.x, p.y, and p.z as properties and test if modifying these values raises an error to confirm immutability.

Solution¶

from math import sqrt

class Point3D(tuple):
    def __new__(cls, x, y, z):
        # We call the parent class tuple constructor with the values x, y, z as a tuple
        return super().__new__(cls, (x, y, z))

    @property
    def x(self):
        return self[0]

    @property
    def y(self):
        return self[1]

    @property
    def z(self):
        return self[2]

    def distance_from_origin(self):
        return sqrt(self.x**2 + self.y**2 + self.z**2)

# Testing the implementation
p = Point3D(3, 4, 5)

# Access the x, y, z coordinates
print(p.x)  # Outputs: 3
print(p.y)  # Outputs: 4
print(p.z)  # Outputs: 5

# Calculate the distance from the origin
print(p.distance_from_origin())  # Outputs: 7.0710678118654755

# Check immutability (should raise a TypeError if modification is attempted)
try:
    p.x = 10  # This should raise an error because the object is immutable
except AttributeError as e:
    print(e)  # Outputs: "can't set attribute"

# Check inheritance
print(isinstance(p, tuple))  # Outputs: True (Point3D should inherit from tuple)

3
4
5
7.0710678118654755
property 'x' of 'Point3D' object has no setter
True

Descriptors¶

In Python, descriptors provide a powerful way to manage attribute access and can help solve certain problems related to attribute management that standard properties (@property) might not address fully. Descriptors allow you to define custom behavior for getting, setting, and deleting attributes, making them more flexible than properties.

Point with @property¶

Let's start with a common scenario using @property. We want to create a Point class that acts as a proxy for a JSON object. The JSON represents coordinates u and v, but we want the user to access them via the more intuitive x and y properties. We also want to ensure that:

• The x and y values are always returned as floats.
• Any update to x or y should modify the underlying JSON.
• Invalid data types (like strings) should raise an error, while integers should be converted to floats.

class Point:
    def __init__(self, json: dict):
        self.json = json

    @property
    def x(self):
        return float(self.json['u'])

    @property
    def y(self):
        return float(self.json['v'])

    @x.setter
    def x(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError('Must be int or float')
        self.json['u'] = float(value)

    @y.setter
    def y(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError('Must be int or float')
        self.json['v'] = float(value)

Expected Behavior:¶

p = Point({'u': 42, 'v': 18.0})
assert p.x == 42.0
p.y = 15
assert p.y == 15.0

assert type(p.x) is float  # Even though 'u' was an int, x is always a float
assert p.json == {'u': 42, 'v': 15.0}
assert type(p.json['v']) is float
assert 'x' not in p.__dict__
assert 'u' not in p.__dict__

Dict Key Order¶

Before introducing descriptors, it's essential to understand how dictionaries behave in different versions of Python, as they play a role when handling JSON-like data:

• Python 3.5 and earlier: Dictionaries do not remember the order of keys.
• Python 3.6: Dictionaries remember the order of keys, but it was not guaranteed in the language specification.
• Python 3.7 and later: Key order is officially part of the language specification, meaning dictionaries maintain the insertion order.

Introduction¶

A descriptor is a Python object that implements one or more of the following special methods:

• __get__(self, instance, owner): Handles attribute access.
• __set__(self, instance, value): Handles setting attribute values.
• __delete__(self, instance): Handles deleting attributes.

Descriptors allow you to manage attribute access in a class in a fine-grained way. Here is an example of a descriptor:

class Descriptor:
    def __get__(self, instance, owner):
        print('self =', self)
        print('instance =', instance)
        print('owner =', owner)
        return 42

    def __set__(self, instance, value):
        print('self =', self)
        print('instance =', instance)
        print('value =', value)

    def __delete__(self, instance):
        print('self =', self)
        print('instance =', instance)

class Owner:
    my_int = 84
    attribute = Descriptor()

owner = Owner()
print(owner.my_int)

84

Access through Instance¶

print(owner.attribute)  # Access via Descriptor (calls Descriptor.__get__)

self = <__main__.Descriptor object at 0x10af084d0>
instance = <__main__.Owner object at 0x10af0bd10>
owner = <class '__main__.Owner'>
42

When you access owner.attribute, it calls the __get__ method of the Descriptor class, and prints the instance and class before returning 42.

Let's assign a value to owner.attribute:

owner.attribute = 100  # Calls Descriptor.__set__

self = <__main__.Descriptor object at 0x10af084d0>
instance = <__main__.Owner object at 0x10af0bd10>
value = 100

Finally, deleting the attribute:

del owner.attribute  # Calls Descriptor.__delete__

self = <__main__.Descriptor object at 0x10af084d0>
instance = <__main__.Owner object at 0x10af0bd10>

Behavior in Initializers¶

What happens when you try to override the descriptor's value in the initializer?

class Owner:
    attribute = Descriptor()

    def __init__(self, k):
        self.attribute = k
        self.casual = k

owner_2 = Owner(10)
print(owner_2.__dict__)

self = <__main__.Descriptor object at 0x10af0be60>
instance = <__main__.Owner object at 0x10af0ad50>
value = 10
{'casual': 10}

The descriptor behavior is bypassed in __init__, but the dictionary shows only casual, not attribute.

Accessing attribute again still invokes the descriptor's __get__ method:The descriptor behavior is bypassed in __init__, but the dictionary shows only casual, not attribute.

Accessing attribute again still invokes the descriptor's __get__ method:

print(owner_2.attribute)

self = <__main__.Descriptor object at 0x10af0be60>
instance = <__main__.Owner object at 0x10af0ad50>
owner = <class '__main__.Owner'>
42

Access through Class¶

Accessing the descriptor through the class (rather than an instance) behaves slightly differently:

print(Owner.attribute)

self = <__main__.Descriptor object at 0x10af0be60>
instance = None
owner = <class '__main__.Owner'>
42

Here, instance is None because we are accessing the attribute directly from the class, not an instance.

You can override the descriptor on the class level:

Owner.attribute = 44  # Bypasses the descriptor

print(Owner.attribute)

44

del Owner.attribute  # Deletes the descriptor
print(Owner.attribute)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[176], line 1
----> 1 del Owner.attribute  # Deletes the descriptor
      2 print(Owner.attribute)

AttributeError: type object 'Owner' has no attribute 'attribute'

Example Use Case¶

Let's look at a more practical example: a power class that can represent power in different units—decibels-milliwatts (dBm), milliwatts (mW), and watts (W). Descriptors are used to convert between these units automatically.

import math

class Unit_dBm:
    '''
    decibel-milliwatts
    '''
    def __get__(self, instance, owner):
        return instance._dBm

    def __set__(self, instance, value):
        instance._dBm = float(value)

class Unit_mW:
    def __get__(self, instance, owner):
        return int(10 ** (instance._dBm / 10))

    def __set__(self, instance, value):
        instance._dBm = 10 * math.log10(float(value))

class Unit_W:
    def __get__(self, instance, owner):
        return (10 ** (instance._dBm / 10)) / 1000

    def __set__(self, instance, value):
        instance._dBm = 10 * math.log10(float(value) * 1000)

class Power:
    dBm = Unit_dBm()
    mw = Unit_mW()
    w = Unit_W()

    _dBm: float

    def __init__(self, dBm=None, mw=None, w=None):
        if dBm is not None:
            self.dBm = dBm
        elif mw is not None:
            self.mw = mw
        elif w is not None:
            self.w = w
        else:
            raise TypeError("Must provide a value for one of the units")

        print('self._dBm =', self._dBm)

power = Power(w=0.2)

self._dBm = 23.010299956639813

print(power.mw)

200

power.mw = 10
print(power.dBm)
print(power.mw)
print(power.w)

10.0
10
0.01

print(power.__dict__)

{'_dBm': 10.0}

Exercise: Implementing a Field Descriptor for Data Validation¶

Problem Description:¶

You are tasked with creating a system for managing attributes in a class that uses data from a JSON structure. Instead of using @property, which results in repetitive code for validation and type conversion, you will use descriptors to generalize this behavior and eliminate code duplication.

The goal is to implement a generic Field class that manages data validation and type conversion for different types of fields. The Field class should be reusable for different types like float, string, or any custom type. Your task is to:

1. Create a base class Field, which will be responsible for handling:

   • Getting values from the underlying JSON.
   • Validating and setting values in the JSON.
   • Performing type conversion.

2. Implement a FloatField class that inherits from Field, specifically for handling floating-point values.

3. Extend the functionality with additional types of fields, such as StringField for strings and TypeField for general type conversion.

4. Finally, implement a Model class that will serve as a base class for other models (like Point). The model will store a reference to a JSON structure, and its attributes will be handled by the Field descriptors.

Requirements:¶

1. FloatField Class:

   • Inherits from Field.
   • Converts the values in the JSON to float.

2. StringField Class:

   • Inherits from Field.
   • Converts the values in the JSON to str.

3. TypeField Class:

   • A more flexible version of Field that can handle any type conversion based on a provided type (like int, float, str, etc.).

4. Field Class:

   • Field should take a key (representing a JSON key) in the constructor and use this key to access the underlying JSON.
   • It should handle type conversion through a convert method.
   • It should raise NotImplementedError if the convert method is not implemented in a subclass.

5. Model Class:

   • The Model class should take a JSON dictionary in the constructor, which will serve as the underlying data store.
   • It will use descriptors (Field, FloatField, etc.) to manage access to its attributes.

Expected Behavior:¶

class Point(Model):
    x = FloatField('u')
    y = TypeField('v', float)
    name = StringField('n')

p = Point({'u': 42, 'v': 18.0, 'n': "A"})

# Test getting values
assert p.x == 42.0
assert p.y == 18.0
assert p.name == "A"

# Test setting values
p.y = 15
assert p.y == 15.0
p.name = "qwer"
assert p.json == {'u': 42, 'v': 15.0, 'n': 'qwer'}

# Test type conversions
assert type(p.x) is float
assert type(p.y) is float

# Test setting values with type conversion
p.name = 123
assert p.json == {'u': 42, 'v': 15.0, 'n': '123'}

Hints:¶

• Use the __get__ and __set__ methods to manage access and assignment of values.
• Implement the convert method in each subclass to handle type conversion.
• Raise an error in Field if the conversion method is not implemented.

Solution:¶

class Model:
    def __init__(self, json):
        self.json = json


class Field:
    def __init__(self, key):
        self.key = key

    def __get__(self, instance, owner):
        return self.convert(instance.json[self.key])

    def __set__(self, instance, value):
        instance.json[self.key] = self.convert(value)

    def convert(self, value):
        raise NotImplementedError("The 'convert' method should be implemented in subclasses.")


class FloatField(Field):
    def convert(self, value):
        return float(value)

class StringField(Field):
    def convert(self, value):
        return str(value)

class TypeField(Field):
    def __init__(self, key, type_):
        super().__init__(key)
        # self.type_ = type_
        self.convert = type_

    # def convert(self, value):
    #     return self.type_(value)

# Define the Point class inheriting from Model
class Point(Model):
    x = FloatField('u')
    y = TypeField('v', float)
    name = StringField('n')

# Example Usage
p = Point({'u': 42, 'v': 18.0, 'n': "A"})

# Access attributes
assert p.x == 42.0
assert p.y == 18.0
assert p.name == "A"

# Modify attributes
p.y = 15
assert p.json == {'u': 42, 'v': 15.0, 'n': 'A'}

p.name = "qwer"
assert p.json == {'u': 42, 'v': 15.0, 'n': 'qwer'}

# Test type conversion
p.name = 123
assert p.json == {'u': 42, 'v': 15.0, 'n': '123'}

Explanation of the Solution:¶

1. Field Class:

   • This class is the base descriptor responsible for handling getting and setting values in the JSON.
   • It requires each subclass to implement a convert method to handle type conversion. This method ensures the value in the JSON is always stored as the correct type.

2. FloatField Class:

   • This subclass converts the value to a float. When the attribute is accessed, the value is fetched from the JSON and converted to float. When the value is set, it converts it to float before storing it.

3. StringField Class:

   • This subclass converts the value to a string using the same pattern as FloatField.

4. TypeField Class:

   • This more generic subclass allows any type conversion to be passed as a parameter. You can specify the desired type (e.g., float, int, etc.) and it will convert the value accordingly.

5. Model Class:

   • The Model class provides the base structure that interacts with the JSON data. The descriptors (fields) manage individual attributes, handling both data validation and conversion.

6. Point Class:

   • This is the final class that inherits from Model. It defines specific attributes (x, y, and name) using the descriptors (FloatField, TypeField, and StringField).

Exercise: Implementing Your Own @property Descriptor¶

In this exercise, you will implement your own custom descriptor called Property, which mimics the behavior of the built-in @property decorator in Python. This custom descriptor should handle both getter and setter methods for attributes, allowing for read-only

Requirements:¶

1. Property class:
   • The Property class should be able to accept getter function via its constructor.
   • If only the getter is defined, the property should act as a read-only property.
   • The __get__ method should return the result of the getter function.

Expected Behavior:¶

You will define a class MyClass that uses the Property descriptor to handle a read-only attribute (readonly_value).

Example Code for Testing:¶

class MyClass:
    def __init__(self, readonly_value):
        self._readonly_value = readonly_value

    @Property
    def readonly_value(self):
        return self._readonly_value


# Test cases
d = MyClass("readonly value")

# Test accessing read-only property
assert d.readonly_value == 'readonly value'


# Test setting read-only property (should raise an AttributeError)
try:
    d.readonly_value = 3
except AttributeError as e:
    print(e)  # Outputs: Cannot set read-only property.

# Test accessing the property directly from the class
print(MyClass.readonly_value)

Solution:¶

class Property:
    def __init__(self, fget=None):
        self.fget = fget

    def __get__(self, instance, owner):
        if instance is None:
            return self
        if self.fget is None:
            raise AttributeError("Unreadable property")
        return self.fget(instance)

class MyClass:
    def __init__(self, readonly_value):
        self._readonly_value = readonly_value

    @Property
    def readonly_value(self):
        return self._readonly_value

# Test cases
d = MyClass("readonly value")

# Test accessing read-only property
assert d.readonly_value == 'readonly value'


# Test setting read-only property (should raise an AttributeError)
try:
    d.readonly_value = 3
except AttributeError as e:
    print(e)  # Outputs: Cannot set read-only property.

# Test accessing the property directly from the class
print(MyClass.readonly_value)

<__main__.Property object at 0x10b64dc10>

Bounded Methods in Python¶

class Foo:
    def __init__(self, f):
        self.f = f

    def method(self, arg):
        print(f'method({arg})')

def function(arg):
    print(f'function({arg})')

foo = Foo(function)

Bound Methods vs. Functions¶

Let's investigate the behavior when we call these methods and functions:

foo.method(42)

method(42)

Foo.method(foo, 42)

method(42)

• foo.method(42) automatically passes foo as the first argument (self) to the method.
• Foo.method(foo, 42) explicitly passes foo as the first argument.

Accessing the Function Stored in an Instance¶

You can also call the function stored in the instance directly:

foo.f(42) # => function(42)

function(42)

However, trying to access f from the class itself will result in an error:

Foo.f(42)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[203], line 1
----> 1 Foo.f(42)

AttributeError: type object 'Foo' has no attribute 'f'

This is because f is an instance attribute and not part of the class itself.

Bound Method vs Unbound Method¶

When you assign a method to a variable, it becomes a bound method, meaning it carries with it the instance it was bound to:

m = foo.method
m(42)

method(42)

If you check foo.method, it is a bound method, as it is tied to the instance foo:

print(foo.method) # Foo.method.__get__(foo, Foo)
print(Foo.method)

<bound method Foo.method of <__main__.Foo object at 0x10adea2d0>>
<function Foo.method at 0x10ba86700>

• foo.method is a bound method, meaning it’s tied to the instance foo.
• Foo.method is a function (unbound method), meaning it can be called, but it expects an instance as its first argument.

Checking Bound Instance¶

You can also check the instance to which a bound method is attached using the __self__ attribute:

m = foo.method
print(m.__self__)

<__main__.Foo object at 0x10adea2d0>

Bound Methods Behind the Scenes¶

When you call foo.method, it is equivalent to calling Foo.method.__get__(foo, Foo). This is how Python implements method binding:

print(foo.method)
print(Foo.method.__get__(foo, Foo))

<bound method Foo.method of <__main__.Foo object at 0x1044a6150>>
<bound method Foo.method of <__main__.Foo object at 0x1044a6150>>

This shows that Python binds methods using the __get__ method of the descriptor protocol.

This mechanics allows a developer to inject a custom code between an call to a method of an class's instance and an actuall call to bound function at the class definition.

class BoundedMethod:

    def __init__(self, method):
        self.method = method

    def __get__(self, instance, class_definition):
        return self.method(instance)


class Foo:
    def method(self, arg):
        print(f'method({arg})')


foo = Foo() # create instance of the Foo class


# python creates empty foo without  method
# foo.method = BoundedMethod(Foo.method) => foo.method => Foo.method.__get__(foo, Foo)

print(Foo.method)
print(foo.method)

<function Foo.method at 0x10bba44a0>
<bound method Foo.method of <__main__.Foo object at 0x1044a6150>>

Summary of Key Concepts¶

• Bound Method: A function that is bound to an instance. It automatically passes the instance as the first argument.
• Unbound Method: A function that is not bound to an instance. It needs an instance to be explicitly passed.
• __get__ method: Python binds methods using the __get__ method of descriptors, which ties a function to an instance of a class.

Conclusion¶

Bound methods allow object-oriented programming in Python to work seamlessly, ensuring that methods are always called with the correct instance. This automatic binding is a core part of how Python handles object methods, making method calls simpler and more intuitive.

Multiple Inheritance in Python¶

class Base1:
    def base_method(self):
        print('base_method')

class Base2:
    def another_method(self):
        print('another_method')

class Child(Base2, Base1):
    def child_method(self):
        print('child_method')

# Creating an instance of Child and calling methods
child = Child()
child.base_method()
child.another_method()    # Inherited from Base2
child.child_method()      # Defined in Child

base_method
another_method
child_method

In this example:

• Child inherits methods from both Base1 and Base2.
• You can access methods from both base classes using an instance of Child.

However, the parent classes (Base1, Base2) do not have access to each other's methods:

b1 = Base1()
b1.base_method()          # Works fine

base_method

b1.child_method()       # Raises an AttributeError

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[219], line 1
----> 1 b1.child_method()       # Raises an AttributeError

AttributeError: 'Base1' object has no attribute 'child_method'

b1.another_method()     # Raises an AttributeError

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[220], line 1
----> 1 b1.another_method()     # Raises an AttributeError

AttributeError: 'Base1' object has no attribute 'another_method'

Method Resolution Order (MRO)¶

When a class inherits from multiple parents, Python needs a way to decide the order in which it looks for methods and attributes. This is called the Method Resolution Order (MRO). Python uses the C3 linearization algorithm to determine the order in which classes are searched for methods and attributes.

Let's explore this with a more complex example:

class Foo:

    def __init__(self):
        print('Foo.__init__')


class Boo(Foo):
    pass


class Zoo(Foo):
    def __init__(self):
        print('Zoo.__init__')


class Doo(Foo):
    def __init__(self):
        super().__init__()
        print('Zoo.__init__')


d = Foo()
b = Boo()
z = Zoo()

Foo.__init__
Foo.__init__
Zoo.__init__

e = Doo()

Foo.__init__
Zoo.__init__

class Person:
    def __init__(self, name):
        self.name = name


class PersonExt(Person):

    def __init__(self, name, surname):
        super().__init__(name)

        self.surname = surname

class External:

    def method1(self):
        pass

    def method2(self):
        pass


class Internal(External):
    pass


class Internal2:

    def __init__(self, ext: External):
        self._ext = ext

    def method1(self):
        return self._ext.method1()

# A => base Interface (no functionality)
# B => read functionality
# C => write functionality
# D => module using write and read


class A:  # Implicitly inherits from object => A(object):
    def __init__(self):
        super().__init__()
        print("A")

class B:
    def __init__(self):
        super().__init__()
        print("B")

class C:
    def __init__(self):
        super().__init__()
        print("C")

class D(B, C):
    def __init__(self):
        super().__init__()
        print("D")

In this case, D inherits from both B and C, which in turn inherit from A. When we create an instance of D, Python will follow the MRO to determine which __init__ methods to call:

print(D.__mro__)

(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>)

d = D()

C
B
D

The MRO determines that:

1. D looks in its own class.
2. Then it looks in B.
3. Then in C.
4. Then in A.
5. Finally, it looks in object, the root of all classes in Python.

As a result, the __init__ methods are called in the following order: A, C, B, and finally D.

Custom MRO Traversal¶

You can manually control how the methods are called by using the __class__.__mro__ attribute, which stores the MRO of a class. Here's an example of manually traversing the MRO and calling the next class in the MRO:

class A:
    def __init__(self):
        mro = self.__class__.__mro__
        next_class = mro[mro.index(A) + 1]
        next_class.__init__(self)
        print("A")

class B(A):
    def __init__(self):
        mro = self.__class__.__mro__
        next_class = mro[mro.index(B) + 1]
        next_class.__init__(self)
        print("B")

class C(A):
    def __init__(self):
        mro = self.__class__.__mro__
        next_class = mro[mro.index(C) + 1]
        next_class.__init__(self)
        print("C")

class D(B, C):
    def __init__(self):
        mro = self.__class__.__mro__
        next_class = mro[mro.index(D) + 1]
        next_class.__init__(self)
        print("D")

d = D()

A
C
B
D

In this version, each class manually retrieves the next class in the MRO and explicitly calls its __init__ method. This approach provides more control, but it’s rarely necessary in normal Python programming since Python’s super() handles most cases.

Excercise¶

Implement ComparableByKeyMixin. Classes inheriting from the mixin should implement get_key() method that returns the value we should compare objects by (i.e., for vectors, it should return their length).

Hint: Six special methods are used to compare objects: __lt__, __le__, __eq__, __ne__, __gt__, and __ge__.

DatabaseModel class already implements the logic of storing an object in a database, so you can simply inherit from it.

Implement the following classes:

• Vector: Should be comparable by length and NOT stored in a database.
• Person: Should be comparable by id and stored in a database.
• TodoItem: Should NOT be comparable and should be stored in a database.

Implement LogCreationMixin:

• This mixin logs (prints to the output) when you create an instance of any class using this mixin.
• This is very useful for debugging.
• Use it for both the Person and TodoItem classes.

Optional tasks (★):

• JSONSerializableMixin: Implements .to_json() method and .from_json(json) classmethod that allow you to convert an object to/from a dictionary.

  • This should work for any class, so you need to dynamically get all object attributes from self.__dict__.
  • Make Vector and Person serializable.

• DateCreatedMixin: Automatically adds created_at attribute and sets it to the current time by default (unless an explicit created_at keyword argument is provided in __init__).

  • Reuse this logic for both Vector and TodoItem.

  Implementation:

• First person implements ComparableByKeyMixin, second person implements LogCreationMixin, then the first person implements JSONSerializableMixin, and the second person implements DateCreatedMixin.

Initial Code¶

class DatabaseModel:
    # Imagine this class implements complex logic of adding
    # transparent persistence in a database. Don't modify the code,
    # however, make sure that both Person and TodoItem inherit
    # from this class.
    def save(self):
        print("Automagically saved to the database.")


class ComparableByKeyMixin:
    def __lt__(self, other):  # triggered when you compare self < other
        pass

    # Implement __le__, __eq__, __ne__, __gt__, __ge__ as well


class LogCreationMixin:
    # Implement logging functionality when a new instance is created
    ...


class Vector(...):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # Vectors should be comparable by length and NOT stored in a database
    ...

class Person(...):
    def __init__(self, id, name):
        self.id = id
        self.name = name

    # Persons should be comparable by id and stored in a database
    ...


class TodoItem(...):
    def __init__(self, id, title):
        self.id = id
        self.title = title

    # TodoItems should be NOT comparable and should be stored in a database
    ...

Expected Behaviour¶

v = Vector(3, 4)  # length 5
u = Vector(0, 6)  # length 6 
assert v < u  # compare by length

# v.save()  # Vectors do NOT support database persistence

p1 = Person(id=1234, name='John')
p2 = Person(id=2345, name='Alice')
assert p1 < p2  # compare by id
p1.save()  # Persons support database persistence
# Output: Created an instance of Person
# Output: Automagically saved to the database.

t1 = TodoItem(1, 'Clean dishes')
t1.save()  # TodoItems support database persistence
# Output: Created an instance of TodoItem
# Output: Automagically saved to the database.

Additional Tasks (Optional)¶

# Optional: DateCreatedMixin
print(v.created_at)
# print(p1.created_at)  # Persons should not have created_at field
print(t1.created_at)
# Output: 2020-11-03 12:46:51.985752

t2 = TodoItem(1, 'Clean dishes', created_at=datetime(2020, 1, 1))
print(t2.created_at)
# Output: Created an instance of TodoItem
# Output: 2020-01-01 00:00:00

# Optional: JSONSerializableMixin
print(v.to_json())
# Output: {'x': 3, 'y': 4}

w = Vector.from_json({'x': 2, 'y': 3})
print(w.__dict__)
# Output: {'created_at': datetime.datetime(2020, 11, 3, 12, 46, 51, 985752), 'x': 2, 'y': 3}

class A:
    def __init__(self):
        super().__init__()
        print('A.__init__')


class B:
    def __init__(self):
        super().__init__()
        print('B.__init__')


class C:
    def __init__(self):
        super().__init__()
        print('C.__init__')


class D(C, B, A):
    def __init__(self):
        super().__init__()
        print('D.__init__')
    # pass


d = D() # d.__init__()

A.__init__
B.__init__
C.__init__
D.__init__

D.__mro__

(__main__.D, __main__.C, __main__.B, __main__.A, object)

#### Solution

from datetime import datetime
from functools import total_ordering
from math import sqrt


class DatabaseModel:
    # Imagine this class implements complex logic of adding
    # transparent persistence in a database. Don't modify the code,
    # however make sure, that both Vector and Person inherit
    # from this class.
    def save(self):
        print("Automagically saved to the database.")


@total_ordering
class ComparableByKeyMixin:
    def __lt__(self, other: 'ComparableByKeyMixin'):  # self < other
        return self.get_key() < other.get_key()

    def __eq__(self, other: 'ComparableByKeyMixin'):  # self == other
        return self.get_key() == other.get_key()

    def get_key(self):
        raise NotImplementedError


class LogCreationMixin:
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        print(f"Created an instance of {self.__class__.__name__}")

class DateCreatedMixin:
    def __init__(self, *args, created_at=None, **kwargs):
        super().__init__(*args, **kwargs)
        if created_at is None:
            created_at = datetime.now()
        self.created_at = created_at

class JSONSerializableMixin:
    def to_json(self):
        return self.__dict__.copy()

    @classmethod
    def from_json(cls, json: dict):
        return cls(**json) # __class__

class Vector(ComparableByKeyMixin, DateCreatedMixin, JSONSerializableMixin):
    def __init__(self, x, y, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.x = x
        self.y = y

    def get_key(self):
        return sqrt(self.x**2 + self.y**2)


class Person(ComparableByKeyMixin, LogCreationMixin, JSONSerializableMixin, DatabaseModel):
    def __init__(self, id, name):
        super().__init__()
        self.id = id
        self.name = name

    def get_key(self):
        return self.id


class TodoItem(LogCreationMixin, DateCreatedMixin, DatabaseModel):
    def __init__(self, id, title, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.id = id
        self.title = title

v = Vector(3, 4)  # length 5
u = Vector(0, 6)  # length 6
assert v < u  # compare by length

# v.save()  # Vectors do NOT support database persistence

p1 = Person(id=1234, name='John')
p2 = Person(id=2345, name='Alice')
assert p1 < p2  # compare by id
p1.save()  # Persons support database persistence
# Output: Created an instance of Person
# Output: Automagically saved to the database.

t1 = TodoItem(1, 'Clean dishes')
t1.save()  # TodoItems support database persistence
# Output: Created an instance of TodoItem
# Output: Automagically saved to the database.

Created an instance of Person
Created an instance of Person
Automagically saved to the database.
Created an instance of TodoItem
Automagically saved to the database.

# Optional: DateCreatedMixin
print(v.created_at)
# print(p1.created_at)  # Persons should not have created_at field
print(t1.created_at)
# Output: 2020-11-03 12:46:51.985752

t2 = TodoItem(1, 'Clean dishes', created_at=datetime(2020, 1, 1))
print(t2.created_at)
# Output: Created an instance of TodoItem
# Output: 2020-01-01 00:00:00

# Optional: JSONSerializableMixin
print(v.to_json())
# Output: {'x': 3, 'y': 4}

w = Vector.from_json({'x': 2, 'y': 3})
print(w.__dict__)
# Output: {'created_at': datetime.datetime(2020, 11, 3, 12, 46, 51, 985752), 'x': 2, 'y': 3}

2024-09-27 11:45:35.724468
2024-09-27 11:45:35.725278
Created an instance of TodoItem
2020-01-01 00:00:00
{'created_at': datetime.datetime(2024, 9, 27, 11, 45, 35, 724468), 'x': 3, 'y': 4}
{'created_at': datetime.datetime(2024, 9, 27, 11, 45, 47, 679946), 'x': 2, 'y': 3}

Metaclasses¶

Metaclasses allow you to control how classes behave. Just as classes control the behavior of their instances, metaclasses control the behavior of classes themselves. This can be useful for tasks such as:

• Automatically adding methods or attributes to classes.
• Enforcing class-level constraints or properties.
• Modifying class behavior dynamically.

In essence, metaclasses allow you to hook into and customize class creation in Python.

Introduction¶

In Python, everything is an object, even classes themselves. This means that classes are instances of something too, and that something is called a metaclass. Metaclasses allow you to control how classes are created.

Let's explore this by starting with a simple integer variable s.

s = 2
print(s)
print(type(s)) # => class int
print(s.__class__) # => class int

2
<class 'int'>
<class 'int'>

Here, the variable s is an instance of the class int. The type() function tells us that s is of type int, and s.__class__ gives the same result.

Now, what about the class itself? Let's check the type of the int class:

k = s.__class__ # return int class form int instance

print(k.__class__) # return ?
print(type(k))
print(type(int))

<class 'type'>
<class 'type'>
<class 'type'>

The int class itself is an instance of the class type. In Python, classes are created using a metaclass, and the default metaclass is type. Now, let's define a simple class:

class MyClass:
    pass

inst = MyClass()
print(type(inst))    # What is the type of inst (instance)?
print(type(MyClass)) # What is the type of MyClass (class)?

<class '__main__.MyClass'>
<class 'type'>

Using type() to Create Classes¶

Normally, we define classes using the class keyword, but Python also provides a way to create classes dynamically using the built-in type() function.

class BaseClass:
    def base_method(self):
        print("Base method called")

class MyClass(BaseClass):
    def bar(self):
        print("Bar method called")

    foo = 42

inst = MyClass()

This can be rewritten using the type() function. The type() function can be used to dynamically create classes at runtime by passing three arguments:

1. Class name: The name of the class as a string.
2. Bases: A tuple of base classes.
3. Namespace: A dictionary representing the class body (attributes and methods).

Here’s how the class MyClass would look if we used type() to define it:

def base_method(self):
    print("Base method called")

name = 'BaseClass'
bases = ()
namespace = {
    'base_method': base_method,
}

BaseClass = type(name, bases, namespace)  # Creating BaseClass dynamically

def bar(self):
    print("Bar method called")

name = 'MyClass'
bases = (BaseClass,)  # Inheriting from BaseClass
namespace = {
    'bar': bar,
    'foo': 42,
}
MyClass = type(name, bases, namespace)  # Creating MyClass with inheritance from BaseClass

inst = MyClass()

inst.bar()         # Calls MyClass's method
inst.base_method() # Calls BaseClass's method

Bar method called
Base method called

• BaseClass: We dynamically create BaseClass using type() with a single method base_method.
• name: The string 'MyClass' is the name of the class we are creating.
• bases: We pass (BaseClass,) as the base class from which MyClass inherits.
• namespace: This dictionary includes the bar method and foo attribute for MyClass.

The type() function creates a class named MyClass that inherits from BaseClass, and has its own methods and attributes.

Exercise: Implement a Metaclass to Uppercase All Attributes¶

Description:¶

In this exercise, you will implement a metaclass called upper_attr. This metaclass will modify the class creation process so that all the attributes (both fields and methods) of the class are converted to uppercase. The idea is to intercept the class creation process and transform all attribute names to uppercase in the resulting class.

Initial Code:¶

def upper_attr(name, bases, namespace):
    # Your code here
    ...
    return type(name, bases, namespace)

Expected Behaviour:¶

You should be able to define a class using upper_attr as its metaclass, and all attributes should be converted to uppercase.

class Foo(metaclass=upper_attr):
    bar = 'foo'

    def function(self):
        print(42)

# Check the class dictionary
print(Foo.__dict__)
# Expected Output:
# {
#     '__MODULE__': '__main__',
#     '__QUALNAME__': 'Foo',
#     'BAR': 'foo',
#     'FUNCTION': <function Foo.function at 0x7fe925bf44c0>,
#     '__module__': '__main__',
#     '__dict__': <attribute '__dict__' of 'Foo' objects>,
#     '__weakref__': <attribute '__weakref__' of 'Foo' objects>,
#     '__doc__': None
# }

f = Foo()

# Ensure the attributes are accessible in uppercase
assert f.BAR == 'foo'
f.FUNCTION()  # Expected Output: 42

Solution¶

# meta function
def upper_attr(name, bases, namespace):
    # Convert all attributes to uppercase
    uppered = {key.upper(): value for key, value in namespace.items()}
    return type(name, bases, uppered)

# Testing the metaclass
class Foo(metaclass=upper_attr): # Foo: => Foo(metaclass=type):
    bar = 'foo'

    def function(self):
        print(42)

# Check the class dictionary
print(Foo.__dict__)

# Test instance attributes and methods
f = Foo()
assert f.BAR == 'foo'
f.FUNCTION()