函数编程思维导图模板_ProcessOn思维导图、流程图

函数、装饰器、迭代器、内置方法

三元运算

语法

val = 1 if 条件成立 else 2

为真时的结果 if 判定条件 else 为假时的结果

特点

优点

节省代码量，可以装X

缺点

代码不易读，不易后期修改

文件处理

基本语法

f = open(file = 'E:/文件夹名字/filename.txt',mode = 'r', encoding = 'utf-8')

----file 参数可以不写，默认就会在第一个参数里写文件名，不用绝对路径就是相对路径

----mode 模式就是需要用什么方式去读取文件，就像mode = 'r'就是只读模式

----encoding 就是用什么编码模式去操作，在内存里保存的编码方式

f.close()

关闭当前的文件

智能检测编码

第三方库：chardet

f = open('filename',mode = 'rb')

以二进制的形式读取需要分析的文件

result = chardet.detect(open('log',mode = 'rb').read())

这个chardet的第三方库就会返回分析的结果

【r 只读模式】(默认模式，文件必须存在，不存在就报错)

读取文件原编码格式

f = open("filename", mode = "r", encoding = "utf-8")

f.read()

f.close()

读取文件二进制编码

f = open("filename", mode = "rb")

f.read()

f.close()

循环读取(边读边处理)

f = open ("filename","r",encoding = "utf-8")

for line in f:#只读一行

print(line)

【w 只写模式】(不可读，不存在就创建，存在就覆盖)

写文件原编码格式

f = open("filename", mode = "w", encoding = "utf-8")

f.write("something")

f.close()

读取文件二进制编码

f = open("filename", mode = "wb")

f.write("something")

f.close()

注意

写模式永远是创建一个新文件，如果之前有相同的文件名，就会对这个文件进行覆盖！清空内容后再写

写模式一定要检测是否有重复的文件

【a 追加模式】(可读，不存在就创建，存在就只在光标处追加内容)

f = open("filename", mode = "a", encoding = "utf-8")

混合模式

【r+ 读写模式】(先读后写)

【w+ 写读模式】(先创建后读)

【a+ 读写模式】(先读后写)

其他功能

【常用方法】

fileno()

返回文件句柄在内核中的索引值，以后做IO多路复用时可以用到（网络编程模块使用）

flush()

把文件从内存buffer（缓存）里强制刷新到硬盘

readable()

判断文件是否可读（Linux上一切皆文件，用来判断文件是否是正常的文件，一般用不到，mode = “w”就是不可读的）

realine()

只读一行，遇到\r or \n为止

seek()

把操作文件的光标移到指定位置，seek取到的光标位置是根据文件的字节去找，read才是按文件的字符取读取

seekable()

判断文件是否可进行seek操作，二进制文件都可以seek，Linux上有的特殊文件就是不能seek的

tell()

返回当前文件操作的光标位置

truncate()

按指定长度截断文件，从当前位置开始截断，既可以截断部分，也可以指定长度的话，就从文件开头开始截断指定长度，不指定长度的话，就从当前位置到文件尾部的内容全部去掉

writeable()

判断文件是否可写

【不常用方法】

isatty()

如果文件连接到一个终端设备返回 True，否则返回 False。

【修改】（本质就是覆盖原文件）

方法

使用seek方法，让光标移动到文件的中间部分，就可以再之后再增加(seek+write)

缺点

覆盖文件的原数据，是不能往后移动的

函数

函数基础

函数的定义

函数是指将一组语句的集合通过一个名字（函数名）封装起来，要想执行这个函数，只需要调用函数名就可以了

函数的特性

提取重复代码，封装称为一个函数，一次编写，多次调用

1.减少重复代码

2.使程序变的可拓展

3.使程序变的易于维护

【注意】：函数名不要大写，函数名小写就可以

参数的分类

参数是否确定

形参

只有在被调用的时候才分配内存单元，在调用结束后，就即刻释放所分配的内存单元，因此，形参只在函数内部有效，函数调用结束返回的主调用函数后则不能再使用形参变量

实参

可以是常量，变量，表达式，函数等，无论是何种类型的量，在进行函数的调用时，它们都必须要有确定的值，以便于把这些值传送给形参，因此应预先用赋值，输入等办法使参数获得确定值

参数的类型

位置参数

调用函数时根据函数定义的参数位置来传递参数

默认参数

默认参数可以为了程序在编写的时候少写些代码

可变参数

*args是可变参数，args接收的是一个tuple

关键字参数

指定了参数名的参数就是关键参数

