python基础-数据类型（none、集合、字典、浮点数）

1. 了解 hash

哈希的原则是通过一一对应的 key 与 value(数字)实现对key的快速访问

通过 hash 函数产生唯一的value(数字) 与 key 对应，如果 key 改变了，value也应该改变，但是可变的数据类型，比如列表：改变后列表地址是不变的，不同的key 指向了相同的 value(数字)  这样就发生了冲突
自然不希望出现冲突的情况，在哈希表中这种情况叫做碰撞，碰撞是难免的，我们只能想办法减少碰撞的发生

• python中可哈希的数据类型，即不可变的数据结构：数值类型（int，float，bool）、字符串str、元组tuple、自定义类的对象
  不可变的数据结构，一旦建立，是不允许修改的，比如添加、删除等

例:
v1 = 1
v2 = "abc"
v1 = "b"       # 实际是创建了两块内存,并没有修改原来的数据结构,也无法修改
v2 = "def"     # 实际是创建了两块内存,并没有修改原来的数据结构,也无法修改

v3 = ('a',[1,2])
v3[1][0] = 3   # ('a',[3,2]) # 元组的元素不可被修改，但元组的列表元素的元素可以被修改

• 不可哈希的数据类型，即可变的数据结构 ：字典dict(键可哈希,值不可哈希可变)，列表list，集合set

# 例:
msg_list = ["a",[3,2]]
msg_list.append("e")      # ['a', [3, 2], 'e'] 修改了内部的数据结构,列表的元素
msg_list[1] = (3,2)       # ['a', (3, 2), 'e'] 修改了列表的元素的元素

msg_set = {"a",(1,2)}
msg_set.add("b")          # {(1, 2), 'a', 'b'}  修改了内部的数据结构,集合的元素

2. None类型

• python的数据类型中有一个特殊的值None，意味这个值什么都没有或表示空。和其它语言中的 null 作用一样。
• 在一定程度上可以帮我们节省内存，例如：

v1 = None
v2 = None
...
v1 = [11,22,33,44]
v2 = [111,22,123]

• 目前能转换为False的值有：

0  
""      
[]、list()
()、tuple() 
set() 
{}、dict()
None

3. 集合 (set)

• 集合是一个无序、可变、不允许数据重复的容器
• 集合的元素必须可哈希
• 集合不支持取值，需要转换为其他数据类型，例如列表
• 一般用于维护不重复的数据，比如：做爬虫去网上找链接，为了避免链接重复，可以通过集合去存储链接地址
  | 方法 | 功能 |
  | --- | --- |
  | add() | 为集合添加元素 |
  | clear() | 移除集合中的所有元素 |
  | copy() | 拷贝一个集合 |
  | difference() | 返回多个集合的差集 |
  | difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
  | discard() | 删除集合中指定的元素 |
  | intersection() | 返回集合的交集 |
  | intersection_update() | 返回集合的交集。 |
  | isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
  | issubset() | 判断指定集合是否为该方法参数集合的子集。 |
  | issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
  | pop() | 随机移除元素 |
  | remove() | 移除指定元素 |
  | symmetric_difference() | 返回两个集合中不重复的元素集合。 |
  | symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
  | union() | 返回两个集合的并集 |
  | update() | 给集合添加元素 |

3.1 定义

v1 = {11,22,33,"python"}

# 定义空集合时,只能使用 v = set{}
# 不能使用 v = {},这样是定义了一个空字典

• 无序，无法通过索引取值 ，体现在添加时会在不固定的位置添加
• 可变，可以添加和删除元素

v1 = {11,22,33,"python"}
v1.add(44)	# 不是在固定位置添加,而是随机位置
v1.discard(11)
print(v1) # {33, 'python', 44, 22} # 多试几次可以看出位置在变化,没有顺序

• 不允许数据重复

v1 = {11,22,33,"python"}
v1.add(22)
print(v1) # 11,22,33,"python"

3.2 独有功能

1. 添加元素 add

v1 = {11,22,33,"python"}
v1.add(44)
print(v1)

2. 删除元素 discard

