Python-Level1-day07：集合基础操作,容器小结,两层循环

0 作业与复习

"""
3. 在终端中获取颜色(RGBA),打印描述信息,否则提示颜色不存在
    "R" -> "红色"
    "G" -> "绿色"
    "B" -> "蓝色"
    "A" -> "透明度"
"""
dict01_color = {
    "R": "红色",
    "G": "绿色",
    "B": "蓝色",
    "A": "透明度"
}
key1 = input("please")
if key1 in dict01_color:
    print(dict01_color[key1])
else:
    print("no")
​

"""
4. 将列表中的数字累减
    list02 = [5, 1, 4, 6, 7, 4, 6, 8, 5]
    提示：初始为第一个元素
"""
list02 = [5, 1, 4, 6, 7, 4, 6, 8, 5]
sum1 = list02[0]
for i in range(1, len(list02)):
    sum -= list02[i]
print(sum1)
​

"""
5. 将列表中整数的十位不是3和7和8的数字存入另外一个列表
   list03 = [135, 63, 227, 675, 470, 733, 3127]
   提示：将数字转换为字符串进行处理,通过索引获取十位
"""
list03 = [135, 63, 227, 675, 470, 733, 3127]
list01 = []
for item in list03:
    if str(item)[-2] in ("3", "7", "8"):
        continue
    list01.append(item)
print(list01)
​
result = [item for item in list03
          if str(item)[-2] not in ("3", "7", "8")]
print(result)
​

"""
 6. 在数字列表中查找最大的数字(不许用内置函数)
    算法：
        [170  ,  160  ,  180  ,  165]
    假设第一个就是最大值
    使用假设的和第二个进行比较, 发现更大的就替换假设的
    使用假设的和第三个进行比较, 发现更大的就替换假设的
    使用假设的和第四个进行比较, 发现更大的就替换假设的
    最后，假设的就是最大的.
"""
list01 = [170, 160, 180, 165]
max_value = list01[0]
for i in range(1, len(list01)):
    if max_value < list01[i]:
        max_value = list01[i]
print(max_value)

---

1 集合基础操作

集合 set定义：由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。相当于只有键没有值的字典(键则是集合的数据)。

基础操作

1. 创建空集合：

集合名 = set()；集合名 = set(可迭代对象)

1. 创建具有默认值集合：

集合名 = {1, 2, 3}；集合名 = set(可迭代对象)

1. 添加元素：集合名.add(元素)

1. 删除元素：集合名.discard(元素)

运算

1. 交集&：返回共同元素。

s1 = {1, 2, 3}；s2 = {2, 3, 4}；s3 = s1 & s2 # {2, 3}

1. 并集：返回不重复元素

s1 = {1, 2, 3}；s2 = {2, 3, 4}；s3 = s1 | s2 # {1, 2, 3, 4}

1. 补集-：返回只属于其中之一的元素

s1 = {1, 2, 3}；s2 = {2, 3, 4}；s1 - s2 # {1} 属于 s1 但不属于 s2补集^：返回不同的的元素

s1 = {1, 2, 3}；s2 = {2, 3, 4}；s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)

1. 子集<：判断一个集合的所有元素是否完全在另一个集合中

1. 超集>：判断一个集合是否具有另一个集合的所有元素

s1 = {1, 2, 3}；s2 = {2, 3}；s2 < s1 # True；s1 > s2 # True

1. 相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。

s1 = {1, 2, 3}；s2 = {3, 2, 1}；s1 == s2 # True；s1 != s2 # False

子集或相同,超集或相同 <= >=

"""
    集合set :可变散列且唯一的不可变变量(即不能扩内存变量)组成
     补充：对于列表与元组 优点考虑元组。
     字典没有改键功能，只能删除再添加
"""
# 1.创建
set01 = {1, "a", 3.5, True, None}
set02 = set("abc")  # set(可迭代对象)
print(set01)
print(set02)  # {'a', 'c', 'b'}
print(set([1, 2, 5, 3, 4, 5, 7, 2, 1]))  # 集合应用1：集合去重复功能
# set04 = {(1,2,3),"123",[1,2,3]} 报错：不予许可变变量元素
​
# 2添加元素add:根据哈希运算随机位置添加
set01.add("ddd")
set01.add("fff")
print(set01)
​
# 3 定位：无 只有遍历
for item in set01:
    print(item)
​
# 4 删除 remove discard
set01.remove("ddd")  # 如果键不存在报错
set01.discard("ddd")  # 如果键不存在也不报错
​

"""
    集合：
        应用1：去重复
        应用2：交并补
"""
set01 = {1, 2, 3}
set02 = {2, 3, 4}
​
print(set01 & set02)
​
print(set01 | set02)
​
print(set01 - set02)  # 补 1
print(set02 - set01)  # 补  4
print(set02 ^ set01) # 补1 4
​

