python基础专栏

python基础（第五期）

数据容器

在Python中，常见的数据容器有以下几种：

1. 列表（List）：列表是最常用的数据容器之一，可以存储任意类型的数据，并且允许重复的元素。列表使用方括号 [] 来表示，各个元素之间用逗号分隔。
2. 元组（Tuple）：元组也是一种常见的数据容器，与列表相似，可以存储任意类型的数据。但不同的是，元组使用圆括号 () 来表示，且元素不能修改。
3. 字典（Dictionary）：字典是一种键值对（Key-Value）的数据容器，可以根据键（Key）来快速检索对应的值（Value）。字典使用花括号 {} 来表示，每个键值对之间用冒号 : 分隔，键和值之间用逗号分隔。
4. 集合（Set）：集合是一种无序且不重复的数据容器，可以进行交集、并集、差集等基本操作。集合使用花括号 {} 来表示，各个元素之间用逗号分隔。

这些数据容器在处理数据时具有不同的特点和用途，可以根据实际需求选择使用

一、列表

1、列表的定义

• 以 [] 作为标识
• 列表内每一个元素之间用，逗号隔开

基本语法

列表名 = [元素1， 元素2， 元素3， ....]
列表名 = [[列表元素1], [列表元素2], [列表元素3], [列表元素4]]

注意点：

• 列表中元素存储的类型可以是不同的。
• 里面的元素也可以是变量。
• 元素可以是嵌套列表哦！里面的子列表就是父列表的一个元素。

"""容器： 列表（list）
"""# 定义一个列表list
my_list = ["liujintao", "python", "hello world"]
print(my_list)
print(type(my_list))my_list = ["helloPython", 999, True, 'A']
print(my_list)
print(type(my_list))# 定义一个嵌套列表
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

2、列表的下标索引

想要从列表中找到特定位置的数据，就得用 “下标索引”。

书写格式：my_list[0] 或者my_list[-1] → 嵌套写法：先取子列表，在取子列表里面的索引号哦

• 正向默认索引从 0 开始，反向默认从 -1 开始。
• 还需注意列表索引不能超出范围哦！

# 通过下标索引取出对应位置的数据
my_list = ["liu", "jin", "tao"]
print(my_list[0])  # 输出结果liu
print(my_list[-1])  # 输出结果tao
# print(my_list[3])   # 报错，下标超出范围# 取出嵌套列表的元素
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][-1])  # 输出结果： 6

方法表

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3、列表的(添加)方法

之前我么学过函数就知道，函数就是封装的一个代码单元，完成特定的功能

• 在python中，如果将函数定义为 class（类）的成员，那么函数就会称为： 方法。

• 函数和方法就是一样的（就是调用方法有些差异）

3.1 列表的查询方法

• 查找某元素的下标： 查找某元素在列表中的下标，找到则返回索引号，否则报错

语法格式：

列表.index(元素)

# 定义一个列表
my_list = ["liu", "jin", "tao"]# 1、查找列表中某元素下标索引号
index = my_list.index("jin")
print(f"jin的下标索引号是{index}")  # jin的下标索引号是1# 2、查找元素不存在，报错
index = my_list("hello")
# print(f"hello的下标索引号是{index}")  # 报错：因为不在列表中

3.2 修改特定下标索引的值

语法格式：

my_list[索引号] = 新值

# 1、修改特定下标索引的值
my_list[0] = "Yu"
print(my_list)   # ['Yu', 'jin', 'tao']

3.3 列表指定位置插入元素

语法格式：

my_list.insert(下标， 插入的元素)

# 1、 在列表指定下标插入元素
my_list.insert(1, "Xin")
print(my_list)      # ['Yu', 'Xin', 'jin', 'tao']

3.3 列表指定元素的追加（尾部添加）

语法格式：

my_list.append(追加的元素)

# 1、列表指定元素的追加（尾部添加）
my_list.append("like")
print(my_list)  # ['Yu', 'Xin', 'jin', 'tao', 'like']

3.4 列表尾部追加指定的容器

my_list.extend(追加的容器)

# 1、尾部追加一批元素(容器)
my_list2 = ["Y", "a", "o"]
my_list.extend(my_list2)
print(my_list) # ['Yu', 'Xin', 'jin', 'tao', 'like', 'Y', 'a', 'o']

