python1.9 数据类型 字典

目录

• 2.字典（dict)
  • 2.1 定义
  • 2.2 独有功能
  • 2.3 公共功能
  • 2.4 转换
  • 1.5 其他
    • 1.5.1 存储原理
    • 1.5.2 速度快
    • 1.5.3 嵌套
  • 总结：字典的方法
    • 字典的查看
    • 字典的添加
    • 字典的改值
    • 字典的删除元素
    • 字典的索引
• 3.浮点型（float）
• 作业

2.字典（dict)

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

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

• 容器

• 元素必须键值对

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

  data = { "k1":1, "k1":2 }
  print(data) # {"k1":2}
  

• 无序（在Python3.6+字典就是有序了，之前的字典都是无序。）

  data = { "k1":1,  "k2":2 }
  print(data)
  

2.1 定义

v1 = {}
v2 = dict()

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

info = { 
    "age":12, 
    "status":True,  
    "name":"wupeiqi",   
    "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
}

data_dict = {
    1: 29,
    True: 5
}
print(data_dict) # {1: 5}

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

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

# 用户列表
user_list = [ ("alex","123"), ("admin","666") ]
...

# 用户列表
user_list = [ {"name":"alex","pwd":"123"}, {"name":"eric","pwd":"123"} ]

2.2 独有功能

1. 获取值

   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
   """
   if data == None:
       print("此键不存在")
   else:
       print(data)
   
   if data:
       print(data)
   else:
       print("键不存在")
   """
   
   """
   # 字典的键中是否存在 email
   if "email" in info:
       data = info.get("email")
       print(data)
   else:
   	print("不存在")
   """
   
   data = info.get("hobby",123)
   print(data) # 输出：123
   

   # 案例：
   user_list = {
       "wupeiqi": "123",
       "alex": "uk87",
   }
   
   username = input("请输入用户名：")
   password = input("请输入密码：")
   # None，用户名不存在
   # 密码，接下来比较密码
   pwd = user_list.get(username)
   
   if pwd == None:
       print("用户名不存在")
   else:
       if password == pwd:
           print("登录成功")
   	else:
           print("密码错误")
   

   # 案例：
   user_list = {
       "wupeiqi": "123",
       "alex": "uk87",
   }
   
   username = input("请输入用户名：")
   password = input("请输入密码：")
   # None，用户名不存在
   # 密码，接下来比较密码
   pwd = user_list.get(username)
   
   if pwd:
       if password == pwd:
           print("登录成功")
   	else:
           print("密码错误")
   else:
       print("用户名不存在")
   

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

2. 所有的键

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

   注意：在Python2中 字典.keys()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。

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

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

3. 所有的值

   info = {"age":12, "status":True, "name":"wupeiqi","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":"wupeiqi","email":"xx@live.com"}
   for val in info.values():
       print(val) 
   

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

4. 所有的键值

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

   for item in info.items():
       print(item[0],item[1]) # item是一个元组 (键，值)
   

   for key,value in info.items():
       print(key,value) # key代表键，value代表值，将兼职从元组中直接拆分出来了。
   

   info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
   data = info.items()
   
   if ('age', 12) in data:
       print("在")
   else:
       print("不在")
   

5. 设置值

   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}
   

6. 更新字典键值对

   info = {"age":12, "status":True}
   info.update( {"age":14,"name":"武沛齐"} )   # info中没有的键直接添加；有的键则更新值
   print(info) # 输出：{"age":14, "status":True,"name":"武沛齐"}
   

7. 移除指定键值对

   info = {"age":12, "status":True,"name":"武沛齐"}
   
   data = info.pop("age")
   
   print(info) # {"status":True,"name":"武沛齐"}
   print(data) # 12
   

8. 按照顺序移除（后进先出）

   info = {"age":12, "status":True,"name":"武沛齐"}
   data = info.popitem() # ("name","武沛齐" )
   
   print(info) # {"age":12, "status":True}
   print(data) # ("name","武沛齐")
   

   • py3.6后，popitem移除最后的值。
   • py3.6之前，popitem随机删除。

# 练习题
""" 
结合下面的两个变量 header 和 stock_dict实现注意输出股票信息，格式如下：
	SH601778，股票名称:中国晶科、当前价:6.29、涨跌额:+1.92。
    SH688566，股票名称:吉贝尔、当前价:...               。
	...
"""
header = ['股票名称', '当前价', '涨跌额']

