python - day06

Posted 2020-10-03

本节课内容(___大纲___)

　　模块【常用模块的学习】

　　os　　、　　sys

　　json　 、　　pickle

　　time　 、　　datetime

　　random、　　string　　、　　join

　　shutil

　　shelve

　　xml

　　configparser

　　hashlib　　【md5　　、sha1　　、sha256　　、sha384　　、sha512】

　　logging

　　re

　　subprocess

---

模块介绍:

模块的分类:

　　1.标准模块　　--系统自带的模块叫标准模块

　　2.自建模块　　--自己写的模块

　　3.第三方模块　--别人写好的.我们引用.第三方模块都放在【第三方模块库】

　　　　安装第三方模块用：pip3  install  xml【此处的xml是模块名】

　　　　导入模块方法：【如下】

　　　　import  os【import 后跟的是模块名称】 

---

os　模块:

os 模块_提供对操作系统进行调用的接口.详细如下:

print(os.getcwd())                              # 获取当前工作目录，即当前python脚本工作的目录路径
print(os.chdir("dirname"))                      # 改变当前脚本工作目录；相当于shell下cd
print(os.curdir)                                # 返回当前目录: (‘.‘)
print(os.pardir)                                # 获取当前目录的父目录字符串名：(‘..‘)
print(os.makedirs(‘dirname1/dirname2‘))         # 可生成多层递归目录
print(os.removedirs(‘dirname1‘))                # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
print(os.mkdir(‘dirname‘))                      # 生成单级目录；相当于shell中mkdir dirname
print(os.rmdir(‘dirname‘))                      # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
print(os.listdir(‘dirname‘))                    # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
print(os.remove())                              # 删除一个文件
print(os.rename("oldname","newname"))       　　 # 重命名文件/目录
print(os.stat(‘path/filename‘))                 # 获取文件/目录信息
print(os.sep)                                   # 输出操作系统特定的路径分隔符，win下为"\\\\",Linux下为"/"
print(os.linesep)                               # 输出当前平台使用的行终止符，win下为"\\t\\n",Linux下为"\\n"
print(os.pathsep)                               # 输出用于分割文件路径的字符串
print(os.name)                                  # 输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
print(os.system("bash command"))            　　 # 运行shell命令，直接显示
print(os.environ)                               # 获取系统环境变量
print(os.path.abspath(path))                    # 返回path规范化的绝对路径
print(os.path.split(path))                      # 将path分割成目录和文件名二元组返回
print(os.path.dirname(path))                    # 返回path的目录。其实就是os.path.split(path)的第一个元素
print(os.path.basename(path))                   # 返回path最后的文件名。如何path以／或\\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
print(os.path.exists(path))                     # 如果path存在，返回True；如果path不存在，返回False
print(os.path.isabs(path))                      # 如果path是绝对路径，返回True
print(os.path.isfile(path))                     # 如果path是一个存在的文件，返回True。否则返回False
print(os.path.isdir(path))                      # 如果path是一个存在的目录，则返回True。否则返回False
print(os.path.join(path1[, path2[, ...]]))      # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
print(os.path.getatime(path))                   # 返回path所指向的文件或者目录的最后存取时间
print(os.path.getmtime(path))                   # 返回path所指向的文件或者目录的最后修改时间

更多:点击这里

sys　模块:

sys模块常用:

print(sys.argv)           　　　　　　# 命令行参数List，第一个元素是程序本身路径
print(sys.exit(0))        　　　　　　# 退出程序，正常退出时exit(0)
print(sys.version)        　　　　　　# 获取Python解释程序的版本信息
print(sys.maxint)         　　　　　　# 最大的Int值
print(sys.path)           　　　　　　# 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
print(sys.platform)       　　　　　　# 返回操作系统平台名称
print(sys.stdout.write(‘please:‘))
val = sys.stdin.readline()[:-1]  

os  and  sys总结:

　　import os

　　import sys

　　设置环境变量:

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

　　sys.path.append(BaseDir )

---

json　模块:

　定义:

 　　把一个内存对象转成字符串的形式【存入到硬盘】叫做序列化

　作用:

　　用于字符串 和 python数据类型间进行转换.序列化和反序列化.

　好处:

　　所有的语言都支持json格式

　语法:

　　json 模块提供四个功能分别是:dumps、dump、loads、load.  详解如下:

　　json.dumps　--序列化.　    针对的是内存对象. 

　　json.dump　  --序列化.　     针对的是文件句柄.　-->第一个参数是序列化对象.第二个参数是打开文件的句柄

　　json.loads　   --反序列化.　 针对的是内存对象.

　　json.load 　　--反序列化　  针对的是文件句柄.　-->传入文件句柄.

需求：先需要将字典中的数据存入硬盘中. 如何操作?

1 date = {
2     "name":"Yuhonglin",
3     "age":27,
4     "sex":"M"
5 }

需要序列化处理的数据

解决办法一:【二逼思路版】

 1 #  将date字典数据写入文件方法
 2 f = open("Date.txt","w",encoding="utf-8")
 3 f.write(str(date))
 4 f.close()
 5 
 6 #  从文件中读取类容. 注意此处取文件中数据时. 需要转换成字典.
 7 f = open("Date.txt","r",encoding="utf-8")
 8 Date = eval(f.read())
 9 print(Date)
10 print(Date["age"])
11 f.close()

二逼思路版

解决办法二:【文艺青年版】 

 1 import json
 2 f = open("Date.txt","w",encoding="utf-8")
 3 
 4 # dumps 用法
 5 # f.write(json.dumps(date))
 6 
 7 # dump  用法
 8 json.dump(date,f)
 9 
10 f.close()

python json 序列化两种方法

 1 import json
 2 f = open("Date.txt",encoding="utf-8")
 3 
 4 # loads  用法
 5 # date = json.loads(f.read())
 6 
 7 # load   用法
 8 date = json.load(f)
 9 
10 print(date)
11 print(date["age"])

python json 反序列化两种方法

总结:

　　文件只能接收字符串 或 二进制bytes类型数据.

　　如果在序列化时用dumps. 那么在反序列化时必须用loads. 否则会报错.一一对应.

pickle　模块:

　语法: 

　　pickle 模块提供四个功能分别是:dumps、dump、loads、load.  详解如下:

　　pickle.dumps　--序列化. 针对的是内存对象.

