import re
#findall 返回所有满足匹配条件的结果，放在列表里
#search 从前往后找到一个就返回,返回的变量需要调用group才能拿到结果，但如果没有找到
        #就会返回None，调用group会报错
#match  match是从头开始匹配，如果正则规则从头开始可以匹配上，就返回一个变量
        # 匹配的内容需要调用group才能显示
        #如果没有匹配上，就返回None，调用group会报错
# ret = re.findall('[a-z]+',' wfrm fwrfwfrw')
# print(ret)
#结果   ['wfrm', 'fwrfwfrw']
# ret = re.search('a','eva egon yuan')
# print(ret)
# <_sre.SRE_Match object; span=(2, 3), match='a'>
# res= ret.group()
# print(res)
#结果 a
ret = re.match('e','eva egon yuan')
res = ret.group()
print(res,type(res))
#结果 e

# ret = re.split('[ab]','abcd')
#先按'a'分割得到''和'bcd'在对''和'bcd'分别按'b’分割
# print(ret)
#结果['', '', 'cd']
# ret= re.sub('\d','H','hhhhehj6b3yua7',1)
# print(ret)
# 结果：hhhhehjHb3yua7  把第一个数字替换为H 功能赫尔replace差不多
# ret = re.subn('\d','H','hhhhehj6b3yua7')
# print(ret)
#结果 ('hhhhehjHbHyuaH', 3)
# 将数字替换成H，返回元组（替换的结果，替换了多少次）

# obj = re.compile('\d{3}')
# #将正则表达式编译成为一个正则表达式对象
# ret = obj.search('bhjgh356hjh567g')
#正则表达式对象调用search，参数为待匹配
# print(ret.group())
#结果356
# ret = obj.search('bnjkhew6789njcdkwh')
# print(ret.group())
#结果678

# ret =re.finditer('\d','geh3bhj47845ed')
# print(ret)  #<callable_iterator object at 0x0000022C163B12B0>
# print(next(ret))  #<_sre.SRE_Match object; span=(3, 4), match='3'>
# print(next(ret).group()) #4
# print(next(ret).group()) #7
# print([i.group() for i in ret])  #['8', '4', '5']

# ret = re.findall('www.(baidu|oldboy).com','www.baidu.com')
# print(ret)   #['baidu']
#findall会优先匹配分组里的内容返回
# ret = re.findall('www.(?:baidu|oldboy).com','www.baidu.com')
# print(ret)   #['www.baidu.com']
#?：是取消分组优先的机制

##注意事项
# ret = re.findall('www.(baidu|oldboy).com','www.baidu.com')
# print(ret)   #['baidu']
#findall会优先匹配分组里的内容返回
# ret = re.findall('www.(?:baidu|oldboy).com','www.baidu.com')
# print(ret)   #['www.baidu.com']
#?：是取消分组优先的机制

# ret = re.split('\d+','wedd3ewf4yaun')
# print(ret)  #结果 ['wedd', 'ewf', 'yaun']
# ret = re.split('(\d+)','wedd3ewf4yaun')
# print(ret)  #结果 ['wedd', '3', 'ewf', '4', 'yaun']
#在匹配部分加上()分组后所切出的结果是不同的
#没有（）的没有保留所匹配的项，但是有（）的却能保留匹配的项

# from collections import namedtuple
# # Point = namedtuple('point',['x','y','z'])
# # p1 = Point(1,2,3)
# # p2 = Point(3,2,1)
# # print(p1,p2)   #point(x=1, y=2, z=3) point(x=3, y=2, z=1)
# # print(p1.x)    #1
# # print(p2.y)    #2

#队列：先进先出
#堆栈：先进后出
# import queue
# q = queue.Queue()
# q.put(5)
# q.put(6)
# q.put(7)
# q.put(8)
# print(q.qsize())   #4  查看队列里面数量
# print(q.get())     #5  按照先put进去的数先get到，如果数据没有了就会阻塞，可以q.qsize查看数量来取值
# print(q.get())      #6
# print(q.get())      #7
# print(q.get())      #8

# from collections import deque  deque双端队列
# dq = deque([1,2])
# dq.append('a')         #从后面插入[1,2,'a]
# dq.appendleft('b')     #从前面放数据['b,1,2,'a]
# dq.insert(2,3)          #从索引为2的前面插入3这个数据['b,1,3,2,'a]
# print(dq.pop())        #从后面取数据  a
# print(dq.pop())         #从后面取数据 2
# print(dq.popleft())     #从前面取数据 b

