blocks|key|1800532|text|实际上，在Python中，它看起来非常相似。有不同的方法可以做到这一点。我通常会创建一个非常简单的logger类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1800533|import+os
import+logging+
import+settings+++#+alternativly+from+whereever+import+settings++

class+Logger(object):

++++def+__init__(self,+name):
++++++++name+=+name.replace('.log','')
++++++++logger+=+logging.getLogger('log_namespace.%25s'+%25+name)++++#+log_namespace+can+be+replaced+with+your+namespace+
++++++++logger.setLevel(logging.DEBUG)
++++++++if+not+logger.handlers:
++++++++++++file_name+=+os.path.join(settings.LOGGING_DIR,+'%25s.log'+%25+name)++++#+usually+I+keep+the+LOGGING_DIR+defined+in+some+global+settings+file
++++++++++++handler+=+logging.FileHandler(file_name)
++++++++++++formatter+=+logging.Formatter('%25(asctime)s+%25(levelname)s:%25(name)s+%25(message)s')
++++++++++++handler.setFormatter(formatter)
++++++++++++handler.setLevel(logging.DEBUG)
++++++++++++logger.addHandler(handler)
++++++++self._logger+=+logger

++++def+get(self):
++++++++return+self._logger|code-block|syntax|javascript|1800534|然后，如果我想在类或模块中记录一些东西，我只需导入记录器并创建一个实例。传递类名将为每个类创建一个文件。然后，记录器可以通过debug、info、error等将消息记录到其文件中：|1800535|from+module_where_logger_is_defined+import+Logger

class+MyCustomClass(object):

++++def+__init__(self):
++++++++self.logger+=+Logger(self.__class__.__name__).get()+++#+accessing+the+"private"+variables+for+each+class

++++def+do_something():
++++++++...
++++++++self.logger.info('Hello')

++++def+raise_error():
++++++++...
++++++++self.logger.error('some+error+message')|1800536|更新的答案|1800537|这些年来，我对Python日志记录的使用方式做了很大的改变。主要基于良好的实践，我在应用程序启动期间首先加载的模块中配置整个应用程序的日志记录一次，然后在每个文件中使用单独的记录器。示例：|1800538|#+app.py+(runs+when+application+starts)

import+logging
import+os.path

def+main():
++++logging_config+=+{
++++++++'version':+1,
++++++++'disable_existing_loggers':+False,
++++++++'formatters':+{
++++++++++++'standard':+{
++++++++++++++++'format':+'%25(asctime)s+[%25(levelname)s]+%25(name)s:+%25(message)s'
++++++++++++},
++++++++},
++++++++'handlers':+{
++++++++++++'default_handler':+{
++++++++++++++++'class':+'logging.FileHandler',
++++++++++++++++'level':+'DEBUG',
++++++++++++++++'formatter':+'standard',
++++++++++++++++'filename':+os.path.join('logs',+'application.log'),
++++++++++++++++'encoding':+'utf8'
++++++++++++},
++++++++},
++++++++'loggers':+{
++++++++++++'':+{
++++++++++++++++'handlers':+['default_handler'],
++++++++++++++++'level':+'DEBUG',
++++++++++++++++'propagate':+False
++++++++++++}
++++++++}
++++}
++++logging.config.dictConfig(logging_config)
++++#+start+application+...

if+__name__+==+'__main__':
++++main()|1800539|#+submodule.py+(any+application+module+used+later+in+the+application)

import+logging

#+define+top+level+module+logger
logger+=+logging.getLogger(__name__)

def+do_something():
++++#+application+code+...
++++logger.info('Something+happended')
++++#+more+code+...
++++try:
++++++++#+something+which+might+break
++++except+SomeError:
++++++++logger.exception('Something+broke')
++++++++#+handle+exception
++++#+more+code+...|1800540|以上是推荐的方法。每个模块都定义了自己的记录器，当您检查日志时，可以根据__name__属性轻松地识别哪个模块记录了哪条消息。这删除了我原始答案中的样板，而是使用Python标准库中的logging.config模块。|offset|length|style|CODE|1800541|entityMap^0|0|0|0|0|0|0|0|0|10|8|2K|E|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|18|8|@$U|19|V|1A|W|X]|$U|1B|V|1C|W|X]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|Z|$]]

<p>Actually in Python it looks pretty much similar. There are different ways to do it. I usually create a logger class which is very simple:</p>

<pre><code>import os
import logging 
import settings   # alternativly from whereever import settings  

class Logger(object):

    def __init__(self, name):
        name = name.replace('.log','')
        logger = logging.getLogger('log_namespace.%s' % name)    # log_namespace can be replaced with your namespace 
        logger.setLevel(logging.DEBUG)
        if not logger.handlers:
            file_name = os.path.join(settings.LOGGING_DIR, '%s.log' % name)    # usually I keep the LOGGING_DIR defined in some global settings file
            handler = logging.FileHandler(file_name)
            formatter = logging.Formatter('%(asctime)s %(levelname)s:%(name)s %(message)s')
            handler.setFormatter(formatter)
            handler.setLevel(logging.DEBUG)
            logger.addHandler(handler)
        self._logger = logger

    def get(self):
        return self._logger
</code></pre>

<p>Then if I want to log something in a class or module I simply import the logger and create an instance. Passing the class name will create one file for each class. The logger can then log messages to its file via debug, info, error, etc.:</p>

<pre><code>from module_where_logger_is_defined import Logger

class MyCustomClass(object):

    def __init__(self):
        self.logger = Logger(self.__class__.__name__).get()   # accessing the "private" variables for each class

    def do_something():
        ...
        self.logger.info('Hello')

    def raise_error():
        ...
        self.logger.error('some error message')
