列表 []
目录
一、关于列表
列表对象的本质是一个有序的、可迭代、可切片、可变的序列，内部元素支持任意对象。
是写在方括号 [] 之间、用逗号分隔开的元素列表。
# 声明一个列表对象的变量l
>>> l = ['l', 'i', 'm', 'a', 'n', 'm', 'a', 'n']
>>> type(l)
<type 'list'>
# 查看list类型的定义
>>> help(list)
# 查看list类型的属性和方法
>>> dir(list)
# 让Python2中也可以兼容Python3的print函数用法
>>> from __future__ import print_function
二、对象创建 & 赋值
赋值运算：向内存申请一空闲内存单元存储列表，然后将变量名指向此内存单元首地址，就可通过变量名操作此内存单元数据。
>>> l = ['5', '2', '1']
# 方式1: 通过字面量形式创建
>>> l = ['5', '2', '1']
# 方式2: 通过类型创建
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
"""
>>> l = list('521')
['5', '2', '1']
[] 空列表
>>> list()
[]
列表推导式
英文全称：List Comprehensions。
列表推导式提供了从 序列 创建列表的简单途径。
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
方法调用
# 这里调用 .strip() 方法去除前后空格
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
# 使用 .lower() 将内容改为小写
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']
# 使用复杂表达式或嵌套函数
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
条件过滤
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
以下是一些关于循环和其它技巧的演示：
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
用两个变量来生成 list
for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value：
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> for k, v in d.items():
... print(k, '=', v)
...
y = B
x = A
z = C
因此，列表生成式也可以使用两个变量来生成list：
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']
使用 range
set[x:y:z] 是一个完整的函数
a = range(0,5)
type(a) # range
print(a) # range(0, 3)
>>> l = list(range(5))
[0, 1, 2, 3, 4]
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
字符串和列表
>>> s = '123'
>>> s[::-1] # 字符串反向遍历
'321'
>>> s # 不会改变原来的值
'123'
>>> list(s)
['1', '2', '3']
>>> list(s)[::1]
['1', '2', '3']
>>> ''.join(list(s)[::1])
'123'
# 使用列表的 reverse 方法
>>> a = list(s)
>>> a
['1', '2', '3']
>>> a.reverse()
>>> a
['3', '2', '1']
应用
列出目录名：列出当前目录下的所有文件和目录名，可以通过一行代码实现：
>>> import os # 导入os模块，模块的概念后面讲到
>>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目录
['.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures', 'Public', 'VirtualBox VMs', 'Workspace']
属性
>>>len([1, 2, 3])
3
>>> max(['d', '2', 'a'])
'd'
>>> max(['d', '2', 'ag'])
'd'
查找遍历
索引
>>> a=['Google', 'Runoob', 'Taobao']
>>> a[2]
'Taobao'
>>> a[-2]
'Runoob'
>>> a[1:]
['Runoob', 'Taobao']
使用for循环遍历
>>> g = (x * x for x in range(10))
>>> for n in g:
... print(n)
...
0
1
4
...
使用next()遍历
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
...
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
in/not in 是否存在
>>>3 in [1, 2, 3]
True
>>> for x in [1, 2, 3]: print(x, end=" ")
增加 & 删除
append 添加 & pop 删除
列表是可变的：可以不改变物理地址指向的前提下，实现原地修改。方法：append，pop。
# 添加对象到最后
>>> l.append('!')
>>> l
['a', 'b', 'c', 'd', '!']
>>> id(l)
140550742839456
# 从列表中删除指定索引位置的对象,L.pop([index]) -> item,默认index的值为-1
>>> l.pop(-1)
'!'
>>> l
['a', 'b', 'c', 'd']
>>> id(l)
140550742839456
>>> l = ['5', '2', '1']
# .append(object)
>>> l.append('!')
>>> l
['5', '2', '1', '!']
# .count(value)
>>> l.count('!')
1
>>> l.count('?')
0
# .extend(iterable)
>>> l.extend('1314') # 自动切割了元素
>>> l
['5', '2', '1', '!', '1', '3', '1', '4']
# .index(value, [start, [stop]]) # 查找值出现在了哪个位置
>>> l.index('!')
3
>>> l.index('?')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: '?' is not in list
# .insert(index, object)
>>> l.insert(len(l), '?')
>>> l
['5', '2', '1', '!', '1', '3', '1', '4', '?']
# .pop([index])
>>> l.pop(-1)
'?'
>>> l.pop(len(l))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: pop index out of range
>>> l
['5', '2', '1', '!', '1', '3', '1', '4']
# .remove(value)
>>> l.remove('!')
>>> l.remove('?')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> l
['5', '2', '1', '1', '3', '1', '4']
# .reverse()
>>> l.reverse()
>>> l
['4', '1', '3', '1', '1', '2', '5']
# .sort(cmp=None, key=None, reverse=False)
>>> l.sort(key=lambda i: i, reverse=True)
>>> l
['5', '4', '3', '2', '1', '1', '1']
>>> l = ['5', '2', '1', '1', '3', '1', '4']
>>> 'x' in l and l.remove('x') # 加上这个判断，删除不存在的就不会报错
False
>>> '1' in l and l.remove('1') # 只删除第一次找到的
>>> l
['5', '2', '1', '3', '1', '4']
del 删除
-
使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。
-
可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。例如：
#!/usr/bin/python3
list = ['Google', 'Runoob', 1997, 2000]
print("原始列表 : ", list)
del list[2]
print("删除第三个元素 : ", list)
以上实例输出结果：
原始列表 : ['Google', 'Runoob', 1997, 2000]
删除第三个元素 : ['Google', 'Runoob', 2000]
>>> a = [1, 2, 3, 4, 5, 6]
>>> del a[0]
>>> a
[2, 3, 4, 5, 6]
>>> a = [1, 2, 3, 4, 5, 6]
>>> del a[2:4]
>>> a
[1, 2, 5, 6]
# 删除全部
>>> del a[:]
>>> a
[]
也可以用 del 删除实体变量：
>>> del a
运算
身份运算 is & ==
常用于比较两个对象是否指向同一个 内存单元
is 比较地址，== 比较数值
>>> l is ['5', '2', '1']
False
>>> l = ['5', '2', '1']
>>> l == ['5', '2', '1']
True
数学运算
结果总是隐式转换为复杂类型
# 加法,可结合赋值运算+=
>>>[1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> l = [1, 2, 3]
>>> l += [4, 5, 6]
>>> l
[1, 2, 3, 4, 5, 6]
# 乘法,可结合赋值运算*=
>>> l * 2
[1, 2, 3, 1, 2, 3]
>>>['Hi!'] * 4
['Hi!', 'Hi!', 'Hi!', 'Hi!']
逻辑运算
# 与, 都为真为真
>>> [] and l
[]
# 或, 一个真即真
>>> [] or l
['5', '2', '1']
# 非,总是隐式转换为布尔对象
>>> not l
False
由于列表对象为可变对象, + = / * = 操作的本质为向变量指向的原内存空间添加新的对象,所以指向的内存地址不变
列表运算符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
| 操作符 | 描述 |
|---|---|
| + | 组合 |
| * | 重复 |
[num] |
索引 |
| [:] | 截取 |
| in | 元素是否存在于列表中 |
| not in |
函数
1、Python 内置函数
| 函数 | 说明 |
|---|---|
| len(list) | 列表元素个数 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(seq) | 将元组转换为列表 |
2、列表自身方法
-
.开头是列表自身方法，非内置方法。 -
方法中 方括号[] 表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。
| 方法 | 描述 | |
|---|---|---|
| l.append(x) | 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。 | |
| l.extend(l1) | 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = l1。 | |
| l.insert(i, x) | 在指定位置插入一个元素，原地修改。 | |
| 第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。 | ||
| l.remove(x) | 删除列表中值为 x 的第一个元素，原地修改。如果没有这样的元素，就会返回 ValueError错误。 | |
| l.pop([i]) | 从列表的指定位置移除元素，并将其返回。 | |
| 索引超出则抛出IndexError异常，index默认为-1( 索引超出则抛出IndexError异常，index默认为-1) | ||
| l.clear() | 移除列表中的所有项，等于del a[:]。 | |
| l.index(value, [start, [stop]]) | 计算从start到stop中间value在列表中的索引值并返回,不存在抛出ValueError异常 | |
| l.count(x) | 返回 x 在列表中出现的次数。 | |
l.sort(cmp=None, key=None, reverse=False) |
将列表按照key对应的函数排序，reverse是否倒序，原地修改 | |
| l.reverse() | 将列表的元素倒序，原地修改 | |
| l.copy() | 浅复制，等于a[:]。 |
|
| l.index(value, [start, [stop]]) | 计算从start到stop中间value在列表中的索引值并返回,不存在抛出ValueError异常 | |
| l.insert(index, object) | 将object插入列表中索引为index的位置, |
将列表当做堆栈使用
append、pop
列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。
将列表当作队列使用
append、popleft
也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'
>>> queue.popleft() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
嵌套列表
以下实例展示了3X4的矩阵列表：
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
以下实例将 3X4 的矩阵列表转换为 4X3 列表：
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
以下实例也可以使用以下方法来实现：
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
另外一种实现方法：
>>> transposed = []
>>> for i in range(4):
... # the following 3 lines implement the nested listcomp
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
