import logging
logging.basicConfig(level=logging.DEBUG,
    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
    datefmt='%a, %d %b %Y %H:%M:%S',
    filename='myapp.log',
    filemode='w')
#################################################################################################
#定義一個StreamHandler，將INFO級別或更高的日志信息打印到標(biāo)準(zhǔn)錯誤，并將其添加到當(dāng)前的日志處理對象#
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
#################################################################################################
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
 
屏幕上打印:
root  : INFO  This is info message
root  : WARNING This is warning message
./myapp.log文件中內(nèi)容為:
Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug message
Sun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info message
Sun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

import logging
import sys
# 獲取logger實例，如果參數(shù)為空則返回root logger
logger = logging.getLogger("AppName")
# 指定logger輸出格式
formatter = logging.Formatter('%(asctime)s %(levelname)-8s: %(message)s')
# 文件日志
file_handler = logging.FileHandler("test.log")
file_handler.setFormatter(formatter) # 可以通過setFormatter指定輸出格式
# 控制臺日志
console_handler = logging.StreamHandler(sys.stdout)
console_handler.formatter = formatter # 也可以直接給formatter賦值
# 為logger添加的日志處理器，可以自定義日志處理器讓其輸出到其他地方
logger.addHandler(file_handler)
logger.addHandler(console_handler)
# 指定日志的最低輸出級別，默認(rèn)為WARN級別
logger.setLevel(logging.INFO)
# 輸出不同級別的log
logger.debug('this is debug info')
logger.info('this is information')
logger.warn('this is warning message')
logger.error('this is error message')
logger.fatal('this is fatal message, it is same as logger.critical')
logger.critical('this is critical message')
# 2016-10-08 21:59:19,493 INFO : this is information
# 2016-10-08 21:59:19,493 WARNING : this is warning message
# 2016-10-08 21:59:19,493 ERROR : this is error message
# 2016-10-08 21:59:19,493 CRITICAL: this is fatal message, it is same as logger.critical
# 2016-10-08 21:59:19,493 CRITICAL: this is critical message
# 移除一些日志處理器
logger.removeHandler(file_handler)

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 （數(shù)值越大級別越高）
addFilter(filter)
removeFilter(filter)
addHandler(handler)
removeHandler(handler)

logger.debug("Houston, we have a %s", "thorny problem", exc_info=1)
info(log_message, [*args[, **kwargs]])

logger.info("Houston, we have a %s", "interesting problem", exc_info=1)
warning(log_message, [*args[, **kwargs]])

logger.warning("Houston, we have a %s", "bit of a problem", exc_info=1)
error(log_message, [*args[, **kwargs]])

logger.error("Houston, we have a %s", "major problem", exc_info=1)
critical(log_message, [*args[, **kwargs]])

logger.critical("Houston, we have a %s", "major disaster", exc_info=1)
exception(message[, *args]) 
self.error(*((msg,) + args), **{'exc_info': 1})
log(log_level, log_message, [*args[, **kwargs]])

logger.log(level, "We have a %s", "mysterious problem", exc_info=1)
logging.getLogger([name])

StreamHandler
FileHandler
RotatingFileHandler
TimedRotatingFileHandler
SocketHandler
DatagramHandler
SysLogHandler
NTEventLogHandler
SMTPHandler
MemoryHandler
HTTPHandler

class Handler(Filterer): 
 def emit(self, record):
  """
  Do whatever it takes to actually log the specified logging record.
  This version is intended to be implemented by subclasses and so
  raises a NotImplementedError.
  """
  raise NotImplementedError, 'emit must be implemented '\
         'by Handler subclasses'
 def flush(self):
  """
  Ensure all logging output has been flushed.
  This version does nothing and is intended to be implemented by
  subclasses.
  """
  pass
 def close(self):
  """ 
  Tidy up any resources used by the handler.
  This version does removes the handler from an internal list
  of handlers which is closed when shutdown() is called. Subclasses
  should ensure that this gets called from overridden close()
  methods.
  """
  #get the module data lock, as we're updating a shared structure.
  _acquireLock()
  try: #unlikely to raise an exception, but you never know...
   if self in _handlers:
    del _handlers[self]
   if self in _handlerList:
    _handlerList.remove(self)
  finally:
   _releaseLock()

