列表的基本函数

range(3) #小于3的整数：0,1,2

range(1,10) #大于等于1小于10的整数，即[1,10)

range(1,10,2)#大于等于1小于10的整数，步长为2，即1,3,5,7,9

lst1= [1,2,3,4]

lst2= ["zhangsan","lisi","wangwu"]

len(lst1)#求数组的长度，输出为4

max(lst1) #求数组的最大值

min(lst1) #求数组的最小值

st = "i love you"list(st)#转换为列表格式，结果为['i', ' ', 'l', 'o', 'v', 'e', ' ', 'y', 'o', 'u']

切片数组元素

alist = ["zhangsan","lisi",1,2,3]

alist[1:3] #切片索引[1,3)，结果为["lisi",1]

alist[1:] #切片索引1到最后，结果为["lisi",1,2,3]

alist[1:-1] #切片索引1到倒数第2个，-1表示最后一位，但是不包括，结果为["lisi",1,2]

alist[1:-1:2] #切片索引1到倒数第2个，步长为2，结果为["lisi",2]

alist[2::-2] #从索引2开始，右向左切片，步长为负数表示从右向左取值，结果为[1,"zhangsan"]

lst = [1,2,3,4,5,6,7]

print(lst[-2:-4]) #输出为空

print(lst[-4:-2]) #输出[4,5]，默认情况只能从左至右切片，且包含左边不包含右边，数组的最后一个元素的索引为-1.到处第二个索引为-1，以此类推

id函数

id函数的参数为需要查询的变量，返回值为该变量的id，id是变量的唯一标识

a = 100b = 200

print("id of a: {0}".format(id(a)))

print("id pf b: {0}".format(id(b)))

c =a

print("id of c: {0}".format(id(c))) #c与a为同一个变量，id相同

a= 101

print("id of a: {0}".format(id(a))) #a一旦被修改，id发生变化

print("id of c: {0}".format(id(c))) #c的id不变

输出为

id of a: 140707208945792id pf b: 140707208948992id of c: 140707208945792id of a: 140707208945824id of c: 140707208945792id of b: 140707208949024

所有的分片操作是产生了一个新的数组，而不是在原数组上操作，原数组仍然保持不变。

lst1 = [1,2,3]

lst2= lst1[:] #切片list所有元素

lst3 = lst1 #lst3指向lst1的列表

print(id(lst1))print(id(lst2)) #切片所得到的lst2与lst1的id不同

print(id(lst3)) #lst3与lst1的id相同

print("*"*20)

lst1[1] = 100

print(id(lst1))print(id(lst2)) #切片所得到的lst2与lst1的id不同

print(id(lst3)) #lst1的第一个元素被修改，lst3和lst1的的id仍然保持一致

print("*"*20)print(lst1)print(lst2) #lst1被修改，不影响lst2列表，lst2继续保持不变

print(lst3) #lst1被修改，lst3也被修改，因为lst3和lst1指向同一个列表

输出为

2181593850440

2181593850504

2181593850440

********************

2181593850440

2181593850504

2181593850440

********************[1, 100, 3]

[1, 2, 3]

[1, 100, 3]

插入数组元素

aList = ["zhangsan","lisi",1,2,3]

bList= ["wangwu",4]

aList.append(5) #在aList数组末尾加上元素5， 数组为["zhangsan","lisi",1,2,3,5]

bList.insert(1,"xixi") #在bList数组的索引为1的位置插入元素xixi，数组为["wangwu","xixi",4]

aList.extend(bList) #将数组bList加入到数组aList中，aList为 ["zhangsan","lisi",1,2,3,"wangwu",4]，bList不变

删除数组元素

alist=[1,2,3]

blist=[“huawei”,"sanxing","xiaomi"]

alist.pop(0)#删除数字第1个元素，删除后的数组为[2,3]

alist.pop() #默认删除数字第1个元素，删除后的数组为[2,3]

alist.remove("sanxing") #删除索元素"sanxing"，删除后的数组为[“huawei”,"xiaomi"]，此处的参数只能是元素值不能是索引，如果列表中没有这个数则报错

del blist[2] #删除blist[2]元素，[]括号内必须是索引

del blist #删除整个数组

修改数组元素

a = ["zhangsan","lisi",1,2,3]

b= ["wangwu",4]

a[1] = 5 #修改后的数组为["zhangsan",5,1,2,3]