**kwargs允许传入字典的形式

组合参数

以上参数是可以组合传入函数中，但是一定要函数传参数的执行顺序

位置参数>默认参数>可变参数>关键字参数

变量的分类

局部变量

局部变量的定义：在函数内部定义的变量就是局部变量

局部变量会在函数自己执行完以后就消失

全局变量

全局变量：定义在函数外部的一级代码，全局都能调用

函数的返回值(return)

根据整改函数的运行结果产生一个结果，然后返回给函数

函数外部的代码要想获取函数的执行结果，就可以在函数里用return语句把结果返回

作用域

作用域的概念

一个函数就是一个作用域

作用域的执行顺序

所有的局部变量其实是放置在其中的作用域里的
对于作用域，定义完成后已经生成，以后再调用的时候就会根据函数的作用关系一层一层的层级关系查找（作用域链向上查找）

匿名函数(lambda)

匿名函数还可以用来判断，最多只能支持三元运算，lambda函数是不支持复杂的逻辑判断的

作用

1.节省代码量

2.使用起来简单高级

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称为高阶函数
如果一个函数可以接收另一个函数，这个函数就称为高阶函数

特性

1.接收一个或多个函数作为输入

2.return返回另外一个函数

函数的递归

递归的定义

递归就是在函数的过程中调用自己

递归调用就是不断的在函数自己里再执行，一直不结束，直到把内存撑爆了，所以需要有限制机制，于是python内部就加上了函数的限制

作用场景

可以用来解决复杂的数学问题，比如斐波那契数列等

递归的特性

1.必须有一个明确的结束条件，要不就会变成死循环了，最终撑爆系统

2.每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3.递归执行效率不高，递归层次过多会导致栈溢出

尾递归优化

目的

不再对栈有多余的占用

方法

尾递归就是在函数执行的时候直接用return调用，第一层调用第二层函数的时候，使用return直接结束第一层函数的执行，就是层层之间互相不再有对应的关系
也就是说当没有必要保留每一层的数据的时候，就可以直接用return调用下一层的函数，不再对栈有多余的占用

函数的内置方法

abs()>>取绝对值函数返回数字的绝对值

dict()>>把一个数据转换成字典

help()>>查看帮助

min()>>方法返回给定参数的最小值，参数可以为序列

max()>>方法返回给定参数的最大值，参数可以为序列

setattr()>>【面向对象详细讲】函数对应函数 getatt()，用于设置属性值，该属性必须存在

all()>>函数用于判断给定的可迭代参数（元祖或列表） iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、FALSE 外都算 TRUE

any()>>any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True

bool()>>判断输入的值是不是True

dir()>>打印当前文件存在的所有变量，包括你自定义的和python解释器自带的

hex()>>十六进制，将一个数字转换为十六进制的表达方式

slice()>>切片

divmod()>>求整除和余数，先得到结果再返回余数

id()>>返回传入的内存地址

sorted()>>排序，可以对字典的value排序，用在列表里的排序，sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作

ascii()>>返回一个可打印的对象字符串方式表示

enumerate() >>枚举法用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

input()>>用户交互输入

oct()>>将输入的数字转换为八进制

staticmethod()>>返回函数的静态方法【以后会讲】

bin()>>转换为二进制

eval() >>函数用来执行一个字符串表达式,并返回表达式的值，将字符串解析成代码（只能处理单行的代码）

exec()>>和eval功能相同，而且能执行多行代码，exec是没有返回值的

int()>>将数字转换为整数，不能转换的就报错

open()>>打开文件

str()>>将数字或字符转换为字符串形式

isintance()>>【面向对象】

ord()>>通过字符串返回在ascii表中的位置

chr()>>通过ascii表中的位置返回字符串对应值

sum()>>求和

bytearray()>>返回一个新字节数组,这个数组里的元素是可变的(原内存地址修改，不是重开辟内存空间)

map()>>根据提供的函数对指定序列做映射，可以用来求列表内的元素自乘(配合lambda函数)list(map(lambda x:x+3,[1,2,3,4,5]))

filter()>>过滤，找到符合条件的值--list(filter(lambda x:x>3,[1,2,3,4,5]))

pow()>>返回输入的数字的幂级数

super()>>【面向对象讲】

bytes()>>返回输入的二进制数

float()>>浮点数

iter()>>生成迭代器

print()>>print(*objects, sep=' ', end='\n', file=sys.stdout)

objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。

sep -- 用来间隔多个对象，默认值是一个空格。

end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。

file -- 要写入的文件对象

tuple()>>转换为元祖

