Python之列表

列表

什么是列表

列表（list）是包含若干元素的有序连续内存空间。当列表增加或删除元素时，列表对象自动进行内存的扩展或收缩，从而保证相邻元素之间没有缝隙。

在Python中，同一个列表中元素的数据类型可以各不相同，可以同时包含整数、实数、字符串等基本类型的元素，也可以包含列表、元组、字典、集合、函数以及其他任意对象。

例如：
[‘spam’, 2.0, 5, [10, 20]]
[[‘file1’, 200,7], [‘file2’, 260,9]]
[{3}, {5:6}, (1, 2, 3)]

列表的创建

使用“=”直接将一个列表赋值给变量即可创建列表对象

使用list()函数把元组、range对象、字符串、字典、集合或其他可迭代对象转换为列表。

>>> list((3,5,7,9,11))                #将元组转换为列表
[3, 5, 7, 9, 11]
>>> list(range(1, 10, 2))             #将range对象转换为列表
[1, 3, 5, 7, 9]
>>> list('hello world')               #将字符串转换为列表
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> list({3,7,5})                     #将集合转换为列表
[3, 5, 7]
>>> list({'a':3, 'b':9, 'c':78})      #将字典的“键”转换为列表
['a', 'c', 'b']
>>> list({'a':3, 'b':9, 'c':78}.items())#将字典的“键:值”对转换为列表
[('b', 9), ('c', 78), ('a', 3)]
>>> x = list()                          #创建空列表

列表的删除

使用del命令将其删除，这一点适用于所有类型的Python对象。

>>> x = [1, 2, 3]
>>> del x                      #删除列表对象
>>> x                          #对象删除后无法再访问，抛出异常
NameError: name 'x' is not defined

列表的访问

访问列表时：0表示第1个元素，1表示第2个元素，2表示第3个元素，以此类推；列表还支持使用负整数作为下标，其中-1表示最后1个元素，-2表示倒数第2个元素，-3表示倒数第3个元素，以此类推。

>>> x = list('Python')             #创建类别对象
>>> x
['P', 'y', 't', 'h', 'o', 'n']
>>> x[0]                           #下标为0的元素，第一个元素
'P'
>>> x[-1]                          #下标为-1的元素，最后一个元素
'n'

列表的常用方法

append()、insert()、extend()

append()用于向列表尾部追加一个元素，insert()用于向列表任意指定位置插入一个元素，extend()用于将另一个列表中的所有元素追加至当前列表的尾部。这3个方法都属于原地操作，不影响列表对象在内存中的起始地址。

>>> x = [1, 2, 3]
>>> x.append(4)                     #在尾部追加元素
>>> x.insert(0, 0)                  #在指定位置插入元素
>>> x.extend([5, 6, 7])             #在尾部追加多个元素

pop()、remove()、clear()

pop()用于删除并返回指定位置（默认是最后一个）上的元素；remove()用于删除列表中第一个值与指定值相等的元素；clear()用于清空列表中的所有元素。这3个方法也属于原地操作。
另外，还可以使用del命令删除列表中指定位置的元素，同样也属于原地操作。

>>> x = [1, 2, 3, 4, 5, 6, 7]
>>> x.pop()                        #弹出并返回尾部元素
7
>>> x.pop(0)                       #弹出并返回指定位置的元素
1
>>> x.clear()                      #删除所有元素
>>> x
[]
>>> x = [1, 2, 1, 1, 2]
>>> x.remove(2)                    #删除首个值为2的元素
>>> del x[3]                       #删除指定位置上的元素
>>> x
[1, 1, 1]

count()、index()

count()用于返回列表中指定元素出现的次数；index()用于返回指定元素在列表中首次出现的位置

>>> x = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
>>> x.count(3)                     #元素3在列表x中的出现次数
3
>>> x.count(5)                     #不存在，返回0
0
>>> x.index(2)                     #元素2在列表x中首次出现的索引
1
>>> x.index(5)                     #列表x中没有5，抛出异常
ValueError: 5 is not in list

list()、 filter()、 reduce()、lambda()

list 函数：list 函数用于将一个可迭代对象（如元组或字符串）转换为列表。例如，可以使用 list 函数将元组转换为列表：

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # 输出: [1, 2, 3]

filter 函数：filter 函数用于根据指定条件筛选出满足条件的元素，并返回一个可迭代对象。它接受两个参数：一个是函数（用于判断条件），另一个是可迭代对象。例如，下面的代码使用 filter 函数从列表中筛选出偶数：

