python_notes数据容器

# 演示tuple元组的定义和操作
# 演示以数据容器的角色，学习字符串的操作

# 定义元组
t1 = (1,"hello",True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是：{t1}")
print(f"t1的类型是：{type(t2)},内容是：{t2}")
print(f"t1的类型是：{type(t3)},内容是：{t3}")

# 定义单个元素的元素
t4 = ("hello",)
print(f"t4的类型是：{type(t4)},t4的内容是：{t4}")
# 元组的嵌套
t5 = ((1,2,3),(4,5,6),(6,7,8))
print(f"t5的类型是：{type(t5)},内容是：{t5}")
# 元组的操作：index查找方法
num = t5[2][2]
print(f"从嵌套元素种去除的数据是：{num}")

# 元组的操作：count操作
t6 = ("船只教育","黑马程序员","黑马程序员","黑马程序员","黑马程序员","黑马")
count = t6.count("黑马程序员")
print(f"t6的元组种的黑的数量有:{count}")
# 元组的操作：len函数统计元素元素数量
t7 = ("船只教育","黑马程序员","黑马程序员","黑马程序员","黑马程序员","黑马")
num = len(t7)
print(f"t7中的元素有:{num}个")
# 元组的遍历：while
index = 0
while index < len(t7):
    print(f"元组的元素有:{t7[index]}")
    # 至关重要
    index += 1
# 元组的遍历:for
for element in t7:
    print(f"元组的内容是：{element}")

# 修改元组的内容
# 定义一个元组
t9 = (1,2,["itheima","itcast"])
print(f"t9的内容是：{t9}")
t9[2][0] = "黑马程序员"
t9[2][1] = "传智教育"
print(f"t9的内容是:{t9}")

---

"""
# 定义一个函数，接受另一个函数做为传入参数
def test_func(compute):
    result = compute(1,2) # 确定compute是函数
    print(f"compute参数的类型是:{type(compute)}")
    print(result)

#定义一个函数，准备作为参数传入另一个函数
def compute(x, y):
    return  x + y

# 调用，并传入函数
test_func(compute)
"""

# lambda函数简化了函数的参数传递
def test_func(compute):
    result = compute(1 ,2)
    print(f"结果是：{result}")

# 通过lambda 函数的形式，将函数做为参数传入
test_func(lambda x, y: x + y)
test_func(lambda x, y: x - y)

---

"""
演示数据容器字典的定义
"""

# 定义字典
my_dict1 = {"王力宏": 99, "周杰伦": 44, "林俊杰": 96}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是:{my_dict1}, 类型是{type(my_dict1)}")
print(f"字典1的内容是:{my_dict2}, 类型是{type(my_dict2)}")
print(f"字典1的内容是:{my_dict3}, 类型是{type(my_dict3)}")

# 定义重复key的字典
my_dict4 = {"王力宏": 99, "王力宏": 44, "林俊杰": 96}
print(f"重复key的字典内容是:{my_dict4}")
# 从字典中基于key获取value
my_dict1 = {"王力宏": 99, "周杰伦": 44, "林俊杰": 96}
score = my_dict1["王力宏"]
print(f"王力宏的分数是：{score}")
score = my_dict1["周杰伦"]
print(f"周杰伦的分数是：{score}")
# 字典嵌套字典
stu_score_dict ={
    "王力宏":{
        "语文": 77,
        "数学": 66,
        "英语": 88
    },"周杰伦":{
        "语文": 77,
        "数学": 45,
        "英语": 55
    },"林俊杰":{
        "语文": 77,
        "数学": 62,
        "英语": 82
    }
}
print(f"学生的考试信息是:{stu_score_dict}")
# 从嵌套字典中获取数据
score = stu_score_dict["周杰伦"]["语文"]
print(f"周杰伦的语文分数为:{score}")

---

"""
演示字典的常用操作
"""
my_dict = {"周杰伦": 99,"林俊杰": 99,"张学友": 99}
# 新增元素
my_dict["张兴哲"] = 99
print(f"字典经过新增元素后，结果是:{my_dict}")
# 更新元素
my_dict["张兴哲"] = 66
print(f"字典经过更新元素后，结果是:{my_dict}")
# 删除元素
score = my_dict.pop("张兴哲")
print(f"字典经过删除元素后，结果是:{my_dict}")
# 清空元素
# my_dict.clear()
# print(f"清楚元素的字典为:{my_dict}")
# 获取全部的key
keys = my_dict.keys()
print(f"字典中的所有key值是:{my_dict}")
# 遍历字典
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是:{my_dict[key]}")

# 方式2：直接对字典进行for循环
for key in my_dict:
    print(f"字典的key是:{key}")
    print(f"字典的value是:{my_dict[key]}")
# 统计字典内的元素数量
num = len(my_dict)
print(f"字典中的元素数量有:{num}")

---

"""
比较大小使用ASCII值进行比价
a = 97
A = 65
以此类推
"""

# abc 和 abd 进行比较
print(f"abd大于abc，结果:{'abd' > 'abc'}")
# a 和 ab 进行比较
print(f"a大于ab，结果:{'a' > 'ab'}")
# a 和 A 进行比较
print(f"a大于A，结果:{'a' > 'A'}")

# key1 和 key2 进行比较
print(f"key1大于key2，结果:{'key1' > 'key2'}")

---

# 演示以数据容器的角色，学习字符串的相关操作
my_str = "ithema and itcast"
# 通过下标索引取值
value = my_str[5]
value1 = my_str[-10]
print(f"从字符串{my_str}取下标为2的元素，值是{value},取下标为16的元素：值是{value1}")

# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是:{value}")

# replace方法
new_my_str = my_str.replace("it","程序")
print(f"将字符串{my_str}，进行替换后得到：{new_my_str}")

# split方法
my_str = "hello python ithema itcast"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到:{my_str_list},类型是：{type(my_str_list)}")

# strip方法
my_str = "  hello python ithema itcast  "
new_my_str = my_str.strip() # 不传入参数指的是取出首位的空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")

# 统计字符串中某字符串出现次数
my_str = "hello python ithema itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")

