configparser — Configuration file parser

Código-fonte: Lib/configparser.py

Este módulo fornece a classe ConfigParser que implementa uma linguagem de configuração básica que fornece uma estrutura semelhante à encontrada nos arquivos INI do Microsoft Windows. Você pode usar isso para escrever programas Python que podem ser facilmente personalizados pelos usuários finais.

Nota

Esta biblioteca não interpreta ou escreve os prefixos de tipo de valor usados ​​na versão estendida do Registro do Windows da sintaxe INI.

Ver também

Módulo tomllib

TOML é um formato bem especificado para arquivos de configuração de aplicações. Ele foi projetado especificamente para ser uma versão melhorada do INI.

Módulo shlex

Suporte para criação de minilinguagens semelhantes a shell Unix que também podem ser usadas para arquivos de configuração de aplicações.

Módulo json

O módulo json implementa um subconjunto de sintaxe JavaScript que às vezes é usado para configuração, mas não suporta comentários.

Início rápido

Vamos pegar um arquivo de configuração bem básico parecido com este:

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

[forge.example]
User = hg

[topsecret.server.example]
Port = 50022
ForwardX11 = no

A estrutura dos arquivos INI é descrita na seção seguinte. Essencialmente, o arquivo consiste em seções, cada uma contendo chaves com valores. As classes configparser podem ler e escrever tais arquivos. Vamos começar criando o arquivo de configuração acima programaticamente.

>>> import configparser
>>> config = configparser.ConfigParser()
>>> config['DEFAULT'] = {'ServerAliveInterval': '45',
...                      'Compression': 'yes',
...                      'CompressionLevel': '9'}
>>> config['forge.example'] = {}
>>> config['forge.example']['User'] = 'hg'
>>> config['topsecret.server.example'] = {}
>>> topsecret = config['topsecret.server.example']
>>> topsecret['Port'] = '50022'     # mutates the parser
>>> topsecret['ForwardX11'] = 'no'  # same here
>>> config['DEFAULT']['ForwardX11'] = 'yes'
>>> with open('example.ini', 'w') as configfile:
...   config.write(configfile)
...

Como você pode ver, podemos tratar um analisador sintático de configuração como um dicionário. Existem diferenças, descritas posteriormente, mas o comportamento é muito próximo do que você esperaria de um dicionário.

Agora que criamos e salvamos um arquivo de configuração, vamos lê-lo e explorar os dados que ele contém.

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

Como podemos ver acima, a API é bastante simples. A única mágica envolve a seção DEFAULT que fornece valores padrão para todas as outras seções [1]. Observe também que as chaves nas seções não diferenciam maiúsculas de minúsculas e são armazenadas em letras minúsculas [1].

It is possible to read several configurations into a single ConfigParser, where the most recently added configuration has the highest priority. Any conflicting keys are taken from the more recent configuration while the previously existing keys are retained.

>>> another_config = configparser.ConfigParser()
>>> another_config.read('example.ini')
['example.ini']
>>> another_config['topsecret.server.example']['Port']
'50022'
>>> another_config.read_string("[topsecret.server.example]\nPort=48484")
>>> another_config['topsecret.server.example']['Port']
'48484'
>>> another_config.read_dict({"topsecret.server.example": {"Port": 21212}})
>>> another_config['topsecret.server.example']['Port']
'21212'
>>> another_config['topsecret.server.example']['ForwardX11']
'no'

Este comportamento é equivalente a uma chamada ConfigParser.read() com vários arquivos passados ​​para o parâmetro filenames.

Tipos de dados suportados

Os analisadores sintáticos de configuração não adivinham os tipos de dados dos valores nos arquivos de configuração, sempre os armazenando internamente como strings. Isso significa que se você precisar de outros tipos de dados, deverá converter por conta própria:

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

Como essa tarefa é tão comum, os analisadores sintáticos de configuração fornecem uma variedade de métodos getter úteis para manipular com números inteiros, pontos flutuantes e booleanos. O último é o mais interessante porque simplesmente passar o valor para bool() não adiantaria nada já que bool('False') ainda é True. É por isso que os analisadores sintáticos de configuração também fornecem getboolean(). Este método não diferencia maiúsculas de minúsculas e reconhece valores booleanos de 'yes'/'no', 'on'/'off', 'true' /'false' e '1'/'0' [1]. Por exemplo:

>>> topsecret.getboolean('ForwardX11')
False
>>> config['forge.example'].getboolean('ForwardX11')
True
>>> config.getboolean('forge.example', 'Compression')
True

Além de getboolean(), os analisadores sintáticos de configuração também fornecem métodos getint() e getfloat() equivalentes. Você pode registrar seus próprios conversores e personalizar os fornecidos. [1]

Valores reservas

Assim como acontece com um dicionário, você pode usar o método get() de uma seção para fornecer valores reservas (fallback):

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