class StreamHandler(Handler): 
 def __init__(self, strm=None):
  Handler.__init__(self)
  if strm is None:
   strm = sys.stderr
  self.stream = strm
 def flush(self):
  if self.stream and hasattr(self.stream, "flush"):
   self.stream.flush()
 def emit(self, record):
  try:
   msg = self.format(record)
   stream = self.stream
   fs = "%s\n"
   if not hasattr(types, "UnicodeType"): #if no unicode support...
    stream.write(fs % msg)
   else:
    try:
     if (isinstance(msg, unicode) and
      getattr(stream, 'encoding', None)):
      fs = fs.decode(stream.encoding)
      try:
       stream.write(fs % msg)
      except UnicodeEncodeError:
       #Printing to terminals sometimes fails. For example,
       #with an encoding of 'cp1251', the above write will
       #work if written to a stream opened or wrapped by
       #the codecs module, but fail when writing to a
       #terminal even when the codepage is set to cp1251.
       #An extra encoding step seems to be needed.
       stream.write((fs % msg).encode(stream.encoding))
     else:
      stream.write(fs % msg)
    except UnicodeError:
     stream.write(fs % msg.encode("UTF-8"))
   self.flush()
  except (KeyboardInterrupt, SystemExit):
   raise
  except:
   self.handleError(record)

%(name)s
logger的名稱
%(levelno)s
日志級別的數(shù)字表現(xiàn)形式
%(levelname)s
日志級別的文本表現(xiàn)形式
%(pathname)s
調(diào)用logging的源文件的全路徑名
%(filename)s
pathname的文件名部分
%(module)s
模塊名（filename的名稱部分）
%(lineno)d
調(diào)用logging的行號
%(funcName)s
函數(shù)名
%(created)f
LogRecord的創(chuàng)建時間（time.time()的返回值）
%(asctime)s
LogRecord的創(chuàng)建時間的文本表現(xiàn)形式
%(msecs)d
創(chuàng)建時間的毫秒部分
%(relativeCreated)d 
LogRecord的創(chuàng)建時間，單位是毫秒。這個時間是相對logging模塊被加載的時間的（通常就是應(yīng)用程序啟動的時間）。
%(thread)d
線程ID
%(threadName)s
線程名稱
%(process)d
進(jìn)程ID
%(message)s
record.getMessage()的返回結(jié)果。

import logging 
import sys 
logger = logging.getLogger(__name__) 
filter = logging.Filter(__name__) 
formatter = logging.Formatter("%(asctime)s|%(name)-12s|%(message)s", "%F %T")
stream_handler = logging.StreamHandler(sys.stdout) 
stream_handler.addFilter(filter) 
stream_handler.setLevel(logging.DEBUG) 
stream_handler.setFormatter(formatter)
logger.setLevel(logging.DEBUG) 
logger.addFilter(filter) 
logger.addHandler(stream_handler)
if __name__ == "__main__": 
 logger.info("info")

2015-12-16 13:52:17|__main__ |info 

import logging 
import logging.config
logging.config.fileConfig("logging.conf")
if __name__ == "__main__": 
 logger = logging.getLogger("test_logging.sublogger")
 logger.info("info")

[loggers]
keys = root,logger
[handlers]
keys = stream_handler
[formatters]
keys = formatter
[logger_root]
handlers = stream_handler
[logger_logger]
handlers = stream_handler 
level = DEBUG 
propagate = 1 
qualname = test_logging
[handler_stream_handler]
class = StreamHandler 
args = (sys.stdout,) 
formatter = formatter 
level = DEBUG
[formatter_formatter]
format = %(asctime)s|%(name)-12s|%(message)s 
datefmt = %F %T 

import logging.config 
import logging 
import time
logging.config.fileConfig("logging.conf") 
logger = logging.getLogger("test_logging.listen")
t = logging.config.listen(9999) 
t.setDaemon(True) 
t.start()
try: 
 while True:
  logger.info('running.')
  time.sleep(3)
except (KeyboardInterrupt, SystemExit, Exception): 
 logging.config.stopListening()

import socket 
import struct
HOST = 'localhost' 
PORT = 9999 
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
s.connect((HOST, PORT)) 
print "connected..." 
data_to_send = open("logging.conf").read() 
s.send(struct.pack(">L", len(data_to_send))) 
s.send(data_to_send) 
print "closing..." 
s.close()