开发技术--面向对象

开发|面向对象

面向对象的学习，可以让我们的代码趋于模块化，规范化，尤其是引入设计模式之后，面向对象的优点就更加明显~~
希望大家在实际使用中多使用面向对象的思想，enjoy!

前言

目前所有的文章思想格式都是:知识+情感。
知识:对于所有的知识点的描述。力求不含任何的自我感情色彩。
情感:用我自己的方式，解读知识点。力求通俗易懂，完美透析知识。

正文

我给本篇文章的定位是回顾自己之前学过的知识点，一定会有我没有涉及到的知识点。我会将我自己学习面向对象之后使用过的，忘记了的，我觉得自己需要掌握的内容，在正文中体现出来~~
花费了我不少时间，哈哈~~

必备知识

1.面向对象直接这么说，是很空的一个概念。尤其是初学者，你说面向对象，根本都不知道是什么，哪怕是学习了很久的人，你问什么是面向对象，十之八九的答案都是，面向对象就是写一个类。。。。terrible~， So， 先一步一步的来了解一下什么是面向对象吧~

2.看面向对象之前，想函数怎么可以执行，除了一个一个的向下执行，还可以嵌套使用吧!在函数中需要增加一个功能，我想需要更改的地方不一出，改完了，你敢确定没有影响其他的功能吗？？？答案肯定是，回去检查一下吧!咋们保险一点~

3.由此面向对象就引出来了，可以简单的理解为面相对象就是解决只使用函数的扩展性问题。(其实，这里有一个问题就是，我写过全是函数的代码，不知你是否写过，又真的有相同体会？)

4.总结一下，面向对象解决了扩展性问题。由此，咋们一起上了面向对象的车，一路开向面向对象的本质~

面向对象初识

接下来将开始，面向对象的第一次实质审查~~

什么面向对象

一开始面向对象，大家会说Python里面一切皆对象，是否还记得linux里面一切皆文件~
补充一下，关于一切皆对象，对象怎么使用？？？
1、都可以被引用，x=obj
2、都可以当作函数的参数传入
3、都可以当作函数的返回值
4、都可以当作容器类的元素，例如: l=[func,time,obj,1]

注意: Python3统一类与类型(数据类型)的概念，类型就是类。
上面这么说有一点空，看一个代码，希望大家可以有所理解~(看到的数据类型都是类)

In [10]: print(list)
<class 'list'>

In [11]: print(str)
<class 'str'>

In [12]: print(dict)
<class 'dict'>

对象 与 类的关系？

1.现实生活中，需要先有了一个一个的对象，才可以将对象分为哪一类，哪一类，但是，在自己写程序的时候，需要自己先写到一个类，才可以产生一个的对象，产生对象的过程，称为实例化类。

2.所以，一定是先有类，才可以实例化成为对象。

创建类

在创建类之前，需要掌握一点基础知识；
1.类中具有自己的数据，称为数据属性，或者叫数据
2.类中具有自己的函数，称为函数属性，或者叫方法
3.看下面创建的类，school属于数据，sleep属于方法

class Student:
    school = 'Peking University'

    def sleep(self):
        print('Student is sleeping.')

使用类

1.使用类，也就如何实例化出对象，根据上例子，student1=Student()，就可以实例化对象。

2.实例化类，并执行函数

In [16]: class Student:
    ...:     school = 'Peking University'
    ...:
    ...:     def sleep(self):
    ...:         print('Student is sleeping.')
    ...:

In [17]: student1 = Student()

In [18]: student1.sleep()
Student is sleeping.

注意:代码加载的时候，就会执行类，产生名称空间存储响应的数据，如果类中的数据属性有another操作，就会被执行。看下面的another操作是print操作。

In [15]: class Student:
    ...:     school = 'Peking University'
    ...:     print(school)
    ...:
    ...:     def sleep(self):
    ...:         print('Student is sleeping.')
    ...:
Peking University

类的属性与方法

在这里将详细的讲一下，一个类中的属性与方法和实例化对象的关系!

1.类的属性是所有对象共同指向的，共同指向同一内存地址
验证:

In [20]: class Student:
    ...:     school = 'Peking University'
    ...:
    ...:     def sleep(self):
    ...:         print('Student is sleeping.')
    ...:

