常用模块part1

• Collections 模块

• collections模块是python库中为使用者们提供了除列表，字典，元祖和集合的额外容器数据类型的模块，借以补足内置数据类型的缺陷。

• 比较常见的数据类型有：

1. 1. 1. namedtuple：生成可以使用名字来访问元素内容的元组
      2. deque：双端队列，一个类似于列表的数据类型，可以从两边快速的添加或者弹出对象
      3. defaultdic：带有默认值的字典
      4. counter：计数器（属于字典一类，用于可哈希的对象的计数
      5. ordereddic：有序字典

• Namedtuple（具名元组）

• # 具名元组
  # 想表示坐标点x为1 y为2的坐标
  from collections import namedtuple
  point = namedtuple('坐标','x,y,z')  # 第二个参数既可以传可迭代对象,第一个参数基本没什么意义，就是给该元组类型起了一个名字
  # point = namedtuple('坐标','x y z')  # 也可以传字符串 但是字符串之间以空格隔开 也可以用列表的形式将名字输入['x','y','z']
  p = point(1,2,5)  # 注意元素的个数必须跟namedtuple第二个参数里面的值数量一致
  print(p)
  print(type(point))
  print(p.x + p.y)     都是输出的是3
  print(p[0] + p[1]) # 其实具名元组就是让本来只能用位置索引取值的元组更加具有可读性，让其能够通过名字(named field)来取值
  
  card = namedtuple('扑克牌','color number')
  # card1 = namedtuple('扑克牌',['color','number'])
  A = card('♠','A')
  print(A)
  print(A.color)
  print(A.number)

• Deque（双端队列）

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

  deque其实是为了高效实现插入和删除操作的双向列表。

• # deque双端队列
  from collections import deque
  q = deque(['a','b','c'])   # 其中括号内的数据类型应该是可迭代数据类型(iteralbe)
  """
  append
  appendleft
  
  pop
  popleft
  """
  q.append(1)
  q.appendleft(2)
  
  """
  队列不应该支持任意位置插值
  只能在首尾插值(不能插队)
  """
  q.insert(1,'nmsl')  # 特殊点:双端队列可以根据索引在任意位置插值
  print(q)
  print(q.pop())　　   输出1
  print(q.popleft())  # 正常来说 列表类型是只能在最后来弹出或者添加数值的 但是双端队列却能在两边随意地添加删除值  输出a
  print(q.popleft())　输出nmsl

• Defaultdic（默认值字典）

• 在以下列表[1,10,20,24,56,78]，将列表中大于24的数字存入字典中的name1，小于等于24的数字存入字典中的name2

• from collections import defaultdict
  
  dic = defaultdict(list)         # 默认value值为列表类型
  value = [1,10,20,24,56,78]
  for i in value:
      if i > 24:
          dic['name1'].append(i)  # 自动生成key的名称
      else:
          dic['name2'].append(i)
  print(dic)                      # default默认的其实是value值的类型,因此在对value值进行改动时，要遵循默认数据类型的内置方法
  
  dic1 = defaultdict(int)
  print(dic1['xxx'])          # 输出 0
  print(dic1['yyy'])
  
  dic2 = defaultdict(bool)
  print(dic2['kkk'])          # 由于没有值 则输出False
  
  dic3 = defaultdict(tuple)
  print(dic3['mmm'])          # 由于没有value值跟mmm的key值对应,所以value值默认的是元组类型，输出一个空元祖

• Counter（计数）

• Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）

• from collections import Counter
  s = 'abcdeabcdabcaba'
  res = Counter(s)
  print(res)
  for i in res:
      print(i)
  # 先循环当前字符串 将每一个字符串都采用字典新建键值对的范式
  d = {}
  for i in s:
      d[i] = 0
  print(d)

• Ordereddic（有序字典）

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

• >>> from collections import OrderedDict
  >>> d = dict([('a', 1), ('b', 2), ('c', 3)])
  >>> d # dict的Key是无序的
  {'a': 1, 'c': 3, 'b': 2}
  >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
  >>> od # OrderedDict的Key是有序的
  OrderedDict([('a', 1), ('b', 2), ('c', 3)])

• Datatime模块

• 时间在python中有三种表现形式：（1）时间戳：此时此刻离Unix系统的诞生1970年距离多少秒、

           （2）格式化的时间字符串：'2019-7-18'、

                                                                 （3）元组(struct_time) ：struct_time元组共有9个元素共九个元素:年，月，日，时，分，秒，一年中第几周，一年中第几天

• 关于这三个形式的相互转化的方法

• 

• 其中的time模块

• import time
  print(time.time())                   # 时间戳
  
  print(time.strftime('%Y-%m-%d'))     # 格式化时间 其中Y代表着Year，m代表着month，d代表着day
  print(time.strftime('%Y-%m-%d %H:%M:%S'))   # H代表着Hour,M代表着minute,S代表着second
  print(time.strftime('%Y-%m-%d %X'))  # %X等价于%H:%M:%S
  print(time.strftime('%H:%M'))       # 中间的一些特殊字符代表着相应的格式
  print(time.strftime('%Y/%m'))
  
  print(time.localtime())            # 时间元祖即结构化时间
  
  print(time.localtime(time.time()))  # 将时间戳转化为结构化时间
  res = time.localtime(time.time())
  print(time.time())
  print(time.mktime(res))             # 将结构化时间转化为时间戳
  print(time.strftime('%Y-%m',time.localtime()))    # 将结构化时间转化为格式化时间
  print(time.strptime(time.strftime('%Y-%m',time.localtime()),'%Y-%m'))   # 将格式化时间转化为结构化时间

• datatime方法

• import datetime
  print(datetime.date.today())  # date>>>:年月日
  print(datetime.datetime.today())  # datetime>>>:年月日 时分秒
  res = datetime.date.today()
  res1 = datetime.datetime.today()
  print(res.year)               # 输出年份
  print(res.month)              # 输出月份
  print(res.day)                # 输出日期
  print(res.weekday())  # 0-6表示星期  0表示周一
  
  print(res.isoweekday())  # 1-7表示星期 7就是周日
  """
  (******)
  日期对象 = 日期对象 +/- timedelta对象
  timedelta对象 = 日期对象 +/- 日期对象
  """
  current_time = datetime.date.today()  # 日期对象
  timetel_t = datetime.timedelta(days=7)  # timedelta对象
  res1 = current_time+timetel_t  # 日期对象
  print(current_time - timetel_t)
  print(res1-current_time)

• Random随机模块

• import random
  
  print(random.randint(1,6))  # 随机取一个你提供的整数范围内的数字  包含首尾
  print(random.random())  # 随机取0-1之间小数
  print(random.choice([1,2,3,4,5,6]))  # 摇号 随机从列表中取一个元素
  res = [1,2,3,4,5,6]
  random.shuffle(res)  # 洗牌
  print(res)

• 随机生成验证码

• def get_code(n):
      code = ''
      for i in range(n):
          # 先生成随机的大写字母 小写字母 数字
          upper_str = chr(random.randint(65,90))
          lower_str = chr(random.randint(97,122))
          random_int = str(random.randint(0,9))
          # 从上面三个中随机选择一个作为随机验证码的某一位
          code += random.choice([upper_str,lower_str,random_int])
      return code
  res = get_code(4)
  print(res)