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

最新推荐文章于 2023-06-10 01:35:05 发布
最新推荐文章于 2023-06-10 01:35:05 发布
阅读量5.8k 收藏 2
点赞数 1
分类专栏： python学习笔记 文章标签： 学习 python numpy list pip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62443409/article/details/127818856
版权

目录

第七章  内置容器（一）

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：列表项，元素无个数限制，可以为任意合法的数据类型。

例：

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.47

PS：周边元素：第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()
雨天_
关注
专栏目录
Python学习笔记 - 探索8种内置函数（上）
Mr数据杨
03-21 1万+
在本教程中，我们深入探索了Python的八种核心内置函数类别前半部分，包括数学函数、类型转换函数、可迭代对象和迭代器。这些函数是Python编程的基础工具，理解并掌握它们将使你能够编写更简洁、高效和可维护的代码。无论是处理复杂的数据结构、执行高效的迭代、管理文件操作，还是实现面向对象的程序设计，这些内置函数都能提供强大的支持。通过不断实践和探索，你将能够更好地运用这些函数来解决实际编程中的问题。希望本教程能够为你的Python学习之旅提供帮助，祝你在编程的道路上不断进步，成为一名更加优秀的开发者。
Python学习笔记-生成器的应用与原理
最新发布
Mr数据杨
11-05 31
生成器是Python中强大且高效的数据生成工具，尤其适合于需要处理大量数据、数据流或长时间任务的场景。通过逐步生成和返回数据，生成器能够有效减少内存消耗，提升程序的性能。Python的生成器还支持多种高级用法，包括生成器表达式、递归生成器以及异步生成器等，使其应用范围涵盖了从基本的序列生成到复杂的异步数据处理。通过系统地学习与实践生成器，可以充分发挥Python在数据生成与处理上的强大能力，为开发更加高效、稳定的应用奠定基础。
Python字符串索引
m0_69752994的博客
04-08 5286
关于string索引的具体介绍
chatgpt赋能python：Python如何从右往左取数
www_xuhss_com的博客
06-10 841
Python中，可以使用负数索引和切片操作从右往左访问列表、字符串等数据结构的元素，也可以通过reversed()函数将可迭代序列反向排列。这些方法可以帮助我们更方便地访问反向元素，避免不必要的遍历操作。本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是chatgpt能力的冰山一角。作为通用的Aigc大模型，只是展现它原本的实力。对于颠覆工作方式的ChatGPT，应该选择拥抱而不是抗拒，未来属于“会用”AI的人。🧡AI职场汇报智能办公文案写作效率提升教程 🧡专注于。
python字符串从左到右索引_python 基础笔记二
weixin_42099987的博客
02-10 4999
Python 变量类型变量存储在内存中，这意味着在创建变量时会在内存中开辟一个空间，用于存放变量的标识、名称、数据。变量的赋值：1.python变量赋值不需要类型声明；2.每个变量在使用前必须赋值，变量赋值以后该变量才会被创建；3.如果变量在脚本中多次被赋值(类型不同)，以最后一次赋值的数据类型为准4.用 = 来给变量赋值；5.多个变量可以同时赋值，如下所示：5.1)、a=b=c=15.2)、a,...
python基础
旺财财的博客
01-14 5880
python基础 文章目录python基础基础语法关键字标识符多行语句数据类型字符串输出import 与from import基本数据类型多个变量赋值标准数据类型Number（数字）数值运算数学函数随机数函数三角函数数学常量String（字符串）字符串切片转义字符字符串运算符字符串格式化字符格式化操作符辅助指令字符串内建函数List（列表）列表切片基础操作访问列标中的值列标更新列表脚本操作符列表截取与拼接列表嵌套列表函数和方法Tuple（元组）访问元组删除元素元组运算符元组切片元组内置函数关于元组是不可变的
python内置容器
weixin_64311421的博客
10-22 339
python内置容器
Python学习笔记--4.Python内置数据结构集合和字典
Rabbit_hyl的博客
06-19 1969
Python学习笔记--4.Python内置数据结构集合和字典前言一、集合集合的创建:集合内置方法--增删改查等frozenset二、字典字典创建、增删改查defaultdict笔记补充 前言 本章我们继续学习python内置数据结构集合和字典。包括集合、frozenset、字典、defaultdict。 集合（set）是一个无序不重复的元素序列，可用于去重。 字典(dict)是另一种可变容器模型，可存储任意类型对象。采用键值对的方式存储，键一般是唯一的，如果重复最后一个键值对会替换前面的，值不需要唯一。
python基础教程-学习笔记充电时刻-模块共13页.p
10-30
理解这些类型及其操作是Python学习的基础。 4. **控制结构（Control Structures）**：包括条件语句（如if-else）用于决定代码的执行路径，循环（如for和while）用于重复执行某段代码，以及异常处理（try-except）来...
python学习笔记
12-17
在Python学习笔记中，我们主要探讨以下几个核心知识点： 1. **数据类型与数据结构** Python支持多种数据类型，包括基本的整型、浮点型、字符串等。其中，数据结构是Python的一大特色，特别是容器类型。容器可以...
Python从右向左查找字符串（倒序查找 从右往左）
STR_Liang的博客
02-24 9852
Python从右向左查找字符串（倒序查找 从右往左）
python索引右往左_[Python笔记]序列（一）索引、分片
weixin_39998998的博客
12-04 1078
Python包含6种内建序列：列表、元组、字符串、Unicode字符串、buffer对象、xrange对象。这些序列支持通用的操作：索引索引是从0开始计数；当索引值为负数时，表示从最后一个元素(从右到左)开始计数。这里列举几个例子：#字符串字面值可以直接使用索引，不需要专门的变量引用>>> 'Hello World!'[0]'H'>>> 'Hello World...
# 字符串从右往左查找_Python字符串反转
weixin_39987926的博客
12-19 2941
一、程序字符串反转在Python中及其简单，直接上程序。str1="abcde" rev_str1=str1[::-1] print(rev_str1)程序执行如图所示。程序执行效果二、解释：1.字符串中的每一个字符都有一个位置索引，索引有正向(从左到右)和反向(从右到左)。如图所示。字符串索引2.切片 一个完整的切片表达式包含两个“:”，用于分隔三个参数(start_index、end_in...
Python - 列表
bupa900318的博客
07-05 527
列表在Python中是一个任意类型对象位置的相关有序集合，它没有固定大小，根据数据量的不同可以动态变化。可以对列表中的数据进行赋值、修改、添加、删除等操作,可以对列表进行索引、切片、分割等操作。 在Python中创建一个列表时，解释器会在内存中创建一个堆栈自下而上堆放数据项，类似于其他编程语言中的数组。列表可以从左向右进行索引，索引号默认从’0’开始，列表也可以从右向左进行索引，最右侧索引号尾’-...
python列表中的索引问题：从左到右由0开始；从右到左由-1开始
热门推荐
weixin_41855010的博客
02-10 1万+
在程序猿的世界，数字是从0开始的，这个同样适用于python语言中的列表索引，我们建立了列表之后，如果要查询或者读取其中的第n个元素，这个元素的索引值并不是n，而是n-1，因为第一1个元素的索引编号是0，也就是有1个位的偏移量。 当然，我们也可使用负数作为索引，python中默认列表中最后一个元素的索引值是-1，倒数第二个索引值是-2，第一个索引值就是-n。注意到，这是一个周期函数，两个索引之间相...
堆和索引堆的python实现
weixin_33918114的博客
03-16 167
堆是一棵完全二叉树。堆分为大根堆和小根堆，大根堆是父节点大于左右子节点，并且左右子树也满足该性质的完全二叉树。小根堆相反。可以利用堆来实现优先队列。 由于是完全二叉树，所以可以使用数组来表示堆，索引从0开始[0:length-1]。结点i的左右子节点分别为2i+1,2i+2。长度为length的树的最后一个非叶子节点为length//2-...
【深入理解ECMAScript 6】 字符串扩展（字符串是否包含、重复字符串、模板字符串）
马云
10-27 1317
ECMAScript6 字符串扩展 目录ECMAScript6 字符串扩展一、字符串判断是否包含ES5ES6includes()startsWith()endsWith()二、重复字符串repeat()三、模板字符串1、什么是模板字符串2、原始字符串3、页面模板分析图 一、字符串判断是否包含 ES5 /* ES5 提供的判断是否包含的方法 string.indexOf(searchStr)方法 作用：返回指定字符串包含的指定子字符串的索引值 结果： 包含：返回第一个匹配的索引
Python3 基础语法学习（一）
Woods的博客
06-16 322
注释 Python中单行注释以 # 开头 多行注释可以用多个 # 号，还有 ‘’’ 和 “”" 行与缩进 python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。 可以使用反斜杠()来实现多行语句 数字(Number)类型 python中数字有四种类型：整数 int 、布尔型 bool、浮点数 float和复数 complex 字符串(String) python中单引号和双引号使用完全相同 2.使用三引号
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
weixin_44523001的博客
01-24 8201
Python中字符串的索引方式，偏移量为1，即第1个字符的索引为0，而从右向左第一个为-1。在这里插入代码片 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雨天_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值