4、列表的(删除)方法

4.1 删除列表元素

语法格式：

方法一： del 列表名[下标]
方法二：列表名.pop(下标)

my_list = ["liu", "jin", "tao"]# 1、方法一：删除指定下标元素
del my_list[0]
print(my_list)  # ['jin', 'tao']# 2、方法二：列表.pop(下标)
my_list.pop(0)
print(my_list)  # ["tao"]

4.2 删除列表的第一个匹配项

语法格式：

列表名.remove(元素)

# 3、删除列表的第一个匹配项
my_list = [1, 3, 1, 3, 5, 6, 7, 8, 1, 10]
print(len(my_list))  # 10
# 删除元素 3
mylist = my_list.remove(3)
print(my_list)  # [1, 1, 3, 5, 6, 7, 8, 1, 10]
print(len(my_list))  # 9

4.3 清空整个列表

语法格式：

列表名.clear()

# 4、 清空列表
my_list.clear()
print(my_list)  # []

5、 统计列表元素

5.1 统计列表指定元素个数

my_list2 = ["Y", "a", "o"]

语法格式：

列表.count(元素)

# 1、统计列表指定元素个数
count = my_list2.count("Y")
print(count)  # Y 的数量为 1

5.2 统计列表元素的总数量

语法格式：

len(列表名)

num = len(my_list2)
print(num)  # 3

6、列表小结：

• 列表可以存放多个元素（也是有限的，只不过正常情况下，我们是用不完的）
• 混装：列表中的元素可以不同类型
• 下标：列表中的元素存放是有序的
• 重复：列表中允许数据重复
• 可操作：允许我们对列表中的数据进行操作

二、列表遍历

语法：请看下面示例注意看函数说明文档

"""list:遍历迭代
"""# 用 while循环实现
def list_while_func():"""这个函数的作用是使用while遍历列表:return: None:index: 是列表的索引号:len(my_list): 是while循环的终止条件:my_list[index]: 根据列表的索引号访问列表达到遍历的效果"""my_list = ["liu", "jin", "tao"]index = 0while index < len(my_list):print(my_list[index])index += 1list_while_func()
"""返回结果：liujintao
"""# 用for循环实现def list_for_func():"""使用for循环遍历列表:return: None:range: 同样的是循环的条件:len(my_list): 是列表的长度，只要 条件变量 i 还在 长度数值范围内，循环执行"""my_list = ["liu", "jin", "tao"]for i in range(len(my_list)):print(my_list[i])list_for_func()
"""返回结果：liujintao
"""

使用场景

while ：适用于任何想要的循环

for： 遍历数据容器的场景或简单的固定次数的循环场景

三、元组的定义和使用

想想看，列表里面的元素是不是可以被修改？

• 那么元组定义后，它里面的元素就不能被修改哦！

列表是可读写的，而元组只能读不能写。

也就是说，我们希望数据不被修改，此时使用元组是最好不过了。

1、元组的定义

和列表一样，就是将[] 换成 （）即可

# 元组字面量
(元素1， 元素2， 元素3，.......)
# 元组变量
变量名称 = （元素， 元素， 元素， .....）
# 空的元组
变量名称 = （）
变量名称 = tuple（）

"""演示 tuple 元组的定义使用
"""# 定义元组
t1 = (1, "hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是:{t1}")  # t1的类型是：<class 'tuple'>,内容是:(1, 'hello', True)
print(f"t2的类型是：{type(t2)},内容是:{t2}")  # t2的类型是：<class 'tuple'>,内容是:()
print(f"t3的类型是：{type(t3)},内容是:{t3}")  # t3的类型是：<class 'tuple'>,内容是:()# 定义单个元素
t4 = (1,)
print(f"t4的类型是：{type(t4)},内容是:{t4}")  # t4的类型是：<class 'tuple'>,内容是:(1,)# 嵌套元组
t5 = ((1, 2, 3), (4, 5, 6))
print(f"t5的类型是：{type(t5)},内容是:{t5}")  # t5的类型是：<class 'tuple'>,内容是:((1, 2, 3), (4, 5, 6))# t5里面取出第 6 个元素
print(t5[1][2])  # 输出结果： 6

2、元组的相关操作

编号	方法	作用
1	index（）	查找某个数据，有返回下标，没有则报错
2	count（）	统计某个数据在当前元组出现的次数
3	len（元组）	统计元组内的元素个数