　　pickle.dump　 --序列化. 针对的是文件句柄. 第一个参数是序列化对象. 第二个参数是打开文件的句柄

　　pickle.loads　  --反序列化. 针对的内存对象.

　　pickle.load　　--反序列化. 针对文件句柄. 传入文件句柄

需求：先需要将字典中的数据存入硬盘中. 如何操作?

1 date = {
2     "name":"Yuhonglin",
3     "age":27,
4     "sex":"M"
5 }

需要序列化处理的数据

解决办法:

1 import pickle
2 f = open("date.pki","wb")
3 
4 # dumps 用法
5 # f.write(pickle.dumps(date))
6 
7 # dump 用法
8 pickle.dump(date,f)

python pickle 序列化两种方法

 1 import pickle
 2 f = open("date.pki","rb")
 3 
 4 # loads 用法
 5 # date = pickle.loads(f.read())
 6 
 7 # load 用法
 8 date = pickle.load(f)
 9 print(date)
10 print(date["sex"])

python pickle 反序列化两种方法

　json  and  pickle 区别总结:

　　json　:不能序列化函数等复杂数据类型.只能序列化和反序列化普通数据类型.　任何语言都支持json

　　pickle :支持python中所有的数据类型.也就是说python中所有的数据类型都可被pickle. 原因:pickle是python自己本身的. 

---

time　and　datetime　模块:

time 时间模块_简单用法:

• tm_year[年]　tm_mon[月]　tm_mday[日]　tm_hour[时]　tm_min[分]　tm_sec[秒]　tm_wday[周0-6]　　tm_yday[年中第几天]　　tm_isdst[是否夏令时] 

#   time_模块的简单用法
print(time.clock())                         #   返回处理时间. 3.3已废弃. 改成time.process_time()测量处理器运算时间.不包括sleep时间.
print(time.altzone/3600)                    #   返回与utc时间的时间差,以秒计算
print(time.asctime())                       #   返回时间格式"Mon Aug  7 21:29:03 2017"
 
Tim1 = time.localtime()                     #   localtime()是对象. 赋值进行说明. 本地时间.
Tim2 = time.localtime(time.time()+3600*3)   #   localtime()是对象. .对tm_hour进行时间+操作
print(Tim1)                                     #   正常返回.
print(Tim2)
                                                #   tm_year[年]  tm_mon[月]   tm_mday[日]  tm_hour[时]  tm_min[分]   tm_sec[秒]
                                                #   tm_wday[周0-6]   tm_yday[一年开头到现在是第几天]    tm_isdst[是否是夏令时]
print(Tim1.tm_year,Tim1.tm_yday)            #   2016年第219天
print(time.gmtime())                        #   和localtime差不多. 区别是:tm_hour  【gmtime()是utc时间.localtime是本地时间.】
print(time.gmtime(time.time()-3600*3))      #   gmtime进行时间运算
 
print(time.time())                          #   时间戳
print(time.time()/(3600*24*365))            #   1970年到现在. 为什么是1970年.应为Unix是1970年诞生的. 下边不解释了...
 
print(time.ctime())                         #   返回当前时间
 
 
#  日期字符串 转成  时间戳
T1 = time.strptime("2017/05/22 22:20","%Y/%m/%d %H:%M")     #   将 日期字符串 转成 struct时间对象格式
print(T1)
 
T2 = time.mktime(T1)                                        #   将struct时间对象转成时间戳. 这样就可以做运算了.
print(T2)
print(T2-20)
 
#  将时间戳转为字符串格式
print(time.gmtime(time.time()))                                 #　　将utc时间戳转换成struct_time格式
print(time.strftime("%Y_%m_%d %H:%M:%S.logs",time.gmtime()) )   #　　将utc struct_time格式转成指定的字符串格式

　datetime 时间模块【时间加减】

