Python学习笔记《Python核心编程》第7章 映像和集合类型

7.1 映射类型：字典

    7.1.1 创建字典和给字典赋值

         dict1 = {}

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

         也可以用工厂方法来创建字典：fdict = dict((['x',1],['y',2]))    =>  {'y':2,'x':1}

    7.1.2 访问字典中的值

        遍历字典：             

for key in dict2.keys():
    print 'key = %s,value=%s' % (key,dict2[key])

    
#key = name,value=earch
#key = port,value=80

       访问字典中的一个数据元素：dict2['name']   #earch , 如果键名不存在，会产生错误；

       判断某个键是否存在的方法有：has_key()  和 in 以及 not in操作符

             ‘server’ in dict2        # or dict2.has_key('server')      返回Falser

       可以采取各种类型的数据作为字典的键,数字或字符串。 如：  dict3 = {3.2:'xyz',1:'abc','1':3.24259}

    7.1.3  如何更新字典

       添加一个新数据项或新元素;修改一个已存在的数据项;或删除一个已存在的数据项

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

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

       dict2.update(dict3)          # 把dict3字典合并到dict2

    7.1.4  删除字典元素和字典

      del dict2['name']   #删除键位‘name’的条目

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

      del dict2              #删除整个字典

      dict2.pop(‘name’) # 删除并返回键位‘name’的条目

7.3  映射类型的内建函数和工厂函数

     7.3.1  标准类型行数type()\str()\cmp()

               字典的比较算法：首选是字典的大小，然后是键，最后是值。不常用

7.4 映射类型内建方法

    1. keys() 方法，返回一个列表，包含字典中所有的键

    2.values()方法，返回一个列表，包含字典中所有的值

    3.items()，返回一个包含所有（键，值）元组的列表。 

    4.sorted()，返回一个有序的迭代

    5.update()，方法用来将一个字典的内容添加到另外一个字典中。

    6.clear()方法用来删除字典中的所有条目，dict3.clear()

    7.copy() 方法返回一个字典的副本，浅复制。

    8.fromkeys() 方法

          {}.fromkeys('xyz')    #{'y':None,'x':None,'z':None}

          {}.fromkeys(('love','honor'),True)    #{'love':True,'honor':True}

7.5  字典的键

     不允许一个键对应多个值、键必须是可哈希的（所有不可变的类型都是可哈希的，他们都可以作为字典的键）。注：值相等的数字表示相同的键，整型数字1和浮点型1.0的哈希值是相同的，即他们是相同的键。元组中只有包括像数字和字符串这样的不可以变参数，才可以作为字典中有效的键。

    

#!/usr/bin/env python

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:')
    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:
                    chosen = True
            if choice == 'q':done = True
            if choice == 'n':newuser()
            if choice == 'e':olduser()
if __name__ == '__main__':showmenu()
            

7.6 集合类型

      集合对象时一组无序排列的可哈希的值。

      集合操作符和关系符号：

      in                   是...的成员

      not in             不是...的成员

      ==                 等于

      !=                 不等于

      <                  是...的子集

      <=                是...的子集，包含等于

      >                  是...的超集

      >=                是...的超集，包含非严格超集

      &                  交集

      |                   合集

      -                   差补或相对补集

      ^                  对称差分？

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

      集合被创建的唯一方法——用集合的工厂方法set() 和 frozenset() :

           s = set('xieweiwoaini')                  #set(['a', 'e', 'i', 'o', 'n', 'w', 'x'])

           t = frozenset('xieweiwoaini')         #frozenset(['a', 'e', 'i', 'o', 'n', 'w', 'x'])

7.6.2   如何访问集合中的值

          可以遍历查看集合成员或检查某项元素是否是以个集合中的成员。

          'k'  in  s               #False

          'x'  in  t               #True

          for i in t:

               print i,

7.6.3  如何更新集合：只能更新可变集合，不可变集合会出错

          s.add('z')                         # 添加

          s.update('pypi')                # 增加每一项

          s.remove('x')                   # 删除‘x’

          s -= set('pipi')                 # 删除字符串中的每个字符

