Самый Pythonic способ предоставить глобальные переменные конфигурации в config.py?

Я сделал это однажды. В конце концов я нашел мой упрощенный basicconfig.py адекватным для моего потребности. Вы можете передать пространство имен с другими объектами для ссылки на него, если вам нужно. Вы также можете передать дополнительные значения по умолчанию из своего кода. Он также сопоставляет атрибут и синтаксис стиля сопоставления с одним и тем же объектом конфигурации.

Как насчет того, чтобы просто использовать встроенные типы, подобные этому:

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, для удобного анализа и доступа к файлу конфигурации.

Мне нравится это решение для небольших приложений:

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's answer). Для небольших приложений это решение проще.

Как насчет использования классов?

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

# main.py
from config import MYSQL

print(MYSQL.PORT) # 3306

Небольшая вариация идеи Хаски, которую я использую. Создайте файл с именем «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)

Люди забывают о существовании классов, даже если никогда не создается экземпляр объекта, являющегося членом этого класса. И переменные в классе, которым не предшествует «я». являются общими для всех экземпляров класса, даже если их нет. Как только «отладка» изменена каким-либо кодом, весь остальной код увидит это изменение.

Импортируя его как gl, вы можете иметь несколько таких файлов и переменных, которые позволяют вам получать доступ и устанавливать значения в файлах кода, функциях и т. д., но без опасности конфликта пространств имен.

В нем отсутствуют некоторые умные проверки ошибок других подходов, но он прост и легок в использовании.

Давайте будем честными, нам, вероятно, следует рассмотреть возможность использования поддерживаемой библиотеки 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)
 ....

Недостатки:

• Неконтролируемое глобальное изменяемое состояние.

Похоже на ответ blubb. Я предлагаю создавать их с помощью лямбда-функций, чтобы сократить код. Так:

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

пожалуйста, ознакомьтесь с системой конфигурации IPython, реализованной с помощью трейлетов для принудительного применения типов, которое вы делаете вручную.

Вырежьте и вставьте сюда, чтобы соответствовать рекомендациям SO, а не просто удалять ссылки, поскольку содержание ссылок меняется с течением времени.

документация по трейтлетам

Вот основные требования, которые мы хотели, чтобы наша система конфигурации имела:

Поддержка иерархической информации о конфигурации.

Полная интеграция с парсерами параметров командной строки. Часто вы хотите прочитать файл конфигурации, но затем переопределить некоторые значения с помощью параметров командной строки. Наша система конфигурации автоматизирует этот процесс и позволяет связать каждый параметр командной строки с определенным атрибутом в иерархии конфигурации, который он переопределяет.

Файлы конфигурации, которые сами по себе являются действительным кодом Python. Этим достигается многое. Во-первых, становится возможным поместить в ваши файлы конфигурации логику, которая устанавливает атрибуты в зависимости от вашей операционной системы, настройки сети, версии Python и т. д. Во-вторых, Python имеет очень простой синтаксис для доступа к иерархическим структурам данных, а именно обычный доступ к атрибутам (Foo. Бар.Бам.имя). В-третьих, использование Python позволяет пользователям легко импортировать атрибуты конфигурации из одного файла конфигурации в другой. В-четвертых, несмотря на то, что Python имеет динамическую типизацию, в нем есть типы, которые можно проверить во время выполнения. Таким образом, 1 в конфигурационном файле — это целое число «1», а «1» — это строка.

Полностью автоматизированный метод получения информации о конфигурации для классов, которым она нужна во время выполнения. Написание кода, который обходит иерархию конфигурации для извлечения определенного атрибута, является болезненным. Когда у вас есть сложная информация о конфигурации с сотнями атрибутов, вам хочется плакать.

Проверка типов и проверка, не требующие статического указания всей иерархии конфигурации перед выполнением. Python — очень динамичный язык, и вы не всегда знаете все, что нужно настроить при запуске программы.

Для этого они в основном определяют 3 класса объектов и их отношения друг к другу:

1) Конфигурация - в основном ChainMap/базовый словарь с некоторыми улучшениями для слияния.

2) Configurable — базовый класс для подкласса всего, что вы хотите настроить.

3) Приложение — объект, созданный для выполнения определенной прикладной функции, или ваше основное приложение для одноцелевого программного обеспечения.

По их словам:

Применение: Приложение

Приложение — это процесс, выполняющий определенную работу. Наиболее очевидным приложением является программа командной строки ipython. Каждое приложение считывает один или несколько файлов конфигурации и один набор параметров командной строки, а затем создает главный объект конфигурации для приложения. Затем этот объект конфигурации передается настраиваемым объектам, которые создает приложение. Эти настраиваемые объекты реализуют фактическую логику приложения и знают, как настроить себя с учетом объекта конфигурации.

Приложения всегда имеют атрибут журнала, который является настроенным Logger. Это позволяет централизованно настроить ведение журнала для каждого приложения. Настраиваемый: Настраиваемый

Конфигурируемый — это обычный класс Python, который служит базовым классом для всех основных классов в приложении. Базовый класс Configurable легковесен и выполняет только одну функцию.

Этот Configurable является подклассом HasTraits, который умеет настраивать себя. Черты уровня класса с метаданными config=True становятся значениями, которые можно настроить из командной строки и файлов конфигурации.

Разработчики создают подклассы Configurable, реализующие всю логику приложения. Каждый из этих подклассов имеет свою собственную информацию о конфигурации, которая управляет тем, как создаются экземпляры.