巨蟒python全栈开发-第5天 字典&集合

今日大纲:

1.什么是字典

　　字典是以key:value的形式来保存数据,用{}表示. 存储的是key:value

2.字典的增删改查(重点)

　　(1) 添加
　　　　dic[新key] = 值

　　　　setdefault()
　　(2)删除
　　　　pop(key)

　　　　del dict[key]

　　　　popitem()

　　　　clear()

　　(3)修改
　　　　dic[老key] = 新值
　　　　d1.update(d2)   把d2的键值对更新到d1中
　　(4)查询
　　　　dic[key]
　　　　get(key, 值)   #推荐用法
　　　　setdefault(key, value)
　　(5) 遍历,字典是一个可迭代对象

3.字典的相关操作

　　(1) keys() 　　获取到所有的键的集合(高仿列表)
　　(2) values() 　获取到所有的值的集合
　　(3)items() 　　拿到所有的键值对  元组形式

　　(4)解构:

　　a,b=(1,2)

　　a,b=1,2

4.字典的嵌套

　　字典的嵌套. 字典套字典

5.集合(非重点),核心功能:去重复

DAY5-基本数据类型(dict&set)

本节主要内容:

1.字典的简单介绍

2.字典的增删改查及其他操作

3.字典的遍历

4.字典的嵌套

5.set集合

一.字典的简单介绍

　　字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成. 在唯⼀的. 在保存的时候, 根据key来计算出⼀个内存地址. 然后将key-value保存这种算法被称为hash算法, 所以, 切记, 在dict中存储的key-value中的key'必须如果你搞不懂什么是可哈希, 暂时可以这样记, 可以改变的都是不可哈希的, 那么可哈希就一位这不可变,这个是 这个是为了能准确的计算内存地址而规定的.

已知的可哈希(不可变)的数据类型: int, str, tuple, bool
不可哈希(可变)的数据类型: list, dict, set

语法 :
{key1: value1, key2: value2....}
注意: key必须是不可变(可哈希)的. value没有要求.可以保存任意类型的数据.

dic={}
print(type(dic))    #<class 'dict'>
(1)#查找,通过列表引入字典
lst=['周杰伦','林俊杰','蔡依林']   #lst[0]
总结:字典是自定义下标的列表

dic={'jay':'周杰伦','jj':'林俊杰','jolin':'蔡依林'}
print(dic['jay'])     #查找   周杰伦
(2)修改
dic={'jay':'周杰伦','jj':'林俊杰','jolin':'蔡依林'}
dic['jay']='马化腾'    #修改键jay对应的值
print(dic)         #结果{'jay': '马化腾', 'jj': '林俊杰', 'jolin': '蔡依林'}
(3)应用,
在手机袋子的查找手机,通过标签寻找
'''
字典的查找效率比较高
坑: a.字典存储数据的时候是用hash值来存储的,知道hash是个NB的算法就行了
    b.算法不能变(python的),数据必须是不可变的(可哈希)
算法对应相同的值,对于结果
对'键'进行运算,计算出一个值来,下次再算,下次还是这个值
'''
(4)
总结:
　　列表是可变的,不可哈希的
　　元组是不可变的,可哈希的
　　字典的键必须是可哈希的
　　print(hash(123))   #结果产生的hash值:123
　　print(hash('胡辣汤'))
　　print((1,2,3))
(5)
dic={'jay':'周杰伦','王力宏':['龙的传人','唯一','改变自己'],['战狼','战狼2']:'武警'}
print(dic)
结果报错:TypeError: unhashable type: 'list'
总结字典不能作为"键

dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序不是连续的. 所以不能进⾏切片⼯作. 它只能通过key来获取dict中的数据

二.字典的增删改查及其他操作

(1)
增加    dic[新键]=新值
dic[老键]=新值   
dic={'意大利':'李云龙','美国':'美国往事'}
dic['日本']='东京审判'   #新key表示添加
dic['韩国']='釜山行'
dic['美国']="华尔街之狼"    #更新
print(dic)