• %a[本地（local）简化星期名称      %A[本地完整星期名称] %b[本地简化月份名称]      %B[本地完整月份名称]      　　            %c[本地相应的日期和时间表示]
• %d[一个月中的第几天(01 - 31)]       %H[一天中的第几个小时(24小时制，00 - 23)]      %I[第几个小时(12小时制.01 - 12)]    %j[年中第几天(001 - 366)]
• %m[月份(01 - 12)]                                  %M[分钟数(00 - 59)]                                                         %p[本地am或者pm的相应符]
• %S[秒(01 - 61)]                                        %U[一年中的星期数.(00 - 53星期天是一个星期的开始.)第一个星期天之前的所有天数都放在第0周]
• %w[一个星期中的第几天(0 - 6，0是星期天)]                                                                                  %W[和%U基本相同.不同的是%W以星期一为一个星期的开始.]
• %x[本地相应日期] %X[本地相应时间]                                                                                                 %y[去掉世纪的年份(00 - 99)]
• %Y[完整的年份]                                         %Z[时区的名字(如果不存在为空字符)]                     %%["%"字符] 

print(datetime.datetime.now())                                  #   返回2017-08-07 22:18:48.081864    [年月日时分秒]
print(datetime.date.fromtimestamp(time.time()))                 #   时间戳直接转成日期格式2017-08-07. [年月日]
print(datetime.datetime.now() + datetime.timedelta(3))          #   当前时间+3天
print(datetime.datetime.now() + datetime.timedelta(-3))         #   当前时间-3天
print(datetime.datetime.now() + datetime.timedelta(hours=3))    #   当前时间+3小时
print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #   当前时间+30分
 
c_time  = datetime.datetime.now()
print(c_time.replace(minute=3,hour=2)) #    时间替换  

---

random　and　string　模块:

　random　随机取数模块:

import random
 
#   -random.random()            随机打印一个小数
print(random.random())
 
#   -random.randint(1,5)        随机打印1-5的数字. （1，2，3，4，5）
print(random.randint(1,5))
 
#   -random.randrange(1,5)      随机打印1-5的数字.但不包含5.（1，2，3，4）
print(random.randrange(1,5))
 
#   -random.sample(range(10),5) 从数字1-10中随机取出5个. 也可用字母.如下:
print(random.sample(range(10),5))

　string　字符模块:

import string
 
#   -string.ascii_letters       打印出a-Z的字母. PS：大小写都打印一遍
print(string.ascii_letters)
 
#   -string.digits              打印出0-9的数字
print(string.digits)
 
#   -string.capwords("aASAS")   首字母大写. 如果其他为大写则转成小写.小写则不转正常输出
print(string.capwords("aASAS"))
 
#   -string.hexdigits           打印出16进制数
print(string.hexdigits)
 
PS：还存在很多.可以官网或百度.

random and string结合使用.验证码　

str_ran = string.ascii_letters + string.digits
print(str_ran)
print("".join(random.sample(str_ran,4)))
输出:ndL2   
PS：注意此处的输出是随机的. 下次运行就不会是这个了.

　需求:实战自动生成验证码

 1 import random
 2 checkcode = ‘‘
 3 for i in range(6):
 4     current = random.randrange(0,6)
 5     if current != i:
 6         #  此处的chr是将对应的数字转换成asc编码值(对应的字母)
 7         temp = chr(random.randint(65,90))
 8     else:
 9         temp = random.randint(0,9)
10     checkcode += str(temp)
11 print(checkcode)

random 实现自动生成验证码 

 Join　模块:

　Python 中有join() and os.path.join()两个函数. 具体作用如下:

　　join:　　　　  连接字符串数组. 将字符串、元组、列表、字典中的元素以指定的字符串（分隔符）连接生成一个新的字符串.

　　os.path.join:  将多个路径组合返回.　　

 　函数说明:

　　join() 函数:

　　语法:

　　　　"separator".join(element)

　　参数说明:

　　　　separate：指的是分隔符. 可以为空

　　　　element： 是要连接的元素序列\\字符串、元组、列表、字典

　　返回值:返回一个以分隔符separate连接各个元素后生成的字符串

 　　

　　os.path.join() 函数:

　　语法:

　　　　os.path.join(path1,[path2,...]) 函数:

　　返回值:将多个路径组合返回

　　PS:第一个绝对路径之前的参数将被忽略

实例如下:

#   对字符串进行操作
sql_list00 = "hello yuhonglin"
print("".join(sql_list00))
print("--".join(sql_list00))
 
#   对列表进行操作
sql_list01 = ["hello","yuhonglin"]
print("".join(sql_list01))
print("--".join(sql_list01))
 
#   对元组进行操作
sql_list02 = ("hello","yuhonglin")
print("".join(sql_list02))
print("--".join(sql_list02))
 
#   对字典进行操作
sql_list03 = {"hello":1,"yuhonglin":2}
print("".join(sql_list03))
print("--".join(sql_list03))
 
#   对目录进行操作
import os
Path_dir = os.path.join("/usr/","local/host/","yuhonglin")
print(Path_dir) 

---

 shutil　模块:

高级的文件、文件夹、压缩包处理模块

shutil.copyfileobj(f01,f02)
　　将文件内容拷贝到另一个文件中.可以部分内容.[部分文件自己去做.哈哈] 

1 import shutil
2 
3 #   拷贝文件f01 -- f02.
4 #   PS:拷贝时注意字符编码和进制问题.  如果是二进制则加对应的参数. rb
5 #   将文件内容拷贝到另一个文件中.可以部分内容. 自己去百度.
6 f01 = open("Day06_笔记-Notes",encoding="utf-8")
7 f02 = open("Day06_笔记-Notes_copy","w",encoding="utf-8")
8 
9 shutil.copyfileobj(f01,f02)

shutil.copyfileobj(file_old,file_new)　

shutil.copy(f01,f02)
　　拷贝文件和权限.

1 import shutil
2 
3 #   将Day_05下的笔记拷贝到当前目录.当然文件名可以更改. 也可以拷贝到其他目录下.写上全路径即可
4 #   PS:windows下拷贝时需要加r. 因为需要转义
5 #   拷贝文件和权限.和原有的保持一致.
6 
7 shutil.copy(r"E:\\Python_Engineering_Review\\Day_05\\Day05_笔记-Notes","Day05_笔记-Notes")

shutil.copy(file_old,file_new)

shutil.copytree
　　递归的去拷贝文件

1 import shutil
2 
3 #   将Day_01整个目录拷贝到当前目录. 递归.[意思是该目录下的所有都拷贝过来.]. 相当于linux下的cp -rf
4 
5 shutil.copytree(r"E:\\Python_Engineering_Review\\Day_01","Day_01_NEW")

shutil.copytree(Directory_old,Directory_new)

shutil.rmtree
　　递归的去删除文件

1 import shutil
2 
3 #   将Day_01删除.包含该目录下的所有目录. 相当于linux下的rm -rf
4 
5 shutil.rmtree("Day_01_NEW")

shutil.rmtree("Directory")

shutil.move
　　递归的去移动文件

1 import shutil
2 
3 #   将Day_05下的笔记拷贝到当前目录.当然文件名可以更改. 也可以拷贝到其他目录下.写上全路径即可
4 
5 shutil.move(r"E:\\Python_Engineering_Review\\Day_05\\Day05_笔记-Notes","Day05_笔记-Notes111")

shutil.move(file_old,file_new)

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

• base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，

　　　　　　如：Day_05　　　　　　 　　　　　　　　　　　　　　=>保存至当前路径

　　　　　　如：E:\\Python_Engineering_Review\\Day_06\\Day_05　=>保存至E:\\Python_Engineering_Review\\Day_0

• format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
• root_dir： 要压缩的文件夹路径（默认当前目录）
• owner： 用户，默认当前用户
• group： 组，默认当前组
• logger： 用于记录日志，通常是logging.Logger对象

#   将E:\\Python_Engineering_Review\\的Day_05压缩成zip格式. 压缩后的文件名是:Day_05.zip
#   压缩成tar包. 注意格式.进制
shutil.make_archive(r"E:\\Python_Engineering_Review\\Day_06\\Day_05",format="zip",root_dir=r"E:\\Python_Engineering_Review\\Day_05")
 
shutil.make_archive(r"E:\\Python_Engineering_Review\\Day_06\\Day_05",format="tar",root_dir=r"E:\\Python_Engineering_Review\\Day_05")

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

 1 import zipfile
 2 
 3 # 压缩
 4 z = zipfile.ZipFile(‘laxi.zip‘, ‘w‘)
 5 z.write(‘a.log‘)
 6 z.write(‘data.data‘)
 7 z.close()
 8 
 9 # 解压
10 z = zipfile.ZipFile(‘laxi.zip‘, ‘r‘)
11 z.extractall()
12 z.close()
13 
14 PS：可指定需要压缩的文件

ZIP File压缩和解压

 1 import tarfile
 2 
 3 # 压缩
 4 tar = tarfile.open(‘your.tar‘,‘w‘)
 5 tar.add(‘/Users/wupeiqi/PycharmProjects/bbs2.zip‘, arcname=‘bbs2.zip‘)
 6 tar.add(‘/Users/wupeiqi/PycharmProjects/cmdb.zip‘, arcname=‘cmdb.zip‘)
 7 tar.close()
 8 
 9 # 解压
10 tar = tarfile.open(‘your.tar‘,‘r‘)
11 tar.extractall()  # 可设置解压地址
12 tar.close()

Tar File压缩和解压

更多:点击这里 

---

shelve　模块: 

shelve　模块:
    shelve模块是一个简单的k,v将内存数据通过文件持久化的模块. 可以持久化任何pickle可支持的python数据格式.
    shelve封装的就是pickle

执行完毕后.会生成三个文件.
持久化写入:

 1 import shelve
 2 
 3 
 4 d = shelve.open(‘Shelve_Test‘) #打开一个文件
 5 
 6 def stu_date(name,age):
 7     print("register stu:",name,age)
 8 
 9 name = ["yuhonglin","gouer","yulan"]
10 d["Test"] = name        #  持久化列表
11 d["Func"] = stu_date    #  持久化列表
12 
13 d.close()

_shelve_模块_run _01

  读取文件内容:

1 import shelve
2 
3 def stu_date(name,age):
4     print("Str...",name,age)
5 
6 f01 = shelve.open("Shelve_Test")
7 
8 print(f01["Test"])
9 print(f01["Func"])

_shelve_模块_read_02

好处:持久化数据. json\\pikcle只可dumps和loads一次.  而shelve可多次. 

---

xml　模块:

xml 说明:

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

xml格式如下:

 1 <?xml version="1.0"?>
 2 <!--申明xml类型和版本 -->
 3 <!--　<date>  表示起始标签 </date> 表示结束标签 代表一组数据
 4       其中这一组数据中还可以放其他数据.
 5       这里表示date这一组数据中包含三组数据.都是country.且country还可以设置属性.属性name=名字
 6             country中还可以设置属性.
 7             ps:属性可随便定义. 开始and结束
 8 -->
 9 <data>
10     <country name="Liechtenstein" sa="1111">
11         <rank updated="yes">2</rank>
12         <year>2008</year>
13         <gdppc>141100</gdppc>
14         <neighbor name="Austria" direction="E"/>
15         <neighbor name="Switzerland" direction="W"/>
16     </country>
17     <country name="Singapore">
18         <rank updated="yes">5</rank>
19         <year>2011</year>
20         <gdppc>59900</gdppc>
21         <neighbor name="Malaysia" direction="N"/>
22     </country>
23     <country name="Panama">
24         <rank updated="yes">69</rank>
25         <year>2011</year>
26         <gdppc>13600</gdppc>
27         <neighbor name="Costa Rica" direction="W"/>
28         <neighbor name="Colombia" direction="E"/>
29     </country>
30 </data>

XML 文本格式信息

python 对xml文本格式信息进行查下操作

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 _Author_ = "Administrator"
 4 
 5 #   导入模块    此处的 as 表示别名
 6 import xml.etree.ElementTree as ET
 7 
 8 #   ET.parse("file")相当于打开文件
 9 tree = ET.parse("Testxml.xml")
10 
11 #   tree.getroot()获取根节点标签
12 root = tree.getroot()
13 print(root.tag)
14 
15 #   遍历xml文档
16 for child in root:
17     #   child.tag根节点标签  child.attrib跟节点标签定义属性. ps:注意注视行的信息.
18     print(child.tag, child.attrib)
19     # for i in child.iter(‘year‘):
20     for i in child:
21         #   i.tag根节点标签  i.text跟节点标签定义属性
22         print("\\t",i.tag, i.text)
23 
24 #   只遍历year 节点
25 #   意思是只取year这个
26 for node in root.iter(‘year‘):
27     print(node.tag, node.text)

python 对xml文本格式进行select

python 对xml文本格式信息进行【改\\删】 

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 _Author_ = "Administrator"
 4 
 5 import xml.etree.ElementTree as ET
 6 
 7 tree = ET.parse("Testxml.xml")
 8 root = tree.getroot()
 9 
10 # 修改
11 for node in root.iter(‘year‘):
12     new_year = int(node.text) + 1
13     node.text = str(new_year)
14     node.set("updated", "yes")
15 
16 tree.write("Testxml.xml")
17 
18 # 删除node
19 for country in root.findall(‘country‘):
20     rank = int(country.find(‘rank‘).text)
21     if rank > 50:
22         root.remove(country)
23 
24 tree.write(‘output.xml‘)

python 对xml文本格式进行update and delete

python 自动创建一个xml文本

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 _Author_ = "Administrator"
 4 
 5 import xml.etree.ElementTree as ET
 6 
 7 #   生成一个根节点
 8 new_xml = ET.Element("namelist")
 9 name = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"})
10 age = ET.SubElement(name, "age", attrib={"checked": "no"})
11 sex = ET.SubElement(name, "sex")
12 sex.text = ‘33‘
13 name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"})
14 age = ET.SubElement(name2, "age")
15 age.text = ‘19‘
16 
17 et = ET.ElementTree(new_xml)  # 生成文档对象
18 et.write("test.xml", encoding="utf-8", xml_declaration=True)
19 
20 ET.dump(new_xml)  # 打印生成的格式

python create xml文本 

---

configparser　模块

　用于生成和修改常用配置文档. 当前模块的名称在python 3.x版本中变更为configparse 

[DEFAULT]
compression = yes
serveraliveinterval = 45
compressionlevel = 9
forwardx11 = yes

[bitbucket.org]
user = Yuhonglin

[topsecret.server.com]
host port = 3306
forwardx11 = no

生成文本事例

　python 自动生成文件

 1 import configparser
 2 
 3 #  生成一个对象
 4 conf = configparser.ConfigParser()
 5 conf["DEFAULT"] = {‘ServerAliveInterval‘: ‘45‘,
 6                       ‘Compression‘: ‘yes‘,
 7                      ‘CompressionLevel‘: ‘9‘}
 8 
 9 #  中括号的是域名称
10 conf[‘bitbucket.org‘] = {}
11 conf[‘bitbucket.org‘][‘User‘] = ‘Yuhonglin‘
12 conf[‘topsecret.server.com‘] = {}
13 
14 topsecret = conf[‘topsecret.server.com‘]
15 topsecret[‘Host Port‘] = ‘3306‘     # mutates the parser
16 topsecret[‘ForwardX11‘] = ‘no‘      # same here
17 
18 conf[‘DEFAULT‘][‘ForwardX11‘] = ‘yes‘
19 with open(‘Yu_honglin.ini‘, ‘w‘) as configfile:
20     conf.write(configfile)

python 使用configparser自动生成文件

　python 读取文件中内容

 1 import configparser
 2 
 3 #   生成一个对象
 4 config = configparser.ConfigParser()
 5 
 6 #   读文件进来.直接写文件名.DEFAULT默认不显示. 但是可以单独打印DEFAULT--->config.defaults()
 7 config.read(‘Yu_honglin.ini‘)
 8 
 9 print(config.sections())
10 print(config.defaults())
11 
12 #   读取topsecret.server.com下的端口
13 section_name = config.sections()[1]
14 print(config[section_name]["host port"])
15 
16 #   只打印自己的和全局的
17 print(config.options(section_name))
18 
19 #   只打印自己的和全局的k -- v
20 print(config.items(section_name))
21 
22 #   循环取值.当作字典
23 for k,v in config[section_name].items():
24     print(k,v)

python 使用configparser读取文件中内容

　python 写\\改\\删

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 _Author_ = "Administrator"
 4 
 5 import configparser
 6 
 7 
 8 #   生成一个对象
 9 config = configparser.ConfigParser()
10 
11 config.read(‘Yu_honglin.ini‘)
12 
13 section_name = config.sections()[1]
14 
15 #   删除section_name下的forwardx11
16 config.remove_option(section_name,"forwardx11")
17 
18 # #   写入到文件中
19 # config.write(open("Yu_honglin_new.ini","w"))
20 
21 #   修改文件中的数据. ps:只能写字符
22 config.set(section_name,"host port",str(3306))
23 
24 #   新增信息到文件中
25 config.has_section(‘wupeiqi‘)
26 config.add_section(‘wupeiqi‘)
27 
28 #   将数据写入到一个新的文件中
29 config.write(open("Yu_honglin_new.ini","w"))

python 使用configparser 写\\改\\删文件中信息  

---

hashlib　模块:

hashlib 作用:

　　用于加密相关的操作:3.x里替代了md5模块和sha模块.主要提供 SHA1.  SHA256. SHA384. SHA512. MD5算法 　　

import hashlib

m1 = hashlib.md5()
m1.update(b"Yuhong")
print(m1.hexdigest())
m1.update(b"lin")
print(m1.hexdigest())

m2 = hashlib.md5()
m2.update(b"Yuhonglin")
print(m2.hexdigest())       #   16进制格式hash
print(m2.digest())          #   2 进制格式hash
"""
    以上的区别:如字符一样.那么他们md5的结果一样. 思考:如果md5一个静态网页.那么就算被篡改了. 在md5进行比较时也能发现.
"""

#   ------------------sha1  加密
hash01 = hashlib.sha1()
hash01.update(b"Yuhonglin")
print("SHA1...........",hash01.hexdigest())

#   ------------------sha256  加密
hash02 = hashlib.sha256()
hash02.update(b"Yuhonglin")
print("SHA1...........",hash02.hexdigest())

#   ------------------sha384  加密
hash03 = hashlib.sha384()
hash03.update(b"Yuhonglin")
print("SHA1...........",hash03.hexdigest())

#   ------------------sha512  加密
hash04 = hashlib.sha512()
hash04.update(b"Yuhonglin")
print("SHA1...........",hash04.hexdigest())

"""
    以上都是加密的.其中加密256.  一般都用256. 比md5安全.
"""

如果还感觉不安全的话.那么还有一个更牛逼的.如下:
　　hmac:hmac是内部对我们创建 key 和 内容 再进行处理然后再加密.
　　散列消息鉴别码.简称HMAC.是一种基于消息鉴别码MAC（Message Authentication Code）的鉴别机制.使用HMAC时.消息通讯的双方.通过验证消息中加入的鉴别密钥K来鉴别消息的真伪
　　一般用于网络通信中消息加密.前提是双方先要约定好key.就像接头暗号一样.然后消息发送把用key把消息加密.接收方用key ＋ 消息明文再加密.拿加密后的值 跟 发送者的相对比是否相等.这样就能验证消息的真实性.及发送者的合法性了.

import hmac

#   网络消息加密传输. 比256快. Yu是key  Yuhonglin是内容.
h_obj = hmac.new(b‘Yu‘,b‘Yuhonglin‘)    

print(h_obj.hexdigest())  

---

logging　模块:

logging　模块:
    什么是logging模块:
        简单通俗讲就是: 标准接口日志模块.用于记录日志
    logging日志级别:
        debug       10  调试详细信息
        info        20  信息
        warning     30  警告信息.出现一些不想出现的错误
        error       40  严重错误.某些功能出现错误
        critical    50  严重错误.程序无法运行
　　ps:默认级别是warning 

import logging

#   默认是root用户. 可进行修改的
logging.info("Test   info")
logging.debug("Test  debug")
logging.error("Test  error")
logging.warning("user [Yuhonglin] attempted wrong password more than 3 times")
logging.critical("server is down")

#    ps：以上命令在运行时.其中info and debug未打印出日志.是因为日志级别问题导致的.默认级别是warning.当然可以进行自定义日志级别

输出：
ERROR:root:Test  error
WARNING:root:user [Yuhonglin] attempted wrong password more than 3 times
CRITICAL:root:server is down

　　将日志写入到文件中:

logging.basicConfig(filename=‘Yuhonglin.log‘,level=logging.WARNING)
logging.info("Test   info")
logging.debug("Test  debug")
logging.error("Test  error")
logging.warning("user [Yuhonglin] attempted wrong password more than 3 times")
logging.critical("server is down")

　　PS:当level=logging.WARNING时. 那么info and debug就不会打印.因此得出只会输出大于和本身级别的日志. 小于本身的日志级别是不会打印的.可设置成DEBUG测试

　　　　filename表示日志名称. level表示设置日志级别(可进行更改.) 

1 INFO:root:Test   info
2 DEBUG:root:Test  debug
3 ERROR:root:Test  error
4 WARNING:root:user [Yuhonglin] attempted wrong password more than 3 times
5 CRITICAL:root:server is down
6 ------------
7 ERROR:root:Test  error
8 WARNING:root:user [Yuhonglin] attempted wrong password more than 3 times
9 CRITICAL:root:server is down

Yuhonglin.log

　日志格式

%(name)s	Logger的名字
%(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	用户输出的消息

需求一:将日志分别记录在日志里面.并按照需求打印格式:【如:日志中加时间、模块、级别等相关信息】  

import logging

logging.basicConfig(filename=‘Yuhonglin.log‘,
                    level=logging.WARNING,
                    #   此处分别是什么意思.请查看日志格式中的各种解释
                    format=‘%(asctime)s %(filename)s:%(lineno)d:%(module)s:%(funcName)s - %(levelname)s: %(message)s‘,
                    datefmt=‘%Y/%d/%m %I:%M:%S %p‘)
logging.info("Test   info")
logging.debug("Test  debug")
logging.error("Test  error")
logging.warning("user [Yuhonglin] attempted wrong password more than 3 times")
logging.critical("server is down")


#   在函数中调用日志模块. 查看日志区别
def Run_start():
    logging.warning("user [Yuhonglin] attempted wrong password more than 3 times")

Run_start()

 1 2017/17/08 10:09:38 PM 11_logging_模块.py - ERROR: Test  error
 2 2017/17/08 10:09:38 PM 11_logging_模块.py - WARNING: user [Yuhonglin] attempted wrong password more than 3 times
 3 2017/17/08 10:09:38 PM 11_logging_模块.py - CRITICAL: server is down
 4 2017/17/08 10:12:38 PM 11_logging_模块.py:46 - ERROR: Test  error
 5 2017/17/08 10:12:38 PM 11_logging_模块.py:47 - WARNING: user [Yuhonglin] attempted wrong password more than 3 times
 6 2017/17/08 10:12:38 PM 11_logging_模块.py:48 - CRITICAL: server is down
 7 2017/17/08 10:14:13 PM 11_logging_模块.py:46:11_logging_模块 - ERROR: Test  error
 8 2017/17/08 10:14:13 PM 11_logging_模块.py:47:11_logging_模块 - WARNING: user [Yuhonglin] attempted wrong password more than 3 times
 9 2017/17/08 10:14:13 PM 11_logging_模块.py:48:11_logging_模块 - CRITICAL: server is down
10 2017/17/08 10:15:05 PM 11_logging_模块.py:46:11_logging_模块:<module> - ERROR: Test  error
11 2017/17/08 10:15:05 PM 11_logging_模块.py:47:11_logging_模块:<module> - WARNING: user [Yuhonglin] attempted wrong password more than 3 times
12 2017/17/08 10:15:05 PM 11_logging_模块.py:48:11_logging_模块:<module> - CRITICAL: server is down
13 2017/17/08 10:15:42 PM 11_logging_模块.py:46:11_logging_模块:<module> - ERROR: Test  error
14 2017/17/08 10:15:42 PM 11_logging_模块.py:47:11_logging_模块:<module> - WARNING: user [Yuhonglin] attempted wrong password more than 3 times
15 2017/17/08 10:15:42 PM 11_logging_模块.py:48:11_logging_模块:<module> - CRITICAL: server is down
16 2017/17/08 10:15:42 PM 11_logging_模块.py:52:11_logging_模块:Run_start - WARNING: user [Yuhonglin] attempted wrong password more than 3 times

Yuhonglin.log

 

需求二：

　　如何同时将log打印在屏幕和文件日志里.?

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

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

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

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

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

　　logger
　　每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名，比如聊天工具的图形界面模块可以这样获得它的Logger：
　　LOG=logging.getLogger(”chat.gui”)
　　而核心模块可以这样：
　　LOG=logging.getLogger(”chat.kernel”)

　　Logger.setLevel(lel):指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
　　Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter
　　Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增加或删除指定的handler
　　Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：可以设置的日志级别

 

　　handler

　　handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台，有些Logger可以把信息输出到文件，还有些 Handler可以把信息发送到网络上。如果觉得不够用，还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler
　　Handler.setLevel(lel):指定被处理的信息级别，低于lel级别的信息将被忽略
　　Handler.setFormatter()：给这个handler选择一个格式
　　Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象

　　每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler：
　　1) logging.StreamHandler
　　使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：
　　StreamHandler([strm])
　　其中strm参数是一个文件对象。默认是sys.stderr

　　2) logging.FileHandler
　　和StreamHandler类似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：
　　FileHandler(filename[,mode])
　　filename是文件名，必须指定一个文件名。
　　mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a‘，即添加到文件末尾。

