zoukankan      html  css  js  c++  java
  • python-30 collections相关 模块

    在内置数据类型(dict、list、set、tuple)的基础上,collections模块还提供了几个额外的数据类型:Counter、deque、defaultdict、namedtuple和OrderedDict等。

    1.namedtuple: 生成可以使用名字来访问元素内容的tuple

    2.deque: 双端队列,可以快速的从另外一侧追加和推出对象

    3.Counter: 计数器,主要用来计数

    4.OrderedDict: 有序字典

    5.defaultdict: 带有默认值的字典

     

    namedtuple

    带有名称的元组,namedtuple(名称,[属性集])

    import collections
    #1.collections.namedtuple('名称', 属性集),属性集,可以是列表,元组,集合等,
    # 但是,集合是无序的,p.x,p.y,p.z值每次都是变化的,故不用
    # point=collections.namedtuple('point',{'x','y','z'})
    point=collections.namedtuple('point',['x','y','z'])
    p=point(1,2,3)
    print(p.x,p.y,p.z)
    View Code

    queue:队列

    queue模块有三种队列及构造函数:

    1. Python queue模块的FIFO队列先进先出。 class queue.Queue(maxsize)
    2. LIFO类似于堆,即先进后出。 class queue.LifoQueue(maxsize)
    3. 还有一种是优先级队列级别越低越先出来。 class queue.PriorityQueue(maxsize)

    queue模块中的常用方法:

    • queue.qsize() 返回队列的大小
    • queue.empty() 如果队列为空,返回True,反之False
    • queue.full() 如果队列满了,返回True,反之False
    • queue.full 与 maxsize 大小对应
    • queue.get([block[, timeout]])获取队列,timeout等待时间  ,
      1. 如果无数据可取,默认会阻塞(block=True),阻塞时可以定义超时时间(timeout=2)
      2. 可以使用block=False设置不阻塞立即报错
    • queue.get_nowait() 相当queue.get(False)
    • queue.put(item) 写入队列,timeout等待时间
    • queue.put_nowait(item) 相当queue.put(item, False)
    • queue.task_done() 在完成一项工作之后,queue.task_done()函数向任务已经完成的队列发送一个信号
    • queue.join() 实际上意味着等到队列为空,再执行别的操作
    • import queue
      #2.queue队列FIFO
      q=queue.Queue(3) #定义队列大小,即maxsize=3  def __init__(self, maxsize=0):
      print("q.maxsize=%d"%(q.maxsize))
      q.put(5,) #放入数据    def put(self, item, block=True, timeout=None):
      q.put(4,False)#可以设置不阻赛,如果队列满了,直接产生raise Full错误
      q.put(3)
      print("队列中现有元素个数:",q.qsize())#q.qsize(),返回队列中现有元素个数,3
      print(q.get(),q.get())#取出元素,先进来的2个数被取出,5和4
      print("队列中现有元素个数:",q.qsize())#q.qsize(),返回队列中现有元素个数,1
      q.put(['a','b','c',7])#列表算1个元素
      q.put((4,5))
      print('队列中现有元素个数:%s--队列已满吗?'%(q.qsize()))#阻塞后,执行不到这条语句
      q.put(2,True,1)    #如果队列满了,默认会阻塞(block=True),可以定义阻塞时间(timeout=1),超时后会raise Full错误
                          #如果block=True,timeout不设置,则会一直处于阻塞中,之后的语句不会执行
      print('队列中现有元素个数:%s--队列已满吗?'%(q.qsize()))#阻塞后,执行不到这条语句
      View Code

    • import queue
      #2.queue队列FIFO
      q=queue.Queue(3) #定义队列大小,即maxsize=3  def __init__(self, maxsize=0):
      print("q.maxsize=%d"%(q.maxsize))
      q.put(5,) #放入数据    def put(self, item, block=True, timeout=None):
      q.put(4,False)#可以设置不阻赛,如果队列满了,直接产生raise Full错误
      q.put(3)
      print("队列中元素个数:",q.qsize())#q.qsize(),返回队列中现有元素个数
      q.put(2,True,1)    #如果队列满了,默认会阻塞(block=True),可以定义阻塞时间(timeout=1),超时后会raise Full错误
                          #如果block=True,timeout不设置,则会一直处于阻塞中,之后的语句不会执行
      print('队列已满吗?')#阻塞后,执行不到
    • deque:双端对队

      使用list存储数据时,按索引访问元素很快,但是插入和删除元素就很慢了,因为list是线性存储,数据量大的时候,插入和删除效率很低。

      deque是为了高效实现插入和删除操作的双向列表,适合用于队列和栈

    • dq=collections.deque(['a','b','c'],2) #创建一个双端对队对象,def __init__(self, iterable=(), maxlen=None)
      print(dq) #返回deque(['b', 'c'], maxlen=2),进队1-->2-->3顺序,数据长度为2,因为对列先进先出特点,故将'a'溢出
      dq.clear()#清空队列内容,但对列长度不被清空,仍为2
      print('dq.maxlen=',dq.maxlen)#dq.maxlen= 2,用于定义的时候使用,不能被写入,形如a.maxlen=10会报错
      
      dp=collections.deque([1,2,3])
      dp.append('a')#同list的append,在队尾加入一个元素
      dp.appendleft('b')#在队首加入一个元素
      dp.insert(2,['a','c'])#在索引2前面插入一个元数,即该数索引为2
      print(dp)#deque(['b', 1, ['a', 'c'], 2, 3, 'a'])
      print(dp.count('a'))#计数,返回:1,指定的是一级索下的元素,故列表中'a'不被统计,
      print(dp[2][0])#返回二级索引中元素'a',即列表中'a'
      
      dp.extend('2bc2f')#参数是一个可迭代变量,在对队尾端按照迭代顺序添加
      print(dp)#deque(['b', 1, ['a', 'c'], 2, 3, 'a', '2', 'b', 'c', '2', 'f']),
      
      print(dp.pop())#弹出对列尾部一个元素:f
      print(dp.popleft())#弹出对列头部一个元素:b
      print(dp)
      
      res1=dp.remove('2')#同list:用于移除列表中某个值的第一个匹配项.
      print('res1=%s-->dp=%s'%(res1,dp))#res1=None-->dp=deque([1, ['a', 'c'], 2, 3, 'a', 'b', 'c', '2'])
      # res1=dp.remove('9')#如果该值不在,则报错
      
      dp.rotate(2)#循环移动,为正全体右移,为负全体左移
      print(dp)#deque(['c', '2', 1, ['a', 'c'], 2, 3, 'a', 'b'])
      View Code
    • OrderedDict:有序字典

      使用dict时,Key是无序的。在对dict做迭代时,我们无法确定Key的顺序。

      如果要保持Key的顺序,可以用OrderedDict

    • dd={'z':1,'y':5,'x':False,'d':2,'a':3}
      od=collections.OrderedDict(b=1,a=2,c=3)#产生有序字典,但不那建议这样做
      od['z']='4' #这种做法比较好
      od['y']='5'
      od['x']=True
      print(sorted(dd.items(),key=lambda item:item[0]))#按key排序
      print(od)#OrderedDict([('b', 1), ('a', 2), ('c', 3), ('z', '4'), ('y', '5'), ('x', True)])
      View Code

      defaultdict:默认字典      def __init__(self, default_factory=None, **kwargs):

    • 其实defaultdict 就是一个字典,只不过python自动的为它的键赋了一个初始值。这也就是说,你不显示的为字典的键赋初值python不会报错,看下实际例子。
    • default_factory:参数是一个工厂函数,且是可callable
    • 工厂函数:统一了类型和类,即他们看上去有点象函数, 实质上他们是类。当你调用它们时, 实际上是生成了该类型的一个实例, 就象工厂生产货物一样。
    • 所有的内建函数都是工厂函数,如 : int(), long(), float(), complex(),bool() ,str(), list(), tuple(),dict(),set(),frozenset()

       object(),type(),classmethod(),staticmethod(),super(),property(),file()

    • python会抛出一个KeyError 异常,因为字典索引之前必须初始化,可以用defaultdict来解决
    • 
      
      dd=collections.defaultdict(tuple)#产生个默认值:int(),即0,若是list,则[],tuple是()
      print(dd['k'],int(),dd)#则不会报错, 返回:() 0 defaultdict(<class 'tuple'>, {'k': ()})

      d2=collections.defaultdict(lambda :5)#参数必需是callable,故可以用函数,直接返回一个值
      print(d2['k']) #返回5
       
  • 相关阅读:
    JavaScript实现类的private、protected、public、static以及继承
    OSS网页上传和断点续传(STSToken篇)
    OSS网页上传和断点续传(OSS配置篇)
    Linq sum()时遇到NULL
    SQLSERVER事务日志已满 the transaction log for database 'xx' is full
    笔记本高分辨软件兼容问题,字体太小或模糊
    H5上传图片之canvas
    An error occurred while updating the entries. See the inner exception for details.
    无限级结构SQL查询所有的下级和所有的上级
    SQLserver 进程被死锁问题解决
  • 原文地址:https://www.cnblogs.com/Zhouzg-2018/p/10270522.html
Copyright © 2011-2022 走看看