当前位置:  编程语言>python

python内置映射类型(mapping type):dict哈希字典遍历方式及其它用法举例

 
    发布时间:2014-2-24  


    本文导语:  python内置映射类型(mapping type):dict哈希字典遍历方式及其它用法举例 python内置映射类型字典(dict)是除列表(list)之外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。两者之间的区...

 python内置映射类型(mapping type):dict哈希字典遍历方式及其它用法举例

  python内置映射类型字典(dict)是除列表(list)之外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

  python内置映射类型字典的主要属性

  *通过键而不是偏移量来读取

  python内置映射类型字典有时称为关联数组或者哈希表。它们通过键将一系列值联系起来,这样就可以使用键从字典中取出一项。如果列表一样可以使用索引操作从字典中获取内容

  *任意对象的无序集合

   与列表不同,保存在字典中的项并没有特定的顺序。实际上,Python将各项从左到右随机排序,以便快速查找。键提供了字典中项的象征性位置(而非物理性的)。

   *可变,异构,任意嵌套

   与列表相似,字典可以在原处增长或是缩短(无需生成一份拷贝),可以包含任何类型的对象,支持任意深度的嵌套,可以包含列表和其他字典等。

  *属于可变映射类型

   通过给索引赋值,字典可以在原处修改。但不支持用于字符串和列表中的序列操作。因为字典是无序集合,根据固定顺序进行操作是行不通的(例如合并和分片操作)。字典是唯一内置的映射类型(键映射到值得对象)。

  *对象引用表(哈希表)

    如果说列表是支持位置读取对象的引用数组,那么字典就是支持键读取无序对象的引用表。从本质上讲,字典是作为哈希表(支持快速检索的数据结构)来实现的。一开始很小,并根据要求而增长。此外,Python采用最优化的哈希算法来寻找键,因此搜索是很快速的。和列表一样字典存储的是对象引用。


python内置映射类型dict遍历中带括号与不带括号的遍历方式:


for (d,x) in dict.items():

     print "key:"+d+",value:"+str(x)


for d,x in dict.items():

    print "key:"+d+",value:"+str(x)


python内置映射类型测试代码

#-*- coding: utf-8 -*-

import datetime,codecs


dict = {}


for i in xrange(0,20000):

   dict.setdefault("name"+str(i))

   dict["name"+str(i)]="name"


s=codecs.open(r'c:\dict.txt','a', 'utf-8')


def write(des):

   s.write(des.覆盖 iis7站长之家("utf-8"))


write("测试条数:")

write(str(len(dict))+"rn")

write("带括号开始时间:")

a=datetime.datetime.now()

s.write(str(a)+"rn")


for (d,x) in dict.items():

   print "key:"+d+",value:"+str(x)

write("带括号结束时间:")

b=datetime.datetime.now()

write(str(b)+"rn")

write("时间间隔:")

write(str(b-a)+"rn")


write("不带括号开始时间:")

c=datetime.datetime.now()

write(str(c)+"rn")

for d,x in dict.items():

   print "key:"+d+",value:"+str(x)

write("不带括号结束时间:")

d=datetime.datetime.now()

write(str(d)+"rn")

write("时间间隔:")

write(str(d-c)+"rn")

write("rn")

s.close()


python内置映射类型字典其它常用用法参考:


#字典的添加、删除、修改操作

dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}

dict["w"] = "watermelon"

del(dict["a"])

dict["g"] = "grapefruit"

print dict.pop("b")

print dict

dict.clear()

print dict

#字典的遍历

dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}

for k in dict:

   print "dict[%s] =" % k,dict[k]

#字典items()的使用

dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}

#每个元素是一个key和value组成的元组,以列表的方式输出

print dict.items()

#调用items()实现字典的遍历

dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}

for (k, v) in dict.items():

   print "dict[%s] =" % k, v

#调用iteritems()实现字典的遍历

dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}

print dict.iteritems()

for k, v in dict.iteritems():

   print "dict[%s] =" % k, v

for (k, v) in zip(dict.iterkeys(), dict.itervalues()):

   print "dict[%s] =" % k, v


#使用列表、字典作为字典的值

dict = {"a" : ("apple",), "bo" : {"b" : "banana", "o" : "orange"}, "g" : ["grape","grapefruit"]}

print dict["a"]

print dict["a"][0]

print dict["bo"]

print dict["bo"]["o"]

print dict["g"]

print dict["g"][1]


dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}

