python_模块

• time

time_obj = time.localtime()
print("%s-%s-%s %s:%s" % (time_obj.tm_year,time_obj.tm_mon,time_obj.tm_mday,time_obj.tm_hour,time_obj.tm_min))

print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))

print(time.strptime("2016-01-28 15:40:12","%Y-%m-%d %H:%M:%S"))

print(datetime.date.today())

current_time = datetime.datetime.now()
print(current_time)
print(current_time.timetuple())

new_date = datetime.datetime.now() + datetime.timedelta(days=10) #比现在加10天
new_date = datetime.datetime.now() + datetime.timedelta(days=-10) #比现在减10天
new_date = datetime.datetime.now() + datetime.timedelta(hours=-10)#比现在减10小时
new_date = datetime.datetime.now() + datetime.timedelta(seconds=120)#比现在增加120s
new_date = datetime.datetime.now() + datetime.timedelta(weeks=1) #比现在加一周

• sys

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys.stdin          输入相关
sys.stdout         输出相关
sys.stderror       错误相关

1、sys.argv使用方法：
import sys,os

os.mkdir(sys.argv[1])
python test4.py heelo #创建目录

2、如果sys.path路径列表没有你想要的路径，可以通过 sys.path.append('路径') 添加：
import sys
import os
project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(project_path

import sys
import time


def view_bar(num, total):
    rate = float(num) / float(total)
    rate_num = int(rate * 100)
    r = '\r%d%% |%s' % (rate_num, rate_num * "*")
    sys.stdout.write(r)
    sys.stdout.flush()


if __name__ == '__main__':
    for i in range(0, 101):
        time.sleep(0.1)
        view_bar(i, 100)

import sys
import time


def view_bar(num, total):
    rate = float(num) / float(total)
    rate_num = int(rate * 100)
    r = '\r%d%%' % (rate_num, )
    sys.stdout.write(r)
    sys.stdout.flush()


if __name__ == '__main__':
    for i in range(0, 100):
        time.sleep(0.1)
        view_bar(i, 100)

• os

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

• 序列化

python提供两个模块：json和pickle，其中功能提供有四个：dump,load,dumps,loads

dumps与loads写法：
import pickle

data = {"k1":123,"k2":"hello"}

with open("read.txt","wb") as f:
    f.write(pickle.dumps(data))

import pickle

with open("read.txt","rb") as f:
    data = pickle.loads(f.read())
    print(data)


dump与load写法：
import pickle

data = {"k1":123,"k2":"hello"}

with open("read.txt","wb") as f:
    pickle.dump(data,f)

import pickle

with open("read.txt","rb") as f:
    data = pickle.load(f)
    print(data)

json:
import pickle,json

data = {"k1":123,"k2":"hello"}

with open("read.txt","w") as f:
    # f.write(pickle.dumps(data))
    #pickle.dump(data,f)
    #f.write(json.dumps(data))
    json.dump(data,f)

import pickle,json

with open("read.txt","rb") as f:
    # data = pickle.loads(f.read())
    # data = pickle.load(f)
    # print(data)

    # data = json.load(f)
    # print(data)
    data = json.loads(f.read())
    print(data)

转换为字符串：
user = [“aa”,”bb”,”cc”]
s = json.dumps(user)
print(s,type(s))

dic = {‘k1’:123,’k2’:”ws”}
json.dump(dic,open(“db”,”w”))

＃字符串转换成字典
r = json.load(open(‘db’,’r’))
print(r,type(r))

#dumps/dump：用于元组，列表，字典等形式转换成字符串
#loads/load：用于字典，列表，元组等形式字符串，装换成字典，列表，元组

• 基本模块知识

from project.day3 import test9

print(__file__) #本身自己文件的路径
print(__doc__)  #py文件的注释
print(test9.__package__) # 当前py所在文件夹，用.划分
print(test9.__cached__) #缓存
print(__name__) #只有执行python 主程序时，__name__=='__main__'，否则，执行模块名

def  test():
    """验证结果"""
    print("测试中")

print(test.__doc__)

• requests模块

import urllib
import requests
from xml.etree import ElementTree as ET

# 使用内置模块urllib发送HTTP请求，或者XML格式内容
"""
f = urllib.request.urlopen('http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=424662508')
result = f.read().decode('utf-8')
"""


# 使用第三方模块requests发送HTTP请求，或者XML格式内容
r = requests.get('http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=424662508')
result = r.text

# 解析XML格式内容
node = ET.XML(result)

# 获取内容
if node.text == "Y":
    print("在线")
else:
    print("离线")

# 1、无参数实例

import requests

ret = requests.get('https://github.com/timeline.json')

print(ret.url)
print(ret.text)

# 2、有参数实例

import requests

payload = {'key1': 'value1', 'key2': 'value2'}
ret = requests.get("http://httpbin.org/get", params=payload)

print(ret.url)
print(ret.text)

# 1、基本POST实例

import requests

payload = {'key1': 'value1', 'key2': 'value2'}
ret = requests.post("http://httpbin.org/post", data=payload)

print(ret.text)

# 2、发送请求头和数据实例

import requests
import json

url = 'https://api.github.com/some/endpoint'
payload = {'some': 'data'}
headers = {'content-type': 'application/json'}

ret = requests.post(url, data=json.dumps(payload), headers=headers)

print(ret.text)
print(ret.cookies)

import requests,json,pprint

place = input("请输入天气地点：")
JsonUrl = "http://wthrcdn.etouch.cn/weather_mini?city=%s" % (place)
TestJsonUrl = requests.get(JsonUrl)
try:
    TestJsonUrl.raise_for_status()
except:
    print("网址请求出错")

Data = json.loads(TestJsonUrl.text)
pprint.pprint(Data)
w = Data['data']
print("地点：%s" % w['city'])

#日期
date_a = []
#最高温与最低温
highTemp = []
lowTemp = []
#天气
weather =[]
#进行五天的天气遍历
for i in range(len(w['forecast'])):
    date_a.append(w['forecast'][i]['date'])
    highTemp.append(w['forecast'][i]['high'])
    lowTemp.append(w['forecast'][i]['low'])
    weather.append(w['forecast'][i]['type'])

    #输出
    print("日期:" + date_a[i])
    print("\t温度：最" + lowTemp[i] + '~最' + highTemp[i] )
    print("\t天气：" + weather[i])
    print("")
print("\n今日着装：" + w['ganmao'])
print("当前温度：" + w['wendu'] + "℃")

#通过HTTP请求和XML实现获取电视节目
import requests
from xml.etree import ElementTree as ET

payload = {'theTVstationID':3}
r = requests.post("http://www.webxml.com.cn/webservices/ChinaTVprogramWebService.asmx/getTVchannelDataSet",data=payload)
ret = r.text

root = ET.XML(ret)
for node in root.iter('TvChanne'):
    print(node.find('tvChannel').text)

• hashlib加密

主要提供了SHA1,SHA256,SHA384,SHA512,MD5算法。

import hashlib
 
# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())
 
 
######## sha1 ########
 
hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha256 ########
 
hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
 
# ######## sha384 ########
 
hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha512 ########
 
hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

如需要安全可靠，对加密算法中添加自定义key再来做加密：
import hashlib
 
# ######## md5 ########
 
hash = hashlib.md5(bytes('898oaFs09f',encoding="utf-8"))
hash.update(bytes('admin',encoding="utf-8"))
print(hash.hexdigest())

hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密：
import hmac
 
h = hmac.new(bytes('898oaFs09f',encoding="utf-8"))
h.update(bytes('admin',encoding="utf-8"))
print(h.hexdigest())

• xml

xml文件格式如下：
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2023</year>
        <gdppc>141100</gdppc>
        <neighbor direction="E" name="Austria" />
        <neighbor direction="W" name="Switzerland" />
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2026</year>
        <gdppc>59900</gdppc>
        <neighbor direction="N" name="Malaysia" />
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2026</year>
        <gdppc>13600</gdppc>
        <neighbor direction="W" name="Costa Rica" />
        <neighbor direction="E" name="Colombia" />
    </country>
</data>

1、解析xml
利用ElementTree.XML将字符串解析成xml对象
from xml.etree import ElementTree as ET

 with open("testxml.xml","r") as f:
     root = ET.XML(f.read())
     print(root.tag)

利用ElementTree.parse将文件直接解析成xml对象

from xml.etree import ElementTree as ET
root = ET.parse("testxml.xml")
test = root.getroot()
print(test)

2､遍历xml文档的所有内容
from xml.etree import ElementTree as ET

root = ET.parse("testxml.xml")
test = root.getroot()
print(test.tag)

for child in test:
    print(child.tag,child.attrib)
    for i in child:
        print(i.tag,i.text)

3､遍历xml中指定的节点
from xml.etree import ElementTree as ET

root = ET.parse("testxml.xml")
test = root.getroot()
print(test.tag)

for node in test.iter("year"):
    print(node.tag,node.text)

4､修改节点内容
from xml.etree import ElementTree as ET

root = ET.parse("testxml.xml")
test = root.getroot()
print(test.tag)

for node in root.iter("year"):
    #将year节点内容自增一
    new_year = int(node.text) + 1
    node.text = str(new_year)

    # 设置属性
    node.set('name','yinjia')
    node.set('age','18')

    #删除属性
    del node.attrib['name']

root.write('testxml.xml',encoding='utf-8')

5､删除节点
from xml.etree import ElementTree as ET

root = ET.parse("testxml.xml")
test = root.getroot()
print(test.tag)

for node in test.findall('country'):
    rank = int(node.find("rank").text)
    if rank > 50:
        test.remove(node)

root.write("testxml.xml",encoding='utf-8')

•  创建xml文档

from xml.etree import ElementTree as ET

#创建根节点
root = ET.Element("Home")

#创建节点大儿子
son1 = ET.Element("son",{"name":"儿1"})
#创建节点小儿子
son2 = ET.Element("son",{"name":"儿2"})

#在大儿子中创建两个孙子
grandson1 = ET.Element("grandson",{"name":"孙1"})
grandson2 = ET.Element("grandson",{"name":"孙2"})
son1.append(grandson1)
son1.append(grandson2)

#把儿子添加到根节点
root.append(son1)
root.append(son2)

tree = ET.ElementTree(root)
tree.write('creat.xml',encoding='utf-8',short_empty_elements=False)

from xml.etree import ElementTree as ET

#创建根节点
root = ET.Element("Home")

#创建节点大儿子
son1 = root.makeelement("son",{"name":"儿1"})

#创建节点小儿子
son2= root.makeelement("son",{"name":"儿2"})

#在大儿子中创建两个孙子
grandson1 = son1.makeelement("grandson",{"name":"孙1"})
grandson2 = son1.makeelement("grandson",{"name":"孙2"})

son1.append(grandson1)
son1.append(grandson2)

#把儿子添加到根节点
root.append(son1)
root.append(son2)

tree = ET.ElementTree(root)
tree.write('creat.xml',encoding='utf-8',short_empty_elements=False)

from xml.etree import ElementTree as ET

#创建根节点
root = ET.Element("Home")

#创建节点大儿子
son1 = ET.SubElement(root,"son",attrib={"name":"儿1"})
#创建节点小儿子
son2 = ET.SubElement(root,"son",attrib={"name":"儿2"})

#在大儿子中创建一个孙子
grandson1 = ET.SubElement(son1,"grandson",attrib={"name":"孙1"})
grandson1.text = "孙子"

et = ET.ElementTree(root)#生成文档对象
et.write("test.xml",encoding='utf-8',xml_declaration=True)

 优化默认保存设置成缩进格式，如下：

#优化改进默认设置成缩进格式
from xml.etree import ElementTree as ET
from xml.dom import minidom

def prettify(elem):
    """
    将节点转换成字符串，并添加缩进
    :param elem:
    :return:
    """
    rough_string = ET.tostring(elem,"utf-8")
    reparsed = minidom.parseString(rough_string)
    return reparsed.toprettyxml(indent='\t')

#创建根节点
root = ET.Element("Home")

#创建节点大儿子
son1 = ET.SubElement(root,"son",attrib={"name":"儿1"})
#创建节点小儿子
son2 = ET.SubElement(root,"son",attrib={"name":"儿2"})

#在大儿子中创建一个孙子
grandson1 = ET.SubElement(son1,"grandson",attrib={"name":"孙1"})
grandson1.text = "孙子"

raw_str = prettify(root)
with open("test.xml",'w',encoding='utf-8') as f:
    f.write(raw_str)

•  xml命名空间

假如这两个 XML 文档被一起使用，由于两个文档都包含带有不同内容和定义的 <table> 元素，就会发生命名冲突。

使用前缀来避免命名冲突
此文档带有某个表格中的信息：
<h:table>
   <h:tr>
   <h:td>Apples</h:td>
   <h:td>Bananas</h:td>
   </h:tr>
</h:table>

此 XML 文档携带着有关一件家具的信息：
<f:table>
   <f:name>African Coffee Table</f:name>
   <f:width>80</f:width>
   <f:length>120</f:length>
</f:table>
现在，命名冲突不存在了，这是由于两个文档都使用了不同的名称来命名它们的 <table> 元素 (<h:table> 和 <f:table>)。
通过使用前缀，我们创建了两种不同类型的 <table> 元素。

from xml.etree import ElementTree as ET

ET.register_namespace('com',"http://www.company.com") #some name

# build a tree structure
root = ET.Element("{http://www.company.com}STUFF")
body = ET.SubElement(root, "{http://www.company.com}MORE_STUFF", attrib={"{http://www.company.com}hhh": "123"})
body.text = "STUFF EVERYWHERE!"

# wrap it in an ElementTree instance, and save as XML
tree = ET.ElementTree(root)

tree.write("page.xml",
           xml_declaration=True,
           encoding='utf-8',
           method="xml")

•  Configparser模块

#config.ini配置文件

[com1]
port = 80
url = www.shou.com
k1 = 123

[com2]
admin = test
password = 123

import configparser

#读取文件操作
con = configparser.ConfigParser()
con.read("config.ini",encoding='utf-8')

result = con.sections() #获取所有项名
print(result)

result1 = con.options("com1") #获取某项名属下的键名
print(result1)

result2 = con.items("com2") #获取某项名下的所有键值对
print(result2)

result3  = con.get("com1","ip") #获取指定节点下指定的key的值
print(result3)

import configparser

#检查、删除、设置等操作方法
con = configparser.ConfigParser()
con.read("config.ini",encoding='utf-8')

#检查
test1 = con.has_section("com1")
print(test1)

#添加节点
con.add_section("add_test")
con.write(open("config.ini",'w'))

#删除节点
con.remove_section("add_test")
con.write(open("config.ini",'w'))


#检查、删除、设置指定组内的键值对
#检查
test2 = con.has_option("com1","ip")
print(test2)

#删除
test3 = con.remove_option("com1","ip")
con.write(open("config.ini",'w'))

#设置键值对
con.set("add_test","k1","123")
con.write(open("config.ini",'w'))

• Shutil模块

#高级的文件、文件夹、压缩包处理。
Shutil.make_archive(base_name,format,…)
#创建压缩包并返回文件路径，例如：zip/tar
base_name: 压缩名的文件名，也可以是压缩包文件路径，只是文件名时，则保存至当前目录，否则保存至指定路径
如:www   =》保存至当前路径
如：/user/www =>保存至/user/
format：压缩包种类，
root_dir：要压缩的文件夹路径（默认当前目录）
owner：用户，默认当前用户
logger：用户记录日志，通常是logging.Logger对象
import shutil,zipfile

#将/user/load/test下的文件打包放置当前程序目录
ret1 = shutil.make_archive("www",'tar',root_dir="/user/load/test")

#将/user/load/test下的文件打包放置/user/yinjia/目录
ret2 = shutil.make_archive("/user/yinjia/www",'tar',root_dir='/user/load/test')

#将文件内容拷贝到另一个文件中
shutil.copyfileobj(open("read.txt",'r'),open("page.xml",'a'))

#拷贝文件
shutil.copyfile("page.xml","pagecopy.xml")

#仅拷贝权限、内容、组、用户均不变
shutil.copymode("page.xml","pagecopy.xml")

#拷贝状态的信息，包括：mode bits,atime,mtime,flags
shutil.copystat('page.xml','pagecopy.xml')

#拷贝文件和权限
shutil.copy('page.xml','pagecopy.xml')

#拷贝文件和状态信息
shutil.copy2('page.xml','pagecopy.xml')

#递归的去拷贝文件夹
shutil.copytree('test1','test2',ignore=shutil.ignore_patterns('*.pyc','tmp'))
shutil.copytree('test1','test2',symlinks=True,ignore=shutil.ignore_patterns('*.pyc','tmp'))

#递归的去删除文件
shutil.rmtree('test1')

#递归去移动文件，类似mv命令，其实就是重命名
shutil.move('test1','test2')

#压缩
z = zipfile.ZipFile("test.zip",'a')
z.write('a.log')
z.write('te.xml')
z.close()

#解压
z = zipfile.ZipFile("test.zip",'r')
z.extractall()
z.close()
#压缩
tar = tarfile.open("test.tar","w")
tar.add('/user/test/1.log',arcname='aa.log')
tar.add("/user/test1/2.log",arcname='bb.log')
tar.close()

#压缩
tar = tarfile.open("test1.tar",'r')
tar.extractall() #可设置解压地址
tar.close()

• subprocess 模块

call 

执行命令，返回状态码

ret = subprocess.call(["ls", "-l"], shell=False)
ret = subprocess.call("ls -l", shell=True)

 

check_call

执行命令，如果执行状态码是 0 ，则返回0，否则抛异常

subprocess.check_call(["ls", "-l"])
subprocess.check_call("exit 1", shell=True)

 

check_output

执行命令，如果状态码是 0 ，则返回执行结果，否则抛异常

subprocess.check_output(["echo", "Hello World!"])
subprocess.check_output("exit 1", shell=True)

subprocess.Popen(...)

参数：

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

import subprocess
ret1 = subprocess.Popen(["mkdir","t1"])
ret2 = subprocess.Popen("mkdir t2", shell=True)

终端输入的命令分为两种：

• 输入即可得到输出，如：ifconfig
• 输入进行某环境，依赖再输入，如：python

import subprocess

obj = subprocess.Popen("mkdir t3", shell=True, cwd='/home/dev',)

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")
obj.stdin.write("print(2)")
obj.stdin.close()

cmd_out = obj.stdout.read()
obj.stdout.close()
cmd_error = obj.stderr.read()
obj.stderr.close()

print(cmd_out)
print(cmd_error)

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")
obj.stdin.write("print(2)")

out_error_list = obj.communicate()
print(out_error_list)

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
out_error_list = obj.communicate('print("hello")')
print(out_error_list)

• logging模块

1､单文件日志

import logging
  
  
logging.basicConfig(filename='log.log',
                    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',
                    level=10)
  
logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log')

日志等级

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

注：只有【当前写等级】大于【日志等级】时，日志文件才被记录。

2､多文件日志

如果想要设置多个日志文件，logging.basicConfig将无法完成，需要自定义文件和日志操作对象。

 

# 定义文件
file_1_1 = logging.FileHandler('l1_1.log', 'a', encoding='utf-8')
fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s")
file_1_1.setFormatter(fmt)

file_1_2 = logging.FileHandler('l1_2.log', 'a', encoding='utf-8')
fmt = logging.Formatter()
file_1_2.setFormatter(fmt)

# 定义日志
logger1 = logging.Logger('s1', level=logging.ERROR)
logger1.addHandler(file_1_1)
logger1.addHandler(file_1_2)


# 写日志
logger1.critical('1111')

 

# 定义文件
file_2_1 = logging.FileHandler('l2_1.log', 'a')
fmt = logging.Formatter()
file_2_1.setFormatter(fmt)

# 定义日志
logger2 = logging.Logger('s2', level=logging.INFO)
logger2.addHandler(file_2_1)

如上述创建的两个日志对象

• 当使用【logger1】写日志时，会将相应的内容写入 l1_1.log 和 l1_2.log 文件中
• 当使用【logger2】写日志时，会将相应的内容写入 l2_1.log 文件中