# 统计字符串的长度，len（）
num = len(my_str)
print(f"字符串{my_str}的长度是{num}")

---

# 数据定义  n
# 列表的下标索引
# 列表的常用操作
# 元素时数据容器中的每一份数据

# 列表的定义
# 列表中每一个数据，称之为元素，以[]为标识，列表中每一个元素之间用逗号隔开
name_list = ['itheima','itcast','python']  # 列表中可以存储各种各样的元素

name_list = [['itheima','itcast'],'python']  # 列表中可以嵌套
print(name_list)
print(type(name_list))
# 字面量

# 定义变量

# 定义空列表

---

"""
演示数据通用操作
"""

# 定义数据容器
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg "
my_set = { 1, 2, 3, 4, 5 }
my_dict = {"key1":1, "key2":2, "key3":3, "key4":4, "key5":5,}

# len 元素个数
print(f"列表 元素个数有: {len(my_list)}")
# max 最大元素
print(f"列表 元素最大数有: {max(my_list)}")
# min 最小元素
print(f"列表 元素最小数有: {min(my_list)}")
# 类型转换:容器转列表
print(f"列表 元素个数有: {list(my_list)}")
# 类型转换:容器转元组
print(f"列表 元素个数有: {tuple(my_list)}")
# 类型转换:容器转字符串
print(f"列表 元素个数有: {str(my_list)}")
# 类型转换:容器转集合
print(f"列表 元素个数有: {set(my_list)}")

# 不能转集合

# 进行容器排序
my_list = [1, 2, 3, 4, 5]
print(f"列表对象的排序结果:{sorted(my_list)}") # 正向排序
print(f"列表对象的排序结果:{sorted(my_list, reverse=True)}") # 反向排序

---

# 演示对是数列进行切片操作


# 对list进行切片，从1开始，4结束，步长为1
my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4]    # 默认步长是1 省略
print(f"结果1：{result1}")

# 对元组tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:]
print(f"结果2：{result2}")
# 对str进行切片，头开始，尾结束，步长为2
my_str = ("中国","日本","欧洲")
result3 = my_str[::2]
print(f"结果2：{result3}")
# 对str进行切片，头开始，尾结束，步长为-1
my_str = ("中国","日本","欧洲")
result3 = my_str[::-1]
print(f"结果2：{result3}")
# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0,1,2,3,4,5,6]
result4 = my_list[3:1:-1]
print(f"结果1：{result4}")
# 对列表进行切片，从头开始，到尾结束，步长-2
my_list = [0,1,2,3,4,5,6]
result5 = my_list[::-2]
print(f"结果1：{result5}")
# 对元组tuple进行切片，从头开始，到最后结束，步长-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2]
print(f"结果2：{result6}")

---

"""
演示数据容器集合的使用
"""

# 定义集合
my_set = {"传智教育","黑马程序员","ithema","传智教育","黑马程序员","ithema","传智教育","黑马程序员","ithema"}
my_set_empty = set()
print(f"my_setd的内容是：{my_set},类型是：{type(my_set)}")
print(f"my_setd_empty的内容是：{my_set_empty},类型是：{type(my_set_empty)}")

# 添加新元素
my_set.add("黑马程序员")
my_set.add("python")
print(f"my_set添加元素后，结果是{my_set}")
# 移除元素
my_set.remove("python")
print(f"my_set移除黑马程序员后，结果是{my_set}")

# 随机取出一个元素
element = my_set.pop()
print(f"取出的随机值是：{element}")
# 清空集合
my_set.clear()
print(f"my_set被清空结果是：{my_set}")

# 取2个集合的差值
set1 = {1,2,3}
set2 = {4,5,6}
set1.difference_update(set2)
print(f"清楚差集后，集合1结果是:{set1}")
print(f"清楚差集后，集合2结果是:{set2}")

# 2个集合合并为1个
set1 = {1,2,3}
set2 = {4,5,6}
set3 = set1.union(set2)
print(f"2集合并的结果:{set3}")
print(f"合并后集合1:{set1}")
print(f"合并后集合2:{set2}")
# 统计集合元素数量
set1 = {1,2,3,4,5,6,7,8}
num = len(set1)
print(f"{num}")
# 集合的遍历
for set in set1:
    print(f"{set}")