# 1、index方法
t6 = ("liu", "jin", "tao")
index = t6.index("jin")
print(f"在元组t6中，查找 jin 的下标为：{index}")  # 在元组t6中，查找 jin 的下标为：1# 2、count方法
t7 = ("liu", "jin", "jin", "jin", "tao")
count = t7.count("jin")
print(f"在元组t7中，元素个数为：{count}")  # 在元组t7中，元素个数为：3# 3、len方法
t8 = ("liu", "jin", "jin", "jin", "tao")
print(f"元组t8的长度为：{len(t8)}")  # 元组t8的长度为：5

3、元组的注意事项

1、 元组是不可以被修改的

2、我们再元组中嵌套了 列表（list）， 这样我们是可以修改里面列表的元素哦。

唯一可修改的地方（内部列表）：

t11 = (1, 2, 3, ["liu", "jin", "tao"])
print(f"t11元组的内容是：{t11}")  # t1元组的内容是：(1, 2, 3, ['liu', 'jin', 'tao'])
t11[3][0] = "LIU"
print(f"修改后的值为：{t11}")  # 修改后的值为：(1, 2, 3, ['LIU', 'jin', 'tao'])

四、元组的遍历

• 和列表一样，既然可以操作小标，那么遍历也是一样的。

# 1、元组的遍历：while
t9 = ("liu", "jin", "jin", "jin", "tao")
i = 0
while i < len(t9):print(t9[i])i += 1# 2、元组的遍历：for
t10 = ("liu", "jin", "jin", "jin", "tao")
for i in range(len(t10)):print(t10[i])

五、字符串

字符串也是容器，一个字符串可以存放多个字符。

• 字符串是只读的，并不支持修改哦
• 长度任意：取决于内存大小
• 支持下标索引
• 允许重复字符
• 支持for循环

5.1 index方法

# index方法
my_srt = "hello world"
print(my_srt.index("l"))    # 2
print(my_srt.index("o"))    # 4
print(my_srt.index("w"))    # 6
print(my_srt.index("d"))    # 10
# print(my_srt.index("z"))  # 报错

5.2 replace字符串替换

语法：字符串.replace(字符串1，字符串2)
功能：将字符串内的全部： 字符串1，替换为字符串2
注意：不是修改字符串本身，而是返回新的字符串，注意接收返回的新值哦！

new_my_str = my_str.replace("world", "python")
print(new_my_str)  # hello python

5.3 split 字符串分隔（切片）

语法：字符串.split(分隔符字符串)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入到列表对象中
注意：字符串本身不变，而是得到一个新的列表对象

my_str = "liu jin tao"
my_str_list = my_str.split(" ")
print(my_str_list)  # ['liu', 'jin', 'tao']

5.4 strip （字符串规整操作） 去首尾空格

语法1：字符串.strip()
语法2：字符串.strip(字符串)

new_my_str = my_str.strip()
print(new_my_str)  # liujintao  like code   99
# 用法2
new_my_str = my_str.strip("99")
print(new_my_str)  # liujintao  like code

5.5 count方法统计字符串出现的个数

count = my_str.count("l")
print(count)    # 2

5.6 len方法统计长度

lens = len(my_str)
print(lens)  # 34

六、序列（容器）的切片操作

上面学习的 ：列表、元组、字符串都是序列哦。

语法格式：

序列[起始下标 ：结束下标 ：步长]

表示从序列中，从指定位置开始，一次取出元素，到指定位置结束，得到一个新的序列。

省略的话默认从头或到尾。

注意点：切片操作不会影响到序列本身，因为操作后会得到一个新的序列。

"""序列切片
"""# 对List进行切片，从 1开始，4结束， 步长为1
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(my_list[1:4])  # [2, 3, 4]
print(my_list[1:4:1])  # [2, 3, 4]# 对tuple进行切片，从头开始，到最后，步长为1
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[0:])  # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[:])  # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[::])  # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)# 对str进行切片，从头开始，到最后结束，步长为2
my_str = "0123456789"
print(my_str[0::2])  # 02468
print(my_str[::2])  # 02468# 倒序: 对列表进行切片, 从 3 开始， 1 结束， 步长 -1
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(my_list[3:1:-1])  # [4, 3]# 倒序: 对tuple进行切片, 从头开始， 尾结束， 步长 -2
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[::-2])  # (10, 8, 6, 4, 2)

