字典

1、字典是由键-值(key-value)对构成的映射数据类型 ，字典也被称作关联数组或哈希表

2、字典元素用大括号{ }包裹

3、字典中的键是唯一的，而值并不唯一

4、值可以取任何数据类型，但键必须是不可变的，如字符串，数或元组

5、通过键取值，不支持下标操作

6、不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

1、创建字典

1.通过{ }操作符创建字典
2.通过dict()工厂方法创建字典
3.通过fromkeys()创建具有相同值的默认字典

#!/usr/bin/env python
#coding:utf-8

aDict = {'name':'bob', 'age':23}
bDict = dict((['name', 'bob'], ['age', 23]))
cDict = {}.fromkeys(('bob', 'alice'), 23)
print aDict
print bDict
print cDict

执行结果：

{'age': 23, 'name': 'bob'}
{'age': 23, 'name': 'bob'}
{'bob': 23, 'alice': 23}

2、访问字典

字典是映射类型，意味着它没有下标，访问字典中的值需要使用相应的键

#!/usr/bin/env python
#coding:utf-8

aDict = {'name':'bob', 'age':23}
for eachKey in aDict:
    print "key=%s,value=%s" % (eachKey,aDict[eachKey])

print '%(name)s' % aDict

执行结果：

key=age,value=23
key=name,value=bob
bob

3、更新字典

1.通过键更新字典
2.如果字典中有该键，则更新相关值
3.如果字典中没有该键，则向字典中添加新值

#!/usr/bin/env python
#coding:utf-8

aDict = {'name':'bob', 'age':23}
print aDict
aDict['age'] = 22
print aDict
aDict['email'] = '123@qq.com'
print aDict

执行结果：

{'age': 23, 'name': 'bob'}
{'age': 22, 'name': 'bob'}
{'age': 22, 'name': 'bob', 'email': '123@qq.com'}

4、删除字典

1.通过del可以删除字典中的元素或整个字典
2.使用内部方法clear()可以清空字典
3.使用pop()方法可以“弹出”字典中的元素

#!/usr/bin/env python
#coding:utf-8

aDict = {'name':'bob', 'age':23}
print aDict
aDict['age'] = 22
print aDict
aDict['email'] = '123@qq.com'
print aDict
del aDict['email']
print aDict
print aDict.pop('age')
print aDict
aDict.clear()
print aDict

执行结果：

{'age': 23, 'name': 'bob'}
{'age': 22, 'name': 'bob'}
{'age': 22, 'name': 'bob', 'email': '123@qq.com'}
{'age': 22, 'name': 'bob'}
22
{'name': 'bob'}
{}

5、字典操作符

1.使用字典键查找操作符[ ]，查找键所对应的值

2.使用in和not in判断键是否存在于字典中

#!/usr/bin/env python
#coding:utf-8

aDict = {'name':'bob', 'age':23}
print aDict['name']
print 'bob' in aDict
print 'name' in aDict

执行结果：

bob
False
True

6、作用于字典的函数

1.len()：返回字典中元素的数目
2.hash()：本身不是为字典设计的，但是可以判断某个对象是否可以作为字典的键

#!/usr/bin/env python
#coding:utf-8

aDict = {'name':'bob', 'age':23}
print aDict
print len(aDict)
print hash(3)
print hash([])

执行结果:这里的报错顺序做了调整

{'age': 23, 'name': 'bob'}
2
3

Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'list

7、字典内置函数&方法

Python字典包含了以下内置函数

 Python字典包含了以下内置函数

字典操作实例:

>>> aDict = {'age': 23, 'name': 'bob'}
>>> aDict
{'age': 23, 'name': 'bob'}


>>> aDict['gender'] = 'male'  #增加
>>> aDict
{'gender': 'male', 'age': 23, 'name': 'bob'}

>>> aDict.clear()  #删除字典内所有元素
>>> aDict  #clear()方法是用来清除字典中的所有数据，因为是原地操作，所以返回None（也可以理解为没有返回值）
{}


