简学Python第五章__模块介绍，经常使用内置模块

Python第五章__模块介绍，经常使用内置模块

 

欢迎加入Linux_Python学习群

  群号：478616847

 

目录：

• 模块与导入介绍

• 包的介绍
  

• time &datetime模块

• random

• os

• sys

• shutil

• json & pickle

• xml处理

• configparser

• hashlib

• subprocess

• logging模块

• re正则表达式

 

1、模块与包介绍

　　模块是某个功能代码的集合，模块是一种组织形式，它将彼此有关系的python代码组织到一个个文件中，模块能够包含可执行代码,

　　函数和类或者这些东西的组合。一个模块建立以后， 你能够从另外一个模块中使用 import 语句导入这个模块来使用。想一想看写一个大

　　的项目的时候是否是有不少代码，那么咱们就须要使用模块把这些代码按照功能结构进行划分，放在不一样的目录或者是包中。

　　形象的来讲模块就是有一些功能的py文件，咱们经过import能够导入这个功能模块，并使用它

　　模块分为三种：

　　　　内置模块

　　　　三方开源模块

　　　　自定义模块

 

　　内置模块:

　　在安装完成python后，python自己就带有库，这个库叫作python内置库，那么内置模块也被称之为标准库

　　三方开源模块:

　　那么python内置的模块，有不少不能知足咱们的需求，那么就会有不少人去本身写模块，而且把它开源出来，就是三方模块、

　　那么这些三方模块，会有一些统一下载的地方，三方模块下载地址 这个地址是pip的网站，里面如今收录了99886个三方模块

　　这么多的三方模块得益于开源精神，因此咱们也是能够在这个网站上上传本身的模块供你们使用。

自定义模块:

自定义模块就是你本身写的代码组成的功能，这些功能称之为一个模块

 

导入模块

模块是有了，可是要在本身的代码中使用模块，是须要导入的，导入的方式有如下这么几种

 1  import module
 2  from module import xx
 3  from module import xx as rename
 4  from module import *
 5 
 6 
 7 import sys
 8 print(sys.path)
 9 
10 from sys import path
11 print(path)
12 
13 from sys import path as new_path
14 print(new_path)
15 
16 from sys import *
17 print(path)
18 print(argv)

导入模块

import sys 直接导入sys模块，想要用sys模块的功能须要 sys.path (拿path举例)

from sys import path 导入sys模块中的path功能，使用时直接使用path

from sys import path as new_path 导入sys模块中的path功能，并经过as 给path功能重命名，使用时直接使用新名字便可这个功能主要分防止功能名冲突

from sys import *导入sys模块中的全部功能，使用时直接用功能名便可

导入自定义模块

导入自定义模块其实也很是简单，首先在同级目录下咱们有main.py和print_mode.py两个文件，在print_mode python文件中定义一个函数内容以下

1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3 
4 
5 def new_print(arg):
6     print("\033[31m%s\033[0m"%arg)

print_mode

而后咱们在main.py文件使用new_print这个函数，下面演示了上面的四种导入方法

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 import print_mode
 4 print_mode.new_print("Hello world")
 5 
 6 
 7 from print_mode import new_print
 8 new_print("Hello world")
 9 
10 
11 from print_mode import new_print as pr
12 pr("Hello world")
13 
14 
15 from  print_mode import *
16 new_print("Hello world")

导入使用自定义模块　

注意在上面我把同级目录下加粗了，也就说这种方法只能导入同级目录下的自定义模块，下面介绍如何导入不是同级目录下的模块

一、首先咱们知道，操做系统有默认的环境变量，好比想要在cmd中使用python就须要在PATH环境变量中加入python的安装目录

那么若是咱们想要导入其它目录下自定义模块，也要给python的PATH变量中加入模块所在的目录，个人目录结构如图

要知道的是咱们的程序在其它计算机上面使用是安装到不一样位置的，因此咱们确定不能再PATH环境变量中添加当前主机的程序位置

因此用os.path.abspath(__file__)获得当前文件绝对路径，而后咱们要获得bin目录的上层目录，由于只有这样才能找到mode目录

经过os.path.dirname(os.path.abspath(__file__))获得的是bin目录的绝对路径，也就是如今这句话获得的是 bin目录，咱们的

目的是获得test目录因此os.path.dirname(os.path.dirname(os.path.abspath(__file__)))，获得test目录的绝对路径了，接下来

把获得的绝对路径经过sys.path.appen加入到python环境变量里面，那么咱们就能够导入mode目录下的python_mode模块了

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 
 4 import os,sys
 5 
 6 print(os.path.abspath(__file__))
 7 print(os.path.dirname(os.path.abspath(__file__)))
 8 print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 9 
10 
11 print("原：",sys.path)
12 base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
13 sys.path.append(base_dir)
14 print("新：",sys.path)
15 
16 from mode import print_mode
17 print_mode.new_print("Hello world")

导入其它目录中的自定义模块main（文件内容）

注意！若是在print_mode文件中有一个print（）语句，那么在print_mode文件被第一次导入的时候就会执行这个print语句，这是由于

第一次导入的时候会把print_mode文件内容加载到内存，为了防止你重复导入，python的优化手段会把后续的import语句仅是对已经加

载大内存中的模块对象增长了一次引用，不会从新执行模块内的语句。

第三方模块的安装

安装第三方模块咱们可使用pip和源码进行安装，源码安装只须要作如下的操做

以paramiko模块为例，第三方模块在安装过程当中就在Python的PATH环境变量中，所以用法和内置模块同样

 1 # pip install paramiko  pip安装方式
 2 
 3 # pycrypto，因为 paramiko 模块内部依赖pycrypto，因此先下载安装pycrypto
 4  
 5 # 下载安装 pycrypto
 6 wget http://files.cnblogs.com/files/wupeiqi/pycrypto-2.6.1.tar.gz
 7 tar -xvf pycrypto-2.6.1.tar.gz
 8 cd pycrypto-2.6.1
 9 python setup.py build
