Python数据容器：list + set + tuple + dict + str 简记 黑马课程

# -*- coding:utf8 -*-
"""
# editor: hjjdreamer
# create-time: 2022/11/16-23:08
# Python-Script: chapter6-container.py
# describe: 数据容器课程代码简单记
2022新版黑马程序员python教程，8天python从入门到精通，学python看这套就够了
https://www.bilibili.com/video/BV1qW4y1a7fU?p=81&vd_source=19d68c51d074de183fd2e6b1b1cb0a9b
"""
# lesson1: list
"""
列表 = []标识符
逗号分割
每个数据称为元素
列表内的元素数据类型不受限制
"""
ls = ["das", 666, True, 12.987]
print(ls)
print(type(ls))

# 列表间的嵌套
ls2 = [1, "dada", ["adad", 123], ["aqwe", True]]
print(ls2)
print(type(ls2))
print(ls2[2][1])

"""
索引 + 下标
从 0 开始，依次增加 == 左到右
反向索引 == 从后向前 == 从 -1 开始
"""
ls3 = ["a", "b", "c"]
print(ls3)
print(ls3[0])
print(ls3[1])
print(ls3[2])
# print(ls3[3])   #IndexError: list index out of range
print("\n反向索引 == 从后向前 == 从 -1 开始")

print(ls3[-1])
print(ls3[-2])
print(ls3[-3])

# 列表嵌套取数
ls4 = [[1, "dada", 12.456], ["adad", 123], ["aqwe", True]]
print(ls4[0][2])  # 12.456
print(ls4[1][1])  # 123
print(ls4[2][0])  # aqwe

# 列表常用操作
"""
在python中，若将函数定义为class的成员，那么函数称之为方法
方法和函数的功能一样，有传入参数，有返回值，只是格式不一样
"""


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


student = student()  # 获取类
num = student.add(3, 4)  # 获取方法
print(num)

# lesson2: index + list
"""
存在返回索引值 + 不存在则报错
"""
list1 = ["a", "b", "c", "d"]
index = list1.index("a")
print(f"a 在列表中的下标索引是 {index}")

# 修改特定元素的索引值
"""
list[index] = value
"""
print(list1)
list1[0] = "abab"
print(f"edit list1 == {list1}")

# insert
"""
insert(下标，索引)，指定位置，插入指定元素
"""
print(list1)
list1.insert(2, "cdcdc")
print(f"insert list1 == {list1}")

# append
"""
追加元素在最后
"""
print(list1)
list1.append("zzzzzzz")
print(f"append list1 == {list1}")

# extend
"""
追加一批元素
"""
list2 = [1, 2, 3, 4]
print(list2)
print(list)
list1.extend(list2)
print(f"extend list == {list1}")

# del + pop
print(list1)
del list1[2]
print(f"del list1 == {list1}")

element = list1.pop(0)
print(f"pop list1 == {list1} + element == {element}")

# remove
"""
删除某元素在列表中的第一个匹配项目，只能删除一个
"""
print(list1)
list1.remove("zzzzzzz")
print(f"remove list1 == {list1}")

# clear() 清空列表
print(list2)
list2.clear()
print(f"clear list2 == {list2}")

# count
list3 = ["a", "a", "a", "a", "a", "ada", "dadq"]
print(list3)
count = list3.count("a")
print(f"list3 has {count} a")

# len
print(list1)
count = len(list1)
print(f"count element == {count}")

# while
"""
index = 0
while index < len(list1):
     element = list1[index]
     index += 1
"""


def list_while():
    print(list1)

    index = 0
    while index < len(list1):
        element = list1[index]
        print(f"element == {element}")
        index += 1


list_while()

# for
"""
for tmc_var in container：
    jobs
"""
list4 = [1, 2, 3, 4, 5, 6, 7]


def list_for():
    for num in list4:
        print(f"{num}")


list_for()

# lesson3: tuple
"""
元组的信息不能篡改
可以封装多个不同类型元素
小括号
逗号分隔
"""
t1 = (1, "hello", True)
t2 = ("adad",)  # 必须带有逗号，否则不是元组类型
t3 = tuple()
print(f"t1 内容是 {t1}, 类型是{type(t1)}")
print(f"t2 内容是 {t2}, 类型是{type(t2)}")
print(f"t3 内容是 {t3}, 类型是{type(t3)}")

# 元组的嵌套
t5 = ((1, 2, 3, 4), (5, 6, 7, 8, 9))
print(f"t5 内容是 {t5}, 类型是{type(t5)}")
# 下标索引
print(t5[1][1])

# 基本操作
"""
index
count
len
"""
# index 查找
t4 = ("adad", "asas", "qwqw")
index = t4.index("adad")
print(f"在元组{t4}, 'adad'下标索引是{index}")

