Python 列表使用技巧

约定不等于承诺〃 2023-07-24 14:54 28阅读 0赞

### 文章目录 ###

*  1.列表表达式与列表排序
 *  2.按照子列表中的某个元素对列表进行排序
 *  3.快速生成嵌套列表

# 1.列表表达式与列表排序 #

列表中的元素也是可迭代的对象如列表、元组等时，要根据这些元素的某个子元素对列表排序，常规排序方式失效，需要用`sorted()`函数并指定key。  
题目：

> 输入一组数到列表nums，请找到列表中任意两个元素相加能够等于9的元素，形成一个元组，使其小数在前大数在后，如：(2,7),(1,8)。重复的元组元素只保留一个，结果按元组第一个元素从小到大顺序输出。  
> 【样例输入】
> 
> numbers:3,4,5,7,2,8,1
> 
> 【样例输出】
> 
> \[(1, 8), (2, 7), (4, 5)\]

示例解答如下：

def get_tuple(num_list):
        temp_list = []
        for i in num_list:
            if (9 - i) in num_list:
                min = (9 - i) if (i >= (9 - i)) else i
                max = i if min == (9 - i) else (9 - i)
                if (min,max) not in temp_list:
                    temp_list.append((min,max))
        return temp_list
    
    nums = input()
    num_list = [int(i) for i in nums.split(',')]
    
    result_list = get_tuple(num_list)
    result_list = sorted(result_list,key=lambda i:i[0])
    
    print(result_list)

代码运行演示如下：  
![list comprehension][]  
说明：  
`[int(i) for i in nums.split(',')]`是列表表达式，有更高的执行效率；  
`sorted(result_list,key=lambda i:i[0])`对列表进行排序，因为列表中有多个元素，要根据每个元素的第一个子元素来排序，必须使用key来指定排序所依据的元素，同时还是用了lambda表达式，给定一个元素，返回第一个子元素。

# 2.按照子列表中的某个元素对列表进行排序 #

例如，有一个列表`unsorted_list = [['a', 'b', 'c', 5, 'd'], ['e', 'f', 'g', 3, 'h'], ['i', 'j', 'k', 4, 'm']]`，需要按照每个子列表中的第4个元素（即整数）对列表进行排序，有3种方式：  
方式一——使用lambda表达式

unsorted_list = [['a', 'b', 'c', 5, 'd'], ['e', 'f', 'g', 3, 'h'], ['i', 'j', 'k', 4, 'm']]
    sorted_list = sorted(unsorted_list, key=lambda x: x[3])
    print(unsorted_list)
    print(sorted_list)

打印：

[['a', 'b', 'c', 5, 'd'], ['e', 'f', 'g', 3, 'h'], ['i', 'j', 'k', 4, 'm']]
    [['e', 'f', 'g', 3, 'h'], ['i', 'j', 'k', 4, 'm'], ['a', 'b', 'c', 5, 'd']]

显然，得到了排序后的新列表；  
其中，lambda表达式返回每个子列表的第4个元素，sorted函数使用lambda表达式的返回值作为key来对列表排序。

方式二——使用itemgetter类

from operator import itemgetter
    unsorted_list = [['a', 'b', 'c', 5, 'd'], ['e', 'f', 'g', 3, 'h'], ['i', 'j', 'k', 4, 'm']]
    sorted_list = sorted(unsorted_list, key=itemgetter(3), reverse=True)
    print(unsorted_list)
    print(sorted_list)

打印：

[['a', 'b', 'c', 5, 'd'], ['e', 'f', 'g', 3, 'h'], ['i', 'j', 'k', 4, 'm']]
    [['a', 'b', 'c', 5, 'd'], ['i', 'j', 'k', 4, 'm'], ['e', 'f', 'g', 3, 'h']]

显然，得到了排序的结果；  
可以用reverse参数使结果倒序。

方式三——调用列表的`sort()`方法

unsorted_list = [['a', 'b', 'c', 5, 'd'], ['e', 'f', 'g', 3, 'h'], ['i', 'j', 'k', 4, 'm']]
    print(unsorted_list)
    unsorted_list.sort(key=lambda x: x[3])
    print(unsorted_list)

显然，得到了正确的排序结果；  
调用`sort()`方法是对原列表排序，不会产生新的列表。

# 3.快速生成嵌套列表 #

需要生成列表如下:

[[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, 43, 44, 45, 46, 47, 48],
     [49, 50, 51, 52, 53, 54, 55, 56],
     [57, 58, 59, 60, 61, 62, 63, 64]]

显然,这是一个8×8的嵌套列表，并且元素逐渐递增,如果手动输入肯定很麻烦，因此可以使用列表推导式，并且是嵌套列表推导式，如下:

ls = [[j for j in range(i, i+8)] for i in range(1, 64, 8)]
    print(ls)

即可实现。

[list comprehension]: /images/20230528/3fd35e5463974bda9da4426e9cd2c959.png