Python中的reverse, reversed, sort, sorted

发表于 更新于 分类于 阅读次数：

参考:
https://note.nkmk.me/en/python-reverse-reversed/
https://note.nkmk.me/en/python-list-sort-sorted/

1. Reverse

对于list, 可以使用 .reverse(), reversed(), 和切片[::-1] 对于字符串和元组（都不可变），可以使用reversed()和切片[::-1]

↑ .reverse() 是列表的方法，是in-place的，会改变原列表，所以String和Tuple不能使用（切片操作实际是一种copy，会生成一个新的列表而不会改变原列表）

1.1 list

  • List type method reverse() reverses the original list.

reverse()是列表的一个内置方法，改变原列表，reverse()返回None

1
2
3
4
5
6
7
8
org_list = [1, 2, 3, 4, 5]

org_list.reverse()
print(org_list)
# [5, 4, 3, 2, 1]

print(org_list.reverse())
# None
  • Built-in function reversed() returns a reverse iterator

reversed()是python的一个内置方法，不会改变原列表，返回一个迭代器，可用list()获取作用后的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
org_list = [1, 2, 3, 4, 5]

reverse_iterator = reversed(org_list)
print(org_list)
# [1, 2, 3, 4, 5]

print(reverse_iterator)
#<list_reverseiterator object at 0x7fdd7151a940>

print(type(reverse_iterator))
# <class 'list_reverseiterator'>

new_list = list(reversed(org_list))
print(org_list)
print(new_list)
# [1, 2, 3, 4, 5]
# [5, 4, 3, 2, 1]
  • 切片：\([start:end:step]\)

忽略start和end时，选取整个list，step=-1，从后往前依次遍历

1
2
3
4
5
6
7
org_list = [1, 2, 3, 4, 5]

new_list = org_list[::-1]
print(org_list)
print(new_list)
# [1, 2, 3, 4, 5]
# [5, 4, 3, 2, 1]

1.2 string

不能使用s.reverse()方法：

1
2
3
4
5
6
7
8
s = 'abcde'
s.reverse()
#Traceback (most recent call last):
#  File "script.py", line 7, in <module>
#    org_str.reverse()
#AttributeError: 'str' object has no attribute 'reverse'
#
#Exited with error status 1

法一：reversed()

因为迭代器不能直接转换成字符串，转换成list后还需使用join()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
org_str = 'abcde'

new_str_list = list(reversed(org_str))
print(new_str_list)
# ['e', 'd', 'c', 'b', 'a']

new_str = ''.join(list(reversed(org_str)))
print(new_str)
# edcba

#也可直接''.join(reversed(..))
new_str = ''.join(reversed(org_str))
print(new_str)
# edcba

关于 join()

1
2
S.join(iterable) -> str
return a string which is the concatenation of the strings in the iterable. The separator between elements is S.

法二：切片

1
2
3
new_str = org_str[::-1]
print(new_str)
# edcba

1.3 tuple

法一：reversed()

使用tuple()将迭代器转换成tuple

1
2
3
4
5
org_tuple = (1, 2, 3, 4, 5)

new_tuple = tuple(reversed(org_tuple))
print(new_tuple)
# (5, 4, 3, 2, 1)

法二：切片

1
2
3
new_tuple = org_tuple[::-1]
print(new_tuple)
# (5, 4, 3, 2, 1)

2. Sort

对于list，可使用 .sort() 或 sorted() 对于字符串和元组，可使用 sorted()

↑ .sort()是列表的方法，是in-place的，会改变原列表，所以String和Tuple不能使用

2.1 list

  • List type method sort() sorts the original list

sort() 是列表的一个内置方法，改变原列表，sort() 返回None，默认按升序排列

1
2
3
4
5
6
7
8
org_list = [3, 1, 4, 5, 2]

org_list.sort()    # sort in-place，默认升序排序
print(org_list)
# [1, 2, 3, 4, 5]

print(org_list.sort())
# None

降序排列：

1
2
3
org_list.sort(reverse=True)
print(org_list)
# [5, 4, 3, 2, 1]
  • Built-in function sorted() returns a sorted list

sorted() 是python的一个内置方法，不会改变原列表，返回一个sorted list，默认按升序排列

1
2
3
4
5
6
7
org_list = [3, 1, 4, 5, 2]

new_list = sorted(org_list)
print(org_list)
print(new_list)
# [3, 1, 4, 5, 2]
# [1, 2, 3, 4, 5]

降序排列：

1
2
3
4
5
new_list_reverse = sorted(org_list, reverse=True)
print(org_list)
print(new_list_reverse)
# [3, 1, 4, 5, 2]
# [5, 4, 3, 2, 1]

2.2 string

使用 sorted()

因为 sorted() 返回一个list，还需使用 join() 转换成 string

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
org_str = 'cebad'

new_str_list = sorted(org_str)
print(org_str)
print(new_str_list)
# cebad
# ['a', 'b', 'c', 'd', 'e']

new_str = ''.join(new_str_list)
print(new_str)
# abcde

new_str_reverse = ''.join(sorted(org_str, reverse=True))
print(new_str_reverse)
# edcba

The order of the characters is determined by their Unicode code point.

2.2 tuple

使用sorted()

需要使用tuple()将结果转换成tuple

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
org_tuple = (3, 1, 4, 5, 2)

new_tuple_list = sorted(org_tuple)
print(org_tuple)
print(new_tuple_list)
# (3, 1, 4, 5, 2)
# [1, 2, 3, 4, 5]

new_tuple = tuple(new_tuple_list)
print(new_tuple)
# (1, 2, 3, 4, 5)

new_tuple_reverse = tuple(sorted(new_tuple_list, reverse=True))
print(new_tuple_reverse)
# (5, 4, 3, 2, 1)

2.3 按指定的 key 排序

.sort() 和 sorted() 都支持按 key 进行排序。key 参数接收一个可调用的对象（例如一个函数），该可调用对象只接收单个参数。

例如，可以按绝对值或字符长度进行排序：

1
2
3
4
5
6
7
l = [-3, 1, 4, -5, 2]
print(sorted(l))
# [-5, -3, 1, 2, 4]

print(sorted(l, key=abs))
# [1, 2, -3, 4, -5]

1
2
3
4
5
6
7
l = ['b', 'cc', 'aaa']
print(sorted(l))
# ['aaa', 'b', 'cc']

print(sorted(l, key=len))
# ['b', 'cc', 'aaa']

结合lambda表达式： 

1
2
3
4
# 按照元组的第二个元素进行排序
a= [(0,2), (4,3), (9,9), (10,-1)]
print(sorted(a, key = lambda item: item[1]))
# [(10, -1), (0, 2), (4, 3), (9, 9)]

.sort() 用法同上。

关于字典的排序见 Advanced Python Types | qypx の blog