Python中字典和集合的详细介绍

Python中字典和集合

映射类型：
    表示一个任意对象的集合，且可以通过另一个几乎是任意键值的集合进行索引
    与序列不同，映射是无序的，通过键进行索引
        任何不可变对象都可用作字典的键，如字符串、数字、元组等
        包含可变对象的列表、字典和元组不能用作键
        引用不存在的键会引发KeyError异常

1)字典

    dict    {  }    空字典
            { key1:value1,key2:value2,... }
        字典在其它编程语言中又称作关联数组或散列表；

    通过键实现元素存取；无序集合；可变类型容器，长度可变，异构，嵌套
                                                 
    支持的操作：
        len(D)                      返回D中的项目数                       
        D[k]                        返回D中键k的值
        D[k] = x                    将D[k]的值设为x                    
                    >>> d1 = {'x':1,'y':2,'z':3}
                    >>> d1['x']
                    1
                    >>> d1['z']                 通过键索引
                    3   
        del D[k]                    从D中删除D[k]
                    >>> del d1['x']
                    >>> d1
                    {'y': 2, 'z': 3}
        k in D                      如果k是D中的值，则返回True
             
     支持的方法：
        D.clear()                   清除所有元素
        D.copy()                    复制一个副本
                    >>> d1 = {'x':1,'y':2,'z':3}
                    >>> id(d1)
                    45320640
                    >>> d2 = d1.copy()                深复制
                    >>> id(d2)
                    45997776            
                    >>> d3 = d1                       浅复制
                    >>> id(d3)
                    45320640                           d1、d3指向同一对象，d2指向另一对象
        D.get(k[,d])                取得对应键的值，若不存在则返回d(默认为空)
                    >>> d1.get('y')
                    2
        D.has_key(k)                是否存在键值，返回True或False.(仅在pyhton2中使用)
        D.items()                   转换为(key,value)元组组成的列表
                    >>> d1.items()
                    [('y', 2), ('x', 1), ('z', 3)]
                    >>> t1,t2,t3 = d1.items()
                    >>> t1
                    ('y', 2)
                    >>> t2
                    ('x', 1)
                    >>> t3
                    ('z', 3)
                    >>> m1,m2 = {'x':1,'y':2}
                    >>> print m1
                    'y'
                    >>> print m2
                    'x'                                 保存的是键，而不是值!!!
        D.values()                  值列表
                    >>> d1.values()
                    [2, 1, 3]
        D.keys()                    键列表
                    >>> d1.keys()
                    ['y', 'x', 'z']
        D.pop(k[,d])                弹出指定键值，若不指定则会触发异常
                    >>> d1.pop()
                    TypeError: pop expected at least 1 arguments, got 0
                    >>> d1.pop('x')
                    1
                    >>> d1
                    {'y': 2, 'z': 3}
        D.popitem()                  随机弹出    
                    >>> d1.popitem()
                    ('y', 2)
                    >>> d1.popitem()
                    ('z', 3)
                    >>> d1.popitem()               
                    KeyError: 'popitem(): dictionary is empty'               为空时异常
                    >>> d1
                    { }
        D.update(m)                   合并字典
                    >>> d1 = { 'x':1,'y':2,'z':3 }
                    >>> d2={'c':'hello','y':66}
                    >>> d1.update(d2)
                    >>> d1
                    {'y': 66, 'x': 1, 'c': 'hello', 'z': 3}             若键存在则会覆盖，不存在就添加   
        D.iteritems()                   返回一个迭代器对象
                    >>> d1 = { 'x':1,'y':2,'z':3 }
                    >>> i1 = d1.iteritems()
                    >>> i1.next()                   使用next方式遍历每一个元素
                    ('y', 2)
                    >>> i1.next()
                    ('x':1)
                    >>> i1.next()
                    ('z':3)
                    >>> i1.next()
                    StopIteration                   遍历结束后不会重新开始
        D.iterkeys()        ->     an iterator over the keys of D
                    >>> i2 = d1.iterkey()
                    >>> i2.next()
                    'y'
        D.itervalues()      ->      an iterator over the values of D
                    >>> i3 = d1.iterkey()
                    >>> i3.next()
                    2
        D.viewvalues()                              返回类似集合方式的字典(值组成)
                    >>> d1.viewvalues()
                    dict_values([2, 1, 3])
        D.viewitems()       ->      a set-like object providing a view on D's items(键值对)
                    >>> d1.viewitems()
                    dict_items([('y', 2), ('x', 1), ('z', 3)])
        D.viewkeys()        ->      a set-like object providing a view on D's keys
                    >>> d1.viewkeys()
                    dict_keys(['y', 'x', 'z'])
                    
                    >>> d2 = dict(x=1,y=2,z=3)              定义字典另一种方式
                    >>> d2
                    {'y': 2, 'x': 1, 'z': 3}

    补充：zip   返回元组组成的列表
            >>> zip('xyz','123')
            [('x', '1'), ('y', '2'), ('z', '3')]            一一对应生成列表
            >>> zip('xyzm','123')
            [('x', '1'), ('y', '2'), ('z', '3')]            多余项被舍弃
            >>> zip('xyz','123','qer')
            [('x', '1', 'q'), ('y', '2', 'e'), ('z', '3', 'r')]                
            >>> dict(zip('xyz','123'))                      构造字典
            {'y': '2', 'x': '1', 'z': '3'}

