day06 数据类型（下）

常见的数据类型：

• int，整数类型（整型）
• bool，布尔类型
• str，字符串类型
• list，列表类型
• tuple，元组类型
• dict，字典类型
• set，集合类型
• float，浮点类型（浮点型）

目标：掌握字典、集合、浮点类型相关知识。

课程概要：

• set集合：一个不允许重复重复 & 可变类型（元素可哈希）。
• dict字典：一个储存键值对的容器。
• float类型：我们生活中常见的小数。

1.集合（set）

集合是一个无序 、可变、不允许数据重复的容器。

1.1 定义

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

• 无序，无法通过索引取值。

• 可变，可以添加和删除元素。

  v1 = {11,22,33,44}
  v1.add(55)
  print(v1)
  # 输出结果：{11,22,33,44,55}
  

• 不允许数据重复。

  v1 = {11,22,33,44}
  v1.add(22)
  print(v1)
  # 输出结果：{11,22,33,44}
  

一般什么时候用集合呢？

一般想要维护一大堆不重复的数据时，就可以使用集合。比如：做爬虫去网上找图片的链接，为了避免链接重复，可以选择用集合去存储链接地址。

注意：定义空集合时，只能使用v = set()，不能使用 v={}。

# 定义一个空列表：
v1 = []
v11 = list()
# 定义一个空元组：
v2 = ()
v22 = tuple()
# 定义一个空集合：
v3 = set()
# 定义一个空字典：
v4 = {}
v44 = dict()

1.2 独有功能

1.2.1 add() 添加元素

data = {"刘嘉玲", '关之琳', "王祖贤"}
data.add("郑裕玲")
print(data)
# 输出结果：
{"刘嘉玲", '关之琳', "王祖贤","郑裕玲"}

data = set()
data.add("周杰伦")
data.add("林俊杰")
print(data)
# 输出结果：
{"周杰伦","林俊杰"}

1.2.2 discard() 删除元素

data = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
data.discard("关之琳")
print(data)
# 输出结果：
{"刘嘉玲", "王祖贤","张曼⽟", "李若彤"}

1.2.3 intersection() 或 &：交集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1.intersection(s2)
print(s3)
s4 = s1 & s2
print(s4)
# 输出结果：{"⽪⻓⼭"}

1.2.4 unio() 或 | ：并集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1.union(s2)
print(s3)
s4 = s1 | s2
print(s4)
# 输出结果：{"刘能", "赵四", "⽪⻓⼭","刘科⻓", "冯乡⻓"}

1.2.5 difference() 或 - ：差集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1.difference(s2)         # s1中有且s2中没有的值
s4 = s1 - s2                   # s1中有且s2中没有的值
print(s3)
# 输出结果：{"刘能", "赵四"}s5 = s2.difference(s1)       # s2中有且s1中没有的值
s6 = s2 - s1                   # s2中有且s1中没有的值
print(s5)
# 输出结果：{"刘科⻓", "冯乡⻓"}

1.3 公共功能

1. 长度

   v = {"刘能", "赵四", "尼古拉斯"}
   data = len(v)
   print(data)
   # 输出结果：3
   

2. for循环

   v = {"刘能", "赵四", "尼古拉斯"}
   for item in v:print(item)
   # 输出结果：
   "刘能"
   "赵四"
   "尼古拉斯"
   

1.4 转换

其他类型转换为集合类型，可以通过set()实现，并且如果有重复的数据会在转换成集合时自动去重。

提示：str / list / tuple / dict 都可以转换为集合。

v1 = "轩小陌"
v2 = set(v1)
print(v2)
# 输出结果：{"轩","小","陌"}

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2)
# 输出结果：{11,22,33,3,99}

注意：为字符串、列表、元组中的元素去重，是集合日常使用过程中的一个主要功能。

1.5 其他

1.5.1 集合的存储原理

1.5.2 集合中的元素必须可哈希

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

注意：目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。因此，集合的元素只能是 int、bool、str、tuple 。

• 转换成功

  v1 = [11,22,33,11,3,99,22]
  v2 = set(v1)
  print(v2)
  # 输出结果：{11,22,33,3,99}
  

• 转换失败

  v1 = [11,22,["alex","eric"],33]
  v2 = set(v1)
  print(v2)
  # 报错
  

1.5.3 查找效率高

因存储原理的特殊性，集合相比列表和元组，查找效率非常高。

