本教程探讨了在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类默认情况下不支持下标操作，因此尝试对其进行下标访问会导致类型错误。
立即学习“Python免费学习笔记（深入）”；
解决方案：直接访问对象属性
要解决这个问题，我们需要理解 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) < (other._age, other._height, other._weight)
# ... 其他 __le__, __gt__, __ge__ 方法类似
# 假设 mergesort 存在并能正确工作，这里使用 sorted 作为替代演示
def mergesort(data, key):
# 实际的归并排序实现，这里仅为演示 key 参数作用
return sorted(data, key=key)
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)]
# 使用字典映射排序键到对应的 lambda 函数，提高代码可读性和可维护性
key_map = {
'name': lambda x: x._name,
'age': lambda x: x._age,
'height': lambda x: x._height,
'weight': lambda x: x._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("Sorted by name: ")
sorted_persons_by_name = create_persons_list(sort_key='name')
for p in sorted_persons_by_name:
print(p)
print("\nSorted by age: ")
sorted_persons_by_age = create_persons_list(sort_key='age')
for p in sorted_persons_by_age:
print(p)在这个修正后的代码中，lambda x: x._name 等表达式直接访问了 Person 对象的内部属性 _name、_age 等，从而为排序提供了正确的比较值。
封装性考量与最佳实践
尽管直接访问 _name 这样的“私有”属性（Python中以下划线开头的属性约定为私有，但仍可访问）可以解决问题，但在面向对象编程中，为了更好的封装性和可维护性，通常推荐通过公共方法（getter）来访问对象的内部状态。
1. 使用 Getter 方法
我们可以为 Person 类添加一系列的 getter 方法，例如 get_name()、get_age() 等。这样，外部代码就通过这些方法来获取属性值，而不是直接访问属性。
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 __le__(self, other):
if not isinstance(other, Person): return NotImplemented
return (self._age, self._height, self._weight) <= (other._age, other._height, other._weight)
def __gt__(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 
