> **Источник:** https://python-all.ru/3.5/library/configparser.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# 14.2. [`configparser`](https://python-all.ru/3.5/library/configparser.html#module-configparser) – Парсер конфигурационных файлов

**Исходный код:** [Lib/configparser.py](https://python-all.ru/src/3.5/Lib/configparser.py)

---

Этот модуль предоставляет класс [`ConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser), реализующий базовый язык конфигурации, структура которого аналогична файлам INI в Microsoft Windows. Его можно использовать для написания программ на Python, которые конечные пользователи могут легко настраивать.

> **Примечание**
>
> Эта библиотека *не* интерпретирует и не записывает префиксы типов значений, используемые в расширенной версии синтаксиса INI из реестра Windows.

> **См. также**
>
> **Модуль [`shlex`](https://python-all.ru/3.5/library/shlex.html#module-shlex)**
>
> Поддержка создания мини-языков, подобных командным оболочкам Unix, которые можно использовать в качестве альтернативного формата для файлов конфигурации приложений.
>
> **Модуль [`json`](https://python-all.ru/3.5/library/json.html#module-json)**
>
> Модуль json реализует подмножество синтаксиса JavaScript, которое также можно использовать для этой цели.

## 14.2.1. Быстрый старт

Рассмотрим простейший конфигурационный файл, который выглядит так:

```ini
[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes

[bitbucket.org]
User = hg

[topsecret.server.com]
Port = 50022
ForwardX11 = no
```

Структура INI-файлов описана [в следующем разделе](https://python-all.ru/3.5/library/configparser.html#supported-ini-file-structure). По существу, файл состоит из секций, каждая из которых содержит ключи со значениями. Класс [`configparser`](https://python-all.ru/3.5/library/configparser.html#module-configparser) может читать и записывать такие файлы. Начнем с программного создания приведенного выше конфигурационного файла.

```pycon
>>> import configparser
>>> config = configparser.ConfigParser()
>>> config['DEFAULT'] = {'ServerAliveInterval': '45',
...                      'Compression': 'yes',
...                      'CompressionLevel': '9'}
>>> config['bitbucket.org'] = {}
>>> config['bitbucket.org']['User'] = 'hg'
>>> config['topsecret.server.com'] = {}
>>> topsecret = config['topsecret.server.com']
>>> topsecret['Port'] = '50022'     # изменяет парсер
>>> topsecret['ForwardX11'] = 'no'  # то же самое
>>> config['DEFAULT']['ForwardX11'] = 'yes'
>>> with open('example.ini', 'w') as configfile:
...   config.write(configfile)
...
```

Как видите, парсер конфигураций можно использовать почти как словарь. Есть различия, [описанные далее](https://python-all.ru/3.5/library/configparser.html#mapping-protocol-access), но поведение очень близко к тому, что можно ожидать от словаря.

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

```pycon
>>> import configparser
>>> config = configparser.ConfigParser()
>>> config.sections()
[]
>>> config.read('example.ini')
['example.ini']
>>> config.sections()
['bitbucket.org', 'topsecret.server.com']
>>> 'bitbucket.org' in config
True
>>> 'bytebong.com' in config
False
>>> config['bitbucket.org']['User']
'hg'
>>> config['DEFAULT']['Compression']
'yes'
>>> topsecret = config['topsecret.server.com']
>>> topsecret['ForwardX11']
'no'
>>> topsecret['Port']
'50022'
>>> for key in config['bitbucket.org']: print(key)
...
user
compressionlevel
serveraliveinterval
compression
forwardx11
>>> config['bitbucket.org']['ForwardX11']
'yes'
```

Как видно выше, API довольно прост. Единственная «магия» – это секция `DEFAULT`, которая предоставляет значения по умолчанию для всех остальных секций [\[1\]](https://python-all.ru/3.5/library/configparser.html#id14). Также обратите внимание, что ключи в секциях нечувствительны к регистру и хранятся в нижнем регистре [\[1\]](https://python-all.ru/3.5/library/configparser.html#id14).

## 14.2.2. Поддерживаемые типы данных

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

```pycon
>>> int(topsecret['Port'])
50022
>>> float(topsecret['CompressionLevel'])
9.0
```

Поскольку эта задача встречается часто, парсеры конфигураций предоставляют ряд удобных методов-геттеров для работы с целыми числами, числами с плавающей точкой и булевыми значениями. Последний тип наиболее интересен, потому что простая передача значения в `bool()` не даст результата, поскольку `bool('False')` все еще является `True`. Именно поэтому парсеры конфигураций также предоставляют метод [`getboolean()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getboolean). Этот метод нечувствителен к регистру и распознает булевы значения из `'yes'`/`'no'`, `'on'`/`'off'`, `'true'`/`'false'` и `'1'`/`'0'` [\[1\]](https://python-all.ru/3.5/library/configparser.html#id14). Например:

```pycon
>>> topsecret.getboolean('ForwardX11')
False
>>> config['bitbucket.org'].getboolean('ForwardX11')
True
>>> config.getboolean('bitbucket.org', 'Compression')
True
```

Помимо [`getboolean()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getboolean), парсеры конфигураций также предоставляют эквивалентные методы [`getint()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getint) и [`getfloat()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getfloat). Вы можете зарегистрировать собственные преобразователи и настроить предоставленные. [\[1\]](https://python-all.ru/3.5/library/configparser.html#id14)

## 14.2.3. Значения по умолчанию

Как и в словаре, для указания резервных значений можно использовать метод `get()` секции:

```pycon
>>> topsecret.get('Port')
'50022'
>>> topsecret.get('CompressionLevel')
'9'
>>> topsecret.get('Cipher')
>>> topsecret.get('Cipher', '3des-cbc')
'3des-cbc'
```

Обратите внимание, что значения по умолчанию имеют приоритет над резервными. Например, в нашем примере ключ `'CompressionLevel'` был указан только в секции `'DEFAULT'`. Если мы попытаемся получить его из секции `'topsecret.server.com'`, мы всегда получим значение по умолчанию, даже если указано резервное:

```pycon
>>> topsecret.get('CompressionLevel', '3')
'9'
```

Еще одна деталь: метод `get()` на уровне парсера предоставляет собственный, более сложный интерфейс, сохраненный для обратной совместимости. При использовании этого метода резервное значение можно передать через именованный аргумент `fallback`:

```pycon
>>> config.get('bitbucket.org', 'monster',
...            fallback='No such things as monsters')
'No such things as monsters'
```

Тот же аргумент `fallback` можно использовать с методами [`getint()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getint), [`getfloat()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getfloat) и [`getboolean()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getboolean), например:

```pycon
>>> 'BatchMode' in topsecret
False
>>> topsecret.getboolean('BatchMode', fallback=True)
True
>>> config['DEFAULT']['BatchMode'] = 'no'
>>> topsecret.getboolean('BatchMode', fallback=True)
False
```

## 14.2.4. Поддерживаемая структура INI-файлов

Конфигурационный файл состоит из секций, каждая секция начинается с заголовка `[section]`, за которым следуют записи ключ/значение, разделённые определённой строкой (по умолчанию `=` или `:` [\[1\]](https://python-all.ru/3.5/library/configparser.html#id14)). По умолчанию имена секций чувствительны к регистру, а ключи – нет [\[1\]](https://python-all.ru/3.5/library/configparser.html#id14). Начальные и конечные пробелы удаляются из ключей и значений. Значения можно опускать, и в этом случае разделитель ключ/значение также может быть опущен. Значения могут занимать несколько строк, если они имеют больший отступ, чем первая строка значения. В зависимости от режима парсера пустые строки могут считаться частью многострочных значений или игнорироваться.

Конфигурационные файлы могут содержать комментарии, начинающиеся с определенных символов (по умолчанию `#` и `;` [\[1\]](https://python-all.ru/3.5/library/configparser.html#id14)). Комментарии могут располагаться на отдельной пустой строке, возможно с отступом. [\[1\]](https://python-all.ru/3.5/library/configparser.html#id14)

Например:

```ini
[Simple Values]
key=value
spaces in keys=allowed
spaces in values=allowed as well
spaces around the delimiter = obviously
you can also use : to delimit keys from values

[All Values Are Strings]
values like this: 1000000
or this: 3.14159265359
are they treated as numbers? : no
integers, floats and booleans are held as: strings
can use the API to get converted values directly: true

[Multiline Values]
chorus: I'm a lumberjack, and I'm okay
    I sleep all night and I work all day

[No Values]
key_without_value
empty string value here =

[You can use comments]
# как этот
; или этот

# По умолчанию только в пустой строке.
# Встроенные комментарии могут быть вредны, поскольку не позволяют пользователям
# использовать разделительные символы как части значений.
# Тем не менее, это можно настроить.

    [Sections Can Be Indented]
        can_values_be_as_well = True
        does_that_mean_anything_special = False
        purpose = formatting for readability
        multiline_values = are
            handled just fine as
            long as they are indented
            deeper than the first line
            of a value
        # Кстати, комментарии тоже можно делать с отступом.
```

## 14.2.5. Интерполяция значений

Помимо основной функциональности, [`ConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser) поддерживает интерполяцию. Это означает, что значения могут обрабатываться перед тем, как быть возвращёнными из вызовов `get()`.

#### `class configparser.BasicInterpolation`

Реализация по умолчанию, используемая в [`ConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser). Она позволяет значениям содержать строки форматирования, ссылающиеся на другие значения в том же разделе или на значения в специальном разделе по умолчанию [\[1\]](https://python-all.ru/3.5/library/configparser.html#id14). Дополнительные значения по умолчанию можно указать при инициализации.

Например:

```ini
[Paths]
home_dir: /Users
my_dir: %(home_dir)s/lumberjack
my_pictures: %(my_dir)s/Pictures
```

В примере выше [`ConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser) с параметром *interpolation*, установленным в `BasicInterpolation()`, преобразовал бы `%(home_dir)s` в значение `home_dir` (в данном случае `/Users`). `%(my_dir)s`, в свою очередь, преобразовалось бы в `/Users/lumberjack`. Все подстановки выполняются по требованию, поэтому ключи, используемые в цепочке ссылок, не обязаны быть указаны в каком-либо определённом порядке в конфигурационном файле.

Если `interpolation` установлен в `None`, анализатор просто вернёт `%(my_dir)s/Pictures` как значение `my_pictures` и `%(home_dir)s/lumberjack` как значение `my_dir`.

#### `class configparser.ExtendedInterpolation`

Альтернативный обработчик для интерполяции, реализующий более сложный синтаксис, используемый, например, в `zc.buildout`. Расширенная интерполяция использует `${section:option}` для обозначения значения из другого раздела. Интерполяция может быть многоуровневой. Для удобства, если часть `section:` опущена, интерполяция по умолчанию берётся из текущего раздела (а также из значений по умолчанию из специального раздела).

Например, конфигурация, заданная выше с базовой интерполяцией, с расширенной интерполяцией будет выглядеть так:

```ini
[Paths]
home_dir: /Users
my_dir: ${home_dir}/lumberjack
my_pictures: ${my_dir}/Pictures
```

Значения из других разделов также можно получать:

```ini
[Common]
home_dir: /Users
library_dir: /Library
system_dir: /System
macports_dir: /opt/local

[Frameworks]
Python: 3.2
path: ${Common:system_dir}/Library/Frameworks/

[Arthur]
nickname: Two Sheds
last_name: Jackson
my_dir: ${Common:home_dir}/twosheds
my_pictures: ${my_dir}/Pictures
python_dir: ${Frameworks:path}/Python/Versions/${Frameworks:Python}
```

## 14.2.6. Доступ через протокол отображения

Новое в версии 3.2.

Доступ через протокол отображения – это общее название функциональности, позволяющей использовать пользовательские объекты как словари. В случае [`configparser`](https://python-all.ru/3.5/library/configparser.html#module-configparser) реализация интерфейса отображения использует нотацию `parser['section']['option']`.

`parser['section']`, в частности, возвращает прокси для данных раздела в анализаторе. Это означает, что значения не копируются, а берутся из исходного анализатора по требованию. Что ещё более важно: при изменении значений в прокси-разделе они фактически изменяются и в исходном анализаторе.

Объекты [`configparser`](https://python-all.ru/3.5/library/configparser.html#module-configparser) ведут себя максимально близко к настоящим словарям. Интерфейс отображения реализован полностью и соответствует абстрактному базовому классу [`MutableMapping`](https://python-all.ru/3.5/library/collections.abc.html#collections.abc.MutableMapping). Однако есть несколько различий, которые следует учитывать:

- По умолчанию все ключи в разделах доступны без учёта регистра [\[1\]](https://python-all.ru/3.5/library/configparser.html#id14). Например, `for option in parser["section"]` возвращает только имена опций, приведённые к `optionxform`. По умолчанию это означает ключи в нижнем регистре. В то же время для раздела, содержащего ключ `'a'`, оба выражения вернут `True`:

  ```python
  "a" in parser["section"]
  "A" in parser["section"]
  ```
- Все разделы также содержат значения `DEFAULTSECT`, то есть `.clear()`, применённый к разделу, может не оставить его видимо пустым. Это связано с тем, что значения по умолчанию нельзя удалить из раздела (технически их там нет). Если они переопределены в разделе, удаление приводит к тому, что значение по умолчанию снова становится видимым. Попытка удалить значение по умолчанию вызывает `KeyError`.
- `DEFAULTSECT` нельзя удалить из анализатора:

  - попытка удалить его вызывает `ValueError`,
  - `parser.clear()` оставляет его нетронутым,
  - `parser.popitem()` никогда его не возвращает.
- `parser.get(section, option, **kwargs)` – второй аргумент **не** является запасным значением. Однако обратите внимание, что методы `get()` на уровне раздела совместимы как с протоколом отображения, так и с классическим API configparser.
- `parser.items()` совместим с протоколом отображения (возвращает список пар *название\_раздела*, *прокси\_раздела*, включая DEFAULTSECT). Однако этот метод также может быть вызван с аргументами: `parser.items(section, raw, vars)`. Последний вызов возвращает список пар *опция*, *значение* для указанного `section`, со всеми раскрытыми интерполяциями (если не указан `raw=True`).

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

## 14.2.7. Настройка поведения парсера

Вариантов формата INI почти столько же, сколько приложений, его использующих. [`configparser`](https://python-all.ru/3.5/library/configparser.html#module-configparser) прилагает большие усилия для поддержки максимально широкого набора стилей INI. Функциональность по умолчанию в основном продиктована историческим опытом, и вполне вероятно, что вам потребуется настроить некоторые возможности.

Самый распространённый способ изменить поведение конкретного анализатора конфигурации – использовать опции [`__init__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__init__):

- *defaults*, значение по умолчанию: `None`

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

  Подсказка: если нужно задать значения по умолчанию для конкретного раздела, используйте `read_dict()` до чтения самого файла.
- *dict\_type*, значение по умолчанию: [`collections.OrderedDict`](https://python-all.ru/3.5/library/collections.html#collections.OrderedDict)

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

  Альтернативный тип словаря можно использовать, например, для сортировки разделов и опций при обратной записи. Также можно использовать обычный словарь по соображениям производительности.

  Обратите внимание: существует несколько способов добавления набора пар ключ-значение за одну операцию. Если в таких операциях используется обычный словарь, порядок ключей может быть случайным. Например:

  ```pycon
  >>> parser = configparser.ConfigParser()
  >>> parser.read_dict({'section1': {'key1': 'value1',
  ...                                'key2': 'value2',
  ...                                'key3': 'value3'},
  ...                   'section2': {'keyA': 'valueA',
  ...                                'keyB': 'valueB',
  ...                                'keyC': 'valueC'},
  ...                   'section3': {'foo': 'x',
  ...                                'bar': 'y',
  ...                                'baz': 'z'}
  ... })
  >>> parser.sections()
  ['section3', 'section2', 'section1']
  >>> [option for option in parser['section3']]
  ['baz', 'foo', 'bar']
  ```

  В таких операциях также необходимо использовать упорядоченный словарь:

  ```pycon
  >>> from collections import OrderedDict
  >>> parser = configparser.ConfigParser()
  >>> parser.read_dict(
  ...   OrderedDict((
  ...     ('s1',
  ...      OrderedDict((
  ...        ('1', '2'),
  ...        ('3', '4'),
  ...        ('5', '6'),
  ...      ))
  ...     ),
  ...     ('s2',
  ...      OrderedDict((
  ...        ('a', 'b'),
  ...        ('c', 'd'),
  ...        ('e', 'f'),
  ...      ))
  ...     ),
  ...   ))
  ... )
  >>> parser.sections()
  ['s1', 's2']
  >>> [option for option in parser['s1']]
  ['1', '3', '5']
  >>> [option for option in parser['s2'].values()]
  ['b', 'd', 'f']
  ```
- *allow\_no\_value*, значение по умолчанию: `False`

  Известно, что некоторые конфигурационные файлы содержат настройки без значений, но в остальном соответствуют синтаксису, поддерживаемому [`configparser`](https://python-all.ru/3.5/library/configparser.html#module-configparser). Параметр *allow\_no\_value* конструктора можно использовать, чтобы указать, что такие значения следует принимать:

  ```pycon
  >>> import configparser

  >>> sample_config = """
  ... [mysqld]
  ...   user = mysql
  ...   pid-file = /var/run/mysqld/mysqld.pid
  ...   skip-external-locking
  ...   old_passwords = 1
  ...   skip-bdb
  ...   # we don't need ACID today
  ...   skip-innodb
  ... """
  >>> config = configparser.ConfigParser(allow_no_value=True)
  >>> config.read_string(sample_config)

  >>> # Настройки со значениями обрабатываются как и раньше:
  >>> config["mysqld"]["user"]
  'mysql'

  >>> # Настройки без значений дают None:
  >>> config["mysqld"]["skip-bdb"]

  >>> # Настройки, которые не указаны, по-прежнему вызывают ошибку:
  >>> config["mysqld"]["does-not-exist"]
  Traceback (most recent call last):
    ...
  KeyError: 'does-not-exist'
  ```
- *delimiters*, значение по умолчанию: `('=', ':')`

  Разделители – это подстроки, которые отделяют ключи от значений внутри раздела. Первое вхождение такой подстроки в строке считается разделителем. Это означает, что значения (но не ключи) могут содержать разделители.

  См. также аргумент *space\_around\_delimiters* для [`ConfigParser.write()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.write).
- *comment\_prefixes*, значение по умолчанию: `('#', ';')`
- *inline\_comment\_prefixes*, значение по умолчанию: `None`

  Префиксы комментариев – это строки, указывающие начало допустимого комментария в конфигурационном файле. *comment\_prefixes* используются только на пустых строках (возможно, с отступом), тогда как *inline\_comment\_prefixes* могут использоваться после любого допустимого значения (например, названий разделов, параметров и пустых строк). По умолчанию строчные комментарии отключены, а в качестве префиксов для комментариев на всю строку используются `'#'` и `';'`.

  Изменено в версии 3.2: В предыдущих версиях [`configparser`](https://python-all.ru/3.5/library/configparser.html#module-configparser) поведение соответствовало `comment_prefixes=('#',';')` и `inline_comment_prefixes=(';',)`.

  Обратите внимание: парсеры конфигурации не поддерживают экранирование префиксов комментариев, поэтому использование *inline\_comment\_prefixes* может помешать пользователям указывать значения параметров, содержащие символы, используемые как префиксы комментариев. Если сомневаетесь, избегайте установки *inline\_comment\_prefixes*. В любом случае, единственный способ сохранить символы префикса комментария в начале строки в многострочных значениях – это интерполировать префикс, например:

  ```python
  >>> from configparser import ConfigParser, ExtendedInterpolation
  >>> parser = ConfigParser(interpolation=ExtendedInterpolation())
  >>> # можно также использовать стандартный BasicInterpolation
  >>> parser.read_string("""
  ... [DEFAULT]
  ... hash = #
  ...
  ... [hashes]
  ... shebang =
  ...   ${hash}!/usr/bin/env python
  ...   ${hash} -*- coding: utf-8 -*-
  ...
  ... extensions =
  ...   enabled_extension
  ...   another_extension
  ...   #disabled_by_comment
  ...   yet_another_extension
  ...
  ... interpolation not necessary = if # is not at line start
  ... even in multiline values = line #1
  ...   line #2
  ...   line #3
  ... """)
  >>> print(parser['hashes']['shebang'])

  #!/usr/bin/env python
  # -*- coding: utf-8 -*-
  >>> print(parser['hashes']['extensions'])

  enabled_extension
  another_extension
  yet_another_extension
  >>> print(parser['hashes']['interpolation not necessary'])
  if # is not at line start
  >>> print(parser['hashes']['even in multiline values'])
  line #1
  line #2
  line #3
  ```
- *strict*, значение по умолчанию: `True`

  Если установлено `True`, парсер не допускает дублирования разделов или параметров при чтении из одного источника (с помощью `read_file()`, `read_string()` или `read_dict()`). В новых приложениях рекомендуется использовать строгие парсеры.

  Изменено в версии 3.2: В предыдущих версиях [`configparser`](https://python-all.ru/3.5/library/configparser.html#module-configparser) поведение соответствовало `strict=False`.
- *empty\_lines\_in\_values*, значение по умолчанию: `True`

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

  ```ini
  [Section]
  key = multiline
    value with a gotcha

   this = is still a part of the multiline value of 'key'
  ```

  Это может быть особенно проблематично для пользователя, если он использует пропорциональный шрифт для редактирования файла. Вот почему, если вашему приложению не нужны значения с пустыми строками, стоит рассмотреть возможность их запрета. Это приведёт к тому, что пустые строки будут каждый раз разделять ключи. В приведённом выше примере получилось бы два ключа: `key` и `this`.
- *default\_section*, значение по умолчанию: `configparser.DEFAULTSECT` (то есть `"DEFAULT"`)

  Возможность выделить специальный раздел со значениями по умолчанию для других разделов или для интерполяции – это мощная концепция данной библиотеки, позволяющая пользователям создавать сложные декларативные конфигурации. Этот раздел обычно называется `"DEFAULT"`, однако его можно настроить на любое другое допустимое имя раздела. Некоторые типичные значения: `"general"` или `"common"`. Указанное имя используется для распознавания разделов по умолчанию при чтении из любого источника, а также при записи конфигурации обратно в файл. Текущее значение можно получить через атрибут `parser_instance.default_section` и изменить во время выполнения (например, для преобразования файлов из одного формата в другой).
- *interpolation*, значение по умолчанию: `configparser.BasicInterpolation`

  Поведение интерполяции можно настроить, передав собственный обработчик через аргумент *interpolation*. `None` позволяет полностью отключить интерполяцию, `ExtendedInterpolation()` предоставляет более продвинутый вариант, вдохновлённый `zc.buildout`. Подробнее об этом в [соответствующем разделе документации](https://python-all.ru/3.5/library/configparser.html#interpolation-of-values). [`RawConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.RawConfigParser) имеет значение по умолчанию `None`.
- *converters*, значение по умолчанию: не задано

  Парсеры конфигурации предоставляют геттеры значений параметров, выполняющие преобразование типов. По умолчанию реализованы [`getint()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getint), [`getfloat()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getfloat) и [`getboolean()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getboolean). Если нужны другие геттеры, пользователи могут определить их в подклассе или передать словарь, где каждый ключ – имя преобразователя, а каждое значение – вызываемый объект, реализующий это преобразование. Например, передача `{'decimal': decimal.Decimal}` добавит `getdecimal()` как на объект парсера, так и на все прокси разделов. Другими словами, станет возможным писать как `parser_instance.getdecimal('section', 'key', fallback=0)`, так и `parser_instance['section'].getdecimal('key', 0)`.

  Если преобразователю требуется доступ к состоянию парсера, его можно реализовать как метод подкласса парсера конфигурации. Если имя этого метода начинается с `get`, он будет доступен на всех прокси разделов в dict-совместимой форме (см. пример `getdecimal()` выше).

Более тонкую настройку можно выполнить, переопределив значения по умолчанию этих атрибутов парсера. Значения по умолчанию заданы на уровне классов, поэтому их можно переопределить в подклассах или путём присваивания атрибуту.

#### `configparser.BOOLEAN_STATES`

По умолчанию при использовании [`getboolean()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.getboolean) парсеры конфигурации считают следующие значения `True`: `'1'`, `'yes'`, `'true'`, `'on'`, а следующие значения `False`: `'0'`, `'no'`, `'false'`, `'off'`. Вы можете переопределить это, указав свой словарь строк и соответствующих им логических значений. Например:

```pycon
>>> custom = configparser.ConfigParser()
>>> custom['section1'] = {'funky': 'nope'}
>>> custom['section1'].getboolean('funky')
Traceback (most recent call last):
...
ValueError: Not a boolean: nope
>>> custom.BOOLEAN_STATES = {'sure': True, 'nope': False}
>>> custom['section1'].getboolean('funky')
False
```

Другие типичные логические пары: `accept`/`reject` или `enabled`/`disabled`.

#### `configparser.optionxform(option)`

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

```pycon
>>> config = """
... [Section1]
... Key = Value
...
... [Section2]
... AnotherKey = Value
... """
>>> typical = configparser.ConfigParser()
>>> typical.read_string(config)
>>> list(typical['Section1'].keys())
['key']
>>> list(typical['Section2'].keys())
['anotherkey']
>>> custom = configparser.RawConfigParser()
>>> custom.optionxform = lambda option: option
>>> custom.read_string(config)
>>> list(custom['Section1'].keys())
['Key']
>>> list(custom['Section2'].keys())
['AnotherKey']
```

#### `configparser.SECTCRE`

Скомпилированное регулярное выражение для разбора заголовков разделов. По умолчанию сопоставляет `[section]` с именем `"section"`. Пробельные символы считаются частью имени раздела, поэтому `[ larch ]` будет прочитан как раздел с именем `" larch "`. Переопределите этот атрибут, если это не подходит. Например:

```pycon
>>> config = """
... [Section 1]
... option = value
...
... [  Section 2  ]
... another = val
... """
>>> typical = ConfigParser()
>>> typical.read_string(config)
>>> typical.sections()
['Section 1', '  Section 2  ']
>>> custom = ConfigParser()
>>> custom.SECTCRE = re.compile(r"\[ *(?P<header>[^]]+?) *\]")
>>> custom.read_string(config)
>>> custom.sections()
['Section 1', 'Section 2']
```

> **Примечание**
>
> Хотя объекты ConfigParser также используют атрибут `OPTCRE` для распознавания строк с опциями, переопределять его не рекомендуется, так как это помешает работе параметров конструктора *allow\_no\_value* и *delimiters*.

## 14.2.8. Примеры устаревшего API

В основном из соображений обратной совместимости [`configparser`](https://python-all.ru/3.5/library/configparser.html#module-configparser) также предоставляет устаревший API с явными методами `get`/`set`. Хотя у методов, перечисленных ниже, есть свои обоснованные сценарии использования, для новых проектов предпочтительнее доступ через протокол отображения. Устаревший API иногда более продвинутый, низкоуровневый и откровенно неинтуитивный.

Пример записи в файл конфигурации:

```python
import configparser

config = configparser.RawConfigParser()

# Обратите внимание: используя функции set класса RawConfigParser, можно присваивать
# ключам внутренние значения, не являющиеся строками, но при попытке
# записи в файл или при получении значения в не-сыром режиме возникнет ошибка. Присваивание
# значений через протокол отображения или ConfigParser.set() не допускает
# выполнения таких присваиваний.
config.add_section('Section1')
config.set('Section1', 'an_int', '15')
config.set('Section1', 'a_bool', 'true')
config.set('Section1', 'a_float', '3.1415')
config.set('Section1', 'baz', 'fun')
config.set('Section1', 'bar', 'Python')
config.set('Section1', 'foo', '%(bar)s is %(baz)s!')

# Записываем наш конфигурационный файл в 'example.cfg'
with open('example.cfg', 'w') as configfile:
    config.write(configfile)
```

Пример повторного чтения файла конфигурации:

```python
import configparser

config = configparser.RawConfigParser()
config.read('example.cfg')

# getfloat() вызывает исключение, если значение не является float.
# getint() и getboolean() делают то же самое для своих типов.
a_float = config.getfloat('Section1', 'a_float')
an_int = config.getint('Section1', 'an_int')
print(a_float + an_int)

# Обратите внимание, что следующий вывод не интерполирует '%(bar)s' или '%(baz)s'.
# Это потому, что мы используем RawConfigParser().
if config.getboolean('Section1', 'a_bool'):
    print(config.get('Section1', 'foo'))
```

Чтобы получить интерполяцию, используйте [`ConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser):

```python
import configparser

cfg = configparser.ConfigParser()
cfg.read('example.cfg')

# Установите необязательный аргумент *raw* метода get() в True, если требуется отключить
# интерполяцию в одной операции get.
print(cfg.get('Section1', 'foo', raw=False))  # -> "Python – это весело!"
print(cfg.get('Section1', 'foo', raw=True))   # -> "%(bar)s – это %(baz)s!"

# Необязательный аргумент *vars* – это словарь с элементами, которые будут иметь
# приоритет при интерполяции.
print(cfg.get('Section1', 'foo', vars={'bar': 'Documentation',
                                       'baz': 'evil'}))

# Необязательный аргумент *fallback* можно использовать для предоставления запасного значения
print(cfg.get('Section1', 'foo'))
      # -> "Python – это весело!"

print(cfg.get('Section1', 'foo', fallback='Monty is not.'))
      # -> "Python – это весело!"

print(cfg.get('Section1', 'monster', fallback='No such things as monsters.'))
      # -> "Монстров не существует."

# Голый вызов print(cfg.get('Section1', 'monster')) вызовет NoOptionError, но мы также можем использовать:
# но мы также можем использовать:

print(cfg.get('Section1', 'monster', fallback=None))
      # -> None
```

Значения по умолчанию доступны в обоих типах ConfigParsers. Они используются при интерполяции, если используемая опция не определена в другом месте.

```python
import configparser

# Новый экземпляр с 'bar' и 'baz', по умолчанию равными 'Life' и 'hard' соответственно.
config = configparser.ConfigParser({'bar': 'Life', 'baz': 'hard'})
config.read('example.cfg')

print(config.get('Section1', 'foo'))     # -> "Python – это весело!"
config.remove_option('Section1', 'bar')
config.remove_option('Section1', 'baz')
print(config.get('Section1', 'foo'))     # -> "Жизнь тяжела!"
```

## 14.2.9. Объекты ConfigParser

#### `class configparser.ConfigParser(defaults=None, dict_type=collections.OrderedDict, allow_no_value=False, delimiters=('=', ':'), comment_prefixes=('#', ';'), inline_comment_prefixes=None, strict=True, empty_lines_in_values=True, default_section=configparser.DEFAULTSECT, interpolation=BasicInterpolation(), converters={})`

Основной парсер конфигурации. Когда задан *defaults*, он инициализируется как словарь внутренних значений по умолчанию. Когда задан *dict\_type*, он будет использоваться для создания словарей для списка разделов, опций внутри раздела и значений по умолчанию.

Когда задан *delimiters*, он используется как набор подстрок, которые отделяют ключи от значений. Когда задан *comment\_prefixes*, он будет использоваться как набор подстрок, которые обозначают начало комментария в иначе пустых строках. Комментарии могут быть с отступом. Когда задан *inline\_comment\_prefixes*, он будет использоваться как набор подстрок, которые обозначают начало комментария в непустых строках.

Когда *strict* равен `True` (по умолчанию), парсер не допускает повторяющихся разделов или опций при чтении из одного источника (файла, строки или словаря), вызывая [`DuplicateSectionError`](https://python-all.ru/3.5/library/configparser.html#configparser.DuplicateSectionError) или [`DuplicateOptionError`](https://python-all.ru/3.5/library/configparser.html#configparser.DuplicateOptionError). Когда *empty\_lines\_in\_values* равен `False` (по умолчанию: `True`), каждая пустая строка обозначает конец опции. В противном случае пустые строки внутри многострочной опции сохраняются как часть значения. Когда *allow\_no\_value* равен `True` (по умолчанию: `False`), опции без значений принимаются; значение для них равно `None`, и они сериализуются без завершающего разделителя.

Если задан параметр *default\_section*, он определяет имя специального раздела, содержащего значения по умолчанию для других разделов и целей интерполяции (обычно называемого `"DEFAULT"`). Это значение можно получить и изменить во время выполнения с помощью атрибута экземпляра `default_section`.

Поведение интерполяции можно настроить, передав собственный обработчик через аргумент *interpolation*. `None` можно использовать для полного отключения интерполяции, `ExtendedInterpolation()` предоставляет более продвинутый вариант, вдохновлённый `zc.buildout`. Подробнее об этом в [соответствующем разделе документации](https://python-all.ru/3.5/library/configparser.html#interpolation-of-values).

Все имена опций, используемые в интерполяции, передаются через метод [`optionxform()`](https://python-all.ru/3.5/library/configparser.html#configparser.optionxform), как и любые другие ссылки на имена опций. Например, при использовании реализации по умолчанию [`optionxform()`](https://python-all.ru/3.5/library/configparser.html#configparser.optionxform) (которая преобразует имена опций в нижний регистр) значения `foo %(bar)s` и `foo %(BAR)s` эквивалентны.

Когда задан *converters*, это должен быть словарь, где каждый ключ представляет имя конвертера типов, а каждое значение – вызываемый объект, реализующий преобразование из строки в нужный тип данных. Каждый конвертер получает свой собственный соответствующий метод `get*()` на объекте парсера и прокси-объектах разделов.

Изменено в версии 3.1: Значение по умолчанию *dict\_type* – [`collections.OrderedDict`](https://python-all.ru/3.5/library/collections.html#collections.OrderedDict).

Изменено в версии 3.2: Были добавлены *allow\_no\_value*, *delimiters*, *comment\_prefixes*, *strict*, *empty\_lines\_in\_values*, *default\_section* и *interpolation*.

Изменено в версии 3.5: Был добавлен аргумент *converters*.

#### `defaults()`

Возвращает словарь, содержащий значения по умолчанию для экземпляра.

#### `sections()`

Возвращает список доступных разделов; *раздел по умолчанию* не включён в список.

#### `add_section(section)`

Добавляет раздел с именем *section* в экземпляр. Если раздел с таким именем уже существует, возбуждается [`DuplicateSectionError`](https://python-all.ru/3.5/library/configparser.html#configparser.DuplicateSectionError). Если передано имя *раздела по умолчанию*, возбуждается [`ValueError`](https://python-all.ru/3.5/library/exceptions.html#ValueError). Имя раздела должно быть строкой; в противном случае возбуждается [`TypeError`](https://python-all.ru/3.5/library/exceptions.html#TypeError).

Изменено в версии 3.2: Имена разделов, не являющиеся строками, вызывают [`TypeError`](https://python-all.ru/3.5/library/exceptions.html#TypeError).

#### `has_section(section)`

Указывает, присутствует ли в конфигурации указанный *раздел*. *Раздел по умолчанию* не учитывается.

#### `options(section)`

Возвращает список доступных параметров в указанном *разделе*.

#### `has_option(section, option)`

Если указанный *раздел* существует и содержит указанный *параметр*, вернуть [`True`](https://python-all.ru/3.5/library/constants.html#True); в противном случае вернуть [`False`](https://python-all.ru/3.5/library/constants.html#False). Если указанный *раздел* равен [`None`](https://python-all.ru/3.5/library/constants.html#None) или пустой строке, подразумевается DEFAULT.

#### `read(filenames, encoding=None)`

Пытается прочитать и разобрать список имён файлов, возвращая список имён файлов, которые были успешно разобраны. Если *filenames* является строкой, она обрабатывается как одно имя файла. Если файл, указанный в *filenames*, не может быть открыт, этот файл игнорируется. Это сделано для того, чтобы можно было указать список возможных расположений конфигурационных файлов (например, текущий каталог, домашний каталог пользователя и какой-нибудь общесистемный каталог), и все существующие конфигурационные файлы из списка будут прочитаны. Если ни один из указанных файлов не существует, экземпляр [`ConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser) будет содержать пустой набор данных. Приложение, которому требуется загрузить начальные значения из файла, должно загрузить требуемый файл или файлы с помощью [`read_file()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.read_file) перед вызовом [`read()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.read) для любых необязательных файлов:

```python
import configparser, os

config = configparser.ConfigParser()
config.read_file(open('defaults.cfg'))
config.read(['site.cfg', os.path.expanduser('~/.myapp.cfg')],
            encoding='cp1250')
```

Новое в версии 3.2: Параметр *encoding*. Ранее все файлы читались с использованием кодировки по умолчанию для [`open()`](https://python-all.ru/3.5/library/functions.html#open).

#### `read_file(f, source=None)`

Читает и разбирает данные конфигурации из *f*, который должен быть итерируемым объектом, возвращающим строки Unicode (например, файлы, открытые в текстовом режиме).

Необязательный аргумент *source* задаёт имя читаемого файла. Если он не указан и *f* имеет атрибут `name`, то он используется для *source*; по умолчанию `'<???>'`.

Новое в версии 3.2: Заменяет [`readfp()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.readfp).

#### `read_string(string, source='<string>')`

Разбирает данные конфигурации из строки.

Необязательный аргумент *source* задаёт контекстно-зависимое имя переданной строки. Если не указан, используется `'<string>'`. Обычно это путь файловой системы или URL.

Новое в версии 3.2.

#### `read_dict(dictionary, source='<dict>')`

Загружает конфигурацию из любого объекта, предоставляющего метод `items()`, подобный словарю. Ключи – это имена разделов, значения – словари с ключами и значениями, которые должны присутствовать в разделе. Если используемый тип словаря сохраняет порядок, разделы и их ключи будут добавлены по порядку. Значения автоматически преобразуются в строки.

Необязательный аргумент *source* задаёт контекстно-зависимое имя переданного словаря. Если не указан, используется `<dict>`.

Этот метод можно использовать для копирования состояния между парсерами.

Новое в версии 3.2.

#### `get(section, option, *, raw=False, vars=None[, fallback])`

Получает значение *параметра* для указанного *раздела*. Если указан *vars*, он должен быть словарём. *Параметр* ищется в *vars* (если указан), *разделе* и в *DEFAULTSECT* в указанном порядке. Если ключ не найден и указан *fallback*, он используется как запасное значение. `None` может быть указан в качестве *запасного значения*.

Все операции `'%'` интерполяции раскрываются в возвращаемых значениях, если только аргумент *raw* не равен true. Значения для ключей интерполяции ищутся так же, как и параметр.

Изменено в версии 3.2: Аргументы *raw*, *vars* и *fallback* стали только ключевыми, чтобы защитить пользователей от попытки использовать третий аргумент в качестве запасного значения *fallback* (особенно при использовании протокола отображения).

#### `getint(section, option, *, raw=False, vars=None[, fallback])`

Удобный метод, который преобразует *параметр* в указанном *разделе* в целое число. См. [`get()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.get) для объяснения *raw*, *vars* и *fallback*.

#### `getfloat(section, option, *, raw=False, vars=None[, fallback])`

Удобный метод, который приводит *option* в указанном разделе *section* к числу с плавающей запятой. См. [`get()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.get) для пояснения параметров *raw*, *vars* и *fallback*.

#### `getboolean(section, option, *, raw=False, vars=None[, fallback])`

Удобный метод, который приводит *option* в указанном *section* к логическому значению. Обратите внимание, что допустимыми значениями для параметра являются `'1'`, `'yes'`, `'true'` и `'on'`, при которых этот метод возвращает `True`, а `'0'`, `'no'`, `'false'` и `'off'` – `False`. Строковые значения проверяются без учёта регистра. Любое другое значение приведёт к возбуждению исключения [`ValueError`](https://python-all.ru/3.5/library/exceptions.html#ValueError). См. [`get()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.get) для пояснения *raw*, *vars* и *fallback*.

#### `items(raw=False, vars=None)`

#### `items(section, raw=False, vars=None)`

Если *section* не указан, возвращает список пар *section\_name*, *section\_proxy*, включая DEFAULTSECT.

В противном случае возвращает список пар *name*, *value* для параметров в указанном *section*. Необязательные аргументы имеют тот же смысл, что и для метода [`get()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.get).

Изменено в версии 3.2: Элементы, присутствующие в *vars*, больше не отображаются в результате. Предыдущее поведение смешивало реальные опции парсера с переменными, предоставленными для интерполяции.

#### `set(section, option, value)`

Если указанный раздел существует, устанавливает заданный параметр в указанное значение; в противном случае возбуждает исключение [`NoSectionError`](https://python-all.ru/3.5/library/configparser.html#configparser.NoSectionError). *option* и *value* должны быть строками; в противном случае возбуждается исключение [`TypeError`](https://python-all.ru/3.5/library/exceptions.html#TypeError).

#### `write(fileobject, space_around_delimiters=True)`

Записывает представление конфигурации в указанный [файловый объект](https://python-all.ru/3.5/glossary.html#term-file-object), который должен быть открыт в текстовом режиме (принимает строки). Это представление может быть разобрано будущим вызовом [`read()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.read). Если *space\_around\_delimiters* равно true, разделители между ключами и значениями окружаются пробелами.

#### `remove_option(section, option)`

Удаляет указанный *option* из указанного *section*. Если раздел не существует, возбуждает исключение [`NoSectionError`](https://python-all.ru/3.5/library/configparser.html#configparser.NoSectionError). Если параметр существовал и был удалён, возвращает [`True`](https://python-all.ru/3.5/library/constants.html#True); в противном случае возвращает [`False`](https://python-all.ru/3.5/library/constants.html#False).

#### `remove_section(section)`

Удаляет указанный *section* из конфигурации. Если раздел действительно существовал, возвращает `True`. В противном случае возвращает `False`.

#### `optionxform(option)`

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

Для использования этого метода не нужно создавать подкласс анализатора; можно также установить его на экземпляре, присвоив функцию, которая принимает строковый аргумент и возвращает строку. Установка его в `str`, например, сделает имена параметров чувствительными к регистру:

```python
cfgparser = ConfigParser()
cfgparser.optionxform = str
```

Обратите внимание, что при чтении файлов конфигурации пробельные символы вокруг имён параметров удаляются перед вызовом [`optionxform()`](https://python-all.ru/3.5/library/configparser.html#configparser.optionxform).

#### `readfp(fp, filename=None)`

Устарело с версии 3.2: Используйте [`read_file()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.read_file) вместо.

Изменено в версии 3.2: [`readfp()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.readfp) теперь выполняет итерацию по *fp* вместо вызова `fp.readline()`.

Для существующего кода, вызывающего [`readfp()`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser.readfp) с аргументами, которые не поддерживают итерацию, следующий генератор можно использовать как обёртку вокруг файлоподобного объекта:

```python
def readline_generator(fp):
    line = fp.readline()
    while line:
        yield line
        line = fp.readline()
```

Вместо `parser.readfp(fp)` используйте `parser.read_file(readline_generator(fp))`.

#### `configparser.MAX_INTERPOLATION_DEPTH`

Максимальная глубина рекурсивной интерполяции для `get()`, когда параметр *raw* равен false. Это актуально только при использовании *интерполяция* по умолчанию.

## 14.2.10. Объекты RawConfigParser

#### `class configparser.RawConfigParser(defaults=None, dict_type=collections.OrderedDict, allow_no_value=False, *, delimiters=('=', ':'), comment_prefixes=('#', ';'), inline_comment_prefixes=None, strict=True, empty_lines_in_values=True, default_section=configparser.DEFAULTSECT[, interpolation])`

Устаревший вариант [`ConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser) с отключенной по умолчанию интерполяцией и небезопасными методами `add_section` и `set`.

> **Примечание**
>
> Рассмотрите возможность использования [`ConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser) – он проверяет типы сохраняемых внутри значений. Если интерполяция не нужна, можно использовать `ConfigParser(interpolation=None)`.

#### `add_section(section)`

Добавляет раздел с именем *section* в экземпляр. Если раздел с указанным именем уже существует, возникает [`DuplicateSectionError`](https://python-all.ru/3.5/library/configparser.html#configparser.DuplicateSectionError). Если передано имя *раздела по умолчанию*, возникает [`ValueError`](https://python-all.ru/3.5/library/exceptions.html#ValueError).

Тип *section* не проверяется, что позволяет создавать разделы с нестроковыми именами. Это поведение не поддерживается и может вызывать внутренние ошибки.

#### `set(section, option, value)`

Если указанный раздел существует, устанавливает указанный параметр в заданное значение; иначе возбуждает [`NoSectionError`](https://python-all.ru/3.5/library/configparser.html#configparser.NoSectionError). Хотя для *внутреннего* хранения нестроковых значений можно использовать [`RawConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.RawConfigParser) (или [`ConfigParser`](https://python-all.ru/3.5/library/configparser.html#configparser.ConfigParser) с параметром *raw*, установленным в true), полная функциональность (включая интерполяцию и вывод в файлы) достигается только при использовании строковых значений.

Этот метод позволяет пользователям присваивать нестроковые значения ключам внутри. Такое поведение не поддерживается и приведет к ошибкам при попытке записи в файл или получении значения в несыром режиме. **Используйте API протокола отображения**, который не допускает таких присваиваний.

## 14.2.11. Исключения

#### `exception configparser.Error`

Базовый класс для всех прочих исключений [`configparser`](https://python-all.ru/3.5/library/configparser.html#module-configparser).

#### `exception configparser.NoSectionError`

Исключение, возбуждаемое, когда указанный раздел не найден.

#### `exception configparser.DuplicateSectionError`

Исключение, возбуждаемое, если `add_section()` вызывается с именем уже существующего раздела, или в строгих парсерах, когда раздел встречается более одного раза в одном входном файле, строке или словаре.

Новое в версии 3.2: Добавлены необязательные атрибуты и аргументы `source` и `lineno` для [`__init__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__init__).

#### `exception configparser.DuplicateOptionError`

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

#### `exception configparser.NoOptionError`

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

#### `exception configparser.InterpolationError`

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

#### `exception configparser.InterpolationDepthError`

Исключение, возбуждаемое, когда строковая интерполяция не может быть завершена, поскольку количество итераций превышает [`MAX_INTERPOLATION_DEPTH`](https://python-all.ru/3.5/library/configparser.html#configparser.MAX_INTERPOLATION_DEPTH). Подкласс [`InterpolationError`](https://python-all.ru/3.5/library/configparser.html#configparser.InterpolationError).

#### `exception configparser.InterpolationMissingOptionError`

Исключение, возбуждаемое, когда параметр, на который есть ссылка из значения, не существует. Подкласс [`InterpolationError`](https://python-all.ru/3.5/library/configparser.html#configparser.InterpolationError).

#### `exception configparser.InterpolationSyntaxError`

Исключение, возбуждаемое, когда исходный текст, в который вносятся подстановки, не соответствует требуемому синтаксису. Подкласс [`InterpolationError`](https://python-all.ru/3.5/library/configparser.html#configparser.InterpolationError).

#### `exception configparser.MissingSectionHeaderError`

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

#### `exception configparser.ParsingError`

Исключение, возникающее при ошибках во время разбора файла.

Изменено в версии 3.2: Атрибут `filename` и аргумент [`__init__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__init__) были переименованы в `source` для согласованности.

Сноски

| \[1\] | *([1](https://python-all.ru/3.5/library/configparser.html#id1), [2](https://python-all.ru/3.5/library/configparser.html#id2), [3](https://python-all.ru/3.5/library/configparser.html#id3), [4](https://python-all.ru/3.5/library/configparser.html#id4), [5](https://python-all.ru/3.5/library/configparser.html#id5), [6](https://python-all.ru/3.5/library/configparser.html#id6), [7](https://python-all.ru/3.5/library/configparser.html#id7), [8](https://python-all.ru/3.5/library/configparser.html#id8), [9](https://python-all.ru/3.5/library/configparser.html#id9), [10](https://python-all.ru/3.5/library/configparser.html#id10))* Парсеры конфигурационных файлов допускают широкую настройку. Если вам интересно изменить поведение, описанное в сноске, обратитесь к разделу [Настройка поведения парсера](https://python-all.ru/3.5/library/configparser.html#customizing-parser-behaviour). |
| --- | --- |