>>> aDict = {'gender': 'male', 'age': 23, 'name': 'bob'}
>>> aDict
{'gender': 'male', 'age': 23, 'name': 'bob'}
>>> bDict = aDict.copy()   #返回字典的浅复制
>>> bDict
{'gender': 'male', 'age': 23, 'name': 'bob'}
>>> 

>>> bDict['name'] = "john"
>>> bDict
{'gender': 'male', 'age': 23, 'name': 'john'}
>>> aDict
{'gender': 'male', 'age': 23, 'name': 'bob'}
>>> 


#fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值
#fromkeys()方法语法：dict.fromkeys(seq[, value]))

 #seq -- 字典键值列表。

#value -- 可选参数, 设置键序列（seq）的值。

>>> seq = ["name",'age',"gender"]
>>> Dict1 = dict.fromkeys(seq)
>>> Dict1
{'gender': None, 'age': None, 'name': None}
>>> 
>>> 
>>> Dict1 = dict.fromkeys(seq,10)
>>> Dict1
{'gender': 10, 'age': 10, 'name': 10}
>>> 

>>> Dict1.get("gender") #返回指定键的值，如果值不在字典中返回default值
10

>>> Dict1.has_key(10)   #如果键在字典dict里返回true，否则返回false
False
>>> Dict1.has_key("age")
True
>>> 

>>> Dict1.items()  #以列表返回可遍历的(键, 值) 元组数组
[('gender', 10), ('age', 10), ('name', 10)]
>>> 

>>> Dict1.keys() #以列表返回一个字典所有的键
['gender', 'age', 'name']
>>> Dict1.values() 以列表返回字典中的所有值
[10, 10, 10]


>>> Dict1.pop("gender")  #删除给定键所对应的值，返回这个值并从字典中把它移除
10
>>> Dict1
{'age': 10, 'name': 10}
>>> 

>>> Dict1.popitem()  #随机返回并删除字典中的一对键和值（项）
('age', 10)
>>> Dict1
{'name': 10}
>>> 



>>> Dict1.setdefault("age") #Python 字典 setdefault() 函数和get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
>>> Dict1
{'age': None, 'name': 10}
>>> Dict1.setdefault('name')
10
>>> Dict1
{'age': None, 'name': 10}
>>> 

>>> Dict2 = {"gender":"male"}  
>>> Dict1.update(Dict2) #把Dict2的键值对更新到Dict1里面
>>> Dict1
{'gender': 'male', 'age': None, 'name': 10}
>>> Dict2
{'gender': 'male'}

>>> Dict1.viewitems()
dict_items([('gender', 'male'), ('age', None), ('name', 10)])

>>> Dict1.viewkeys()
dict_keys(['gender', 'age', 'name'])

>>> Dict1.viewvalues()
dict_values(['male', None, 10])
>>> 


元组嵌套：
>>> t = (11,22,["alex",{"k1":"v1"}])
>>> t[2][1]['k1']
'v1'
>>> 

tuple,dict,list之间的转换

　　直接声明的list和tuple无法通过dict()转换成dict类型

　　直接声明的dict可以通过tuple()和list()分别转换成tuple和list类型（结果只包含了keys），可是此时却能通过dict()反转回原来的dict类型

1. 字典

    

#!/usr/bin/env python
#coding:utf-8
dict = {'name': 'Zara', 'age': 7}
#字典转为字符串
print str(dict)

#字典可以转为元组
print tuple(dict)

#字典可以转为元组
print tuple(dict.values())

#字典转为列表
print list(dict)

#字典转为列表
print dict.values()

执行结果：

{'age': 7, 'name': 'Zara'}
('age', 'name')
(7, 'Zara')
['age', 'name']
[7, 'Zara']

2、元组
 

#!/usr/bin/env python
#coding:utf-8

tup=(1, 2, 3, 4, 5,6,7,8)
#元组转为字符串
print tup.__str__()
#元组转为列表
print list(tup)
#元组不可以转为字典

 执行结果：

(1, 2, 3, 4, 5, 6, 7, 8)
[1, 2, 3, 4, 5, 6, 7, 8]

