Python学习笔记4—Python字典元组

zhwz

　　一、字典定义
　　用大括号{}包裹，以逗号分割每个键值对，键与值之间使用冒号连接,构成（key{values)结构。
　　键和值可以是任意的数据对象，大多数情况还是以数字和字符串的方式构成
　　字典是无序的，键在字典中必须是唯一，在字典中取值的方式是以键寻找相对应的值
　　字典是python中的映射数据类型
　　字典不支持拼接(concatenation)和重复(repetirion)
a={}    #定义空字典，没有任何的键和值　　
print a
　　
a={'a':1,'b':2,'c':3,'d':4}     #创建字典，键与值对应，以逗号分割，键与值以冒号连接
　　
print a
　　
a={}.fromkeys(list('abcdef'))     #创建字典,使用字典方法，值创建键，值为None，键来自列表的元素
　　
print a
　　
a=dict((['x', 1], ['y', 2]))    #使用字典函数创建字典
　　
print a
　　
a=dict(zip(["key1",'key2'],(1,2)))  #使用zip方法和dict函数创建字典
　　
print a
　　执行结果为
{}　　
{'a': 1, 'c': 3, 'b': 2, 'd': 4}
　　
{'a': None, 'c': None, 'b': None, 'e': None, 'd': None, 'f': None}
　　
{'y': 2, 'x': 1}
　　
{'key2': 2, 'key1': 1}
　　zip([iterable, ...])
　　zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。利用*号操作符，可以将list unzip（解压）。
>>> a=zip(list('abcdefg'),list('1234567'))　　
>>> print a
　　
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4'), ('e', '5'), ('f', '6'), ('g', '7')]
　　
>>> zip(*a)
　　
[('a', 'b', 'c', 'd', 'e', 'f', 'g'), ('1', '2', '3', '4', '5', '6', '7')]
　　二、字典访问
　　字典无序的，定义字典的顺序与生成字典的顺序是不一至的
　　通过字典的键，取得字典键所对应的值
>>> a={'a':1,'b':2,'c':{'d':3}}    #字典中包含字典　　
>>> print a
　　
{'a': 1, 'c': {'d': 3}, 'b': 2}
　　
>>> a['a']
　　
1
　　
>>> a['c']
　　
{'d': 3}
　　
>>> a['c']['d']
　　
3
　　
>>> a['a']=67    #字典更新
　　
>>> a
　　
{'a': 67, 'c': {'d': 3}, 'b': 2}
　　
>>> del a['a']    #字典删除
　　
>>> a
　　
{'c': {'d': 3}, 'b': 2}
　　三、字典方法
　　1.dict.keys()    获取字典内所有键，以列表返回
　　dict.values()    获取字典内所有值，以列表返回
>>> a=dict(zip(list('abcdef'),list('1234567')))　　
>>> a
　　
{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'f': '6'}
　　
>>> a.keys()
　　
['a', 'c', 'b', 'e', 'd', 'f']
　　
>>> a.keys()[3]
　　
'e'
　　
>>> a.values()
　　
['1', '3', '2', '5', '4', '6']
　　
>>> a.values()[3]
　　
'5'
　　2.dict.pop(k,[d])
　　弹出指定键k所对应的值，并且将该键及其所对应的值删除,如果键没有找到，将返回指定d
>>> a　　
{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'f': '6'}
　　
>>> a.pop('c')
　　
'3'
　　
>>> a
　　
{'a': '1', 'b': '2', 'e': '5', 'd': '4', 'f': '6'}
　　
>>> a.pop('c','not found')
　　
'not found'
　　
>>> a.pop('d','not found')
　　
'4'
　　3.dict.update()
　　更新字典内键与值，键名即使是字符串，在更新时不需要加引号，更新是以赋值的方式进行。等价于dict['key']='new-value'
>>> a　　
{'a': '1', 'b': '2', 'e': '5', 'f': '6'}
　　
>>> a.update(a=55)
　　
>>> a
　　
{'a': 55, 'b': '2', 'e': '5', 'f': '6'}
　　
>>> a['a']=66
　　
>>> a
　　
{'a': 66, 'b': '2', 'e': '5', 'f': '6'}
　　4.dict.get()    获取字典内所有键对应的值，与d['keyname']相同
>>> a　　
{'a': 66, 'b': '2', 'e': '5', 'f': '6'}
　　
>>> a.get('a')
　　
66
　　
>>> a['a']
　　
66
　　5.dict.items()
　　将字典的键和值放在一个元组中，每一个键和值作为一个元组，放在列表中存储返回
>>> a　　
{'a': 66, 'b': '2', 'e': '5', 'f': '6'}
　　
>>> a.items()
　　
[('a', 66), ('b', '2'), ('e', '5'), ('f', '6')]
　　6.dict.popitem()    随机的删除字典中的一个键值对，并且以元组的方式返回
>>> a　　
{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'g': '7', 'f': '6', 'i': '9', 'h': '8', 'j': '0'}
　　
>>> a.popitem()
　　
('a', '1')
　　
>>> a.popitem()
　　
('c', '3')
　　
>>> a.popitem()
　　
('b', '2')
　　
>>> a.popitem()
　　
('e', '5')
　　7.dict.viewitems()    返回字典dict的元素视图
　　dict.viewkeys()     返回字典dict的键视图
　　dict.viewvalues()   返回字典dict的值视图
>>> a　　
{'d': '4', 'g': '7', 'f': '6', 'i': '9', 'h': '8', 'j': '0'}
　　
>>> a.viewitems()
　　
dict_items([('d', '4'), ('g', '7'), ('f', '6'), ('i', '9'), ('h', '8'), ('j', '0')])
　　
>>> a.viewkeys()
　　
dict_keys(['d', 'g', 'f', 'i', 'h', 'j'])
　　
>>> a.viewvalues()
　　
dict_values(['4', '7', '6', '9', '8', '0'])
　　8.dict.iteritems()    返回字典dict的迭代对象
　　dict.iterkeys()     返回字典dict的键的迭代对象
　　dict.itervalues()   返回字典dict的值迭代对象
>>> a　　
{'d': '4', 'g': '7', 'f': '6', 'i': '9', 'h': '8', 'j': '0'}
　　
>>> a.iteritems()
　　
<dictionary-itemiterator object at 0x0000000002E2FA98>
　　
>>> a.iterkeys()
　　
<dictionary-keyiterator object at 0x0000000002E41548>
　　
>>> a.itervalues()
　　
<dictionary-valueiterator object at 0x0000000002E2FA98>
　　
>>> a.iteritems().next()
　　
('d', '4')
　　
>>> a.iterkeys().next()
　　
'd'
　　
>>> a.itervalues().next()
　　
'4'
　　9.dict.setdefault(k，[d])
　　如果键在字典中，返回字典键所对应的值，如果不在创建该键，值默认为None，如果d给定值,值为d
>>> a　　
{'d': '4', 'g': '7', 'f': '6', 'i': '9', 'h': '8', 'j': '0'}
　　
>>> a.setdefault('d',99)
　　
'4'
　　
>>> a.setdefault('a')    #创建键a
　　
>>> a
　　
{'a': None, 'd': '4', 'g': '7', 'f': '6', 'i': '9', 'h': '8', 'j': '0'}
　　
>>> a.setdefault('a',99)    #存在键a，不再创建，a的值为None，没有显示
　　
>>> a
　　
{'a': None, 'd': '4', 'g': '7', 'f': '6', 'i': '9', 'h': '8', 'j': '0'}
　　
>>> a.setdefault('b',88)    #创建键b,并赋值为88，将88弹出
　　
88
　　
>>> a
　　
{'a': None, 'b': 88, 'd': '4', 'g': '7', 'f': '6', 'i': '9', 'h': '8', 'j': '0'}
　　10.dict.copy（）    产生字典副本，或者说是替身
a=dict(zip(list('abcdefg'),list('123456789')))　　
b=a.copy()
　　
print a
　　
print b
　　
print b is a
　　
b['a']=99
　　
print b
　　
print a
　　执行结果为
{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'g': '7', 'f': '6'}　　
{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'g': '7', 'f': '6'}
　　
False
　　
{'a': 99, 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'g': '7', 'f': '6'}
　　
{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'g': '7', 'f': '6'}
import copy　　
a=list('abcdefg')
　　
b=copy.copy(a)
　　
print a
　　
print b
　　可以使用这种方法，复制列表等其他对象，执行结果为
['a', 'b', 'c', 'd', 'e', 'f', 'g']　　
['a', 'b', 'c', 'd', 'e', 'f', 'g']
　　11.dict.clear（）    清除字典内的所有键、值
>>> a　　
{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'g': '7', 'f': '6'}
　　
>>> a.clear()
　　
>>> a
　　
{}
　　12.dict.has key（）
　　成员关系检查，判断字典中是否存在指定的键
　　python3.0 has key将不在支持，被in替代
>>> a　　
{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'g': '7', 'f': '6'}
　　
>>> a.has_key('a')
　　
True
　　
>>> a.has_key('h')
　　
False
　　
>>> 'a' in a
　　
True
　　
>>> 'a' not in a
　　
False
　　
>>> 'h' in a
　　
False
　　
>>> 'h' not in a
　　
True
　　四、Python元组
　　Python元组是python重要的数据对象
　　元组大多数情况下，用于系统的输入或者系统的返回，元组的特性是不可以修改，但是支持迭代
　　元组的方法相对来说，比较少，只有count 和 index
　　元组的定义是以"()"包含以","作为分割元素的对象，元素也可以是任何的数据对象
　　五、Python数据类型比较
　　python 数据类型十分灵活,分别有列表，字典，元组
比较点列表字典元组表示方法[],[1,2]{},{'a':1,'b':2}(),(1,2)访问元素的方式索引键索引有序性有序无序有序可变性可变可变不可变可操作性操作丰富操作丰富操作单调