re模块补充、正则起别名及分组机制、 collections模块 、time与datetime模块 、 random随机数模块

re模块补充说明

findall补充：

默认是分组优先展示，正则表达式中如果有括号分组，那么在展示匹配结果的时候，默认只演示括号内正则表达式匹配到的内容

取消分组有限展示的机制

（？：）括号内正则的前面加问号冒号

import re
a = 'abcabcabcabc'
ret = re.findall('(a)(b)c',a)
print(ret)  # [('a', 'b'), ('a', 'b'), ('a', 'b'), ('a', 'b')]
ret = re.findall('a(?:b)c',a)
print(ret)  # ['abc', 'abc', 'abc', 'abc']
ret = re.findall('(a)(b)(c)',a)
print(ret)  # [('a', 'b', 'c'), ('a', 'b', 'c'), ('a', 'b', 'c'), ('a', 'b', 'c')]

search补充：

ret1 = re.search('(a)(b)(c)', 'abcabcabcabc')
print(ret1.group())  # abc
# 可以通过索引的方式单独获取到分组内匹配到的数据
print(ret1.group(0))  # abc
print(ret1.group(1))  # a
print(ret1.group(2))  # b
print(ret1.group(3))  # c
# print(ret1.group(4)) #  IndexError: no such group
'''针对search和match有几个分组，group方法括号内最大就可以写几个'''


# 分组之后起别名	(?P<名字>)
ret1 = re.search('(a)(?P<name>b)(?P<name1>c)', 'abcabcabcabc')
print(ret1.group('name'))  # b
print(ret1.group('name1'))  # c

collections模块

提供了更多的数据类型

具名数组(namedtuple)

namedtuple(): 生成可以使用名字来访问元素内容的tuple子类
from collections import namedtuple
from collections import namedtuple

# 先产生一个元组对象模板
point = namedtuple('坐标', ['x', 'y'])
# 创建诸多元组数据
p1 = point(1, 2)
p2 = point(10, 8)
print(p1, p2)  # 坐标(x=1, y=2) 坐标(x=10, y=8)
print(p1.x)  # 1
print(p1.y)  # 2
# ----------------------------------------------
person = namedtuple('人物', 'name age gender')
p1 = person('tuzi', 18, 'male')
p2 = person('kevin', 3, 'male')
print(p1)  # 人物(name='tuzi', age=18, gender='male')
print(p2)  # 人物(name='kevin', age=3, gender='male')
print(p1.name, p1.age)  # tuzi 18
"""具名元组的使用场景也非常的广泛 比如数学领域、娱乐领域等"""

card = namedtuple('扑克牌', '花色 点数')
c1 = card('黑桃♠', 'A')
c2 = card('黑梅♣', 'K')
c3 = card('红心❤', 'A')
print(c1, c2, c3)
print(c1.点数)  # A

队列与双端队列

队列(queue)

先进先出,默认是只有一端只能进另外一段只能出,不属于collections里的模块,是单独的queue模块

import queue

q = queue.Queue(3)  # 设置最大能放多少个元素,这里为3
q.put(111)  # 存放元素
q.put(222)  # 存放元素
q.put(333)  # 存放元素
# q.put(444)  # 如果队列满了 继续添加则原地等待
# 获取元素
print(q.get())  # 111
print(q.get())  # 222
print(q.get())  # 333
# print(q.get())  # 如果队列空了 继续获取则原地等待

双端队列(deque)

两端都可以进出

from collections import deque

q = deque([1, 2, 3])
print(q)  # deque([1, 2, 3])
q.append(444)  # 右边添加元素
print(q)  # deque([1, 2, 3, 444])
q.appendleft(555)  # 左边添加元素
print(q)  # deque([555, 1, 2, 3, 444])
q.popleft()  # 左边弹出元素
print(q)  # deque([1, 2, 3, 444])
q.pop()  # 右边弹出元素
print(q)  # deque([1, 2, 3])

有序字典(OrderedDict)

# 正常的字典是无序的
d1 = dict([('name', 'tuzi'), ('pwd', 123), ['age', 18]])
print(d1)  # {'pwd': 123,'name': 'tuzi', 'age': 18}

