常用模块

# 常用模块

"""

1.time 
2.random 
3.shutil 
4.os 
5.sys 
6.json
7.shelve
8.xml
9.hashlib
10.configparser
11.subprocess
12.re

""" time模块 与时间相关的功能 在python中 时间分为3种 1.时间戳 timestamp 从1970 1 月 1日 到先在的秒数 主要用于计算两个时间的差 2.localtime 本地时间 表示的是计算机当前所在的位置 3.UTC 世界协调时间 时间戳 结构化 格式化字符 """ import time 获取时间戳 返回浮点型 print(time.time()) 1533816939.0587194 获取当地时间 返回的是结构化时间 print(time.localtime()) time.struct_time(tm_year=2018, tm_mon=8, tm_mday=9, tm_hour=20, tm_min=15, tm_sec=39, tm_wday=3, tm_yday=221, tm_isdst=0) 获取UTC时间 返回的还是结构化时间 比中国时间少8小时 print(time.gmtime()) 将获取的时间转成我们期望的格式 仅支持结构化时间 print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())) 2018-08-09 20 (tel:2018080920):15:39 将格式化字符串的时间转为结构化时间 注意 格式必须匹配 print(time.strptime("2018-08-09 09 (tel:2018080909):01:22","%Y-%m-%d %H:%M:%S")) time.struct_time(tm_year=2018, tm_mon=8, tm_mday=9, tm_hour=9, tm_min=1, tm_sec=22, tm_wday=3, tm_yday=221, tm_isdst=-1) 时间戳 转结构化 print(time.localtime(time.time())) 结构化转 时间戳 print(time.mktime(time.localtime())) sleep 让当前进程睡眠一段时间 单位是秒 time.sleep(2) print("over") 不太常用的时间格式 print(time.asctime()) Thu Aug 9 20:15:39 2018 print(time.ctime()) Thu Aug 9 20:15:39 2018 """ datetime python实现的一个时间处理模块 time 用起来不太方便 所以就有了datetme 总结 datetime相比time 更灵活 更本土化 timedelta表示时间差 两个时间差可以 +-/ # 时间差和datetime 可以+- # """ # import datetime # 获取时间 获取当前时间 并且返回的是格式化字符时间 # print(datetime.datetime.now()) # 2018-08-09 20 (tel:2018080920):21:11.957489 # 单独获取某个时间 年 月 # d = datetime.datetime.now() # print(d.year) #2018 # print(d.day) #9 # 手动指定时间 # d2 = datetime.datetime(2018,8,9,9,50,00) # print(d2) #2018-08-09 09 (tel:2018080909):50:00 # 计算两个时间的差 只能- 不能加+ # print(d - d2) #10:32:31.883157 # 替换某个时间 # print(d.replace(year=2020)) #2020-08-09 20:22:31.883157 # 表示时间差的模块 timedelta # print(datetime.timedelta(days=1)) #1 day, 0:00:00 # t1 = datetime.timedelta(days=1) # t2 = datetime.timedelta(weeks=1) # print(t2 - t1) #6 days, 0:00:00 # 时间差可以和一个datetime进行加减 # print(d + t2) #2018-08-16 20 (tel:2018081620):22:31.883157  random # random 随机数相关模块 # random 0-1 闭开 # randint 0 - 3 闭闭 # randrange 0 - 3 闭开 # choice [1,2,32,3,2,"哈哈"] 随机选⼀个 # sample([1,"a",["c","d"]],2) 随机选指定个数 # uniform(1,3) 开开 浮点 # shuffle(列表) 打乱顺序 # ''' # import random # 0 - 1 随机浮点 不包含1 # print(random.random()) #0.802506175049402 # print(random.randint(1,3)) #3 # print(random.randrange(1,3)) #2 # print(random.choices((1,2,3))) #[3] # print(random.sample([1,2,3],2)) #[1, 2] # l = [1,2,3,4,5] # print(random.shuffle(l)) #None # print(l) #[1, 3, 2, 5, 4] # print(random.uniform(1,2)) #1.565222332888115 # 生产验证码 整形和字符(全大写)随机组成 可以指定长度 # import random # def make_code(i): # res = "" # for j in range(i): # # 随机0到9 # num = str(random.randint(0,9)) # c = chr(random.randint(65,90)) # s = random.choice([num,c]) # res += s # return res # print(make_code(4)) # '''  shutil # 模块 非常简便的文件操作 # 压缩包处理模块 # ''' import shutil import zipfile,tarfile #拷贝文件 提供两个文件对象 长度表示缓冲区大小 # shutil.copyfileobj(open("a.txt","r",encoding="utf-8"),open("b.txt","w",encoding="utf-8"),length=1024) # shutil.copyfile(src, dst) #拷贝文件,提供两个文件路径 # shutil.copymode() # 拷贝文件权限,提供两个文件路径 # shutil.copystat(src, dst) #拷贝文件状态信息,最后访问以及最后修改的日志信息,提供两个⽂文件路路径 #shutil.copy(src, dst) #拷贝文件和权限,提供两个文件路路径 # shutil.copy2(src, dst) #拷贝文件和状态信息,提供两个文件路路径 # shutil.ignore_patterns("mp3", ".py") #忽略文件  shutil.copytree(src, dst, symlinks=False, ignore=None) #拷贝目录  symlinks #默认False将软链接拷贝为硬链接,否则拷贝为软连接  shutil.rmtree #删除目录,可以设置忽略文件  shutil.move(src, dst) #移动目录和文件  压缩与解压缩 利用shutil来创建压缩文件 仅支持 tar 和zip格式 内部调用zipFIle tarFIle模块实现 shutil.make_archive("test","zip",root_dir="D:\脱产三期视频\Day17\代码") #zip 压缩  z = zipfile.ZipFile ("test.zip","w") z.write ("sys.py") z.write ("start.py") z.close() 解压zip z = zipfile.ZipFile(r"D:\脱产三期视频\Day17\test.zip") z.extractall() z.close() tar 压缩 t = tarfile.open("test.tar", "w") t.add("start.py") t.add("sys.py") t.close() 解压tar t = tarfile.open(r"D:\脱产三期视频\Day17\test.tar") t.extractall() t.close() 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 返回操作系统平台名称 进度条: def progress(percent,width=30): percent = percent if percent <= 1 else 1 text = ("\r[%%-%ds]" % width) % ("" int((width * percent))) text = text + "%d%%" text = text % (percent * 100) print( text , end="") # 模拟下载 # 文件大小 import time file_size = 10240 # 已经下载大小  cur_size = 0 while True: time.sleep(0.5) cur_size += 1021 progress(cur_size / file_size) if cur_size >= file_size: print() print("finish") break os 模块 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd os.curdir 返回当前目录: ('.') os.pardir 获取当前目录的父目录字符串名：('..') os.makedirs('dirname1/dirname2') 可生成多层递归目录 os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 os.mkdir('dirname') 生成单级目录,相当于shell中mkdir dirname os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错;相当于shell中rmdir dirname os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏⽂文件，并以列表方式打印 os.remove() 删除一个文件 os.rename("oldname","newname") 重命名文件/目录 os.stat('path/filename') 获取文件/目录信息 os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/" os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n" os.pathsep 输出用于分割文件路径的字符串, win下为;, Linux下为:\ os.name 输出字符串指示当前使用平台。win→'nt'; Linux→'posix' os.system("bash command") 运行shell命令，直接显示 os.environ 获取系统环境变量 os.path.basename(path) 去掉路径，返回文件名 os.path.dirname(path) 去掉文件名，返回路径 os.path.join(path1,path2,..) 将path1,path2等各个部分组合成一个路径名 os.path.split(path) 分割文件名与路径 返回一个元组 os.path.splitext(path) 分离文件名与扩展名 返回一个元组 os.path.getsize(file) 返回指定一个文件的大小 单位是字节 os.path.getatime(file) 返回指定文件最近访问的时间，可用time的gmtime()或localtime()换算 os.path.gectime(file) 返回指定文件的创建时间，可用time的gmtime()或localtime()换算 os.path.gtmtime(file) 返回指定文件最新修改的时间，可用time的gmtime()或localtime()换算 以下函数返回True或False os.path.exists(path) 判断指定路径（目录或文件）是否存在 os.path.isabs(path) 判断指定路径是否为绝对路径 os.path.isdir(path) 判断指定路径是否存在且是一个目录 os.path.isfile(path) 判断指定路径是否存在且是一个文件 os.path.islink(path) 判断指定路径是否存在且是一个符号链接 os.path.ismount(path) 判断指定路径是否存在且是一个挂载点 os.path.samefile(paht1,path2) 判断path1和path2是否指向同一个文件 """ pickle模块 作用于序列化 序列化就是将内存中的数据持久化到硬盘 回顾 使用文件读写也能完成把数据持久化存储 但是有局限性 当数据比较复杂时用起来就很麻烦 例如 需要把一个字典存储到硬盘中 先转成字符串 写入 读取为字符串 转为原始的格式 所以就有了pickle 1.能将所有python中的数据序列化 int float str dic list tuple set bool 2.反序列化 将之前序列化的数据 在恢复成python的数据格式 pickle产生的数据 只能由python读取 (跨平台性差) 今后你开发程序不可能就是单机程序 你需要和其他设备 其他平台 交换数据 一三八四三八零零四三八 我们需要找到一种通用的数据格式 让各个平台都能识别 """ users = {"name":"yyh","age":20,"hobbies":["打豆豆","飘"]} f = open("a.txt","wt",encoding="utf-8") f.write(str(users)) f.close() import pickle print(pickle.dumps(users)) 序列化 f = open("p.txt","wb") f.write(pickle.dumps(users)) f.close() 反序列化 f = open("p.txt","rb") print(type(pickle.loads(f.read()))) f.close() 序列化 pickle.dump(users,open("pp.txt","wb")) print(pickle.load(open("pp.txt","rb"))) """ pickle产生的数据 只能由python读取 (跨平台性差) 今后你开发程序不可能就是单机程序 你需要和其他设备 其他平台 交换数据 一三八四三八零零四三八 我们需要找到一种通用的数据格式 让各个平台都能识别 json模块 用于处理json格式数据的模块 json 全称 JavaScrip Object Notation js的对象表示法 所以json能支持的数据类型就是js支持数据类型 json格式标准 能存储的有 str int float dic list bool 案列 要求 数据的最开始和最末尾 必须是{} [] {"name":"yyh"} json是一种通用的数据交换格式 目前主流的语言都能够轻松解析 注意: 在使用json格式的时候 数据类型必须按照要求来写 并且 不支持python 元祖 True/Flase '' ''' 常用方法 序列化 dump 处理文件 dumps 处理字符串 反序列化 load 处理文件 loads 处理字符串 """ 将python格式的数据序列化为json格式 python中的任何类型都能被转化为json格式 表现形式不同 import json users = {'name':"音乐会","age":20,"hobbies":("music","movies")} print(json.dumps(users)) json.dump(users,open("users.json","wt",encoding="utf-8")) json的反序列化 jsonstr = json.load(open("users.json","r",encoding="utf-8")) print(jsonstr) """ time 时间转换 *** *# datetime* *# 获取时间 * os 操作系统的文件路和目录 os.path # sys # 解释器相关 用于设计脚本程序 *# pickle* *# python本地序列化方式 比较局限 * json 通用的数据交换格式 使用起来挺简单 # shutil # 文件相关的高级操作 *# random* *# 随机数相关 简单 *** """

 

