पायथन में कंसोल लॉगिंग को अक्षम और पुन: सक्षम कैसे करें?

Question

मैं पायथन लॉगिंग का उपयोग कर रहा हूं मॉड्यूल रहा हूं और मैं कुछ समय के लिए कंसोल लॉगिंग को अक्षम करना चाहता हूं लेकिन यह काम नहीं करता है।

#!/usr/bin/python
import logging

logger = logging.getLogger() # this gets the root logger
# ... here I add my own handlers 
#logger.removeHandler(sys.stdout)
#logger.removeHandler(sys.stderr)

print logger.handlers 
# this will print [<logging.StreamHandler instance at ...>]
# but I may have other handlers there that I want to keep

logger.debug("bla bla")

उपरोक्त कोड bla blastdout पर प्रदर्शित होता है और मुझे नहीं पता कि मैं कंसोल हैंडलर को सुरक्षित रूप से कैसे निष्क्रिय कर सकता हूं। मैं यह कैसे सुनिश्चित कर सकता हूं कि मैं अस्थायी रूप से कंसोलहैंडलर को हटा दूं और दूसरे को नहीं?

Comments

उन लोगों के लिए जो किसी को भी लॉगिंग को अक्षम करना चाहते हैं: आप पासवर्ड या एपीआई कुंजी जैसे निजी डेटा को लॉग इन नहीं करना चाहेंगे।

— स्टेवोइसाक

@StevenVascellaro। उन लोगों को पहली बार एक लकड़हारे के पास क्यों भेजा जा रहा है? यह सही नहीं लगता ...

— मैड फिजिसिस्ट

@MadPhysicist मेरे पास एक एप्लिकेशन है जो एक्सएमएल अनुरोधों को बाहरी एपीआई में भेजता है। डिफ़ॉल्ट रूप से, इन अनुरोधों को एक फ़ाइल में लॉग किया जाता है। हालाँकि, प्रारंभिक लॉगिन के लिए उपयोगकर्ता नाम और पासवर्ड के साथ प्रमाणीकरण की आवश्यकता होती है, जिसे मैं लॉग इन नहीं करना चाहता।

— स्टेवोइसाक

@StevenVascellaro। समझा। स्पष्टीकरण के लिए धन्यवाद।

— मैड फिजिसिस्ट

आप यह नहीं दिखाते हैं कि आप अपने हैंडलर को कैसे / कहाँ जोड़ते हैं। अगर वे जड़ लकड़हारा में जोड़ा गया था इस पर वर्णन किए गए डिफ़ॉल्ट StreamHandler जोड़ने से प्रवेश रोका जा सके docs.python.org/3/library/logging.html#logging.basicConfig , इसके अलावा जुड़ा हुआ वर्णन प्रति, डिफ़ॉल्ट StreamHandler केवल पहले के दौरान जोड़ा जाता है जब आप logger.handlersइसे प्रिंट करते हैं, तो इसे खाली करने के लिए लॉग संदेश को कॉल करें (जैसा कि यह पूर्व logger.debug()कॉल है)। प्रश्न में कोड केवल [](हैंडलर की खाली सूची) प्रदर्शित करता है । पायथन 2.7.15 और पायथन 3.6.6 के साथ सत्यापित।

— पिओटर डोब्रोगोस्ट

Answer 1

मुझे इसके लिए एक समाधान मिला:

logger = logging.getLogger('my-logger')
logger.propagate = False
# now if you use logger it will not log to console.

यह लॉग को ऊपरी लकड़हारे को भेजने से रोकेगा जिसमें कंसोल लॉगिंग शामिल है।

Comments

मुझे नहीं लगता कि यह एक अच्छा समाधान है। उच्च लकड़हारा को नहीं प्रचारित करने के अन्य अवांछनीय परिणाम हो सकते हैं।

— lfk

यदि आप एक निश्चित लॉग लेवल के नीचे केवल संदेश को फ़िल्टर करना चाहते हैं (कहते हैं, सभी INFOसंदेश), तो आप दूसरी पंक्ति को कुछ इस तरह से बदल सकते हैंlogger.setLevel(logging.WARNING)

— हार्टले ब्रॉडी

आप लॉग को बाद में फिर से कैसे सक्षम करेंगे?

— स्टेवोइसाक

प्रचार प्रसार को अवरुद्ध करने के रूप में एक उत्तर नहीं , रूट लॉगर के सभी हैंडलर को प्रभावी ढंग से निष्क्रिय कर देता है और प्रश्न स्पष्ट रूप से बताता है (…) लेकिन मेरे पास अन्य हैंडलर हो सकते हैं जो मैं रखना चाहता हूं जो यह सुझाव देता है कि रूट लॉगऑन के डिफ़ॉल्ट स्ट्रीमहैंडलर को केवल अक्षम करना है ।

— पायोटर डोब्रोगोस्ट

संदेश प्रसार रोकना पर्याप्त नहीं है। पायथन 3.2 के बाद से , logging.lastResortहैंडलर अभी भी अन्य हैंडलर की अनुपस्थिति में गंभीरता logging.WARNINGऔर अधिक से अधिक के संदेश लॉग करेगा sys.stderr। मेरा जवाब देखिए ।

— मैगीयरो

Answer 2

मैं उपयोग करता हूं:

logger = logging.getLogger()
logger.disabled = True
... whatever you want ...
logger.disabled = False

Comments

यह पूरी तरह सेlogging लॉगिंग को अक्षम करने के लिए मॉड्यूल स्तर पर भी काम करता है , उदाहरण के लिए :: docs.python.org/2/library/log.html#logging.disableimport logging; logging.disable(logging.CRITICAL);

— lsh

यह प्रसार को अक्षम करने से बहुत बेहतर है।

— मेटर्रे मर्क

जवाब नहीं - सवाल पूछता है कि केवल डिफॉल्ट स्ट्रीमहैंडलर को कैसे निष्क्रिय किया जाए ।

— पिओट्र डोब्रोगोस्ट

disabledविशेषता सार्वजनिक एपीआई का हिस्सा नहीं है। Bugs.python.org/issue36318 देखें ।

— मैगीरियो

Answer 3

आप उपयोग कर सकते हैं:

logging.basicConfig(level=your_level)

जहाँ आपका_लेवल उनमें से एक है:

      'debug': logging.DEBUG,
      'info': logging.INFO,
      'warning': logging.WARNING,
      'error': logging.ERROR,
      'critical': logging.CRITICAL

इसलिए, यदि आप सेट your_level को logging.CRITICAL , आपके द्वारा भेजी गई केवल महत्वपूर्ण संदेश प्राप्त होगा:

logging.critical('This is a critical error message')

अपने_लेवल सेट करना को logging.DEBUG प्रवेश के सभी स्तरों पर दिखाई देगा।

अधिक जानकारी के लिए, कृपया एक नज़र डालें लॉगिंग उदाहरणों ।

प्रत्येक हैंडलर के लिए स्तर बदलने के लिए उसी तरीके से हैंडलर का उपयोग करें ।सेटवेल () फ़ंक्शन।

import logging
import logging.handlers

LOG_FILENAME = '/tmp/logging_rotatingfile_example.out'

# Set up a specific logger with our desired output level
my_logger = logging.getLogger('MyLogger')
my_logger.setLevel(logging.DEBUG)

# Add the log message handler to the logger
handler = logging.handlers.RotatingFileHandler(
          LOG_FILENAME, maxBytes=20, backupCount=5)

handler.setLevel(logging.CRITICAL)

my_logger.addHandler(handler)

Comments

यह आम तौर पर उपयोगी जानकारी है, लेकिन सवाल पूछा गया कि कंसोल लॉगिंग को कैसे अक्षम किया जाए, न कि अतिरिक्त हैंडलर कैसे जोड़ा जाए। यदि आप मूल उदाहरण पर लागू उपरोक्त कोड वाले my_logger.handlers की जांच करने वाले थे, तो आपको दो हैंडलर दिखाई देंगे - आपका नया फ़ाइल हैंडलर और मूल स्ट्रीम हैंडलर।

— जो

CRITICAL वह शब्द था जिसकी मुझे तलाश थी। धन्यवाद।

— निशांत

मैं ऑफ का एक डिबग स्तर देखना पसंद करूंगा। यह असंदिग्ध और सरल है।

— मशीन नहीं

Answer 4

(लंबे मृत प्रश्न, लेकिन भविष्य के खोजकर्ताओं के लिए)

मूल पोस्टर के कोड / आशय के करीब, यह मेरे लिए अजगर 2.6 के तहत काम करता है

#!/usr/bin/python
import logging

logger = logging.getLogger() # this gets the root logger

lhStdout = logger.handlers[0]  # stdout is the only handler initially

# ... here I add my own handlers 
f = open("/tmp/debug","w")          # example handler
lh = logging.StreamHandler(f)
logger.addHandler(lh)

logger.removeHandler(lhStdout)

logger.debug("bla bla")

मुझे जो वर्कआउट करना था वह स्टैडआउट हैंडलर को हटाना था एक नया जोड़ने के बाद ; यदि कोई हैंडलर मौजूद नहीं है, तो लकड़हारा कोड स्वचालित रूप से स्टडआउट को पुनः जोड़ देता है।

Comments

अनुक्रम logger = logging.getLogger(); lhStdout = logger.handlers[0]गलत है क्योंकि मूल लकड़हारा शुरू में कोई हैंडलर नहीं है - python -c "import logging; assert not logging.getLogger().handlers"। पायथन 2.7.15 और पायथन 3.6.6 के साथ सत्यापित।

— पियोट्र डोब्रोगोस्ट

Answer 5

प्रसंग प्रबंधक

import logging 
class DisableLogger():
    def __enter__(self):
       logging.disable(logging.CRITICAL)
    def __exit__(self, a, b, c):
       logging.disable(logging.NOTSET)

उपयोग का उदाहरण:

with DisableLogger():
    do_something()

Comments

मैं वास्तव में इस मुहावरे को पसंद करता हूं, लेकिन मैं एक विशेष नामस्थान को अक्षम कर सकता हूं। उदाहरण के लिए, मैं बस रूट लॉगर को अस्थायी रूप से अक्षम करना चाहता हूं। हालांकि इस मुहावरे का उपयोग करते हुए, हमें केवल अस्थायी रूप से हैंडलर और ऐसे ही जोड़ने / हटाने में सक्षम होना चाहिए।

— क्रिस

सवाल पूछता है कि केवल डिफ़ॉल्ट स्ट्रीमहैंडलर को कैसे अक्षम किया जाए ।

— पिओटर डोब्रोगोस्ट

आपको अपने स्वयं के वर्ग को रोल करने की ज़रूरत नहीं है, आप संदर्भ सूची से @contemanman का उपयोग कर सकते हैं और एक उपज समारोह लिख सकते हैं

— KristianR

यदि आप अपने पिज्जा पर विदेशी फलों में हैं। ज़रूर।

— user3504575

Answer 6

लॉगिंग को पूरी तरह से अक्षम करने के लिए :

logging.disable(sys.maxint) # Python 2

logging.disable(sys.maxsize) # Python 3

लॉगिंग को सक्षम करने के लिए :

logging.disable(logging.NOTSET)

---

अन्य जवाब काम के आसपास प्रदान करते हैं जो समस्या को पूरी तरह से हल नहीं करते हैं, जैसे कि

logging.getLogger().disabled = True

और, n50 से अधिक के लिए,

logging.disable(n)

पहले समाधान के साथ समस्या यह है कि यह केवल रूट लकड़हारे के लिए काम करता है। अन्य लॉगर का उपयोग करके बनाया गया, कहते हैं, logging.getLogger(__name__)इस विधि द्वारा अक्षम नहीं हैं।

दूसरा समाधान सभी लॉग को प्रभावित करता है। लेकिन यह आउटपुट को दिए गए स्तरों से ऊपर ले जाता है, इसलिए कोई इसे 50 से अधिक के स्तर के साथ लॉग इन करके ओवरराइड कर सकता है।

इससे बचाव किया जा सकता है

logging.disable(sys.maxint)

जहां तक ​​मैं बता सकता हूं ( स्रोत की समीक्षा करने के बाद ) लॉगिंग को पूरी तरह से अक्षम करने का एकमात्र तरीका है।

Comments

डाउनवोट सवाल के रूप में मानक स्ट्रीमहैंडलर को केवल

— पिओट्र

Answer 7

यहाँ वास्तव में कुछ अच्छे उत्तर हैं, लेकिन स्पष्ट रूप से सबसे सरल को बहुत अधिक ध्यान में नहीं लिया जाता है (केवल इन्फिनिटो से)।

root_logger = logging.getLogger()
root_logger.disabled = True

यह रूट लकड़हारे को निष्क्रिय करता है, और इस प्रकार अन्य सभी लकड़हारे को। मैं वास्तव में परीक्षण नहीं किया है, लेकिन यह भी सबसे तेज होना चाहिए।

अजगर 2.7 में लॉगिंग कोड से मैं यह देखता हूं

def handle(self, record):
    """
    Call the handlers for the specified record.

    This method is used for unpickled records received from a socket, as
    well as those created locally. Logger-level filtering is applied.
    """
    if (not self.disabled) and self.filter(record):
        self.callHandlers(record)

जिसका अर्थ है कि जब इसे अक्षम किया जाता है तो कोई हैंडलर नहीं कहा जाता है, और यह अधिक कुशल होना चाहिए कि बहुत अधिक मूल्य को फ़िल्टर करना या उदाहरण के लिए नो-ऑप हैंडलर सेट करना।

Comments

जब तक मैं कुछ गलत कर रहा हूं, यह केवल रूट log = logging.getLogger(__name__)

— लकड़हारे

यदि आप एक से अधिक लॉगर या एकाधिक हैंडलर के साथ काम कर रहे हैं तो यह समस्याग्रस्त हो सकता है। यदि, उदाहरण के लिए, आप अभी भी एक फ़ाइल में लॉग इन करना चाहते हैं, लेकिन किसी विशिष्ट मामले में स्ट्रीम हैंडलर को अक्षम करना चाहते हैं।

— जो

यह रूट लकड़हारे को निष्क्रिय कर देता है, और इस प्रकार अन्य सभी लकड़हारे - रूट लकड़हारे को सख्ती से अक्षम करने से कोई अन्य लकड़हारा अक्षम नहीं होता है। इसके अलावा सवाल केवल डिफ़ॉल्ट स्ट्रीमहैंडलर को अक्षम करने के बारे में पूछता है ।

— पायोत्र डोब्रोगोस्ट

disabledविशेषता सार्वजनिक एपीआई का हिस्सा नहीं है। Bugs.python.org/issue36318 देखें ।

— मैगीयरो

Answer 8

Stdout को डायवर्ट करने की आवश्यकता नहीं है। यहाँ यह करने के लिए बेहतर तरीका है:

import logging
class MyLogHandler(logging.Handler):
    def emit(self, record):
        pass

logging.getLogger().addHandler(MyLogHandler())

एक और भी सरल तरीका है:

logging.getLogger().setLevel(100)

Comments

पाइथन 2.7+

— पियरे

logging.basicConfig()फ़ंक्शन ( विवरण मेरा) को पढ़ते समय यह कार्य क्यों करता है (डिफ़ॉल्ट स्ट्रीमहैंडलर अक्षम करता है ): डिफ़ॉल्ट फॉर्मैटर के साथ स्ट्रीमहैंडलर बनाकर और इसे रूट लॉगर में जोड़कर लॉगिंग सिस्टम के लिए मूल कॉन्फ़िगरेशन करता है। डिबग (), जानकारी (), चेतावनी (), त्रुटि () और क्रिटिकल () बुनियादी रूप से कॉल करेगा अगर रूट हैंडलर के लिए कोई हैंडलर परिभाषित नहीं किया गया है । - docs.python.org/3/library/log.html#logging.basicConfig

— Piotr Dobrogost

Answer 9

मैं लॉगिंग मॉड्यूल को बहुत अच्छी तरह से नहीं जानता, लेकिन मैं इसका उपयोग उस तरह से कर रहा हूं जैसे मैं आमतौर पर केवल डिबग (या जानकारी) संदेशों को अक्षम करना चाहता हूं। आप उपयोग कर सकते हैंHandler.setLevel() लॉगिंग स्तर को CRITICAL या उच्चतर पर सेट लिए ।

इसके अलावा, आप लेखन के लिए खुली एक फ़ाइल द्वारा sys.stderr और sys.stdout को बदल सकते हैं। Http://docs.python.org/library/sys.html#sys देखें । टालमटोल करना । लेकिन मैं यह सलाह नहीं दूंगा।

Comments

यह काम कर सकता है अगर logger.handlers कुछ होगा, वर्तमान में है []।

— सोरिन

Answer 10

आप यह भी कर सकते हैं:

handlers = app.logger.handlers
# detach console handler
app.logger.handlers = []
# attach
app.logger.handlers = handlers

Comments

आप app.loggerप्रश्न ( logging.getLogger()) और अधिकांश उत्तरों में स्पष्ट रूप से उल्लिखित रूट लकड़हारे के बजाय जो आप भी निर्दिष्ट नहीं करते हैं, उसका उपयोग क्यों कर रहे हैं ? आप कैसे जानते हैं कि आप handlersकॉलिंग Logger.addHandlerविधि के बजाय संपत्ति को सुरक्षित रूप से संशोधित कर सकते हैं ?

— पायोत्र डोब्रोगोस्ट