In [21]: student1 = Student()

In [22]: student2 = Student()

In [23]: id(student1.school)
Out[23]: 1745287897136

In [24]: id(student2.school)
Out[24]: 1745287897136

2.类的方法是绑定给每一个对象的，对象调用的时候自动传参，bound method 。
验证:

In [29]: student1.sleep
Out[29]: <bound method Student.sleep of <__main__.Student object at 0x000001965B6F95F8>>

In [30]: student2.sleep
Out[30]: <bound method Student.sleep of <__main__.Student object at 0x000001965B9F2CF8>>

面向对象进阶

类的命名空间 dict

1.类的命名空间查看，如下:

In [33]: Student.__dict__
Out[33]:
mappingproxy({'__module__': '__main__',
              'school': 'Peking University',
              'sleep': <function __main__.Student.sleep(self)>,
              '__dict__': <attribute '__dict__' of 'Student' objects>,
              '__weakref__': <attribute '__weakref__' of 'Student' objects>,
              '__doc__': None})

2.可以执行下面的代码
类.__ dict __['name]
类.name

In [40]: Student.__dict__['school']
Out[40]: 'Peking University'

In [41]: Student.school
Out[41]: 'Peking University'

3.如果想要执行类中的函数属性，需要加上一个对象，来看下面，直接执行会报错，缺少一个对象的参数。解决，传入一个对象即可。

In [42]: Student.sleep()
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-42-6e9af3d2ac0b> in <module>
----> 1 Student.sleep()

TypeError: sleep() missing 1 required positional argument: 'self'

In [43]: Student.sleep(student1)
Student is sleeping.

init 方法

1.init作为初始化，可以为每一个对象定制属于自己的属性，只需要在实例化的时候传入即可。

2.方式一，实例化的时候，直接传参得到对象。

In [44]: class Student:
    ...:
    ...:     school = 'Peking University'
    ...:
    ...:     def __init__(self, name, age):
    ...:         self.name = name
    ...:         self.age = age
    ...:
    ...:     def sleep(self):
    ...:         print('%s is sleeping.' % self.name)
    ...:

In [45]: student1 = Student('kate', 18)

In [46]: student1.__dict__
Out[46]: {'name': 'kate', 'age': 18}

3.方式二，在使用方式一的时候，执行了两步，首先是实例化了对象，其次是传入参数，看下面，

In [48]: class Student:
    ...:
    ...:     school = 'Peking University'
    ...:
    ...:     def sleep(self):
    ...:         print('Student is sleeping.')
    ...:

In [49]: student2 = Student()

In [50]: student2.name = 'kate'

In [51]: student2.age = 18

In [52]: student2.__dict__
Out[52]: {'name': 'kate', 'age': 18}

bases

bases的作用就是查看继承的父类有哪些，看下面例子，这个时候出现了一个object的类，但是我们在书写类的时候，并没有继承那个类啊，为什么会多了一个object的类，有疑惑的请移步到新式类与经典类，默认Python3中都是继承object类的，不写也给你默认继承。

In [54]: Student.__bases__
Out[54]: (object,)

继承

1.继承顾名思义就是继承，继承一个或者多个父类，被继承的类叫做基类(超类)，继承者叫做子类(派生类)。其中，继承表示的是:什么是什么的关系。

2.继承之后，实例化的对象的属性查找，需要特别留意。对象的属性，在不继承的时候，先从自己属性查找，再从类中找，找不到就报错。如果有父类，会去父类中找，找不到报错。

3.总结: 继承的查找顺序----->先自己找，再去类中找，再去父类中找(父类中找也会出现问题，哪一个先找呢，看mro表就知道了~~)

4.实际看一下继承的书写,(学生继承人这个类)

In [55]: class People:
    ...:
    ...:     def __init__(self, name, age):
    ...:         self.name = name
    ...:         self.age = age
    ...:
    ...:     def sleep(self):
    ...:         print('%s is sleeping.' % self.name)
    ...:
    ...:
    ...: class Student(People):
    ...:
    ...:     school = 'Peking University'
    ...:

In [56]: student = Student('kate', 18)

In [57]: student.__dict__
Out[57]: {'name': 'kate', 'age': 18}

派生

1.在继承中，派生可以得到不同于父类的属性与方法，有两种方式，下面我们一起分别看一下~

2.指名道姓重用，(不依赖于继承)

In [65]:
    ...: class People:
    ...:
    ...:     def __init__(self, name, age):
    ...:         self.name = name
    ...:         self.age = age
    ...:
    ...:     def sleep(self):
    ...:         print('%s is sleeping.' % self.name)
    ...:
    ...:
    ...: class Student(People):
    ...:     school = 'Peking University'
    ...:
    ...:     def sleep(self):
    ...:         People.sleep(self)
    ...:         print('Self sleeping....')
    ...:

In [66]: stu = Student('kate', 18)

In [67]: stu.sleep()
kate is sleeping.
Self sleeping....

3.使用super()，依赖于继承，使用mro表计算实现继承顺序，在mro也存在一个指针，只要是遇到super，就继续沿着mro表，继续向后找。

In [68]: class People:
    ...:
    ...:     def __init__(self, name, age):
    ...:         self.name = name
    ...:         self.age = age
    ...:
    ...:     def sleep(self):
    ...:         print('%s is sleeping.' % self.name)
    ...:
    ...:
    ...: class Student(People):
    ...:     school = 'Peking University'
    ...:
    ...:     def sleep(self):
    ...:         super(Student, self).sleep()
    ...:         print('Self sleeping....')
    ...:

In [69]: stu = Student('kate', 18)

In [70]: stu.sleep()
kate is sleeping.
Self sleeping....

4，注意:一般的派生都是使用super()。并且更多的应用场景是在init中继承父类的内容，也有自己的内容。一定不要忘记子啊继承查找的时候，遇到super的试试，会继续向后查找的，就不会回到前面在查找了~~

mro

mro列表，是查找继承的顺序列表，表示了属性的查找顺序。
例子:

In [71]: class A:
    ...:     name = 'A'
    ...:
    ...:
    ...: class B(A):
    ...:     name = "B"
    ...:
    ...:
    ...: class C(A):
    ...:     name = "C"
    ...:
    ...:
    ...: class D(B, C):
    ...:     name = 'D'
    ...:

In [74]: D.mro()
Out[74]: [__main__.D, __main__.B, __main__.C, __main__.A, object]

新式类

1.新式类，并不是它有多么的新，哈~
新式类的讨论，需要分python2与Python3来说了，接下来，没我们一起来看看吧!

2.Python2的新式类，必须继承object类，继承object的类以及他的子类称为新式类。

3.Python3，默认所有 的类都是默认继承object类，所以都是新式类，也就是说Python3中没有经典类。

4.新式类在mro寻继承的时候，遵循广度优先。具体可以查看自己的mro列表。

经典类

1.经典类是专门来对于Python2来说的，所以经典类说的是在Python2中， 没有继承object的类。

2.经典类在继承查询的时候，遵循的是深度优先。

组合

1.组合，不需要深入的了解，当一个类不能通过继承实现关系的时候，有需要自己有自己有什么关系的时候，就可以使用派生。此时就，派生出自己的属性与方法。

In [58]: class People:
    ...:
    ...:     def __init__(self, name, age):
    ...:         self.name = name
    ...:         self.age = age
    ...:
    ...:     def sleep(self):
    ...:         print('%s is sleeping.' % self.name)
    ...:
    ...:
    ...: class Student(People):
    ...:
    ...:     school = 'Peking University'
    ...:
    ...:
    ...: class Course:
    ...:
    ...:     def __init__(self, name, price):
    ...:         self.name = name
    ...:         self.price = price
    ...:

In [59]: student = Student('kate', 18)

In [60]: math = Course('math', 666)

In [61]: student.course = math

In [62]: student.__dict__
Out[62]: {'name': 'kate', 'age': 18, 'course': <__main__.Course at 0x1965b5c1198>}

In [63]: student.course.name
Out[63]: 'math'

In [64]: student.course.price
Out[64]: 666

2.此时表示给对象绑定了一个对象作为他的属性，可以实现代码的重用。

多态

Python属于多态的语言，多态更多的体现在方法的调用上，保证多个类可以实现调用同一种方法，实现相同的任务。
回想，len()，这个内置函数，在执行的时候，可以对字符串，对列表，对元祖获取数据的长度，但是不同的数据类型都是不一样的类，但是实现了同样的函数方法。感觉自己解释不清楚了，看代码吧!

In [1]: a = 'hello'

In [2]: b = (1, 2, 3)

In [3]: c = [4, 5, 6]

In [4]: len(a)
Out[4]: 5

In [5]: len(b)
Out[5]: 3

In [6]: len(c)
Out[6]: 3

In [8]: a.__len__
Out[8]: <method-wrapper '__len__' of str object at 0x000002B0701D12D0>

In [9]: b.__len__
Out[9]: <method-wrapper '__len__' of tuple object at 0x000002B070404EE8>

In [10]: c.__len__
Out[10]: <method-wrapper '__len__' of list object at 0x000002B0703C0588>

鸭子类型

鸭子类型，具体的概念我就不解释了!我想解释的是，鸭子模式体现的是多态性，正如上文我所述的len()内置方法。它属于一个比较理论的知识内容，Python语言本身就具体多态性，所以自己在学习的时候，按需进行学习!

封装

1.封装作为面向对象的特性之一，就我目前的理解，封装主要是对数据的隐藏，或者是变成自己私有的，由于Python语言的特性，会在内部自动对杠杠开头的变量进行相应的处理，所以正好使用这一特性实现数据隐藏。

2.具体的实现，隐藏，使前面加 __，此时的 __name 变为 _类名__name，在类的加载阶段已经变化了，加上前缀的类名。

3.看下命名空间，应该可以理解的吧~

In [11]: class People:
    ...:
    ...:     def __init__(self, name, age):
    ...:         self.__name = name
    ...:         self.__age = age
    ...:
    ...:     def sleep(self):
    ...:         print('%s is sleeping.' % self.__name)
    ...:

In [12]: human = People('kate', 18)

In [13]: human.__dict__
Out[13]: {'_People__name': 'kate', '_People__age': 18}

4.封装可以将封装起来的数据，自己进行定义，不需要调用者操作与查看，不仅仅是封装数据，还隔离复杂度。

面向对象高阶

在面向对象高阶，我们开始一步一步的去寻找类的产生源头~~追根溯源。

抽象类

1.抽象类的实现，使用的是abc模块，子哎程序的设计模式中可能会使用到，我在设计模式的文章中写过~，主要使用的是Python的abc模块

2.抽象类的特性:** 只能被继承，不能被实例化。只要是继承抽象类的类，必须重写相应的类方法，名字都必须一样，不然报错~，这在设计模式的时候，就很好的规范了底层的调用接口。**

3.例子，实现抽象类

In [17]: import abc
    ...:
    ...:
    ...: class People(metaclass=abc.ABCMeta):
    ...:
    ...:     @abc.abstractmethod
    ...:     def sleep(self):
    ...:         pass
    ...:
    ...:
    ...: class Student(People):
    ...:     school = 'Peking University'
    ...:
    ...:     def __init__(self, name, age):
    ...:         self.name = name
    ...:         self.age = age
    ...:
    ...:     def sleep(self):
    ...:         print('Self sleeping....')
    ...:

In [18]: stu = Student('kate', 18)

In [19]: stu.__dict__
Out[19]: {'name': 'kate', 'age': 18}

property

1.property 将访问函数属性变为访问数据属性的方法。原本需要加上括号才可以调用，现在直接就可以进行调用了。统一调用形式，不用加括号进行调。用了

2.可以联动设置的参数，修改:name.setter， 删除:name.deleter

3.代码实现，了解一下，这个property还是很常用的，

In [23]: class People:
    ...:
    ...:     def __init__(self, name):
    ...:         self.__name = name
    ...:
    ...:     @property
    ...:     def name(self):
    ...:         return self.__name
    ...:
    ...:     @name.setter
    ...:     def name(self, new_name):
    ...:         self.__name = new_name
    ...:
    ...:
    ...:     @name.deleter
    ...:     def name(self):
    ...:         print('Error .... no permission to delete..')
    ...:

IIn [24]: human = People('kat')

In [26]: human.name
Out[26]: 'kat'

In [27]: human.name = 'kate'

In [28]: human.name
Out[28]: 'kate'

In [29]: del human.name
Error .... no permission to delete..

classmethod

classmethod属于绑定到类的方法，类可以使用，并且将类作为第一个参数传递进去。此时，可以回忆一下开始面向对象的时候，关于数据属性是所有的对象共同拥有的，所有的函数属性是绑定给每一个对象。**注意:bond method **
看以下关于classmethod的例子:

In [30]: class People:
    ...:
    ...:     def __init__(self, name):
    ...:         self.__name = name
    ...:
    ...:     @classmethod
    ...:     def eat(self):
    ...:         print('eat....')
    ...:
    ...:     def sleep(self):
    ...:         print('sleep...')
    ...:

In [31]: peo = People('kate')

In [32]: peo.sleep
Out[32]: <bound method People.sleep of <__main__.People object at 0x000002B071C3E898>>

In [33]: peo.eat
Out[33]: <bound method People.eat of <class '__main__.People'>>

In [34]: People.sleep
Out[34]: <function __main__.People.sleep(self)>

In [35]: People.eat
Out[35]: <bound method People.eat of <class '__main__.People'>>

staticmethod

staticmethod表示非绑定方法，对象和类都可以使用，一般没有什么具体的意思，就是一个普通的函数，我在使用的过程中也没有遇到，使用方法类似于classmethod。可以百度了解一下~~

反射

反射，这个使用的次数是很多的，尤其是在很多开源的框架(Django 的框架中配置文件中的应用类，内部都是使用getattr)中都使用，这个方法很巧妙，可以字符串与函数关联起来。即可以通过字符串映射到对象的属性。

hasattr

hasatrr单独使用是没有啥用的，只是做一个判断，看下对象中是不是存在一个字符串对应的属性。

getattr

grtattr 是真正干活的那个，可以进行字符串与函数属性的映射，操作起来相当顺溜~~，一定要多使用，尤其是在开放封闭原则的配置文件，配置参数的时候局可以使用。

setattr

setattr一般使用的很少，我在上次学习到现在基本上没有怎么使用。

delattr

基本不使用的命令了，没使用过，要是不看到他了，我都忘记了这个了......

反射示例

In [39]: class Ftp:
    ...:
    ...:     def start(self):
    ...:         while 1:
    ...:             inp = input('>>>').strip()
    ...:             cmds = inp.split()
    ...:             if hasattr(self, cmds[0]):
    ...:                 func = getattr(self, cmds[0])
    ...:                 func(cmds)
    ...:
    ...:     def put(self, cmds):
    ...:         print(cmds)
    ...:
    ...:     def get(self, cmds):
    ...:         print(cmds)
    ...:

In [40]: f =Ftp()

In [41]: f.start()
>>>get d.md
['get', 'd.md']
>>>put s.doc
['put', 's.doc']

item系列

item系列，主要是将取出类中的数据属性，变成字典的方式取出，相应的包含getitem, setitem, delitem,实现属性的增删改查。

In [1]: class Student:
   ...:     def __init__(self, name):
   ...:         self.name = name
   ...:
   ...:     def __getitem__(self, item):
   ...:         print('getitem...')
   ...:         return self.__dict__.get(item)
   ...:
   ...:     def __setitem__(self, key, value):
   ...:         print('setitem.... %s' % value)
   ...:         self.__dict__[key] = value
   ...:
   ...:     def __delitem__(self, key):
   ...:         print('delitem....')
   ...:         del self.__dict__[key]
   ...:

In [2]: stu = Student('kate')

In [3]: stu.name
Out[3]: 'kate'

In [4]: stu['name']
getitem...
Out[4]: 'kate'

In [5]: stu['age']
getitem...

In [6]: stu['age'] = 18
setitem.... 18

In [7]: stu['age']
getitem...
Out[7]: 18

In [8]: del stu['age']
delitem....

In [9]: stu.__dict__
Out[9]: {'name': 'kate'}

str

类中定义__str__之后，会在打印print的时候，自动触发对应的方法，获得该方法的返回值进行输出，所以str方法必须有返回值，且必须是字符串类型。目前在数据库表中使用过，So，需要学会使用~

In [10]: class Student:
    ...:
    ...:     def __init__(self, name):
    ...:         self.name = name
    ...:
    ...:     def __str__(self):
    ...:         print('__str__ method')
    ...:         return self.name
    ...:

In [11]: stu = Student('kate')

In [12]: print(stu)
__str__ method
kate

iter

iter方法比较常用，在python中实现了__iter__方法的对象是可迭代的。实际上要想让一个迭代器工作，至少要实现__iter__方法和next方法。

In [20]: class Test():
    ...:     def __init__(self,data):
    ...:         self.data = data
    ...:
    ...:     def __iter__(self):
    ...:         return self
    ...:     def __next__(self):
    ...:         if self.data > 5:
    ...:             raise StopIteration
    ...:         else:
    ...:             self.data+=1
    ...:             return self.data
    ...:

In [21]: t = Test(3)

In [22]: t
Out[22]: <__main__.Test at 0x1d9198679e8>

In [23]: for i in t:
    ...:     print(i)
    ...:
4
5
6

del

1.了解del之前，希望大家可以回一下自己在文件操作的时候，是不是需要打开文件之后必须要关闭文件啊!不想自己的关闭的时候，可以指定使用with语句进行关闭，但是这里就出现了一个问题，程序运行结束打开的文件是不是关闭了？？

2.已经引出del的作用了，del是实现回收操作系统资源，打开文件是操作系统打开文件，并不是自己的英语程序打开，想一下软件是运行在操作系统上的，操作系统建立在硬件的基础之上，获得f文件句柄是是应用程序的变量，记住，文件句柄f是应用程序的一个变量，指向的是操作系统的打开文件的资源，调用read函数的时候，是去操作系统的内存取数据，完了，晕了晕了，可自行百度一下~~

3.就算del不实现，在程序结束的时候，程序也会自动的时间回收系统资源。在这里瞬间让我想到了numpy中创建一个空数组的时候，会出现非0的空数组，里面包含的资源就是遗留的内存数据~~

doc

doc方法是创建类的时候，书写注释之后就可以自动触发该方法执行，并且在这里面可以看到对应的注释内容。

call

调用对象的时候，在实例化的对象的后面加上括号，自动触发call执行。还记的怎么触发init方法执行不，是不是实例化对象的时候触发执行~

In [24]: class School:
    ...:
    ...:     def __init__(self):
    ...:         print('init....')
    ...:
    ...:     def __call__(self, *args, **kwargs):
    ...:         print('call....')
    ...:
    ...:

In [25]: s = School()
init....

In [26]: s()
call....

单例模式

1.单例模式，需要好好地掌握，在程序的设计模式中存在，在实际的使用中会使用，我推荐两种实现单例模式的方法。

2.第一种实现单例模式，在类模块中直接实例化成为一个对象，在其他模块引入调用的时候，直接调用已经实例化的对象即可，此时就实现了调用的单例模式。

3.在类的内部进行是否已经有实例化的判断，如果已经实例化，就需要将之前的实例化对象返回即可。

4.单例模式的优点，将参数相同的属性在内存中指向同一个地方，优化的策略。

5.简单实现单例模式，类内部判断方法

In [34]: class Mysql:
    ...:     __instance = None
    ...:
    ...:     def __init__(self):
    ...:         self.host = '127.0.0.1'
    ...:         self.port = 3306
    ...:
    ...:     @classmethod
    ...:     def singleton(cls):
    ...:         if not cls.__instance:
    ...:             mysql = cls()
    ...:             cls.__instance = mysql
    ...:         return cls.__instance
    ...:

In [35]: m = Mysql.singleton()

In [36]: n = Mysql.singleton()

In [37]: m
Out[37]: <__main__.Mysql at 0x1d919a8fda0>

In [38]: n
Out[38]: <__main__.Mysql at 0x1d919a8fda0>

元类

终于来到面向对象的高阶中的顶级了~~~让我们一起，看看类的祖宗~

1.需要了解的东西，元类，顾名思义就是说产生类的类都是元类，其实就是type~

2.此时我们就可以得到定义类的两种方式: 使用class 或者 使用元类

3.使用元类定义类的三要素:** 类名 继承类 命名空间**
类名: 当然是自己起什么就是什么了
继承类: 没有多继承，那** object 还是需要继承的**
命名空间: 这个就需要自己结合之前学过一个**内置函数 exec() ** ，这个函数的执行会产生相应的局部命名空间与全局命名空间。

4.尝试使用元类定义一个类~，看下面的例子:
注意: 使用exec的时候，如果不将exec内部书写的字符串数据定格书写会报错的，语法不能解析~~~

In [41]: # 定义类的三要素:类名，类的基类们，类的名称空间
    ...: class_name = 'Chinese'
    ...: class_bases = (object,)
    ...:
    ...: class_body = """
    ...: country='China'
    ...:
    ...: def __init__(self, name):
    ...:     self.name=name
    ...:
    ...: def area(self):
    ...:  print('%s is area' % self.name)
    ...: """
    ...:
    ...: class_dic = {}
    ...: exec(class_body, globals(), class_dic)  # Execute the given source in the context o
    ...: f globals and locals.
    ...:
    ...: Chinese = type(class_name, class_bases, class_dic)  # 元类type定义类，type(name, ba
    ...: ses, dict) -> a new type
    ...:

