num = 23
print("num的类型", type(num))
lst = [1, 2, 4]
print("lst的类型:", type(lst))
name = "Atul"
print("name的类型:", type(name))

num的类型: 
lst的类型: 
name的类型: 

class Student:
    pass
stu_obj = Student()
# 打Student对象的类型
print("Student的对象是:", type(stu_obj))

Student的对象是: 

class Student:
    pass
# Student类的类型
print("Student类的类型:", type(Student))

Student类的类型: 

# 定义一个类，没有其他任何类方法和变量
class test:pass
# 定义类方法
test.x = 45
# 定义类方法
test.foo = lambda self: print('你好')
# 创建对象
myobj = test()
print(myobj.x)
myobj.foo()

45
你好

def test_method(self):
    print("这是Test类的方法!")
# 创建一个基类
class Base:
    def myfun(self):
        print("这是一个继承的方法!")
# 动态创建Test类，使用type()方法
Test = type('Test', (Base, ), dict(x="mango", my_method=test_method))
# 打印Test的type
print("Test类的type: ", type(Test))
# 创建Test的对象
test_obj = Test()
print("Test对象的type: ", type(test_obj))
# 调用继承方法
test_obj.myfun()
# 调用Test类方法
test_obj.my_method()
# 打印变量
print(test_obj.x)

Test类的type:  
Test对象的type:  
这是一个继承的方法!
这是Test类的方法!
mango

# 我们的元类metaclass
class MultiBases(type):
    # 重写 __new__方法
    def __new__(cls, clsname, bases, clsdict):
        # 如果基类的数量比1大，报错
        if len(bases)>1:
            raise TypeError("继承了多个基类!!!")
        # 否则执行父类的__new__ , 调用type类的 __init__
        return super().__new__(cls, clsname, bases, clsdict)
# 元类可以通过'metaclass'关键字参数指定，现在MultiBase类用于创建类，该类将传播到父类Base的所有子类
class Base(metaclass=MultiBases):
    pass
# 如下合法
class A(Base):
    pass
# 如下合法
class B(Base):
    pass
# 如下会报错!
class C(A, B):
    pass

Traceback (most recent call last):
  File "", line 2, in 
  File "", line 8, in __new__
TypeError: 继承了多个基类!!!

from functools import wraps
def debug(func):
    '''装饰器，用于调试传递的函数'''
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("此方法的全名:", func.__qualname__)
        return func(*args, **kwargs)
    return wrapper
def debugmethods(cls):
    '''类装饰器使用调试装饰器来调试类方法 '''
    # 在类字典中检查是否存在任何可调用(方法)(如果存在)，将其替换为调试版本
    for key, val in vars(cls).items():
        if callable(val):
            setattr(cls, key, debug(val))
    return cls
# 样本类
@debugmethods
class Calc:
    def add(self, x, y):
        return x+y
    def mul(self, x, y):
        return x*y
    def div(self, x, y):
        return x/y
mycal = Calc()
print(mycal.add(2, 3))
print(mycal.mul(5, 2))

此方法的全名: Calc.add
5
此方法的全名: Calc.mul
10

from functools import wraps
def debug(func):
    '''装饰器，用于调试传递的函数'''
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("此方法的全名:", func.__qualname__)
        return func(*args, **kwargs)
    return wrapper
def debugmethods(cls):
    '''类装饰器使用调试装饰器来调试类方法 '''
    for key, val in vars(cls).items():
        if callable(val):
            setattr(cls, key, debug(val))
    return cls
class debugMeta(type):
    '''元类，将创建的类对象提供给debug方法以获取启用调试功能的对象'''
    def __new__(cls, clsname, bases, clsdict):
        obj = super().__new__(cls, clsname, bases, clsdict)
        obj = debugmethods(obj)
        return obj
# 现在，具有元类'debugMeta'的基类的所有子类都将应用调试
class Base(metaclass=debugMeta):pass
# 继承基类Base
class Calc(Base):
    def add(self, x, y):
        return x+y
# 继承Calc
class Calc_adv(Calc):
    def mul(self, x, y):
        return x*y
# 现在，Calc_adv对象显示调试行为
mycal = Calc_adv()
print(mycal.mul(2, 3))

此方法的全名: Calc_adv.mul
6