在 Python 语言中含有四种集合数据类型：
列表（List）、元组（Tuple）、集合（Set）、词典（Dictionary）
1. 列表
列表是一个有序并定义好后可修改的集合。在 Python 中，列表用方括号 [ ] 编写，是最常用的 Python 数据类型。列表的数据项不需要具有相同的类型，只需用逗号分隔不同的数据项就行。
q1 = [2.3, 4, 5, "asd"]
print(q1)
print(type(q1))
#----[2.3, 4, 5, 'asd']
#----<class 'list'>
1.1 列表访问
1.1.1 下标访问
下标就是编号，（即数据的编号位置）
从左向右访问，从0开始；
从右向左访问，从-1开始。
下标访问格式：变量名[下标]
# 下标访问
q2 = [1, 2, 3, "a", "ppt", "d", "f", "asdf"]
print(q2)
print(q2[0])
print(q2[3])
print(q2[6])
#----[1, 2, 3, 'a', 'ppt', 'd', 'f', 'asdf']
#----1
#----a
#----f
1.1.2 切片访问
切片访问和下标访问类似
下标访问每次只能访问单个元素,切片访问每次可以访问多个元素
切片访问格式：变量名[起始值：终止值：步长]
访问时:
1.如果没有设置起始值，默认起始值为开头位置；
2.如果没有设置终止值，默认到列表结束，如果设置了终止值，到终止位置结束，不包括结尾位置；
3.如果没有设置步长，步长默认为1
q2 = [1, 2, 3, "a", "ppt", "d", "f", "asdf"]
print(q2[::])#初始值、终止值、步长不定义时，访问无转换
print(q2[3::])
print(q2[:5:])
print(q2[::2])
print(q2[1:-2:])
# 初始值，终止值表示具体位置:从哪里开始，到哪里结束，但终止值不计入
#----[1, 2, 3, 'a', 'ppt', 'd', 'f', 'asdf']
#----['a', 'ppt', 'd', 'f', 'asdf']
#----[1, 2, 3, 'a', 'ppt']
#----[1, 3, 'ppt', 'f']
#----[2, 3, 'a', 'ppt', 'd']
1.2 列表的加法和乘法
+ :表示字符串拼接， * n :代表字符串复制n次
q3 = [1, 2, 3]
q4 = ["a", "ppt", "d", "f", "asdf"]
print(q3 + q4)
print(q3 * 2)
print(q4 * 2)
#----[1, 2, 3, 'a', 'ppt', 'd', 'f', 'asdf']
#----[1, 2, 3, 1, 2, 3]
#----['a', 'ppt', 'd', 'f', 'asdf', 'a', 'ppt', 'd', 'f', 'asdf']
1.3 列表相关函数
1.3.1 列表元素的增加
|
append
|
尾部增加：列表的最后一个字符后面添加一个字符
|
|
insert
|
指定位置增加
|
|
extend
|
把一个列表的所有元素添加到另一个列表后边
|
append:
# 1.列表元素的增加
q5 = ["ppt", "excel", "word"]
q6 = input("输入字符")
q5.append(q6) # append:前(q5)加()q6,q5在前q6在后
print(q5)
#----输入字符123
#----['ppt', 'excel', 'word', '123']
insert:
q7 = ["ppt", "excel"]
q7.insert(1, "♥") # 指定位置(1)处加，原位置数据后移
print(q7)
#----['ppt', '♥', 'excel']
extend:
q8 = ["ppt", "excel"]
q9 = [1, 2, 3]
q8.insert(1, "♥") # 把其中一个列表中元素加到另一列表的数据后面
q9.extend(q8) #q9的数据在q8前面
print(q8)
print(q9)
#----['ppt', '♥', 'excel']
#----[1, 2, 3, 'ppt', '♥', 'excel']
拓展：
# q10 = [] # for q11 in range(5): # q10.append(int(input())) # print(q10)
1.3.2 列表元素的删除
|
remove
|
删除指定元素
|
|
pop
|
指定下标删除
|
|
clear
|
删除列表中所有元素
|
|
del关键字
|
删除整个列表
|
remove:
q12 = ["ppt", "excel", "word"]
q12.remove("ppt") # 删除指定元素
print(q12)
#----['excel', 'word']
pop:
q13 = ["java", "python", "c语言", "c++"]
q13.pop(1) # 指定下标删除
print(q13)
#----['java', 'c语言', 'c++']
clear:
q14 = ["java", "python", "c语言", "c++"]
q14.clear() # 删除例表中的数据，列表还在
print(q14)
#----[]
del:
q15 = ["java", "python", "c语言", "c++"]
del q15 # 删除整个列表
print(q15)
#----NameError: name 'q15' is not defined
1.3.3 列表元素的修改
用下标或切片的方式修改单个或多个元素
列表名[下标] = 新的元素内容
w1 = ["java", "python", "c语言", "c++", "345"]
w1[1] = "CAD" # 找到下标为1的位置，用新数据覆盖掉原来在这个位置的旧数据
print(w1)
w1[1:4] = ["PS", "3D Max"] # 覆盖位置1-4的数据，加入新的数据，数据多少不限
# 把原来的从初始位置到终止位置（不含终止位置数据）这个区间的数据被新数据所覆盖
print(w1)
#----['java', 'CAD', 'c语言', 'c++', '345']
#----['java', 'PS', '3D Max', '345']
1.3.4 列表元素的查询
count( ): 查找某元素出现的次数
in 关键字：如果存在返回True,否则False 或者：not in
e1 = ["java", "python", "c语言", "c++", "345", "PS", "3D Max"]
print(e1.count("python"))
if "python" in e1:
print("存在")
print(e1)
#----1
#----存在
#----['java', 'python', 'c语言', 'c++', '345', 'PS', '3D Max']
1.3.5 其他函数
|
len
|
元素个数
|
|
reverse
|
反转
|
|
sort
|
排序
|
|
copy
|
拷贝
|
len:
e2 = ["java", "python", "c语言", "c++"]
print(len(e2))
#----4
reverse:
e2 = ["java", "python", "c语言", "c++"]
print(len(e2))
e2.reverse()
print(e2)
#----4
#----['c++', 'c语言', 'python', 'java']
sort：sort 默认从小到大，默认按字符Unicode排序，
e3 = ["CAD", "PS", "3D Max"]
# sort 默认从小到大，默认按字符Unicode排序，
e3.sort()
print(e3)
#----['3D Max', 'CAD', 'PS']
e4 = ["CAD", "PS", "3D Max"]
e4.sort(reverse=True) # 从大到小
print(e4)
#----['PS', 'CAD', '3D Max']
e5 = ["CAD", "PS", "3D Max"]
e5.sort(reverse=False) # 从小到大
print(e5)
#----['3D Max', 'CAD', 'PS']
# key自定义排序依据
e6 = ["CAD", "PS", "3D Max"]
e6.sort(key=len) # 按字符长度从小到大
print(e6)
#----['PS', 'CAD', '3D Max']
copy：q在 Python 中，拷贝（copy） 分为浅拷贝（Shallow Copy）和深拷贝（Deep Copy），它们的主要区别在于对复合对象（如列表嵌套列表、字典嵌套字典等） 的处理方式。
|
赋值（=） |
创建对象的引用（别名），新旧对象共享内存 |
|
浅拷贝 |
创建新对象，但嵌套的子对象仍与原对象共享 |
|
深拷贝 |
完全递归复制所有层级，新旧对象完全独立 |
可视化对比
假设原始对象：q = [1, [2, 3], 4]
赋值 (=) → new = q
｜
｜所有修改同步影响新旧对象
▼
内存示意图： [1, [2,3], 4]
↑ ↑
｜ ｜
q new
浅拷贝 (copy.copy) → new = copy.copy(q)
｜
｜顶层独立，嵌套层共享
▼
q → [1, ───→ [2,3], 4]
new → [1, ───→ [2,3], 4] # 嵌套列表是同一个对象
深拷贝 (copy.deepcopy) → new = copy.deepcopy(g)
｜
｜完全独立
▼
q → [1, [2,3], 4]
new → [1, [2,3], 4] # 所有元素都是新对象
浅拷贝（Shallow Copy）：
复制规则：
创建新对象，复制顶层对象。
嵌套的子对象（如列表中的子列表）仍是原对象的引用（共享内存）。
import copy #---自行导入
q1 = [1, [2, 3], 4]
q2 = copy.copy(q1) #----浅拷贝
# 修改顶层元素（互不影响）
q1[0] = 100
print(q1) # [100, [2, 3], 4]
print(q2) # [1, [2, 3], 4] #----顶层独立
q1[2] = 2
print(q1) # [100, [2, 3], 2]
print(q2) # [1, [2, 3], 4] #----顶层独立
# 修改嵌套元素（共享内存）
q1[1][0] = 200
print(q1) # [100, [200, 3], 2]
print(q2) # [1, [200, 3], 4] → 嵌套层被同步修改！
深拷贝（Deep Copy）：
复制规则：
递归复制所有层级的对象，新旧对象完全独立（不共享内存）。
import copy
q1 = [1, [2, 3], 4]
q2 = copy.deepcopy(q1) # 深拷贝
# 修改嵌套元素（互不影响）
q1[1][0] = 200
print(q1) # [1, [200, 3], 4]
print(q2) # [1, [2, 3], 4] → 完全独立！
|
是否创建新对象 |
嵌套子对象是否独立 | |
|
赋值 ( |
× |
× |
|
浅拷贝 |
√ |
× |
|
深拷贝 |
√ |
√ |
1.4 列表的嵌套
列表中的元素无论是单个字符还是列表，访问时，先指定外层元素的下标，逐层向内访问
r1 = [1, 2, [33, 4.5], "qwe", "asd"]
print(len(r1))
print(r1[2]) # r1==[33, 4.5]
print(r1[2][1])
# 列表中的元素还是列表
# 访问时，先指定外层元素的下标，逐层 向内访问
#----5
#----[33, 4.5]
#----4.5
1.5 列表推导式
列表推导式（List Comprehension）是 Python 中一种简洁高效的创建列表的方式，它可以用一行代码替代多行循环语句，使代码更加易读。
语法：new=[expression for item in iterable]
q1 = [1, 2, 3, 4, 5]
# 要求：生成一个新列表，元素是元素列表中元素的平方
# 基础操作：
# 获取q1每个元素， **2
q2 = []
for i in q1: # 第一次循环：i = 1,第二次循环：i = 2 ...直到处理完所有元素
q2.append(i ** 2) # 将计算结果添加到 q2 列表的末尾
print(q2)
# 列表推导式
q3 = [i ** 2 for i in q1]
print(q3)
练习：
# 给定一个非负整数num,反复将各个位上的数字相加，直到结果为一位数，返回这个结果
# 输入：num =38
# 输出：2
# 解析：各个位上相加的过程：
# 38→3+8→11
# 11→1+1→2
# 按数字类型解答
num = int(input("请输入一个大于9的整数"))
if num > 9:
while num > 9:
a = 0
while num > 0:
a += num % 10
num //= 10
num = a
print(num)
else:
print("输入错误")
#----请输入一个大于9的整数123
#----6
# 按字符串类型解答
num = iinput("请输入一个大于9的整数")
while len(num) > 1:
a = 0
for i in num:
a += int(i) # a=a+int(i)
num = str(a)
print(num)
#----请输入一个大于9的整数123
#----6
扫一扫
1031
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
