Python类

经典类

不由任意内置类型派生出的类，称之为经典类（存在于Python2.0）。

  1. class 类名:
  2.     代码
  3.     ...

新式类

存在于Python3.0以上的类，称之为新式类。

  1. class 类名(object):
  2.     代码
  3.     ...
  5. 其中：
  6.     object表示的是需要继承的父类，写object或不写参数表示继承的是基类（顶级类）。

面向对象的继承

Python面向对象的继承，指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法。

  • 所有类默认继承object类，**object**类是顶级类或基类，其他的子类叫作派生类。 ```python

    父类A

    class A(): def init(self):

    1.   self.str = "hello world"

    def print_info(self):

    1.   print(self.str)

子类B

class B(A): pass

result = B() result.print_info() # hello world

  1. <a name="VEq2N"></a>
  2. ## 单继承
  3. 单继承，指的是**一个类仅继承了一个父类**。
  4. ```python
  5. # 父类A
  6. class A():
  7.     def __init__(self):
  8.         self.str = "hello world"
  10.     def print_info(self):
  11.         print(self.str)
  14. # 子类B
  15. class B(A):
  16.     pass
  19. result = B()
  20. result.print_info()  # hello world

多继承

所谓多继承，指的是一个类同时继承了多个父类。

  • 当一个类有多个父类的时候，默认使用的是第一个父类的同名属性和方法。 ```python

    父类A

    class A(object): def init(self):

    1.   self.str = "hello world"

    def print_info(self):

    1.   print(self.str)

父类B

class B(object): def init(self): self.str = “hi world”

  1. def print_info(self):
  2.     print(self.str)

子类C

class C(A, B): pass

result = C() result.print_info() # hello world

  1. <a name="enGhH"></a>
  2. # 子类和父类的方法和属性
  3. <a name="ynTeH"></a>
  4. ## 子类重写父类同名方法和属性
  5. **子类和父类具有同名属性和方法时**，**默认使用子类的同名属性和方法**。
  6. ```python
  7. # 父类A
  8. class A(object):
  9.     def __init__(self):
  10.         self.str = "hello world"
  12.     def print_info(self):
  13.         print(self.str)
  16. # 父类B
  17. class B(object):
  18.     def __init__(self):
  19.         self.str = "hi world"
  21.     def print_info(self):
  22.         print(self.str)
  25. # 子类C
  26. class C(A, B):
  27.     def __init__(self):
  28.         self.str = "I am here!"
  30.     def print_info(self):
  31.         print(f"哈哈哈，{self.str}")
  34. result = C()
  35. result.print_info()  # 哈哈哈，I am here!

__mro__查看对象的继承关系

  1. print(对象.__mro__)
  3. 输出信息：子类 ==> 父类层级，即越靠右，其对应的父级层级越高。

子类调用父类的同名方法

子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装即可。

  • 在子类的方法中，如果先调用父类的属性和方法，父类属性会覆盖子类的属性，因此调用子类方法前，先调用子类的属性初始化；
  • 调用父类的方法前，为保证调用的是父类的属性，必须在调用方法前调用父类的属性。

——调用谁的方法，就先调用谁的属性。

  1. # 父类A
  2. class A(object):
  3.     def __init__(self):
  4.         self.str = "hello world"
  6.     def print_info(self):
  7.         print(self.str)
  10. # 父类B
  11. class B(object):
  12.     def __init__(self):
  13.         self.str = "hi world"
  15.     def print_info(self):
  16.         print(self.str)
  19. # 子类C
  20. class C(A, B):
  21.     def __init__(self):
  22.         self.str = "I am here!"
  24.     def print_info(self):
  25.         self.__init__()  # 先调用子类的属性初始化
  26.         print(f"哈哈哈，{self.str}")
  28.     # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
  29.     def mainA(self):
  30.         A.__init__(self)  # 先调用父类的属性初始化
  31.         A.print_info(self)
  33.     def mainB(self):
  34.         B.__init__(self)  # 先调用父类的属性初始化
  35.         B.print_info(self)
  38. result = C()
  39. result.print_info()  # 哈哈哈，I am here!
  40. result.mainA()  # hello world
  41. result.mainB()  # hi world
  43. # print(C.__mro__)