Answer 11

import logging

log_file = 'test.log'
info_format = '%(asctime)s - %(levelname)s - %(message)s'
logging.config.dictConfig({
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'info_format': {
            'format': info_format
        },
    },
    'handlers': {
        'console': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'info_format'
        },
        'info_log_file': {
            'class': 'logging.handlers.RotatingFileHandler',
            'level': 'INFO',
            'filename': log_file,
            'formatter': 'info_format'
        }
    },
    'loggers': {
        '': {
            'handlers': [
                'console',
                'info_log_file'
            ],
            'level': 'INFO'
        }
    }
})


class A:

    def __init__(self):
        logging.info('object created of class A')

        self.logger = logging.getLogger()
        self.console_handler = None

    def say(self, word):
        logging.info('A object says: {}'.format(word))

    def disable_console_log(self):
        if self.console_handler is not None:
            # Console log has already been disabled
            return

        for handler in self.logger.handlers:
            if type(handler) is logging.StreamHandler:
                self.console_handler = handler
                self.logger.removeHandler(handler)

    def enable_console_log(self):
        if self.console_handler is None:
            # Console log has already been enabled
            return

        self.logger.addHandler(self.console_handler)
        self.console_handler = None


if __name__ == '__main__':
    a = A()
    a.say('111')
    a.disable_console_log()
    a.say('222')
    a.enable_console_log()
    a.say('333')

कंसोल आउटपुट:

2018-09-15 15:22:23,354 - INFO - object created of class A
2018-09-15 15:22:23,356 - INFO - A object says: 111
2018-09-15 15:22:23,358 - INFO - A object says: 333

test.log फ़ाइल सामग्री:

2018-09-15 15:22:23,354 - INFO - object created of class A
2018-09-15 15:22:23,356 - INFO - A object says: 111
2018-09-15 15:22:23,357 - INFO - A object says: 222
2018-09-15 15:22:23,358 - INFO - A object says: 333

Comments

कोड के बारे में कुछ विवरण जोड़ें। यह बहुत बेहतर मदद करेगा

— मैथ्यूज सनी

Answer 12

"Logging.config.dictConfig" में एक स्तर को बदलकर आप पूरे लॉगिंग स्तर को एक नए स्तर पर ले जा सकेंगे।

logging.config.dictConfig({
'version': 1,
'disable_existing_loggers': False,
'formatters': {
    'console': {
        'format': '%(name)-12s %(levelname)-8s %(message)s'
    },
    'file': {
        'format': '%(asctime)s %(name)-12s %(levelname)-8s %(message)s'
    }
},
'handlers': {
    'console': {
        'class': 'logging.StreamHandler',
        'formatter': 'console'
    },
#CHANGE below level from DEBUG to THE_LEVEL_YOU_WANT_TO_SWITCH_FOR
#if we jump from DEBUG to INFO
# we won't be able to see the DEBUG logs in our logging.log file
    'file': {
        'level': 'DEBUG',
        'class': 'logging.FileHandler',
        'formatter': 'file',
        'filename': 'logging.log'
    },
},
'loggers': {
    '': {
        'level': 'DEBUG',
        'handlers': ['console', 'file'],
        'propagate': False,
    },
}

})

Answer 13

डेकोरेटर्स का उपयोग करके एक सुरुचिपूर्ण समाधान मिला , जो निम्न समस्या को संबोधित करता है: क्या होगा यदि आप कई फ़ंक्शन के साथ एक मॉड्यूल लिख रहे हैं, उनमें से प्रत्येक में कई डीबगिंग संदेश हैं, और आप सभी फ़ंक्शन में लॉगिंग को अक्षम करना चाहते हैं लेकिन वर्तमान में आप जिस पर ध्यान केंद्रित कर रहे हैं?

आप इसे डेकोरेटर्स का उपयोग करके कर सकते हैं:

import logging, sys
logger = logging.getLogger()
logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)


def disable_debug_messages(func):
    def wrapper(*args, **kwargs):
        prev_state = logger.disabled
        logger.disabled = True
        result = func(*args, **kwargs)
        logger.disabled = prev_state
        return result
    return wrapper

फिर, आप कर सकते हैं:

@disable_debug_messages
def function_already_debugged():
    ...
    logger.debug("This message won't be showed because of the decorator")
    ...

def function_being_focused():
    ...
    logger.debug("This message will be showed")
    ...

