python 对字符串list中的元素进行排序

  • 引言
  • 利用`sort() 函数`对list进行排序
  • 利用`sorted() 函数`对list进行排序
  • `sorted()函数`的可迭代对象iterable为字典时
  • 字典 in 操作符
  • 按照字符串中的数字的大小进行排序


引言

sort() 函数和sorted() 函数的区别：

  • sorted() 函数可以对所有可迭代的对象 iterable进行排序操作，但是sort()函数 只能应用在 list 上的方法。
  • list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

利用sort() 函数对list进行排序

描述：

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

语法：

list.sort( key=None, reverse=False)

参数：

  • key – 指定用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

返回值：

该方法没有返回值，但是会对列表的对象进行排序。

典型范例：

# 例1：
aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
aList.sort()   # sort()函数没有返回值，使用时无赋值（=）
print ( "List : ", aList)
>>>
List :  ['Facebook', 'Google', 'Runoob', 'Taobao']

##或者，使用sorted()函数亦可实现同等效果

aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
aList = sorted(aList)  # sorted()函数有返回值，使用时赋值（=）
print ( "List : ", aList)
>>>
List :  ['Facebook', 'Google', 'Runoob', 'Taobao']

# 例2：
# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
# 降序排列
vowels.sort(reverse=True)  # 参数reserve可以设置排序方式
# 输出结果
print ( '降序输出:', vowels )
>>>
降序输出: ['u', 'o', 'i', 'e', 'a']

# 例3  通过指定列表中的元素排序来输出列表
# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
 
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond) # 即：根据list中元组的第二个元素进行排序
# 输出类别
print ('排序列表：', random)
>>>
排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]

# 对list中元素为int、str、float等均无影响（But，亲测str为“汉字”时，排序效果不符合预期，后续解决！！！！）
random = [('c', 'Beijing'), ('g', 'Shanghai'), ('a', 'Guangzhou'), ('h', 'Xiamen')]
# 指定第二个元素排序
random.sort(key=takeSecond)
# 输出类别
print("排序列表：", random)
>>>
排序列表： [('c', 'Beijing'), ('a', 'Guangzhou'), ('g', 'Shanghai'), ('h', 'Xiamen')]

# 或者，使用sorted()函数亦可实现同等效果
random = [('c', 'Beijing'), ('g', 'Shanghai'), ('a', 'Guangzhou'), ('h', 'Xiamen')]
random = sorted(random , key=lambda x: x[1])
# 输出类别
print("排序列表：", random)
>>>
排序列表：[('c', 'Beijing'), ('a', 'Guangzhou'), ('g', 'Shanghai'), ('h', 'Xiamen')]

# sort()函数无返回值
list1 = 'as,jj,bk'
temp = list1.strip().split(',').sort()  # 由于sort()函数无返回值，故无法进行赋值操作
# temp.sort()
print(temp)
>>>
None

#修改后如下：
list1 = 'as,jj,bk'
temp = list1.strip().split(',')
temp.sort()
print(temp)
>>>
['as', 'bk', 'jj']
# 或者
list1 = 'as,jj,bk'
temp=sorted(list1.strip().split(','))
# temp = sorted(temp)
print(temp)
>>>
['as', 'bk', 'jj']

利用sorted() 函数对list进行排序

语法：

sorted(iterable, key=None, reverse=False)

参数：

  • iterable – 可迭代对象。
  • key – 指定用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值：

该方法返回重新排序的列表。

典型范例：

# 例1：
sorted([5, 2, 3, 1, 4])  # 默认为升序
>>>
[1, 2, 3, 4, 5]

"""
你也可以使用 list 的 list.sort() 方法。这个方法会修改原始的 list（返回值为None）。
通常这个方法不如sorted()方便-如果你不需要原始的 list，list.sort()方法效率会稍微高一些。
"""
# 利用key进行倒序排序
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)
>>>
[7, 6, 5, 4, 3, 2, 1, 0]
# 要进行反向排序，也通过传入第三个参数 reverse=True：
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
sorted(example_list, reverse=True)
>>>
[7, 6, 5, 4, 3, 2, 1, 0]

sorted()函数的可迭代对象iterable为字典时

当可迭代对象iterable为字典时，利用sorted()函数可以根据字典的key对可迭代对象进行排序，结果返回按key排序后的新list。

# 例1
random = {1: 'D', 5: 'B', 8: 'B', 4: 'E', 2: 'A'}
random = sorted({1: 'D', 5: 'B', 8: 'B', 4: 'E', 2: 'A'})
print("排序后：", random)
>>>
排序后： [1, 2, 4, 5, 8]

参考链接：
Python3 List sort()方法Python3 sorted()

字典 in 操作符

描述:

Python 字典中 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。 而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。

语法:

key in dict

如果键在字典dict里返回true，否则返回false。

综上所述:

执行[x for x in dict_x]语句，输出结果为由字典dict的键组成的list。例如：