10 python setup.py install
11  
12 # 进入python环境，导入Crypto检查是否安装成功
13  
14 # 下载安装 paramiko
15 wget http://files.cnblogs.com/files/wupeiqi/paramiko-1.10.1.tar.gz
16 tar -xvf paramiko-1.10.1.tar.gz
17 cd paramiko-1.10.1
18 python setup.py build
19 python setup.py install
20  
21 # 进入python环境，import paramiko检查是否安装成功便可

安装第三方模块

更多运维中经常使用的第三方模块请参考 Python自动化运维

 

2、包的介绍

包是一种经过使用"  .模块名  "来组织python模块名称空间的方式，其实python中的包 就是一个包含__init__.py文件的目录。模块称之为文件

那么包就是文件的集合，在咱们使用目录来存储模块，会形成模块名冲突的问题，那么包就能够有效地避免模块名冲突的问题,在学习包以前

首先建立了一个根目录目录和app,bin,config这三个包，每一个包里都有py文件

 1 #app_one
 2 def conf_app_one():
 3     print("From app_one")
 4 
 5 #app_two
 6 def conf_app_two1():
 7     print("From 1 app_two.py")
 8 
 9 def conf_app_two2():
10     print("From 2 app_two.py")
11 
12 #conf
13 def conf_func():
14     print("From conf.py")

文件内容

　　

导入包

包的导入也分为import，和from...import，import导入语句也是导入同级目录的因此这里不作演示 不管是import形式仍是from...import形式，凡是在导入语

句中（而不是在使用时）遇到带点的，都是关于包才有的导入语法,而且from后面的import导入的模块是不能带点的，因此点的左边必须是一个包

错误方法：from aa import bb.c

第一次导入包的时候，会执行包中的 __init__.py文件，首先咱们能够在config模块中的 __init__.py 写一句 print，而后在main。py中导入 config模块试一下

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 import os,sys
5 path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
6 sys.path.append(path)
7 
8 from config import conf

导入模块触发__init__

当咱们运行main.py 后就触发了在config模块中的 __init__.py 的print语句

 

__all__

那么这个__init__.py还能干什么事呢？

此次咱们导入 app包下的模块，看看*能不能把app下面的文件所有导入进来

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 
 5 #main文件
 6 import os,sys
 7 path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 8 sys.path.append(path)
 9 
10 from app import *
11 
12 app_one.conf_app_one()
13 app_two.conf_app_two1()

__all__的做用

然而咱们一运行发现报错，说app_one没有定义！

这不科学，安装道理说from app import *应该导入 app包下的全部py文件啊！其实在app下的__init__文件中加入__all__ = ["app_one","app_two"]，就能够这样调用了。

最后咱们来看正常导入的方式

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 import os,sys
 5 path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 6 sys.path.append(path)
 7 
 8 from app import app_two
 9 app_two.conf_app_two1()
10 
11 from app import app_two as two
12 two.conf_app_two2()
13 
14 from app.app_one import *
15 conf_app_one()

包的导入

 

pyc文件

有一天我忽然打开包的目录，突然发现，目录中多出了__pycache__的文件夹，里面有.pyc的文件，在好奇心的驱使下我百度出它的真面目

原来python为了提升模块的加载速度，Python缓存编译的版本，每一个模块在__pycache__目录下有着以module.version.pyc的形式命名

的文件，这些文件名包含了python的版本号，模块名，如CPython版本3.5，而且Python会检查源文件的修改时间与编译的版本进行对比，

若是过时就须要从新编译。这是彻底自动的过程。不一样的版本编译后的pyc文件不一样，2.5编译的pyc文件不能到3.5上执行，而且pyc文件是

能够反编译的，于是它的出现仅仅是用来提高模块的加载速度的。

 

3、time &datetime模块

接下来开始学习经常使用的内置模块，内置模块就是集成在python中的工具包，咱们要学习经常使用的工具包的用法，这些用法很是简单

在平时的代码中，常常要与实际打交道　与时间处理有关的模块就包括：time，datetime以及calendar这里讲解前两个模块

 

Time模块

python中一般有这几种形式来表示时间：一、时间戳  二、格式化的时间字符串 三、元祖

一、time.localtime()会经过time.struct_time的class类转换成特殊时间的格式，括号中能够传入时间戳，若是不传入则用的是当前时间，咱们能够经过下标取出对应的值

time.struct_time(tm_year=2017, tm_mon=3, tm_mday=10, tm_hour=15, tm_min=53, tm_sec=53, tm_wday=4, tm_yday=69, tm_isdst=0)

二、time.gmtime()与time.localtime()方法相似，只不过会把当前时间转换成0时区的时间

time.struct_time(tm_year=2017, tm_mon=3, tm_mday=10, tm_hour=16, tm_min=1, tm_sec=16, tm_wday=4, tm_yday=69, tm_isdst=0)

time.struct_time(tm_year=2017, tm_mon=3, tm_mday=10, tm_hour=8, tm_min=1, tm_sec=16, tm_wday=4, tm_yday=69, tm_isdst=0)

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

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

五、time.sleep(secs)：线程推迟指定的时间运行。单位为秒，能够是小数

六、time.clock()：在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。

而第二次以后的调用是自第一次调用之后到如今的运行时间。

七、time.asctime([t])：把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。若是没有参数，将会将time.localtime()做为参数传入。

八、time.ctime([secs])：把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。若是参数未给或者为None的时候，将会默认time.time()为参数。

它的做用至关于time.asctime(time.localtime(secs))。

 

输出自定义的日期格式

1 import time
2 
3 print(time.strftime("%Y:%m:%d,%H",time.localtime(time.time())))

自定义日志输出格式

能够看到其中双引号的内容就是调用了下面的格式

 

datetime模块

这个模块能够理解为data和time两个部分，主要用于时间的加减，也能够计算时间差

 1 import datetime
 2 import time
 3 
 4 #返回 当前时间
 5 print(datetime.datetime.now())
 6 # 时间戳直接转成日期格式 2016-08-19
 7 print(datetime.date.fromtimestamp(time.time()) )
 8 
 9 #当前时间+3天