增加  setdefault(难点)
总结:
　　有添加的功能,如果key是存在的,不添加
　　流程:判断你给的key是否在字典中存在了,如果已经存在了,则不再新增,不存在,则添加

dic={'意大利':'李云龙','美国':'美国往事'}
dic.setdefault('印度')   #只有键,值显示 None
print(dic)   #结果:{'意大利': '李云龙', '美国': '美国往事', '印度': None}

dic.setdefault('印度','三傻大闹宝莱坞')   #即使是空值也不重新赋值
print(dic)      #结果:{'意大利': '李云龙', '美国': '美国往事', '印度': None}

dic.setdefault('美国','三傻大闹宝莱坞')
print(dic)          #结果:{'意大利': '李云龙', '美国': '美国往事', '印度': None}

总结:即使一用setdefault开始创建没有添加值,利用setdefault再次添加也不会更新新的值.
(2)删除 pop/popitem/del/clear

dic={'张艺谋':'红高粱','李安':'断背山','陈凯歌':'霸王别姬','郭德纲':'祖宗十九代'}
方法一
dic.pop('郭德纲')  #重点 需要记住的
print(dic)         #结果:   {'张艺谋': '红高粱', '李安': '断背山', '陈凯歌': '霸王别姬'}
方法二
dic.popitem()      #现在python3.6是删除最后一个,python3.5以前随机删除  ,在Python早期,字典的无序的
print(dic)         #结果: {'张艺谋': '红高粱', '李安': '断背山'}
方法三
del dic['李安']
print(dic)         #结果: {'张艺谋': '红高粱'}

dic.clear()        #清空
print(dic)         #结果: {}

(3)#修改   dic[新键]=新值   update

dic={'河南':'胡辣汤','开封':'灌汤包','武汉':'热干面'}
dic['河南']='烩面'     #总结:老key=新值
print(dic)    #{'河南': '烩面', '开封': '灌汤包', '武汉': '热干面'}

