python 字典查看键值对 python查看字典键的集合

python.png

一、字典基本操作

基本语法：

dict = {'ob1':'computer', 'ob2':'mouse', 'ob3':'printer'}

技巧：

字典中包含列表：dict={'yangrong':['23','IT'],"xiaohei":['22','dota']}

字典中包含字典：dict={'yangrong':{"age":"23","job":"IT"},"xiaohei":{"'age':'22','job':'dota'"}}

增加字典元素

>>> nameinfo={}
>>> nameinfo['a1']='yangrong' #若字典里有a1主键，则覆盖原来的值，没有，则添加
>>> nameinfo
{'a1': 'yangrong'}

遍历字典主键与键值

>>> for k, value in nameinfo.items():
... print k,value
...
a1 yangrong

查看字典所有主键

>>> dict = {'ob1':'computer','ob2':'mouse', 'ob3':'printer'}
>>>
>>>
>>> dict.keys()
['ob2', 'ob3', 'ob1']
>>> for k in d.keys():
print dict[k]

判断字典中是否有该主键

>>> dict.keys()
['ob2', 'ob3', 'ob1']
>>> dict.has_key('ob2') #或'ob2' in dict
True
>>> dict.has_key('ob4')
False

也有人用循环方法来判断

for key in dict.keys():

但是这种方法毕竟不够简洁，

查看字典所有键值内容

>>> dict = {'ob1':'computer','ob2':'mouse', 'ob3':'printer'}
>>> dict.values()
['mouse', 'printer', 'computer']

列出所有项目

>>> dict.items()
[('ob2', 'mouse'), ('ob3', 'printer'),('ob1', 'computer')]

清空字典

>>> dict.clear()
>>> dict
{}

拷贝字典

>>> dict
{'ob2': 'mouse', 'ob3': 'printer', 'ob1':'computer'}
>>> a=dict
>>> a
{'ob2': 'mouse', 'ob3': 'printer', 'ob1':'computer'}
>>> b=dict.copy()
>>> b
{'ob2': 'mouse', 'ob3': 'printer', 'ob1': 'computer'}

比较字典

>>> cmp(a,b)

首先比较主键长度，然后比较键大小，然后比较键值大小，（第一个大返回1，小返回-1，一样返回0）

更新字典

>>>dict={'yangrong':{"age":"23","job":"IT"},"xiaohei":{"'age':'22','job':'dota'"}}
>>> dict
{'xiaohei':set(["'age':'22','job':'dota'"]), 'yangrong': {'age': '23', 'job':'IT'}}
>>> dict['xiaohei']=111 #修改一级字典
>>> dict
{'xiaohei': 111, 'yangrong': {'age': '23','job': 'IT'}}
>>> dict['yangrong']['age']=25 #修改二级字典
>>> dict
{'xiaohei': 111, 'yangrong': {'age': 25,'job': 'IT'}}
>>> dict={'yangrong':['23','IT'],"xiaohei":['22','dota']}
>>>dict['xiaohei'][1]="dota2" #修改字典中列表某项，1是代表列表中第2个字符串。
>>> dict
{'xiaohei': ['22', 'dota2'], 'yangrong':['23', 'IT']}

删除字典元素

>>> dict
{'xiaohei': ['22', 'dota2'], 'yangrong':['23', 'IT']}
>>> del dict['xiaohei'] #删除xiaohei键值
>>> dict
{'yangrong': ['23', 'IT']}
>>> dict
{'yangrong': ['23', 'IT']}
>>>
>>> del dict['yangrong'][1] #删除yangrong主键的每2字值
>>> dict
{'yangrong': ['23']}

删除整个字典

>>> dict
{'yangrong': ['23']}
>>> dict.clear() #同del dict
>>> dict
{}

将字符串切分为列表

>>> s="hello world bye"
>>> s.split() #用于把有规律的文本，读取出来后，使用列表进行修改，再写入文件。
['hello', 'world', 'bye']

将列表转换为字符串

S.split(str, ' ') #将string转list，以空格切分

存储字典(pickle序列化)

#需导入pickle模块

import pickle

把字典内容存入文件

f=file('data.txt','wb') #新建文件data.txt，'wb'，b是打开块文件，对于设备文件有用
pickle.dump(a,f) #把a序列化存入文件
f.close()

把内容读入字典（反序列化）

a=open('data.txt','rb') #打开文件
print pickle.load(a) #把内容全部反序列化

合并2个字典

dict1={1:[1,11,111],2:[2,22,222]}
dict2={3:[3,33,333],4:[4,44,444]}

合并两个字典得到类似

{1:[1,11,111],2:[2,22,222],3:[3,33,333],4:[4,44,444]}

方法1：

dictMerged1=dict(dict1.items()+dict2.items())

方法2：

dictMerged2=dict(dict1, **dict2)

方法2等同于：

dictMerged=dict1.copy()
dictMerged.update(dict2)

或者

dictMerged=dict(dict1)
dictMerged.update(dict2)

方法2比方法1速度快很多

总结：字典内置函数&方法

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

1、cmp(dict1, dict2)：比较两个字典元素。

2、len(dict)：计算字典元素个数，即键的总数。

3、str(dict)：输出字典可打印的字符串表示。

4、type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置方法：

1、radiansdict.clear()：删除字典内所有元素

