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

第三种：

列表名[:]

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以内的奇数和偶数的笛卡尔积：

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