今天看啥 热点：
Python中使用item()方法遍历字典的例子，pythonitem
Python字典的遍历方法有好几种，其中一种是for...in，这个我就不说明，在Python了几乎随处都可见for...in。下面说的这种遍历方式是item()方法。
item()方法把字典中每对key和value组成一个元组，并把这些元组放在列表中返回。
复制代码 代码如下:
person={'name':'lizhong','age':'26','city':'BeiJing','blog':'www.jb51.net'}
for key,value in person.items():
&&& print 'key=',key,'，value=',value
执行结果：
可见key接收了字典的key，value接收了字典的value值。
但如果只有一个参数接收呢？
复制代码 代码如下:
person={'name':'lizhong','age':'26','city':'BeiJing','blog':'www.jb51.net'}
for x in person.items():
&&& print x
只有一个变量接收值的情况下，直接返回的是每一对key,value对应的元组。
使用item()就有点类似于php里的foreach类似。都能把键=&值的方式遍历出来，如果纯使用for..in则只能取得每一对元素的key值
复制代码 代码如下:
person={'name':'lizhong','age':'26','city':'BeiJing','blog':'www.jb51.net'}
for x in person:
&&& print x
执行结果：
for key in e:
for value in e[key]:
print value
没有优雅的方法解决，只有不要使用print语句，如楼上所说，或者使用python3.X中的print函数（通过from __future__ import print_function使能print函数形式）其实，在python2.X手册中对print语句描述说：（python2.7.2官方帮助文档）一个空格会被自动打印在每个对象前，除非：（1）还没有输出写到标准输出中（2）当最后一个写到标准输出的是一个除了空格‘ ’的空白字符（3）当最后写到标准输出的不是一个print语句。所以在apple、banana等每个字符前都有一个空格。（apple的a前也有空格呢！）一个好的解决办法是使用python3.X中的print函数。通过在文件前面加上：from __future__ import print_function就可以使用print的函数形式了。print函数的语法：print([object, ...][, sep=' '][, end='\n'][, file=sys.stdout]) 默认下，若没有指定sep，则使用空格。没指定end，则使用换行符。没指定输出文件则输出到标准输出。例如：print('hello','world',sep='-',end='#')输出：hello-world#所以，你的程序可改为：from __future__ import print_functionlist = [&apple&, &banana&, &grape&, &orange&]for x in range(len(list)):
print('list[%d]:'%x,end='')
for y in range(len(list[x])):
print(list[x][y],sep='',end='')
print('')至于： 'list[%d]:'%x 这里的百分号，是一个对字符串的操作符。百分号使得百分号前面的字符串中的%d被百分号后的x的值替换掉。参考资料：python2.7.2官方帮助文档。
相关搜索：
相关阅读：
相关频道：
&&&&&&&&&&&&&&&&
Python教程最近更新Python（22）
字典是python语言中唯一的映射类型，用花括号{}表示，一个字典条目就是一个键值对，方法keys()返回字典的键列表，values()返回字典的值列表，items()返回字典的键值对列表。字典中的值没有任何限制，它们可以是任意python对象，但字典中的键是有类型限制的，每个键只能对应一个值，且键必须是可哈系的，所有不可变类型都是可哈希的。不可变集合frozenset的元素可作为字典的键，但可变集合set就不行了。
以下是字典类型的常用方法。
clear()：删除字典中所有元素。
copy()：返回字典（浅复制）的一个副本。
fromkeys(seq,val=None)：创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值。
get(key,default=None)：返回字典中的键key对应的值value，如果字典中不存在此键，则返回default的值。
has_key(key)：如果键key在字典中存在，返回True，否则返回False。python2.2后这个方法几乎已废弃不用了，通常用in来替代。
items()：返回一个包含字典中键值对元组的列表。
keys()：返回一个包含字典中键的列表。
iter()：方法iteritems()、iterkeys()、itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表。
pop(key[,default])：和方法get()类似，如果字典中key键存在，删除并返回dict[key]，如果key键不存在，且没有给出default的值，引发KeyError异常。
setdefault(key,default=None)：和方法get()相似，如果字典中不存在key键，由dict[key]=default为它赋值。
update(dict2)：将字典dict2的键值对添加到当前字典中。
values()：返回一个包含字典中所有值的列表。
下面以一个模拟用户登录的数据系统为例介绍字典的用法。
#!/usr/bin/env python
def newuser():
prompt = 'register: '
while True:
name = raw_input(prompt)
if db.has_key(name):
prompt = 'name taken, try another: '
pwd = raw_input('passwd: ')
db[name] = pwd
def olduser():
name = raw_input('login: ')
pwd = raw_input('passwd: ')
passwd = db.get(name)
if passwd == pwd:
print 'login success:', name
print 'login failure'
def showmenu():
prompt = &&&
Enter choice: &&&
done = False
while not done:
chosen = False
while not chosen:
choice = raw_input(prompt).strip()[0].lower()
except (EOFError, KeyboardInterrupt):
choice = 'q'
print '\nYour choice: [%s]' %choice
if choice not in 'rlq':
print 'invalid option, try again'
chosen = True
if choice == 'r':
elif choice == 'l':
done = True
if __name__ == '__main__':
showmenu()
脚本第三行初始化一个空的db字典，第9行通过has_key()判断新注册的用户名（字典的key）是否存在，第15行通过方括号[]给一个用户名添加密码（即给一个键添加值），第20行通过get()获取用户名对应的密码（即与字典的key对应的value）。第38行的strip()是字符串处理函数，这个地方用来删除字符串首尾的空白符。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：114628次
积分：3350
积分：3350
排名：第8162名
原创：203篇
评论：26条
微信: blithe_gemini
email: blithe_
文章：25篇
阅读：12256
文章：25篇
阅读：5407
文章：50篇
阅读：20986
(5)(1)(1)(4)(36)(12)(1)(5)(2)(7)(6)(4)(5)(2)(2)(4)(24)(20)(12)(20)(4)(5)(2)(14)(8)2013年10月 其他开发语言大版内专家分月排行榜第二2012年2月 其他开发语言大版内专家分月排行榜第二
2013年11月 其他开发语言大版内专家分月排行榜第三2012年4月 其他开发语言大版内专家分月排行榜第三2011年6月 其他开发语言大版内专家分月排行榜第三
本帖子已过去太久远了，不再提供回复功能。六、 python中的数据类型——字典 - 简书
六、 python中的数据类型——字典
字典（dict）
字典是python内置的一种数据类型，使用键-值（key-value）进行存储，查找速度极快。字典，顾名思义，就是通过关键字查询它的含义。python中的字典与之类似，每个键对应一个值，使用键可以其访问对应的值。· 字典的特点是使用花括号，键与值之间用冒号隔开，键值对之间用逗号隔开。· 键不能重复，值可以重复。· 字典内的元素是无序的
1. 定义字典
&&& a = {}
#定义一个空字典
&&& print(type(a))
#打印a的类型
&class 'dict'&
#a的类型是字典
&&& b = {'Tom': 20}
#定义一个只含有一个键值对的字典
&&& c = {'Tom': 20, 'Jack': 19}
#定义一个含有两个键值对的字典
&&& print(b)
{'Tom': 20}
&&& print(c)
{'Jack': 19, 'Tom': 20}
定义方法与之前定义列表和元组的方法极为相似，只是将括号改为了花括号。我们可以发现，在定义字典c的时候，是'Tom'在前，'Jack'在后，但是打印的时候，却出现了相反的情况，这是因为元素在字典内是无序的。列表和元组都是有序的。字典使用了与列表和元组不同的实现方式，在性能上要比列表和元组更快，假设我们要查找一个人的年龄。有两个列表，一个列表储存了所有人的姓名，另一个储存了所有人的年龄。我们首先要在姓名的列表中找到其位置，再通过这个位置，找到年龄列表中对应的值。列表越长，查询速度越慢，时间越长。但是如果使用字典，将姓名与年龄链接起来，直接根据姓名查询年龄，速度就会快很多，无论这个字典多大，都能保证速度极快。这是因为python中的字典在实现的时候，使用了哈希表，这个东西查找速度极快，在生成字典的过程中，先后顺序不同，因此里面的元素是无序的。
2. 访问元素
在字典中，通过使用键访问其对应的值。dict[key]
&&& name_age = {'Tom': 20, 'Jack': 19}
#定义字典name_age
&&& print(name_age['Tom'])
#打印字典name_age中'Tom'的值
&&& print(name_age['Jack'])
#打印字典name_age中'Jack'的值
在列表和元组中访问元素是通过索引的方式，在字典中是通过使用键访问，两者的相同之处都是使用“对象+中括号”，在上例中，name_age是字典名，在其后加上中括号与键名，即代表了在该字典中，此键对应的值。如果你访问的键在字典中不存在，就会报错，类似下面的例子
&&& a = {}
#定义字典a
&&& print(a['Tom'])
#打印字典a中的'Tom'的值
Traceback (most recent call last):
File "&pyshell#27&", line 1, in &module&
print(a['Tom'])
KeyError: 'Tom'
我们要访问a中'Tom'的值，但是a中并不存在'Tom'，因此出现了KeyError: 'Tom'。因此在访问字典内的元素时，有两种方法可以判断键是否在字典中。
in与前面列表和元组的例子类似，in也适用于字典，不过只能判断键在不在字典内，不能判断值是否在字典内。
&&& a = {'Jack': 20, 'Tom': 19}
&&& print('Jack' in a)
#'Jack' in a为真
&&& print('David' in a)
#'David' in a为假
get方法字典内置了get方法。dict.get(key, value)，如果字典内存在key，返回key对应的值，如果不存在，返回value，没有指定value的时候，返回None
&&& a = {'Jack': 20, 'Tom': 19}
&&& print(a.get('Jack'))
&&& print(a.get('David'))
&&& print(a.get('David',2))
&&& print(a)
{'Jack': 20, 'Tom': 19}
3.添加元素
在字典中添加元素可以使用键加入。dict[key] = value
&&& a = {}
#定义一个空字典
&&& a['Tom'] = 19
#加入'Tom'，赋值为19
&&& a['Jack'] = 20
#加入'Jack'，赋值为20
&&& print(a)
#打印字典a
{'Jack': 20, 'Tom': 19}
我们知道，字典中的键是唯一的，因此如果使用该方法对同一个键赋值多次，只会取最后一次赋值的结果。如下面这个例子
&&& a = {'Jack': 20, 'Tom': 19}
&&& a['David'] = 20
#在字典中加入'David'并赋值为20
&&& print(a['David'])
#打印字典中'David'的值
&&& a['David'] = 21
#将字典中的'David'赋值为21
&&& print(a['David'])
#打印字典中'David'的值
&&& print(a)
#打印字典a
{'David': 21, 'Jack': 20, 'Tom': 19}
dict.setdefault(key,value)字典内置了setdefault()方法，如果key存在，返回其对应的值，如果不存在，将key与value组成键值对，加入到字典中，并返回value
&&& my_dict = {'Juicy': 12, 'Tom': 20}
&&& my_dict.setdefault('Tom', 'd')
#使用setdefault设置'Tom'的值
&&& my_dict.setdefault('Jack', 19)
#使用setdefault设置'Jack'的值
&&& print(my_dict)
{'Juicy': 12, 'Jack': 19, 'Tom': 20}
因为my_dict中存在'Tom'，所以setdefault('Tom', 'd')返回了'Tom'的值，并且不对其进行赋值。因为my_dict中不存在'Jack'，所以setdefault('Jack' ,19)返回了19，并且将'Jack'的值赋为了19，存入了字典中。
4. 删除元素
删除字典中的键值对，使用dict.pop(key)方法，对应的value也会一并删除。
&&& my_dict = {'Juicy': 12, 'Tom': 20}
&&& my_dict.pop('Tom')
#删除my_dict中'Tom'及其值
&&& my_dict.pop('David')
#删除my_dict中'David'及其值
Traceback (most recent call last):
File "&pyshell#46&", line 1, in &module&
my_dict.pop('David')
KeyError: 'David'
#报错，因为字典中不存在'David'这个键
&&& print(my_dict)
{'Juicy': 12}
当要删除的键不存在的时候，也会报错。
5.其他方法
复制一个字典dict.copy()
&&& my_dict1 = {'Juicy': 12, 'Tom': 20}
#定义字典my_dict1
&&& my_dict2 = my_dict1.copy()
#使用copy()进行复制
&&& print(my_dict2)
#打印复制后的新字典
{'Juicy': 12, 'Tom': 20}
查看所有的键dict.keys()
&&& my_dict = {'Jack': 19, 'Juicy': 12, 'Tom': 20}
&&& print(my_dict.keys())
#打印my_dict中所有的键
dict_keys(['Tom', 'Juicy', 'Jack'])
&&& print(type(my_dict.keys()))
#打印其类型
&class 'dict_keys'&
我们可以发现，使用dict.keys()即可得到dict这个字典中所有的键，得到的类型，就是上面写的'dict_keys'，这种类型比较奇葩，不能灵活的操作，像索引一类的都不能使用。
&&& my_dict.keys()[0]
Traceback (most recent call last):
File "&pyshell#53&", line 1, in &module&
my_dict.keys()[0]
TypeError: 'dict_keys' object does not support indexing
不支持索引所以我们在使用的时候，可以将其转换成为列表
&&& b = list(my_dict.keys())
#在外面加一个list()，对其强制类型转换，赋给b
&&& print(b)
['Tom', 'Juicy', 'Jack']
就可以得到所有的键组成的一个列表了，这样就方便操作了。
查看所有的值dict.values()与dict.keys()类似
&&& my_dict = {'Jack': 19, 'Juicy': 12, 'Tom': 20}
&&& print(my_dict.values())
#打印字典所有的值
dict_values([20, 12, 19])
print(list(my_dict.values()))
#打印强制类型转换为列表的字典所有的值
[12, 19, 20]
清空字典dict.clear()字典提供了一个叫做clear()的方法，用来清除字典内部所有的键值对。
&&& my_dict = {'Jack': 19, 'Juicy': 12, 'Tom': 20}
&&& my_dict.clear()
#清除my_dict内所有元素
&&& print(my_dict)
5.查看字典内键值对的个数len()函数len()对字典也适用。
&&& my_dict = {'Jack': 19, 'Juicy': 12, 'Tom': 20}
#定义字典my_dict
&&& print(len(my_dict))
打印my_dict中元素的个数
更多关于字典的信息，可以使用help(dict)查看