类与面向对象

一、面向对象

Python 从设计之初就已经是一门面向对象的语言。

• 示意图：

• 类 (Class)： 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

• 方法：类中定义的函数。

• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

• 局部变量：定义在方法中的变量，只作用于当前实例的类。

• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个 Dog 类型的对象派生自 Animal 类，这是模拟"是一个（is-a）"关系（例图，Dog 是一个 Animal）。

• 实例化：创建一个类的实例，类的具体对象。

• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

• Python 中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

二、类

2.1 类定义

• 语法格式：

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>
1
2
3
4
5
6

• 类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

2.2 类对象

类对象支持两种操作：属性引用和实例化。

• 代码示例：

# 定义一个动物类。
class Animal:
    # 有年龄和重量的属性。
    age = 0
    weight = 0

    # 有跑和吃的方法。
    def run(self):
        print("run")

    def eat(self):
        print("eat")


# 实例化对象。
a = Animal()

# 通过对象去读取属性及方法调用。
print(a.age)
# 0
a.run()
# run

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• 构造方法：

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用。

class Animal:
    # 初始化带参构造。
    def __init__(self, age, weight):
        self.age = age
        self.weight = weight


# 参数通过 __init__() 传递到类的实例化操作上。
a = Animal(18, 20)
print(a.age)
# 18

1
2
3
4
5
6
7
8
9
10
11
12

2.3 self 代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

• 代码示例：

class Test:
    def print(self):
        print("对象实例:", self)
        print("类:", self.__class__)


t = Test()
t.print()
# 对象实例: <__main__.Test object at 0x0000020E5E97AC50>
# 类: 

1
2
3
4
5
6
7
8
9
10
11

• self 不是 python 关键字，换成 this 也是可以正常执行的：

class Test:
    def print(this):
        print("对象实例:", this)
        print("类:", this.__class__)


t = Test()
t.print()
# 对象实例: <__main__.Test object at 0x000001F09D64AC50>
# 类: 

1
2
3
4
5
6
7
8
9
10
11

三、类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

• 代码示例：

class Student:
    # 私有属性。
    __name = ""
    __age = 0

    # 初始化构造。
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    # 通过 getter 获取私有属性。
    def get_name(self):
        return self.__name


stu = Student("jan", 18)
print(stu.get_name())
# jan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

四、多继承

在 Python 中，多继承是指一个类可以继承多个父类的特性和方法。这使得 Python 具有灵活和强大的面向对象编程能力。要实现多继承，只需在类定义时在括号中列出所有要继承的父类即可。

• 多继承的类定义：

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>
1
2
3
4
5
6

• 代码示例：

class Father:
    def earn_money(self):
        pass

    def speak(self):
        print("father's method")


class Mother:
    def do_housework(self):
        pass

    def speak(self):
        print("mother's method")


# 多继承。
class Child(Father, Mother):
    pass


child = Child()
# 调用继承的方法。
child.earn_money()
child.do_housework()

# 需要注意的是，由于多继承可能导致方法冲突。
child.speak()
# father's method

# Python采用了方法解析顺序（MRO）来确定方法的调用顺序。
print(Child.mro())
# [, , , ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

• 提示：多继承也有其潜在的复杂性和困难，所以在使用时应谨慎考虑，并确保正确地使用和理解继承关系。

五、方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法。

• 代码示例：

class Father:
    def speak(self):
        print("father's method")


# 继承。
class Child(Father):
    def speak(self):
        print("child's method")


child = Child()
child.speak()
# child's method

# 可以通过子类对象调用同名的父类方法。
super(Child, child).speak()
# father's method

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

六、私有属性及私有方法

两个下划线开头，声明该属性或方法为私有，不能在类的外部被使用或直接访问。

• 代码示例：

class User:
    name = ""
    # 双下划线开头表示属性私有。
    __age = 0

    def public_method(self):
        pass

    # 双下划线开头表示方法私有。
    def __private_method(self):
        pass


user = User()
print(user.name)
user.public_method()

# 外部不能访问私有属性或者调用私有方法。
print(user.__age)
# Error
user.__private_method()
# # Error

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

七、类的专有方法

Python中的专有方法（也称为魔术方法或特殊方法）是一组在类定义中使用双下划线（__）包围的特殊命名的方法。这些方法用于定义类的行为，控制类对象的创建、比较、运算等操作。

• 对象实例化和初始化：

  • __init__(self, ...)：类的构造函数，用于创建对象并进行初始化。
  • __new__(cls, ...)：在实例化之前被调用的特殊方法，用于创建对象的实例。

• 对象的字符串表示：

  • __str__(self)：当使用 print() 或 str() 函数时，以字符串形式表示对象。
  • __repr__(self)：返回对象的规范字符串表示，用于调试和开发。

• 对象的比较：

  • __eq__(self, other)：进行相等性比较(==)。
  • __ne__(self, other)：进行不等性比较(!=)。
  • __lt__(self, other)：进行小于(<)比较。
  • __gt__(self, other)：进行大于(>)比较。
  • __le__(self, other)：进行小于等于(<=)比较。
  • __ge__(self, other)：进行大于等于(>=)比较。

• 对象的运算：

  • __add__(self, other)：定义加法操作(+)。
  • __sub__(self, other)：定义减法操作(-)。
  • __mul__(self, other)：定义乘法操作(*)。
  • __div__(self, other)：定义除法操作(/)。
  • __mod__(self, other)：定义取模操作(%)。
  • __pow__(self, other)：定义指数操作(**)。

• 容器类操作：

  • __len__(self)：返回容器中的元素数量。
  • __getitem__(self, key)：获取容器中给定键的值。
  • __setitem__(self, key, value)：设置容器中给定键的值。
  • __delitem__(self, key)：删除容器中给定键的值。
  • __contains__(self, item)：检查容器中是否包含指定元素。

• 这只是一部分 Python 中可用的专有方法，你还可以在需要时定义其他魔术方法以自定义类的行为。

• 每个魔术方法都有其特定的用途和应用场景，在不同情况下会有不同的调用时机。

• 详细的魔术方法列表可以在 Python 官方文档中找到。

八、专有方法重载

Python支持对类的专有方法进行重载，下面以 __str__(self) 的重载为例。

• 重载前：

class Sample:
    pass


sample = Sample()
print(sample)
# <__main__.Sample object at 0x000002300A67AC50>
1
2
3
4
5
6
7

• 重载后：

class Sample:
    def __str__(self):
        return "user defined."


sample = Sample()
print(sample)
# user defined.

1
2
3
4
5
6
7
8
9

九、结束语

---

“-------怕什么真理无穷，进一寸有一寸的欢喜。”

微信公众号搜索：饺子泡牛奶。