python核心基础语法(4)

python

书接上回，这次我们讲数据容器

数据容器：顾名思义，盛放数据的，比如数组，字符串

数据容器的特点：

1. 数据容器，有时也简称为容器。

2. 数据容器可以存放多个数据，每个数据也被称为一个元素。

3. 数据容器中的元素可以是任意类型。

4. 数据容器会给我们提供多种操作元素的方法。

python中常用的数据容器：

1. 列表（List）

2. 元组（tuple）

3. 字符串（str）

4. 集合（set）

5. 字典（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.可存放不同类型元素

1. 元素是有序存储的（正索引、负索引）。

2. 元组中的元素允许重复。

3. 元素不允许修改文（不能：增、删、改、只能：查）。

4. 长度固定定（一旦创建，元素个数不能增减）

元组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，就是一个一个取出。

○ 步长为 2，就是每次越过 1 个元素取出。

○ 步长为 3，就是每次越过 2 个元素取出。

○ 步长为 n，就是每次越过 n-1 个元素取出。

1. 起始索引默认值为 0，结束索引默认截取到末尾，步长默认值为 1。

2. 当起始索引大于结束索引时，步长必须为负数，否则结果是空列表。

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)

集合特点：

1. 无序：集合中的元素没有固定顺序，无法通过下标访问。

2. 不重复：集合会自动去重，同一个元素只会保留一份。

3. 分为两种：可变集合合（set）和不可变集合（forzenset）。

4. 集合中的元素必须是不可变类型（如：数字、字符串、元组）。

5. 集合支持：并集、交集、差集、对称差集等数学操作。

字典：用来存放键值对数据

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 可重复 

练习：

1. 将如下多个列表合并为一个列表，并去重重复元素，排好序（升序）后输出到控制台。 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)

上面的练习都会做了就代表今天的数据容器知识过关了~，明天讲面向对象同时会发一个数据容器的综合练习~