Python 类的属性和方法详解

　　在 Python 的面向对象编程（OOP） 中，类（Class） 和 对象（Object） 是核心概念，而属性（Attribute） 和 方法（Method） 是类的基本组成部分。Python 允许在类中定义不同类型的属性（实例属性、类属性）和方法（实例方法、类方法、静态方法），通过它们，可以高效地组织代码，提高代码的模块化、可读性和复用性。本文将详细介绍 Python 中类的属性和方法，并结合示例帮助你理解和掌握它们的用法。

1. Python 类的属性（Attributes）

（1）实例属性（Instance Attribute）

实例属性 是属于对象（实例）的变量，每个对象的实例属性相互独立。

• 通过 self.属性名 定义，在 __init__() 方法中初始化。
• 只能通过对象访问，不会影响其他实例。

示例：实例属性的定义和使用

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

# 创建对象
p1 = Person("小明", 25)
p2 = Person("小红", 22)

# 访问实例属性
print(p1.name, p1.age)  # 输出：小明 25
print(p2.name, p2.age)  # 输出：小红 22

# 修改实例属性（不会影响其他对象）
p1.age = 26
print(p1.age)  # 输出：26
print(p2.age)  # 输出：22（不变）

✅ 总结：

• 每个实例对象都有自己的实例属性，互不影响。
• self 关键字 代表实例本身，self.name 和 self.age 绑定到具体的对象。

（2）类属性（Class Attribute）

类属性 是属于整个类的变量，所有对象共享同一个类属性。

• 通过 类名.属性名 定义，所有实例对象共享该属性。
• 修改类属性会影响所有对象，但修改实例属性不会影响类属性。

示例：类属性的定义和使用

class Student:
    school = "Python大学"  # 类属性（所有实例共享）

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

# 创建对象
s1 = Student("张三")
s2 = Student("李四")

# 访问类属性
print(s1.school)  # 输出：Python大学
print(s2.school)  # 输出：Python大学

# 修改类属性（影响所有实例）
Student.school = "编程学院"
print(s1.school)  # 输出：编程学院
print(s2.school)  # 输出：编程学院

# 修改实例的类属性（仅影响当前对象）
s1.school = "Python学院"
print(s1.school)  # 输出：Python学院
print(s2.school)  # 输出：编程学院  （未受影响）

✅ 总结：

• 类属性由所有对象共享，适用于全局性信息（如学校名称）。
• 实例属性属于单个对象，修改不会影响其他对象。
• 如果实例对象尝试修改类属性，它会创建一个新的实例属性，而不会影响原类属性。

2. Python 类的方法（Methods）

（1）实例方法（Instance Method）

实例方法 是最常见的方法类型：

✅ 第一个参数必须是 self，代表实例对象本身。

✅ 可以访问实例属性和类属性。

✅ 只能通过实例调用。

示例：实例方法的定义和使用

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

    def bark(self):  # 实例方法
        return f"{self.name} 叫了一声：汪汪！"

# 创建对象
dog1 = Dog("旺财")
dog2 = Dog("小白")

# 调用实例方法
print(dog1.bark())  # 输出：旺财 叫了一声：汪汪！
print(dog2.bark())  # 输出：小白 叫了一声：汪汪！

✅ 总结：

• 实例方法用于操作实例数据，必须通过实例调用。
• self 代表实例本身，可以访问实例属性。

（2）类方法（Class Method）

类方法 操作类属性，对所有实例生效。

✅ 使用 @classmethod 装饰器 定义。

✅ 第一个参数必须是 cls，代表类本身。

✅ 可以通过 cls.类属性 访问和修改类属性。

示例：类方法的定义和使用

class Animal:
    species = "哺乳动物"  # 类属性

    @classmethod
    def change_species(cls, new_species):
        cls.species = new_species  # 修改类属性

# 访问类方法
print(Animal.species)  # 输出：哺乳动物
Animal.change_species("爬行动物")
print(Animal.species)  # 输出：爬行动物

