首页 > 编程语言 >python基础-数据类型（none、集合、字典、浮点数）

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

时间：2023-10-20 16:57:38浏览次数：48  
标签：none item 数据类型 浮点数 print list v1 msg age

目录

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)
  1. 删除元素 discard
v1 = {11,22,33,"python"}
v1.discard(11)
print(v1)
  1. 交集 &、intersection
v1 = {"aaa","bbb","ccc"}
v2 = {"123","456","aaa"}
v3 = v1.intersection(v2)  # "aaa" 取同时存在两个集合中的值
v4 = v1 & v2              # "aaa"
  1. 并集 |、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'}
  1. 差集 -、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
  1. 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 集合的存储原理

capture_20220302230721988.bmp

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 对比和嵌套

类型 是否可变 是否有序 元素要求 是否可哈希 转换 定义空
list 是 是 无 否 list() v = []
或 v = list()
tuple 否 是 无 是 tuple() v = ()
或 v = tuple()
set 是 否 可哈希 否 set() v = set()
注意v = {}是定义一个空字典 
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)
  1. 下列哪些值不能做集合的元素
0
[11,22,33]  # 不能
[]          # 不能
(123,)
{1,2,3}     # 不能
  1. 模拟用户信息录入程序，已录入则不再创建
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(...) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |
方法 功能
dict.clear() 删除字典内所有元素
dict.copy() 返回一个字典的浅复制
dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key,default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
key in dict 如果键在字典dict里返回true，否则返回false
dict.items() 以列表返回一个视图对象
dict.keys() 返回一个视图对象
dict.setdefault(key,default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2) 把字典dict2的键/值对更新到dict里
dict.values() 返回一个视图对象
[pop(key,default)] 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem() 返回并删除字典中的最后一对键和值。

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
  1. 所有的键 keys 、所有的值 values、所有的键值 items
    • keys
msg = {
    "age": 12,
    "status": True,
    "name": "shaochong",
    "email": "[email protected]"
}
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": "[email protected]"
}
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": "[email protected]"
}

data = msg.items()
print(data)
# 输出为: dict_items([('age', 12), ('status', True), ('name', 'shaochong'), ('email', '[email protected]')])
# 在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)
  1. 设置值 setdefault
msg = {
    "age": 12,
    "status": True
}

msg.setdefault("age", 18)  # 有则忽略     {"age": 12, "status": True}
msg.setdefault("aaa", 18)  # 没有则添加   {'age': 12, 'status': True, 'aaa': 18}
  1. 更新字典键值对 update
msg = {
    "age": 12,
    "status": True
}

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

print(msg)  # 没有键添加键值,有键则更新值 {'age': 18, 'status': True, 'bbb': 18}
  1. 移除指定键值对 pop
msg = {
    "age": 12,
    "status": True
}
v1 = msg.pop("age")
print(v1)  # 12
print(msg) # {'status': True}
  1. 按照顺序移除 (后进来先出去) 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}
  1. 长度 len
msg = {"age": 12, "status": True}
len(msg) # 2
  1. 是否包含 in
msg = {"age": 12, "status": True}
"age" in msg               # 判断键是否存在于字典 等同于  "age" in msg.keys()
"age" in msg.values()      # 判断值是否存在于字典
("age",12) in msg.items()  # 判断键值对是否存在于字典
  1. 索引(通过键[key]取值,而不是数值[0])
# 与 msg.get()的区别: msg.get("aaa")不存在不会报错,而会返回None
msg = {"age": 12, "status": True}
msg["age"]     # 12
msg["status"]  # True
msg["aaa"]     # 不存在会报错
  1. 根据 键 修改值、添加值、删除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} # 没有键会报错
  1. 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': [
        '[email protected]', 
        '[email protected]'
    ]
}

# 获取小明第一个朋友的名字
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)
  1. 根据需求写代码
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]
  1. 循环提示用户输入，并将输入内容添加到字典中(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)
  1. 将字典的键和值分别追加到 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())
  1. 循环打印k2对应的值中的每个元素
info = {
    'k1': 'a',
    'k2': ['北京', '上海', '广州', ]
}

for item in info["k2"]:
    print(item)
  1. 将字符串 "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)
  1. 写代码
