这是 Python 面向对象编程中最核心、最常用的方法类型。

什么是实例方法？

实例方法是定义在类中，与类的实例（对象）相关联的方法，它既可以访问和修改实例的状态（即实例的属性），也可以访问和修改类的状态（即类的静态属性），但它的主要目的是操作与特定实例相关的数据。

核心特点：

• 第一个参数是 self：这是实例方法最显著的特征。self 代表类的实例本身，当你调用一个实例方法时，Python 会自动将实例对象作为第一个参数传递给 self。
• 需要通过实例调用：你必须先创建一个类的实例（对象），然后才能调用其实例方法。
• 可以访问和修改实例属性：通过 self，方法可以读取和修改实例的变量。

实例方法的语法

class MyClass:
    # 类属性
    class_attribute = "I am a class attribute"
    def __init__(self, instance_attribute_value):
        # 实例属性，在创建对象时初始化
        self.instance_attribute = instance_attribute_value
    # 这是一个实例方法
    def instance_method(self, param1, param2):
        # 方法体
        # 1. 可以访问实例属性
        print(f"Instance attribute: {self.instance_attribute}")
        # 2. 可以访问类属性
        print(f"Class attribute: {MyClass.class_attribute}") # 或者 self.class_attribute
        # 3. 可以修改实例属性
        self.instance_attribute = param1
        # 4. 可以修改类属性（通常不推荐在实例方法中直接修改，但技术上可行）
        # MyClass.class_attribute = param2
        # 5. 可以返回值
        return f"Method executed with params: {param1}, {param2}"

self 的详细解释

self 只是一个 Python 约定的名称（你也可以用 this 或其他名字，但强烈不推荐），它代表了当前正在被操作的那个对象。

让我们通过一个例子来理解 self 的工作原理：

class Dog:
    def __init__(self, name, breed):
        # self.name = name 的意思是：
        # "给这个特定的 Dog 对象创建一个 name 属性，并将传入的 name 值赋给它。"
        self.name = name
        self.breed = breed
    def bark(self):
        # self.name 的意思是：
        # "获取这个特定 Dog 对象的 name 属性的值。"
        print(f"{self.name} says: Woof!")
# 创建两个不同的 Dog 实例
dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Lucy", "German Shepherd")
# 调用 bark 方法
dog1.bark()  # 输出: Buddy says: Woof!
dog2.bark()  # 输出: Lucy says: Woof!

当你调用 dog1.bark() 时，Python 在幕后执行的操作类似于 Dog.bark(dog1)。dog1 这个对象被作为第一个参数 self 传递给了 bark 方法，在 bark 方法内部，self.name 指的就是 dog1.name。

实例方法的完整示例

下面是一个更完整的例子,展示了实例方法的创建、调用以及如何访问和修改数据。

class BankAccount:
    # 类属性，所有账户共享
    bank_name = "Python National Bank"
    interest_rate = 0.02
    def __init__(self, owner, balance):
        # 实例属性，每个账户独有
        self.owner = owner
        self.balance = balance
    # 实例方法：存款
    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            print(f"{self.owner} deposited ${amount}. New balance: ${self.balance}")
        else:
            print("Deposit amount must be positive.")
    # 实例方法：取款
    def withdraw(self, amount):
        if amount > 0 and amount <= self.balance:
            self.balance -= amount
            print(f"{self.owner} withdrew ${amount}. New balance: ${self.balance}")
        else:
            print("Invalid withdrawal amount (insufficient funds or negative).")
    # 实例方法：查询余额
    def get_balance(self):
        return self.balance
    # 实例方法：显示账户信息
    def display_info(self):
        print(f"--- Account Info ---")
        print(f"Owner: {self.owner}")
        print(f"Bank: {BankAccount.bank_name}") # 访问类属性
        print(f"Balance: ${self.balance}")
        print(f"Interest Rate: {BankAccount.interest_rate}") # 访问类属性
        print("--------------------")
# --- 使用 ---
# 创建两个账户实例
account1 = BankAccount("Alice", 1000)
account2 = BankAccount("Bob", 500)
# 调用实例方法
account1.display_info()
account2.display_info()
print("\n--- Transactions ---")
account1.deposit(200)
account1.withdraw(50)
account2.withdraw(100) # 有效
account2.withdraw(600) # 无效，余额不足
print("\n--- Final Info ---")
account1.display_info()
account2.display_info()

输出：

--- Account Info ---
Owner: Alice
Bank: Python National Bank
Balance: $1000
Interest Rate: 0.02
--------------------
--- Account Info ---
Owner: Bob
Bank: Python National Bank
Balance: $500
Interest Rate: 0.02
--------------------
--- Transactions ---
Alice deposited $200. New balance: $1200
Alice withdrew $50. New balance: $1150
Bob withdrew $100. New balance: $400
Invalid withdrawal amount (insufficient funds or negative).
--- Final Info ---
--- Account Info ---
Owner: Alice
Bank: Python National Bank
Balance: $1150
Interest Rate: 0.02
--------------------
--- Account Info ---
Owner: Bob
Bank: Python National Bank
Balance: $400
Interest Rate: 0.02
--------------------

实例方法 vs. 类方法 vs. 静态方法

为了更好地理解实例方法,我们通常会将它与另外两种方法进行比较。

简单对比示例：

class MyClass:
    class_var = "I am a class variable"
    def __init__(self, instance_var):
        self.instance_var = instance_var
    # 实例方法
    def instance_method(self):
        print(f"Instance method called. Instance var: {self.instance_var}, Class var: {self.class_var}")
    # 类方法
    @classmethod
    def class_method(cls):
        # cls 指向类 MyClass
        print(f"Class method called. Class var: {cls.class_var}")
        # 不能直接访问 self.instance_var
    # 静态方法
    @staticmethod
    def static_method():
        # 不接收 self 或 cls
        print("Static method called. It's like a regular function inside a class.")
        # 无法直接访问 MyClass.class_var 或 self.instance_var
# 创建实例
obj = MyClass("I am an instance variable")
# 调用
obj.instance_method()
MyClass.class_method()
MyClass.static_method()

• 实例方法是面向对象编程的基石。
• 它的第一个参数永远是 self，代表调用该方法的实例本身。
• 它的主要目的是操作和封装与单个对象相关的数据和逻辑。
• 必须通过类的实例来调用。
• 理解 self 的工作原理是掌握 Python OOP 的关键一步。