Observe que os valores padrão têm precedência sobre os valores substitutos. Por exemplo, em nosso exemplo a chave 'CompressionLevel' foi especificada apenas na seção 'DEFAULT'. Se tentarmos obtê-lo na seção 'topsecret.server.example', sempre obteremos o padrão, mesmo se especificarmos um substituto:

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

Mais uma coisa a ter em conta é que o método get() no nível do analisador fornece uma interface personalizada e mais complexa, mantida para compatibilidade com versões anteriores. Ao usar este método, um valor substituto pode ser fornecido através do argumento somente-nomeado fallback:

>>> config.get('forge.example', 'monster',
...            fallback='No such things as monsters')
'No such things as monsters'

O mesmo argumento fallback pode ser usado com os métodos getint(), getfloat() e getboolean(), por exemplo:

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

Estrutura dos arquivos INI

Um arquivo de configuração consiste em seções, cada uma liderada por um cabeçalho [section], seguido por entradas de chave/valor separadas por uma string específica (= ou : por padrão [1]) . Por padrão, os nomes das seções diferenciam maiúsculas de minúsculas, mas as chaves não [1]. Os espaços em branco à esquerda e à direita são removidos das chaves e dos valores. Os valores podem ser omitidos se o analisador sintático estiver configurado para permitir [1], caso em que o delimitador chave/valor também pode ser omitido. Os valores também podem abranger várias linhas, desde que sejam indentados de forma mais profunda que a primeira linha do valor. Dependendo do modo do analisador sintático, as linhas em branco podem ser tratadas como partes de valores multilinhas ou ignoradas.

Por padrão, um nome de seção válido pode ser qualquer string que não contenha ‘\n’. Para alterar isso, consulte ConfigParser.SECTCRE.

