一、什么是字典？
字典是Python语言中唯一的映射类型。
映射类型对象里哈希值（键，key）和指向的对象（值，value）是一对多的的关系，通常被认为是可变的哈希表。
字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也可包括其他容器类型。
字典类型与序列类型的区别：
1.存取和访问数据的方式不同。2.序列类型只用数字类型的键（从序列的开始按数值顺序索引）；3.映射类型可以用其他对象类型作键（如：数字、字符串、元祖，一般用字符串作键），和序列类型的键不同，映射类型的键直4.接或间接地和存储数据值相关联。5.映射类型中的数据是无序排列的。这和序列类型是不一样的，序列类型是以数值序排列的。6.映射类型用键直接&映射&到值。
字典是Python中最强大的数据类型之一。
二、如何创建字典和给字典赋值
简单地说字典就是用大括号包裹的键值对的集合。（键值对也被称作项）一般形式：
id_db = {'wang':{
'name':"delong",
"addr":'juye'},
'name':"jun",
"addr":'shanghai'},
'name':"li",
"addr":'biyang'},
特点：1、键与值用冒号&：&分开；2、项与项用逗号&，&分开；3、字典中的键必须是唯一的，而值可以不唯一。
三、字典的基本操作
1、如何访问字典中的值？adict[key] 形式返回键key对应的值value，如果key不在字典中会引发一个KeyError。
2、如何检查key是否在字典中？
a、has_key()方法 形如：adict.haskey(&name') 有&&True，无&&Falseb、in 、not in&& 形如：'name' in adict&&&&& 有&&True，无&&False
3、如何更新字典？
a、添加一个数据项（新元素）或键值对adict[new_key] = value 形式添加一个项b、更新一个数据项（元素）或键值对adict[old_key] = new_valuec、删除一个数据项（元素）或键值对del adict[key] 删除键key的项 / del adict 删除整个字典adict.pop(key) 删除键key的项并返回key对应的 value值
四、映射类型操作符
标准类型操作符（+，-，*，&,&,&=,&=,==,!=,and,or, not)
a、字典不支持拼接和重复操作符（+，*）b、字典的比较操作先比较字典的长度也就是字典的元素个数键比较值比较
五、映射相关的函数
1、len() 返回字典的长度2、hash() 返回对象的哈希值，可以用来判断一个对象能否用来作为字典的键3、dict() 工厂函数，用来创建字典
六、字典的方法
1、adict.keys() 返回一个包含字典所有KEY的列表；2、adict.values() 返回一个包含字典所有value的列表；3、adict.items() 返回一个包含所有（键，值）元祖的列表；4、adict.clear() 删除字典中的所有项或元素；5、adict.copy() 返回一个字典浅拷贝的副本；6、adict.fromkeys(seq, val=None) 创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值（默认为None）；7、adict.get(key, default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）；8、adict.has_key(key) 如果key在字典中，返回True，否则返回False。 现在用 in 、 not in；9、adict.iteritems()、adict.iterkeys()、adict.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表；10、adict.pop(key[,default]) 和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常；11、adict.setdefault(key, default=None) 和set()方法相似，但如果字典中不存在Key键，由 adict[key] = default 为它赋值；12、adict.update(bdict) 将字典bdict的键值对添加到字典adict中。
七、字典的遍历
1、遍历字典的key（键）
for key in adict.keys():print key
2、遍历字典的value（值）
for value in adict.values(): print value
3、遍历字典的项（元素）
for item in adict.items():print item
4、遍历字典的key-value
for item，value in adict.items(): print &key=%s, value=%s' %(item, value)
for item，value in adict.iteritems(): print &key=%s, value=%s' %(item, value)
注意：for item,value in adict.items(): print &key=%s', &value=%s', %(item, value) 这种写法是错误的
八、使用字典的注意事项
1、不能允许一键对应多个值；2、键必须是可哈希的。
具体的应用实例：
#获取字典，数据字典有天然去重的功能，字典是无序的。
id_db = {'wang':{
'name':"delong",
"addr":'juye'},
'name':"jun",
"addr":'shanghai'},
'name':"li",
"addr":'biyang'},
print(id_db)
print(id_db["wan"]) #打印一个key对应的value
id_db["wan"]["name"]="wanli" #修改一个对应的value,的值
print(id_db["wan"]) #打印一个key对应的value
id_db["wan"]["qq"]=28776 #天假一个新的。value对应的值
print(id_db["wan"]) #打印一个key对应的value
id_db["wan"].pop("age")#删除一个value的值
print(id_db["wan"])
v=id_db.get("liu") #去一个kye,对应的值
v=id_db.get("") #去一个kye,对应的值对对对，当不存在时为None
vv =id("liu")
#这样也可以，但是如果没有时会报错，建议用get方法获取
print(id_db.keys()) #获取数据字典里面的，所有德kye，转换成列表
print(id_db.values()) #打印所有德value，转换成列表
打印效果：
id_db = {'wang':{
'name':"delong",
"addr":'juye'},
'name':"jun",
"addr":'shanghai'},
'name':"li",
"addr":'biyang'},
"naem":"ddddddddd",
'name':"liwan",
id_db.update(d_db2) #把d_db2的内容更新到id_db里面去，如果id_db 有相同的内容会进行更细,没有回添加，注意如果有相同的key,会同步d_db2的内容
print(id_db)
print(id_db.items()) #把字典变成列表，但如果字典数据量大的时候不要做这种事情，转换很耗时间
"wang" in id_db #查看是否包含着key
print(id_db.setdefault("naem")) #如果存在就取出，不存在就添加一个key,kye的值是Noey
print(id_db.setdefault("wangdeeee")) #如果存在就取出，不存在就添加一个key,kye的值是None
print(id_db.setdefault("wangde","wdbdfbeebeb")) #如果存在就取出，不存在就添加一个key,给他附一个值values
print(dict.fromkeys([1,2,3,4,5,6,7],"dddd")) #把列表里面的按照顺序取出来，当做key,把后面的东西当做values
print(id_db.popitem()) #随机删除一个值，是随机删除没有顺序
print(id_db)
&循环的效果:
id_db = {'wang':{
'name':"delong",
"addr":'juye'},
'name':"jun",
"addr":'shanghai'},
'name':"li",
"addr":'biyang'},
"naem":"ddddddddd",
'name':"liwan",
for k,v in id_db.items():#效率低，因为有一个转换过程，dict 转list
print(k,v)
for key in id_db: #效率高的用法
print(key,id_db[key])
for key in enumerate(id_db): #增加key序列选项，序列是下标值
print("%s:%s" % key)
阅读(...) 评论()Python中的字典容器深度讲解- Python教程-PHP中文网QQ群微信公众号还没有收藏Python中的字典容器深度讲解字典（dictionary）我们都曾经使用过语言词典来查找不认识的单词的定义。语言词典针对给定的单词（比如 python）提供一组标准的信息。这种系统将定义和其他信息与实际的单词关联（映射）起来。使用单词作为键定位器来寻找感兴趣的信息。这种概念延伸到 Python 编程语言中，就成了特殊的容器类型，称为 字典（dictionary）。字典（dictionary） 数据类型在许多语言中都存在。它有时候称为关联 数组（因为数据与一个键值相关联），或者作为散列表。但是在 Python 中，字典（dictionary） 是一个很好的对象，因此即使是编程新手也很容易在自己的程序中使用它。按照正式的说法，Python 中的 字典（dictionary） 是一种异构的、易变的映射容器数据类型。创建字典本系列中前面的文章介绍了 Python 编程语言中的一些容器数据类型，包括 tuple、string 和 list（参见 参考资料）。这些容器的相似之处是它们都是基于序列的。这意味着要根据元素在序列中的位置访问这些集合中的元素。所以，给定一个名为 a 的序列，就可以使用数字索引（比如 a[0] ）或片段（比如 a[1:5]）来访问元素。Python 中的 字典（dictionary） 容器类型与这三种容器类型的不同之处在于，它是一个无序的集合。不是按照索引号，而是使用键值来访问集合中的元素。这意味着构造字典（dictionary）容器比 tuple、string 或 list 要复杂一些，因为必须同时提供键和相应的值，如清单 1 所示。清单 1. 在 Python 中创建字典，第 1 部分&&& d = {0: 'zero', 1: 'one', 2 : 'two', 3 : 'three', 4 : 'four', 5: 'five'}
{0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
&&& len(d)
&&& type(d)
# Base object is the dict class
&type 'dict'&
&&& d = {}
# Create an empty dictionary
&&& len(d)
&&& d = {1 : 'one'} # Create a single item dictionary
{1: 'one'}
&&& len(d)
&&& d = {'one' : 1} # The key value can be non-numeric
{'one': 1}
&&& d = {'one': [0, 1,2 , 3, 4, 5, 6, 7, 8, 9]}
{'one': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}如这个例子所示，在 Python 中创建字典（dictionary）要使用花括号和以冒号分隔的键-值组合。如果没有提供键-值组合，那么就会创建一个空的 dictionary。使用一个键-值组合，就会创建具有一个元素的 dictionary，以此类推，直至您需要的任何规模。与任何容器类型一样，可以使用内置的 len 方法查明集合中元素的数量。前面的示例还演示了关于字典（dictionary）容器的另一个重要问题。键并不限制为整数；它可以是任何不易变的数据类型，包括 integer、float、tuple 或 string。因为 list 是易变的，所以它不能作为字典（dictionary）中的键。但是字典（dictionary）中的值可以是任何数据类型的。最后，这个示例说明了 Python 中字典（dictionary）的底层数据类型是 dict 对象。要进一步了解如何使用 Python 中的 字典（dictionary），可以使用内置的帮助解释器来了解 dict 类，如清单 2 所示。清单 2. 获得关于字典（dictionary）的帮助&&& help(dict)on class dict in module __builtin__:
dict(object)
| dict() -& new empty dictionary.
| dict(mapping) -& new dictionary initialized from a mapping object's
(key, value) pairs.
| dict(seq) -& new dictionary initialized as if via:
for k, v in seq:
| dict(**kwargs) -& new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
| Methods defined here:
| __cmp__(...)
x.__cmp__(y) &==& cmp(x,y)
| __contains__(...)
x.__contains__(y) &==& y in x
| __delitem__(...)
x.__delitem__(y) &==& del x[y]
...关于 dict 类的帮助指出，可以使用构造函数直接创建字典（dictionary），而不使用花括号。既然与其他容器数据类型相比，在创建字典（dictionary）时必须提供更多的数据，那么这些创建方法比较复杂也就不足为奇了。但是，在实践中使用字典（dictionary）并不难，如清单 3 所示。清单 3. 在 Python 中创建字典（dictionary），第 2 部分&&& l = [0, 1,2 , 3, 4, 5, 6, 7, 8, 9]
&&& d = dict(l)(most recent call last):
File &&stdin&&, line 1, in ?: can't convert dictionary
update sequence element #0 to a sequence
&&& l = [(0, 'zero'), (1, 'one'), (2, 'two'), (3, 'three')]
&&& d = dict(l)
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
&&& l = [[0, 'zero'], [1, 'one'], [2, 'two'], [3, 'three']]
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
&&& d = dict(l)
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
&&& d = dict(zero=0, one=1, two=2, three=3)
{'zero': 0, 'three': 3, 'two': 2, 'one': 1}
&&& d = dict(0=zero, 1=one, 2=two, 3=three): keyword can't be an expression可以看到，创建字典（dictionary）需要键值和数据值。第一次从 list 创建字典（dictionary）的尝试失败了，这是因为没有匹配的键-数据值对。第二个和第三个示例演示了如何正确地创建 字典（dictionary）：在第一种情况下，使用一个 list，其中的每个元素都是一个 tuple；在第二种情况下，也使用一个 list，但是其中的每个元素是另一个 list。在这两种情况下，内层容器都用于获得键到数据值的映射。直接创建 dict 容器的另一个方法是直接提供键到数据值的映射。这种技术允许显式地定义键和与其对应的值。这个方法其实用处不大，因为可以使用花括号完成相同的任务。另外，如前面的例子所示，在采用这种方式时对于键不能使用数字，否则会导致抛出一个异常。访问和修改字典（dictionary）创建了 dictionary 之后，需要访问其中包含的数据。访问方式与访问任何 Python 容器数据类型中的数据相似，如清单 4 所示。清单 4. 访问 dictionary 中的元素&&& d = dict(zero=0, one=1, two=2, three=3)
{'zero': 0, 'three': 3, 'two': 2, 'one': 1}
&&& d['zero']
&&& d['three']
&&& d = {0: 'zero', 1: 'one', 2 : 'two', 3 : 'three', 4 : 'four', 5: 'five'}
'zero'
'four'
&&& d[6](most recent call last):
File &&stdin&&, line 1, in ?: 6
&&& d[:-1](most recent call last):
File &&stdin&&, line 1, in ?: unhashable type可以看到，从字典（dictionary）中获取数据值的过程几乎与从任何容器类型中获取数据完全一样。在容器名后面的方括号中放上键值。当然，字典（dictionary）可以具有非数字的键值，如果您以前没有使用过这种数据类型，那么适应这一点需要些时间。因为在字典（dictionary）中次序是不重要的（dictionary 中数据的次序是任意的），所以可以对其他容器数据类型使用的片段功能，对于 字典（dictionary）是不可用的。试图使用片段或者试图从不存在的键访问数据就会抛出异常，指出相关的错误。Python 中的字典（dictionary）容器也是易变的数据类型，这意味着在创建它之后可以修改它。如清单 5 所示，可以添加新的键到数据值的映射，可以修改现有的映射，还可以删除映射。清单 5. 修改字典（dictionary）&&& d = {0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
'zero'
&&& d[0] = 'Zero'
{0: 'Zero', 1: 'one', 2: 'two', 3: 'three'}
&&& d[4] = 'four'
&&& d[5] = 'five'
{0: 'Zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
&&& del d[0]
{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
&&& d[0] = 'zero'
{0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}清单 5 演示了几个重点。首先，修改数据值是很简单的：将新的值分配给适当的键。其次，添加新的键到数据值的映射也很简单：将相关数据分配给新的键值。Python 自动进行所有处理。不需要调用 append 这样的特殊方法。对于 dictionary 容器，次序是不重要的，所以这应该好理解，因为不是在字典（dictionary）后面附加映射，而是将它添加到容器中。最后，删除映射的办法是使用 del 操作符以及应该从容器中删除的键。在清单 5 中有一个情况看起来有点儿怪，键值是按照数字次序显示的，而且这个次序与插入映射的次序相同。不要误解 —— 情况不总是这样的。Python 字典（dictionary）中映射的次序是任意的，对于不同的 Python 安装可能会有变化，甚至多次使用同一 Python 解释器运行相同代码也会有变化。如果在一个字典（dictionary）中使用不同类型的键和数据值，那么就很容易看出这一点，如清单 6 所示。清单 6. 异构的容器&&& d = {0: 'zero', 'one': 1}
{0: 'zero', 'one': 1}
'zero'
&&& type(d[0])
&type 'str'&
&&& d['one']
&&& type(d['one'])
&type 'int'&
&&& d['two'] = [0, 1, 2]
{0: 'zero', 'two': [0, 1, 2], 'one': 1}
&&& d[3] = (0, 1, 2, 3)
{0: 'zero', 3: (0, 1, 2, 3), 'two': [0, 1, 2], 'one': 1}
&&& d[3] = 'a tuple'
{0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}如这个例子所示，可以在一个字典（dictionary）中使用不同数据类型的键和数据值。还可以通过修改字典（dictionary）添加新的类型。最后，产生的 dictionary 的次序并不与插入数据的次序匹配。本质上，字典（dictionary）中元素的次序是由 Python 字典（dictionary）数据类型的实际实现控制的。新的 Python 解释器很容易改变这一次序，所以一定不要依赖于元素在字典（dictionary）中的特定次序。用字典（dictionary）进行编程作为正式的 Python 数据类型，字典（dictionary）支持其他较简单数据类型所支持的大多数操作。这些操作包括一般的关系操作符，比如 &、& 和 ==，如清单 7 所示。清单 7. 一般关系操作符&&& d1 = {0: 'zero'}
&&& d2 = {'zero':0}
&&& d1 & d2
&&& d2 = d1
&&& d1 & d2
&&& d1 == d2
&&& id(d1)
&&& id(d2)
&&& d2 = d1.copy()
&&& d1 == d2
&&& id(d1)
&&& id(d2)前面的示例创建两个字典（dictionary）并使用它们测试 & 关系操作符。尽管很少以这种方式比较两个字典（dictionary）；但是如果需要，可以这样做。然后，这个示例将赋值给变量 d1 的字典（dictionary）赋值给另一个变量 d2。注意，内置的 id() 方法对于 d1 和 d2 返回相同的标识符值，这说明这不是复制操作。要想复制字典（dictionary） ，可以使用 copy() 方法。从这个示例中的最后几行可以看出，副本与原来的字典（dictionary）完全相同，但是容纳这字典（dictionary）的变量具有不同的标识符。在 Python 程序中使用字典（dictionary）时，很可能希望检查字典（dictionary）中是否包含特定的键或值。如清单 8 所示，这些检查很容易执行。清单 8. 条件测试和字典（dictionary）&&& d = {0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}
&&& d.keys()
[0, 3, 'two', 'one']
&&& if 0 in d.keys():
print 'True'
&&& if 'one' in d:
print 'True'
&&& if 'four' in d:
print 'Dictionary contains four'
... elif 'two' in d:
print 'Dictionary contains two'
... contains two测试字典（dictionary）中键或数据值的成员关系是很简单的。dictionary 容器数据类型提供几个内置方法，包括 keys() 方法和 values() 方法（这里没有演示）。这些方法返回一个列表，其中分别包含进行调用的字典（dictionary）中的键或数据值。因此，要判断某个值是否是字典（dictionary）中的键，应该使用 in 操作符检查这个值是否在调用 keys() 方法所返回的键值列表中。可以使用相似的操作检查某个值是否在调用 values() 方法所返回的数据值列表中。但是，可以使用字典（dictionary）名作为简写表示法。这是有意义的，因为一般希望知道某个数据值（而不是键值）是否在字典（dictionary）中。在 “Discover Python, Part 6” 中，您看到了使用 for 循环遍历容器中的元素是多么容易。同样的技术也适用于 Python 字典（dictionary），如清单 9 所示。清单 9. 迭代和字典（dictionary）&&& d = {0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}
&&& for k in d.iterkeys():
print d[k]
&&& for v in d.itervalues():
&&& for k, v in d.iteritems():
print 'd[',k,'] = ',v
... [ 0 ] = zero[ 3 ] = a tuple[ two ] = [0, 1, 2][ one ] = 1这个示例演示了遍历字典（dictionary）的三种方式：使用从 iterkeys()、itervalues() 或 iteritems() 方法返回的 Python 迭代器。（顺便说一下，可以通过在字典（dictionary）上直接调用适当方法，比如 d.iterkeys()，从而检查这些方法是否返回一个迭代器而不是容器数据类型。）iterkeys() 方法允许遍历字典（dictionary）的键，而 itervalues() 方法允许遍历字典（dictionary）包含的数据值。另一方面，iteritems() 方法允许同时遍历键到数据值的映射。字典（dictionary）：另一种强大的 Python 容器本文讨论了 Python 字典（dictionary）数据类型。字典（dictionary）是一种异构的、易变的容器，依赖键到数据值的映射（而不是特定的数字次序）来访问容器中的元素。访问、添加和删除字典（dictionary）中的元素都很简单，而且字典（dictionary）很容易用于复合语句，比如 if 语句或 for 循环。可以在字典（dictionary）中存储所有不同类型的数据，可以按照名称或其他复合键值（比如 tuple）访问这些数据，所以 Python 字典（dictionary）使开发人员能够编写简洁而又强大的编程语句。以上就是Python中的字典容器深度讲解的详细内容，更多请关注php中文网其它相关文章！共3篇827点赞收藏分享：.&猜你喜欢PHP中文网：独家原创，永久免费的在线，php技术学习阵地！
All Rights Reserved | 皖B2-QQ群:关注微信公众号后使用快捷导航没有帐号？
查看: 4661|回复: 1
python容器类数据结构
中级会员, 积分 299, 距离下一级还需 201 积分
论坛徽章:1
容器类数据结构： 1，列表：列表是处理一组有序项目的数据结构,即你可以在一个列表中存储一个序列的项目。一旦你创建了一个列表,你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目,我们说列表是可变的数据类型,即这种类型是可以被改变的。介绍几个列表的方法insert(i, x) ---- 在指定位置插入一项。第一自变量是要在哪一个元素前面插入，用下标表示例如，list.insert(0, x)在列表前面插入，list.insert(len(list), x)等价于list.append(x)。append(x) ---- 等价于list.insert(len(a), x)index(x) ---- 在列表中查找值x然后返回第一个值为x的元素的下标。没有找到时出错。remove(x) ---- 从列表中删去第一个值为x的元素，找不到时出错。sort() ---- 对列表元素在原位排序。注意这个方法改变列表，而不是返回排序后的列表。reverse() ---- 把列表元素反序。改变列表。count(x) ---- 返回x在列表中出现的次数。Python代码&&& list = ['a','c','g','e','t','b','f','d','g']&&&&& list.insert(3,'d')&&&&& list&&['a', 'c', 'g', 'd', 'e', 't', 'b', 'f', 'd', 'g']&&&&& list.append('c')&&&&& list&&['a', 'c', 'g', 'd', 'e', 't', 'b', 'f', 'd', 'g', 'c']&&&&& list.index('c')&&1 &&& list.remove('c')&&&&& list.index('c')&&9 &&& list.count('d')&&2 &&& list.sort()&&&&& list&&['a', 'b', 'c', 'd', 'd', 'e', 'f', 'g', 'g', 't']&&&&& new_list = ['a','c','g','d','b']&&&&& new_list.reverse()&&&&& new_list&&['b', 'd', 'g', 'c', 'a']
可以使用help(list)获得列表对象的所有方法。 2，元组：元组和列表十分类似,只不过元组和字符串一样是不可变的,即你不能修改元组。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候,即被使用的元组的值不会改变。举例：Python代码&&& zoo = ('wolf', 'elephant', 'penguin')&&&&& print len(zoo)&&3 &&& new_zoo = ('monkey', 'dolphin', zoo)&&&&& print len(new_zoo)&&3 &&& print new_zoo&&('monkey', 'dolphin', ('wolf', 'elephant', 'penguin'))&&&&& print new_zoo[2]&&('wolf', 'elephant', 'penguin')&&&&& print new_zoo[2][1]&&elephant
从代码中可以看出列表和元组的区别。 3，字典：字典是一系列未排序的“键值：值”的集合，在同一字典内键值是互不相同的。对字典的主要操作是以某个键值保存一个值，以及给定键值后查找对应的值。也可以用del删除某个键值：值对。如果用一个已有定义的键值保存某个值则原来的植被遗忘。用不存在的键值去查找会出错。字典不象序列，它不是用在一个范围之内的数字下标来索引，而是用键值 来索引，键值可以是任何不可变类型。字符串和数值总可以作键值。如果元组只包含字符串 、数值或元组，则元组也可以作键值使用，因为元组是不可更改的。列表不能用作键值，因为列表可以用其append()方法就地改变值。字典对象的keys()方法返回字典中所有键值组成的列表，次序是随机的。需要排序时只要对返回的键值列表使用sort()方法。为了检查某个键值是否在字典中，使用字典的has_key()方法。字典使用举例：Python代码&&& employee_id = {'Sammy':1, 'david':2, 'shirley':3,'jack':4,'guido':5}& &&&& employee_id['shirley']& &3& &&&& employee_id.has_key('fly')& &False& &&&& employee_id.keys()& &['shirley', 'Sammy', 'guido', 'jack', 'david']& &&&& employee_id& &{'shirley': 3, 'Sammy': 1, 'guido': 5, 'jack': 4, 'david': 2}& &&&& del employee_id['david']& &&&& employee_id& &{'shirley': 3, 'Sammy': 1, 'guido': 5, 'jack': 4}& &&&& for name, id in employee_id.items():& &.... print 'employee %s id is %d' % (name, id)& &....& &employee shirley id is 3& &employee Sammy id is 1& &employee guido id is 5& &employee jack id is 4& &&&& if 'shirley' in employee_id or employee_id.has_key('shirley'):& &.... print employee_id.get('shirley')& &....& &3&&
中级会员, 积分 274, 距离下一级还需 226 积分
论坛徽章:1
拜读了，讲得挺详细的，赞~
扫一扫加入本版微信群