08-集合&字典

集合的特点：

1. 无序性：每个元素是无序的，没有下标
2. 互异性：没有重复元素
3. 确定性：任何元素，只有属于或不属于该集合这两种情况

创建集合

set1 = {1, 1, 2, 3}
print(set1)  # {1, 2, 3}
set2 = set()  # 创建空集合必须用这种方式，否则是字典

集合元素的遍历

注意：无法用下标取值

for elem in set1:
    print(elem)

集合的运算

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 判断集合是否含有某元素
print(1 in set1)
print(2 not in set1)

# 交集
print(set1 & set2)
print(set1.intersection(set2))

# 并集
print(set1 | set2)
print(set1.union(set2))

# 差集
print(set1 - set2)
print(set1.difference(set2))

# 对称差:去掉相同的元素，然后取并集
print(set1 ^ set2)
print(set1.symmetric_difference(set2))

# 判断子集
print(set1 < set2)
print(set1.issubset(set2))

集合的存储特点

💡 列表、元组和字符串存储方式是顺序存储，优点是可以指哪打哪，取指定元素。但是查找某个元素是否在其中，效率及其低下

• 集合的数据存储是哈希存储，计算哈希值然后决定存储位置。因此判断某元素是否在集合里，效率非常高。因为只需要再计算一次哈希值，去内存对应位置寻找即可。
• 无法计算哈希码的对象，无法放到集合中。所以列表、集合、字典都无法放入集合中。

集合元素的操作

set1 = {"apple", "cherry", "banana"}
set1.add("grape")  # 添加的元素，不按顺序摆放
print(set1)
set1.discard("bababa")  # 删除指定元素
set1.pop()  # 删除的元素是随机的
set1.clear()  # 清空集合

集合的应用：列表去重

nums = [1, 2, 1, 2, 3]
set2 = set(nums)
list2 = list(set2)
print(list2)

💡 注意，这样操作列表的元素顺序可能发生改变

字典dict的定义

用来存储对象的多个属性，相当于其他编程语言中的object

student ={
    "name": "Yuki",
    "age": 13,
    "sex": True,
    "courses": ["英语", "数学", "语文"],
    "contacts": {
        "QQ": "376803165",
        "tel": "123456"
    }
}
print(student["name"])
print(student["courses"])
print(student["contacts"]["tel"])

#  第二种构造方式
student2 = dict(id=1002, name="Johnny")
print(student2)

# 第三种构造字典的方式
dict1 = {i: i ** 2 for i in range(1, 10)}
print(type(dict1))
print(dict1)

💡 注意，以下构造方式会生成一个生成器

gen_obj = (i for i in range(10))
print(type(gen_obj))  # <class 'generator'>

字典的遍历

for key in student:  # 遍历键，和student.keys()效果一样
    print(key, student[key])
for value in student.values():  # 遍历值
    print(value)
for key, value in student.items():  # 遍历键和值
    print(key, value)

字典的成员运算

赋值：

student = dict(name="Yuki", age=13, sex=True, courses=["英语", "数学", "语文"],
               contacts={
        "QQ": "376803165",
        "tel": "123456"
    })
student["name"] = "yuki zhong"
student["address"] = "四川成都"
# 注意：用dict()创建的字典可以赋值，否则会报一个警告This dictionary creation could be rewritten as a dictionary literal

判断是否含有某个属性：

print("name" in student)

💡 如果某个键不存在，取到他就会报错。所以事先判断某个属性是否存在很重要

获取某个属性的值：

用get方法可以避免报错，取不到的时候会返回none。也可以设定一个默认值

print(student.get("age"))
print(student.get("grade", 6))  # 如果没有grade属性，那么默认是6年级

删除某个属性：

del student["age"]
student.pop("age")  # pop方法会返回删除属性的值
studen.popitem()  # 删除最后一个属性

合并两个字典，update

dic1 = {"A": 100, "B": 200}
dic2 = {"C": 300, "D": 400, "A": 111}
# 如果有相同键值，则更新他的值；如没有，则增加键
dic1.update(dic2)
print(dic1)

设定默认值：如果该键不存在，加入新的键和默认值；如果存在，返回该键的值。

dic1.setdefault("F", 200)

例子1：输入一段话，统计每个英文字母出现的次数

sentence = input("请输入一段句子：")
counter = {}
for item in sentence:
    if "A" <= item <= "Z" or "a" <= item <= "z":
        counter[item] = counter.get(item, 0) + 1
for key, value in counter.items():
    print(f"{key}出现了{value}次")

例子2：统计每个单词出现次数

sentence = input("请输入一段句子：")
counter = {}
sentence = sentence.lower()
table = str.maketrans(",.", "  ")
sentence = sentence.translate(table)
words = sentence.split()
for word in words:
    counter[word] = counter.get(word, 0) + 1
print(counter)

优化：用replace来替换标点符号

sentence = input("请输入一段句子：")
counter = {}
words = sentence.lower().replace(",", "").replace(".", "").split()
for word in words:
    counter[word] = counter.get(word, 0) + 1

sorted_words = sorted(counter, key=counter.get, reverse=True)
# 按照键值排序，出来的结果是一个列表，里面只有键
for key in sorted_words:
    print(f"{key}:{counter[key]}次")

例子3：字典中保存了股票信息

