更多相干收费学习：python视频教程
正在python中应用日记最罕用的形式就是正在管制台以及文件中输入日记了,logging模块也很好的提供的相应的类,应用起来也十分不便,然而有时咱们可能会有一些需要,如还需求将日记发送到远端,或许间接写入数据库,这类需要该若何完成呢?
1、StreamHandler以及FileHandler
起首咱们先来写一套简略输入到cmd以及文件中的代码
# -*- coding: utf-8 -*-"""
-------------------------------------------------
File Name： loger
Description :
Author : yangyanxing
date： 2020/9/23
-------------------------------------------------
"""import loggingimport sysimport os# 初始化loggerlogger = logging.getLogger("yyx")
logger.setLevel(logging.DEBUG)# 设置日记格局fmt = logging.Formatter('[%(asctime)s] [%(levelname)s] %(message)s', '%Y-%m-%d %H:%M:%S')# 增加cmd handlercmd_handler = logging.StreamHandler(sys.stdout)
cmd_handler.setLevel(logging.DEBUG)
cmd_handler.setFormatter(fmt)# 增加文件的handlerlogpath = os.path.join(os.getcwd(), 'debug.log')
file_handler = logging.FileHandler(logpath)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(fmt)# 将cmd以及file handler增加到logger中logger.addHandler(cmd_handler)
logger.addHandler(file_handler)
logger.debug("明天天色没有错")复制代码起首初始化一个logger, 而且设置它的日记级别是DEBUG,而后添初始化了 cmd_handler以及 file_handler, 最初将它们增加到logger中, 运转剧本,会正在cmd中打印出 [2020-09-23 10:45:56] [DEBUG] 明天天色没有错 且会写入到以后目次下的debug.log文件中.
2、增加HTTPHandler
假如想要正在记载时将日记发送到近程效劳器上,能够增加一个 HTTPHandler , 正在python规范库logging.handler中,曾经为咱们界说好了不少handler,有些咱们能够间接用,内陆应用tornado写一个接纳日记的接口,将接纳到的参数全都打印进去
# 增加一个httphandlerimport logging.handlers
http_handler = logging.handlers.HTTPHandler(r"127.0.0.1:1987", '/api/log/get')
http_handler.setLevel(logging.DEBUG)
http_handler.setFormatter(fmt)
logger.addHandler(http_handler)
logger.debug("明天天色没有错")复制代码后果正在效劳端咱们收到了不少信息
{
'name': [b 'yyx'],
'msg': [b '\xe4\xbb\x8a\xe5\xa4\xa9\xe5\xa4\xa9\xe6\xb0\x94\xe4\xb8\x8d\xe9\x94\x99'],
'args': [b '()'],
'levelname': [b 'DEBUG'],
'levelno': [b '10'],
'pathname': [b 'I:/workplace/yangyanxing/test/loger.py'],
'filename': [b 'loger.py'],
'module': [b 'loger'],
'exc_info': [b 'None'],
'exc_text': [b 'None'],
'stack_info': [b 'None'],
'lineno': [b '41'],
'funcName': [b '<module>'],
'created': [b '1600831054.8881223'],
'msecs': [b '888.1223201751709'],
'relativeCreated': [b '22.99976348876953'],
'thread': [b '14876'],
'threadName': [b 'MainThread'],
'processName': [b 'MainProcess'],
'process': [b '8648'],
'message': [b '\xe4\xbb\x8a\xe5\xa4\xa9\xe5\xa4\xa9\xe6\xb0\x94\xe4\xb8\x8d\xe9\x94\x99'],
'asctime': [b '2020-09-23 11:17:34']
}复制代码能够说是信息十分之多,然而却并非咱们想要的样子,咱们只是想要相似于 [2020-09-23 10:45:56] [DEBUG] 明天天色没有错 这样的日记.
logging.handlers.HTTPHandler 只是简略的将日记一切信息发送给效劳端,至于效劳端要怎样组织内容是由效劳端来实现. 以是咱们能够有两种办法,一种是改效劳端代码,依据传过去的日记信息从新组织一下日记内容, 第二种是咱们从新写一个类,让它正在发送的时分将从新格局化日记内容发送到效劳端.
咱们采纳第二种办法,由于这类办法比拟灵敏， 效劳端只是用于记载，发送甚么内容应该是由客户端来决议。
咱们需求从新界说一个类,咱们能够参考logging.handlers.HTTPHandler 这个类,从新写一个httpHandler类
每一个日记类都需求重写emit办法,记载日记时真正要执行是也就是这个emit办法
class CustomHandler(logging.Handler):
def __init__(self, host, uri, method="POST"):
logging.Handler.__init__(self)
self.url = "%s/%s" % (host, uri)
method = method.upper() if method not in ["GET", "POST"]: raise ValueError("method must be GET or POST")
self.method = method def emit(self, record):
'''
:param record:
:return:
'''
msg = self.format(record) if self.method == "GET": if (self.url.find("?") >= 0):
sep = '&'
else:
sep = '?'
url = self.url + "%c%s" % (sep, urllib.parse.urlencode({"log": msg}))
requests.get(url, timeout=1) else:
headers = { "Content-type": "application/x-www-form-urlencoded", "Content-length": str(len(msg))
}
requests.post(self.url, data={'log': msg}, headers=headers, timeout=1)复制代码下面代码中有一行界说发送的参数 msg = self.format(record)
这行代码示意,将会依据日记工具设置的格局前往对应的内容. 之后再将内容经过requests库进行发送,无论应用get 仍是post形式,效劳端均可以失常的接纳到日记
[2020-09-23 11:43:50] [DEBUG] 明天天色没有错
3、异步的发送近程日记
如今咱们思考一个成绩,当日记发送到近程效劳器进程中,假如近程效劳器解决的很慢,会消耗肯定的工夫,那末这时候记载日记就会都变慢
修正效劳器日记解决类,让其进展5秒钟,模仿长期的解决流程
async def post(self):
print(self.getParam('log')) await asyncio.sleep(5)
self.write({"msg": 'ok'})复制代码此时咱们再打印下面的日记
logger.debug("明天天色没有错")
logger.debug("是风以及日丽的")复制代码失去的输入为
[2020-09-23 11:47:33] [DEBUG] 明天天色没有错 [2020-09-23 11:47:38] [DEBUG] 是风以及日丽的复制代码
咱们留意到,它们的工夫距离也是5秒。
那末如今成绩来了，本来只是一个记载日记，如今却成为了拖累整个剧本的负担，以是咱们需求异步的来解决近程写日记。
3.1 应用多线程解决
起首想的是应该是用多线程来执行发送日记办法
def emit(self, record):
msg = self.format(record) if self.method == "GET": if (self.url.find("?") >= 0):
sep = '&'
else:
sep = '?'
url = self.url + "%c%s" % (sep, urllib.parse.urlencode({"log": msg}))
t = threading.Thread(target=requests.get, args=(url,))
t.start() else:
headers = { "Content-type": "application/x-www-form-urlencoded", "Content-length": str(len(msg))
}
t = threading.Thread(target=requests.post, args=(self.url,), kwargs={"data":{'log': msg}, "headers":headers})
t.start()复制代码这类办法是能够达到没有梗阻主目的,然而每一打印一条日记就需求开启一个线程,也是挺糜费资本的。咱们也能够应用线程池来解决
3.2 应用线程池解决
python 的 concurrent.futures 中有ThreadPoolExecutor, ProcessPoolExecutor类,是线程池以及过程池,就是正在初始化的时分先界说几个线程,之后让这些线程来解决相应的函数,这样不必每一次都需求新创立线程
线程池的根本应用
exector = ThreadPoolExecutor(max_workers=1) # 初始化一个线程池,只有一个线程exector.submit(fn, args, kwargs) # 将函数submit到线程池中复制代码
假如线程池中有n个线程,当提交的task数目年夜于n时,则过剩的task将放到行列步队中.
再次修正下面的emit函数
exector = ThreadPoolExecutor(max_workers=1)def emit(self, record):
msg = self.format(record)
timeout = aiohttp.ClientTimeout(total=6) if self.method == "GET": if (self.url.find("?") >= 0):
sep = '&'
else:
sep = '?'
url = self.url + "%c%s" % (sep, urllib.parse.urlencode({"log": msg}))
exector.submit(requests.get, url, timeout=6) else:
headers = { "Content-type": "application/x-www-form-urlencoded", "Content-length": str(len(msg))
}
exector.submit(requests.post, self.url, data={'log': msg}, headers=headers, timeout=6)复制代码这里为何要只初始化一个只有一个线程的线程池? 由于这样的话能够保障进步前辈行列步队里的日记会先被发送,假如池子中有多个线程,则纷歧定保障程序了。
3.3 应用异步aiohttp库来发送申请
下面的CustomHandler类中的emit办法应用的是requests.post来发送日记,这个requests自身是梗阻运转的,也正上因为它的存正在,才使患上剧本卡了很长期,所们咱们能够将梗阻运转的requests库交换为异步的aiohttp来执行get以及post办法, 重写一个CustomHandler中的emit办法
class CustomHandler(logging.Handler):
def __init__(self, host, uri, method="POST"):
logging.Handler.__init__(self)
self.url = "%s/%s" % (host, uri)
method = method.upper() if method not in ["GET", "POST"]: raise ValueError("method must be GET or POST")
self.method = method async def emit(self, record):
msg = self.format(record)
timeout = aiohttp.ClientTimeout(total=6) if self.method == "GET": if (self.url.find("?") >= 0):
sep = '&'
else:
sep = '?'
url = self.url + "%c%s" % (sep, urllib.parse.urlencode({"log": msg})) async with aiohttp.ClientSession(timeout=timeout) as session: async with session.get(self.url) as resp:
print(await resp.text()) else:
headers = { "Content-type": "application/x-www-form-urlencoded", "Content-length": str(len(msg))
} async with aiohttp.ClientSession(timeout=timeout, headers=headers) as session: async with session.post(self.url, data={'log': msg}) as resp:
print(await resp.text())复制代码这时候代码执行解体了
C:\Python37\lib\logging\__init__.py:894: RuntimeWarning: coroutine 'CustomHandler.emit' was never awaited self.emit(record) RuntimeWarning: Enable tracemalloc to get the object allocation traceback复制代码
效劳端也不收到发送日记的申请。
究其缘由是因为emit办法中应用async with session.post 函数,它需求正在一个应用async 润饰的函数里执行,以是修正emit函数,应用async来润饰,这里emit函数变为了异步的函数, 前往的是一个coroutine 工具,要想执行coroutine工具,需求应用await, 然而剧本里却不正在那里挪用 await emit() ,以是解体信息中显示coroutine 'CustomHandler.emit' was never awaited.
既然emit办法前往的是一个coroutine工具,那末咱们将它放一个loop中执行
async def main():
await logger.debug("明天天色没有错") await logger.debug("是风以及日丽的")
loop = asyncio.get_event_loop()
loop.run_until_complete(main())复制代码执行仍然报错
raise TypeError('An asyncio.Future, a coroutine or an awaitable is '复制代码意义是需求的是一个coroutine,然而传出去的工具没有是。
这仿佛就不方法了，想要应用异步库来发送，然而却不能够挪用await之处.
处理方法是有的,咱们应用 asyncio.get_event_loop() 猎取一个事情轮回工具, 咱们能够正在这个工具上注册不少协程工具,这样当执行事情轮回的时分,就是去执行注册正在该事情轮回上的协程, 咱们经过一个小例子来看一下
import asyncio
async def test(n):
while n > 0: await asyncio.sleep(1)
print("test {}".format(n))
n -= 1
return n
async def test2(n):
while n >0: await asyncio.sleep(1)
print("test2 {}".format(n))
n -= 1def stoploop(task):
print("执行完结, task n is {}".format(task.result()))
loop.stop()
loop = asyncio.get_event_loop()
task = loop.create_task(test(5))
task2 = loop.create_task(test2(3))
task.add_done_callback(stoploop)
task2 = loop.create_task(test2(3))
loop.run_forever()复制代码咱们应用loop = asyncio.get_event_loop() 创立了一个事情轮回工具loop, 而且正在loop上创立了两个task, 而且给task1增加了一个回调函数,正在task1它执行完结当前,将loop停掉.
留意看下面的代码,咱们并无正在某处应用await来执行协程,而是经过将协程注册到某个事情轮回工具上,而后挪用该轮回的run_forever() 函数,从而使该轮回上的协程工具患上以失常的执行.
下面失去的输入为
test 5 test2 3 test 4 test2 2 test 3 test2 1 test 2 test 1 执行完结, task n is 0复制代码
能够看到,应用事情轮回工具创立的task,正在该轮回执行run_forever() 当前就能够执行了.
假如没有执行loop.run_forever() 函数,则注册正在它下面的协程也没有会执行
loop = asyncio.get_event_loop() task = loop.create_task(test(5)) task.add_done_callback(stoploop) task2 = loop.create_task(test2(3)) time.sleep(5)# loop.run_forever()复制代码
下面的代码将loop.run_forever() 正文掉,换成time.sleep(5) 停5秒, 这时候剧本没有会有任何输入,正在停了5秒当前就停止了.
回到以前的日记发送近程效劳器的代码,咱们能够应用aiohttp封装一个发送数据的函数, 而后正在emit中将这个函数注册到全局的事情轮回工具loop中,最初再执行loop.run_forever() .
loop = asyncio.get_event_loop()class CustomHandler(logging.Handler):
def __init__(self, host, uri, method="POST"):
logging.Handler.__init__(self)
self.url = "%s/%s" % (host, uri)
method = method.upper() if method not in ["GET", "POST"]: raise ValueError("method must be GET or POST")
self.method = method # 应用aiohttp封装发送数据函数
async def submit(self, data):
timeout = aiohttp.ClientTimeout(total=6) if self.method == "GET": if self.url.find("?") >= 0:
sep = '&'
else:
sep = '?'
url = self.url + "%c%s" % (sep, urllib.parse.urlencode({"log": data})) async with aiohttp.ClientSession(timeout=timeout) as session: async with session.get(url) as resp:
print(await resp.text()) else:
headers = { "Content-type": "application/x-www-form-urlencoded",
} async with aiohttp.ClientSession(timeout=timeout, headers=headers) as session: async with session.post(self.url, data={'log': data}) as resp:
print(await resp.text()) return True
def emit(self, record):
msg = self.format(record)
loop.create_task(self.submit(msg))# 增加一个httphandlerhttp_handler = CustomHandler(r"http://127.0.0.1:1987", 'api/log/get')
http_handler.setLevel(logging.DEBUG)
http_handler.setFormatter(fmt)
logger.addHandler(http_handler)
logger.debug("明天天色没有错")
logger.debug("是风以及日丽的")
loop.run_forever()复制代码这时候剧本就能够失常的异步执行了.
loop.create_task(self.submit(msg)) 也能够应用
asyncio.ensure_future(self.submit(msg), loop=loop)
来替代,目的都是将协程工具注册到事情轮回中.
但这类形式有一点要留意,loop.run_forever() 将会不断梗阻,以是需求有个中央挪用loop.stop()办法. 能够注册到某个task的回调中.
以上就是一同看看python 中日记异步发送到近程效劳器的具体内容，更多请存眷资源魔其它相干文章！
标签： Python python教程 python编程 python使用问题
相关文章
抱歉，评论功能暂时关闭!