python学习[第十一篇] 数据类型之字典

字典概念

字典是python中唯一的映射类型。映射类型对象包括键和值两部分，映射是一种一对多的关系。

字典对象是可变的容器类型。能存储任意类型的python对象。

字典类型和序列类型的区别是存储和访问数据的方式不同。序列类型的键通常称为索引，必须是整数类型。而字典的键可以是其他类型的对象。通常是字符串类型，映射类型是无序的。

字典的增删改查

字典的创建及赋值

#创建空的字典
adict={}
#创建非空的字典
adict={'key':'value'}
adict={'website':'http://127.0.0.1:','port':80}

使用字典内建函数来创建字典

#使用dict函数，接收一个元组为参数，返回一个字典
ddict=dict((['x',1],['y',2]))
>>> ddict
{'y': 2, 'x': 1}

#使用fromkeys()函数,接收一个元组作为参数返回一个字典

#使用fromkeys()函数，并赋予默认value值
>>> ddict={}.fromkeys(('x','y'),-1)
>>> ddict={}.formkeys(('x','y'),-1)
>>> ddict
{'y': -1, 'x': -1}
>>> ddict={}.fromkeys(('x','y'),(-1,-2))
>>> ddict
{'y': (-1, -2), 'x': (-1, -2)}
#使用fromkeys()函数 ,如果没有给出value值，默认为None
>>> ddict={}.fromkeys(('x','y'))
>>> ddict
{'y': None, 'x': None}

字典的访问