10 print(datetime.datetime.now() + datetime.timedelta(3))
11 #当前时间-3天
12 print(datetime.datetime.now() + datetime.timedelta(-3))
13 #当前时间+3小时
14 print(datetime.datetime.now() + datetime.timedelta(hours=3))
15 #当前时间+30分
16 print(datetime.datetime.now() + datetime.timedelta(minutes=30))
17 
18 #时间替换
19 c_time  = datetime.datetime.now()
20 print(c_time.replace(minute=3,hour=2))
21 
22 
23 #计算时间差，返回天数
24 datas = "2016-08-19"
25 def Repayment(past_time):
26     def conversion(str_data):#把每一个元素变成int类型
27         data_list = str_data.split("-")
28         for i in data_list:data_list[data_list.index(i)] = int(i)
29         return data_list
30     #获得新老时间的列表
31     new_time_list = conversion(time.strftime("%Y-%m-%d",time.localtime(time.time())))
32     past_time_list = conversion(past_time)
33     n_time = datetime.datetime(new_time_list[0],new_time_list[1],new_time_list[2])
34     p_time = datetime.datetime(past_time_list[0],past_time_list[1],past_time_list[2])
35     return ((n_time - p_time).days)
36 print(Repayment(datas))

datatime

 

4、random

生成随机数

 1 #!/usr/bin/env python
 2 
 3 import random
 4 
 5 #生成一个0到1的随机浮点数
 6 print(random.random())
 7 
 8 #用于生成一个指定范围内的随机符点数
 9 print( random.uniform(10, 20))
10 print( random.uniform(10, 20))
11 
12 #用于生成一个指定范围内的整数。
13 print(random.randint(10, 20))
14 
15 #指定范围内，按指定基数递增的集合中 获取一个随机数。
16 #例子中也就是只会从 10 12 14 ... 18取得随机数，第三个参数为2的时候也就是取偶数
17 print(random.randrange(10,20, 2))
18 
19 #从序列中获取一个随机元素。
20 data_str = "I love Python"
21 data_list = [1,2,3,4,5,6]
22 data_tuple = ("A","B","C","D","E")
23 print(random.choice(data_str))
24 print(random.choice(data_list))
25 print(random.choice(data_tuple))
26 
27 #用于将一个列表中的元素打乱。
28 data_list = [1,2,3,4,5,6]
29 random.shuffle(data_list)
30 print(data_list)
31 
32 #从指定序列中随机获取指定长度的片段
33 data_list = [1,2,3,4,5,6]
34 print(random.sample(data_list,3))

random用法

小例子：生成随机的验证码

 1 #!/usr/bin/env python
 2 
 3 import random
 4 # 初版
 5 def code(number):
 6     '''
 7     随机数生成器
 8     '''
 9     number_check = ''
10     for i in range(0,number):
11         number_curr = random.randrange(0,5)
12         if number_curr != i:
13             number_temp = chr(random.randint(97,122))
14         else:
15             number_temp = random.randint(0,9)
16         number_check += str(number_temp)
17     return number_check
18 print(code(5))
19 
20 # 第二版
21 import string
22 source = string.digits + string.ascii_uppercase + string.ascii_lowercase
23 print("".join(random.sample(source, 4)))

生成随机验证码或者密码

 

5、os

os模块以前咱们接触了与文件相关的发放，os模块还有不少与操做系统交互的函数

 1 os.getcwd() 获取当前工做目录，即当前python脚本工做的目录路径
 2 os.chdir("dirname")  改变当前脚本工做目录；至关于shell下cd
 3 os.curdir  返回当前目录: ('.')
 4 os.pardir  获取当前目录的父目录字符串名：('..')
 5 os.makedirs('dirname1/dirname2')    可生成多层递归目录
 6 os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
 7 os.mkdir('dirname')    生成单级目录；至关于shell中mkdir dirname
 8 os.rmdir('dirname')    删除单级空目录，若目录不为空则没法删除，报错；至关于shell中rmdir dirname
 9 os.listdir('dirname')    列出指定目录下的全部文件和子目录，包括隐藏文件，并以列表方式打印
10 os.remove()  删除一个文件
11 os.rename("oldname","newname")  重命名文件/目录
12 os.stat('path/filename')  获取文件/目录信息
13 os.sep    输出操做系统特定的路径分隔符，win下为"\\",Linux下为"/"
14 os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
15 os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
16 os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
17 os.system("bash command")  运行shell命令，直接显示
18 os.environ  获取系统环境变量
19 os.path.abspath(path)  返回path规范化的绝对路径
20 os.path.split(path)  将path分割成目录和文件名二元组返回
21 os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
22 os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
23 os.path.exists(path)  若是path存在，返回True；若是path不存在，返回False
24 os.path.isabs(path)  若是path是绝对路径，返回True
25 os.path.isfile(path)  若是path是一个存在的文件，返回True。不然返回False
26 os.path.isdir(path)  若是path是一个存在的目录，则返回True。不然返回False
27 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径以前的参数将被忽略
28 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
29 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
30 os.path.normpath(path)  #规范化路径，转换path的大小写和斜杠

os模块

 

6、sys

sys模块也是比较经常使用的模块，好比获取命令执行python是后面的参数

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    返回操做系统平台名称

sys功能

 

7、shutil

shutil是一种高层次的文件操做工具，提供了大量的文件高级操做（能够用print(help(shutil))来查看），好比 拷贝删除，压缩等等

 1 #!/usr/bin/env python
 2 
 3 import shutil
 4 
 5 #一、将文件拷贝到另外一个文件中
 6 shutil.copyfileobj(open('test','r'), open('test2', 'w'))
 7 
 8 #二、拷贝文件
 9 shutil.copyfile('test', 'test2.conf')
10 
11 #三、拷贝权限 内容、组、用户均不变（目标文件必须存在）
12 shutil.copymode('test', 'test2.conf')
13 
14 #四、仅拷贝状态的信息，包括：mode bits, atime, mtime, flags（目标文件必须存在）
15 shutil.copystat('test', 'test2.conf')
16 
17 #五、拷贝文件和权限
18 shutil.copy('test', 'test3')
19 
20 #六、拷贝文件和状态信息
21 shutil.copy2('test', 'test3')
22 
23 #七、递归的去拷贝文件夹
24 shutil.copytree('testlist', 'test2list', ignore=shutil.ignore_patterns('main.py',))
25 """目标目录不能存在，注意对test2list目录父级目录要有可写权限，
26 ignore的意思是排除，这里表示不拷贝main.py文件，多个能够用逗号隔开，也能够用*.py"""
27 
28 #拷贝软链接
29 shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc'))
30 #一般的拷贝都把软链接拷贝成硬连接，即对待软链接来讲，建立新的文件
31 
32 #八、递归的去删除文件
33 shutil.rmtree('test2list')
34 
35 #九、递归的去移动文件，它相似mv命令，其实就是重命名。
36 shutil.move("testlist", "testlist2")

