• python学习笔记（05）---（内置容器-列表）

    目录

    第七章  内置容器（一）

    1.容器概念

    2.列表

    （1）概念：将多种类型数据使用逗号分割放置在中括号中的一组可变序列

    （2）创建列表：

    （3）删除列表：

    （4）通过索引访问列表

    （5）索引引用：listname[索引]，如：team[0],team[1],team[2]

    （6）输出列表：print（列表名）

    （7）列表切片

    （8）列表相加

    （9）列表相乘

    （10）列表的包含与不包含

    （11）列表常用函数

    （12）列表遍历

    （13）程序实例

    （14）列表元素的添加与删除

    （15）列表元素统计：

    （16）列表的排序

    （17）列表查找

    （18）列表的逆置（颠倒顺序）

    （19）列表的元素组合：

    （20）列表的深拷贝和浅拷贝

    （21） 列表的推导式

    （22）程序实例

    （23）二维列表

    第七章  内置容器（一）

    1.容器概念

    （1）在python中包含其他对象的对象，称为容器，是一种数据结构。

    （2）常用容器分为两种：序列（如：列表、元组）和映射（如字典）

    2.列表

    （1）概念：将多种类型数据使用逗号分割放置在中括号中的一组可变序列

    （2）创建列表：

    <1> 格式：listname=[element1,element2,element3……,elementn]

    • listname：列表名，必须符合标识符命名规则
    • element：列表项，元素无个数限制，可以为任意合法的数据类型。

    例：

    1. a = [2, 3, 4, 5]
    2. b = ['china', 'hello', 'world']
    3. c = [45.6, 'hello', '中国']
    4. print(a, b, c, sep='\n')
    5. # [2, 3, 4, 5]
    6. # ['china', 'hello', 'world']
    7. # [45.6, 'hello', '中国']

    <4> 创建空列表：listname = []

    PS:为了提高程序可读性，建议在列表中存储相同类型的数据

    <4> 使用list()内置函数创建列表：

    • 格式：listname = list（迭代对象）

    例：

    1. t1 = list()
    2. t2 = list('china')
    3. print(t1, t2, sep='\n')
    4. # []
    5. # ['c', 'h', 'i', 'n', 'a']

    <5> 使用range()创建数值迭代列表：

    1. t3 = list(range(10, 20, 2))  # 10-20的数值中，创建步长为2的列表
    2. print(t3)
    3. # [10, 12, 14, 16, 18]

    PS：list()参数必须为可迭代对象，否则将报错

    1. 将列表转换为列表无意义，浪费资源：
    2. t1 = [1, 2, 3, 4, 5, 6, 7]
    3. t2 = t1
    4. print(t1)
    5. # [1, 2, 3, 4, 5, 6, 7]

    （3）删除列表：

    <1> 格式1：del  listname

    1. team = ['皇马', '拜仁', '梵蒂冈', '罗马']
    2. del team
    3. # print(team) 报错
    4. # 删除的是引用指向，列表还在

    <2> listname.clear()：清空列表内容，保留列表结构

    1. team = ['皇马', '拜仁', '梵蒂冈', '罗马']
    2. team.clear()
    3. print(team)
    4. # []

    PS：python自带垃圾回收机制，会自动销毁不同列表，一般不需要手动删除

    （4）通过索引访问列表

    <1> 作用：在序列中每个元素都有一个编号（下标），可用于访问元素

    <2> 原则：由左向右从 0 开始递增，也可由右向左从-1开始递减

    <3> 例：

    （5）索引引用：listname[索引]，如：team[0],team[1],team[2]

    <1> 注意：可以通过列表索引删除元素：del  listname[索引]。当为空列表，不能通过索引访问引用

    1. team = []
    2. team[0] # 报错

    （6）输出列表：print（列表名）

    （7）列表切片

    <1> 作用：通过切片可以访问一定范围内的元素

    <2> 格式：listname[start:end:step]

    • start:切片开始索引（包含），省略则为0
    • end:切片截止索引（不包含），省略则整个列表长度
    • step:切片长度，省略则为1，且最后一个冒号也可以省略，为负值表示反向取值

    <3> 例：

    1. t1 = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
    2. #     0 1 2 3 4  5   6  7  8  9
    3. print(t1[0:7:4])  # 输出索引0-6，间隔为4的值
    4. print(t1[1:5])  # 1索引开始，到4索引结束，默认间隔为1
    5. print(t1[2:])  # 2索引开始到结尾
    6. print(t1)  # 输出列表全部内容
    7. print(t1[:])  # 全部内容
    8. print(t1[::])  # 全部内容
    9. print(t1[0:])  # 全部内容
    10. print(t1[:-1])  # 正序输出，不包含最后一个数
    11. # 相当于 print(t1[0:-1:1])
    12. print(t1[0:6:0])  # 报错，步长不能为0
    13. print(t1[::-1])  # 反向输出

    （8）列表相加

    <1> 作用：将相同类型的序列连接，但是不会去掉重复值

    <2> 符号：+（列表的连接）

    <3> 示例：

    1. 例1：
    2. t1 = [1, 2, 3]
    3. t2 = [4, 5, 6]
    4. t3 = ['hello']
    5. t4 = ['world']
    6. t5 = t1 + t2
    7. t6 = t3 + t4
    8. t7 = t5 + t6
    9. print(t5, t6, t7, sep='\n')
    10. # [1, 2, 3, 4, 5, 6]
    11. # ['hello', 'world']
    12. # [1, 2, 3, 4, 5, 6, 'hello', 'world']
    1. 例2：列表和常量连接会报错
    2. t1 = [1, 2, 3, 4, 5, 6, 7]
    3. print(t1 + 8)  # 报错
    4. t2 = ['hello', 'world']
    5. print(t2 + 'china')  # 报错

    （9）列表相乘

    <1> 作用：使用数字n乘以一个列表会进行复制，重复n次

    <2> 符号：*

    <3> 示例：

    1. 例1：
    2. t1 = [1, 2, 3]
    3. t2 = ['hello', 'world']
    4. print(3 * t1)
    5. print(2 * t2)
    6. # [1, 2, 3, 1, 2, 3, 1, 2, 3]
    7. # ['hello', 'world', 'hello', 'world']
    1. 例2：初始化长度为n的空列表
    2. emptylist = [None] * 5
    3. print(emptylist)
    4. # [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：输出列表最大值

    1. import random as r
    2. 法1：
    3. t1 = r.sample(range(10, 20), 10)
    4. # 产生10-30,10个随机数
    5. print(t1)
    6. print('max=', max(t1))
    7. 法2：
    8. # 将列表排序后输出最大值
    9. t1 = r.sample(range(10, 20), 10)
    10. # 产生10-30,10个随机数
    11. t1.sort()
    12. print(t1)
    13. print('max=',t1[-1])
    14. 法3：for循环输出最大值
    15. t1 = r.sample(range(10, 30), 10)
    16. print(t1)
    17. max = t1[0]  # max变量存储列表的第一个元素
    18. for i in t1:
    19.     if max < i:
    20.         max = i  # 将最大值存储到列表中第一个元素中
    21. print('max=', max)
    22.  
    23. # [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    24. # max= 19

    <2> 例2：将列表中值为偶数，索引为奇数的值输出

    1. import random as r
    2.  
    3. t1 = r.sample(range(10, 30), 10)
    4. print(t1)
    5. for index, item in enumerate(t1):
    6.     if item % 2 == 0 and index % 2 == 1:
    7.         print(index, item)
    8. # [19, 25, 18, 10, 15, 22, 23, 17, 21, 14]
    9. # 3 10
    10. # 5 22
    11. # 9 14

    <3> 例3：素数筛选判断法：筛选出100以内的素数
    产生2-99的序列：2 3 4 5 6 7 8 9......99

    1. list1 = list(range(0, 101))  # 产生0-100的列表
    2. print()
    3. i = 2  # 从最小素数2开始
    4. while i < 100:  # 遍历列表
    5.     j = list1[i] * 2  # 计算当前值的倍数
    6.     while j < 100:
    7.         list1[j] = 0  # 将倍数置为0
    8.         j = j + list1[i]
    9.     i += 1
    10.     while list1[i] == 0:
    11.         i += 1  # 排除已经置为0的元素不再遍历
    12. # 循环数除列表中不是0的素数
    13. t = 0
    14. for i in range(2, 100):
    15.     if list1[i] != 0:
    16.         t += 1
    17.         print(list1[i], end=' ')
    18.         if t % 10 == 0:
    19.             print()
    20. # 2 3 5 7 11 13 17 19 23 29 
    21. # 31 37 41 43 47 53 59 61 67 71 
    22. # 73 79 83 89 97

    （14）列表元素的添加与删除

    <1> 添加元素：listname.append(obj)

    <2> 例：将值为奇数，索引为偶数的元素存储到另一个列表中

    1. import random as r
    2.  
    3. t1 = r.sample(range(10, 30), 10)
    4. t2 = []
    5. for index, item in enumerate(t1):
    6.     if item % 2 == 0 and index % 2 == 1:
    7.         t2.append(item)
    8. print(t2)
    9. # [12, 28]

    <3> 例：删除元素

    • 根据索引删除：del  listname[index]
    • 根据内容删除：listname.remove()
    1. import random as r
    2.  
    3. t1 = r.sample(range(10, 30), 10)
    4. print(t1)
    5. n = int(input('请输入需要删除的元素的值：'))
    6. t1.remove(n)
    7. print(t1)
    8. # [26, 22, 28, 23, 10, 14, 11, 17, 19, 13]
    9. # 请输入需要删除的元素的值：26
    10. # [22, 28, 23, 10, 14, 11, 17, 19, 13]

    （15）列表元素统计：

    <1> 格式：listname.count(obj)

    <2> 作用：获取元素在列表中出现的次数，只能精确匹配

    <3> 注意：count()方法与remove()方法配合使用，删除前首先统计元素是否存在

    <4> 例：删除列表中元素的值，删除前可确认元素在不在列表中

    1. import random as r
    2.  
    3. t1 = r.sample(range(10, 30), 10)
    4. print(t1)
    5. n = int(input('请输入需要删除的元素的值:'))
    6. if t1.count(n) > 0:
    7.     t1.remove(n)
    8.     print(t1)
    9. else:
    10.     print('输入元素不在列表中')
    11. # [28, 18, 23, 16, 26, 13, 10, 27, 20, 11]
    12. # 请输入需要删除的元素的值:1
    13. # 输入元素不在列表中

    （16）列表的排序

    <1> 选择法排序：有n个元素参与排序，一共进行n-1次比较，每次都是当前值与下一个值进行比较，比较到n之前结束（大于号是升序，小于号是降序）

    1. t1 = r.sample(range(10, 20), 10)
    2. print('排序前：', t1)
    3. for i in range(len(t1) - 1):
    4.     for j in range(i + 1, len(t1)):
    5.         if t1[i] > t1[j]:
    6.             t1[i], t1[j] = t1[j], t1[i]
    7. print('排序后:', t1)
    8. # 排序前： [11, 13, 14, 16, 10, 15, 19, 12, 18, 17]
    9. # 排序后: [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

    <2> 插入法排序：将无序序列分成两个部分,( 前:有序, 后:无序 )通过构建有序序列；对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入；插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间

    1. import random
    2.  
    3. t1 = random.sample(range(0, 10), 10)
    4. print('排序前：', t1)
    5. for i in range(0, 10):
    6.     t = t1[i]  # t为待插入元素
    7.     j = i - 1
    8.     while j >= 1 and t < t1[j]:
    9.         t1[j + 1] = t1[j]
    10.         j = j - 1
    11.     t1[j + 1] = t  # 插入备份元素
    12. print('排序后：', t1)
    13. # 排序前： [0, 9, 7, 3, 5, 2, 8, 4, 6, 1]
    14. # 排序后： [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

    例：对列表进行升序和降序排序

    1. import random as r
    2.  
    3. l1 = r.sample(range(0, 20), 10)
    4. print(l1)
    5. l1.sort()  # 升序
    6. print(l1)
    7. l1.sort(reverse=True)  # 降序
    8. print(l1)
    9. # [11, 17, 5, 2, 6, 19, 13, 10, 1, 8]
    10. # [1, 2, 5, 6, 8, 10, 11, 13, 17, 19]
    11. # [19, 17, 13, 11, 10, 8, 6, 5, 2, 1]

    <5> 使用内置sorted()

    • 用法参照sort()
    • PS：不改变列表顺序，会生成副本

    例：对列表进行降序排序

    1. import random as r
    2.  
    3. l1 = r.sample(range(0,10),10)
    4. print(l1)
    5. print(sorted(l1,reverse=True))
    6. print(l1)
    7. # [9, 0, 3, 2, 8, 4, 5, 7, 1, 6]
    8. # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
    9. # [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. 例1：在列表中查找数据
    2. l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
    3. print(l1.index(2))  # 在列表中查找数值为2的元素索引下标
    4. print(l1.index(8, 3, 10))  # 在下标为3-10的索引中查找数值为8的索引下标
    5. print(l1.index(6, 3))  # 3索引开始到结束，查找数值6
    6. # print(l1.index(4,0,3))  # 在[0,3)索引中查找4，未找到报错，可采用count()判断
    1. 例2：列表andy,内容包含名称和一系列比赛得分，计算他在第几场得到最高分
    2. andy = ['andy', 23, 24, 45, 34, 56, 78]
    3. print(andy)
    4. score_max = max(andy[1:])
    5. i = andy.index(score_max)
    6. print(andy[0], '在%d场得到最高分%d' % (i, score_max))
    7. # ['andy', 23, 24, 45, 34, 56, 78]
    8. # andy 在6场得到最高分78

    <2> 使用in   not in查找列表元素

    1. l1 = [12, 234, 56, 7, 8, 990, 89]
    2. print(12 in l1)  # True
    3. print(123 not in l1)  # True

    <3> 折半查找（二分法查找）：必须是有序（升序）序列，若为无序应先排序

    1. import random
    2.  
    3. l1 = random.sample(range(0, 10), 10)
    4. l1.sort()
    5. print(l1)
    6. n = int(input('请输入待查找的值'))
    7. i = 0
    8. j = 9
    9. while i <= j:
    10.     mid = (i + j) // 2  # 若为偶数个元素，折半查找的中间数向左偏
    11.     # 计算中间数索引
    12.     if l1[mid] == n:
    13.         print('已找到')
    14.         break
    15.     else:
    16.         if n < l1[mid]:
    17.             j = mid - 1  # 向左折半
    18.         else:
    19.             i = mid + 1
    20. if i > j:
    21.     print('未找到')
    22. # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    23. # 请输入待查找的值5
    24. # 已找到

    （18）列表的逆置（颠倒顺序）

    <1> 格式：listname.reverse()

    <2> 示例：

    1. import random
    2.  
    3. l1 = random.sample(range(0,20),10)
    4. print(l1)
    5. l1.reverse()
    6. print(l1)
    7. # [12, 10, 9, 4, 8, 5, 2, 17, 3, 15]
    8. # [15, 3, 17, 2, 5, 8, 4, 9, 10, 12]

    PS：永久性改变，若要使用原始数据，只需要再次逆置一次

    （19）列表的元素组合：

    <1> 作用：将列表的元素组成一个字符串

    <2> 格式：char.join(seq)

    • char：组合后的元素分隔符
    • seq：表示处理的对象，必须为列表、元素等序列数据
    1. char = '-'
    2. l1 = ['hello', 'world', 'education']
    3. print(char.join(l1))
    4. print('=='.join(l1))
    5. print('\n'.join(l1))
    6. # hello-world-education
    7. # hello==world==education
    8. # hello
    9. # world
    10. # education

    （20）列表的深拷贝和浅拷贝

    <1> 列表之间的赋值操作

    1. l1 = [1, 2, 3, 4, 5]
    2. l2 = l1  # 相当于给同一内存区域，起另一个名字
    3. print(id(l1), id(l2))
    4. for i in range(len(l1)):
    5.     l1[i] += 1  # 给列表l1中所有元素加1
    6. print(l1)
    7. print(l2)
    8. # 1781136982272 1781136982272
    9. # [2, 3, 4, 5, 6]
    10. # [2, 3, 4, 5, 6]

    分析：列表的赋值相当于取别名，即两者都指向同一个堆栈区的地址列表。操作任意一个，另一个同步发生变化。

    <2> 浅拷贝：浅拷贝针对不可变元素会完全隔离，有可变元素无法实现完全隔离

    1. l1 = [1, 2, 3, 4, 5]
    2. l2 = l1.copy()  # l2是l1的浅拷贝结果
    3. print(id(l1), id(l2))
    4. for i in range(len(l1)):
    5.     l1[i] += 1  
    6. print(l1)
    7. print(l2)
    8. # [2, 3, 4, 5, 6]
    9. # [1, 2, 3, 4, 5]

    分析：l2是l1的浅拷贝，id与l1不同，这是因为通过浅拷贝，产生一段新的内存地址空间，与l2绑定。内容相同，地址不同；相互隔离，互不影响。但如果列表中出现可变类型，浅拷贝无效。

    1. l1 = [1, 2, [3, 4, 5]]
    2. l2 = l1.copy()  # l2是l1的半浅拷贝结果
    3. print(id(l1), id(l2))
    4. l1[0] += 1
    5. l1[1] += 1
    6. l2[2][0] += 1
    7. l2[2][1] += 1
    8. print(l1)
    9. print(l2)
    10. print(id(l1), id(l2))
    11. # 2816571507072 2816571535872
    12. # [2, 3, [4, 5, 5]]
    13. # [1, 2, [4, 5, 5]]
    14. # 2816571507072 2816571535872

    分析：l1列表两个不可变元素1和2没有改变并未影响l2，但是l1的可变类型元素[3,4]变成了[4,5],l2列表中的子列表也一同发生改变，说明l1和l2并未完全隔离。虽然l1和l2的内存地址互相独立，但是列表第三项绑定的是同一个内存地址，若原列表包含可变类型元素，通过浅拷贝得到的新列表，不能实现与原列表完全隔离，如要完全隔离需要使用深拷贝。

    <3> 深拷贝

    1. import copy
    2.  
    3. l1 = [1, 2, [3, 4]]
    4. l2 = copy.deepcopy(l1)  # l2是l1的深拷贝
    5. print(id(l1), id(l2))
    6. l1[0] += 1
    7. l1[1] += 1
    8. l2[2][0] += 1
    9. l2[2][1] += 1
    10. print(id(l1), id(l2))
    11. print(l1)
    12. print(l2)
    13. # 2683227889792 2683229572096---深拷贝也改变了外部地址，实现完全隔离
    14. # 2683227889792 2683229572096---内部可变类型元素地址不同
    15. # [2, 3, [3, 4]]
    16. # [1, 2, [4, 5]]

    分析：通过深拷贝，列表实现完全隔离，从而实现与原列表真正的完全区分隔离

    （21） 列表的推导式

    <1> 作用：可以使用列表推导式生成新列表

    <2> 格式：listname = [表达式，for循环变量 in range()]

    <3> 例：创建数值为0-9的列表

    1. l1 = [x for x in range(10)]
    2. print(l1)
    3. # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    4. l1 = []
    5. for x in range(10):
    6.     l1.append(x)
    7. print(l1)
    8. # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    <4> 创建100-200间的10个随机数

    • 格式：randint(x,y)表示产生一个随机数，范围在x与y之间

    1. import random
    2.  
    3. l1 = [random.randint(100, 200) for i in range(10)]
    4. print(l1)
    5. # [157, 144, 192, 198, 107, 190, 138, 127, 170, 105]

    <5> 根据旧列表生成指定新列表

    • 格式：newlistname=[表达式 , for 循环变量 in 旧列表]

    例：根据原生列表生成数值折半列表

    1. import random
    2.  
    3. l1 = [random.randint(0, 100) for i in range(10)]
    4. print(l1)
    5. l2 = [x / 2 for x in l1]
    6. print(l2)
    7. # [68, 11, 93, 87, 6, 61, 24, 16, 6, 42]
    8. # [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之间的偶数列表

    1. import random
    2.  
    3. l1 = [random.randint(1, 10) for i in range(10)]
    4. print(l1)
    5. l2 = [x for x in l1 if x % 2 == 0]
    6. print(l2)
    7. # [10, 1, 2, 10, 8, 5, 9, 3, 2, 1]
    8. # [10, 2, 10, 8, 2]

    PS：只用列表推导式来创建新列表，并且尽可能保持简短；若列表推导式代码超过两行，则代码可读性大大降低，应考虑写成循环

    （22）程序实例

    <1> 例1：将10个十进制整数存取到列表中，计算列表中的奇数平均值，偶数平均值，偶数方差。

    1. import numpy
    2. import random
    3.  
    4. x = random.sample(range(0, 30), 10)
    5. a1 = []
    6. a2 = []
    7. for i in x:
    8.     if i % 2 == 1:
    9.         a1.append(i)
    10.     else:
    11.         a2.append(i)
    12. print('奇数平均值：', numpy.mean(a1))
    13. print('偶数平均值：', numpy.mean(a2))
    14. print('偶数方差：', numpy.var(a2))
    15. # 奇数平均值： 15.857142857142858
    16. # 偶数平均值： 14.0
    17. # 偶数方差： 98.66666666666667

    <2> 例：将输出的空格作为分隔符的数字去重后输出

    1. # 2 2 2 3 4 5 4 22 2
    2. # split():将空格分隔的字符串切片后转为字符串列表
    3. l1 = input('请输入空格分隔的字符内容：').split()
    4. for i in range(len(l1)):
    5.     l1[i] = int(l1[i])
    6. print(l1)
    7. l2 = []
    8. for i in l1:
    9.     if l2.count(i) == 0:  # 统计接收到的列表，若为0则表示追加
    10.         l2.append(i)
    11. print(l2)
    12. # 请输入空格分隔的字符内容：2 2 2 3 4 5 4 22 2
    13. # [2, 2, 2, 3, 4, 5, 4, 22, 2]
    14. # [2, 3, 4, 5, 22]

    <3> 例：合并2个有序列表构成一个新的有序列表

    1. l1 = list(eval(input('请输入第一个列表：')))
    2. l2 = list(eval(input('请输入第二个列表:')))
    3. l1.extend(l2)  # extend尾部追加一个元素
    4. l1.sort()
    5. print(l1)
    6. # 请输入第一个列表：1,2,3,4,5,6
    7. # 请输入第二个列表:7,8,9,0,13,12
    8. # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13]

    <4> 例：编写程序实现判断列表是否为升序

    1. l1 = list(eval(input('请输入第一个列表：')))
    2. f = 1  # 标志位，默认为升序
    3. for i in range(len(l1) - 1):
    4.     if l1[i] > l1[i + 1]:
    5.         f = 0
    6.         break
    7. if f:
    8.     print('升序')
    9. else:
    10.     print('无序')
    11. # 请输入第一个列表：1,2,3,4,5,6,7,8,9
    12. # 升序
    13. # 请输入第一个列表：1,2,4,3,5,7
    14. # 无序

    <5> 例：输入一个十进制转为二进制输出

    1. a = int(input('请输入一个整数：'))
    2. print('转为二进制为：', bin(a))
    3. # 请输入一个整数：12
    4. # 转为二进制为： 0b1100
    5.  
    6. a = int(input('请输入一个十进制整数：'))
    7. l1 = []
    8. if a == 0:
    9.     print('0000')
    10. else:
    11.     while a:
    12.         a, r = divmod(a, 2)
    13.         l1.append(r)
    14.     l1.reverse()
    15.     print(l1)
    16. # 请输入一个十进制整数：12
    17. # [1, 1, 0, 0]

    <6> 例：将列表前p个元素平移到列表尾部输出

    1. # 法1：
    2. import random as a
    3. l1=a.sample(range(0,20),10)
    4. print(l1)
    5. p=int(input('请输入移动元素个数：'))
    6. for i in range(p):
    7.     l1.append(l1[i])
    8. l1=l1[p:]
    9. print(l1)
    10. # [14, 17, 4, 3, 13, 19, 7, 10, 5, 12, 2, 0, 18, 6, 1, 16, 9, 8, 15, 11]
    11. # 请输入移动元素个数：6
    12. # [7, 10, 5, 12, 2, 0, 18, 6, 1, 16, 9, 8, 15, 11, 14, 17, 4, 3, 13, 19]
    13. # 法2
    14. import random as a
    15.  
    16. l1 = a.sample(range(0, 20), 10)
    17. print(l1)
    18. p = int(input('请输入移动元素个数：'))
    19. l2 = l1[0:p]
    20. l1 = l1[p:]
    21. l3 = l1 + l2
    22. print(l3)
    23. # [0, 17, 13, 6, 15, 14, 8, 10, 1, 9]
    24. # 请输入移动元素个数：3
    25. # [6, 15, 14, 8, 10, 1, 9, 0, 17, 13]

    （23）二维列表

    <1> 格式：listname=[一维列表1],[一维列表2],[一维列表3],[一维列表n]

    <2> 示例：

    例1：直接创建

    1. l1=[[1,2,3],
    2.     [4,5,6],
    3.     [7,8,9]]
    4. print(l1)
    5. # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    例2：使用for循环创建

    1. l1 = []
    2. for i in range(2):
    3.     l1.append([])  # 每行添加一个空列表
    4.     for j in range(4):
    5.         l1[i].append(j)  # 为内层列表添加元素值
    6. print(l1)
    7. # [[0, 1, 2, 3], [0, 1, 2, 3]]

    例3：利用列表推导式创建

    1. l1 = [[j for j in range(4)] for i in range(4)]
    2. print(l1)
    3. # [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]

    例4：二维列表的随机数赋值

    1. import random
    2.  
    3. l1 = []
    4. for i in range(4):
    5.     l1.append([])  # 每行添加一个空列表
    6.     for j in range(4):
    7.         t = random.randint(10, 30)
    8.         l1[i].append(t)  # 为内层列表添加元素值
    9. for i in range(4):
    10.     print(l1[i])
    11. # [19, 24, 14, 18]
    12. # [18, 14, 20, 16]
    13. # [24, 15, 23, 18]
    14. # [29, 28, 24, 28]

    例6：计算二维列表每行最大值和每列最小值

    1. import random
    2.  
    3. l1 = []
    4. max1 = []
    5. min1 = []
    6. for i in range(4):  # 二维列表随机数赋值
    7.     l1.append([])
    8.     for j in range(3):
    9.         t = random.randint(10, 20)
    10.         l1[i].append(t)
    11.  
    12. for i in range(4):  # 输出
    13.     print(l1[i])
    14.  
    15. for i in range(4):  # 计算每行最大值，追加到m1中
    16.     max1.append(max(l1[i]))
    17.  
    18. for j in range(3):  # 计算每列最大值。列项访问，内循环调换位置
    19.     min1.append(l1[0][j])  # 将当前列第一个值追加到最小数值组中
    20.     for i in range(4):
    21.         if min1[j] > l1[i][j]:
    22.             min1[j] = l1[i][j]
    23. print('每列最小值：', min1)
    24. print('每行最大值：', max1)
    25. # [18, 18, 20]
    26. # [19, 13, 14]
    27. # [19, 17, 19]
    28. # [15, 16, 15]
    29. # 每列最小值： [15, 13, 14]
    30. # 每行最大值： [20, 19, 19, 16]

    <3> 二维列表局部处理

    • 左下半三角元素

    例1：二维列表的左下半三角（行号大于列号），左下半三角元素加1

    1. l1 = [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
    2. for i in range(4):
    3.     print(l1[i])
    4. for i in range(4):
    5.     for j in range(4):
    6.         if i > j:  # 规则：行>列
    7.             l1[i][j] += 1
    8. print()
    9. for j in range(4):
    10.     print(l1[j])
    11. # [1, 1, 1, 1]
    12. # [1, 1, 1, 1]
    13. # [1, 1, 1, 1]
    14. # [1, 1, 1, 1]
    15. # 
    16. # [1, 1, 1, 1]
    17. # [2, 1, 1, 1]
    18. # [2, 2, 1, 1]
    19. # [2, 2, 2, 1]
    • 右上半三角元素
    1. l1 = [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
    2. for i in range(4):
    3.     print(l1[i])
    4. for i in range(4):
    5.     for j in range(4):
    6.         if i < j:  # 规则：行<列
    7.             # 处理l1[ i ] [ j ] +=1
    8.             l1[i][j] += 1
    9. print()
    10. for j in range(4):
    11.     print(l1[j])
    12. # [1, 1, 1, 1]
    13. # [1, 1, 1, 1]
    14. # [1, 1, 1, 1]
    15. # [1, 1, 1, 1]
    16. # 
    17. # [1, 2, 2, 2]
    18. # [1, 1, 2, 2]
    19. # [1, 1, 1, 2]
    20. # [1, 1, 1, 1]
    • 主副对角线

    1. l1 = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 8, 7, 6], [5, 4, 3, 2]]
    2. for i in range(4):
    3.     print(l1[i])
    4. print('主对角线：')
    5. for i in range(4):
    6.     print(l1[i][i], end=',')
    7. # [1, 2, 3, 4]
    8. # [5, 6, 7, 8]
    9. # [9, 8, 7, 6]
    10. # [5, 4, 3, 2]
    11. # 主对角线：
    12. # 1,6,7,2,
    1. l1 = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 8, 7, 6], [5, 4, 3, 2]]
    2. for i in range(4):
    3.     print(l1[i])
    4. print('副对角线：')
    5. for i in range(4):
    6.     print(l1[i][4 - i - 1], end=',')
    7. # [1, 2, 3, 4]
    8. # [5, 6, 7, 8]
    9. # [9, 8, 7, 6]
    10. # [5, 4, 3, 2]
    11. # 副对角线：
    12. # 4,7,8,5,

    PS：上述四种列表只针对行==列的正方形列表

    <4> 例：打印杨辉三角前10行。第0列和主对角线为1，中间内容=上方值+左上方值

    1. l1=[]
    2. for i in range(5):  # 生成5*5的矩阵，内容为0
    3.     l1.append([])
    4.     for j in range(5):
    5.         l1[i].append([])
    6.  
    7. for i in range(5):
    8.     for j in range(5):
    9.         if j==0 or i==j:  # 定位第0列及主对角线
    10.             l1[i][j] =1
    11.         elif i>j:
    12.             l1[i][j] = l1[i-1][j] + l1[i-1][j-1]
    13.             # 当前值  = 上方值 + 左上方值
    14. for i in range(5):
    15.     for j in range(5):
    16.         if i>=j:
    17.             print(l1[i][j],end=' ')
    18.     print()
    19. # 1 
    20. # 1 1 
    21. # 1 2 1 
    22. # 1 3 3 1 
    23. # 1 4 6 4 1

    PS:以上内容只适合行==列的正方形矩阵

    <5> 周边元素处理，计算4*3二维列表周边元素的平均值的平方根

    1. import random as dom
    2. import math
    3.  
    4. l1 = []
    5. sum = 0
    6. for i in range(4):  # 创建行
    7.     l1.append([])
    8.     for j in range(3):  # 创建列
    9.         t = dom.randint(1, 10)
    10.         l1[i].append(t)  # 赋值
    11. for i in range(4):
    12.     print(l1[i])  # 按行输出
    13. for i in range(4):
    14.     for j in range(3):
    15.         if i == 0 or j == 0 or i == 4 - 1 or j == 3 - 1:
    16.             sum += l1[i][j]
    17. sum = sum / 10
    18. print('结果为：%.2f' % math.sqrt(sum))
    19. # [5, 10, 10]
    20. # [6, 7, 1]
    21. # [8, 5, 4]
    22. # [8, 3, 6]
    23. # 结果为：2.47

    PS：周边元素：第0行和最后一行，第0列和最后一列

    <6> 二维数组列表的排序问题

    1. import random as dom
    2.  
    3. l1 = []
    4. sum = 0
    5. for i in range(4):
    6.     l1.append([])
    7.     for j in range(3):
    8.         t = dom.randint(1, 10)
    9.         l1[i].append(t)
    10. print('排序前：')
    11. for i in range(4):
    12.     print(l1[i])
    13. for i in range(4):
    14.     l1[i].sort()  # 将行进行排序
    15. print('排序后：')
    16. for i in range(4):
    17.     print(l1[i])
    18. # 排序前：
    19. # [7, 9, 9]
    20. # [6, 10, 5]
    21. # [1, 7, 9]
    22. # [3, 8, 9]
    23. # 排序后：
    24. # [7, 9, 9]
    25. # [5, 6, 10]
    26. # [1, 7, 9]
    27. # [3, 8, 9]

    <7> 思考1：输出n层正方形二维列表，每层与数字相同，如：

    1. l1 = []
    2. n = int(input('请输入层数：'))
    3. for i in range(2 * n - 1):
    4.     l1.append([])
    5.     for j in range(2 * n - 1):
    6.         l1[i].append(0)
    7.  
    8. for k in range(1, n + 1):
    9.     for i in range(k - 1, 2 * n - k):
    10.         for j in range(k - 1, 2 * n - k):
    11.             l1[i][j] = k
    12.  
    13. for i in range(2 * n - 1):
    14.     for j in range(2 * n - 1):
    15.         print(l1[i][j], end=' ')
    16.     print()
    17. # 请输入层数：3
    18. # 1 1 1 1 1 
    19. # 1 2 2 2 1 
    20. # 1 2 3 2 1 
    21. # 1 2 2 2 1 
    22. # 1 1 1 1 1

    <8> 思考2：输出螺旋矩阵，如：


    1. l1 = []
    2. num = 1
    3. for i in range(10):
    4.     l1.append([])
    5.     for j in range(10):
    6.         l1[i].append(0)
    7. n = int(input('请输入螺旋矩阵阶数：'))
    8. for k in range(n // 2 + 1):  # 总的循环次数
    9.     for j in range(k, n - k):  # 上边
    10.         l1[k][j] = num
    11.         num += 1
    12.     for i in range(k + 1, n - k - 1):  # 右边
    13.         l1[i][n - k - 1] = num
    14.         num += 1
    15.     for j in range(n - k - 1, k, -1):  # 下边
    16.         l1[n - k - 1][j] = num
    17.         num += 1
    18.     for i in range(n - k - 1, k, -1):  # 左边
    19.         l1[i][k] = num
    20.         num += 1
    21. for i in range(n):
    22.     for j in range(n):
    23.         print('{:3d}'.format(l1[i][j], end=' '))
    24.     print()
  • 相关阅读:
    FAST-LIO论文阅读
    CSS之常用属性、元素的显示模式、盒模型
    sql语句数据库查询：如果当前元素已经使用过，下拉框不显示该元素该如何查询？
    BC题目归纳
    CentOS8替代盘点
    Spring AOP 简单使用
    最年轻获奖者诞生！一文带你了解历届国家最高科学技术奖获奖人
    linux centos安装nvm
    Mac M3 Pro 部署Flink-1.16.3
    RabbitMQ中的死信队列产生的几个条件和应用场景
  • 原文地址：https://blog.csdn.net/weixin_62443409/article/details/127818856