欢迎来到我的博客！💃💃

🏡🏡推荐博客：August_._

一起持续学习，不断总结，共同进步🎊🎊

 

数据容器

概念：

        一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

类型：

        list 列表、tuple 元组、str 字符串、set 集合、dict 字典

列表

语法

#  字面量
    [元素1，元素2，元素3，元素4 ······· ]
#  定义变量
    变量名称 = [元素1，元素2，元素3，元素4 ······· ]
#  定义空列表
    变量名称 = [ ]
    变量名称 = list()

列表内的每一个数据，称之为元素：

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

 列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套 

方法（查询功能）

# 如果将函数定义为class（类）的成员，则函数会称之为方法

class Student:

    def add(self, x, y):
        return x + y

# 方法的调用
student = Student()
num = student.add(1,2)

遍历（迭代）

将容器内的元素依次取出进行处理的行为

1、while 循环：可以自定循环条件

def 函数名():
    变量 = [元素1,元素2……]
    # 通过while循环，使用列表[下标]的方式取出
    # 定义一个变量表示下标，从0开始
    # 循环条件为 下标值<列表的元素数量
    index = 0
    while index < len(列表):
        元素 = 列表[index]
        对元素进行处理
        index += 1

# 调用函数
函数名()

 2、for 循环：不可以自定循环条件、更适合遍历数据容器的场景

# for循环语法
for 临时变量 in 数据容器:
    对临时变量进行处理

例如： 

def list_for_func():
    my_list = [1, 2, 3, 4, 5]
    for element in my_list:
        print(f"列表的元素是:{element}")

list_for_func()

元组 

1、同列表一样，可封存多个、不同类型的元素在内

2、元组一旦定义而成，就不可修改，否则会直接报错

3、可以修改元组内 list 的内容（修改元素、增加、删除、反转等）

4、元组只有一个数据，这个数据后面要加逗号

嵌套

# 元组的嵌套
t1 = ((2, 4, 6), (5, 2, 4))
print(t1[0][0])  # 结果2

遍历

# 循环的遍历：while
t2 = (2, 4, 6, 5, 2, 4)
index = 0
while index < len(t2):
    print(f"元组里的元素有：{t2[index]}")
    index += 1

# 以下代码效果一样

# 元组的遍历：for
for element in t2:
    print(f"元组里的元素有：{element}")

字符串

概念

可以看作字符的容器，支持下标索引等特性

注意：

1、只可以存储字符串

2、不可以修改（增加或删除元素等）

替换

语法：字符串.replace(字符串1，字符串2)

功能：将字符串内的全部：字符串1，替换成字符串2

注意：不是修改字符串本身，而是得到了一个新字符串

例如： 

str_1 = "LOVE YOU FOREVER"
new_str_1 = str_1.replace("YOU", "MYSELF")
print(f"将字符串{str_1}，进行替换后得到：{new_str_1}")

分割

语法：字符串.split(分割符字符串)

功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到了一个列表对象

str_1 = "LOVE YOU FOREVER"
new_str_1 = str_1.split(" ")
print(f"将字符串{str_1}，进行替换后得到：{new_str_1}，类型是：{type(new_str_1)}")

规整操作

1、去前后空格

语法：字符串.strip()

str_1 = "  LOVE YOU FOREVER  "
print(str_1.strip())

2、去前后指定字符串 

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

str_1 = "17LOVE YOU FOREVER17"
print(str_1.strip("17"))

常用操作汇总

序列

概念

内容连续、有序，可使用下标索引的一类数据容器，eg：列表、元组、字符串

切片

从一个序列中，取出一个子序列

语法：序列 [ 起始下标：结束下标：步长 ]    #  步长为1可以省略不写

1、起始下标表示从何处开始，可以留空，留空视作从头开始

2、结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

3、步长表示，依次取元素的间隔

• 步长N表示，每次跳过N - 1个元素取
• 步长为负数表示反向取（注意：起始下标和结束下标也要反向标记）

集合

语法

# 定义集合变量

    变量名称 = { 元素，元素，··· ··· ，元素 }

# 定义空集合
    变量名称 = set()

注意：

1.  不支持重复的，无序的，且不支持下标索引访问
2.  不是序列（有序、支持下标索引）
3.  和列表样，是允许修改的

添加新元素

语法：集合.add（元素）

str_1 = {'春天', '夏天', '秋天', '春天', '夏天', '秋天'}
# 添加新元素
str_1.add('冬天')
print(f"str_1添加元素后结果是：{str_1}")

 移除元素