my_list = [1, 2, 3, 4, 5, 6]
filtered_list = list(filter(lambda x: x % 2 == 0, my_list))
print(filtered_list)  # 输出: [2, 4, 6]

在上面的例子中，lambda x: x % 2 == 0 是一个匿名函数，用于判断元素是否为偶数。

lambda 函数：lambda 函数也称为匿名函数，它是一种定义简单函数的方式，不需要使用 def 关键字来定义函数。lambda 函数通常在需要一个简单的函数，但不想定义具名函数的情况下使用。例如，下面的代码定义了一个简单的 lambda 函数，用于计算两个数的和：

add_numbers = lambda x, y: x + y
result = add_numbers(3, 4)
print(result)  # 输出: 7

reduce 函数：reduce 函数位于 functools 模块中，用于将一个二元操作函数应用于序列的前两个元素，然后将结果与下一个元素再次应用该函数，直到处理完整个序列并返回最终结果。

from functools import reduce

sequence = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, sequence)
print(result)  # 输出：15

在上述示例中，我们使用 reduce 函数对序列 [1, 2, 3, 4, 5] 执行了累加操作。lambda x, y: x + y 是一个匿名函数，它接收两个参数 x 和 y 并返回它们的和。reduce(lambda x, y: x + y, sequence) 将这个匿名函数应用于序列中的所有元素，并返回累加的结果。

列表支持的运算

加法运算符+

可以实现列表增加元素的目的，但不属于原地操作，而是返回新列表，涉及大量元素的复制，效率非常低。使用复合赋值运算符+=实现列表追加元素时属于原地操作，与append()方法一样高效。

>>> x = [1, 2, 3]
>>> id(x)
53868168
>>> x = x + [4]                        #连接两个列表
>>> x
[1, 2, 3, 4]
>>> id(x)                              #内存地址发生改变
53875720
>>> x += [5]                           #为列表追加元素
>>> x
[1, 2, 3, 4, 5]
>>> id(x)                              #内存地址不变
53875720

乘法运算符*

用于列表和整数相乘，表示序列重复，返回新列表。运算符*=也可以用于列表元素重复，属于原地操作

>>> x = [1, 2, 3, 4]
>>> id(x)
54497224
>>> x = x * 2                           #元素重复，返回新列表
>>> x
[1, 2, 3, 4, 1, 2, 3, 4]
>>> id(x)                               #地址发生改变
54603912
>>> x *= 2                              #元素重复，原地进行
>>> x
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
>>> id(x)                               #地址不变
54603912

成员测试运算符in

用于测试列表中是否包含某个元素，查询时间随着列表长度的增加而线性增加，而同样的操作对于集合而言则是常数级的。

>>> 3 in [1, 2, 3]
True
>>> 3 in [1, 2, '3']
False

内置函数对列表的操作

max()、min()函数用于返回列表中所有元素的最大值和最小值
sum()函数用于返回列表中所有元素之和
len()函数用于返回列表中元素个数
zip()函数用于将多个列表中元素重新组合为元组并返回包含这些元组的zip对象
enumerate()函数返回包含若干下标和值的迭代对象
map()函数把函数映射到列表上的每个元素
filter()函数根据指定函数的返回值对列表元素进行过滤
all()函数用来测试列表中是否所有元素都等价于True
any()用来测试列表中是否有等价于True的元素

标准库functools中的reduce()函数以及标准库itertools中的compress()、groupby()、dropwhile()等大量函数也可以对列表进行操作

>>> x = list(range(11))              #生成列表
>>> import random
>>> random.shuffle(x)                #打乱列表中元素顺序
>>> x
[0, 6, 10, 9, 8, 7, 4, 5, 2, 1, 3]
>>> all(x)                           #测试是否所有元素都等价于True
False
>>> any(x)                           #测试是否存在等价于True的元素
True
>>> max(x)                           #返回最大值
10
>>> max(x, key=str)                  #按指定规则返回最大值
9
>>> min(x)
0
>>> sum(x)                    #所有元素之和
55
>>> len(x)                    #列表元素个数
11
>>> list(zip(x, [1]*11))      #多列表元素重新组合
[(0, 1), (6, 1), (10, 1), (9, 1), (8, 1), (7, 1), (4, 1), (5, 1), (2, 1), (1, 1), (3, 1)]
>>> list(zip(range(1,4)))     #zip()函数也可以用于一个序列或迭代对象
[(1,), (2,), (3,)]
>>> list(zip(['a', 'b', 'c'], [1, 2]))    #如果两个列表不等长，以短的为准
[('a', 1), ('b', 2)]
>>> enumerate(x)              #枚举列表元素，返回enumerate对象
<enumerate object at 0x00000000030A9120>
>>> list(enumerate(x))        #enumerate对象可以转换为列表、元组、集合
[(0, 0), (1, 6), (2, 10), (3, 9), (4, 8), (5, 7), (6, 4), (7, 5), (8, 2), (9, 1), (10, 3)]

