Python核心编程第七章笔记

创建字典

>>>dict1 = {}

>>>dict2 = {'name': 'earth', 'port': 80}

>>>dict1, dict2

({},{'port': 80, 'name': 'earth'})

>>>fdict = dict((['x', 1], ['y', 2]))

>>>fdict

{'y':2, 'x': 1}

>>ddict = {}.fromkeys(('x', 'y'), -1)

>>>ddict

{'y':-1, 'x': -1}

EditBy Vheavens Edit By Vheavens

>>>

>>>edict = {}.fromkeys(('foo', 'bar'))

>>>edict

{'foo':None, 'bar': None}

访问字典中的值

>>>dict2 = {'name': 'earth', 'port': 80}

>>>

>>>>for key in dict2:

...print 'key=%s, value=%s' % (key, dict2[key])

...

key=name,value=earth

key=port,value=80

如果我们想访问该字典中的一个数据元素,而它在这个字典中没有对应的键,将会产生一个错误:

>>>dict2['server'] Traceback (innermost last):

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

KeyError:server

一个字典中混用数字和字符串的例子:

>>>dict3 = {}

>>>dict3[1] = 'abc'

>>>dict3['1'] = 3.14159

>>>dict3[3.2] = 'xyz'

>>>dict3

{3.2:'xyz', 1: 'abc', '1': 3.14159}

更新字典

>>>dict2['name'] = 'venus'   # 更新已有条目

>>>dict2['port'] = 6969         # 更新已有条目

>>>dict2['arch'] = 'sunos5'   # 增加新条目

删除字典元素和字典

deldict2['name'] #删除键为“name”的条目

dict2.clear() #删除dict2中所有的条目

deldict2 #删除整个dict2字典

dict2.pop('name') #删除并返回键为“name”的条目

从Python2.2 起,用in和 notin 操作符来检查某个键是否存在于字典中:

>>>'name' in dict2

True

>>>'phone' in dict2

False

字典比较算法

(1)比较字典长度

如果字典的长度不同,那么用cmp(dict1,dict2) 比较大小时,如果字典dict1比 dict2长,cmp()返回正值,如果dict2比 dict1长,则返回负值。也就是说,字典中的键的个数越多,这个字典就越大,即:

len(dict1)> len(dict2) ==> dict1 > dict2

(2)比较字典的键

如果两个字典的长度相同,那就按字典的键比较;键比较的顺序和keys()方法返回键的顺序相同。(注意:相同的键会映射到哈希表的同一位置,这保证了对字典键的检查的一致性。)这时,如果两个字典的键不匹配时,对这两个(不匹配的键)直接进行比较。当dict1中第一个不同的键大于dict2中第一个不同的键,cmp()会返回正值。

(3)比较字典的值

如果两个字典的长度相同而且它们的键也完全匹配,则用字典中每个相同的键所对应的值进行比较。一旦出现不匹配的值,就对这两个值进行直接比较。若dict1比 dict2中相同的键所对应的值大,cmp()会返回正值。

(4)Exact Match

到此为止,即,每个字典有相同的长度、相同的键、每个键也对应相同的值,则字典完全匹配,返回0值。

映射类型相关的函数

dict()函数

