初识Python(5)__Python映射和集合

映射类型：字典

字典：可以快速查到某个特定的词语（键），从而找到它的定义（值）。（没有顺序）键和值之间用冒号（：）隔开，项之间用逗号（，）隔开，字典由{}括起来

>>> dict1 = {}                                #空字典

>>> dict2 = {'name': 'earth', 'port': 80}            #用{}创建
>>> dict1, dict2
({}, {'port': 80, 'name': 'earth'})

>>> fdict = dict((['x', 1], ['y', 2]))                 #用工厂函数dict()创建
>>> fdict
{'y': 2, 'x': 1}

基本字典操作

len(d)---返回d中项的数量

d[k]---返回关联到键k上的值

d[k]=v---将值v关联到键k上

del d[k]--- 删除键为k的项

k in/not in d---检查d中是否含有键为k的项（从Python 2.2 起，程序员可以不用has_key()方法，而用 in 和 not in 操作符来检查某个键是否存在于字典中）

关于删除字典元素和字典

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

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

del dict2            # 删除整个dict2 字典

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

关于字典的键：

字典所有的键必须是可哈希的，即数据类型必须是不可变的。

>>> us = (2,32,'hj')
>>> hk = {us:12}     #元组做为键
>>> hk
{(2, 32, 'hj'): 12}

>>> r = {['q','w']:2}    #列表作为键-不可行

 Traceback (most recent call last):
  File "<pyshell#27>", line 1, in <module>
    r = {['q','w']:2}
TypeError: unhashable type: 'list'

>>> ua = frozenset('adfwf')
>>> uc = {ua:1}     #不可变集合作为键
>>> uc
{frozenset(['a', 'd', 'w', 'f']): 1}

 >>> ub = set('jay')
>>> uy = {ub:'s'}    #可变集合作为键—不可行

 Traceback (most recent call last):
  File "<pyshell#45>", line 1, in <module>
    uy = {ub:'s'}
TypeError: unhashable type: 'set'

字典比较算法

按一下顺序比较：

(1)     比较字典长度

(2)     比较字典的键

(3)     比较字典的值

(4)     Exact Match

关于工厂函数dict()

工厂函数被用来创建字典。如果不提供参数，会生成空字典。当容器类型对象做为一个参数传递给方法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}

字典方法

1) d.clear():清除字典中的所有的项（清空原始字典中所有的元素）

2) d.copy():返回一个具有相同键-值对的新字典（该方法是浅复制，使用相同的值，改动一个值，则都变化）
    >>> dict4 = dict2.copy()
    >>> dict4
{'server': 'http', 'port': 80, 'host': 'venus'}

3) d.deepcopy():深复制，复制其包含的值。from copy import deepcopy

4) d.fromkeys():使用给定的件建立新的字典，默认对应的值为None---{}.fromkeys(['name','age'])自己提供默认值：dict.fromkeys(['name','age'],'(unknow)')---unknow为值
    >>> {}.fromkeys('xyz')
    {'y': None, 'x': None, 'z': None}
    >>> 
    >>> {}.fromkeys(('love', 'honor'), True)
    {'love': True, 'honor': True}

5) d.get():更宽松的访问字典，即使访问不存在的键时，也不会出现异常，而是得到None值。默认的None值可以替换：d.get('name','N/A')
    >>> dict4.get('host')
    'venus'
    >>> dict4.get('xxx')
    >>> type(dict4.get('xxx'))
    <type 'None'>
    >>> dict4.get('xxx', 'no such key')
    'no such key'

6) d.has_key():检查字典中是否含有给出的键。 d.has_key(k) 相当于表达式k in d。

7) d.items()：将字典以列表形式返回d.items()

8) d.iteritems()：和tiems类似，不过是返回一个迭代器对象

9) d.keys()：将字典中的键以列表形式返回

10) d.iterkeys(): 返回一个针对键的迭代器

11) d.pop(): 给指定键，返回该键的值，然后再删掉这个键-值。

12) d.popitem():和pop类似，不过不需要给出键

13) d.setdefault():检查字典中是否含有某键。 如果字典中这个键存在，你可以取到它的值。 如果所找的键在字典中不存在，你可以给这个键赋默认值并返回此值。
    >>> myDict = {'host': 'earth', 'port': 80}
    >>> myDict.keys()
    ['host', 'port']
    >>> myDict.items()
    [('host', 'earth'), ('port', 80)]
    >>> myDict.setdefault('port', 8080)
    80
    >>> myDict.setdefault('prot', 'tcp')
   'tcp'
    >>> myDict.items()
    [('prot', 'tcp'), ('host', 'earth'), ('port', 80)]

14) d.update(): 把一个字典项更新到目标字典。d.update(x)--把x字典更新到d字典
    >>> dict2= {'host':'earth', 'port':80}
    >>> dict3= {'host':'venus', 'server':'http'}
    >>> dict2.update(dict3)
    >>> dict2
    {'server': 'http', 'port': 80, 'host': 'venus'}
    >>> dict3.clear()                        #清空字典所有项
     >>> dict3
    {}

15) d.values(): 以列表的形式返回字典中的值，返回值的列表可以包含重复的元素。

16) d.itervalues():返回值的迭代器

集合

集合的创建

只能通过工厂函数set() 和 frozenset() 创建：

>>> j = set('jayjiang')
>>> j
set(['a', 'g', 'i', 'j', 'n', 'y'])

>>> i = frozenset('jayjiang')
>>> i
frozenset(['a', 'g', 'i', 'j', 'n', 'y'])

>>> j == i
True

>>> type(j)
<type 'set'>

>>> type(i)
<type 'frozenset'>

>>> 

集合的操作(适用于所有类型集合)

成员关系（in，not in）

集合等价/不等价（==， !=）

子集/超集( <，<=，>, >=)

联合( | )

交集( & )

差补/相对补集( – )

对称差分( ^ )

集合类型方法 

方法名称	操作
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 的浅复制

可变集合类型的操作方法（ set() ）

方法名	操作
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 中的元素(obj notin s)，将引发KeyError 错误
s.discard(obj)	如果obj 是集合s 中的元素，从集合s 中删除对象obj
s.pop()	删除集合s 中的任意一个对象，并返回它
s.clear()	删除集合s 中的所有元素