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
&&& dict.has_key('ob4')
也有人用循环方法来判断
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()
{'ob2': 'mouse', 'ob3': 'printer', 'ob1':'computer'}
&&& a=dict
{'ob2': 'mouse', 'ob3': 'printer', 'ob1':'computer'}
&&& b=dict.copy()
{'ob2': 'mouse', 'ob3': 'printer', 'ob1': 'computer'}
&&& cmp(a,b)
首先比较主键长度，然后比较键大小，然后比较键值大小，（第一个大返回1，小返回-1，一样返回0）
&&&dict={'yangrong':{"age":"23","job":"IT"},"xiaohei":{"'age':'22','job':'dota'"}}
{'xiaohei':set(["'age':'22','job':'dota'"]), 'yangrong': {'age': '23', 'job':'IT'}}
&&& dict['xiaohei']=111
#修改一级字典
{'xiaohei': 111, 'yangrong': {'age': '23','job': 'IT'}}
&&& dict['yangrong']['age']=25
#修改二级字典
{'xiaohei': 111, 'yangrong': {'age': 25,'job': 'IT'}}
&&& dict={'yangrong':['23','IT'],"xiaohei":['22','dota']}
&&&dict['xiaohei'][1]="dota2"
#修改字典中列表某项，1是代表列表中第2个字符串。
{'xiaohei': ['22', 'dota2'], 'yangrong':['23', 'IT']}
删除字典元素
{'xiaohei': ['22', 'dota2'], 'yangrong':['23', 'IT']}
&&& del dict['xiaohei']
#删除xiaohei键值
{'yangrong': ['23', 'IT']}
{'yangrong': ['23', 'IT']}
&&& del dict['yangrong'][1]
#删除yangrong主键的每2字值
{'yangrong': ['23']}
删除整个字典
{'yangrong': ['23']}
&&& dict.clear()
#同del 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序列化存入文件
把内容读入字典（反序列化）
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]}
dictMerged1=dict(dict1.items()+dict2.items())
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']:
2）键必须不可变，可以用数，字符串或元组充当，但是用列表不行，如下实例：
dict = {['Name']: 'Zara', 'Age': 7}
print "dict['Name']: ", dict['Name']
#以上实例输出结果：
#Traceback (most recent call last):
File "test.py", line 3, in &module&
#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==d2
print d1==d3
{"a": 123, "b": 789, "c": 456}
{"a": 123, "c": 456, "b": 789}
{"a": 123, "b": 789, "c": 456}
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)
dumps(data)
dumps(data, indent=2)
dumps(data, separators): 25
indent:是缩进的意思，它可以使得数据存储的格式变得更加优雅。
data1 = {'b':789,'c':456,'a':123}
d1 = json.dumps(data1,sort_keys=True,indent=4)
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}
附录：字典常用方法
得到字典a中元素的个数
取得字典a中键K所对应的值
设定字典a中键k所对应的值成为v
使用 key从一个 dictionary中删除独立的元素。如，删除Dictionary dic中的user=’root’：del dic[“user”]
从一个 dictionary中清除所有元素。如，删除Dictionary dic中的所有元素：dic.clear()
得到字典副本
字典中存在键k则为返回True，没有则返回False
k not in a
字典中不存在键k则为返回true,反之返回False
a.has_key(k)
判断字典a中是否含有键k
得到字典a中的键—值对list
得到字典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所有值的迭代器。
@晴天- 17:40:56 -updat
莫道谗言如浪深，莫言迁客似沙沉。
千淘万漉虽辛苦，吹尽狂沙始到金。
转载一篇非常好的介绍python对json处理的blog 什么是json： JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Lang...
Python黑帽编程2.3字符串、列表、元组、字典和集合 本节要介绍的是Python里面常用的几种数据结构。通常情况下，声明一个变量只保存一个值是远远不够的，我们需要将一组或多组数据进行存储、查询、排序等操作，本节介绍的Python内置的数据结构可以满足大多数情况下的需求。...
本节要介绍的是Python里面常用的几种数据结构。通常情况下，声明一个变量只保存一个值是远远不够的，我们需要将一组或多组数据进行存储、查询、排序等操作，本节介绍的Python内置的数据结构可以满足大多数情况下的需求。这一部分的知识点比较多，而且较为零散，需要认真学习。 2....
基础1.r''表示''内部的字符串默认不转义2.'''...'''表示多行内容3. 布尔值：True、False（注意大小写）4.与运算and、或运算：or、非运算：not5. None代表空值6.声明一个变量（前面不用声明类型--动态语言）：
我猜，有很多人跟我一样，因为各种各样的原因，经常乘坐火车。你们有没有觉得，火车是一个非常有意思的地方？ 如果你留心的话，你会看到，火车上往往会有一个带着孩子的年轻的爸爸，这个爸爸可能长得还不错。我猜想，离开家的时候，他的妻子肯定多次叮嘱他一定要照顾好孩子。所以当你看见这对父...
收集的一些iOS开发技术博客与牛人共同进步 调试打包日志测试持续集成 oneapm.com BugHD 易观方舟 CocoaLumberjack和XcodeColors的安装和使用 CocoaLumberjack的ios应用开发使用指南 iOS开发中的单元测试 Xcode7...
毕业越久是不是越感觉孤单孤独，尤其是从农村出来的孩子。工作越久是不是越想出游畅玩，尤其是刚毕业的小青年。 小时候的夏季啊，月亮很亮很圆，月亮初上，就搬出来凳子、躺椅、竹床，在门前的大空地上摆好，不用招呼，一下子就聚满了人，或站着，或坐着，或躺着，或跑着，大人们聊家常，小孩们...
不是所有的人都能成为朋友，不是所有的情都值得你去珍惜。时间是一剂良药，它会沉淀最美的感情，也会带走留不住的虚情。缘分，需要珍惜，和双向互动；感情，需要感恩，和双方呵护。爱不是单向，情不是索取，懂得珍惜才会持久，知道不易才能永恒。爱得无怨，疼得无悔，只因不图任何回报；爱到卑微...
你越来 越像你妈了 饭桌上 白科长冷不丁 冒出了一句 女人立马 放下筷子 嫌我老 就直说 用不着 这么拐弯抹角 李燕子 年轻漂亮 会来事 你看上她 就和她过去 （日）在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
# 你新建了一个dict
In[1]: dic = {'k1': 1, 'k2': 3, 'k3': 2}
# 然后用sorted对字典的key按照字母升序排列
In[2]: sorted(dic.items())
# 注意看输出, 上面的排序是重新生成了一个由(key, value)组成的list, 并没有作用到dict上, 另外dict的key是hashtable, 本身无序, 是不能对其排序的
Out[2]: [('k1', 1), ('k2', 3), ('k3', 2)]
In[3]: dic
# dict在这里并没有做任何修改
Out[3]: {'k1': 1, 'k2': 3, 'k3': 2}
In[4]: sorted(dic.items())[0]
Out[4]: ('k1', 1)
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
字典是无序的，不能排序，sorted只是排序 d 的 键值对 元组的列表。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
sorted(zip(d.keys(), d.values())) 可解
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
因为dic是字典，是无序的，每次打印出来的结果可能都不相同
而sorted(dic.item())是对生成的元组('k1', 1), ('k2', 2), ('k3', 3)默认按每个元组的第一个值进行排序，所以打印结果为('k1', 1)
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
V=sorted(dic.items())这条语句后面不需要[0]，因为sorted排序结果就是{['k1':1],['k2':2],['k3':3]},添加一句[0],相当于print的是V[0]，所以结果就是['k1':1]
同步到新浪微博
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。Python中字典和集合 - 旅客y - 博客园
Python中字典和集合
映射类型：
表示一个任意对象的集合，且可以通过另一个几乎是任意键值的集合进行索引
与序列不同，映射是无序的，通过键进行索引
任何不可变对象都可用作字典的键，如字符串、数字、元组等
包含可变对象的列表、字典和元组不能用作键
引用不存在的键会引发KeyError异常
{ key1:value1,key2:value2,... }
字典在其它编程语言中又称作关联数组或散列表；
通过键实现元素存取；无序集合；可变类型容器，长度可变，异构，嵌套
支持的操作：
返回D中的项目数
返回D中键k的值
将D[k]的值设为x
&&& d1 = {'x':1,'y':2,'z':3}
&&& d1['x']
&&& d1['z']
通过键索引
从D中删除D[k]
&&& del d1['x']
{'y': 2, 'z': 3}
如果k是D中的值，则返回True
支持的方法：
清除所有元素
复制一个副本
&&& d1 = {'x':1,'y':2,'z':3}
&&& id(d1)
&&& d2 = d1.copy()
&&& id(d2)
&&& d3 = d1
&&& id(d3)
d1、d3指向同一对象，d2指向另一对象
D.get(k[,d])
取得对应键的值，若不存在则返回d(默认为空)
&&& d1.get('y')
D.has_key(k)
是否存在键值，返回True或False.(仅在pyhton2中使用)
转换为(key,value)元组组成的列表
&&& d1.items()
[('y', 2), ('x', 1), ('z', 3)]
&&& t1,t2,t3 = d1.items()
&&& m1,m2 = {'x':1,'y':2}
&&& print m1
&&& print m2
保存的是键，而不是值!!!
D.values()
&&& d1.values()
&&& d1.keys()
['y', 'x', 'z']
D.pop(k[,d])
弹出指定键值，若不指定则会触发异常
&&& d1.pop()
TypeError: pop expected at least 1 arguments, got 0
&&& d1.pop('x')
{'y': 2, 'z': 3}
D.popitem()
&&& d1.popitem()
&&& d1.popitem()
&&& d1.popitem()
KeyError: 'popitem(): dictionary is empty'
为空时异常
D.update(m)
&&& d1 = { 'x':1,'y':2,'z':3 }
&&& d2={'c':'hello','y':66}
&&& d1.update(d2)
{'y': 66, 'x': 1, 'c': 'hello', 'z': 3}
若键存在则会覆盖，不存在就添加
D.iteritems()
返回一个迭代器对象
&&& d1 = { 'x':1,'y':2,'z':3 }
&&& i1 = d1.iteritems()
&&& i1.next()
使用next方式遍历每一个元素
&&& i1.next()
&&& i1.next()
&&& i1.next()
StopIteration
遍历结束后不会重新开始
D.iterkeys()
an iterator over the keys of D
&&& i2 = d1.iterkey()
&&& i2.next()
D.itervalues()
an iterator over the values of D
&&& i3 = d1.iterkey()
&&& i3.next()
D.viewvalues()
返回类似集合方式的字典(值组成)
&&& d1.viewvalues()
dict_values([2, 1, 3])
D.viewitems()
a set-like object providing a view on D's items(键值对)
&&& d1.viewitems()
dict_items([('y', 2), ('x', 1), ('z', 3)])
D.viewkeys()
a set-like object providing a view on D's keys
&&& d1.viewkeys()
dict_keys(['y', 'x', 'z'])
&&& d2 = dict(x=1,y=2,z=3)
定义字典另一种方式
{'y': 2, 'x': 1, 'z': 3}
返回元组组成的列表
&&& zip('xyz','123')
[('x', '1'), ('y', '2'), ('z', '3')]
一一对应生成列表
&&& zip('xyzm','123')
[('x', '1'), ('y', '2'), ('z', '3')]
多余项被舍弃
&&& zip('xyz','123','qer')
[('x', '1', 'q'), ('y', '2', 'e'), ('z', '3', 'r')]
&&& dict(zip('xyz','123'))
{'y': '2', 'x': '1', 'z': '3'}
无序排列、可哈希；
支持集合关系测试
成员关系测试：
不支持：索引、元素获取、切片
集合的类型：
frozenset()
没有特定语法格式，只能通过工厂函数创建
&&& s1=set(1,2,3)
TypeError: set expected at most 1 arguments, got 3
&&& s1 = set([1,2,3])
set([1, 2, 3])
&&& type(s1)
支持的方法和操作：
如何获取使用帮助：
获取对象支持使用的属性和方法：dir()
某方法的具体使用帮助：help(list.pop)
获取可调用对象的文档字串：print obj.__doc__
容器、类型、对象：
1、列表、元组、字典字面量可在无换行符下分布在多行内，最后一个字符后可跟逗号(若空则不可使用)
2、所有对象都有引用计数(sys模块中getrefcount方法);
&&& import sys
set([1, 2, 3])
&&& sys.getrefcount(s1)
查看s1的引用计数
3、列表和字典都支持两种类型的复制操作：浅复制和深复制；深复制可使用copy模块中的deepcopy()实现。
4、Python中的所有对象都是“第一类的”，这意味着使用标识符命名的所有对象都具有相同状态，于是，能够命名所有对象都可以直接当数据进行处理；
5、所有序列都支持迭代；(非负整数的有序集合)
6、所有序列都支持的操作和方法：
s[i:j:stride]
所有为true
任意为true
s1 + s2: 连接
s1 * N: 重复
成员关系判断：
obj not in s1
7、可变序列的操作：
s[index] = value
s[i:j] = t
s[i:j:stride] = t
扩展切片赋值
del s[index]
del s[i:j]
del s[i:j:stride]
扩展切片删除
引用计数和垃圾回收：
所有对象都有引用计数
给对象分配一个新名称或将其放入一个容器内，其引用计数都会增加
用del语句或为变量重新赋值时，其引用计数会减少
sys.getrefcount()可以获得对象的当前引用计数
一个对象的引用计数器归零时，它将被垃圾收集机制回收
阅读(...) 评论()下次自动登录
现在的位置:
& 综合 & 正文
python天天进步(4)–字典排序
1、 准备知识：
在python里，字典dictionary是内置的数据类型，是个无序的存储结构，每一元素是key-value对：
如：dict = {‘username’：‘password’，‘database’：‘master’}，其中‘username’和‘database’是key，而‘password’和‘master’是value，可以通过d[key]获得对应值value的引用，但是不能通过value得到key。
对于dictionnary，需知道以下几点注意事项：
a、 dictionary 的 key 是大小写敏感的；
b、 一个dictionary中不能有重复的 key；
c、 dictionary是无序的，没有元素顺序的概念，它们只是序偶的简单排列。
2、 字典排序实现：
参见cookbook，Recipe 5.1. Sorting a Dictionary讲述了字典排序的方法；
前面已说明dictionary本身没有顺序概念，但是总是在某些时候，但是我们常常需要对字典进行排序，怎么做呢？下面告诉你：
方法1：最简单的方法，排列元素（key/value对），然后挑出值。字典的items方法，会返回一个元组的列表，其中每个元组都包含一对项目——键与对应的值。此时排序可以sort()方法。
def sortedDictValues1(adict):
items = adict.items()
items.sort()
return [value for key, value in items]
方法2：使用排列键的方式，挑出值，速度比方法1快。。
def sortedDictValues1(adict):
keys = adict.keys()
keys.sort()
return [adict[key] for key in keys]
方法3：通过映射的方法去更有效的执行最后一步
def sortedDictValues1(adict):
keys = adict.keys()
keys.sort()
return map（adict.get,keys）
方法4：对字典按键排序，用元组列表的形式返回，同时使用lambda函数来进行；
sorted(iterable[, cmp[, key[, reverse]]]cmp和key一般使用lambda如：
&&& d={"ok":1,"no":2}
对字典按键排序，用元组列表的形式返回
&&& sorted(d.items, key=lambda d:d[0])
[('no', 2), ('ok', 1)]
对字典按值排序，用元组列表的形式返回
&&& sorted(d.items, key=lambda d:d[1])
[('ok', 1), ('no', 2)]
对字典元素的排序虽然有好多种方法，这里也没有总结全，但如果对程序效率没有太高要求，选择喜欢的用就好。
~~~~~~~~~~~~believe yourself ,nothing is impossible, write in 02.19.2009 by vivilorne~~~~~~~~~~~~~
【上篇】【下篇】当前位置： &
Python中字典的基础知识归纳小结
【导读】 & & 作者：一路向北
字体： 类型：转载 时间：& & 这篇文章主要介绍了Python中字典的基础知识归纳小结,都是Python入门学习中的基本知识,值得反复巩固:)需要的朋友可以参考下& &
& & 作者：一路向北
字体： 类型：转载 时间：& & 这篇文章主要介绍了Python中字典的基础知识归纳小结,都是Python入门学习中的基本知识,值得反复巩固:)需要的朋友可以参考下& & 定义一个字典& & &&& d = {"server":"mpilgrim", "database":"master"} 1&&& d{‘server‘: ‘mpilgrim‘, ‘database‘: ‘master‘}&&& d
2‘mpilgrim‘&&& d
3‘master‘&&& d
4&/p&&p&& & Traceback (innermost last):&/p&&p&& & File "&interactive input&", line 1, in ?&/p&&p&& & KeyError: mpilgrim&/p&& & 首先，我们创建了一个拥有两个元素的新字典，并将其赋值给变量 d。每一个元素都是一个键-值对，整个元素集合用大括号括起来。& & server 是一个键字，它所关联的值为 mpilgrim，用 d 来引用。& & database 是一个键字，它所关联的值为 master，用 d 来引用。& & 你可以通过键字来得到值，但是不能通过值得到键字。所以 d 为 mpilgrim，但是使用 d 会引发一个异常，因为 mpilgrim 不是一个键字。& & 修改一个字典& & &&& d{‘server‘: ‘mpilgrim‘, ‘database‘: ‘master‘}&&& d = "pubs" 1&&& d{‘server‘: ‘mpilgrim‘, ‘database‘: ‘pubs‘}&&& d = "sa"
2&&& d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘pubs‘}& & 不能在一个字典中有重复的键字。给一个存在的键字赋值会抹掉原来的值。& & 可以在任何时候加入新的键-值对。这种语法同修改存在的值一样。(是的，它可能某天会给你带来麻烦，你可能认为增加了新值，但实际上只是反复地修改了同样的值，因为你的键字没有按照你的想象改变。)& & 注意新的元素（键字为 uid，值为 sa）出现在字典中间。实际上，它只不过是一种巧合，在第一个例子中的元素看上去是有序的。现在它们看上去无序了则更是一种巧合。& & Note& & 字典没有元素顺序的概念。说元素顺序乱了是不正确的，它们只是简单的无序。这是一个重要的特性，它会在你想要以一种特定的，可重复的顺序（象以键字的字母表顺序）存取字典元素的时候骚扰你。有一些实现的方法，它们只是没有加到字典中去。& & 在字典中混用数据类型& & &&& d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘pubs‘}&&& d = 3 1&&& d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘master‘, ‘retrycount‘: 3}&&& d = "douglas" 2&&& d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘master‘, 42: ‘douglas‘, ‘retrycount‘: 3}& & 字典不是只用于字符串。字典的值可以是任意数据类型，包括字符串，整数，对象，或者甚至其它的字典。在一个单个字典里，字典的值并不需要全都是同一数据类型，可以根据需要混用和配匹。& & 字典的关键字要严格一些，但是它们可以是字符串，整数和几种其它的类型（后面还会谈到这一点）。也可以在一个字典中混用和配匹关键字。& & 从字典中删除元素& & &&& d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘master‘, 42: ‘douglas‘, ‘retrycount‘: 3}&&& del d 1&&& d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘master‘, ‘retrycount‘: 3}&&& d.clear() 2&&& d{}& & del 允许你根据键字将单个元素从字典中删除。& & clear 会删除一个字典中所有元素。注意空的大括号所表示的集合说明一个字典没有元素。& & 字符串是大小写敏感& & &&& d = {}&&& d = "value"&&& d = "other value" 1&&& d{‘key‘: ‘other value‘}&&& d = "third value" 2&&& d{‘Key‘: ‘third value‘, ‘key‘: ‘other value‘}& & 将一个值赋给一个存在的字典关键字只是简单的用新值替换旧值。& & 这样做不会将一个值赋给一个存在的字典关键字，因为在Python中字符串是大小写敏感的，所以 ‘key‘ 与 ‘Key‘ 是不同的。这样就在字典中生成了一个新的键/值对。对你来说可能差不多，但对于Python来说，完全是不同的。& & 如何访问字典中的值:& & &&& dict2 = {‘name‘:‘earth‘,‘port‘:80}
&&& for key in dict2.keys():
... print ‘key=%s,value=%s‘ %(key,dict2)...key=name,value=earthkey=port,value=80&&& for key in dict2:
... print ‘key=%s,value=%s‘ %(key,dict2)...key=name,value=earthkey=port,value=80& & 获取字典某个元素值:& & &&& dict2‘earth‘&&& print ‘host %s is running on port %d‘ %(dict2,dict2)host earth is running on port 80& & 检查字典中是否有某个键的方法 has_key()或in,not in& & &&& ‘name‘ in dict2True&&& ‘server‘ in dict2False&&& ‘name‘ in dict2 True&&& dict2‘earth‘&&& dict2.has_key(‘server‘)False&&& dict2.has_key(‘name‘) True& & 一个字典中混用数字和字符串的例子:& & &&& dict3 = {}&&& dict3 = ‘abc‘&&& dict3 = 3.14159&&& dict3 = ‘xyz‘&&& dict3{‘1‘: 3.14159, 1: ‘abc‘, 3.2: ‘xyz‘}& & 整体赋值:& & &&& dict3 = {‘1‘: 3.14159, 1: ‘abc‘, 3.2: ‘xyz‘,33:‘hehe‘}&&& dict3{‘1‘: 3.14159, 1: ‘abc‘, 3.2: ‘xyz‘, 33: ‘hehe‘}& & 更新字典:& & &&& dict2 = ‘venus‘&&& dict2 = 6969&&& dict2 = ‘sunos5‘&&& print ‘host %(name)s is running on port %(port)d‘ %dict2host venus is running on port 6969& & 删除字典元素和字典& & &&& dict2{‘arch‘: ‘sunos5‘, ‘name‘: ‘venus‘, ‘port‘: 6969}&&& del dict2&&& dict2{‘arch‘: ‘sunos5‘, ‘port‘: 6969}&&& dict2.clear()&&& dict2{}&&& del dict2&&& dict2Traceback (most recent call last): File "&stdin&", line 1, in &module&NameError: name ‘dict2‘ is not defined&&& dict3{‘1‘: 3.14159, 1: ‘abc‘, 3.2: ‘xyz‘, 33: ‘hehe‘}&&& dict3.pop(33) ‘hehe‘&&& dict3{‘1‘: 3.14159, 1: ‘abc‘, 3.2: ‘xyz‘}& & 注:避免使用内建对象名字作为变量的标识符& & 类似: dict,list,file,bool,str,input,len
八大懒人减肥法 - 七丽时尚网
夏天怎么除体内湿气 - 七丽时尚网
苏珊米勒本周星座运势-7.22 - 七丽时尚网
女性调节内分泌的方法 - 七丽时尚网
哪些吃饭习惯对身体不好 - 七丽时尚网
八种起床后的坏习惯 - 七丽时尚网