python——sort函数sorted函数以及lambda函数_python sort lamda

排序函数sort

列表的sort()方法可以对列表进行永久的就地排序，即直接修改原列表，会改变原对象的值。并不会去产生一个新的列表。
语法：`list.sort(self,key,reverse)
参数reverse：默认为False。如果reverse=True，则数据将按降序排列。
参数key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

list=[1,2,4,6,7,9,5,8,13,10,14,11,12]
list.sort()
print(list)
#输出结果
[1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
1
2
3
4
5

list=[1,2,4,6,7,9,5,8,13,10,14,11,12]
new_list=list.sort()
print(new_list)
#输出
None
1
2
3
4
5

在Python中，列表的sort()方法是原地排序，即直接修改原列表，而不返回新的排序后的列表。因此，使用new_list = list.sort()时，list.sort()会对列表进行排序，但不会返回任何值，所以new_list的值为None。

list=[1,3,4,5,6,9,-7,-18]
list.sort(key=lambda x: abs(x))
print(list)

"""abs是python中内置函数，用于返回数值的绝对值"""
print(abs(-12))

#输出；
[1, 3, 4, 5, 6, -7, 9, -18]
12
1
2
3
4
5
6
7
8
9
10

list=[1,3,4,5,6,9,-7,-18]
list.sort(key=lambda x: (x**3))
print(list)

#[-18, -7, 1, 3, 4, 5, 6, 9]
1
2
3
4
5

list.sort(key=lambda x: (x**2)) 是将列表按照每个元素的平方值进行排序，而不是将元素本身变为平方。这意味着在排序时，会用到元素的平方值进行比较，但不会改变元素本身的值。

具体来说，lambda x: (x**2) 是一个匿名函数，它接受一个参数 x 并返回 x 的平方。当列表进行排序时，会根据这个函数的返回值来比较元素，而不是根据元素本身的值来比较。因此，排序后列表中的元素仍然是原来的值，但它们的位置是根据其平方值来排列的。

排序函数sorted

sorted 是 Python 中的一个内置函数，用于对可迭代对象进行排序。它返回一个新的已排序列表，而原始列表保持不变。
sorted 函数可以接受一个可选的 key 参数，它是一个函数，用于指定排序规则。如果不提供 key 参数，则默认按元素的升序排序。
语法：

sorted(iterable,cmp=None,key=None,reverse)
1

cmp 参数：这是一个可选参数，用于指定自定义的比较函数。这个函数应该接受两个参数并返回一个负整数、零或正整数，表示第一个参数应该位于第二个参数之前、两者相等或第一个参数应该位于第二个参数之后。如果 cmp 参数未指定或为 None，则使用默认比较函数，即通过对象的 < 和 > 运算符进行比较。

key 参数：这是一个可选参数，用于指定一个函数，该函数将被用于从每个元素中提取一个比较键。这个函数应该接受一个参数并返回一个可比较的值。如果 key 参数未指定或为 None，则使用元素的原始值作为比较键。

reverse 参数：这是一个可选参数，用于指定排序的顺序。如果 reverse 参数未指定或为 False，则按升序排序。如果 reverse 参数为 True，则按降序排序。

list=[1,2,3,4,6,5,9,7,8,15,10,12]
new_list=sorted(list)
print(new_list)
new_list+=[20]
print(new_list)
print(list)

#输出：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 20]
[1, 2, 3, 4, 6, 5, 9, 7, 8, 15, 10, 12]

1
2
3
4
5
6
7
8
9
10
11
12

在上述代码中我们可以看出来使用sorted（）函数会产生一个新的列表，通过 sorted() 排序，不改变原列表

list=[1,2,3,4,6,5,9,7,8,15,10,12,-11]
new_list=sorted(list,key=lambda x:(x**2))
print(new_list)
#输出：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -11, 12, 15]

1
2
3
4
5
6

test = [('b', 6), ('c', 2), ('b', 3), ('d', 9), ('a', 10), ('f', 4), ('b', 5), ('a', 2)]
# 一. 利用参数 key 和 lambda 对函数内的容器元素以下标为 0 的元素进行升序排序
# 若下标为 0 的元素相同则按照原数组的先后顺序排序
result = sorted(test, key=lambda x: x[0])
print('test_1:', result)

# 二. 利用参数 key 和 lambda 对函数内的容器元素以下标为 1 的元素进行升序排序
# 若下标为 1 的元素相同则按照原数组的先后顺序排序
result = sorted(test, key=lambda x: x[1])
print('test_2:', result)

# 三. 利用参数 key 和 lambda 对函数内的容器元素以下标为 1 的元素进行降序排序
# 若下标为 1 的元素相同则按照原数组的先后顺序排序
result = sorted(test, key=lambda x: x[1], reverse=True)
print('test_3:', result)

#结果
test_1: [('a', 10), ('a', 2), ('b', 6), ('b', 3), ('b', 5), ('c', 2), ('d', 9), ('f', 4)]
test_2: [('c', 2), ('a', 2), ('b', 3), ('f', 4), ('b', 5), ('b', 6), ('d', 9), ('a', 10)]
test_3: [('a', 10), ('d', 9), ('b', 6), ('b', 5), ('f', 4), ('b', 3), ('c', 2), ('a', 2)]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

lambda函数

Lambda函数是一种匿名函数，也称为lambda函数。它是在Python中定义简短函数的一种简洁方式，不需要使用def关键字定义函数名称。

Lambda函数的语法如下：

lambda arguments: expression
1

arguments是函数的参数列表，expression是函数的返回值表达式。

Lambda函数可以接受任意数量的参数，但只能有一个表达式，该表达式将计算并返回一个值。如果一个函数的函数体仅有 1 行表达式，则该函数就可以用 lambda 表达式来代替。

```python
num=lambda x:x**2
print(num(5))

