python面向对象编程设计与开发

class Person(object):
    """人类"""
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk(self):
        print("hello, my name is %s, I‘m %s years old" % (p.name, p.age))


p = Person("jack", 22)
print(p.name, p.age)  # 查看对象属性
p.talk()  # 注意这里调用并未传递参数
# 新增类属性
Person.country = "China"  # 给类新增一个属性
# Person.__dict__[‘country‘] = "China"  # 不支持这样新增 
# 查看类属性
print(Person.__dict__["country"])  # 查看属性
print(Person.__dict__)  # 查看所有属性
# 删除类属性
del Person.country  # 删除属性
# Person.__dict__.pop("country")  # 不支持这样删除
print(Person.__dict__)  # 查看属性，发现country属性已不存在


"""
输出：
jack 22
hello, my name is jack, I‘m 22 years old
China
{‘__module__‘: ‘__main__‘, ‘__doc__‘: ‘人类‘, ‘__init__‘: <function Person.__init__ at 0x0000000001E48950>, ‘talk‘: <function Person.talk at 0x0000000001E489D8>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Person‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Person‘ objects>, ‘country‘: ‘China‘}
{‘__module__‘: ‘__main__‘, ‘__doc__‘: ‘人类‘, ‘__init__‘: <function Person.__init__ at 0x0000000001E48950>, ‘talk‘: <function Person.talk at 0x0000000001E489D8>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Person‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Person‘ objects>}

class LuffyStudent:
    school = "luffycity"

    def __init__(self, name, sex, age):  # 使用构造方法初始化对象
        self.name = name
        self.sex = sex
        self.age = age

    def learning(self, x):
        print("%s is learning %s" % (self.name, x))


stu1 = LuffyStudent("alex", "男", 22)
stu2 = LuffyStudent("rain", "男", 23)
stu3 = LuffyStudent("laura", "女", 22)
print(LuffyStudent.__dict__)

class LuffyStudent:
    school = "luffycity"

    def __init__(self, name, sex, age):  # 使用构造方法初始化对象
        self.name = name
        self.sex = sex
        self.age = age

    def learning(self, x):
        print("%s is learning %s" % (self.name, x))


stu1 = LuffyStudent("alex", "男", 22)
stu2 = LuffyStudent("rain", "男", 23)
stu3 = LuffyStudent("laura", "女", 22)
# print(LuffyStudent.__dict__)
# 修改
stu1.name = "Alex"  # 等同于：stu1.__dict__["name"] = "Alex"
print(stu1.__dict__)
# 删除
del stu1.age  # 等同于：stu1.__dict__.pop("age")
print(stu1.__dict__)
# 新增
stu1.course = "python"  # 等同于：stu1.__dict__["course"] = "python"
print(stu1.__dict__)


输出：
{‘name‘: ‘Alex‘, ‘sex‘: ‘男‘, ‘age‘: 22}
{‘name‘: ‘Alex‘, ‘sex‘: ‘男‘}
{‘name‘: ‘Alex‘, ‘sex‘: ‘男‘, ‘course‘: ‘python‘}

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class ‘__main__.ParentClass1‘>,)
>>> SubClass2.__bases__
(<class ‘__main__.ParentClass1‘>, <class ‘__main__.ParentClass2‘>)

# 属性查找
class Foo:
    def f1(self):
        print("from Foo.f1")

    def f2(self):
        print("from Foo.f2")
        self.f1()  # 相当于b.fi()


class Bar(Foo):
    def f1(self):
        print("form Bar.f1")


b = Bar()
print(b.__dict__)
b.f2()


输出：
{}
from Foo.f2
form Bar.f1

class A(object):
    def test(self):
        print(‘from A‘)

class B(A):
    def test(self):
        print(‘from B‘)

class C(A):
    def test(self):
        print(‘from C‘)

class D(B):
    def test(self):
        print(‘from D‘)

class E(C):
    def test(self):
        print(‘from E‘)

class F(D,E):
    # def test(self):
    #     print(‘from F‘)
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C

class A:
    def f1(self):  # 根据C.mro()列表，首先在A中找到f1
        print("from A")
        super().f1()  # 当程序运行到这一步时，super会沿着C.mro()列表往下找f1

class B:
    def f1(self):  # 然后在B中找到f1
        print("from B")


class C(A,B):
    pass


print(C.mro())

c = C()
c.f1()  # 运行程序，发现打印了A，也打印了B，因为这是基于C类引发的寻找，super只会根据C.mro()中的列表顺序一个接一个往下找


输出：
[<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]
from A
from B

class People:
    """人类"""
    school = "luffy"

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


class Teacher(People):
    """教师类"""
    def __init__(self, name, age, sex, level, salary):
        super(Teacher, self).__init__(name, age, sex)
        self.level = level
        self.salary = salary

    def teach(self):
        print("%s is teaching" % self.name)


class Student(People):
    """学生类"""
    def __init__(self, name, age, sex, class_time):
        super().__init__(name, age, sex)
        self.class_time = class_time

    def learn(self):
        print("%s is learning" % self.name)


class Course:
    """课程类"""
    def __init__(self, course_name, course_price, course_period):
        self.course_name = course_name
        self.course_price = course_price
        self.course_period = course_period

    def course_info(self):
        print("课程名：%s 价格：%s 课时：%s" % (self.course_name, self.course_price, self.course_period))


python = Course("python", 10000, "3month")
linux = Course("linux", 8000, "2month")

teach1 = Teacher("alex", 38, "male", 10, 3000)
teach2 = Teacher("egon", 28, "male", 20, 4000)
teach1.course = python  # 给老师添加课程属性
teach2.course = python
print(teach1.__dict__)
print(teach2.__dict__)
print(teach1.course.course_name)  # 查看老师所教的课程名
teach2.course.course_info()  # 查看课程信息

stu1 = Student("rain", 14, "male", "8:30")
stu1.course1 = python
stu1.course2 = linux
stu1.course1.course_info()  # 查看课程信息
stu1.course2.course_info()
stu1.courses = []
stu1.courses.append(python)
stu1.courses.append(linux)
print(stu1.__dict__)

输出：
{‘name‘: ‘alex‘, ‘age‘: 38, ‘sex‘: ‘male‘, ‘level‘: 10, ‘salary‘: 3000, ‘course‘: <__main__.Course object at 0x000000000251B518>}
{‘name‘: ‘egon‘, ‘age‘: 28, ‘sex‘: ‘male‘, ‘level‘: 20, ‘salary‘: 4000, ‘course‘: <__main__.Course object at 0x000000000251B518>}
python
课程名：python 价格：10000 课时：3month
课程名：python 价格：10000 课时：3month
课程名：linux 价格：8000 课时：2month
{‘name‘: ‘rain‘, ‘age‘: 14, ‘sex‘: ‘male‘, ‘class_time‘: ‘8:30‘, ‘course1‘: <__main__.Course object at 0x000000000251B518>, ‘course2‘: <__main__.Course object at 0x000000000251B550>, ‘courses‘: [<__main__.Course object at 0x000000000251B518>, <__main__.Course object at 0x000000000251B550>]}

# 定义接口Interface类来模仿接口的概念
class Animal:  # 接口类
    all_type = "animal"  # 接口名

    def run(self):  # 接口名，但不去实现它
        pass

    def eat(self):  # 接口名
        pass


class People(Animal):  # 子类继承接口
    def run(self):  # 调用接口
        print("people is walking")  # 实现接口的功能

    def eat(self):
        print("people is eating")


class Pig(Animal):
    def run(self):
        print("pig is walking")

    def eat(self):
        print("pig is eating")


class Dog(Animal):
    def run(self):
        print("dog is walking")

    def eat(self):
        print("dog is eating")


poe1 = People()
pig1 = Pig()
dog1 = Dog()

poe1.run()
dog1.run()
print(poe1.all_type)

# 如下代码，实现接口约束
import abc  # 导入模块


class Animal(metaclass=abc.ABCMeta):  # 这个Animal类只能被继承，不能被实例化
    all_type = "animal"  # 数据属性

    @abc.abstractmethod  # 装饰器
    def run(self):  # 定义抽象方法，无需实现功能  （函数属性）
        pass

    @abc.abstractmethod
    def eat(self):  # 定义抽象方法，无需实现功能
        pass


class People(Animal):  # 此时若在子类里面没有定义父类的run和eat方法，程序就会报错，父类相当于起到一个规范的作用
    def run(self):  # 子类必须定义run方法
        pass  # print("people is walking")

    def eat(self):  # 子类必须定义eat方法
        print("people is eating")


class Pig(Animal):
    def run(self):
        print("pig is walking")

    def eat(self):
        print("pig is eating")


class Dog(Animal):
    def run(self):
        print("dog is walking")

    def eat(self):
        print("dog is eating")


poe1 = People()
pig1 = Pig()
dog1 = Dog()

poe1.run()
dog1.run()
print(poe1.all_type)
# 这样大家都是被归一化了,也就是一切皆文件的思想

import abc  # 导入模块


class Animal(metaclass=abc.ABCMeta):
    all_type = "animal"

    @abc.abstractmethod
    def run(self):
        pass

    @abc.abstractmethod
    def eat(self):
        pass


class People(Animal):
    def run(self):
        print("people is walking")

    def eat(self):
        print("people is eating")


class Pig(Animal):
    def run(self):
        print("pig is walking")

    def eat(self):
        print("pig is eating")


class Dog(Animal):
    def run(self):
        print("dog is walking")

    def eat(self):
        print("dog is eating")


# 多态性：在不考虑实例（对象）类型的情况下，直接使用实例（对象)
# 动态多态性（调用方法）：
peop1 = People()  # 造一个对象
dog = Dog()
# peop1.eat()  # 使用实例
# dog.run()


def func(animal):  # 设计一个函数接口
    animal.run()


func(peop1)  # 传入对象，调用函数
func(dog)

class A:
    __x = 1  # 打印A的属性字典发现，x这个属性已经变形为：_A__x‘

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

    def __foo(self):  # 函数在字典中的属性已经变形为： _A__foo. 相当于：def _A__foo(self)
        print("run foo")

    def bar(self):
        self.__foo()  # 在类内部调用__foo，看是否能运行
        print("from bar")

# print(A.__x)  # 在类外部打印类的变量__x，发现报错，说没有这个属性
# print(A.__foo())
a = A("egon")
# print(a.__name)
a.bar()  # 调用没有加“__”的函数，结果发现bar里面的__foo运行了，说明在类内部可以调用这个方法
print(A.__dict__)  # 打印属性字典，观察里面的属性名称
a._A__foo()  # 这样就能访问，使用python在正真意义上并没有完全禁止外部访问这个隐藏属性

"""这种变形的特点：
1、在类外部无法直接使用obj.__AttrName进行类的属性访问
2、在类内部可以直接使用obj.__AttrName进行属性方法的访问
3、子类无法覆盖父类"__"开头的属性,因为你会发现它俩根本不是一个名字（看下面的例子）

