Python系统学习1-7-字典_num = random.randint(1,33)-CSDN博客

列表：由一系列变量组成的可变序列容器
字典：由一系列键值对组成的可变散列容器
字典优势：利用（内存）空间，换取（CPU查找）时间
键key 必须唯一且为不可变数据（字符串，数字，元组），若相同，第二个相同的key覆盖第一个（通过不可变保证唯一性）
值value 没有限制

2、基本操作

(1)创建

# 列表善于存储单一纬度数据
list_name = ["丽丽","红红","嘿嘿"]
list_age = [20, 54, 56]
list_sex = ["女", "男", "女"]

# 字典善于存储多个维度数据
# 创建方法1：字典名 = {键1：值1，键2：值2}

dict_ll = {"name":"丽丽", "age":"20", "sex":"女"}
dict_hh= {"name":"红红", "age":"54", "sex":"男"}
dict_hs = {"name":"嘿嘿", "age":"56", "sex":"女"}

创建方法2：字典名 = dict (容器)

# 需要保质容器的每个元素必须能一分为二

list_name = ["丽丽","红红","嘿嘿"]

print(dict(list_name))

（2）添加

添加,其实就是修改（如果key在，就是修改，如果key不在，就是添加）

添加方法：字典名[键] = 值

dict_ll = {"name":"丽丽", "age":"20", "sex":"女"}

dict_ll["money"] = 10000

# 定位快，修改

dict_ll["age"] = 26

# 读取，先判断，再读取 print(dict_ll["age"])

注意：dict中根据key找value，直接定位，字典名[键]

根据value找key，则需要一一遍历

（3）删除

del 字典名[键1],字典名[键2] 删除后键值对同步消失

（4）遍历

dict_ll = {"name":"丽丽", "age":"20", "sex":"女"}
# 所有key
for key in dict_ll:
    print(key)
'''
name
age
sex
'''
# 所有key
for key in dict_ll.keys():
    print(key)
'''
name
age
sex
'''

# 所有value
for value in dict_ll.values():
    print(value)
'''
丽丽
20
女
'''
# 所有键和值
for item in dict_ll.items():
    print(item)
'''
('name', '丽丽')
('age', '20')
('sex', '女')
'''
# 等价于
for key,value in dict_ll.items():  # 上述的拆包
    print(key,value)
'''
name 丽丽
age 20
sex 女
'''
# 默认打印只有key值
print(dict_ll) #['name', 'age', 'sex']
print(dict_LL.items())

3、列表list和字典dict互相转换

dict_ll = {"name":"丽丽", "age":"20", "sex":"女"}
# dict转list
print(list(dict_ll.items()))
# [('name', '丽丽'), ('age', '20'), ('sex', '女')]
# list转dict
print(dict([('name', '丽丽'), ('age', '20'), ('sex', '女')]))
# {'name': '丽丽', 'age': '20', 'sex': '女'

4、练习

# 疫情信息
list_epidemic = [
    {
        "region": "台湾", "new": 16,
        "now": 2339, "total": 16931,
    },
    {
        "region": "陕西", "new": 182,
        "now": 859, "total": 1573,
    },
    {
        "region": "浙江", "new": 2,
        "now": 505, "total": 2008,
    },
]
# --打印所有疫情信息
for i in range(len(list_epidemic)):
    print(list_epidemic[i]["region"])
    print(list_epidemic[i]["new"])

# 优化
for item in list_epidemic:
    print(item["region"])
    print(item["new"])

# --查找新增人数大于10的地区名称(将结果存入新列表)
new_list = []
for i in range(len(list_epidemic)):
    if list_epidemic[i]["new"]>10:
        new_list.append(list_epidemic[i]["region"])
print(new_list)

# 优化
new_list = []
for item in list_epidemic:
    if item["new"] > 10:
        new_list.append(item["new"])
# --查找现有人数最大的地区信息(结果为字典)
max = list_epidemic[0]["now"]
flag = 0
for i in range(0,len(list_epidemic)):
    if max <= list_epidemic[i]["now"]:
        max = list_epidemic[i]["now"]
        flag = i
print(list_epidemic[flag])
list_epidemic = [
    {
        "region": "台湾", "new": 16,
        "now": 2339, "total": 16931,
    },
    {
        "region": "陕西", "new": 182,
        "now": 859, "total": 1573,
    },
    {
        "region": "浙江", "new": 2,
        "now": 505, "total": 2008,
    },
]
# --根据现有人数对疫情信息降序(大->小)排列
for i in range(len(list_epidemic)):
    for j in range(i+1,len(list_epidemic)):
        if list_epidemic[i]["now"] < list_epidemic[j]["now"]:
            list_epidemic[i],list_epidemic[j]=list_epidemic[j],list_epidemic[i]