# count + len 统计
t6 = ("adad", "asas", "qwqw", "adad", "asas", "qwqw")
num = t6.count("asas")
num1 = len(t6)
print(f"元组{t6} 一共有 {num1} elements, 'asas'一共有{num}")

# while + for
index = 0  # 控制初始值
while index < len(t6):
    print(f"{t6} has {t6[index]}")
    index += 1
print("while done\n")

for element in t6:
    print(f"{t6} has {element}")

# 元组的修改
"""
不可以修改元组的元素
可以修改元组内的列表元素 == 列表的特征 == 增删改查
"""
t7 = (1, 2, ["a", "b", "c"])
print(f"t7 == {t7}")
t7[2][1] = "dadadad"
t7[2][0] = "12323123dadadad"
print(f"t7 == {t7}")

"""
summar
可以容纳多个不同类型元素
支持下标索引
允许重复数据
不可以修改（增删改），可以修改元组内的列表元素
支持while + for
"""

# lesson4: str
"""
字符串可以通过下标索引访问
字符串是一个无法修改的数据容器
如果进行修改，得到一个新的字符串
"""
str1 = "asdfghjk qweqrewrq ewrqwer"
print(str1[0])
print(str1[-1])

# index
value = str1.index("q")
print(value)

# replace
"""
str.replace(str1, str2)
字符串替换，得到一个新的字符串
"""
str2 = str1.replace("ewrqwer", "c")
print(f"str1 == {str1} + str2 == {str2}")
print(id(str2))
print(id(str1))

# split
"""
str.split(分隔符)
按照分隔符对字符串进行分隔成多个字符串，并存入列表对象中
字符串本身不变，得到一个新的列表对象
"""
list1 = str1.split(" ")
print(list1)

# strip
"""
str.strip() == 去除前后空格
str.strip(str) == 去除前后指定字符串
"""
str3 = "    a b c d e          "
str31 = str3.strip()  # 去除首位空格
print(f"str3 == {str3} \nstr31 =={str31}")

str4 = "12a b c d e12"
str41 = str4.strip("12")
print(f"str4 == {str4} \nstr41 =={str41}")

# count
print(str1)
count = str1.count("qw")
print(f"{str1} has {count} qw")

# len
num = len(str1)
print(f"str1 == {str1} + len == {num}")

# while + for
str5 = "abcdefg"
index = 0
while index < len(str5):
    print(str5[index])
    index += 1

for i in str5:
    print(i)

"""
summary
只可以存储字符串
长度任意
支持下标索引
允许重复字符
不可以修改
支持循环
"""

# test
# TODO 1:define
str6 = "itheima itcast boxuegu"
# TODO 2:COUNT(IT)
num = str6.count("it")
print(f"str6 = {str6} has {num} it")
# TODO 3:REPLACE
str61 = str6.replace(" ", "|")
print(f"str6 == {str6} + str61 == {str61}")
# TODO 4:SPLIT
str61_list = str61.split("|")
print(str61_list)

# lesson5 序列
"""
序列 == 内容连续，有序，可以使用下标索引的一类数据容器
列表，元组，字符串都可以视为序列

切片 == 从一个序列中取出一个子序列 == 序列(起始下标: 结束下标: 步长)
表示从序列中，指定位置开始，依次取出元素，到指定位置结束，得到一个新序列
起始下标为空 == 从头开始，包含
结束下标为空 == 从尾开始，不包含
"""
list5 = [0, 1, 2, 4, 3, 5, 6]
list51 = list5[1:4]
print(list51)
list52 = list5[3:1:-1]
print(list52)

tuple2 = (0, 1, 2, 3, 4, 5, 6)
tuple21 = tuple2[:]
print(tuple21)
tuple22 = tuple2[::-2]
print(tuple22)

str7 = "01234567"
str71 = str7[::2]
print(str71)
str72 = str7[::-1]
print(str72)

# lesson6 set
"""
去重
逗号分隔元素
没有顺序，不支持下标索引
支持修改

回顾：
列表 []
元组 ()
字符 ""
集合 {}
"""
set1 = {"a", "b", "c", "d", "a", "b", "c", "d", "a", "b", "c", "d"}
set_empty = set()
print(f"set1 == {set1}, type = {type(set1)}")
print(f"set1 == {set_empty}, type = {type(set_empty)}")

# add 添加新元素
set1.add("wq")
set1.add("43242")

print(set1)

# remove 移除新元素
set1.remove("a")
print(f"{set1}")

# pop 随机取数
element1 = set1.pop()
print(f"{set1} get element = {element1}")

# clear 清空集合
set1.clear()
print(f"{set1}")