　　3) logging.handlers.RotatingFileHandler
　　这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建 一个新的同名日志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后，RotatingFileHandler自动把 文件改名为chat.log.1。不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。它的构造函数是：
　　RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])
　　其中filename和mode两个参数和FileHandler一样。
　　maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。
　　backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。

　　4) logging.handlers.TimedRotatingFileHandler
　　这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就 自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：
　　TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
　　其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。
　　interval是时间间隔。
　　when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：
　　S 秒
　　M 分
　　H 小时
　　D 天
　　W 每星期（interval==0时代表星期一）
　　midnight 每天凌晨

　　日志屏幕正常打印并写在文件中:

 1 import logging
 2 
 3 #   create logger   TEST-LOG表示创建日志的名字.
 4 logger = logging.getLogger(‘TEST-LOG‘)
 5 #   设置DEBUG级别.可修改成其他.
 6 logger.setLevel(logging.DEBUG)
 7 
 8 
 9 #   create console handler and set level to debug
10 #   创建handler 和设置日志级别.
11 ch = logging.StreamHandler()
12 ch.setLevel(logging.WARNING)
13 
14 #   create file handler and set level to warning
15 #   创建文件handler 和设置级别
16 fh = logging.FileHandler("Access.log",encoding="utf-8")
17 fh.setLevel(logging.ERROR)
18 #   以上创建了两个handler
19 #   定义日志格式fh_formatter 输入文件中格式  ch_formatter输入屏幕日志格式
20 fh_formatter = logging.Formatter(‘%(asctime)s %(filename)s:%(lineno)d:%(module)s: - %(levelname)s: %(message)s‘)
21 ch_formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)
22 
23 #   add formatter to ch and fh.
24 fh.setFormatter(fh_formatter)
25 ch.setFormatter(ch_formatter)
26 
27 #   add ch and fh to logger
28 #   告诉log往那里输出.
29 logger.addHandler(fh)
30 logger.addHandler(ch)
31 
32 
33 logger.warning("Warning commint.............")
34 logger.error("errors  happend...............")