二、容器小结

1、种类与特征

字符串：存储字符编码(a-97)，不可变，序列

列表list：存储变量(地址)，可变，序列

元组tuple：存储变量(地址)，不可变，序列

字典dict：存储键值对，可变，散列

# 字典想拿到第一个键值对  转换为列表/元组
dict_ll = {"name":"丽丽", "age":"20", "sex":"女"}
list_key = list(dict_ll())  # 拿到的只有键
print(list_key)
key = list_key[0]
value = dict_ll[key]

list_item = list(dict_ll.items())
print(list_item[0])

# 转成元组更好，省内存
tuple_item = tuple(dict_ll.items())
print(tuple_item[0])

2、Python语言有哪些数据类型

        可变类型：预留空间+自动扩容
            如：列表list,字典dict
            优点：操作数据方便（能够增删改）
            缺点：占用内存太大
不可变类型：按需分配
            如：int,float,bool,str,tuple
            优点：占用内存小
            缺点：不能适应现实的变化

3、序列与散列

序列：支持索引切片，定位数据灵活
散列：通过键定位数据，速度最快

4、语法

列表字典
   创建
        列表名=[数据1，数据2] 字典名={键1:值1,键2:值2}
        列表名=list(容器) 字典名=dict(容器)
   添加
        列表名.append(元素) 字典名[键]=值不可变数据才可以当键
        列表名.insert(索引,元素)
   定位
        列表名[整数] 字典名[键]
        列表名[开始:结束:间隔]
   删除
         del 列表名[索引或切片] del 字典名[键] ,键值都删除
                 注意索引越界
         列表名.remove(数据)
                 注意数据必须存在于列表中
   遍历
        for item in 列表名: for key in 字典：
        for i range(len(列表名)): for value in 字典.values()：
for k,v in 字典.items()：

三、练习1

# 2. 在终端中获取颜色(RGBA),打印描述信息,
#     否则提示颜色不存在
#     "R" -> "红色"
#     "G" -> "绿色"
#     "B" -> "蓝色"
#     "A" -> "透明度"
dict_rgb = {"R":"红色", "G":"绿色", "B":"蓝色", "A":"透明度"}
input_rgb = input("请输入颜色：")
if input_rgb in dict_rgb:
        print(dict_rgb[input_rgb])
else:
    print("不存在")

# 3. 将列表中的数字累减
list02 = [5, 1, 4, 6, 7, 4, 6, 8, 5]
sum_last = list02[0]
for i in range(1, len(list02)):
    sum_last -= list02[i]
print(sum_last)

# 4. 在列表中查找最大值(不使用max,自定义算法实现)
#     思路:
#         假设第一个元素就是最大值
#         依次与后面元素进行比较
# #         如果发现更大值,则替换
list02 = [5, 1, 4, 6, 7, 4, 6, 8, 5]
max = list02[0]
for item in list02:
    if max < item:
        max = item
print(max)



# 5. （选做）彩票：双色球
#     红色：6个  1--33之间的整数   不能重复
#     蓝色：1个  1--16之间的整数
#     1) 随机产生一注彩票(列表(前六个是红色，最后一个蓝色))
#     2) 在终端中录入一支彩票
#     要求：满足彩票的规则.
import random
list_lottery = []
for i in range(6):
    num = random.randint(1,33)
    while num in list_lottery:
        num = random.randint(1, 33)
        list_lottery.append(num)
list_lottery.append(random.randint(1,16))

# 优化
import random
list_lottery = []
while len(list_lottery) < 6:
    num = random.randint(1, 33)
    if num not in list_lottery:
        list_lottery.append(num)
list_lottery.append(random.randint(1,16))

# 2) 在终端中录入一支彩票
#     要求：满足彩票的规则.
list_lottery = []
i = 1
while i <= 6:
    num = int(input(f"请录入红色第{i}注彩票："))
    if 1 < num < 33:
        if num not in list_lottery:
            list_lottery.append(num)
            i += 1
        else:
            print("不能重复，请重新输入")
    else:
        print("您输入的数字超出范围1-33，请重新输入")

while True:
    num2 = int(input(f"请录入蓝色第{i}注彩票："))
    if 1 < num2 < 6:
        list_lottery.append(num2)
        break
    else:
        print("您输入的数字超出范围1-6，请重新输入")
print(f"下注为{list_lottery}")