DevOps系列文章 之 Python基础
字典
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'] = '[email protected]'
print aDict
执行结果：
{'age': 23, 'name': 'bob'}
{'age': 22, 'name': 'bob'}
{'age': 22, 'name': 'bob', 'email': '[email protected]'}
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'] = '[email protected]'
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': '[email protected]'}
{'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 "", line 1, in TypeError: unhashable type: 'list
7、字典内置函数&方法
Python字典包含了以下内置函数
| 序号 | 函数及描述 |
|---|---|
| 1 | cmp(dict1, dict2) 比较两个字典元素。 |
| 2 | len(dict) 计算字典元素个数，即键的总数。 |
| 3 | str(dict) 输出字典可打印的字符串表示。 |
| 4 | type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 |
Python字典包含了以下内置函数
| 序 号 | 函数 | 描述 |
| 1 | clear(self) | 删除字典内所有的元素 |
| 2 | copy(self) | 返回一个字典的浅copy ，俗称赋值 |
| 3 | fromkeys(*args,**kwargs) | 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| 4 | get(self,k,d=None) | 返回指定键的值，如果值不在字典中返回default值 |
| 5 | items(self) | 以列表返回可遍历的(键, 值) 元组数组 |
| 6 | keys(self) | 以列表返回一个字典所有的键 |
| 7 | pop(self,k,d=None) | 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值 |
| 8 | popitem(self) | 随机返回并删除字典中的一对键和值 |
| 9 | setdefault(self,k,d=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 10 | update(self,E=None,**F) | 把self的东西更新到外面字典 |
| 11 | values(self) | 以列表返回字典中的所有值 |
字典操作实例:
>>> 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('输入的有非数字，请重新输入')
执行输出：