七、集合的定义和使用

我们学习了，列表、元组、字符三个数据容器其实基本上能够满足大多数场景，为何还需要学习集合类型？

• 列表可修改，支持重复元素且有序

• 元组、字符串不可修改、支持重复元素且有序

由此发现：都是有序的啊！有什么方法可以乱序啊！

此时，就得使用集合了。

注意：

• 首先，因为集合是无序的，所以集合不支持：下标索引访问。
• 但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

7.1 基本语法定义

列表、元组、字符串等定义的语法基本相同：

# 定义集合字面量
{元素， 元素， .....}
# 定义集合变量
变量名称 = {元素， 元素， .....}
# 定义空集合
变量名称 = set()

"""集合的几把呢使用
"""# 定义集合
my_set = {"liu", "jin", "tao"}
my_set_empty = set()
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")   # my_set的内容是：{'liu', 'jin', 'tao'}, 类型是：<class 'set'>
print(f"my_set的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")   # my_set的内容是：set(), 类型是：<class 'set'>

7.2 添加指定元素（add）

set.add(元素):将指定元素，添加到集合内。

集合本身被修改，添加了新元素

my_set.add("python")
my_set.add("java")
print(f"my_set添加元素结果为：{my_set}")    # my_set添加元素结果为：{'python', 'liu', 'tao', 'jin'}

由于集合是去重的，不能有重复的，如果我们添加的元素集合里面有，那么就不会再次进行添加。

7.3 移除指定元素（remove）

set.remove(元素)：将指定元素，从集合内移除。

集合本身被修改，移除了元素

my_set.remove("tao")
print(f"my_set移除元素结果为：{my_set}")    # my_set移除元素结果为：{'python', 'java', 'liu', 'jin'}

7.4 随机取元素（pop）

my_set.pop()
print(f"my_set随机取元素结果为：{my_set}")   # {'liu', 'jin', 'python'}

7.5 清空集合 （clear）

my_set.clear()
print(f"my_set清空集合结果为：{my_set}")   # set()

八、集合的差集

8.1 取集合的差集（difference）

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取差集后的结果是：{set3}, 元素有的集合为：{set1, set2}")  # 取差集后的结果是：{2, 3}, 元素有的集合为：({1, 2, 3}, {1, 5, 6})

• 去除元素相同的，得到新的集合（原来的集合不变）

8.2 消除集合的差集 (difference_update)

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后的集合1为：{set1}, 集合2为：{set2}")  # 消除差集后的集合1为：{2, 3}, 集合2为：{1, 5, 6}

• 消除两个集合中相同的元素（此时集合1就会发生变化）

8.3 合并集合（union）

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"两集合合并后结果为：{set3}")  # 两集合合并后结果为：{1, 2, 3, 5, 6}

• 将两个集合合并起来，但是重复的只保留一个（得到新的集合）

8.4 统计集合元素方法 （len）

set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(num)  # 5  （因为集合去重）

8.5 集合的遍历(for )

• 集合没有下标，不能使用while（只能用for处理）

for i in set1:print(i)  # 1 2 3 4 5

集合练习

信息去重：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, "liu", "jin", "liu", "jin", "tao"]
my_set = set()
for i in my_list: # 将列表中的元素一个一个拿出来添加到集合中my_set.add(i)
print(my_set)  # {1, 2, 3, 4, 5, 6, 7, 8, 9, 'jin', 'tao', 'liu'}

8.6 集合总结

集合总结：
1、可以容纳多个数据
2、可以容纳不同数据类型的数据
3、数据时无序的（不支持下标索引）
4、不允许重复数据存在
5、可以修改（增加或删除元素）
6、支持（for循环）遍历

九、字典定义

生活中的字典就是：字：含义

字典的定义同样使用{}，不过存储的元素是一个个的键值对，如下所示：

# 定义字典字面量
{key: value, key: value, .....}
# 定义字典字面量
my_dict = {key: value, key: value,......}
# 定义空字典
my_dict = {}
my_dict = dict()

9.1 字典的定义

