OPP

Posted 2021-01-18 -hjj

面向对象编程

  object(对象) 

什么是对象

 对象是指现实中的物体或实体

什么是面向对象

 把一切看成对象(实例), 让对象和对象之建立关联关系

对象都有什么特征

  对象有很多属性(名词)
   姓名, 年龄, 性别, 
 对象有很多行为(动作,动词)
   学习,吃饭,睡觉,踢球, 工作

什么是类: class

  拥有相同属性和行为的对象分为一组,即为一个类
  类是用来描述对象的工具,用类可以创建同类对象

类的创建语句:

  语法:
     class 类名(继承列表):
          '''类的文档字符串'''
           实例方法定义(类内的函数称为方法method)
           类变量定义
          类方法定义
          静态方法定义
     作用:
     创建一个类
      用于描述此类对象的行为和属性
      类用于创建此类的一个或多个对象(实例)

示例:

 class Dog:
  pass

构造函数

 表达式:
 类名([创建传参列表])
作用:
    创建这个类的实例对象,并返回此实例对象的引用关系

实例(对象)说明

     实例有自己的作用域和名字空间,可以为该实例添加实例变量(属性)
  实例可以调用类方法和实例方法
     实例可以访问类变量和实例变量
示例:
     class Dog:
          pass
     dog1 = Dog()

实例方法:

 语法:
  class 类名(继承列表):
       def 实例方法名(self, 参数1, 参数2, ...):
          '''实例方法的文档字符串'''
          语句块
 作用:
  用于描述一个对象的行为,让此类型的全部对象都拥有相同的行为
说明:
 实例方法实质是函数,是定义在类内的函数
 实例方法至少有一个形参,第一个形参代表调用这个方法的实例,一般命名为'self'

  实例方法的调用语法:
      实例.实例方法名(调用传参)
      或
         类名.实例方法名(实例, 调用传参)

属性 attribute(也叫实例变量)

每个实例都可以有自己的变量,此变量称为实例变量(也叫属性)

属性的使用语法:

实例.属性名

赋值规则:

 首次为属性赋值则创建此属性
 再次为属性赋值则必变属性的绑定关系
作用:
    用来记录对象自身的数据

删除属性

用del语句可以删除一个对象的实例变量

语法:
 del 对象.实例变量名
 示例:
  class Cat:
       pass

  c1 = Cat()  # 创建变量
  c1.color = "白色"  # 添加属性 
  print(c1.color)   # 白色
 del c1.color     # 删除属性
print(c1.color)  # 属性错误

初始化方法

作用:
 对新创建的对象添加实例变量(属性)或相应的资源  
 语法格式:
 class 类名(继承列表):
        def __init__(self [,形参列表]): 
            语句块
说明:
  1. 初始化方法名必须为__init__ 不可改变
   2. 初始化方法会在构造函数创建实例后自动调用,且将实例自身通过第一个参数    self传入__init__方法
  3. 构造函数的实参将通过__init__方法的形参列表传入 __init__ 方法中
  4. 初始化方法内部如果需要返回则只能返回None

析构方法

  语法:
      class 类名(继承列表):
          def __del__(self):
             语句块
     说明:
     析构方法在对象销毁时被自动调用
    作用:
        清理此对象所占用的资源

预置实例属性

 __dict__ 属性
    此属性绑定一个存储此实例自身实例变量(属性)的字典

 示例:
 class Dog:
       pass
 dog1 = Dog()
 print(dog1.__dict__)
 dog1.kinds = '京巴'
 print(dog1.__dict__)

class 属性

    此属性用来绑定创建此实例的类
 作用:
      可以借助此属性来访问创建此实例的类
示例:
 class Dog:
      pass
    dog1 = Dog()
 dog2 = Dog()
 dog3 = dog1.__class__()  # 创建dog1的同类对象

类变量 class variable(也叫类属性)

类变量是类的属性,此属性属于类

 作用:
    用来记录类相关的数据

说明:

 类变量可以通过类直接访问
 类变量可以通过类的实例直接访问
 类变量可以通过此类的实例的__class__属性间接访问
 示例:
 class Human:
       count = 0  # 创建类变量

继承/派生的名词

  基类(base class), 超类(super class), 父类(father class)
    派生类(derived class) / 子类(child class)

单继承

 语法:
 class 类名(基类名):
     语句块