3、列表

    

#!/usr/bin/env python
#coding:utf-8

nums=[1, 3, 5, 7, 9, 11, 13]
#列表转为字符串
print str(nums)
#列表转为元组
print tuple(nums)
#列表不可以转为字典

执行结果：

[1, 3, 5, 7, 9, 11, 13]
(1, 3, 5, 7, 9, 11, 13)

4、字符串
 

#!/usr/bin/env python
#coding:utf-8

str="(1,2,3)"
#字符串转为元组
print tuple(eval(str))
#字符串转为列表
print list(eval("(1,2,3)"))
#字符串转为字典
str1="{'name':'alex', 'age':24}"
print eval(str1)

执行结果：

(1, 2, 3)
[1, 2, 3]
{'age': 24, 'name': 'alex'}

练习字典

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

　　a.请循环输出所有的key

　　b.请循环输出所有的value

　　c.请循环输出所有的key和value

　　d.请在字典中添加一个键值对，"k4":"v4"，输出添加后的字典

　　e.请在修改字典中“k1”对应的值为“alex”，输出修改后的字典

　　f.请在k3对应的值中追加一个元素44，输出修改后的字典

　　g.请在k3对应的值的第1个位置插入个元素18，输出修改后的字典

dic={'k1':"v1","k2":"v2","k3":[11,22,33]}
# 　　a.请循环输出所有的key
for i in dic :
    print(i)
for i in dic.keys():
    print(i)
# 　　b.请循环输出所有的value
for i in dic.values():
    print(i)
　　c.请循环输出所有的key和value
for i,j in dic.items():
    print(i,j)
# 　　d.请在字典中添加一个键值对，"k4":"v4"，输出添加后的字典
dic2 = {'k4':'v4'}
dic.update(dic2)
print(dic)
dic['k4'] = 'v4'
print(dic)
 
# 　　e.请在修改字典中“k1”对应的值为“alex”，输出修改后的字典
dic['k1'] ='alex'
print(dic)
　　f.请在k3对应的值中追加一个元素44，输出修改后的字典
dic['k3'].append(44)
print(dic)
# 　　g.请在k3对应的值的第1个位置插入个元素18，输出修改后的字典
dic['k3'].insert(0,18)
print(dic)

练习1：

编写一个石头、剪刀、布的游戏。你和计算机各出一项，判断输赢。

提示：计算机出什么，可以使用random模块中的choice随机在一个列表中选择某一项

#!/usr/bin/env python
#coding: utf8

import random
import sys

allList = ['石头', '剪刀', '布']
gDict = {'石头':0, '剪刀':1, '布':2}
prompt = """(0)石头
(1)剪刀
(2)布
请选择对应的数字: """

chnum = raw_input(prompt)
if chnum not in '012':
    print 'Invalid choice'
    sys.exit(1)

uchoice = allList[int(chnum)]
cchoice = random.choice(allList)
#print '您选择了:', uchoice, '\n计算机选择了:',cchoice
print '您选择了: %s\n计算机选择了:%s' % (uchoice, cchoice)
if uchoice == cchoice:
    print '平局'
elif (gDict[cchoice] - gDict[uchoice] == 1) or (gDict[cchoice] - gDict[uchoice] == -2):
    print 'You WIN!!!'
else:
    print 'You LOSE!!!'

执行结果：

(0)石头
(1)剪刀
(2)布
请选择对应的数字: 0
您选择了: 石头
计算机选择了:剪刀
You WIN!!!

练习：寻找差异

# 数据库中原有
old_dict = {
    "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 },
    "#2":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
    "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
}
   
# cmdb 新汇报的数据
new_dict = {
    "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 800 },
    "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
    "#4":{ 'hostname':c2, 'cpu_count': 2, 'mem_capicity': 80 }
}

执行方法：

#!/usr/bin/env python
#-*- coding:utf-8 -*-


old_dict = {
    "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }
            }

# cmdb 新汇报的数据

new_dict = {
    "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },
    "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 }
            }

