def increment_with_report(current, increments):
    added_count = 0
    def missing():
        '''カウントを+1して0を返す'''
        nonlocal added_count  # ステートフルなclosure
        added_count += 1
        return 0
    result = defaultdict(missing, current)  # closureを仕込む
    for key, amount in increments:
        result[key] += amount
    return result, added_count

class BetterCountMissing:
    def __init__(self):
        self.added = 0
    def __call__(self):
        self.added += 1
        return 0

counter = BetterCountMissig()
result = defaultdict(counter, current)  # counterを関数として渡す
for key, amount in increments:
    result[key] += amount

class InputData:
    def read(self):
        raise NotImplementedError

class PathIputData(InputData):
    def __init__(self, path):
        super().__init__()
        self.path = path
    def read(self):
        with open(self.path) as f:
            return f.read()

class Worker:
    def __init__(self, input_data):
        self.input_data = input_data
        self.result = None
    def map(self):
        raise NotImplementedError
    def reduce(self, other):
        raise NotImplementedError

class LineCountWorker(Worker):
    def map(self):
        data = self.input_data.read()
        self.result = data.count('\n')
    def reduce(self, other):
        self.result += other.result

import os
def generate_inputs(data_dir):
    for name in os.listdir(data_dir):
        yield PathInputData(os.path.join(data_dir, name))

# 引数input_listはPathInputDataをyieldするジェネレーター
def create_workers(input_list):  
    workers = []
    for input_data in input_list:
        workers.append(LineCountWorker(input_data))
    return workers

from threading import Thread
def execute(workers):
    threads = [Thread(target=w.map) for w in workers]
    for thread in threads: thread.start()
    for thread in threads: thread.join()
    first, *rest = workers
    for worker in rest:
        first.reduce(worker)
    return first.result

def mapreduce(data_dir):
    inputs = generate_inputs(data_dir)  # ジェネレーターを返す
    workers = create_workers(inputs)
    return execute(workers)

class GenericInputData:
    def read(self):
        raise NotImplementedError
    @classmethod
    def generate_inputs(cls, config):
        raise NotImplementedError

class PathInputData(GenericInputData):
    def __init__(self, path):
        super().__init__()
        self.path = path
    def read(self):
        with open(self.path) as f:
            return f.read()
    @classmethod
    def generate_input(cls, config):
        data_dir = config['data_dir']
        for name in os.listdir(data_dir)
            yield cls(os.path.join(data_dir, name))

class GenericWorker:
    def __init__(self, input_data)
        self.input_data = input_data
        self.result = None
    def map(self):
        raise NotImplementedError
    def reduce(self, other):
        raise NotImplementedError

    @classmethod
    def create_workers(cls, input_class, config):
        workers = []
        for input_data in input_class.generate_inputs(config):
            workers.append(cls(input_data))
        return workers

class LineCountWorker(GenericWorker):
    def map(self):
    ...
    def reduce(self, other):
    ...

def mapreduce(worker_class, input_class, config):
    workers = worker_class.create_workers(input_class, config)
    return execute(workers)

config = {'data_dir': tmpdir}
result = mapreduce(LineCountWorker, PathInputData, config)
print(f'There are {result} lines')

>>>
There are 4360 lines

class BinaryTree(ToDictMixin):
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

tree = BinaryTree(10, 
    left=BinaryTree(7, right=BinaryTree(9)),
    right=BinaryTree(13, left=BinaryTree(11)))
