列表定义
列表是可变序列，通常用于存储数据的集合，是Python中使用最频繁的数据类型。
列表可以用多种方式构建:
使用一对方括号表示空列表: []
使用方括号，用逗号分隔项目: [a], [a, b, c]
使用列表推导: [x for x in iterable]
使用类型构造函数: list() 或 list(iterable)
例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
|
L1 = [1,2,3,4] # 列表L1有四个成员，分别是数字1，数字2，数字3和数字4
L2 = [] # 列表L2是空列表。
a = "hello"
b = "world"
L3 = [x for x in a] # 列表推导生成列表
L4 = list() # 构造函数生成空列表
L5 = list(b) # 根据字符串，转换成列表
print(L1)
print(L2)
print(L3)
print(L4)
print(L5)
|
执行以上程序会输出如下结果：
1
2
3
4
5
|
[1, 2, 3, 4]
[]
['h', 'e', 'l', 'l', 'o']
[]
['w', 'o', 'r', 'l', 'd']
|
其中，用逗号分割的列表，最后一个逗号是可选的。
[1,2,3,4] 和 [1,2,3,4,]都是合法的列表。
列表推导式
列表推导语法：
[ x for x in iterable ]
列表推导式的结构是由一对方括号所包含的以下内容：
一个表达式，后面跟一个for子句，然后是零个或多个for或if子句。其结果将是一个新列表，由对表达式依据后面的 for 和 if 子句的内容进行求值计算而得出。
举例来说，以下列表推导式会将两个列表中不相等的成员组合起来:
1
2
|
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
|
列表推导式可以使用复杂的表达式和嵌套函数。
例如：
1
2
3
|
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
|
嵌套的列表推导式
列表推导式可以嵌套在另一个列表推导式中，形成嵌套列表推导式。
例如，考虑下面这个3x4的矩阵，它由3个长度为4的列表组成
1
2
3
4
5
|
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
|
下面的嵌套列表推导式将交换其行和列。内层的列表推导式是[row[i] for row in matrix]。
1
2
|
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
|
列表中成员的类型可以不相同，它支持数字，字符串甚至可以包含列表（也就是所谓的嵌套）。
例如，下面的列表L3有四个成员，第一个成员是整数1，第二个成员是浮点数10.5，第三个成员是字符串hello，第四个成员是列表[“a”,“b”]，其又包含字符串成员a和b。
L3 = [1,10.5,"hello",["a","b"]]
索引操作
按照索引访问列表，格式如下。
i是索引值。i是正数，从左向右计算，第一个是0，第二个是1，依次类推。i是负数，从右向左计算，第一个是-1，第二个是-2，依次类推。
例如：
1
2
3
4
5
6
7
|
L1 = [1,2,3,4]
a = L1[0] # i是正数，从左向右计算，0表示是第一个。
b = L1[-1] # i是负数，从右向左计算。-1表示第一个。
c = L1[2]
print(a)
print(b)
print(c)
|
执行以上程序会输出如下结果：
切片操作
和字符串一样，列表同样支持切片，列表被截取后返回一个包含所需成员的新列表。
切片操作语法格式如下：
列表[start:end]
start，end都是整数。索引值以 0 为开始值，如果是负数，则从尾部开始。-1为最末尾。
省略start，默认从0开始。
省略end，则获取剩余所有。
同时省略start和end，则复制当前的列表。
例如：
1
2
3
4
5
6
7
8
9
10
11
12
|
L = ['a','b','c','d','e']
print(L) #打印L列表
print(L[0:3])
print(L[3:])
print(L[2:4])
print(L[:4])
print(L[:])
#id内置函数，返回对象的“标识”。它保证在这个对象的生存期内是唯一的和不变的。
#生命周期不重叠的两个对象可能具有相同的id（）值。
print(id(L))
print(id(L[:]))
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
7
8
|
['a', 'b', 'c', 'd', 'e']
['a', 'b', 'c']
['d', 'e']
['c', 'd']
['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd', 'e']
140027734454088
140027734454152
|
注意： L[:]会复制当前的列表，生成一个和列表L一样的新列表。
如果索引start或end超出列表大小，也不会报错。
例如：
1
2
3
4
|
L = ['a','b','c','d','e']
print(L[0:7]) # 列表L没有第七个成员，L[0:7]返回['a','b','c','d','e']，相当于L[0:5]。
print(L[7:]) # 列表L没有第七个以后的成员，L[7:]只能返回空列表[]。
print(L[8:7]) # 看似逻辑不通，但不报错，返回空列表
|
执行以上程序会输出如下结果：
1
2
3
|
['a', 'b', 'c', 'd', 'e']
[]
[]
|
与Python字符串不一样的是，列表是可变对象，列表的成员是可以改变的：
例如：
1
2
3
4
|
L = ['a','b','c','d','e']
L[0] = 1 # 列表L的第一个成员由字符串a变成整数1，L的内容是[1,'b','c','d','e']
L[1:4] = [7,8,9] # 修改列表L第二到第四个成员，L的内容是[1,7,8,9,'e']
L[1:4] = [] # 删除列表L第二到第四个成员,L的内容是[1,'e']
|
列表切片操作可以接收第三个参数step，step参数作用是截取的步长。格式如下：
列表[start:end:step]
以下实例在索引 1 到索引 5 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
列表连接，复制
列表连接运算符 + 将两个列表连接为一个列表。
1
2
3
4
|
L1 = ['a','b']
L2 = ['c','d']
L = L1 + L2
print(L) #列表L，['a','b','c','d']
|
列表重复操作运算符 *。星号后面的数字是重复的次数。数字必须是正整数。
1
2
|
L1 = ['a','b']
L = L1*2 # 重复2次L1，L的结果是['a','b','a','b']
|
列表常用方法
list.append(x)
在列表的末尾添加一个元素。相当于a[len(a):] = [x]。返回值是None。
例如：
1
2
3
4
|
L = ['a','b']
L1 = L.append("0")
print(L1) # None
print(L) # ['a', 'b', '0']
|
list.extend(iterable)
使用可迭代对象中的所有元素来扩展列表。相当于 a[len(a):] = iterable。返回值是None。
例如：
1
2
3
4
|
L = ['a','b']
L1 = L.extend("012")
print(L1) # None
print(L) # ['a', 'b', '0', '1', '2']
|
append与extend方法有什么区别
append表示把某个数据当做新成员追加到列表的最后面，它的参数可以是任意对象。
例如：
1
2
3
4
|
x = [1, 2, 3]
y = [4, 5]
x.append(y)
print(x) # [1, 2, 3, [4, 5]]
|
extend的参数必须是一个可迭代对象，表示把该对象里面的所有成员逐个地追加到列表的后面
例如：
1
2
3
4
5
6
7
|
x = [1, 2, 3]
y = [4, 5]
x.extend(y)
print(x) # [1, 2, 3, 4, 5]
# 等价于：
for i in y:
x.append(i)
|
list.insert(i, x)
在给定的位置插入一个元素。第一个参数是要插入的元素的索引，所以 a.insert(0, x) 插入列表头部，a.insert(len(a), x) 等同于 a.append(x) 。返回值是None。
例如：
1
2
3
4
|
L = ['a','b']
L1 = L.insert(1,"1")
print(L1) #None
print(L) #['a','1','b']
|
list.pop([i])
删除列表中给定位置的元素并返回它。
无参数时，删除list末尾成员，返回值是被删除的成员。
有参数时，删除指定位置成员，返回值是被删除的成员。
例如：
1
2
3
4
5
6
7
|
L = ['a','b','c','d']
L1 = L.pop()
print(L1) # 'd'
print(L) # ['a','b','c']
L2 = L.pop(1)
print(L2) # 'b'
print(L) # ['a','c']
|
list.remove(x)
移除列表中第一个值为 x 的元素。如果没有这样的元素，则抛出 ValueError 异常。返回值是None。
例如：
1
2
3
4
|
L = ['a','b']
L1 = L.remove()
print(L1) # None
print(L) # ['b']
|
list.clear()
删除列表中所有的元素。相当于del a[:] 。
例如：
1
2
3
4
|
L = ['a','b']
L1 = L.clear()
print(L1) # None
print(L) # []
|
list.count(x)
返回元素 x 在列表中出现的次数。
例如：
1
2
3
4
|
L = ['a','b','c','d','c']
print(L.count('a')) # 1
print(L.count('c')) # 2
print(L.count('e')) # 0
|
list.sort(key=None, reverse=False)
对列表中的元素进行排序（参数可用于自定义排序，解释请参见 sorted()）。返回值是None。
例如：
1
2
3
4
|
L = ['a','b','d','c']
L1 = L.sort()
print(L1) # None
print(L) # ['a', 'b', 'c', 'd']
|
list.reverse()
反转列表中的元素。
例如：
1
2
3
4
|
L = ['a','b','d','c']
L1 = L.reverse()
print(L1) # None
print(L) # ['c', 'd', 'b', 'a']
|
list.copy()
返回列表的一个浅拷贝。相当于a[:]。
例如：
1
2
3
|
L = ['a','b','d','c']
L1 = L.copy()
print(L1) # ['a','b','d','c']
|
列表切片技巧
复制列表：
1
2
3
4
5
6
|
l = [1, 2, 3]
m = l[:]
print(id(l))
print(l)
print(id(m))
print((m)
|
执行以上程序会输出如下结果：
1
2
3
4
|
140197504741192
[1, 2, 3]
140197504741000
[1, 2, 3]
|
移除/替换 列表中的任意成员：
1
2
3
|
l = [1, 2, 3]
l[1:-1] = [4, 5, 6, 7]
# l的结果为[1, 4, 5, 6, 7, 3]
|
用切片来删除序列的某一段
1
2
3
|
a = [1, 2, 3, 4, 5, 6, 7]
a[1:4] = []
print(a) # 结果为[1, 5, 6, 7]
|
当然用 del a[1:4] 也是可以的
在列表的开头添加成员：
1
2
3
|
l = [1, 2, 3]
l[:0] = [4, 5, 6]
print(l) # 结果为[4, 5, 6, 1, 2, 3]
|
在列表的尾部添加成员：
1
2
3
|
l = [1, 2, 3]
l[-1:] = [4, 5, 6]
print(l) # 结果为[1, 2, 3, 4, 5, 6]
|
反转列表：
1
2
3
|
l = [1, 2, 3]
l[:] = l[::-1]
print(l) # 结果为[3, 2, 1]
|
转载请注明本网址。