shutil

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

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

• • base_name： 压缩包的文件名，也能够是压缩包的路径。只是文件名时，则保存至当前目录，不然保存至指定路径，
  • 如 data_bak =>保存至当前路径
  • 如：/tmp/data_bak =>保存至/tmp/
  • format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
  • root_dir： 要压缩的文件夹路径（默认当前目录）
  • owner： 用户，默认当前用户
  • group： 组，默认当前组
  • logger： 用于记录日志，一般是logging.Logger对象

 1 #!/usr/bin/env python
 2 
 3 import shutil
 4 
 5 #打包当前目录下的testlist目录，打包成a_bk.zip
 6 #支持方法"zip", "tar", "bztar" "gztar".
 7 tar = shutil.make_archive("a_bk","zip",root_dir="./testlist")
 8 
 9 #把打包结果文件刚在/mnt/目录下
10 tar2 = shutil.make_archive("/mnt/a_bk","gztar",root_dir="./testlist")

打包

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的

 

8、json & pickle

在程序运行的过程当中，变量都是在变化的，而且当程序结束后变量将消失，那么为了让程序下次运行的时候还能够用上次的变量，就须要对这些变量，字典，列表经过

序列化保存在文件中，下一次读取文件中的内容进行反序列化就可获得上次运行时的变量数据，那么json和pickle是用于数据序列化的模块，有些童鞋会常常听见开发说

，这个Api返回的是一串json，因此json就是不一样平台直接传输数据的，由于在java中在html中都支持json格式的数据

Json和Pickle 都提供了四个功能：dumps、dump、loads、load

Json 

 1 #!/usr/bin/env python
 2 import json
 3 
 4 #-----------序列化---------#
 5 dic = {"name":'aaa',"age":22,}
 6 lis = [1,2,3,"4"]
 7 
 8 with open("test","w") as file:
 9     file.write(json.dumps(dic))
10 with open("test2","w") as file:
11     json.dump(lis,file)
12 
13 #----------反序列化---------#
14 with open("test","r") as file:
15     data_dic = json.loads(file.read())
16 with open("test2","r") as file:
17     data_lis = json.load(file)
18 print(type(data_lis),":",data_lis)
19 print(type(data_dic),":",data_dic)

Json

注！Json不能保存函数和类对象，可是Pickle能够

 

Pickle，是python独有的，其它语言并不支持，而且保存的数据类时要用bytes方式写入

 1 #!/usr/bin/env python
 2 import pickle
 3 
 4 #-----------序列化---------#
 5 dic = {"name":'aaa',"age":22,}
 6 def func():
 7     return "Hello"
 8 
 9 with open("test","wb") as file:
10     file.write(pickle.dumps(dic))
11 with open("test2","wb") as file:
12     pickle.dump(func,file)
13 
14 #----------反序列化---------#
15 with open("test","rb") as file:
16     data_dic = pickle.loads(file.read())
17 with open("test2","rb") as file:
18     data_func = pickle.load(file)
19 print(type(data_func),":",data_func)
20 print(data_func())
21 print(type(data_dic),":",data_dic)

Pickle

 

9、xml处理

　　xml也是实现不一样语言或程序之间的数据交互，跟json差很少，它是诞生在json以前，现在不少传统公司和金融行业的系统主要的

　　接口仍是xml

　　xml数据格式以下

 1 <?xml version='1.0' encoding='utf-8'?>
 2 <userdata>
 3     <name Name="XiaoMing">
 4         <age>22</age>
 5         <gender>Men</gender>
 6     </name>
 7     <name Name="XiaoHong">
 8         <age>19</age>
 9         <gender>Women</gender>
10     </name>
11 </userdata>

xml文件

建立上面内容的xml文件

 1 #生成 最外层的<userdata>
 2 new_xml = ET.Element("userdata")
 3 
 4 #生成<name Name="XiaoMing">
 5 name1 = ET.SubElement(new_xml,"name",attrib={"Name":"XiaoMing"})
 6 #生成<name Name="XiaoMing">中的<age>22</age>
 7 age = ET.SubElement(name1,"age")
 8 age.text = "22"
 9 #生成<name Name="XiaoMing">中的<gender>Men</gender>
10 gender = ET.SubElement(name1,"gender")
11 gender.text = "Men"
12 
13 #生成<name Name="XiaoHong">
14 name2 = ET.SubElement(new_xml,"name",attrib={"Name":"XiaoHong"})
15 #生成<name Name="XiaoHong">中的<age>19</age>
16 age = ET.SubElement(name2,"age")
17 age.text = '19'
18 #生成<name Name="XiaoHong">中的<gender>Women</gender>
19 gender = ET.SubElement(name2,"gender")
20 gender.text = "Women"
21 
22 et = ET.ElementTree(new_xml) #生成文档对象
23 et.write("test.xml", encoding="utf-8",xml_declaration=True)#写入

生成xml文件

读取xml文件内容

 1 #获取最外层的<userdata>
 2 tree = ET.parse("test.xml")
 3 root = tree.getroot()
 4 print(root.tag)
 5 print("-----------------遍历xml文档------------------")
 6 #遍历xml文档
 7 for child in root:
 8     print(child.tag,child.attrib)#打印<name Name="XiaoMing">和<name Name="XiaoHong">
 9     for i in child:
10          print(i.tag,i.text)#分别打印年龄和性别
11 
12 print("-----------------只遍历age 节点------------------")
13 #只遍历age 节点
14 for node in root.iter("age"):
15     print(node.tag,node.text)

读取xml文件内容

更改删除xml文件内容

 1 import xml.etree.ElementTree as ET
 2 
 3 print("--------------------年龄加1------------------")
 4 tree = ET.parse("test.xml")
 5 root = tree.getroot()
 6 
 7 for node in root.iter('age'):
 8     node.text = str(int(node.text) + 1)#年龄加一
 9     node.set("updated","yes") #增长属性 updated=“yex”
