re模块补充

findall方法优先显示

      import re
      res = re.findall('abc', 'adcabcabcacc')
      res1 = re.findall('(a)bc', 'adcabcabcacc')
      res2 = re.findall('(a)(b)c', 'adcabcabcacc')
      res3 = re.findall('(a)(b)(c)', 'adcabcabcacc')
      print(res)  # ['abc', 'abc']
      print(res1)  # ['a', 'a']
      print(res2)  # [('a', 'b'), ('a', 'b')]
      print(res3)  # [('a', 'b', 'c'), ('a', 'b', 'c')]

 re 模块里的findall方法
  1. findall()里面的正则表达式可以加小括号进行分组，小括号内的内容优先显示
  2. 如果含有多个分组的话，有几个将几个分组组合成元组类型数据元素，列表输出
  3. 不过这里需要注意，先找到的仍然是正则表达式里面所要筛选的组合，会在找到的组合进行拆分优先显示而已
   解释：也就是上述代码依然会先找'abc'字符组，只不过会将找到的数据进行拆分优先显示

取消优先显示

      import re
      res = re.findall('(?:a)bc', 'adcabcabcacc')
      print(res)  # ['abc', 'abc']

 findall方法里的分组默认优先显示，不过我们可以在分组内的左边加上?:来解除分组的优先显示

索引获取search、match匹配到的分组内的数据

      import re
# search 方法
      res = re.search('(a)b(c)', 'adcabcabcacc')  # search只匹配一个结果
      print(res.group())  # 通过group方法进行取分组数据，默认的参数是0，不取分组，取全部结果 abc
      print(res.group(0))  # 与无参相同 abc
      print(res.group(1))  # 取正则匹配结果的第1个分组 a
      print(res.group(2))  # 取正则匹配结果的第2个分组 c
      print(res.group(3))  # 第三分组不存在，取不到会直接报错 
# match 方法
      res = re.match('(a)b(c)', 'abcabcabcacc')  # search只匹配一个位于开头位置的结果 
      print(res.group())  # 通过group方法进行取分组数据，默认的参数是0，不取分组，取全部结果 abc
      print(res.group(0))  # 与无参相同 abc
      print(res.group(1))  # 取正则匹配结果的第1个分组 a
      print(res.group(2))  # 取正则匹配结果的第2个分组 c
      print(res.group(3))  # 第三分组不存在，取不到会直接报错

 对于search和match方法所匹配到的结果
  1. 在正则表达式里如果存在分组的时候，可以通过group方法进行取值
  2. group后面的参数最大值与正则表达式里的分组个数一样
  3. group取分组匹配数据的时候，默认参数是0的时候，取正则匹配数据，而不是分组匹配数据

对匹配的分组数据命名

      import re

      res = re.search('(?P<namea>a)bc', 'adcabcabcacc')
      print(res.group('namea'))  # 用group方法跟命的名，可以取该分组内数据 a 

      res = re.match('(?P<namea>a)(?P<nameb>b)c', 'abcabcabcacc')
      print(res.group('nameb'))  # 用group方法跟命的名，可以取该分组内数据 b

  1. 给分组内数据命名只需要在分组内的前部加上?:<名字>即可
  2. 后续访问该数据就可以用group方法加该名字

collections模块

 作用：提供更多数据类型

具名元组（namedtuple）

      from collections import namedtuple

      coordinate = namedtuple('位置', ['x', 'y', 'z'])  # 生成元组对象模板
      coor1 = coordinate(1, 2, 3)  # 用元组模板创建多个元组数据
      coor2 = coordinate(1, 1, 3)
      coor3 = coordinate(2, 2, 3)
      coor4 = coordinate(3, 3, 3)


      print(coor1, coor2, coor3, coor4)  # 位置(x=1, y=2, z=3) 位置(x=1, y=1, z=3) 位置(x=2, y=2, z=3) 位置(x=3, y=3, z=3)
      print(coor1.x, coor2.y, coor3.x, coor4.z)  # 可以通过点名的方式查看元组内的数据

