七、面向对象编程基础语法

面向对象编程（OOP）是 Python 的核心特性之一，它提供了一种组织代码的强大方式，使代码更模块化、可重用且易于维护。本文将系统介绍 Python 面向对象编程的基础语法，包括类定义、对象创建、继承、多态等核心概念。

文章目录

• 一、类

• 二、类的操作

  • 1、成员引用
  • 2、实例化

• 三、__init()__方法

• 四、self

  • 1、self 作为实例传参
  • 2、通过 self 在类中调用类的实例属性和实例方法

• 五、属性

  • 1、类属性

  • 2、实例属性

• 六、方法

  • 1、实例方法

  • 2、类方法

  • 3、静态方法

  • 4、在类外定义方法

  • 5、特殊方法

• 七、动态添加属性与方法

  • 1、动态给对象添加属性

  • 2、动态给类添加属性

  • 3、动态给实例添加方法

  • 4、动态给类添加方法

  • 5、动态删除属性与方法

  • 6、__slots__限制实例属性与实例方法

一、类

1、类

1.1、语法

class 类名:
    """类说明文档"""
    类体

1.2、 案例

定义一个人的类，包含 init() 方法、eat() 方法和 drink() 方法

class Person:

    """人的类"""

    home = "earth"

    def __init__(self):
        self.age = 0

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

    def drink(self):
        print("drinking...")

二、类的操作

1、成员引用

1.1、语法

类名.成员名

1.2、案例

class Person:

    """人的类"""

    home = "earth"

    def __init__(self):
        self.age = 0

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

    def drink(self):
        print("drinking...")

home = Person.home         # 获取一个字符串
eat_function = Person.eat  # 获取一个函数对象
doc = Person.__doc__       # 获取类的说明文档

print(home)                # earth
print(eat_function)        # <function Person.eat at 0x00000232C8230F40>
print(doc)                 # 人的类

2、实例化

2.1、语法

变量名 = 类名()

2.2、案例

class Person:

    """人的类"""

    home = "earth"

    def __init__(self):
        self.age = 0

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

    def drink(self):
        print("drinking...")


p = Person()   # 创建一个对象
print(p.home)  # earth
print(p.age)   # 0

p.eat()        # eating...
p.drink()      # drinking...

三、__init()__方法

init() 是一个特殊的方法，也被称作构造函数。init() 方法的主要作用是在创建类的对象时，对对象的属性进行初始化。当你使用类名创建一个新的对象时，Python 会自动调用 init() 方法，并将新创建的对象作为第一个参数（通常命名为 self）传递给它。

注意：

self：这是一个约定俗成的参数名，它代表类的实例对象本身。在方法内部，通过 self 可以访问和修改对象的属性

__init__() 方法不是必需的。如果类中没有定义 __init__() 方法，Python 会使用默认的构造函数，该构造函数不执行任何操作

__init__() 方法只能返回 None，不能返回其他值。如果尝试返回其他值，会引发 TypeError 异常

class Person:

    """人的类"""

    home = "earth"

    def __init__(self, name):
        self.name = name

p = Person("张三")  # 创建一个对象

print(p.name)       # 张三

四、self

1、self 作为实例传参

self 代表类的实例自身。调用实例方法时，实例对象会作为第一个参数被传入。因此，我们调用 p.eat() 时就相当于调用了Person.eat(p)

class Person:

    """人的类"""

    home = "earth"

    def __init__(self, name):
        self.name = name

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

    def drink(self):
        print("drinking...")

p = Person("张三")  # 创建一个对象
p.eat()             # eating...

Person.eat(p)       # eating...

2、通过 self 在类中调用类的实例属性和实例方法

class Person:

    """人的类"""

    home = "earth"

    def __init__(self, name):
        self.name = name

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

    def drink(self):
        print("drinking...")

    def eat_and_drink(self):
        print(self.name)     # 在类中调用name
        self.eat()           # 在类中调用eat()方法
        self.drink()         # 在类中调用drink()方法

p = Person("张三")           # 创建一个对象

p.eat_and_drink()

五、属性

1、类属性

也叫类变量。在类中方法外定义的属性。

1.1、通过 类名.属性名 或 实例名.属性名 访问

