Python中自定义对象排序键的灵活配置与封装实践-Python教程-PHP中文网

Python中自定义对象排序键的灵活配置与封装实践

本教程探讨了在python中对自定义类对象进行排序时，如何通过lambda函数灵活指定排序键，并解决了常见的typeerror: 'person' object is not subscriptable问题。文章将展示如何正确访问对象属性作为排序依据，并讨论了在封装性要求下的最佳实践，包括直接属性访问、引入getter方法以及使用operator.attrgetter。

在Python编程中，对包含自定义对象（如类实例）的列表进行排序是一个常见需求。无论是使用Python内置的list.sort()方法、sorted()函数，还是自定义的排序算法（例如归并排序），都可以通过key参数来指定排序依据。key参数接受一个可调用对象（通常是lambda函数），该对象将作用于列表中的每个元素，并返回一个用于比较的值。

问题背景：自定义对象排序中的类型错误

考虑一个Person类，它包含姓名、年龄、身高和体重等属性。我们希望能够根据这些不同的属性对Person对象列表进行排序。

以下是初始的Person类定义和尝试排序的代码片段：

import numpy as np
import enum
# 假设 merge_sort 模块中包含 mergesort 函数
# from merge_sort import mergesort 

NAMES = ["Alice", "Bob", "Charlie", "David", "Eve", "Frank", "Grace", "Hank", "Ivy", "Jack"]

class Person():
    def __init__(self, name, age, height, weight):
        self._name = name
        self._age = age
        self._height = height
        self._weight = weight

    def __repr__(self):
        return f"Person('{self._name}', {self._age}, {self._height}, {self._weight})"

    # 其他魔术方法 __eq__, __lt__ 等略

def create_persons_list(n=10, sort_key='weight'):
    person_objects = [Person(np.random.choice(NAMES), np.random.randint(18, 101), 
                             np.random.randint(150, 201), np.random.randint(45, 101)) 
                      for _ in range(n)]

    # 尝试使用索引作为排序键，导致TypeError
    if sort_key == 'name':
        # return mergesort(person_objects, key=lambda x: x[0]) 
        pass # 此处会报错
    # ... 其他条件分支

# 假设 mergesort 存在并能正确工作，这里使用 sorted 作为替代演示
def mergesort(data, key):
    # 实际的归并排序实现，这里仅为演示 key 参数作用
    return sorted(data, key=key)

# 示例调用 (会导致TypeError)
# sorted_persons_by_name = create_persons_list(sort_key='name')

当尝试运行类似 mergesort(person_objects, key=lambda x: x[0]) 的代码时，Python会抛出 TypeError: 'Person' object is not subscriptable。这个错误的原因在于，lambda函数中的参数 x 是一个 Person 类的实例，而不是一个像列表或元组那样可以通过索引（[0]）来访问元素的序列。Person类默认情况下不支持下标操作，因此尝试对其进行下标访问会导致类型错误。

解决方案：直接访问对象属性

要解决这个问题，我们需要理解 lambda 函数接收的是 Person 对象本身。因此，正确的做法是直接通过属性名访问 Person 对象的相应属性作为排序键。例如，如果我们要按年龄排序，就应该访问 x._age。

修改后的 create_persons_list 函数如下所示：

import numpy as np
# from merge_sort import mergesort # 假设 mergesort 函数可用

NAMES = ["Alice", "Bob", "Charlie", "David", "Eve", "Frank", "Grace", "Hank", "Ivy", "Jack"]