2、radiansdict.copy()：返回一个字典的浅复制

3、radiansdict.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

4、radiansdict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值

5、radiansdict.has_key(key)：如果键在字典dict里返回true，否则返回false

6、radiansdict.items()：以列表返回可遍历的(键, 值) 元组数组

7、radiansdict.keys()：以列表返回一个字典所有的键

8、radiansdict.setdefault(key, default=None)：和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default

9、radiansdict.update(dict2)：把字典dict2的键/值对更新到dict里

10、radiansdict.values()：以列表返回字典中的所有值

二、字典的特性

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print "dict['Name']: ", dict['Name']
#以上实例输出结果：
#dict['Name']: Manni

2）键必须不可变，可以用数，字符串或元组充当，但是用列表不行，如下实例：

dict = {['Name']: 'Zara', 'Age': 7}
print "dict['Name']: ", dict['Name']
#以上实例输出结果：
#Traceback (most recent call last):
# File "test.py", line 3, in 
#dict = {['Name']: 'Zara', 'Age': 7};
#TypeError: list objects are unhashable

3）Dictionary中的key值是大小写敏感的。并且，Dictionary中没有元素顺序的概念。

三、字典与JSON互转

实际上JSON就是Python字典的字符串表示，但是字典作为一个复杂对象是无法直接转换成定义它的代码的字符串（不能传递所以需要先将其转换成字符串），Python有一个叫simplejson的库（就叫 json ）可以方便的完成JSON的生成和解析，这个包已经包含在Python2.6中， 主要包含四个方法：

dump和dumps（从Python生成JSON）

区别：dump和dumps的唯一区别是dump会生成一个类文件对象，dumps会生成字符串

转换对照表.png

load和loads（解析JSON成Python的数据类型）

区别：load和loads分别解析类文件对象和字符串格式的JSON

转换对照表.png

json.dumps()方法提供了很多好用的参数可供选择，比较常用的有sort_keys，separators，indent等参数。

sort_keys:对dict对象进行排序，我们知道默认dict是无序存放的

data1 = {'b':789,'c':456,'a':123}
data2 = {'a':123,'b':789,'c':456}
d1 = json.dumps(data1, sort_keys=True)
d2 = json.dumps(data2)
d3 = json.dumps(data2, sort_keys=True)
print d1
print d2
print d3
print d1==d2
print d1==d3

输出：

{"a": 123, "b": 789, "c": 456}
{"a": 123, "c": 456, "b": 789}
{"a": 123, "b": 789, "c": 456}
False
True

separators:对数据进行压缩,该参数传递是一个元组，包含分割对象的字符串。

print 'DATA:', repr(data)
print 'repr(data) :', len(repr(data))
print 'dumps(data) :', len(json.dumps(data))
print 'dumps(data, indent=2) :', len(json.dumps(data, indent=4))
print 'dumps(data, separators):', len(json.dumps(data, separators=(',',':')))

输出：

DATA: {'a': 123, 'c': 456, 'b': 789}
repr(data) : 30
dumps(data) : 30
dumps(data, indent=2) : 46
dumps(data, separators): 25

indent:是缩进的意思，它可以使得数据存储的格式变得更加优雅。

data1 = {'b':789,'c':456,'a':123}
d1 = json.dumps(data1,sort_keys=True,indent=4)
print d1
输出：
{
"a": 123,
"b": 789,
"c": 456
}

skipkeys：dumps方法存储dict对象时，key必须是str类型，如果出现了其他类型的话，那么会产生TypeError异常，如果开启该参数，设为True的话，则会比较优雅的过度。

data = {'b':789,'c':456,(1,2):123}
print json.dumps(data,skipkeys=True)
输出：
{"c": 456, "b": 789}

附录：字典常用方法

方法名

说明

len(a)

得到字典a中元素的个数

a[k]

取得字典a中键K所对应的值

a[k] = v

设定字典a中键k所对应的值成为v

del a[k]

使用 key从一个 dictionary中删除独立的元素。如，删除Dictionary dic中的user=’root’：del dic[“user”]

a.clear()

从一个 dictionary中清除所有元素。如，删除Dictionary dic中的所有元素：dic.clear()

a.copy()

得到字典副本

k in a

字典中存在键k则为返回True，没有则返回False

k not in a

字典中不存在键k则为返回true,反之返回False

a.has_key(k)

判断字典a中是否含有键k

a.items()

得到字典a中的键—值对list

a.keys()

得到字典a中键的list

a.update([b])

从b字典中更新a字典，如果键相同则更新，a中不存在则追加.

a.fromkeys(seq[, value])

创建一个新的字典，其中的键来自sql，值来自value

a.values()

得到字典a中值的list

a.get(k[, x])

从字典a中取出键为k的值，如果没有，则返回x

a.setdefault(k[, x])

将键为k的值设为默认值x。如果字典a中存在k,则返回k的值，如果不存在，向字典中添加k-x键值对，并返回值x

a.pop(k[, x])

取出字典a中键k的值，并将其从字典a中删除，如果字典a中没有键k，则返回值x

a.popitem()

取出字典a中键值对，并将其从字典a中删除

a.iteritems()

返回字典a所有键-值对的迭代器。

a.iterkeys()

返回字典a所有键的迭代器。

a.itervalues()

返回字典a所有值的迭代器。