class Person:

    """人的类"""

    home = "earth"  # 定义类属性

print(Person.home)  # 通过类名访问类属性

p1 = Person()       # 创建一个实例对象
print(p1.home)      # 通过实例名访问类属性，(如果实例没有覆盖这个类属性的值)

1.2、通过 类名.属性名 添加与修改类属性

class Person:

    """人的类"""


Person.home = "earth"  # 添加类属性
print(Person.home)  # earth

Person.home = "mars"  # 修改类属性
print(Person.home)  # mars

若使用 实例名.属性名 则会创建或修改实例属性，因此不建议类属性和实例属性同名

class Person:

    """人的类"""

    home = "earth"


p1 = Person()
p2 = Person()
print(Person.home)  # earth
print(p1.home)      # earth
print(p2.home)      # earth


print("通过 类名.属性名 修改 类属性")
Person.home = "mars"
print(Person.home)  # mars
print(p1.home)      # mars
print(p2.home)      # mars


print("通过 实例名.属性名 会创建 实例属性")
p1.home = "venus"
print(Person.home)  # mars
print(p1.home)      # venus
print(p2.home)      # mars

1.3、所有该类的实例共享同一个类属性

class Person:
    """人的类"""

    home = "earth"   # 定义类属性，所有实例共享


p1 = Person()        # 创建一个实例对象
p2 = Person()        # 创建另一个实例对象

print(p1.home)       # earth
print(p2.home)       # earth

Person.home = "mars" # 修改类属性
print(p1.home)       # mars
print(p2.home)       # mars

2、实例属性

也叫实例变量。在类__init__方法中定义的属性。通过 self.属性名定义。

2.1、通过 类名.属性名 或 实例名.属性名 访问

class Person:
    """人的类"""

    def __init__(self, name, age):
        self.name = name   # 定义实例属性
        self.age = age     # 定义实例属性


p1 = Person("张三", 18)    # 创建一个实例对象
print(p1.name, p1.age)     # 张三 18


p2 = Person("李四", 81)    # 创建一个实例对象
print(p2.name, p2.age)     # 李四 81


print(Person.name)         # 报错

2.2、通过 实例名.属性名 添加与修改实例属性

class Person:
    """人的类"""

    pass

p1 = Person()           # 创建一个实例对象
p1.name = "张三"        # 添加实例属性
p1.age = 18             # 添加实例属性
print(p1.name, p1.age)  # 张三 18

p1.age = 25             # 修改实例属性
print(p1.name, p1.age)  # 张三 25

2.3、每个实例独有一份实例属性

class Person:
    """人的类"""

    def __init__(self, name):
        self.name = name  # 定义实例属性
        self.age = 0      # 定义实例属性


p1 = Person("张三")       # 创建一个实例对象
print(p1.name, p1.age)    # 张三 0


p1.age = 18               # 修改p1的age属性
print(p1.name, p1.age)    # 张三 18

p2 = Person("李四")       # 创建另一个实例对象
print(p2.name, p2.age)    # 李四 0

六、方法

Python的类中有三种方法：实例方法、静态方法、类方法。

1、实例方法

实例方法在类中定义，第一个参数为self，代表实例本身。

实例方法只能被实例对象调用。

可以访问实例属性、类属性、类方法。

class Person:
    """人的类"""

    home = "earth"

    def __init__(self, name):
        self.name = name

    def instance_method(self):
        print(self.name, self.home, Person.home)

p = Person("张三")
p.instance_method()           # 张三 earth earth，此时p中没有home实例属性，会去查找home类属性

Person.home = "venus"         # 修改类属性
p.home = "mars"               # 定义实例属性
p.instance_method()           # 张三 mars venus

2、类方法

类方法在类中通过 @classmethod 定义，第一个参数为cls，代表类本身。

类方法可以被类和实例对象调用。

可以访问类属性。

在不创建实例的情况下调用，通过类名直接调用，非常方便，适合一些和类整体相关的操作。

class Person:
    """人的类"""

    home = "earth"  # 定义类属性

    @classmethod
    def class_method(cls):
        print(cls.home)


Person.class_method()  # 通过类调用类方法