"""
练习：一家公司有如下岗位：
 "经理"："曹操","刘备","孙权"
 "技术" ："曹操","刘备","张飞","关羽"
​
1. 定义数据结构,存储以上信息.
2. 是经理也是技术的都有谁?
3. 是经理不是技术的都有谁?
4. 不是经理是技术的都有谁?
5. 身兼一职的都有谁?
6. 公司总共有多少人数?
"""
#集合运算的结果仍是集合
​
dict01 = {
    "经理": {"曹操", "刘备", "孙权"},
    "技术": {"曹操", "刘备", "张飞", "关羽"}
}
print(dict01["经理"] & dict01["技术"])
print(dict01["经理"] - dict01["技术"])
print(dict01["技术"] - dict01["经理"])
print(dict01["经理"] ^ dict01["技术"])
print(len(dict01["经理"] | dict01["技术"]))
​

集合推导式

1. 定义：使用简易方法，将可迭代对象转换为集合。

1. 语法:{表达式 for 变量 in 可迭代对象} ；{表达式 for 变量 in 可迭代对象 if 条件}

2 容器小结

"""
小结 容器：
​
     1.种类与特点：
       字符串-存储：字符编码   可变（内存）：不可变    序列：序列
       列表 - 存储：变量      可变（内存）：可变      序列：序列
       元组 - 存储：变量(可以放内存可变元素)   可变 （内存）:不可变    序列：序列
       字典 - 存储：键值对（建唯一不可变（数字，字符串，元组等内存不可变的放建），值可变）  可变（内存） ：可变
       集合 - 存储：建(放内存不可变元素)   可变（内存）：可变   散列
​
    2.可变：内存预留空间，但效率低
      不可变：按需分配，效率高
​
    3.序列：有顺序，定位灵活，有索引和切片
      散列：没有顺序，节省内存，无索引，定位单个元素最高
"""
"""
列表字典最频繁用
1.创建
2.添加
3,定位
4.遍历
5.删除
"""
dict01 = {
    "a": 1,
    "b": 20,
    "c": 3
}
del dict01["a"]  # 字典删除
dict01["d"] = 4  # 字典添加
# key; value; value key;字典三种遍历方法
​
# 不支持遍历时候删除字典记录，其他容器也一样
# for key, value in dict01.items():
#     if value == 20:
#         del dict01[key]
​
# 思想：存到其他容器，进行本容器的删除
# 方法：遍历列表删除字典，字典通过list将所有键存储到列表
list01 = list(dict01)
for key in list01:
    if dict01[key] == 20:
        del dict01[key]
print(dict01)
​

3 二层循环

"""
    for for
"""
for i in range(5):
    for j in range(5):
        print("*", end=" ")  # 以空格结束而不是换行
    print()  # 换行
​
for i in range(4):
    for j in range(4):
        if i % 2 == 0:
            print("*", end=" ")
        else:
            print("#", end=" ")
    print()
​

"""
打印图形
*
* *
* * *
* * * * 
"""
for i in range(4):
    for j in range(i + 1):
        print("*", end=" ")
    print()
​

"""
练习 3：多个人的多个爱好
dict_hobbies = { "于谦": ["抽烟", "喝酒", "烫头"], "郭德纲":
                ["说", "学", "逗", "唱"], }
    1. 打印于谦的所有爱好(一行一个) 效果：抽烟喝酒烫头
    2. 计算郭德纲所有爱好数量 效果：4
    3. 打印所有人(一行一个) 效果：于谦郭德纲
    4. 打印所有爱好(一行一个) 抽烟喝酒烫头说学逗唱
"""
ict_hobbies = {
    "于谦": ["抽烟", "喝酒", "烫头"],
    "郭德纲": ["说", "学", "逗", "唱"],
}
​
for item in ict_hobbies["于谦"]:
    print(item)
​
print(len(ict_hobbies["郭德纲"]))
​
for key in ict_hobbies:
    print(key)
​
for value in ict_hobbies.values():
    for value1 in value:
        print(value1)
​

"""
练习 4：dict_travel_info = { "北京": { "景区": ["长城", "故宫"],
"美食": ["烤鸭", "豆汁焦圈", "炸酱面"] },
"四川": { "景区": ["九寨沟", "峨眉山"],
"美食": ["火锅", "兔头"] } }
​
     1. 打印北京的第一个景区 效果：长城 打印四川的第二个美食 效果：兔头
     2. 所有城市 (一行一个) 效果：北京四川
     3. 北京所有美食(一行一个) 效果：烤鸭豆汁焦圈 炸酱面
     4. 打印所有城市的所有美食(一行一个) 效果：烤鸭豆汁焦圈 炸酱面 火锅兔头
"""
dict_travel_info = {
    "北京": {
        "景区": ["长城", "故宫"],
        "美食": ["烤鸭", "豆汁焦圈", "炸酱面"]
    },
    "四川": {
        "景区": ["九寨沟", "峨眉山"],
        "美食": ["火锅", "兔头"]}
}
​
print(dict_travel_info["北京"]["景区"][0])
​
for item in dict_travel_info["北京"]["景区"]:
    print(item)
    