callable()>>判断一个东西是否可调用，可以判断变量是否是函数

len()>>判断字符串的长度

property()>>【面向对象】

type()>>判断参数的数据类型

frozenset()>>返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

vars()>>打印当前所有的变量

locals()>>在函数的内部执行，打印当前函数的所有的局部变量

globals()>>无论在函数内部还是外部都打印全局的变量

zip()>>函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表，只能是一一对应的关系

函数进阶

命名空间

1.locals:是函数内的名称空间，包括局部变量和形参

临时存活，局部有效

2.globals：全局变量，函数定义所在模块的名字空间

全局灵活，全局有效

3.builtins：内置模块的名字空间

作用域的查找空间

作用域的查找顺序

LEGB>>locals->enclosing function ->globals->__builtins__

1.locals:是函数内的名称空间，包括局部变量和形参

2.enclosing 外部嵌套函数的命名空间

3.globals：全局变量，函数定义所在模块的名字空间(打印所在脚本的所有变量)

4.builtins：内置模块的名字空间

闭包

特点

必须有一个内嵌函数

内嵌函数必须引用外部函数中的变量

外部函数的返回值必须是内嵌函数

意义

返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，在函数无论在何处调用，优先使用自己外层的

装饰器

引出

开放-封闭原则

已经实现功能的代码是不能被修改的，但是可以被扩展

固定格式

def wrapper(f): #装饰器函数，f是被装饰的函数

def inner(*args,**kwargs):

'''在被装饰函数之前要做的事'''

ret = f(*args,**kwargs) #被装饰的函数

'''在被装饰函数之后要做的事'''

return ret

return inner

生成器

创建方式

1.列表生成式（只能用三元运算符进行简单的运算）

2.自己编写带yield的函数，生成器可以把函数执行的每一个步骤都通过yield返回出去（yield可以理解为暂停）

列表内就是可以做为一个三元运算符的循环的，执行的结果就会放在列表的最外层

作用

1.1个for循环1行搞定，只能写在列表里

2.代码量少

1.1个for循环1行搞定，只能写在列表里

2.代码量少

特点

生成器只能往后生成，不能往前调用

案例

斐波那契数列

迭代器（Iterator）

概念

迭代器就是一个数据流，生成迭代器的时候不需要规定终止点，没有终止也不需要终止条件，这样的就表示为数据流。

小结

凡是可以作用for循环的对象都是Iterator类型；

生成器一定是迭代器，迭代器不一定是生成器（可以自己写对象）

生成器都是迭代器，都是列表、字典、字符串虽然都是迭代对象，但是都不是迭代器，因为不能使用next()方法，但是可以使用iter()函数将它们变成迭代器

随机数模块

random模块

random.randrange(1,10) #返回1-10之间的一个随机数，不包括10

random.randint(1,10) #返回1-10之间的一个随机数，包括10

random.random() #返回一个随机浮点数

random.choice('abce3#$@1') #返回一个给定数据集合中的随机字符

random.sample('abcdefghij',3) #从多个字符中选取特定数量的字符

序列化模块

序列化的概念

序列化是指把内存里的数据类型转变成字符串，以使其能存储到硬盘或通过网络传输到远程，因为硬盘或网络传输时只能接受bytes

json模块

用于字符串和 python数据类型间进行转换

dumps

将数据通过特殊的形式转换位所有程序语言都认识的字符串

dump

将数据通过特殊的形式转换位只有python语言认识的字符串，并写入文件

loads

load

pickle模块

用于python特有的类型和 python的数据类型间进行转换

dumps

将数据通过特殊的形式转换位只有python语言认识的字符串

dump

数据通过特殊的形式转换位只有python语言认识的字符串，并写入文件

loads

load

shelve模块

概念

持久化任何pickle可支持的python数据格式

序列化

反序列化

小结

JSON

优点

跨语言、体积小

缺点

只能支持int\str\list\tuple\dict

Pickle

优点

专为python设计，支持python所有的数据类型

缺点

只能在python中使用，存储数据占空间大

xml模块

遍历xml文档

for child in root:
print(child.tag, child.attrib)
for i in child:
print(i.tag,i.text)

遍历year 节点

for node in root.iter('year'):
print(node.tag,node.text)

修改

for node in root.iter('year'):
new_year = int(node.text) + 1
node.text = str(new_year)
node.set("updated","yes")

tree.write("xmltest.xml")

删除node

for country in root.findall('country'):
rank = int(country.find('rank').text)
if rank > 50:
root.remove(country)

