初识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”的条目

字典比较算法

按一下顺序比较：

(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‘>

>>> 

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

 1 成员关系（in，not in）
 2
 3 集合等价/不等价（==， !=）
 4
 5 子集/超集( <，<=，>, >=)
 6
 7 联合( | )
 8
 9 交集( & )
10
11 差补/相对补集( – )
12
13 对称差分( ^ )

集合类型方法

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