python常用模块

Posted 2020-10-19 nathaniel-j

模块 , 将常用的代码封装起来重复使用到其它程序，或提供给第三方使用，或用作开发大型软件项目中的某个部分，然后在软件项目的封装阶段将所有这些模块组织编译成为一个完整程序。模块就像一个已经编译好的程序，如果你需要可以直接带到你的程序里来使用.

假设你正开发一个软件,其中某个功能在很多地方都会用到,你可能会考虑写一个函数.如果这样的功能有很多,你可能会专门用一个文件存放这些函数,呐,这个文件就是一个简单的模块了

要使用模块,首先得导入模块

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename
from module.xx.xx import *

相当于告诉Python解释器需要解释那个py文件

导入一个py文件，解释器就解释该py文件 , 导入一个包，解释器就解释该包下的 __init__.py 文件

time && datetime

import time
# UTC（Coordinated Universal Time,世界协调时）即格林威治天文时间,世界标准时间.中国为UTC+8,DST（Daylight Saving Time）即夏令时
print((time.time())) # 从1970年1月1日00:00:00(Unix诞生时间)开始按秒计算的偏移量,距离今天一共过去了多少秒
time.sleep(0.5) # 线程推迟0.5秒运行
print(time.clock()) # 计算CPU工作的时间
print(time.localtime()) # 将一个时间戳转换为当前时区的struct_time形式,不填参数默认本地时间(年月日时分秒周几一年的第几天是否夏令时)
print(time.gmtime()) # 将一个时间戳转换为UTC时区（0时区）的struct_time,不填参数默认当前UTC时间
print(time.mktime(time.localtime())) # 将一个struct_time转换为时间戳
print(time.asctime()) # 特定格式的本地时间Tue Nov 28 16:45:41 2017
print(time.ctime()) # 将时间戳转换为特点格式,未填写参数以本地时间为准
print(time.strftime(‘%Y年%m月%d日%A %X‘,time.localtime())) # 将一个代表时间的struct_time格式化返回
print(time.strptime(‘2017年11月28日 16:52:54‘,‘%Y年%m月%d日 %H:%M:%S‘)) # strftime的逆向操作,将一个格式化的时间转换为struct_time格式(需指定格式)

import datetime
print(datetime.datetime.now()) # 打印本地时间

%a	Locale’s abbreviated weekday name.
%A	Locale’s full weekday name.
%b	Locale’s abbreviated month name.
%B	Locale’s full month name.
%c	Locale’s appropriate date and time representation.
%d	Day of the month as a decimal number [01,31].
%H	Hour (24-hour clock) as a decimal number [00,23].
%I	Hour (12-hour clock) as a decimal number [01,12].
%j	Day of the year as a decimal number [001,366].
%m	Month as a decimal number [01,12].
%M	Minute as a decimal number [00,59].
%p	Locale’s equivalent of either AM or PM.	(1)
%S	Second as a decimal number [00,61].	(2)
%U	Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0.	(3)
%w	Weekday as a decimal number [0(Sunday),6].
%W	Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0.	(3)
%x	Locale’s appropriate date representation.
%X	Locale’s appropriate time representation.
%y	Year without century as a decimal number [00,99].
%Y	Year with century as a decimal number.
%z	Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59].
%Z	Time zone name (no characters if no time zone exists).
%%	A literal ‘%‘ character.

random

import random
print(random.random())  # 0到1之间的随机数
print(random.randint(1,2)) # 闭区间内的随机整数
print(random.randrange(5)) # 相当于range()
checkcode = ‘‘
for i in range(4): # 生成随机验证码
    if random.randint(1,2) == 1:
        checkcode = ‘‘.join((checkcode,chr(random.randint(65,90))))
    else:
        checkcode = ‘‘.join((checkcode,str(random.randint(0,9))))
print(checkcode)

OS

import os  # 提供对操作系统进行调用的接口
print(os.getcwd()) # 获取当前工作目录
os.chdir(‘/Users/nathaniel/PycharmProjects/hellobiketest/test‘) # 相当于shell下的cd
print(os.curdir) # .
print(os.pardir) # ..
os.mkdir(‘./day1/test‘) # 创建单个文件夹
os.makedirs(‘./day1/test/test1/test2‘) # 递归创建文件夹
os.removedirs(‘./day1/test/test1/test2‘) # 递归删除空文件夹,依次回到上一级,若不为空则停止,最后一级不为空报错
print(os.listdir(‘./‘)) # 列表展示当前路径下的文件名
os.remove() # 删除一个文件,只能删除文件
os.rename(‘old_path‘,‘new_path‘) # 重命名文件夹/文件
print(os.stat(‘./day1‘)) # 获取文件/目录信息
print(os.stat(‘./day1‘).st_size) # 获取文件/目录信息
print(os.sep) # 获取当前系统环境的路径分隔符,Windows返回\,mac和Linux返回/
print(os.linesep) # 输出当前系统换行符,Windows下‘\r\n‘,mac下‘\r‘,Linux下‘\n‘
print(os.pathsep) # 输出用于分隔文件路径的字符串,比方环境变量path里边的诸多路径如何分隔,Linux和mac返回:Windows返回;
print(os.name) # 输出字符串指示当前使用平台,mac和Linux为posix,Windows为nt
os.system(‘ls‘) # 相当于在终端执行ls
print(os.environ) # 输出环境变量
print(os.path.abspath(‘./‘)) # 返回相对路径的绝对路径
print(os.path.split(‘/Users/nathaniel/PycharmProjects/hellobiketest/test/day1/some_module.py‘)) # 将文件所在目录及文件名依次放入一个元组
print(os.path.dirname(‘/Users/nathaniel/PycharmProjects/hellobiketest/test/day1/some_module.py‘)) # 返回上层目录
print(os.path.basename(‘/Users/nathaniel/PycharmProjects/hellobiketest/test/day1‘)) # 返回当前目录,以/结尾返回空值
print(os.path.exists(‘/Users/nathaniel/PycharmProjects/hellobiketest/test/day1/some_module.py‘)) # 判断路径是否存在-->True
print(os.path.isabs(‘./‘)) # 判断是否为绝对路径-->False
print(os.path.isdir(‘/Users/nathaniel/PycharmProjects/hellobiketest/test/day1/some_module.py‘)) # 判断目录是否存在-->False
print(os.path.join(‘path1‘,‘path2‘,‘paths‘)) # 路径依次拼接
print(os.path.getatime(‘/Users/nathaniel/PycharmProjects/hellobiketest/test/day1/some_module.py‘)) # 返回文件的最后存取时间戳
print(os.path.getctime(‘/Users/nathaniel/PycharmProjects/hellobiketest/test/day1/some_module.py‘)) # 返回文件的最后修改时间戳

sys

import sys
# sys.exit() # 退出程序
print(sys.path) # 返回模块搜索路径,初始化时使用PYTHONPATH环境变量的值,可以用 sys.path.append() 添加寻找模块的路径
print(sys.platform) # 返回操作系统平台的名称
import os
if sys.platform == ‘win32‘:
    os.system(‘dir‘)
elif sys.platform == ‘darwin‘:
    os.system(‘ls ../‘)

hashlib

import hashlib # 通过一系列算法加密明文
m = hashlib.md5() # 新建一个对象,包含加密算法
print(m)
m.update(‘hello world‘.encode(‘utf-8‘)) # 将需要加密的明文添加进去
a = m.hexdigest() # 以十六进制返回
print(a)
m.update(‘2‘.encode(‘utf-8‘)) # 追加明文到算法里边>>>相当于对   ‘hello world2‘   进行加密
print(m.hexdigest()) # 用方法从算法中取出加密后的内容


m2 = hashlib.sha256()  # 更复杂的算法,也更消耗CPU(常用)
m2.update(‘hello world‘.encode(‘utf-8‘))
a = m2.hexdigest()
print(a)

# 以上加密算法虽然厉害，但也存在缺陷，即：通过撞库可以反解。所以，我们可以在加密算法中添加自定义key,这样,对方想装库的话,首先还得知道你的key
m3 = hashlib.sha256(‘78ja8la0a‘.encode(‘utf-8‘))
m3.update(‘hello world‘.encode(‘utf-8‘))
a = m3.hexdigest()
print(a)

logging

import logging

logging.basicConfig(level=logging.INFO, # 设置日志级别
                    format=‘%(asctime)s   %(filename)s [line:%(lineno)d] %(levelname)s :%(message)s‘, # 指定日志显示格式
                            # 时间        产生日志的文件名  产生日志的行号               日志级别     日志内容
                    datefmt=‘%Y-%m-%d %H:%M:%S‘, # 指定日期时间格式
                    filename=‘./test.log‘, # 指定日志文件路径
                    filemode=‘a‘) # 文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”

logging.debug(‘debug message123‘)
logging.info(‘info message123‘)
logging.warning(‘warning message123‘)
logging.error(‘error message123‘)
logging.critical(‘critical message123‘)


logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler(‘test.log‘)

# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()

# 制定一个输出格式,相当于  basicConfig 中的  format
formatter = logging.Formatter(‘%(asctime)s  %(name)s  %(levelname)s : %(message)s‘)

# 传入输出格式
fh.setFormatter(formatter)
ch.setFormatter(formatter)

# 往logger中添加输出方式
logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
logger.addHandler(ch)

# 使用logger 调用日志方法
logger.debug(‘logger debug message‘)
logger.info(‘logger info message‘)
logger.warning(‘logger warning message‘)
logger.error(‘logger error message‘)
logger.critical(‘logger critical message‘)

 

configparser

import configparser
config = configparser.ConfigParser()

# 写配置文件   可以试着当成一个字典来写
config[‘DEFAULT‘] = {
    ‘name‘:‘nathaniel‘,
    ‘server‘:‘something‘,
    ‘other‘:‘anything‘
}

config[‘db‘] = {
    ‘db_host‘:‘127.0.0.1‘,
    ‘db_port‘:‘22‘,
    ‘db_user‘:‘root‘,
    ‘db_pass‘:‘rootroot‘
}


config[‘concurrent‘] = {
    ‘thread‘:‘10‘,
    ‘processor‘:‘20‘
}

config[‘concurrent‘][‘Host Port‘] = ‘50022‘


with open(‘test.ini‘,‘w‘,encoding=‘utf-8‘) as f:
    config.write(f)

# 读取配置文件
config.read(‘./test.ini‘) # 什么时候需要指定读取哪个配置文件呢?根据对象判断
print(config.sections())
print(config.defaults())


# 判断section是否在config中
print(‘concurrent‘ in config)


# 读某个section中的具体某个值
print(config[‘db‘][‘db_host‘])


for key in config:print(key)
print()
for key in config[‘db‘]:print(key)


# 删
config.remove_section(‘concurrent‘)
config.remove_option(‘db‘,‘db_pass‘)

# 改
config.set(‘db‘,‘db_port‘,‘23‘)

# 文件在硬盘中的存储机制决定了,改,并不能真正的改,只能生成一个新的对象去覆盖
with open(‘test.ini‘,‘w‘,encoding=‘utf-8‘) as f:
    config.write(f)

 

正则表达式

正则表达式,又称规则表达式,常被用来检索、替换那些符合某个模式(规则)的文本.

正则表达式是对字符串（包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”））操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。正则表达式是一种文本模式，模式描述在搜索文本时要匹配的一个或多个字符串

给定一个正则表达式和另一个字符串，我们可以达到如下的目的：

1. 给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）；

2. 可以通过正则表达式，从字符串中获取我们想要的特定部分。

正则表达式的特点是：

1. 灵活性、逻辑性和功能性非常强；

2. 可以迅速地用极简单的方式达到字符串的复杂控制。

3. 对于刚接触的人来说，比较晦涩难懂。

由于正则表达式主要应用对象是文本，因此它在各种文本编辑器场合都有应用，小到著名编辑器EditPlus，大到Microsoft Word、Visual Studio等大型编辑器，都可以使用正则表达式来处理文本内容

 

正则表达式的方法

# re.findall()  所有结果都返回到一个列表里
print(re.findall(‘a‘,‘nathaniel‘))
# re.split()    以匹配到的字符当做列表分隔符
print(re.split(‘a‘,‘nathaniel‘))
# search()      返回一个对象,使用group方法将结果取出来,只匹配第一个即只匹配一次
print(re.search(‘a‘,‘nathaniel‘).group())
# re.match()    从头开始匹配,返回一个对象,使用group方法将结果取出来,只匹配第一个即只匹配一次
print(re.match(‘n‘,‘nathaniel‘).group())
# re.sub()      匹配字符并替换
print(re.sub(‘world‘,‘python‘,‘hello world‘))
# re.compile()  封装一个规则到一个对象里
obj = re.compile(‘abc‘)
print(obj.search(‘abc.abc‘).group())

元字符

正则表达式由一些由一些普通字符和一些元字符组成,普通字符包括大小写的字母和数字，而元字符则具有特殊的含义

以下进行一些简单描述和举例