说明
 单继承是指派生类由一个基类衍生出来的类

继承说明:

  任何类都直接或间接的继承自object类
 object类是一切类的超类(祖类)

类的__base__ 属性

 __base__属性用来记录此类的基类

用于类的函数

issubclass(cls, class_or_tuple)   判断一个类是否继承自其它的类,如果此类cls是class或     tuple中的一个派生子类则返回True,否则返回False

示例:
     class A:
       pass
    class B(A):
        pass
    class C(B):
          pass
    issubclass(C, (A, B))  # True
     issubclass(C, (int, str)) # False

封装 enclosure

 封装是指隐藏类的实现细节,让使用者不用关心这些细节
 封装的目的是让使用者尽可能少的实例变量(属性)进行操作

私有属性:

python类中,以双下划线'__'开头,不以双下划线结尾的标识符为私有成员,在类的外部无   法直接访问


函数重写 override
  重写是在自定义的类内添加相应的方法,让自定义的类生成的对象(实例)像内建对象一样进行内建的函数操作

数值转换函数的重写

 def __complex__(self)   complex(obj) 函数调用
def __int__(self)       int(obj) 函数调用
 def __float__(self)     float(obj) 函数调用
 def __bool__(self)      bool(obj) 函数调用

内建函数的重写

__abs__        abs(obj)
__len__        len(obj)
__reversed__   reversed(obj)
 __round__      round(obj)

布尔测试函数的重写

 格式 def __bool__(self):
     ...
作用:
  用于bool(obj) 函数取值
 用于if语句真值表达式中
 用于while语句真值表达式中
 说明:
  1. 优先调用__bool__方法取值
 2. 如果不存在__bool__方激动 ,则用__len__()方法取值后判断是否为零值,如果不为零 返回True,否则返回False
  3. 如果再没有__len__方法,则直接返回True

迭代器(高级)

 什么是迭代器
 可以通过next(it) 函数取值的对象就是迭代器
迭代器协议:
    迭代器协议是指对象能够使用next函数获取下一项数据,在没有下一项数据时触发  一个StopIterator来终止迭代的约定
实现方法:
 类内需要有 __next__(self) 方法来实现迭代器协议
 语法形式:
 class MyIterator
      def __next__(self):
           迭代器协议的实现
          return 数据

什么是可迭代对象

     是指能用iter(obj) 函数返回迭代器的对象(实例)
     可迭代对象内部一定要定义__iter__(self)方法来返回迭代器

可迭代对象的语法形式:

 class MyIterable:
      def __iter__(self):
            语句块
           return 迭代器

异常(高级)

 回顾异常相关的语句:
  try-except    用来捕获异常通知
     try-finally   用来做一定要做的事情
     raise         用来发生异常通知
     assert  用来根据条件来发出AssertionError类型的异常通知

with 语句

 语法:
 with 表达式1 [as 变量1], 表达式2 [as 变量2]:
     语句块
 作用:
 使用于对资源进行访问的场合,确保使用过程中不管是否发生异常,都会执行必须的'清    理'操作,并释放资源
     如: 文件使用后自动关闭, 线程中锁的自动获取和释放等

 说明:
 能够用于with语句进行管理的对象必须是环境管理器

环境管理器:

 1. 类内有__enter__ 和 __exit__实例方法的类被称为环境管理器
 2. 够用with语句管理的对象必须是环境管理器
 3. __enter__方法将在进入with语句时被调用,并返回由 as变量管理的对象
 4. __exit__将在离开with语句时被调用,且可以用参数来判断在离开with语句时是否有   异常发生并做出相应的处理

示例:
     class A:
        def __enter__(self):
         print("已进入with语句")
         return self  # 返回的对象将由 as绑定
        def __exit__(self, exc_type, exc_val, exc_tb):
         print("已离开with语句")

对象的属性管理函数:

    1. getattr(obj, name[, default])  从一个对象得到对象的属性；getattr(x, 'y') 等同于x.y; 当    属性不存在时,如果给
出default参数,则返回default,如果没有给出default 则产生一个AttributeError错误
    2. hasattr(obj, name)  用给定的name返回对象obj是否有此属性,此种做法可以避免在  getattr(obj, name)时引发错误
    3. setattr(obj, name, value)   给对象obj的名为name的属性设置相应的值value, set(x,  'y', v) 等同于 x.y = v
     4. delattr(obj, name)  删除对象obj中的name属性, delattr(x, 'y') 等同于 del x.y