2)集合

  无序排列、可哈希；
  支持集合关系测试
        成员关系测试：
            in
            not in
            迭代
  不支持：索引、元素获取、切片

  集合的类型：  set()    frozenset()
                可变       不可变
  没有特定语法格式，只能通过工厂函数创建   
      例：
            >>> s1=set(1,2,3)                                       
            TypeError: set expected at most 1 arguments, got 3              错误方式
            >>> s1 = set([1,2,3])                                           正确方式
            >>> s1
            set([1, 2, 3])
            >>> type(s1)
            set
  支持的方法和操作：

3)小结

    如何获取使用帮助：
        获取对象支持使用的属性和方法：dir()
        某方法的具体使用帮助：help(list.pop)
        获取可调用对象的文档字串：print obj.__doc__
        
    容器、类型、对象：
        1、列表、元组、字典字面量可在无换行符下分布在多行内，最后一个字符后可跟逗号(若空则不可使用)    

        2、所有对象都有引用计数(sys模块中getrefcount方法);
                >>> import sys
                >>> s1
                set([1, 2, 3])
                >>> sys.getrefcount(s1)                 查看s1的引用计数
                3
                
        3、列表和字典都支持两种类型的复制操作：浅复制和深复制；深复制可使用copy模块中的deepcopy()实现。
    
        4、Python中的所有对象都是“第一类的”，这意味着使用标识符命名的所有对象都具有相同状态，于是，能够命名所有对象都可以直接当数据进行处理；
    
        5、所有序列都支持迭代；(非负整数的有序集合)
    
        6、所有序列都支持的操作和方法：
            s[i]            索引                s[i:j]      切片            
            s[i:j:stride]   扩展切片            len(s)
            min(s)          max(s)              sum(s)
            all(s)          所有为true          any(s)      任意为true
            s1 + s2: 连接                       s1 * N: 重复
            成员关系判断：
                obj in s1
                obj not in s1
        7、可变序列的操作：
            s[index] = value        元素赋值
            s[i:j] = t              切片赋值
            s[i:j:stride] = t       扩展切片赋值
            del s[index]            元素删除
            del s[i:j]              切片删除
            del s[i:j:stride]       扩展切片删除
        引用计数和垃圾回收：
            所有对象都有引用计数
                给对象分配一个新名称或将其放入一个容器内，其引用计数都会增加
                用del语句或为变量重新赋值时，其引用计数会减少
                sys.getrefcount()可以获得对象的当前引用计数
            一个对象的引用计数器归零时，它将被垃圾收集机制回收

以上就是Python中字典和集合的详细介绍的详细内容，更多请关注其它相关文章！