10 tree.write("test.xml")#写入
11 
12 
13 print("----------------删除年龄大于20的-------------")
14 tree = ET.parse("test.xml")
15 root = tree.getroot()
16 
17 for country in root.findall('name'):#循环name标签，[<Element 'name' at 0x009F4180>, <Element 'name' at 0x009F4240>]
18    rank = int(country.find('age').text)#获取name标签下的年龄
19    if rank > 20:#判断年龄是否大于20
20      root.remove(country)#若是大则删除
21 tree.write('test.xml')#写入

更改删除xml文件内容

 

10、configparser

　　这个内置模块呢通常用处用来作配置文件的操做,能够操做如下格式的文件

1 [www.test.org]
2 user = test
3 port = 20012
4 
5 [www.test2.org]
6 user = test2
7 port = 20011
8 forwardx11 = no

文件内容

　　语法：读操做

　　-read(filename) 直接读取文件内容 
　　-sections() 获得全部的section，并以列表的形式返回 
　　-options(section) 获得该section的全部option 
　　-items(section) 获得该section的全部键值对 
　　-get(section,option) 获得section中option的值，返回为string类型 
　　-getint(section,option) 获得section中option的值，返回为int类型

　　写操做
　　-add_section(section) 添加一个新的section
　　-set( section, option, value) 对section中的option进行设置

　　示例代码

 1 #!/usr/bin/env python
 2 
 3 import configparser
 4 import time
 5 
 6 conf = configparser.ConfigParser()
 7 conf.read('conf')
 8 
 9 print("----------------读----------------")
10 #获得全部的section，并以列表的形式返回
11 print(conf.sections())
12 #获得该section的全部option
13 print(conf.options('www.test.org'))
14 #获得该section的全部键值对
15 print(conf.items('www.test2.org'))
16 print(conf.get('www.test2.org',"User"))#获得section中option的值，返回为string类型
17 time.sleep(2)
18 
19 print("----------------改----------------")
20 conf.set('www.test2.org','port',"1234")
21 conf.write(open('conf', "w"))
22 time.sleep(2)
23 
24 print("----------------判断---------------")
25 print(conf.has_section('www.test2.org'))
26 time.sleep(2)
27 
28 print("----------------删----------------")
29 #删除section中的option
30 conf.remove_option('www.test.org','port')
31 #删除section
32 conf.remove_section('www.test.org')
33 conf.write(open('conf', "w"))
34 time.sleep(2)
35 
36 print("----------------写----------------")
37 #添加section
38 conf.add_section('www.test3.org')
39 #添加section中的option
40 conf.set('www.test3.org','port',"222")
41 conf.write(open('conf', "w"))

configparser操做

 

11、hashlib

　　hashlib在python3中代替了MD5和sha模块，主要提供了SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法，在python3中已经废弃了

　　md5和sha模块，其中最为经常使用的MD5算法，咱们常常看到下载一个光盘镜像的时候，后面会告诉你一个MD5值，这个就是用来作文件完整性验证的

　　因此同一种字符串计算出来的MD5值是同样的

　　特色：一、相同的内容hash运输的结果是相同的二、这种计算是不可逆的三、相同算法，不管校验多长的数据，获得的哈希值长度固定。

　　以常见的摘要算法MD5为例，计算出一个字符串的MD5值：

 1 #!/usr/bin/env python
 2 
 3 import  hashlib
 4 
 5 #首先定义一个hashlib的对象
 6 ha = hashlib.md5()#用的md5加密方式,这里还能够用SHA1, SHA224, SHA256, SHA384, SHA512算法
 7 ha.update("Hello".encode("utf-8"))
 8 print(ha.hexdigest())#返回16进制
 9 print(ha.digest())#返回二进制
10 #结果 8b1a9953c4611296a827abf8c47804d7  b"\x8b\x1a\x99S\xc4a\x12\x96\xa8'\xab\xf8\xc4x\x04\xd7"

hashlib

 

12、subprocess

subprocess用于执行本地命令，它是经过管道的形式，链接到他们的输入/输出/错误,并得到他们的返回代码。

示例代码：（官方介绍）

 1 import subprocess
 2 #执行命令，若是命令结果为0，就正常返回，不然抛异常
 3 retcode = subprocess.call(["ls", "-l"])
 4 
 5 #接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果
 6 results = subprocess.getstatusoutput('ls /bin/ls')
 7 print(results)
 8 
 9 #接收字符串格式命令，并返回结果
10 print(subprocess.getoutput('ls /bin/ls'))
11 
12 #执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res
13 res=subprocess.check_output(['ls','-l'])
14 print(res)
15 
16 #调用subprocess.run(...)是推荐的经常使用方法，在大多数状况下能知足需求，
17 subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)

subprocess

 

其实上面的方法都是对Popen的封装subprocess模块中只定义了Popen这个类，咱们可使用Popen来建立进程，并与进程进行复杂的交互。

这个模块将取代 os.system 和 os.spawn*，Popen这个类其中能够跟不少参数。 

args	shell命令，能够是字符串或者序列类型（如：list，元组）
bufsize	指定缓冲： 0:无缓冲 1:行缓冲 其余正值:缓冲区大小 负值:采用默认系统缓冲(通常是全缓冲)
executable	通常不用吧，args字符串或列表第一项表示程序名
stdin stdout stderr	分别表示程序的标准输入、输出、错误句柄
preexec_fn	钩子函数， 只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行以前被调用
close_fds	unix 下执行新进程前是否关闭0/1/2以外的文件
	在windows平台下，若是close_fds被设置为True，则新建立的子进程将不会继承父进程的输入、输出、错误管道。 因此不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
shell	为真的话 unix下至关于在命令前面添加了 "/bin/sh” ”-c” window下，至关于添加"cmd.exe /c"
cwd	设置工做目录
env	设置环境变量
universal_newlines	不一样系统的换行符不一样，True -> 则统一使用 \n 为换行符
startupinfo	window下传递给CreateProcess的结构体
creationflags	只在windows下有效 将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

