本教程探讨了在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", "D*id", "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", "D*id", "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 等，从而为排序提供了正确的比较值。

Codeium

一个免费的AI代码自动完成和搜索工具

345 查看详情

封装性考量与最佳实践

尽管直接访问 _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", "D*id", "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

以上就是Python中自定义对象排序键的灵活配置与封装实践的详细内容，更多请关注其它相关文章！

# 仅为  # 周口优化seo  # 地瓜推广营销目的  # 耳机网络营销推广  # 昆明营销推广多少钱  # 宁波 自助建站seo  # 金融网站建设模板下载  # 广州市推广seo  # 武夷山网站推广外包公司  # 岳阳网站建设推进  # 驻马店招聘seo  # 不容错过  # 并能  # 解决问题  # python  # 可以通过  # 您的  # 的是  # 面向对象  # 是一个  # 自定义  # 代码可读性  # 封装性  # python编程  # 面向对象编程  # 排序算法  # ai 

相关栏目： 【 科技资讯46185 】 【 网络学院92790 】

相关推荐： CSS Flexbox如何实现多行排列_flex-wrap wrap自动换行显示  马斯克：Optimus 人形机器人复数形式为 Optimi  外媒分析《GTA6》定价：卖100美元可以但真没必要！  Tabulator表格日期时间排序问题及自定义解决方案  Win11怎么关闭触摸屏_Windows 11禁用HID符合标准触摸屏  Golang如何使用buffered channel提高性能_Golang buffered channel优化技巧  学习通网页版官方登录 超星学习通电脑端入口指南  sublime如何优雅地处理行尾空格_sublime自动清理多余空白字符配置  《噬血代码2》新预告片发布 展示游戏剧情  使用 Pandas 高效处理 .dat 文件：数据清洗与数值计算实战  探索高级语言到原生C/C++的转译：挑战与内存管理策略  CSS布局：解决全屏元素100%尺寸与外边距导致的页面溢出问题  漫蛙MANWA漫画主页官方入口 漫蛙漫画最新在线阅读地址  提升屏幕阅读器对“m”时间单位的播报准确性：HTML与CSS组合解决方案  QQ邮箱网页版快速登录 QQ邮箱邮箱账号官方入口地址  Win10系统服务哪些可以禁用 Win10安全优化服务列表【干货】  C++如何实现一个智能指针_手动实现C++ shared_ptr的引用计数功能  windows10怎么查看本机ip_windows10命令提示符ipconfig使用  怎样把文件彻底粉碎无法恢复_Windows下安全删除敏感数据【隐私保护】  QQ邮箱在线登录平台 QQ邮箱个人邮箱网页版入口  实现全屏滚动与导航点：专业教程  怎么在html里运行vbs脚本_html中运行vbs脚本方法【教程】  网易大神怎么保存别人动态的图片_网易大神动态图片保存方法  Win10自动更新怎么关闭 Win10永久关闭系统更新的两种方法【终极版】  Selenium Python中处理点击后新窗口加载冻结问题的策略与实践  QQ邮箱官网登录入口 QQ邮箱网页版邮箱快速登录  b站赚钱渠道_b站收益来源  必由学官网首页入口 必由学教师网页版登录指南  蛙漫漫画免费阅读入口_蛙漫官方正版无广告纯净版  在WordPress中通过REST API获取BasicAuth保护的远程文章  steam官方入口大全 steam账号注册及操作指南  2025俄罗斯Yandex最新入口 官方网站地址及浏览器下载指南  一加Ace 6T支持全新明眸护眼：通过了最严苛的护眼小金标认证  微信网页版官方入口教程 微信网页版网页版快速登录步骤  C++如何操作注册表_Windows平台下C++读写注册表的API函数详解  qq游戏大厅官方下载_qq游戏免费下载安装入口  qq游戏跨平台入口_qq游戏多设备同步登录  Excel如何用迷你图显趋势_Excel用迷你图显趋势【趋势小图】  如何为你的Composer包编写自动化测试_集成PHPUnit到Composer的scripts工作流  必由学官网快捷入口 必由学网页版在线学习平台  mysql备份恢复性能优化_mysql备份恢复性能优化方法  自定义Bag-of-Words实现：处理带负号的词汇权重  HTML长属性值处理：表单action路径优化与代码规范应对  如何在CSS中使用visited与link控制链接颜色_visited link伪类配合  CSS Box Model与弹性按钮：维持布局稳定的动画实践  mcjs网页版流畅运行 mcjs低配电脑畅玩入口  UC浏览器官网入口2025最新 UC浏览器网页版正式地址  CKEditor 5 自定义构建在React应用中渲染失败的调试与解决  ExcelARRAYTOTEXT函数怎么自定义分隔符输出数组文本_ARRAYTOTEXT实现动态生成SQL语句  UE5.7引擎表现爆炸优化无敌！5090跑4K稳定60FPS