p1 = Person()          # 创建一个实例对象
p1.class_method()      # 通过实例对象调用类方法

3、静态方法

静态方法在类中通过 @staticmethod 定义

不访问实例属性或类属性，只依赖于传入的参数

可以通过类名或实例调用，但它不会访问类或实例的内部信息，更像是一个工具函数，只是为了方便组织代码，把它放在了类里面。

class Person:
    """人的类"""

    home = "earth"  # 定义类属性

    @staticmethod
    def static_method():
        print("static method")


Person.static_method()  # 通过类调用静态方法

p1 = Person()           # 创建一个实例对象
p1.static_method()      # 通过实例对象调用静态方法

4、特殊方法

方法名中有两个前缀下划线和两个后缀下划线的方法为特殊方法，也叫魔法方法。上文提到的 init() 就是一个特殊方法。这些方法会在进行特定的操作时自动被调用。

4.1、 new()：对象实例化时第一个调用的方法。

4.2、 init()：类的初始化方法。

4.3、 del()：对象的销毁器，定义了当对象被垃圾回收时的行为。使用 del xxx 时不会主动调用

4.4、str()：定义了对类的实例调用 str() 时的行为。

4.5、repr()：定义对类的实例调用 repr() 时的行为。 str() 和 repr() 最主要的差别在于目标用户。 repr() 的作用是产生机器可读的输出（大部分情况下，其输出可以作为有效的Python代

七、动态添加属性与方法

1、动态给对象添加属性

class Person:
    def __init__(self, name=None):
        self.name = name


p = Person("张三")
print(p.name)  # 张三

p.age = 18
print(p.age)  # 18

2、动态给对象添加方法

2.1、添加普通方法

class Person:
    def __init__(self, name=None):
        self.name = name


def eat():
    print("吃饭")


p = Person("张三")

p.eat = eat # 添加普通方法
p.eat()     # 调用，吃饭

2.2、添加实例方法

给对象添加的实例方法只绑定在当前对象上，不对其他对象生效，而且需要传入 self 参数。需要使用 types.MethodType(方法名，实例对象) 来添加实例方法。

import types

class Person:
    def __init__(self, name=None):
        self.name = name


def eat(self):
    print(f"{self.name}在吃饭")


p = Person("张三")
p.eat = types.MethodType(eat, p)
p.eat()  # 张三在吃饭

3、动态给类添加属性

class Person:
    def __init__(self, name=None):
        self.name = name


p = Person("张三")
print(p.name)       # 张三

Person.age = 0      # 给类添加属性
print(p.age)        # 0

4、动态给类添加方法

给类添加的方法对它的所有对象都生效，添加类方法需要传入 cls 参数，添加静态方法则不需要

class Person:
    home = "earth"

    def __init__(self, name=None):
        self.name = name


# 定义类方法
@classmethod
def come_from(cls):
    print(f"来自{cls.home}")


# 定义静态方法
@staticmethod
def static_function():
    print("static function")


Person.come_from = come_from
Person.come_from()                         # 来自earth


Person.static_function = static_function
Person.static_function()                   # static function

5、动态删除属性与方法

5.1、del 对象.属性名

5.2、delattr(对象，属性名)

6、__slots__限制实例属性与实例方法

Python允许在定义类的时候，定义一个特殊的 slots 变量，来限制该类的实例能添加的属性。使用 slots 可以限制添加实例属性和实例方法，但类属性、类方法和静态方法还可以添加。slots仅对当前类生效，对其子类无效。

import types

class Person:
    __slots__ = ("name", "age", "eat")

    def __init__(self, name=None):
        self.name = name

def eat(self):
    print(f"{self.name}在吃饭")

def drink(self):
    print(f"{self.name}在喝水")

p = Person("张三")

# 添加实例属性
p.age = 10
print(p.age)  # 10

# 添加实例方法
p.eat = types.MethodType(eat, p)
p.eat()  # 张三在吃饭

# 添加实例属性
p.weight = 100  # AttributeError: 'Person' object has no attribute 'weight'

# 添加实例方法
p.drink = type.MethodType(drink, p)  # AttributeError: type object 'type' has no attribute 'MethodType'