#输出key的列表

print dict.keys()

#输出value的列表

print dict.values()

#每个元素是一个key和value组成的元组,以列表的方式输出

print dict.items()

dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}

it = dict.iteritems()

print it

#字典中元素的获取方法

dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}

print dict

print dict.get("c", "apple")        

print dict.get("e", "apple")

#get()的等价语句

D = {"key1" : "value1", "key2" : "value2"}

if "key1" in D:

   print D["key1"]

else:

   print "None"

#字典的更新

dict = {"a" : "apple", "b" : "banana"}

print dict

dict2 = {"c" : "grape", "d" : "orange"}

dict.update(dict2)

print dict

#udpate()的等价语句

D = {"key1" : "value1", "key2" : "value2"}

E = {"key3" : "value3", "key4" : "value4"}

for k in E:

   D[k] = E[k]

print D

#字典E中含有字典D中的key

D = {"key1" : "value1", "key2" : "value2"}

E = {"key2" : "value3", "key4" : "value4"}

for k in E:

   D[k] = E[k]

print D

#设置默认值

dict = {}

dict.setdefault("a")

print dict

dict["a"] = "apple"

dict.setdefault("a","default")

print dict

#调用sorted()排序

dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}

print dict  

#按照key排序

print sorted(dict.items(), key=lambda d: d[0])

#按照value排序

print sorted(dict.items(), key=lambda d: d[1])

#字典的浅拷贝

dict = {"a" : "apple", "b" : "grape"}

dict2 = {"c" : "orange", "d" : "banana"}

dict2 = dict.copy()

print dict2


#字典的深拷贝

import copy

dict = {"a" : "apple", "b" : {"g" : "grape","o" : "orange"}}

dict2 = copy.deepcopy(dict)

dict3 = copy.copy(dict)

dict2["b"]["g"] = "orange"

print dict

dict3["b"]["g"] = "orange"

print dict


python内置映射类型字典补充用法:

1 初始化

>>> d = dict(name='visaya', age=20)

>>> d = dict(zip(['name', 'age'], ['visaya', 20]))


#dict.fromkeys(listkeys, default=0) 把listkeys中的元素作为key均赋值为value,默认为0

>>> d = dict.fromkeys(['a', 'b'], 1)

>>> d

{'a': 1, 'b': 1}

2 字典视图几何

dict.keys()类似信使可以进行交集和并集等集合操作(类似集合,因为不存在重复的项),但dict.values()不可以进行如上操作。

>>> k = d.keys()

>>> k

dict_keys(['a', 'b'])

>>> list(k)

['a', 'b']

>>> k | {'x': 3}

{'a', 'x', 'b'}

>>> k | {'x'}

{'a', 'x', 'b'}

>>> k | {'x', 'y'}

{'a', 'y', 'b', 'x'}

>>> k & {'x'}

set()

>>> v = d.values()

>>> v

dict_values([1, 2])

>>> v | {'x'}

Traceback (most recent call last):

 File "<stdin>", line 1, in <module>

TypeError: unsupported operand type(s) for |: 'dict_values' and 'set'

3 排序字典键

两种方法:

3.1 sort:

>>> Ks = list(d.keys())

>>> ks.sort()

>>> for k in Ks:

...     print(k, d[k])

...

a 1

b 2

3.2 sorted:

>>> for k in sorted(d.keys()):

...     print(k, d[k])

...

a 1

b 2


3.3 注意

>>> for k in list(d.keys()).sort():

...     print(k, d[k])

...

Traceback (most recent call last):

 File "<stdin>", line 1, in <module>

TypeError: 'NoneType' object is not iterable



出错原因:

list.sort() list.append()函数都是对自身的操作,没有返回值,故需先将list(d.keys())的结果保存下来,在结果上进行sort()

4 常用函数

4.1 get()

D.get(k[, d])   => D[k] if k in D else d. d defaults to none.

4.2 pop()

D.pop(value[, d])   => Remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised.

4.3 udpate()

   D.update(E, **F) -> None.  Update D from dict/iterable E and F.

   If E has a .keys() method, does:     for k in E: D[k] = E[k]

   If E lacks .keys() method, does:     for (k, v) in E: D[k] = v

   In either case, this is followed by: for k in F: D[k] = F[k]


>>> d = dict(name='visaya', age=21)

>>> d1= {'age': 20, 'sex': 'male'}

>>> d2 = zip(['a', 'b'], [1, 2])



