编程语言
首页 > 编程语言> > python学习记录-列表

python学习记录-列表

作者:互联网

列表

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的位置停止输出。

第三种:

列表名[:]

startstop都不赋值,就会默认输出列表中所有元素。

第四种:

列表名[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:
在这里插入图片描述
注意:
startstop未被赋值时,且所查找的元素在其列表中不止一个时,就会值返回第一个出现的索引值。比如栗子中的index(4)就只会返回第一次出现的位置,也就是索引值为1的地方。

有了index方法,结合改操作中的下标索引法,就可以做到即使不知道要修改的内容的索引值,但依然可以修改
栗子:
在这里插入图片描述
output:
在这里插入图片描述
当我们给startstop复制后,就可以实现即使有多个相同元素,但依然可以找到后一个。
栗子:
在这里插入图片描述
output:
在这里插入图片描述
可以看到,虽然要查找的元素都是4,但是因为第二个print中的indexstart进行了赋值限定,所以结果不同。

二、列表的复制(浅拷贝)
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以内的奇数和偶数的笛卡尔积:
在这里插入图片描述

标签:下标,记录,python,元素,列表,栗子,print,output
来源: https://blog.csdn.net/m0_61545318/article/details/122177519