# .     通配符,匹配\r\n之外的任意字符
print(re.findall(‘hell.,world..‘,‘gds3hello,world\r\n3sdf2f99dhw0hs2hell‘))
print(re.findall(‘....‘,‘\t\vworld3sdf2f99dhw0hs2hell0a8‘))

# ^     匹配行首,即匹配的是一个位置
print(re.findall(‘^na‘,‘na.na.na.na‘))
print(re.findall(‘^na.‘,‘nat.na.na.na‘))

# $     匹配行尾,即匹配的是一个位置
print(re.findall(‘el$‘,‘el.el.el.el.el.el‘))
print(re.findall(‘elt$‘,‘el.el.el.el.el.4elt‘))

# *     匹配前面的子表达式任意次,可以是0次也可以是无穷次
print(re.findall(‘na*123‘,‘naaaaaaaaaaa123‘))
print(re.findall(‘na*123‘,‘n123‘))

# +     匹配前面的子表达式一次或多次,最少一次
print(re.findall(‘na+123‘,‘naaaaaaaaaaa123‘))
print(re.findall(‘na+‘,‘n123‘))

# ?     匹配前面的子表达式零次或一次,要么0次要么一次
print(re.findall(‘ab?‘,‘abc.a.ac‘))
print(re.findall(‘a?‘,‘abc.a.a‘))

# {n}   n是一个非负整数,匹配前面的子表达式n次
print(re.findall(‘a{2}‘,‘aaa2bc2daa‘))
print(re.findall(‘a{5}‘,‘aaaaaa2bc2daa‘))

# {n,}  n是一个非负整数,至少匹配n次
print(re.findall(‘a{2,}‘,‘aaa2bc2daa‘)) # 匹配前面的子表达式2到8次(取最大值
print(re.findall(‘a{3,}‘,‘aaa2bc2daa‘)) # 匹配前面的子表达式2到8次(取最大值

# {n,m} m和n均为非负整数,其中n<=m,最少匹配n次且最多匹配m次
print(re.findall(‘a{2,8}‘,‘aa3aaaaaaaaaaaaaa‘))
print(re.findall(‘a{8,9}‘,‘aa3aaaaaaaaaaaaaa‘))

# []    字符集,匹配所包含的任意一个字符
print(re.findall(‘[abc]‘,‘ab9c6‘))
print(re.findall(‘[^abc]‘,‘a98#9c6‘)) # 表示取反,即除a,b,c之外的全部可以匹配

# ()    将( 和 ) 之间的表达式定义为“组”（group），并且将匹配这个表达式的字符保存到一个临时区域（一个正则表达式中最多可以保存9个），它们可以用 \1 到\9 的符号来引用
print(re.findall("(a)", "aaaaaac"))
print(re.findall("(ac)", "aaaaaac"))

# |     将两个匹配条件进行逻辑“或”（or）运算。例如正则表达式(him|her) 匹配"it belongs to him"和"it belongs to her"，但是不能匹配"it belongs to them."。注意：这个元字符不是所有的软件都支持的
print(re.findall(‘a|c‘,‘ab‘))
print(re.findall(‘a|c‘,‘bc‘))

# \  反斜杠,将下一个字符标记符、或一个向后引用、或一个八进制转义符。例如，“\\n”匹配\n。“\n”匹配换行符。“\\”匹配“\”而“\(”则匹配“(”。即相当于多种编程语言中都有的“转义字符”的概念
# \  具有两个功能:
#       1.可以使部分普通字符具有特殊意义
#       2.可以使元字符失去特殊功能

# \d 匹配任意十进制数;相当于类 [0-9]
print(re.findall(‘\d\das‘,‘123as‘))
print(re.findall(‘2\das‘,‘123as‘))

# \D 匹配任意非数字字符;相当于类 [^0-9]
print(re.findall(‘\D\Das‘,‘123f,as‘))
print(re.findall(‘2\D\Das‘,‘12]]as‘))

# \s 匹配不可见字符,包括空格、制表符、换页符等等,相当于类[\t\n\r\f\v]
print(re.findall(‘hello\sworld‘,‘hello world‘))
print(re.findall(‘hello\sworld‘,‘‘‘hello
world‘‘‘))

# \S 匹配任意非空白字符,相当于类 [^\t\n\r\f\v]
print(re.findall(‘\S\S\S\S\S‘,‘hello world‘))
print(re.findall(‘\S\S\S\S\S‘,‘hello\nworld‘))

