Python3中`sorted()函数`与`lambda表达式`原理解析

最新推荐文章于 2023-02-23 18:13:50 发布
最新推荐文章于 2023-02-23 18:13:50 发布
阅读量1.8k 收藏 12
点赞数 5
分类专栏： Python的一些探索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011467553/article/details/104998858
版权

Python3中sorted()函数与lambda表达式原理解析

相信很多小伙伴们在一开始学习Python的一些高级用法时遇到过很多困扰。
我准备日常分享一些比较浅显的原理解析帮助大家理解。

博主的原文：

目录：

问题描述

很多小伙伴面对这样的排序，很是懵逼：

# 预按照每个字典中键'b'的值进行列表排序
L = [{'a': 1, 'b': 4}, {'a': 1111, 'b': 2}, {'a': 1111, 'b': 3}]
L_sorted = sorted(L, key=lambda d: d['b'], reverse=False)
print(L_sorted)

运行结果：

[{'a': 1111, 'b': 2}, {'a': 1111, 'b': 3}, {'a': 1, 'b': 4}]

这里面包含了函数高级用法中的sorted和lambda的两个用法

下面，我将逐一解析。

原理解析

  • lambda表达式相当于一个简化的函数
  • sorted(iterable, key=None, reverse=False)，此处的key=需要传递一个函数，相当于将iterable中的每一个元素迭代取出，传入key=处给定的函数，通过函数处理返回的值组成的新的迭代对象，通过该新对象的排序映射回iterable完成排序。

示例1：lambda表达式理解：

# 1) 普通函数func_add的定义
def func_add(x, y):
    return x + y
print(func_add(10, 20))  # 30

# 2) 对于函数func_add, 可以使用lambda表达式一行定义
myadd = lambda x, y: x + y
print(myadd(10, 20))  # 30

示例2: sorted函数理解

# sorted原理解析 —— 自定义函数实现sorted
def my_sorted(iters, key=None, reverse=None):
    if key:
        DICT = dict()
        for it in iters:
            # 用函数处理过后的值做键, 处理相同的键加入列表
            DICT.setdefault(key(it), []).append(it)
        INDEX = list(DICT)  # 获得函数处理过后的值列表
        INDEX.sort(reverse=reverse)  # 排序
        # 按顺序展开
        return [xx for x in INDEX for xx in DICT[x]]
    else:
        INDEX = list(iters)
        INDEX.sort(reversed=reverse)
        return INDEX


names = ['Tom', 'Spike', 'Jerry', 'Tyke']

L = sorted(names, key=len, reverse=True)
print(L)  # 结果 ['Tom', 'Tyke', 'Jerry', 'Spike']

L = my_sorted(names, key=len, reverse=True)
print(L)  # 结果 ['Tom', 'Tyke', 'Jerry', 'Spike']

附：原文基础知识

lambda表达式

（原文链接： lambda表达式）

引入：

  • 除了def语句可以创建函数之外，lambda表达式也可以创建函数。

概念：

  • lambda表达式（又称匿名函数），用于封装有限的逻辑的函数
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

语法格式：

  • lambda [变量1，变量2，… ]:表达式

说明：

  • 可以省略变量
  • 只能包含一条表达式

示例：lambda函数理解

# 1) 普通函数func_add的定义
def func_add(x, y):
    return x + y
print(func_add(10, 20))  # 30

# 2) 对于函数func_add, 可以使用lambda表达式一行定义
myadd = lambda x, y: x + y
print(myadd(10, 20))  # 30

# 3) 语法理解 x 为形参接收值, 后面紧跟表达式返回值
myfunc = lambda x: 123 + x
print(myfunc(100))  # 223

# lambda可以行使正常函数的所有功能
myfunc = lambda: print('hello', end=' ')
print(myfunc())  # hello None

# 求1到10的平方和
fun = lambda x: sum([x * x for x in range(1, x + 1)])
print(fun(10))  # 385

sorted 函数

（原文链接： sorted()函数）

  • 作用:

    • 将原可迭代对象提供的数据进行排序，生成排序后的列表

  • 格式:

    • sorted(iterable, key=None, reverse=False)
    • 说明:
      • iterable 可迭代对象
      • key 函数是用来提供一个排序参考值的函数，这个函数的返回值将作为排序的依据
      • reverse 标志用来设置是否降序排序
    • 返回
      • 列表list

  • 理解：

    • 此处的key=需要传递一个函数，相当于将iterable中的每一个元素迭代取出，传入key=处给定的函数，通过函数处理返回的值组成的新的迭代对象，通过该新对象的排序映射回iterable完成排序。

  • 与列表中自带方法 L.sort() 有什么区别？

    • sorted(L)
      • 是Building域名空间的一个系统函数；
      • 是将L作为参数输入，返回新列表，对原列表无影响；
    • L.sort()
      • 是list类中的一个方法，只能痛殴；
      • 是将L的内部元素进行直接排列，不返回新对象
    • 示例：
      L = [3, 5, 4, 2, 1]