Os arquivos de configuração podem incluir comentários, prefixados por caracteres específicos (# e ; por padrão [1]). Os comentários podem aparecer sozinhos em uma linha vazia, possivelmente identados. [1]

Por exemplo:

[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]
# like this
; or this

# By default only in an empty line.
# Inline comments can be harmful because they prevent users
# from using the delimiting characters as parts of values.
# That being said, this can be customized.

    [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
        # Did I mention we can indent comments, too?

Interpolação de valores

Além da funcionalidade principal, ConfigParser oferece suporte a interpolação. Isso significa que os valores podem ser pré-processados ​​antes de retorná-los das chamadas get().

class configparser.BasicInterpolation

A implementação padrão usada por ConfigParser. Ele permite que os valores contenham strings de formato que se referem a outros valores na mesma seção ou valores na seção padrão especial [1]. Valores padrão adicionais podem ser fornecidos na inicialização.

Por exemplo:

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

[Escape]
# use a %% to escape the % sign (% is the only character that needs to be escaped):
gain: 80%%

No exemplo acima, ConfigParser com interpolation definido como BasicInterpolation() resolveria %(home_dir)s para o valor de home_dir (/Users neste caso). %(my_dir)s na verdade resolveria para /Users/lumberjack. Todas as interpolações são feitas sob demanda, portanto as chaves usadas na cadeia de referências não precisam ser especificadas em nenhuma ordem específica no arquivo de configuração.

Com interpolation definido como None, o analisador sintático simplesmente retornaria %(my_dir)s/Pictures como o valor de my_pictures e %(home_dir)s/lumberjack como o valor de my_dir.

class configparser.ExtendedInterpolation

Um manipulador alternativo para interpolação que implementa uma sintaxe mais avançada, usada, por exemplo, em zc.buildout. A interpolação estendida usa ${section:option} para denotar um valor de uma seção estrangeira. A interpolação pode abranger vários níveis. Por conveniência, se a parte section: for omitida, a interpolação será padronizada para a seção atual (e possivelmente para os valores padrão da seção especial).

Por exemplo, a configuração especificada acima com interpolação básica ficaria assim com interpolação estendida:

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

[Escape]
# use a $$ to escape the $ sign ($ is the only character that needs to be escaped):
cost: $$80

Valores de outras seções também podem ser obtidos:

[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}

Acesso através do protocolo de mapeamento

Novo na versão 3.2.

Acesso através do protocolo de mapeamento é um nome genérico para funcionalidade que permite usar objetos personalizados como se fossem dicionários. No caso de configparser, a implementação da interface de mapeamento está usando a notação parser['section']['option'].

parser['section'] em particular retorna um intermediário para os dados da seção no analisador sintático. Isso significa que os valores não são copiados, mas obtidos do analisador sintático original sob demanda. O que é ainda mais importante é que quando os valores são alterados em um intermediário de seção, eles são, na verdade, modificados no analisador sintático original.

Os objetos configparser se comportam o mais próximo possível dos dicionários reais. A interface de mapeamento é completa e segue a ABC MutableMapping. No entanto, existem algumas diferenças que devem ser levadas em consideração:

  • Por padrão, todas as chaves nas seções são acessíveis sem distinção entre maiúsculas e minúsculas [1]. Por exemplo. for option in parser["section"] produz apenas nomes de chaves de opção optionxformada. Isso significa chaves em letras minúsculas por padrão. Ao mesmo tempo, para uma seção que contém a chave 'a', ambas as expressões retornam True:

    "a" in parser["section"]
"A" in parser["section"]

  • Todas as seções também incluem valores DEFAULTSECT, o que significa que .clear() em uma seção não pode deixá-la visivelmente vazia. Isso ocorre porque os valores padrão não podem ser excluídos da seção (porque tecnicamente eles não estão lá). Se eles forem substituídos na seção, a exclusão fará com que o valor padrão fique visível novamente. Tentar excluir um valor padrão causa um KeyError.

  • DEFAULTSECT não pode ser removido do analisador sintático:

    • tentar excluí-lo levanta ValueError,

    • parser.clear() deixa-o intacto,

    • parser.popitem() nunca o retorna.

  • parser.get(section, option, **kwargs) - o segundo argumento não é um valor substituto. Observe, entretanto, que os métodos get() em nível de seção são compatíveis tanto com o protocolo de mapeamento quanto com a API clássica do configparser.

  • parser.items() é compatível com o protocolo de mapeamento (retorna uma lista de pares section_name, section_proxy incluindo o DEFAULTSECT). Entretanto, este método também pode ser invocado com argumentos: parser.items(section, raw, vars). A última chamada retorna uma lista de pares option, value para uma section especificada, com todas as interpolações expandidas (a menos que raw=True seja fornecido).

O protocolo de mapeamento é implementado sobre a API legada existente para que as subclasses que substituem a interface original ainda tenham mapeamentos funcionando conforme o esperado.

Personalizando o comportamento do analisador sintático

Existem quase tantas variantes de formato INI quanto aplicações que o utilizam. configparser percorre um longo caminho para fornecer suporte para o maior conjunto sensato de estilos INI disponíveis. A funcionalidade padrão é determinada principalmente pelo histórico e é muito provável que você queira personalizar alguns dos recursos.

A maneira mais comum de alterar a forma como um analisador sintático de configuração específico funciona é usar as opções __init__():

  • defaults, valor padrão: None

    Esta opção aceita um dicionário de pares chave-valor que será inicialmente colocado na seção DEFAULT. Isso é uma maneira elegante de oferecer suporte a arquivos de configuração concisos que não especificam valores iguais ao padrão documentado.

    Dica: se você deseja especificar valores padrão para uma seção específica, use read_dict() antes de ler o arquivo real.

  • dict_type, valor padrão: dict

    Esta opção tem um grande impacto no comportamento do protocolo de mapeamento e na aparência dos arquivos de configuração gravados. Com o dicionário padrão, cada seção é armazenada na ordem em que foram adicionadas ao analisador sintático. O mesmo vale para opções dentro das seções.

    Um tipo de dicionário alternativo pode ser usado, por exemplo, para ordenar as seções e opções ao fazer write-back.

    Observação: existem maneiras de adicionar um conjunto de pares de valores-chave em uma única operação. Quando você usa um dicionário regular nessas operações, a classificação das chaves será ordenada. Por exemplo:

    >>> 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()
['section1', 'section2', 'section3']
>>> [option for option in parser['section3']]
['foo', 'bar', 'baz']

  • allow_no_value, valor padrão: False

    Alguns arquivos de configuração são conhecidos por incluir configurações sem valores, mas que de outra forma estão em conformidade com a sintaxe suportada por configparser. O parâmetro allow_no_value para o construtor pode ser usado para indicar que tais valores devem ser aceitos:

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

>>> # Settings with values are treated as before:
>>> config["mysqld"]["user"]
'mysql'

>>> # Settings without values provide None:
>>> config["mysqld"]["skip-bdb"]

>>> # Settings which aren't specified still raise an error:
>>> config["mysqld"]["does-not-exist"]
Traceback (most recent call last):
  ...
KeyError: 'does-not-exist'

  • delimiters, valor padrão: ('=', ':')

    Delimitadores são substrings que delimitam chaves de valores dentro de uma seção. A primeira ocorrência de uma substring delimitadora em uma linha é considerada um delimitador. Isso significa que os valores (mas não as chaves) podem conter os delimitadores.

    Veja também o argumento space_around_delimiters para ConfigParser.write().

  • comment_prefixes, valor padrão: ('#', ';')

  • inline_comment_prefixes, valor padrão: None

    Prefixos de comentários são strings que indicam o início de um comentário válido em um arquivo de configuração. comment_prefixes são usados ​​apenas em linhas vazias (opcionalmente indentadas), enquanto inline_comment_prefixes pode ser usado após cada valor válido (por exemplo, nomes de seções, opções e linhas vazias também). Por padrão, os comentários embutidos estão desabilitados e '#' e ';' são usados ​​como prefixos para comentários de linha inteira.

    Alterado na versão 3.2: Nas versões anteriores do configparser, o comportamento correspondia a comment_prefixes=('#',';') e inline_comment_prefixes=(';',).

    Observe que os analisadores sintáticos de configuração não oferecem suporte a escape de prefixos de comentários, portanto, usar inline_comment_prefixes pode impedir que os usuários especifiquem valores de opção com caracteres usados ​​como prefixos de comentários. Em caso de dúvida, evite definir inline_comment_prefixes. Em qualquer circunstância, a única maneira de armazenar caracteres de prefixo de comentário no início de uma linha em valores multilinha é interpolar o prefixo, por exemplo:

    >>> from configparser import ConfigParser, ExtendedInterpolation
>>> parser = ConfigParser(interpolation=ExtendedInterpolation())
>>> # the default BasicInterpolation could be used as well
>>> 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, valor padrão: True

    Ao definir como True, o analisador sintático não permitirá nenhuma seção ou opção duplicada durante a leitura de uma única fonte (usando read_file(), read_string() ou read_dict()). Recomenda-se usar analisadores sintáticos estritos em novas aplicações.

    Alterado na versão 3.2: Nas versões anteriores do configparser, o comportamento correspondia a strict=False.

  • empty_lines_in_values, valor padrão: True

    Em analisadores sintáticos de configuração, os valores podem abranger várias linhas, desde que sejam mais indentados do que a chave que os contém. Por padrão, os analisadores sintáticos também permitem que linhas vazias façam parte de valores. Ao mesmo tempo, as chaves podem ser indentados arbitrariamente para melhorar a legibilidade. Consequentemente, quando os arquivos de configuração ficam grandes e complexos, é fácil para o usuário perder o controle da estrutura do arquivo. Tomemos por exemplo:

    [Section]
key = multiline
  value with a gotcha

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

    Isso pode ser especialmente problemático para o usuário ver se está usando uma fonte proporcional para editar o arquivo. É por isso que quando sua aplicação não precisa de valores com linhas vazias, você deve considerar proibi-los. Isso fará com que as linhas vazias dividam as chaves sempre. No exemplo acima, seriam produzidas duas chaves, key e this.

  • default_section, valor padrão: configparser.DEFAULTSECT (isto é: "DEFAULT")

    A convenção de permitir uma seção especial de valores padrão para outras seções ou fins de interpolação é um conceito poderoso desta biblioteca, permitindo aos usuários criar configurações declarativas complexas. Esta seção normalmente é chamada de "DEFAULT", mas pode ser personalizada para apontar para qualquer outro nome de seção válido. Alguns valores típicos incluem: "general" ou "common". O nome fornecido é usado para reconhecer seções padrão ao ler de qualquer fonte e é usado ao gravar a configuração em um arquivo. Seu valor atual pode ser recuperado usando o atributo parser_instance.default_section e pode ser modificado em tempo de execução (ou seja, para converter arquivos de um formato para outro).

  • interpolation, valor padrão: configparser.BasicInterpolation

    O comportamento de interpolação pode ser personalizado fornecendo um manipulador personalizado por meio do argumento interpolation. None pode ser usado para desligar completamente a interpolação, ExtendedInterpolation() fornece uma variante mais avançada inspirada em zc.buildout. Mais sobre o assunto na seção de documentação dedicada. RawConfigParser tem um valor padrão de None.

  • converters, valor padrão: não definido

    Os analisadores sintáticos de configuração fornecem getters de valor de opção que realizam conversão de tipo. Por padrão, getint(), getfloat() e getboolean() são implementados. Caso outros getters sejam desejáveis, os usuários podem defini-los em uma subclasse ou passar um dicionário onde cada chave é um nome do conversor e cada valor é um chamável que implementa a referida conversão. Por exemplo, passar {'decimal': decimal.Decimal} adicionaria getdecimal() no objeto analisador sintático e em todos os proxies de seção. Em outras palavras, será possível escrever parser_instance.getdecimal('section', 'key', fallback=0) e parser_instance['section'].getdecimal('key', 0).

    Se o conversor precisar acessar o estado do analisador sintático, ele poderá ser implementado como um método em uma subclasse do analisador sintático de configuração. Se o nome deste método começar com get, ele estará disponível em todos os intermediários de seção, na forma compatível com dict (veja o exemplo getdecimal() acima).

Uma personalização mais avançada pode ser obtida substituindo os valores padrão desses atributos do analisador sintático. Os padrões são definidos nas classes, portanto podem ser substituídos por subclasses ou por atribuição de atributos.

ConfigParser.BOOLEAN_STATES

Por padrão, ao usar getboolean(), os analisadores sintáticos de configuração consideram os seguintes valores True: '1', 'yes', 'true', 'on' e os seguintes valores False: '0', 'no', 'false', 'off'. Você pode substituir isso especificando um dicionário personalizado de strings e seus resultados booleanos. Por exemplo:

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

Outros pares booleanos típicos incluem accept/reject ou enabled/disabled.

ConfigParser.optionxform(option)

Este método transforma nomes de opções em cada operação de leitura, obtenção ou definição. O padrão converte o nome em letras minúsculas. Isso também significa que quando um arquivo de configuração for gravado, todas as chaves estarão em letras minúsculas. Substitua esse método se for inadequado. Por exemplo:

>>> 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']

Nota

A função optionxform transforma nomes de opções em um formato canônico. Esta deve ser uma função idempotente: se o nome já estiver na forma canônica, deverá ser retornado inalterado.

ConfigParser.SECTCRE

Uma expressão regular compilada usada para analisar cabeçalhos de seção. O padrão corresponde a [section] para o nome "section". O espaço em branco é considerado parte do nome da seção, portanto [  larch  ] será lido como uma seção de nome "  larch  ". Substitua esse atributo se for inadequado. Por exemplo:

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

Nota

Embora os objetos ConfigParser também usem um atributo OPTCRE para reconhecer linhas de opção, não é recomendado substituí-lo porque isso interferiria nas opções do construtor allow_no_value e delimiters.

Exemplos de APIs legadas

Principalmente por questões de compatibilidade com versões anteriores, configparser fornece também uma API legada com métodos get/set explícitos. Embora existam casos de uso válidos para os métodos descritos abaixo, o acesso ao protocolo de mapeamento é preferido para novos projetos. A API legada é às vezes mais avançada, de baixo nível e totalmente contraintuitiva.

Um exemplo de escrita em um arquivo de configuração:

import configparser

config = configparser.RawConfigParser()

# Please note that using RawConfigParser's set functions, you can assign
# non-string values to keys internally, but will receive an error when
# attempting to write to a file or when you get it in non-raw mode. Setting
# values using the mapping protocol or ConfigParser's set() does not allow
# such assignments to take place.
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!')

# Writing our configuration file to 'example.cfg'
with open('example.cfg', 'w') as configfile:
    config.write(configfile)

Um exemplo de leitura do arquivo de configuração novamente:

import configparser

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

# getfloat() raises an exception if the value is not a float
# getint() and getboolean() also do this for their respective types
a_float = config.getfloat('Section1', 'a_float')
an_int = config.getint('Section1', 'an_int')
print(a_float + an_int)

# Notice that the next output does not interpolate '%(bar)s' or '%(baz)s'.
# This is because we are using a RawConfigParser().
if config.getboolean('Section1', 'a_bool'):
    print(config.get('Section1', 'foo'))

Para obter interpolação, use ConfigParser:

import configparser

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

# Set the optional *raw* argument of get() to True if you wish to disable
# interpolation in a single get operation.
print(cfg.get('Section1', 'foo', raw=False))  # -> "Python is fun!"
print(cfg.get('Section1', 'foo', raw=True))   # -> "%(bar)s is %(baz)s!"

# The optional *vars* argument is a dict with members that will take
# precedence in interpolation.
print(cfg.get('Section1', 'foo', vars={'bar': 'Documentation',
                                       'baz': 'evil'}))

# The optional *fallback* argument can be used to provide a fallback value
print(cfg.get('Section1', 'foo'))
      # -> "Python is fun!"

print(cfg.get('Section1', 'foo', fallback='Monty is not.'))
      # -> "Python is fun!"

print(cfg.get('Section1', 'monster', fallback='No such things as monsters.'))
      # -> "No such things as monsters."

# A bare print(cfg.get('Section1', 'monster')) would raise NoOptionError
# but we can also use:

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

Os valores padrão estão disponíveis em ambos os tipos de ConfigParsers. Eles são usados ​​em interpolação se uma opção usada não estiver definida em outro lugar.

import configparser

# New instance with 'bar' and 'baz' defaulting to 'Life' and 'hard' each
config = configparser.ConfigParser({'bar': 'Life', 'baz': 'hard'})
config.read('example.cfg')

print(config.get('Section1', 'foo'))     # -> "Python is fun!"
config.remove_option('Section1', 'bar')
config.remove_option('Section1', 'baz')
print(config.get('Section1', 'foo'))     # -> "Life is hard!"

Objetos ConfigParser

class configparser.ConfigParser(defaults=None, dict_type=dict, 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={})

O principal analisador sintático de configuração. Quando defaults é fornecido, ele é inicializado no dicionário de padrões intrínsecos. Quando dict_type for fornecido, ele será usado para criar os objetos dicionário para a lista de seções, para as opções dentro de uma seção e para os valores padrão.

Quando delimitadores são fornecidos, eles são usados ​​como o conjunto de substrings que dividem chaves de valores. Quando comment_prefixes for fornecido, ele será usado como o conjunto de substrings que prefixam comentários em linhas vazias. Os comentários podem ser indentados. Quando inline_comment_prefixes for fornecido, ele será usado como o conjunto de substrings que prefixam comentários em linhas não vazias.

Quando strict for True (o padrão), o analisador sintático não permitirá nenhuma seção ou opção duplicada durante a leitura de uma única fonte (arquivo, string ou dicionário), levantando DuplicateSectionError ou DuplicateOptionError. Quando empty_lines_in_values é False (padrão: True), cada linha vazia marca o fim de uma opção. Caso contrário, as linhas vazias internas de uma opção multilinha serão mantidas como parte do valor. Quando allow_no_value for True (padrão: False), opções sem valores serão aceitas; o valor mantido para estes é None e eles são serializados sem o delimitador final.

Quando default_section é fornecido, ele especifica o nome da seção especial que contém valores padrão para outras seções e propósitos de interpolação (normalmente chamada de "DEFAULT"). Este valor pode ser recuperado e alterado em tempo de execução usando o atributo de instância default_section. Isso não reavaliará um arquivo de configuração já analisado, mas será usado ao escrever configurações analisadas em um novo arquivo de configuração.

O comportamento de interpolação pode ser personalizado fornecendo um manipulador personalizado por meio do argumento interpolation. None pode ser usado para desligar completamente a interpolação, ExtendedInterpolation() fornece uma variante mais avançada inspirada em zc.buildout. Mais sobre o assunto na seção de documentação dedicada.

Todos os nomes de opções usados ​​na interpolação serão passados ​​através do método optionxform() assim como qualquer outra referência de nome de opção. Por exemplo, usando a implementação padrão de optionxform() (que converte nomes de opções para letras minúsculas), os valores foo %(bar)s e foo %(BAR)s são equivalentes.

Quando conversers é fornecido, deve ser um dicionário onde cada chave representa o nome de um conversor de tipo e cada valor é um chamável implementando a conversão de string para o tipo de dados desejado. Cada conversor obtém seu próprio método get*() correspondente no objeto analisador sintático e nos intermediários de seção.

Alterado na versão 3.1: O padrão dict_type é collections.OrderedDict.

Alterado na versão 3.2: allow_no_value, delimiters, comment_prefixes, strict, empty_lines_in_values, default_section e interpolation foram adicionados.

Alterado na versão 3.5: O argumento converters foi adicionado.

Alterado na versão 3.7: O argumento defaults é lido com read_dict(), fornecendo um comportamento consistente em todo o analisador: chaves e valores que não são de string são convertidos implicitamente em strings.

Alterado na versão 3.8: O dict_type padrão é dict, pois agora preserva a ordem de inserção.

defaults()

Retorna um dicionário contendo os padrões de toda a instância.

sections()

Retorna uma lista das seções disponíveis; a seção padrão não está incluída na lista.

add_section(section)

Adiciona uma seção de nome section à instância. Se já existir uma seção com o nome fornecido, DuplicateSectionError será levantada. Se o nome da seção padrão for passado, ValueError será levantada. O nome da seção deve ser uma string; caso contrário, TypeError será levantada.

Alterado na versão 3.2: Nomes de seções sem string levantam TypeError.

has_section(section)

Indica se a section nomeada está presente na configuração. A seção padrão não é reconhecida.

options(section)

Retorna uma lista de opções disponíveis na section especificada.

has_option(section, option)

Se a section fornecida existir e contiver a option fornecida, retorna True; caso contrário, retorna False. Se a section especificada for None ou uma string vazia, DEFAULT será presumido.

read(filenames, encoding=None)

Tenta ler e analisar um iterável de nomes de arquivos, retornando uma lista de nomes de arquivos que foram analisados ​​com sucesso.

Se filenames for uma string, um objeto bytes ou um objeto caminho ou similar, este parâmetro será tratado como um único nome de arquivo. Se um arquivo nomeado em filenames não puder ser aberto, esse arquivo será ignorado. Isso foi projetado para que você possa especificar um iterável de possíveis locais de arquivo de configuração (por exemplo, o diretório atual, o diretório inicial do usuário e algum diretório de todo o sistema) e todos os arquivos de configuração existentes no iterável serão lidos.

Se nenhum dos arquivos nomeados existir, a instância ConfigParser conterá um conjunto de dados vazio. Uma aplicação que requer que valores iniciais sejam carregados de um arquivo deve carregar o arquivo ou arquivos necessários usando read_file() antes de chamar read() para quaisquer arquivos opcionais:

import configparser, os

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

Alterado na versão 3.2: Adicionado o parâmetro encoding. Anteriormente, todos os arquivos eram lidos usando a codificação padrão para open().

Alterado na versão 3.6.1: O parâmetro filenames aceita um objeto caminho ou similar.

Alterado na versão 3.7: O parâmetro filenames aceita um objeto bytes.

read_file(f, source=None)

Lê e analisa dados de configuração de f que devem ser iteráveis, produzindo strings Unicode (por exemplo, arquivos abertos em modo texto).

O argumento opcional source especifica o nome do arquivo que está sendo lido. Se não for fornecido e f tiver um atributo name, que é usado para source; o padrão é '<???>'.

Novo na versão 3.2: Substitui readfp().

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

Analisa dados de configuração de uma string.

O argumento opcional source especifica um nome específico do contexto da string passada. Se não for fornecido, '<string>' será usado. Geralmente deve ser um caminho do sistema de arquivos ou uma URL.

Novo na versão 3.2.

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

Carrega a configuração de qualquer objeto que forneça um método items() dict ou similar. Chaves são nomes de seções, valores são dicionários com chaves e valores que devem estar presentes na seção. Se o tipo de dicionário usado preservar a ordem, as seções e suas chaves serão adicionadas em ordem. Os valores são convertidos automaticamente em strings.

O argumento opcional source especifica um nome específico do contexto do dicionário passado. Se não for fornecido, <dict> será usado.

Este método pode ser usado para copiar o estado entre analisadores sintáticos.

Novo na versão 3.2.

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

Obtém um valor de option para a section nomeada. Se vars for fornecido, deverá ser um dicionário. A option é pesquisada em vars (se fornecido), section e em DEFAULTSECT nesta ordem. Se a chave não for encontrada e fallback for fornecido, ele será usado como um valor alternativo. None pode ser fornecido como um valor fallback.

Todas as interpolações '%' são expandidas nos valores de retorno, a menos que o argumento raw seja verdadeiro. Os valores das chaves de interpolação são consultados da mesma maneira que a opção.

Alterado na versão 3.2: Os argumentos raw, vars e fallback são palavras somente-nomeadas para proteger os usuários de tentarem usar o terceiro argumento como substituto fallback (especialmente ao usar o protocolo de mapeamento).

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

Um método de conveniência que força a option na section especificada ser um número inteiro. Veja get() para explicação de raw, vars e fallback.

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

A convenience method which coerces the option in the specified section to a floating point number. See get() for explanation of raw, vars and fallback.

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

Um método de conveniência que força a option na section especificada a um valor booleano. Observe que os valores aceitos para a opção são '1', 'yes', 'true', e 'on', o que fazem com que este método retorne True, e '0', 'no', 'false', e 'off', o que fazem com que ele retorne False. Esses valores de string são verificados sem distinção entre maiúsculas e minúsculas. Qualquer outro valor fará com que ele levante ValueError. Veja get() para explicação de raw, vars e fallback.

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

Quando section não é fornecido, retorna uma lista de pares section_name, section_proxy, incluindo DEFAULTSECT.

Caso contrário, retorna uma lista de pares name, value para as opções na section fornecida. Argumentos opcionais têm o mesmo significado do método get().

Alterado na versão 3.8: Os itens presentes em vars não aparecem mais no resultado. O comportamento anterior misturava opções reais do analisador sintático com variáveis ​​fornecidas para interpolação.

set(section, option, value)

Se a seção fornecida existir, defina a opção fornecida com o valor especificado; caso contrário, levanta NoSectionError. option e value devem ser strings; caso contrário, TypeError será levantada.

write(fileobject, space_around_delimiters=True)

Escreve uma representação da configuração no objeto arquivo especificado, que deve ser aberto em modo texto (aceitando strings). Esta representação pode ser analisada por uma futura chamada read(). Se space_around_delimiters for verdadeiro, os delimitadores entre chaves e valores serão envoltos por espaços.

Nota

Os comentários no arquivo de configuração original não são preservados ao escrever a configuração. O que é considerado um comentário depende dos valores fornecidos para comment_prefix e inline_comment_prefix.

remove_option(section, option)

Remove a option especificada da section especificada. Se a seção não existir, levanta NoSectionError. Se existisse a opção de ser removida, retorna True; caso contrário, retorna False.

remove_section(section)

Remove a section especificada da configuração. Se a seção de fato existiu, retorna True. Caso contrário, retorna False.

optionxform(option)

Transforma o nome da opção option conforme encontrado em um arquivo de entrada ou conforme passado pelo código do cliente no formato que deve ser usado nas estruturas internas. A implementação padrão retorna uma versão em minúsculas de option; subclasses podem substituir isso ou o código do cliente pode definir um atributo com esse nome nas instâncias para afetar esse comportamento.

Você não precisa criar uma subclasse do analisador sintático para usar esse método; você também pode configurá-lo em uma instância, para uma função que recebe um argumento de string e retorna uma string. Definir como str, por exemplo, faria com que sejam diferenciadas as letras maiúsculas das minúsculas nos nomes das opções:

cfgparser = ConfigParser()
cfgparser.optionxform = str

Observe que ao ler arquivos de configuração, os espaços em branco ao redor dos nomes das opções são removidos antes de optionxform() ser chamado.

readfp(fp, filename=None)

Obsoleto desde a versão 3.2: Use read_file() instead.

Alterado na versão 3.2: readfp() now iterates on fp instead of calling fp.readline().

For existing code calling readfp() with arguments which don’t support iteration, the following generator may be used as a wrapper around the file-like object:

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

Instead of parser.readfp(fp) use parser.read_file(readline_generator(fp)).

configparser.MAX_INTERPOLATION_DEPTH

A profundidade máxima para interpolação recursiva para get() quando o parâmetro raw é falso. Isso é relevante apenas quando a interpolation padrão é usada.

Objetos RawConfigParser

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

Variante legada do ConfigParser. Ela tem a interpolação desabilitada por padrão e permite nomes de seções não-string, nomes de opções e valores através de seus métodos inseguros add_section e set, bem como o tratamento de argumentos nomeados legados defaults= .

Alterado na versão 3.8: O dict_type padrão é dict, pois agora preserva a ordem de inserção.

Nota

Considere usar ConfigParser, que verifica os tipos de valores a serem armazenados internamente. Se você não quiser interpolação, você pode usar ConfigParser(interpolation=None).

add_section(section)

Adiciona uma seção chamada section à instância. Se já existir uma seção com o nome fornecido, DuplicateSectionError será levantada. Se o nome da seção padrão for passado, ValueError será levantada.

O tipo da section não está marcado, o que permite aos usuários criar seções nomeadas sem string. Este comportamento não é compatível e pode causar erros internos.

set(section, option, value)

Se a seção fornecida existir, defina a opção fornecida com o valor especificado; caso contrário, levanta NoSectionError. Embora seja possível usar RawConfigParser (ou ConfigParser com parâmetros raw definidos como verdadeiro) para armazenamento interno de valores não-string, funcionalidade completa (incluindo interpolação e saída para arquivos) só pode ser alcançado usando valores de string.

Este método permite que os usuários atribuam valores não-string às chaves internamente. Este comportamento não é suportado e causará erros ao tentar escrever em um arquivo ou obtê-lo no modo não bruto. Use a API do protocolo de mapeamento que não permite que tais atribuições ocorram.

Exceções

exception configparser.Error

Classe base para todas as outras exceções do configparser.

exception configparser.NoSectionError

Exceção levantada quando uma seção especificada não é encontrada.

exception configparser.DuplicateSectionError

Exceção levantada se add_section() for chamado com o nome de uma seção que já está presente ou em analisadores sintáticos estritos quando uma seção for encontrada mais de uma vez em um único arquivo de entrada, string ou dicionário.

Alterado na versão 3.2: Adicionados os atributos e parâmetros opcionais source e lineno a __init__().

exception configparser.DuplicateOptionError

Exceção levantada por analisadores sintáticos estritos se uma única opção aparecer duas vezes durante a leitura de um único arquivo, string ou dicionário. Isso detecta erros ortográficos e erros relacionados a diferenciação de letras maiúsculas e minúsculas como, p. ex., um dicionário pode ter duas chaves representando a mesma chave de configuração que não diferencia maiúsculas de minúsculas.

exception configparser.NoOptionError

Exceção levantada quando uma opção especificada não é encontrada na seção especificada.

exception configparser.InterpolationError

Classe base para exceções levantadas quando ocorrem problemas ao executar a interpolação de strings.

exception configparser.InterpolationDepthError

Exceção levantada quando a interpolação de string não pode ser concluída porque o número de iterações excede MAX_INTERPOLATION_DEPTH. Subclasse de InterpolationError.

exception configparser.InterpolationMissingOptionError

Exceção levantada quando uma opção referenciada a partir de um valor não existe. Subclasse de InterpolationError.

exception configparser.InterpolationSyntaxError

Exceção levantada quando o texto fonte no qual são feitas as substituições não está em conformidade com a sintaxe exigida. Subclasse de InterpolationError.

exception configparser.MissingSectionHeaderError

Exceção levantada ao tentar analisar um arquivo que não possui cabeçalhos de seção.

exception configparser.ParsingError

Exceção levantada quando ocorrem erros ao tentar analisar um arquivo.

Alterado na versão 3.2: The filename attribute and __init__() argument were renamed to source for consistency.

Notas de rodapé