神刀安全网

Python全栈开发之9、面向对象、元类以及单例

前面一系列博文讲解的都是面向过程的编程,如今是时候来一波面向对象的讲解了

一、简介

面向对象编程是一种编程方式,使用 “类” 和 “对象” 来实现,所以,面向对象编程其实就是对 “类” 和 “对象” 的使用。类就是一个模板,模板里可以包含多个方法(函数),方法里实现各种各样的功能,,对象则是根据模板创建的实例,通过实例,对象可以执行类中的方法,每个对象都拥有相同的方法,但各自的数据可能不同。

二、类、对象和方法

在Python中,定义类是通过 class 关键字, class 后面紧接着是类名,类名通常是大写开头的单词,紧接着是 ('要继承的类名') ,表示该类是从哪个类继承下来的,通常如果没有合适的继承类,就使用 object 类,这是所有类最终都会继承的类,也可以不写。

class MyClass():             # 创建类     def func(self):          # 定义方法         pass  obj1=MyClass()               # 根据MyClass创建对象

类中定义方法的时候,和以前定义函数一样,都是用来实现某种功能的,不过定义方法的时候必须传至少一个参数(self),代表创建的对象,而函数则不需要,下面来看一下self具体指的什么。

class MyClass():     def func(self,str):         print(self,str)      def func1(self,str):         pass obj1=MyClass()          # self 哪个对象调用的,self就是那个对象  obi <====> self print(obj1)             # <__main__.MyClass object at 0x000002C2119AD4A8> obj1.func('jason')      # <__main__.MyClass object at 0x000002C2119AD4A8>

从上面打印出的数据可以看出,创建出来的obj1对象的地址值和func方法里面self的地址值一样,两者一致,说明self就是指代创建的对象,这里读者一定需要理解self指的是什么。

三、面向对象三大特性,封装、继承和多态。

1、封装

面向对象有3大特性,首先我们来说第一个特性,封装,封装一般是通过在类中封装数据,而通过对象或者self获取。和其他面向对象的语言类似,也是通过构造函数来进行数据封装。下面来看一下代码。

class A:     def __init__(self,name):        # 构造函数,初始化数据,         self.name=name              # 封装数据      def f1(self):         print(self.name)            # 通过self获取封装的数据  a=A('jason') a.f1()                              #通过对象获取封装数据

还有一种封装的方式,使用私用的属性来封装数据,看一下具体的用法,

class A:     name='Jason'     __age=18                        # 私有静态字段,     def __init__(self):         self.__like='soccer'        # 私有普通字段         self.hobby='kkkk'      def f1(self):         print(self.__age)         # 私有静态字段,私有普通字段只能被类中的方法调用         print(self.__like) # A.__age                         # 外部获取不到私有静态字段,数据被封装起来 a=A()                             # soccer a.f1()                            # 18 print(a.hobby)

2、继承

Python里面的继承可以多继承,通过继承,可以获得父类的功能,继承的时候,如果父类中有重复的方法,优先找自己,如果有下面关系,D继承B,E继承C,F继承D,E,则查找顺序,D->B->E->C,如果有下面关系,B继承A,C继承A,D继承B,E继承C,F继承D,E,则查找顺序,D->B->E->C-A,下面来看一下用法

class A:     def f(self):         print('a') class B:     def f(self):         print('b')      def f1(self):         print('bbbb')  class C(A,B):     def f1(self):         print('c') cc=C() cc.f()         # a cc.f1()        # c  #下面的是难点重点 class A:     def bar(self):         print('bar')         self.f1()  class B(A):     def f1(self):         print('b')  class C():     def f1(self):         print('c') class D(B):     def f1(self):         print('d')  class E(C,D):     pass  d=D() d.bar()             # d.bar().f1() 去哪里找f1?

除了继承方法,还可以继承父类的构造函数

# 继承构造方法 class A:     def __init__(self):         self.name='jason'  class B(A):     def __init__(self):         self.age='16'         super(B,self).__init__()         # A.__init__(self)          #另一种继承构造函数的方法  d=B()

3、多态

python本身就是支持多态的,所以在Python面向对象里面讨论多态并没有什么意义,这里也就不多讲了

四、类成员

类的成员可以分为三大类:字段、方法和属性,下面从代码来看一下用法