shelve
shelve模块也是一种可以将数据序列化的模块
使用方法
1. open
2. 读写
3. close
特点:使用方法比较简单 提供一个文件名字就可以开始读写,读写的方法和字典一致;跨平台性差

代码示例：
import shelve
# 序列化
sl = shelve.open("shelvetest.txt")
sl["date"] = "8-13"
sl["list1"] = ["123","456"]
sl.close() 


# 反序列化
s2 = shelve.open("shelvetest.txt")
print(s2.get("list1"))
s2.close()


XML
XML:全称 可扩展标记语言
标记指的是代表某种含义的字符 XML<>

为什么需要XML
为能够在不同的平台间继续数据的交换
为了使交换的数据能让对方看懂 就需要按照一定的语法规范来书写

XML语法格式:
一、任何的起始标签都必须有一个结束标签。

<tagname></tagname>

<tagname/> 简化写法


二、可以采用另一种简化语法，可以在一个标签中同时表示起始和结束标签。这种语法是在大于符号之前紧跟一个斜线（/），例如<百度百科词条/>。
三、标签必须按合适的顺序进行嵌套，关闭标签应该从内往外 一层一层关闭 顺序不能乱
四、所有的属性都必须有值。
<person name="">
</person>
五、所有的属性都必须在值的周围加上双引号。
注意:最外层有且只有一个标签 这个标签称之为根标签，第一行应该有文档声明 用于告诉计算机怎么理解文档
例如:<?xml version="1.0" encoding="utf-8"?> 
使用场景: 配置文件、常规的数据交换 例如从服务器获取一段新闻

