x = 9
y = 2
divmod(x, y) == (x // y, x % y), divmod(x, y) is (x // y, x % y)

class X: pass
class A(X): pass 
class B(X): pass 
class D(A, B): pass
print([cls.__name__ for cls in D.__mro__])

#задача
class A:
    count = 0
    def __init__(self):
        A.count = A.count + 1
    def get(self):
        return A.count
x, y, z = A(), A(), A()
print(x.get(), A().__class__.get(A()), z.__class__.get(y))

class A:
    count = 0 
    def __init__(self):
        A.count += 1
    def print_count():
        print(A.count)  
    print_count = staticmethod(print_count)
    
class B(A): pass

x, y, z = B(), A(), B() 
B.print_count()

class A:
    count = 0 
    def __init__(self) :
        self.__class__.count += 1
  
class B(A):
    pass
                  
class C(A):
    pass 

x, y, z = B(), A(), C()
print(A.count, B.count, C.count)

class A:
    count = 0
    @classmethod
    def inc(cls):
        cls.count += 1 
    def __init__ (self):
        self.inc() 
        
class B(A):
    count = 0
    def __init__(self): 
        A.__init__(self)
        
class C(A): 
    count = 0
    
x = A()  
y1, y2 = B(), B() 
z1, z2, z3 = C(), C(), C()
print(x.count, y1.count, z1.count)

import random
random.random() < random.randint(1, 10)

(0 or 8 != 11 or 0) + (0 and 8 != 11 and 0)

class counter:
    def __init__(self, func): 
        self.calls = 0
        self.func = func
        
    def __call__(self, *args): 
        self.calls += 1
        return self.func(*args), self.calls
    
@counter 
def square(a): 
    return a ** 2

print(square(2)[0] + square(3)[0] + square(4)[1])

def decorator(cls):
    class Proxy:
        def __init__ (self, *args): 
            self.wrapped = cls(*args)
        def __getattr__(self, name): 
            return 1 if name == 'x' else getattr(self.wrapped, name)
    return Proxy

@decorator
class S:
    def __init__(self, x):
        self.x = x
    def square(self): 
        return self.x ** 2 
s = S(10) 
print(s.square() + s.x)