屏幕中正常打印日志和写入文件中

需求三:

 1 import logging
 2 
 3 from logging import handlers
 4 
 5 logger = logging.getLogger(‘TEST‘)
 6 
 7 #   定义日志名称
 8 log_file = "TimeOut.log"
 9 #   maxBytes定义文件中字节数    backupCount最多保留三个
10 fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3,encoding="utf-8")
11 
12 #   定义日志格式
13 formatter = logging.Formatter(‘%(asctime)s %(module)s:%(lineno)d %(message)s‘)
14 
15 fh.setFormatter(formatter)
16 
17 logger.addHandler(fh)
18 
19 logger.warning("test1")
20 logger.warning("test12")
21 logger.warning("test13")
22 logger.warning("test14")
23 logger.warning("test15")
24 logger.warning("test16")
25 logger.warning("test17")

日志文件自动截断_运行看效果

 1 import logging
 2 
 3 from logging import handlers
 4 
 5 logger = logging.getLogger(‘TEST‘)
 6 
 7 #   定义日志名称
 8 log_file = "TimeOut.log"
 9 
10 #   按时间生成.when表示秒 对应的S可修改成D等其他的.
11 fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3,encoding="utf-8")
12 
13 #   定义日志格式
14 formatter = logging.Formatter(‘%(asctime)s %(module)s:%(lineno)d %(message)s‘)
15 
16 fh.setFormatter(formatter)
17 
18 logger.addHandler(fh)
19 import time
20 
21 logger.warning("test1")
22 time.sleep(2)
23 logger.warning("test12")
24 time.sleep(2)
25 logger.warning("test13")
26 logger.warning("test14")
27 time.sleep(2)
28 logger.warning("test15")
29 logger.warning("test16")