L2 = sorted(L)
print("L:", L, "L2:", L2)
# L: [3, 5, 4, 2, 1] L2: [1, 2, 3, 4, 5]
a = L.sort()
print("L:", L, "a:", a)
# L: [1, 2, 3, 4, 5] a: None

示例1: sorted的简单示例

L = [5, -2, -4, 0, 3, 1]
print(sorted(L))  # 直接按大小排序
# [-4, -2, 0, 1, 3, 5]
print(sorted(L, key=abs))  # 按绝对值排序
# [0, 1, -2, 3, -4, 5]
print(sorted(L, key=abs, reverse=True)  # 按绝对值降序排序
# [5, -4, 3, -2, 1, 0]

示例2: sorted原理解析 —— 自定义函数实现sorted

# sorted原理解析 —— 自定义函数实现sorted
def my_sorted(iters, key=None, reverse=None):
    if key:
        DICT = dict()
        for it in iters:
            # 用函数处理过后的值做键, 处理相同的键加入列表
            DICT.setdefault(key(it), []).append(it)
        INDEX = list(DICT)  # 获得函数处理过后的值列表
        INDEX.sort(reverse=reverse)  # 排序
        # 按顺序展开
        return [xx for x in INDEX for xx in DICT[x]]
    else:
        INDEX = list(iters)
        INDEX.sort(reversed=reverse)
        return INDEX


names = ['Tom', 'Spike', 'Jerry', 'Tyke']

L = sorted(names, key=len, reverse=True)
print(L)  # 结果 ['Tom', 'Tyke', 'Jerry', 'Spike']

L = my_sorted(names, key=len, reverse=True)
print(L)  # 结果 ['Tom', 'Tyke', 'Jerry', 'Spike']

高级示例：

  • lambda与sorted高级联用
  1. 对列表里的字典排序
L = [{'a': 1, 'b': 4}, {'a': 1111, 'b': 2}, {'a': 1111, 'b': 3}]
L_sorted = sorted(L, key=lambda d: d['b'], reverse=False)
# [{'a': 1111, 'b': 2}, {'a': 1111, 'b': 3}, {'a': 1, 'b': 4}]
  1. 对字典进行按key排序
d = {'a':25, 'c':27, 'b':20, 'd':22}
L_sorted = sorted(d.items(), key=lambda x:x[0])
print(L_sorted)
# [('a', 25), ('b', 20), ('c', 27), ('d', 22)]
  1. 对字典进行按values排序
d = {'a':25, 'c':27, 'b':20, 'd':22}
L_sorted = sorted(d.items(), key=lambda x:x[1])
print(L_sorted)
# [('b', 20), ('d', 22), ('a', 25), ('c', 27)]
  1. 降序排序的另类写法
  • 问题一：如何对字母进行数学上写法的降序排序？
    • 利用ord()函数转为编码值，再*-1
Data = [['y', 2], ['x', 3], ['z', 4], ['a',1]]

# 对每个列表的第一个值进行正常排序
print(sorted(Data, key=lambda x: x[0]))
# [['a', 1], ['x', 3], ['y', 2], ['z', 4]]
# 对每个列表的第一个值进行降序排序
print(sorted(Data, key=lambda x: x[0], reverse=True))
# [['z', 4], ['y', 2], ['x', 3], ['a', 1]]
print(sorted(Data, key=lambda x: ord(x[0])*-1))  # 问题一
# [['z', 4], ['y', 2], ['x', 3], ['a', 1]]

# 对每个列表的第二个值进行正常排序
print(sorted(Data, key=lambda x: x[1]))
# [['a', 1], ['y', 2], ['x', 3], ['z', 4]]
# 对每个列表的第二个值进行降序排序
print(sorted(Data, key=lambda x: x[1], reverse=True))
# [['z', 4], ['x', 3], ['y', 2], ['a', 1]]
print(sorted(Data, key=lambda x: x[1]*-1))
# [['z', 4], ['x', 3], ['y', 2], ['a', 1]]
  1. 多重排序
  • 难点：
    • 如何实现部分列的升序和部分列的降序排序同时存在？
# - 排序规则
#   - 先按照书籍编号降序排序
#   - 再按照书名正序排序
#   - 再按照年份降序排序

# 书籍的编号
number = {
    "Robinson Crusoe": "B",
    "The Old Man and the Sea": "A",
    "The Little Prince": "C",
    "Secret garden": "A",
    "Thorn bird": "A"
}

# 年份，书籍，销售额
data_text = """2017,126,Robinson Crusoe
2017,110,The Old Man and the Sea
2017,152,The Little Prince
2017,98,Secret garden
2017,89,Thorn bird
2018,116,Robinson Crusoe
2018,98,The Old Man and the Sea
2018,176,The Little Prince
2018,79,Secret garden
2018,90,Thorn bird
2019,122,Robinson Crusoe
2019,102,The Old Man and the Sea
2019,187,The Little Prince
2019,102,Secret garden
2019,103,Thorn bird"""

Datas = [x.split(',') for x in data_text.splitlines()]
# 对数据进行排序
result = sorted(Datas, key=lambda x: (ord(number[x[2]])*-1,
                                      x[2], int(x[0])*-1))
# 结果的打印
for x in result:
    print(number[x[2]], *x, sep='\t')

运行结果：

C       2019    187     The Little Prince
C       2018    176     The Little Prince
C       2017    152     The Little Prince
B       2019    122     Robinson Crusoe
B       2018    116     Robinson Crusoe
B       2017    126     Robinson Crusoe
A       2019    102     Secret garden
A       2018    79      Secret garden
A       2017    98      Secret garden
A       2019    102     The Old Man and the Sea
A       2018    98      The Old Man and the Sea
A       2017    110     The Old Man and the Sea
A       2019    103     Thorn bird
A       2018    90      Thorn bird
A       2017    89      Thorn bird
  • itemgetter与attrgetter模块的使用
    • 可以简化代码
from operator import itemgetter

student_tuples = [
    ('john', 'A', 15),
    ('jane', 'B', 12),
    ('dave', 'B', 10),
]

# 按照索引为2的数据排序
print(sorted(student_tuples, key=itemgetter(2)))
# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

# 多重排序：按照索引为1，再按照2的数据排序
print(sorted(student_tuples, key=itemgetter(1, 2)))
# [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

from operator import attrgetter

 class Student:
        def __init__(self, name, grade, age):
                self.name = name
                self.grade = grade
                self.age = age
        def __repr__(self):
                return repr((self.name, self.grade, self.age))

student_objects = [
        Student('john', 'A', 15),
        Student('jane', 'B', 12),
        Student('dave', 'B', 10),
]

# 按age排序
print(sorted(student_objects, key=attrgetter('age')))
# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

# 多重排序，先以grade，然后再以age来排序
print(sorted(student_objects, key=attrgetter('grade', 'age')))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

练习:

  • 已知:
    • names = ['Tom', 'Jerry', 'Spike', 'Tyke']
  • 排序的依据为原字符串反序的字符串
    • 'moT', 'yrreJ', 'ekipS', 'ekyT'
  • 结果:
    • ['Spike', 'Tyke', 'Tom', 'Jerry']

参考：

>>> sorted(['Tom', 'Jerry', 'Spike', 'Tyke'],
           key=lambda x:x[::-1])
['Spike', 'Tyke', 'Tom', 'Jerry']
【Python深入浅出⑱】解锁Python3的神秘武器：Lambda函数
邓邓子的博客
02-03 1186
Lambda 函数和普通函数在定义方式上有着明显的区别。Lambda 函数使用lambda关键字来定义，其语法结构紧凑，仅需在lambda关键字后依次列出参数列表，再用冒号分隔，最后跟上一个表达式即可，例如lambda x, y: x + y。这种定义方式相对更为完整和详细，适用于定义较为复杂的函数逻辑。通过对 Python 3 中 Lambda 函数的深入探讨，我们对其有了全面的认识。Lambda 函数以其独特的匿名性和简洁的语法，为我们在 Python 编程中处理简单函数逻辑提供了一种高效的方式。
详解python中的lambda与sorted函数
09-16
主要介绍了python中的lambda与sorted函数的相关资料，帮助大家更好的理解和学习python，感兴趣的朋友可以了解下
python3排序 sorted(key=lambda)
热门推荐
木子木泗的博客
03-29 9万+
　　当待排序列表的元素由多字段构成时，我们可以通过sorted(iterable，key，reverse)的参数key来制定我们根据那个字段对列表元素进行排序。 　　key=lambda 元素: 元素[字段索引] 　　例如：想对元素第二个字段排序，则 　　key=lambda y: y[1] 备注：这里y可以是任意字母，等同key=lambda x: x[1] 看...
lambda表达式在sort中的使用(python3)
Fragrant_huee
03-06 3019
一、lambda表达式一般用法 lambda argument: manipulate(argument) Example: add = lambda x, y: x + y print(add(3, 5)) # Output: 8 二、 lambda表达式在sort中的使用 1、sort基本用法 sort()函数用来对list数据类型进行排序。reverse为True时，从大到小...
Python3排序sorted(key=lambda)
zying的博客
09-07 9310
使用python对列表(list)进行排序，用函数sorted的具体方法：1.2.假如a是一个由元组构成的列表，我们需要用到参数key，也就是关键词，看下面这句命令，lambda是一个隐函数，是固定写法，不要写成别的单词；x表示列表中的一个元素，在这里，表示一个元组，x只是临时起的一个名字，你可以使用任意的名字；x[0]表示元组里的第一个元素，当然第二个元素就是x[1]；所以这句命令的意思就是按照...
python sort和sorted函数
weixin_33794672的博客
08-13 1440
sort 与 sorted 区别： sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。 sorted 语法： sorted(iterable[, cmp[, key[, reverse]...
Python3中lambda表达式与函数式编程讲解
09-19
在Python3中，lambda表达式是一种简洁的创建小型匿名函数的方式。它们主要在不需为函数定义一个名称的场合下使用，特别是在函数式编程中。下面我们将深入探讨lambda表达式的用法及其在函数式编程中的应用。 1. **...
Python中 Lambda表达式全面解析
09-21
### Python中 Lambda表达式全面解析 #### 一、Lambda表达式的定义与特点 Lambda表达式在Python中是一种特殊的函数形式，它允许我们快速定义一个简短的匿名函数。这种匿名函数通常用于那些只需要使用一次或者不需要...
【python】sorted() 函数和 lambda 函数的详细讲解
m0_61003348的博客
02-23 1703
函数通常用于简单的、一次性的函数定义，它可以在不需要专门定义一个函数的情况下快速定义一个函数。是Python内置的一个排序函数，它可以对可迭代对象进行排序。函数可以接受三个参数：要排序的可迭代对象、key和reverse。是一个只包含一个表达式的代码块，用于计算函数的返回值。是一个可调用对象，用于指定排序时要比较的键；函数作为键，即对字符串的长度进行比较。，这是按照字符串长度从小到大排序后的结果。通常是该元素的一个属性或是一个计算。参数指定一个函数来指定排序的方式。函数来指定排序时要比较的键。
Python 函数 sort()，sorted() 之区别及 key=lambda x:x[] 之理解
iprobobo的博客
01-28 3万+
数据排序
Python3 Sorted排序（key=lambda）
dream_coke的博客
07-25 2982
sorted(iterable[, key][, reverse]) 从iterable中的项目返回新的排序列表。 有两个可选参数，必须指定为关键字参数。 key指定一个参数的函数，用于从每个列表元素中提取比较键：key=str.lower。默认值为None（直接比较元素）。 reverse是一个布尔值。如果设置为True，那么列表元素将按照每个比较反转进行排序。 示例：创...
function函数的用法_Python笔记第六回——常用内置函数用法
weixin_39613188的博客
11-27 113
一些常用的内置函数经常会忘记，方便自己回溯用法，纯干货，无杂质。只推常用。下列内置函数基于Python3all()和any()参数为iterable，即元组或列表all()函数用于判断iterable中的所有元素是否都为TRUE，元素除了是 0、空、None、False 外都算 True。any()函数用于判断iterable中的所有元素是否都为False。容易混淆，而且有坑，不清楚不建议使用bo...
Python 使用 lambda() 结合sort() 或 sorted() 对列表嵌套字典格式的数据进行排序
weixin_30549175的博客
08-22 588
1.使用sort()方法进行排序 my_list = [{"age":65, "money":5}, {"age":35, "money":1000000}] 按照age的大小进行倒序排序 my_list.sort(key=lambda x: x["age"]，reverse=True) 2.使用sorted()进行排序 my_list = sorted(my_list, key=...
Python3入门基础：第十二篇（sort函数和lambda表达式）
self_learning
03-07 3456
sort函数： #sort函数 排序 #简单数据类型 a = [22,10,24,21,20] b = a.sort() print(a) c = a.sort(reverse=True) print(a) #复杂排序 from functools import cmp_to_key persons = [ {'name':'ming ming', 'age':18 ...
python_sorted函数
qjk19940101的博客
05-21 783
Python_sorted函数>>> help(sorted) Help on built-in function sorted in module __builtin__:sorted(...) sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list sorted是内建函数函数定义： sorted(
python3排序sort()、sorted()、sort(key=lambda)、sorted(key=lambda)区别
weixin_44374912的博客
06-04 2180
sort() sort 与 sorted 区别： sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值