v1 = {11,22,33,"python"}
v1.discard(11)
print(v1)

3. 交集 &、intersection

v1 = {"aaa","bbb","ccc"}
v2 = {"123","456","aaa"}
v3 = v1.intersection(v2)  # "aaa" 取同时存在两个集合中的值
v4 = v1 & v2              # "aaa"

4. 并集 |、union

v1 = {"aaa","bbb","ccc"}
v2 = {"123","456","aaa"}
v3 = v1.union(v2)    # {'456', '123', 'ccc', 'bbb', 'aaa'} 两个集合的值合并为一个集合，重复数据只保留一个"aaa"  
v4 = v1 | v2         # {'456', '123', 'ccc', 'bbb', 'aaa'}

5. 差集 -、difference

v1 = {"aaa","bbb","ccc"}
v2 = {"123","456","aaa"}
v3 = v1.difference(v2)  # {'bbb', 'ccc'} 取v1中有,v2中没有的值  # v3 = v1 - v2
v4 = v2 - v1            # {'123', '456'} 取v2中有,v1中没有的值  # v4 = v2.difference(v1)

3.3 公共功能

1. -、计算差集
2. &、计算交集
3. |、计算并集
4. 长度

v1 = {11,22,33,"python"}
print(len(v1))    # 4

5. for循环

v1 = {11,22,33,"python"}
for item in v1:
    print(item)  # 循环中可以看出是无序循环输出

3.4 转换

• 其它类型转换为集合类型，可以通过 set 进行转换，并且如果有重复数据会剔除掉
• bool、int 无法转换 (即便它们可哈希) ， int在列表中可转换

v1 = "abc"
v2 = [11,22,33,11]
print(set(v1)) # {'c', 'a', 'b'}
print(set(v2)) # {33, 11, 22}   # 去除重复

3.5 其他

3.5.1 集合的存储原理

3.5.2 元素必须可哈希

• 因存储原理，集合的元素必须是可哈希的值，即：内部可通过 hash 函数把值转换成一个数字

# 转换成功
v1 = [11,22,11,33,]            # 都是int元素,可哈希
set(v1)  # {11,22,33}

# 转换失败
v1 = [11,22,["abc","aaa"],13]  # ["abc","aaa"]是列表,不可哈希
set(v1)  # 报错 TypeError: unhashable type: 'list'

3.5.3 集合查找元素速度快

• 效率低：例如 列表、元组
• 效率高：集合

city_set = {"北京","上海","深圳"}
if "北京" in city_set:
    pass

3.5.4 对比和嵌套

data_list = [
    "aba",
    11,
    (11,22,33,{"eee","qqqq"},22),
    [11,22,33,22],
    {11,22,(True,["中国","北京"],"沙河"),33} # 由于集合中包含["中国","北京"]列表不可hash，会报错 TypeError: unhashable type: 'list'
]

集合练习题

1. 写代码实现

v1 = {"hello","world","世界"}
v2 = []
# 循环提示用户输入,如果输入的值在v1中存在,则追加到v2中,如果v1中不存在,则添加到v1中,Q/q退出
while True:
    value = input("请输入 (Q/q退出):")
    if value.upper() == "Q":
        break
    if value in v1:
        v2.append(value)
    v1.add(value)

2. 下列哪些值不能做集合的元素

0
[11,22,33]  # 不能
[]          # 不能
(123,)
{1,2,3}     # 不能

3. 模拟用户信息录入程序，已录入则不再创建

user_info_set = set()
for i in range(2):
    name = input("请输入姓名:")
    age = input("请输入年龄:")
    item = (name, age)
    if item not in user_info_set:
        user_info_set.add(item)
print(user_info_set)

4. 字典 (dict)

字典是一个 无序、元素只能是键值对  且   键不重复、键可hash、可变的容器

• 容器
• 元素必须键值对
• 键不重复，重复会被覆盖

data = {"k1":1,"k1":2}  # 重复覆盖,只保留{"k1":2}

