Python-模块
一、模块
1. 什么是模块
在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码就会越来越长，越来越不容易维护。
为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Python中，一个.py文件就称之为一个模块（Module）。
2. 使用模块的好处
最大的好处是大大提高了代码的可维护性。其次，编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用。我们在编写程序的时候，也经常引用其他模块，包括Python内置的模块和来自第三方的模块。
使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。点这里查看Python的所有内置函数。
3. 使用模块
Python本身就内置了很多非常有用的模块，只要安装完毕，这些模块就可以立刻使用。
我们以内建的sys模块为例，编写一个hello的模块：
1 # !/usr/bin/env python3 #该行注释可以使本文件直接在Unix/Linux/Mac上运行 2 # -*- coding: utf-8 -*- #该行注释表示文件本身使用标准UTF-8编码 3 4 ' a test module ' #表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释 5 6 __author__ = 'Michael Liao' #使用__author__变量将作者写入文件 7 8 import sys #导入内置模块sys(使用模块的方式） 9 10 11 def test(): 12 args = sys.argv #调用sys模块的argv属性，该变量以列表的形式存储命令行的所有参数 13 if len(args) == 1: 14 print('Hello, world!') 15 elif len(args) == 2: 16 print('Hello, %s!' % args[1]) 17 else: 18 print('Too many arguments!') 19 20 21 if __name__ == '__main__': #当我们在命令行运行hello模块文件时，Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该hello模块时，if判断将失败， 22 # 因此，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。 23 test()
4. 安装第三方模块
在Python中，安装第三方模块，是通过包管理工具pip完成的。
#在命令行模式下运行：Pillow为第三方的模块名称 pip install Pillow
5. 模块搜索路径
当我们试图加载一个模块时，Python会在指定的路径下搜索对应的.py文件，如果找不到，就会报错，如上图所示，import hello报错
默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块，搜索路径存放在sys模块的path变量中：
>>> import sys >>> sys.path ['', 'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib', 'C:\\Python36', 'C:\\Python36\\lib\\site-packages '] >>>
如果我们要添加自己的搜索目录，有两种方法：
一是直接修改sys.path，添加要搜索的目录：
>>> import sys >>> sys.path.append('要搜索的目录')
这种方法是在运行时修改，运行结束后失效。
第二种方法是设置环境变量PYTHONPATH，该环境变量的内容会被自动添加到模块搜索路径中。设置方式与设置Path环境变量类似。注意只需要添加你自己的搜索路径，Python自己本身的搜索路径不受影响。
二、常用模块
1. time
a. 在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：
import time #时间戳(timestamp) 通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。 time.time() 1493207044.6561139 #格式化的时间字符串(Format String)： time.strftime('%Y-%m-%d %X') '2017-04-26 19:47:54' #元组(struct_time) ：struct_time元组共有9个元素:(年，月，日，时，分，秒，本周的第几天（周一为0），本年的第几天，时区） time.localtime() time.struct_time(tm_year=2017, tm_mon=4, tm_mday=26, tm_hour=19, tm_min=48, tm_sec=23, tm_wday=2, tm_yday=116, tm_isdst=0)
小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的
b. 时间形式的转换
#时间戳--->结构化时间 time.localtime() time.struct_time(tm_year=2017, tm_mon=4, tm_mday=26, tm_hour=19, tm_min=57, tm_sec=38, tm_wday=2, tm_yday=116, tm_isdst=0) time.gmtime() time.struct_time(tm_year=2017, tm_mon=4, tm_mday=26, tm_hour=11, tm_min=57, tm_sec=48, tm_wday=2, tm_yday=116, tm_isdst=0) #结构化时间--->时间戳 time.mktime(time.localtime()) 1493208155.0 time.mktime(time.gmtime()) 1493179366.0 #结构化时间--->字符串时间 time.strftime('%Y-%m-%d %X', time.localtime()) '2017-04-26 20:04:22' #字符串时间--->结构化时间 time.strptime('2017-04-27', '%Y-%m-%d') time.struct_time(tm_year=2017, tm_mon=4, tm_mday=27, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=117, tm_isdst=-1)
c. asctime and ctime
#结构化的时间--->字符串时间 time.asctime(time.localtime(1493208155.0)) 'Wed Apr 26 20:02:35 2017' #时间戳--->字符串时间 time.ctime(1493208155.0) 'Wed Apr 26 20:02:35 2017'
2. random
import random #随机小数x: 0<x<1 random.random() 0.9354224633786534 #随机整数x: 1<=x<=10 random.randint(1,10) 1 #随机整数x: 3=<x<5 random.randrange(3,5) 3 #随机返回列表中的任一元素 random.choice([1,'23',[4,5]]) 1 #随机返回列表中的任一元素 random.choice([1,'23',[4,5]]) [4, 5] #随机返回列表中的任2元素 random.sample([2,'a',33,['b',56],7],2) ['a', 7] #随机小数x： 1<x<3 random.uniform(1,3) 1.8055721248003096 #将列表中的元素打乱 item = [1,3,5,7,9] #打乱前 random.shuffle(item) item [9, 3, 5, 1, 7] #打乱后
练习:
1 import random 2 3 def v_code(): 4 5 “”“根据ASCII码定制5位随机字符验证码”“” 6 code = '' 7 for i in range(5): 8 a = random.randint(48, 57) # 数字0-9 9 b = random.randint(65, 90) # 大写字母A-Z 10 c = random.randint(97, 122) # 小写字母a-z 11 d = random.choice([a, b, c]) #随机返回以上3个范围的数字 12 code = ''.join([code, chr(d)]) 13 14 return code 15 16 17 print(v_code())
3. hashlib
a. 算法介绍
Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。
什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。
摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。
摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。
我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：
1 import hashlib 2 3 md5 = hashlib.md5() 4 md5.update('Hello world!'.encode('utf-8')) 5 print(md5.hexdigest()) 6 7 #结果： 8 #86fb269d190d2c85f6e0468ceca42a20
如果数据量很大，可以分块多次调用update()，最后计算的结果是一样的：
1 import hashlib 2 3 md5 = hashlib.md5() 4 md5.update('Hello '.encode('utf-8')) #注意：Hello后面有一个空格 5 md5.update('world!'.encode('utf-8')) 6 print(md5.hexdigest()) 7 8 #结果： 9 #86fb269d190d2c85f6e0468ceca42a20
MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示。另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似：
1 import hashlib 2 3 sha1 = hashlib.sha1() 4 sha1.update('Hello '.encode('utf-8')) # 5 sha1.update('world!'.encode('utf-8')) 6 print(sha1.hexdigest()) 7 8 sha2 = hashlib.sha1() 9 sha2.update('Hello world!'.encode('utf-8')) 10 print(sha2.hexdigest()) 11 12 #结果： 13 #d3486ae9136e7856bc42212385ea797094475802 14 #d3486ae9136e7856bc42212385ea797094475802
SHA1的结果是160 bit字节，通常用一个40位的16进制字符串表示。比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法越慢，而且摘要长度更长。
b. 算法应用
任何允许用户登录的网站都会存储用户登录的用户名和口令。如何存储用户名和口令呢？方法是存到数据库表中：
name | password --------+---------- michael | 123456 bob | abc999 alice | alice2008
如果以明文保存用户口令，如果数据库泄露，所有用户的口令就落入黑客的手里。此外，网站运维人员是可以访问数据库的，也就是能获取到所有用户的口令。正确的保存口令的方式是不存储用户的明文口令，而是存储用户口令的摘要，比如MD5：
username | password ---------+--------------------------------- michael | e10adc3949ba59abbe56e057f20f883e bob | 878ef96e86145580c38c87f0410ad153 alice | 99b1c2188db85afee403b1536010c2c9
考虑这么个情况，很多用户喜欢用123456，888888，password这些简单的口令，于是，黑客可以事先计算出这些常用口令的MD5值，得到一个反推表：
'e10adc3949ba59abbe56e057f20f883e': '123456' '21218cca77804d2ba1922c33e0151105': '888888' '5f4dcc3b5aa765d61d8327deb882cf99': 'password'
这样，无需破解，只需要对比数据库的MD5，黑客就获得了使用常用口令的用户账号。
对于用户来讲，当然不要使用过于简单的口令。但是，我们能否在程序设计上对简单口令加强保护呢？
由于常用口令的MD5值很容易被计算出来，所以，要确保存储的用户口令不是那些已经被计算出来的常用口令的MD5，这一方法通过对原始口令加一个复杂字符串来实现，俗称“加盐”：
hashlib.md5("salt".encode("utf8"))
经过Salt处理的MD5口令，只要Salt不被黑客知道，即使用户输入简单口令，也很难通过MD5反推明文口令。
但是如果有两个用户都使用了相同的简单口令比如123456，在数据库中，将存储两条相同的MD5值，这说明这两个用户的口令是一样的。有没有办法让使用相同口令的用户存储不同的MD5呢？
如果假定用户无法修改登录名，就可以通过把登录名作为Salt的一部分来计算MD5，从而实现相同口令的用户也存储不同的MD5。
摘要算法在很多地方都有广泛的应用。要注意摘要算法不是加密算法，不能用于加密（因为无法通过摘要反推明文），只能用于防篡改，但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。
4. os
1 ''' 2 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径 3 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd 4 os.curdir 返回当前目录: ('.') 5 os.pardir 获取当前目录的父目录字符串名：('..') 6 os.makedirs('dirname1/dirname2') 可生成多层递归目录 7 os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 8 os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname 9 os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname 10 os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 11 os.remove() 删除一个文件 12 os.rename("oldname","newname") 重命名文件/目录 13 os.stat('path/filename') 获取文件/目录信息 14 os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/" 15 os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n" 16 os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为: 17 os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix' 18 os.system("bash command") 运行shell命令，直接显示 19 os.environ 获取系统环境变量 20 os.path.abspath(path) 返回path规范化的绝对路径 21 os.path.split(path) 将path分割成目录和文件名二元组返回 22 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 23 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素 24 os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False 25 os.path.isabs(path) 如果path是绝对路径，返回True 26 os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False 27 os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False 28 os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 29 os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间 30 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间 31 os.path.getsize(path) 返回path的大小 32 '''
5. sys
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
6. json & pickle
a. 什么是序列化
我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
b. json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
1 import json 2 dic = {'name': 'alvin', 'age': 23, 'sex': 'male'} 3 print('序列化前--->', dic, type(dic)) 4 5 #将字典数据序列化 6 j = json.dumps(dic) 7 print('序列化后--->', j, type(j)) 8 9 json.dump(dic, open('a.txt', 'a+')) #将序列化的字符串以追加的方式存入文件a.txt 10 11 #将上步序列化的字符串反序列化为字典 12 data = json.loads(j) 13 print('反序列化后--->', data, type(data)) 14 15 data2 = json.load(open('a.txt')) 16 print('反序列化后--->', data2, type(data2)) #将文件a.txt中的字符串反序列化为字典 17 18 19 #运行结果 20 # 序列化前---> {'name': 'alvin', 'age': 23, 'sex': 'male'} <class 'dict'> 21 # 序列化后---> {"name": "alvin", "age": 23, "sex": "male"} <class 'str'> 22 # 反序列化后---> {'name': 'alvin', 'age': 23, 'sex': 'male'} <class 'dict'> 23 # 反序列化后---> {'name': 'alvin', 'age': 23, 'sex': 'male'} <class 'dict'>
1 #如果要将字符串反序列化为字典，其键值对只能用双引号（在序列化的时候，会自动将单引号转换为双引号） 2 dct = {"name": "jack"} 3 dct1 = str(dct) 4 print('str函数会将键值对的双引号转换为单引号', dct1, type(dct1)) 5 #print(json.loads(dct1)) #json无法识别单引号，报错 6 7 #解决方法： 8 dct2 = '{"name": "jack"}' 9 print(json.loads(dct2), type(json.loads(dct2))) 10 11 12 #运行结果 13 # str函数会将键值对的双引号转换为单引号 {'name': 'jack'} <class 'str'> 14 # {'name': 'jack'} <class 'dict'>
c. pickle
1 import pickle 2 3 dic = {'name': 'alvin', 'age': 23, 'sex': 'male'} 4 print('序列化前--->', dic, type(dic)) 5 #序列化 6 j = pickle.dumps(dic) 7 print('序列化后--->', j, type(j)) 8 9 f = open('b.txt', 'wb') #等价于pickle.dump(dic,f) 10 f.write(j) 11 f.close() 12 13 #反序列化 14 f = open('b.txt', 'rb') 15 data = pickle.loads(f.read()) 16 print('反序列化后--->', data, type(data)) 17 18 19 20 # 运行结果 21 # 序列化前---> {'name': 'alvin', 'age': 23, 'sex': 'male'} <class 'dict'> 22 # 序列化后---> b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x05\x00\x00\x00alvinq\x02X\x03\x00\x00\x00ageq\x03K\x17X\x03\x00\x00\x00sexq\x04X\x04\x00\x00\x00maleq\x05u.' <class 'bytes'> 23 # 反序列化后---> {'name': 'alvin', 'age': 23, 'sex': 'male'} <class 'dict'>
7. logging
a. 简单应用
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') 7 8 # 运行结果 9 # WARNING:root:warning message 10 # ERROR:root:error message 11 # CRITICAL:root:critical message
默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET），默认的日志格式为日志级别：Logger名称：用户输出消息。
b. 灵活配置日志级别，日志格式，输出位置
1 import logging 2 3 logging.basicConfig(level=logging.DEBUG, #设置默认日志级别为DEBUG 4 format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', 5 #格式化输出信息：时间 文件名 代码执行位置(第几行) 日志级别 输出信息 6 datefmt='%a, %d %b %Y %H:%M:%S', #时间格式 7 filename='test.log', #日志信息写入的文件 8 filemode='w') #文件打开方式 9 10 logging.debug('debug message') 11 logging.info('info message') 12 logging.warning('warning message') 13 logging.error('error message') 14 logging.critical('critical message') 15 16 17 18 #以上日志将信息写入了test.log文件，文件内容如下： 19 #Thu, 27 Apr 2017 20:09:56 35.py[line:130] DEBUG debug message 20 #Thu, 27 Apr 2017 20:09:56 35.py[line:131] INFO info message 21 #Thu, 27 Apr 2017 20:09:56 35.py[line:132] WARNING warning message 22 #Thu, 27 Apr 2017 20:09:56 35.py[line:133] ERROR error message 23 #Thu, 27 Apr 2017 20:09:56 35.py[line:134] CRITICAL critical message
可见在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
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用户输出的消息
c. logger对象
上述几个例子中我们了解到了logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()（分别用以记录不同级别的日志信息），logging.basicConfig()（用默认日志格式（Formatter）为日志系统建立一个默认的流处理器（StreamHandler），设置基础配置（如日志级别等）并加到root logger（根Logger）中）这几个logging模块级别的函数，另外还有一个模块级别的函数是logging.getLogger([name])（返回一个logger对象，如果没有指定名字将返回root logger）
先看一个最简单的过程：
1 import logging 2 3 logger = logging.getLogger() 4 5 fh = logging.FileHandler('test.log') # 创建一个handler，用于写入日志文件 6 7 ch = logging.StreamHandler() # 再创建一个handler，用于输出到控制台 8 9 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') 10 11 fh.setFormatter(formatter) 12 ch.setFormatter(formatter) 13 14 logger.addHandler(fh) #logger对象可以添加多个fh和ch对象 15 logger.addHandler(ch) 16 17 logger.debug('logger debug message') 18 logger.info('logger info message') 19 logger.warning('logger warning message') 20 logger.error('logger error message') 21 logger.critical('logger critical message')
先简单介绍一下，logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。
未完待续。。。
8. re
就其本质而言，正则表达式（或 RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。
字符串是编程时涉及到的最多的一种数据结构，对字符串进行操作的需求几乎无处不在。比如判断一个字符串是否是合法的Email地址，虽然可以编程提取@前后的子串，再分别判断是否是单词和域名，但这样做不但麻烦，而且代码难以复用。
正则表达式是一种用来匹配字符串的强有力的武器。它的设计思想是用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该字符串就是不合法的。
所以我们判断一个字符串是否是合法的Email的方法是：
- 创建一个匹配Email的正则表达式；
-
用该正则表达式去匹配用户的输入来判断是否合法。
因为正则表达式也是用字符串表示的，所以，我们要首先了解如何用字符来描述字符。
a. 元字符
在正则表达式中，如果直接给出字符，就是精确匹配。用\d可以匹配一个数字，\w可以匹配一个字母或数字，所以：
'00\d'可以匹配'007'，但无法匹配'00A'；
-
'\d\d\d'可以匹配'010'； -
'\w\w\d'可以匹配'py3'；
.可以匹配任一字符，所以：
'py.'可以匹配'pyc'、'pyo'、'py!'等等。
要匹配变长的字符，在正则表达式中，用*表示任意个字符（包括0个），用+表示至少一个字符，用?表示0个或1个字符，用{n}表示n个字符，用{n,m}表示n-m个字符：
来看一个复杂的例子：\d{3}\s+\d{3,8}。
我们来从左到右解读一下：
-
\d{3}表示匹配3个数字，例如'010'； -
\s可以匹配一个空格（也包括Tab等空白符），所以\s+表示至少有一个空格，例如匹配' '，' '等； -
\d{3,8}表示3-8个数字，例如'1234567'。
综合起来，上面的正则表达式可以匹配以任意个空格隔开的带区号的电话号码。
如果要匹配'010-12345'这样的号码呢？由于'-'是特殊字符，在正则表达式中，要用'\'转义，所以，上面的正则是\d{3}\-\d{3,8}。
但是，仍然无法匹配'010 - 12345'，因为带有空格。所以我们需要更复杂的匹配方式。
b. 元字符之字符集［］
要做更精确地匹配，可以用[]表示范围，比如：
-
[0-9a-zA-Z\_]可以匹配一个数字、字母或者下划线； -
[0-9a-zA-Z\_]+可以匹配至少由一个数字、字母或者下划线组成的字符串，比如'a100'，'0_Z'，'Py3000'等等； -
[a-zA-Z\_][0-9a-zA-Z\_]*可以匹配由字母或下划线开头，后接任意个由一个数字、字母或者下划线组成的字符串，也就是Python合法的变量； -
[a-zA-Z\_][0-9a-zA-Z\_]{0, 19}更精确地限制了变量的长度是1-20个字符（前面1个字符+后面最多19个字符）。
A|B可以匹配A或B，所以(P|p)ython可以匹配'Python'或者'python'。
^表示行的开头，^\d表示必须以数字开头。
$表示行的结束，\d$表示必须以数字结束。
你可能注意到了，py也可以匹配'python'，但是加上^py$就变成了整行匹配，就只能匹配'py'了。
c. \转义符
Python提供re模块，包含所有正则表达式的功能。由于Python的字符串本身也用\转义，所以要特别注意：
1 s = 'ABC\\-001' # Python的字符串 2 # 对应的正则表达式字符串变成： 3 # 'ABC\-001'
因此我们强烈建议使用Python的r前缀，就不用考虑转义的问题了：
1 s = r'ABC\-001' # Python的字符串 2 # 对应的正则表达式字符串不变： 3 # 'ABC\-001'
先看看如何判断正则表达式是否匹配：
1 >>> import re 2 >>> re.match(r'^\d{3}\-\d{3,8}$', '010-12345') 3 <_sre.SRE_Match object; span=(0, 9), match='010-12345'> 4 >>> re.match(r'^\d{3}\-\d{3,8}$', '010 12345') 5 >>>
match()方法判断是否匹配，如果匹配成功，返回一个Match对象，否则返回None。常见的判断方法就是：
1 test = '用户输入的字符串' 2 if re.match(r'正则表达式', test): 3 print('ok') 4 else: 5 print('failed')
d. 切分字符串
用正则表达式切分字符串比用固定的字符更灵活，请看正常的切分代码：
1 >>> 'a b c'.split(' ') 2 ['a', 'b', '', '', 'c']
嗯，无法识别连续的空格，用正则表达式试试：
1 >>> re.split(r'\s+', 'a b c') 2 ['a', 'b', 'c']
无论多少个空格都可以正常分割。加入,试试：
1 >>> re.split(r'[\s\,]+', 'a,b, c d') 2 ['a', 'b', 'c', 'd']
再加入;试试：
1 >>> re.split(r'[\s\,\;]+', 'a,b;; c d') 2 ['a', 'b', 'c', 'd']
如果用户输入了一组标签，下次记得用正则表达式来把不规范的输入转化成正确的数组。
e. 分组
除了简单地判断是否匹配之外，正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组（Group）。比如：
^(\d{3})-(\d{3,8})$分别定义了两个组，可以直接从匹配的字符串中提取出区号和本地号码：
1 >>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345') 2 >>> m 3 <_sre.SRE_Match object; span=(0, 9), match='010-12345'> 4 >>> m.group(0) 5 '010-12345' 6 >>> m.group(1) 7 '010' 8 >>> m.group(2) 9 '12345'
如果正则表达式中定义了组，就可以在Match对象上用group()方法提取出子串来。
注意到group(0)永远是原始字符串，group(1)、group(2)……表示第1、2、……个子串。
提取子串非常有用。来看一个更凶残的例子：
1 >>> t = '19:05:30' 2 >>> m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t) 3 >>> m.groups() 4 ('19', '05', '30')
这个正则表达式可以直接识别合法的时间。但是有些时候，用正则表达式也无法做到完全验证，比如识别日期：
1 '^(0[1-9]|1[0-2]|[0-9])-(0[1-9]|1[0-9]|2[0-9]|3[0-1]|[0-9])$'
对于'2-30'，'4-31'这样的非法日期，用正则还是识别不了，或者说写出来非常困难，这时就需要程序配合识别了。
f. 贪婪匹配
最后需要特别指出的是，正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。举例如下，匹配出数字后面的0：
1 >>> re.match(r'^(\d+)(0*)$', '102300').groups() 2 ('102300', '')
由于\d+采用贪婪匹配，直接把后面的0全部匹配了，结果0*只能匹配空字符串了。
必须让\d+采用非贪婪匹配（也就是尽可能少匹配），才能把后面的0匹配出来，加个?就可以让\d+采用非贪婪匹配：
1 >>> re.match(r'^(\d+?)(0*)$', '102300').groups() 2 ('1023', '00')
j. 编译
当我们在Python中使用正则表达式时，re模块内部会干两件事情：
-
编译正则表达式，如果正则表达式的字符串本身不合法，会报错；
-
用编译后的正则表达式去匹配字符串。
如果一个正则表达式要重复使用几千次，出于效率的考虑，我们可以预编译该正则表达式，接下来重复使用时就不需要编译这个步骤了，直接匹配：
1 >>> import re 2 # 编译: 3 >>> re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$') 4 # 使用： 5 >>> re_telephone.match('010-12345').groups() 6 ('010', '12345') 7 >>> re_telephone.match('010-8086').groups() 8 ('010', '8086')
编译后生成Regular Expression对象，由于该对象自己包含了正则表达式，所以调用对应的方法时不用给出正则字符串。
练习：
1 import re 2 3 email_v1 = re.compile(r'[0-9a-zA-Z\-\._]*@[0-9a-zA-Z]*.(com)$') 4 5 def match_email(): 6 s = input('Please input the email:') 7 res = email_v1.match(s) 8 if res: 9 print("legal email:", res.group()) 10 else: 11 print("illegal email") 12 13 match_email()
附：
| 字符 | 含义 |
| . | 表示匹配除了换行符外的任何字符 |
| 注：通过设置 re.DOTALL 标志可以使 . 匹配任何字符（包含换行符） | |
| | | A | B，表示匹配正则表达式 A 或者 B |
| ^ | 1. （脱字符）匹配输入字符串的开始位置 |
| 2. 如果设置了 re.MULTILINE 标志，^ 也匹配换行符之后的位置 | |
| $ | 1. 匹配输入字符串的结束位置 |
| 2. 如果设置了 re.MULTILINE 标志，$ 也匹配换行符之前的位置 | |
| \ | 1. 将一个普通字符变成特殊字符，例如 \d 表示匹配所有十进制数字 |
| 2. 解除元字符的特殊功能，例如 \. 表示匹配点号本身 | |
| 3. 引用序号对应的子组所匹配的字符串 | |
| 4. 详见下方列举 | |
| [...] | 字符类，匹配所包含的任意一个字符 |
| 注1：连字符 - 如果出现在字符串中间表示字符范围描述；如果如果出现在首位则仅作为普通字符 | |
| 注2：特殊字符仅有反斜线 \ 保持特殊含义，用于转义字符。其它特殊字符如 *、+、? 等均作为普通字符匹配 | |
| 注3：脱字符 ^ 如果出现在首位则表示匹配不包含其中的任意字符；如果 ^ 出现在字符串中间就仅作为普通字符匹配 | |
| {M,N} | M 和 N 均为非负整数，其中 M <= N，表示前边的 RE 匹配 M ~ N 次 |
| 注1：{M,} 表示至少匹配 M 次 | |
| 注2：{,N} 等价于 {0,N} | |
| 注3：{N} 表示需要匹配 N 次 | |
| * | 匹配前面的子表达式零次或多次，等价于 {0,} |
| + | 匹配前面的子表达式一次或多次，等价于 {1,} |
| ? | 匹配前面的子表达式零次或一次，等价于 {0,1} |
| *?, +?, ?? | 默认情况下 *、+ 和 ? 的匹配模式是贪婪模式（即会尽可能多地匹配符合规则的字符串）；*?、+? 和 ?? 表示启用对应的非贪婪模式。 |
| 举个栗子：对于字符串 "FishCCC"，正则表达式 FishC+ 会匹配整个字符串，而 FishC+? 则匹配 "FishC"。 | |
| {M,N}? | 同上，启用非贪婪模式，即只匹配 M 次 |
| (...) | 匹配圆括号中的正则表达式，或者指定一个子组的开始和结束位置 |
| 注：子组的内容可以在匹配之后被 \数字 再次引用 | |
| 举个栗子：(\w+) \1 可以字符串 "FishC FishC.com" 中的 "FishC FishC"（注意有空格） | |
| (?...) | (? 开头的表示为正则表达式的扩展语法（下边这些是 Python 支持的所有扩展语法） |
| (?aiLmsux) | 1. (? 后可以紧跟着 'a'，'i'，'L'，'m'，'s'，'u'，'x' 中的一个或多个字符，只能在正则表达式的开头使用 |
| 2. 每一个字符对应一种匹配标志：re-A（只匹配 ASCII 字符），re-I（忽略大小写），re-L（区域设置），re-M（多行模式）, re-S（. 匹配任何符号），re-X（详细表达式），包含这些字符将会影响整个正则表达式的规则 | |
| 3. 当你不想通过 re.compile() 设置正则表达式标志，这种方法就非常有用啦 | |
| 注意，由于 (?x) 决定正则表达式如何被解析，所以它应该总是被放在最前边（最多允许前边有空白符）。如果 (?x) 的前边是非空白字符，那么 (?x) 就发挥不了作用了。 | |
| (?:...) | 非捕获组，即该子组匹配的字符串无法从后边获取 |
| (?P<name>...) | 命名组，通过组的名字（name）即可访问到子组匹配的字符串 |
| (?P=name) | 反向引用一个命名组，它匹配指定命名组匹配的任何内容 |
| (?#...) | 注释，括号中的内容将被忽略 |
| (?=...) | 前向肯定断言。如果当前包含的正则表达式（这里以 ... 表示）在当前位置成功匹配，则代表成功，否则失败。一旦该部分正则表达式被匹配引擎尝试过，就不会继续进行匹配了；剩下的模式在此断言开始的地方继续尝试。 |
| 举个栗子：love(?=FishC) 只匹配后边紧跟着 "FishC" 的字符串 "love" | |
| (?!...) | 前向否定断言。这跟前向肯定断言相反（不匹配则表示成功，匹配表示失败）。 |
| 举个栗子：FishC(?!\.com) 只匹配后边不是 ".com" 的字符串 "FishC" | |
| (?<=...) | 后向肯定断言。跟前向肯定断言一样，只是方向相反。 |
| 举个栗子：(?<=love)FishC 只匹配前边紧跟着 "love" 的字符串 "FishC" | |
| (?<!...) | 后向否定断言。跟前向肯定断言一样，只是方向相反。 |
| 举个栗子：(?<!FishC)\.com 只匹配前边不是 "FishC" 的字符串 ".com" | |
| (?(id/name)yes-pattern|no-pattern) | 1. 如果子组的序号或名字存在的话，则尝试 yes-pattern 匹配模式；否则尝试 no-pattern 匹配模式 |
| 2. no-pattern 是可选的 | |
| 举个栗子：(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) 是一个匹配邮件格式的正则表达式，可以匹配 <user@fishc.com> 和 'user@fishc.com'，但是不会匹配 '<user@fishc.com' 或 'user@fishc.com>' | |
| \ | 下边列举了由字符 '\' 和另一个字符组成的特殊含义。注意，'\' + 元字符的组合可以解除元字符的特殊功能 |
| \序号 | 1. 引用序号对应的子组所匹配的字符串，子组的序号从 1 开始计算 |
| 2. 如果序号是以 0 开头，或者 3 个数字的长度。那么不会被用于引用对应的子组，而是用于匹配八进制数字所表示的 ASCII 码值对应的字符 | |
| 举个栗子：(.+) \1 会匹配 "FishC FishC" 或 "55 55"，但不会匹配 "FishCFishC"（注意，因为子组后边还有一个空格） | |
| \A | 匹配输入字符串的开始位置 |
| \Z | 匹配输入字符串的结束位置 |
| \b | 匹配一个单词边界，单词被定义为 Unidcode 的字母数字或下横线字符 |
| 举个栗子：\bFishC\b 会匹配字符串 "love FishC"、FishC." 或 "(FishC)" | |
| \B | 匹配非单词边界，其实就是与 \b 相反 |
| 举个栗子：py\B 会匹配字符串 "python"、"py3" 或 "py2"，但不会匹配 "py "、"py." 或 "py!" | |
| \d | 1. 对于 Unicode（str 类型）模式：匹配任何一个数字，包括 [0-9] 和其他数字字符；如果开启了 re.ASCII 标志，就只匹配 [0-9] |
| 2. 对于 8 位（bytes 类型）模式：匹配 [0-9] 中任何一个数字 | |
| \D | 匹配任何非 Unicode 的数字，其实就是与 \d 相反；如果开启了 re.ASCII 标志，则相当于匹配 [^0-9] |
| \s | 1. 对于 Unicode（str 类型）模式：匹配 Unicode 中的空白字符（包括 [ \t\n\r\f\v] 以及其他空白字符）；如果开启了 re.ASCII 标志，就只匹配 [ \t\n\r\f\v] |
| 2. 对于 8 位（bytes 类型）模式：匹配 ASCII 中定义的空白字符，即 [ \t\n\r\f\v] | |
| \S | 匹配任何非 Unicode 中的空白字符，其实就是与 \s 相反；如果开启了 re.ASCII 标志，则相当于匹配 [^ \t\n\r\f\v] |
| \w | 1. 对于 Unicode（str 类型）模式：匹配任何 Unicode 的单词字符，基本上所有语言的字符都可以匹配，当然也包括数字和下横线；如果开启了 re.ASCII 标志，就只匹配 [a-zA-Z0-9_] |
| 2. 对于 8 位（bytes 类型）模式：匹配 ASCII 中定义的字母数字，即 [a-zA-Z0-9_] | |
| \W | 匹配任何非 Unicode 的单词字符，其实就是与 \w 相反；如果开启了 re.ASCII 标志，则相当于 [^a-zA-Z0-9_] |
| 转义符号 | 正则表达式还支持大部分 Python 字符串的转义符号：\a，\b，\f，\n，\r，\t，\u，\U，\v，\x，\\ |
| 注1：\b 通常用于匹配一个单词边界，只有在字符类中才表示“退格” | |
| 注2：\u 和 \U 只有在 Unicode 模式下才会被识别 | |
| 注3：八进制转义（\数字）是有限制的，如果第一个数字是 0，或者如果有 3 个八进制数字，那么就被认为是八进制数；其他情况则被认为是子组引用；至于字符串，八进制转义总是最多只能是 3 个数字的长度 |
参考资料：
