一. 列表的创建
- 创建一个空列表：
list()或[]； - 使用可迭代对象创建一个列表：
list(可迭代对象)
>> []
[]
>> list()
[]
>> list("abc")
['a', 'b', 'c']
二. 列表的运算
列表实现的算数运算符有：+ += * *=；
关系运算：!= == >；
成员运算符：in not in；
逻辑运算符：and or not
2.1 乘法运算
列表将作为一个序列整体，进行乘法运算：
>> l = list(range(3))
>> l
[0, 1, 2]
>> l * 2
[0, 1, 2, 0, 1, 2]
2.2 加法运算
+ 运算符的另一端必须是列表；+= 运算符的另一端可以是任何的迭代器：
>> l + [3, 4, 5]
[0, 1, 2, 3, 4, 5]
定一个生成器函数：
def my_iter():
for i in range(3,6):
yield i
+ 运算符连接列表和生成器：
>> i = my_iter()
>> l + i
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-9-30c132c08838> in <module>()
1 i = my_iter()
----> 2 l + i
TypeError: can only concatenate list (not "generator") to list
+= 运算符连接列表和生成器：
>> l += i
>> l
[0, 1, 2, 3, 4, 5]
+= 运算符右侧也可以是其它任何形式的迭代器：
>> l += '678'
>> l
[0, 1, 2, 3, 4, 5, '6', '7', '8']
>> l += ['91011']
>> l
[0, 1, 2, 3, 4, 5, '6', '7', '8', '91011']
2.3 成员运算符
列表包含对象则返回 True ：
>> 6 in l
False
>> '6' in l
True
2.4 逻辑运算
>> a = [1, 2, 3] and []
>> a
[]
>> b = [1, 2, 3] or []
>> b
[1, 2, 3]
>> not []
True
三. 列表切片
切片操作通常用来复制列表，如：[:]，或进行切片赋值。使用切片赋值的格式：列表[切片slice] = 可迭代对象。
语法：[起始：结束：步长]，省略步长时，默认为1。
切片赋值一次修改多个元素：
>> l = [0, 2, 4, 6]
>> l[1:3] = [20, 40]
>> l
[0, 20, 40, 6]
切片赋值增加列表元素：
>> l = [0, 2, 4, 6]
>> l[4:] = [8, 10]
>> l
[0, 2, 4, 6, 8, 10]
切片赋值在不替换任何元素的情况下，为列表插入新元素：
>> l = [0, 2, 4, 6]
>> l[2:2] = 'abc'
>> l
[0, 2, 'a', 'b', 'c', 4, 6]
切片赋值删除列表元素：
>> l = [0, 2, 4, 6]
>> l[1:3] = []
>> l
[0, 6]
列表倒序：
>> l = [0, 2, 4, 6]
>> l[::-1]
[6, 4, 2, 0]
四. 列表常用函数
| 函数 | 说明 |
|---|---|
| len() | 返回列表长度 |
| min() | 返回列表中的最小值 |
| max() | 返回列表中的最大值 |
| sum() | 返回列表中所有元素的和 |
备注：sum(列表[,起始值]) 起始值缺省为 0，即从 0 开始叠加。
五. 列表常用方法
| 方法 | 说明 |
|---|---|
| L.index() | 返回列表中某个元素的索引，无此元素则抛出异常。 |
| L.count() | 返回列表中对应元素的个数。 |
| L.append() | 向列表添加元素，返回值为 None。 |
| L.extend(可迭代对象) | 向列表追加另一个列表，返回值为 None。 |
| L.insert(index, obj) | 向列表指定位置插入元素，返回值为 None。 |
| L.pop() | 删除索引对应的元素，缺省时删除末尾元素；存在返回值，返回值为弹出的元素。 |
| L.remove() | 删除列表中第一次出现的值，返回值为 None。 |
| L.copy() | 浅拷贝列表：只拷贝一层，不会拷贝深层对象，相当于 L[::]。 |
| L.reverse() | 反转列表的排列顺序，返回值为 None，相当于 L[::-1]。 |
| L.sort() | 按顺序重新排列列表元素，返回值为 None，此方法对列表的修改是永久性的；sorted() 函数返回排序后的列表，原列表不会被修改。key 指定排序的规则，通常使用 lambda 表达式指定，reverse=False 默认升序，reverse=True 则降序； |
| L.clear() | 清空列表，相当于 L[:] = []；此时 id(L) 的值不变，而 L = [] 相当于重新绑定对象，id(L) 的值也会改变。 |
六. 深拷贝、浅拷贝、不拷贝
- 浅拷贝：浅拷贝是指在复制过程中，只复制一层变量，并不会复制深层变量绑定的对象。
列表的 copy 方法实现的则是浅拷贝：
>> L1 = ['A', 'B', 'C']
>> L2 = ['a', 'b', 'c', L1]
>> L2
['a', 'b', 'c', ['A', 'B', 'C']]
>> L3 = L2.copy()
>> L3
['a', 'b', 'c', ['A', 'B', 'C']]
修改 L2 第一层的元素：
我们发现列表的 copy 方法确实对第一层元素进行了拷贝，修改 L2 不会影响 L1 。下面我们对 L2 的深层元素进行修改：
由于浅拷贝只拷贝一层，即 L2 和 L3 中嵌套的列表其实是同一个列表 L1 ，因此修改 L1 ， L2 和 L3 都将发生改变。此外，列表的切片操作，实则也是浅拷贝：
- 深拷贝：对所有可变对象进行层层复制，实现对象的各自独立。
>> import copy
>> L1 = ['A', 'B', 'C']
>> L2 = ['a', 'b', 'c', L1]
>> L5 = copy.deepcopy(L2)
>> L5
['a', 'b', 'c', ['A', 'B', 'C']]
修改深层列表元素：
- 不拷贝
等号赋值，如：L6 = L2，实则是将两个变量绑定到了同一个列表，并没有产生任何新的列表：
>> import copy
>> L1 = ['A', 'B', 'C']
>> L2 = ['a', 'b', 'c', L1]
>> L6 = L2
>> L6
['a', 'b', 'c', ['A', 'B', 'C']]
修改 L2 和 L1 ，L6 都将发生变化：
七. split 、 join
| 方法 | 说明 |
|---|---|
| str.split(sep=None) | 使用 sep 作为分隔符分割字符串，返回分割后的字符串列表；缺省时使用空白分隔符。 |
| str.join(iterable) | 用可迭代对象中提供的字符串，返回一个中间用 str 分割的字符串，即用字符串把可迭代对象粘成一个新的字符串。 |
具体用法如下：
