在我过度复杂化简单内容的无尽追求中，我正在研究最常用的“Pythonic”方法，在Python egg包中的典型“ config.py ”中提供全局配置变量。
传统方式（aah，good ol' #define ！）如下：
MYSQL_PORT = 3306
MYSQL_DATABASE = 'mydb'
MYSQL_DATABASE_TABLES = ['tb_users', 'tb_groups']
因此，全局变量以下列方式之一导入：
from config import *
dbname = MYSQL_DATABASE
for table in MYSQL_DATABASE_TABLES:
print table
或：
import config
dbname = config.MYSQL_DATABASE
assert(isinstance(config.MYSQL_PORT, int))
这很有意义，但有时可能会有点混乱，特别是当你想要记住某些变量的名字时。此外，提供'配置'对象，变量作为属性，可能更灵活。因此，从 bpython config.py文件中取得领先，我提出了：
class Struct(object):
def __init__(self, *args):
self.__header__ = str(args[0]) if args else None
def __repr__(self):
if self.__header__ is None:
return super(Struct, self).__repr__()
return self.__header__
def next(self):
""" Fake iteration functionality.
"""
raise StopIteration
def __iter__(self):
""" Fake iteration functionality.
We skip magic attribues and Structs, and return the rest.
"""
ks = self.__dict__.keys()
for k in ks:
if not k.startswith('__') and not isinstance(k, Struct):
yield getattr(self, k)
def __len__(self):
""" Don't count magic attributes or Structs.
"""
ks = self.__dict__.keys()
return len([k for k in ks if not k.startswith('__')\
and not isinstance(k, Struct)])
和导入该类的'config.py'，内容如下：
from _config import Struct as Section
mysql = Section("MySQL specific configuration")
mysql.user = 'root'
mysql.pass = 'secret'
mysql.host = 'localhost'
mysql.port = 3306
mysql.database = 'mydb'
mysql.tables = Section("Tables for 'mydb'")
mysql.tables.users = 'tb_users'
mysql.tables.groups = 'tb_groups'
并以这种方式使用：
from sqlalchemy import MetaData, Table
import config as CONFIG
assert(isinstance(CONFIG.mysql.port, int))
mdata = MetaData(
"mysql://%s:%s@%s:%d/%s" % (
CONFIG.mysql.user,
CONFIG.mysql.pass,
CONFIG.mysql.host,
CONFIG.mysql.port,
CONFIG.mysql.database,
)
)
tables = []
for name in CONFIG.mysql.tables:
tables.append(Table(name, mdata, autoload=True))
这似乎是一种在包中存储和获取全局变量的更具可读性，表达性和灵活性的方法。
Lamest的想法永远？应对这些情况的最佳做法是什么？什么是以方式在包中存储和获取全局名称和变量？
答案 0 :(得分：49)
如何使用这样的内置类型：
config = {
"mysql": {
"user": "root",
"pass": "secret",
"tables": {
"users": "tb_users"
}
# etc
}
}
您可以按如下方式访问这些值：
config["mysql"]["tables"]["users"]
如果您愿意牺牲在配置树中计算表达式的潜力，可以使用YAML并最终得到一个更易读的配置文件，如下所示：
mysql:
- user: root
- pass: secret
- tables:
- users: tb_users
并使用像PyYAML这样的库来方便地解析和访问配置文件
答案 1 :(得分：8)
类似于blubb的答案。我建议使用lambda函数构建它们以减少代码。像这样：
User = lambda passwd, hair, name: {'password':passwd, 'hair':hair, 'name':name}
#Col Username Password Hair Color Real Name
config = {'st3v3' : User('password', 'blonde', 'Steve Booker'),
'blubb' : User('12345678', 'black', 'Bubb Ohaal'),
'suprM' : User('kryptonite', 'black', 'Clark Kent'),
#...
}
#...
config['st3v3']['password'] #> password
config['blubb']['hair'] #> black
这确实闻起来像你可能想要上课一样。
或者，正如MarkM所说，您可以使用namedtuple
from collections import namedtuple
#...
User = namedtuple('User', ['password', 'hair', 'name']}
#Col Username Password Hair Color Real Name
config = {'st3v3' : User('password', 'blonde', 'Steve Booker'),
'blubb' : User('12345678', 'black', 'Bubb Ohaal'),
'suprM' : User('kryptonite', 'black', 'Clark Kent'),
#...
}
#...
config['st3v3'].password #> passwd
config['blubb'].hair #> black
答案 2 :(得分：5)
我做过一次。最终我发现我的简化basicconfig.py足以满足我的需求。如果需要，可以使用其他对象传入名称空间以供引用。您还可以从代码中传递其他默认值。它还将属性和映射样式语法映射到同一配置对象。
答案 3 :(得分：5)
如何使用课程？
# config.py
class MYSQL:
PORT = 3306
DATABASE = 'mydb'
DATABASE_TABLES = ['tb_users', 'tb_groups']
# main.py
from config import MYSQL
print(MYSQL.PORT) # 3306
答案 4 :(得分：3)
我使用赫斯基的想法的一个小变化。创建一个名为'globals'的文件（或任何你喜欢的文件），然后在其中定义多个类，如下：
#globals.py
class dbinfo : # for database globals
username = 'abcd'
password = 'xyz'
class runtime :
debug = False
output = 'stdio'
然后，如果你有两个代码文件c1.py和c2.py，两者都可以在顶部
import globals as gl
现在所有代码都可以访问和设置值，如下所示：
gl.runtime.debug = False
print(gl.dbinfo.username)
人们忘记了类存在，即使没有实例化的对象是该类的成员。并且类中的变量前面没有'self'。在所有类的实例中共享，即使没有。一旦'debug'被任何代码更改，所有其他代码都会看到更改。
通过将其导入为gl，您可以拥有多个此类文件和变量，允许您跨代码文件，函数等访问和设置值，但不存在命名空间冲突的危险。
这缺乏对其他方法的一些巧妙的错误检查，但是简单易行。
答案 5 :(得分：1)
请查看IPython配置系统，通过traitlets实现您手动执行的类型实施。
剪切并粘贴在此处，以符合SO指南，不仅仅是随着链接内容的变化而删除链接。
以下是我们希望配置系统具备的主要要求：
支持分层配置信息。
与命令行选项解析器完全集成。通常，您希望读取配置文件，但随后使用命令行选项覆盖某些值。我们的配置系统自动执行此过程，并允许每个命令行选项链接到它将覆盖的配置层次结构中的特定属性。
配置文件本身就是有效的Python代码。这完成了许多事情。首先，可以在配置文件中放置逻辑，根据您的操作系统，网络设置，Python版本等设置属性。其次，Python有一个超级简单的语法来访问分层数据结构，即常规属性访问（Foo。 Bar.Bam.name）。第三，使用Python可以让用户轻松地将配置属性从一个配置文件导入另一个配置文件。 第四，即使Python是动态类型的，它也有可以在运行时检查的类型。因此，配置文件中的1是整数“1”，而“1”是字符串。
一种完全自动化的方法，用于在运行时将配置信息提供给需要它的类。编写遍历配置层次结构以提取特定属性的代码非常痛苦。当您拥有包含数百个属性的复杂配置信息时，这会让您想哭。
类型检查和验证，不需要在运行时之前静态指定整个配置层次结构。 Python是一种非常动态的语言，并且您并不总是知道程序启动时需要配置的所有内容。
为了实现这一点，他们基本上定义了3个对象类及其相互关系：
1）配置 - 基本上是一个ChainMap / basic dict，带有一些合并的增强功能。
2）可配置 - 基类，用于子类化您希望配置的所有内容。
3）应用程序 - 实例化以执行特定应用程序功能的对象，或用于单用途软件的主应用程序。
用他们的话说：
申请：申请
应用程序是执行特定作业的过程。最明显的应用是ipython命令行程序。每个应用程序读取一个或多个配置文件和一组命令行选项，然后为应用程序生成主配置对象。然后将此配置对象传递给应用程序创建的可配置对象。这些可配置对象实现了应用程序的实际逻辑，并知道如何在给定配置对象的情况下自行配置。
应用程序始终具有一个已配置的Logger的日志属性。这允许每个应用程序集中记录配置。 可配置：可配置
可配置是一个常规Python类，它充当应用程序中所有主类的基类。可配置基类是轻量级的，只做一件事。
此Configurable是HasTraits的子类，它知道如何配置自身。具有元数据config = True的类级别特征将成为可以从命令行和配置文件配置的值。
开发人员创建可实现的子类，实现应用程序中的所有逻辑。这些子类中的每一个都有自己的配置信息，用于控制实例的创建方式。
答案 6 :(得分：0)
说实话，我们可能应该考虑使用 Python Software Foundation 维护的库：
https://docs.python.org/3/library/configparser.html
配置示例：（ini格式，但提供JSON）
[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
[bitbucket.org]
User = hg
[topsecret.server.com]
Port = 50022
ForwardX11 = no
代码示例：
>>> import configparser
>>> config = configparser.ConfigParser()
>>> config.read('example.ini')
>>> config['DEFAULT']['Compression']
'yes'
>>> config['DEFAULT'].getboolean('MyCompression', fallback=True) # get_or_else
使其可全局访问：
import configpaser
class App:
__conf = None
@staticmethod
def config():
if App.__conf is None: # Read only once, lazy.
App.__conf = configparser.ConfigParser()
App.__conf.read('example.ini')
return App.__conf
if __name__ == '__main__':
App.config()['DEFAULT']['MYSQL_PORT']
# or, better:
App.config().get(section='DEFAULT', option='MYSQL_PORT', fallback=3306)
....
缺点：