标签：web center window mda base 规范化 struct make xxx
模块：为了编写可维护的代码，我们将很多函数分组，分别放到不同的文件里，这样，代码的可利用率提高，代码量减少。在Python中，一个 .py文件就称之为一个模块（module）。
模块有以下几种方式：
a.Python标准库
b.第三方模块
c.引用程序自定义模块
引入模块方式：
1、import 模块名1,模块名2（调用：模块名1.函数名）
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 5 def add(x, y): 6 return x+y 7 8 9 def sub(x, y): 10 return x-y
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import cal 4 5 6 print(cal.add(3, 5))
2、from 模块名1 import 函数名（调用：函数名）
#!/usr/bin/env python # -*- coding:utf-8 -*- def add(x, y): return x+y def sub(x, y): return x-y
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 from cal import add # 只引入一个函数 4 from cal import * # 引入多个函数 5 6 7 print(add(3, 5))
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import sys # 引入标准库 4 print(sys.path) # 查看当前路径 5 6 from my_module import cal # 引入自定义库，在当前路径的下一层 7 from my_module.module1.module2 import cal # 引入自定义库，多级目录 8 print(cal.add(3, 2))
在Python中，通常有这几种方式来表示时间：
a.时间戳（timestamp）：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型
b. 格式化的时间字符串
c.元祖（struct_time）：struct_time元祖共有9个元素（年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时）
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import time 4 5 # 时间戳,用于计算 6 print(time.time()) # 1548861231.773613秒,从1970年1月1日 00:00:00开始计算 7 # 结构化时间，当地时间 8 print(time.localtime()) # time.struct_time(tm_year=2019, tm_mon=1, tm_mday=30, tm_hour=23, tm_min=18, tm_sec=52, tm_wday=2, tm_yday=30, tm_isdst=0) 9 t = time.localtime() 10 print(t.tm_year) # 获取当前年份 11 print(t.tm_mday) # 获取当前月的第多少天 12 print(t.tm_wday) # 获取这周第几天，默认从0-6 13 # 结构化时间，标准时间--UTC 14 print(time.gmtime()) # 世界标准时间，英国；time.struct_time(tm_year=2019, tm_mon=1, tm_mday=30, tm_hour=15, tm_min=26, tm_sec=17, tm_wday=2, tm_yday=30, tm_isdst=0) 15 ‘‘‘ 16 struct_time ---> Timestamp:mktime 17 Timestamp ---> struct_time:localtime/gmtime 18 struct_time ---> Format string:strftime 19 Format string ---> struct_time:strptime 20 strptime：把一个格式化时间字符串转换为struct_time。实际上它和strftime()是逆操作 21 %Y:年 22 %m:月 23 %d:日 24 %X:时分秒 25 ‘‘‘ 26 # ----将结构化时间转换成时间戳 27 print(time.mktime(time.localtime())) 28 # ----将结构化时间转成字符串时间 29 print(time.strftime("%Y-%m-%d %X", time.localtime())) 30 # ----将字符串时间转成结构化时间 31 print(time.strptime("2019:01:30:23:53:59", "%Y:%m:%d:%X")) 32 33 print(time.asctime()) # Wed Jan 30 23:56:16 2019 34 print(time.ctime()) # Wed Jan 30 23:57:09 2019 35 ‘‘‘ 36 time.sleep(3)：线程推迟指定的时间运行，单位为秒 37 time.clock()： 38 a.UNIX系统上，他返回的是“进程时间”，它是用秒表示的浮点数 39 b.Windows中，第一次调用，返回的是进程运行的实际时间；第二次之后的调用时第一次调用以后到现在运行的时间，即时间差 40 ‘‘‘ 41 42 43 import datetime 44 print(datetime.datetime.now()) # 2019-01-31 00:04:25.944866
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import random 4 print(random.random()) # 0-1之间的随机数 5 print(random.randint(1, 10)) # 自定义范围的整形 6 print(random.randrange(1, 5)) # 自定义范围，第二个数取不到 7 print(random.choice([11, 12, 13, 14, 15])) 8 print(random.sample([11, 12, 13, 14, 15], 2)) # 指定一个列表，并指定随机产生的个数 9 print(random.uniform(1, 3)) # 取任意范围的float 10 item = [1, 3, 5, 7, 9] 11 random.shuffle(item) # 打乱集合中的顺序 12 print(item)
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import random 4 5 6 def v_code(): 7 res = "" 8 for i in range(5): 9 num = random.randint(0, 9) 10 alf = chr(random.randint(65, 122)) 11 s = str(random.choice([num, alf])) 12 res += s 13 return res 14 15 16 print(v_code()) # 25Ze5
OS模块是与操作系统交互的一个接口
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import os 4 print(os.getcwd()) # 获取当前工作目录，即当前python脚本工作的目录路径 5 # print(os.chdir("dirname")) # 改变当前脚本工作目录，相当于shell下cd 6 print(os.curdir) # 返回当前目录：（‘.‘） 7 print(os.pardir) # 获取当前目录的父目录字符串名：（‘..‘） 8 print(os.makedirs(‘dirname1/dirname2‘)) # 可生成多层递归目录 9 print(os.removedirs(‘dirname‘)) # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，以此类推 10 print(os.mkdir(‘dirname‘)) # 生成单级目录，相当于shell中 mkdir dirname 11 print(os.rmdir(‘dirname‘)) # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname 12 print(os.listdir(‘dirname‘)) # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 13 print(os.remove(‘dirname‘)) # 删除一个文件 14 print(os.rename(‘oldname‘, ‘newname‘)) # 重命名文件/目录 15 print(os.stat(‘path/filename‘)) # 获取文件/目录信息 16 print(os.sep) # 输出操作系统特定的路径分隔符，win下为‘\\‘，linux下为‘\‘ 17 print(os.linesep) # 输出当前平台使用的行终止符，win下为‘\r\n‘,linux下为‘\n‘ 18 print(os.pathsep) # 输出用于分割文件路径的字符串win下为‘;‘,linux下为‘: ‘ 19 print(os.name) # 输出字符串指定当前使用平台。win下为‘nt‘，linux下为‘posix‘ 20 print(os.system(‘bash command‘)) # 运行shell命令，直接显示 21 print(os.environ) # 获取系统环境变量 22 print(os.path.abspath(‘path‘)) # 返回path规范化的绝对路径 23 print(os.path.split(‘path‘)) # 将path分割成目录和文件名二元祖返回 24 print(os.path.dirname(‘path‘)) # 返回path目录，其实就是os.path.split(‘path‘) 的第一个元素 25 print(os.path.basename(‘path‘)) # 返回path最后的文件名。 26 print(os.path.exists(‘path‘)) # 如果path存在，返回True；反之则False 27 print(os.path.isabs(‘path‘)) # 如果path是绝对路径，返回True 28 print(os.path.isdir(‘path‘)) # 如果path是一个存在的目录，则返回True，反之则False 29 print(os.path.join(‘path1‘, ‘path2‘)) # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 30 print(os.path.getatime(‘path‘)) # 返回path所指向的文件或目录的最后存取时间 31 print(os.path.getmtime(‘path‘)) # 返回path所指向的文件或目录的最后修改时间
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import sys 4 print(sys.argv) # 命令行参数list，第一个元素是程序本身路径 5 print(sys.exit(‘n‘)) # 退出程序，正常退出时exit(0) 6 print(sys.version) # 获取Python解释程序的版本信息 7 print(sys.path) # 返回模块的搜索路径，初始化时使用Pythonpath环境变量的值 8 print(sys.platform) # 返回操作系统平台名称
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import sys,time 4 for i in range(100): 5 sys.stdout.write(‘#‘) 6 time.sleep(0.1) # 睡眠0.1秒 7 sys.stdout.flush() # 刷新缓存
之前学习过的Python内置函数eval方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了，所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import json 4 # x = "[null,true,false,1]" 5 # # print(eval(x)) # 报错 6 # print(json.loads(x)) # [None, True, False, 1] 7 dic = {"name": "alex"} 8 f = open("hello", "w") 9 dic_str = json.dumps(dic) 10 f.write(dic_str) # 等价于 json.dump(dic,f)，一般用于文件操作
1 # import pickle 2 # dic = {‘name‘: ‘alex‘, ‘age‘: 23, ‘sex‘: ‘male‘} 3 # print(type(dic)) # <class ‘dict‘> 4 # j = pickle.dumps(dic) 5 # print(type(j)) # <class ‘bytes‘> 6 # f = open(‘序列化对象_pickle‘, ‘wb‘) # 注意是w是写入str，wb是写入bytes，j是‘bytes‘ 7 # f.write(j) # 等价于 pickle.dump(dic,j) 8 # f.close() 9 10 # -------反序列化 11 import pickle 12 f = open(‘序列化对象_pickle‘, ‘rb‘) 13 data = pickle.loads(f.read()) # 等价于 data = pickle.load(f) 14 print(data[‘name‘])
什么是序列化？
我们把对象（变量）从内存中编程可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称为serialization,marshalling,flattening等等，都是一个意思。
序列化之后，就可以把序列化后的内存写入磁盘，或者通过网络传输到别的机器上。
反过来，把变量内存从序列化的对象重新读到内存里称之为反序列化，即unpickling。
json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化未JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
XML是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，以前在json还没诞生的黑暗年代，大家只能选择用XML呀，至今很多传统公司如金融行业的很多系统的接口还主要是XML。
XML的格式如下，就是通过<>节点来区别数据结构的：
1 <?xml version ="1.0" ?> 2 <date> 3 <country name="Liechtenstein"> 4 <rank updated="yes">2</rank> 5 <year>2008</year> 6 <gdppc>141100</gdppc> 7 <neighbor name="Austria" direction="E"/> 8 <neighbor name="Switzerland" direction="W"/> 9 </country> 10 </date>
XML协议在各个语言里的都是支持的，在Python中可以用以下模块操作xml：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import xml.etree.ElementTree as ET 4 5 tree = ET.parse("xml_lesson") # 调用ET下的parse解析这个XML文件,拿到的对象赋值给tree 6 root = tree.getroot() 7 print(root.tag) 8 9 # 遍历XML文档 10 for child in root: 11 print(child.tag, child.attrib) # child.attrib:获取节点属性 12 for i in child: 13 print(i.tag, i.attrib, i.text) 14 15 # 只遍历year节点 16 for node in root.iter(‘rank‘): # 遍历root根节点下的iter某一节点的“rank” 17 print(node.tag, node.text) 18 19 # 修改 20 for node_update in root.iter(‘rank‘): 21 new_rank = int(node_update.text) + 1 22 node_update.text = str(new_rank) 23 node_update.set(‘updated‘, ‘no‘) # 设置他的标签值 24 25 tree.write(‘xml_lesson‘) # 将内存中的数据重新写入进去 26 27 # 删除node 28 for country in root.findall(‘country‘): 29 rank = int(country.find(‘rank‘).text) 30 if rank == 5: 31 root.remove(country) 32 33 tree.write(‘xml_lesson‘)
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import xml.etree.ElementTree as ET 4 new_xml = ET.Element("namelist") # 创建根节点 5 name = ET.SubElement(new_xml, "name", attrib={"enrooled": "yes"}) 6 age = ET.SubElement(name, "age", attrib={"checked": "no"}) 7 sex = ET.SubElement(name, "sex") 8 sex.text = ‘33‘ 9 name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"}) 10 age = ET.SubElement(name2, "age") 11 age.text = ‘19‘ 12 13 et = ET.ElementTree(new_xml) # 生成文档对象 14 et.write("xml_test.xml", encoding="utf-8", xml_declaration=True) 15 16 ET.dump(new_xml) # 打印生成的格式 17 18 # =========以下为XML创建效果===== 19 <?xml version=‘1.0‘ encoding=‘utf-8‘?> 20 <namelist> 21 <name enrooled="yes"> 22 <age checked="no" /> 23 <sex>33</sex> 24 </name> 25 <name enrolled="no"> 26 <age>19</age> 27 </name> 28 </namelist>
正则表达式（或re）是一种小型的、高度专业化的编程语言，（Python）它内嵌在Python中，并通过re模块实现。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。
字符匹配（普通字符，元字符）：
普通字符 >>>re.findall(‘alex‘, ‘zhangsanalexlisi‘)
[‘alex‘]
元字符：.、^、$、*、+、?、{}、[]、|、()、\
.：匹配任意字符，除\n之外
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 print(re.findall(‘alex‘, ‘zhangsanalexlisi‘)) # [‘alex‘] 5 print(re.findall(‘a..x‘, ‘zhangsanalexlisi‘)) # [‘alex‘]
^：必须将“^”放在字符串开头位置，判断字符串以XXX开头，返回布尔值，如果以XXX开头，返回“真”，反之则“假”
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 print(re.findall(‘^alex‘, ‘zhangsanalexlisi‘)) # [] 5 print(re.findall(‘^alex‘, ‘alexzhangsanlisi‘)) # [‘alex‘] 6 print(re.findall(‘^a..x‘, ‘zhangsanalexlisi‘)) # [] 7 print(re.findall(‘^a..x‘, ‘alexzhangsanlisi‘)) # [‘alex‘]
$：必须将“$”放在字符串结尾位置，判断字符串以XXX结尾，返回布尔值，如果以XXX结尾，返回“真”，反之则“假”
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 print(re.findall(‘alex$‘, ‘zhangsanalexlisi‘)) # [] 5 print(re.findall(‘alex$‘, ‘zhangsanlisialex‘)) # [‘alex‘] 6 print(re.findall(‘^alex$‘, ‘zhangsanalexlisi‘)) # [] 7 print(re.findall(‘^alex$‘, ‘alex‘)) # [‘alex‘] 8 print(re.findall(‘a..x$‘, ‘zhangsanalexlisi‘)) # [] 9 print(re.findall(‘a..x$‘, ‘zhangsanlisialex‘)) # [‘alex‘] 10 print(re.findall(‘^a..x$‘, ‘zhangsanlisialex‘)) # [‘‘] 11 print(re.findall(‘^a..x$‘, ‘alex‘)) # [‘alex‘]
*、+、？、{}：以x重复出现
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 # *：范围（0，无穷） 5 print(re.findall(‘d*‘, ‘zhangsanddddddalexlisi‘)) # [‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘dddddd‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘, ‘‘] 6 7 8 # +：范围（1，无穷） 9 print(re.findall(‘d+‘, ‘zhangsanddddddalexlisi‘)) # [‘dddddd‘] 10 11 12 # *与+区别： 13 print(re.findall(‘alex*‘, ‘asdfgalex‘)) # [‘alex‘] 14 print(re.findall(‘alex+‘, ‘asdfgalex‘)) # [‘alex‘] 15 print(re.findall(‘alex*‘, ‘asdfgale‘)) # [‘ale‘] 16 print(re.findall(‘alex+‘, ‘asdfgale‘)) # [] 17 18 19 # ？：范围（0,1） 20 print(re.findall(‘alex?‘, ‘asdfgale‘)) # [‘ale‘] 21 print(re.findall(‘alex?‘, ‘asdfgalex‘)) # [‘alex‘] 22 23 24 # *与？共用：以最小匹配0次 25 print(re.findall(‘alex*?‘, ‘asdfgale‘)) # [‘ale‘] 26 print(re.findall(‘alex*?‘, ‘asdfgalexxxx‘)) # [‘ale‘] 27 28 29 # +与？共用：以最小匹配1次 30 print(re.findall(‘alex+?‘, ‘asdfgale‘)) # [] 31 print(re.findall(‘alex+?‘, ‘asdfgalexxxx‘)) # [‘alex‘] 32 33 34 # {}: 给定一个范围 35 # {0，无穷}==>* 36 # {1，无穷}==>+ 37 # {0,1} ==>? 38 # {6}:出现6次 39 # {1,6}：出现1至6任意一个次数 40 print(re.findall(‘alex{6}‘, ‘asdfgalex‘)) # [] 41 print(re.findall(‘alex{6}‘, ‘asdfgalexxxxxx‘)) # [‘alexxxxxx‘] 42 print(re.findall(‘alex{1,6}‘, ‘asdfgalexxx‘)) # [‘alexxx‘] 43 print(re.findall(‘alex{1,6}‘, ‘asdfgalexxxxxx‘)) # [‘alexxxxxx‘]
[]：中间出现的全部为普通字符；相当于“或”；只匹配一个；表示范围
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 5 # []字符串:中间出现的全部为普通字符；相当于“或”；只匹配一个；表示范围 6 print(re.findall(‘x[y]‘, ‘abcx‘)) # [] 7 print(re.findall(‘x[y]‘, ‘abcxy‘)) # [‘xy‘] 8 9 10 # 中间出现：* 11 print(re.findall(‘x[y*]‘, ‘abcx‘)) # [] 12 print(re.findall(‘x[y*]‘, ‘abcxy‘)) # [‘xy‘] 13 print(re.findall(‘x[y*]‘, ‘abcx*‘)) # [‘x*‘] 14 15 16 # 中间出现：-;范围不允许a-Z,只能a-z或者A-Z 17 print(re.findall(‘a[a-z]‘, ‘a2bcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ‘)) # [] 18 print(re.findall(‘a[a-z]‘, ‘abcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ‘)) # [‘ab‘] 19 print(re.findall(‘a[A-Z]‘, ‘a2bcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ‘)) # [] 20 print(re.findall(‘a[A-Z]‘, ‘aAbcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ‘)) # [‘aA‘] 21 22 23 # 后面在出现一个：* 24 print(re.findall(‘a[a-z]*‘, ‘a2bcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ‘)) # [‘a‘] 25 print(re.findall(‘a[a-z]*‘, ‘abcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ‘)) # [‘abcdefghijklmnopqrxtuvwxyz‘] 26 print(re.findall(‘a[a-z]*‘, ‘abcdefghijklmnopqrxtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ9‘)) # [‘abcdefghijklmnopqrxtuvwxyz‘] 27 28 29 # 中间出现:^；代表“非” 30 print(re.findall(‘q[^a-z]‘, ‘qabc‘)) # [] 31 print(re.findall(‘q[^a-z]‘, ‘q12‘)) # [‘q1‘]
|：“或”的意思，要么左边，要么右边
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 print(re.findall(r‘ka|b‘, ‘sdfgjkabc‘)) # [‘ka‘, ‘b‘] 5 print(re.findall(r‘ka|b‘, ‘sdfgjkac‘)) # [‘ka‘] 6 print(re.findall(r‘ka|b‘, ‘sdfgjkbc‘)) # [‘b‘]
()：分组，代表一个整体
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 print(re.findall(‘(abc)‘, ‘abcabcabc‘)) # [‘abc‘, ‘abc‘, ‘abc‘] 5 print(re.search(‘\d‘, ‘dfas25fd35‘)) # <re.Match object; span=(4, 5), match=‘2‘> 6 print(re.search(‘\d‘, ‘dfas25fd35‘).group()) # 2 7 print(re.search(‘\d+‘, ‘dfas25fd35‘)) # <re.Match object; span=(4, 6), match=‘25‘> 8 print(re.search(‘\d+‘, ‘dfas25fd35‘).group()) # 25 9 print(re.search(‘\d{3}‘, ‘dfas25fd35‘)) # None 10 print(re.search(‘(?P<name>[a-z]+)‘, ‘alex28liming33‘)) # <re.Match object; span=(0, 4), match=‘alex‘> 11 print(re.search(‘(?P<name>[a-z]+)‘, ‘alex28liming33‘).group()) # alex 12 print(re.search(‘(?P<name>[a-z]+)\d+‘, ‘alex28liming33‘)) # <re.Match object; span=(0, 6), match=‘alex28‘> 13 print(re.search(‘(?P<name>[a-z]+)\d+‘, ‘alex28liming33‘).group()) # alex28 14 print(re.search(‘(?P<name>[a-z]+)\d+‘, ‘alex28liming33‘).group(‘name‘)) # alex
\：转义符
反斜杠后面跟元字符去除特殊功能
反斜杠后面跟普通字符实现特殊功能
\d：匹配任何十进制数；相当于[0-9]
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 print(re.findall(‘\d‘, ‘12+(34*6+2-5*(2-1))‘)) # [‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘6‘, ‘2‘, ‘5‘, ‘2‘, ‘1‘] 5 print(re.findall(‘\d+‘, ‘12+(34*6+2-5*(2-1))‘)) # [‘12‘, ‘34‘, ‘6‘, ‘2‘, ‘5‘, ‘2‘, ‘1‘]
\D：匹配任何非十进制数；相当于[^0-9]
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 print(re.findall(‘\D‘, ‘12+(34*6+2-5*(2-1))‘)) # [‘+‘, ‘(‘, ‘*‘, ‘+‘, ‘-‘, ‘*‘, ‘(‘, ‘-‘, ‘)‘, ‘)‘] 5 print(re.findall(‘\D+‘, ‘12+(34*6+2-5*(2-1))‘)) # [‘+(‘, ‘*‘, ‘+‘, ‘-‘, ‘*(‘, ‘-‘, ‘))‘]
\s：匹配任何空白字符；相当于[\t\n\r\f\v]
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 5 # 转义符:\ 6 print(re.findall(‘\s‘, ‘hello word!‘)) # [‘ ‘]
\S：匹配任何非空白字符；相当于[^\t\n\r\f\v]
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 5 print(re.findall(‘\S‘, ‘hello word!‘)) # [‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘w‘, ‘o‘, ‘r‘, ‘d‘, ‘!‘] 6 print(re.findall(‘\S+‘, ‘hello word!‘)) # [‘hello‘, ‘word!‘]
\w：匹配任何字母数字字符；相当于[a-zA-Z0-9]
\W：匹配任何非字母数字字符；相当于[^a-zA-Z0-9]
\b：匹配任何一个特殊字符边界，如：空格、&、#等
re模块下的常用方法
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 # 1 5 print(re.findall(‘a‘, ‘alex lisi‘)) # [‘a‘];返回所有满足匹配条件的结果，放到列表里 6 7 8 # 2 9 print(re.search(‘a‘, ‘alex lisi‘).group()) # a;函数在字符串内查找模式匹配，只能找到第一个匹配然后返回一个包；通过调用group()方法得到匹配的字符串，如果字符串没有匹配，则返回node 10 11 12 # 3 13 print(re.match(‘a‘, ‘zabc‘)) # None；同search()，仅匹配字符串开始处 14 15 16 # 4 17 print(re.split(‘ ‘, ‘hello word abc‘)) # [‘hello‘, ‘word‘, ‘abc‘] 18 19 20 # 5 21 print(re.sub(‘\d+‘, ‘A‘, ‘alex6jack5‘, 1)) # alexAjack5 22 print(re.subn(‘\d+‘, ‘A‘, ‘alex6jack5‘, 1)) # (‘alexAjack5‘, 1) 23 24 25 # 6 26 com = re.compile(‘\d{3}‘) 27 print(com.search(‘abc123de45‘).group()) # 123；可以多次调用 28 29 # 7 30 ret = re.finditer("\d+", "ab35cde47fg88") 31 print(ret) # <callable_iterator object at 0x00000028E5A765C0> 32 print(next(ret).group()) # 35 33 print(next(ret).group()) # 47 34 print(next(ret).group()) # 88
re补充：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import re 4 print(re.findall(‘www\.(baidu|sina)\.com‘, ‘www.baidu.com‘)) # [‘baidu‘];优先匹配分组的内容 5 6 # 分组中添加‘？:’去除优先级 7 print(re.findall(‘www\.(?:baidu|sina)\.com‘, ‘www.baidu.com‘)) # [‘www.baidu.com‘]
标签：web center window mda base 规范化 struct make xxx
原文地址：https://www.cnblogs.com/chenyanbin/p/10339885.html