• 无序
  • 3.6+之后是有序
  • 3.6之前是无序，遍历顺序是随机的
    | 函数 | 功能 |
    | --- | --- |
    | len(dict) | 计算字典元素个数，即键的总数。 |
    | str(dict) | 输出字典，可以打印的字符串表示。 |
    | type(...) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |

4.1 定义

字典中对键值的要求：

• 键：必须可 hash
• 值：任意类型

v1 = {}  # 定义空字典
v2 = dict()  # 定义空字典

data = {
    "age": 12,
    123: ("a", "b", 3),
    True: "yes",
    (11, 22, 33): ["aaa", "bbb"]
}

data2 = {
    1: 25,
    True: a
}  # 1和True重复 {1:a}

表示一组固定信息时，用字典可以更加直观，例如：

# 用户列表
user_list = [
    {
        "name": "root",
        "pwd": "123"
    },
    {
        "name": "look",
        "pwd": "abc"
    }
]

4.2 独有功能

1. 获取值 get

msg = {
    "age": 12,
    "name": "shaochong",
    "status": True
}
key = input("请输入要查询的键:")
result = msg.get(key)
if key in msg:
    print("键 {} 存在,值为:{}".format(key, result))
else:
    print("键 {} 不存在".format(key))

"""
print(msg.get("status"))  # True
print(msg.get("age"))     # 12
print(msg.get("age",123)) # 123 # 当键不存在时返回指定数据
print(msg.get("aaaa"))    # None
"""

# get设置默认值,即当字典中get的值不存在时，返回一个默认值
msg = {'age': 12}
v1 = msg.get('aaa', 3)
print(v1)  # 3

2. 所有的键 keys 、所有的值 values、所有的键值 items
   • keys

msg = {
    "age": 12,
    "status": True,
    "name": "shaochong",
    "email": "xx@163.com"
}
data = msg.keys()
print(data)
# 输出为: dict_keys(['age', 'status', 'name', 'email'])
# 转换为列表: list(data)

# 在python2字典.keys()直接获取到的是列表，而python3中返回的是高仿列表，这个列表可以被循环显示
for item in msg.keys():
    print(item)
# 或使用if
if "age" in msg.keys():
    print("age 是字典的键")

• values

msg = {
    "age": 12,
    "status": True,
    "name": "shaochong",
    "email": "xx@163.com"
}
data = msg.values()
print(data)
# 输出为: dict_values(['age', 'status', 'name', 'email'])
# 转换为列表: list(data)

# 在python2字典.values()直接获取到的是列表，而python3中返回的是高仿列表，这个列表可以被循环显示
for item in msg.values():
    print(item)
# 或使用if
if 12 in msg.values():
    print("12 是字典的值")

• items

msg = {
    "age": 12,
    "status": True,
    "name": "shaochong",
    "email": "xx@163.com"
}

data = msg.items()
print(data)
# 输出为: dict_items([('age', 12), ('status', True), ('name', 'shaochong'), ('email', 'xx@163.com')])
# 在python2字典.items()直接获取到的是列表，而python3中返回的是高仿列表，这个列表可以被循环显示

for item in msg.items():
    print(item)  # item是一个元组(键,值)
    print('key:{} value:{}'.format(item[0], item[1]))

# 拆包
for key, value in msg.items():
    print(key, value)

3. 设置值 setdefault

msg = {
    "age": 12,
    "status": True
}

msg.setdefault("age", 18)  # 有则忽略     {"age": 12, "status": True}
msg.setdefault("aaa", 18)  # 没有则添加   {'age': 12, 'status': True, 'aaa': 18}

4. 更新字典键值对 update

msg = {
    "age": 12,
    "status": True
}

msg.update(
    {"age": 18, 
     "status": True, 
     "bbb": 18})

print(msg)  # 没有键添加键值,有键则更新值 {'age': 18, 'status': True, 'bbb': 18}

5. 移除指定键值对 pop

msg = {
    "age": 12,
    "status": True
}
v1 = msg.pop("age")
print(v1)  # 12
print(msg) # {'status': True}

6. 按照顺序移除 (后进来先出去) popitem