>>>dict(zip(('x', 'y'), (1, 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}

>>>dict(x=1, y=2)

{'y':2, 'x': 1}

>>>dict8 = dict(x=1, y=2)

>>>dict8

{'y':2, 'x': 1}

>>>dict9 = dict(**dict8)

>>>dict9

{'y':2, 'x': 1}

我们提醒读者dict9的例子只作为了解dict()方法的用途,它不是现实中的例子。使用下面这些行的方法更聪明(效率更好):

>>>dict9 = dict8.copy()

>>>dict9

{'y':2, 'x': 1}

len()函数

>>>dict2 = {'name': 'earth', 'port': 80}

>>>len(dict2)

2

hash()函数

>>>hash([])

Traceback(innermost last):

TypeError:list objects are

>>>

>>>dict2[{}] = 'foo'

Traceback(most recent call

TypeError:dict objects are

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

unhashable

last):File "<stdin>", line 1, in ?

unhashable

>>dict2.keys()

['port','name']

>>>

>>>dict2.values()

[80,'earth']

>>>

>>>dict2.items()

[('port',80), ('name', 'earth')]

>>>dict2= {'host':'earth', 'port':80}

>>>dict3= {'host':'venus', 'server':'http'}

>>>dict2.update(dict3)

>>>dict2

{'server':'http', 'port': 80, 'host': 'venus'}

>>>dict4 = dict2.copy()

>>>dict4

{'server':'http', 'port': 80, 'host': 'venus'}

>>>dict4.get('host')

'venus'

>>>dict4.get('xxx')

>>>type(dict4.get('xxx'))

<type'None'>

>>>dict4.get('xxx', 'no such key')

'nosuch key'

不允许一个键对应多个值

>>>dict1 = {' foo':789, 'foo': 'xyz'}

>>>dict1

{'foo':'xyz'}

>>>

>>>dict1['foo'] = 123

>>>dict1

{'foo':123}

键必须是可哈希的

所有不可变的类型都是可哈希的,因此它们都可以做为字典的键。

一个要说明的是问题是数字:值相等的数字表示相同的键。换句话来说,整型数字1和 浮点数1.0的哈希值是相同的,即它们是相同的键。

集合类型

创建集合类型和给集合赋值

>>>s = set('cheeseshop')

>>>s

set(['c','e', 'h', 'o', 'p', 's'])

>>>t = frozenset('bookshop')

>>>t

frozenset(['b','h', 'k', 'o', 'p', 's'])

>>>type(s)

<type'set'>

>>>type(t)

<type'frozenset'>

>>>len(s)

6

不可变集合frozenset、可变集合set

可变集合(set)不是可哈希的,因此既不能用做字典的键也不能做其他集合中的元素。不可变集合(frozenset)则正好相反,即,他们有哈希值,能被用做字典的键或是作为集合中的一个成员。

更新集合

>>>s.add('z')

>>>s

set(['c','e', 'h', 'o', 'p', 's', 'z'])

>>>s.update('pypi')

>>>s

set(['c','e', 'i', 'h', 'o', 'p', 's', 'y', 'z'])

>>>s.remove('z')

>>>s

set(['c','e', 'i', 'h', 'o', 'p', 's', 'y'])

>>>s -= set('pypi')

>>>s

set(['c','e', 'h', 'o', 's'])

>>>set('shop') < set('cheeseshop')

True

>>>set('bookshop') >= set('shop')

True

联合(| ) 等价的方法union().

>>>s | t

set(['c','b', 'e', 'h', 'k', 'o', 'p', 's'])

交集(& ) 等价的方法intersection().

>>>s & t

set(['h','s', 'o', 'p']

差补/相对补集(– )等价的方法difference().

>>>s - t

set(['c','e'])

对称差分 异或(^ )等价的方法symmetric_difference()

>>>s ^ t

set(['k','b', 'e', 'c'])

如果左右两个操作数的类型相同,既都是可变集合或不可变集合,则所产生的结果类型是相同的,但如果左右两个操作数的类型不相同(左操作数是set,右操作数是frozenset,或相反情况),则所产生的结果类型与左操作数的类型相同。

>>>v = s + t

Traceback(most recent call last):

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

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

>>>v = s | t

>>>v

set(['c','b', 'e', 'h', 'k', 'o', 'p', 's'])

>>>len(v)

8

>>>s < v

True

s.issubset(t)

如果s是 t的子集,则返回True,否则返回False

s.issuperset(t)

如果t是 s的超集,则返回True,否则返回False

s.union(t)

返回一个新集合,该集合是s和 t的并集

s.intersection(t)

返回一个新集合,该集合是s和 t的交集

s.difference(t)

返回一个新集合,该集合是s的成员,但不是t的成员

s.symmetric_difference(t)

返回一个新集合,该集合是s或 t的成员,但不是s和 t共有的成员

s.copy()

返回一个新集合,它是集合s的浅复制

add(),remove(), discard(), pop(), clear()必须是可哈希的。

s.update(t)

用t中的元素修改s,即,s现在包含s或 t的成员

s.intersection_update(t)

s中的成员是共同属于s和 t的元素。

s.difference_update(t)

s中的成员是属于s但不包含在t中的元素

s.symmetric_difference_update(t)s 中的成员更新为那些包含在s或 t中,但不

是s和t共有的元素

s.add(obj)

在集合s中添加对象obj

s.remove(obj)

从集合s中删除对象obj;如果obj不是集合s中的元素(objnotin s),将引发KeyError错误

s.discard(obj)

如果obj是集合 s中的元素,从集合s中删除对象obj;

s.pop()

删除集合s中的任意一个对象,并返回它

s.clear()

删除集合s中的所有元素