stock_dict = {
    'SH601778': ['中国晶科', '6.29', '+1.92'], 
    'SH688566': ['吉贝尔', '52.66', '+6.96'], 
    'SH688268': ['华特气体', '88.80', '+11.72'], 
    'SH600734': ['实达集团', '2.60', '+0.24']
}

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. 是否包含

   info = { "age":12,  "status":True,"name":"武沛齐" }
   v1 = "age" in info
   print(v1)
   
   v2 = "age" in info.keys()
   print(v2)
   
   if "age" in info:
       pass
   else:
       pass
   

   info = {"age":12, "status":True,"name":"武沛齐"}
   v1 = "武佩奇" in info.values()
   print(v1)
   

   info = {"age": 12, "status": True, "name": "武沛齐"}
   # 输出info.items()获取到的 dict_items([ ('age', 12),  ('status', True),  ('name', 'wupeiqi'),  ('email', 'xx@live.com')  ])
   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["xxxx"] )   	# 报错，通过键为索引去获取之后时，键不存在会报错（以后项目开发时建议使用get方法根据键去获取值）
   
   value = info.get("xxxxx") # None
   print(value)
   

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"]  # 删除info字典中键为age的那个键值对（键不存在则报错）
   
   print(info) # 输出： {"status":True,"name":"武沛齐"}
   

   info = {"age": 12, "status": True, "name": "武沛齐"}
   if "agea" in info:
   
       # del info["age"]
       data = info.pop("age")
       print(info)
       print(data)
   else:
       print("键不存在")
   

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)
"""

总结：字典的方法

字典的查看

1.get 查看一个键

dcit.get 获取到不存在的键时，返回的是None 空值
code = {
    "name" :"stone",
    "age" :"18",
    "school" :"beida"
}

print(code.get("email"))

2. for i in dict 默认显示的字典内的所有键

3. for i in dict.keys 也是显示字典内的所有键

4. for i in dict.values 显示字典的所有的值

5. for i in dict.items 显示字典的所有的值和值

   通过输入的数据可以in 判断有没有在字典内存在

6. 字典可以通过索引的键 来获取到value

   info = {"age": 12, "status": True, "name": "武沛齐"}
   print(info["age"])
   
   

字典的添加

1. 添加一个元素 dict.setdefault

   dict.setdefault("code","111") # 添加一个键和值，如果键存在，字典内的值不变,键不在，添加
   
   

2. 添加一个元素 dict.update #

   # 添加一个键和值，如果键存在，字典内的值值改变, 键不在添加
   

3. 批量加入元素 使用字典的并集 , 不改变原来的字典，新字典没有重复的元素

   code1 = {
       "name" :"stone",
   }
   code2 = {
       "name" :"stone",
       "age" :"18",
       "school" :"beida"
   }
   code3 = code1 | code2
   print(code3)
   

4. 根据索引添加一个元素

   info = {"age": 12, "status": True, "name": "武沛齐"}
   
   info["aaa"]=12
   print(info)
   
   

字典的改值

1. dict.update 更新键的值 当字典键存在时，更新值，当键不存在时，添加键值

   code1 = {
       "name" :"stone",
       "age" :"18",
       "school" :"beida"
   }
   print(code1.update({"name1":"zhangsan"}))
   print(code1)
   

2. 根据索引改一个值

   info = {"age": 12, "status": True, "name": "武沛齐"}
   
   info["name"]="123"
   
   print(info)
   
   

字典的删除元素

1. 使用dict.pop() 删除的元素后，删除的返回值 等于该元素的value

   info = {"age":12, "status":True,"name":"武沛齐"}
   
   data = info.pop("age")
   
   
   
   

2. dict.popitem 随机删除

   在字典中 使用popitem 就是从后往前 依次删除 字典中的元素
   info = {"age": 12, "status": True, "name": "武沛齐"}
   
   print(info.popitem()) # 返回的是 删除的元素
   
   print(info)
   
   

3. 根据索引键 删除一个值

   info = {"age": 12, "status": True, "name": "武沛齐"}
   
   del info['age']
   print(info)
   

字典的索引

info = {"age": 12, "status": True, "name": "武沛齐"}
查看 info["age"]
改值 info["age"]=13
增加 info["aaa"]=44 键不存在 和setuodate 相识
删除 del info["age"]

3.浮点型（float）

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

v1 = 3.14
v2 = 9.89

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

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

  v1 = 3.14 
  data = int(v1)
  print(data) # 3
  

• 想要保留小数点后N位

  v1 = 3.1415926
  result = round(v1,3)
  print(result) # 3.142
  

• 浮点型的坑（所有语言中）
  

  底层原理视频：https://www.bilibili.com/video/BV1354y1B7o1/

  在项目中如果遇到精确的小数计算应该怎么办？

import decimal

v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3

## 总结

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

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

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

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

5. py3.6+之后字典就变为有序了。

6. py3.9 新增了一个 `{} | {} `运算。

7. 字典的常见功能。

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

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

 ```python
 0
 ""
 [] or list()
 () or tuple()
 set()
 None
 {} or dict()

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

作业

1. 根据需求写代码

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

2. 根据需求写代码

   dic1 = {
    'name':['alex',2,3,5],
    'job':'teacher',
    'oldboy':{'alex':['python1','python2',100]}
   }
   
   # 1，将name对应的列表追加⼀个元素’wusir’。
   # 2，将name对应的列表中的alex全变成大写。
   # 3，oldboy对应的字典加⼀个键值对’⽼男孩’:’linux’。
   
   
   # 4，将oldboy对应的字典中的alex对应的列表中的python2删除
   将oldboy对应的字典中的alex对应的列表中的python2删除
   dic1 = {
       'name': ['alex', 2, 3, 5],
       'job': 'teacher',
       'oldboy': {'alex': ['python1', 'python2', 100]}
   }
   最后列表的删除方式  remove pop  索引删除  赋None
   dic1['oldboy']['alex'].remove("python2")
   dic1['oldboy']['alex'].pop(1)
   del dic1['oldboy']['alex'][1]
   dic1['oldboy']['alex'][1]=None
   
   字典的删除 del  update  索引修改
   del dic1.get("oldboy").get('alex')[1]
   
   code = {"alex":[['python1', 100]]}
   dic1['oldboy'].update(code)
   
   dic1['oldboy']['alex']=['python1', 100]
   
   print(dic1)
   
   
   

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

   例如：用户输入 x1|wupeiqi ,则需要再字典中添加键值对 {'x1':"wupeiqi"}
   
   使用 in  判断键是否在字典内
   name_dict = {}
   for key_num in range(1,100):
       name = input("请输入你的用户名（x1 | wupeiqi）：(退出Q/q)")
       if name.upper() == 'Q':
           print("再见")
           break
       else:
           list_name = name.split("|")
           if list_name[0] in name_dict:
               print("用户名已存在，请重新输入")
               continue
           else:
   
               name_dict.update({list_name[0]:list_name[1]})
               print(name_dict)
   使用 dict.get 返回值 Node 判断 当字典为空字典的时候，不适用判断key  因为空的字典 返回都是空
   name_dict = {}
   for key_num in range(1,100):
       name = input("请输入你的用户名（x1 | wupeiqi）：(退出Q/q)")
       if name.upper() == 'Q':
           print("再见")
           break
       else:
           list_name = name.split("|")
           if name_dict.get(list_name[0]):
               print("用户名已存在，请重新输入")
               continue
           else:
   
               name_dict.update({list_name[0]:list_name[1]})
               print(name_dict)
   

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

   • 1

   • -1

   • ""

   • None

   • [1,2]

   • (1,)

   • 1  字典 ok  集合ok
     -1  字典 ok  集合ok
     ""  字典 ok  集合ok
     None  字典 ok  集合ok
     [1,2] 字典 ok  集合no
     (1,) 字典 ok  集合ok
     {11,22,33,4}  字典 ok  集合no 
     {'name':'wupeiq','age':18}  字典 ok  集合no 
     
     

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)
   
   
   key_list = []
   value_list = []
   info = {'k1':'v1','k2':'v2','k3':'v3'}
   
   for key,value in info.items():
       key_list.insert(0, key)
       value_list.insert(0, value)
   
   print(key_list)
   print(value_list)
   
   
   
   
   key_list = []
   value_list = []
   info = {'k1':'v1','k2':'v2','k3':'v3'}
   
   for key in info:
       key_list.insert(0,key)
       value_list.insert(0,info.get(key))
   
   print(key_list)
   print(value_list)
   

6. 字典dic =

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

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

   info = {
       'k1':'v1',
       'k2':[('alex'),('wupeiqi'),('oldboy')],
   }
   
   
   for item in info['k2']:
       print(item)
   
   for item in info.get('k2'):
       print(item)
   
   
   for item in info.pop('k2'):
       print(item)
   

8. 有字符串"k: 1|k1:2|k2:3 |k3 :4" 处理成字典

   str_list = "k: 1|k1:2|k2:3  |k3 :4"
   dict_list={}
   for item in str_list.split("|"):
       key,value =item.split(":")
       # dict_list.setdefault(key.strip(),int(value.strip()))
       # dict_list[key.strip()]=int(value.strip())
       # dict_list.update({key.strip():int(value.strip())})
   print(dict_list)
   

9. 写代码

   """
   有如下值 li= [11,22,33,44,55,66,77,88,99,90] ,将所有大于 66 的值保存至字典的第一个key对应的列表中，将小于 66 的值保存至第二个key对应的列表中。
   
      result = {'k1':[],'k2':[]}
   """
   
   result = {'k1':[],'k2':[]}
   li= [11,22,33,44,55,66,77,88,99,90]
   for item in li:
       if int(item)==66:
           pass
       elif  int(item)>66:
           result['k1'].append(item)
       else:
           result['k2'].append(item)
   
   print(result)
   
   
   
   
   result = {'k1':[],'k2':[]}
   li= [11,22,33,44,55,66,77,88,99,90]
   for item in range(len(li)):
       if int(li[item])==66:
           pass
       elif  int(li[item])>66:
           result['k1'].append(li[item])
       else:
           result['k2'].append(li[item])
   
   print(result)
   

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": "游艇1", "price": 120},
        {"name": "美女", "price": 998}
    ]
    num_list= set()
    state = True
    while state:
        for item  in range(len(goods)):
    
            num = item+1
            num_list.add(str(num))
    
            name = goods[item].get('name')
            price = goods[item].get('price')
    
            print(num,name,price)
    
        choose = input("输入选择的商品序号：（按Q|q退出 ）")
        if choose.upper() == 'Q':
            state=False
        elif  choose in num_list:
            chooses = int(choose)-1
            print(goods[int(chooses)].get('name'),goods[int(chooses)].get('price'))
        else:
            print('输入有误，并重新输入')