一、数据容器

1.数据容器：list(列表)

容器：就是为了批量存储和批量使用多份数据，容器内的每一份数据称之为元素。

"""
# 字面量
[元素1，元素2，元素3……]
# 定义变量
变量名称 = [元素1，元素2，元素3，……]
# 定义空列表
li1 = []
li2 = list()
从以上可以得出：列表的标识为中括号[],里面的每一个元素之间使用逗号‘，’分割
注意：列表里面的数据元素可以为不同的数据类型，支持嵌套
"""
print("同一种元素类型定义的列表")
name = ["张三","李四","王五"]
print(name)
print("不同一种元素类型定义的列表")
name1 = ["张三",18,"王五"]
print(name1)
print("列表中的元素为嵌套的形式")
name2 = [[1,2,3],[4,5,6]]
print(name2)

"""
列表的下标索引
语法：列表[下标]，从前向后的方向，从0开始递增
"""
list1 = ['张三', '李四', '王五']
for name in range(len(list1)):
    print(list1[name])

"""
嵌套列表的下标
"""
list1 = [[1,2,3],[4,5,6]]
for name in list1:
    for index in range(len(name)):
        print(name[index])

"""
查找某个元素的下标
语法：列表.index(元素)
"""
my_list = ["张三","李四","王五"]
print(my_list.index("李四"))

"""
列表的修改（重新赋值）功能
语法：列表[下标]=值  
直接对指定下标（正向、反向下标均可）的值进行重新赋值修改
"""
list1 = [1,2,3]
list1[1] = "修改了"
print(list1)
list2 = [4,5,6]
list2[2] = "修改了111"
print(list2)
"""
插入元素
语法：列表.insert(下标，元素) 即在指定的下标位置插入指定的元素,之后原来位置的元素以及后续的元素均后移
"""
list_insert = [1,2,3]
list_insert.insert(1,"插入测试")
print(list_insert)
"""
追加元素
语法：列表.append(元素)，将指定元素，追加到列表的尾部
"""
list_append = [1,2,3]
list_append.append(4)
print(list_append)
"""
追加元素方式2
语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，一次追加到列表尾部
"""
list_extend = [1,2,3]
list8 = [7,8,9]
list_extend.extend(list8)
print(list_extend)
"""
列表的删除：
语法1 del 列表[下标]
语法2 列表.pop(下标)
删除某一个元素在列表中的第一个匹配项，语法 列表.remove(元素)
清空列表内容：语法：列表.clear()
"""
list_del = [1,2,3,4,5,6,7]
del list_del[0]
print(list_del)
list_del.pop(1)
print(list_del)
list_del.remove(7)
print(list_del)
list_del.clear()
print(list_del)
"""
统计某元素在列表内的数量（次数）
语法：列表.count(元素值)
统计列表有几个元素 语法：len(列表)
"""
list_count = [1,1,2,3,4,5,6,7]
print(list_count.count(1))
print(len(list_count))

2.list(列表)的遍历

"""
第一种方式：
while方式
index = 0
while index <len(列表)
    元素 = 列表[index]
    对元素进行处理
    index += 1
第二种方式
for循环
for 临时变量 in 数据容器
    对临时变量进行处理
"""
# 第一种：while遍历
list1 = [1,2,3,4]
index = 0
while index < len(list1):
     i = list1[index]
     index += 1
     print(f"while遍历结果为{i}")
# 第二种：for循环遍历
for j in list1:
    print(f"for遍历结果为{j}")

while循环可以自定循环条件，并自行控制
for循环不可用自定循环条件，只可以从容器中一个个取出所需要的数据，且for不能实现无限循环，因为列表的数据是有限的

3.数据容器：tuple(元组)

元组定义：定义元组可以使用小括号，里面的数据元素使用逗号隔开，元素可以使不同的数据类型，元组数据一旦定义，就不能修改。