# 有序字典
from collections import OrderedDict
d2 = OrderedDict([('a',1),('b',2),('c',3)])
print(d2)  # OrderedDict([('a', 1), ('b', 2), ('c', 3)])
d2['x'] = 111
d2['y'] = 222
d2['z'] = 333
print(d2)  # OrderedDict([('a', 1), ('b', 2), ('c', 3), ('x', 111), ('y', 222), ('z', 333)])

print(d2.keys())  # odict_keys(['a', 'b', 'c', 'x', 'y', 'z'])

默认字典(defaultdict)

"""
有如下值集合 [11,22,33,44,55,67,77,88,99,999]，
将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
"""
from collections import defaultdict
l1 = [11,22,33,44,55,67,77,88,99,999]
d2 = defaultdict(list)  # 字典所有的值默认是列表{'':[].'':[]}
for i in l1:
    if i > 66:
        d2['k1'].append(i)
    else:
        d2['k2'].append(i)

计数器(Counter)

res = 'abcdeabcdabcaba'
'''
统计字符串中所有字符出现的次数
    {'a':3,'b':5...}
'''
new_dict = {}
for i in res:
    if i not in new_dict:
        new_dict[i] = 1
    else:
        new_dict[i] += 1
print(new_dict)  # {'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1}


'''Counter模块'''
from collections import Counter
res = Counter(res)
print(res)  # Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
print(res.get('a'))  # 5    可以当成字典使用
# 写出两个例子是为了方便对比,有对比才有更好的选择

time模块

time模块中常用方法

使用该模块中的函数时，必须先引入该模块（import time）
'''
time.time()：返回当前时间的时间戳time.time()
print(time.time())  # 1648540338.4823465
'''
time.sleep(secs)  # 推迟指定的时间运行,单位为秒
#  ps:该方法贯穿前后(基础、后期)

三种用于表示时间的格式(彼此之间可以转换)

时间戳(time.time())

时间戳就是距离1970年1月1日0时0分0秒到此时此刻相差的秒数
print(time.time())  # 1648540338.4823465

结构化时间(time.localtime())

# 该时间类型主要是给计算机看
print(time.localtime())  # time.struct_time(tm_year=2022, tm_mon=3, tm_mday=29, tm_hour=16, tm_min=14, tm_sec=30, tm_wday=1, tm_yday=88, tm_isdst=0)

时间类型	eg
tm_year(年)	比如2022
tm_mon(月)	1-12
tm_mday(日)	1-31
tm_hour(时)	0-23
tm_min(分)	0-59
tm_sec(秒)	0-60
tm_wday	0-6(0表示周一)
tm_yday(一年中的第几天)	1-366
tm_isdst(是否是夏令时)	默认为0

格式化时间(time.strftime())

# 人最容易接受的一种时间格式	2022/3/29 11:11:11
import time
print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 区分大小写  2022-03-29 15:48:14
print(time.strftime('%Y-%m-%d %X'))  # 区分大小写  2022-03-29 15:48:14

时间类型有:

时间类型	说明
%y	两位数的年份表示(00-99)
%Y	四位数的年份表示(000-9999)
%m	月份(01-12)
%d	月内中的一天(0-31)
%H	24小时制小时数(0-23)
%I	12小时制小时数
%M	分钟数(00-59)
%S	秒(00-59)
%a	本地简化星期名称
%A	本地完整星期名称
%b	本地简化的月份名称
%B	本地完整的月份名称
%c	本地相应的日期表示和时间表示
%j	年内的一天(001-366)
%p	本地A.M.或P.M.的等价符
%U	一年中的星期数(00-53)星期天为星期的开始
%w	星期(0-6),星期天为星期的开始
%W	一年中的星期数(00-53)星期一为星期的开始
%x	本地相应的日期表示
%X	本地相应的时间表示
%Z	当前时区的名称
%%	%号本身

时间类型的转换

	格式化时间	<==> 结构化时间 <==>	 时间戳

时间戳<-->结构化时间

'''
如果secs参数未提供，则以当前时间为准（即会默认调用time.time()）。
'''
'''时间戳<---->结构化时间'''
# localtime
# 未给定参数
会以当前的时间返回
print(time.localtime())  # time.struct_time(tm_year=2022, tm_mon=3, tm_mday=29, tm_hour=16, tm_min=35, tm_sec=15, tm_wday=1, tm_yday=88, tm_isdst=0)