class A:      country = 'China'               # 静态字段,保存在类中 节省内存      def __init__(self, name):         self.name = name            # 普通字段,保存在对象中      def show(self):                 # 普通方法,保存在类中,对象通过类对象指针使用         print('普通方法')         return self.name      @staticmethod                   # 静态方法,保存在类中     def f1():                       # 没有 self 参数         print('静态方法')      @classmethod                    # 类方法 相当于静态方法加了一个类名参数     def f2(cls):                    # 将当前类名当作参数传进去         print('类方法')      @property                       # 属性或者叫特性,将普通方法伪装成字段,但是不能传入第二个参数     def f3(self):         print('属性')         return self.name      @f3.setter                      # 设置属性     def f3(self,value):         print(value)         self.name= value  a = A('jason') print(hasattr(A, 'name'))  # False print(hasattr(a, 'name'))  # True print(hasattr(a, 'show'))  # True print(hasattr(A, 'country'))  # True print(hasattr(a, 'country'))  # True  # 优先,自己先去访问自己的成员除了类中的方法  # 用下面的方式去操作 #      通过类去访问的有:静态字段,静态方法,类方法(静态方法加一个类名参数) #      通过对象访问的有:普通字段,普通方法 # 有 self,对象调用 # 无 self,类调用  A.f1()                             # 静态方法 a.show()                           # 普通方法 A.f2()                             # 类方法 a.f3                               # 属性,获取属性值 执行的时候不用加括号,和对象调用普通字段类似 a.f3='kobe'                        # 设置属性值,  print(A.country) print(a.name)  # 私有的只能在类中调用,不能再外部调用 class A:     name='Jason'     __age=18                        # 私有静态字段     def __init__(self):         self.__like='soccer'        # 私有普通字段         self.hobby='kkkk'      def f1(self):         print(self.__age)         # 私有静态字段,私有普通字段只能被类中的方法调用         print(self.__like) # A.__age                         # 外部获取不到私有静态字段 a=A()                             # soccer a.f1()

特殊成员,也不多说了,直接上代码了

class A:     def __init__(self):         print('init')         self.name='jason'      def __str__(self):         return '........'      def __call__(self, *args, **kwargs):         print('call')         return 1      def __getitem__(self, item):         print(item,type(item))      def __setitem__(self, key, value):         print(key,value)      def __delitem__(self, key):         print(key)      def __iter__(self):         yield 1         yield 2   a=A()             # init             类后面加个括号执行      __init__ a()               # call             对象后面加个括号执行    __call__ print(a)          # 执行 __str__方法 k=A()()           # init call k=1  a['dddd']                   # 执行 __getitem__                <class 'str'> a['name']='jason'           # 执行 __setitem__ del a['name']               # 执行 __delitem__   a[1:3]                   # py2__getslice__,py3执行 __getitem__  <class 'slice'> a[1:3]=[1,2]             # py2__setslice__,py3执行 __setitem__ del a[1:3]               # py2__detslice__,py3执行 __delitem__  print(a.__dict__)       # {'name': 'jason'} 对象里面的字段 print(A.__dict__)       # 类里面的字段  for i in a:             # 执行__iter__     print(i)

五、元类

在Python中一切事物都是对象,类也是对象,那么问题来了,类是如何创建的了,类的定义是运行时动态创建的,而创建class的方法就是使用 type() 函数,通过 type() 函数创建的类和直接写class是完全一样的,因为Python解释器遇到class定义时,仅仅是扫描一下class定义的语法,然后调用 type() 函数创建出class。type可以接受一个类的描述作为参数,然后返回一个类可以像这样使用: type (类名 , 父类的元组(针对继承的情况,可以为空),包含属性的字典(名称和值))

# 通过type自定义类 def f1(self):     print(self.name)  MyClass=type('MyClass',(),{'name':'jason','f1':f1}) print(MyClass,type(MyClass))                  # <class '__main__.MyClass'> ,<class 'type'> print(MyClass.name)                           # jason  my=MyClass() print(my.__class__)                           # <class '__main__.MyClass'> print(my)                                     # <__main__.MyClass object at 0x000001F3013751D0> my.f1()                                       # jason

说完了type,那么type和元类到底是什么关系了,type实际上是一个元类。type就是Python在背后用来创建所有类的元类,除了使用 type() 动态创建类以外,要控制类的创建行为就要用到metaclass(元类),我们想创建出类,那就根据metaclass创建出类,所以:先定义metaclass,然后创建类。连接起来就是:先定义metaclass,就可以创建类,最后创建实例。元类的一般作用是拦截类的创建,修改类, 返回修改之后的类。下面看一下代码的使用