print(tree.to_dict())
>>>
{'value': 10,
 'left': {'value': 7, 
          'left': None, 
          'right: {'value': 9, 'left': None, 'right': None}},
 'right': {'value': 13, 
          'left': {'value': 11, 'left': None, 'right': None},
          'right': None}}

import json
class JsonMixin:
    @classmethod
    def from_json(cls, data):
        kwargs = json.loads(data)
        return cls(**kwargs)
    def to_json(self):
        return json.dumps(self.to_dict())

>>> age = 35
>>> age.__class__
<class 'int'>
>>> name = 'bob'
>>> name.__class__
<class 'str'>
>>> def foo(): pass
... 
>>> foo.__class__
<class 'function'>
>>> class Bar(object): pass
... 
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>

>>> age.__class__.__class__
<class 'type'>
>>> name.__class__.__class__
<class 'type'>
>>> foo.__class__.__class__
<class 'type'>
>>> b.__class__.__class__
<class 'type'>

class Duck():
    def __init__(self, input_name):
        self.hidden_name = input_name
    @property
    def name(self):
        return self.hidden_name
    @name.setter
    def name(self, input_name):
        self.hidden_name = input_name

duck = Duck('No name')
duck.name = 'Donald'
print(duck.name)
>>>
Donald

class Bucket:
    def __init__(self, period):
        self.period_delta = timedelta(seconds=period)
        self.reset_time = datetime.now()
        self.quota = 0  # クオータを0に初期化
    def __repr__(self):
        return f'Bucket(quota={self.quota})'

def fill(bucket, amount):
    now = datatime.now()
    if (now - bucket.reset_time) > bucket.period_delta:
        bucket.quota = 0
        bucket.reset_time = now
    bucket.quota += amount

def deduct(bucket, amount):
    now = datetime.now()
    if (now - bucket.reset_time) > bucket.period_delta:
        return False  # この期間にバケツはフィルされていない
    if bucket.quota - amount < 0:
        return False  # 使いたい量がない
    bucket.quota -= amount
    return True

class NewBucket:
    def __init__(self, period):
        self.period_delta = timedelta(seconds=period)
        self.reset_time = datetime.now()
        self.max_quota = 0
        self.quota_consumed = 0
    def __repr__(self):
        return (f'NewBucket(max_quota={self.max_quota}, '
               f'quota_consumed={self.quota_consumed})')
    @property
    def quota(self):
        return self.max_quota - self.quota_consumed

@quota.setter
def quota(self, amount):
    delta = self.max_quota - amount  # 減少量 = 最大量 - 設定値
    if amount == 0:
        # 0を指定した場合は、新たな期間のためにリセットする
        self.quota_consumed = 0
        self.max_quota = 0
    eilf delta < 0:
        # 新たな期間のために残量をフィルする
        assert self.quota_comsumed == 0
        self.max_quota = amount
    else:
        # 当該期間において、残量を使う
        assert self.max_quota >= self.quota_consumed
        self.quota_consumed += delta  # 消費した量に減少量を加える

__get__(self, obj, type=None) -> object
__set__(self, obj, value) -> None
__delete__(self, obj) -> None

class Grade:
    def __get__(self, instance, instance_type):
        ...
    def __set__(self, instance, value):
        ...

class Exam:
    math_grade = Grade()
    writing_grade = Grade()
    science_grade = Grade()

exam = Exam()
exam.writing_grade = 40

Exam.__dict__['writing_grade'].__set__(exam, 40)

print(Exam.__dict__)
>>>
{'__module__': '__main__', 'math_grade': <__main__.Grade object at 0x10c02afa0>, 'writing_grade': <__main__.Grade object at 0x10c02af70>, 'science_grade': <__main__.Grade object at 0x10c041070>, '__dict__': <attribute '__dict__' of 'Exam' objects>, '__weakref__': <attribute '__weakref__' of 'Exam' objects>, '__doc__': None}

exam.writing_grade

Exam.__dict__['writing_grade'].__get__(exam, Exam)

from weakref import WeakKeyDictionary
class Grade:
    def __init__(self):
        self._values = WeakKeyDictionary()
    def __get__(self, instance, instance_type):
        ...
    def __set__(self, instance, value):
        ...

class Exam:
    math_grade = Grade()
    writing_grade = Grade()
    science_grade = Grade()

first_exam = Exam()
first_exam.writing_grade = 82
second_exam = Exam()
second_exam.writing_grade = 75
print(f'First {first_exam.writing_grade}')
print(f'Second {second_exam.writing_grade}')
>>>
First 82
Second 75

class SomeClass:
    def __init__(self, aaa):
        self.exists = 5
    # オブジェクトが指定アトリビュートを持たない時に呼ばれる
    def __getattr__(self, name):
        print("getattr is called")
        value = 15  # 本当は、ここで外部DBなどから値を持ってくる
        setattr(self, name, value)
        return value

sc = SomeClass()
print(sc.exists)
print("1st: ", sc.foo)
print("2nd: ", sc.foo)
>>>
5
getattr is called
1st:  15
2nd:  15

class SomeClass:
    def __init__(self):
        self.exists = 5
    def __getattribute__(self, name):
        print("__getattribute__ is called")
        value = 15
        setattr(self, name, value)
        return value

sc = SomeClass()
print(sc.exists)
print("1st: ", sc.foo)
print("2nd: ", sc.foo)
>>>
__getattribute__ is called
15
__getattribute__ is called
1st:  15
__getattribute__ is called
2nd:  15

def __setaddr__(self, name, value):
    なにかチェックして例外を上げたり。。。
    super().__setattr__(name, value)

class Meta(type):
    def __new__(meta, name, bases, class_dict):
        print(f'* Running {meta}.__new__ for {name}')
        print('Bases:', bases)
        print(class_dict)
        return type.__new__(meta, name, bases, class_dict)

class MyClass(metaclass=Meta):
    stuff = 123
    def foo(self):
        pass

class MySubclass(MyClass):
    other = 567
    def bar(self):
        pass

Running <class '__main__.Meta'>.__new__ for MyClass
Bases: ()
{'__module__': '__main__', '__qualname__': 'MyClass', 'stuff': 123, 'foo': <function MyClass.foo at 0x10632f550>}
Running <class '__main__.Meta'>.__new__ for MySubclass
Bases: (<class '__main__.MyClass'>,)
{'__module__': '__main__', '__qualname__': 'MySubclass', 'other': 567, 'bar': <function MySubclass.bar at 0x10632f5e0>}

class BetterPolygon:
    sides = None  # サブクラスで指定必要

    def __init_subclass__(cls):
        super().__init_subclass()
        if cls.sides < 3:
            raise ValueError('Polygons need 3+ sides')
    @classmethod
    def interior_angles(cls):
        return (cls.sides - 2) * 180

class Point(BetterPolygon):
    sides = 1
>>>
Traceback ...
ValueError: Polygons need 3+ sides

class Top:
    def __init_subclass__(cls):
        super().__init_subclass()
        print(f'Top for {cls}')

class Left(Top):  # これを定義する時にTop.__init_subclass__()が呼ばれる
    def __init_subclass__(cls):
        super().__init_subclass()  # Rightにて既に実行済みのため何もしない
        print(f'Left for {cls}')

class Right(Top):  # これを定義する時にTop.__init_subclass__()が呼ばれる
    def __init_subclass__(cls):
        super().__init_subclass()  # Top.__init_subclass__()を呼ぶ
        print(f'Right for {cls}')

# これを定義する時にRight.__init_subclass__()が呼ばれる
#   その中で、top.__init_subclass__()を呼ぶ
# 次に、Left.__init_subclass__()が呼ばれる
#   その中で、top.__init_subclass__()を呼ばない(Rightが実行済み)
class Bottom(Left, Right):
    def __init_subclass__(cls):
        super().__init_subclass()
        print(f'Bottom for {cls}')

Top for <class '__main__.Left'>  # LeftからTopの__init_subclass__実行
Top for <class '__main__.Right'>  # RightからTopの__init_subclass__実行
# BottomからRight.__init_subclass__実行->Topの__init_subclass__実行
Top for <class '__main__.Bottom'>  
Right for <class '__main__.Bottom'>  # BottomからRight.__init_subclass__実行
Left for <class '__main__.Bottom'>  # BottomからLeft.__init_subclass__実行

registry = {}
def registr_class(target_class):
    registry[target_class.__name__] = target_class

class Register():
    def __init_subclass__(cls):
        super().__init_subclass__()
        register_class(cls)

class NewClass(Register):
    pass

print(registry)
>>>
{'NewClass': <class '__main__.NewClass'>}

class Field:
    def __init__(self):
        self.name = None
        self.internal_name = None
    def __set_name__(self, owner, name):
        # Called on class creation for each descriptor
        self.name = name
        self.internal_name = '_' + name
    def __get__(self, instance , instance_type):
        if instance is None:
            return self
        return getattr(instance, self.internal_name, '')
    def __set__(self, instance, value):
        setattr(instance, self.internal_name, value)

class FixedCustomer:
    first_name = Field()
    last_name = Filed()
    prefix = Field()
    suffix = Field()

>>> cust = FixedCustomer()
>>> cust.__dict__
{}
>>> cust.first_name.__dict__  # 変数名はデスクリプターField内の__dict__に保持
{'name': 'first_name', 'internal_name': '_first_name'}
>>> cust.first_name = 'Joy'
>>> cust.__dict__  # 変数の値は各custオブジェクトの__dict__に保持
{'_first_name': 'Joy'}
>>> cust.first_name.__dict__
{'name': 'first_name', 'internal_name': '_first_name'}

def my_class_decorator(klass):
    klass.extra_param = 'hello'
    return klass

@my_class_decorator
class MyClass:
    pass

print(MyClass)
print(MyClass.extra_param)
>>>
<class '__main__.MyClass'>
hello

from functools import wraps

def trace_func(func):
    if hasattr(func, 'tracing'):  # Only decorate once
        return func

    @wraps(func)
    def wrapper(*args, **kwargs):
        result = None
        try:
            result = func(*args, **kwargs)
            return result
        except Exception as e:
            result = e
            raise
        finally:
            print(f'{func.__name__}({args!r}, {kwargs!r}) -> '
                  f'{result!r}')

    wrapper.tracing = True
    return wrapper

import types
trace_types = (
    types.MethodType,
    types.FunctionType,
    types.BuiltinFunctionType,
    types.BuiltinMethodType,
    types.MethodDescriptorType,
    types.ClassMethodDescriptorType)

def trace(klass):
    for key in dir(klass):
        value = getattr(klass, key)
        if isinstance(value, trace_types):
            wrapped = trace_func(value)
            setattr(klass, key, wrapped)
    return klass

>>> @trace
... class TraceDict(dict):
...     pass
... 
>>> trace_dict = TraceDict([('hi', 1)])
__new__((<class '__main__.TraceDict'>, [('hi', 1)]), {}) -> {}
>>> trace_dict['there'] = 2
>>> trace_dict['hi']
__getitem__(({'hi': 1, 'there': 2}, 'hi'), {}) -> 1
1
>>> try:
...     trace_dict['does not exist']
... except KeyError:
...     pass  # Expected
... 
__getitem__(({'hi': 1, 'there': 2}, 'does not exist'), {}) -> KeyError('does not exist')

>>> isinstance(trace_dict.__new__, types.MethodType)
True
>>> isinstance(trace_dict.__getitem__, types.MethodType)
True
>>> isinstance(trace_dict.__setitem__, types.MethodType)
False  # あれ!?
>>> trace_dict.__new__
<bound method dict.__new__ of {'hi': 1, 'there': 2}>
>>> type(trace_dict.__new__)
<class 'method'>
>>> type(trace_dict.__getitem__)
<class 'method'>
>>> type(trace_dict.__setitem__)
<class 'method-wrapper'>