python列表

列表（可变）

有序队列

初始化

​ 注:列表不能一开始就定义大小

#初始化一个空列表
ls=list()
ls1=[]
print(ls)
print(ls1)
#输出
[]
[]

#list(iterable)，只要是可迭代对象都是可以做list参数的
ls=list(range(5))
print(ls)
#输出
[0, 1, 2, 3, 4]

列表索引访问

#优秀于其他语言在于他有正负索引之分
#正负索引不可以越界，不然就会报异常
ls=[1,2,3,5]
print(ls[3])
#输出
5

列表查询

#index(value,[start,[stop]])
#匹配第一个就返回索引，匹配不到就抛异常
ls=[1,2,3,5]
print(ls.index(5))
#输出
3

#count(value)
#返回列表中匹配value的次数，没有匹配到报0，不会报异常
ls=[1,2,3,5,34,5,2,4,5,623,325,4,5]
print(ls.count(5))
print(ls.count(100))
#输出
4
0

#时间复杂度
#index和count方法都是O(n)

列表元素修改

#索引不能越界,不然是会报异常
ls=[1,2,3,5,34,5,2,4,5,623,325,4,5]
ls[2]=100
print(ls)
#输出
[1, 2, 100, 5, 34, 5, 2, 4, 5, 623, 325, 4, 5]

列表增加、插入元素

#append(object)-->None(这就是就地修改的意思)
#在尾部追加，时间复杂度O(1)
ls=[1,2,3,5,3]
print(ls.append(4))
print(ls)
#输出
None
[1, 2, 3, 5, 3, 4]

#insert(index，object) -->None
#在指定位置追加，本来位置上的值以及后面的所有值都往后移一位，时间复杂度O(n)
#超上界头部追加，超下界尾部追加
ls=[1,2,3,5,3]
print(ls.insert(1,4))
print(ls)
#输出
None
[1, 4, 2, 3, 5, 3]

#extend(iteratable)-->None
#将可迭代的元素追加进来
ls1=[1,2,3,5,3]
ls2=[4,6,7]
print(ls1.extend(ls2))
print(ls1)
#输出
None
[1, 2, 3, 5, 3, 4, 6, 7]

#+-->list，连接操作，将两个列表连接起来
ls1=[1,2,3,5,3]
ls2=[4,6,7]
print(ls1+ls2)
#输出
[1, 2, 3, 5, 3, 4, 6, 7]

####extend与+的区别，extend是在调用者上修改，而+则是重新在生成一个新的列表，原来的两个列表不变，实质上是调用__add__()方法####

#*-->list,重复操作
ls2=[4,6,7]
print(ls2*3)
#输出
[4, 6, 7, 4, 6, 7, 4, 6, 7]

列表删除元素

#remove(value)-->None
#从左至右查找第一个匹配的value的值,输入没有的值会抛异常
#时间复杂度O(n)
ls2=[4,6,7]
print(ls2.remove(4))
print(ls2)
#输出
None
[6, 7]

#pop([index])-->item(弹出的值)
#不指定index，尾部弹出，指定index效果跟remove一样了，索引超界抛异常
#不指定index的时间复杂度为O(1)，指定的为O(n)
ls2=[4,6,7]
print(ls2.pop(2))
print(ls2)
#输出
7
[4, 6]

#clear()-->None
#清空列表，只剩个空列表
ls2=[4,6,7]
print(ls2.clear())
print(ls2)
#输出
None
[]

列表其它操作

#reversed()-->None
#将列表元素反转
ls2=[4,6,7]
print(ls2.reverse())
print(ls2)
#输出
None
[7, 6, 4]

#sort(key=None,reverse=False)->None
#reverse为Ture，逆序
#key是一个函数，指定key如何排序
ls2=[4,6,5]
print(ls2.sort())    #默认是False
print(ls2)
#输出
None
[4,5,6]

#in
print([3,4] in [1,2,[3,4]] )
print([3,4] in [1,2,3,4])

for i in [1,2,3,4]:
    print(i)
#输出
True
False
1
2
3
4

列表复制

l0=list(range(4))
print(id(l0))
l2=list(range(4))
print(id(l2))               #说明2者不指向一块空间
print(l0==l2)               #说明值相等
l1=l0 
print(id(l0))
print(id(l1))               #说明2者是指向一块空间
l1[2]=10
print(l0)
print(l1)
print(l2)
#输出
4368109960
4368109832
True
[0, 1, 10, 3]
[0, 1, 10, 3]
[0, 1, 2, 3]
4368109960
4368109960


#copy()
l0=list(range(4))
l5=l0.copy()
print(id(l0))
print(id(l5))              #他与=不用的是，他是再复制一块内存空间
print(l5==l0)
l5[2]=10
print(l0)
print(l5)
#输出
4359721352
4359619784
True
[0, 1, 2, 3]
[0, 1, 10, 3]

l0=[1,[2,3,4],5]
l1=l0.copy()
print(l1==l0)
print(id(l0))
print(id(l1))
l1[2]=10
print(l0==l1)
l1[2]=5
l1[1][1]=20
print(l1==l0)      #这里是浅拷贝，虽然l0[1]中的列表的值变了，但是比较的是l0[1]这里列表的地址
print(l0)
print(l1)
#输出
True
4368008456
4368009800
False
True
[1, [2, 20, 4], 5]
[1, [2, 20, 4], 5]

注意：所以说copy是属于浅拷贝，他第一层仅仅是复制嵌套列表的地址

a=[1,2,3,4,5,6,7]
b=a[:]
c=a
print(id(a))
print(id(b))
print(id(c))

#输出
4368139464
4368139528
4368139464

注意：这两者复制有差别一个会开辟空间，一个不会

#深拷贝
import copy					#需要导包
l0=[1,[2,3,4],5]
l1=copy.deepcopy(l0)
l1[1][1]=20
print(l1==l0)
print(l1)
print(l0)
#输出
False
[1, [2, 20, 4], 5]
[1, [2, 3, 4], 5]

注意：深拷贝可以认定为上图存放嵌套列表的地址，存放具体的内容;

随机数

#随机数（伪随机）
import random
#randint(a,b)返回[a,b]之间的整数,2边都闭
# print(random.randint(0,1))
#输出
0和1都有随机到

# 随机选择一个非空序列
print(random.choice([2,35,6,78,9,1]))

#randrange([start],stop,[step]),从指定范围（左闭右开中随机取出一个）
print(random.randrange(1,7,2))    #可能性只有1，3，5

# random.shuffle(list)-->None就地打乱

#round，四舍六入五取偶，银行家算法;