✅ 总结：

• 类方法修改类属性，影响所有实例。
• 使用 cls 访问类属性，而不是 self。
• 可以通过 类名.类方法() 直接调用，无需创建实例。

（3）静态方法（Static Method）

静态方法 是独立的工具方法，既不操作实例，也不操作类，仅提供功能。

✅ 使用 @staticmethod 装饰器 定义。

✅ 没有 self 或 cls 参数，不能访问实例属性或类属性。

✅ 适用于不依赖类和实例的独立功能。

示例：静态方法的定义和使用

class MathHelper:
    @staticmethod
    def add(x, y):
        return x + y

    @staticmethod
    def multiply(x, y):
        return x * y

# 直接调用静态方法（无需创建对象）
print(MathHelper.add(5, 3))     # 输出：8
print(MathHelper.multiply(4, 6)) # 输出：24

类中静态方法的使用，直接调用静态方法，而无需创建对象.

#!/usr/bin/env python
#coding:utf-8

policy = {
    "times": "2025-07-24",
    "hostname": "nginx-server01",
    "IP_Adress": "10.50.1.33",
    "details": {
        "nginx-server01_10.50.1.33_vm": [
            "Server type:           web01",
            "Active:                yes",
            "System:                Vmware"
            ]
    }
}
class PolicyParser:
    def __init__(self):
        self.all_results = {}
    def extract_info(self):
        for key,value in policy.get('details',{}).items():
            # print(f'key: {key}: value: {value}')
            #暂未用到标识符
            unique_key = f'{policy.get('hostname')}_{policy.get('IP_Adress')}'
            #print(unique_key)
　　　　　　　 #这一步时调用类的静态方法.
            parsed = self.parse_details(value)
            self.all_results = {
                "IP地址": policy.get('IP_Adress'),
                "主机名": policy.get('hostname'),
                "创建时间": policy.get('times'),
                "服务类型": parsed.get('Server type',"N/A"),
                "服务状态": parsed.get('Active',"N/A"),
                "操作系统": parsed.get('System',"N/A"),
            }
        #print(f'打印出 all_results的值: {self.all_results}')
        return self.all_results
    @staticmethod
    def parse_details(details):
        fields = {}
        for line in details:
            strip_line = line.strip()
            if not strip_line or ":" not in strip_line:
                continue
            key_part,value_part = strip_line.split(':',1)
            key = key_part.strip()
            value = value_part.strip()
            if key == "Server type":
                fields['Server type'] = value
            elif key == "Active":
                fields['Active'] = value
            elif key == "System":
                fields['System'] = value
        #print(f'fields字典中的值: {fields}')
        return fields
    def print_summary(self):
        """打印摘要信息"""
        print(f"成功找到 {policy.get('hostname')}主机,信息如下：")
        # 按主机名统计主机信息
        for k,v in self.all_results.items():
            print(f'{k}: {v}')
obj = PolicyParser()
obj.extract_info()
obj.print_summary()

 

✅ 总结：

• 静态方法适合独立计算或工具方法，如数学运算、字符串处理等。
• 不能访问 self 和 cls，不能修改实例或类属性。
• 可以通过 类名.静态方法() 直接调用，无需创建实例。

3. 结论

类别	定义方式	参数	访问范围	调用方式
实例属性	self.属性名	self	仅限实例	对象.属性名
类属性	类名.属性名	cls	所有实例共享	类名.属性名
实例方法	def 方法(self):	self	可访问实例和类属性	对象.方法()
类方法	@classmethod	cls	仅访问类属性	类名.方法()
静态方法	@staticmethod	无	不能访问实例和类属性	类名.方法()

Python 的类的属性和方法提供了丰富的功能，使得代码更具灵活性、可读性和可维护性。通过合理使用 实例属性、类属性、实例方法、类方法和静态方法，可以编写更清晰、更高效的 OOP 代码！

 

参考文档：https://zhuanlan.zhihu.com/p/1890499862375675316