"""
# 定义元组字面量
(元素，元素，……)
# 定义元组变量
变量名称 = （元素，元素，……）
# 定义空元组
变量名称 = （）
变量名称 = tuple()
元组的相关操作如下三个所示：
1.index()查找某个数据，如果数据存在，返回对应的下标，否则报错
2.count()统计某个数据在当前元组出现的次数
3.len(元组)统计元组内的元素个数
注意：元组因为不可修改的特性，所以操作方法比较少
"""
# 根据下标（索引）取出数据
t1 = (1,"测试",3)
print(t1[1])  # 结果，‘测试’
# 根据index()，查找特定元素的第一个匹配项
print(t1.index('测试'))  # 结果，1
# 统计某个数据在元组内出现的次数
print(t1.count('测试'))  # 结果，1
# 统计元组内的元素个数
print(len(t1))  # 结果，3

"""
嵌套使用
"""
t2 = (1,2,['a','b','c'])
# 此时可以修改元组里面列表的某一个元素值
t2[2][0]='修改'
print(t2)

4.数据容器：str(字符串)

字符串：和其他数据容器元组和列表一样，字符串也是可以通过下标进行访问。

• 从前往后，下标从0开始
• 从后往前，下标从-1开始

同元组一样，字符串是一个无法修改的数据容器

字符串常用操作汇总：

"""
字符串切片
查找特定字符串的下标索引值
语法：字符串.index(待查找的字符串)
"""
my_str = "I am lgl"
print(my_str.index("lgl"))  # 结果5，即第一个字母所在索引
"""
字符串的替换
语法：字符串.replace(字符串1，字符串2)
就是将字符串的全部字符串1替换为字符串2，并返回一个新的字符串，不会修改原来的字符串
"""
my_str1 = "I am lgl"
new_str = my_str1.replace('lgl','zyt')
print(new_str)  # I am zyt

"""
字符串分割：
语法：字符串.split(分割符)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并入列表中，结果返回一个列表对象中
注意：字符串本身不发生改变，而是得到了一个新的字符串
"""
new_split = my_str1.split(" ")  # 以空格进行分割
print(new_split)  # ['I', 'am', 'lgl']
"""
去除字符串的前后空格
语法：字符串.strip()或字符串.strip(去掉前后指定的字符)
返回一个去掉空格后的字符串
"""
my_str11 = "   12I am lgl21"
print(my_str11.strip())  # 12I am lgl21
print("12I am lgl21".strip('12'))   # I am lgl
"""
统计字符串中某个字符串出现的次数
语法：字符串.count(字符串)
"""
print("lgl_dsajdgk_lgl".count("lgl"))  # 2
"""
统计字符串的长度
语法：len(字符串)
"""
print(len("hdaklak  ***00"))  # 14

5.数据容器的切片

序列：是指内容连续、有序、可使用下标索引的一类数据容器
列表、元组、字符串均可以视为序列

切片：即从一个序列中取出一个子序列
语法：序列[起始下标：结束下标：步长]

my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]	# 下标1开始，下标4（不含）结束，步长1
print(new_list)		# 结果：[2, 3, 4]

my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]		# 从头开始，到最后结束，步长2
print(new_list)		# 结果：[1, 3, 5]

my_str = "12345"
new_str = my_str[:4:2]	 # 从头开始，到下标4（不含）结束，步长2
print(new_str)		# 结果："13"

6.数据容器：set(集合)

集合自带去重功能，内容无序