a[1:3] = ["update1","update2] #修改后的数组为["zhangsan","update1","update2",2,3]

列表排序

srt=["A","b","D","d"]

srt.sort()#将数组按照ASCII码升序排列(默认即为升序)，排序后的数组为['A', 'D', 'b', 'd']

srt.sort(reverse=True) #将数组按照ASCII码降序排列，排序后的数组为['d', 'b', 'D', 'A']

sorted(srt)#将srt数组排序，但是并没有改变srt数组本身的顺序，只是返回排序后的新数组

sorted(srt,reverse=True)

其他操作

a = [1,2,3]

b= ['a','b','c']

c= a +b

print(c) #a和b两个数组合并

d= b * 3#b数组扩大3倍

print(d)

输出为

[1, 2, 3, 'a', 'b', 'c']

['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

1 in a #判断元素"A"是否在数组中，此处返回Ture"c" not in b#判断元素"d"是否不在数组中，此处返回False

type(a)is list #判断对象srt是否为list类型，此处返回True

嵌套列表/双层列表

lst = [["one",1,"a"],["two",2,"b"],["three",3,"c"]]for k,v,w inlst:print(k,"...",v,"...",w)

输出为

one ... 1... a

two ...2... b

three ...3 ... c

列表生成器，嵌套列表生成器

#使用列表a创建列表b

a = [1,2,3]

b= [i for i ina]print(a)print(b) #列表b和a的内容完全一致

c= [i*10 for i in a] #对a中的每个元素乘以10，生成一个新的列表

print(c)

d= [x for x in range(1,10)] #生成一个1到9的列表

print(d) #输出[1, 2, 3, 4, 5, 6, 7, 8, 9]

e = [y for y in d if y%2==0] #取出列表d中的所有偶数生成新的列表

print(e) #输出[2, 4, 6, 8]

a= [1,2,3]

b= [100,200]

c= [i+j for i in a for j in b if i+j<200] #列表生成器可以嵌套，a在外层b在里层

print(c) #输出[101, 102, 103]

参数传递

对于简单的数值(如int, float, string)，采用传值，即在函数内的操作不影响函数外的该变量

对于复杂的数值(如list, set, dict等)，采用传址，即指向的是同一个地址，任何一个地方此内容的修改，都会影响其他地方的该变量

deffunc1(lst):

lst[0]= 101

print("in func1, lst:", lst)returnNonedeffunc2(num):

num+= 100

print(num)returnNonedeffunc3(st):

st= "updated"

print("in func3, str:", st)returnNone

l= [1,2,3,4,5]print(l) #输出[1,2,3,4,5]

func1(l) #传地址，而不是传值，因此，参数在函数内被修改，会体现到函数外

print(l) #输出[101,2,3,4,5]

n= 1

print(n) #输出1

func2(n) #传值，而不是传地址，因此，参数在函数内被修改，不会体现到函数外

print(n) #输出1

st= "initiated"

print(st) #输出initiated

func3(st) #传值，而不是传地址，因此，参数在函数内被修改，不会体现到函数外

print(st) #输出initiated

Copy函数

a = [1,2,3,4,5]

b= a #传地址，因此a和b指向同一个位置

print(id(a),"-->",a)print(id(b),"-->",b)

b[3]=100 #修改b的数据，同样a也会被修改

print(a)print(b)

c= a.copy() #传值，c是a的另一份拷贝，指向不同的位置

print(id(a),"-->",a)print(id(c),"-->",c)

c[1] = 200 #修改c的值，a不受影响

print(a)print(c)

输出为

2428798001736 --> [1, 2, 3, 4, 5]

[1, 2, 3, 100, 5]

[1, 2, 3, 100, 5]2428798001736 --> [1, 2, 3, 100, 5]2428798492552 --> [1, 2, 3, 100, 5]

[1, 2, 3, 100, 5]

[1, 200, 3, 100, 5]

深拷贝、浅拷贝，copy函数只浅拷贝函数，只拷贝一层内容：

a = [1,2,3,[4,5,6]]

b=a.copy()print(id(a))print(id(b)) #传值，a和b指向不同的空间

print("*"*20)print(id(a[3]))print(id(b[3])) #a[3]和b[3]指向同一个空间,第二层内容不再拷贝，只传址

a[3][0] = 100

print(a[3])print(b[3]) #修改a[3]的任意值，b[3]也会被修改

上述代码中的变量a相当于，a[3]相当于一个指针指向另外一个数组：

输出为

2056105648776

2056106139464

********************

2056105648712

2056105648712[100, 5, 6]

[100, 5, 6]