Python的ConfigParser和Log操作

这个是一个非常好的模块，因为不可能所有的参数或者名字都放在运行代码里，工程很大的话是不好管理和修改里面的参数或变量的，首先得找到然后才能修改，所以这是个非常good的模块。

Python的ConfigParser Module 中定义了3个类对INI文件进行操作。分别是RawConfigParser、ConfigParser、SafeConfigParser。 RawCnfigParser是最基础的INI文件读取类，ConfigParser、SafeConfigParser支持对%(value)s变量的 解析。

一、类和方法

1、RawConfigParser实例方法

defaults() ：返回全部示例中所以defaults。

sections() ：返回有效的section列表，DEFAULT不包含在列表中。

add_section(section) ：为实例添加一个section，如果给定的section名已经存在，将抛出DuplicateSectionError异常。

has_section(section) ：判断给定的section名在配置文件中是否存在，DEFAULT section不包括。

options(section) ：返回给定的section下的所有可用option的列表。

has_option(section, option) ：如果section存在，并包含给定的option，返回true，放在返回false, 1.6版本新增。

read(filenames) ：尝试解析文件列表，如果解析成功返回文件列表。如果filenames是string或Unicode
string，将会按单个文件来解析。如果在filenames中的文件不能打开，该文件将被忽略。这样设计的目的是，让你能指定本地有可能是配置文件的
列表（例如，当前文件夹，用户的根目录，及一些全系统目录），所以在列表中存在的配置文件都会被读取。如果文件都不存在，那么ConfigParser实
例会包含空数据集。一个需要从配置文件读取初始化数据的应用程序，应该使用readfp()方法来加载所需要的文件，之后可以使用read()方法来获取
任何可能的文件：2.4版本之后，返回成功解析的文件列表。

readfp(fp[, filename]) ：从文件或fp（值使用该对象的readline()方法）中的似文件类读取并解析配置数据，如果filename被省略，fp有一个name属性，该属性用于获取filename 。

get(section, option) ：获取section下option的值。

getint(section, option) ：强制指定section下的option的值，作为Int类型返回的方便方法。

getfloat(section, option) ：强制section下的option值，作为float类型返回的方法方法。

getboolean(section, option) ：强制section下的option值，作为布尔类型返回的方法方法。注意可接受的option的true值有“1”，“yes”，“true”及
“on”，可接受的false值有“0”，“no”，“false”，“off”。字符串值不检测大小写，其他值会抛出ValueError异常。

itmes(section) ：返回给定section下的所以option的（name, value）对列表。

set(section, option, value) ：如果给定的setion存在，为option设定给定的值；否则抛出NoSectionError异常。当可能使用RawConfigParser（或者
ConfigParser的参数raw为true）来在内部存储非字符串值，所以功能（包括填补和输出到文件）只能使用字符串值来归档。1.6版本新增。

write(fileobject) ：将配置表示写入指定文件类，该表示以后可以通过调用read()来解析，1.6版本新增。

remove_option(section, option) ：从指定section中删除指定option，如果section不存在，抛出NoSectionError异常；如果option存在，则删除，并返回True；否则返回false。1.6版本新增。

remove_section(section) ：从配置文件中删除指定的section，如果section确实存在，返回true，否则返回false。

optionxform(option) ：将输入文件中，或客户端代码传递的option名转化成内部结构使用的形式。默认实现返回option的小写形式；子类可能重写该方法或客户端代码可能将该方法作为实例的属性，以此来影响它的行为。将此用于str()，例如，会使option名称大小写敏感。

2、ConfigParser对象方法

ConfigParser类扩展了RawConfigParser的一些接口方法，添加了一些可选参数。

get(section, option [, raw[, vars]]) ：获取给定section下的option的值，所以“%”占位符在返回值中被填补，基于构造时传递的默认值，就像option，vars也被提供，除非raw参数为true。

items(section, [, raw[, vars]])  ：返回给定section下的所以option的（name, value）对列表。可选参数同get方法，2.3版本新增。

3、SafeConfigParser对象中的方法

SafeConfigParser类实现了ConfigParser相同的接口，新增如下方法：

set(section, option, value) ：如果给定的section存在，给option赋值；否则抛出NoSectionError异常。Value值必须是字符串（str或unicode）；如果不是，抛出TypeError异常，2.4版本新增。

Example：

dbconf.ini文件

[baseconf]
host=127.0.0.1
port=3306
user=root
password=root
db_name=evaluting_sys
[concurrent]
processor=20

读写：

