Python自定义类排序：解决lambda键值访问TypeError的实践指南-Python教程-PHP中文网

Python自定义类排序：解决lambda键值访问TypeError的实践指南

本文旨在解决在python中使用`lambda`函数作为排序键（`key`）对自定义类对象进行排序时遇到的`typeerror: 'person' object is not subscriptable`错误。我们将深入探讨该错误产生的原因，并提供正确的属性访问方式，同时介绍`operator.attrgetter`等优化方案，以帮助开发者高效、优雅地实现自定义对象的灵活排序。

理解Python中的对象排序与key参数

在Python中，对列表或其他可迭代对象进行排序通常使用内置的sorted()函数或列表的sort()方法。这两个函数都支持一个可选的key参数，它接收一个单参数函数，该函数会在比较之前对每个元素进行处理，并返回一个用于排序的值。这使得我们可以根据对象的特定属性或计算结果进行排序，而不仅仅是对象的默认比较方式。

当处理自定义类的实例列表时，key参数显得尤为重要。例如，我们有一个Person类，包含姓名、年龄、身高、体重等属性，我们可能需要根据不同的属性对Person对象列表进行排序。

错误场景：TypeError: 'Person' object is not subscriptable

考虑以下Person类定义及其初始化和排序的尝试：

import numpy as np

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(name='{self._name}', age={self._age}, height={self._height}, weight={self._weight})"

    # 为了简洁，此处省略了 __eq__, __lt__ 等比较方法，但它们在实际应用中很重要。
    # 假设有一个 mergesort 函数用于排序

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)
    ]

    # 假设 mergesort 是一个可用的排序函数
    # 错误示例：尝试将 Person 对象当作元组进行索引
    if sort_key == 'name':
        return mergesort(person_objects, key=lambda x: x[0]) # 错误
    elif sort_key == 'age':
        return mergesort(person_objects, key=lambda x: x[1])  # 错误
    # ... 其他排序键
    else:
        # 为了演示，此处直接返回未排序列表
        return person_objects 

# 假设 mergesort 函数已定义并可用
def mergesort(arr, key=None):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = mergesort(arr[:mid], key)
    right = mergesort(arr[mid:], key)

    return merge(left, right, key)

def merge(left, right, key):
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        left_val = key(left[i]) if key else left[i]
        right_val = key(right[j]) if key else right[j]

        if left_val <= right_val:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])
    return result

# 尝试执行会导致 TypeError
# sorted_persons_by_name = create_persons_list(sort_key='name')

登录后复制

当上述代码中的mergesort函数（或sorted()）调用key=lambda x: x[0]时，Python会尝试将列表中的Person对象x当作一个序列（如列表或元组）来使用索引[0]进行访问。然而，Person类并没有实现__getitem__方法，使其成为可下标（subscriptable）的。因此，Python抛出TypeError: 'Person' object is not subscriptable。

立即学习“Python免费学习笔记（深入）”；

正确实现排序键：直接访问对象属性

问题的核心在于，lambda函数接收的x是一个Person类的实例，而不是一个包含其属性的元组。要访问Person对象的属性，应该使用点号（.）操作符。

修正后的create_persons_list函数应如下所示：

# ... (Person 类和 mergesort 函数保持不变) ...

def create_persons_list_corrected(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)
    ]

    if sort_key == 'name':
        return mergesort(person_objects, key=lambda x: x._name) # 正确
    elif sort_key == 'age':
        return mergesort(person_objects, key=lambda x: x._age)   # 正确
    elif sort_key == 'height':
        return mergesort(person_objects, key=lambda x: x._height) # 正确
    elif sort_key == 'weight':
        return mergesort(person_objects, key=lambda x: x._weight) # 正确
    else:
        raise ValueError("Invalid sort_key. Supported values are 'name', 'age', 'height', and 'weight'.")

print("--- 修正后的排序结果 ---")
sorted_persons_by_name = create_persons_list_corrected(sort_key='name')
print("Sorted by name: \n", sorted_persons_by_name)

sorted_persons_by_age = create_persons_list_corrected(sort_key='age')
print("Sorted by age: \n", sorted_persons_by_age)

sorted_persons_by_height = create_persons_list_corrected(sort_key='height')
print("Sorted by height: \n", sorted_persons_by_height)

sorted_persons_by_weight = create_persons_list_corrected(sort_key='weight')
print("Sorted by weight: \n", sorted_persons_by_weight)

登录后复制

通过将lambda x: x[0]改为lambda x: x._name，我们直接访问了Person对象的私有属性_name（或_age、_height、_weight），从而提供了正确的排序键。

进一步的优化与考量

