目录
1。什么是可迭代对象？
2。列表(list)
列表的创建
列表基本操作
以上全部代码的总运行结果
列表脚本操作符
列表常用的方法和函数
列表推导式
编辑列表的嵌套
以上全部代码的总运行结果
复习列表内容
3。元组(tuple)
元组的基本运算
元组的方法
以上所有代码运行结果
1。什么是可迭代对象？
2。列表(list)
列表的创建
#以C++的角度理解python
#列表(list)
#2.1列表是一种有序、可变序列，可以包含任意类型的元素。
#创建列表可以使用列表list函数()，也可以变量 = []的形式
#1.创建一个空链表
ret1 = list()#返回值给到ret1
ret2 = []
print(f'{ret1 = }, {ret2 = }')
#上面这个打印方法在Python中，print(f'') 是格式化字符串（f-string）的语法。
#它允许你在字符串中嵌入表达式，这些表达式在运行时会被其值所替换。f 或 F 前缀表示这是一个格式化字符串字面量。
#在 f'' 或 F'' 中的大括号 {} 内，你可以放入任何有效的Python表达式。
#当 print 函数执行时，这些表达式会被求值，并且其结果会被插入到字符串的相应位置。
#这个语法有点奇怪，f""也是可以的，取决于你要打印的类型是字符串还是字符
print(f'{ret1}, {ret2}')
#当{}里面遇到变量=或者函数=时，等号的左边在解析时会被保留，连同着等号右边被解析的东西一起被保留下来
#如果f-string表达式的{}里面没有=，那只会运算表达式的内容(值), 字符和字符串不需要加'',打印不会出现""都只会有''
str='union'
str55="dfggthth"
print(f'{str[::-1]=}')
print(f'{str[::-1]}')
print(f'{str55 = }')
print(f"{str55}")
print(f'{str=}')
lst=[1,2,3]
print(f'{lst.reverse()=}')#reverse()方法没有返回值，输出其返回值，但对原列表反向排序。#lst.reverse()=None
print(f'{lst=}')
print()
lst1 = [1, 2, 3]#列表
for item in lst1:#相当于范围for, for循环结尾有一个:
print(item)
ret3 = list('hello')#list函数，列表函数,转换成列表
print("lit1 =", ret3)
ret4 = list("hello bit")#list函数将参数对象转换成列表
print("ret4 = ", ret4)
#经过打印可以发现，列表存储字符串的方式是逐字母存储的，一个字母存一个空间
ret5 = [1, 2, 3, 'r']
print(f'{ret5 = }')
print(f"{ret5 = }")
#无论是用f''或者f""格式化打印都没有什么问题, 随便选一种都可以
a = 5
print(f"hhdhhcdsich addf ddef {a}")
print(f'hhdhhcdsich addf ddef {a}')
##无论是用f''或者f""格式化打印都没有什么问题, 随便选一种都可以
列表基本操作
ret5 = [1, 2, 3, "apple", "banaban", 'dafd']#直接使用[]赋值相当于C++的可变参数列表Args... args, 放什么类型的数据都可以
ret6 = ['how', 'are', 'you']
for item in ret6: #类似于C++11的范围for注意:
print(item, end = '%')#如下
print(item, end = ':')#每一次打印的结尾换行被:占了，所以就没有换行了
print(item)
#print()#属于单个for语句包含的语句要对齐, 空的print语句仍然保留自动换行的属性，这里起到自动换行的作用
#print()#这个没有和for里面的语句对其所以不属于for语句里面的东西
#所以这个的意思是等for语句执行完后再打印的换行
#使用enumerate()函数遍历列表同时获得每个元素的索引(下标值)和元素值(列表中对应下标的对应的元素的内容)
#获取打印出来的格式为：下标 元素值 ———和C++一样下标也是从0开始的
for ideax, itea in enumerate(ret6):#一个负责获取下标一个负责获取元素值，多个变量中间用,隔开
print(ideax, itea)#for循环里面的语句千万不要置顶写, 语法规定不能
#访问列表元素的基本操作
ret7 = [1, 2, 3, "apple", "banaban", 'dafd']
print(ret7[0])#取列表从左往右的第1个元素
print(ret7[2])#取列表从左往右的第3个元素
#print(ret7[11])#越界了
#print(ret7[9])#越界了
#print(ret7[7])#越界了
print(ret7[-1])#下标为负数时是从最右边往下标为0的数，也就是如果是-1，那就是从右往左数的第一个
print(ret7[-2])#从右往左的第2个
##print(ret7[-100])#越界
#由上面的访问-100，11，7，9下标都越界报错了，可以看出python列表的越界检查不是抽样式的，而是抛异常式的，这一点像C++的array
#添加元素到列表的操作
ret8 = [1, 2, 3, "apple", "banana"]
ret9 = [8, "hdggf"]
ret8.append('ret')#append的作用是在列表末尾添加一个元素
print(ret8)
ret8.insert(1, "hehe")#insert的作用是在指定位置插入一个元素，这个指定的位置不能为空(这里和C++就不一样了)
print(ret8)
ret8.extend(ret9)#extend的作用是将另一个列表的所有元素添加到当前列表的末尾
print(ret8)
ret8.extend(["hehe"])#可以传右值(C++)
print(ret8)
#删除列表元素
print()
ret10 = [1, 2, 3, "apple", "banana", 'uhdcv', 4, 8]
ret10.pop(0)#pop的作用是删除指定下标位置的元素
print(ret10)
ret10.pop(1)
print(ret10)
print(ret10[0])
print(ret10[1])
#由上面代码执行逻辑可以发现, 每次删除后，各元素下标都会重新按正常的顺序排布
ret10.remove("banana")#remove的作用是删除指定的元素，这个元素需要列表里面有的，不然会报错
#ret10.remove(100)
print(ret10)
ret10.clear()#clear的作用是删除列表的所有元素
print(ret10)
ret11 = [1, 2, 3, "apple", "banana", 'uhdcv', 4, 8]
del ret11#del的作用是删除整个列表
#print(ret11[2])#列表被del后就彻底消失了，这时就取不到列表里面的元素了
# lst1 = [1, 2, 3, 44, 5, 7, 8, 9, 10, 11, 12, 13, 34, 45, 99]
# lst2 = lst1[1:8:2]
# lst3 = lst1[-1:-8:-2]#步长默认缺省值为1
# lst4 = lst1[-1:-9]#步长默认缺省值为1
以上全部代码的总运行结果
列表脚本操作符([:::])
lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
lst3 = lst1 + lst2#连接操作符+, 用于将两个链表连接在一起，也就是相当于将一个链表尾插到另一个列表当中
print(lst3)
lst4 = lst1 * 3#重复操作符*，用于将一个链表的全部元素按原顺序重复n次
print(lst4)#重复3次
print(f"{3 in lst1 = }")#成员关系操作符(in/not in): 判断成员变量是否在列表中，输出一个bool值(False/True)
print(f"{5 in lst1 = }")
print(f"{5 not in lst1 = }")
# while 5 not in lst1:#可以作为循环判断的条件
# print("hehe")
print()
#[::]切片操作，用来访问一个列表的子集
#切片运算符的语法：object [start : end : step]
#✓ start: 切片开始位置，省略时默认为起点或终点，由step正负决定。
#✓ end: 切片结束（但不包含）位置，（默认为列表长度）。
#✓ step: 切片的步长，可正，可负，（默认为1）。step正负号决定了切取方向，切记！#从C++的角度就是相当于步长给了一个缺省值，然后可以不写的，直接使用缺省值
#从开始位置的元素开始取，隔n个下标取一个元素
# 切片操作不会因为下标越界而
# 抛出异常，而是在列表尾部截
# 断或返回一个空列表，代码具
# 有更强的健壮性。
lst5 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
ret1 = lst5[::1]
ret2 = lst5[3:8:2]
ret4 = lst5[-3:-8:2]#需要全部同号才能正确取到，头尾步长三个的方向一致才可以进行
ret5 = lst5[-3:-8:-2]#负的下标是从-1开始的
ret3 = lst5[3::2]
ret6 = lst5[3:]#下标为3之后的元素自行截断
ret7 = lst5[::-1]#逆序遍历所有元素
print(ret1)
print(ret2)
print(ret3)
print(ret4)
print(ret5)
print(ret6)
print(ret7)
print()
列表常用的方法和函数
lst7 = ['a', 'z', 'd', 'f', 'g', 'A']
lst8 = [1, 2, 6, 5, 3, 99, 78]
lst8.sort()#sort默认升序
print(lst8)
#print(lst8.sort())#不可以直接这么写，因为没有返回值，所有会直接输出None
print(f"lst7.sort() = {lst8}")
lst9 = [9, 7, 6, 5, 4, 3, 17, 15, 13, 11]
print(sorted(lst9))#内置函数sorted默认升序，使用内置函数sorted()对列表进行排序，并返回排序后的新列表；但原列表不变。
print(sorted(lst9, reverse = True))#降序排序, 一看就懂了，就是在原本升序排完之后再确认是要反转一下
print(lst9)
print()
#sum作为内置函数起到将内部的所有元素取和的作用
print(sum(range(1, 11)))#sum()函数的start参数默认为0
print(sum(range(1, 11), 5))#指定start参数为5，等价于5+sum(range(1,11)), range(i,j)相当于生成从[i, j)(左闭右开)的连续整数
ret11 = [1, 2, 2, 2, 2, 2, 3, 4, 'a', 'b', 'a', 'c', 'f']
print("hello python")
#index的作用是返回列表中第一个值为x的元素的下标，若不存在值为x的元素则抛出异常
print(ret11.index(1))
print(ret11.index('a'))
#ret11.index(100)#ValueError: 100 is not in list
#count的作用是返回指定元素x在列表中的出现次数
print(ret11.count('a'))
#reverse的作用是对列表所有元素进行逆序排列,无返回值
ret11.reverse()
print(ret11)
#copy的作用是返回列表的浅复制(相当于C++的浅拷贝)---copy可以将原列表复制到新的列表对象, 返回一个新的对象
ret12 = ret11.copy()
print(f'{ret12 = }')
print(ret12.copy())
列表推导式
#一般格式：[expression for item in iterable [if condition]]
#➢expression：表示在迭代过程中对每个元素执行的操作或表达式。
#➢item：表示可迭代对象中的每个元素。
# ➢iterable：表示可迭代对象，例如列表、元组或集合。
# ➢condition：(可选) 表示条件，只有满足条件的元素才会被包含在结果列表中。
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ret9 = [x**2 for x in numbers if x % 2 == 0]#可以这么理解，每一个可以通过条件if的并且可以在指定循环的列表或者range中取到的元素x都需要
#执行for前面的语句，然后得出的最终值存储在新列表中，所以列表推导式的返回值是列表对象
#x**2的意思是x的平方, n**m的意思是n的m次方
print(ret9)
ret10 = [x * 5 for x in range(5)]#range的默认起始值是0，所以根据左闭右开原则，range(i) 的范围就是0到i - 1
print(ret10)
#if条件只是起到约束列表取值的条件，所以可以省略
print(sum([2**x for x in range(64)]))
列表的嵌套
◆ 列表嵌套是指在一个列表中包含另一个或多个列表。这样做可以创建多维结构的列表。 ◆ 例如：学生的成绩单grades 列表包含了三个子列表，分别表示每个学生的成绩。 grades = [ ["Alice", 85, 90, 92], ["Bob", 78, 82, 80], ["Charlie", 90, 95, 88] ] ◆ 通过列表嵌套，可以方便地访问和操作多维数据。例如，思考 grades[1][2] = ？ ◆ 列表嵌套还可以进一步嵌套，形成更复杂的数据结构。例如，可以在每个学生的成绩列 表中再嵌套一个列表，表示每个科目的具体信息，如考试日期、教师等。 ◆ 列表嵌套是一种灵活且强大的数据结构，可以在编程中用于表示和处理复杂的数据关系。
#学生的成绩单grades 列表包含了三个子列表---就是列表里面有列表，相当于二维数组
garden = [["dadf", 1, 2, 3], ["dedf", 1, 3, 4, 5], ["edrrvg", 4, 5, 66, 7]]
print(garden)
print(garden[1][2])#3
以上全部代码的总运行结果
复习列表内容
3。元组(tuple)
# ◆ 元组：有序、不可变的元素序列。（不可变，意味着一旦创建就不能修改）
# ◆ 元组创建：通过圆括号 () 或 tuple()函数来创建。
# ◆ 访问元组元素（可使用索引、切片或for循环遍历）:
# ➢ tup[index]: 通过指定索引index访问元组tup中的特定位置的元素。
# ➢ tup.index(x): 返回tup中第一个值为x的元素的下标，若x值不存在则抛出异常。
# ➢ tup[star:stop:step]: 使用切片操作(slicing), 获取元组的子元组。
# ➢ for item in tup：遍历元组中的所有元素。
# ◆ 成员身份判断：in，not in. 例如，if 'apple' in ('apple', 'banana', 'orange’):
元组的创建
# ❖ 元组一旦定义就不允许更改。
# ❖ 元组没有append()、extend()和insert()等方法，无法向元组中添加元素。
# ❖ 元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能
# 从元组中删除元素。
# ❖ 元组的速度比列表更快。如果定义了一系列常量值，而所需做的仅是对它进行遍历，
# 那么一般使用元组而不用列表。
# ❖ 元组对不需要改变的数据进行“写保护”将使得代码更加安全。
# ❖ 元组可用作字典的“键”，也可以作为集合的元素。列表不能作为字典的“键”，
# 包含列表、字典、集合或其他类型可变对象的元组也不能做字典的“键”。
x = (1, 2, 3, 4)#相当于C++的隐式类型转换，将=左边的未知类型转换成右边的元组类型
print(x.index(1))#通过指定索引index访问元组x中的特定位置的元素。
print(x[1])#通过指定索引index访问元组x中的特定位置的元素。
y = tuple((1, 2, 3, 4, 5, 6, 7, 8, 9))#注意双括号, 里面这个表示元组, 在使用中可以发现这个函数非常鸡肋
print(y[0:5:2])#使用切片操作(slicing), 获取元组的子元组。
for i in y:#遍历元组中的所有元素。
print(i**2, end = '%')
print();
# while 1 in y:#成员身份判断
# print("hehe")
if 1 in y:
print("hehe")
else :
print("haha")
if 1 not in y:
print("hehe")
else :
print("haha")
print()
# ❖ 元组一旦定义就不允许更改。
# ❖ 元组没有append()、extend()和insert()等方法，无法向元组中添加元素。
# ❖ 元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能
# 从元组中删除元素。
# ❖ 元组的速度比列表更快。如果定义了一系列常量值，而所需做的仅是对它进行遍历，
# 那么一般使用元组而不用列表。
# ❖ 元组对不需要改变的数据进行“写保护”将使得代码更加安全。
# ❖ 元组可用作字典的“键”，也可以作为集合的元素。列表不能作为字典的“键”，
# 包含列表、字典、集合或其他类型可变对象的元组也不能做字典的“键”。
#元组中如果包含的可变对象，那可变对象仍然可变
ret1 = ([1, 2, 3], 4, 5)
#如果元组中包含列表或其他类型的可变对象，这些对象是可变的，但对元组元素
#的直接引用仍是不可变的。
#简单来说就是，如果元组元素直接放置在=左边称为直接引用修改，虽然是可变对象，那还是会被识别为元组的元素，就不可以修改了
注意一下上图的错误信息：
ret1[0][0] = 10#把元组想象成数组就可以了，这里是两个数组的嵌套
print(ret1)
ret1[0].append(4)
print(ret1)
# ret1[0] += [0]
# print(ret1)
print()
ret2 = (1, 2, 3, 4, 'a','a', 'b','b', 'b', 'c')
#访问元组中的元素---通过下标访问
print(ret2[0])
print(ret2[4])
元组的基本运算
print(len(ret2))#len的作用是获取元组的长度
print(ret2 + (1, 2, 3))#拼接元组---相当于尾插一个+后面的元组
print(ret2 * 2)#重复元组使其连续打印出n份
元组的方法(index, count)
print(ret2.index('a'))#index的作用是获取这个元素第一次出现在元组中的下标仅一次
print(ret2.count('b'))#count的作用是获取这个元素在元组中出现的次数
以上所有代码运行结果