"""
集合的定义：
集合字面量
{元素，元素，……}
定义集合变量
变量名称 = {元素，元素，……}
定义空集合
变量名称 = set()

集合可以去重，所以去重后无法保证与原来的序列顺序一致
"""
test = {'研究生','本科生','博士生','本科生'}
print(test)  # {'研究生', '本科生', '博士生'}
"""
集合常用操作：
修改：
添加新元素，集合.add(元素)。将指定元素添加到元素内，此时原来的集合也相对应的改变
移除元素：集合.remove("需要移除的元素")，此时原集合会被修改，移除了元素
取出元素：集合.pop() 从集合中随机取出一个元素，结果会得到一个元素结果，同时集合本身被修改，元素被移除
清空集合：集合.clear(),此时集合中所有被清空，返回一个空集合
取出两个集合的差集：语法：集合1.difference(集合2)  取出集合1和集合2之间的差集，集合1有，而集合2没有的,此时返回一个新的集合，集合1和集合2原本的都不变
消除两个集合的差集：语法：集合1.difference_update(集合2)  对比集合1和集合2，在集合1内删除和集合2相同的元素，结果集合1被修改，集合2不变
两个集合合并：集合1.union(集合2)  功能：将集合1和集合2组成新的集合，此时得到新集合，集合1和集合2不变
查看集合的元素数量：语法：len(集合)  统计集合中由多少个元素
集合遍历：只能使用for进行遍历，因为集合不支持下标索引，所以也就不支持while循环

"""
test.add("海归")
print(test)
test.remove("海归")
print(test)
test.pop()
print(test)
# test.clear()
# print(test)
test2 = {"本科生","海归"}
# print(test.difference(test2))
test.difference_update(test2)
print(test)
hebin1 = {1,2,3}
hebin2 = {4,5,6}
temp = hebin1.union(hebin2)
print(temp)  # {1, 2, 3, 4, 5, 6}
# for循环遍历
set1 = {1,2,3}
for i in set1:
    print(i)

7.数据容器：dict(字典、映射)

字典：键值对的形式，可以使用key取出对应的value


常用的操作

"""
定义字典字面量
{key : value, key : value……}
定义字典变量
dict_test = {key : value, key : value……}
定义空字典
第一种方式 dict_1 = {}
第二种方式 dict_2 = dict()
"""
# 字典常用操作
"""
新增元素
语法：字典[key] = value 结果字典被修改，新增了元素
"""
stu_dict = {
    "张三": 20,
    "李四": 80,
    "王五": 90
}
stu_dict["李华"] = 100
print(stu_dict)  # {'张三': 20, '李四': 80, '王五': 90, '李华': 100}
"""
更新元素
字典中key不可以重复，所以对已经存在的key进行赋值就是进行更新操作
"""
stu_dict["张三"] = 100
print(stu_dict)
"""
删除元素
语法：字典.pop(key) 结果获得指定的key对应的value,同时字典被修改，指定的key对应的value被删除
"""
value = stu_dict.pop("李华")
print(stu_dict)
print(value)
"""
清空元素
语法：字典.clear()
结果字典被修改，元素被清空
"""
stu_dict.clear()
print(stu_dict)
"""
获取所有的key
语法：字典.keys(),结果：得到字典中全部的key
"""
stu_dict = {
    "张三": 20,
    "李四": 80,
    "王五": 90
}
keys = stu_dict.keys()
print(keys)
"""
遍历字典
语法：for key in 字典.keys()
"""
for k in stu_dict.keys():
    print(f"学生：{k},分数：{stu_dict[k]}")

"""
计算字典中全部元素的数量
语法：len(字典)
"""
print(len(stu_dict))

8.数据容器的通用操作

遍历：5种数据容器都支持for循环遍历。列表、元组、字符串支持while循环，集合和字典不支持while，因为这两个无法索引到下标
通用统计功能：len(容器)，表示统计容器的元素个数；max(容器)，表示统计容器的最大元素；min(容器)，表示容器的最小元素
通用类型转换：list(容器)，将给定容器转换为列表；str(容器)，将给定容器转换为字符串；tuple(容器)，将给定容器转换为元组；set(容器)，将给定容器转换为集合
通用排序功能：sorted(容器，[reverse=True])，将给定容器进行排序，排序后都会得到列表（list）对象，reverse=True表示降序。