Python3: 面向对象

太过爱你忘了你带给我的痛 2021-09-21 22:36 367阅读 0赞

本文链接: [https://blog.csdn.net/xietansheng/article/details/115557427][https_blog.csdn.net_xietansheng_article_details_115557427]

[Python3 学习笔记（目录）][Python3]

## 1. 类的定义与实例化 ##

使用`class`关键字定义类，类名首字母通常为大写:

#! /usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    
    class 类名:
        """ 类的注释 """
        属性1 = 值1
        属性2 = 值2
        
        def 方法1(self):
            方法代码块
        
        def 方法2(self):
            方法代码块

类的定义与实例化代码示例:

#! /usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    
    class Person:
        """ 类注释 """
        name = None
        """ name属性的注释 """
    
        age = 0
        """ age属性的注释 """
    
        def hello(self):
            """ 类方法的注释 :return: 返回值说明 """
            print("name=" + self.name + ", age=" + str(self.age))
            return 0
    
        def fun(self, a):
            print("Add: " + str(self.age + a))
    
    
    p = Person()
    p.name = "Tom"
    p.age = 25
    p.hello()           # 输出: name=Tom, age=25
    p.fun(5)            # 输出: Add: 30

PS: 其中方法的第 1 个参数 self 表示调用该方法的对象本身，可以是任意合法的标识符，一般约定为 self。

## 2. 类的属性 ##

访问类的属性，通过`对象.属性名`的方式访问。

### 2.1 公开属性 与 私有属性 ###

类的属性默认为公开属性，在外部可以访问。类的私有属性使用两根下划线`__`开头定义（`__private_attrs`），私有属性只能在类的内部访问（`self.__private_attrs`）。

代码示例：

class Person:
        name = None         # 公开属性
        __age = 0           # 两根下划线开头的私有属性（只能在类内部访问）
    
        def __init__(self, name, age):
            """ 方法的第1个参数表示当前调用该方法的对象本身（默认传入, 调用构造方法时不需要传入） """
            self.name = name
            self.__age = age
    
        def hello(self):
            # 可以在类内部通过 self.__age 访问私有属性 __age
            print("name=" + self.name + ", age=" + str(self.__age))
    
    
    p = Person("Tom", 25)
    p.hello()
    
    # 外部不能访问私有属性, 运行时将会报错
    print(p.__age)

### 2.2 受保护（protected）的属性 ###

类的受保护（protected）的属性使用单根下划线`_`开头定义（`_protected_attrs`），protected 属性一般只在 **类的内部和子类中** 访问（`self._protected_attrs`）。实际上 protected 属性在类的外部也可以访问，这只是在语法上的暗示和隐喻，提醒在类的外部访问该属性时要保持慎重。

代码示例：

class Person:
        name = None         # 公开属性
        __age = 0           # 两根下划线开头的私有属性（只能在类内部访问）
        _gender = None      # 单根下划线开头的受保护属性（在类内部和子类中访问）

### 2.3 特殊属性 ###

类除了在 class 代码块中定义的属性外，还有一些其他默认定义的特殊属性，特殊属性的开头结尾均有两根下划线（`__attrs__`），可以直接通过 `对象.__attrs__`的形式访问。

常用的几个类的特殊属性：

*  `__class__`: (type) 对象的类
 *  `__module__`: (str) 类所在模块
 *  `__doc__`: (str) 类的描述
 *  `__dict__`: (dict) 对象的所有属性和值的字典形式

代码示例：

class Person:
        """ Person类的描述 """
        name = None
        __age = 0
    
        def __init__(self, name, age):
            self.name = name
            self.__age = age
    
    
    p = Person("Tom", 25)
    
    print(p.__class__)      # (type) 对象的类, 即 Person 本身, 结果: <class '__main__.Person'>
    print(p.__module__)     # (str) 类所在模块, 结果: __main__
    print(p.__doc__)        # (str) 类的描述, 结果: Person类的描述
    print(p.__dict__)       # (dict) 把对象的属性和值以字典的形式返回, 结果: {'name': 'Tom', '_Person__age': 25}
    
    
    #
    # Python 中一切皆对象, 类本身也是一个对象, 因此 Person 类对象也有相关的属性和方法
    #
    print(Person.__class__)     # 类对象的类是 type, 结果: <class 'type'>
    print(Person.__module__)    # 类所在模块, 结果: __main__
    print(Person.__doc__)       # 类的描述, 结果: Person类的描述
    print(Person.__dict__)      # Person 类的所有属性（包括许属性、方法等多项内容）
    
    # 可以通过类名直接访问类的属性, 修改其在实例化对象时的默认值
    Person.name = "Hello"

## 3. 类的方法 ##

### 3.1 构造方法 ###

类有一个名为`__init__()`的特殊方法，该方法为类的 **构造方法**，在类实例化（创建对象）的时候，该方法将被调用。

代码示例：

class Person:
        name = None
        age = 0
    
        def __init__(self, name, age):
            """ 方法的第1个参数表示当前调用该方法的对象本身（默认传入, 调用构造方法时不需要传递） """
            self.name = name
            self.age = age
    
        def hello(self):
            print("name=" + self.name + ", age=" + str(self.age))
    
    
    p = Person("Tom", 25)   # 创建对象, 对应的 __init__()方法将被调用
    p.hello()

### 3.2 公开方法 和 私有方法 ###

类的方法默认为公开方法，在外部可以访问。类的私有方法使用两根下划线`__`开头定义（`def __private_methods(...):`），私有方法只能在类的内部访问（`self.__private_methods()`）。

代码示例：

class Person:
        name = None
        age = 0
    
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def pub_fun(self):
            """ 公有方法, 可以在类的外部访问 """
            print("pub: " + self.name + ", " + str(self.age))
            self.__pri_fun()    # 类的内部访问私有方法
    
        def __pri_fun(self):
            """ 私有方法, 只能在类的内部访问: self.__pri_fun() """
            print("pri: " + self.name + ", " + str(self.age))
    
    
    p = Person("Tom", 25)
    p.pub_fun()             # 类的外部访问公有方法
    
    # 通过 “对象.方法名” 调用类的方法时, 默认自动把 对象 传递给 self,
    # 也可以通过 “类名.方法名” 把方法当做普通方法调用, 并手动把 对象 传递给 self
    Person.pub_fun(p)

### 3.3 受保护（protected）的方法 ###

类的受保护（protected）的方法使用单根下划线`_`开头定义（`def _protected_methods(...):`），protected 方法一般只在 **类的内部和子类中** 访问（`self._protected_methods()`）。实际上 protected 方法在类的外部也可以访问，这只是在语法上的暗示和隐喻，提醒在类的外部访问该方法时要保持慎重。

代码示例：

class Person:
        def _pro_fun(self):
            """ 受保护方法, 在类的内部和子类中访问: self._pro_fun() """
            pass

### 3.4 静态方法 与 类方法 ###

`静态方法`不需要实例化对象，直接通过`类名.方法名`调用，定义类方法需要在方法名上面添加装饰器`@staticmethod`，静态方法可以不需要任何参数。

`类方法`和静态方法类似，也不需要实例化对象，直接通过`类名.方法名`调用，定义类方法需要在方法名上添加装饰器`@classmethod`，类方法需要有第 1 个默认参数`cls`表示类本身。

代码示例：

class Demo:
    
        def __init__(self):
            pass
    
        @staticmethod                   # 静态方法使用 @staticmethod 装饰器
        def stat_fun(s):
            """ 静态方法没有默认的第 1 个参数, 直接通过 “类名.方法名” 调用 """
            print("静态方法, s=" + s)
    
        @classmethod                    # 类方法使用 @classmethod 装饰器
        def cls_fun(cls, s):
            """ 类方法直接通过 “类名.方法名” 调用, 第 1 个参数 cls 表示类本身, 即 Demo, 调用类方法时, 第 1 个参数不用手动传递（默认自动传递）。 """
            print("类方法: " + str(cls) + ", s=" + s)  # 类方法: <class '__main__.Demo'>, s=...
    
    
    Demo.stat_fun("hello")      # 调用静态方法
    Demo.cls_fun("world")       # 调用类方法

PS: 类方法的第 1 个表示类本身的参数 cls 可以是任意合法的标识符，一般约定为 cls。

### 3.5 特殊方法 ###

类有一些特殊方法，方法名开头结尾均有两根下划线（`__methods__(...)`），用于在某些运算或内置函数调用时被调用。

类的部分特殊方法：

#
    # 对象创建与回收
    #
    __init__(self, ...)                 # 构造方法, 创建对象时调用
    __del__(sel)                        # 析构方法, 释放对象时调用
    
    #
    # 比较运算
    #
    __eq__(self, other)                 # 返回 self == other
    __ne__(self, other)                 # 返回 self != other
    __ge__(self, other)                 # 返回 self >= other
    __gt__(self, other)                 # 返回 self > other
    __le__(self, other)                 # 返回 self <= other
    __lt__(self, other)                 # 返回 self < other
    
    #
    # 算数运算
    #
    __add__(self, other)                # 返回 self + other
    __sub__(self, other)                # 返回 self - other
    __mul__(self, other)                # 返回 self * other
    __truediv__(self, other)            # 返回 self / other
    __mod__(self, other)                # 返回 self % other
    __rfloordiv__(self, other)          # 返回 self // other
    __lshift__(self, other)             # 返回 self << other
    __rshift__(self, other)             # 返回 self >> other
    __pow__(self, power, modulo=None)   # 返回 self ** power
    
    __len__(self)                       # 返回 len(self)
    __str__(self)                       # 返回 str(self)
    __hash__(self)                      # 返回 hash(self)
    __sizeof__(self)                    # 返回 对象的在内存中占用的字节大小
    
    #
    # 索引和属性
    #
    __setitem__(self, key, value)       # 实现 self[key] = value
    __getitem__(self, item)             # 返回 self[key]
    
    __setattr__(self, key, value)       # 实现 setattr(self, name, value)
    __getattr__(self, item)             # 返回 getattr(self, name)
    __delattr__(self, item)             # 实现 delattr(self, name)
    
    
    #
    # 其他
    #
    __iter__(self)                      # 创建迭代器, 实现 iter(self)
    __next__(self)                      # 迭代的下一个元素, 实现 next(self)
    
    __repr__(self)                      # 返回 repr(self)
    __dir__(self)                       # dir(self) 的默认实现
    
    __call__(self, ...)         # 实现该方法使类的实例成为可调用对象, 即把对象当成方法调用, 
                                # 调用者为对象自己, 即以 “对象(...)” 的形式调用时将调用该方法。

PS：上面的特殊方法，有些有默认实现，有些需要在用到时自己在类中实现。

### 3.6 运算符重载 ###

运算符重载通过重写对应的特殊方法实现，代码示例：

class Point:
        x = 0
        y = 0
    
        def __init__(self, x, y):
            self.x = x
            self.y = y
    
        def __add__(self, other):
            """ 两个 Point 对象进行加法运算时调用该方法返回运算结果 """
            return Point(self.x + other.x, self.y + other.y)
    
        def __str__(self):
            """ 调用 str(obj) 内置方法时将调用该方法并返回结果 """
            return "(%d, %d)" % (self.x, self.y)
    
    
    p1 = Point(2, 3)
    p2 = Point(4, 5)
    
    p3 = p1 + p2        # 调用类的 __add__ 方法, 相当于: p3 = p1.__add__(p2)
    s = str(p3)         # 调用类的 __str__ 方法, 相当于: s = p3.__str__()
    
    print(s)            # 结果输出: (6, 8)

PS：类只有重载了运算符方法，其他实例对象才能进行相应运算，否则将报错。

## 4. 继承 ##

### 4.1 类的继承 与 方法重写 ###

Python 类继承与方法重写代码示例：

class BaseClassName:
        """ 一个普通的类（父类） """
        base_name1 = None
        base_name2 = None
    
        def __init__(self, base_name1, base_name2):
            self.base_name1 = base_name1
            self.base_name2 = base_name2
    
        def base_fun1(self, var1):                  # 父类方法
            print("base_fun1(): " + str(var1))
    
        def base_fun2(self, var1):
            print("base_fun2(): " + str(var1))      # 父类方法
    
    
    class SubClassName(BaseClassName):
        """ 一个普通的类（子类）, 继承 BaseClassName """
        sub_name1 = None
    
        def __init__(self, base_name1, base_name2, sub_name1):
            # 调用父类的构造方法, super() 表示引用父类;
            # 如果多继承, super().__init__(...) 调用的是继承的第 1 个父类的构造方法;
            # 父类构造方法可以不调用（逻辑上一般需要调用）。
            super().__init__(base_name1, base_name2)
            self.sub_name1 = sub_name1
    
        def sub_fun1(self, var1):                       # 子类方法
            print("sub_fun1(): " + str(var1))
    
        def base_fun1(self, var1):                      # 重写父类方法
            # super() 函数访问父类方法, 将从 类名.mro() 方法返回的继承类列表中,
            # 从当前类的下一个类开始依次查找需要访问方法, 找到后即调用。
        
            # 调用父类方法, 方式一
            # 其中 super(SubClassName, self) 表示 self 对象对应的 SubClassName 的父类引用
            # super(SubClassName, self).base_fun1(var1)
    
            # 调用父类方法, 方式二
            # 相当于 super(__class__, <first argument>), 其中 __class__ 在类范围内表示类本身
            super().base_fun1(var1)
    
            # 调用父类方法, 方式三
            # 直接使用父类的方法对象, 手动传递调用对象self
            # BaseClassName.base_fun1(self, var1)
    
        def base_fun2(self, a):                         # 重新父类方法
            print("base_fun2(): " + str(self.base_name1) + ", " + str(self.base_name2) + ", " + str(self.sub_name1))
    
    
    s = SubClassName("base_value1", "base_value2", "sub_value1")
    s.sub_fun1("hi_1")          # 输出: sub_fun1(): hi_1
    s.base_fun1("hi_2")         # 输出: base_fun1(): hi_2
    s.base_fun2("hi_3")         # 输出: base_fun2(): base_value1, base_value2, sub_value1

### 4.2 多继承 ###

Python 支持多继承，多继承代码示例：

class BaseClassName1:
        """ 一个普通的类（父类1） """
        base_name = "value1"
    
        def __init__(self):
            pass
    
        def base1_fun(self):                            # 父类方法
            print("base1_fun()")
    
        def base_fun(self):
            print("BaseClassName1.base_fun()")          # 父类方法
    
    
    class BaseClassName2:
        """ 一个普通的类（父类2） """
        def __init__(self):
            pass
    
        def base2_fun(self):                            # 父类方法
            print("base2_fun()")
    
        def base_fun(self):                             # 父类方法
            print("BaseClassName2.base_fun()")
    
    
    class SubClassName(BaseClassName1, BaseClassName2):
        """ 一个普通的类（子类）, 继承 BaseClassName1, BaseClassName2 """
        def __init__(self):
            BaseClassName1.__init__(self)               # 调用 父类1 的构造方法
            BaseClassName2.__init__(self)               # 调用 父类2 的构造方法
    
        def sub_fun(self):                              # 子类方法
            print("sub_fun()")
    
        def base_fun(self):                             # 重写父类（同名）方法
            # 访问父类的属性, 父类属性已被子类继承,
            # 直接使用 self 访问父类属性
            print(self.base_name)                       # 输出:value1
    
            # 调用父类方法, super() 将从 类名.mro() 方法返回的继承类列表中,
            # 从当前类的下一个类开始依次查找需要访问的方法, 找到后即调用
            super().base_fun()                          # 输出: BaseClassName1.base_fun()
    
            # 父类有同名方法, 可以通过父类名访问指定的父类方法
            BaseClassName2.base_fun(self)               # 输出: BaseClassName2.base_fun()
    
    
    s = SubClassName()
    
    s.sub_fun()         # 输出: sub_fun()
    s.base1_fun()       # 输出: base1_fun()
    s.base2_fun()       # 输出: base2_fun()
    
    s.base_fun()        # 如果调用的方法不在子类中, 将从继承的父类列表中从左到右依次查找

### 4.3 抽象类 ###

抽象类的定义需要使用`abc`模块，代码示例：

import abc
    
    
    class AbsClassName(metaclass=abc.ABCMeta):  # 使用 metaclass=abc.ABCMeta 标注该类为抽象类
        def __init__(self):
            """ 抽象类不能直接实例化, 必须子类继承后实例化子类 """
            pass
    
        @abc.abstractmethod                     # 使用装饰器 @abc.abstractmethod 标注该方法为抽象方法
        def abs_fun(self):
            """ 抽象方法在抽象类中不需要实现, 在子类中必须实现 """
            pass
    
    
    class Demo(AbsClassName):
        def abs_fun(self):                      # 实现抽象父类的抽象方法
            print("abs_fun()")
    
    
    d = Demo()
    d.abs_fun()         # 输出: abs_fun()

### 4.4 获取类的信息（父类、继承关系、类属性和方法） ###

**对象的类型判断**：

# 返回对象 obj 的类型, 即 obj.__class__
    type(obj)
    
    # 判断对象 obj 是否是类型 cls 的实例（支持继承）, 返回 True/False
    isinstance(obj, cls)

**类继承关系判断**：

# 判断类型 sub_cls 是否为类型 base_cls 的子类, 返回 True/False（类型相同返回 True）
    issubclass(sub_cls, base_cls)

**类类型的几个属性/方法**（直接通过`类名.属性名/方法名`访问）：

*  `mro()`: (list) 返回以类本身，以及类的所有直接和间接继承过的父类组成的列表
 *  `__bases__`: (tupe) 类直接继承的所有父类（不包括间接继承的）
 *  `__class__`: (type) 类的类型，类的类型均为 type
 *  `__name__`: (str) 类的名称
 *  `__module__`: (str) 类所在模块
 *  `__doc__`: (str) 类的描述
 *  `__dict__`: (dict) 以类(不包括父类)的所有属性和方法为 key, 其值为 value 组成的字典

以前面`4.2`多继承示例中的三个类（`BaseClassName1`、`BaseClassName2`、`SubClassName`）为例：

>>> SubClassName.mro()
    [<class '__main__.SubClassName'>, <class '__main__.BaseClassName1'>, 
     <class '__main__.BaseClassName2'>, <class 'object'>]
    
    >>> SubClassName.__bases__
    (<class '__main__.BaseClassName1'>, <class '__main__.BaseClassName2'>)
    
    >>> SubClassName.__name__
    SubClassName
    
    >>> SubClassName.__class__
    <class 'type'>
    
    >>> SubClassName.__module__
    __main__
    
    >>> SubClassName.__doc__
    一个普通的类（子类）, 继承 BaseClassName1, BaseClassName2
    
    >>> SubClassName.__dict__
    { '__module__': '__main__', 
     '__doc__': '一个普通的类（子类）, 继承 BaseClassName1, BaseClassName2', 
     '__init__': <function SubClassName.__init__ at 0x10eaa6488>, 
     'sub_fun': <function SubClassName.sub_fun at 0x10eaa6510>, 
     'base_fun': <function SubClassName.base_fun at 0x10eaa6598>}
    
    >>> BaseClassName1.__dict__
    { '__module__': '__main__', 
     '__doc__': '一个普通的类（父类1）', 
     'base_name': 'value1', 
     '__init__': <function BaseClassName1.__init__ at 0x1049d3158>, 
     'base1_fun': <function BaseClassName1.base1_fun at 0x1049d31e0>, 
     'base_fun': <function BaseClassName1.base_fun at 0x1049d3268>, 
     '__dict__': <attribute '__dict__' of 'BaseClassName1' objects>, 
     '__weakref__': <attribute '__weakref__' of 'BaseClassName1' objects>}

**PS:**

*  定义的类如果没有指定继承的类，则默认继承 object 类。
 *  **object 类是所有类的父类**，object 没有父类。
 *  类也是一个对象，类的类型为 type 类型。
 *  object 和 type 也是一个类，其类型也为 type。

## 5. type() 函数动态创建类 ##

`type(...)`函数通常用来获取一个对象的类型，除此之外还可以利用该函数在运行时动态创建一个类。Python 解释器解析到使用`class`关键字在源码中创建的类时，实际上也是根据 class 定义的语法和参数再调用 type(…) 函数动态创建出 class。

#!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    
    def init(self, a, b):
        self.a = a
        self.b = b
    
    
    def add(self):
        return self.a + self.b
    
    
    # 通过 type() 方法创建一个类, 共 3 个参数:
    # 第 1 个参数: str, 类的名称（等号左边的 Demo 仅为变量名称, 可以是任意合法标识符）
    # 第 2 个参数: tuple, 继承的所有父类类型元组
    # 第 3 个参数: dict, 类的成员（包括属性和方法）
    Demo = type(
        "Demo",                     # 类的名称
        (object,),                  # 继承的父类
        { 
            "name": "Hello",        # name 属性
            "age": 25,              # age 属性
            "__init__": init,       # 构造方法
            "fun": add              # 对象方法
        }
    )
    
    d = Demo(2, 3)                  # 实例化一个对象
    print(d.name, d.age)            # 输出: Hello 25
    print(d.fun())                  # 输出: 5
    
    print(type(d))                  # 输出: <class '__main__.Demo'>
    print(type(Demo))               # 输出: <class 'type'>

[https_blog.csdn.net_xietansheng_article_details_115557427]: https://blog.csdn.net/xietansheng/article/details/115557427
[Python3]: https://blog.csdn.net/xietansheng/article/details/109266600