# 用函数实现 # def upper_attr(future_class_name, future_class_parents, future_class_attrs): #     attrs=((name, value) for name,value in future_class_attrs.items() if not name.startswith('__')) #     uppercase_attr=dict((name.upper(), value) for name,value in attrs) #     return type(future_class_name,future_class_parents,uppercase_attr()) # # class A(): #     # __metaclass__ = upper_attr #     country="China" #     def __init__(self): #         self.name='jason' # # print(hasattr(A,'country')) # print(hasattr(A,'COUNTRY'))  ''' __new__()方法接收到的参数依次是:     当前准备创建的类的对象;     类的名字;     类继承的父类集合;     类的方法集合。  __new__ 是在__init__之前被调用的特殊方法 __new__是用来创建对象并返回之的方法 而__init__只是用来将传入的参数初始化给对象 你很少用到__new__,除非你希望能够控制对象的创建 这里,创建的对象是类,我们希望能够自定义它,所以我们这里改写__new__ 如果你希望的话,你也可以在__init__中做些事情 还有一些高级的用法会涉及到改写__call__特殊方法,但是我们这里不用  '''  class UppMetaclass(type):     def __new__(cls, name,base,attrs):         uppattrs = dict((k.upper(),v)for k,v in attrs.items() if not k.startswith('__'))         # return type.__new__(cls, name, base, uppattrs)         return super(UppMetaclass, cls).__new__(cls, name, base, uppattrs)  class A(metaclass=UppMetaclass):     # __metaclass__ = UppMetaclass     country="China"     def __init__(self):         self.name='jason'  print(hasattr(A,'country')) print(hasattr(A,'COUNTRY')) print(A.COUNTRY)

六、单例模式

单例,顾名思义单个实例,单利模式存在的目的是保证当前内存中仅存在单个实例,避免内存浪费,下面直接看一下怎么实现单例

class Instance:                    # 方法一      __instance=None                               # 私有静态字段      def __init__(self):         self.name='jason'         self.passwd='kkkkk'      @staticmethod     def get_instance():         if not Instance.__instance:              # 如果私有静态字段为空的话,创建一个实例             Instance.__instance = Instance()         return Instance.__instance               # 不为空的话,直接返回一个实例  obj1=Instance.get_instance()             # 执行静态方法,创建一个实例赋值给obj1 obj2=Instance.get_instance()             # 执行静态方法,将私有静态字段保存的对象赋值给obj2 print(obj1)                              # <__main__.Instance object at 0x0000021AEDF56048> print(obj2)                              # <__main__.Instance object at 0x0000021AEDF56048>  class Singleton():              # 方法二     def __new__(cls, *args, **kwargs):         if not hasattr(cls,'_instance'):             cls._instance=super(Singleton,cls).__new__(cls,*args, **kwargs)         return cls._instance  class A(Singleton):     pass a=A() b=A() print(a is b)  class Singleton(type):                # 方法三     def __call__(cls, *args, **kwargs):         if not hasattr(cls, '_instance'):             cls._instance = super(Singleton, cls).__call__(*args, **kwargs)         return cls._instance   class A(metaclass=Singleton):         # __metaclass__ = Singleton     pass a = A() b = A() print(a is b)

七、补充

属性的另一种表达方式:

class A:     def __init__(self):         self.mylist = [1, 2, 3, 4]      def getmylist(self):         print(self.mylist)      def setmylist(self, value):         self.mylist.append(value)         print(self.mylist)     def delmylist(self):         if len(self.mylist) > 0:             self.mylist.pop()         print(self.mylist)     my_pro_list = property(getmylist, setmylist, delmylist, 'Property')  a = A() a.my_pro_list a.my_pro_list = 7 del a.my_pro_list  '''     [1, 2, 3, 4]     [1, 2, 3, 4, 7]     [1, 2, 3, 4] '''

单利补充:

class SingMetaclass(type):     def __call__(self, *args, **kwargs):         if not hasattr(self, 'instance'):             # self.instance = super(SingMetaclass, cls).__new__(cls, name, base, attrs)             # self.instance = self.__new__(self, *args, **kwargs)   # 下面这种方式也行,但是没有注释掉的好理解             self.instance = super().__call__(*args, **kwargs)         return self.instance  class A(metaclass=SingMetaclass):     pass

py27继承顺序,有一种情况和py3不一样,如下图,其中bar没有继承object(经典类)、深度优先,其他情况一样,都是广度优先

Python全栈开发之9、面向对象、元类以及单例

# py27  class bar():     def f1(self):         print('bar')  class A(bar):     def f(self):         print('a')  class C(A):     def f(self):         print('c')  class B(bar):     def f1(self):         print('b')  class D(B):     def f1(self):         print('d')  class E(C,D):     def f(self):         print('e')  e = E() e.f1()

抽象类和抽象方法:

from abc import ABCMeta  from abc import abstractclassmethod   class Absclass(metaclass=ABCMeta):      # 抽象类+抽象方法,类似接口,约束类     @abstractclassmethod     def f1(self): pass      @abstractclassmethod     def f2(self): pass   class B(Absclass):        # B 需要完全实现抽象类中的抽象方法     def f1(self): pass      def f2(self): pass          # 如果 B 类中没有完全实现 Absclass 类中的方法话,可以编译过,但是执行的话会报错      def f3(self): pass   c = B()

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » Python全栈开发之9、面向对象、元类以及单例

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址