# \w 匹配包括下划线的任何单词字符,等价于[A-Za-z0-9_]，这里的"单词"字符使用Unicode字符集
print(re.findall(‘\w\was\w‘,‘asas_a_‘))
print(re.findall(‘\w\was\w‘,‘CA_as0‘))

# \W 匹配任意非字母数字字符,相当于类 [^a-z0-9A-Z]
print(re.findall(‘\W\Was\W‘,‘#%as]‘))
print(re.findall(‘\W\Was\W‘,‘^-as%‘))

# \b 匹配一个单词边界,也就是指单词和空格间的位置（正则表达式的“匹配”有两种概念,一种是匹配字符,一种是匹配位置
print(re.findall(r‘hello\b‘,‘hello world‘))
print(re.findall(‘hello\\b‘,‘hello,hellox,hello$d‘))

# \元字符,使其失去特殊功能
print(re.findall(‘a\.\^s{2}‘,‘a.^sss‘))
print(re.findall(‘a\.‘,‘.aaa‘))

# 来点刺激的,多个反斜杠
print(re.findall(r‘\\\\d‘,‘abc\\\\de‘))
a = [‘\q‘]
print(a)

反斜杠的困扰

与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观

元字符	描述
\	将下一个字符标记符、或一个向后引用、或一个八进制转义符。例如，“\\n”匹配\n。“\n”匹配换行符。序列“\\”匹配“\”而“\(”则匹配“(”。即相当于多种编程语言中都有的“转义字符”的概念。
^	匹配输入字行首。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。
$	匹配输入行尾。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。
*	匹配前面的子表达式任意次。例如，zo*能匹配“z”，也能匹配“zo”以及“zoo”。*等价于o{0,}
+	匹配前面的子表达式一次或多次(大于等于1次）。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。
?	匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“do”或“does”中的“do”。?等价于{0,1}。
{n}	n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。
{n,}	n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。
{n,m}	m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o为一组，后三个o为一组。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“oooo”，“o+”将尽可能多的匹配“o”，得到结果[“oooo”]，而“o+?”将尽可能少的匹配“o”，得到结果 [‘o‘, ‘o‘, ‘o‘, ‘o‘]
.点	匹配除“\r\n”之外的任何单个字符。要匹配包括“\r\n”在内的任何字符，请使用像“[\s\S]”的模式。
(pattern)	匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“\(”或“\)”。
(?:pattern)	非获取匹配，匹配pattern但不获取匹配结果，不进行存储供以后使用。这在使用或字符“(|)”来组合一个模式的各个部分时很有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式。
(?=pattern)	非获取匹配，正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	非获取匹配，正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。
(?<=pattern)	非获取匹配，反向肯定预查，与正向肯定预查类似，只是方向相反。例如，“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”，但不能匹配“3.1Windows”中的“Windows”。
(?<!pattern)	非获取匹配，反向否定预查，与正向否定预查类似，只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”，但不能匹配“2000Windows”中的“Windows”。这个地方不正确，有问题 此处用或任意一项都不能超过2位，如“(?<!95|98|NT|20)Windows正确，“(?<!95|980|NT|20)Windows 报错，若是单独使用则无限制，如(?<!2000)Windows 正确匹配
x|y	匹配x或y。例如，“z|food”能匹配“z”或“food”(此处请谨慎)。“[zf]ood”则匹配“zood”或“food”。
[xyz]	字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“plin”。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。 注意:只有连字符在字符组内部时,并且出现在两个字符之间时,才能表示字符的范围; 如果出字符组的开头,则只能表示连字符本身.
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置（即正则表达式的“匹配”有两种概念，一种是匹配字符，一种是匹配位置，这里的\b就是匹配位置的）。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。
\B	匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。
\cx	匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。
\d	匹配一个数字字符。等价于[0-9]。grep 要加上-P，perl正则支持
\D	匹配一个非数字字符。等价于[^0-9]。grep要加上-P，perl正则支持
\f	匹配一个换页符。等价于\x0c和\cL。
\n	匹配一个换行符。等价于\x0a和\cJ。
\r	匹配一个回车符。等价于\x0d和\cM。
\s	匹配任何不可见字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
\S	匹配任何可见字符。等价于[^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于\x09和\cI。
\v	匹配一个垂直制表符。等价于\x0b和\cK。
\w	匹配包括下划线的任何单词字符。类似但不等价于“[A-Za-z0-9_]”，这里的"单词"字符使用Unicode字符集。
\W	匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
\xn	匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“\x41”匹配“A”。“\x041”则等价于“\x04&1”。正则表达式中可以使用ASCII编码。
\num	匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)\1”匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字（0-7），则n为一个八进制转义值。
\nm	标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式，则nm为向后引用。如果\nm之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字（0-7），则\nm将匹配八进制转义值nm。
\nml	如果n为八进制数字（0-7），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。
\un	匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9匹配版权符号（&copy;）。
\p{P}	小写 p 是 property 的意思，表示 Unicode 属性，用于 Unicode 正表达式的前缀。中括号内的“P”表示Unicode 字符集七个字符属性之一：标点字符。 其他六个属性： L：字母； M：标记符号（一般不会单独出现）； Z：分隔符（比如空格、换行等）； S：符号（比如数学符号、货币符号等）； N：数字（比如阿拉伯数字、罗马数字等）； C：其他字符。 *注：此语法部分语言不支持，例：javascript。
\< \>	匹配词（word）的开始（\<）和结束（\>）。例如正则表达式\<the\>能够匹配字符串"for the wise"中的"the"，但是不能匹配字符串"otherwise"中的"the"。注意：这个元字符不是所有的软件都支持的。
( )	将( 和 ) 之间的表达式定义为“组”（group），并且将匹配这个表达式的字符保存到一个临时区域（一个正则表达式中最多可以保存9个），它们可以用 \1 到\9 的符号来引用。
|	将两个匹配条件进行逻辑“或”（Or）运算。例如正则表达式(him|her) 匹配"it belongs to him"和"it belongs to her"，但是不能匹配"it belongs to them."。注意：这个元字符不是所有的软件都支持的。

 

速记理解技巧

.

[ ]

^

$

四个字符是所有语言都支持的正则表达式，所以这四个是基础的正则表达式。正则难理解因为里面有一个等价的概念，这个概念大大增加了理解难度，让很多初学者看起来会懵，如果把等价都恢复成原始写法，自己书写正则就超级简单了，就像说话一样去写你的正则了：

　　等价：

等价是等同于的意思，表示同样的功能，用不同符号来书写。

?,*,+,\d,\w 都是等价字符
　　?等价于匹配长度{0,1}
　　*等价于匹配长度{0,} 
　　+等价于匹配长度{1,}
　　\d等价于[0-9]

\D等价于[^0-9]
　　\w等价于[A-Za-z_0-9]

\W等价于[^A-Za-z_0-9]。

常用运算符与表达式：
　　^ 开始
　　（） 域段
　　[] 包含,默认是一个字符长度
　　[^] 不包含,默认是一个字符长度
　　{n,m} 匹配长度 
　　. 任何单个字符(\. 字符点)
　　| 或
　　\ 转义
　　$ 结尾
　　[A-Z] 26个大写字母
　　[a-z] 26个小写字母
　　[0-9] 0至9数字

[A-Za-z0-9] 26个大写字母、26个小写字母和0至9数字
　　， 分割
　　.
　　
　　分割语法：
　　[A,H,T,W] 包含A或H或T或W字母
　　[a,h,t,w] 包含a或h或t或w字母
　　[0,3,6,8] 包含0或3或6或8数字

　　语法与释义：
　　基础语法 "^([]{})([]{})([]{})$"
　　正则字符串 = "开始（[包含内容]{长度}）（[包含内容]{长度}）（[包含内容]{长度}）结束" 
　　
　　?,*,+,\d,\w 这些都是简写的,完全可以用[]和{}代替，在(?:)(?=)(?!)(?<=)(?<!)(?i)(*?)(+?)这种特殊组合情况下除外。
　　初学者可以忽略?,*,+,\d,\w一些简写标示符，学会了基础使用再按表自己去等价替换

　　
　　实例：
　　字符串；tel:[phone]
　　原始正则："^tel:[0-9]{1,3}-[0][0-9]{2,3}-[0-9]{8,11}$" 
　　速记理解：开始 "tel:普通文本"[0-9数字]{1至3位}"-普通文本"[0数字][0-9数字]{2至3位}"-普通文本"[0-9数字]{8至11位} 结束"
　　等价简写后正则写法："^tel:\d{1,3}-[0]\d{2,3}-\d{8,11}$" ，简写语法不是所有语言都支持。