#方法1:
for k in new_dict:
# #通过键更新值，new_dict[k]通过键更新字典
#new_dict[k]表示的是新字典中的值,键中是有值的；old_dict[k] = new_dict[k]这条命令表示将新字典的值更新到旧字典中；若有则改变，无则添加new_dict[k]
    old_dict[k] = new_dict[k] 

print old_dict
#方法2：
#也可以用update
old_dict.update(new_dict)  #把new_dict的键值更新到old_dict里面

#更新字典

#1.通过键更新字典
#2.如果字典中有该键，则更新相关值
#3.如果字典中没有该键，则向字典中添加新值 

执行结果：

{'#3': {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80}, '#2': {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80}, '#1': {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 800}, '#4': {'hostname': 'c2', 'cpu_count': 2, 'mem_capicity': 80}}

练习:

1 练习：元素分类
2 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
3 即： {'k1': 大于66 , 'k2': 小于66}

回答：

a=[11,22,33,44,55,66,77,88,99,90]
dict1={'k1':[],'k2':[]}

for i in a:
    if i >66:
        dict1['k1'].append(i)
    else:
        dict1['k2'].append(i)
print dict1

最好的是用下面的方法来动态的扩展字典：
a=[11,22,33,44,55,66,77,88,99,90]
dict1={}  #动态的增加字典

for i in a:
    if i >66:
        if 'k1' in dict1.keys():
            dict1['k1'].append(i)
        else:
            dict1['k1'] = [i,]
    else:
        if 'k2' in dict1.keys():
            dict1['k2'].append(i)
        else:
            dict1['k2'] = [i,]
print dict1

练习：

第1题

1，有如下变量(tu是个元祖)，请实现要求的功能
    tu = ("alex", [11, 22, {"k1": 'v1',元祖的特性 "k2": ["age", "name"], "k3": (11,22,33)}, 44])
    a. 讲述元祖的特性
    答案：
    1.创建之后不能加减修改元素
    2.元素也可以是数字、字符、变量或者混杂
    3.元组也可以嵌套
 
    b. 请问tu变量中的第一个元素 "alex" 是否可被修改？
    答案： 不可以
 
    c. 请问tu变量中的"k2"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素 "Seven"
    答案："k2"对应的值是列表，可以修改。
    修改代码如下:
    tu[1][2]['k2'].append('Seven')
 
    d. 请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素 "Seven"
    答案："k3"对应的值是元组类型，不可以修改

第2题

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)
 
    b. 请循环输出所有的value
 
    dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
    for i in dic.values():
        print(i)
 
    c. 请循环输出所有的key和value
 
    dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
    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)
 
    e. 请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
 
    dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
    dic['k1'] = 'alex'
    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)
    print(dic)

第3题：

3，av_catalog = {
    "欧美":{
        "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
        "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
        "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
        "x-art.com":["质量很高,真的很高","全部收费,屌丝请绕过"]
    },
    "日韩":{
        "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","verygood"]
    },
    "大陆":{
        "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
    }
}
 
    # 1，给此 ["很多免费的,世界最大的","质量一般"]列表第二个位置插入一个元素：'量很大'。
 
    av_catalog['欧美']['www.youporn.com'].insert(1,'量很大')
 
    # 2，将此 ["质量很高,真的很高","全部收费,屌丝请绕过"]列表的 "全部收费,屌丝请绕过" 删除。
 
    av_catalog['欧美']['x-art.com'].pop(1)
 
    # 3，将此 ["质量很高,真的很高","全部收费,屌丝请绕过"]列表的 "全部收费,屌丝请绕过" 删除。
 
    av_catalog['欧美']['x-art.com'].pop(1)
 
    # 4，将此["质量怎样不清楚,个人已经不喜欢日韩范了","verygood"]列表的 "verygood"全部变成大写。
 
    av_catalog['日韩']['tokyo-hot'][1].upper()
 
    # 5，给 '大陆' 对应的字典添加一个键值对 '1048' :['一天就封了']
 
    av_catalog['大陆']['1048'] = ['一天就封了']
 
    # 6，删除此"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"]键值对。
 
    av_catalog['欧美'].pop('letmedothistoyou.com',None)
 
    # 7，给此["全部免费,真好,好人一生平安","服务器在国外,慢"]列表的第一个元素，加上一句话：'可以爬下来'
 
    av_catalog['大陆']['1024'][0] = av_catalog['大陆']['1024'][0]+'可以爬下来'