import time
# time.sleep(100)  #停100秒
#时间的三种方式
#1、时间戳--float：给计算机看的
# time.time()      #返回一个以秒为单位的浮点数，表示从1970年1月1日0点开始计算的偏移量
#2、格式化的时间字符串：给人看的
#3、结构化时间--元组：计算用的
#   %y 两位数的年份表示（00-99）
#   %Y 四位数的年份表示（000-9999）
#   %m 月份（01-12）
#   %d 月内的一天（01-31）
#   %H 24小时制小时数（0-23）
#   %M 分钟数（01-59）
#   %I 12小时制小时数（01-12）
#   %S 秒（00-59）
#   %a 本地简化星期名称(英文的周一至周日)
#   %A 本地完成星期名称（英文的周一至周日完整英文）
#   %b 本地简化的月份名称
#   %B 本地完成的月份名称
#   %c 本地相应的日期表示和时间表示
#   %j 年内的一天（001-366）
#   %p 本地A.M.或P.M.的等价符
#   %U 一年中的星期数（00-53）星期天为星期的开始
#   %w 星期（0-6）星期天为星期的开始
#   %x 本地相应的日期表示
#   %X 本地相应的时间表示
#   %Z 当前时区的名称
#   %% %号本身
# print(time.strftime('%Y-%m-%d %H:%M:%S'))  #2020-11-05 18:16:45
# print(time.strftime('%Y/%m/%d %H:%M:%S'))  #2020/11/05 18:18:49
# print(time.strftime('%a'))              #Thu（周四）
# print(time.strftime('%A'))                 #Thursday（周四完成字母）
# print(time.strftime('%b'))              #Nov 11月份
# print(time.strftime('%B'))                  #November 11月份
# print(time.strftime('%c'))              #Thu Nov  5 18:32:21 2020 周四 11月5号 时间 年
# print(time.strftime('%j'))                #310  一年的第310天
# print(time.strftime('%U'))              #44 为一年的第44个星期
# print(time.strftime('%w'))              #4
# print(time.strftime('%x'))              #11/05/20
# print(time.strftime('%X'))                  #18:40:41
# print(time.strftime('%z'))                  #+0800  时区
# print(time.strftime('%%'))                  #%

import time
# t = time.time(）
# print(time.localtime())  #time.struct_time(tm_year=2020, tm_mon=11, tm_mday=6, tm_hour=9, tm_min=29, tm_sec=8, tm_wday=4, tm_yday=311, tm_isdst=0)
# print(time.localtime(t))  #time.struct_time(tm_year=2020, tm_mon=11, tm_mday=6, tm_hour=9, tm_min=29, tm_sec=8, tm_wday=4, tm_yday=311, tm_isdst=0)
# print(time.gmtime(t))   #time.struct_time(tm_year=2020, tm_mon=11, tm_mday=6, tm_hour=1, tm_min=29, tm_sec=8, tm_wday=4, tm_yday=311, tm_isdst=0)
# print(time.localtime(1900000000)) #time.struct_time(tm_year=2020, tm_mon=9, tm_mday=13, tm_hour=20, tm_min=26, tm_sec=40, tm_wday=6, tm_yday=257, tm_isdst=0)
#将格式化时间转化为结构化时间
# print(time.strptime('2020:11:06','%Y:%m:%d')) #time.struct_time(tm_year=2020, tm_mon=11, tm_mday=6, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=311, tm_isdst=-1)
#将结构化时间转化为格式化时间
# print(time.strftime('%Y/%m/%d %H:%M:%S',time.localtime(3000000000))) #2065/01/24 13:20:00

#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
# print(time.asctime()) #Fri Nov  6 10:47:23 2020 返回当前时间
#time.localtime(3000000000) 这个是结构化时间
# print(time.asctime(time.localtime(3000000000)))   #Sat Jan 24 13:20:00 2065
# time.ctime(时间戳) 如果不传参数，直接返回当前的时间的格式化串
# print(time.ctime())    #Fri Nov  6 10:50:19 2020
# print(time.ctime(3000000000))    #Sat Jan 24 13:20:00 2065 
#总结 asctime和ctime要是传参数一个是结构化参数一个是时间戳

import random
#随机小数
# print(random.random())    #0.401293336194141 随机返回一个大于0小于1的小数
# print(random.uniform(1,5))  #3.1172146680910737 随机返回一个大于1小于5的小数
#随机整数
# print(random.randint(2,6))   #6 随机返回一个大于等于2且小于等于6的一个整数
# print(random.randrange(2,11,2)) # 2 随机返回一个大于等于2小于11且步长为2
#随机选择一个返回
# print(random.choice([2,4,[6,'a']]))  #[6,'a'] 随机返回列表中3个元素的其中一个
# print(random.sample([2,4,[6,'a'],'b'],3))  #[4, 'b', 2] 随机返回列表中4个元素的其他三个
#打乱列表顺序
# item =[1,33,5,3,65,77]
# random.shuffle(item)   #打乱次序
# print(item)     #[33, 77, 65, 3, 1, 5]