msg = {
    "age": 12, 
    "status": True
}
msg.popitem()  # {"age": 12}

# python3.6之前是随机删除

练习题

# 结合下面的两个变量 header 和 stock_dict实现输出股票信息,格式如下:
# SH601778,股票名称:中国晶科、当前价:6.29、涨跌额:+1.92。

header = ["股票名称", "当前价", "涨幅额"]
stock_dict = {
    'SH601778': ['中国晶科', '6.29', '+1.92'],
    'SH688566': ['吉贝尔', '52.66', '+6.96'],
    'SH688268': ['华特气体', '88.80', '+11.72'],
    'SH600734': ['实达集团', '2.60', '+0.24']
}
# 补充代码
for key, value in stock_dict.items():
    text_list = []
    for index in range(len(value)):
        text = "{}:{}".format(header[index], value[index])
        text_list.append(text)
    data = "、".join(text_list)
    result = "{},{}。".format(key, data)
    print(result)

4.3 公共功能

1. 求并集 |

# update是更新原有字典,求并集是创建一个新的字典
# python3.9版本新加入
v1 = {"k1":1,"k2":2}
v2 = {"k2":22,"k3":3}
v3 = v1 | v2    # {"k1":1,"k2":22,"k3":3}

2. 长度 len

msg = {"age": 12, "status": True}
len(msg) # 2

3. 是否包含 in

msg = {"age": 12, "status": True}
"age" in msg               # 判断键是否存在于字典 等同于  "age" in msg.keys()
"age" in msg.values()      # 判断值是否存在于字典
("age",12) in msg.items()  # 判断键值对是否存在于字典

4. 索引(通过键[key]取值,而不是数值[0])

# 与 msg.get()的区别: msg.get("aaa")不存在不会报错,而会返回None
msg = {"age": 12, "status": True}
msg["age"]     # 12
msg["status"]  # True
msg["aaa"]     # 不存在会报错

5. 根据 键 修改值、添加值、删除del键值对

# setdefault(): setdefault()没有键会新增,有则不改变原字典
msg = {"age": 12, "status": True}
msg["aaa"] = 123 # 没有键会新增  {"age": 12, "status": True,"aaa":123}
msg["age"] = 18  # 有键值会修改 {"age": 18, "status": True}

# del 与 pop() 区别: pop()没有键同样会报错,区别在于pop()可以将删除的键赋值 v1 = msg.pop("age")
del msg["age"]   # {"status": True} # 没有键会报错

6. for

msg = {"age": 12, "status": True}
# 默认循环键
for item in msg.keys():     # 等同于for item in msg:
    print(item)

for item in msg.values():
    print(item)

for key,value in msg.items():
    print(key,value)

4.4 转换

# 列表、元组转字典
v = dict([["k1","a"],("k2","b")])   # {'k1': 'a', 'k2': 'b'}

# 字典转列表
info = {'k1': 'a', 'k2': 'b'}
v1 = list(info) # ["k1","k2"]  等同于 v1 = list(info.keys())
v2 = list(info.values()) # ["a","b"]
v3 = list(info.items())  # [("k1","a"),(k2,"b")]

# 字符串与字典的转换
data = str({'id': '30142123', 'types': ['剧情', '儿童', '动画'], 'regions': ['中国大陆'], 'title': '猫咪小贝'})
print(type(data)) # <class 'str'>
data = eval(data)
print(type(data)) # <class 'dict'>

4.5 其他

4.5.1 存储原理

类似于集合，键hash，查找速度快

msg = {"age": 12, "status": True}
for item in msg:
    pass

if msg["age"]:
    pass

if msg.get("age"):
    pass

4.5.2 嵌套

在涉及多种数据类型直接的嵌套时，需注意：

• 字典的键必须可哈希，字典的值可以是任意类型
• 集合元素必须可哈希
• 字典的键和集合的元素在遇到布尔值1、0时需注意重复的情况

dic = {
    'name': '小明',
    'age': 18,
    'friend': [
        {'name': '小红', 'age': 16}, 
        {'name': '小王', 'age': 12}
    ],
    'email': [
        'xxx@163.com', 
        'xxx@qq.com'
    ]
}