# 差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)  # 集合1有，集合2没有
set4 = set2.difference(set1)  # 集合2有，集合1没有
print(set3)  # {2, 3}
print(set4)  # {5, 6}
print(set1)  # {1, 2, 3}
print(set2)  # {1, 5, 6}

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

# union 合并组成新集合
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set3)  # {1, 2, 3, 5, 6}
print(set2)  # {1, 5, 6}
print(set1)  # {1, 2, 3}

# len 统计
num = len(set3)
print(f"{num}")

# 遍历
"""
集合不支持下标索引，不适用while循环
for循环适用
"""
for i in set3:
    print(f"{i}")

# 案例
list6 = ["a", "b", "c", "d", "a", "e", "a", "b"]
set5 = set()
for element in list6:
    set5.add(element)

print(f"{list6}")
print(f"{set5}")

"""
可以容纳不同类型的多个数据
无序存储
不允许重复
可以修改
支持for循环
"""

# lesson7: 字典
"""
key:value

不可以使用下标索引
可以通过key取得value
"""
dict1 = {"a": 1, "b": 2, "c": 3}
# 定义空字典
dict2 = {}
dict3 = dict()

print(f"dict1 == {dict1}, type == {type(dict1)}")
print(f"dict2 == {dict2}, type == {type(dict2)}")
print(f"dict3 == {dict3}, type == {type(dict3)}")

# key value的覆盖，后面覆盖前面
dict2 = {"a": 1, "a": 2, "c": 3}
print(dict2)

# 通过key 取得value
dict1 = {"a": 1, "b": 2, "c": 3}
num = dict1["b"]
print(f"{dict1}, b value == {num}")

# 字典的嵌套
"""
字典的key 和 value 是任意数据类型，但是key不能为字典
"""
dict2 = {
    "a": {"chinese": 85, "maths": 85, "english": 85},
    "b": {"chinese": 75, "maths": 75, "english": 75},
    "c": {"chinese": 65, "maths": 65, "english": 65}
}
print(dict2)
score = dict2["b"]["maths"]
print(f"b + maths == {score}")
score1 = dict2["c"]["english"]
print(f"c + english == {score1}")

# 新增或者修改
"""
dict[key] = value
字典key不可以重复：
对已存在的key执行就是更新key的value
对不存在的key执行就是新增
"""

dict1 = {"a": 1, "b": 2, "c": 3}
dict1["a"] = 5
dict1["d"] = 4
print(dict1)

# 删除元素
num = dict1.pop("a")
print(f"dict1 use pop update {dict1}, delete a, value == {num}")

# 清空 clear
dict1.clear()
print(f"dict1 clear == {dict1}")

# 获取所有的键 keys
keys = dict2.keys()
print(f"{dict2} has {keys}")

# 遍历字典
"""
通过获取全部的key，执行for循环遍历
"""
for key in keys:
    print(f"dict2_key == {key}")
    print(f"dict2_value == {dict2[key]}")

"""
直接对dict2的key 执行循环
"""
for key in dict2:
    print(f"dict2_key == {key}")
    print(f"dict2_value == {dict2[key]}")

"""
利用多重赋值的技巧，利用循环结构将键或值分别赋给不同的变量
"""

a = {'数学': 95, '语文': 89, '英语': 90}
for k in a.keys():
    print(k, end=' ')
print("\n---------------")
for v in a.values():
    print(v, end=' ')
print("\n---------------")
for k, v in a.items():
    print("key:", k, " value:", v)

# len
num = len(dict2)
print(num)
print("===================")

# example
info_dict = {
    "a": {"depart": "sci", "pay": 3000, "level": 1},
    "b": {"depart": "mark", "pay": 5000, "level": 2},
    "d": {"depart": "mark", "pay": 7000, "level": 3},
    "c": {"depart": "sci", "pay": 4000, "level": 1},
    "e": {"depart": "mark", "pay": 6000, "level": 2}
}
print(f"{info_dict}")
# 遍历
for name in info_dict:
    # if 条件判断
    if info_dict[name]["level"] == 1:  # "1" == 报错
        # 获取信息
        empl_info_dict = info_dict[name]
        print(f"{empl_info_dict}")

        empl_info_dict["level"] = 2  # == 失败
        empl_info_dict["pay"] += 1000

        # 返回值
        info_dict[name] = empl_info_dict

print(f"{info_dict}\n")
"""
小结
容纳多个不同类型元素
每一份数据都是键值对模式
key不可重复，通过key获取value
不支持下标
可以修改
支持for循环
"""