列表推导式

列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性。
列表推导式语法形式为：
[expression for expr1 in sequence1 if condition1
for expr2 in sequence2 if condition2
for expr3 in sequence3 if condition3
…
for exprN in sequenceN if conditionN]

列表推导式在逻辑上等价于一个循环语句，只是形式上更加简洁。例如：

>>> aList = [x*x for x in range(10)]
# 相当于
>>> aList = []
>>> for x in range(10):
    aList.append(x*x)

>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> aList = [w.strip() for w in freshfruit]
# 等价于下面的代码
>>> aList = []
>>> for item in freshfruit:
        aList.append(item.strip())

列表输入元素

eval是Python的一个内置函数，功能十分强大，这个函数的作用是，返回传入字符串的表达式的结果。就是说：将字符串当成有效的表达式 来求值 并 返回计算结果。

eval函数就是实现list、dict、tuple与str之间的转化，同样str函数把list，dict，tuple转为为字符串

a=input()
item=a.split(" ") # 使用字符串的split()方法，将字符串a按照空格进行分割，得到一个包含多个子串的列表
list=[eval(x) for x in item] # 使用列表推导式，遍历列表item中的每个子串，并将其转换为对应的数字
print(list)

切片操作

在形式上，切片使用2个冒号分隔的3个数字来完成。
[start: end :step]

第一个数字start表示切片开始位置，默认为0；
第二个数字end表示切片截止（但不包含）位置（默认为列表长度）；
第三个数字step表示切片的步长（默认为1）。
当start为0时可以省略，当end为列表长度时可以省略，当step为1时可以省略，省略步长时还可以同时省略最后一个冒号。
当step为负整数时，表示反向切片，这时start应该在end的右侧才行

（1）使用切片获取列表部分元素

使用切片可以返回列表中部分元素组成的新列表。与使用索引作为下标访问列表元素的方法不同，切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::]                #返回包含原列表中所有元素的新列表
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::-1]              #返回包含原列表中所有元素的逆序列表
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> aList[::2]               #隔一个取一个，获取偶数位置的元素
[3, 5, 7, 11, 15]
>>> aList[1::2]              #隔一个取一个，获取奇数位置的元素
[4, 6, 9, 13, 17]
>>> aList[3:6]               #指定切片的开始和结束位置
[6, 7, 9]
>>> aList[0:100]             #切片结束位置大于列表长度时，从列表尾部截断
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[100]               #抛出异常，不允许越界访问
IndexError: list index out of range

（2）使用切片为列表增加元素

可以使用切片操作在列表任意位置插入新元素，不影响列表对象的内存地址，属于原地操作。

>>> aList = [3, 5, 7]
>>> aList[len(aList):]
[]
>>> aList[len(aList):] = [9]       #在列表尾部增加元素
>>> aList[:0] = [1, 2]             #在列表头部插入多个元素
>>> aList[3:3] = [4]               #在列表中间位置插入元素
>>> aList
[1, 2, 3, 4, 5, 7, 9]

（3）使用切片替换和修改列表中的元素

>>> aList = [3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3]           #替换列表元素，等号两边的列表长度相等
>>> aList
[1, 2, 3, 9]
>>> aList[3:] = [4, 5, 6]           #切片连续，等号两边的列表长度可以不相等
>>> aList
[1, 2, 3, 4, 5, 6]
>>> aList[::2] = [0]*3              #隔一个修改一个
>>> aList
[0, 2, 0, 4, 0, 6]
>>> aList[::2] = ['a', 'b', 'c']    #隔一个修改一个
>>> aList
['a', 2, 'b', 4, 'c', 6]

（4）使用切片删除列表中的元素

>>> aList = [3, 5, 7, 9]
>>> aList[:3] = []                  #删除列表中前3个元素
>>> aList
[9]

也可以结合使用del命令与切片结合来删除列表中的部分元素，并且切片元素可以不连续。

>>> aList = [3, 5, 7, 9, 11]
>>> del aList[:3]                   #切片元素连续
>>> aList
[9, 11]
>>> aList = [3, 5, 7, 9, 11]
>>> del aList[::2]                  #切片元素不连续，隔一个删一个
>>> aList
[5, 9]