运算符重载

什么是运算符重载
 让自定义的类生成的对象(实例)能够使用运算符进行操作

作用:
 让自定义的类的实例像内建对象一样运行运算符操作
    让程序简洁易读
    对自定义的对象,将运算符赋予新的运算规则

算术运算符的重载:

 __add__(self, rhs)        self + rhs   加法
 __sub__(self, rhs)        self - rhs   减法
 __mul__(self, rhs)        self * rhs   乘法
__truediv__(self, rhs)    self / rhs   除法
 __floordiv__(self, rhs)   self // rhs  地板除法
 __mod__(self, rhs)        self % rhs   求余
__pow__(self, rhs)        self ** rhs  冪

 注: rhs (right hands side)  右手边

反向算术运算符的重载

当左手边的类型为内建类型,右手边为自定义类型时,要实现运算必须用以下方法重载

反向算术运算符的重载:

__radd__(self, lhs)        lhs + self   加法
__rsub__(self, lhs)        lhs - self   减法
__rmul__(self, lhs)        lhs * self   乘法
__rtruediv__(self, lhs)    lhs / self   除法
 __rfloordiv__(self, lhs)   lhs // self  地板除法
 __rmod__(self, lhs)        lhs % self   求余
 __rpow__(self, lhs)        lhs ** self  冪

复合赋值算术运算符的重载

__iadd__(self, rhs)        self += rhs   加法
 __isub__(self, rhs)        self -= rhs   减法
 __imul__(self, rhs)        self *= rhs   乘法
 __itruediv__(self, rhs)    self /= rhs   除法
 __ifloordiv__(self, rhs)   self //= rhs  地板除法
 __imod__(self, rhs)        self %= rhs   求余
__ipow__(self, rhs)        self **= rhs  冪

比较运算符的重载

__lt__(self, rhs)     self <  rhs   小于
 __le__(self, rhs)     self <= rhs   小于等于
__gt__(self, rhs)     self >  rhs   大于
 __ge__(self, rhs)     self >= rhs   大于等于
 __eq__(self, rhs)     self == rhs   等于
__ne__(self, rhs)     self != rhs   不等于

注:
     比较运算符通常返回True或False

位运算符重载

__invert__(self)       　 ~ self   　　　　取反(一元运算符)
__and__(self, rhs)       self & 　rhs  位与
__or__(self, rhs)        self | 　rhs  位或
__xor__(self, rhs)       self ^ 　rhs  位异或
__lshift__(self, rhs)    self << rhs  左移
__rshift__(self, rhs)    self >> rhs  右移

反向位运算符重载

__rand__(self, lhs)       lhs & 　self  位与
 __ror__(self, lhs)        lhs | 　self  位或
__rxor__(self, lhs)       lhs ^ 　self  位异或
__rlshift__(self, lhs)    lhs << self  左移
__rrshift__(self, lhs)    lhs >> self  右移

复合赋值位运算符重载

__iand__(self, rhs)       self &= 　rhs  位与
__ior__(self, rhs)        self |= 　rhs  位或
 __ixor__(self, rhs)       self ^= 　rhs  位异或
__ilshift__(self, rhs)    self <<= rhs  左移
__irshift__(self, rhs)    self >>= rhs  右移

一元运算符的重载

 __neg__(self)        - self   负号
__pos__(self)　　　　　　　　+ self   正号
__invert__(self)     ~ self   取反

一元运算符的重载方法:

     class 类名:
         def __xxx__(self):
          ...

运算符重载说明:

    运算符重载不能改变运算符的优先级

索引和切片运算符的重载

__getitem__(self, i)      x = self[i] 索引/切片取值
__setitem__(self, i, v)   self[i] = v 索引/切片赋值
__delitem__(self, i)      del self[i] del语句删除索引等

作用:
    让自定义的类型的对象能够支持索引和切片操作

slice 构造函数

作用:
    用于创建一个Slice切片对象, 此对象存储一个切片的起始值，终止值和步长信息
slice(start, stop=None, step=None)  创建一个切片对象

 slice的对象的属性:
s.start  切片起始值,默认为None
    s.stop   切片终止值,默认为None
    s.step   切片步长  ,默认为None