• 效率低

  user_list = ["轩小陌","alex","李璐"]
  if "alex" in user_list:print("在")
  else:print("不在")user_tuple = ("轩小陌","alex","李璐")
  if "alex" in user_tuple:print("在")
  else:print("不在")
  

• 效率高

  user_set = {"轩小陌","alex","李璐"}
  if "alex" in user_set:print("在")
  else:print("不在")
  

1.5.4 列表、元组、集合的对比和嵌套

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	v=[]或v=list()
tuple	否	是	无	是	tuple(其他)	v=()或v=tuple()
set	是	否	可哈希	否	set(其他)	v=set()

data_list = ["alex",11,(11, 22, 33, {"alex", "eric"}, 22),[11, 22, 33, 22],{11, 22, (True, ["中国", "北京"], "沙河"), 33}
]
# 通过以上示例可看出：列表中可嵌套元组和集合，元组中可嵌套列表和集合，但集合中只能嵌套元组

注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整型 0、1和False、True在集合中同时出现会自动被去重：

v1 = {True, 1}
print(v1)       # 输出结果：{True}v3 = {0, False}
print(v3)       # 输出结果：{0}

练习题

1. 写代码实现

   v1 = {'alex','轩sir','肖大'}
   v2 = []# 循环提示用户输入，如果输入值在v1中存在，则追加到v2中，如果v1中不存在，则添加到v1中。（如果输入N或n则停止循环）
   while True:name = input("请输入姓名(N/n退出)：")if name.upper() == "N":breakif name in v1:v2.append(name)else:v1.add(name)
   

2. 下面那些值不能做集合的元素

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

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

   user_info_set = set()while True:name = input("请输入姓名：")age = input("请输入年龄：")item = (name,age,)if item in user_info_set:print("该用户已录入")else:user_info_set.add(item)
   

4. 给列表去重。

   v = [11,22,11,22,44455]
   v = list(set(v))
   

补充：None类型

Python的数据类型中有一个特殊的值None，意味着这个值啥都不是或表示空。 相当于其他语言中 null作用一样。

在一定程度上可以帮助我们去节省内存。例如：

v1 = []
v2 = []
# 会在底层创建两个空列表，占用一定内存v1 = None
v2 = None
# 不会在底层重新创建，不浪费空间

截至目前，所有转换为布尔值为False的数据类型有：

0,   "",    []/list(), ()/tuple(), set(),  None

2.字典（dict)

字典是无序、键不重复且元素为键值对的可变的容器。

data = { "k1":1,  "k2":2 }

• 容器

• 元素必须为键值对

• 键不重复，重复则会被覆盖

  data = { "k1":1, "k1":2 }
  print(data)
  # 输出结果：{"k1":2 }data_dict = {1: 29,True: 5
  }
  print(data_dict)
  # 输出结果：{1: 5}
  

• 在Python3.6版本之前字典是无序的，但Python3.6之后变成有序了。

2.1 定义

v1 = {}
v2 = dict()

info = { "age":12, "status":True,  "name":"xuanxiaomo",   "hobby":['篮球','足球']
}

字典中对键值得要求：

• 键：必须可哈希。 目前为止学习的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict。
• 值：任意类型。

data_dict = {"轩小陌":29,True:5,123:5,(11,22,33):["alex","eric"]
}

# 错误的字典示例：列表、集合、字典均不能作为字典中的键
v1 = {[1, 2, 3]: '周杰伦',"age" : 18
} v2 = {{1,2,3}: "哈哈哈",'name':"alex"
} v3 = {{"k1":123,"k2":456}: '呵呵呵',"age":999
}

那么一般在什么情况下会用到字典呢？

当我们想要表示固定信息的组合时，用字典可以更加的直观，例如：

user_list = [ ("alex","123"), ("admin","666") ]
user_list = [ {"name":"alex","pwd":"123"}, {"name":"admin","pwd":"666"} ]

2.2 独有功能

2.2.1 get() 获取值

info = { "age":12, "status":True, "name":"轩小陌","data":None
}
data1 = info.get("name")
print(data1)                # 输出结果："轩小陌"
data2 = info.get("age")
print(data2)                # 输出结果：12
data = info.get("email")      # 键不存在，默认返回None
data = info.get("hobby",'不存在')
print(data)                 # 输出结果：不存在