Popen使用方法

但若是你须要进行一些复杂的与系统的交互的话,则需呀Popen,语法以下

 1 import subprocess
 2 
 3 subprocess.Popen(["ls","test"])
 4 subprocess.Popen("cat test.txt", shell=True)
 5 p = subprocess.Popen("ls test",stdin=subprocess.PIPE,stdout=subprocess.PIPE,shell=True)
 6 p.stdout.read()
 7 
 8 #须要交互的命令示例
 9 obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
10 obj.stdin.write('print(1) \n ')
11 obj.stdin.write('print(2) \n ')
12 obj.stdin.write('print(3) \n ')
13 obj.stdin.write('print(4) \n ')
14 
15 out_error_list = obj.communicate(timeout=10)
16 print(out_error_list)

Popen

 

subprocess实现sudo 自动输入密码

 1 import subprocess
 2 
 3 mypass = '123'#密码
 4 
 5 echo = subprocess.Popen(['echo',mypass],stdout=subprocess.PIPE,)
 6 #命令
 7 sudo = subprocess.Popen(['sudo','-S','iptables','-L'],stdin=echo.stdout,stdout=subprocess.PIPE,)
 8 
 9 end_of_pipe = sudo.stdout
10 print("Password ok \n Iptables Chains %s" % end_of_pipe.read())

实现sudo自动输入密码

 

十3、logging模块

logging模块主要针对日志，在程序中须要日志，好帮助咱们进行统计以及问题分析，logging的日志能够分为 debug(), info(), warning(), error() and critical() 5个级别

下面来看一下用法

1 import logging
2  
3 logging.warning("user test attempted wrong password more than 3 times")
4 logging.critical("server is down")
5 logging.error("File cannot be opened")

简单用法

咱们发现有logging模块有info级别有error级别，那么看看这些级别表明的意思

1 import logging
2  
3 print(logging.NOTSET) #0
4 print(logging.DEBUG)  #10
5 print(logging.INFO)   #20
6 print(logging.WARNING)#30
7 print(logging.ERROR)  #40
8 print(logging.CRITICAL)#50

对应着不一样的级别

 

把日志写入文件

1 import logging
2 
3 logging.basicConfig(filename='test.log',level=logging.INFO)
4 logging.debug('debug')
5 logging.info('info')
6 logging.warning("warning")

把日志写入文件

咱们能够发现debug信息是没有写入日志的level=logging.INFO是定义了最低写入日志的级别，只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里

上面的日志中少了时间，咱们能够定义一些日志格式来实现本身的需求

1 import logging
2 
3 logging.basicConfig(level=logging.DEBUG,
4     format='%(asctime)s %(name)s %(levelname)s %(message)s',
5     datefmt='[%Y-%m-%d %H:%M:%S]',
6     filename='test.log',
7     filemode='a')
8 
9 logging.warning('warning')

自定义日志格式

在自定义日志中，format表示日志格式，用到的就是下面截图中的功能，filename是日志的文件名，filemode是打开日志的格式，默认是w打开因此要是想追加

日志就须要把模式改为a

 

日志格式 

 

若是想同时把log打印在屏幕和文件日志里，就须要了解一点复杂的知识了

Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的归纳最为合适：

• • logger提供了应用程序能够直接使用的接口；
  • handler将(logger建立的)日志记录发送到合适的目的输出；
  • filter提供了细度设备来决定输出哪条日志记录；
  • formatter决定日志记录的最终输出格式。

 1 logger
 2 每一个程序在输出信息以前都要得到一个Logger。Logger一般对应了程序的模块名，好比聊天工具的图形界面模块能够这样得到它的Logger：
 3 LOG=logging.getLogger(”chat.gui”)
 4 而核心模块能够这样：
 5 LOG=logging.getLogger(”chat.kernel”)
 6 
 7 Logger.setLevel(lel):指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
 8 Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter
 9 Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增长或删除指定的handler
10 Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：能够设置的日志级别
11 
12  
13 
14 handler
15 
16 handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可使用。有些Handler能够把信息输出到控制台，有些Logger能够把信息输出到文件，还有些 Handler能够把信息发送到网络上。若是以为不够用，还能够编写本身的Handler。能够经过addHandler()方法添加多个多handler
17 Handler.setLevel(lel):指定被处理的信息级别，低于lel级别的信息将被忽略
18 Handler.setFormatter()：给这个handler选择一个格式
19 Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象
20 
21 
22 每一个Logger能够附加多个Handler。接下来咱们就来介绍一些经常使用的Handler：
23 1) logging.StreamHandler
24 使用这个Handler能够向相似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：
25 StreamHandler([strm])
26 其中strm参数是一个文件对象。默认是sys.stderr
27 
28 
29 2) logging.FileHandler
30 和StreamHandler相似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：
31 FileHandler(filename[,mode])
32 filename是文件名，必须指定一个文件名。
33 mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a'，即添加到文件末尾。
34 
35 3) logging.handlers.RotatingFileHandler
36 这个Handler相似于上面的FileHandler，可是它能够管理文件大小。当文件达到必定大小以后，它会自动将当前日志文件更名，而后建立 一个新的同名日志文件继续输出。好比日志文件是chat.log。当chat.log达到指定的大小以后，RotatingFileHandler自动把 文件更名为chat.log.1。不过，若是chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后从新建立 chat.log，继续输出日志信息。它的构造函数是：
37 RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])
38 其中filename和mode两个参数和FileHandler同样。
39 maxBytes用于指定日志文件的最大文件大小。若是maxBytes为0，意味着日志文件能够无限大，这时上面描述的重命名过程就不会发生。
40 backupCount用于指定保留的备份文件的个数。好比，若是指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被改名，而是被删除。
41 
42 
43 4) logging.handlers.TimedRotatingFileHandler
44 这个Handler和RotatingFileHandler相似，不过，它没有经过判断文件大小来决定什么时候从新建立日志文件，而是间隔必定时间就 自动建立新的日志文件。重命名的过程与RotatingFileHandler相似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：
45 TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
46 其中filename参数和backupCount参数和RotatingFileHandler具备相同的意义。
47 interval是时间间隔。
48 when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有如下取值：
49 S 秒
50 M 分
51 H 小时
52 D 天
53 W 每星期（interval==0时表明星期一）
54 midnight 天天凌晨

