列表
1.什么列表
列表就是用来存储不同数据的一个集合。
2.创建列表
将所有准备放入列表中的元素包裹起来,不同元素之间用逗号隔开。
[1,2,3,4,5]
[1,2,3,4,5,'ukd']
上面俩个都是列表,但是并没有给列表命名,所以无法调用,我们可以这样给列表进行命名。
i = [1,2,3,4,5,'ukd']
print(i)
output:
就像这样我们就可以调用输出这个列表了。
3.按顺序访问输出每一个类表中的元素
i = [1,2,3,4,5,'ukd']
for j in i:
print(j)
利用 for 循环,可以按顺序输出每一个列表中的元素。
output:
但是并不能只输出某一个特定的列表元素。所以可以给列表引入下标。
第一个元素的下标为0,
第二个元素的下标为1,
第三个元素的下标为2,
以此类推
也可以这样去使用下标:
最后一个元素下标为-1
倒数第二个元素下表为-2
以此类推
就像这样:
i = [1,2,3,4,5,'ukd']
print(i[0],i[-1])
ouput:
1 ukd
同时可以使用len()
函数测量列表的长度
i = [1,2,3,4,5,'ukd']
length = len(i)
print(length)
output:
4.列表切片:
i = [1,2,3,4,5,'ukd']
print(i[1:4])
print(i[:4])
print(i[:])
print(i[::2])
output:
[2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4, 5, 'ukd']
[1, 3, 5]
这就是列表的切片使用。
第一种:
列表名[start:stop]
从下标是start
的元素开始输出,到下标为stop
的位置停止。
第二种:
列表名[:stop]
不给start
的值,就默认从第一个元素开始输出,到下标为stop
的位置停止输出。
第三种:
列表名[:]
start
和stop
都不赋值,就会默认输出列表中所有元素。
第四种:
列表名[start:stop:step]
这里start和stop也可以为空,step负责步频,也就是列表输出的跨度值。所以当print(i[::2])
被输出时,结果就是[1, 3, 5]
。
列表的使用
一、增删改查
1.增
就是在原有列表的基础上增加元素
a.append()
方法
append的功能是在列表的末尾来添加一个指定的元素。
添加格式:
列表名.append('所添加元素')
举个栗子:
i = [1,2,3]
i.append(4)
print(i)
output:
[1, 2, 3, 4]
append()
方法的缺点是只能在列表的末尾添加一个元素,当需要一次性添加多个元素时就不再适用了。
b.extend()
方法
可以在列表的末尾添加任意个元素。注意:extend()
方法的参数必须是一个可迭代对象。
格式:
列表名.extend([元素1,元素2,...])
举个栗子:
i = [1,2,3]
i.extend([4,5,6])
print(i)
output:
[1, 2, 3, 4, 5, 6]
c.利用切片去完成增加
格式:
列表名[len(列表名):] = [元素1,元素2,...]
举个栗子:
i = [1,2]
i[len(i):] = [3]
print(i)
output:
[1, 2, 3]
另一个例子:
i = [1,2]
i[len(i):] = [3,4,5]
print(i)
[1, 2, 3, 4, 5]
d.insert()
方法
格式:
列表名.inset(待插入位置的下标,待插入元素)
举个栗子;
i = [1,3,4]
i.insert(1,2)
print(i)
i.insert(len(i),5)
print(i)
output:
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
2.删
a.remove()
方法
格式;
列表名.remove('删除元素')
举个栗子;
i = [1,2,2,3]
j = [1,2,3,4]
i.remove(2)
j.remove(4)
print(i)
print(j)
output:
[1, 2, 3]
[1, 2, 3]
注意事项:
1.如果列表中存在多个匹配的元素,则只会删除第一个。比如例子中的列表i
。
2.如果列表中无匹配的元素,则会报错。
b.pop()
方法
格式;
列表名.pop(元素下标)
举个栗子:
i = [1,2,3,4]
i.pop(0)
print(i)
output:
[2, 3, 4]
c.clear()
方法
格式:
列表名.clear()
举个栗子:
i = [1,2,3,4]
i.clear()
print(i)
output:
[]
整个方法会直接清空列表中的所有元素。
3.改
a.下标索引法
列表的改操作本质上就是使用下标索引的方法,在利用赋值运算符将新的元素值去替换进去。
举个栗子:
i = [1,2,3,5]
i[3] = 4
print(i)
output;
[1, 2, 3, 4]
这一办法只可以改变一个元素。
b.切片法
这个办法的原理就是先把指定位置的内容删除,之后将要改正的新元素插入原来指定的位置当中。
格式;
列表名[start:stop] = [新的元素]
举个栗子;
i = [1,2,3,5,6]
i[2:] = [3,4]
print(i)
out[put:
[1, 2, 3, 4]
这个切片的方法很好用,多多练习。
扩充
将一个乱序的数字列表按照由小到大的进行排序。
可以使用python中的一个模块。sort()
可以实现上述功能。
格式:
列表名.sort()
举个栗子:
i = [1,4,5,8,4]
print(i)
i.sort()
print(i)
output:
[1, 4, 5, 8, 4]
[1, 4, 4, 5, 8]
而要实现从大到小的排序则需要使用reverse()
模块
格式:
列表名.reverse()
栗子:
output:
4.查
a.count()
方法
该方法用于查找某一元素在其列表中的个数。
格式:
列表名.count(元素1)
栗子:
output;
b.index()
方法
该方法用于查找某一个元素的索引值(下标)
格式:
列表名.index(元素1,start,stop)
栗子:
output:
注意:
当start
与stop
未被赋值时,且所查找的元素在其列表中不止一个时,就会值返回第一个出现的索引值。比如栗子中的index(4)
就只会返回第一次出现的位置,也就是索引值为1的地方。
有了index方法,结合改操作中的下标索引法,就可以做到即使不知道要修改的内容的索引值,但依然可以修改。
栗子:
output:
当我们给start
和stop
复制后,就可以实现即使有多个相同元素,但依然可以找到后一个。
栗子:
output:
可以看到,虽然要查找的元素都是4,但是因为第二个print
中的index
对start
进行了赋值限定,所以结果不同。
二、列表的复制(浅拷贝)
1.切片法
格式:
待赋值的列表 = 被复制的列表[start:stop:step]
栗子:
output:
2.copy()
方法
格式:
待赋值的列表 = 被复制的列表.copy()
栗子:
output:
这个办法只可以全部复制,灵活性不如切片法。
列表的加法与乘法(concatenation and multiplication of list)
一、列表的加法
列表的加法其实就是列表的拼接,所以要求符号两边都是列表。
格式:
列表名1 + 列表名2
栗子:
output:
二、列表的乘法
其实就是将列表中的元素重复n
次
栗子:
output:
嵌套列表(nested list)
一、嵌套列表
嵌套列表又可以叫做二位列表。比如matrix = [[1,2],[3,4]]
就是一个二维列表。
或者这样书写:
matrix = [[1,2],
[3,4]]
第二种写法更更加直观。
扩充:
我们可以使用列表的乘法来创建一个二维列表。比如
A = [0]*3
for i in range(3):
A[i] = [0] *3
这样创建出来的列表是这个样子的,[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
。但是注意不可以为了方便这样子创建:
B = [[0]*3]*3
这样创建出来的列表虽然也是[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
。但是在我们需要更改某一个位置的元素时就会出现问题。
比如我们需要整改列表B中的B[1][1]
,就会出现这样的情况:
output:
可以看到B[i][1](i<3)
中的所有值都被改变了。这是直接利用乘法所创建的列表在存储时所有的B[i](i<3)
都是同一对象。
output:
这样就解释了为什么不可以直接利用乘法去创建列表。
最后附一张图去理解:
这就是A和B是如何存储的。
二、访问嵌套列表(access nested list)
第一种:
下标访问法
matrix = [[1,2],
[3,4]]
for i in range(2):
for j in range(2):
print(matrix[i][j],end = ' ')
print( )
output:
第二种:
切片:
matrix = [[1,2],
[3,4]]
for i in matrix:
for j in i:
print(j,end = ' ')
print( )
output:
深拷贝
变量不是一个盒子
在python中,变量就是一个名字,不是盒子。具体的来说就是再给变量赋值时,其实就是引用。举个栗子:
在这个例子中,当赋值运算发生时,python并不是将数据放入变量,而是引用(将变量与数据挂钩),就是这个样子:
我们可以发现,如果修改x中的值,比如x[1] = 3
那么y中的值也会随之改变。如果想要得到两个独立的列表,就需要用到copy()方法或者切片的方法,这些都是浅拷贝 。
深拷贝
在以为列表的复制当中浅拷贝已经够用,但是在面对二维列表的拷贝时,浅拷贝就不足以满足要求,所以引入深拷贝。:
格式:
import copy//调用模块
待拷贝列表名 = copy.deepcopy(被拷贝列表名)
栗子:
output:
深拷贝过后就可以有两个独立的二维列表了。
在二维列表中,如果不用深拷贝而用浅拷贝就会是这样的。
output;
列表推导式(list comprehension expression)
问题引入:
如果需要将一个数字列表中的每一个值都乘以2该如何实现。
当然可以用for循环和下标索引的方式去实现,:
就像这样也是可以但是不够简介,所以引入列表推导式:
就像这样也可以解决问题,更加简洁。
格式l;
[expression for target in iterable]
栗子;
output:
这个列表推导式就相当于for循环中的;
x = []
for i in range(10):
x.append(i)
推导式在字符串中的使用;
ouytput:
列表推导式的使用
1.带有if
判断
格式:
[expression for target in interable if condition]
栗子:
output:
而推导式内部的执行顺序是:先执行for
语句,后执行if
判断,最后是表达式部分。
2.推导式的嵌套
格式:
[expression for target1 in iterable1
for target2 in iterable2
...
for targetN in iterableN]
栗子:将一个二维列表降维成为一维列表
output:
推导式执行顺序:
1.for j in x
2.for i in j
3.i
本质上就是循环的嵌套。
同时:推导式的嵌套也是可以添加判断条件的:
格式:
[expression for target1 in iterable1 if condition1
for target2 in iterable2 if condition2
...
for targetN in iterableN if conditionN]
栗子:
这样就会产生一个二维数组,内容是10以内的奇数和偶数的笛卡尔积: