Python中模块之collections系列

collection系列功能介绍

1. 常用的集中类

1. Counter(计数器)

计数器的常用方法如下:

  1. 创建一个字典计数器

    格式:collections.Counter(obj)
    例如:print(collections.Counter('abcab'))
    >>> Counter({'a': 2, 'c': 2, 'b': 1})
    返回值:collections.Counter
    #把传入的字符串进行单个字符拆分,字符作为字典计数器的key,字符出现的个数作为字典计数器的value。
    print(collections.Counter([1,2,3,2,3]))
    >>> Counter({1: 1, 2: 2, 3: 2})
    返回值:collections.Counter
    #把元祖的元素进行统计,返回每个元素的个数。
    print(collections.Counter((1,2,3,1,3)))
    >>> Counter({1: 2, 2: 1, 3: 2})
    返回值:collections.Counter
    #把元祖的元素进行统计,返回每个元素的个数。
    print(collections.Counter({1,2,3}))
    >>> Counter({1: 1, 2: 1, 3: 1})
    返回值:collections.Counter
    #统计集合中元素的个数,由于集合天生除重,因此每个元素的个数均为1。
    print(collections.Counter({'a':'b','b':'c'}))
    >>> Counter({'b': 'c', 'a': 'b'})
    返回值:collections.Counter
    #当参数为字典时,返回值不再是统计个数。

    注:由于该类是对字典的增强,因此字典拥有的方法,该类都有。

  2. clear(清空字典计数器)

    格式:collections.Counter(obj).clear()
    例如:print(collections.Counter('abcab').clear())
    >>> Counter()
    返回值:collections.Counter
    #对原字典计数器进行操作,清空所有元素。
  3. copy(复制)

    格式:collections.Counter(obj).copy()
    例如:print(collections.Counter('abccc').copy())
    >>> Counter({'c': 3, 'a': 1, 'b': 1})
    返回值:collections.Counter
    #复制一个字典计数器
  4. elements(成员)

    格式:collections.Counter(obj).elements()
    例如:print(collections.Counter('abccc').elements())
    >>> itertools.chain object at 0x0000000000D26518
    返回值:itertools.chain
    for i in collections.Counter('abccc').elements():
    print(i)
    >>> 'a'
    >>> 'b'
    >>> 'c'
    #获取成员后生成一个迭代器,遍历时得到的是字典计数器中的key。
  5. get(获取字典计数器的值)

    格式:collections.Counter(obj).get(key[,value])
    例如:print(collections.Counter('abccc').get('c'))
    >>> 3
    print(collections.Counter('abccc').get('d','adc'))
    >>> 'adc'
    返回值:obj
    #获取字典计数器指定key的value,如果key不存在时,可以指定key的value。
  6. items(所有的键值对)

    格式:collections.Counter(obj).items()
    例如:print(collections.Counter('abccc').items())
    >>> dict_items([('a', 1), ('c', 3), ('b', 1)])
    返回值:dict_items
    #获取字典计数器的键值对,每对字典计数器的key和value作为一个元祖的两个元素,该元祖又作为列表的元素返回。可以通过遍历获取字典计数器的key和value。
  7. keys(所有的键)

    格式:collections.Counter(obj).keys()
    例如:print(collections.Counter('abccc').keys())
    >>> dict_keys(['a', 'c', 'b'])
    返回值:dict_keys
    #把字典计数器中所有的key作为列表的元素返回。
  8. most_common(取前面的N个元素)

    格式:collections.Counter(obj).most_common(number)
    例如:print(collections.Counter('abccc').most_common())
    >>> [('c', 3), ('a', 1), ('b', 1)]
    print(collections.Counter('abccc').most_common(1))
    >>> [('c', 3)]
    返回值:list
    #把每对key和value作为元祖的两个元素,该元祖又作为列表的元组返回,对返回的列表进行排序,默认倒序,参考依据为列表中元祖的第二个元素,也就是原字典计数器中元素的个数。
  9. pop(指定键删除字典计数器的值)

    格式:collections.Counter(obj).pop(key[,value])
    例如:print(collections.Counter('abccc').pop('a'))
    >>> 1
    print(collections.Counter('abccc').pop('d',5))
    >>> 5
    返回值:obj
    #指定字典计数器的key进行删除,同时返回被删除的value,当key不存在时,如果不指定value,程序将报错,当指定value时,将返回value。
  10. popitem(随机删一对键值对)

    格式:collections.Counter(obj).popitem()
    例如:print(collections.Counter('abccc').popitem())
    >>> ('a',1)
    返回值:tuple
    #随机删除一对键值对,并以元祖的形式返回被删除的键值对。
  11. setdefault(默认字典计数器)

    格式:collections.Counter(obj).setdefault(key[,value])
    例如:print(collections.Counter('abccc').setdefault('a'))
    >>> 1
    print(collections.Counter('abccc').setdefault('a',6))
    >>> 1
    print(collections.Counter('abccc').setdefault('d'))
    >>> None
    print(collections.Counter('abccc').setdefault('e',5))
    >>> 5
    返回值:obj
    #设置字典计数器的默认value,当该key存在时,该操作不改变原字典计数器,当key不存在时,如果不知道value,则默认为None,如果指定value,则字典新增key的值即为value。
  12. subtract(减去)

    格式:collections.Counter(obj).subtract(*args,**kwargs)
    例如:sub = collections.Counter('abccc')
    print(sub)
    >>> Counter({'c': 3, 'a': 1, 'b': 1})
    sub1 = sub.subtract('a')
    print(sub1)
    >>> None
    print(sub)
    >>> Counter({'c': 3, 'b': 1, 'a': 0})
    返回值:None
    sub2 = sub.subtract('d')
    print(sub)
    >>> Counter({'c': 3, 'b': 1, 'a': 0, 'd': -1})
    sub3 = sub.subtract(('b',3))
    >>> Counter({'c': 3, 'a': 0, 'b': 0, 'd': -1, 3: -1})
    sub4 = sub.subtract({'a':2})
    >>> Counter({'c': 3, 'b': 0, 'd': -1, 3: -1, 'a': -2})
    #更新原字典计数器,如果传入的参数为字符串,那么该字符串将作为字典计数器的key,如果该key存在,则直接key对于的value减去1,当key不存在,则新增一对键值对,value为-1,当传入的参数为元祖时,元祖的元素均作为key更新原字典计数器,如果传入的参数为字典计数器时,如果有key相同,则value直接相减,如果key不同,则value为-value。
  13. update(更新字典计数器)

    格式:collections.Counter(obj)
    返回值:None
    #该方法为相加与subtract刚好相反,具体实例参考上述方法。
  14. values(所有的值)

    格式:collections.Counter(obj).values()
    例如:print(collections.Counter('abccc').values())
    >>> dict_values([1, 3, 1])
    返回值:dict_values
    #把字典计数器中所有的value作为列表的元素返回。

2.OrderedDict(有序字典)

有序字典的常用方法如下:

  1. 创建一个有序字典

    格式:collections.OrderedDict(variable=value)
    例如:print(collections.OrderedDict(a='abcd'))
    >>> OrderedDict([('a', 'abcd')])
    格式:collections.OrderedDict(dict)
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}))
    >>> OrderedDict([('b', 'bc'), ('a', 'ab')])
    返回值:collections.OrderedDict
    #创建一个有序的字典常用的还是第二种,第一种方法一次只能创建一对键值对的有序字典。

    注:有序字典的键值对和字典不一样,有序字典的键值对是以元祖的形式存在,但字典所拥有的功能,有序字典也有。

  2. clear(清空字典)

    格式:collections.OrderecDict(dict).clear()
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).clear())
    >>> None
    返回值:None
    #把原有序字典进行清空
  3. copy(复制)

    格式:collections.OrderedDict(dict).copy()
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).copy())
    >>> OrderedDict([('b', 'bc'), ('a', 'ab')])
    返回值:collections.OrderedDict
    #复制原有序字典,生成新的一个有序字典。
  4. fromkeys(创建值相同的新有序字典)

    格式:collections.OrderedDict(dict).fromkeys(obj[,value])
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).fromkeys('xyz'))
    >>> OrderedDict([('x', None), ('y', None), ('z', None)])
    返回值:collections.OrderedDict
    #创建新默认有序字典,顺序从左到右,传入的第一个参数(int类除外)将作为新有序字典的key,当第一个参数为字典时,将只取其key作为新有序字典的key,第二个参数为新有序字典的value,默认为None。

    注:创建新有序字典时,元素的位置为传入时的,从左到右。

  5. get(获取有序字典的值)

    格式:collections.OrderedDict(dict).get(k[,value])
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).get('c','xx'))
    >>> 'xx'
    返回值:obj
    #当指定获取有序字典的key时,如果key存在,将直接返回有序字典的value,忽略第二个参数,当key不存在时,将直接返回传入的第二个参数,默认为None。
  6. items(获取有序字典的键值对)

    格式:collections.OrderedDict(dict).items()
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).items())
    >>> odict_items([('b', 'bc'), ('a', 'ab')])
    返回值:odict_items
    #由于有序字典里面其实也是一个列表,因此该方法获取到的内容和元素和有序字典的元素是一样的。
  7. keys(获取有序字典所有的键)

    格式:collections.OrderedDict(dict).keys()
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).keys()
    >>> odict_keys(['b', 'a'])
    返回值:odict_keys
    #把有序字典所有的key作为列表的元素返回。
  8. movetoend(指定键的键值对移动到末尾)

    格式:collections.OrderedDict(dict).move_to_end(key)
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).move_to_end('a'))
    >>> None
    返回值:None
    #该方法直接操作原有序字典,指定key的键值对将移动到有序字典的最右边,如果该键值对已在有序字典的最右边,程序也不会报错。
  9. pop(删除指定键的键值对)

    格式:collections.OrderedDict(dict).pop(key[,value])
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).pop('a'))
    >>> 'ab'
    返回值:obj
    #删除指定key的键值对,并返回该键值对的value,当key存在时,将返回key对应的value,当key不存在时,如果指定第二个参数将返回第二个参数,否则将报错。
  10. popitem(删除最右边的键值对)

    格式:collections.OrderedDict(dict).popitem()
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).popitem())
    >>> ('a', 'ab')
    返回值:tuple
    #删除有序字典最右边的键值对,并返回该键值对,由于有序字典的键值对是一元祖的形式存在,因此返回的类型为元祖类型。
  11. setdefault(设置默认有序字典)

    格式:collections.OrderedDict(dict).setdefault(key[,value])
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).setdefault('a'))
    >>> 'ab'
    返回值:obj
    #设置有序字典的默认value,当key存在时,将不进行修改,当key不存在时,第二个参数将作为新key的默认value,当不指定第二个参数时,默认value为None。
  12. update(更新有序字典)

    格式:collections.OrderedDict(dict).update(dict)
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).update({'c':'cd'}))
    >>> None
    返回值:None
    #更新原有序字典,传入参数的字典的键值对作为有序字典的元祖。
  13. values(获取有序字典所有的值)

    格式:collections.OrderedDict(dict).values()
    例如:print(collections.OrderedDict({'a':'ab','b':'bc'}).values())
    >>> odict_values(['bc', 'ab'])
    返回值:odict_values
    #把有序字典所有的values作为列表的元素返回。

3. defaultdict(默认字典)

    格式:collections.defaultdict(type)
例如:dic_l = collections.defaultdict(list)#创建一个空的默认字典,默认值的类型为list。
dic['k1'].append(1)
print(dic)
>>> defaultdict(<class 'list'>, {'k1':[1]})
返回值:defaultdict(<class 'list'>, {})
#可以设置默认字典默认值的类型为list、tuple、dict和set,添加键值对时,就可以调用相应类的方法。由于其方法与字典和有序字典一样,因此这里不做详细介绍。

4. namedtuple(可命名元祖)

由于该系列没有定义该类,需要手动创建类。

  1. 创建类

    格式:name = collections.namedtuple('name',type)
    tu = name(obj)
    例如:name_tuple = collections.namedtuple('name_tuple',['x','y','z'])
    tu = name_tuple(1,3,4)
    print(tu)
    >>> name_tuple(x=1,y=3,z=4)
    #定义该类时,指定类的名字和元祖元素的名字的类型,常用list和tuple,因为dict和set是无序的,因此在传入参数时不能按照定义类时,元祖元素的名字一致。

    注:定义类时,指定元祖元素名字的类型时,其个数与创建元祖时需要一致,当定义的类型为dict时,只取dict的key。

  2. 调用方法

    例如:print(tu.x)
    >>> 1
    print(tu[2])
    >>> 4
    #一般元祖获取元素时,只能通过切片的方法,但如果不知道该元素的下标时,将无法获取,该方法就是通过命名直接获取,无需知道元素的下标,当然也是可以切片方法获取。由于元祖不可能修改,因此方法只有index和count两种,由于这两种方法的参数是value,因此这里也不做详细介绍。