1. 找出股票价格大于100元的，并创建新字典
2. 找出价格最高和价格最低的股票的股票代码
3. 按照股价从高到低给股票代码排序

stocks = {
    "bilibili": 101.2,
    "sina": 99.6,
    "baidu": 50.5,
    "bate_dance": 200.3,
    "tencent": 150.9
}

good_stocks = {}
max_stock, min_stock = "baidu", "baidu"
for key, value in stocks.items():
    if value > 100:
        good_stocks.update({key: value})
    if value > stocks[max_stock]:
        max_stock = key
    if value < stocks[min_stock]:
        min_stock = key
print(good_stocks)
print(f"股价最高的是：{max_stock}，股价最低的是：{min_stock}")

优化：

good_stocks = {key: value for key, value in stocks.items() if value > 100}
min_stock = min(zip(stocks.values(), stocks.keys()))[1]
max_stock = max(zip(stocks.values(), stocks.keys()))[1]

优化：设定max(),min(),sorted()的规则

min_stock = min(stocks, key=stocks.get)
max_stock = max(stocks, key=stocks.get)
print(sorted(stocks, key=stocks.get, reverse=True))

💡 字典没有sort函数，可以使用sorted函数

例子4：将字典的键和值翻转

zip函数进行打包

dict1 = {"a": 1, "b": 2, "c": 3, "d": 4}
dict2 = dict(zip(dict1.values(), dict1.keys()))
print(dict1)
print(dict2)

JSON数据类型介绍

1. 两个异构的系统之间交换数据最好是纯文本格式
2. 纯文本应该是结构化或半结构化的，即，有一定的格式

• XML - 可扩展标记语言
• JSON - Javascript Object Notation
• YAML - Tet Anither Markup Language

将JSON转为字典

Python中的JSON模块中的loads方法可以降JSON转为字典

import json
data = """
    {
  "code": 200,
  "msg": "success",
  "result": {
    "list": [
      {
        "name": "何彼襛矣",
        "content": "何彼禯矣，唐棣之华。曷不肃雍，王姬之车。何彼禯矣，华如桃李。平王之孙，齐侯之子。其钓维何？维丝伊缗。齐侯之子，平王之孙。",
        "note": "襛：花木繁盛貌。唐棣：木名，似白杨，又作棠棣、常棣，一说指车帷。曷：何。肃：庄严肃静。雍：雍容安详。王姬：周王的女儿，姬姓，故称王姬；一说为美女的代称。平王、齐侯：指谁无定说，或谓非实指，乃夸美之词。",
        "author": "国风·召南"
      }
    ]
  }
}
"""
songs = json.loads(data)
print(songs["result"]["list"])

例子5:联网获取JSON数据，并解析出需要的内容

三方库：requests→pip install requests

import requests
data = requests.get(
    url="https://apis.tianapi.com/shijing/index",
    params={
        "key": "7f02f47b0c1cb709984ea9eb2814c23f",
        "num": 5
    }
)
songs_dict = data.json()
songs_list = songs_dict["result"]["list"]
for song in songs_list:
    print(song)

题目1：赌博游戏

玩家摇两个骰子，如果第一次摇出7或者11，玩家胜利；2 3 12 庄家胜利；否则游戏继续。

如果玩家摇出的点数和第一次相同，玩家胜利；7点，庄家胜利；否则游戏继续。

玩家重新摇骰子，直到分出胜负。

玩家有1000元的初始资金，玩家可以选择下注金额。赢取下注金额或者输掉下注金额。

结束条件是玩家把钱输光。

import random
money = 1000
while money > 0:
    print(f"当前玩家手中还有：{money}元")
    turn, is_end = 1, False
    bet_money = int(input("请输入投注金额:"))
    dice_result = random.randrange(1, 7) + random.randrange(1, 7)
    print(f"第{turn}次投掷，玩家掷出了{dice_result}点")
    if dice_result in (7, 11):
        money += bet_money
        print(f"玩家掷出了{dice_result}点，玩家胜利，金钱加{bet_money}")
    elif dice_result in (2, 3, 12):
        money -= bet_money
        print(f"玩家掷出了{dice_result}点，庄家胜利，金钱减{bet_money}")
    else:
        while not is_end:
            dice_result2 = random.randrange(1, 7) + random.randrange(1, 7)
            turn += 1
            print(f"第{turn}次投掷，玩家掷出了{dice_result2}点")
            if dice_result2 == dice_result:
                money += bet_money
                print(f"玩家第二次掷出了{dice_result}点，和第一次相同，玩家胜利，金钱加{bet_money}")
                is_end = True
            elif dice_result2 == 7:
                money -= bet_money
                is_end = True
                print(f"玩家掷出了{dice_result2}点，庄家胜利，金钱减{bet_money}")

题目2：双色球（模拟机选N注）

红色球01-33，选择不重复的6个球，按从小到大排列

蓝色球01-16，选择一个球，跟在红色球后面

import random
red_balls = [i for i in range(1, 34)]
blue_balls = [i for i in range(1, 17)]
tickets = int(input("请输入你要下几注:"))
lotteries = []
for i in range(0, tickets):
    lottery = random.sample(red_balls, 6)
    lottery.sort()
    lottery.append(random.choice(blue_balls))
    lotteries.append(lottery)
print(lotteries)