# lesson8: 总结
"""
支持索引？
    Y: list tuple str   == 序列类型
    N: set dict         == 非序列类型 

支持重复元素？
    Y: list tuple str   == 序列类型
    N: set dict         == 非序列类型

支持修改？
    Y: list set dict
    N: tuple str
"""

"""
数据容器  列表  元组  字符    集合  字典
元素数量  多个  多个  多个    多个  多个
元素类型  任意  任意  仅字符  任意   K:Y
下标索引  支持  支持  支持    不行  不行
重复元素  支持  支持  支持    不行  不行
可修改性  支持  不行  不行    支持  支持
数据有序  是的  是的  是的    没有  没有
"""

"""
数据容器的应用场景
list    一批数据 + 可修改 + 可重复
tuple   一批数据 + 不可修改 + 可重复
str     一串字符串
set     一批数据 + 可修改 + 不可重复
dict    一批数据 + Key:Value
"""

"""
通用操作
for     都支持
while   list + tuple + str ==> set + dict 没有下标索引，所以不支持
pycharm 垂直选择多行,alt+鼠标左键选择
len() + max() + min()
"""

list8 = [1, 2, 3, 4, 5]
tuple8 = (1, 2, 3, 4, 5)
str8 = "abcdefg"
set8 = {1, 2, 3, 4, 5}
dict8 = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
# len
print(f"list == len == {len(list8)} == {list8}")
print(f"tuple == len == {len(tuple8)} == {tuple8}")
print(f"str == len == {len(str8)} == {str8}")
print(f"set == len == {len(set8)} == {set8}")
print(f"dict == len == {len(dict8)} == {dict8}")

# max
# pycharm 垂直选择多行,alt+鼠标左键选择
print(f"list == max == {max(list8)} == {list8}")
print(f"tuple == max == {max(tuple8)} == {tuple8}")
print(f"str == max == {max(str8)} == {str8}")
print(f"set == max == {max(set8)} == {set8}")
print(f"dict == max == {max(dict8)} == {dict8}")
# min
print(f"list == min == {min(list8)} == {list8}")
print(f"tuple == min == {min(tuple8)} == {tuple8}")
print(f"str == min == {min(str8)} == {str8}")
print(f"set == min == {min(set8)} == {set8}")
print(f"dict == min == {min(dict8)} == {dict8}")

# 通用类型转换
# list()
print("\nlist()\n")
print(f"list =to= list == {list(list8)}")
print(f"tuple =to= list == {list(tuple8)}")
print(f"str =to= list == {list(str8)}")
print(f"set =to= list == {list(set8)}")
print(f"dict =to= list == {list(dict8)}")


# str()
print("\nstr()\n")
print(f"list =to= str == {str(list8)}")
print(f"tuple =to= str == {str(tuple8)}")
print(f"str =to= str == {str(str8)}")
print(f"set =to= str == {str(set8)}")
print(f"dict =to= str == {str(dict8)}")




# tuple()
print("\ntuple()\n")
print(f"list =to= tuple == {tuple(list8)}")
print(f"tuple =to= tuple == {tuple(tuple8)}")
print(f"str =to= tuple == {tuple(str8)}")
print(f"set =to= tuple == {tuple(set8)}")
print(f"dict =to= tuple == {tuple(dict8)}")



# set()
print("\nset()\n")
print(f"list =to= set == {set(list8)}")
print(f"tuple =to= set == {set(tuple8)}")
print(f"str =to= set == {set(str8)}")
print(f"set =to= set == {set(set8)}")
print(f"dict =to= set == {set(dict8)}")

# sorted()
list8 = [3,1,2,5,4]
tuple8 = (3,1,2,5,4)
str8 = "gacbefd"
set8 = {3,1,2,5,4}
dict8 = {"a": 1, "c": 2, "b": 3, "e": 4, "d": 5}

print(f"list = sort == {sorted(list8)}")
print(f"tuple = sort == {sorted(tuple8)}")
print(f"str = sort == {sorted(str8)}")
print(f"set = sort == {sorted(set8)}")
print(f"dict = sort == {sorted(dict8)}")

print("sorted + reverse")
print(f"list = sort == {sorted(list8, reverse=True)}")
print(f"tuple = sort == {sorted(tuple8, reverse=True)}")
print(f"str = sort == {sorted(str8, reverse=True)}")
print(f"set = sort == {sorted(set8, reverse=True)}")
print(f"dict = sort == {sorted(dict8, reverse=True)}")


# TypeError: ‘list’ object is not callable
# callable()是python的内置函数，用来检查对象是否可被调用，可被调用指的是对象能否使用()括号的方法调用，类似于iterable（）
# 在如上代码中，由于变量list和函数list重名了，所以函数在使用list函数时，发现list是一个定义好的列表，而列表是不能被调用的，因此抛出一个类型错误