日志文件按时间自动生成_运行看效果 

---

 re　模块:

　作用:用于字符串匹配

　　常用正则表达式符号如下:

‘.‘     默认匹配除\\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行【包括特殊符号】
‘^‘     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\\nabc\\neee",flags=re.MULTILINE)
‘$‘     匹配字符结尾，或e.search("foo$","bfoo\\nsdfsf",flags=re.MULTILINE).group()也可以
‘*‘     匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为[‘abb‘, ‘ab‘, ‘a‘]
‘+‘     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果[‘ab‘, ‘abb‘]
‘?‘     匹配前一个字符1次或0次
‘{m}‘   匹配前一个字符m次
‘{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|456)c", "abcabca456c").group() 结果 abcabca456c
 
 
‘\\A‘    只从字符开头匹配，re.search("\\Aabc","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‘
 
‘(?P<name>...)‘ 分组匹配.如下实例:
	re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 
	结果:{‘province‘: ‘3714‘, ‘city‘: ‘81‘, ‘birthday‘: ‘1993‘}

　　常用匹配语法:

re.match 	从头开始匹配
re.search 	匹配包含
re.findall 	把所有匹配到的字符放到以列表中的元素返回
re.splitall 以匹配到的字符当做列表分隔符
re.sub      匹配字符并替换

　　反斜杠的困扰:

　　与大多数编程语言相同.正则表达式里使用"\\"作为转义字符.这就可能造成反斜杠困扰.假如你需要匹配文本中的字符"\\".那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\\\\\":前两个和后两个分别用于在编程语言里转义成反斜杠.转换成两个反斜杠后再在正则表达式里转义成一个反斜杠.Python里的原生字符串很好地解决了这个问题.这个例子中的正则表达式可以使用r"\\\\"表示.同样.匹配一个数字的"\\\\d"可以写成r"\\d".有了原生字符串.你再也不用担心是不是漏写了反斜杠.写出来的表达式也更直观.

　　仅需轻轻知道的几个匹配模式：　　

re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
M(MULTILINE): 		 多行模式，改变‘^‘和‘$‘的行为（参见上图）
S(DOTALL): 			 点任意匹配模式，改变‘.‘的行为

　　实战:

 1 import re
 2 
 3 #   写死的精确匹配
 4 #   注意:match是从头匹配. 如果写inrt后的信息. 是匹配不到的.
 5 A01 = re.match("inet","inet addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
 6 print(A01.group())
 7 
 8 #   动态匹配
 9 #   ‘\\w‘    匹配一个字符[A-Za-z0-9]
10 #   +       匹配前一个字符一次或多次
11 A02 = re.match("\\w","inet addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
12 print(A02.group())
13 A02 = re.match("\\w+","192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
14 print(A02.group())
15 
16 #   . 匹配任意一个字符.
17 #   + 意思是匹配前边任意一个字符一次或多次
18 A03 = re.match(".","inet addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
19 print(A03.group())
20 A03 = re.match(".+","inet addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
21 print(A03.group())
22 
23 #   由于match是从头匹配故此处加^毫无意义.也就是说加与不加都一样的.
24 A04 = re.match("^.+","inet addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
25 print(A04.group())
26 
27 #   *  匹配*号前的字符0次或多次. 由于\\w无法匹配特殊字符.故此处匹配不到数据.如果第一个包含特殊字符.那么\\w后跟其他的话可能会报错.
28 A05 = re.match("\\w*","!inet addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
29 print("--->",A05.group())
30 
31 #   ? 匹配前一个字符一次或0次.  注意就算是多个后面也只打印一次
32 A06 = re.match("\\w?","iinet addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
33 print(A06.group())
34 
35 #   {3} 匹配前一个字符3次\\w是规则
36 A07 = re.match("\\w{3}","inet addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
37 print(A07.group())
38 
39 #   | 匹配左边或右边
40 A08 = re.match("inet0|INET","INET addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
41 print(A08.group())

Python re.match实战

 1 import re
 2 #   search 匹配包含
 3 #   abc匹配2次.
 4 A09 = re.search("(abc){2}a(123|456)c", "abcabca456c").group()
 5 print(A09)
 6 
 7 A10 = re.search("(\\d{2})(\\d{2})(\\d{2})(\\d{4})","id:513723199006242278 name:Yuhonglin").groups()
 8 print(A10)
 9 
10 #   此处的\\A和^相等
11 A11 = re.search("\\A51","513723199006242278 name:Yuhonglin").group()
12 print(A11)
13 
14 #   ^\\d.*\\d$  意思是以数字开头任意一个在进行多次匹配并以数字结束的  ps:$ 等于 \\Z
15 A11 = re.search("^\\d.*\\d$","513723199006242278 name:Yuhonglin1").group()
16 print(A11)
17 
18 
19 A12 = re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","513723199006242278")
20 print(A12.groupdict("city"))
21 
22 #   search 匹配IP地址
23 A13 = re.search("(\\d{1,3}\\.){3}\\d{1,3}","inet addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0")
24 print(A13.group())

Python re.search实战

 1 import re
 2 #   findall 匹配包含
 3 A14 = re.findall("\\d+","sda2jkbs8dasjlk9012nd12")
 4 print(A14)
 5 A141 = re.findall("\\D+","sda2jkbs8dasjlk9012nd12")
 6 print(A141)
 7 
 8 A15 = re.findall("\\w+","sda2jkbs8dasjlk9012nd12")
 9 print(A15)
10 A16 = re.findall("[a-zA-Z]+","sda2jkbs8dasjlk9012nd12")
11 print(A16)

Python re.findall实战

1 import re
2 #   split以什么为分隔符.\\d 意思是以数字为分隔符  \\D以数字为分隔符
3 A17 = re.split("\\d+","sda2jkbs8dasjlk9012nd12as")
4 print(A17)
5 A18 = re.split("\\D+","sda2jkbs8dasjlk9012nd12as")
6 print(A18)

Python re.split实战

1 import re
2 #   sub 匹配字符并替换
3 A19 = re.sub("\\d+","|","sda2jkbs8dasjlk9012nd12as")
4 print(A19)
5 A19 = re.sub("\\d+","|","sda2jkbs8dasjlk9012nd12as",count=2)
6 print(A19)

Python re.sub实战

 总结:

　　常用的是search\\findall\\spilt\\sub  

---

 subprocess　模块: 

 subprocess:

　　作用:用于和系统之间进行交互

常用subprocess方法实例:

import subprocess
 
#   向linux提交执行命令.并返回结果
subprocess.run(["df","-h"])
subprocess.run("df -h",shell=True)
 
#   打印并进行过滤.  ps:此处的shell=True意思是:不需让python进行解析.把命令按字符串形式传递给linux. 让linux自己去解析.
#   涉及到|管道这用这种方法.  不涉及到管道|那么用上边的方法.列表即可. 也可以字符串的方式. 不过需要加shell=True.字符串形式必须加shell=True
subprocess.run("df -h|grep sda1",shell=True)
 
#   向linux提交执行命令.并返回结果. 0 or 非0[抛出异常]
subprocess.call(["ls","-l"])
subprocess.check_call(["ls", "-l"])
 
#   接收字符串格式命令.返回元组形式.第1个元素是执行状态.第2个是命令结果
subprocess.getstatusoutput(‘ls /bin/ls‘)
>>>(0, ‘/bin/ls‘)
 
#   接收字符串格式命令.并返回结果
subprocess.getoutput(‘ls /bin/ls‘)
>>>‘/bin/ls‘
 
#   执行命令.返回结果.注意是返回结果. 格式是二进制格式
subprocess.check_output("pwd",shell=True)
>>>b‘/root\\n‘
 
#上面那些方法，底层都是封装的subprocess.Popen
poll()
Check if child process has terminated. Returns returncode
 
wait()
Wait for child process to terminate. Returns returncode attribute.
 
terminate()   杀掉所启动进程
communicate() 等待任务结束
 
stdin  标准输入
stdout 标准输出
stderr 标准错误
 
"""
   此处的stdin表示标准输入. stdout表示标准输出. stderr表示标准错误输出 shell=True的意思上边已经解释了.
   读取方法：
        p.stdout.read() 读取输出命令
        p.stderr.read() 读取标准错误输出命令
"""
p = subprocess.Popen("ifconfig|grep 192",stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,shell=True)
#   检测命令是否执行完. 返回None表示未执行完. 返会0或者报错.说明执行完毕
print(p.poll())
#   等待执行结果返回的状态
print(p.wait())
#   终止任务
print(p.terminate())

p.stdout.read()
>>>b‘          inet addr:192.168.12.120  Bcast:192.168.12.255  Mask:255.255.255.0\\n‘

　subprocess.Popen讲解: 

可用参数：
    args：		shell命令.可以是字符串或者序列类型(如：list，元组)
    bufsize：	指定缓冲.0 无缓冲.1 行缓冲.其他缓冲区大小.负值系统缓冲
    preexec_fn： 只在Unix平台下有效.用于指定一个可执行对象(callable object).它将在子进程运行之前被调用
    close_sfs：	在windows平台下.如果close_fds被设置为True.则新创建的子进程将不会继承父进程的输入\\输出\\错误管道. 
    shell：		同上
    cwd：		用于设置子进程的当前目录
    env：		用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
	
    stdin, stdout, stderr:	分别表示程序的标准输入\\输出\\错误句柄
	  所以不能将close_fds设置为True同时重定向子进程的标准输入\\输出与错误(stdin, stdout, stderr).
    universal_newlines:		不同系统的换行符不同，True -> 同意使用 \\n
    startupinfo与createionflags只在windows下有效
		将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等
		
终端输入的命令分为两种：
    输入即可得到输出，如：ifconfig
    输入进行某环境，依赖再输入，如：python
 
p = subprocess.Popen("find / -size +1000000 -exec ls -shl {} \\;",shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
print(p.stdout.read()) 

 1 import subprocess
 2  
 3 def user_password():
 4     user_password = ‘123456‘
 5     return user_password
 6  
 7 echo = subprocess.Popen([‘echo‘,user_password()],
 8                         stdout=subprocess.PIPE,
 9                         )
10  
11 sudo = subprocess.Popen([‘sudo‘,‘-S‘,‘iptables‘,‘-L‘],
12                         stdin=echo.stdout,
13                         stdout=subprocess.PIPE,
14                         )
15  
16 end_of_pipe = sudo.stdout
17  
18 print "Password ok \\n Iptables Chains %s" % end_of_pipe.read()

subprocess实现sudo 自动输入密码脚本  

---

 总结:所有变量可以只用dir(变量名)进行查看有那些对应的方法.