开发技术--面向对象

开发|面向对象

面向对象的学习,可以让我们的代码趋于模块化,规范化,尤其是引入设计模式之后,面向对象的优点就更加明显~~
希望大家在实际使用中多使用面向对象的思想,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的一切皆对象,底层的很多杠杠方法,我个人觉得,学习重在思考与实践与总结。
希望大家阅读愉快~

posted @ 2019-07-25 13:13 Kate_liu 阅读(...) 评论(...) 编辑 收藏