python set查找的时间复杂度_初学python之以时间复杂度去理解列表常见使用方法...

列表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)

in()

----> 1 a.sort(reverse=False)

TypeError: unorderable types: str()

那么我们可以使用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)