介绍

实现的代码

 1 import logging
 2 
 3 #定义文件日志格式
 4 logging.basicConfig(level=logging.DEBUG,
 5     format='%(asctime)s %(name)s %(levelname)s %(message)s',
 6     datefmt='[%Y-%m-%d %H:%M:%S]',
 7     filename='test.log',
 8     filemode='a')
 9 
10 #create logger建立日志记录器
11 logger = logging.getLogger()
12 logger.setLevel(logging.DEBUG)
13 
14 # create console handler and set level to debug
15 #定义输出级别为DEBUG
16 ch = logging.StreamHandler()
17 ch.setLevel(logging.DEBUG)
18 
19 # create formatter 建立日志输出的格式
20 formatter = logging.Formatter('%(asctime)s %(name)s - %(levelname)s - %(message)s',
21                                 datefmt='[%Y-%m-%d %H:%M:%S]')
22 
23 # add formatter to ch 绑定日志输出格式
24 ch.setFormatter(formatter)
25 
26 # add ch to logger 绑定到日志记录器
27 logger.addHandler(ch)
28 
29 #调用日志
30 logger.debug('debug message')
31 logger.info('info message')
32 logger.warn('warn message')
33 logger.error('error message')
34 logger.critical('critical message')

实现代码

 

十4、re正则表达式

　　正则表达式相信不少人都熟悉了，在python中正则表达式的支持是经过re（regular expression）模块来支持的

　　下面来熟悉下正则中的几个概念：

　　一、通配符

　　通配符是一种特殊语句可使用它来代替一个或多个真正的字符好比‘ . ’点，他就能够代替任意的字符除了换行符，.python就能够等于xpython、+python等等

　　二、字符集

　　既然通配符”.  ”能够表示一个任意的字符，那么字符集就能够表示一个字符的范围例如[a-z]就能够表示a-z的任意一个字符，还能够[a-zA-Z0-9]来表示大小写字母

　　和数字，咱们还能够将它来转义[^a]就是除了a的意思

　　注意的是这里的转意符不是单个\而是双\\

　　为何使用两个反斜线？这是为了经过解释器进行转义，须要进行两个级别的转义：1.经过解释器的转义；2.经过 re 模块转义。若是不想使用两个反斜线，能够考

　　虑使用原始字符串，如：r'python\.org'。

　　三、选择符

　　为何存在选择符呢？主要缘由是假如咱们想匹配两个字符串如“aaa”,“bbb”，咱们就须要使用管道符（|）所以在匹配的时候就能够写成‘aaa|bbb’，当有的时候不

　　须要匹配这两的时候假如只须要匹配字符串“aaa”或者“bbb”就能够写成“p（aaa|bbb）”

　　四、表示个数（重复模式）

　　表示个数顾名思义就是来表示这个字符有多少个的意思主要模式（pattern）有：

　　（pattern）*：表示这个模式能够重复0次或者屡次

　　（pattern）+：表示容许这个模式出现一次或者屡次

　　（pattern）{m，n}：表示容许这个模式重复m到n次

　　（pattern）{n}：表示重复n次

　　（pattern）{n，} ：表示重复n或者更屡次，最低重复n次

五、表示开头和结尾

当咱们要匹配以什么什么开头或者以什么什么结尾是表示开头咱们可使用‘^a’表示以a开头，’$a‘表示以a结尾

　　

re模块提供的功能：

　　　　1 、compile(pattern[, flags])                 根据包含正则表达式的字符串建立模式对象

　　　　2 、search(pattern, string[, flags])        在字符串中寻找模式

　　　　3 、match(pattern, string[, flags])         在字符串的开始处匹配模式

　　　　4 、split(pattern, string[, maxsplit=0])   根据模式的匹配项来分割字符串

　　　　5 、findall(pattern, string)                     列出字符串中模式的全部匹配项

　　　　6 、sub(pat, repl, string[, count=0])      将字符串中全部pat的匹配项用repl替换

　　　　7 、escape(string)                               将字符串中全部特殊正则表达式字符转义

　　语法：

　　re.match(pattern, string, flags=0)

　　pattern:匹配的正则表达式

　　string:要匹配的字符串。

　　flags:标志位，用于控制正则表达式的匹配模式，如：是否区分大小写，多行匹配等等（例子：print(re.match("^[a]+[d]+","aADdsdaa",flags=re.IGNORECASE))）

 1 I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case
 2 使匹配对大小写不敏感；字符类和字符串匹配字母时忽略大小写。举个例子，[A-Z]也能够匹配小写字母，Spam 能够匹配 "Spam", "spam", 或 "spAM"。这个小写字母并不考虑当前位置。
 3  
 4 L = LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale
 5 影响 "w, "W, "b, 和 "B，这取决于当前的本地化设置。
 6 locales 是 C 语言库中的一项功能，是用来为须要考虑不一样语言的编程提供帮助的。举个例子，若是你正在处理法文文本，你想用 "w+ 来匹配文字，但 "w 只匹配字符类 [A-Za-z]；它并不能匹配 "é" 或 "?"。若是你的系统配置适当且本地化设置为法语，那么内部的 C 函数将告诉程序 "é" 也应该被认为是一个字母。当在编译正则表达式时使用 LOCALE 标志会获得用这些 C 函数来处理 "w 後的编译对象；这会更慢，但也会象你但愿的那样能够用 "w+ 来匹配法文文本。
 7  
 8 U = UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode locale
 9 统一成unicode编码
10 
11 M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline
12 使用 "^" 只匹配字符串的开始，而 $ 则只匹配字符串的结尾和直接在换行前（若是有的话）的字符串结尾。当本标志指定後， "^" 匹配字符串的开始和字符串中每行的开始。一样的， $ 元字符匹配字符串结尾和字符串中每行的结尾（直接在每一个换行以前）。
13 
14 S = DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline
15 使 "." 特殊字符彻底匹配任何字符，包括换行；没有这个标志， "." 匹配除了换行外的任何字符。
16 
17 X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments
18 该标志经过给予你更灵活的格式以便你将正则表达式写得更易于理解。当该标志被指定时，在 RE 字符串中的空白符被忽略，除非该空白符在字符类中或在反斜杠之後；这可让你更清晰地组织和缩进 RE。它也能够容许你将注释写入 RE，这些注释会被引擎忽略；注释用 "#"号 来标识，不过该符号不能在字符串或反斜杠之後。