In [42]: obj1 = Chinese('kate')

In [43]: obj1.name
Out[43]: 'kate'

In [44]: obj1
Out[44]: <__main__.Chinese at 0x1d919881be0>

元类控制类的行为

使用元类控制类的行为，包括控制类的创建行为，与实例化行为。

1.控制创建行为可以实现， 创建的类必须首字母大写， 必须写注释。。。。，并且可以直接在Mymeta类中添加属性，子类直接可以进行调用。

In [49]: class Mymeta(type):
    ...:     def __init__(self, class_name, class_bases, class_dic):
    ...:         self.country = 'china'
    ...:
    ...:         if '__doc__' not in class_dic or not class_dic.get('__doc__').strip():
    ...:             raise TypeError('必须为类指定文档注释')
    ...:
    ...:         if not class_name.istitle():
    ...:             raise TypeError('类名首字母必须大写')
    ...:
    ...:         super(Mymeta, self).__init__(class_name, class_bases, class_dic)
    ...:
    ...:
    ...: class Student(object, metaclass=Mymeta):
    ...:     """
    ...:     Student class
    ...:     """
    ...:     def __init__(self, name, age):
    ...:         self.name = name
    ...:         self.age = age
    ...:
    ...:
    ...: stu = Student('kate', 18)
    ...:

In [50]: stu.__dict__
Out[50]: {'name': 'kate', 'age': 18}

2.控制类的实例化行为， 使用的是 触发__call__方法，这个时候就自己创建一个空对象，并调用init函数，返回对象，实现自动触发init执行的内容。

In [49]: class Mymeta(type):
    ...:     def __init__(self, class_name, class_bases, class_dic):
    ...:         self.country = 'china'
    ...:
    ...:         if '__doc__' not in class_dic or not class_dic.get('__doc__').strip():
    ...:
    ...:         if not class_name.istitle():
    ...:             raise TypeError('类名首字母必须大写')
    ...:
    ...:         super(Mymeta, self).__init__(class_name, class_bases, class_dic)
    ...:
    ...:     def __call__(self, *args, **kwargs):
    ...:         obj = object.__new__(self)  # 实例化Student，产生空对象obj
    ...:         self.__init__(obj, *args, **kwargs)  # 调用Student下的函数__init__，初始化o
    ...: bj
    ...:         return obj  # 返回初始化好了的obj
    ...:
    ...:
    ...: class Student(object, metaclass=Mymeta):
    ...:     """
    ...:     Student class
    ...:     """
    ...:
    ...:     def __init__(self, name, age):
    ...:         self.name = name
    ...:         self.age = age
    ...:
    ...:
    ...: stu = Student('kate', 18)

In [52]: stu.__dict__
Out[52]: {'name': 'kate', 'age': 18}

结束语

结束了面向对象的内容，长出一口气，又陷入了新的迷茫~
面向对象的内容，远不止我所述的这些，还有很多，尤其是面向对象的思想，Python的一切皆对象，底层的很多杠杠方法，我个人觉得，学习重在思考与实践与总结。
希望大家阅读愉快~