b = {"age":20,"name":"a"}
[x for x in b]  # 输出由dict的键组成的列表list
>>>
['age', 'name']
a = {1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}
[x for x in a] # 输出由dict的键组成的列表list
>>>
[1, 2, 3, 4, 5]

知识点补充——切片
python题字符串重新排列 python中给字符串排序_元组
切片是Python序列的一个重要操作，适用于列表、元组、字符串、range对象等类型。 字典不存在切片操作。
python题字符串重新排列 python中给字符串排序_元组
切片使用2个冒号分隔的3个数字来完成，第一个数字表示切片的开始位置(默认为0)，第二个数字表示切片截至(但不包含)位置(默认为列表长度)，第三个数字表示切片的步长(默认为1)，当步长省略时可以省略最后一个冒号。

由多个含相同键key的dict组成的list可以通过指定相同键key来对各个字典dict进行排序；如果是由多个含不相同键key的dict组成的list则无法执行此操作。 示例如下：

### 正确示范：
"""
由多个含相同键key的dict组成的list可以通过相同键key来对各个字典dict进行排序
"""
# sorted 的应用，也可以通过 key 的值来进行数组/字典的排序，比如
array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
array = sorted(array,key=lambda x:x["age"])
print(array)
>>>
[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]

# 进阶示例：
# 多列排序——先按照成绩降序排序，相同成绩的按照名字升序排序：
# 先按照成绩降序排序，相同成绩的按照名字升序排序：
d1 = [{'name':'alice', 'score':38}, {'name':'bob', 'score':18}, {'name':'darl', 'score':28}, {'name':'christ', 'score':28}]
l = sorted(d1, key=lambda x:(-x['score'], x['name']))
print(l)
>>>
[{'name': 'alice', 'score': 38}, {'name': 'christ', 'score': 28}, {'name': 'darl', 'score': 28}, {'name': 'bob', 'score': 18}]



### 错误示范：
"""
如果是由多个含不相同键key的dict组成的list则无法执行此操作
"""
# 列表
random = [{2:'北京'}, {3: '上海'}, {4:'广州'}, {1:'厦门'}]
# 指定第二个元素排序
random = sorted(random, key=lambda x: x[1])  # 由于各个字典dict不存在相同键key。因此，此处无法通过指定某个相同“key”对各个字典dict进行排序。另外，字典也不允许做切片，所以，不能通过 x[1]取到dict的value值。
# 输出类别
print("排序列表：", random)
>>>
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-228-41a0692456fc> in <module>
      2 random = [{2:'北京'}, {3: '上海'}, {4:'广州'}, {1:'厦门'}]
      3 # 指定第二个元素排序
----> 4 random = sorted(random, key=lambda x: x[1])
      5 # 输出类别
      6 print("排序列表：", random)

<ipython-input-228-41a0692456fc> in <lambda>(x)
      2 random = [{2:'北京'}, {3: '上海'}, {4:'广州'}, {1:'厦门'}]
      3 # 指定第二个元素排序
----> 4 random = sorted(random, key=lambda x: x[1])
      5 # 输出类别
      6 print("排序列表：", random)

KeyError: 1

# 如果将字典格式组成的list，改为由元组格式组成的list，则可以正常运行上述代码

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
# 列表
random = [(2, '北京'), (3, '上海'), (4, '广州'), (1, '厦门')]
# 指定第二个元素排序
random.sort(key=takeSecond)  # 根据元组的第二个元素进行排序
# 输出类别
print("排序列表：", random)
>>>
排序列表： [(3, '上海'), (2, '北京'), (1, '厦门'), (4, '广州')]

## 或者直接使用匿名函数lambda，借助元组切片指定排序的key来实现
# 列表
random = [(2, '北京'), (3, '上海'), (4, '广州'), (1, '厦门')]
# 指定第二个元素排序
random.sort(key=lambda x: x[0])  # 通过元组切片x[0]来指定取各个元组的第一个元素
# 输出类别
print("排序列表：", random)
>>>
排序列表： [(1, '厦门'), (2, '北京'), (3, '上海'), (4, '广州')]

按照字符串中的数字的大小进行排序

譬如，存在一组记录文件，分别为‘1.dat’,‘2.dat’…，如何让这些字符串按照数字进行排列？

1、把该文件夹中的所有记录文件名读到一个列表中；

2、首先通过正则表达式，提取出字符串中的数字；

3、排序，选择built-in函数sorted进行排序；

示例代码如下：

s = ['1.dat','10.dat','5.dat']
new = sorted(s, key = lambda i:int(re.match(r'(\d+)',i).group()))
print(new)
>>>
['1.dat', '5.dat', '10.dat']

## 或者
s = ['1.dat','10.dat','5.dat']
s.sort(key = lambda i:int(re.match(r'(\d+)',i).group()))
print(s)
>>>
['1.dat', '5.dat', '10.dat']

关于re.match(r'(\d+)',i).group()的用法，详见Python3 正则表达式