# 获取小明第一个朋友的名字
print(dic['friend'][0]["name"])

# 获取小明的邮箱
print(dic['email'])

# 获取小明的第一个邮箱
print(dic['email'][0])

# 小明的第一个朋友名字变更为 翠花
dic['friend'][0]["name"] = "翠花"

# 小明再交一个朋友
dic['friend'].append({'name': "铁锤", 'age': 30})

# 给小明添加一个性别:男
dic["sex"] = "man"

# 删除小明的年龄
del dic["age"]
# 或
dic.pop("age")

5. 浮点型 (folat)

浮点型用于表示小数，例如：1.01、3.1415

• 浮点型转换为整形时，会将小数点去掉

v1 = 3.14
data = int(v1) # 3

• 保留浮点数的后N位 round

v1 = 3.1415926
data = round(v1,4) # 3.1416 自动四舍五入

• 浮点型的坑

v1 = 0.1
v2 = 0.2
v3 = v1 + v2 # 0.30000000000000004  # 浮点型的坑,由于且内部存储原理可能会引发数据存储不够精准

# 引入decimal解决,注意""
import decimal
v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2 
print(v3)   # 0.3

6. 练习题

1. 根据需求写代码

dic = {'k1': 'a', 'k2': 'b', 'k3': [11, 22, 33]}

# 在字典中添加键值对 'k4':'d'
dic.setdefault("k4", "d")
# dic['k4'] = 'd'

# 修改字典中 'k1' 对应的值为 'apple'
dic["k1"] = "apple"

# 在'k3'对应的值中追加一个元素 44
dic['k3'].append(44)

# 在'k3'对应的值的第0个索引位置插入一个元素 55
dic['k3'].insert(0, 55)

2. 根据需求写代码

dic = {
    'name': ['chong', 2, 3, 5],
    'msg': {'k1': ['python1', 'python2', 100]}
}

# 将name对应的列表追加一个元素"cccc"
dic['name'].append('ccc')

# 修改字典,将name对应列表中的chong大写
v1 = dic['name'][0].upper()
dic['name'][0] = v1

# msg对应的字典加一个键值对'k2':'linux'
dic['msg']['k2'] = 'linux'

# 将msg对应的字典中k1对应的列表中的python2删除
dic['msg']['k1'].remove("python2")
# 或
del dic['msg']['k1'][1]

3. 循环提示用户输入，并将输入内容添加到字典中(Q/q停止循环)

# 例如: 用户输入 x1|aaa,则在字典中添加键值对{'x1':'aaa'}
info = {}
while True:
    text = input("请输入内容(Q/q退出):")
    if text.upper() == "Q":
        break
    data_list = text.split("|")
    info[data_list[0]] = data_list[1]

print(info)

4. 将字典的键和值分别追加到 key_list 和 value_list列表中

key_list = []
value_list = []
info = {'k1': 'a', 'k2': 'b', 'k3': 'c'}
for key, value in info.items():
    key_list.append(key)
    value_list.append(value)
# 或
key_list = list(info.keys())
value_list = list(info.values())

5. 循环打印k2对应的值中的每个元素

info = {
    'k1': 'a',
    'k2': ['北京', '上海', '广州', ]
}

for item in info["k2"]:
    print(item)

6. 将字符串 "k1:a|k2:b|k3:c"处理成字典{'k1':'a','k2':'b','k3':'c'}

"""
v1 = "k1:a"
v2,v3 = v1.split(":") # k1 a
print(v2,v3)
"""
v1 = "k1:a|k2:b|k3:c"
v2 = {}
data_list = v1.split("|")  # ["k1:a","k2:b","k3:c"]
for item in data_list:
    key, value = item.split(":")  # ["k2":"a"]
    v2[key] = value
print(v2)

7. 写代码

"""
list = [11,22,33,44,55,66,77,88,99,999]
将所有大于 66 的至保存值空字典的键为k1对应的列表中，将小与 66 的值保存键为k2对应的列表中,最后打印字典
动态创建k1 k2
"""
result_dic = {}
num_list = [11, 22, 33, 44, 55, 66, 77, 88, 99, 999]