双端队列(queue)

 1. 之前的学习过程中讲过队列与堆栈。队列属于先进先出的数据类型，也就是类似于排队，一端进一端出
 2. 双端队列也就是指两端都可以进出的队列

      import queue

      que = queue.Queue(2)  # 队列内最多只能放两个元素

      # 添加元素
      que.put('oliver')
      que.put('kevin')
      # que.put('jason')  # 队列排到最大容量时，会停止到这里

      # 获取元素
      print(que.get())  # oliver  一次取一个元素
      print(que.get())  # kevin
      # print(que.get())  # 队列取空以后再取元素会停止到这里不往下执行

      # 内部结构
      que.put('oliver')
      print(que.get())  # oliver
      que.put('kevin')
      print(que.get())  # kevin
      que.put('jason')
      print(que.get())  # jason
      que.put('justin')
      print(que.get())  # justin
      que.put('henry')
      print(que.get())  # henry 
      # 典型的放一个取一个，这样的话，队列不会填满，也就不会停止执行


      # 队列的左右添加删减操作
      # from collections import deque
      #
      # q = deque(['oliver', 'kevin', 'jason', 'henry'])
      # print(q)
      # q.append('帅气逼人')  # 尾部添加元素
      # print(q)  # deque(['oliver', 'kevin', 'jason', 'henry', '帅气逼人'])
      # q.appendleft('英俊潇洒')  # 首部添加元素
      # print(q)  # deque(['英俊潇洒', 'oliver', 'kevin', 'jason', 'henry', '帅气逼人'])
      # q.pop()  # 尾部弹出元素
      # print(q)  # deque(['英俊潇洒', 'oliver', 'kevin', 'jason', 'henry'])
      # q.popleft()  # 首部弹出元素
      # print(q)  # deque(['oliver', 'kevin', 'jason', 'henry'])

有序字典（orderedDict）

      from collections import OrderedDict

      dict_name = OrderedDict([('name', 'oliver'), ('age', 23), ('gender', 'male')])
      print(dict_name)  # OrderedDict([('name', 'oliver'), ('age', 23), ('gender', 'male')])
      print(dict_name['name'])  # oliver
      # 值的修改
      dict_name['name'] = 'jerry'
      dict_name['age'] = 18
      dict_name['gender'] = 'female'
      dict_name['hobby'] = 'music'  # 与字典相同，没有键的时候直接添加
      print(dict_name)  # OrderedDict([('name', 'jerry'), ('age', 18), ('gender', 'female'), ('hobby', 'music')])
      print(dict_name.keys())  # odict_keys(['name', 'age', 'gender', 'hobby'])
      print(dict_name.values())  # odict_values(['jerry', 18, 'female', 'music'])
      print(dict_name.items())  # OrderedDict([('name', 'jerry'), ('age', 18), ('gender', 'female'), ('hobby', 'music')])

 对于常用的字典的内置方法，有序字典都是可以调用的

默认值字典（defaultdict）

      from collections import defaultdict

      list1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 111]
      my_dict = defaultdict(list)  # 默认字典里的值是空列表
      for i in list1:
          if i < 50:
              my_dict['little'].append(i)  # 添加进键为'little'的值（列表）里
          else:
              my_dict['large'].append(i)  # 添加进键为'large'的值（列表）里

      print(my_dict)  # defaultdict(<class 'list'>, {'little': [11, 22, 33, 44], 'large': [55, 66, 77, 88, 99, 111]})

 给字典的值提供了默认值

计数器（Counter）

 统计字符串里字符出现的次数

# for循环实现统计字符串str1所有字符出现的次数
      str1 = 'wdadwsdawdasdwadadsawdawdssdawdasdwwsdawdsdwdasdawsdwdas'
      dict1 = {}
      for i in str1:
          if i not in dict1:
              dict1[i] = 1
          else:
              dict1[i] += 1
      print(dict1)  # {'w': 13, 'd': 19, 'a': 13, 's': 11}