update
dic1={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
dic2={'赵四':'宝宝','刘能':'萌萌','皮校长':'皮长山'}
dic1.update(dic2)
print(dic1)   #dic2把dic1更新   结果:{'赵四': '宝宝', '刘能': '萌萌', '王木生': '范伟', '皮校长': '皮长山'}
print(dic2)   #dic2不变        结果:{'赵四': '宝宝', '刘能': '萌萌', '皮校长': '皮长山'}

小结:update有相同的键,就把原来的值更新,但是不常用

(4)查找

dic1={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
a.   直接使用key就可以拿到value
dic1={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
print(dic1['赵四'])        #结果:刘小光
print(dic1['赵四四'])      #KeyError: '赵四四'  key不存在

b.   get(key)
dic1={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
print(dic1.get('刘能'))     #结果:王晓利
print(dic1.get('刘能能'))     #结果:None  当key不存在返回None
print(dic1.get('刘能能','没有这个人'))     #结果:当key不存在,返回第二个参数,默认第二个参数是None
　　　　　　　　　　　　　　　　　　　　　　　　#结果:没有这个人
c.　　setdefault()

setdefault() 第一个功能是添加(当key不存在),第二个功能是查询(根据你给的key查询)
整个执行流程:判断给的key是否存在,
如果key存在,就不执行新增流程,直接查询出这个key对应的value
如果key不存在,先执行新增操作,再使用key把对应的value查询出来

例一
　　dic1={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
　　ret=dic1.setdefault('皮长山','皮校长')
　　print(ret)   #结果:皮校长  #先找再查

例二
　　dic1={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
　　ret=dic1.setdefault('王木生','宝宝')
　　print(ret)     #结果:范伟   #先找再查

三.字典的遍历

(1)for循环遍历字典
A.
dic={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
直接用for循环
 for key in dic:   #直接循环字典拿到的是key,有key直接拿value
     print(key)
     print(dic[key])

结果:
     赵四
     刘小光
     刘能
     王晓利
     王木生
     范伟
B.
dic={'赵四':'刘晓光','刘能':'王晓利','王木生':'范伟'}
直接for循环
 for key in dic:   　　　　#直接循环字典拿到的是key,有key直接拿value
     print(key,dic[key])   #打印出来的是:键和值
 结果:
 　　赵四 刘小光
 　　刘能 王晓利
 　　王木生 范伟
(2)
A:
不常用,上边有一个更简单的,直接用dic
dic={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
print(dic.keys())   #dict_keys(['赵四', '刘能', '王木生'])  ,像列表,是山寨列表,高仿列表
for el in dic.keys():   #循环,可以获取到每一个key
    print(el)
结果:
 　　赵四
 　　刘能
 　　王木生
B:
dic={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
当只需要值的时候
for v in dic.values():
    print(v)
结果:
     刘小光
     王晓利
     范伟
C:
dic={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
print(dic.values())    #结果:dict_values(['刘小光', '王晓利', '范伟'])
print(dic.keys())      #结果:dict_keys(['赵四', '刘能', '王木生'])
print(dic.items())     #结果:dict_items([('赵四', '刘小光'), ('刘能', '王晓利'), ('王木生', '范伟')])
D:
dic={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
for item in dic.items():
    print(item)    #元组类型
    k=item[0]
    v=item[1]
    print(k,v)
 结果:
　　('赵四', '刘小光')
　　 赵四 刘小光
　  ('刘能', '王晓利')
    刘能 王晓利
    ('王木生', '范伟')
    王木生 范伟
E:
dic={'赵四':'刘小光','刘能':'王晓利','王木生':'范伟'}
for k,v in dic.items():
    print(k,v)

 结果:
　　 赵四 刘小光
　　 刘能 王晓利
　　 王木生 范伟
(3)
a,b=1,2   #解构,解包
print(a)
print(b)

c=1,2,3
print(c)　　　　　　#1,2,3
print(type(c))   #<class 'tuple'>

d=(1,2,3)  #没有解包,直接创建一个元组
print(d)

支持解包的类型: list,tuple
(4)
遍历字典的最简单的方法(最高效的方法)
#for k,v in dic.items():

dic={'周五':'等着放假','周六':'放假','周日':'等着上课'}
a.直接用for循环遍历字典的key
for k in dic:           #k直接拿到的是key
    print(k,dic[k])

b.使用dic.items() 解构可以直接拿到k,v,也就是键和值
for k,v in dic.items():
    print(k,v)

四.字典的嵌套

题目

wf={
    'name':'汪峰',
    'age':52,
    'hobby':['唱歌','上头条','穿皮库'],
    'wife':{
        'name':'章子怡',
        'age':49,
        'hobby':['演戏','上电视','当导师'],
        'tishen':{
            'name':'萌萌',
            'age':28
        },
        'zhuli':{
            'name':'磊磊',
            'age':20
        }
    },
    'zhuli':{
        'name':'宝宝',
        'age':23,
        'hobby':['抽烟','喝酒','烫头']
    },
    'children':[{'name':'汪老大'},{'name':'汪老二'}]
}

练习题:

汪峰第二个孩子的年龄
wf['children'][1]['age']=2
print(wf)
(1)汪峰助理的名字
print(wf['zhuli']['name'])
(2)汪峰老婆的替身的名字
print(wf['wife']['tishen']['name'])
(3)汪峰老婆的第二个爱好
print(wf['wife']['hobby'][1])
(4)汪峰助理的第三个爱好
print(wf['zhuli']['hobby'][2])
(5)给汪峰的助理+10岁     #(两种方法)
wf['zhuli']['age']=wf['zhuli']['age']+10
wf['zhuli']['age']=33
print(wf)
(6)汪峰的老婆添加一个爱好('导戏)
wf['wife']['hobby'].append('导戏')
wf['wife']['hobby'].extend('导戏')        #错误方法,这个是迭代添加   '当导师', '导戏', '导', '戏'
print(wf)
(7)删除汪峰助理的'抽烟'爱好   (三种删除方法)
wf['zhuli']['hobby'].remove('抽烟')
wf['zhuli']['hobby'].pop(0)           #注意pop指定的是索引
del wf['zhuli']['hobby'][0]
print(wf)

五.set集合

(1)
运行之后,是无序的
　　s={'周润发','大润发','王润发','周润发'}    #去重,留下不重复的
　　print(s)
(2)把列表转化成集合 x 转化成y类型 y()

唯一能用到的点,去重复
lst = ["麻将", "牌九", "骰子", "扑克", "虎机", "骰子", "扑克", "虎机", "扑克", "虎机", "扑克", "虎机"]
s=set(lst)
print(s)   #把集合编绘列表

lst=list(s)
print(lst)  #顺序是乱的,但是对比它的优点,是可以忽略的
(3)计算机中麻烦的事情
　　1.去重     2.排序

(4)

了解 集合的增删改查就行,不需要记忆
可以用石墨文档//印象笔记
A.增加
s={'小米','华为','vivo'}
s.add('oppo')  #非要记,就记这个就行了
print(s)

s.update('冬瓜')     #迭代添加
print(s)
B.删
s={'小米','华为','vivo'}
ret=s.pop()   #随机删除一个
print(s)     #剩下的集合
print(ret)    #删除的元素

s.remove('小米')   #指定删除
print(s)
重点记忆:集合和字典,都是没有索引和切片的,因为两者内部都是乱序的
s.clear()    #清空
print(s)

C.改
修改,先删除,再添加
把小米改成J罗
s={'小米','华为','vivo'}
s.remove('小米')
s.add('J罗')
print(s)

for el in s:
    print(el)    #迭代打印

(5)
数学运算
s1={1,2,3}
s2={1,2,4}

交集   &与字符
print(s1&s2)
print(s1.intersection(s2))

并集
print(s1|s2)
print(s1.union(s2))

差集
print(s1-s2)   #s1中特有的内容
print(s1.difference(s2))

反交集
print(s1^s2)  #两个集合中特有的内容
print(s1.symmetric_difference(s2))
反交集是什么?
例如：集合A={0,1,2,3}，集合B={2，3}
那么集合A和集合B的交集就是{2,3}
集合A和集合B的反交集就是{0,1}

(6)
集合本身是可变的数据类型,不可哈希
集合套集合->不能相互嵌套的
集合中的元素必须可哈希(不可变的)
s={123}

#<冰雪奇缘>
如果非要集合套集合
s=frozenset({'哈哈','呵呵'})   #不可变的数据类型(集合)
print(s)
验证
for el in s:
    print(el)
(7)
关于set集合作业:写一个彩票开奖(36选7)
什么时候够7个就结束
怎么产生随机数

#题目解法答案:

from random import randint
l=set()
# print(type(l))            #查看l的数据类型
for i in range(100):
    k=randint(1,36)         #randint是在一个自定义范围内产生随机整数,
    # print(randint(1,36))
    l.add(k)
    if len(l)==7:　　　　　　#生成7个不重复的代码3
　　　　  break
print(l,i)                 #最后显示,添加集合的结果,一共随机了几个数

(8)
预习
    深浅拷贝
    小数据池;是干嘛的,小数据池存在的意义

    文件操作(带来的作业会很多)

    开讲-函数:
    第一次考试:从开始到文件操作
    下周:函数
    　　f(x)=x+1
       f(1)=2
    难点:多线程,多线程之后是一马平川
　　　　　　不只是多线程,还有多进程,单线程,单进程,协程等等

今日作业

# 1，有如下变量（tu是个元祖），请实现要求的功能
# tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11, 22, 33)}, 44])
# a.讲述元祖的特性
'''
不可更改的数据类型,有序
'''
# b.请问tu变量中的第一个元素, "alex",是否可被修改？
'''
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11, 22, 33)}, 44])
tu[0]=1
print(tu)
#TypeError: 'tuple' object does not support item assignment
上边案例说明,tu是不可变数据类型,第一层元素的第一个元素是不可以更改的
#字符串不可变
#元组第一层不可变
'''

# c.请问tu变量中的"k2"
# 对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素"Seven"
'''
(1)对应的是列表类型(list)
(2)是可以被修改的
(3)
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11, 22, 33)}, 44])
tu[1][2]['k2'].append('Seven')
print(tu)
'''

# d.请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素"Seven"

'''
(1)元组
(2)不可以被修改
(3)#强行转也是可以的
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11, 22, 33)}, 44])
tu[1][2]['k3'].append('Seven')
print(tu)
#结果报错:AttributeError: 'tuple' object has no attribute 'append'
'''

2， 字典dic, dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}

# a.请循环输出所有的key
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
#方法一
# for i in dic:
#     print(i)
#方法二:
# for i in dic.keys():
#     print(i)
'''
# b.请循环输出所有的value
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
# 方法一
for i in dic:
    print(dic[i])
# 方法二:
for i in dic.keys():
    print(dic[i])
'''
# c.请循环输出所有的key和value
'''
#方法一:
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
for i in dic:
    print(i,dic[i])
#方法二:
for k,v in dic.items():
    print(k,v)
'''
# d.请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
# 方法一:
# dic['k4']='v4'
# print(dic)
#方法二
# dic.setdefault('k4','v4')
# print(dic)
'''

# e.请在修改字典中"k1"对应的值为"alex"，输出修改后的字典
'''
#方法一:
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic['k1']='alex'
print(dic)
# 方法二
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic1={'k1':'alex'}
dic.update(dic1)
print(dic)
'''

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

3，

av_catalog = {
    "欧美": {
        "www.youporn.com": ["很多免费的,世界最大的", "质量一般"],
        "www.pornhub.com": ["很多免费的,也很大", "质量比yourporn高点"],
        "letmedothistoyou.com": ["多是自拍,高质量图片很多", "资源不多,更新慢"],
        "x-art.com": ["质量很高,真的很高", "全部收费,屌丝请绕过"]
    },
    "日韩": {
        "tokyo-hot": ["质量怎样不清楚,个人已经不喜欢日韩范了", "verygood"]
    },
    "大陆": {
        "": ["全部免费,真好,好人一生平安", "服务器在国外,慢"]
    }
}

# a, 给此["很多免费的,世界最大的", "质量一般"]列表第二个位置插入一个元素：'量很大'。
#注意这个插入的方法的应用
av_catalog['欧美']["www.youporn.com"].insert(1,'量很大')
print(av_catalog)
# b, 将此["质量很高,真的很高", "全部收费,屌丝请绕过"]列表的"全部收费,屌丝请绕过"删除。
#方法:del remove pop

#方法一
# av_catalog['欧美']["x-art.com"].pop()
# print(av_catalog)
#方法二:
# del av_catalog['欧美']["x-art.com"][1]
# print(av_catalog)
# 方法三:
# av_catalog['欧美']["x-art.com"].pop(1)
# print(av_catalog)
#方法四:
# av_catalog['欧美']["x-art.com"].remove("全部收费,屌丝请绕过")
# print(av_catalog)
'''
# c, 在此["质量很高,真的很高", "全部收费,屌丝请绕过"]列表中添加"金老板最喜欢这个"。
'''
#方法一
# av_catalog['欧美']['x-art.com'].append('金老板最喜欢这个')
# print(av_catalog)
#方法二
# av_catalog['欧美']['x-art.com'].insert(-1,'金老板最喜欢这个')
# print(av_catalog)
'''
# d, 将此["质量怎样不清楚,个人已经不喜欢日韩范了", "verygood"]列表的"verygood"全部变成大写。
'''
#方法一
# av_catalog['日韩']['tokyo-hot'][-1]=av_catalog['日韩']['tokyo-hot'][-1].upper()
# print(av_catalog)
#方法二
# av_catalog['日韩']['tokyo-hot'][-1]=av_catalog['日韩']['tokyo-hot'][-1].swapcase()
# print(av_catalog)
# 方法三
# av_catalog['日韩']['tokyo-hot'][-1]='VERYGOOD'
# print(av_catalog)
#方法四
# av_catalog['日韩']['tokyo-hot'][1]='VERYGOOD'
# print(av_catalog)
'''
# e, 给'大陆'对应的字典添加一个键值对 '1048': ['一天就封了']
'''
#方法一
# av_catalog['大陆']['1048']='一天就封了'
# print(av_catalog)
# 方法二
# av_catalog['大陆'].setdefault('1048','一天就封了')
# print(av_catalog)
'''
# f, 删除此 "letmedothistoyou.com": ["多是自拍,高质量图片很多", "资源不多,更新慢"]键值对。
'''
#pop和del 可以指定删除字典
# 方法一
# av_catalog['欧美'].pop('letmedothistoyou.com')
# print(av_catalog)
#方法二
# del av_catalog['欧美']['letmedothistoyou.com']
# print(av_catalog)
'''
# g, 给此["全部免费,真好,好人一生平安", "服务器在国外,慢"]列表的第一个元素，加上一句话：'可以爬下来'
'''
#方法一;在最前面添加一个元素"可以爬下来"
# av_catalog['大陆']['1024'].insert(0,'可以爬下来')
# print(av_catalog)
#方法二1:#在第一个元素的后面添加
# av_catalog['大陆']['1024'][0]=av_catalog['大陆']['1024'][0]+'可以爬下来'
# print(av_catalog)
#方法二2:
av_catalog['大陆']['1024'][0]='全部免费,真好,好人一生平安可以爬下来'
print(av_catalog)

 4、有字符串
 "k:1|k1:2|k2:3|k3:4"
 处理成字典
 {'k': 1, 'k1': 2....}(升级题)

#方法一:
# dic={}
# s="k:1|k1:2|k2:3|k3:4"
# s=s.split("|")
# print(s)
# for i in s:
#     a,b=i.split(':')
#     dic[a]=int(b)
# print(dic)

#方法二
# dic={}
# s="k:1|k1:2|k2:3|k3:4"
# s=s.split("|")
# print(s)
# for i in s:
#     a=i.split(':')
#     dic[a[0]]=int(a[1])
# print(dic)

 5、元素分类
 有如下值li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]，将所有大于66的值保存至字典的第一个key中，将小于66
 的值保存至第二个key的值中。
 即： {'k1': 大于66的所有值列表, 'k2': 小于66的所有值列表}

方法一

s={'k1':[],'k2':[]}
 li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
 for i in li:
     if i>66:
         s['k1'].append(i)
     elif i<66:
         s['k2'].append(i)
     else:
         continue
 print(s)

方法二

 s={}
 li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
 for i in li:
     if i>66:
         s.setdefault('k1',[]).append(i)
     elif i<66:
         s.setdefault('k2',[]).append(i)
     else:
         continue
 print(s)

6、输出商品列表，用户输入序号，显示用户选中的商品(升级题)
商品列表：
 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 i in range(len(goods)):
    print(i+1,goods[i]['name'],goods[i]['price'])
while 1:
    content = input("输入Q退出,或请输入选择的商品序号:").strip()
    if content.upper()=='Q':
        break
    elif content.isdigit():
        if int(content) in range(1,len(goods)+1):
            print(int(content),goods[int(content)-1]['name'],goods[int(content)-1]['price'])
        else:
            print('输入错误,请重新输入')
    else:
        print('输入错误,请重新输入')

方法二:运用三元运算符

goods = [{"name": "电脑", "price": 1999},
         {"name": "鼠标", "price": 10},
         {"name": "游艇", "price": 20},
         {"name": "美女", "price": 998}, ]
for i in range(len(goods)):
    print(i+1,goods[i]['name'],goods[i]['price'])
while 1:
    content = input("输入Q退出,或请输入选择的商品序号:").strip()
    if content.upper()=='Q':
        break
    elif content.isdigit():
        print(int(content),goods[int(content)-1]['name'],goods[int(content)-1]['price'] if int(content) in range(1,len(goods)+1) else print('输入错误,请重新输入'))
    else:
        print('输入错误,请重新输入')

补充:字典没有就显示后面的这条数据