5. deque(双向队列)

  1. 创建双向队列

    格式:collections.deque(obj[,maxlen])
    例如:print(collections.deque())#创建空队列
    >>> deque([])
    返回值:collections.deque
    print(collections.deque('abc'))#元素为字符串的队列,未指定最大长度
    >>> deque(['a', 'b', 'c'])
    print(collections.deque('abc',2))#指定最大长度
    >>> deque(['b', 'c'], maxlen=2)
    #当指定最大长度时,如果队列长度大于限定的最大长度时,将删除最先传入的元素。
    print(collections.deque([1,2,3,4],5))#元素为列表的队列
    >>> deque([1, 2, 3, 4], maxlen=5)
    #当限定的最大长度大于队列的实际长度时,将不会增加默认元素。
  2. append(右边添加元素)

    格式:collections.deque(obj[,maxlen]).append(obj)
    例如:que = collections.deque([1,2,3,4],5)
    print(que.append((1,2,3,)))
    >>> None
    返回值:None
    print(que)
    >>> deque([1, 2, 3, 4, (1, 2, 3)], maxlen=5)
    #直接在原队列的最右边添加,传入的参数可以是int类型,而且传入的参数作为一个整体传入到队列中,如果超出限定的最大长度时,将删除最左边的元素。
  3. appendleft(左边添加元素)

    格式:collections.deque(obj[,maxlen]).appendleft(obj)
    例如:que = collections.deque([1,2,3,4],5)
    print(que.appendleft((1,2,3,)))
    >>> None
    返回值:None
    print(que)
    >>> deque([(1, 2, 3), 1, 2, 3, 4], maxlen=5)
    #直接在原队列的最左边添加,传入的参数可以是int类型,而且传入的参数作为一个整体传入到队列中,如果超出限定的最大长度时,将删除最右边的元素。
  4. clear(清空队列)

    格式:collections.deque(obj[,maxlen]).clear()
    例如:que = collections.deque([1,2,3,4],5)
    print(que.clear())
    >>> None
    返回值:None
    print(que)
    >>> deque([], maxlen=5)
    #清空原队列。
  5. copy(复制队列)

    格式:collections.deque(obj[,maxlen]).copy()
    例如:que = collections.deque([1,2,3,4],5)
    print(que.copy())
    >>> deque([1, 2, 3, 4], maxlen=5)
    返回值:collections.deque
    #复制原队列,生成一个新队列。
  6. count(计数)

    格式:collections.deque(obj[,maxlen]).count(value)
    例如:que = collections.deque([1,2,3,4],5)
    print(que.count(2))
    >>> 1
    返回值:int
    #统计队列中元素的个数。
  7. extend(扩展队列)

    格式:collections.deque(obj[,maxlen]).extend(obj)
    例如:que = collections.deque([1,2,3,4],5)
    print(que.extend('abc'))
    >>> None
    返回值:None
    print(que)
    >>> deque([3, 4, 'a', 'b', 'c'], maxlen=5)
    #扩展也是在队列的最右边进行扩展,如果队列长度超出最大限度长度,将删除队列最左边的元素。
  8. index(查找元素下标)

    格式:collections.deque(obj[,maxlen]).index(value[start,[stop]])
    例如:que = collections.deque([1,2,3,4],5)
    print(que.index(4))
    >>> 3
    返回值:int
    #返回元素的下标,可以指定开始和结束范围,当元素不存在时,程序报错。
  9. insert(插入)

    格式:collections.deque(obj[,maxlen]).insert(index,obj)
    例如:que = collections.deque([1,2,3,4],5)
    print(que.insert(3,'abc'))
    >>> None
    返回值:None
    print(que)
    >>> deque([1, 2, 3, 'abc', 4], maxlen=5)
    #指定位置插入元素,直接修改原队列。
  10. pop(删除最右边的元素)

    格式:collections.deque(obj[,maxlen]).pop()
    例如:que = collections.deque([1,2,3,4],5)
    print(que.pop())
    >>> 4
    返回值:obj
    #删除原队列最右边的元素,同时返回删除的对象。
  11. popleft(删除最左边的元素)

    格式:collections.deque(obj[,maxlen]).popleft()
    例如:que = collections.deque([1,2,3,4],5)
    print(que.popleft())
    >>> 1
    返回值:obj
    #删除原队列最左边的元素,同时返回删除的对象。
  12. remove(删除指定元素)

    格式:collections.deque(obj[,maxlen]).remove(value)
    例如:que = collections.deque([1,2,3,4],5)
    print(que.remove(4))
    >>> None
    返回值:None
    #直接删除原队列中指定的元素。
  13. reverse(反转)

    格式:collections.deque(obj[,maxlen]).reverse()
    例如:que = collections.deque([1,2,3,4],5)
    print(que.reverse())
    >>> None
    返回值:None
    print(que)
    >>> deque([4, 3, 2, 1], maxlen=5)
    #直接对原队列进行反转排序。
  14. rotate(元素位置移动)

    格式:collections.deque(obj[,maxlen]).rotate(number)
    例如:que = collections.deque([1,2,3,4],5)
    print(que.rotate(2))
    >>> None
    返回值:None
    print(que)
    >>> deque([3, 4, 1, 2], maxlen=5)
    #把元素从左边移动到右边,默认一次只移动一步,属于整体移动,所以最右边的将移动到最左边。
  15. maxlen(最大长度)

    格式:collections.deque(obj[,maxlen]).maxlen
    例如:que = collections.deque([1,2,3,4],5)
    print(que.maxlen)
    >>> 5
    返回值:int
    #当不限定最大长度时,该返回值为None。

    注:该方法为队列的变量,并不是函数,因此不能被调用。

2. 待续。。。

上一篇:fusionchart实现ZoomLine 源码 破解版 能够导出


下一篇:34.js----JS 开发者必须知道的十个 ES6 新特性