多层继承（单继承）

  1. """继承方式： A ==> B ==> C ==>D    """
  2. # 父类A
  3. class A(object):
  4.     def __init__(self):
  5.         self.str = "hello world"
  7.     def print_info(self):
  8.         print(self.str)
  11. # 父类B
  12. class B(object):
  13.     def __init__(self):
  14.         self.str = "hi world"
  16.     def print_info(self):
  17.         print(self.str)
  20. # 子类C
  21. class C(A, B):
  22.     def __init__(self):
  23.         self.str = "I am here!"
  25.     def print_info(self):
  26.         self.__init__()  # 先调用子类的属性初始化
  27.         print(f"哈哈哈，{self.str}")
  29.     # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
  30.     def print_parent(self):
  31.         A.__init__(self)  # 先调用父类的属性初始化
  32.         A.print_info(self)
  34.         B.__init__(self)  # 先调用父类的属性初始化
  35.         B.print_info(self)
  38. class D(C):
  39.     pass
  42. result = D()  # 孙继承类可以调用多个父级类的方法
  43. result.print_info()  # 哈哈哈，I am here!
  44. result.print_parent()  # hello world   hi world

使用super()调用父类方法

**super()**函数可以自动查找父类。调用顺序遵循__mro__类属性的顺序，比较适合单继承。

  1. # 方法1（Python2）：
  2. super(当前类名, 对象或类).xxx
  4. # 方法2（Python3）：
  5. super().xxx
  7. 其中，第二个参数”对象或类“，一般使用self。

单继承使用super()

  1. """继承方式： A ==> B ==> C ==> D    """
  2. # 父类A
  3. class A(object):
  4.     def __init__(self):
  5.         self.num = 1
  7.     def print_info(self):
  8.         print(self.num)
  11. # 父类B
  12. class B(A):
  13.     def __init__(self):
  14.         self.num = 2
  16.     def print_info(self):
  17.         print(self.num)
  19.         # 调用父级方法
  20.         # 方法1：
  21.         # super(B, self).__init__()
  22.         # super(B, self).print_info()
  23.         # 方法2：
  24.         super().__init__()
  25.         super().print_info()
  28. # 子类C
  29. class C(B):
  30.     def __init__(self):
  31.         self.num = 3
  33.     def print_info(self):
  34.         # self.__init__()  # 先调用子类的属性初始化
  35.         print(self.num)
  37.         # 调用父级方法
  38.         # 方法1：
  39.         # super(C, self).__init__()
  40.         # super(C, self).print_info()
  41.         # 方法2：
  42.         super().__init__()
  43.         super().print_info()
  46. class D(C):
  47.     pass
  50. result = D()  # 孙继承类可以调用多个父级类的方法
  51. result.print_info()  # 3 2 1

多继承使用super()

  1.  """    多继承方式----棱形继承
  2.      ---> B ---
  3.  A --|          |--> D
  4.       ---> C ---
  5.  """
  6. class A(object):
  7.     def __init__(self):
  8.         print("Enter A")
  9.         print("Leave A")
  12. class B(A):
  13.     def __init__(self):
  14.         print("Enter B")
  15.         super().__init__()
  16.         print("Leave B")
  19. class C(A):
  20.     def __init__(self):
  21.         print("Enter C")
  22.         super().__init__()
  23.         print("Leave C")
  26. class D(B, C):
  27.     def __init__(self):
  28.         print("Enter D")
  29.         super().__init__()
  30.         print("Leave D")
  33. # 创建对象
  34. d = D()        # 创建对象时，自动调用类中的初始化属性
  35. """
  36. 执行结果如下：
  37. Enter D
  38. Enter B
  39. Enter C
  40. Enter A
  41. Leave A
  42. Leave C
  43. Leave B
  44. Leave D
  45. """

类的私有属性和方法

在Python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或方法不允许子类继承。

  • 私有属性和私有方法只能在同一个类中访问和修改。

    1. class 类名():
    2.   # 私有属性
    3.   __属性名 = 值
    5.   # 私有方法
    6.   def __函数名(self):
    7.       代码

    私有属性和方法示例

    ```python class A(): def init(self):

    1.   self.str = "hello"
    2.   self.__money = 100    # 私有属性

    def __print_info(self): # 私有方法

    1.   print(self.str)
    2.   print(self.__money)

class B(A): def init(self): self.str = “world”

  1. def print_info(self):
  2.     print("haha")
  4.     super().__init__()
  5.     super().__print_info()

result = B() result.print_info() # 无法调用私有方法，报错

  1. <a name="rITSi"></a>
  2. ## 获取和修改私有属性值
  3. 在Python中，**一般定义函数名**`**get_xxx**`**用来获取私有属性，定义**`**set_xxx**`**用来修改私有属性**。
  5. - **私有属性和私有方法只能在同一个类中访问和修改**。
  6. ```python
  7. class A():
  8.     def __init__(self):
  9.         self.str = "hello"
  10.         self.__money = 100
  12.     def get_money(self):  # 获取私有属性
  13.         return self.__money
  15.     def set_money(self):  # 修改私有属性
  16.         self.__money = 500
  18.     def __print_info(self):
  19.         print(self.str)
  20.         print(self.__money)
  23. result = A()
  24. print(result.get_money())  # 100
  25. result.set_money()
  26. print(result.get_money())  # 500