7.6.4  如何删除集合中的成员和集合     del s

7.7   集合类型操作符

        标准类型操作符（所有的集合类型）

        1、成员关系 （in , not in）

        2、集合等价/不等价

             集合相等是指当却仅当其中一个集合中的每个成员也是另一个集合中的成员。也可以说每个集合石另一个集合的一个子集，即s<=t 和  s>=t , 与集合成员的顺序无关，至于集合的元素有关

       3、子集、超集（小于符号<,<=）用于判断子集，大于符号（>,>=）用来判断超集

       4、联合（|）

           联合是以个新的集合，该集合的每个元素至少是其中的一个集合成员，联合符号有一个等价的方法，union()：

           s | t         #s.union(t)

       5、交集（&）：即属于两个集合的成员。等价方法，intersection()

       6、差补/相对补集 （-）：只属于集合S，而不属于集合T，等价方法：defference()

            s - t        #s.difference(t)

       7、对称差分（^）：只属于集合S或者集合T的成员，不能同时属于两个集合，等价方法，symmetric_difference()

           s ^ t        #s.difference(t)

       8、混合集合类型操作，上面的示例左边s是可变集合，右边是不可变集合，如果调换一下位置，则结果就不同了，所产生的结果类型与左操作数的类型相同。

            加号(+)，不是集合类型的操作符。

7.7.3 集合类型操作符（仅适用于可变集合）

         Update(|=)    这个更新方法从已存在的集合中添加成员（可能多个），此方法和update()等价。 

>>> s = set('abcdef')
>>> s
set(['a', 'c', 'b', 'e', 'd', 'f'])
>>> u = frozenset(s)
>>> u
frozenset(['a', 'c', 'b', 'e', 'd', 'f'])
>>> s
set(['a', 'c', 'b', 'e', 'd', 'f'])
>>> s |= set('ghijk')
>>> s
set(['a', 'c', 'b', 'e', 'd', 'g', 'f', 'i', 'h', 'k', 'j'])

Intersection Update（&=）    保留操作符保留与其他集合的共有成员，与intersection_update()等价。

>>> s = set(u)
>>> s
set(['a', 'c', 'b', 'e', 'd', 'f'])
>>> s &= set('abc')
>>> s
set(['a', 'c', 'b'])

symmetric differece update（^=）    对集合s和t进行堆成差分更新操作（s^=t）,返回一个集合，该集合中的成员仅是原集合s或仅是另一个集合t中的成员。

与symmetric_difference_update()等价。

7.8 内建函数

      1.  标准类型函数：len()——返回集合元素的个数；

      2.  工厂函数：set() 和 frozenset() : 用来生成可变和不可变集合。不提供参数会生成共的集合，如果提供一个参数，则该参数必须是可迭代的，即一个序列，或迭代器，或支持迭代的一个对象，列入一个文件或一个字典。

           frozenset(['foo','bar'])        #frozenset(['foo','bar'])

7.9 集合类型的内建方法

    方法：copy() ——赋值对象副本

　 方法名称                                                         操作

    s.issubset(t)                                                  如果s是t的子集，则返回True，否则返回False

    s.issuperset(t)                                               如果s是t的超集，则返回True，否则返回False

    s.union(t)                                                      返回一个新集合，该集合是s和t的并集

    s.intersection(t)                                             返回一个新集合，该集合是s和t的交集

    s.difference(t)                                                返回一个新集合，该集合是s的成员，但不是t的成员

    s.symmertric_difference(t)                               返回一个新集合，该集合是s或t的成员，但不是s和t共有的成员

    s.copy()                                                         返回一个新集合，它是集合s的浅复制

7.9.2   方法（仅适用于可变集合）

    方法名                                                            操作

    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 not in s），将引发错误

    s.dicard(obj)                                                   如果obj是集合s中的元素，从集合s中删除对象obj

    s.pop()                                                           删除集合s中的任意一个对象，并返回它

    s.clear()                                                          删除集合s中的所有元素