列表如同地铁站排好的队伍，有序，可以插队、离队，可以索引。
一个排列整齐的队伍，Python采用顺序表实现
列表内的个体称作元素，由若干元素组成列表
元素可以是任意对象（数字、字符串、对象、列表等）
列表内元素有顺序，可以使用索引
线性的数据结构
使用 [ ] 表示
列表是可变的
形式
ls1 = []
ls2 = list()
ls3 = [2, ‘ab’, [3 , ‘abc’], (5, 30, 50)] # 列表是一个容器，元素可以是其它类型
ls4 = list(range(5)) # 非常常用的构造方式，将一个可迭代对象转换为一个列表
索引
索引，也叫下标
正索引：从左至右，从0开始，为列表中每一个元素编号
如果列表有元素，索引范围[0, 长度-1]
负索引：从右至左，从-1开始
如果列表有元素，索引范围[-长度, -1]
正、负索引不可以超界，否则引发异常IndexError
查询
1 通过下标搜索值
list[index] ，index就是索引，使用中括号访问
例如
a[1]
2 通过值，搜索下标
list.index(value,[start,[stop]])
[start,[stop]] 包左不包右
从左往右找
通过值value，从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError
a.index(2, 2, 6)
list.count(value)
返回列表中匹配value的次数
例如
a=[1,2,3,2,3,2,3,2]
print(a.count(2))
len(list)
返回列表的元素个数
print(len(a))
修改
直接赋值
ls1 = [1,2,3,4]
ls1[2] = 200
增加单个元素
list.append(object) -> None
追加
列表尾部追加元素，返回None
返回None就意味着没有新的列表产生，就地修改
list.insert(index, object) -> None
插入
在指定的索引index处插入元素object
返回None就意味着没有新的列表产生，就地修改
例子
a.append(100)
a.insert(2,222)
增加多个元素
list.extend(iteratable) -> None
将可迭代对象的元素尾部追加进来，返回None
就地修改，本列表自身扩展
+ -> list
连接操作，将两个列表拼接起来，产生新的列表，原列表不变
本质上调用的是魔术方法__add__()方法
* -> list
重复操作，将本列表元素重复n次，返回新的列表，原列表不变
只是简单的一层是可以重复后更改元素
如果是列表套列表，再重复，然后替换，就会出现全部被替换的情况
列表中的列表位置存放的是列表的地址，所以修改b[1][0]也就相当于同时在修改b[2][0]``b[3][0]，*3相当于把b[1]的内存地址复制了3次，所以b[1]``b[2]``b[3]第一是同一个
删除
list.remove(value) -> None
通过值来删除，没有返回值
从左至右查找第一个匹配value的值，找到就移除该元素，并返回None，否则ValueError
就地修改
效率低，需要遍历列表
list.pop([index]) -> item
通过下标来删除，返回值为下标对应的值
不指定索引index，就从列表尾部弹出一个元素
指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
效率不高
list.clear() -> None
清除列表所有元素，剩下一个空列表
反转
list.reverse() -> None
将列表元素反转，返回None
就地修改
这个方法最好不用，可以倒着读取，都不要反转
排序
list.sort(key=None, reverse=False) -> None
对列表元素进行排序，就地修改，默认升序
reverse为True，反转，降序
key一个函数，指定key如何排序，lst.sort(key=function)
print(a)
[33, 44, 9, 'a']
a.sort(key=str,reverse=True)
print(a)
['a', 9, 44, 33]
b=[2,33,222,1111,7]
b.sort(key=str)
print(b)
[1111, 2, 222, 33, 7]
in成员操作
in判断在不在，返回的是个bool值
for x in [1,2,3,4]:
pass
性能低，需要遍历
列表复制
a=list(range(5))
b=list(range(5))
print(a==b)
True
c=a
print(a)
[0, 1, 2, 3, 4]
print(c)
[0, 1, 2, 3, 4]
id(a)
Out[81]: 2979549093064
id(c)
Out[82]: 2979549093064
c[2]=5
print(a)
[0, 1, 5, 3, 4]
print(c)
[0, 1, 5, 3, 4]
c=b
并不是赋值了数据
只是赋值了b的地址
is
a is b
就是比的内存地址
哪怕a的数据与b的数据相同，地址不一样，也是False
copy
copy复制的是内容
d=c.copy()
print(c)
[0, 1, 5, 3, 4]
print(d)
[0, 1, 5, 3, 4]
id(c)
Out[89]: 2979549093064
id(d)
Out[90]: 2979549210952
print(c==d,c is d)
True False
shadow copy
影子拷贝，也叫浅拷贝。遇到引用类型数据，仅仅复制一个引用而已
单独用copy也是浅拷贝
a=[1,2,3,[1,2,3,4,5],3,4]
b=a.copy()
id(a)
Out[98]: 2979549219272
id(b)
Out[99]: 2979549280008
id(a[3])
Out[100]: 2979549217288
id(b[3])
Out[101]: 2979549217288
deep copy
深拷贝，往往会递归复制一定深度
需要导入copy模块
import copy
a = [1, [2 , 3], 4]
b = copy.deepcopy(a)
原文地址：http://www.cnblogs.com/guangdelw/p/16918389.html