adict={'website':'http://127.0.0.1:','port':80}
#查询单一值
adict['website]

#遍历字典

for key in adict:
    print key,adict[key]

for key in adict.keys():
    print key,adict[key]

#判断 键是否在字典中
#key in dict

'website' in adict

如果我们范围单一的字典元素时，如果键不存在于字典中，会报KeyError

>>> adict={'website':'http://127.0.0.1:','port':80}
>>> adict['website1']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'website1'

字典的更新

#添加新的数据项
adict['username']='pzq'
#更新原有的数据项
adict['username']='pzq123'

字典删除

#删除字典的某一个数据项
del adict['username']

#删除字典的某一个数据项,并返回其值
adict.pop('username')

#清空整个字典
adict.clear()

#删除整个字典
del adict

操作符

标准类型操作符

对象值比较操作符 > >= < <= == != =

身份操作符 is is not

布尔操作符 and or not

字典操作符

切片操作符 []

#使用切片查看数据项
adict['username']

#使用切片修改数据项
adict['username']=’pzq'

成员操作符 in

判断对象是否是字典的键

#判断字符串对象是否是字典的键
'username' in adict

映射类型内建函数及工厂函数

标准类型内建函数

cmp()函数

比较字典长度如果长度不同，字典中的键的个数越多，字典越大。
比较字典的键如果字典长度相同，那就比较字典的键，键的比较顺序和keys()方法返回的顺序相同。即hash后键的大小？
比较字典的值如果字典长度相同，键也相同，则对字典中每一个键对应的值进行比较
完全匹配的话返回0

type() str() repr() 和其他类型没有什么区别

>>> adict = {'website':'http://127.0.0.1:','port':80}
>>> type(adict)
<type 'dict'>
>>> str(adict)
"{'website': 'http://127.0.0.1:', 'port': 80}"
>>> repr(adict)
"{'website': 'http://127.0.0.1:', 'port': 80}"

映射类型相关的函数

dict() 函数

dict 函数接收两种参数序列参数和映射参数即 dict(sequence) 和 dict(mapping)

1 dict(sequence) 如果dict接收的参数是序列参数，即可迭代的参数例如序列，迭代器，或支持迭代的对象那么这个可迭代的元素必须成对出现

>>> dict(zip(('x','y'),(1,2)))
{'y': 2, 'x': 1}

>>> dict([['x',1],['y',2]])
{'y': 2, 'x': 1}

>>> dict((['x',1],['y',2]))
{'y': 2, 'x': 1}

>>> dict([('xy'[i-1] ,i) for i in range(1,3)])
{'y': 2, 'x': 1}

2 dict(mapping) 如果dict接收的参数是映射对象，比如字典对象，会对其调用dict()函数会从存在的字典里复制内容除了生成新的字典。生成的字典是原来的字典的浅拷贝。同内建方法copy()的作用是一样的，但是速度要比copy()方法慢

#通过映射生成dict8
>>> dict(x=1,y=2)
{'y': 2, 'x': 1}
>>> dict8=dict(x=1,y=2)
>>> dict8
{'y': 2, 'x': 1}
#通过**args生成 dict9
>>> dict9=dict(**dict8)
>>> dict9
{'y': 2, 'x': 1}

>>> dict9=dict8.copy()
>>> dict9
{'y': 2, 'x': 1}


#测试浅拷贝
>>> dict8=dict(x=[1,2],y=2)
>>> dict8
{'y': 2, 'x': [1, 2]}
>>> dict9=dict8.copy()
>>> dict9
{'y': 2, 'x': [1, 2]}
>>> dict8['x'][0]=11
>>> dict8
{'y': 2, 'x': [11, 2]}
>>> dict9
{'y': 2, 'x': [11, 2]}

#测试浅拷贝
>>> dict9=dict(**dict8)
>>> dict9
{'y': 2, 'x': [11, 2]}
>>> dict8['x'][0]=1
>>> dict8
{'y': 2, 'x': [1, 2]}
>>> dict9
{'y': 2, 'x': [1, 2]}

len 函数

len函数是统计dict中键的个数

>>> len(dict8)
2

hash()函数

hash函数可以判断一个对象是否可以作为键，如果对象不是可hash的，会报TypeError

>>> hash('x')
-1819822983
>>> hash('y')
-1691822600
>>> hash('x')
-1819822983
>>> hash('x')
-1819822983
>>> hash('y')
-1691822600
>>> hash(['x','u'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

字典的内建方法

key有关的函数

dict.fromkeys(seq,value=None)创建并返回一个新字典，val作为所有键的值

dict.keys() 返回一个包含列表所有键列表

dict.has_key() 判断一个对象是否是字典的键返回True或False

dict.get(key,default=None) 对字典的键，返回value，如果字典中不存在此键，则返回default值

dict.pop(key,default=None) 和get方法类似，如果字典中key存在，删除并返回dict[key] .如果键值不存在且没有给出default值则引发keyError

dict.iterkeys() 返回一个迭代对象。不是列表

dict.setdefault(key,default=None) 如果字典不存在key的键，则有dict[key] = default为他赋值

>>> adict=dict(x=1,y=2)  #创建一个字典
>>> adict
{'y': 2, 'x': 1}
#keys返回一个列表，列表中包含字典的所有键
>>> adict.keys()         
['y', 'x']
#dict.has_key() 判断一个对象是否是字典的键
>>> adict.has_key('x')
True
#dict.fromkeys() 通过fromkeys批量创建字典，如果值没有被指定，则默认为None
>>> adict.fromkeys(('x','y'),1)
{'y': 1, 'x': 1}


>>> adict=dict(x=1,y=2)
>>> adict
{'y': 2, 'x': 1}
#dict.get() 获取字典中对应键的值
>>> adict.get('x')
1
#dict.get() 如果输入的参数不存在如字典中则返回None
>>> adict.get('z')
>>> z=adict.get('z')
>>> z
>>> print z
None
#dict.get() 如果输入的参数符合键的要求，则报错TypeError
>>> z=adict.get(['z'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

#dict.get() 获取字典中对应键的值 ,并从字典中删除对应的数据项
>>> adict
{'y': 2, 'x': 1}
>>> adict.pop('x')
1
>>> adict
{'y': 2}
#iterkeys()方法与非迭代方法一样，不同的是返回一个迭代子。而不是一个对象
>>> for x in adict.iterkeys():
...    print x
y

#setdefault 方法，为键值设置默认值，如果不存在则dict[key]=value添加新的数据项，存在则返回此key对应的值，不会修改值为None的key的值，

>>> adict
{'y': 2}
>>> adict.setdefault('y',default=3)
2
#key不存在，没有设置default值 则使用None为其赋值

>>> adict.setdefault('x')
>>> adict
{'y': 2, 'x': None}

#key存在值为None,则什么都不做返回None
>>> adict.setdefault('x',1)
>>> adict
{'y': 2, 'x': None}

value 有关的函数

dict.values() 返回一个包含字典所有值的列表

dict.itervalues() 同dict.itervalues()

>>> adict
{'y': 2, 'x': None}
#values返回字典所有值的列表
>>> adict.values()
[2, None]
#itervalues 返回字典所有值的迭代
>>> for y in adict.itervalues():
...     print y
...
2
None

键值对相关函数

dict.items() 返回字典中键值对元组的列表（即每一个键值以元组存放，整个结果为列表）

dict.iteritems() 返回列表中键值对的迭代

dict.update(dict2) 将dict2的键值存添加到dict中

dict.copy() 返回一个字典的浅拷贝

>>> adict
{'y': 2, 'x': None}
#items将每对键值以元组形式存放，然后返回一个列表
>>> adict.items()
[('y', 2), ('x', None)]
#iteritems 将每对键值返回为一个迭代
>>> for x,y in adict.iteritems():
...     print x,y
...
y 2
x None

>>> adict2={'z':3}
>>> adict
{'y': 2, 'x': None}
#update中待添加的字典的键不存在则将新的键值对加入到字典中，返回None
>>> adict.update(adict2)
>>> adict
{'y': 2, 'x': None, 'z': 3}
#update中带添加的键存在则将修改原有的键对应的值为带添加的值，返回None
>>> adict3={'y':4}
>>> adict.update(adict3)
>>> adict
{'y': 4, 'x': None, 'z': 3}
>>> x=adict.update(adict3)
>>> print x
None

#使用itemitems实现items方法
>>> ret=[]
>>> for x,y in adict.iteritems():
...     ret.append((x,y))
...
>>> print ret
[('y', 4), ('x', None), ('z', 3)]

#copy函数，返回浅拷贝
>>> adict_c=adict.copy()
>>> adict_c
{'y': 4, 'x': None, 'z': 3}
>>>

字典的键的原则

不允许一个键对应多个值

每个键只能对应一个值，当有键发生冲突时，取最后的赋值作为键的值，即python从左到右检查键值对。给字典赋值时，如果一个键不存在，则会被创建和添加，如果键已经存在则此键所对应的值将被替换。

#故意定义了重复的键，取右边的值为最终的值
>>> adict={'x':1,'x':2}
>>> adict
{'x': 2}
#使用切片方法赋值，当键不存在时，将键值添加到字典中
>>> adict['y'] = 2
>>> adict
{'y': 2, 'x': 2}
#使用切片方法赋值，当键已存在时，将对应的键值修改为最后的值
>>> adict['y'] = 3
>>> adict
{'y': 3, 'x': 2}

键必须是可hash的

python 内建的数据类型中，字典和列表是可变类型，因为他们是不能hash的，所以不能作为字典的键。所有不可变的类型都是可哈希的，都可以作为字典的键。

如果自定义的对象实现了__hash__方法，并返回一个固定的值，那么这个对象也可以作为键。

>>> class Person():
...     def __init__(self,name,age):
...         self.name = name
...         self.age = age
...     def __hash__(self):
...         return hash(self.name+str(self.age))
...
>>> ttt=Person('xxx',12)
>>> print ttt
<__main__.Person instance at 0x02BB0A80>
>>> yyy=Person('xxx',12)
>>> print ttt.__hash__
<bound method Person.__hash__ of <__main__.Person instance at 0x02BB0A80>>
>>> print yyy.__hash__
<bound method Person.__hash__ of <__main__.Person instance at 0x02BB09E0>>
>>> u={ttt:'z'}
>>> u
{<__main__.Person instance at 0x02BB0A80>: 'z'}
>>> print u
{<__main__.Person instance at 0x02BB0A80>: 'z'}

###### end

posted @ 2018-07-17 18:11 panzq 阅读(173) 评论(0) 编辑收藏举报

刷新页面返回顶部

panzq

开启知识分享的舞台~

python学习[第十一篇] 数据类型之字典

python学习[第十一篇] 数据类型之字典

字典概念

字典的增删改查

操作符

标准类型操作符

字典操作符

切片操作符 []

成员操作符 in

映射类型内建函数及工厂函数

标准类型内建函数

映射类型相关的函数

dict() 函数

len 函数

字典的内建方法

key有关的函数

value 有关的函数

键值对相关函数

字典的键的原则

不允许一个键对应多个值

键必须是可hash的

公告

panzq

开启知识分享的舞台~

python学习[第十一篇] 数据类型之 字典

python学习[第十一篇] 数据类型之 字典

字典概念

字典的增删改查

操作符

标准类型操作符

字典操作符

切片操作符 []

成员操作符 in

映射类型内建函数及工厂函数

标准类型内建函数

映射类型相关的函数

dict() 函数

len 函数

字典的内建方法

key有关的函数

value 有关的函数

键值对相关函数

字典的键的原则

不允许一个键对应多个值

键必须是可hash的

公告

python学习[第十一篇] 数据类型之字典

python学习[第十一篇] 数据类型之字典