यहां तक ​​कि अगर आप function_already_debuggedभीतर से कॉल करते हैं function_being_focused, तो संदेशों से डीबग करेंfunction_already_debugged नहीं दिखाए जाएंगे। यह सुनिश्चित करता है कि आप जिस फ़ंक्शन पर ध्यान केंद्रित कर रहे हैं, उससे केवल डिबग संदेश देखेंगे।

आशा करता हूँ की ये काम करेगा!

Answer 14

यदि आप एक निश्चित लकड़हारे को अस्थायी रूप से निष्क्रिय करना चाहते हैं तो यहां वही किया जाता है।

उदाहरण लॉग

2019-10-02 21:28:45,663 django.request PID: 8  Internal Server Error: /service_portal/get_all_sites

कोड

django_request_logger = logging.getLogger('django.request')
django_request_logger.disabled = True
django_request_logger.disabled = False

Answer 15

लॉगिंग पायथन लाइब्रेरी में, निम्न में से कोई एक करके किसी विशेष लकड़हारे के लिए लॉगिंग ( सभी स्तरों के लिए) को पूरी तरह से अक्षम कर सकते हैं :

1. लकड़हारे को एक logging.NullHandler()हैंडलर में जोड़ना ( logging.lastResortहैंडलर को गंभीरता logging.WARNINGऔर अधिक से अधिक की लॉगिंग घटनाओं से रोकने के लिए sys.stderr) और उस लकड़हारे की propagateविशेषता को स्थापित करनाFalse (अपने पूर्वज लकड़हारा के संचालकों को घटनाओं को पारित करने से रोकने के लिए)।

   • मुख्य API का उपयोग करना:

     import logging
     
     logging.getLogger("foo").addHandler(logging.NullHandler())
     logging.getLogger("foo").propagate = False

   • कॉन्फ़िगरेशन API का उपयोग करना:

     import logging.config
     
     logging.config.dictConfig({
         "version": 1,
         "handlers": {
             "null": {
                 "class": "logging.NullHandler"
             }
         },
         "loggers": {
             "foo": {
                 "handlers": ["null"],
                 "propagate": False
             }
         }
     })

2. लकड़हारा को एक lambda record: Falseफिल्टर में जोड़ना ।

   • मुख्य API का उपयोग करना:

     import logging
     
     logging.getLogger("foo").addFilter(lambda record: False)

   • कॉन्फ़िगरेशन API का उपयोग करना:

     import logging.config
     
     logging.config.dictConfig({
         "version": 1,
         "filters": {
             "all": {
                 "()": lambda: (lambda record: False)
             }
         },
         "loggers": {
             "foo": {
                 "filters": ["all"]
             }
         }
     })

चेतावनी। - 1 समाधान के विपरीत, दूसरा समाधान चाइल्ड लॉगर (उदाहरण के लिए logging.getLogger("foo.bar")) से लॉगिंग को अक्षम नहीं करता है , इसलिए किसी एक लॉगर के लिए लॉगिंग को अक्षम करने के लिए इसका उपयोग करना चाहिए।

ध्यान दें। - लकड़हारा की disabledविशेषता को निर्धारित करना True3 जी समाधान नहीं है, क्योंकि यह सार्वजनिक एपीआई का हिस्सा नहीं है। देखें https://bugs.python.org/issue36318 :

import logging

logging.getLogger("foo").disabled = True  # DO NOT DO THAT

Answer 16

जिस हैंडलर को आप अस्थायी रूप से अक्षम करना चाहते हैं, उसे उप-वर्ग में रखें:

class ToggledHandler(logging.StreamHandler):
"""A handler one can turn on and off"""

def __init__(self, args, kwargs):
    super(ToggledHandler, self).__init__(*args, **kwargs)
    self.enabled = True  # enabled by default

def enable(self):
    """enables"""
    self.enabled = True

def disable(self):
    """disables"""
    self.enabled = False

def emit(self, record):
    """emits, if enabled"""
    if self.enabled:
        # this is taken from the super's emit, implement your own
        try:
            msg = self.format(record)
            stream = self.stream
            stream.write(msg)
            stream.write(self.terminator)
            self.flush()
        except Exception:
            self.handleError(record)

नाम से हैंडलर ढूंढना काफी आसान है:

_handler = [x for x in logging.getLogger('').handlers if x.name == your_handler_name]
if len(_handler) == 1:
    _handler = _handler[0]
else:
    raise Exception('Expected one handler but found {}'.format(len(_handler))

एक बार मिल गया:

_handler.disable()
doStuff()
_handler.enable()