for item in num_list:
    if item > 66:
        if 'k1' in result_dic:
            result_dic['k1'].append(item)
        else:
            result_dic['k1'] = [item]
    elif item == 66:
        pass
    else:
        if 'k2' in result_dic:
            result_dic['k2'].append(item)
        else:
            result_dic['k2'] = [item]

print(result_dic)

8. 输出商品列表，用户输入序号，显示选择的商品

# 1. 页面显示 序号+商品名称+商品价格: 1 华为MatebookPro14s 6999
# 2. 用户输入选择的商品序号，然后打印商品名称和商品价格
# 3. 如果序号有误，提示输入错误并重新输入
# 4. 输入 Q/q退出程序
# 准则:
#      尽可能少if嵌套
#      简单的逻辑放前面处理
goods = [
    {'name': '华为MatebookPro14s', 'price': 6999},
    {'name': '薯片', 'price': 10},
    {'name': '利群', 'price': 15},
    {'name': '美女', 'price': 998}
]

#  1 华为MatebookPro14s 6999
for item in range(len(goods)):
    print(item + 1, goods[item]['name'], goods[item]['price'])

while True:
    num = input("请输入商品序号:")
    if num.upper() == 'Q':
        break
    if not num.isdecimal():
        print('输入错误,请重新输入')
    else:
        num = int(num)
        if num > 4 or num < 1:
            print('序号有误,请重新输入')
            continue
        target_index = num - 1
        print(num, goods[target_index]['name'], goods[target_index]['price'])

9. 数据类型中哪些是可变类型，哪些是可哈希的，哪些是有序的

   • 可变: list、set、dict
   • 可哈希: int、float、bool、tuple、str
   • 有序: list、tuple、dict(py3.6以后)

10. 进制之间如何进行转换

- 十进制转其他进制: bin、oct、hex
- 其他进制转十进制: int("其他进制",base=2或6或16)

11. for循环实现九九乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        result = i * j
        text = "{} * {} = {}".format(i, j, result)
        print(text, end="\t")
    print(" ")

12. 车牌区域划分

"""
car_list = ['鲁A32444','沪B12333','京C49678','京B8696M','黑B23323','晋B25565','沪C32456']
根据列表获取各省车牌数量，例如info = {"沪":2,"京":2}
"""
car_list = ['鲁A32444', '沪B12333', '京C49678', '京B8696M', '黑B23323', '晋B25565', '沪C32456']
info = {}
for item in car_list:
    city = item[0]            # 循环逐个取出所有车牌
    num = info.get(city, 0)   # 定义一个num,取info字典的车牌对应的值,如果不存在返回0
    info[city] = num + 1      # 列表添加值:info[京] = 0 + 1,第二次遇到num变量便为1了,则info[京] = 1 + 1,其它同理
print(info)

13. 数据格式化处理

# 将数据处理格式为:  info = [{'id:'xx','name:'xxx','age':'xxx',"job":"xxx"}]
text = """id,name,age,phone
1,sunwukong,22,13656567557
2,lixunhuan,31,18333238493
3,zhangsan,99,18234949212
"""
info = []
data_list = text.strip().split('\n')
header_list = data_list[0].split(',')
for index in range(1, len(data_list)):  # len(data_list)= 4 # 1,2,3
    item = {}
    row = data_list[index]  # 取到data_list的每一行,此时又从列表变成了字符串
    row_item_list = row.split(",")  # 通过','分割再转回为列表
    for i in range(len(row_item_list)):  # [1,sunwukong,22,13656567557]... 0,1,2,3
        item[header_list[i]] = row_item_list[i]
    info.append(item)
print(info)

14. 棋牌游戏11点

• 生成一副扑克牌
• 3个玩家
• 发牌规则
  • 默认先给用户发一张牌，默认J、Q、K、15、16代表的值为0.5，其它为牌面值
  • 用户根据情况判断是否继续要牌，要则发一张，不要则给下一个玩家发
  • 如果玩家的所有牌相加大于11，则表示爆了，此人分数为0，并继续给下一个玩家发牌
