列表list，一个有序的队列
列表内的个体为元素，由若干个元素按照顺序进行排列，列表是可变化的，也就是说可以增删
list定义
常用的列表定义方式： 使用[] 或者 a = list()
取数列表可以用range()
列表查询方法
index
index = 索引，以0开始查找
方法:value，[start,[stop]]
通过对应位置的索引进行查找，找到列表内的元素是否有匹配，如有则返回索引值
匹配到第一个元素则立即返回索引位
有时候从右边查找更加便利，比如反斜杠/ 从右边找更加便捷
例：
In [22]: a
Out[22]: [1, 2, 3, 5, 10, 20, 33, 55]
In [23]: a.index(3)
Out[23]: 2
In [24]: a.index(33)
Out[24]: 6
从右向左查找 index(value, [start, [stop]])
从某个值开始查找
In [46]: a.index(33,3)
Out[46]: 6
In [50]:a.index(55,-1)
Out[50]: 7
计算元素出现的次数
In [53]: a = [1,1,1,3,2,11,5,43,1,1]
In [54]: a.count(1)
Out[54]: 5
时间复杂度
计算机科学中，算法的时间复杂度是一个函数，它定性描述了该算法的运行时间。这是一个关于代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。使用这种方式时，时间复杂度可被称为是渐近的，它考察当输入值大小趋近无穷时的情况
index 和count 方法对应的时间复杂度
数学符号对应 O
O(n)
O(2)
O(1)
n表示多少个元素，意思为有多少个元素就从前到后多少个元素
将所有的元素都遍历一遍
需要考虑index方法和count方法适用性，是否该用，选型哪个需要考虑
随着列表数据规模增加而效率下降，如果能做到O1/2/3 这样则可以很快返回结果
list列表元素修改
对某一项索引位置赋值(修改)
In [59]: a
Out[59]: [1, 1, 1, 3, 2, 11, 5, 43, 1, 1]
In [60]: a[1] = 2
In [61]: a
Out[61]: [1, 2, 1, 3, 2, 11, 5, 43, 1, 1]
列表就地修改
对列表本身进行追加元素
lst.append(100)
[1, 2, 3, 2, 2, 5, 6, 100]
append 对list进行增加元素，返回一个None
In [71]: lst = [1,2,3,2,2,5,6]
In [72]: a = lst.append(100)
In [73]: type(a)
Out[73]: NoneType
In [74]: a
In [75]: print(a)
None
这里返回值为空
list运算
In [77]: a = [1,2,3]
In [78]: a * 3
Out[78]: [1, 2, 3, 1, 2, 3, 1, 2, 3]
这里有返回打印
有输出则是没有被就地修改，都是构造新的列表
我们看到增加之后原列表发生了变化，这样被称为就地修改，就地修改为只对当前列表进行修改，修改的是对象的本身
append对时间复杂度为O(1),因为通过索引进行修改，而且是从尾部进行修改
这样通过索引线性修改所耗时间很快，并非O(n) ，O（n)为逐步遍历，找到某个项再进行修改
insert 插入元素
In [81]: a.insert(1,‘a‘)
In [82]: a
Out[82]: [1, ‘a‘, 2, 3]
insert 为在指定处插入对象，这样会引起整个内存结构变化，所有数据统一向后错位，如果量级大则不要去做，尽可能new一个
所以尽可能避免挪动
insert时间复杂度为 O(n),如果放在开头则不建议，一般list规模很大，所以要考虑效率问题
所以，insert更适合链表方式
extend 将迭代对象追加
迭代对象不用解释了，可以是列表，可以是字典等等
b = {‘c‘:123}
In [85]: a.extend(b)
In [86]: a
Out[86]: [1, ‘a‘, 2, 3, ‘c‘]
追加迭代自己
In [88]: a.extend(a)
In [89]: a
Out[89]: [1, ‘a‘, 2, 3, ‘c‘, 1, ‘a‘, 2, 3,‘c‘]
remove 删除某个元素
remove 为删除某个内容，而并非索引
remove 为就地修改，在做位置的挪动，所以这里需要注重效率
In [89]: a
Out[89]: [1, ‘a‘, 2, 3, ‘c‘, 1, ‘a‘, 2, 3,‘c‘]
In [90]: a.remove(1)
In [91]: a
Out[91]: [‘a‘, 2, 3, ‘c‘, 1, ‘a‘, 2, 3,‘c‘]
In [92]: a.remove(1)
In [93]: a
Out[93]: [‘a‘, 2, 3, ‘c‘, ‘a‘, 2, 3, ‘c‘]
在顺序列表中，在中间包括开头，需要考虑效率问题
pop 弹出
从尾部进行弹出并且删除尾部的元素
In [103]: a = [1,2,3,11,13,12,20]
In [104]: a.pop()
Out[104]: 20
pop效率为O(1) 由于是在尾部进行就地修改，所以效率非常高
使用index进行pop，而索引则是从1开始并非是0
In [108]: a.pop(0)
Out[108]: 1
In [109]: a
Out[109]: [2, 3, 11, 13, 12]
pop的特性直接将前端显示，移除+修改并行操作
在清除对象过多的情况下，会引起大规模GC垃圾回收，同样要考虑到效率问题
list的排序
sort() 排序
In [113]: a = [63,1,44,2,19,94,64,21]
In [114]: a.sort()
In [115]: a
Out[115]: [1, 2, 19, 21, 44, 63, 64, 94]
reverse进行到排序
默认为： sort(Key=None,reverse=False)
默认情况下是升序排列，降序由大到小，那么进行到排序：
In [116]: a.sort(reverse=True)
In [117]: a
Out[117]: [94, 64, 63, 44, 21, 19, 2, 1]
但是当前如果遇到字符串则无法进行
In [117]: a
Out[117]: [94, 64, 63, 44, 21, 19, 2, 1]
In [118]: a.append(‘haha‘)
In [119]: a.sort(reverse=False)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-119-83555bcb738d> in<module>()
----> 1 a.sort(reverse=False)
TypeError: unorderable types: str() <int()
那么我们可以使用key=None 的方法进行对字符串排序
In [121]: a.sort(key=str)
In [122]: a
Out[122]: [1, 19, 2, 21, 44, 63, 64, 94,‘haha‘]
In [123]: a.sort(key=str,reverse=True)
In [124]: a
Out[124]: [‘haha‘, 94, 64, 63, 44, 21, 2,19, 1]
同样可以按照字母进行正排倒排
In [125]: a.append(‘ab‘)
In [126]: a.append(‘ba‘)
In [127]: a.sort(key=str,reverse=True)
In [128]: a
Out[128]: [‘haha‘, ‘ba‘, ‘ab‘, 94, 64, 63,44, 21, 2, 19, 1]
In [129]: a.sort(key=str)
In [130]: a
Out[130]: [1, 19, 2, 21, 44, 63, 64, 94,‘ab‘, ‘ba‘, ‘haha‘]
排序规则：将每个元素转为字符串，其都是直接转为ASCII码进行排序，这里的str为当前定义的函数，如果是自己写的函数可以自定义排序规则
取随机数
涉及random
choice 从非空序列的元素中随机选择
In [167]: a
Out[167]: [1, 19, 2, 21, 44, 63, 64, 94,‘ab‘, ‘ba‘, ‘haha‘]
In [168]: import random
In [169]: random.choice(a)
Out[169]: 1
In [170]: random.choice(a)
Out[170]: 64
randrange取之间的随机数的，以及步长
In [172]: random.randrange(1,10)
Out[172]: 5
shuffle 打乱元素
In [174]: random.shuffle(a)
In [175]: a
Out[175]: [94, 64, ‘ba‘, 21, 44, 19, 63, 2,1, ‘ab‘, ‘haha‘]
列表复制
== 和is 的区别
In [131]: lst0 = list(range(4))
In [132]: lst0
Out[132]: [0, 1, 2, 3]
In [133]: id(lst0)
Out[133]: 140196597896584
首先进行哈希匹配
In [134]: hash(id(lst0))
Out[134]: 140196597896584
给lst1 进行赋值 让其等于lst0
In [135]: lst1 = list(range(4))
In [136]: id(lst1)
Out[136]: 140196608816840
查看两个列表的值
In [138]: lst1
Out[138]: [0, 1, 2, 3]
In [139]: lst0
Out[139]: [0, 1, 2, 3]
In [140]: lst0 == lst1
Out[140]: True
In [141]: lst0 is lst1
Out[141]: False
通过以上，可以明白：
== 比较返回值 判断是否依次相等
is 比较内存地址是否一致
地址空间的引用
In [142]: id(lst0[1])
Out[142]: 9177888
In [143]: id(lst1[1])
Out[143]: 9177888
以上看到，是没有复制的过程，而是被引用了同样的内存地址空间
使用copy进行复制并返回一个新的列表
In [150]: lst0
Out[150]: [0, 1, 2, 3]
In [151]: lst5=lst0.copy()
In [152]: lst5
Out[152]: [0, 1, 2, 3]
使用= 进行拷贝
In [163]: lst5 = lst0
In [164]: lst0[1] = 555
In [165]: lst0
Out[165]: [0, 555, 2, 3]
In [166]: lst5
Out[166]: [0, 555, 2, 3]
因为赋值的是引用类型，所以直接将嵌套的list拷贝的内存地址
通过这个内存地址修改，则对两个list同时修改
需要注意的是：需要观察拷贝的类型是什么，不然会引起副作用，但是也可以通过特性批量进行操作
深拷贝和潜拷贝的基本概念
浅拷贝
在一般都是实现了浅拷贝，只拷贝了第一层结构，
被称为 shadow copy,但是引用的都是同一个内存地址
深拷贝
如果出现层次嵌套，会对引用类型进行深入拷贝，在结构上拷贝的一模一样，引用的内存地址则独立开辟
使用deepcopy可以进行深拷贝
使用list求100内的质数：
lst1 = []
for x in range(2,101):
for i in lst1:
if x % i == 0:
break
else:
lst1.append(x)
print(lst1)
本文出自 “心情依旧” 博客，请务必保留此出处http://yijiu.blog.51cto.com/433846/1966783
原文地址：http://yijiu.blog.51cto.com/433846/1966783
