time模块
1 import time 2 #print(help(time)) 查看帮助 3 4 print(time.time()) #1517193182.0534253 时间戳（s），unix诞生以来开始计算 5 time.sleep(3) #休眠3s 6 print(time.clock()) #7.551609587825597e-07 计算cpu执行时间（不包括上面的3s） 7 print(time.gmtime()) #结构化时间：time.struct_time(tm_year=2018, tm_mon=1, tm_mday=29, tm_hour=2, tm_min=36, tm_sec=5, tm_wday=0, tm_yday=29, tm_isdst=0) 即UTC（世界标准）时间，和北京时间差8h 8 print(time.localtime()) #本地时间：time.struct_time(tm_year=2018, tm_mon=1, tm_mday=29, tm_hour=10, tm_min=45, tm_sec=10, tm_wday=0, tm_yday=29, tm_isdst=0) 9 10 #print(time.strftime(format,p_tuple)) 11 print(time.strftime("%Y-%m-%d %H:%M:%S" )) #字符串时间即自定义格式输出日期 2018-01-29 10:55:02 12 struct_time=time.localtime() 13 print(time.strftime("%Y-%m-%d %H:%M:%S",struct_time)) #将结构化时间以字符串时间输出：2018-01-29 10:58:51 14 15 #time.strptime(string,format) 将字符串时间以结构化时间输出 16 print(time.strptime("2018-01-29 10:58:51","%Y-%m-%d %H:%M:%S")) #time.struct_time(tm_year=2018, tm_mon=1, tm_mday=29, tm_hour=10, tm_min=58, tm_sec=51, tm_wday=0, tm_yday=29, tm_isdst=-1) 17 #取某个时间值： 18 a=time.strptime("2018-01-29 10:58:51","%Y-%m-%d %H:%M:%S") 19 print(a.tm_hour) #10 20 print(a.tm_mon) #1 21 22 #time.ctime(seconds) 23 print(time.ctime()) #取当前时间：Mon Jan 29 11:11:09 2018 24 print(time.ctime(234566)) #将给定的时间以看得懂的方式输出（unix诞生以来的时间开始计算） 25 26 #time.mktime(p_tuple) 27 a=time.localtime() 28 print(time.mktime(a)) #将本地时间转化为时间戳：1517195833.0
datatime模块
1 import datetime 2 print(datetime.datetime.now()) #2018-01-29 11:20:48.342246
random模块
1 import random 2 print(random.random()) #取0-1内的随机数 3 print(random.randint(1,8)) #1-8内的随机数，包括8 4 print(random.choice("hello")) #在给定的字符串选取随机数 5 print(random.choice([1,2,3,4,5])) #也可以放列表 6 print(random.sample([1,2,[3,4]],2)) #在序列中随机选2个 7 print(random.randrange(1,10)) #取1-10的数，不包括10 8 9 10 #生成随机验证码 11 import random 12 checkcode = ‘‘ 13 for i in range(4): 14 current = random.randrange(0,4) 15 if current != i: 16 temp = chr(random.randint(65,90)) 17 else: 18 temp = random.randint(0,9) 19 checkcode += str(temp) 20 print checkcode
os模块
提供对操作系统进行调用的接口。
r：以字符原意思输出。
1 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径； 2 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd ；os.chdir(r‘F:\code‘) 3 os.curdir 返回当前目录: (‘.‘) 4 os.pardir 获取当前目录的父目录字符串名：(‘..‘) 5 os.makedirs(‘dirname1/dirname2‘) 可生成多层递归目录；os.makedirs(r‘abc\lriwu\alen‘) 6 os.removedirs(‘dirname1‘) 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 ；s.removedirs(r‘abc\lriwu\alen‘) 7 os.mkdir(‘dirname‘) 生成单级目录；相当于shell中mkdir dirname 8 os.rmdir(‘dirname‘) 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname 9 os.listdir(‘dirname‘) 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 10 os.remove() 删除一个文件 11 os.rename("oldname","newname") 重命名文件/目录 12 os.stat(‘path/filename‘) 获取文件/目录信息 13 os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/" 14 os.linesep 输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n" 15 os.pathsep 输出用于分割文件路径的字符串；windows:‘;‘ linux:‘:‘ 16 os.name 输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘ 17 os.system("bash command") 运行shell命令，直接显示 18 os.environ 获取系统环境变量 19 os.path.abspath(path) 返回path规范化的绝对路径;print(os.path.abspath(‘./os.py‘)) 20 os.path.split(path) 将path分割成目录和文件名二元组返回 21 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 22 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素 23 os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False 24 os.path.isabs(path) 如果path是绝对路径，返回True 25 os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False 26 os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False 27 os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 28 os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间 29 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
sys模块
1 sys.argv 命令行参数List，第一个元素是程序本身文件名 2 sys.exit(n) 退出程序，正常退出时exit(0) 3 sys.version 获取Python解释程序的版本信息 4 sys.maxint 最大的Int值 5 sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 6 sys.platform 返回操作系统平台名称 7 sys.stdout.write(‘please:‘) 8 val = sys.stdin.readline()[:-1]
hashlib模块
用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法；
1 import hashlib 2 3 m = hashlib.md5() 4 m.update("Hello".encode(‘utf8‘)) #python3中，内存中的字符串都是unicode类型，update参数一定需要接收bytes类型，所以需要encode转换（因为python3中只有bytes和str两种数据类型） 5 m.update("It‘s me".encode(‘utf8‘)) 6 print(m.digest()) #2进制格式hash b‘]\xde\xb4{/\x92Z\xd0\xbf$\x9cR\xe3Br\x8a‘ 7 print(len(m.hexdigest())) #16进制格式hash 5ddeb47b2f925ad0bf249c52e342728a 8 9 10 #加密过程等同于： 11 m2 = hashlib.md5() 12 m2.update("HelloIt‘s me".encode(‘utf8‘)) 13 print(len(m2.hexdigest())) #16进制格式hash 5ddeb47b2f925ad0bf249c52e342728a 14 15 16 17 18 import hashlib 19 20 # ######## md5 ######## 21 22 hash = hashlib.md5() 23 hash.update(‘admin‘) 24 print(hash.hexdigest()) 25 26 # ######## sha1 ######## 27 28 hash = hashlib.sha1() 29 hash.update(‘admin‘) 30 print(hash.hexdigest()) 31 32 # ######## sha256 ######## 33 34 hash = hashlib.sha256() 35 hash.update(‘admin‘) 36 print(hash.hexdigest()) 37 38 39 # ######## sha384 ######## 40 41 hash = hashlib.sha384() 42 hash.update(‘admin‘) 43 print(hash.hexdigest()) 44 45 # ######## sha512 ######## 46 47 hash = hashlib.sha512() 48 hash.update(‘admin‘) 49 print(hash.hexdigest())
logging模块
1.简单应用
1 import logging 2 logging.debug(‘debug message‘) 3 logging.info(‘info message‘) 4 logging.warning(‘warning message‘) 5 logging.error(‘error message‘) 6 logging.critical(‘critical message‘) #输出 WARNING:root:warning message ERROR:root:error message CRITICAL:root:critical message
可见，默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET），默认的日志格式为日志级别：Logger名称：用户输出消息。
2.灵活配置日志级别，日志格式，输出位置（文件输出和标准输出只能选一种）
1 import logging 2 logging.basicConfig(level=logging.DEBUG, 3 format=‘%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s‘, 4 datefmt=‘%a, %d %b %Y %H:%M:%S‘, 5 filename=‘/tmp/test.log‘, 6 filemode=‘w‘) 7 8 logging.debug(‘debug message‘) 9 logging.info(‘info message‘) 10 logging.warning(‘warning message‘) 11 logging.error(‘error message‘) 12 logging.critical(‘critical message‘) #查看输出： cat /tmp/test.log Mon, 05 May 2014 16:29:53 test_logging.py[line:8] DEBUG debug message Mon, 05 May 2014 16:29:53 test_logging.py[line:9] INFO info message Mon, 05 May 2014 16:29:53 test_logging.py[line:10] WARNING warning message Mon, 05 May 2014 16:29:53 test_logging.py[line:11] ERROR error message Mon, 05 May 2014 16:29:53 test_logging.py[line:12] CRITICAL critical message
可见在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。（a:追加写；w:覆盖写）
注意：如果没有指定filename和filemode，默认将日志打印到了标准输出中。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的默认日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log‘,‘w‘))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。
format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息
3.logger对象
上述几个例子中我们了解到了logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical() 分别用以记录不同级别的日志信息；logging.basicConfig() 用默认日志格式为日志系统建立一个默认的流处理器：设置基础配置（如日志级别等）并加到root logger中，这几个是logging模块级别的函数；另外还有一个模块级别的函数是logging.getLogger([name])（返回一个logger对象，如果没有指定名字将返回root logger）
先看一个最简单的过程：
1 import logging 2 #创建一个日志（logger）对象 3 logger = logging.getLogger() 4 5 # 创建一个handler即文件输出流对象，用于写入日志文件 6 fh = logging.FileHandler(‘test.log‘) 7 8 # 再创建一个handler即标准输出流对象，用于输出到控制台 9 ch = logging.StreamHandler() 10 11 #日志格式对象 12 formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘) 13 14 fh.setFormatter(formatter) #为文件输出设置日志格式 15 ch.setFormatter(formatter) #为标准输出设置日志格式 16 17 #通过addHandler为logger添加文件输出对象和标准输出对象 18 logger.addHandler(fh) #logger对象可以添加多个fh和ch对象 19 logger.addHandler(ch) 20 #logger1.setLevel(logging.DEBUG) 设置输出日志级别，不指定默认是warnning 21 logger.debug(‘logger debug message‘) 22 logger.info(‘logger info message‘) 23 logger.warning(‘logger warning message‘) 24 logger.error(‘logger error message‘) 25 logger.critical(‘logger critical message‘)
输出：
#控制台输出 2018-01-30 09:53:10,887 - root - WARNING - logger warning message 2018-01-30 09:53:10,887 - root - ERROR - logger error message 2018-01-30 09:53:10,887 - root - CRITICAL - logger critical message #文件输出 cat test.log 2018-01-30 09:53:10,887 - root - WARNING - logger warning message 2018-01-30 09:53:10,887 - root - ERROR - logger error message 2018-01-30 09:53:10,887 - root - CRITICAL - logger critical
流程图：
4.应用
1 import os 2 import time 3 import logging 4 from config import settings 5 6 7 def get_logger(card_num, struct_time): 8 9 if struct_time.tm_mday < 23: 10 file_name = "%s_%s_%d" %(struct_time.tm_year, struct_time.tm_mon, 22) 11 else: 12 file_name = "%s_%s_%d" %(struct_time.tm_year, struct_time.tm_mon+1, 22) 13 14 file_handler = logging.FileHandler( 15 os.path.join(settings.USER_DIR_FOLDER, card_num, ‘record‘, file_name), 16 encoding=‘utf-8‘ 17 ) 18 fmt = logging.Formatter(fmt="%(asctime)s : %(message)s") 19 file_handler.setFormatter(fmt) 20 21 logger1 = logging.Logger(‘user_logger‘, level=logging.INFO) 22 logger1.addHandler(file_handler) 23 return logger1
ConfigParser模块
常用配置文件的格式如下：
1 [DEFAULT] 2 ServerAliveInterval = 45 3 Compression = yes 4 CompressionLevel = 9 5 ForwardX11 = yes 6 7 [bitbucket.org] 8 User = hg 9 10 [topsecret.server.com] 11 Port = 50022 12 ForwardX11 = no
使用python生成一个这样的文档：
1 import configparser 2 3 config = configparser.ConfigParser() #生成一个文件操作句柄 4 config["DEFAULT"] = {‘ServerAliveInterval‘: ‘45‘, 5 ‘Compression‘: ‘yes‘, 6 ‘CompressionLevel‘: ‘9‘} 7 8 config[‘bitbucket.org‘] = {} 9 config[‘bitbucket.org‘][‘User‘] = ‘hg‘ 10 config[‘topsecret.server.com‘] = {} 11 topsecret = config[‘topsecret.server.com‘] 12 topsecret[‘Host Port‘] = ‘50022‘ # mutates the parser 13 topsecret[‘ForwardX11‘] = ‘no‘ # same here 14 config[‘DEFAULT‘][‘ForwardX11‘] = ‘yes‘ 15 with open(‘example.ini‘, ‘w‘) as configfile: #创建文件 16 config.write(configfile)
增删改查操作：
1 import configparser 2 3 config = configparser.ConfigParser() 4 #---------------------------------------------查 5 print(config.sections()) #[] 6 config.read(‘example.ini‘) #关联文件 7 print(config.sections()) #[‘bitbucket.org‘, ‘topsecret.server.com‘] 即打印字段，default是默认字段，不会显示出来 8 print(config.defaults()) #OrderedDict([(‘compression‘, ‘yes‘), (‘compressionlevel‘, ‘9‘), (‘serveraliveinterval‘, ‘45‘), (‘forwardx11‘, ‘yes‘)]) 查看default字段下的所有属性以及属性值 9 print(config.items(‘bitbucket.org‘)) #[(‘serveraliveinterval‘, ‘45‘), (‘compression‘, ‘yes‘), (‘compressionlevel‘, ‘9‘), (‘forwardx11‘, ‘yes‘), (‘user‘, ‘hg‘)] 查看非default字段下的所有属性以及属性值 10 print(config.options(‘bitbucket.org‘))#[‘user‘, ‘serveraliveinterval‘, ‘compression‘, ‘compressionlevel‘, ‘forwardx11‘] 查看字段下的属性 11 print(‘bytebong.com‘ in config)# False 查看配置文件中是否有该字段 12 print(config.has_section(‘bitbucket.org‘)) #查看配置文件中是否有该字段 13 print(config[‘bitbucket.org‘][‘User‘]) # hg 查看属性值 14 15 for key in config: 16 print(key) 17 # 输出：打印config下的所有字段 18 # DEFAULT 19 # bitbucket.org 20 # topsecret.server.com 21 22 23 for key in config[‘bitbucket.org‘]: 24 print(key) 25 # 输出：bitbucket.org字段下的属性以及default字段下的属性 26 # user 27 # compression 28 # compressionlevel 29 # serveraliveinterval 30 # forwardx11 31 32 #---------------------------------------------删,改,增 33 34 #删除字段 35 config.remove_section(‘topsecret.server.com‘) 36 37 #添加字段 38 config.add_section(‘yuan‘) 39 40 #修改属性值 41 config.set(‘bitbucket.org‘,‘user‘,‘lriwu‘) 42 43 #删除键值对 44 config.remove_option(‘bitbucket.org‘,‘user‘) 45 46 47 (config.write(open(‘r.cfg‘, "w"))) #最后这句语句是必须的
re模块
正则表达式（或 RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模块被编译成一系列的字节码，然后由C 编写的匹配引擎执行。
作用：字符串提供的方法是完全匹配，无法实现模糊匹配，所以引入正则的原因是可以实现模糊匹配。
字符匹配（普通字符，元字符）：
1.普通字符：字符串提供的方法是完全匹配，无法实现模糊匹配。
1 import re 2 re.findall(‘w\w{2}l‘, ‘hello world‘) #[‘worl‘] 模糊匹配
3 re.findall(‘alex‘,‘yuanaleSxalexwupeiqi‘) #[‘alex‘] 精确匹配（如果只实现这一功能，使用字符串的方法就可以了）
2.元字符：可以实现模糊匹配
- 元字符之. ^ $ * + ? { }
1 import re 2 3 #‘.‘：匹配任意字符一次（不能匹配换行符） 4 ret = re.findall(‘a..in‘, ‘helloalvin‘) 5 print(ret) # [‘alvin‘] 6 7 #‘^‘:行首匹配 8 ret = re.findall(‘^a...n‘, ‘alvinhelloawwwn‘) 9 print(ret) # [‘alvin‘] 10 11 #‘$‘:行尾匹配 12 ret = re.findall(‘a...n$‘, ‘alvinhelloawwwn‘) 13 print(ret) # [‘awwwn‘] 14 15 #‘*‘:即匹配前面的字符[0,+oo]次 16 ret = re.findall(‘abc*‘, ‘abcccc‘) 17 print(ret) # [‘abcccc‘] #贪婪匹配 18 ret = re.findall(‘abc*‘, ‘ab‘) 19 print(ret) # [‘ab‘] #匹配0次例子 20 21 #‘+‘:匹配前面的字符[1,+oo]次即匹配前面的字符至少一次 22 ret = re.findall(‘abc+‘, ‘abccc‘) 23 print(ret) # [‘abccc‘] #贪婪匹配 24 25 #‘?‘:匹配前面的字符[0,1]次 26 ret=re.findall(‘abc?‘,‘abccc‘)#[0,1] 27 print(ret)#[‘abc‘] #贪婪匹配 28 ret = re.findall(‘a?b‘, ‘aaaabhghabfb‘) 29 print(ret) # [‘ab‘,‘ab‘,‘b‘] 30 31 32 ret = re.findall(‘abc{1,4}‘, ‘abccc‘) #匹配前面的1-4次都行 33 print(ret) # [‘abccc‘] 贪婪匹配 34 ret = re.findall(‘a{5}b‘,‘aaaaab‘) #aaaaab 匹配前面的5次
注意：前面的*,+,?等都是贪婪匹配，也就是尽可能多次匹配，后面加?号使其变成惰性匹配即按照最少的进行匹配；
1 ret=re.findall(‘abc*?‘,‘abcccccc‘) 2 print(ret)#[‘ab‘]
- 元字符之字符集［］：
1 # --------------------------------------------字符集[] 2 ret = re.findall(‘a[bc]d‘, ‘acd‘) #或的关系[b,c]表示b或c 3 print(ret) # [‘acd‘] 4 5 ret = re.findall(‘[a-z]‘, ‘acd‘) 6 print(ret) # [‘a‘, ‘c‘, ‘d‘] 7 8 #取消元字符的特殊功能 9 ret = re.findall(‘[.*+]‘, ‘a.cd+‘) #这里的.*+只表示自身意义 10 print(ret) # [‘.‘, ‘+‘] 11 12 # 在字符集里仍有功能的符号: - ^ \ 13 ret = re.findall(‘[1-9]‘, ‘45dha3‘) #‘-‘代表范围 14 print(ret) # [‘4‘, ‘5‘, ‘3‘] 15 16 ret = re.findall(‘[^a,b]‘, ‘45bdha3‘) #‘^‘代表取反即除了a和b以外的 17 #等同于：ret = re.findall(‘[^ab]‘, ‘45bdha3‘) 18 print(ret) # [‘4‘, ‘5‘, ‘d‘, ‘h‘, ‘3‘] 19 20 21 # 反斜杠后边跟元字符去除特殊功能,比如\. 22 # 反斜杠后边跟普通字符实现特殊功能,比如\d，相当于类 [0-9] 23 ret = re.findall(‘[\d]‘, ‘45bdha3‘) 24 print(ret) # [‘4‘, ‘5‘, ‘3‘]
反斜杠后边跟元字符去除特殊功能,比如\.
反斜杠后边跟普通字符实现特殊功能,比如\d
\d 匹配任何十进制数；它相当于类 [0-9]。
\D 匹配任何非数字字符；它相当于类 [^0-9]。
\s 匹配任何空白字符；它相当于类 [ \t\n\r\f\v]。
\S 匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v]。
\w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
\W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]
\b 匹配一个特殊字符边界，比如空格 ，&，＃，$等
1 ret=re.findall(‘I\b‘,‘I am LIST‘) 2 print(ret)#[] 3 ret=re.findall(r‘I\b‘,‘I am LI$T‘) 4 print(ret)#[‘I‘,‘I‘]
现在我们聊一聊\,先看下面两个匹配：
1 #-----------------------------eg1: 2 import re 3 ret=re.findall(‘c\l‘,‘abc\le‘) 4 print(ret)#[] 没有匹配 5 ret=re.findall(‘c\\l‘,‘abc\le‘) 6 print(ret)#[] 没有匹配 7 ret=re.findall(‘c\\\\l‘,‘abc\le‘) #在python解释器里先将‘\\\\’转义成‘\\’；再在re模块里将‘\\‘转义成‘\’ ，即就匹配到了‘c\l’ 8 print(ret)#[‘c\\l‘] 匹配到了 9 ret=re.findall(r‘c\\l‘,‘abc\le‘) #r表示告诉python解释器里面的字符串就是原生字符串，在python接收器中无需转义 10 print(ret)#[‘c\\l‘] 匹配到了 11 12 #-----------------------------eg2: 13 #之所以选择\b是因为\b在ASCII表中是有意义的 14 m = re.findall(‘\bblow‘, ‘blow‘) 15 print(m) #[] 没有匹配 16 m = re.findall(r‘\bblow‘, ‘blow‘) 17 print(m) #[‘blow‘] 匹配到了
- 元字符之分组()
1 print(re.search(‘(as)+‘,‘sdjkfasas‘).group()) #asas ‘+‘ 匹配前面分组[1,+oo]次
2 ret = re.findall(‘www.(\w+).com‘,‘www.baidu.com‘) #[‘baidu‘] 只会打印出组中的内容
3 ret = re.findall(‘www.(?:\w+).com‘,‘www.baidu.com‘) #[‘www.baidu.com‘] 取消组的权限
1 ret=re.search(‘(?P<id>\d{2})‘,‘23/com‘) #?P<id> 为分组取名字为id 2 print(ret.group())#23 3 print(ret.group(‘id‘))#23 #通过分组名取匹配到的值
- 元字符之或 |
ret=re.search(‘(?P<id>\d{2})/(?P<name>\w{3})‘,‘23/com‘)
print(ret.group())#23/com print(ret.group(‘id‘))#23
- re模块下的常用方法
1 import re 2 3 # 1 4 re.findall(‘a‘, ‘alvin yuan‘) # [‘a‘, ‘a‘]即返回所有满足匹配条件的结果,放在列表里 5 # 2 6 re.search(‘a‘, ‘alvin yuan‘).group() # ‘a‘ 即返回匹配到的第一个对象,对象可以调用group()返回结果；如果字符串没有匹配，则返回None。 7 8 # 3 9 re.match(‘a‘, ‘abca‘).group() # ‘a‘ 同search,不过只在字符串开始处进行匹配 10 11 # 4 分割 12 ret = re.split(‘b‘, ‘abcd‘) 13 print(ret) # [‘a‘, ‘cd‘] 14 15 ret = re.split(‘[ab]‘, ‘abcd‘) # 先按‘a‘分割得到‘‘和‘bcd‘,在对‘‘和‘bcd‘分别按‘b‘分割 16 print(ret) # [‘‘, ‘‘, ‘cd‘] 17 18 ret = re.split(‘[js]‘, ‘sdjksal‘) #[‘‘, ‘d‘, ‘k‘, ‘al‘] 19 20 # 5 替换 21 ret = re.sub(‘\d‘, ‘abc‘, ‘alvin5yuan6‘, 1) 22 print(ret) # alvinabcyuan6 23 ret = re.subn(‘\d‘, ‘abc‘, ‘alvin5yuan6‘) #没有指定第三个参数，全部替换 24 print(ret) # (‘alvinabcyuanabc‘, 2) 25 26 # 6 compile可以把正则表达式编译成一个正则表达式对象，可以把经常使用的正则表达式编译成正则表达式对象，这样可以提高一定的效率。 27 obj = re.compile(‘\d{3}‘) #实现一种规则可以匹配多次 28 ret = obj.search(‘abc123eeee‘) 29 print(ret.group()) # 123
30
31 #7
32 ret = re.finditer(‘\d‘,‘ds3sy4784a‘)
33 print(res) #<callable_iterator object at 0x00000233DBFA5208> 返回的结果是迭代器对象
34 print(next(ret).group()) #3