第4题

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

先使用split()指定分割符| 切割成列表

li = "k:1|k1:2|k2:3|k3:4"
li_s = li.split('|')
for i in li_s:
    print(i)

执行输出：

k:1
k1:2
k2:3
k3:4

在for循环里面是，指定分割符：，再次切割

li = "k:1|k1:2|k2:3|k3:4"
li_s = li.split('|')
for i in li_s:
    q = i.split(':')
    print(q)

执行输出：

['k', '1']
['k1', '2']
['k2', '3']
['k3', '4']

那么列表中索引为0的就是key，索引为1就是value

使用字典方法添加键值对，完整代码如下：

li = "k:1|k1:2|k2:3|k3:4"
#使用|分割成列表
li_s = li.split('|')
#空字典
dic = {}
for i in li_s:
    #使用:分割成列表
    qie = i.split(':')
    # #字典key
    key = qie[0]
    #字典value
    value = qie[1]
    #添加键值对
    dic[key] = value
 
#打印字典
print(dic)

执行输出：

{'k1': '2', 'k2': '3', 'k': '1', 'k3': '4'}

代码优化

li = "k:1|k1:2|k2:3|k3:4"
#使用|分割成列表
li_s = li.split('|')
#空字典
dic = {}
for i in li_s:
    #使用:分割成列表
    qie = i.split(':')
    #添加键值对
    dic[qie[0]] = qie[1]
 
#打印字典
print(dic)

执行输出：

{'k3': '4', 'k2': '3', 'k': '1', 'k1': '2'}

将数字转换为整型

li = "k:1|k1:2|k2:3|k3:4"
#使用|分割成列表
li_s = li.split('|')
#空字典
dic = {}
for i in li_s:
    #使用:分割成列表
    qie = i.split(':')
    #添加键值对
    dic[qie[0]] = int(qie[1])
 
#打印字典
print(dic)

执行输出：

{'k2': 3, 'k': 1, 'k1': 2, 'k3': 4}

第5题：

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

先打印列表的每一个元素

li= [11,22,33,44,55,66,77,88,99,90]
for i in li:
    print(i)

执行输出：

11
22
33

...

90

定义字典，将大于66的，放入k1的列表中

li= [11,22,33,44,55,66,77,88,99,90]
#定义字典，key和value是空列表
dic1 = {'k1': [], 'k2': []}
for i in li:
    if i > 66:
        dic1['k1'].append(i)
print(dic1)

执行输出：

{'k2': [], 'k1': [77, 88, 99, 90]}

将小于66的放入k2中，完整代码如下：

li= [11,22,33,44,55,66,77,88,99,90]
#定义字典，key和value是空列表
dic1 = {'k1': [], 'k2': []}
 
for i in li:
    #判断i是否大于66
    if i > 66:
        #追加到k1中
        dic1['k1'].append(i)
    else:
        # 追加到k2中
        dic1['k2'].append(i)
 
print(dic1)

执行输出：

