一 time 模块
1 '2017-06-21' #时间字符串 2 import time 3 #时间戳 4 ''' 5 1970_01_01 0:0:0 -------------------最开始时间 6 1970_01_01 0:0:1 ------------------ 以秒开始计算 7 8 1971_01_01 0:0:0 -----------------------24*3600*365 以秒计算时间 9 ''' 10 #当前时间戳 11 # print(time.time()) 12 13 #时间对象 对象.方法 14 #print(time.localtime()) 15 16 # g=time.gmtime() 17 # print(g) 18 19 #取部分时间 20 # s=time.localtime() # 21 # print(s.tm_year) 22 23 #将时间戳转换成结构化时间 24 # s=time.localtime(7552574592) 25 # print(s) 26 27 #将结构化时间转换成时间戳 28 # s=time.mktime(time.localtime()) # 29 # print(s.tm_year) 30 31 # g=time.mktime(time.gmtime()) 32 # print(g) 33 34 #时间字符串 35 # g='2012-02-23' 36 # print(g) 37 38 #将结构时间转换成时间字符串 39 # s=time.strftime('%Y-%m-%d',time.localtime()) 40 # print(s) 41 42 #将字符串时间转换成结构化时间 43 # a=time.strptime('2012-02-23','%Y-%m-%d') 44 # print(a) 45 46 #将时间戳转换成字符串时间，转换的时间字符串格式是定义好的 47 # print(time.ctime(2146897342)) 48 49 #将结构化时间转换成字符串时间,只需要提供结构化时间，不需要给他格式，就是返回一个固定时间，转换的时间字符串格式是定义好的 50 # print(time.asctime()) 51 52 #时间睡一下，相当于停多少时间,模拟了I/O操作。暂停时不会占用CPU 53 # time.sleep(1) 54 55 #时间戳是就是一个浮点型的数字，标识着对应的年份 56 #结构化时间方便我们取决信息 57 #时间字符串为了让我们人能看懂 58 59 60 61 # #小练习 62 # s='2017-6-21' 63 # struct_t=time.strptime(s,'%Y-%m-%d') #先将字符串时间转换成结构化时间 64 # stamp_t=time.mktime(struct_t) #然后再将结构化时间转换成时间戳 65 # new_stamp=stamp_t+3600*24*3 #然后再加上3天的时间戳 66 # new_etr_t=time.strftime('%Y-%m-%d',time.localtime(new_stamp)) #最后再转回去，转成字符串时间。 67 # print(new_etr_t)
二 random 随机模块
1 #随机数模块 2 # import random 3 # 4 # #返回一个floot浮点型数字，范围在0到1之间的浮点型数字 5 # #print(random.random()) 6 # 7 # #取整数，取头也取尾，随机取一个值 8 # print(random.randint(1,6)) 9 # 10 # #取整数，顾头不顾尾，随机取一个值 11 # print(random.randrange(1,6)) 12 # 13 # #随机取列表中的一个元素 14 # print(random.choice([1,4,7,2,0,6])) 15 # 16 # #随机取多个值，自己定义 17 # print(random.sample([1,5,6,76,7,4],3)) 18 # 19 # #取该范围的浮点型数字 20 # print(random.uniform(1,4)) 21 # 22 # #打乱列表中的数字 23 # l=[1,2,3,4,5,6] 24 # random.shuffle(l) 25 # print(l) 26 27 28 #练习，随机五位验证码，包括大小写字母，还有数字。 29 # import random 30 # def fang(): 31 # ret='' 32 # for i in range(5): 33 # a=random.randint(0,9) 34 # b=chr(random.randint(97,122)) 35 # c=chr(random.randint(65,90)) 36 # s=random.choice([str(a),b,c]) 37 # ret=ret+s 38 # return ret 39 # print(fang())
三 hashlib 模块 摘要算法
1 #摘要算法 2 # import hashlib 3 # #返回一个32未16进制的数字，返回的16进制数字是定义好的 4 # md5_obj=hashlib.md5() 5 # md5_obj.update(b'hello') # 5d41402abc4b2a76b9719d911017c592 6 # print(md5_obj.hexdigest()) 7 # 8 # #返回一个32未16进制的数字，返回的16进制数字是定义好的 9 # md5_obj=hashlib.md5() 10 # md5_obj.update(b'helloworld') # fc5e038d38a57032085441e7fe7010b0 11 # print(md5_obj.hexdigest()) 12 # 13 # #返回一个内容分成两个小的内容16进制的数字，返回的16进制数字和只返回那一个的结果一样 14 # md5_obj=hashlib.md5() 15 # md5_obj.update(b'hello') 16 # md5_obj.update(b'world') # fc5e038d38a57032085441e7fe7010b0 17 # print(md5_obj.hexdigest()) 18 19 #总结：在想要返回一个大内容的时候，可以把他分成多个小的内容，然后在一块返回结果。 20 #’’’ 21 #摘要算法应用：文件一致性，登陆 22 #例如： 23 #username pwd 24 #方杰 623745594545 25 #975485445486448 865835645731 26 #6583454589687 5774234566555 27 28 29 #fang 6467635485548887588 30 #jie 5436532437i87685865 31 #’’’ 32 33 #加盐：就是在需要返回的参数还没有在定义之前加入内容。 34 # import hashlib 35 # md5_obj=hashlib.md5(b'hello') 36 # md5_obj.update(b'fang') #d621f78d93f9bd588acae089c88ff149 37 # print(md5_obj.hexdigest())
四 os 模块
1 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径 2 3 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd 4 5 os.curdir 返回当前目录: ('.') 6 7 os.pardir 获取当前目录的父目录字符串名：('..') 8 9 os.makedirs('dirname1/dirname2') 可生成多层递归目录 10 11 os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 12 13 os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname 14 15 os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname 16 17 os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 18 19 os.remove() 删除一个文件 20 21 os.rename("oldname","newname") 重命名文件/目录 22 23 os.stat('path/filename') 获取文件/目录信息 24 25 os.sep 输出操作系统特定的路径分隔符，win下为"\",Linux下为"/" 26 27 os.linesep 输出当前平台使用的行终止符，win下为" ",Linux下为" " 28 29 os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为: 30 31 os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix' 32 33 os.system("bash command") 运行shell命令，直接显示 34 35 os.environ 获取系统环境变量 36 37 os.path.abspath(path) 返回path规范化的绝对路径 38 39 os.path.split(path) 将path分割成目录和文件名二元组返回 40 41 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 42 43 os.path.basename(path) 返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素 44 45 os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False 46 47 os.path.isabs(path) 如果path是绝对路径，返回True 48 49 os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False 50 51 os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False 52 53 os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 54 55 os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间 56 57 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间 58 59 os.path.getsize(path) 返回path的大小
五 sys 模块
1 # import sys 2 # sys.exit() #推出程序，正常退出时是sys.exit(0) 3 # sys.argv #命令函参数，第一个元素是程序本身路径 4 # sys.path #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 5 # sys.version #获取python解释器的版本信息 6 # sys.maxint #最大的Int值 7 # sys.platfrom #返回icaozuo系统平台名称 8 # 9 # 10 # 11 # 小练习 12 # count=1 13 # while count<10: 14 # print('ok') 15 # if count==8: 16 # #break #终止了if判断的后面条件，但是while循环还会继续进行 17 # sys.exit() #程序在这后面的都结束。直接全部终止 18 # count+=1 19 # print('ending') 20 # 21 # 22 # 23 # 24 # 小练习 25 # 26 # ret=sys.arge #["模块.py","fang","666"] 27 # print(ret) #["sys模块.py",'-u','fang','-p','666'] 28 # # 只有放在-u后面的是用户名，放在-p后面的是用户名密码。 29 # username=ret[1] 30 # password=ret[2] 31 # print(sys.argv) #显示当前服务器的绝对路径， 32 # print('huijia') 33 # username=input('username:') #io是一个阻塞状态 34 # password=input('password:') 35 # if username =='fang'and password=='666': 36 # print('huijia') 37 # 38 # sys.path #显示一堆路径，以列表的形式显示出来 39 # print(sys.path) #['E:\文本编辑器\pycharm\方杰\目录\模块', 'E:\文本编辑器\pycharm', 'E:\python3.5\python36.zip', 40 # 'E:\python3.5\DLLs', 'E:\python3.5\lib', 'E:\python3.5', 'E:\python3.5\lib\site-packages'] 41 # #寻找模块，从当前的路径下开始寻找，如果当前路径下没有，就会挨个的按照列表 42 # # 的顺序寻找下去，如果找到了，就不再寻找。 43 # import re 44 # import hashlib 45 # print(re.findall(r"hello","hello")) 46 # 47 # 48 # Base_dir=r'E:文本编辑器pycharm方杰阿豪' 49 # sys.path.append(Base_dir) 50 # import lesson1 51 # lesson1.foo() 52 # 不管是人家添加还是自己添加的模块，只要有路径，就会寻找到。
六 logging 模块 日志模块
1 #日志模块：为我们记录一些信息 2 # import logging 3 4 # logging.basicConfig( 5 # # level=logging.INFO 6 # # level=logging.DEBUG 7 # level=logging.ERROR, 8 # # filename='log.txt', 9 # # filemode='a', #追加的方式写入 #也可以写'w'是覆盖写入 10 # format='%(asctime)s---%(filename)s---%(lineno)s---%(name)s--%(message)s' 11 # )#2017-06-22 15:55:37,614---logging.模块.py---14---root 12 # # 2017-06-22 15:55:37,659---logging.模块.py---15---root 13 # # 2017-06-22 15:55:37,659---logging.模块.py---16---root 14 # 15 # 16 # logging.debug('debug message') 17 # logging.info('info message') 18 # logging.warning('warning message') 19 # logging.error('error message') 20 # logging.critical('critical meddage') 21 22 # #logging 对象 23 # import logging 24 # 25 # logger_obj=logging.getLogger() 26 # 27 # fh=logging.FileHandler('logger_file.txt') 28 # ch=logging.StreamHandler() 29 # 30 # #创建格式 31 # logging.Formatter('%(asctime)s-%(name)s-%(levelname)s-%(message)s') 32 # fh.setFormatter(format) 33 # ch.setFormatter(format) 34 # # 35 # # logger_obj.addHandler(fh) #logger对象可以添加多个fh和ch对象 36 # # logger_obj.addHandler(ch) 37 # 38 # logger_obj.info('info') 39 # logger_obj.error('error') 40 # logger_obj.warning('warning') 41 # logger_obj.debug('debug') 42 # 43 # 44 # import logging 45 # 46 # def get_logger(): 47 # logger_obj=logging.getLogger() 48 # 49 # fh=logging.FileHandler('logger_file.txt') # 创建一个handler，用于写入日志文件 50 # ch=logging.StreamHandler() # 再创建一个handler，用于输出到控制台 51 # 52 # #创建格式 53 # logging.Formatter('%(asctime)s-%(name)s-%(levelname)s-%(message)s') 54 # fh.setFormatter(format) 55 # ch.setFormatter(format) 56 # return logger_obj 57 # logger_obj=get_logger() 58 # # 59 # # logger_obj.addHandler(fh) 60 # # logger_obj.addHandler(ch) 61 # 62 # logger_obj.info('info') 63 # logger_obj.error('error') 64 # logger_obj.warning('warning') 65 # logger_obj.debug('debug')
七 json 模块 有序化模块
1 #序列化 2 #import json 3 4 5 # 有序化加入 6 # import json 7 # 8 # fang={"name":'jie','age':18} 9 # f=open('l.txt','w') 10 # hui=json.dumps(fang) 11 # print(hui) 12 # print(type(hui)) 13 # f.write(hui) 14 # f.close() 15 #有序化返回 16 # import json 17 # f=open('l.txt','r') 18 # hui=f.read() 19 # fang=json.loads(hui) 20 # print(fang) 21 # print(type(fang)) 22 23 #有序化 24 # import json 25 # f=open('la.txt','r') 26 # hui=f.read() 27 # fang=json.loads(hui) 28 # print(fang) 29 # print(type(fang)) 30 31 32 # import json 33 # fang={'name':'jie','age':18} 34 # f=open('hui.txt','w') 35 # dong=json.dumps(fang) 36 # print(dong) 37 # print(type(dong)) 38 # f.write(dong) 39 # f.close() 40 41 # import json 42 # f=open('hui.txt','r') 43 # dong=f.read() 44 # ai=json.loads(dong) 45 # print(ai) 46 # print(type(ai)) 47 48 #简写有序化 49 # import json 50 # fang={'name':'jie','age':18} 51 # f=open('hui.txt','w') 52 # json.dump(dic,f) 53 # f.close() 54 55 #简写有序化返回 56 # import json 57 # f=open('hui.txt','r') 58 # a=json.load(f) 59 # print(a) 60 # print(type(a))
八 pickle 模块 只限于python中使用的有序化模块
1 # 和json使用方法一样，仅仅换了一个名字。 2 # 缺点：pickle仅仅用于python数据类型转换，不能再其他的语言之间进行使用。 3 # 优点：能支持python的所有数据类型，所有数据类型之间都可以进行转换的。 4 # 5 6 #加入类容 7 # import pickle 8 # 9 # a={'name':'b','age':22} 10 # # print(type(a)) #class 'dict' 11 # c=pickle.dumps(a) 12 # print(c) 13 # print(type(c)) #calss 'bytes' 14 # 15 # f=open('有序化对象——piskle','wb') #注意’w‘是写入str，wb是写入bytes，c是’bytes‘ 16 # f.write(c) # 等价于piskle。dump（c，f） 17 # f.close() 18 # 19 #返回数据 20 # import pickle 21 # f=open('有序化对象——piskle','rb') 22 # h=pickle.loads(f.read()) #等同于h=pickle.liad(f) 23 # print(h) 24 # print(h['age']) 25 # 26 # 27 28 29 #练习 30 # import datetime 31 # d=datetime.datetime.now() 32 # print(d) 33 # print(type(d)) 34 #
九 re 模块 正则表达式
1 #正则表达式的功能：字符串的模糊匹配查询。 2 import re 3 # ret=re.findall("方","方杰,方合意,方磊,光东,阿杰,李杰,方何军") ##匹配出所有符合条件的元素 4 # print(ret) 5 6 # . 可以代替除换行符以外任意一个元素， 7 # ret=re.findall("方..","方杰,方合意,方磊,光东,阿杰,李杰,方何军") ##匹配出所有符合条件的元素 8 # print(ret) 9 10 11 # ret=re.findall("方.","方杰,方合意,方磊,光东,阿杰,李杰,方何军") #匹配出所有符合条件的元素 12 # print(ret) 13 14 # ^ 匹配第一个 元素的类容，匹配不成功，也不会去匹配后面的元素 15 # ret=re.findall("^方.","方杰,方合意,方磊,光东,阿杰,李杰,方何军") #匹配出所有符合条件的元素 16 # print(ret) 17 18 # $ 匹配该对象的最后一个内容，不会去匹配其他位置的内容 19 # ret=re.findall("y..n$","方杰,方合意,方磊,光东,阿杰,李杰,方何军yuan") #匹配出所有符合条件的元素 20 # print(ret) 21 22 # *(0到无穷次） +（1到无穷次） ？（0到1） {} ：制定次数 23 # ret=re.findall("d{16}","234214455,663255654534246,545556564367656653,4453576489780423") 24 # print(ret) 25 26 # ret=re.findall("333d*","333234214455,333255654534246,545556564367656653,4453576489780423") 27 # print(ret) 28 29 # ret=re.findall("333d+","3334214455,333255654534246,333,56564367656653,4453576489780423") 30 # print(ret) 31 32 # ret=re.findall('131d+?','1312312312') 33 # print(ret) 34 35 # ret=re.findall("d+.?d+","3555,8498,64.674,2344") 36 # print(ret) 37 38 #匹配整数 39 # ret=re.findall("d","3334214455,3332546,333,56564356653,44580423") 40 # print(ret) 41 42 # ret=re.findall("d+","33342455,3332546,-333,5653,-4423") 43 # print(ret) 44 45 #可以匹配出负整数和正整数 46 # ret=re.findall("-?d+","33342455,3332546,-333,5653,-4423") 47 # print(ret) 48 49 # ret=re.findall("d?","2342,43,7654,87") 50 # print(ret) 51 52 #转义符 53 54 # 换行符 55 56 #将原字符转换成普通符号 57 # ret=re.findall(".com","www.baidu.com,www.youji.com,www.xiongdi.com,www.ss.cn") 58 # print(ret) 59 60 #将一些普通符号转换成特殊功能 61 62 #w匹配任何字母数字字符； 它相当于类 [^a-zA-Z0-9_] 63 # ret=re.findall("w","yuan323665534") 64 # print(ret) 65 66 #W 匹配任何非字母数字字符； 它相当于类 [^a-zA-Z0-9_] 67 # ret=re.findall("W","yuan3236$655&34") 68 # print(ret) 69 70 # ret=re.findall("w+","yuan323665534") 71 # print(ret) 72 73 #d 匹配任何十进制数； 它相当于类 [0-9]。 74 # ret=re.findall("d","yuan3236$655&34") 75 # print(ret) 76 77 #D 匹配任何非数字字符； 它相当于类 [^0-9]。 78 # ret=re.findall("D","yuan3236$655&34") 79 # print(ret) 80 81 #s 匹配任何空白字符； 它相当于类 [ fv]。 82 # ret=re.findall("s","hello i love like") 83 # print(ret) 84 85 #S 匹配任何非空白字符； 它相当于类 [^ fv]。 86 # ret=re.findall("S","hello i love like") 87 # print(ret) 88 89 # 匹配一个特殊字符边界，比如空格 ，&，＃等 90 # ret=re.findall(r"i","hello i love like") 91 # print(ret) 92 93 # ret=re.findall(r"i","hello i love li$ke") 94 # print(ret) 95 96 # r 97 # ret=re.findall(r"c\l","abcle") 98 # print(ret) 99 100 #字符集[]： 在[]里面多选一的效果 一个字符集只匹配一个字符 101 # ret=re.findall(r"abc","abcjpofdabhiac") 102 # print(ret) 103 104 # 105 # ret=re.findall(r"a[bc]","abcjpofdabhiac") 106 # print(ret) 107 108 # ret=re.findall(r"a[bc]d","abdcjpofdabhiacd") 109 # print(ret) 110 111 # ret=re.findall(r"a[b.c]d","abcjpofdabhia.dc") 112 # print(ret) 113 114 115 #字符集里面只有三个特殊符号：- ^ 116 117 # ret=re.findall(r"[0-9]","ds1246634347cvkdhsd") 118 # print(ret) 119 # 120 # 121 # ret=re.findall(r"[a-z]","ds1246634347cvkdhsd") 122 # print(ret) 123 # 124 # ret=re.findall(r"[A-Z]","ds1246DSJFKS47cvkdhsd") 125 # print(ret) 126 # 127 # ret=re.findall(r"[A-Za-z0-9]","ds1246634347cvkdhsd") 128 # print(ret) 129 130 # ret=re.findall(r"a[d]c","ds12a34c7cvkdhsd") 131 # print(ret) 132 133 134 # ret=re.findall(r"[^d]","ds1246634347cvkdhsd") 135 # print(ret) 136 137 138 # ret=re.findall(r"[^da-z]","ds1246634347cvk#dhsd") 139 # print(ret) 140 141 #字符集 | 或者的意思 要配合 （）用的 142 143 # ret=re.findall("www.(w+).com","www.baidu.com,www.youji.com,www.xiongdi.com,www.ss.cn") 144 # print(ret) 145 146 # ret=re.findall("www.(w+).(com|cn)","www.baidu.com,www.youji.com,www.xiongdi.com,www.ss.cn") 147 # print(ret) 148 149 # ret=re.findall("www.(?:w+).(?:com|cn)","www.baidu.com,www.youji.com,www.xiongdi.com,www.ss.cn") 150 # print(ret) 151 152 #分组 （） 153 # ret=re.findall("(fang)","fangffksdl;hfangfangfnag") 154 # print(ret) 155 # 156 # ret=re.findall("(fang)+","fangffksdl;hfangfangfnag") 157 # print(ret) 158 159 # ret=re.findall("(方.{1,3}),","方杰归来,方合意,方磊,光东,阿杰,李杰,方何军,") ##匹配出所有符合条件的元素 160 # print(ret) 161 162 #只有匹配到了一项内容就不会在继续匹配了 163 # ret=re.search("(fang)+","fangffksdl;hfangfangfnag") 164 # print(ret) 165 # print(ret.group()) 166 # 167 # #没有匹配内容则会返回None，group（）则会报错报错 168 # ret=re.search("(fakl)+","fangffksdl;hfangfangfnag") 169 # print(ret) 170 # print(ret.group()) 171 172 173 174 #match 只匹配字符串开头的位置 175 # ret=re.match("(fang)+","fangffksdl;hfangfangfnag") 176 # print(ret) 177 # print(ret.group()) 178 179 #开头位置匹配不上就会报错 180 # ret=re.match("(fang)+","sdffangffksdlaihngfangfnag") 181 # print(ret) 182 # print(ret.group()) 183 184 185 186 187 # ret=re.search(r"blog-aticles-20[01]d","blog-aticles-2005") 188 # print(ret) 189 # print(ret.group()) 190 # 191 # 192 # ret=re.search(r"blog-aticles-20[01]d-d+","blog-aticles-2005-12") 193 # print(ret) 194 # print(ret.group()) 195 # 196 # 197 # ret=re.findall(r"blog-aticles-(20[01]d)-(d+)","blog-aticles-2005-12") 198 # print(ret) 199 # 200 # 201 # #命名分组 202 # ret=re.search(r"blog-aticles-(?P<year>20[01]d)-(d+)","blog-aticles-2005-12") 203 # print(ret.group('year')) 204 # 205 # ret=re.search(r"blog-aticles-(?P<year>20[01]d)-(?P<mansh>d+)","blog-aticles-2005-12") 206 # print(ret.group('mansh'))
1 #贪娈匹配 2 # ret=re.findall("abc+","abccccccccccccccgds") 3 # print(ret) 4 5 # ret=re.findall("abc{1,}","abccccccccccccccgds") 6 # print(ret) 7 8 #非贪娈模式 9 # ret=re.findall("abc+?","abccccccccccccccgds") 10 # print(ret) 11 12 # s="asfdhgfasflfhfas" 13 # ret=re.findall("as.*?as",s) 14 # print(ret) 15 16 17 #import re 18 #re.findall(） 19 # ret=re.findall("abc(?:d)","abc34das") #1返回的是列表的格式 2 findall优先筛选 20 # print(ret) 21 22 #分割 23 # s="hello23fang54jie543jia" 24 # ret=re.split("d+",s) 25 # print(ret) 26 # 27 # #自定义分割 28 # s="hello23fang54jie543jia" 29 # ret=re.split("d+",s,1) 30 # print(ret) 31 32 #同时返回分隔符 33 # s="hello23fang54jie543jia" 34 # ret=re.split("(d+)",s) 35 # print(ret) 36 37 #替换 38 # ret="hello fang".replace("fang","jie") 39 # print(ret) 40 41 #多个同时替换 42 # ret=re.sub("f.*?g","jieshao","hello fang fhog felscg") 43 # print(ret) 44 45 #多个替换，同时显示替换词数 46 # ret=re.subn("f.*?g","jieshao","hello fang fhog felscg") 47 # print(ret) 48 49 #编译 50 # obj=re.compile("d+") 51 # a=obj.findall("sfjdskghr7o456o474o56j5h") 52 #print(a) 53 # ret=obj.findall("sdg36ew4375g5445y") #和re.findall一样，不过可以在多个使用时，同时使用一个编译 54 # print(ret) 55 56 #迭代器 57 # ret=re.finditer("d+","sdj6jtqbvw4y4n56m456h876nl;wnB%$5ln56l7jb6kn7jiuk3vtb5jnil6756") 58 # print(ret) 59 # print(next(ret).group()) 60 # print(next(ret).group()) 61 # print(next(ret).group()) 62 # print(next(ret).group()) 63 # print(next(ret).group()) 64 65 66 67 #1 findall的优先级查询： 68 69 70 # import re 71 # 72 # ret=re.findall('www.(baidu|oldboy).com','www.oldboy.com') 73 # print(ret)#['oldboy'] 这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可 74 # 75 # ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com') 76 # print(ret)#['www.oldboy.com'] 77 78 79 #2 split的优先级查询 80 81 # ret=re.split("d+","yuan2egon56alex") 82 # print(ret) 83 # 84 # ret=re.split("(d+)","yuan2egon56alex") 85 # print(ret)
十 configparser模块
1 #文件的基本格式是 例如： 2 # [DEFAULT] 3 # ServerAliveInterval = 45 4 # Compression = yes 5 # CompressionLevel = 9 6 # ForwardX11 = yes 7 # 8 # [bitbucket.org] 9 # User = hg 10 # 11 # [topsecret.server.com] 12 # Port = 50022 13 # ForwardX11 = no 14 15 #configparser使用的格式是：分为三段，每段相当于是一个字典的形式，然后字典里面在包含一个字典 16 #生成文件的方法是 17 #fang=configparser.ConfigParser() #首先调用模块的对象，然后再赋值给一个对象 18 #fang["DEFAULT"]={"key1":"vales1","key2':"vales2"........} 19 #fang[ "自定义字典名称"]={"key1":"vales1","key2":'vales2".....} 20 #fang["自定义字典名称2”]={"key1":"vales1","key2":vales2"......} 21 #with open("要添加的路劲","w")as f: 22 # fang.write(f) 23 24 # import configparser 25 # #例如将下面内容写入到文件中 26 # fang=configparser.ConfigParser() 27 # fang["DEFAULT"]={ 28 # "ServerAliveInterval" :45, 29 # "Compression" :"yes", 30 # "CompressionLevel" : 9, 31 # "ForwardX11" : "yes" 32 # } 33 # fang["bitbucket.org"]={"User": "hg"} 34 # fang["topsecret.server.com"]={"Port" : 50022,"ForwardX11" :"no"} 35 # with open("yuan.txt","w")as f: 36 # fang.write(f) 37 ##创建的第一个字段名称必须是DEFAULT名称，后面创建的字段可以自定义名称，第一个字段创建的内容会在后面创建的每一个字段中自动添加上去。 38 # 39 # #操作文件：读与写操作 40 # import configparser 41 # jie=configparser.ConfigParser() 42 # jie.read("yuan.txt") 43 # print(fang.sections()) #查字段的信息 44 # 45 # import configparser 46 # jie=configparser.ConfigParser() 47 # jie.read("yuan.txt") 48 # print('topsecret.server.com' in fang) #查看字段是否在该字典里 49 # 50 # 51 # import configparser 52 # jie=configparser.ConfigParser() 53 # jie.read("yuan.txt") 54 # print(fang.items("topsecret.server.com")) #取出某个字段的内容 55 56 # import configparser 57 # 58 # config = configparser.ConfigParser() 59 # 60 # #---------------------------查找文件内容,基于字典的形式 61 # 62 # print(config.sections()) # [] 63 # 64 # config.read('example.ini') 65 # 66 # print(config.sections()) # ['bitbucket.org', 'topsecret.server.com'] 67 # 68 # print('bytebong.com' in config) # False 69 # print('bitbucket.org' in config) # True 70 # 71 # 72 # print(config['bitbucket.org']["user"]) # hg 73 # 74 # print(config['DEFAULT']['Compression']) #yes 75 # 76 # print(config['topsecret.server.com']['ForwardX11']) #no 77 # 78 # 79 # print(config['bitbucket.org']) #<Section: bitbucket.org> 80 # 81 # for key in config['bitbucket.org']: # 注意,有default会默认default的键 82 # print(key) 83 # 84 # print(config.options('bitbucket.org')) # 同for循环,找到'bitbucket.org'下所有键 85 # 86 # print(config.items('bitbucket.org')) #找到'bitbucket.org'下所有键值对 87 # 88 # print(config.get('bitbucket.org','compression')) # yes get方法取深层嵌套的值 89 #
十一 subpeocess 模块 命令模块
1 #调用系统的命令 2 # import subprocess 3 # 4 # # 创建一个新的进程,与主进程不同步 if in win: s=subprocess.Popen('dir',shell=True) 5 # s=subprocess.Popen('ls') 6 # s.wait() # s是Popen的一个实例对象 7 # 8 # print('ending...') 9 # import subprocess 10 # s=subprocess.Popen("dir",shell=True) #Popen是一个类，开启了新的进程， 11 #print("ending") #两个抢用CPU，看谁的速度快，就先打印谁 12 13 # s=subprocess.Popen("dir",shell=True) #制定谁先使用CPU 14 # s.wait() 15 # print("ending") 16 17 # import subprocess 18 # s=subprocess.Popen("Ls-L",shell=True) #命令带参数 19 20 #子进程的文本流控制 21 #可以在Popen()建立子进程的时候改变标准输入、标准输出和标准错误，并可以利用subprocess.PIPE将多个 22 #子进程的输入和输出连接在一起，构成管道(pipe)： 23 # import subprocess 24 # s=subprocess.Popen("Ls-L",shell=True,stdout=subprocess.PIPE) 25 # print(s.stdout.read()) #拿到一个字节 26 # 27 # import subprocess 28 # s=subprocess.Popen("Ls-L",shell=True,stdout=subprocess.PIPE) 29 # print(s.stdout.read().decode("gbk")) #进行一个转换 30 31 #当我们想要更个性化我们的需求的时候，就要转向Popen类，该类生成的对象用来代表子进程。刚才我们使用到了一个wait方法 32 33 #此外，你还可以在父进程中对子进程进行其它操作： 34 35 # s.poll() # 检查子进程状态 36 # s.kill() # 终止子进程 37 # s.send_signal() # 向子进程发送信号 38 # s.terminate() # 终止子进程 39 # 40 # s.pid:子进程号 41 42 ''' 43 subprocess.call() 44 45 父进程等待子进程完成 46 返回退出信息(returncode，相当于Linux exit code) 47 48 49 subprocess.check_call() 50 父进程等待子进程完成 51 返回0,检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含 52 有returncode属性，可用try…except…来检查 53 54 55 subprocess.check_output() 56 父进程等待子进程完成 57 返回子进程向标准输出的输出结果 58 检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含 59 有returncode属性和output属性，output属性为标准输出的输出结果，可用try…except…来检查。 60 61 62 '''
十二 模块和包的调用
1 在同一个目录下调用模块
1 #创建模块1 2 def func(): 3 print("func") 4 5 #创建模块2 6 x=10 7 8 def get(): 9 print(x) 10 11 def set(): 12 global x 13 x=100 14 15 #创建模块3 16 print("fang 1") 17 18 def foo(): 19 print("foo") 20 21 def da(): 22 print("da") 23 24 x=100 25 print("fang 2") 26 27 28 29 #使用方法 30 # import sys 31 # 32 # print(sys.path) #查看查找路径的顺序，将执行文件的目录路径插入到sys.path的第一个位置 33 # 34 35 #方式一 #推荐 36 #import fang1 37 # import fadng 38 #方式二 39 # import fang1,fadng 40 41 42 43 # fang1.foo() 44 # fadng.func() 45 #################调用过程 46 # import fang1 #第一次调用直接存到了内存 47 # import fang1 #第二次调用，不会在执行该模块，只是完成一次引用 48 49 50 51 #import的两个过程： 1 创建一个新的名称空间，2 执行被调用的模块 52 53 54 # import hui 55 # 56 # x=12 57 # 58 # print(hui.x) #10 59 # hui.get() #10 60 # hui.set() 61 # hui.get() #100 62 # 63 # print(x) #12 64 # 65 # import fadng as fang2 #修改模块的名字 66 # 67 # fang2.func() 68 69 70 #总结，每个模块都是独立的名称空间，定义在这个模块中的函数， 71 # 把这个模块的名称空间当做全局名称空间，这样我们在编写自己 72 # 的模块时，就不用担心我们定义在自己模块中全局变量会在被导入 73 # 时，与使用者的全局变量冲突 74 75 #import的使用在于同一个目录使用 76 #########################################from 。。。。import 。。。 77 #import fang1 78 79 80 # 自定义执行某个模块里的内容，可以多个同时进行 81 # from fang1 import x 82 # from fang1 import foo 83 # from fang1 import da 84 # print(x) 85 # foo() 86 # da() 87 88 89 #自定义执行某个模块的类容，多个同时可以被引用，上面的简写。 90 # from fang1 import x,foo,da 91 # print(x) 92 # foo() 93 # da() 94 95 #指定某个模块里的内容被引用，可以随时执行。相当于引用了一个变量 96 # #使用时要慎用 97 # from fang1 import * 98 # print(x) 99 # foo() 100 # da() 101 # 102 103 # from fang1 import * 104 # def foo(): 105 # print("ok") 106 # foo() 107 108 # def foo(): 109 # print("ok") 110 # from fang1 import * 111 # 112 # foo() 113 114 115 # from fang1 import * 116 # x=12 117 # print(x) 118 119 # x=12 120 # from fang1 import * 121 # 122 # print(x)
2 在同级目录下调用子模块
1 #创建模块1 2 def add(x,y): 3 print(x+y) 4 5 6 #创建模块2 7 import logging 8 9 def get_logger(): 10 logger=logging.getLogger() 11 fh=logging.FileHandler("lei.txt") 12 logger.addHandler(fh) 13 14 return logger 15 16 17 #导入模块的方法 18 19 #包中模块的调用 20 #组织模块的方式：包 21 22 #在python中，包可以理解成一个文件夹，但是每一个文件夹必须要有一个__init__.py模块 23 24 #包和文件夹的区别在于有没有__init__.py模块 25 26 #from 包 import 模块名 27 28 # from dong import lei 29 # 30 # a=lei.get_logger() 31 # a.error("error") 32 # 33 # from dong.ljr import aa 34 # aa.add(2,5)
3 在两个同级目录下调用模块
1 #创建模块1 2 def add(x,y): 3 print(x+y) 4 5 6 #创建模块2 7 import logging 8 9 def get_logger(): 10 logger=logging.getLogger() 11 fh=logging.FileHandler("lei.txt") 12 logger.addHandler(fh) 13 14 return logger 15 16 17 18 #导入模块的方法 19 import sys 20 import os 21 22 #路径给写死了 23 #sys.path.append(r"E:文本编辑器pycharm方杰目录模块2jiedong") 24 25 print(__file__) #打印当前执行目录的路径 26 27 # #上上级绝对路径 #上一级绝对路径 #当前绝对路径 28 a_b=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))# 29 30 print(a_b) 31 32 sys.path.insert(0,a_b) 33 from lei import get_logger 34 35 a=get_logger() 36 a.error("error") 37 38 from ljr import aa 39 aa.add(2,5)
4 __name__
1 当前模块下 2 def foo(): 3 print("ok") 4 # 5 # 6 # def main(): 7 # foo() 8 # 9 if __name__=="__main__": #推荐添加上这种格式 10 foo() 11 # 12 #print(__name__) 13 14 #name 就是main 15 16 17 18 调用的结果 19 import name #__name__在调用的时候打印的是当前模块的名称 20 21 22 23 #在上级目录往下寻找包和模块的格式是 24 #from 包.包 import 模块名字 25 #或者是 from 包.包.模块 import 调用对象 26 27 # from dong.ljr import aa 28 # aa.add(2,5) 29 #