目录

• 面向对象知识点回顾整理
  • 一、面向对象基础
    • 1、类和对象
    • 2、属性查找：
    • 3、绑定方法：
    • 4、对象之间的交互：
    • 5、类的内置属性
    • 6、三大特性：继承、多态、封装
  • 二、面向对象高阶
    • 元类
    • 单例模式

面向对象知识点回顾整理

一、面向对象基础

面向对象编程的核心是对象二字，对象是属性与方法的结合体，python中一切皆对象。

优点：可扩展性强

缺点：编程的复杂度高

1、类和对象

对象：属性和方法的结合体

类：一堆属性和方法的结合体

python中是先有类再有对象，现实生活中是先有对象再有类

类名()就是类的实例化可以产生对象

class Person:
    school = 'xxx'
    def __init__(self):  # 对象初始化方法，对象的绑定方法，对象来调用会把对象传过来
        self.name = 'xxx'
p = Person()  # 类实例化产生对象会调用类的__init__方法

2、属性查找：

• 数据属性：对象自身中找---》类中---》父类（按照mro列表查找）---》object---》没有就报错
• 方法查找：对象的绑定方法---》父类中按照mro列表查找---》object---》没有就报错

3、绑定方法：

• 定义在类内部，没有被任何装饰器装饰的函数，就是方法
• 给对象来用：对象 . 方法() 默认把对象自身传过去
• 类来调用就是普通函数，有几个值就传几个值

4、对象之间的交互：

• 把一个对象传到另一个对象中，操作这个对象 ----之前写的人狗大战例子

5、类的内置属性

? --类名.__name__: 类的名字(字符串)

? --类名.__doc__: 类的文档字符串

? --类名.__bases__：类的所有父类

? --类名.__base__：类的第一个父类

? --类名.__dict__：类的名称空间字典（包含属性和方法）

? --类名.__module__：类定义所在的模块

? --类名.__class__：实例对应的类（仅新式类中有）

6、三大特性：继承、多态、封装

? --继承：

? --在类名后的括号中写要继承的类，用逗号分隔

? --py中支持多继承（属性查找顺序）

? --新式类和经典类

? --继承了object的类都叫新式类（py3中都是新式类）

? --py2中才有新式类，经典类的说法

? --菱形问题的查找顺序

? --新式类：广度优先

? --经典类：深度优先

? --mro列表

? --super() 特殊对象，调用父类的属性和方法（严格按照mro列表查找）

? --self和super的区别：self一定是从根本上找，super() 从当前位置按照mro列表查找

? --类名 . 方法() 就是个普通函数，这个就不按照mro列表查找，而是指名道姓的使用

? --派生：子类多出来的属性和方法

? --多态和多态性

? -- 多态：一个事物有多种形态

? -- 多态性：执行同一个事物的同一个方法，表现出来的结果是不一样的

? -- 两种限制子类必须实现什么方法的方式

? -- 一个abc模块

? -- raise抛异常

? -- 鸭子类型：走路像鸭子，你就是鸭子

? -- len() 其实就是调用对象.__len__()

? --封装

? -- 把属性和方法隐藏

? --以__开头，就会隐藏

? -- 并没有实际隐藏（做了变性）

? -- 隐藏属性：保证数据安全

? -- 隐藏方法：隔离复杂度

? -- property 装饰器：把类包装成数据属性

? -- 其他两个装饰器

? -- classmethod：类的绑定方法，可以类来调用会自动把类传入（对象也可以调用）

? -- staticmethod：静态方法，谁都可以调用，不会自动传参数

?

二、面向对象高阶

元类

• 元类的概念：因为一切皆对象，类也是对象，元类构造类，因此能够实例化得到类的类就是元类
• type是最顶层的元类
• py3中所有类都是继承自object（包括元类type也是继承pbject的）
• object类是由元类type创建的，而type类也是由元类type创建的
• 自定义元类：继承了type的类，都叫元类，因此我们可以自定义元类（class Person(metaclass=Mymeta)就是指定我自定义的元类

• class Mymeta(type):
      # 通过重写__call__来控制对象的产生
          def __call__(self,*args,**kwargs):
          # 这个会在类加括号（实例化产生对象）的时候触发，用来控制对象的创建
          # 第一步：调用Person类的__new__方法，来产生一个空对象
          # obj=object.__new__(self)
          obj = self.__new__(self) # 推荐使用这种方式来创造空对象，以为这种方式会检索类和类的父类，而object.__new__则是直接跨过了他们三个
          # 第二步：调用Person类的__init__,完成对象初始化
          obj.__init__(*args,**kwargs)
          # 这里写初始化对象的语句
          # 第三步：返回初始化好的对象
          return obj
          pass
  
      def __new__(cls,name,bases,dic):
          # 控制类的产生
          # 产生空对象(空类)，在这里面生成的其实并不是空类，是有数据的类了
          # 这里写修改类的名称空间的代码，通过修改dic来控制产生的类的名称空间
  
          _class=type.__new__(cls,name,bases,dic) # 完成类的初始化，并且把name,bases,dic这些东西放入
          return _class  # 把产生的类返回出来
          pass
     # Mymeta(name,bases,dic)实例化产生类，会调用type的__call__,内部调用Mymeta的__new__和__init__，
  
     def __init__(self):
          # 控制类的初始化
          pass     
  
  class Person(metaclass=Mymeta):
          pass

• __new__和__init__的区别

  1、__new__创建空对象（类也是对象）

  2、__init__初始化对象

• 元类中：

  1、重写自定义元类中__call__方法：控制自定义元类产生的类实例化产生的对象的创建

  2、重写自定义元类中__new__方法：控制类的产生的最根上，其实本质最根上也不是它，是元类type的__call__，但是我们没法修改type，所以只能重写自定义元类中__new__方法

  3、重写自定义元类中__init__方法：控制自定义元类实例化产生的类的创建，但是是在__new__之后。

• 有了元类之后的属性查找顺序

  对象层：先从对象自身找---》类中找---》父类中按mro列表找---》没有就报错

  类层：先从类本身中找---》父类中按mro列表找---》自定义元类中找---》元类type中找---》没有就报错

• issubclass和isinstance

  --issubclass():判断第一个类是不是第二个类的子类，返回结果是True或False

  --isinstance():判断第一个参数是不是第二个参数(类)的对象，返回结果是True或False

• 反射（通过字符串获取、修改、删除对象的属性或方法）

  -- hasattr()：判断一个属性是否在对象中，返回True或False hasattr(对象，属性)

  -- getattr()：通过字符串获取属性或方法，获取到就返回相应属性或方法 getattr(对象，属性或方法)

  -- setattr()：通过字符串设置属性或方法 setattr(对象，‘方法名‘，方法名)

  -- delattr()：通过字符串删除属性或方法 delattr(对象，属性或方法)

• 内置方法（魔法方法）

  点拦截方法：对象.方法就会触发

  ? -- __getattr__：对象加.获取值，一旦取不到就进入该方法

  ? -- __setattr__：对象加.赋值，一旦取不到就进入该方法

  ? -- __delattr__：对象加.删除值，会进入该方法

单例模式

• 概念：多次实例化指向的都是同一块内存地址，拿到的都是同一个对象
• 优点：节约空间
• 四种实现单例模式的方法
• 1、定义一个类的绑定方法实现单例模式

  2、定义一个装饰器实现单例模式

  3、定义一个元类实现单例模式

  4、通过模块导入实现单例模式（python的模块是天然的单例）

原文地址：https://www.cnblogs.com/zhuangyl23/p/11503338.html