</code></pre>

<h1>Updated answer</h1>

<p>Over the years I changed how I am using Python logging quite a bit. Mostly based in good practices I configure the logging of the whole application once in whatever module is loaded first during startup of the application and then use individual loggers in each file. Example:</p>

<pre class="lang-py prettyprint-override"><code>
# app.py (runs when application starts)

import logging
import os.path

def main():
    logging_config = {
        'version': 1,
        'disable_existing_loggers': False,
        'formatters': {
            'standard': {
                'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
            },
        },
        'handlers': {
            'default_handler': {
                'class': 'logging.FileHandler',
                'level': 'DEBUG',
                'formatter': 'standard',
                'filename': os.path.join('logs', 'application.log'),
                'encoding': 'utf8'
            },
        },
        'loggers': {
            '': {
                'handlers': ['default_handler'],
                'level': 'DEBUG',
                'propagate': False
            }
        }
    }
    logging.config.dictConfig(logging_config)
    # start application ...

if __name__ == '__main__':
    main()
</code></pre>

<pre class="lang-py prettyprint-override"><code>
# submodule.py (any application module used later in the application)

import logging

# define top level module logger
logger = logging.getLogger(__name__)

def do_something():
    # application code ...
    logger.info('Something happended')
    # more code ...
    try:
        # something which might break
    except SomeError:
        logger.exception('Something broke')
        # handle exception
    # more code ...
</code></pre>

<p>The above is the recommended way of doing this. Each module defines its own logger and can easily identify based on the <code>__name__</code> attribute which message was logged in which module when you inspect the logs. This removes the boilerplate from my original answer and instead uses the <code>logging.config</code> module from the Python standard library.</p>


blocks|key|1585671|text|文档provide+a+pretty+good+example+of+using+your+logger+in+multiple+modules。基本上，您只需在程序开始时设置一次日志。然后，将日志记录模块导入到您想要进行日志记录的任何位置，并使用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1585672|myapp.py|1585673|import+logging
import+mylib

def+main():
++++logging.basicConfig(filename='myapp.log',+level=logging.INFO)
++++logging.info('Started')
++++mylib.do_something()
++++logging.info('Finished')

if+__name__+==+'__main__':
++++main()|code-block|syntax|javascript|1585674|mylib.py|1585675|import+logging

def+do_something():
++++logging.info('Doing+something')|1585676|这个示例显示了一个非常简单的记录器设置，但是您可以很容易地使用various+ways+to+configure+logging来设置更高级的场景。|1585677|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/howto/logging.html#logging-basic-tutorial|1|http://docs.python.org/howto/logging.html#configuring-logging^0|2|1Y|0|0|0|0|0|0|V|X|1|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|T|U|V|C|$W|Z]]]]

<p>The docs <a href="http://docs.python.org/howto/logging.html#logging-basic-tutorial">provide a pretty good example of using your logger in multiple modules</a>. Basically, you set up the logging once at the start of your program. Then, you import the logging module wherever you want to have logging, and use it.</p>

<h2>myapp.py</h2>

<pre><code>import logging
import mylib

def main():
    logging.basicConfig(filename='myapp.log', level=logging.INFO)
    logging.info('Started')
    mylib.do_something()
    logging.info('Finished')

if __name__ == '__main__':
    main()
</code></pre>

<h2>mylib.py</h2>

<pre><code>import logging

def do_something():
    logging.info('Doing something')
</code></pre>

<p>This example shows a very simplistic logger setup, but you could very easily use the <a href="http://docs.python.org/howto/logging.html#configuring-logging">various ways to configure logging</a> to set up more advanced scenarios.</p>


<p>I am new to Python and just starting one project. I am used to use <code>log4j</code> in Java and I would like to log all modules and classes in Python as I do in Java.</p>

<p>In Java I have one log configuration file in src folder named <code>log4j.properties</code> like below:</p>

<pre><code>log4j.rootLogger=DEBUG, Console, fileout

log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d{dd/MM/yyyy HH:mm:ss} %5p [%t] (%F:%L) - %m%n

log4j.appender.fileout=org.apache.log4j.RollingFileAppender
log4j.appender.fileout.File=servidor.log
log4j.appender.fileout.layout=org.apache.log4j.PatternLayout
log4j.appender.fileout.layout.ConversionPattern=%d{dd/MM/yyyy HH:mm:ss} (%F:%L) %p %t %c - %m%n
</code></pre>

<p>It logs to console and a file.</p>

<p>In my classes, I only have to import <code>log4j</code> and add a static attribute to recovery the <code>log4j</code> logger with config loaded then all classes will be logging in console and file. The configuration file is loaded automaticaly by the name. For example:</p>

<pre><code>import org.apache.log4j.Logger;

public class Main {
    public static Logger logger = Logger.getLogger(Main.class);
    public static void main(String[] args) {
        logger.info("Hello");
    }
}
</code></pre>

<p>Now I am having problem to setup logging in Python, I have read the docs but I couldn't find a way to use it in many modules/classes. How could I setup Python logging in an easy way to log my modules and classes without code much in every module/class? Is it possible to reproduce same code that I have wrote in Python?</p>


How to configure Logging in Python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我是Python的新手，刚刚开始一个项目。我习惯于在Java语言中使用log4j，我想用Python语言记录所有的模块和类，就像我在Java语言中做的那样。在Java中，我在src文件夹中有一个名为log4j.properties的日志配置文件，如下所示：log4j.rootLogger=DEBUG, Console,...

问如何在Python中配置日志
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Python中配置日志EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Python中配置日志
EN