my_dict = {"name": "张三", "age": 18}
print(type(my_dict))  # <class 'dict'>
print(my_dict)  # {'name': '张三', 'age': 18}# 定义空的字典
empty_dict = {}
my_dict1 = dict()
print(empty_dict)   # {}
print(my_dict1)  # {}

9.2 获取字典

my_dict = {"name": "张三", "age": 18}
age = my_dict["age"]
print(age)  # 18

9.3 字典的嵌套

stu_score_dict = {"liu": {"语文": 90,"数学": 99,"英语": 66,},"jin": {"语文": 80,"数学": 89,"英语": 76,},"tao": {"语文": 95,"数学": 99,"英语": 76,}
}print(stu_score_dict)  # {'周杰轮': {'语文': 90, '数学': 99, '英语': 66}, 'jin': {'语文': 80, '数学': 89, '英语': 76}, 'tao': {'语文': 95, '数学': 99, '英语': 76}}
print(stu_score_dict["tao"]["数学"])  # 99
print(stu_score_dict["liu"]["英语"])  # 66

9.4 字典的注意事项

键值对的 key 和 value 可以是任意类型（key不可为字典）

字典内 key 不允许重复，重复添加等同于覆盖原有数据

字典没有下标，用的是key来检索 value值

十、字典的操作

以下面字典操作为例：

my_dict = {"liu": 99, "jin": 88, "tao": 77}

10.1 新增元素

my_dict["yxy"] = 100
print(f"字典经过新增元素后结果为：{my_dict}")  # 字典经过新增元素后结果为：{'liu': 99, 'jin': 88, 'tao': 77, 'yxy': 100}

10.2 更新元素

• 有则跟新，无则添加

my_dict["liu"] = 100
print(f"修改元素后的结果为：{my_dict}")   # 修改元素后的结果为：{'liu': 100, 'jin': 88, 'tao': 77, 'yxy': 100}

10.3 删除字典元素（pop）

• 有新的返回值

	score = my_dict.pop("yxy")
print(f"删除字典元素后的结果为：{my_dict}")  # 删除字典元素后的结果为：{'liu': 100, 'jin': 88, 'tao': 77}
print(score)  # 100

10.4 清空字典（clear）

my_dict.clear()
print(my_dict)  # {}

2、获取全部的 key

• 注意有返回值哦！
• 可以使用遍历去操作字典的 key 和 value

语法：

字典.keys()  # 得到所有的key

my_dicts = {"liu": "yu","jin": "xin","tao": "yao"
}keys = my_dicts.keys()
print(keys)  # dict_keys(['liu', 'jin', 'tao'])

3、 遍历字典

重点是keys使我们通过keys方法获取到的一个key列表，然后，我们使用for循环依次遍历列表。这样i就是keys这个列表迭代器里面的每一个元素。

最后我们每次循环都对字典key进行访问器结果值。

# keys拿到的结果，我用for循环拿到key 然后 在获取到value
for i in keys:print(my_dicts[i])"""运行结果：yuxinyao"""

方法2：

for key in my_dicts:print(key)  # 得到所有的 keyprint(my_dicts[key])  # 得到所有的value值

• 效果是一样的。

注意：字典是不能使用while的，因为他不允许下标索引。

统计字典中元素的个数

• 使用len方法实现

number = len(my_dicts)
print(number)  # 3

• 用变量计数器

count = 0
for key in my_dicts:count += 1print(f"字典中共有：", count)
"""字典中共有： 1字典中共有： 2字典中共有： 3
"""

字典小结

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是key value键值对
• 可以通过key获取到value，key不可重复（重复会覆盖掉）
• 不支持下标索引（因此不能使用while遍历）
• 可以修改（增删或更新）
• 只能for循环遍历

字典练习

"""完成数据的存储通过遍历，一级员工升级并+ 1000
"""def main():is_dict = {"王力宏": {"部门": "科技部","工资": 3000,"级别": 1},"周杰轮": {"部门": "市场部","工资": 5000,"级别": 2},"林俊杰": {"部门": "市场部","工资": 7000,"级别": 3},"张学友": {"部门": "科技部","工资": 4000,"级别": 1},"刘德华": {"部门": "市场部","工资": 6000,"级别": 2}}# 遍历判断等级for key in is_dict.keys():if is_dict[key]["级别"] == 1:is_dict[key]["级别"] = 2is_dict[key]["工资"] += 1000print(is_dict[key])
main()