for item in dict_travel_info:
    print(item)
    
for item in dict_travel_info["北京"]["美食"]:
    print(item)
​
for value in dict_travel_info.values():
    for item in value["美食"]:
        print(item)
​

​
""" 
    排序算法：其中一个经典排序算法
"""
list01 = [2, 3, 2, 5, 6, 4, 9, 7, 1]
for i in range(len(list01) - 1):
    for j in range(i + 1, len(list01)):
        if list01[i] > list01[j]:
            list01[i], list01[j] = list01[j], list01[i]
print(list01)

"""
练习 6：商品字典 dict_commodity_infos = {
1001: {"name": "屠龙刀", "price": 10000},
1002: {"name": "倚天剑", "price": 10000},
1003: {"name": "金箍棒", "price": 52100},
1004: {"name": "口罩", "price": 20},
1005: {"name": "酒精", "price": 30}, }
​
# 订单列表 list_orders = [    {"cid": 1001, "count": 1},
                            {"cid": 1002, "count": 3},
                            {"cid": 1005, "count": 2}, ]
​
"""
dict_commodity_infos = {
    1001: {"name": "屠龙刀", "price": 10000},
    1002: {"name": "倚天剑", "price": 10000},
    1003: {"name": "金箍棒", "price": 52100},
    1004: {"name": "口罩", "price": 20},
    1005: {"name": "酒精", "price": 30},
}
​
list_orders = [
    {"cid": 1001, "count": 1},
    {"cid": 1002, "count": 3},
    {"cid": 1005, "count": 2},
]
​
# f格式打印需要在引用建的时候用单引号,解决引号嵌套问题
# 1.打印所有商品信息, 式：商品编号 xx,商品名称 xx,商品单价 xx.
for key in dict_commodity_infos:
    print("商品编号 :%s  商品名称 :%s  商品单价:%s" % (
        key, dict_commodity_infos[key]["name"],
        dict_commodity_infos[key]["price"]))
​
# 2. 打印所有订单中的信息, 格式：商品编号 xx,购买数量 xx.
for item in list_orders:
    print("商品编号 : %s  购买数量: %s" % (item["cid"], item["count"]))
​
# 3. 打印所有订单中的商品信息, 格式：商品名称 xx,商品单价:xx,数量 xx.
for key in dict_commodity_infos:
    for item in list_orders:
        if item["cid"] == key:
            print(f"商品名称 {dict_commodity_infos[key]['name']},"
                  f"商品单价:{dict_commodity_infos[key]['price']},"
                  f"数量 {item['count']}.")
​
for item in list_orders:
    print(f"商品名称 {dict_commodity_infos[item['cid']]['name']},"
          f"商品单价:{dict_commodity_infos[item['cid']]['price']},"
          f"数量 {item['count']}")
​
# 4. 查找数量最多的订单(使用自定义算法,不使用内置函数)
max_order = list_orders[0]
for item in list_orders:
    if item["count"] > max_order["count"]:
        max_order = item
print(max_order)
​
# 5. 根据购买数量对订单列表降序(大->小)排列
for i in range(len(list_orders) - 1):
    for j in range(i + 1, len(list_orders)):
        if list_orders[i]["count"] < list_orders[j]["count"]:
            list_orders[i], list_orders[j] = list_orders[j], list_orders[i]
print(list_orders)
​

作业

作业
1. 三合一
2. 当天练习独立完成
3. 容器综合训练
# 员工字典(员工编号 部门编号 姓名 工资)
dict_employees = {
    1001: {"did": 9002, "name": "师父", "money": 60000},
    1002: {"did": 9001, "name": "孙悟空", "money": 50000},
    1003: {"did": 9002, "name": "猪八戒", "money": 20000},
    1004: {"did": 9001, "name": "沙僧", "money": 30000},
    1005: {"did": 9001, "name": "小白龙", "money": 15000},
}
# 部门列表
list_departments = [
    {"did": 9001, "title": "教学部"},
    {"did": 9002, "title": "销售部"},
    {"did": 9003, "title": "品保部"},
]
# 1. 打印所有员工信息,
# 格式：xx的员工编号是xx,部门编号是xx,月薪xx元.
# 2. 打印所有月薪大于2w的员工信息,
# 格式：xx的员工编号是xx,部门编号是xx,月薪xx元.
# 3. 在部门列表中查找编号最小的部门
# 4. 根据部门编号对部门列表降序排列
​
​