这种隐藏只是一种变形操作，在类定义阶段就会发生变形"""


输出：
run foo
from bar
{‘__module__‘: ‘__main__‘, ‘_A__x‘: 1, ‘__init__‘: <function A.__init__ at 0x00000000021C88C8>, ‘_A__foo‘: <function A.__foo at 0x00000000021C8950>, ‘bar‘: <function A.bar at 0x00000000021C89D8>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘A‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘A‘ objects>, ‘__doc__‘: None}
run foo

class B:
    __x = 1

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


print(B._B__x)

B.__y = 2  # 在类定义完了之后又增加一个“__”开头的属性
print(B.__dict__)   # 打印发现字典里面__y的格式是：‘__y‘: 2 , 没有发生变形

b = B("egon")
print(b.__dict__)  # 打印结果：{‘_B__name‘: ‘egon‘}

b.__age = 22  # 给b对象新增一个属性
print(b.__dict__)  # 打印结果：{‘_B__name‘: ‘egon‘, ‘__age‘: 22}
# 所以变形只在类定义阶段发生，且只发生一次

# 正常情况：
class A:
    def foo(self):
        print("A.foo")

    def bar(self):
        print("A.bar")
        self.foo()  # 实际相当于执行：b.foo()


class B(A):
    def foo(self):
        print("B.foo")


b = B()
b.bar()

输出：
A.bar
B.foo

# 在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的：
class A:
    def __foo(self):  # _A__foo
        print("A.foo")

    def bar(self):
        print("A.bar")
        self.__foo()  # self._A__foo()


class B(A):
    def __foo(self):  # _B__foo
        print("B.foo")


b = B()
b.bar()

输出：
A.bar
A.foo

# 例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）
# 做一个计算BMI的程序,体质指数（BMI）=体重（kg）÷身高^2（m）,计算一个对象是出于哪个级别（过轻，正常，...)
class People:
    def __init__(self, weight, high):
            self.weight = weight
            self.high = high

    def bmi(self):
        return self.weight / (self.high * self.high)


p = People(47, 1.58)
print(p.bmi())  # 使用property之前


# 使用property
class People:
    def __init__(self, weight, high):
        self.weight = weight
        self.high = high

    @property
    def bmi(self):  # 这个方法必须要有个返回值
        return self.weight / (self.high * self.high)


p = People(47, 1.58)
print(p.bmi)  # 使用了property后，对于使用者来说，就像调用数据属性一样调用了函数
# 此时的p.bmi是不能被赋值的，它只是被做的像数据属性，其实本质还是一个函数的

class Circle:
    def __init__(self, r):
        self.r = r

    @property
    def perimeter(self):
        return self.r * 2 * 3.14

    @property
    def area(self):
        return self.r ** 2 * 3.14


c = Circle(3)
print(c.perimeter)  # 可以向访问数据属性一样去访问perimeter,会触发一个函数的执行,动态计算出一个值
print(c.area)  # 同上

# 注意：此时的特性area和perimeter不能像一般的属性那样可以被赋值
# c.area=3 #为特性area赋值
# 执行程序会抛出异常：AttributeError: can‘t set attribute

class People:
    def __init__(self, name):
        self.__name = name

    @property
    def name(self):  # 查询方法
        # print("getter")  # 测试用
        return self.__name

    @name.setter
    def name(self, val):  # 修改信息方法，使得p.name可以进行赋值操作
        # print("setter")  # 测试
        if not isinstance(val, str):  # 合法性判断
            print("名字必须是字符串类型")
            return
        self.__name = val  # 如果输入合法，就将新的值赋给self.__name

    @name.deleter
    def name(self):  # 删除信息方法
        # print("deleter")  # 测试
        print("不允许删除名字")


p = People("egon")
# 查询：
print(p.name)  # 触发查询方法(第一个name方法）

# 修改：
p.name = "alex"  # 触发修改方法（第二个name方法）
print(p.name)  # 查看修改后的值

# 删除：
del p.name  # 触发删除方法（第三个name方法）


输出：
egon
alex
不允许删除名字

class Foo:
    def __init__(self, val):
        self.__NAME = val  # 将所有的数据属性都隐藏起来，_Foo__NAME

    @property
    def name(self):
        return self.__NAME  # obj.name访问的是self.__NAME(这也是真实值的存放位置) f._Foo__NAME

    @name.setter
    def name(self, value):
        if not isinstance(value, str):  # 在设定值之前进行类型检查
            raise TypeError(‘%s must be str‘ % value)
        self.__NAME = value  # 通过类型检查后,将值value存放到真实的位置self.__NAME

    @name.deleter
    def name(self):
        raise TypeError(‘Can not delete‘)


f = Foo(‘egon‘)
print(f.name)
# f.name = 10  # 抛出异常：TypeError: 10 must be str
# del f.name  # 抛出异常：TypeError: Can not delete

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

    def tell(self):  # 绑定给对象的方法
        print("名字是%s" % self.name)

    @classmethod  # 绑定给类的方法
    def func(cls):
        print(cls)

    @staticmethod  # 非绑定方法
    def func1(x, y):
        return x + y


f = Foo("egon")
print(Foo.func)  # <bound method Foo.func of <class ‘__main__.Foo‘>>  是一个bound method
print(f.func1)  # <function Foo.func1 at 0x0000000001E58A60>  是一个function
print(Foo.func1)  # <function Foo.func1 at 0x0000000001E58A60>
print(f.func1(2, 3))
print(Foo.func1(2, 3))

class A:
    pass


class B(A):
    pass


b=B()
print(isinstance(b,B))
print(isinstance(b,A))
print(type(b) is B)
print(type(b) is A)


输出：
True
True
True
False

class People:
    country = "China"
    def __init__(self, name, age):
        self.Name = name
        self.age = age

    def talk(self):
        print("%s is talking" % self.Name)


obj = People("egon", 23)
# 判断一个属性是不是对象的属性，即该属性名是否存在于对象的属性字典里面
print(hasattr(obj, "Name"))  # obj.name 是否存在于 obj.__dict__
print(hasattr(obj, "talk"))

# 拿到一个对象的属性值
# print(getattr(obj, "Namexx"))  # 如果没有这个属性，程序会报错：AttributeError: ‘People‘ object has no attribute ‘Namexx‘
print(getattr(obj, "Name", None))  # 这样的话，如果没有这个属性，就返回None，而不会报错
print(getattr(obj, "talk", None))

# 修改
setattr(obj, "sex", "male")  # obj.sex = "male"  新增一个sex属性
print(obj.sex)

# 删除
delattr(obj, "age")  # del obj.age
print(obj.__dict__)

# 同样的方法对类也是可以使用的
print(getattr(People, "country"))  # 拿到类中的country属性值

import sys


def s1():
    print( ‘s1‘)


def s2():
    print(‘s2‘)


this_module = sys.modules[__name__]
print(this_module)
print(hasattr(this_module, ‘s1‘))
print(getattr(this_module, ‘s2‘))

class Service:
    def run(self):  # self = obj
        while True:
            inp = input(">>>").strip()  # 输入属性方法：假如是要下载：cmd =get a.txt
            cmds = inp.split()  # cmd = ["get","a.txt"]
            if hasattr(self, cmds[0]):  # 对象中存在该属性
                func = getattr(self, cmds[0])  # 获取该属性值,func = get
                func(cmds)  # 调用属性方法

    def get(self,cmds1):
        print("get...", cmds1)

    def put(self,cmds2):
        print("put...", cmds2)


obj = Service()
obj.run()

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

    def __getattr__(self, item):
        print(‘----> from getattr:你找的属性不存在‘)


    def __setattr__(self, key, value):
        print(‘----> from setattr‘)
        # self.key=value #这就无限递归了,你好好想想
        # self.__dict__[key]=value #应该使用它

    def __delattr__(self, item):
        print(‘----> from delattr‘)
        # del self.item #无限递归了
        self.__dict__.pop(item)

#__setattr__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)

#__delattr__删除属性的时候会触发
f1.__dict__[‘a‘]=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)

#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx

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

    def __getattr__(self, item):
        print(‘run __getattr__‘)
        # return self.__dict__[item]
    def __getattribute__(self, item):
        print(‘不管是否存在,我都会执行‘)
        raise AttributeError(‘哈哈‘)

f1=Foo(10)
f1.x
f1.xxxxxx

#当__getattribute__与__getattr__同时存在,只会执行__getattrbute__,除非__getattribute__在执行过程中抛出异常AttributeError

class Foo:
    def __get__(self, instance, owner):
        print(‘触发get‘)
    def __set__(self, instance, value):
        print(‘触发set‘)
    def __delete__(self, instance):
        print(‘触发delete‘)

#包含这三个方法的新式类称为描述符,由这个类产生的实例进行属性的调用/赋值/删除,并不会触发这三个方法
f1=Foo()
f1.name=‘egon‘
f1.name
del f1.name
#疑问:何时,何地,会触发这三个方法的执行

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

    def __getitem__(self, item): # 查看属性  self = obj ,item = "name"
        # print(item)
        return self.__dict__.get(item, None)  # 返回属性值

    def __setitem__(self, key, value):  # 修改/新增属性
        # print(key, value)
        self.__dict__[key] = value  # 给字典增加键和值
        # return self.__dict__[key]

    def __delitem__(self, key):
        self.__dict__.pop(key)  # 或者： del self.__dict__[key]
        # print(key)


obj = Foo("egon")
# 一般使用 obj.属性名  的格式  去访问属性
print(obj["name"])  # 像字典一样去访问属性值。 直接触发getitem方法

# 修改/新增属性
# obj.age = 22  # 以前的方法
obj["age"] = 23  # 触发setitem方法， 现在的方法
# 查看设置后的属性
print(obj["age"])  # 方式一
print(obj.age)  # 方式二
print(obj.__dict__)

# 删除
del obj["name"]  # 触发delitem方法
print(obj.__dict__)

d = dict({"name": "egon"})
print(isinstance(d, dict))
print(d)  # 输出：{‘name‘: ‘egon‘}

class Foo:
    pass

obj = Foo()
print(obj)  # 输出：<__main__.Foo object at 0x0000000001E67828>

# 从上面两个打印结果看出，同为对象，打印出的结果却不一样，因为python给做了定制操作
# 下面自己来定制一个一样效果的操作：
class People:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        # print(">>>")
        return self.name  # 必须有个字符串格式的返回值


obj = People("egon", 22)
print(obj)  #  此时可以触发__str__方法:obj.__str__()

f = open("settings.py")  # 给操作系统发送请求打开资源
f.read()
f.close()  # 提醒操作系统回收资源
print(f)


class Open:
    def __init__(self, filename):
        print("open file...")
        self.filename = filename

    def __del__(self):  # 所以在这个方法里面可以作回收操作系统资源的操作
        print("回收操作系统资源")


f = Open("settings.py")
print("----main-----")  # 程序运行到最后一步的时候会触发__del__方法

g = {
    "x": 1,
    "y": 2
}
l = {}

exec("""
global x, z
x = 100
z = 200  # 变量z函数exec执行期间产生的名字，但是它被声明为全局变量了，所以将被存放到全局名称空间中
m = 300  # 变量m函数exec执行期间产生的名字，将被存放到局部名称空间中
""", g, l)
print(g)
print(l)

# 定义类的两种方式：1、class关键字定义
class Chinese:
    country = "China"

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

    def talk(self):
        print("%s is talking" % self.name)


print(Chinese)
obj = Chinese("egon", 18)  # 可以实例化对象
print(obj.__dict__)

# 造出一个类的要素：类名、类的基类们、类的名称空间

# 第一步：设置类名：
class_name = "Chinese"
# 第二步：设置类的基类：
class_bases = (object,)
# 第三步：设置类体，即用于产生类的名称空间的函数体：
class_body = """
country = "China"

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