# import random
# item = ''
# for i in range(6):
#     num1 = random.randint(0,9)
#     if num1 < 5:
#         num =str(random.randint(0,9))
#         item += num
#     else:
#         zm = random.randint(65,91)
#         zm = chr(zm)
#         item += zm
# #chr()将数字变成对应的字母  ord()将字母变成对应的数字
# print(item)

import os
#获取当前工作目录，即当前python脚本工作的目录路径
# print(os.getcwd())   #E:\py\day19
#改变当前脚本的工作目录，相当于shell下面的cd
# os.chdir('E:\py')
# print(os.getcwd())    #E:\py

#可生成多层递归目录
# os.makedirs('dirname1/dirname2')
#若目录为空，则删除，并递归到上一级目录，如果为空，则删除，依此类推
# os.removedirs('dirname1/dirname2')
#生成单级目录，相当于shell中的mkdir
# os.mkdir('dirname')
#删除单级目录，若目录不为空则无法删除，报错
# os.rmdir('dirname')

#列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
# print(os.listdir('E:\py'))
#删除一个文件
# print(os.remove('name'))
#重命名文件/目录
# print(os.rename('name1','name2'))
#获取文件/目录信息
# print(os.stat('E:\py'))
#python代码跨平台：linux windows都可以使用
# print(os.sep)

#输出用于分割文件路径的字符串 win下为; linux下为:
# print(os.pathsep)
#输出字符串指示当前使用平台 win---》'nt' Linux--->'posix'
# print(os.name)
#
# os.system('dir')   运行shell命令，直接显示，无返回值
# ret = os.popen('dir').read()  运行shell命令，获取执行结果，有返回值
# print(ret)
#获取系统环境变量
# print(os.environ)
# print(os.path.abspath('模块.py'))   #结果E:\py\day19\模块.py   返回模块.py的绝对路径
# print(os.getcwd())   #E:\py\day19  当前目录
# # print(os.path.split(os.getcwd()))   #('E:\\py', 'day19')  将path分割成目录和文件名二元组返回
# print(os.path.dirname(os.getcwd()))   #E:\py  返回path的目录
# print(os.path.dirname('E:\py\day19\模块.py'))  #E:\py\day19
# print(os.path.basename('E:\py\day19\模块.py'))  #模块.py
# print(os.path.basename(os.getcwd()))   #day19   返回path最后的文件名
# print(os.path.exists(os.getcwd()))    #True   如果括号内path存在就返回True不存在返回False
# print(os.path.exists('2.py'))       #False
# print(os.path.isabs('模块.py'))      #False   如果path是绝对路径，返回True否则返回False
# print(os.path.isabs('E:\py\day19\模块.py'))   #True
# print(os.path.isabs(os.getcwd()))      #True
# print(os.path.isfile('模块.py'))       #True   如果path是一个存在的文件，返回True，否则返回False
# print(os.path.isdir('E:\py\day19'))    #True   如果path是一个存在的目录，返回True
# print(os.path.getatime('模块.py'))     #返回path所指向的文件或者目录的最后访问时间(返回的时间是时间戳可以转换为字符串时间)
# t= os.path.getatime('模块.py')
# print(time.strftime('%Y:%m:%d %H:%M:%S',time.localtime(t)))
# print(os.path.getmtime('模块.py'))      #返回path所指向的文件或者目录的最后修改时间
# print(os.path.getsize('模块.py'))     #9109   返回path的大小
# print(os.path.join('E:\py\day19','user','books'))   #E:\py\day19\user\books 将多个路径组合起来

#sys模块时与python解释器交互的一个接口
import sys
# print(sys.platform)      #返回操作系统平台
# print(sys.version)          #获取python解释程序的版本信息
# print(sys.exit())            #退出程序，正常退出exit(0)  错误退出exit（1）

# print(sys.path)      #返回模块的搜索路径存放在列表中
# print(sys.path.clear())   清空列表后import模块就会报错，因为路径找不到
# import re
# re.findall('a','refrqa')

#sys.argv 返回的其实是一个列表，列表中的元素就是通过外部传入的参数，第一个参数永远是该python文件自己
# print(sys.argv[0])
# 举例1：列表的第一个参数
# cmd中传入参数
# 执行   python 模块.py
#结果   模块.py

# print(sys.argv[2])
#举例2 列表中其他参数来源  这个1是最少传变量的个数和打印的索引值
#执行  python 模块.py 2 4   打印结果为2   且外部执行时候最少传2个参数

#例子3 参数的切片
# print(sys.argv[2:])
#执行  python 模块.py 2 4 打印结果为['4']