>>> d.update(d1)

>>> d

{'age': 20, 'name': 'visaya', 'sex': 'male'}

#for k in d1: d[k] = d1[k]



>>> d.update(d2)

>>> d

{'age': 20, 'name': 'visaya', 'sex': 'male'}

#for (k, v) in d2: d[k] = v

4.4 del()

del D[key]

4.5 clear()

4.6 copy()

Python中的dict

初始化

构造方法创建

Python代码  

d = dict()  

d = dict(name="nico", age=23)  

d = dict((['name', "nico"], ['age', 23]))  

当然还有更方便,简单的

Python代码  

d = {}  

d = {"name":"nico", "age":23}  



遍历

通过对key的遍历,遍历整个dict


Python代码  

d = {"name":"nico", "age":23}  

for key in d:  

   print "key=%s, value=%s" % (key, d[key])  


for key in d.iterkeys():  

   print "key=%s, value=%s" % (key, d[key])  


for key in d.keys():  

   print "key=%s, value=%s" % (key, d[key])  


for key in iter(d):  

   print "key=%s, value=%s" % (key, d[key])  


for key,item in d.items():  

   print "key=%s, value=%s" % (key, item)  


当然也可以直接遍历value


Python代码  

d = {"name":"nico", "age":23}  

for value in d.values():  

   print value  


for key,value in d.viewitems():  

   print "key=%s, value=%s" % (key, value)  


for value in d.viewvalues():  

   print "value=%s" % (value)  

这里values和viewvalues的区别


后者返回的是该字典的一个view对象,类似数据库中的view,当dict改变时,该view对象也跟着改变


常用方法


Python代码  

d = {"name":"nico", "age":23}  

d["name"] = "aaaa"  

d["address"] = "abcdefg...."  

print d   #{'age': 23, 'name': 'aaaa', 'address': 'abcdefg....'}  



获取dict值

Python代码  

print d["name"]               #nico  

print d.get("name")         #nico  


如果key不在dict中,返回default,没有为None

Python代码  

print d.get("namex", "aaa")       #aaa  

print d.get("namex")                  #None  


排序sorted()

Python代码  

d = {"name":"nico", "age":23}  

for key in sorted(d):  

   print "key=%s, value=%s" % (key, d[key])  

#key=age, value=23  

#key=name, value=nico  



删除del

Python代码  

d = {"name":"nico", "age":23}  

Python代码  

del d["name"]  

#如果key不在dict中,抛出KeyError  

del d["names"]  

Python代码  

Traceback (most recent call last):  

 File "F:workspaceprojectpydevsrcdddddddd.py", line 64, in <module>  

   del d["names"]  

KeyError: 'names'  



清空clear()

Python代码  

d = {"name":"nico", "age":23}  

d.clear()  

print d                                                    #{}  


copy()

Python代码  

d1 = d.copy()               #{'age': 23, 'name': 'nico'}  

#使用返回view对象  

d2 = d1.viewitems()    #dict_items([('age', 23), ('name', 'nico')])  

#修改字典d1,新增元素  

d1["cc"] = "aaaaaa"  

print d2                  

#dict_items([('cc', 'aaaaaa'), ('age', 23), ('name', 'nico')])  



pop(key[, default])

如果key在dict中,返回,不在返回default

Python代码  

#如果key在dict中,返回,不在返回default  

print d.pop("name", "niccco")                #nico  

print d.pop("namezzz", "niccco")           #niccco  

#key不在dict中,且default值也没有,抛出KeyError  

print d.pop("namezzz")                         #此处抛出KeyError  


popitem()

删除并返回dict中任意的一个(key,value)队,如果字典为空会抛出KeyError

Python代码  

d = {"name":"nico", "age":23}  

print d.popitem()       #('age', 23)  

print d.popitem()       #('name', 'nico')  

#此时字典d已为空  

print d.popitem()      #此处会抛出KeyError  


update([other])

将字典other中的元素加到dict中,key重复时将用other中的值覆盖

Python代码  

d = {"name":"nico", "age":23}  

d2 = {"name":"jack", "abcd":123}  

d.update(d2)  

print d     #{'abcd': 123, 'age': 23, 'name': 'jack'}  


相关文章推荐:


站内导航:


特别声明:169IT网站部分信息来自互联网,如果侵犯您的权利,请及时告知,本站将立即删除!

©2012-2021,,E-mail:www_#163.com(请将#改为@)

浙ICP备11055608号-3