tree.write('output.xml')

xml文档创建

import xml.etree.ElementTree as ET

new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'

et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)

ET.dump(new_xml) #打印生成的格式

配置文件类

configparser模块

config.options('group2') # 获取指定section的keys

config.items('group2') # 获取指定 section 的 keys & values ,key value 以元组的形式

onfig.get('group1','key') # 获取指定的key 的value

config.remove_section('group1') # 删除section 并返回状态(true, false)

日志模块

logging模块

日志的级别

DEBUG

INFO

WARNING

ERROR

CRITICAL

支持的参数格式

%(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

用户输出的消息

主要功能

logger提供了应用程序可以直接使用的接口；

handler将(logger创建的)日志记录发送到合适的目的输出；

filter提供了细度设备来决定输出哪条日志记录；

formatter决定日志记录的最终输出格式。

软件开发规范

项目文件组成

bin/: 存放项目的一些可执行文件，当然你可以起名script/之类的也行。

oo/: 存放项目的所有源代码

docs/: 存放一些文档。

setup.py: 安装、部署、打包的脚本。

requirements.txt: 存放软件依赖的外部Python包列表。

README: 项目说明文件。

LICENSE.txt,ChangeLog.txt文件等

模块的引出

概念

在Python中，一个.py文件就是一个模块(Moudle)

把各种功能写进文件里，把很多小文件模块互相调用

模块的分类

1.内置标准模块（又称为标准库）执行help（modules）查看所有python自带模块列表

2.第三方开源模块，可通过pip insatall 模块名联网安装

3.自定义模块

导入模块的方式

import moudle

from * import moudle

用在一个模块里比较多的时候，只希望用某一个功能

from * import moudle as name

为导入的模块取一个别名

from moudle import *

导入模块里的所有py文件，不需要再写前缀了，但是尽量不要使用

模块的安装方式

1.下载源码，通过setup.py build安装

2.pip命令可以安装和删除(install&uninstall)

包及跨模块导入

包的概念

一个规范的包（package）一定包含一个py文件__init__.py，初始化文件，python就会拿到这个文件当做包

时间类型模块

time模块

time.localtime([secs])：将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准

time.gmtime([secs])：和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区英国时间格式）的struct_time。

time.time()：返回当前时间的时间戳。

time.mktime(t)：将一个struct_time转化为时间戳。

time.sleep(secs)：线程推迟指定的时间运行。单位为秒。

time.asctime([t])：把一个表示时间的元组或者struct_time表示为这种形式：'Sun Oct 1 12:04:38 2017'。如果没有参数，将会将time.localtime()作为参数传入。

time.ctime([secs])：把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

time.strftime(format[, t])：把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。

time.strptime(string[, format])：把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。

datetime模块

datetime.date：表示日期的类。常用的属性有year, month, day；

datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond；

datetime.datetime：表示日期时间。

datetime.timedelta：表示时间间隔，即两个时间点之间的长度。

datetime.tzinfo：与时区有关的相关信息

时间运算(只支持days hours minutes seconds)

时间替换

replace(year=2999,month=11,day=30)

程序、操作系统交互类

os模块

os.getcwd()

得到当前工作目录，即当前Python脚本工作的目录路径

os.listdir()

os.remove()

函数用来删除一个文件

os.removedirs（r“c：\python”）

删除多个目录

os.path.isfile()

检验给出的路径是否是一个文件

os.path.isdir()

检验给出的路径是否是一个目录

os.path.isabs()

判断是否是绝对路径

os.path.exists()

检验给出的路径是否真地存在

os.path.split()

返回一个路径的目录名和文件名

os.path.splitext()

分离扩展名

os.path.dirname()

获取路径名

os.path.abspath()

获得绝对路径

os.path.basename()

获取文件名

os.system()

运行shell命令

os.getenv("HOME")

读取操作系统环境变量HOME的值

os.environ

返回操作系统所有的环境变量

os.environ.setdefault('HOME','/home/')

设置系统环境变量，仅程序运行时有效

os.linesep

给出当前平台使用的行终止符

os.name

指示你正在使用的平台

os.rename

重命名

os.makedirs

创建多级目录

os.mkdir

创建单个目录

os.stat（file）

获取文件属性

os.chmod（file）

修改文件权限与时间戳

os.path.getsize（filename）

获取文件大小

os.path.join(dir,filename)

结合目录名与文件名

os.chdir(dirname)

改变工作目录到dirname

os.get_terminal_size()

获取当前终端的大小

os.kill

杀死进程

sys模块

sys.argv 命令行参数List，第一个元素是程序本身路径

sys.exit(n) 退出程序，正常退出时exit(0)

sys.version 获取Python解释程序的版本信息

sys.maxint 最大的Int值

sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform 返回操作系统平台名称

sys.stdout.write('please:') #标准输出 , 引出进度条的例子，注，在py3上不行，可以用print代替

val = sys.stdin.readline()[:-1] #标准输入

sys.getrecursionlimit() #获取最大递归层数

sys.setrecursionlimit(1200) #设置最大递归层数

sys.getdefaultencoding() #获取解释器默认编码

sys.getfilesystemencoding #获取内存数据存到文件里的默认编码

shutil模块

shutil.copyfileobj(fsrc, fdst[, length])

将文件内容拷贝到另一个文件中

shutil.copyfile(src, dst)

拷贝文件，目标文件无需存在

shutil.copymode(src, dst)

仅拷贝权限。内容、组、用户均不变，目标文件必须存在

shutil.copystat(src, dst)

仅拷贝状态的信息，目标文件必须存在

shutil.copy(src, dst)

拷贝文件和权限

shutil.copy2(src, dst)

拷贝文件和状态信息

shutil.copytree(src, dst, symlinks=False, ignore=None)

递归的去拷贝文件夹

shutil.rmtree(path[, ignore_errors[, onerror]])

递归的去删除文件

shutil.rmtree('folder1')

shutil.move(src, dst)

递归的去移动文件，它类似mv命令，其实就是重命名。

shutil.make_archive(base_name, format,...)

创建压缩包并返回文件路径，例如：zip、tar

format：压缩包种类，“zip”, “tar”, “bztar”，“gztar”

root_dir：要压缩的文件夹路径（默认当前目录）

owner：用户，默认当前用户

group：组，默认当前组

logger：用于记录日志，通常是logging.Logger对象

压缩

z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close()

解压

z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall(path='.')
z.close()

subprocess模块

run()方法

标准写法

subprocess.run(['df','-h'],stderr=subprocess.PIPE,stdout=subprocess.PIPE,check=True)

涉及到管道|的命令

subprocess.run('df -h|grep disk1',shell=True)

call()方法

retcode = subprocess.call(["ls", "-l"])

执行命令，返回命令执行状态， 0 or 非0

subprocess.check_call(["ls", "-l"])

执行命令，如果命令结果为0，就正常返回，否则抛异常

subprocess.getstatusoutput('ls /bin/ls')

接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果

subprocess.getoutput('ls /bin/ls')

接收字符串格式命令，并返回结果

subprocess.check_output(['ls','-l'])

执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res

Popen()方法

args：shell命令，可以是字符串或者序列类型（如：list，元组）

stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄

preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用

shell：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用

cwd：用于设置子进程的当前目录

env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。

加密模块

概念

Hash

散列算法，变换成固定长度的输出，该输出就是散列值

HASH主要用于信息安全领域中加密算法，他把一些不同长度的信息转化成杂乱的128位的编码里,叫做HASH值

使用

hash = hashlib.md5()

hash.update('admin'.encoding = 'utf-8')

print(hash.hexdigest())

hashlib模块

md5

sha1

sha256

sha384

sha512

正则表达式

re模块

常用的表达式规则

'.' 默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行

'^' 匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)

'$' 匹配字符结尾，若指定flags MULTILINE ,re.search('foo.$','foo1\nfoo2\n',re.MULTILINE).group() 会匹配到foo1

'*' 匹配*号前的字符0次或多次， re.search('a*','aaaabac') 结果'aaaa'

'+' 匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']

'?' 匹配前一个字符1次或0次 ,re.search('b?','alex').group() 匹配b 0次

'{m}' 匹配前一个字符m次 ,re.search('b{3}','alexbbbs').group() 匹配到'bbb'

'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']

'|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'

'(...)' 分组匹配， re.search("(abc){2}a(123|45)", "abcabca456c").group() 结果为'abcabca45'

'\A' 只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的，相当于re.match('abc',"alexabc") 或^

'\Z' 匹配字符结尾，同$

'\d' 匹配数字0-9

'\D' 匹配非数字

'\w' 匹配[A-Za-z0-9]

'\W' 匹配非[A-Za-z0-9]

's' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'

匹配语法

re.match 从头开始匹配

re.search 匹配包含

re.findall 把所有匹配到的字符放到以列表中的元素返回

re.split 以匹配到的字符当做列表分隔符

re.sub 匹配字符并替换

re.fullmatch 全部匹配