129

在我对过于复杂的简单事物的无尽追求中，我正在研究最“Pythonic”的方式来在 Python egg 包中的典型“ config.py ”中提供全局配置变量。

传统的方式（啊，好' #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))

这似乎是一种在包内存储和获取全局变量的更具可读性、表现力和灵活性的方式。

有史以来最蹩脚的想法？应对这些情况的最佳做法是什么？您在包中存储和获取全局名称和变量的方式是什么？

4

8 回答 8

63

像这样使用内置类型怎么样：

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之类的库来方便地解析和访问配置文件

于 2011-06-01T09:52:12.093 回答
29

我喜欢这种适用于小型应用程序的解决方案：

class App:
  __conf = {
    "username": "",
    "password": "",
    "MYSQL_PORT": 3306,
    "MYSQL_DATABASE": 'mydb',
    "MYSQL_DATABASE_TABLES": ['tb_users', 'tb_groups']
  }
  __setters = ["username", "password"]

  @staticmethod
  def config(name):
    return App.__conf[name]

  @staticmethod
  def set(name, value):
    if name in App.__setters:
      App.__conf[name] = value
    else:
      raise NameError("Name not accepted in set() method")

然后用法是：

if __name__ == "__main__":
   # from config import App
   App.config("MYSQL_PORT")     # return 3306
   App.set("username", "hi")    # set new username value
   App.config("username")       # return "hi"
   App.set("MYSQL_PORT", "abc") # this raises NameError

..你应该喜欢它，因为：

  • 使用类变量（没有对象可以传递/不需要单例），
  • 使用封装的内置类型，看起来像（是）一个方法调用App，
  • 可以控制单个配置的不变性，可变全局变量是最糟糕的全局变量。
  • 在您的源代码中促进常规和命名良好的访问/可读性
  • 是一个简单的类，但强制执行结构化访问，另一种方法是使用@property，但这需要每个项目更多的变量处理代码并且是基于对象的。
  • 需要最少的更改来添加新的配置项并设置其可变性。

--Edit--：对于大型应用程序，将值存储在 YAML（即属性）文件中并将其作为不可变数据读取是一种更好的方法（即blubb/ohaal 的答案）。对于小型应用程序，上述解决方案更简单。

于 2017-05-12T15:37:44.133 回答
18

如何使用类？

# config.py
class MYSQL:
    PORT = 3306
    DATABASE = 'mydb'
    DATABASE_TABLES = ['tb_users', 'tb_groups']

# main.py
from config import MYSQL

print(MYSQL.PORT) # 3306
于 2017-07-01T22:41:51.233 回答
14

老实说，我们可能应该考虑使用Python 软件基金会维护的库：

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)
 ....

缺点：

  • 不受控制的全局可变状态。
于 2019-11-18T04:19:13.470 回答
10

我使用的赫斯基想法的一个小变化。创建一个名为“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”开头的变量。在类的所有实例之间共享，即使没有。一旦任何代码更改了“调试”，所有其他代码都会看到更改。

通过将其作为 gl 导入，您可以拥有多个此类文件和变量，这些文件和变量允许您跨代码文件、函数等访问和设置值，但没有命名空间冲突的危险。

这缺乏其他方法的一些巧妙的错误检查，但简单易懂。

于 2017-10-13T00:57:15.443 回答
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
于 2014-09-16T23:42:00.190 回答
5

我做过一次。最终，我发现简化的basicconfig.py足以满足我的需要。如果需要，您可以传入带有其他对象的名称空间以供参考。您还可以从代码中传递其他默认值。它还将属性和映射样式语法映射到相同的配置对象。

于 2011-06-01T08:47:28.643 回答
4

请查看 IPython 配置系统，通过 traitlets 实现您手动执行的类型强制。

在此处剪切和粘贴以符合 SO 准则，因为链接的内容会随着时间的推移而变化，而不仅仅是删除链接。

traitlets 文档

以下是我们希望配置系统具备的主要要求：

支持分层配置信息。

与命令行选项解析器完全集成。通常，您希望读取配置文件，然后使用命令行选项覆盖某些值。我们的配置系统自动执行此过程，并允许将每个命令行选项链接到配置层次结构中将覆盖的特定属性。

配置文件本身就是有效的 Python 代码。这完成了很多事情。首先，可以将逻辑放入配置文件中，根据操作系统、网络设置、Python 版本等设置属性。其次，Python 有一种非常简单的语法来访问分层数据结构，即常规属性访问（Foo. Bar.Bam.name）。第三，使用 Python 使用户可以轻松地将配置属性从一个配置文件导入到另一个配置文件。第四，尽管 Python 是动态类型的，但它确实具有可以在运行时检查的类型。因此，配置文件中的 1 是整数 '1'，而 '1' 是字符串。

一种完全自动化的方法，用于在运行时将配置信息传递给需要它的类。编写遍历配置层次结构以提取特定属性的代码是痛苦的。当您拥有具有数百个属性的复杂配置信息时，这会让您想哭。

不需要在运行前静态指定整个配置层次结构的类型检查和验证。Python 是一种非常动态的语言，您并不总是知道程序启动时需要配置的所有内容。

为了实现这一点，他们基本上定义了 3 个对象类及其相互关系：

1) 配置 - 基本上是一个 ChainMap / 基本字典，具有一些合并增强功能。

2) 可配置 - 基类来子类您希望配置的所有内容。

3) 应用程序 - 被实例化以执行特定应用程序功能的对象，或用于单一用途软件的主应用程序。

用他们的话来说：

应用：应用

应用程序是执行特定工作的进程。最明显的应用是 ipython 命令行程序。每个应用程序读取一个或多个配置文件和一组命令行选项，然后为应用程序生成一个主配置对象。然后将此配置对象传递给应用程序创建的可配置对象。这些可配置对象实现了应用程序的实际逻辑，并且知道如何在给定配置对象的情况下配置自己。

应用程序始终有一个日志属性，即配置的 Logger。这允许每个应用程序集中日志配置。可配置：可配置

可配置是一个常规的 Python 类，它充当应用程序中所有主要类的基类。Configurable 基类是轻量级的，只做一件事。

这个 Configurable 是 HasTraits 的一个子类，它知道如何配置自己。元数据 config=True 的类级别特征成为可以从命令行和配置文件配置的值。

开发人员创建可配置的子类来实现应用程序中的所有逻辑。这些子类中的每一个都有自己的配置信息，用于控制如何创建实例。

于 2017-04-14T15:55:11.713 回答