import sys,os
import ConfigParser
def test(config_file_path):
    cf = ConfigParser.ConfigParser()
    cf.read(config_file_path)
    s = cf.sections()
    print 'section:', s
    o = cf.options("baseconf")
    print 'options:', o
    v = cf.items("baseconf")
    print 'db:', v
    db_host = cf.get("baseconf", "host")
    db_port = cf.getint("baseconf", "port")
    db_user = cf.get("baseconf", "user")
    db_pwd = cf.get("baseconf", "password")
    print db_host, db_port, db_user, db_pwd
    cf.set("baseconf", "db_pass", "123456")
    cf.write(open("config_file_path", "w"))
if __name__ == "__main__":
    test("../conf/db_config.ini")

也可以按如下用法处理

muti_site.ini

[site]
url = http://www.361way.com/
username = 361way
password = nothing
[site2]
url = http://www.91it.org/
username = 91it
password = org

读写：

from ConfigParser import SafeConfigParser
parser = SafeConfigParser()
parser.read('multisection.ini')
for section_name in parser.sections():
    print 'Section:', section_name
    print '  Options:', parser.options(section_name)
    for name, value in parser.items(section_name):
        print '  %s = %s' % (name, value)

在对ini文件里的不存在的key进行取值时，如取username1，由于不存在会报错，针对该问题，可以使用下面的一个类进行处理：

import sys,os,time
import ConfigParser
class Config:
    def __init__(self, path):
        self.path = path
        self.cf = ConfigParser.ConfigParser()
        self.cf.read(self.path)
    def get(self, field, key):
        result = ""
        try:
            result = self.cf.get(field, key)
        except:
            result = ""
        return result
    def set(self, filed, key, value):
        try:
            self.cf.set(field, key, value)
            cf.write(open(self.path,'w'))
        except:
            return False
        return True
def read_config(config_file_path, field, key):
    cf = ConfigParser.ConfigParser()
    try:
        cf.read(config_file_path)
        result = cf.get(field, key)
    except:
        sys.exit(1)
    return result
def write_config(config_file_path, field, key, value):
    cf = ConfigParser.ConfigParser()
    try:
        cf.read(config_file_path)
        cf.set(field, key, value)
        cf.write(open(config_file_path,'w'))
    except:
        sys.exit(1)
    return True
if __name__ == "__main__":
   if len(sys.argv) < 4:
      sys.exit(1)
   config_file_path = sys.argv[1]
   field = sys.argv[2]
   key = sys.argv[3]
   if len(sys.argv) == 4:
      print read_config(config_file_path, field, key)
   else:
      value = sys.argv[4]   #值从0－4，第5个值的下标为4
      write_config(config_file_path, field, key, value)

Example：设定配置文件test2.conf

1 2 3 4

[portal]  url = http: // %(host)s:%(port)s /Portal  host = localhost  port = 8080

使用RawConfigParser：

1 2 3 4 5 6 7 8 9 10 11

import  ConfigParser     cf  =  ConfigParser.RawConfigParser()     print  "use RawConfigParser() read"  cf.read( "test2.conf" )  print  cf.get( "portal" ,  "url" )     print  "use RawConfigParser() write"  cf. set ( "portal" ,  "url2" ,  "%(host)s:%(port)s" )  print  cf.get( "portal" ,  "url2" )

得到终端输出：

1 2 3 4

use RawConfigParser()  read  http: // %(host)s:%(port)s /Portal  use RawConfigParser() write  %(host)s:%(port)s

改用ConfigParser：

1 2 3 4 5 6 7 8 9 10 11

import  ConfigParser     cf  =  ConfigParser.ConfigParser()     print  "use ConfigParser() read"  cf.read( "test2.conf" )  print  cf.get( "portal" ,  "url" )     print  "use ConfigParser() write"  cf. set ( "portal" ,  "url2" ,  "%(host)s:%(port)s" )  print  cf.get( "portal" ,  "url2" )

得到终端输出：

1 2 3 4

use ConfigParser()  read  http: //localhost :8080 /Portal  use ConfigParser() write  localhost:8080

改用SafeConfigParser：

1 2 3 4 5 6 7 8 9 10 11

import  ConfigParser     cf  =  ConfigParser.SafeConfigParser()     print  "use SafeConfigParser() read"  cf.read( "test2.conf" )  print  cf.get( "portal" ,  "url" )     print  "use SateConfigParser() write"  cf. set ( "portal" ,  "url2" ,  "%(host)s:%(port)s" )  print  cf.get( "portal" ,  "url2" )

得到终端输出(效果同ConfigParser)：

1 2 3 4

use SafeConfigParser()  read  http: //localhost :8080 /Portal  use SateConfigParser() write  localhost:8080

三个类的区别。