class Person():
    def __init__(self, name, age, height, weight):
        self._name = name
        self._age = age
        self._height = height
        self._weight = weight

    def __repr__(self):
        # 优化 repr，使其更具可读性
        return f"Person(name='{self._name}', age={self._age}, height={self._height}, weight={self._weight})"

    # 为了使 Person 对象能够被直接比较，可以实现比较魔术方法
    # 注意：这些方法定义了 Person 对象之间的默认比较行为，
    # 而 key 参数允许我们基于特定属性进行排序，两者作用不同。
    def __eq__(self, other):
        if not isinstance(other, Person):
            return NotImplemented
        return (self._age, self._height, self._weight) == (other._age, other._height, other._weight)

    def __lt__(self, other):
        if not isinstance(other, Person):
            return NotImplemented
        return (self._age, self._height, self._weight) <p>在这个修正后的代码中，lambda x: x._name 等表达式直接访问了 Person 对象的内部属性 _name、_age 等，从而为排序提供了正确的比较值。</p><div class="aritcle_card flexRow artxards">
											<div class="artcardd flexRow">
												<a class="aritcle_card_img" rel="nofollow" href="/xiazai/skill9965" title="macOS UI 自动化技能包 —— 用 Python 控制你的 Mac"><img
														src="https://img.php.cn/upload/skill/001/246/273/6adaf20dbae7c507.jpg" alt="macOS UI 自动化技能包 —— 用 Python 控制你的 Mac" onerror="this.onerror='';this.src='/static/lhimages/moren/morentu.png'" ></a>
												<div class="aritcle_card_info flexColumn">
													<a rel="nofollow" href="/xiazai/skill9965" title="macOS UI 自动化技能包 —— 用 Python 控制你的 Mac" class="overflowclass">macOS UI 自动化技能包 —— 用 Python 控制你的 Mac</a>
													<p class="overflowclass">让 macOS 自动化像说话一样简单 —— 用代码控制你的 Mac，无需学习 AppleScript

系统要求
macOS 14+ (Sonoma)

Python 3.9+

需要开启：辅助功能 + 屏幕录制权限</p>
												</div>
												<a rel="nofollow" href="/xiazai/skill9965" title="macOS UI 自动化技能包 —— 用 Python 控制你的 Mac" class="aritcle_card_btn flexRow flexcenter"><b></b><span>下载</span>
												</a>
											</div>
										</div><h3>封装性考量与最佳实践</h3><p>尽管直接访问 _name 这样的“私有”属性（Python中以下划线开头的属性约定为私有，但仍可访问）可以解决问题，但在<a style="color:#f60; text-decoration:underline;" title="面向对象编程" href="https://m.php.cn/zt/24154.html" target="_blank">面向对象编程</a>中，为了更好的封装性和可维护性，通常推荐通过公共方法（getter）来访问对象的内部状态。</p><h4>1. 使用 Getter 方法</h4><p>我们可以为 Person 类添加一系列的 getter 方法，例如 get_name()、get_age() 等。这样，外部代码就通过这些方法来获取属性值，而不是直接访问属性。</p><pre class="brush:php;toolbar:false;">class Person():
    def __init__(self, name, age, height, weight):
        self._name = name
        self._age = age
        self._height = height
        self._weight = weight

    # Getter 方法
    def get_name(self):
        return self._name

    def get_age(self):
        return self._age

    def get_height(self):
        return self._height

    def get_weight(self):
        return self._weight

    def __repr__(self):
        return f"Person(name='{self._name}', age={self._age}, height={self._height}, weight={self._weight})"

    # ... 其他魔术方法

然后，在 create_persons_list 函数中，lambda 表达式将调用这些 getter 方法：

def create_persons_list_with_getters(n=10, sort_key='weight'):
    person_objects = [Person(np.random.choice(NAMES), np.random.randint(18, 101), 
                             np.random.randint(150, 201), np.random.randint(45, 101)) 
                      for _ in range(n)]

    key_map = {
        'name': lambda x: x.get_name(),
        'age': lambda x: x.get_age(),
        'height': lambda x: x.get_height(),
        'weight': lambda x: x.get_weight(),
    }

    if sort_key in key_map:
        return mergesort(person_objects, key=key_map[sort_key])
    else:
        raise ValueError("Invalid sort_key. Supported values are 'name', 'age', 'height', and 'weight'.")

# 示例调用
print("\n--- 使用 Getter 方法排序 ---")
print("Sorted by height: ")
sorted_persons_by_height = create_persons_list_with_getters(sort_key='height')
for p in sorted_persons_by_height:
    print(p)

2. 使用 operator.attrgetter

Python的 operator 模块提供了一些高效的函数，可以替代常见的 lambda 表达式。operator.attrgetter(attr) 就是其中之一，它创建一个可调用对象，该对象从其操作数中获取指定的属性。这通常比 lambda 表达式更简洁、更高效。