匹配的模式

 

re中的表示模式

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则能够匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c以外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片断，非贪婪方式
re{ n}
re{ n,}	精确匹配n个前面表达式。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片断，贪婪方式
a| b	匹配a或b
(re)	G匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	相似 (...), 可是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#...)	注释.
(?= re)	前向确定界定符。若是所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，不然失败。但一旦所含表达式已经尝试，匹配引擎根本没有提升；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否认界定符。与确定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯。
\w	匹配字母数字
\W	匹配非字母数字
\s	匹配任意空白字符，等价于 [\t\n\r\f].
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9].
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，若是是存在换行，只匹配到换行前的结束字符串。c
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 能够匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等.	匹配一个换行符。匹配一个制表符。等
\1...\9	匹配第n个分组的子表达式。
\10	匹配第n个分组的子表达式，若是它经匹配。不然指的是八进制字符码的表达式。

　　演示代码：

 1 #!/usr/bin/env python
 2 
 3 import re
 4 
 5 #re.match从起始位置开始根据模型去字符串中匹配指定内容，匹配单个
 6 #re .match(pattern, string, flags=0)
 7 text = "111apple222pear"
 8 f1 = re.match("\d+",text)
 9 if f1:print(f1.group())
10 else:print("无")
11 """运行一下试试，咱们能够发现匹配到了111，因此咱们能够肯定的是，match匹配的是从起始位置来去匹配，
12 起始位置匹配到了则正常，不然返回空 “\d+”表示匹配任意数字出现1次或者更屡次,若是把+号变成{1,2}
13 你就发现匹配的结果是11，这是由于{1,2}表示匹配一个或两个"""
14 
15 
16 #re.search这个表示根据模式去匹配字符串中的匹配内容,也只匹配单个
17 #re.search(pattern, string, flags=0)
18 text = "aaa111apple222pear"
19 f1 = re.search("\d+",text)
20 if f1:print(f1.group())
21 else:print("无")
22 #这个例子咱们发现,re.search把111匹配出来了因此他就是从整个字符串中匹配出模式符合的字符串,而且只匹配第一个
23 
24 
25 #group（）与groups（）的区别
26 text = "jnj111apple222pear"
27 f1 = re.search("([0-9]+)([a-z]+)",text)
28 if f1:
29     print(f1.group(0),f1.group(1),f1.group(2))
30     print(f1.groups())
31 else:print("无")
32 """看到结果清晰可见，re模块匹配到后会将值传入子组，group（）默认不写参数就返回匹配的整个值，
33 写入参数就返回参数对应的值，而groups（）则返回匹配到的值的元组"""
34 
35 
36 #匹配全部符合条件的值re.finadll(pattern, string, flags=0)
37 text = "jnj111apple222pear"
38 f1 = re.findall("([0-9]+)",text)
39 if f1:print(f1)
40 else:print("无")
41 """执行上面的例子,获得的结果是个列表,列表中包含着全部符合条件的值([0-9]+)也能够写成(\d+)"""
42 
43 
44 #用于替换匹配条件的字符串re.sub(pattern, repl, string, count=0, flags=0)
45 text = "jnj111apple222pear"
46 f1 = re.sub("([a-z]+)",'A',text)
47 if f1:print(f1)
48 else:print("无")
49 #输出的结果是全部的字母全变成大写的A了相似于str.repalce
50 
51 
52 #re.split(pattern, string, maxsplit=0, flags=0)
53 content = "a1*b2c3*d4e5"
54 new_content = re.split('[\*]', content,2)
55 print (new_content)
56 #表示以*号做为分割符保持在列表中相似于str.split
57 
58 
59 #将匹配规则赋予对象，这样作的好处是能够提高匹配的速度compile(pattern, flags=0)
60 import re
61 content = "a1b*2c3*d4e5"
62 aaa = re.compile('[\*]')
63 new_content = re.split(aaa, content)
64 print (new_content)
65 
66 
67 #将字符串中全部特殊正则表达式字符转义escape(string)
68 import re
69 content = "a1b*2c3*d4e5"
70 ccc = re.escape(content)
71 print(ccc)

re演示代码

 

　　小练习

　　一、匹配出其中的年龄字段,字符串是："name: aaa , age:22 , user:1112"

1 import re
2 str_in = 'name: aaa , age:22 , user:11121'
3 new_str_in = re.findall("[age]+\:\d{1,3}",str_in)
4 #表示age出现最低一次加上：号加上任意数字出现1到3次
5 print(new_str_in)

练习1

　　二、匹配出字符串中的全部网址，字符串是："The url is www.aaa.com wwa.ccc.dsa www.cdsa.c"

1 import re
2 str_in = "The url is www.aaa.com wwa.ccc.dsa www.cdsa.c"
3 new_str_in = re.findall("www\.\S*\..{2,3}",str_in)
4 #以www加.加任意非空字符加任意字符出现次数为2到3次
5 print(new_str_in)

练习2

　　三、算出括号中的值并进行替换，字符串是："The name is xiaoyan The money I have （5+5),6-1'

1 import re
2 str_in = 'The name is xiaoyan The money I have (5+5),6-1'
3 new_str_in = re.findall("\(*\d+[\+]+\d+\)*",str_in)#匹配出括号中的内容
4 value = new_str_in[0].strip('(,)')#取出括号
5 n1, n2 = value.split('+')#以+做为分割付
6 new_value = str(int(n1)+int(n2))#进行计算
7 aaa = str_in.replace(new_str_in[0],new_value)#进行替换
8 print(aaa)

练习3

 

　

 

官网网站提供的内置模块文档，点击这里

 

  　　　　做者：北京小远
  　　　　出处：http://www.cnblogs.com/bj-xy/   　　　　本文版权归做者和博客园共有，欢迎转载，但未经做者赞成必须在文章页面明显位置给出原文链接，不然保留追究法律责任的权利。