user_list = {"xuanxiaomo": "123","alex": "uk87",
}
username = input("请输入用户名：")
password = input("请输入密码：")
pwd = user_list.get(username)
if not pwd:print("用户名不存在")
else:if password == pwd:print("登录成功")else:print("密码错误")# 写代码的基本准则：简单的逻辑处理放前面；复杂的逻辑处理放后面

2.2.2 keys() 获取所有的键

info = {"age":12, "status":True, "name":"xuanxiaomo","email":"xx@live.com"}
data = info.keys()
print(data)
# 输出结果：
dict_keys(['age', 'status', 'name', 'email'])    result = list(data)
print(result)
# 输出结果：
['age', 'status', 'name', 'email']

注意：在Python2中字典.keys()直接获取到的是列表，而Python3中得到的是高仿列表，这个高仿列表可有以下功能：

# 循环
info = {"age":12, "status":True, "name":"xuanxiaomo","email":"xx@live.com"}
for ele in info.keys():print(ele)

# 判断是否存在
info = {"age":12, "status":True, "name":"xuanxiaomo","email":"xx@live.com"}
if "age" in info.keys():print("age是字典的键")
else:print("age不是")

2.2.3 value() 获取所有的值

info = {"age":12, "status":True, "name":"xuanxiaomo","email":"xx@live.com"}
data = info.values()
print(data)
# 输出结果：
dict_values([12, True, 'wupeiqi', 'xx@live.com'])

注意：在Python2中字典.values()直接获取到的是列表，而Python3中得到的是高仿列表，这个高仿列表可有以下功能：

# 循环
info = {"age":12, "status":True, "name":"xuanxiaomo","email":"xx@live.com"}
for val in info.values():print(val)

# 判断是否存在
info = {"age":12, "status":True, "name":"xuanxiaomo","email":"xx@live.com"}
if 12 in info.values():print("12是字典的值")
else:print("12不是")

2.2.4 items() 获取所有的键值

info = {"age":12, "status":True, "name":"xuanxiaomo","email":"xx@live.com"}
data = info.items()print(data)
# 输出结果：
dict_items([ ('age', 12),  ('status', True),  ('name', 'xuanxiaomo'),  ('email', 'xx@live.com')  ])

# 循环字典：
for item in info.items():print(item[0],item[1]) for key,value in info.items():      # 输入2个变量key默认为键，value默认为值print(key,value)

# 判断键值对是否在字典中：
info = {"age":12, "status":True, "name":"xuanxiaomo","email":"xx@live.com"}
if ('age', 12) in info.items():       print("在")
else:print("不在")

2.2.5 setdefault() 新增键值对（如果键在字典中已存在，则不会修改）

data = {"name": "轩小陌","email": 'xxx@live.com'
}
data.setdefault("age", 18)
print(data)
# 输出结果：
{'name': '轩小陌', 'email': 'xxx@live.com', 'age': 18}data.setdefault("name", "alex")
print(data)
# 输出结果：
{'name': '轩小陌', 'email': 'xxx@live.com', 'age': 18}

2.2.6 update() 更新键值对（如果键在字典中已存在，则修改值，否则新增键值对）

info = {"age":12, "status":True}
info.update( {"age":14,"name":"轩小陌"} )
print(info)
# 输出结果：
{"age":14, "status":True,"name":"轩小陌"}

2.2.7 pop() 移除指定键值对

info = {"age":12, "status":True,"name":"轩小陌"}
data = info.pop("age")
print(info)
# 输出结果：{"status":True,"name":"轩小陌"}

2.2.8 popitem() 按照顺序移除键值对

Python3.6版本之前，popitem() 随机删除字典中的键值对，Python3.6后，popitem() 移除最后一组键值对

info = {"age":12, "status":True,"name":"轩小陌"}
data = info.popitem()
print(info)         # 输出结果：{"age":12, "status":True}
print(data)         # 输出结果：("name","轩小陌")# popitem() 返回的是一个元组类型

练习题

"""
结合下面的两个变量 header 和 stock_dict实现逐一输出股票信息，格式如下：SH601778，股票名称：中国晶科、当前价：6.29、涨跌额：+1.92SH688566，股票名称：吉贝尔、当前价：52.66、涨跌额：+6.96...
"""
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():print(f'{key}，{header[0]}:{value[0]}、{header[1]}:{value[1]}、{header[2]}:{value[2]}')

2.3 公共功能

