Python之路【第八篇】:Python模块

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

阅读目录

一、模块和包

模块(module)的概念：

在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码会越来越长，越来越不容易维护。

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Python中， 一个.py文件就称之为一个模块(module)。

使用模块有哪些好处？

1、最大的好处就是大大提高了代码的可维护性。

2、编写代码不必从零开始。当一个模块编写完成，就可以被其他地方调用。我们在编写程序的时候，也经常饮用其他模块，包括Python内置的模块和来自第三方的模块。

模块一共分为三种：

1、python标准库

2、第三方模块

3、应用程序自定义模块

注意：

使用模块还可以避免函数名跟变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们在自己编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。

二、模块的导入方法

1、import语句

import module1,[module2[,...moduleN]]

当我们使用import语句的时候，Python解释器是怎样找到对应的文件？答案就是解释器有自己的搜索路径，存在sys.path里。

import sys

print(sys.path)

运行结果如下：

['G:\\python_s3\\day21', 'G:\\python_s3', 'C:\\Python35\\python35.zip', 'C:\\Python35\\DLLs', 'C:\\Python35\\lib', 'C:\\Python35', 'C:\\Python35\\lib\\site-packages', 'D:\\Program Files (x64)\\pycharm软件安装\\config\\PyCharm 2018.3\\helpers\\pycharm_matplotlib_backend']

因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块没屏蔽掉。

2、from...import ...语句

from modname import name1[,name2[, ... nameN]]

这个声明不会把整个modulename模块导入到当前的命名空间中，只会讲它里面的name1或name2单个引入到执行这个声明的模块的全局符号表。

3、from...import*语句

from modname import *

4、运行本质

1、import test

2、from test import add

无论1还是2，首先通过sys.path找到test.py，然后执行test脚本，区别是1会将test这个变量名加载到名字空间，而2只会将add这个变量名加载进来。

5、包(package)

1、如果不同的人编写的模块名相同怎么办？为了避免模块名冲突，Python又引入了按目录来组织模块的方法，成为包(Package)。

举个例子：一个abc.py的文件就是一个名字叫abc的模块，一个simon.py的文件就是一个叫simon的模块。

现在，假设我们的abc和simon这两个模块名字和其他模块起冲突了，于是我们可以通过包来组织模块，从而避免冲突。方法就是选择一个顶层包名：

2、引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突。现在，view.py模块的名字就变成了hello_django.app01.views，类似的，manage.py的模块名则是hello_django.manage。

请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录(文件夹)，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是对应包的名字。

注意点(important)

调用包就是执行包下的__init__.py文件

#1--------------------------------

在node1中import hello是找不到的，有人说可以找到呀，那是因为你的pycharm为你把myapp这一层路径加入到了sys.path里面，所以可以找到，然而程序一旦在命令行运行，则报错。有同学问那怎么办？简单啊，自己把这个路径加进去不就OK啦：

import sys,os

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(BASE_DIR) #临时修改

import hello

hello.hello1()

#2、--------------

if __name__=='__main__':

    print('ok')

“Make a .py both importable and executable”

如果我们是直接执行某个.py文件的时候，该文件中那么"__name__ == '__main__' "是True，但是我们如果从另外一个.py文件通过import导入该文件的时候，这时__name__的值就是我们这个py文件的名字而不是__main__.

这个功能还有一个用处：调试代码的时候，在"if __name__ == '__main__' "中加入一些我们的调试代码，我们可以让外部模块调用的时候不执行我们的调试代码，但是如果我们想排查问题的时候，直接执行该模块文件，调试代码能够正常运行！

##-------------cal.py

def add(x,y):

    return x+y

##-------------main.py

import cal      #from module import cal

def main():

    cal.add(1,2)

##--------------bin.py

from module import main

main.main()

注意：

# from module import cal 改成 from . import cal同样可以，这是因为bin.py是我们的执行脚本，

# sys.path里有bin.py的当前环境。即/Users/simon/Desktop/whaterver/project/web这层路径，

# 无论import what ,  解释器都会按这个路径找。所以当执行到main.py时，import cal会找不到，因为

