目录
1.序列
1.1. 索引
1.2. 切片
1.3. 总结
2.加法和乘法
2.1. 加法
2.2. 乘法
3.常用函数
3.1.sum()函数
3.2.max()函数和min()函数
3.3.len()函数
4. list 列表 [ ] 基本操作
4.1. 列表的定义
4.2. 列表的创建（list()函数）
4.3. 列表的删除
4.4. 列表的复制
4.5 .列表的元素增删改查（数据结构基本操作）
4.5.1. 遍历列表
4.5.2. 查找元素
4.5.3. 增加元素
4.5.4. 删除元素
4.5.5. 改变元素
4.5.6. 插入元素
4.6.列表的排序和逆序
4.6.1. 列表排序
4.6.2. 列表逆序
4.7.列表推导式
4.7.1. 规定范围的数值列表
4.7.2. 根据规定条件生成列表
4.7.3. 符合条件的元素组成的列表
4.7.4. 例题
4.8.二维列表
4.8.1. 直接创建法
4.8.2. 循环创建法
4.8.3. 列表推导创建法
4.8.4. 例题
4.8.5. 总结
习题
1.[编程入门]三个数最大值
2. 二级C语言-最小绝对值
3.计算数字个数
4.[编程入门]矩阵对角线求和
5.蓝桥杯算法提高VIP-数组替换-题解(Python代码)
1.序列
序列是保存多个数据项的对象，它的存储方式是一个接一个的排列。同时每个元素都会拥有一个值，这个值代表他们存储在序列中的位置，一般我们称它为索引。打个比方来说，一个班级有若干个学生，每个学生都有一个学号，每个学号对应一个名字，而这个学号就是每个学生的索引值。
在Python中，序列有字符串、列表 [中括号 ]、元组（小括号）、字典、集合 {大括号}，对于这些序列，其中集合和字典是不能够使用索引、切片、相加等操作的。
本章我们将介绍一下索引和切片。
1.1. 索引
索引作为一种访问方式，我们在访问列表元素的时候最常用到索引。上面我们也提到过，索引值是每个元素对应的位置，那么索引是有一定值的，索引的值是从0开始，因此每个元素对应的位置是他的索引值+1。
我们定义一个列表：
my_list = [1,2,3,4,5]我们通过图来看一下：
| 元素值 | 1 | 2 | 3 | 4 | 5 |
| 正索引值 | 0 | 1 | 2 | 3 | 4 |
| 负索引值 | -5 | -4 | -3 | -2 | -1 |
对于正索引值也就是说，第一个元素对应的索引值为0，第二个元素的索引值为1，依此类推，最后一个元素的索引值对应的就是列表内总元素的数量减1。
而对于负索引值，第一个元素对应的索引值是0，而-1代表的是元素的最后一个，然后依次递减到元素的第一位，如表所示。
通过实例来看一下：
my_list = [1,2,3,4,5]
print('列表第一个元素',my_list[0])#访问第一个元素，索引值为0
print('列表第二个元素',my_list[1],my_list[-4])#访问第二个元素，正索引值为1，负索引值为-4
print('列表最后一个元素',my_list[4],my_list[-1])#访问最后一个元素，正索引值为4，负索引值为-1
运行结果为:
| 1 2 3 |
|
1.2. 切片
序列的切片就是将序列切成小的子序列，切片运算符有两种形式。
- [start:end]:start为起始索引位置（包含start），end为结束索引位置（不包含end）。
- [start:end:step]:同上一样，不同的是step，step为步长，在前面讲range()函数的时候提到过这个，它的用法和前面讲的一样，在这里指切片之间的间隔，但是步长对应的是每两个子序列间的间隔的值减1，不含step时默认为1（此时无间隔），step也可以为负值。
切片在列表操作的时候经常会使用到，使用切片还可以进行列表或字符串的逆序等操作。
my_list = [1,2,3,4,5,6,7,8,9,]
print('取列表的前5项',my_list[0:4])#当0省略的时候默认为0，即为my_list[:4]
print('取列表的第2-4项',my_list[1:4])#注意4是列表的第五项，但是在这里是不包含4的，所以没有第五项
print('取列表所有项，步长为2',my_list[::2])#步长为2，也就是走2步，所以间隔为1
print('取列表的逆序',my_list[::-1])#当步长为-1的时候，也就是反向走了一遍，即为逆序输出结果：
| 1 2 3 4 |
|
1.3. 总结
索引和切片在我们学习Python的过程中使用的比较频繁，无论我们是在访问序列中某一项的时候还是我们在遍历序列的时候，通过索引值的方式都可以帮助精准快速的完成操作。切片操作用起来更是方便，很多算法问题我们通过切片解决起来都十分方便，就拿逆序问题来说一下切片，切片能使用字符串、元组和列表，再通过下面一个例子来强化一下对于切片逆序的学习。
a= '123456'
b = (1,2,3,4,5,6)
c = [1,2,3,4,5,6]
a = a[::-1]
b = b[::-1]
c = c[::-1]
print(a)
print(b)
print(c)输出结果为：
| 1 2 3 |
|
2.加法和乘法
2.1. 加法
序列具有相加的功能，这个相加同我们数字之间的相加类似，但序列支持将两个类型相同的序列加在一起，使用‘+’符号进行操作。
我们通过两个例子简单看一下：
1）相同类型的序列相加，代码如下：
my_list = [1,2,3,4,5,6,7,8,9,]
my_list2 = [11,22,33,44,55,66]
my_str = 'abcdefghijklmn'
my_str2 = 'opqrstuvwxyz'
my_tuple = (1,2,3,4,5)
my_tuple2 = (6,7,8,9)
print('两个列表相加后为：',my_list+my_list2)
print('两个字符串相加后为：',my_str+my_str2)
print('两个元组相加后：',my_tuple+my_tuple2)运行结果：
两个列表相加后为： [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66]
两个字符串相加后为： abcdefghijklmnopqrstuvwxyz
两个元组相加后： (1, 2, 3, 4, 5, 6, 7, 8, 9)
2）不同类型的序列相加，代码如下：
my_list = [1,2,3,4,5,6,7,8,9,]
my_str = 'abcdefghijklmn'
my_tuple = (1,2,3,4,5)
print('列表和字符串相加：',my_list+my_str)
print('字符串和元组相加：',my_str+my_tuple)运行结果：
错误提示为：只能将列表（不是“str”）连接到列表，因此在‘+’操作的时候要使用相同类型进行相加。
2.2. 乘法
Python提供序列的相乘功能，这个相乘和算法的不太相同，当一个序列乘上x的时候，生成的新的序列是将原有序列重复的相加了x次。
序列的乘法相对来说也是比较简单的，我们通过简单例子来看一下。
my_list = [1,2,3,4,5]
my_str = 'www.dotcpp.com'
my_tuple = (1,2,3,4,5)
print('将my_list列表乘上3得到一个新列表为：',my_list*3)
print('将my_str字符串乘上3得到一个新字符串为：',my_str*3)
print('将my_tuple元组乘上3得到一个新元组为：',my_tuple*3)运行图为：
唯一要注意的就是这里生成的是新的列表，字符串，元组，原始的列表和字符串以及元组都是没有改变的，这一点大家可以通过再次print来试一下。
序列的乘法还有一个初始化指定长度列表的功能。
看一下下面代码：
my_list = [None] * 5#实现一个长度为5的初始化列表
print(my_list)输出结果：
[None,None,None,None,None]
这种方式通常在列表操作超出已有数据的长度的时候会使用到，因为当访问列表的索引大于列表长度的时候就会出现访问错误的问题。
3.常用函数
下面表格中为Python提供的内置函数，我们可以直接进行使用。
| 函 数 | 功 能 |
| sum() | 求序列中所有值的和 |
| max() | 求序列中的最大值 |
| min() | 求序列中的最小值 |
| len() | 求序列的长度 |
| str() | 把序列格式转换为字符串 |
| list() | 把序列格式转换为列表 |
| set() | 把序列格式转换为集合 |
| tuple() | 把序列格式转换为元组 |
| reversed() | 把序列中的所有元素进行逆序 |
| sorted() | 把序列中的所有元素进行排序 |
| enumerate() | 把序列组合成一个索引序列，一般在for循环中 |
本小节主要介绍前四个函数，剩下的函数会穿插在本章的后续小节中。
3.1.sum()函数
sum函数的语法格式为：
sum(iterable[start:end]其中iterable指可迭代的，在这里我们指序列，
start代表对应序列的起始位置（包含）
end为终止位置（不包含此位置），
用这种切片方式我们可以求出指定片段的序列和，当仅使用sum（iterable）的时候即求出整个序列的和。
下面我们仍通过实例来看一下：
my_list = [1,2,3,4,5,6]
my_tuple = (1,2,3,4,5,6)
my_set = {1,2,3,4,5,6}
print(sum(my_list))
print(sum(my_tuple))
print(sum(my_set))输出结果为：
| 1 2 3 |
|
关于sum()函数需要注意它只针对整数求和，如果序列我们要求的项中有非整数部分，那么就报错。
3.2.max()函数和min()函数
对于这两个函数，大家可以很简单的从字面意思理解到它是求最大值和最小值的，因此我们一样可以在序列中使用他们，同时也要注意他们不止是针对整数段，他们还支持对字符串的处理。
来看个例子：
my_list = [1,2,3,4,5,6]
my_str = '123456'
my_tuple = (1,2,3,4,5,6)
my_set = {1,2,3,4,5,6}
string = 'abcedfg'#当对于英文字母时
listing = ['a','b','c','d']
print(max(my_list),min(my_list))#求列表中的最大值和最小值
print(max(my_str),min(my_str))#求字符串中的最大值和最小值
print(max(my_tuple),min(my_tuple))#求元组中的最大值和最小值
print(max(my_set),min(my_set))#求集合中的最大值和最小值
print(max(string),min(string))#字母中的最大和最小值
print(max(listing),min(listing))#列表中字母的最大和最小值
输出结果为：
| 1 2 3 4 5 6 |
|
在这里需要注意这两个函数可以在字符串中找到最大值和最小值，针对26个英文字母，系统规定最大值为‘z'，最小值为‘a'，这两个函数在基础算法题求解的过程可以给我们提供很大的帮助。
3.3.len()函数
这个函数大家可以用length（长度）来理解，它用来统计序列的长度，即列表中有多少元素。当涉及到索引问题的时候，len（）函数能提供很大的帮助，我在遍历列表的时候最常用的一种方式就是for i in range（len（list）），这样在进行遍历的时候就可以直接从列表的第一项遍历到最后一项，同时要注意索引。
来看下面例子：
my_list = [1,2,3,4,5,6]
my_str = '123456'
my_tuple = (1,2,3,4,5,6)
my_set = {1,2,3,4,5,6}
print(len(my_list))#求列表中的长度
print(len(my_str))#求字符串中的长度
print(len(my_tuple))#求元组中的长度
print(len(my_set))#求集合中的长度输出结果：
| 1 2 3 4 |
|
4. list 列表 [ ] 基本操作
首先我们还是先介绍一下列表，列表是一个可以包含多种数据类型的对象，列表中的内容是可以改变的，它属于一种动态数据结构，我们可以对它进行添加或删除操作，因此在列表操作的时候离不开索引的使用。
4.1. 列表的定义
其实大家在前面可以多次的看到我们对列表的定义，在Python中我们不可以简单的只定义一个变量名，例如我们接下来要使用一个列表，我们不可以先定义一个my_list,之后再进行赋值什么的，因此我们定义列表的方式为：
my_liss = []#定义空列表
my_list = [1,2,3,4,5,6]#定义已有值的列表
my_lizz = ['a','b','c','d']我们可以把列表当作一种容器，我们用它来存放东西，可以在其中存放相同类型的数据，也可以存放不同类型的数据，但是为了提高程序的可读性，建议在一个列表中存放同一种数据类型。
4.2. 列表的创建（list()函数）
有的时候我们需要创建拥有一定数值的列表，而我们又不想手动输入，因此我们可以用list()函数嵌套range()函数直接进行创建。
list()函数不止可以进行强制类型转换，把字符串或元组转换为列表，还可以在定义的时候就使用列表方式。
举个例子：
我们想要创建一个列表，列表中包含1~10的数字，那么我们可以采用如下方式：
my_list = list(range(1,11))
print(my_list)输出结果为：
| 1 |
|
这样就可以很快捷的创建一个我们想要得到的列表。
输入一个列表：
# 提示用户输入，假设用户以空格分隔输入的数字
a= input().strip().split()
# 如果需要将输入的字符串转换为整数
my_list = [int(i) for i in my_list]
l1=list(map(int,input().split()))
l2=list(map(int,input().split()))
my_list = []
# 假设用户要输入5个元素
for i in range(5):
item = int(input(f"请输入第{i+1}个元素："))
my_list.append(item)
# 如果需要将输入的字符串转换为整数
#my_list = [int(item) for item in my_list]
4.3. 列表的删除
列表的删除采用del语句来操作。格式为：
del my_list看下面实例：
my_list = []
del my_list#删除这个已被创建的列表
print(my_list)#输出一下试试输出结果为：
| 1 2 3 |
|
通过报错提示我们可以知道我们创建的列表已经被删除了。
4.4. 列表的复制
我们有时候会需要做一个列表的副本，这时候我们就需要复制列表中的元素，我们可以先思考一下，如果先定义一个列表，然后再定义一个列表，让第二个列表等于第一个列表，我们修改了第一个列表中的值之后，第二个列表中的值会变吗？
看下面代码：
first_list = [1, 2, 3, 4] # 先定义一个列表
second_list = first_list # 复制这个列表
print('修改前(第一个列表和第二个列表）：', first_list, ',', second_list) # 输出看一下
first_list[0] = 10
print('修改后(第一个列表和第二个列表）：', first_list, ',', second_list) # 再输出看一下
print(id(first_list), id(second_list)) # 通过访问id可以发现此时两个列表地址是相同的
输出结果为：
| 1 2 3 |
|
可以发现复制的第二个列表在第一个列表中的元素值被修改之后也跟随着修改，说明了他们是使用的同一列表。
看下示意图：
也就是说着两个变量使用的是内存中的同一列表，无论修改哪个列表中的元素，对应的都是同一列表。
如果想要使用相同内容的列表但各自独立的话可以采用下面的方法：
first_list = [1,2,3,4]#先定义一个列表
second_list = [] + first_list#使用连接符
print(id(first_list),id(second_list))#通过访问id可以发现此时两个列表是相互独立的输出结果为：
| 1 |
|
4.5 .列表的元素增删改查（数据结构基本操作）
在使用列表的时候需要用到很多方法，例如遍历列表、查找元素、增加元素、删除元素、改变元素、插入元素、列表排序、逆序列表等操作。
部分操作会通过对应函数去完成，函数介绍如下表：
| 函数 | 功能 |
| index(element) | 返回与element值相同的第一个元素的索引。如果element在列表中没有找到，会引发Value.Error异常 |
| append(element) | 将element添加到列表末尾 |
| remove(element) | 从列表中移除x出现的第一个元素。如果element在列表中没有找到，会引发Value-Error异常 |
| insert(index,element) | 将element插人到列表中指定的index位置。 |
| sort() | 将列表的元素按从小到大排列 |
| reverse() | 逆置列表中的所有元素 |
4.5.1. 遍历列表
遍历列表通常采用for循环的方式以及for循环和enumerate()函数搭配的方式去实现。
1) for循环方式遍历
这种方式比较简单，前面讲for循环的时候也用到过很多次直接用于遍历，循环执行，看一下代码。
first_list = [1,2,3,4]#先定义一个列表
for i in first_list:#i为用于保存从列表中获取到的元素值，要输出元素的时候直接输出i即可。
print(i)输出结果：
| 1 2 3 4 |
|
2) for循环方式配合enumerate()函数遍历
enumerate函数它的作用是把序列组合成一个索引序列，我们配合for循环使用的时候，能得到列表中的元素及其索引值。
语法格式为：
for index,element in enumerate(list):index值的是索引值，element指元素，list值我们要遍历的列表，下面看个例子。
my_list = ['小明','小华','小天','小娜','小美','小李']
for index,element in enumerate(my_list):
print('序号为：',index,'名字为：',element)
输出结果为：
| 1 2 3 4 5 6 |
|
通过这种方式我们能更清楚的看到每个元素在列表中的位置。
4.5.2. 查找元素
在查找元素的时候，我们可以使用index()方法，它会返回元素的索引值,如果找不到元素就会报错。
my_list = ['小明','小华','小天','小娜','小美','小李']
print(my_list.index('小天'))输出结果：
| 1 |
|
4.5.3. 增加元素
增加元素相对来说比较简单，使用append()方法进行添加。
my_list = []#创建一个空列表
my_list.append(1)#添加一个元素1
my_list.append(2)#添加一个元素2
print(my_list)#输出输出结果为：
| 1 |
|
4.5.4. 删除元素
删除元素的时候我们通常采用两种方法，分别是根据索引值删除和根据元素值删除。
1）根据索引值删除
my_list = ['小明','小华','小天','小娜','小美','小李']
del my_list[1]#删除索引值为1的元素，对应为‘小华’
print(my_list)输出结果：
| 1 |
|
2）根据元素值删除
根据元素值删除的时候我们会使用到remove()函数进行删除。
代码如下：
my_list = ['小明','小华','小天','小娜','小美','小李','小天']
my_list.remove('小天')#直接找到第一个为‘小天’的元素
print(my_list)输出结果：
| 1 |
|
我们可以发现它只删除了第一个名为‘小天’的元素，如果想要全部删除可以配合if语句等去进行删除，大家可以自己去练习一下。
4.5.5. 改变元素
如果要改变列表中某个元素的值，我们可以采用直接更改的方式，例如：
my_list = ['小明', '小华', '小娜', '小美', '小李', '小天']
my_list [0] = '小明的哥哥'
print(my_list)输出：
| 1 |
|
4.5.6. 插入元素
当我们想要在列表中某个位置增添一个元素的时候，
我们可以采用insert(index,element)方法，index为索引位置，element为插入元素。
当元素插入到列表时，列表大小会扩大以容纳新的元素。
而之前在指定索引位置上的元素以及其后的所有元素则依次向后移动一个位置。
如果你指定了一个无效索引，不会引发异常。
如果指定的位置超过了列表末尾，元素会添加到列表未尾。
如果你使用负索引指定了一个非法索引，元索会添加到列表开始。
看个例子：
已知一个列表为： ['小明', '小华', '小娜', '小美', '小李', '小天']，我们需要在小明和小华之间插入一个元素‘小张’，那么我们首先要找到的是小华的索引值为1，那么我们就可以使用insert方法直接进行插入。
代码如下：
my_list = ['小明', '小华', '小娜', '小美', '小李', '小天']
my_list.insert(1,'小张')
print(my_list)输出结果为：
| 1 |
|
4.6.列表的排序和逆序
关于列表的排序和逆序问题，我们在遇到很多算法问题以及数据分析的时候，我们都会涉及到这两种问题，通常在求解问题的时候把数据放在列表中，然后使用列表方法进行排序逆序，都能迅速的帮助我们解决问题。
4.6.1. 列表排序
列表排序的时候我们可以采用两种方式，一种使用sorted(list)进行排序，一种是使用list.sort()进行排序，他们的使用结构分别为：
1) listname.sort(key=None,reverse=False)
listname为目标列表，
key表示指定一个从每个列表元素中提取一个比较的键，
reverse为可选参数，当指定为True时为降序，如果为Flase则为升序。默认为升序。
2) newlist = sorted(listname,key=None,reverse=False)
newlist为新的序列，
listname为要排序的列表，
key和reverse和1）中一致。
两种方式的区别在于前者等于在原序列上进行直接修改，而后者会生成一个新的序列。
先定义一个列表为my_list = [2,1,3,5,4,6,8,9,7,10]，然后我们进行排序。
代码如下：
my_list = [2,1,3,5,4,6,8,9,7,10]
my_list.sort()#这种格式是直接在列表后使用sort()函数
b = sorted(my_list)#这种方式是定义一个新列表来存放排序过的序列
print(b)
print(my_list)输出结果为：
| 1 2 |
|
这两种方式的使用可以自己选择，但一定要注意格式的正确性。
4.6.2. 列表逆序
我们在做算法题的时候，很多时候需要把我们存放的数据逆序，把一个容器中的数据逆序在Python中采用reverse()函数或者reversed()显得十分简单。
他们的结构和排序结构有所不同，reverse()和sort()类似，都是直接在列表后面使用方法就可以了，但reversed需要在前面加上一个存储类型（因为在reversed()作用后，返回一个迭代器，迭代器中的数据是逆序过的，我们使用一种已知的存储结构来存储迭代器中的元素更方便访问，通常会使用列表方法）。
list.reverse()
newlist = list(reversed(list))我们来看一下实例：
my_list = [2,1,3,5,4,6,8,9,7,10]
c = list(reversed(my_list))#使用reversed逆序一定要加上一个存储类型
my_list.reverse()#使用reverse逆序
print(c)#输出
print(my_list)#输出输出结果为：
| 1 2 |
|
列表逆序的时候还可以使用前面学习过的切片操作，直接进行逆序：
my_list = [2,1,3,5,4,6,8,9,7,10]
my_list = my_list[::-1]
print(my_list)输出结果为：
| 1 |
|
4.7.列表推导式
Python中存在一种特殊的表达式，名为推导式，它的作用是将一种数据结构作为输入，再经过过滤计算等处理，最后输出另一种数据结构。根据数据结构的不同会被分为列表推导式、集合推导式和字典推导式。我们先着重来介绍最常使用的列表推导式。
我们先看一下列表推导式的语法格式：
listname = [expression for variable in 对象（if condition）]listname：新生成的列表名字。
expression：表达式。
variable：变量名。
（if condition）：用于从对象中选择符合要求的列表。
4.7.1. 规定范围的数值列表
我们先思考一下当我们需要生成10个数字并存放列表当中，我们先看一下普通方式：
| 1 2 3 4 |
|
输出结果为：
| 1 |
|
而使用列表推导式只需要一行就可以:
| 1 |
|
输出结果为：
| 1 |
|
这种方式能简化我们在定义列表时的操作。
4.7.2. 根据规定条件生成列表
假定我们已知一个列表为 listname = [1,3,5,6,7,9,10,23,26,28,64,98]，我们要找到其把里面的数全部加5，普通方法：
| 1 2 3 4 |
|
输出结果为：
| 1 |
|
而使用列表推导式同样很简洁：
| 1 2 |
|
输出：
| 1 |
|
4.7.3. 符合条件的元素组成的列表
这种类型的列表推导式要比前两种复杂点，但是能简化更多的代码。
我们先举个列子来看一下代码格式：
已知一个列表为listname = [8,33,53,64,73,95,101,123,126,164,198]，然后我们要找到列表中小于大于100的数字，然后乘上0.8，最后返回到列表中。
如果我们使用普通方法：
| 1 2 3 4 5 6 7 |
|
输出结果为：
| 1 |
|
使用列表推导式：
| 1 2 3 |
|
输出结果：
| 1 |
|
我们来根据这个例子的语法结构来分析一下:
在使用复杂的列表推导式的时候我们可以采用这种方式，可以理解为我们先把符合条件的元素（条件语句）从对象中挑选出来，然后再经过输出表达式的处理，最后存放到了列表当中，形成新的列表。
4.7.4. 例题
下面提供几道例题可以尝试着做一下。
1.列表[1,2,13,22,25],请使用使用列表推导式提取出大于10的数，并把每个数平方，最终输出。
运行结果为：
| 1 |
|
代码如下，可以先尝试做完参考答案。
| 1 2 3 |
|
2.列表推导式求列表所有奇数并构造新列表，list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
代码如下：
| 1 2 3 |
|
输出结果为：
| 1 |
|
4.8.二维列表
二维列表是将其他列表当做列表的元素放在一个列表当中，也就是列表的嵌套。有接触过C或C++的可能了解数组这个概念，在Python中数组存在于第三方库中，因此在不安装第三方插件的前提下我们想要在Python中使用数组方法，就要采用二维列表这个方法。
实际上列表中的元素可以是任何数据类型，我们看个例子：
| 1 2 |
|
输出结果为：
| 1 |
|
在这个列表中包含了列表，字符串，集合，元组。当一个列表中的元素全部为列表的时候，是我们最常用的二维列表，下面会介绍几种二维列表的创建方法及其访问方式。
4.8.1. 直接创建法
直接创建法就是定义了列表名字之后直接进行输入，我们来定义一个简单的小键盘，即1-9：
| 1 2 |
|
输出为：
| 1 |
|
我们在理解的时候可以这样理解：
| 索引 | 0 | 1 | 2 |
| 0 | 1 | 2 | 3 |
| 1 | 4 | 5 | 6 |
| 2 | 7 | 8 | 9 |
由图可以看，my_list[0]对应的就是[1,2,3]，因此我们在访问1的时候，他对应的坐标就为（0,0），我们可以通过索引访问，即my_list[0][0],它的值对应的就是1，其他值访问的方式和它一样，像元素9对应的访问方式就为my_list[2][2]。
4.8.2. 循环创建法
使用循环也可以实现而为列表的创建，通常会采用for循环来实现，我们来创建一个6*6的二维列表，代码如下：
| 1 2 3 4 5 6 7 |
|
输出为：
| 1 2 3 4 5 6 |
|
输出的实际结果应是在一行中，为了方便大家理解所以这样排列，大家也可以通过while循环尝试一下去创建一个二维列表。
4.8.3. 列表推导创建法
使用列表推导式也是可以创建二维列表的，上一节我们刚刚学习过列表推导式，因此我们可以直接使用这种方式来简化我们的代码。
我们再次创建一个六行六列的二维列表，它的代码就相对简洁很多，代码如下：
| 1 2 |
|
输出为：
| 1 2 3 4 5 6 |
|
这种方式的不仅节省时间还优化了代码，等同于循环创建了6个列表并赋予了6个值，最后他们是放在了一个列表中构成了二维列表。
4.8.4. 例题
再通过一个例子来进一步了解一下。
我们想要创建一个6*6的列表，然后里面的值从1-100中随机取值。代码如下：
| 1 2 3 4 5 6 7 8 9 |
|
输出为：
| 1 2 3 4 5 6 |
|
这道题的思路和上面第二种方法是一致的，如果对列表推导式掌握的不熟练的同学可以在初期使用这种方式，它对比于前面的例子增添了一个随机取值功能。
4.8.5. 总结
关于二维列表，这一点对于要参加竞赛的同学很重要，不管是之后遇到迷宫问题还是2n皇后问题，都离不开二维列表的使用，因此在这里先简单的介绍一下，大家在可以初步了解，在后续竞赛题中会有关于这两种类型题的讲解，当然也能更进一步的去了二维列表。
习题
1.[编程入门]三个数最大值
a=list(map(int,input().strip().split()))
print(max(a))2. 二级C语言-最小绝对值
a = list(map(int, input().strip().split()))
min = 9999999
val=9
for i in range(10):
if a[i] < 0:
a[i] = -a[i]
if a[i] < min:
min = a[i]
val = i
temp = a[val]
a[val] = a[9]
a[9] = temp
for i in a:
print(i,end=' ')
3.计算数字个数
s=input(list)
#字符串编码 '0'----48 '9'---57 A----65 a-----97
sum=0
for i in s:
if i>='0' and i<='9':
#if i.isdigit():
sum=sum+1
print(sum)4.[编程入门]矩阵对角线求和
my_list=[]
for m in range(3):
j=[]
a,b,c=map(int,input().split())
j.append(a)
j.append(b)
j.append(c)
my_list.append(j)
n=my_list[0][0]+my_list[1][1]+my_list[2][2]
m=my_list[0][2]+my_list[1][1]+my_list[2][0]
print(n,m)5.蓝桥杯算法提高VIP-数组替换-题解(Python代码)
m,n = map(int,input().split())
a = [i for i in input().split()]
b = [i for i in input().split()]
m1,n1 = map(int,input().split())
if m == len(a) and n == len(b):
list1 = a[:m1] + b[:n1]
if len(list1) < len(a): #坑 少这一步 出现18%的错误
list1 += a[len(list1):]
print(','.join(list1))#join() 方法会把列表 list1 中的每个元素转换成字符串，并用逗号 , 将它们连接起来。
