python核心基础语法(4)
- 2026-06-29 20:52:44
python
书接上回，这次我们讲数据容器
数据容器：顾名思义，盛放数据的，比如数组，字符串
数据容器的特点：
数据容器，有时也简称为容器。
数据容器可以存放多个数据，每个数据也被称为一个元素。
数据容器中的元素可以是任意类型。
数据容器会给我们提供多种操作元素的方法。
python中常用的数据容器：
列表（List）
元组（tuple）
字符串（str）
集合（set）
字典（dict）
1.列表：用来存放一组有序的数据，并且可以对其中的数据进行：增删改查。
list=[1,2,3,4,5]
list2=['张若昀','周杰伦','四面楚歌']
list3=[1,4,[1,3]]#嵌套列表
print(list)
print(list2)
print(list3)
下标（索引值）
在前端js中下标都是正索引
python不一样，python有正索引和负索引
正索引从左向右数 起始点是0
负索引从右向左数 起始点是-1
print(list[0]) #1
print(list[1])#2
print(list[2])#3
print(list[3])#4
print(list[4])#5
print(list[-5])#1
print(list[-4])#2
print(list[-3])#3
print(list[-2])#4
print(list[-1])#5
print(list3[2][1])#3
列表的增删改查
list.append(元素)
list.insert(下标，元素)//指定下标加元素
list.extend(可迭代对象)//可迭代对象内容依次取出，追加到列表尾部
list.pop(下标)删除指定位置的元素
list.remove(值)删除指定值
list.clear()清空所有元素
list[下标]=值//修改
list[下标]查询
list.append(6)
print(list)#[1, 2, 3, 4, 5, 6]
list.insert(1,7)#[1, 7, 2, 3, 4, 5, 6]
print(list)
list.extend("四面楚歌")#[1, 7, 2, 3, 4, 5, 6, '四', '面', '楚', '歌']
print(list)
list.pop(1)#[1, 2, 3, 4, 5, 6, '四', '面', '楚', '歌']
list[1]=43#修改
print(list)
# list.clear()
# print(list)
列表常用方法
1.列表.index(值)//查询下标
2.列表.count(值)//统计值的出现次数
3.list.reverse()反转
4.list.sort()排序
fruit=["苹果","香蕉","梨"]
result=fruit.index("苹果")
print(result)
#统计元素出现几次
nums = [10, 20, 10, 30, 10, 40, [10, 10, 10]]
results=nums.count(10)
print(results)
results1=nums[6].count(10)
print(results1)
#翻转
nums1 = [23, 11, 32, 30, 17, [6, 7, 8, 9]]
nums1.reverse()
print(nums1)
#排序
arr=[1,2,3,5,4]
arr.sort()
print(arr)
arr1=["夜曲","以父之名","将军"]
arr1.sort()#['以父之名', '夜曲', '将军']
print(arr1)
列表的内置函数
sorted(容器)排序后返回一个新数组
len(容器)数组长度
max(容器)数组最大值
min(容器)数组最小值
sum(容器)数组所有元素的和
list=[1,4,5,2,3]
print(sorted(list))
print(len(list))
print(max(list))
print(min(list))
print(sum(list))
列表的循环遍历
while方法
list2=[62,55,66,3,33]
index=0
while index < len(list2):
print(list2[index])
index+=1
for遍历
list2=[62,55,66,3,33]
for item in list2:
print(item)
for item in list2:
print(item)
for m in range(len(list2)):
print(list2[m])
练习
元组：
一组有序的列表，不能进行增删改，只能进行查
t1=(28,31,42,33)
t2=("北京","天津","衡水")
t3=(33,None)
t4=(11,"44",(12,4))
t5=(33,)
t6=()
t7=tuple()
print(t1)
print(t2)
print(t3)
print(t4)
元组只有1个元素时候末尾需要有逗号
读取元组元素
print(t1[0])
元组不可以修改，但是元组里面如果有可变类型的列表的情况下可以修改可变类型
t8=(1,2,3,4,["以父之名",3,5,7])
print(t8)(1, 2, 3, 4, ['以父之名', 3, 5, 7])
t8[4][1]="夜曲"
print(t8)(1, 2, 3, 4, ['以父之名', '夜曲', 5, 7])
元组常用方法
result=t8.index(3)
index 方法：获取指定元素在元组中第一次出现的下标
print(result)
result1=t8.count(4)
count 方法：统计指定元素在元组中出现的次数。
print(result1)
元组的内置函数如列表，此处略
元组传参
test=(1,2,4)
def show(*args):
print(args,"arg")
show(*test)
元组特点
1.可存放不同类型元素
元素是有序存储的（正索引、负索引）。
元组中的元素允许重复。
元素不允许修改文（不能：增、删、改、只能：查）。
长度固定定（一旦创建，元素个数不能增减）
元组vs列表
列表可变，元组不可变
元组安全性高于列表
元组是固定的数据，列表可变
字符串常用方法
split()根据指定字符分割
index()寻找指定字符的位置
replace(a,b)替换指定字符
count()指定字符出现次数
strip()从字符两端删除，直到找不到为止
str="ccc,ddd,eee"
print(str.index("dd"))#4
print(str.split("."))#['ccc,ddd,eee']
print(str.replace("ddd","fff"))#ccc,fff,eee
print(str.count("ccc"))
strr="cdcedec"
strr.strip("c")
print(strr.strip("c"))#dcede
内置函数和列表一样，此处略
遍历字符串
msg="abcd"
for item in msg:
print(item)
序列切片：原有序列取出一部分成为新序列
公式list[0:5:1]
起始索引 终止索引 步长
切片操作的区间是左闭右开的，即：截取时包含起始位置，但不包含结束位置。
步长是指取出元素时的间隔，例如：
○ 步长为 1，就是一个一个取出。
○ 步长为 2，就是每次越过 1 个元素取出。
○ 步长为 3，就是每次越过 2 个元素取出。
○ 步长为 n，就是每次越过 n-1 个元素取出。
起始索引默认值为 0，结束索引默认截取到末尾，步长默认值为 1。
当起始索引大于结束索引时，步长必须为负数，否则结果是空列表。
list=[1,2,3,4,5,6,7,8,9]
list1=list[0:5:1]
list2=list[0:5:2]
print(list1)[1, 2, 3, 4, 5]
print(list2)[1, 3, 5]
# 当起始索引大于结束索引时，步长必须为负数，否则结果是空列表。
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
list2 = list1[7:2:-1]
print(list2) # [80,
序列拼接
只能是数组+数组，字符串+字符串，元组+元组
list3=[1,3]
list4=[2,4]
list5=list3+list4
print(list5)
序列相乘
list6=list3*3
print(list6)
集合
可变集合：内部的元素无序（不保证顺序）、不能通过下标访问元素、会自动去除重复元素
不可变集合（forzenset）：特点和可变集合一样，唯一的区别就是：其中的元素不可修改。
s1={10,20,30,40,50}
print(s1)
s2=set()
不可变集合
s3=frozenset({10,20,30,40,50})
print(s3)
s4=frozenset("123")
print(s4)
集合中可以嵌套不可变集合
s5={1,4,6,s3}
print(s5)
集合中增删改查
s6={32,444}
s6.add(555)
print(s6)
s6.update([1,3])
print(s6)
s6.remove(32)
#pop(),remove(),clear()
print(s6)
使用集合A.difference(集合B)，找出集合A中，不同于集合B的元素。
s1={1,2,3,4}
s2={4,5,6}
s=s1.difference(s2)
使用集合A.difference_update(集合B)，从集合A中，删除集合B中存在的元素
s1.difference_update(s2)
使用集合A.union(集合B)，合并两个集合，集合A 和 集合B 都不变，返回的是一个新的集合。
集合A.union(集合B)： 作用：合并两个集合，集合A 和 集合B 都不变，返回的是一个新的集合
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
result = s2.union(s1)
print(s1)
print(s2)
print(result)
使用集合A.issubset(集合B)，判断集合A是否为集合B的子集，返回值为布尔值。 集合A.issubset(集合B)： 作用：判断集合A是否为集合B的子集 如果 集合A的所有元素都在集合B中，那就返回True，否则返回False
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
s3 = {30, 40, 50}
result = s3.issubset(s1)
print(result)
使用集合A.issuperset(集合B)，判断集合A是否是集合B的超`集，返回值为布尔值。 集合A.issuperset(集合B)： 作用：判断集合A是否是集合B的超集 如果集合A中，包含了集合B中的所有元素，那就返回True，否则返回False
s2 = {30, 40, 50, 60, 70}
s3 = {30, 40, 50}
result = s1.issuperset(s3)
print(result)
使用集合A.isdisjoint(集合B)，判断集合A和集合B是否没有交集，返回值为布尔值。 集合A.isdisjoint(集合B)： 作用： 如果没有交集，返回True；只要有一个公共元素，就返回False
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
s3 = {80, 90}
result = s1.isdisjoint(s2)
集合的数学运算
s1 = {10, 20, 30, 40, 50, 60}
s2 = {40, 50, 60, 70, 80, 90}
# 并集
result = s1 | s2
print(result)
# 交集
result = s1 & s2
print(result)
# 差集
result = s1 - s2
print(result)
# 对称差集
result = s1 ^ s2
print(result)
循环遍历
s1 = {10, 20, 30, 40, 50, 60}
# 集合不能使用while循环遍历（以下是错误示例）
# index = 0
# while index < len(s1):
# print(s1[index])
# index += 1
# 集合可以使用for循环遍历
for item in s1:
print(item)
集合特点：
无序：集合中的元素没有固定顺序，无法通过下标访问。
不重复：集合会自动去重，同一个元素只会保留一份。
分为两种：可变集合合（set）和不可变集合（forzenset）。
集合中的元素必须是不可变类型（如：数字、字符串、元组）。
集合支持：并集、交集、差集、对称差集等数学操作。
字典：用来存放键值对数据
d2={"小美女":1,"大美女":2}
print(d2)
可以嵌套
student_dict = {
2025001: {
'姓名': '张三',
'年龄': 18,
'成绩': 72,
'爱好': ['抽烟', '喝酒', '烫头']
},
2025002: {
'姓名': '李四',
'年龄': 19,
'成绩': 60,
'爱好': ['唱歌', '跳舞', '打台球']
},
2025003: {
'姓名': '王五',
'年龄': 20,
'成绩': 85,
'爱好': ['学习', '看书', '打太极']
}
}
print(student_dict)
总结
有序与无序：
● 有序：列表(list)、元组(tuple)、字符串(str)—— 元素有顺序，可通过下标访问元素。
● 无序：集合(set)、字典(dict) —— 元素没有固定位置，不能用下标访问。
可修改：
● 可变：列表(list)、集合(set)、字典(dict) —— 可以对内容进行增、删、改操作。
● 不可变：元组(tuple) 、字符串(str) —— 内容固定，创建后无法修改。
可重复：
● 允许重复：列表(list) 、元组(tuple) 、字符串(str)
● 不允许重复：集合(set) 、字典(dict) 备注：字典的 key 是唯一的，但 value 可重复
练习：
将如下多个列表合并为一个列表，并去重重复元素，排好序（升序）后输出到控制台。 list1 = ['M', 'A', 'C', 'E', 'F', 'G', 'H', 'L', 'N', 'I', 'J', 'K', 'O'] list2 = ['X', 'Z', 'T', 'Y', 'D', 'E', 'F', 'G'] list3 = ['W', 'A', 'S', 'D']
list1 = ['M', 'A', 'C', 'E', 'F', 'G', 'H', 'L', 'N', 'I', 'J', 'K', 'O']
list2 = ['X', 'Z', 'T', 'Y', 'D', 'E', 'F', 'G']
list3 = ['W', 'A', 'S', 'D']
list4=list1+list2+list3
newlist=list(set(list4))
print(list4)
print(newlist)
需求2：将如下列表中能被3 或 5整除的元素提出来，并获取这些数字对应的平方，组成一个新的列表。
list4 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
list=[]
for n in list4:
print(n)
if(n%3 == 0 or n%5 == 0):
list.append(n)
print(list)
newlist=[]
for m in list:
newlist.append(m**2)
print(newlist)
将如下列表中的正数提取出来，封装为一个新的列表。 list5 = [11, 2, 31, 4, -5, 15, 17, 28, 49, 10, -11, 16, 54, -14, 36, -16, 87, -39]
list5 = [11, 2, 31, 4, -5, 15, 17, 28, 49, 10, -11, 16, 54, -14, 36, -16, 87, -39]
list=[]
for n in list5:
print(n)
if(n>0):
list.append(n)
print(list)
将用户输入的10个字符串, 反转后全部转换为大写, 然后记录在列表中, 最后将列表内容，遍历输出出来。
content=input("请输入")
list=[]
for n in content:
list.append(n.upper())
list.reverse()
print(list)
上面的练习都会做了就代表今天的数据容器知识过关了~，明天讲面向对象同时会发一个数据容器的综合练习~