# 给定参数
# 以给定的时间戳来返回时间
print(time.localtime(1648540338.4823465))  # time.struct_time(tm_year=2022, tm_mon=3, tm_mday=29, tm_hour=15, tm_min=52, tm_sec=18, tm_wday=1, tm_yday=88, tm_isdst=0)

# gmtime 
将一个时间戳转换为UTC时区的struct_time 
time.gmtime() 函数将一个时间戳转换为UTC时区（0时区）的struct_time
可选的参数是时间戳。其默认值为time.time()
函数返回time.struct_time类型的对象。
如果secs参数未提供，则以当前时间为准。 
print(time.gmtime(1648540338.4823465))
# time.struct_time(tm_year=2022, tm_mon=3, tm_mday=29, tm_hour=7, tm_min=52, tm_sec=18, tm_wday=1, tm_yday=88, tm_isdst=0)
ps:UTC时间比我所在的区域时间早八个小时(时区划分)

结构化时间<-->格式化时间

# strptime  将格式字符串转化成struct_time. 
print(time.strptime('2022-03-29', '%Y-%m-%d'))
# time.struct_time(tm_year=2022, tm_mon=3, tm_mday=29, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=88, tm_isdst=-1)

# strftime	返回字符串表示的当地时间. 
print(time.strftime('%Y-%m-%d %H:%M:%S'))
# 2022-03-29 17:00:51

datetime模块

# 基本操作
import datetime

print(datetime.date.today())  # 2022-03-29
print(datetime.datetime.today())  # 2022-03-29 17:03:15.263879
'''
data      意思就是年月日
datetime  意思就是年月日 时分秒
ps:后期很多时间相关的操作都是跟date和time有关系
'''
res = datetime.date.today()
print(res.year)  # 2022
print(res.month)  # 3
print(res.day)  # 29
print(res.weekday())  # 1  星期0-6
print(res.isoweekday())  # 2  星期1-7

# 时间差
ctime = datetime.datetime.today()
time_tle = datetime.timedelta(days = 4)
print(ctime)  # 2022-03-29 17:12:35.806605
print(ctime + time_tle)  # 2022-04-02 17:12:35.806605
print(ctime - time_tle)  # 2022-03-25 17:12:35.806605
#---------------------------------
res = ctime + time_tle
print(res - ctime)  # 4 days, 0:00:00
'''
datetime.timedelta()里的时间选项
days            # 天
seconds         # 秒
microseconds    # 微妙
milliseconds    # 毫秒
minutes         # 分钟
hours           # 小时
weeks           # 星期
'''
"""
针对时间计算的公式
    日期对象 = 日期对象 +/- timedelta对象
    timedelta对象 = 日期对象 +/- 日期对象
"""

random模块(别名:随机数模块)

import random
# uniform  随机生成区间里的小数
# randint  随机生成区间里的整数
# shuffle  随机打乱一个数据集合(例如扑克牌游戏)
# choice   随机抽取一个(抽奖)
# sample   随机指定个数抽样
print(random.random())  # 随机产生一个0到1之间的小数

print(random.uniform(2,4))  # 随机产生一个2到4之间的小数
# randint  随机生成区间里的整数

print(random.randint(0,9))  # 随机产生一个0到9之间的整数(包含0和9)

# shuffle  随机打乱一个数据集合(例如扑克牌游戏)
poker = [2,3,4,5,6,7,8,9,10,'J','Q','K','A','king','kinglet']
random.shuffle(poker)
print(poker)  # ['kinglet', 7, 10, 5, 'A', 'king', 'J', 2, 6, 'Q', 8, 'K', 4, 9, 3]

# choice   随机抽取一个(抽奖)
prize_box = ['特等奖','一等奖','二等奖','三等奖','只差一点点,接着充钱啊~~']
print(random.choice(prize_box))  # 随机抽取一个

# 什么?五连抽???
count = 0
res = []
while count<5:
    prize_box = ['特等奖', '一等奖', '二等奖', '三等奖', '只差一点点,接着充钱啊~~']
    ret = random.choice(prize_box,1)
    res.append(ret)
    count+=1
print(res)
# [['三等奖'], ['只差一点点,接着充钱啊~~'], ['一等奖'], ['只差一点点,接着充钱啊~~'], ['一等奖']]

# sample   随机指定个数抽样
l1 = [1,2,3,4,5,6,7,8,9,10]
print(random.sample(l1,3))  # 随机指定个数抽样
# [6, 4, 10]