"""
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)
  1. 输出商品列表，用户输入序号，显示选择的商品
# 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'])

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

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

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

- 十进制转其他进制: bin、oct、hex
- 其他进制转十进制: int("其他进制",base=2或6或16)
  1. 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(" ")
  1. 车牌区域划分
"""
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)
  1. 数据格式化处理
# 将数据处理格式为:  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)
  1. 棋牌游戏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）

标签：none,item,数据类型,浮点数,print,list,v1,msg,age
From： https://www.cnblogs.com/ican97/p/17777474.html

相关文章

  • python基础-数据类型（字符串-布尔-整数）
    目录1.整数(int)1.1定义1.2独有功能1.3公共功能1.4转换1.5其他1.5.1长整型1.5.2地板除1.5.3其它2.布尔(bool)2.1定义2.2独有功能2.3公共功能2.4转换2.5其他做条件自动转换3.字符串(str)3.1定义3.2独有功能3.2.1练习题3.3公共功能3.4转换3.5其他4.练习题......
  • 数据类型分类(看到建议看一下)
    数据类型分类按存值个数存一个值：整型/浮点型/字符串存多个值：列表/字典/元组/集合按有序无序有序：字符串/列表/元组无序：字典/集合按可变or不可变可变：列表/字典/集合不可变：整型/浮点型/字符串/元组......
  • 元组数据类型内置方法
    元组数据类型内置方法元组和列表的内置方法一模一样，但是元祖无法修改元组咋i定义的那一刻他的元素个数以及元素的值就全部固定了毫无用处，早期永远一般用于减小内存占用，以后只要定义列表就行了定义方式列表的中括号改成小括号tup=(1,2,3,4,5)内置方法查看索引位置......
  • 字典数据类型内置方法
    字典数据类型内置方法1.作用对于值添加描述信息使用他2.定义方式用{}以逗号隔开加入键值对：key:valueinfo_dict={'name':'wangdapao','age':18,'height':120,'gender':'female','hobby_list':['dapao','basketball'......
  • 列表数据类型的内置方法
    列表数据类型的内置方法1.作用列表的作用就是可以描述多个值，就比如一个人可以有很多的爱好2.定义方式hobby_list=['play','swimming','dancing']print(hobby_list)lt=list('randysun')print(lt)3.内置方法优先掌握索引取值hobby_list=['play','swimming......
  • 【从零学习python 】03. Python编程基础：变量、数据类型与标识符
    变量以及数据类型一、变量的定义对于重复使用，并且经常需要修改的数据，可以定义为变量，来提高编程效率。定义变量的语法为:变量名=变量值。(这里的=作用是赋值。)定义变量后可以使用变量名来访问变量值。如下示例:#不使用变量打印三次"今天天气真好",如果需要变成打印"......
  • Java基础的转义符、数据类型和标识符
    1.转义符把字符转义成特殊含义或原来意思，这就是转义符的作用例如：1publicclassDemo{2publicstaticvoidmain(String[]args){3//\"：因为在Java中双引号（"）是有特殊含义的双引号是成双成对出现的4//当你想打印一个双引号时，就需要运用转义......
  • DataWhale DAY3 数据类型和操作
    DataWhaleDAY3数据类型和操作写在前面的：python基本操作统一放在https://www.cnblogs.com/hewo/p/17635277.html本文放一些有意思的东西首先味大的python提供了很是自动的动态类型。对象性质作为一个面向对象的语言，python具有很好的“面向对象友好”性质。举个例......
  • numpy的数据类型转换和数组广播
    numpy对象的常用属性第一种方法装好python，然后打开终端输入pipinstalljupyter（如果觉得速度慢可以加上镜像站-ihttps://pypi.douban.com/simple/）,然后再输入pipinstallnotebook(这里和前面一样，觉得慢就加镜像),打开在终端输入jupyternotebook。另一种方法就是去anacond......
  • 02_常见内置数据类型
    常见内置数据类型标签(tag):Python，数据类型，可变对象，不可变对象，可哈希对象，可迭代对象，可遍历对象参考资料：Python文档：内置类型(Build-inTypes)Python文档：数据模型-对象、值与类型Python文档：术语对照表-可哈希Python文档：属于对照表-可迭代对象Python文档：逻辑值检测Pyt......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99