• 最终计算并获得每个玩家的分数值

import random
result = {}   # 最终放玩家分数
user_list = ["小红","小明","翠花"]

# 1. 生成扑克牌
total_poke_list = [("小王,15"),("大王",16)]
color_list = ["红桃","黑桃","梅花","方片"]
num_list = []
for num in range(1,15):
    num_list.append(num)
for color in color_list:
    for num in num_list:
        item = (color,num)
        total_poke_list.append(item)
print(total_poke_list)

# 2. 发牌
for user in user_list:
    score = 0   # 初始化分数
    index = random.randint(0,len(total_poke_list)-1)
    poke = total_poke_list.pop(index)
    # JQKA大小王代表0.5
    value = poke[1]
    if poke[1] > 10:
        value = 0.5
    score += value
    print("给{}发的牌:{}{},牌面值总和:{}".format(user,poke[0],poke[1],score))
    # 用户选择是否继续
    while True:
        choice = input("是否继续要牌(Y/N):")
        choice = choice.upper()
        if choice not in {"Y","N"}:
            print("输入错误,请重新输入")
            continue
        if choice == "N":
            print("{}不要牌了".format(user))
            break
        # 继续要牌,再抽一张
        index = random.randint(0, len(total_poke_list) - 1)
        poke = total_poke_list.pop(index)
        value = poke[1]
        if poke[1] > 10:
            value = 0.5
        score += value
        print("给{}发的牌:{}{},牌面值总和:{}".format(user, poke[0], poke[1], score))
        # 判断是否大于11点
        if score > 11:
            print("{}牌爆了".format(user))
            score = 0
            break
    result[user] = score
print(result)

统计一个列表中重复的元素

# 方式1: 将每个元素出现的次数记录到字典中
my_list = [111, 22, 22, 22]
my_dict = {}

for item in my_list:
    if item not in my_dict:
        my_dict[item] = 0
    else:
        my_dict[item] += 1


# 方式2: 利用集合的元素必须唯一的特性
my_list = [1, 2, 33, 'a', 2, 4, 'a']
my_set = set(my_list)

for item in my_set:
    if my_list.count(item) > 1:
        print(item)

日志状态码百分比

status_code_list = [200, 502, 502, 502, 200, 302, 200, 500, 502, 200, 302, 302]
status_code_dict = {}
for code in status_code_list:
    code = str(code)
    if code not in status_code_dict:
        status_code_dict[code] = 1
    else:
        status_code_dict[code] += 1

print(status_code_dict)

sum_code = len(status_code_list)
for k, v in status_code_dict.items():
    print("{}状态码占比: {}%".format(*(k, round((int(v) / sum_code * 100), 2))))

7. 数据类型特点总结

• 可变、可哈希、有序：列表（list）
• 可变、不可哈希、无序：集合（set）
• 不可变、可哈希、有序：元组（tuple）
• 不可变、可哈希、有序：字符串（str）
• 不可变、可哈希、无序：整数（int）、浮点数（float）
• 不可变、不可哈希、无序：字典（dict）

本栏目推荐文章
• Jmeter 如何连接mysql数据库？
• 函数的参数类型
• SQL Server 检测是不是数字型数据的两种方法
• python字典的使用
• 【Shell基础】Bash基础与Linux三剑客
• 如何通过Navicat把MySQL远程数据库导入到本地数据库
• 和利时MACS6通过dat文件实现任意时间范围与测点的历史数据提取与科研分析
• 深入理解spring框架：剖析多线程模式下数据库连接
• 数据可视化是如何帮助大型企业提高效率的？
• redis 数据库

点数 字典 类型 基础 数据点数 字典 类型 基础 字典 类型 基础 数据 语言基础 点数 语言 类型 浮点 字典 类型 基础 数组 点数 类型 数据 整数 点数 类型 数据 字典 类型 数据python 类型 数据 点数 之间 字典 类型 方法 数据 字典 类型 工具 数据