与json的区别:
作用是一样的 都是一种数据格式
xml比json先诞生
json的数据比xml小
目前json是主流

python中的xml处理
ElmentTree 表示整个文件的元素树

Elment 表示一个节点

属性
1. text 开始标签和结束标签中间的文本
2. attrib 所有的属性 字典类型
3. tag 标签的名字

方法

get 获取某个属性的值

1.解析XML
查找标签
find 在子标签中获取名字匹配第一个
findall 在子标签中获取名字匹配的所有标签
iter(tagname) 在全文中查找[匹配的所有标签 返回一个迭代器


生成XML


用ElmentTree
parse() 解析一个文件
getroot() 获取根标签
write() 写入到文件


修改xml


set 一个属性
remove 一个标签
append 一个标签

# 语法格式练习: 要求把你的同桌的手机信息用xml来描述
import xml.etree.ElementTree as et

# 读取xml文档到内存中 得到一个包含所有数据的节点树
# 每一个标签就称之为一个节点 或 元素
tree = et.parse("text.xml")
# 获取根标签
root = tree.getroot()
# 获取所有的country 找的是第一个
print(root.find("country"))
# 找的是所有
print(root.findall("country"))

# 获取year
print(root.iter("country"))
for i in root.iter("country"):
print(i)

# 遍历整个xml
for country in root:
print(country.tag,country.attrib,country.text)
for t in country:
print(t.tag, t.attrib, t.text)

# 读取到内存
tree = et.parse("text.xml")
for country in tree.findall("country"):
yeartag = country.find("year")
yeartag.text = str(int(yeartag.text) + 1) 修改标签文本

country.remove(country.find("year")) 删除标签

# 添加子标签
newtag = et.Element("newTag")
# 文本
newtag.text = "123"
#属性
newtag.attrib["name"] = "DSB"
#添加
country.append(newtag)

# 写回到内存
tree.write("text.xml",encoding="utf-8",xml_declaration=False)


hashlib
hashlib 是一个提供了一些流行的hash算法的 Python 标准库．
其中所包括的算法有 md5, sha1, sha224, sha256, sha384, sha512. 另外，模块中所定义的 new(name, string=”) 方法可通过指定系统所支持的hash算法来构造相应的hash对象．
hash的特点:
1.输入数据不同,得到的hash值有可能相同
2.不能通过hash值来得到输入的值
3.如果算法相同,无论输入的数据长度是多少,得到的hash值长度相同

hashlib用法
from hashlib import md5# 导入模块

md5 = hashlib.md5() # 构造hash对象
md5.update('hello')#传入要hash的数据
md5.update('python') 
m2 = hashlib.md5('hello python')
print (md5.hexdigest() == m2.hexdigest()) # 两种方式的效果相同



通常为防止密码被撞库破解，在传输密码时会使用加密算法，并会使用为密码加盐，增加密码被撞库破解的难度

from hashlib import md5 

pwd = ‘123456’
md5 = hashlib.md5()
md5.update('hello,world') #加盐
md5.update(pwd) 
print(md5. hexdigest())

configparser
configparser 是配置文件解析模块
什么是配置文件?
用于提供程序运行所需要的一些信息的文件 后缀 ini cfg
有什么用?
方便用户修改 例如超时时间

配置文件内容格式

只包括两种元素
section 分区
option 选项
一个文件可以有多个section
一个section可以有多个选项

核心功能
1.sections 获取所有分区
2.options 获取所有选项
3.get 获取一个值 传入 section option

注意:大小写不敏感

用法
import configparser #导入模块

conf = configparser.ConfigParser() #创建对象
conf.read('config.ini', encoding='utf-8') #读取配置文件信息，指定‘utf-8’
print(conf['sections']['options']) #取值
conf['sections']['options'] = 'new_config' #赋值、修改

conf.write(open('config.ini', 'w', encoding='utf-8')) #保存到原文件

 

import subprocess

# dos命令
# tasklist | findstr python #查询关于python的进程
# taskkill /?
# D:\code>taskkill /F /PID 12360 #dos命令--杀死进程

# linux系统（了解）
# ps aux | grep python
# kill -9 PID 

# import os
# while True:
# cmd=input('>>>: ').strip()
# if not cmd:continue
# # print('%s run' %cmd)
# res=os.system(cmd)




# import os
#
# res=os.system('dixCVr')
# print('运行结果：',res)

import subprocess

obj=subprocess.Popen('dir',
 shell=True,
 stdout=subprocess.PIPE, #正确的结果往这个管道输入
 stderr=subprocess.PIPE #错误的结果往这个管道输入
 )

# print(obj)

res1=obj.stdout.read() #从正确的管道拿输出后的结果
print('正确结果1111: ',res1)

res2=obj.stdout.read() #从正确的管道拿输出后的结果，不过拿不到，只能拿一次
print('正确结果2222: ',res2) #只能取一次，取走了就没有了

# res2=obj.stderr.read() #从错误的管道拿输出后的结
# print('错误结果：',res2.decode('gbk'))
RE是什么
 正则 表达 式子
 就是一些带有特殊含义的符号或者符号的组合
 它的作用是对字符串进行过滤
 在一堆字符串中找到你所关心的内容
 你就需要告诉计算机你的过滤规则是什么样 通过什么方式来告诉计算机 就通过正则表达式
 注： re模块的内部实现 不是python 而是调用了c库
import re
s = "abc a1c 12\+- $_\n\tqaz" #定义字符串
b = "a ab abb abbb abbbbb a1bbbbbbbb" #定义字符串



\w    #匹配所有字母数字下划线

\W    #匹配所有非字母数字下划线

\s    #匹配所有空白字符

\S    #匹配所有非空白字符

\d    #匹配所有数字

\D    #匹配所有非数字

\n    #匹配所有的\n

\t    #匹配所有的\t

^ab    #从开头匹配字符串ab，只匹配一次

qaz$    #从结尾匹配字符串qaz，只匹配一次

.    代表除了换行符外的任意一个字符

?    不能单独用，代表左边的那一个字符重复0次或一次

*    代表左边的那一个字符重复0次或多次

+    代表左边的那一个字符重复1次或多次(至少出现一次)

{m，n} 代表左边的那一个字符出现m次到n次（n不写，代表无穷次）

 
.*  匹配任意长度，任意的字符-----》贪婪匹配(例：a.*c,从a开始，会一直找到最右边一个c，中间所有的字符都获取了，比较贪婪)

.*?    非贪婪匹配，找到最近的即可

()    分组:带括号去匹配，如果匹配成功，只留下括号内的字符串

[]    中括号内可以放任意字符，一个中括号代表一个字符，，这一个字符来自于中括号内

"""
 re模块常用方法：
 findall 从左往右查找所有满足条件的字符 返回一个列表
 search 返回第一个匹配的字符串 结果封装为对象 span=(0, 5) 匹配的位置 match匹配的值
 match 匹配行首 返回值与search相同
 对于search match 匹配的结果通过group来获取
 compile 将正则表达式 封装为一个正则对象 好处是可以重复使用这个表达式
"""
例子：
print(re.findall("\w",s)) #匹配所有字母数字下划线
print(re.findall("\W",s)) #匹配所有非字母数字下划线
print(re.findall("\s",s)) #匹配所有空白字符
print(re.findall("\S",s)) #匹配所有非空白字符
print(re.findall("\d",s)) #匹配所有数字
print(re.findall("\D",s)) #匹配所有非数字
print(re.findall("\n",s)) #匹配所有的\n
print(re.findall("\t",s)) #匹配所有的\t
print(re.findall("^ab",s)) #从开头匹配字符串，只匹配一次
print(re.findall("qaz$",s)) #从结尾匹配字符串，只匹配一次
# .代表除了换行符外的任意一个字符（要想可以匹配换行符，findall方法里可以加参数，re.DOTALL--DOT：点，ALL：所有）
print(re.findall("a.c",s)) #['abc', 'a1c']
# ? 不能单独用，代表左边的那一个字符重复0次或一次
print(re.findall("ab?",b)) #['a', 'ab', 'ab', 'ab', 'ab', 'a']
print(re.findall("ab{0,1}",b)) #['a', 'ab', 'ab', 'ab', 'ab', 'a']
# *代表左边的那一个字符重复0次或多次
print(re.findall("ab*",b)) #['a', 'ab', 'abb', 'abbb', 'abbbbb', 'a']
print(re.findall("ab{0,}",b)) #['a', 'ab', 'abb', 'abbb', 'abbbbb', 'a']

# + 代表左边的那一个字符重复1次或多次(至少出现一次)
print(re.findall("ab+",b)) #['ab', 'abb', 'abbb', 'abbbbb']
print(re.findall('ab{1,}',b)) #['ab', 'abb', 'abbb', 'abbbbb']

# {m，n}代表左边的那一个字符出现m次到n次（n不写，代表无穷次）
# .* 匹配任意长度，任意的字符-----》贪婪匹配(从a开始，会一直找到最右边一个c，中间所有的字符都获取了，比较贪婪)
print(re.findall("a.*c","a123c456c")) #['a123c456c']
# .*? 非贪婪匹配，找到最近的即可
print(re.findall("a.*?c","a123c456c")) #['a123c']

#分组:带括号去匹配，如果匹配成功，只留下括号内的字符串
print(re.findall("(abc)_sb","abc_sb sadsaddasdaabc_sb")) #['abc', 'abc']

#[]:中括号内可以放任意字符，一个中括号代表一个字符，，这一个字符来自于中括号内
# 在中括号内，“-”有特殊含义，当需要使用-的普通字符来使用的时候，把-放到[]的最左边或者最右边
print(re.findall("a[0-9]c","a1c a c a-c a+c aAc")) #['a1c']
print(re.findall("a[a-z]c","a1c a c a-c a+c aAc acc")) #['acc']
print(re.findall("a[A-Z]c","a1c a c a-c a+c aAc acc")) #['aAc']
print(re.findall("a[*+-]c","a1c a c a-c a+c a*c aAc acc")) #['a-c', 'a+c', 'a*c']

#^上尖号在中阔内表示取反的意思，并不是以某某开头
print(re.findall("a[^a-z]c","a1c a c a-c a+c aAc acc")) #['a1c', 'a c', 'a-c', 'a+c', 'aAc'](除了acc，都在这儿了)
print(re.findall("([a-z]+)_sb","lxx_sb sadadw213sdaalex_sb egon_sbasdasd "))

# | 竖杠 代表或者的意思
print(re.findall("compan(ies|y)","too many companies shutdown,I have a company"))
#['ies', 'y'],这个结果不是我们需要的，它只打印了ies或者y

print(re.findall("compan(?:ies|y)","too many companies shutdown,I have a company"))
#['companies', 'company']加上 ?: 表示前面的也需要，再加上竖杠选择的结果。

print(re.findall("alex|sb","alex is sb asdasdadalex sadasb egon")) #['alex', 'sb', 'alex', 'sb']

#re模块的其他方法：
# search ：只找一个，如果找到，就返回一个找到的对象，用group方法可以得到对应的值。
# match ：相当于带上尖号版本的search,它是也用group方法获得对应的值
print(re.search("alex","alex is sb asdasdadalex sadasb egon"))
#<_sre.SRE_Match object; span=(0, 4), match='alex'>
print(re.search("alex","alex is sb asdasdadalex sadasb egon").group()) #alex
print(re.match("alex","alex is sb asdasdadalex sadasb egon")) #<_sre.SRE_Match object; span=(0, 4), match='alex'>

print(re.search("^alex","sad asd alex is sb asdasdadalex sadasb egon")) #None
print(re.match("alex","sad asd alex is sb asdasdadalex sadasb egon")) #None


#spilt方法
print(re.split("[a,w]","1a2w3e4r"))

使用字符串替换
# print('egon is beutifull egon'.replace('egon','EGON',1))

使用sub方法替换第二处的egon，替换为EGON
# print(re.sub('(.*?)(egon)(.*?)(egon)(.*?)',r'\1\2\3EGON\5','123 egon is beutifull egon 123'))

# (123 )(egon)( is beutifull )(egon)( 123)

#\1\2\3EGON\5

# print(re.sub('(lqz)(.*?)(SB)',r'\3\2\1',r'lqz is SB'))
# print(re.sub('([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)',r'\5\2\3\4\1',r'lqzzzz123+ is SB'))

#(lqzzzz)(123+ )(is)( )(SB)

如果经常需要用到某个正则表达式，可以先存起来，然后直接调用，存的方法是complie
pattern=re.compile('alex')
print(pattern.findall('alex is alex alex'))
print(pattern.findall('alexasdfsadfsadfasdfasdfasfd is alex alex'))