python学习笔记（05）---（内置容器-列表）
（1）在python中包含其他对象的对象，称为容器，是一种数据结构。（2）常用容器分为两种：序列（如：列表、元组）和映射（如字典） 格式：listname=[element1,element2,element3……,elementn] listname：列表名，必须符合标识符命名规则 element：列表项，元素无个数限制，可以为任意合法的数据类型。例：创建空列表：listname = [] 使用
·
目录
（1）概念：将多种类型数据使用逗号分割放置在中括号中的一组可变序列
（5）索引引用：listname[索引]，如：team[0],team[1],team[2]
第七章 内置容器（一）
1.容器概念
（1）在python中包含其他对象的对象，称为容器，是一种数据结构。
（2）常用容器分为两种：序列（如：列表、元组）和映射（如字典）
2.列表
（1）概念：将多种类型数据使用逗号分割放置在中括号中的一组可变序列
（2）创建列表：
<1> 格式：listname=[element1,element2,element3……,elementn]
- listname：列表名，必须符合标识符命名规则
- element：列表项，元素无个数限制，可以为任意合法的数据类型。
例：
a = [2, 3, 4, 5]
b = ['china', 'hello', 'world']
c = [45.6, 'hello', '中国']
print(a, b, c, sep='\n')
# [2, 3, 4, 5]
# ['china', 'hello', 'world']
# [45.6, 'hello', '中国']<4> 创建空列表：listname = []
PS:为了提高程序可读性，建议在列表中存储相同类型的数据
<4> 使用list()内置函数创建列表：
- 格式：listname = list（迭代对象）
例：
t1 = list()
t2 = list('china')
print(t1, t2, sep='\n')
# []
# ['c', 'h', 'i', 'n', 'a']<5> 使用range()创建数值迭代列表：
t3 = list(range(10, 20, 2)) # 10-20的数值中，创建步长为2的列表
print(t3)
# [10, 12, 14, 16, 18]PS：list()参数必须为可迭代对象，否则将报错
将列表转换为列表无意义，浪费资源：
t1 = [1, 2, 3, 4, 5, 6, 7]
t2 = t1
print(t1)
# [1, 2, 3, 4, 5, 6, 7]（3）删除列表：
<1> 格式1：del listname
team = ['皇马', '拜仁', '梵蒂冈', '罗马']
del team
# print(team) 报错
# 删除的是引用指向，列表还在<2> listname.clear()：清空列表内容，保留列表结构
team = ['皇马', '拜仁', '梵蒂冈', '罗马']
team.clear()
print(team)
# []PS：python自带垃圾回收机制，会自动销毁不同列表，一般不需要手动删除
（4）通过索引访问列表
<1> 作用：在序列中每个元素都有一个编号（下标），可用于访问元素
<2> 原则：由左向右从 0 开始递增，也可由右向左从-1开始递减
<3> 例：
（5）索引引用：listname[索引]，如：team[0],team[1],team[2]
<1> 注意：可以通过列表索引删除元素：del listname[索引]。当为空列表，不能通过索引访问引用
team = []
team[0] # 报错（6）输出列表：print（列表名）
（7）列表切片
<1> 作用：通过切片可以访问一定范围内的元素
<2> 格式：listname[start:end:step]
- start:切片开始索引（包含），省略则为0
- end:切片截止索引（不包含），省略则整个列表长度
- step:切片长度，省略则为1，且最后一个冒号也可以省略，为负值表示反向取值
<3> 例：
t1 = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
# 0 1 2 3 4 5 6 7 8 9
print(t1[0:7:4]) # 输出索引0-6，间隔为4的值
print(t1[1:5]) # 1索引开始，到4索引结束，默认间隔为1
print(t1[2:]) # 2索引开始到结尾
print(t1) # 输出列表全部内容
print(t1[:]) # 全部内容
print(t1[::]) # 全部内容
print(t1[0:]) # 全部内容
print(t1[:-1]) # 正序输出，不包含最后一个数
# 相当于 print(t1[0:-1:1])
print(t1[0:6:0]) # 报错，步长不能为0
print(t1[::-1]) # 反向输出
（8）列表相加
<1> 作用：将相同类型的序列连接，但是不会去掉重复值
<2> 符号：+（列表的连接）
<3> 示例：
例1：
t1 = [1, 2, 3]
t2 = [4, 5, 6]
t3 = ['hello']
t4 = ['world']
t5 = t1 + t2
t6 = t3 + t4
t7 = t5 + t6
print(t5, t6, t7, sep='\n')
# [1, 2, 3, 4, 5, 6]
# ['hello', 'world']
# [1, 2, 3, 4, 5, 6, 'hello', 'world']例2：列表和常量连接会报错
t1 = [1, 2, 3, 4, 5, 6, 7]
print(t1 + 8) # 报错
t2 = ['hello', 'world']
print(t2 + 'china') # 报错
（9）列表相乘
<1> 作用：使用数字n乘以一个列表会进行复制，重复n次
<2> 符号：*
<3> 示例：
例1：
t1 = [1, 2, 3]
t2 = ['hello', 'world']
print(3 * t1)
print(2 * t2)
# [1, 2, 3, 1, 2, 3, 1, 2, 3]
# ['hello', 'world', 'hello', 'world']例2：初始化长度为n的空列表
emptylist = [None] * 5
print(emptylist)
# [None, None, None, None, None]（10）列表的包含与不包含
<1> 作用：检查某个元素是否为列表成员
<2> 格式：value in listname 或 value not in listname（value---被检查的元素）
（11）列表常用函数
<1> 计算列表长度：len(listname)
<2> 计算列表最大值：max(listname)
<3> 计算列表最小值：min(listname)
<4> 计算列表元素和：sum(listname)
（12）列表遍历
<1> 处理数值：
<2> 处理索引和数值：
（13）程序实例
<1> 例1：输出列表最大值
import random as r
法1：
t1 = r.sample(range(10, 20), 10)
# 产生10-30,10个随机数
print(t1)
print('max=', max(t1))
法2：
# 将列表排序后输出最大值
t1 = r.sample(range(10, 20), 10)
# 产生10-30,10个随机数
t1.sort()
print(t1)
print('max=',t1[-1])
法3：for循环输出最大值
t1 = r.sample(range(10, 30), 10)
print(t1)
max = t1[0] # max变量存储列表的第一个元素
for i in t1:
if max < i:
max = i # 将最大值存储到列表中第一个元素中
print('max=', max)
# [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
# max= 19<2> 例2：将列表中值为偶数，索引为奇数的值输出
import random as r
t1 = r.sample(range(10, 30), 10)
print(t1)
for index, item in enumerate(t1):
if item % 2 == 0 and index % 2 == 1:
print(index, item)
# [19, 25, 18, 10, 15, 22, 23, 17, 21, 14]
# 3 10
# 5 22
# 9 14<3> 例3：素数筛选判断法：筛选出100以内的素数
产生2-99的序列：2 3 4 5 6 7 8 9......99
list1 = list(range(0, 101)) # 产生0-100的列表
print()
i = 2 # 从最小素数2开始
while i < 100: # 遍历列表
j = list1[i] * 2 # 计算当前值的倍数
while j < 100:
list1[j] = 0 # 将倍数置为0
j = j + list1[i]
i += 1
while list1[i] == 0:
i += 1 # 排除已经置为0的元素不再遍历
# 循环数除列表中不是0的素数
t = 0
for i in range(2, 100):
if list1[i] != 0:
t += 1
print(list1[i], end=' ')
if t % 10 == 0:
print()
# 2 3 5 7 11 13 17 19 23 29
# 31 37 41 43 47 53 59 61 67 71
# 73 79 83 89 97 （14）列表元素的添加与删除
<1> 添加元素：listname.append(obj)
<2> 例：将值为奇数，索引为偶数的元素存储到另一个列表中
import random as r
t1 = r.sample(range(10, 30), 10)
t2 = []
for index, item in enumerate(t1):
if item % 2 == 0 and index % 2 == 1:
t2.append(item)
print(t2)
# [12, 28]<3> 例：删除元素
- 根据索引删除：del listname[index]
- 根据内容删除：listname.remove()
import random as r
t1 = r.sample(range(10, 30), 10)
print(t1)
n = int(input('请输入需要删除的元素的值：'))
t1.remove(n)
print(t1)
# [26, 22, 28, 23, 10, 14, 11, 17, 19, 13]
# 请输入需要删除的元素的值：26
# [22, 28, 23, 10, 14, 11, 17, 19, 13]（15）列表元素统计：
<1> 格式：listname.count(obj)
<2> 作用：获取元素在列表中出现的次数，只能精确匹配
<3> 注意：count()方法与remove()方法配合使用，删除前首先统计元素是否存在
<4> 例：删除列表中元素的值，删除前可确认元素在不在列表中
import random as r
t1 = r.sample(range(10, 30), 10)
print(t1)
n = int(input('请输入需要删除的元素的值:'))
if t1.count(n) > 0:
t1.remove(n)
print(t1)
else:
print('输入元素不在列表中')
# [28, 18, 23, 16, 26, 13, 10, 27, 20, 11]
# 请输入需要删除的元素的值:1
# 输入元素不在列表中（16）列表的排序
<1> 选择法排序：有n个元素参与排序，一共进行n-1次比较，每次都是当前值与下一个值进行比较，比较到n之前结束（大于号是升序，小于号是降序）
t1 = r.sample(range(10, 20), 10)
print('排序前：', t1)
for i in range(len(t1) - 1):
for j in range(i + 1, len(t1)):
if t1[i] > t1[j]:
t1[i], t1[j] = t1[j], t1[i]
print('排序后:', t1)
# 排序前： [11, 13, 14, 16, 10, 15, 19, 12, 18, 17]
# 排序后: [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]<2> 插入法排序：将无序序列分成两个部分,( 前:有序, 后:无序 )通过构建有序序列；对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入；插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间
import random
t1 = random.sample(range(0, 10), 10)
print('排序前：', t1)
for i in range(0, 10):
t = t1[i] # t为待插入元素
j = i - 1
while j >= 1 and t < t1[j]:
t1[j + 1] = t1[j]
j = j - 1
t1[j + 1] = t # 插入备份元素
print('排序后：', t1)
# 排序前： [0, 9, 7, 3, 5, 2, 8, 4, 6, 1]
# 排序后： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<3> 排序归类：
<4> 使用sort()方法排序：
- 格式：listname.sort(key=None,reverse=False)
- Key:元素排序时比较的关键字。（数列基本用不上，字符串用的多）
- 如：key=str.lower 表示排序时不区分大小写字母。
- reverse：排序规则，true表示降序，false是升序，默认升序。
- sort（）：会修改列表的内容，返回值为None
例：对列表进行升序和降序排序
import random as r
l1 = r.sample(range(0, 20), 10)
print(l1)
l1.sort() # 升序
print(l1)
l1.sort(reverse=True) # 降序
print(l1)
# [11, 17, 5, 2, 6, 19, 13, 10, 1, 8]
# [1, 2, 5, 6, 8, 10, 11, 13, 17, 19]
# [19, 17, 13, 11, 10, 8, 6, 5, 2, 1]<5> 使用内置sorted()
- 用法参照sort()
- PS：不改变列表顺序，会生成副本
例：对列表进行降序排序
import random as r
l1 = r.sample(range(0,10),10)
print(l1)
print(sorted(l1,reverse=True))
print(l1)
# [9, 0, 3, 2, 8, 4, 5, 7, 1, 6]
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
# [9, 0, 3, 2, 8, 4, 5, 7, 1, 6]（17）列表查找
<1> index()方法：用来查找某个元素在列表中第一次出现的位置（索引）。若无该元素，会导致valueError 错误，所以一般使用count()方法判断是否存在
- 格式：listname.index(obj:start,end)
- listname：列表名
- obj：查找的元素对象
- start：起始索引
- end：终止索引（不包含）
- 返回值：索引
示例：
例1：在列表中查找数据
l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
print(l1.index(2)) # 在列表中查找数值为2的元素索引下标
print(l1.index(8, 3, 10)) # 在下标为3-10的索引中查找数值为8的索引下标
print(l1.index(6, 3)) # 3索引开始到结束，查找数值6
# print(l1.index(4,0,3)) # 在[0,3)索引中查找4，未找到报错，可采用count()判断
例2：列表andy,内容包含名称和一系列比赛得分，计算他在第几场得到最高分
andy = ['andy', 23, 24, 45, 34, 56, 78]
print(andy)
score_max = max(andy[1:])
i = andy.index(score_max)
print(andy[0], '在%d场得到最高分%d' % (i, score_max))
# ['andy', 23, 24, 45, 34, 56, 78]
# andy 在6场得到最高分78<2> 使用in not in查找列表元素
l1 = [12, 234, 56, 7, 8, 990, 89]
print(12 in l1) # True
print(123 not in l1) # True<3> 折半查找（二分法查找）：必须是有序（升序）序列，若为无序应先排序
import random
l1 = random.sample(range(0, 10), 10)
l1.sort()
print(l1)
n = int(input('请输入待查找的值'))
i = 0
j = 9
while i <= j:
mid = (i + j) // 2 # 若为偶数个元素，折半查找的中间数向左偏
# 计算中间数索引
if l1[mid] == n:
print('已找到')
break
else:
if n < l1[mid]:
j = mid - 1 # 向左折半
else:
i = mid + 1
if i > j:
print('未找到')
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 请输入待查找的值5
# 已找到（18）列表的逆置（颠倒顺序）
<1> 格式：listname.reverse()
<2> 示例：
import random
l1 = random.sample(range(0,20),10)
print(l1)
l1.reverse()
print(l1)
# [12, 10, 9, 4, 8, 5, 2, 17, 3, 15]
# [15, 3, 17, 2, 5, 8, 4, 9, 10, 12]PS：永久性改变，若要使用原始数据，只需要再次逆置一次
（19）列表的元素组合：
<1> 作用：将列表的元素组成一个字符串
<2> 格式：char.join(seq)
- char：组合后的元素分隔符
- seq：表示处理的对象，必须为列表、元素等序列数据
char = '-'
l1 = ['hello', 'world', 'education']
print(char.join(l1))
print('=='.join(l1))
print('\n'.join(l1))
# hello-world-education
# hello==world==education
# hello
# world
# education（20）列表的深拷贝和浅拷贝
<1> 列表之间的赋值操作
l1 = [1, 2, 3, 4, 5]
l2 = l1 # 相当于给同一内存区域，起另一个名字
print(id(l1), id(l2))
for i in range(len(l1)):
l1[i] += 1 # 给列表l1中所有元素加1
print(l1)
print(l2)
# 1781136982272 1781136982272
# [2, 3, 4, 5, 6]
# [2, 3, 4, 5, 6]分析：列表的赋值相当于取别名，即两者都指向同一个堆栈区的地址列表。操作任意一个，另一个同步发生变化。
<2> 浅拷贝：浅拷贝针对不可变元素会完全隔离，有可变元素无法实现完全隔离
l1 = [1, 2, 3, 4, 5]
l2 = l1.copy() # l2是l1的浅拷贝结果
print(id(l1), id(l2))
for i in range(len(l1)):
l1[i] += 1
print(l1)
print(l2)
# [2, 3, 4, 5, 6]
# [1, 2, 3, 4, 5]分析：l2是l1的浅拷贝，id与l1不同，这是因为通过浅拷贝，产生一段新的内存地址空间，与l2绑定。内容相同，地址不同；相互隔离，互不影响。但如果列表中出现可变类型，浅拷贝无效。
l1 = [1, 2, [3, 4, 5]]
l2 = l1.copy() # l2是l1的半浅拷贝结果
print(id(l1), id(l2))
l1[0] += 1
l1[1] += 1
l2[2][0] += 1
l2[2][1] += 1
print(l1)
print(l2)
print(id(l1), id(l2))
# 2816571507072 2816571535872
# [2, 3, [4, 5, 5]]
# [1, 2, [4, 5, 5]]
# 2816571507072 2816571535872分析：l1列表两个不可变元素1和2没有改变并未影响l2，但是l1的可变类型元素[3,4]变成了[4,5],l2列表中的子列表也一同发生改变，说明l1和l2并未完全隔离。虽然l1和l2的内存地址互相独立，但是列表第三项绑定的是同一个内存地址，若原列表包含可变类型元素，通过浅拷贝得到的新列表，不能实现与原列表完全隔离，如要完全隔离需要使用深拷贝。
<3> 深拷贝
import copy
l1 = [1, 2, [3, 4]]
l2 = copy.deepcopy(l1) # l2是l1的深拷贝
print(id(l1), id(l2))
l1[0] += 1
l1[1] += 1
l2[2][0] += 1
l2[2][1] += 1
print(id(l1), id(l2))
print(l1)
print(l2)
# 2683227889792 2683229572096---深拷贝也改变了外部地址，实现完全隔离
# 2683227889792 2683229572096---内部可变类型元素地址不同
# [2, 3, [3, 4]]
# [1, 2, [4, 5]]
分析：通过深拷贝，列表实现完全隔离，从而实现与原列表真正的完全区分隔离
（21） 列表的推导式
<1> 作用：可以使用列表推导式生成新列表
<2> 格式：listname = [表达式，for循环变量 in range()]
<3> 例：创建数值为0-9的列表
l1 = [x for x in range(10)]
print(l1)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l1 = []
for x in range(10):
l1.append(x)
print(l1)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<4> 创建100-200间的10个随机数
-
格式：randint(x,y)表示产生一个随机数，范围在x与y之间
import random
l1 = [random.randint(100, 200) for i in range(10)]
print(l1)
# [157, 144, 192, 198, 107, 190, 138, 127, 170, 105]<5> 根据旧列表生成指定新列表
- 格式：newlistname=[表达式 , for 循环变量 in 旧列表]
例：根据原生列表生成数值折半列表
import random
l1 = [random.randint(0, 100) for i in range(10)]
print(l1)
l2 = [x / 2 for x in l1]
print(l2)
# [68, 11, 93, 87, 6, 61, 24, 16, 6, 42]
# [34.0, 5.5, 46.5, 43.5, 3.0, 30.5, 12.0, 8.0, 3.0, 21.0]<6> 从旧列表中选择符合条件的元素组成新列表
- 格式：newlistname=[表达式，for 循环变量 in 旧列表名 if 条件表达式]
例：创建1-10之间的偶数列表
import random
l1 = [random.randint(1, 10) for i in range(10)]
print(l1)
l2 = [x for x in l1 if x % 2 == 0]
print(l2)
# [10, 1, 2, 10, 8, 5, 9, 3, 2, 1]
# [10, 2, 10, 8, 2]PS：只用列表推导式来创建新列表，并且尽可能保持简短；若列表推导式代码超过两行，则代码可读性大大降低，应考虑写成循环
（22）程序实例
<1> 例1：将10个十进制整数存取到列表中，计算列表中的奇数平均值，偶数平均值，偶数方差。
import numpy
import random
x = random.sample(range(0, 30), 10)
a1 = []
a2 = []
for i in x:
if i % 2 == 1:
a1.append(i)
else:
a2.append(i)
print('奇数平均值：', numpy.mean(a1))
print('偶数平均值：', numpy.mean(a2))
print('偶数方差：', numpy.var(a2))
# 奇数平均值： 15.857142857142858
# 偶数平均值： 14.0
# 偶数方差： 98.66666666666667<2> 例：将输出的空格作为分隔符的数字去重后输出
# 2 2 2 3 4 5 4 22 2
# split():将空格分隔的字符串切片后转为字符串列表
l1 = input('请输入空格分隔的字符内容：').split()
for i in range(len(l1)):
l1[i] = int(l1[i])
print(l1)
l2 = []
for i in l1:
if l2.count(i) == 0: # 统计接收到的列表，若为0则表示追加
l2.append(i)
print(l2)
# 请输入空格分隔的字符内容：2 2 2 3 4 5 4 22 2
# [2, 2, 2, 3, 4, 5, 4, 22, 2]
# [2, 3, 4, 5, 22]
<3> 例：合并2个有序列表构成一个新的有序列表
l1 = list(eval(input('请输入第一个列表：')))
l2 = list(eval(input('请输入第二个列表:')))
l1.extend(l2) # extend尾部追加一个元素
l1.sort()
print(l1)
# 请输入第一个列表：1,2,3,4,5,6
# 请输入第二个列表:7,8,9,0,13,12
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13]
<4> 例：编写程序实现判断列表是否为升序
l1 = list(eval(input('请输入第一个列表：')))
f = 1 # 标志位，默认为升序
for i in range(len(l1) - 1):
if l1[i] > l1[i + 1]:
f = 0
break
if f:
print('升序')
else:
print('无序')
# 请输入第一个列表：1,2,3,4,5,6,7,8,9
# 升序
# 请输入第一个列表：1,2,4,3,5,7
# 无序<5> 例：输入一个十进制转为二进制输出
a = int(input('请输入一个整数：'))
print('转为二进制为：', bin(a))
# 请输入一个整数：12
# 转为二进制为： 0b1100
a = int(input('请输入一个十进制整数：'))
l1 = []
if a == 0:
print('0000')
else:
while a:
a, r = divmod(a, 2)
l1.append(r)
l1.reverse()
print(l1)
# 请输入一个十进制整数：12
# [1, 1, 0, 0]<6> 例：将列表前p个元素平移到列表尾部输出
# 法1：
import random as a
l1=a.sample(range(0,20),10)
print(l1)
p=int(input('请输入移动元素个数：'))
for i in range(p):
l1.append(l1[i])
l1=l1[p:]
print(l1)
# [14, 17, 4, 3, 13, 19, 7, 10, 5, 12, 2, 0, 18, 6, 1, 16, 9, 8, 15, 11]
# 请输入移动元素个数：6
# [7, 10, 5, 12, 2, 0, 18, 6, 1, 16, 9, 8, 15, 11, 14, 17, 4, 3, 13, 19]
# 法2
import random as a
l1 = a.sample(range(0, 20), 10)
print(l1)
p = int(input('请输入移动元素个数：'))
l2 = l1[0:p]
l1 = l1[p:]
l3 = l1 + l2
print(l3)
# [0, 17, 13, 6, 15, 14, 8, 10, 1, 9]
# 请输入移动元素个数：3
# [6, 15, 14, 8, 10, 1, 9, 0, 17, 13]
（23）二维列表
<1> 格式：listname=[一维列表1],[一维列表2],[一维列表3],[一维列表n]
<2> 示例：
例1：直接创建
l1=[[1,2,3],
[4,5,6],
[7,8,9]]
print(l1)
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
例2：使用for循环创建
l1 = []
for i in range(2):
l1.append([]) # 每行添加一个空列表
for j in range(4):
l1[i].append(j) # 为内层列表添加元素值
print(l1)
# [[0, 1, 2, 3], [0, 1, 2, 3]]例3：利用列表推导式创建
l1 = [[j for j in range(4)] for i in range(4)]
print(l1)
# [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]例4：二维列表的随机数赋值
import random
l1 = []
for i in range(4):
l1.append([]) # 每行添加一个空列表
for j in range(4):
t = random.randint(10, 30)
l1[i].append(t) # 为内层列表添加元素值
for i in range(4):
print(l1[i])
# [19, 24, 14, 18]
# [18, 14, 20, 16]
# [24, 15, 23, 18]
# [29, 28, 24, 28]例6：计算二维列表每行最大值和每列最小值
import random
l1 = []
max1 = []
min1 = []
for i in range(4): # 二维列表随机数赋值
l1.append([])
for j in range(3):
t = random.randint(10, 20)
l1[i].append(t)
for i in range(4): # 输出
print(l1[i])
for i in range(4): # 计算每行最大值，追加到m1中
max1.append(max(l1[i]))
for j in range(3): # 计算每列最大值。列项访问，内循环调换位置
min1.append(l1[0][j]) # 将当前列第一个值追加到最小数值组中
for i in range(4):
if min1[j] > l1[i][j]:
min1[j] = l1[i][j]
print('每列最小值：', min1)
print('每行最大值：', max1)
# [18, 18, 20]
# [19, 13, 14]
# [19, 17, 19]
# [15, 16, 15]
# 每列最小值： [15, 13, 14]
# 每行最大值： [20, 19, 19, 16]<3> 二维列表局部处理
- 左下半三角元素
例1：二维列表的左下半三角（行号大于列号），左下半三角元素加1
l1 = [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
for i in range(4):
print(l1[i])
for i in range(4):
for j in range(4):
if i > j: # 规则：行>列
l1[i][j] += 1
print()
for j in range(4):
print(l1[j])
# [1, 1, 1, 1]
# [1, 1, 1, 1]
# [1, 1, 1, 1]
# [1, 1, 1, 1]
#
# [1, 1, 1, 1]
# [2, 1, 1, 1]
# [2, 2, 1, 1]
# [2, 2, 2, 1]- 右上半三角元素
l1 = [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
for i in range(4):
print(l1[i])
for i in range(4):
for j in range(4):
if i < j: # 规则：行<列
# 处理l1[ i ] [ j ] +=1
l1[i][j] += 1
print()
for j in range(4):
print(l1[j])
# [1, 1, 1, 1]
# [1, 1, 1, 1]
# [1, 1, 1, 1]
# [1, 1, 1, 1]
#
# [1, 2, 2, 2]
# [1, 1, 2, 2]
# [1, 1, 1, 2]
# [1, 1, 1, 1]- 主副对角线
l1 = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 8, 7, 6], [5, 4, 3, 2]]
for i in range(4):
print(l1[i])
print('主对角线：')
for i in range(4):
print(l1[i][i], end=',')
# [1, 2, 3, 4]
# [5, 6, 7, 8]
# [9, 8, 7, 6]
# [5, 4, 3, 2]
# 主对角线：
# 1,6,7,2,l1 = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 8, 7, 6], [5, 4, 3, 2]]
for i in range(4):
print(l1[i])
print('副对角线：')
for i in range(4):
print(l1[i][4 - i - 1], end=',')
# [1, 2, 3, 4]
# [5, 6, 7, 8]
# [9, 8, 7, 6]
# [5, 4, 3, 2]
# 副对角线：
# 4,7,8,5,PS：上述四种列表只针对行==列的正方形列表
<4> 例：打印杨辉三角前10行。第0列和主对角线为1，中间内容=上方值+左上方值
l1=[]
for i in range(5): # 生成5*5的矩阵，内容为0
l1.append([])
for j in range(5):
l1[i].append([])
for i in range(5):
for j in range(5):
if j==0 or i==j: # 定位第0列及主对角线
l1[i][j] =1
elif i>j:
l1[i][j] = l1[i-1][j] + l1[i-1][j-1]
# 当前值 = 上方值 + 左上方值
for i in range(5):
for j in range(5):
if i>=j:
print(l1[i][j],end=' ')
print()
# 1
# 1 1
# 1 2 1
# 1 3 3 1
# 1 4 6 4 1 PS:以上内容只适合行==列的正方形矩阵
<5> 周边元素处理，计算4*3二维列表周边元素的平均值的平方根
import random as dom
import math
l1 = []
sum = 0
for i in range(4): # 创建行
l1.append([])
for j in range(3): # 创建列
t = dom.randint(1, 10)
l1[i].append(t) # 赋值
for i in range(4):
print(l1[i]) # 按行输出
for i in range(4):
for j in range(3):
if i == 0 or j == 0 or i == 4 - 1 or j == 3 - 1:
sum += l1[i][j]
sum = sum / 10
print('结果为：%.2f' % math.sqrt(sum))
# [5, 10, 10]
# [6, 7, 1]
# [8, 5, 4]
# [8, 3, 6]
# 结果为：2.47PS：周边元素：第0行和最后一行，第0列和最后一列
<6> 二维数组列表的排序问题
import random as dom
l1 = []
sum = 0
for i in range(4):
l1.append([])
for j in range(3):
t = dom.randint(1, 10)
l1[i].append(t)
print('排序前：')
for i in range(4):
print(l1[i])
for i in range(4):
l1[i].sort() # 将行进行排序
print('排序后：')
for i in range(4):
print(l1[i])
# 排序前：
# [7, 9, 9]
# [6, 10, 5]
# [1, 7, 9]
# [3, 8, 9]
# 排序后：
# [7, 9, 9]
# [5, 6, 10]
# [1, 7, 9]
# [3, 8, 9]<7> 思考1：输出n层正方形二维列表，每层与数字相同，如：
l1 = []
n = int(input('请输入层数：'))
for i in range(2 * n - 1):
l1.append([])
for j in range(2 * n - 1):
l1[i].append(0)
for k in range(1, n + 1):
for i in range(k - 1, 2 * n - k):
for j in range(k - 1, 2 * n - k):
l1[i][j] = k
for i in range(2 * n - 1):
for j in range(2 * n - 1):
print(l1[i][j], end=' ')
print()
# 请输入层数：3
# 1 1 1 1 1
# 1 2 2 2 1
# 1 2 3 2 1
# 1 2 2 2 1
# 1 1 1 1 1<8> 思考2：输出螺旋矩阵，如：
l1 = []
num = 1
for i in range(10):
l1.append([])
for j in range(10):
l1[i].append(0)
n = int(input('请输入螺旋矩阵阶数：'))
for k in range(n // 2 + 1): # 总的循环次数
for j in range(k, n - k): # 上边
l1[k][j] = num
num += 1
for i in range(k + 1, n - k - 1): # 右边
l1[i][n - k - 1] = num
num += 1
for j in range(n - k - 1, k, -1): # 下边
l1[n - k - 1][j] = num
num += 1
for i in range(n - k - 1, k, -1): # 左边
l1[i][k] = num
num += 1
for i in range(n):
for j in range(n):
print('{:3d}'.format(l1[i][j], end=' '))
print()
权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区
更多推荐
1
0- 0
已为社区贡献1条内容
所有评论(0)