语法：集合.remove(元素)

str_1 = {'春天', '夏天', '秋天', '冬天', '春天', '夏天', '秋天'}
# 移除元素
str_1.remove('冬天')
print(f"str_1移除元素后结果是：{str_1}")

随机取元素

语法：集合.pop() 

功能：从集合中随机取出一个元素 【集合本身被修改，元素被移除】

str_1 = {'春天', '夏天', '秋天', '冬天'}
element = str_1.pop()
print(f"集合被取出元素是：{element},取出元素后的集合：{str_1 }")

 清空集合

语法：集合.clear() 【集合本身被清空】

取2个集合的差集

语法：集合1.difference(集合2)

功能：取出集合1和集合2的差集（集合1有而集合2没有的）

【得到一个新集合，集合1和集合2不变】

set_1 = {1, 2, 3}
set_2 = {3, 4, 5}
set_3 = set_1.difference(set_2)
print(set_3)

消除2个集合的差集

语法：集合1.difference_update（集合2）

功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素

【集合1被修改，集合2不变】

set_1 = {1, 2, 3}
set_2 = {3, 4, 5}
set_1.difference_update(set_2)
print(set_1)
print(set_2)

合并2个合集

语法：集合1.union（集合2）

功能：将集合1和集合2组成新集合

【得到新集合，集合1和集合2不变】

set_1 = {1, 2, 3}
set_2 = {3, 4, 5}
set_3 = set_1.union(set_2)
print(set_1)
print(set_2)
print(set_3)

 统计集合的元素数量

set1 = {1, 2, 3, 4, 5}
num = len(set1)

 集合的遍历

不支持下标索引，所以不能用while循环进行遍历

可以用for循环

set_1 = {1, 2, 3}
for element in set_1:
    print(element)

常用功能总结

字典 

语法

注意：

1、可以容纳不同类型数据，存储的元素是键值对

2、可以修改，不可以重复，重复添加等同于覆盖原有数据

3、同集合一样，不可以使用下标索引,可以通过key值来取得对应的Value

4、支持for循环，不支持while循环

dict_1 = {"高数": 100, "英语": 99, "体育": 98}
print(dict_1["高数"])
print(dict_1["英语"])

嵌套

字典的Key和Value可以是任意数据类型（Key不可以为字典）

例如：

dict_2 = {"张三": {
    "高数": 100,
    "英语": 80,
    "体育": 90
},
    "李四": {
    "高数": 80,
    "英语": 96,
    "体育": 89
},
    "王五": {
    "高数": 90,
    "英语": 85,
    "体育": 87
}}
score = dict_2["李四"]["英语"]
print(f"李四的英语成绩是{score}")

新增元素

语法：字典[Key] = Value

结果：字典被修改，新增了元素 

dict_3 = {"高数": 100, "英语": 80, "体育": 90}
dict_3["思政"] = 98
print(f"字典更新后:{dict_3}")

新增元素

语法：字典[Key] = Value

结果：字典被修改，新增了元素 

注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新value值

dict_3 = {"高数": 100, "英语": 80, "体育": 90}
dict_3["英语"] = 98
print(f"字典更新后:{dict_3}")

删除元素

语法：字典.pop(Key)

结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除

dict_4 = {"高数": 100, "英语": 80, "体育": 90}
score = dict_4.pop("英语")
print(f"字典更新后:{dict_4},被删除的数据是{score}")

清空字典

语法：字典.clear()

结果：字典被修改，元素被清空

dict_4 = {"高数": 100, "英语": 80, "体育": 90}
dict_4.clear()
print(f"字典清空后:{dict_4}")

获得全部Key 

语法：字典.keys()

结果：得到字典中全部Key

dict_4 = {"高数": 100, "英语": 80, "体育": 90}
keys = dict_4.keys()
print(f"字典中全部key：{keys}")

 遍历字典

方法一：

通过获取全部的Key来完成遍历

dict_4 = {"高数": 100, "英语": 80, "体育": 90}
keys = dict_4.keys()
# 遍历字典
for key in keys:
    print(f"字典中的key是：{key}")
    print(f"字典中Value是：{dict_4[key]}")

方法二：

通过对字典进行for循环，每一次循环都是直接得到key

dict_4 = {"高数": 100, "英语": 80, "体育": 90}
# 遍历字典
for key in dict_4:
    print(f"字典中的key是：{key}")
    print(f"字典中Value是：{dict_4[key]}")

常用操作总结