# Counter实现统计字符串str1所有字符出现的次数
      str1 = 'wdadwsdawdasdwadadsawdawdssdawdasdwwsdawdsdwdasdawsdwdas'
      from collections import Counter

      res = Counter(str1)  # 统计字符串里字符出现的个数
      print(res)  # Counter({'d': 19, 'w': 13, 'a': 13, 's': 11})
      print(res.get('s'))  # 获取s对应的出现次数（值）11

time 模块

常用方法

      import time
      time.time()  # 获取时间戳  1648574515.9904044
      time.sleep()  # 休眠时间：执行到该语句的时候，会在此处停留10秒
      time.time()  # 获取休眠时间后的时间戳  1648574525.990836

三种时间的表示方式

 1. 获取时间戳 time.time()
距离1970年1月1日到程序运行时相差的时间差

 2. 结构化时间 time.localtime()
该时间类型主要是给计算机看的，是不适合人看的

 3. 格式化时间 time.strftime()
人最容易接受的一种时间格式

时间类型的转换

      import time

      # 格式化时间 <==> 结构化时间 <==> 时间戳
      print(time.time())
      res = time.localtime()
      print(res)
      print(time.strftime('%Y-%m-%d %H:%M:%S'))

      # 时间戳 <--> 结构化时间
      print(time.gmtime(1648568039.8701835))  # 将时间戳转为结构化时间
      print(time.localtime(1648568039.8701835))  # 将时间戳转为结构化时间
      res = time.localtime()  # 用res接收结构化时间
      print(time.mktime(res))  # 将结构化时间转换成时间戳

      # 结构化时间 <--> 格式化时间
      print(time.strftime('格式化时间的格式', '结构化时间'))  # 将结构化时间转换为格式化时间
      time.strptime('格式化时间', '格式化时间的格式')  # 将格式化时间转换为结构化时间
      print(time.strftime('%Y-%m-%d', res))
      print(time.strptime('2022-03-30-00-04-55', '%Y-%m-%d-%H-%M-%S'))
      # 前后必须一致

datetime 模块

      import datetime

      print(datetime.date.today())  # 获得时间的年月日 2022-03-30
      print(datetime.datetime.today())  # 获得时间的年月日，时分秒2022-03-30 01:48:49.011196

      res = datetime.date.today()
      print(res)  # 2022-03-30
      print(res.year)  # 2022
      print(res.month)  # 3
      print(res.day)  # 30
      print(res.weekday())  # 0-6的周几数 2
      print(res.isoweekday())  # 1—7的周几数 3
      print(res.isocalendar())  # 获得（年份，第几周，周几） (2022, 13, 3)

时间差

      import datetime

      start_time = datetime.datetime.today()
      del_time = datetime.timedelta(days=3, hours=3, minutes=13, seconds=44)  # 时间间隔为3天3小时13分钟44秒
      print(start_time)
      print(del_time)
      print(start_time - del_time)  # 前推3天3小时13分钟44秒  2022-03-26 21:12:17.447559
      print(start_time + del_time)  # 后推3天3小时13分钟44秒  2022-04-02 03:39:45.447559

      res = start_time + del_time
      res1 = res - start_time
      print(res1)  # 3 days, 3:13:44  # 时间间隔为3天3小时13分钟44秒

随机数模块

      import random

      print(random.random())  # 随机产生0-1的小数
      print(random.uniform(1, 9))  # 随机产生指定区域的小数
      print(random.randint(1, 9))  # 随机产生指定区域的整数
      print(random.randint(1, 6))  # 掷骰子
      list_num = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
      random.shuffle(list_num)  # 是在列表内部直接打乱的，需要先打乱，才能输出
      print(list_num)

      print(random.sample(list_num, 3))  # 在指定的数据集里随机抽取指定个元素

 random每次执行所得到的结果都是随机的

模块（二）结束