下面是一个configparser example工程，多个配置文件的使用，字体配置和日志信息配置文件

settings.ini

[Settings]
font = Courier
font_size = 10
font_style = Normal
font_info = You are using %(font)s at %(font_size)s pt

config.ini

[loggers]
keys=root,exampleApp

[logger_root]
level=DEBUG
handlers=hand02

[logger_exampleApp]
level=INFO
handlers=hand01
qualname=exampleApp
############################################
[handlers]
keys=hand01,hand02

[handler_hand01]
class=StreamHandler
level=DEBUG
formatter=myFormatter
args=(sys.stdout,)

[handler_hand02]
class=FileHandler
formatter=myFormatter
args=("config.log",'a')

##############################################
[formatters]
keys=myFormatter

[formatter_myFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=

运行一个加法函数并且输出到log中

other_module.py

import logging

#module_logger = logging.getLogger("exampleApp.other_module")
def add(x, y):
    """
    Add two items together.
    :param x:
    :param y:
    :return:
    """
    logger = logging.getLogger("exampleApp.other_module.add")
    logger.info("added %s and %s to get %s" % (x, y, x+y))

    return x + y

settings.ini文件也可以生成，create_config.py

import configparser
import os
def create_config(file_path):
    """
    Create a config file.
    :param file_path:
    :return:
    """
    config = configparser.ConfigParser()
    config.add_section("Settings")
    config.set("Settings", "font", "Courier")
    config.set("Settings", "font_size", "10")
    config.set("Settings", "font_style", "Normal")
    config.set("Settings", "font_info", "You are using %(font)s at %(font_size)s pt")

    with open(file_path, "w") as config_file:
        config.write(config_file)


def get_config(file_path):
    """
    Get a config object.
    :param file_path:
    :return config: Config obj
    """
    if not os.path.exists(file_path):
        create_config(file_path)

    config = configparser.ConfigParser()
    config.read(path)

    return config


def get_setting(file_path, section, setting):
    """
    Print a setting to console.
    :param file_path:
    :param section:
    :param setting:
    :return value:
    """
    config = get_config(file_path)
    value = config.get(section, setting)
    msg = "{section} {setting} is {value}". format(section=section,
                                                   setting=setting,
                                                   value=value)
    print(msg)
    return value


def update_setting(file_path, section, setting, value):
    """
    Update a config setting.
    :param file_path:
    :param section:
    :param setting:
    :param value:
    :return:
    """
    config = get_config(file_path)
    config.set(section, setting, value)
    with open(file_path, "w") as config_file:
        config.write(config_file)


def delete_setting(file_path, section, setting):
    """
    Delete a config setting.
    :param file_path:
    :param section:
    :param setting:
    :return:
    """
    config = get_config(file_path)
    config.remove_option(section, setting)
    with open(file_path, "w") as config_file:
        config.write(config_file)
def interpolation_demo(file_path):
    """
    Interpolation means we can use some options to build another option.
    Example would be the font_info option values that can be changed via dictionary.
    :param file_path:
    :return:
    """
    if not os.path.exists(file_path):
        create_config(file_path)

    config = configparser.ConfigParser()
    config.read(file_path)

    print(config.get("Settings", "font_info"))

    print(config.get("Settings", "font_info",
                     vars={"font": "Arial", "font_size": "100"}))

if __name__ == "__main__":
    path = "settings.ini"
    # create_config(path)
    # font = get_setting(path, 'Settings', 'font')
    # font_size = get_setting(path, 'Settings', 'font_size')
    #
    # update_setting(path, "Settings", "font_size", "12")
    #
    # delete_setting(path, "Settings", "font_style")
    interpolation_demo(path)

log_with_config.py

import logging
import logging.config
import other_module


def main():
    logging.config.fileConfig("config.ini")
    logger = logging.getLogger("root")

    logger.info("Program started")
    result = other_module.add(7, 8)
    logger.info("Done!")

if __name__ == "__main__":
    main()

logger.py

import logging
import other_module
def main():
    """
    The main entry point of the application.
    :return:
    """
    logger = logging.getLogger("example_app")
    logger.setLevel(logging.INFO)
    # create the logging file handler
    fh = logging.FileHandler("new.log")
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    fh.setFormatter(formatter)
    # add handler to logger object
    logger.addHandler(fh)

    logger.info("Program started")
    result = other_module.add(7, 8)
    logger.info("Done!")

if __name__ == "__main__":
    main()

log+configparser模块整合学习收工。。。。。。。。。。。。。。。。。。。。

参考：

http://www.361way.com/python-configparser/4631.html

http://www.pythontab.com/html/2014/pythonhexinbiancheng_1120/919.html