尽管直接访问属性解决了TypeError，但在实际开发中，我们还可以采用更优雅和健壮的方式。

Type

生成草稿，转换文本，获得写作帮助-等等。

查看详情

1. 使用operator.attrgetter

Python的operator模块提供了一个attrgetter函数，它能生成一个可调用对象，用于从对象中获取指定属性。这通常比lambda函数更简洁和高效。

from operator import attrgetter

# ... (Person 类和 mergesort 函数保持不变) ...

def create_persons_list_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)
    ]

    # 使用 attrgetter 动态生成排序键
    if sort_key == 'name':
        return mergesort(person_objects, key=attrgetter('_name'))
    elif sort_key == 'age':
        return mergesort(person_objects, key=attrgetter('_age'))
    elif sort_key == 'height':
        return mergesort(person_objects, key=attrgetter('_height'))
    elif sort_key == 'weight':
        return mergesort(person_objects, key=attrgetter('_weight'))
    else:
        raise ValueError("Invalid sort_key. Supported values are 'name', 'age', 'height', and 'weight'.")

print("\n--- 使用 attrgetter 排序结果 ---")
sorted_persons_by_name_ag = create_persons_list_attrgetter(sort_key='name')
print("Sorted by name (attrgetter): \n", sorted_persons_by_name_ag)

登录后复制

attrgetter的优点在于它能处理多个属性，例如key=attrgetter('_age', '_name')可以实现先按年龄排序，年龄相同再按姓名排序。

2. 封装属性访问（Getter方法或@property）

如果类设计要求更严格的封装，不希望直接访问私有属性（即使是带有下划线的“约定私有”属性），可以为Person类添加公共的getter方法或使用@property装饰器。

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

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @property
    def height(self):
        return self._height

    @property
    def weight(self):
        return self._weight

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

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

    if sort_key == 'name':
        return mergesort(person_objects, key=lambda x: x.name) # 访问公共属性
    elif sort_key == 'age':
        return mergesort(person_objects, key=lambda x: x.age)
    # ... 其他排序键
    else:
        return person_objects

print("\n--- 使用封装属性排序结果 ---")
sorted_persons_by_age_encap = create_persons_list_encapsulated(sort_key='age')
print("Sorted by age (encapsulated): \n", sorted_persons_by_age_encap)

登录后复制

在这种情况下，attrgetter同样可以用于公共属性，如key=attrgetter('name')。

3. 实现富比较方法（Rich Comparison Methods）

对于自定义类，如果存在一个明确的默认排序逻辑，可以在类内部实现富比较方法（如__lt__、__le__、__gt__、__ge__、__eq__、__ne__）。一旦实现了__lt__（小于），Python的sorted()函数或list.sort()就可以在不指定key参数的情况下对对象进行排序。

在原始问题中，Person类已经实现了这些方法，其默认排序逻辑是基于(age, height, weight)元组的比较。这意味着，如果调用mergesort(person_objects)而不提供key，它将按照这个默认逻辑进行排序。

class Person_With_Comparisons():
    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(name='{self._name}', age={self._age}, height={self._height}, weight={self._weight})"

    def __lt__(self, other):
        # 默认按年龄、身高、体重排序
        return (self._age, self._height, self._weight) < (other._age, other._height, other._weight)

# ... (mergesort 函数保持不变) ...

def create_persons_list_default_sort(n=10):
    person_objects = [
        Person_With_Comparisons(np.random.choice(NAMES), np.random.randint(18, 101), 
                                np.random.randint(150, 201), np.random.randint(45, 101)) 
        for _ in range(n)
    ]
    # 不提供 key 参数，将使用 __lt__ 进行默认排序
    return mergesort(person_objects)

print("\n--- 默认排序（通过__lt__）结果 ---")
sorted_persons_default = create_persons_list_default_sort()
print("Sorted by default (__lt__): \n", sorted_persons_default)

登录后复制

总结

在Python中对自定义类对象进行排序时，key参数的lambda函数接收的是类实例本身。因此，要正确指定排序依据，必须通过点号（.）操作符直接访问对象的属性（如lambda x: x._attribute或lambda x: x.public_attribute），而不是尝试将其当作序列进行索引（x[0]）。

为了代码的简洁性和效率，推荐使用operator.attrgetter来生成排序键。此外，根据类的设计需求，可以通过封装（getter方法或@property）来控制属性访问，或者通过实现富比较方法（如__lt__）来提供默认的排序行为。理解这些机制能够帮助开发者编写出更加灵活、健壮且符合Pythonic风格的排序代码。

以上就是Python自定义类排序：解决lambda键值访问TypeError的实践指南的详细内容，更多请关注php中文网其它相关文章！