def talk(self):
    print("%s is talking" % self.name)
"""
class_dict = {}  # 名称空间
exec(class_body, globals(), class_dict)  # 使用exec函数产生类的名称空间
# print(class_dict)

Chinese1 = type(class_name, class_bases, class_dict)  # 使用type元类造出一个类
print(Chinese1)
obj1 = Chinese1("alex", 19)  # 可以实例化对象
print(obj1.__dict__)

class Mymeta(type):  # 模拟一个元类，在这里面可以作一些类的规则的控制
    def __init__(self, class_name, class_bases, class_dict):
        # print(self)  # self = Chinese
        # print(class_name)  # 类名  Chinese
        # print(class_bases)  # 基类  (<class ‘object‘>,)
        # print(class_dict)  # 名称空间  {‘__module__‘: ‘__main__‘, ‘__qualname__‘: ‘Chinese‘, ...}
        if not class_name.istitle():  # 判断类名首字母是否大写
            raise TypeError("类名首字母必须大写")  # 抛出异常
        if "__doc__" not in class_dict or not class_dict["__doc__"].strip():  # 注释是否存在，或者是否为空
            # 如果__doc__属性不在字典里面或者__doc__为空
            raise TypeError("必须有注释，且注释不能为空")  # 抛出异常
        super(Mymeta, self).__init__(class_name, class_bases, class_dict)  # 调用父类方法，继承父类属性


class Chinese(object, metaclass=Mymeta):  # 继承元类Mymeta
    """
    在Chinese类里面
    """
    country = "China"

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

    def talk(self):
        print("%s is talking" % self.name)


c = Chinese("egon", 12)
print(c.__dict__)

# Chinese = Mymeta(class_name, class_bases, class_dict)

# __call__方法,在对象调用时会触发
class Foo:
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)


obj = Foo()
obj(1, 2, 3, a=4, b=5)  # 调用对象:obj.__call__(obj, (1, 2, 3), {a = 4, b = 5})


输出：
<__main__.Foo object at 0x00000000021D74E0>
(1, 2, 3)
{‘a‘: 4, ‘b‘: 5}

class Mymeta(type):
    """模拟一个元类"""
    def __init__(self, class_name, class_bases, class_dict):
        print(class_name)  # 类名
        print(class_bases)  # 基类
        print(class_dict)  # 名称空间
        if not class_name.istitle():  # 判断类名首字母是否大写
            raise TypeError("类名首字母必须大写")  # 抛出异常
        if "__doc__" not in class_dict or not class_dict["__doc__"].strip():  # 注释是否存在，或者是否为空
            # 如果__doc__属性不在字典里面或者__doc__为空
            raise TypeError("必须有注释，且注释不能为空")  # 抛出异常
        super(Mymeta, self).__init__(class_name, class_bases, class_dict)

    def __call__(self, *args, **kwargs):  # __call__(Chinese, "egon", 12)
        print(self)  # 打印参数, self = Chinese
        print(args)  # args = (‘egon‘,)
        print(kwargs)  # kwargs = {‘age‘: 12}
        # 第一件事：实例化一个类，造出一个空对象obj
        obj = object.__new__(self)  # self = Chinese
        # 第二件事：初始化对象obj
        self.__init__(obj, *args, **kwargs)
        # 第三件事：返回初始化好了的对象obj
        return obj


class Chinese(object, metaclass=Mymeta):  # 继承元类Mymeta
    """在Chinese类里面"""
    country = "China"

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

    def talk(self):
        print("%s is talking" % self.name)


c = Chinese("egon", age = 12)  # 实例化其实就是相当于调用类。相当于执行：Chinese.__call__(Chinese, "egon", 12)
"""调用Chinese会有三件事发生：
1、造出一个空对象
2、初始化对象
3、返回对象
"""

print(c.__dict__)


输出：
{‘__module__‘: ‘__main__‘, ‘__qualname__‘: ‘Chinese‘, ‘__doc__‘: ‘\n    在Chinese类里面\n    ‘, ‘country‘: ‘China‘, ‘__init__‘: <function Chinese.__init__ at 0x00000000023D8A60>, ‘talk‘: <function Chinese.talk at 0x00000000023D8AE8>}
<class ‘__main__.Chinese‘>
(‘egon‘,)
{‘age‘: 12}
{‘name‘: ‘egon‘, ‘age‘: 12}

class Mysql:
    def __init__(self):
        self.host = "127.0.0.1"
        self.port = 3306


obj1 = Mysql()
obj2 = Mysql()

print(obj1)
print(obj2)

输出：
<__main__.Mysql object at 0x0000000002177630>
<__main__.Mysql object at 0x0000000002177748>

class Mysql:
    __instance = None

    def __init__(self):
        self.host = "127.0.0.1"
        self.port = 3306

    @classmethod  # 绑定给类的方法
    def single(cls):  # cls = Mysql
        if not cls.__instance:  # 判断cls有没有值
            obj = cls()  # 没有值就实例化cls产生一个obj对象
            cls.__instance = obj  # 将obj对象赋值给__instance
        return cls.__instance


obj1 = Mysql.single()  # 实例化对象，自动传值：Mysql.single(Mysql)
obj2 = Mysql.single()

print(obj1)
print(obj2)
# 打印结果发现，此时两个对象的内存地址都一样了，因为通过这种单例模式使得它们共用了一个内存空间
print(obj1 is obj2)  # 判断两个对象内存地址（id)是否相同


输出：
<__main__.Mysql object at 0x00000000021E7780>
<__main__.Mysql object at 0x00000000021E7780>
True

class Mymeta(type):  # 模拟一个元类
    def __init__(self, class_name, class_bases, class_dict):  # self = Mysql
        if not class_name.istitle():  # 判断类名首字母是否大写
            raise TypeError("类名首字母必须大写")  # 抛出异常
        if "__doc__" not in class_dict or not class_dict["__doc__"].strip():  # 注释是否存在，或者是否为空
            # 如果__doc__属性不在字典里面或者__doc__为空
            raise TypeError("必须有注释，且注释不能为空")  # 抛出异常
        super(Mymeta, self).__init__(class_name, class_bases, class_dict)
        self.__instance = None

    def __call__(self, *args, **kwargs):  # __call__(Chinese, "egon", 12)
        if not self.__instance:  # 判断__instance是否为空
            obj = object.__new__(self)  # 若果为空就实例化一个空对象
            self.__init__(obj)  # 初始化空对象
            self.__instance = obj  # 将初始化后的对象赋值给__instance
        return self.__instance


class Mysql(object, metaclass=Mymeta):
    """
    使用单例模式控制类的实例化
    """
    def __init__(self):
        self.host = "127.0.0.1"
        self.port = 3306


obj1 = Mysql()
obj2 = Mysql()
obj3 = Mysql()

print(obj1 is obj2 is obj3)


输出：
True

class Mymetaclass(type):
    def __new__(cls, name, bases, attrs):
        update_attrs = {}
        for k, v in attrs.items():
            if not callable(v) and not k.startswith("__"):  # 判断是否为数据属性
                update_attrs[k.upper()] = v  # 是数据属性就将属性名改为大写
            else:
                update_attrs[k] = v  # 否则不修改
        return type.__new__(cls, name, bases, update_attrs)  # 返回修改后的数据


class Chinese(metaclass=Mymetaclass):
    country = "China"  # 数据属性
    tag = "Legend of the Dragon"  # 数据属性

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

    def walk(self):  # 函数属性
        print("%s is walking" % self.name)


print(Chinese.__dict__)  # 打印结果发现，类中所有数据属性都变为大写

"""
1.元类帮其完成创建对象，以及初始化操作；
2.要求实例化时传参必须为关键参数形式，否则抛出异常TypeError: must use keyword argument
3.key作为用户自定义类产生对象的属性，且所有属性变成大写
"""
class Mymetaclass(type):
    def __call__(self, *args, **kwargs):
        # print(self)  # self = Chinese
        # print(args)  # args = ()
        # print(kwargs)  # kwargs = {‘name‘: ‘egon‘, ‘age‘: 18, ‘sex‘: ‘male‘}
        if args:  # 如果args中有内容，说明实例化的时候传入了非关键参数
            raise TypeError("must use keyword argument for key function")
        obj = object.__new__(self)  # 创建对象，self= Chinese
        for k, v in kwargs.items():
            obj.__dict__[k.upper()] = v  # 将属性名改为大写
        return obj


class Chinese(metaclass=Mymetaclass):
    country = "China"
    tag = "Legend of the Dragon"

    def walk(self):
        print(‘%s is walking‘)


p = Chinese(name=‘egon‘,age=18,sex=‘male‘)
print(p.__dict__)


输出：
{‘NAME‘: ‘egon‘, ‘AGE‘: 18, ‘SEX‘: ‘male‘}