import operator
# ... (Person class with getters as above)

def create_persons_list_with_attrgetter(n=10, sort_key='weight'):
    person_objects = [Person(np.random.choice(NAMES), np.random.randint(18, 101), 
                             np.random.randint(150, 201), np.random.randint(45, 101)) 
                      for _ in range(n)]

    # 使用 operator.attrgetter
    key_map = {
        'name': operator.attrgetter('_name'),    # 直接访问私有属性
        'age': operator.attrgetter('get_age'),   # 调用 getter 方法
        'height': operator.attrgetter('_height'),
        'weight': operator.attrgetter('get_weight'),
    }

    if sort_key in key_map:
        return mergesort(person_objects, key=key_map[sort_key])
    else:
        raise ValueError("Invalid sort_key. Supported values are 'name', 'age', 'height', and 'weight'.")

# 示例调用
print("\n--- 使用 operator.attrgetter 排序 ---")
print("Sorted by weight: ")
sorted_persons_by_weight = create_persons_list_with_attrgetter(sort_key='weight')
for p in sorted_persons_by_weight:
    print(p)

需要注意的是，operator.attrgetter 既可以直接获取属性（如 _name），也可以获取方法并调用它（如 get_age）。选择哪种方式取决于类的封装设计。在严格封装的场景下，通过 getter 方法访问是更推荐的做法。

完整示例代码

为了提供一个完整的可运行示例，我们将上述所有概念整合到一起。这里我们假设 mergesort 函数与 sorted() 函数的行为一致，接受 key 参数。

import numpy as np
import operator

# 假设 merge_sort 模块中包含 mergesort 函数
# 为了演示，这里我们使用 Python 内置的 sorted() 函数作为 mergesort 的替代
# 在实际应用中，您会导入并使用您的 mergesort 实现
def mergesort(data, key):
    """
    模拟归并排序函数，接受 key 参数。
    在实际使用中，请替换为您的归并排序实现。
    """
    return sorted(data, key=key)

NAMES = ["Alice", "Bob", "Charlie", "David", "Eve", "Frank", "Grace", "Hank", "Ivy", "Jack"]

class Person():
    def __init__(self, name, age, height, weight):
        self._name = name
        self._age = age
        self._height = height
        self._weight = weight

    # Getter 方法，提供受控的属性访问
    def get_name(self):
        return self._name

    def get_age(self):
        return self._age

    def get_height(self):
        return self._height

    def get_weight(self):
        return self._weight

    def __repr__(self):
        return f"Person(name='{self._name}', age={self._age}, height={self._height}, weight={self._weight})"

    # 实现比较魔术方法，使 Person 对象本身可比较（与 key 参数独立）
    def __eq__(self, other):
        if not isinstance(other, Person): return NotImplemented
        return (self._age, self._height, self._weight) == (other._age, other._height, other._weight)

    def __lt__(self, other):
        if not isinstance(other, Person): return NotImplemented
        return (self._age, self._height, self._weight)  (other._age, other._height, other._weight)

    def __ge__(self, other):
        if not isinstance(other, Person): return NotImplemented
        return (self._age, self._height, self._weight) >= (other._age, other._height, other._weight)

def create_persons_list_and_sort(n=10, sort_key='weight'):
    person_objects = [Person(np.random.choice(NAMES), np.random.randint(18, 101), 
                             np.random.randint(150, 201), np.random.randint(45, 101)) 
                      for _ in range(n)]

    # 使用 operator.attrgetter 结合 getter 方法，实现最佳实践
    key_map = {
        'name': operator.attrgetter('get_name'),
        'age': operator.attrgetter('get_age'),
        'height': operator.attrgetter('get_height'),
        'weight': operator.attrgetter('get_weight'),
    }

    if sort_key in key_map:
        print(f"\n--- 排序方式: {sort_key.capitalize()} ---")
        sorted_list = mergesort(person_objects, key=key_map[sort_key])
        for p in sorted_list:
            print

Python免费学习笔记（深入）：立即使用
在学习笔记中，你将探索 Python 的核心概念和高级技巧！