Python编程实战—面向对象与进阶语法 | 属性与方法

一、引言：类的核心------属性与方法

在面向对象编程（OOP）中，类（Class） 是一个"蓝图"，而属性（Attribute） 和方法（Method） 是这张蓝图的组成部分。

• 属性代表对象的"特征"------是什么；
• 方法代表对象的"行为"------能做什么。

例如，一辆汽车有颜色、品牌、速度（属性），能启动、加速、刹车（方法）。 属性和方法共同定义了对象的状态与功能。

---

二、属性（Attribute）

1. 属性的分类

在 Python 中，属性分为两类：

类型	定义位置	说明
实例属性	在 __init__() 中定义	属于对象自身，每个对象独立
类属性	在类体中定义	属于整个类，所有对象共享

---

2. 实例属性示例

实例属性一般在构造函数 __init__ 中定义：

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

my_car = Car("Tesla", "红色")
print(my_car.brand)  # Tesla
print(my_car.color)  # 红色

每个对象都有自己的属性值，互不影响。

car1 = Car("BYD", "蓝色")
car2 = Car("BMW", "黑色")

print(car1.brand)  # BYD
print(car2.brand)  # BMW

---

3. 类属性示例

类属性通常定义在类体中，所有对象共享。

class Dog:
    species = "犬科动物"  # 类属性

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

dog1 = Dog("旺财")
dog2 = Dog("小黑")

print(dog1.species, dog2.species)  # 犬科动物 犬科动物

如果修改类属性，会影响所有实例：

Dog.species = "哺乳动物"
print(dog1.species)  # 哺乳动物

但如果在实例上单独赋值，会"遮蔽"类属性：

dog1.species = "宠物狗"
print(dog1.species)  # 宠物狗
print(dog2.species)  # 哺乳动物

---

三、方法（Method）

方法定义了类或对象可以执行的操作。

1. 方法的种类

方法类型	装饰器	第一个参数	调用方式	说明
实例方法	无	self	对象调用	操作实例数据
类方法	@classmethod	cls	类或对象调用	操作类数据
静态方法	@staticmethod	无	类或对象调用	工具函数，与类逻辑相关但不依赖实例

---

2. 实例方法

实例方法是最常用的方法，用于操作对象属性。

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def show_info(self):
        print(f"学生：{self.name}，成绩：{self.score}")

stu = Student("小明", 95)
stu.show_info()

输出：

学生：小明，成绩：95

---

3. 类方法

类方法使用装饰器 @classmethod 定义，第一个参数是 cls，表示类本身。 常用于修改或访问类属性。

class School:
    school_name = "Python大学"

    @classmethod
    def change_name(cls, new_name):
        cls.school_name = new_name

School.change_name("AI学院")
print(School.school_name)

输出：

AI学院

---

4. 静态方法

静态方法使用 @staticmethod 定义，与类相关但不依赖于类或实例的属性。 适合写通用工具方法。

class MathTool:
    @staticmethod
    def add(a, b):
        return a + b

print(MathTool.add(5, 7))  # 12

---

四、属性的访问控制

Python 没有像 Java 那样严格的访问修饰符（public/private），但提供了命名约定来实现"伪私有化"。

1. 公有属性

• 命名：name
• 外部可直接访问

2. 受保护属性

• 命名：_name
• 按约定仅类及子类中使用（但外部仍可访问）

3. 私有属性

• 命名：__name
• 外部无法直接访问（会被"名称改写"）

class Person:
    def __init__(self, name, age):
        self.name = name          # 公有属性
        self._nickname = "小名"    # 受保护属性
        self.__age = age          # 私有属性

p = Person("张三", 18)
print(p.name)         # 张三
# print(p.__age)      # 报错
print(p._Person__age)  # 可通过改写访问（不推荐）

---

五、属性的封装与访问方法

为了保护数据安全，我们可以使用 getter / setter 方法。

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

    def get_balance(self):
        return self.__balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
        else:
            print("存款金额必须大于0")

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("余额不足")

account = BankAccount("李雷", 1000)
account.deposit(500)
print(account.get_balance())  # 1500

---

六、使用 @property 装饰器实现更优雅的属性访问

@property 可以把方法"伪装成属性"，让访问方式更自然。

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def area(self):
        return 3.14 * self._radius ** 2

c = Circle(5)
print(c.area)  # 78.5

无需调用方法，直接访问即可。 这是一种常见的 Pythonic 编程风格。

---

七、属性与方法的协作------对象的完整行为

综合示例：

class Car:
    wheels = 4  # 类属性

    def __init__(self, brand, speed):
        self.brand = brand
        self.speed = speed

    def accelerate(self, value):
        self.speed += value
        print(f"{self.brand} 提速至 {self.speed} km/h")

    def brake(self):
        print(f"{self.brand} 减速，当前速度 {self.speed} km/h")

car = Car("Tesla", 80)
car.accelerate(20)
car.brake()

输出：

Tesla 提速至 100 km/h
Tesla 减速，当前速度 100 km/h

---

八、小结

分类	定义方式	特点
实例属性	self.属性名	每个对象独有
类属性	直接定义在类中	所有对象共享
实例方法	def func(self)	操作对象数据
类方法	@classmethod def func(cls)	操作类数据
静态方法	@staticmethod def func()	通用逻辑函数
封装	_ 或 __ 前缀	保护数据安全

---

九、结语

在 Python 的面向对象编程中，属性是数据，方法是行为。 掌握属性与方法的定义、访问和封装，就掌握了类的灵魂。

属性描述对象，方法定义行为。 它们让类不再是"模板"，而成为"有生命的对象"。

---