# sys.path里没有/Users/simon/Desktop/whaterver/project/web/module这个路径，而

#  from  module/.  import cal 时，解释器就可以找到了。

三、time模块(* * * *)

三种时间表示

在Python中，通常有这几种方式来表达时间：

1、时间戳(timestamp):通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”,返回的是float类型。

2、格式化的时间字符串

3、元祖(struct_time):struct_time元祖共有9个元素：(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

import time

#1、time():  返回当前时间的时间戳

print(time.time())

运行结果如下：

C:\Python35\python3.exe G:/python_s3/day21/example.py

1555996405.5020845

#2、localtime(secs):  将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。

print(time.localtime())

运行结果如下：

C:\Python35\python3.exe G:/python_s3/day21/example.py

time.struct_time(tm_year=2019, tm_mon=4, tm_mday=23, tm_hour=13, tm_min=18, tm_sec=9, tm_wday=1, tm_yday=113, tm_isdst=0)

#3、gmtime([secs])和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区(0时区)的struct_time。

print(time.gmtime())

运行结果如下：

C:\Python35\python3.exe G:/python_s3/day21/example.py

time.struct_time(tm_year=2019, tm_mon=4, tm_mday=23, tm_hour=5, tm_min=21, tm_sec=25, tm_wday=1, tm_yday=113, tm_isdst=0)

#4、mktime(t):  将一个struct_time转化为时间戳

print(time.mktime(time.localtime())) #

运行结果如下：

C:\Python35\python3.exe G:/python_s3/day21/example.py

1555998160.0

#5、asctime([t]):  把一个表示时间的元祖或者struct_time表示为这种形式：'Tue Apr 23 13:45:49 2019'

#如果没有参数，将会将time.localtime()作为参数传入。

print(time.asctime())

运行结果如下：

C:\Python35\python3.exe G:/python_s3/day21/example.py

Tue Apr 23 13:45:49 2019

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

print(time.ctime())  #Tue Apr 23 14:02:45 2019

print(time.ctime(time.time()))  #Tue Apr 23 14:03:50 2019

#7、strftime(format[,t])  #把一个代表时间的元祖或者struct_time(如由time.localtime()和time.gmtime()返回)  转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个元素过界，ValueError的错误将会被抛出。

print(time.strftime("%Y-%m-%d %X",time.localtime()))  #2019-04-23 14:11:12

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

print(time.strptime('2019-04-23 14:15:07', '%Y-%m-%d %X'))

输出结果为：

time.struct_time(tm_year=2019, tm_mon=4, tm_mday=23, tm_hour=14, tm_min=15, tm_sec=7, tm_wday=1, tm_yday=113, tm_isdst=-1)

#在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。

#9、sleep(sesc)

print(time.sleep(3))   #线程推迟指定的时间运行，单位为秒。

#10、clock

# 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是"进程时间"，它是用秒表示的浮点数(时间戳)。而在windows中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间，即两次时间差。

关系图：

四、random模块(* *)

import random

ret=random.random()

# ret=random.randint(1,3)  #[1,3]

# ret=random.randrange(1,3)  #[1,3]

# ret=random.choice([11,22,33,44,55])

# ret=random.sample([11,22,33,44,55],2)

# ret=random.uniform(1,4)

# print(ret)

# ret=[1,2,3,4,5]

# random.shuffle(ret)

# print(ret)

item=[1,3,5,7,9]

random.shuffle(item)

print(item)

#随机生成验证码

import random

def v_code():

    ret=""

    for i in range(5):

        num=random.randint(0,9)

        alf=chr(random.randint(65,122))

        s=str(random.choice([num,alf]))

        ret+=s

    return ret

print(v_code())

五、os模块(* * * *)

os模块是与操作系统交互的接口

os.getcwd()  #获取当前工作目录，即当前python脚本的目录路径

os.chdir("dirname")  #改变当前脚本工作目录，相当于shell下cd

os.cudir  #返回当前目录：(' . ')

os.pardir   #获取当前目录的父目录字符串名：(' . . ')

os.makedirs('dirname1/dirname2')  #可生成多层递归目录

os.removedirs('dirname1')  #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname')  #生成单级目录，相当于linux中mkdir dirname

os.rmdir('dirname')   #删除单级空目录，若目录不为空则无法删除，报错，相当于shell中rmdir dirname

os.listdir('dirname')  #列出指定目录下的所有文件和子目录，包含隐藏文件，并以列表的方式打印

os.remove()  #删除一个文件

os.rename("oldname","newname")  #重命名文件/目录

os.stat('path/filename')   #获取文件/目录信息

例：

print(os.stat("sss.py"))

C:\Python35\python3.exe G:/python_s3/day22/os_test.py

os.stat_result(st_mode=33206, st_ino=11821949021847676, st_dev=2159804260, st_nlink=1, st_uid=0, st_gid=0, st_size=10, st_atime=1556025329, st_mtime=1556025329, st_ctime=1556025302)

os.sep   #输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

os.linesep  #输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"

os.pathsep   #输出用于分隔文件路径的字符 win下为; ,Linux下为：

os.name   #输出字符串指示当前使用平台。win-->'nt'; Linux-->'posix'

os.system("bash command")   #运行shell命令，直接显示

os.environ   #获取系统环境变量

例：

print(os.environ)

environ({'FP_NO_HOST_CHECK': 'NO', 'PUBLIC': 'C:\\Users\\Public', 'PYCHARM': 'D:\\Program Files (x64)\\pycharm软件安装\\config\\PyCharm 2018.3\\bin;', 'COMPUTERNAME': 'DELL-PC', 'PYTHONPATH': 'G:\\python_s3;D:\\Program Files (x64)\\pycharm软件安装\\config\\PyCharm 2018.3\\helpers\\pycharm_matplotlib_backend', 'PYCHARM_HOSTED': '1', 'PYCHARM_MATPLOTLIB_PORT'

os.path.abspath(path)   #返回path规范化的绝对路径

os.path.split(path)   #将path分割成目录和文件名二元组返回

例：

print(os.path.split(r"G:\python_s3\day22\sss.py"))

输出结果：

('G:\\python_s3\\day22', 'sss.py')

os.path.dirname(path)   #返回path的目录。其实就是os.path.split(path)的第一个元素

例：

print(os.path.dirname(r"G:\python_s3\day22\sss.py"))

输出结果：

G:\python_s3\day22

os.path.basename(path)   #返回path最后的文件名，如果path以/ 或 \结尾，那么就会返回空值。即os.path.split(path) 的第二个元素

例：

print(os.path.basename(r"G:\python_s3\day22\sss.py"))

输出结果：

sss.py

os.path.exists(path)   #如果path存在，返回True;如果path不存在，返回False

os.path.isabs(path)   #如果path是绝对路径，返回True

os.path.isfile(path)   #如果path是一个存在的文件，返回True,否则返回False

os.path.isdir(path)   #如果path是一个存在的目录，则返回True，否则返回False

os.path.join(path1,paht2[,  ...])   #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

例：

a="G:\python_s3\day22"

b="sss.py"

print(os.path.join(a,b))

输出结果：

G:\python_s3\day22\sss.py

os.path.getatime(paht)   #返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path)   #返回path所指向的文件或者目录的最后修改时间

六、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       返回操作系统平台名称
#7、sys.stdout.write("please:")    #标准输出，引出进度条的例子，注意，在py3上不行，可以用print代替
#8、sys.stdout.flush()        #刷新缓存

##进度条

import time,sys

for i in range(10):

    sys.stdout.write('#')

    time.sleep(1)

    sys.stdout.flush()

输出结果：

C:\Python35\python3.exe G:/python_s3/day22/sys_test.py

##########

七、json&pickle模块(* * * *)

之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了，所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

用于序列化的两个模块

● json，用于任何语言和 python数据类型间进行转换

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

dic='{"name":"simon"}'

f=open('hello','w')

f.write(dic)

f_read=open('hello','r')

data=f_read.read()

print(type(data)) #读到的文件内容是字符串<class 'str'>

data=eval(data) #将字符串转成字典

print(data['name']) #读取字典name对应的值

输出结果为：

C:\Python35\python3.exe G:/python_s3/day22/json&pickle.py

<class 'str'>

simon

1、什么是序列化？

我们把对象(变量)从内存中变成可储存或传输的过程称之为序列化，在Python中叫pickling,在其他语言中也称之为serialization,marshalling,flattening等。

序列化之后，就可以把序列化后的内容写到磁盘，或者通过网络传输到别的机器上。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpicking。

2、json

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON,因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便的存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

JSON类型	Python类型
{}	dict
[]	list
"string"	str
1234.56	int或float
true/false	True/False
null	None

#1、通过eval处理，只能讲字符串转成字典

dic='{"name":"simon"}'

# f=open('hello','w')

# f.write(dic)

f=open('hello','r')

data=f.read()

print(type(data)) #读到的文件内容是字符串<class 'str'>

data=eval(data)      ##将字符串转成字典

print(data["name"])  #读取字典name对应的值

打印：

<class 'str'>

simon

#2、通过json模块处理python字典

import json

dic={"name":"simon"}   #----------->{"name":"simon"}-------'{"name":"simon"}'

dic_str=json.dumps(dic)

print(dic_str)   #{"name": "simon"}

print(type(dic_str))   #<class 'str'>

f=json.loads(dic_str)  #将json字符串通过loads转成字典的过程

print(f)  #{'name': 'simon'}

print(type(f))  #<class 'dict'>

print(f["name"])  #simon

打印：

{"name": "simon"}

<class 'str'>

{'name': 'simon'}

<class 'dict'>

simon

#2、通过json模块处理python数字

i=8

i=json.dumps(i)  #无论是字典、字符串、列表、整型，json.dumps都会把无论是单引号还是双引号多会转成双引号，然后加单引号变成json字符串

print(i)

p=json.loads(i)

print(type(p))

打印：

8

<class 'str'>

<class 'int'>

#3、通过json模块处理字符串

s='hello'              #----------->"hello"----------->'"hello"'，json.dumps都会把无论是单引号还是双引号都会转成双引号，然后加单引号变成json字符串

s=json.dumps(s)

print(s)

p=json.loads(s) #通过json.loads将dumps后的json字符串转为json支持的数据类型

print(p)

print(type(p))

打印：

"hello"

hello

<class 'str'>

#4、通过json模块处理列表

l=[1,2,3]              #----------->"[1,2,3]"

l=json.dumps(l)

print(l)

print(type(l))

p=json.loads(l)

print(p)  #转成json的列表类型

print(type(p))

打印：

[1, 2, 3]

<class 'str'>

[1, 2, 3]  #处理后的json列表

<class 'list'>

#5、对于文件的操作dumps方法可以用dump替代

f_read=open("new_hello","r")

data=json.loads(f_read.read())   #等价于data=json.load(f_read)

print(data)

print(type(data))

print(data["name"])

#注意点：

import json

#dct="{'1':111}"#json 不认单引号

#dct=str({"1":111})#报错,因为生成的数据还是单引号:{'one': 1}

dct='{"1":"111"}'

print(json.loads(dct))

#conclusion:

#        无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads

注意点

3、pickle

#--------------------pickle------------------

import pickle

dic={'name':'william','age':24,'sex':'male'}

print(type(dic))  #<class 'dict'>

j=pickle.dumps(dic)

print(type(j))   #<class 'bytes'>

f = open('序列化对象_pickle','wb')  #注意是w是写入str，wb是写入bytes，j是'bytes'

f.write(j)       #------------------------等价于pickle.dump(dic,f)

# pickle.dump(dic,f)

f.close()

#----------------------------反序列化

f = open('序列化对象_pickle','rb')

data = pickle.loads(f.read())  #等价于data=pickle.load(f)

print(data['age'])  #24

pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python,并且不同于其他版本的python彼此版本不兼容，因此，只能用pickle保存那些不重要的数据，不能成功地反序列化也没关系。

八、shelve模块(* * *)

import shelve

f = shelve.open(r'shelve')  #目的：将一个字典放入文本 f={}

# f['stu1_info']={'name':'simon','age':'18'}

# f['stu2_info']={'name':'simonn','age':'20'}

# f['school_info']={'website':'baidu.com','city':'beijing'}

#

#

# f.close()

print(f.get('stu1_info')['age'])   #18

九、xml模块(* * *)

xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

xml的格式如下，就是通过<>节点来区别数据结构的:

<?xml version="1.0"?>

<data>

    <country name="Liechtenstein">

        <rank updated="yes">2</rank>

        <year>2008</year>

        <gdppc>141100</gdppc>

        <neighbor name="Austria" direction="E"/>

        <neighbor name="Switzerland" direction="W"/>

    </country>

    <country name="Singapore">

        <rank updated="yes">5</rank>

        <year>2011</year>

        <gdppc>59900</gdppc>

        <neighbor name="Malaysia" direction="N"/>

    </country>

    <country name="Panama">

        <rank updated="yes">69</rank>

        <year>2011</year>

        <gdppc>13600</gdppc>

        <neighbor name="Costa Rica" direction="W"/>

        <neighbor name="Colombia" direction="E"/>

    </country>

</data>

xml数据

xml协议在各个语言里的都是支持的，在python中可以用以下模块操作xml：

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")

root = tree.getroot()

print(root.tag)

#遍历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)

#---------------------------------------

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")

root = tree.getroot()

#修改

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) #打印生成的格式

十、re模块(* * * * *)

1、什么是正则？

正则就是用一些具有特殊含义的符号组合到一起(称为正则表达式)来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。(在python中)它内嵌在Python中，并通过re模块实现。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。

字符匹配(普通字符，元字符)：

1、普通字符：大多数字符和字母都会和自身匹配

>>> re.findall("zhurui","FREWRFVZHURzhuruiSIMONsimon")
['zhurui']
>>>

2、元字符：. ^ $ * + ? {} [] | () \

1、元字符之( . ^ $ * + ? { } )

import re

ret=re.findall('si..n','qwerwrsimonreorerge') #['simon']

print(ret)

ret=re.findall('^s...n','simonreorserpnerge') #['simon']

print(ret)

ret=re.findall('s...n','simonreorserpnerge') #['simon', 'serpn']

print(ret)

ret=re.findall('s...n$','simonreorserpnergesrren') #['srren']

print(ret)

ret=re.findall('^s*','sssasdfgdsjjuresssss')  #['sss'],*:表示0到无穷次  +：表示1到无穷次

print(ret)

ret=re.findall('alex*','asdfhfalexxx')  #

print(ret) #['alexxx']

ret=re.findall('alex+','asdfhfalexxx')  #[1,+oo]

print(ret)  #['alexxx']

ret=re.findall('alex*','asdfhfale')  #['ale']

print(ret)

ret=re.findall('alex+','asdfhfale')  #[]

print(ret)

ret=re.findall('simon?','asdhfsimonnn')  #[0,1],?:表示匹配0到1个

print(ret) #['simon']

ret=re.findall('simon{1,3}','asdhfsimonnnnnn')  #['simonnn'] 贪婪匹配

print(ret)

注意：前面*，+，？等都是贪婪匹配，也就是尽可能多匹配，后面加?号使其变成惰性匹配

ret=re.findall('abc*?','abcccccc')

print(ret)  #['ab']

2、元字符之字符集[ ]:

##---------------------------字符集[]

ret=re.findall('www[simon  baidu]','wwwbaidu')

print(ret)

ret=re.findall('x[yz]','xyuuuu')

print(ret)

ret=re.findall('x[yz]','xyuuxzuu') #['xy', 'xz']

print(ret)

ret=re.findall('x[yz]p','xypuuxzpuu') #['xyp', 'xzp']

print(ret)

ret=re.findall('x[y,z]p','xypuuxzpux,pu') #['xyp', 'xzp', 'x,p']

print(ret)

ret=re.findall('q[a*z]','xypuuxzpqaa') #['qa']

print(ret)

ret=re.findall('q[a-z]*','quouuiuni') #['quouuiuni']

print(ret)

ret=re.findall('q[a-z]*','quouuiuni9') #['quouuiuni']

print(ret)

ret=re.findall('q[0-9]*','q8910uouuiuni9') #['q8910']

print(ret)

ret=re.findall('q[0-9]*','q8910uouuiuniq9') #['q8910', 'q9']

print(ret)

ret=re.findall('q[^a-z]*','q821') #['q821']

print(ret)

3、元字符之转义符\

反斜杠后边跟元字符去除特殊功能,比如\.
反斜杠后边跟普通字符实现特殊功能,比如\d

\d  匹配任何十进制数；它相当于类 [0-9]。

\D 匹配任何非数字字符；它相当于类 [^0-9]。

\s  匹配任何空白字符；它相当于类 [ \t\n\r\f\v]。

\S 匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v]。

\w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。

\W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]