1. 求并集（Python3.9版本之后新增功能）

   v1 = {"k1": 1, "k2": 2}
   v2 = {"k2": 22, "k3": 33}
   v3 = v1 | v2
   print(v3)
   # 如果键相同，则后面字典的值会覆盖前面字典的值
   # 输出结果：
   {'k1': 1, 'k2': 22, 'k3': 33}
   

2. 长度

   info = {"age":12, "status":True,"name":"轩小陌"}
   data = len(info)
   print(data)
   # 输出结果：3
   

3. in 包含判断

   # 判断键知否在字典中
   info = { "age":12,  "status":True,"name":"轩小陌" }
   v1 = "age" in info
   print(v1)
   v2 = "age" in info.keys()
   print(v2)
   

   # 判断值知否在字典中
   info = {"age":12, "status":True,"name":"轩小陌"}
   v1 = "轩小陌" in info.values()
   print(v1)
   

   # 判断键值对知否在字典中
   info = {"age": 12, "status": True, "name": "轩小陌"}
   v1 = ("age", 12) in info.items()
   print(v1)
   

4. 索引（键）
   字典不同于元组和列表，字典的索引是键，而列表和元组则是 0、1、2等数值 。

   info = { "age":12,  "status":True, "name":"轩小陌"}
   print( info["age"] )          # 输出结果：12
   print( info["name"] )     # 输出结果：轩小陌
   print( info["status"] )       # 输出结果：True
   print( info["xxxxx"] )    # 键不存在时会报错（以后项目开发时建议使用）
   print( info.get("xxxxx") )    # 输出结果：None# 建议后续开发过程中使用get方法根据键去获取值，因为即使键不存在也不会报错，而是返回None
   

5. 根据键 修改值 和 添加值 和 删除键值对
   上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作

   # 往字典中增加键值对
   info = {"age":12, "status":True,"name":"轩小陌"}
   info["gender"] = "男"
   print(info)
   # 输出结果：
   {"age":12, "status":True,"name":"轩小陌","gender":"男"}
   

   # 修改字典中指定键的值
   info = {"age":12, "status":True,"name":"轩小陌"}
   info["age"] = "18"
   print(info)
   # 输出结果：
   {"age":"18", "status":True,"name":"轩小陌"}
   

   # 删除字典中指定键的键值对（如果键不存在则报错）
   info = {"age":12, "status":True,"name":"轩小陌"}
   del info["age"]
   print(info)
   # 输出结果：
   {"status":True,"name":"轩小陌"}
   

6. for循环
   由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的键、值、键值对进行循环；

   info = {"age":12, "status":True,"name":"轩小陌"}
   for item in info:   # 默认输出所有的键print(item)
   

   info = {"age":12, "status":True,"name":"轩小陌"}
   for item in info.key():print(item)
   

   info = {"age":12, "status":True,"name":"轩小陌"}
   for item in info.values():print(item)
   

   info = {"age":12, "status":True,"name":"轩小陌"}
   for key,value in info.items():print(key,value)
   

2.4 转换

# 其他数据类型转换为字典：
v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )
print(v)
# 输出结果：
{ "k1":"v1", "k2":"v2" }

# 字典转换为其他数据类型：
info = { "age":12, "status":True, "name":"轩小陌" }
v1 = list(info)                # 输出结果：["age","status","name"]
v2 = list(info.keys())         # 输出结果：["age","status","name"]
v3 = list(info.values())   # 输出结果：[12,True,"轩小陌"]
v4 = list(info.items())    # 输出结果：[ ("age",12), ("status",True), ("name","轩小陌") ]

1.5 其他

1.5.1 存储原理

1.5.2 查询效率高

