Python核心编程之字典和集合

1、了解字典
字典是python中唯一的映射类型。映射类型对象里哈希值和指向的对象是一对多的关系。
字典是可变类型。
字典类型和序列类型容器（列表、元组）的区别是存储和访问数据的方式不同。序列类型只用数字类型的键，从序列的开始起按数值顺序索引；字典类型可以用其他对象类型做键，常见的是用字符串做键，键直接或间接地和存储的数据值相关联。

2、创建字典，给字典赋值
1）把字典赋值给一个变量
示例程序一：

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

2）工厂方法dict()
示例程序二：

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

>>>
3）内建方法fromkeys()创建默认字典，字典中元素具有相同的值，若没有给出，默认为None
示例程序三：

>>> dict4 = {}.fromkeys(('x', 'y'), -1)
>>> dict4
{'y': -1, 'x': -1}
>>> dict5 = {}.fromkeys(('foo','bar'))
>>> dict5
{'foo': None, 'bar': None}
>>>

4)访问字典中值
示例程序四：访问字典

>>> dict2
{'name': 'earth', 'port': '80'}
>>> for key in dict2.keys():
... print 'key=%s, value=%s' % (key, dict2[key])
...
key=name, value=earth
key=port, value=80
>>>

示例程序五：

>>> 'name' in dict2 # 查询是否具有某一键值
True

>>> dict2['name'] = 'haha' # 更新已有条目
>>> dict2
{'name': 'haha', 'port': '80'}

>>>dict2.has_key('name')
True
>>>dict2.clear() #删除字典中的所有条目
>>>dict2.pop('name') #删除并返回键为name的条目
>>>dict2.values() #返回值的列表
>>>dict2.items() #返回键值对元组的列表

3、映射相关函数
dict([container]) —— 创建字典的工厂函数。
len(mapping) —— 返回映射到长度（键值对的个数）
hash(obj) —— 返回obj的哈希值
示例程序六：

>>> 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}
>>> dict8 = dict(x=1, y=2)
>>> dict8
{'y': 2, 'x': 1}
>>> dict9 = dict8.copy()
>>> dict9
{'y': 2, 'x': 1}
>>>
>>> len(dict8)
2
>>>

4、字典的键
(1)不允许一个键对应多个值
对应的值可以是其他的容器类型的对象。
(2)键必须是可以哈希的
像列表和字典这样的可变类型，由于它们不是可哈希的，所以不能作为键。所有不可变类型的都是可哈希的，因此他们都可以作为字典的键。一个要说明的问题是数字：值相等的数字表示相同的键。同时，也有一些可变对象（很少）是可哈希的，他们可以作为字典的键，但是很少见。举一个例子，实现了__hash__特殊方法的类。因为__hash__返回一个整型，所以仍然是用不可变的值（做字典的键）。
我们知道数字和字符串可以被用作字典的键，但元组如何呢？用元组做有效的键，必须加以限制：元组中只包括想数字和字符串这样的不可变参数，才可以作为字典中有效的键。

5、映射类型的内建函数和工厂函数
(1)标准类型函数[type()、str()和cmp()]
字典的比较cmp()函数按照如下的顺序：(1)比较字典的长度，参数一长度大于参数二返回正值，小于参数二返回负值（2）比较字典的键（3）比较字典的值（4）完全匹配。
(2)映射类型相关的函数
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)
{'y':2,
'x':1}

>>dict9
= dict(**dict8)
{'y':2,
'x':1}

len()
hash() 如果非可哈希类型作为参数传给hash()方法，会产生TypeError错误（因此，如果使用这样的对象作为键给字典赋值会出错）。

字典类型方法(映射类型的内建方法)
方法名字 操作
dict.clear()删除字典中所有元素
dict.copy()返回字典(浅复制)的一个副本
dict.fromkeys(seq,val=None)创建并返回一个字典，以seq中的元素作为字典的键，val作为所有键对应的值的初始值
dict.get(key,default=None)对字典中的键key，返回它对应的值value，如果字典中不存在此键，则返回default的值
dict.has_key(key)如果存在键key，返回True；否则返回False。由于in和 not in的引入，此方法几乎废弃，但仍提供一个可工作的接口。
dict.items()返回包含键值对元组的列表
dict.keys()返回包含字典中键的列表
dict.iter()方法iteritems(),iterkeys(),itervalues()与其对应的非迭代方法一样，不同的是一个返回迭代子，一个返回列表。
dict.pop(key[,default])与get()方法相似,如果键key存在，删除并返回返回dict[key]，如果不存在且没有给出default值，引发KeyError异常。
dict.setdefault(key,default=None)与方法set()类似，如果键key不存在，那么由dict[key]=default为它赋值。
dict.update(dict2)将字典dict2的键值对添加到dict中。
dict.values()返回包含字典中所有值得列表

6、用户登录小程序（userpw.py）

#! /usr/bin/env python
#coding=utf-8
db = {}

def newuser():
prompt = 'login desired: '
while True:
name = raw_input(prompt)
if db.has_key(name):
prompt = 'name taken, try another: '
continue
else:
break
pwd = raw_input('passwd: ')
db[name] = pwd

def olduser():
name = raw_input('login: ')
pwd = raw_input('passwd: ')
passwd = db.get(name)
if passwd == pwd:
print 'welcome back', name
else:
print 'login incorrect'

def showmenu():
prompt = """
(N)ew User Login
(E)xisting User Login
(Q)uit
Enter choice: """

done = False
while not done:

chosen = False
while not chosen:
try:
choice = raw_input(prompt).strip()[0].lower()
except (EOFError, KeyboardInterrupt):
choice = 'q'
print '\nYou picked: [%s]' % choice
if choice not in 'neq':
print 'invalid option, try again'
else:
if choice == 'n':
newuser()
elif choice == 'e':
olduser()
else:
print 'quit!'
return

if __name__ == '__main__':
showmenu()

7、集合类型
集合对象是一组无序排列的可哈希的值。因为无序，不支持切片操作。
集合分为可变集合和不可变集合。
8、集合基本操作
1）集合的创建
set() frozenset()
示例程序七：创建集合

>>> 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'>
>>> len(t)
6
>>> s == t
False
>>>

2）访问集合中的值
in 和 not in
示例程序八：访问集合元素

>>> 'k' in s
False
>>> for i in s:
... print i
...
c
e
h
o
p
s
>>>

3）更新集合
add() update() remove()
示例程序九：更新集合元素

>>> 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'])
>>>

4)删除集合
>>> del s
9、集合类型操作符
(1)标准类型操作符（所有的集合类型）
成员关系（in, not in）,集合等价/不等级（==，!=）,子集/超集（<,<=,>,>=）
(2)集合类型操作符
联合（|），交集（&），差补/相对补集（-），对称差分（^）
(3)集合类型操作符
|=，&=，-=，^=

集合类型方法
方法名称 操作
s.issubset(t)
子集判断，如名字所示。
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的浅复制。

仅适用于可变集合的方法
s.update(t)
s.intersection_update(t) 交集。
s.difference_update(t) 差集。
s.symmetric_difference_update(t) 对称差集。
s.add(obj)
s.remove(obj)
s.discard(obj)
s.pop() 删除任意一个对象。
s.clear()

REF:http://blog.sina.com.cn/s/blog_76e94d210100wcb6.html