\b  匹配一个特殊字符边界，比如空格 ，&，＃等

import re

print(re.findall("^I","hello I am LIST"))

print(re.findall(r"I\b","hello I am LIST")) #['I']

print(re.findall("I\\b","hello I am LIST")) #['I']

print(re.findall(r"c\\l","abc\lerwt")) #['c\\l']

print(re.findall("c\\\\l","abc\lerwt")) #['c\\l']

4、元字符之分组()

m = re.findall(r'(ad)+','add')

print(m)

ret=re.search('(?P<id>\d{2})/(?P<name>\w{3})','23/com')

print(ret.group()) # 23/com

print(ret.group('id')) #23

ret=re.search("(?P<name>[a-z]+)\d+","123simon27zhurui24william45").group()

print(ret) #simon27

ret=re.search("(?P<name>[a-z]+)\d+","123simon27zhurui24william45").group('name')

print(ret) #simon

ret=re.search("(?P<name>[a-z]+)(?P<age>\d+)","123simon27zhurui24william45").group('age') #.group是固定格式

print(ret) #27

5、元字符之 |

ret=re.search('(ab)|\d','rabhdg8sdgrui') #ab

print(ret.group())

6、re模块下的常用方法

import re

#方法1

print(re.findall("s","simon zhu"))   #['s']，返回所有满足匹配条件的结果，放在列表里