{'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]}

由于66跑到k2里面了，在改一下判断条件

li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
# 定义字典，key和value是空列表
dic1 = {'k1': [], 'k2': []}
 
for i in li:
    # 判断i是否大于66
    if i > 66:
        # 追加到k1中
        dic1['k1'].append(i)
    elif i <= 66:
        # 追加到k2中
        dic1['k2'].append(i)
 
print(dic1)

执行输出：

{'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55, 66]}

第6题

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

    商品 li = ["手机", "电脑", '鼠标垫', '游艇']

要求：1：页面显示 序号 + 商品名称，如：

        1 手机
        2 电脑
             …
        2： 用户输入选择的商品序号，然后打印商品名称
        3：如果用户输入的商品序号有误，则提示输入有误，并重新输入。
        4：用户输入Q或者q，退出程序。

先输入商品列表，并打印序号(使用index方法)

li = ["手机", "电脑", '鼠标垫', '游艇']
for i in li:
    #索引值
    index = li.index(i)
    print(index,i)

执行输出：

0 手机
1 电脑
2 鼠标垫
3 游艇

有了序号，就可以打印商品

判断用户的输入的内容是否为数字，定义一个非法字符串aa

li = ["手机", "电脑", '鼠标垫', '游艇']
#用户输入内容
entry = 'aa'
for i in li:
    #索引值
    index = li.index(i)
    #判断用户输入的，是否是数字
    if entry.isdigit():
        #输入的序号转换为数字
        entry_int = int(entry)
    else:
        print('您输入的含有非数字元素')
        break

执行输出：

您输入的含有非数字元素

判断用户输入的数字是否大于列表的长度，定义一个数字11

li = ["手机", "电脑", '鼠标垫', '游艇']
#用户输入内容
entry = '11'
for i in li:
    #索引值
    index = li.index(i)
    #判断用户输入的，是否是数字
    if entry.isdigit():
        #输入的序号转换为数字
        entry_int = int(entry)
        #判断序号是否大于列表长度
        if entry_int < len(li):
            #打印商品列表
            print(li[entry_int])
            break
        else:
            print('你输入的序号商品不存在,请重新输入!')
            break
    else:
        print('您输入的含有非数字元素')
        break

执行输出：

你输入的序号商品不存在,请重新输入!

重新修改数字为1，再次执行，就可以输出商品了。

上面的代码是一次性输入，如果需要循环执行，怎么办？用while循环

先来一个简单的循环输入input，根据第4点要求，遇到Q或者q，退出程序

flag = True
while flag:
    entry = input('请输入序号：').strip()
    #将内容转换为大写, 判断是否是Q
    if entry.upper() == 'Q':
        flag = False
        print('退出程序')

执行程序：

执行执行之前，打印商品列表

li = ["手机", "电脑", '鼠标垫', '游艇']
#标志位
flag = True
#遍历商品列表
for i in li:
    # 索引值
    index = li.index(i)
    #打印序号和商品名称
    print(index, i)
while flag:
    entry = input('请输入序号：').strip()
    #将内容转换为大写, 判断是否是Q
    if entry.upper() == 'Q':
        flag = False
        print('退出程序')
    else:
        pass

执行输出：

将6.3里面的for循环代码复制，替换到6.5里面pass里面，最后代码如下：

li = ["手机", "电脑", '鼠标垫', '游艇']
#标志位
flag = True
#遍历商品列表
for i in li:
    # 索引值
    index = li.index(i)
    #打印序号和商品名称
    print(index, i)
while flag:
    entry = input('请输入序号：').strip()
    #将内容转换为大写, 判断是否是Q
    if entry.upper() == 'Q':
        flag = False
        print('退出程序')
    else:
        for i in li:
            # 索引值
            index = li.index(i)
            # 判断用户输入的，是否是数字
            if entry.isdigit():
                # 输入的序号转换为数字
                entry_int = int(entry)
                # 判断序号是否大于列表长度
                if entry_int < len(li):
                    # 打印商品列表
                    print(li[entry_int])
                    break
                else:
                    print('你输入的序号商品不存在,请重新输入!')
                    break
            else:
                print('您输入的含有非数字元素')
                break

执行输出：

 输出部分修饰一下：

li = ["手机", "电脑", '鼠标垫', '游艇']
#标志位
flag = True
print('''
|欢迎访问天猫商店|
|序号| |商品名|
''')
#遍历商品列表
for i in li:
    # 索引值
    index = li.index(i)
    #打印序号和商品名称
    print('    '+str(index), ' '+i)
while flag:
    entry = input('请输入序号：').strip()
    #将内容转换为大写, 判断是否是Q
    if entry.upper() == 'Q':
        flag = False
        print('退出程序')
    else:
        for i in li:
            # 索引值
            index = li.index(i)
            # 判断用户输入的，是否是数字
            if entry.isdigit():
                # 输入的序号转换为数字
                entry_int = int(entry)
                # 判断序号是否大于列表长度
                if entry_int < len(li):
                    # 打印商品列表
                    print(li[entry_int])
                    break
                else:
                    print('你输入的序号商品不存在,请重新输入!')
                    break
            else:
                print('您输入的含有非数字元素')
                break

执行输出：

 代码优化：

li = ["手机", "电脑", '鼠标垫', '游艇']
#标志位
flag = True
print('''
|欢迎访问天猫商店|
|序号| |商品名|
''')
#遍历商品列表
for i in li:
    # 索引值
    index = li.index(i)
    #打印序号和商品名称
    print('    '+str(index), ' '+i)
 
while flag:
    entry = input('请输入序号：').strip()
    # 判断用户输入的，是否是数字
    if entry.isdigit():
        # 输入的序号转换为数字
        entry_int = int(entry)
        # 判断序号是否大于列表长度
        if entry_int < len(li):
            # 打印商品列表
            print(li[entry_int])
        else:
            print('你输入的序号商品不存在,请重新输入!')
    elif entry.upper() == 'Q':
        flag = False
        print('退出程序')
    else:
        print('您输入的含有非数字元素')

执行效果同上：

再次优化

li = ["手机", "电脑", '鼠标垫', '游艇']
#标志位
flag = True
print('''
|欢迎访问天猫商店|
|序号| |商品名|
''')
 
while flag:
    # 遍历商品列表
    for i in li:
        # 索引值
        index = li.index(i)
        # 打印序号和商品名称
        print('    ' + str(index), ' ' + i)
    #用户输入编号
    entry = input('请输入序号：').strip()
    # 判断用户输入的，是否是数字
    if entry.isdigit():
        # 输入的序号转换为数字
        entry_int = int(entry)
        # 判断序号是否大于列表长度
        if entry_int < len(li):
            # 打印商品列表
            print('您选择的商品是：%s' % li[entry_int])
        else:
            print('你输入的序号商品不存在,请重新输入!')
    #判断用户是否输入q
    elif entry.upper() == 'Q':
        flag = False
        print('退出程序')
    else:
        print('您输入的含有非数字元素')

执行输出：

调整序号，加1。取值的时候，再减1

li = ["手机", "电脑", '鼠标垫', '游艇']
#标志位
flag = True
print('''
|欢迎访问天猫商店|
|序号| |商品名|
''')
 
while flag:
    # 遍历商品列表
    for i in li:
        # 索引值
        index = li.index(i)
        # 打印序号和商品名称,默认是从0开始，这里加1
        print('    ' + str(index+1), ' ' + i)
    #用户输入编号
    entry = input('请输入序号：').strip()
    # 判断用户输入的，是否是数字
    if entry.isdigit():
        # 输入的序号转换为数字
        entry_int = int(entry)
        # 判断序号是否大于0以及小于等于列表长度
        if 0 < entry_int <= len(li):
            # 打印商品列表,取值的时候，要减1
            print('您选择的商品是：%s' % li[entry_int - 1])
        else:
            print('你输入的序号商品不存在,请重新输入!')
    #判断用户是否输入q
    elif entry.upper() == 'Q':
        flag = False
        print('退出程序')
    else:
        print('您输入的含有非数字元素')

执行输出：

 老师的代码：

li = ["手机", "电脑", '鼠标垫', '游艇']
while True:
    for i in li:
        print('{}\t{}'.format(li.index(i)+1,i))
    num = input('请输入商品序号: q/Q退出：').strip()
    if num.isdigit():
        num = int(num)
        if num > 0 and num <= len(li):
            print(li[num - 1])
        else:
            print('您输入的选项,超出范围，请重新输入')
    elif num.upper() == 'Q':break
    else:
        print('输入的有非数字，请重新输入')

执行输出：