add=lambda x,y:x*y
add1=add(5,5)
print(add1)
#结果
25
25
1
2
3
4
5
6
7
8
9
10
11

关于上述代码的一般式是：

def num(x):
    return x**2
num1=num(5)
print(num1)

def add(x,y):
    return x*y
print(add(5,5))
1
2
3
4
5
6
7
8

map() 是 Python 中的一个内置函数，用于将一个函数应用于一个或多个可迭代对象的所有项目。如果指定了多个可迭代对象，那么 map() 函数会并行地迭代它们，直到最短的输入可迭代对象被耗尽。

map() 函数的基本语法是：

map(function, iterable, ...)
1

function 是一个函数，用于处理每个输入元素。
iterable 是一个或多个可迭代对象（例如列表、元组等）。
map() 函数返回一个迭代器，该迭代器产生由 function 函数处理每个输入元素后得到的结果。为了得到一个列表或其他数据类型，你通常需要使用 list() 或其他构造函数来转换这个迭代器。

# 定义一个函数，用于平方一个数
def square(x):
    return x ** 2


# 一.使用 map() 函数将 square 函数应用于一个列表的所有元素
numbers = [1, 2, 3, 4, 5]
squared = map(square, numbers)

# 将结果转换为列表并打印
print(list(squared))

#你还可以使用 lambda 函数与 map() 结合，以更简洁的方式实现相同的功能：
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)
print(list(squared))

# 匿名函数写法

# 二. 通过 map() 和 lambda 计算列表各个元素的三次方
result = map(lambda x: x ** 3, [1, 2, 3, 4, 5])
print('test_2:', list(result))

# 三. 提供两个列表，将其相同索引位置的列表元素进行相加
result = list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
print('test_3:', list(result))
# 四. 列表长度不同时，相加后的结果列表长度为较小列表的长度
result = map(lambda x, y: x + y, [1, 3, 5, 7, 9, 11, 13], [2, 4, 6, 8, 10])
print('test_4:', list(result))

result = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10, 12, 14])
print('test_5:', list(result))

#输出
[1, 4, 9, 16, 25]
[1, 4, 9, 16, 25]
test_2: [1, 8, 27, 64, 125]
test_3: [3, 7, 11, 15, 19]
test_4: [3, 7, 11, 15, 19]
test_5: [3, 7, 11, 15, 19]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

filter() 是 Python 的内置函数之一，用于过滤序列。它根据指定的条件过滤序列，返回由符合条件元素组成的新列表。

filter() 函数的语法如下：

filter(function, iterable)
1

function 是一个返回值为布尔值的函数，用于测试序列中的每个元素是否符合条件。
iterable 是一个可迭代对象，例如列表、元组等。
filter() 函数将 function 应用于 iterable 中的每个元素，并返回一个迭代器，该迭代器产生符合条件的元素。为了得到一个列表或其他数据类型，你通常需要使用 list() 或其他构造函数来转换这个迭代器。

# 定义一个函数，用于判断一个数是否为偶数
def is_even(n):
    return n % 2 == 0


# 使用 filter() 函数过滤出列表中的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = filter(is_even, numbers)

# 将结果转换为列表并打印
print(list(even_numbers))  # 输出: [2, 4, 6, 8, 10]
1
2
3
4
5
6
7
8
9
10
11