#方法2

ret=re.search("(?P<name>[a-z]+)(?P<age>\d+)","123simon27zhurui24william45").group('age') #函数会在字符串内查找模式匹配，只找到第一个匹配然后返回一个包含匹配信息的对象，该对象可以通过调用group()方法得到匹配的字符串，如果字符串没有匹配，则返回None

print(ret) #27

#方法3

print(re.match("\d+","23simon24zhurui23will78")) #同search,不过尽在字符串开始处进行匹配

#方法4

ret=re.split("[ab]","abcd") #先按'a'分割得到' ' 和'bcd'，在对' '和'bcd'分别按'b'分割

print(ret) #['', '', 'cd']

#方法5

 ret=re.sub('\d','abc','simon7zhurui9',1)

print(ret) #simonabczhurui9

ret=re.subn('\d','abc','alvin5yuan6')

print(ret)#('alvinabcyuanabc', 2)

#方法6

obj=re.compile('\d{3}')

ret=obj.search('abc123eeee')

print(ret.group())#123

ret=re.finditer('\d','ds3sy4784a')

print(ret)        #<callable_iterator object at 0x10195f940>

print(next(ret).group())

print(next(ret).group())

注意：

ret=re.findall('www.(baidu|oldboy).com','www.oldboy.com')

print(ret)#['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')

print(ret)#['www.oldboy.com']

ret=re.findall("www\.(baidu|163)\.com","fddsfsfdwww.baidu.comrerggetbbvfd")

print(ret) #['baidu']

ret=re.findall("www\.(?:baidu|163)\.com","fddsfsfdwww.baidu.comrerggetbbvfd")

print(ret) #['www.baidu.com']

补充：

import re

print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>"))

print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>"))

print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>"))

补充2：

#匹配出所有的整数

import re

#ret=re.findall(r"\d+{0}]","1-2*(60+(-40.35/5)-(-4*3))")

ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")

ret.remove("")

print(ret)

正文