info = {"alex":["肝胆","铁锤"], "男孩":["二蛋","缺货"]
}
for "alex" in info:print("在"）

info = {"alex":["肝胆","铁锤"], "男孩":["二蛋","缺货"]
}
v1 = info["alex"]
v2 = info.get("alex")

1.5.3 嵌套

我们已学了很多数据类型，在涉及多种数据类型之间的嵌套时，需注意一下几点：

• 字典的键必须可哈希（ list / set / dict 不可哈希 ）。

  # 正确
  info = {(11,22):123}# 错误
  info = {(11,[11,22,],22):"alex"}
  

• 字典的值可以是任意类型。

  info = {"k1":{12,3,5},"k2":{"xx":"x1"}
  }
  

• 字典的键和集合的元素在遇到 布尔值 和 1、0 时，需注意重复的情况。

• 字典中如果存在元组的元素，是元组内部的元素是不可以被修改的。

练习题

dic = {'name':'汪峰','age':48,'wife':[ {'name':'国际章','age':38},{'name':'李杰','age':48} ],'children':['第一个娃','第二个娃']
}
# 1. 获取汪峰的妻子名字d1 = dic['wife'][0]['name']print(d1)
# 2. 获取汪峰的孩子们d2 = dic['children']print(d2)
# 3. 获取汪峰的第一个孩子d3 = dic['children'][0]print(d3)
# 4. 汪峰的媳妇姓名变更为"章子怡"dic['wife'][0]['name] = "章子怡"print(dic)
# 5. 汪峰再娶一任妻子dic['wife'].append( {"name":"铁锤","age":19} )print(dic)
# 6. 给汪峰添加一个爱好：吹牛逼dic['hobby'] = "吹牛逼"print(dic)
# 7. 删除汪峰的年龄del dic['age']或 dic.pop('age')print(dic)

3.浮点型（float）

浮点型，一般在开发过程中中用于表示小数。

v1 = 3.14
v2 = 9.89

关于浮点型的其他知识点如下：

• 在浮点型转换为整型时，会将小数部分去掉。

  v1 = 3.14
  data = int(v1)
  print(data)
  # 输出结果：3
  

• 四舍五入保留小数点后N位（round）

  v1 = 3.1415926
  result = round(v1,3)
  print(result)
  # 输出结果：3.142
  

• 在使用浮点型直接进行计算时，可能会有一点微小的误差，如下图：
  
  在项目中如果需要精确计算小数，可以使用 decimal 模块中的 Decimal() 方法：

  import decimal
  v1 = decimal.Decimal("0.1")
  v2 = decimal.Decimal("0.2")
  v3 = v1 + v2
  print(v3)
  # 输出结果：0.3
  

今日总结

1. 集合，是无序、不重复、元素必须可哈希、可变的容器（子孙元素都必须是可哈希）。

2. 集合的查找速度比较快（底层是基于哈希进行存储）

3. 集合可以具有交、并、差的功能。

4. 字典是无序、键不重复且元素只能是键值对的可变的容器（键子孙元素都必须是可哈希）。

5. Python3.6版本之后字典就变为有序了。

6. Python3.9版本新增了 {} | {}的运算。

7. 字典的常见功能。

8. 在python2 和python3 中，字典的 keys() 、values()、items() 三个功能获取的数据类型不一样。

9. None代表内存中的一个空值。

10. 浮点型用于表示小数，但是由于其内部存储原理可能会导致数据存储不够精准。

今日作业

1. 根据需求写代码

   dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
   # 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
   dic["k4"] = "v4"
   print(dic)
   # 请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
   dic["k1"] = "alex"
   print(dic)
   # 请在k3对应的值中追加一个元素 44，输出修改后的字典
   dic["k3"].append(44)
   print(dic)
   # 请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
   dic["k3"].insert(0,18)
   print(dic)
   

2. 根据需求写代码

   dic1 = {'name':['alex',2,3,5],'job':'teacher','oldboy':{'alex':['python1','python2',100]}
   }
   # 1，将name对应的列表追加⼀个元素"Xuansir"
   dic1['name'].append('Xuansir')
   print(dic1)
   # 2，将name对应的列表中的alex全变成大写
   dic1['name'][0] = dic1['name'][0].upper()
   print(dic1)
   # 3，oldboy对应的字典加⼀个键值对"语言": "linux"
   dic1['oldboy']['语言'] = 'linux'
   print(dic1)
   # 4，将oldboy对应的字典中的alex对应的列表中的python2删除
   dic1['oldboy']['alex'].remove('python2')
   print(dic1)
   

3. 循环提示用户输入，并将输入内容添加到字典中（如果输入N或n则停止循环）

   例如：用户输入 x1|xuanxiaomo ,则需要在字典中添加键值对 {'x1':"xuanxiaomo"}dic = {}
   while True:item = input('请输入(N/n退出)：')if item.upper() == 'N':breakelse:lis = item.split('|')dic[lis[0]] = lis[1]
   print(dic)
   

4. 判断以下值那个能做字典的key ？那个能做集合的元素？

   - 1                                 # 能做字典的key，也能做集合的元素
   - -1                                # 能做字典的key，也能做集合的元素
   - ""                              # 能做字典的key，也能做集合的元素
   - None                              # 能做字典的key，也能做集合的元素
   - [1,2]                             # 不能做字典的key，也不能做集合的元素
   - (1,)                              # 能做字典的key，也能做集合的元素
   - {11,22,33,4}                       # 不能做字典的key，也不能做集合的元素
   - {'name':'xuanxiaomo','age':18}     # 不能做字典的key，也不能做集合的元素
   

5. 将字典的键和值分别追加到 key_list 和 value_list 两个列表中，如：

   key_list = []
   value_list = []
   info = {'k1':'v1','k2':'v2','k3':'v3'}# 请补充代码：
   for key,value in info.items():key_list.append(key)value_list.append(value)
   print(key_list)
   print(value_list)
   

6. 字典dic = {‘k1’: “v1”, “k2”: “v2”, “k3”: [11,22,33]}

   # a. 请循环输出所有的key
   for key in dic.keys():print(key)
   # b. 请循环输出所有的value
   for value in dic.values():print(value)
   # c. 请循环输出所有的key和value
   for key,value in info.items():print(key)print(value)
   

7. 请循环打印k2对应的值中的每个元素。

   info = {'k1':'v1','k2':[('alex'),('wupeiqi'),('oldboy')],
   }
   # 请补充代码;
   for item in info['k2']:print(item)
   

8. 有字符串"k: 1|k1:2|k2:3 |k3 :4" 处理成字典 {‘k’:1,‘k1’:2…}

   text = "k: 1|k1:2|k2:3  |k3 :4"
   lis = text.split('|')
   dic = {}
   for item in lis:key,value = item.split(':')key = key.strip()dic[key] = int(value)
   print(dic)
   

9. 写代码

   """
   有如下值 li= [11,22,33,44,55,66,77,88,99,90] ,将所有大于 66 的值保存至字典的第一个key对应的列表中，将小于 66 的值保存至第二个key对应的列表中。result = {'k1':[],'k2':[]}
   """
   # 请补充代码：
   li= [11,22,33,44,55,66,77,88,99,90]
   large_li = []
   small_li = []
   dic = {}
   for item in li:if item > 66:large_li.append(item)elif item == 66:passelse:small_li.append(item)
   dic['k1'] = large_li
   dic['k2'] = small_li
   print(dic)
   

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

    """
    商品列表：goods = [{"name": "电脑", "price": 1999},{"name": "鼠标垫", "price": 10},{"name": "鼠标", "price": 20},{"name": "显卡", "price": 998}]
    要求:
    1：页面显示 序号 + 商品名称 + 商品价格，如：1 电脑 1999 2 鼠标垫 10...
    2：用户输入选择的商品序号，然后打印商品名称及商品价格
    3：如果用户输入的商品序号有误，则提示输入有误，并重新输入。
    4：用户输入Q或者q，退出程序。
    """
    # 请补充代码：
    goods = [{"name": "电脑", "price": 1999},{"name": "鼠标垫", "price": 10},{"name": "鼠标", "price": 20},{"name": "显卡", "price": 998}
    ]
    for index in range(len(goods)):item = goods[index]print(index+1,item['name'],item['price'])
    while True:num = input('请输入商品序号(Q/q退出)：')if num.upper() == 'Q':breakelif num.isdecimal() and 0 < int(num) <= 4:num = int(num)-1good = goods[num]print(good['name'],good['price'])else:print('输入有误，请重新输入')continue# 本着"减少if嵌套"，"简单的逻辑先处理"的原则，以上代码可精简成如下：
    goods = [{"name": "电脑", "price": 1999},{"name": "鼠标", "price": 10},{"name": "游艇", "price": 20},{"name": "美女", "price": 998}
    ]
    for index in range(len(goods)):item = goods[index]print(index + 1, item['name'], item['price'])
    while True:num = input("请输入要选择的商品序号(Q/q)：")  # "1"if num.upper() == "Q":breakif not num.isdecimal():print("用输入的格式错误")breaknum = int(num)if num > 4 or num < 0:print("范围选择错误")breaktarget_index = num - 1choice_item = goods[target_index]print(choice_item["name"], choice_item['price'])
    

轩小陌的Python笔记-day07 数据类型相关推荐

1. 轩小陌的Python笔记-day06 数据类型

   day06 数据类型(中) 常见的数据类型: int,整数类型(整形) bool,布尔类型 str,字符串类型 list,列表类型 tuple,元组类型 dict,字典类型 set,集合类型 floa ...

2. 轩小陌的Python笔记-day05 数据类型

   day05 数据类型(上) 接下来的3篇的内容都是讲解数据类型的知识点,常见的数据类型: int,整数类型(整型) bool,布尔类型 str,字符串类型 list,列表类型 tuple,元组类型 d ...

3. 轩小陌的Python笔记-day13 匿名函数、生成器、内置函数、推导式

   day13 内置函数和推导式 今日概要: 匿名函数 生成器 内置函数 附加:推导式,属于数据类型的知识,内部的高级的用法会涉及到[生成器]和[函数]的内容. 1. 匿名函数 传统的函数的定义包括了:函 ...

4. 轩小陌的Python笔记-day25 MySQL入门

   第四模块 MySQL数据库 从今天开始将进入第四模块的学习,这个模块就是给大家讲解MySQL数据库. 以前,在开发程序时,我们会把很多的数据和信息存储到某个文件夹中的文件中,例如:user.txt . ...

5. 轩小陌的Python笔记-day26 必备SQL语句、表关系及授权

   day26 必备SQL和表关系及授权 课程目标:掌握开发中最常见的SQL语句和表关系及授权相关知识点. 课程概要: 必备SQL(8个必备) 表关系 授权 1. 必备SQL语句 上一节讲解了最基础SQL ...

6. 轩小陌的Python笔记-day02 快速上手

   day02 快速上手 课程目标:学习Python最基础的语法知识,可以用代码快速实现一些简单的功能. 课程概要: 初识编码(密码本) 编程初体验 输出 初识数据类型 变量 注释 输入 条件语句 1.初 ...

7. 轩小陌的Python笔记-day17 初识面向对象

   第三模块 面向对象&网络编程&并发编程 第三模块包含的知识内容: 面向对象,Python中支持两种编程方式来编写代码,分别是:函数式编程.面向对象式编程. 函数式 # 定义函数,在函数 ...

8. 轩小陌的Python笔记-day15 内置模块（剩余）和开发规范

   day15 内置模块和开发规范 目标:掌握常见的内置模块的使用及了解软件开发的规范. 今日概要: 内置模块 json time datetime re 开发规范 主文件 配置文件 数据 附件 业务代码 ...

9. 轩小陌的Python笔记-day16 模块二总结

   day16 阶段总结 课程目标:对第二模块 "函数和模块" 阶段的知识点进行总结. 课程概要: 知识补充 阶段总结(思维导图) 1. 知识补充 1.1 nolocal关键字 在之前 ...

最新文章

1. crossdomain.xml配置错误导致登录不了
2. 060_JavaScript作用域
3. 2005年存储市场关键词TOP10
4. 开源项目导入eclipse的一般步骤[转]
5. php启动 大量sess文件,关于PHP中Session文件过多的问题
6. Java访问对象的属性和行为
7. 下班后比你多学2个小时的人，在看这几个公众号
8. AKKA 集群中的发布与订阅Distributed Publish Subscribe in Cluster
9. linux模拟cpu过载,linux下模拟CPU占用100%小程序
10. 一个真正容易成大事的人，大多都熬过这4种苦，看看你熬过几种？
11. 问题六：C++中是干嘛用的（引用类型）
12. 【python】lxml-The E-factory
13. 基于VisualStudio11开发Windows8的Metro sample讲解（1）MessageBox
14. MySQL(13)-----多表查询(子查询)
15. 随机森林模型预测和交叉验证
16. Oracle long 类型转 varchar2
17. 竞争10nm产品市场 联发科新增Helio X35
18. OpenCV情绪识别（Python实现，超简单）
19. 华为eNsp 配置ospf协议
20. cont_c指令_SFB41_CONT_C输入和输出参数

热门文章

1. 【快速排序（Quicksort）】
2. PG系统表之pg_class
3. PostgreSQL pg_dropcache修改（兼容pg13）
4. 实现页面1与页面2的来回切换，其中页面1是主页面
5. Junit 单元测试生成工具Maven插件
6. 忙里偷闲附上打油诗一首
7. exit函数和_exit函数的区别
8. 7月访问学者博士后热门国家入境政策汇总
9. Java计算机毕业设计电影周边产品查找系统源码+系统+数据库+lw文档
10. python学习学习笔记二