Como ler e escrever arquivos ini e conf usando python

A linguagem de programação do Python vem com um módulo interno útil chamado "ConfigParser", que pode ser usado para escrever de forma limpa parâmetros de configuração para aplicativos. O ConfigParser usa uma linguagem de configuração bem definida e estruturada totalmente compatível com os arquivos INI encontrados no Microsoft Windows. Esses arquivos ini podem ser usados ​​com aplicativos Python em execução no Linux e eles fornecem uma maneira persistente de armazenar e recuperar valores.

No Linux, é mais comum ver “.Arquivos confiados do que “.arquivos ini ”. Os arquivos confiados no Linux são como outros arquivos de texto e, portanto, eles podem ser estruturados de qualquer forma. Depende do analisador como ele interpreta um “.arquivo conf ”. O módulo ConfigParser do Python pode analisar “.Arquivos conf ”também (ou qualquer outra extensão aleatória), desde que esses arquivos sejam definidos na linguagem de configuração compatível com INI. Este artigo explicará a leitura e a escrita “.arquivos conf ”no Linux usando a versão estável mais recente do Python 3. Observe que se você substituir todas as ocorrências de “.Extensão conf ”neste artigo com“.Extensão ini ”, o resultado seria o mesmo. O processo e o código explicados abaixo também devem ser compatíveis com o Microsoft Windows, com algumas pequenas diferenças. Embora essas diferenças não sejam abordadas neste artigo.

Módulo de configurador

Analisador de arquivos de configuração ou configparser é um módulo Python que permite ler e gravar arquivos de configuração usados ​​em aplicativos Python. Como explicado acima, este módulo suporta a sintaxe do arquivo ini. Um muito simplista “.ini " /".o arquivo conf ”se parece com este.

[PADRÃO]
som = 1
música = 1
volume = 0.8
Resolução = 1920x1080
[Do utilizador]
# o som pode ter 0 (falso) e 1 (verdadeiro) como possíveis valores
som = 1
; A música pode ter 0 (false) e 1 (verdadeiro) como possíveis valores
música = 0
Volume = 0.4
Resolução = 1280x720

O exemplo ".O arquivo conf ”acima tem duas seções,“ padrão ”e“ usuário ”. Normalmente, os programas Python são codificados de maneira que os valores da seção padrão nunca sejam alterados. A seção padrão é usada para redefinir valores gerais ou individuais para valores padrão. A seção do usuário reflete as alterações feitas por um usuário final que está usando o programa Python. Observe que os nomes da seção podem ser qualquer coisa e não é necessário ter uma seção padrão. No entanto, sempre que a seção "padrão" estiver presente (o nome deve estar na mancha), ela será usada para fornecer valores padrão com segurança se o ConfigParser não conseguir analisar certas variáveis. A lógica para lidar com essas seções, variáveis ​​sob elas e valores de fallback deve ser definida no próprio programa Python. Símbolos como "#" e ";" pode ser usado para denotar comentários em “.arquivos conf ”. Todos os pares de valores-chave no arquivo de configuração são insensíveis a maiúsculas, geralmente escritas em minúsculas.

Manipulação de dados de dados por configparser

Antes de seguir em frente com alguns exemplos de configparser, é importante entender o manuseio de dados de dados por este módulo. Para o ConfigParser, todo pedaço de código escrito ou analisado é uma string. Não pode diferenciar entre números ou qualquer outro formato. Os programadores precisam escrever lógica em seu programa para converter uma string "1234" em número usando int ("1234") enquanto lê dados de um ".arquivo conf ”.

Embora a conversão em números usando o método INT e Float seja uma tarefa bastante fácil, a conversão para booleana pode ser complicada, pois o python trata o bool ("any_string") para ser verdadeiro. Para superar esse problema, você pode usar declarações condicionais verificando uma string específica. O módulo ConfigParser também fornece um método chamado "getBoolean ()". Este método pode diferenciar corretamente 'sim'/'não', 'em'/'off', 'verdadeiro'/'false' e '1'/'0' valores booleanos, mesmo que sejam strings. ConfigParser também inclui métodos getint () e getfloat () para sua conveniência.

Escrever e salvar um novo arquivo confy usando o ConfigParser

Vamos supor o “.Conf ”o arquivo mencionado acima não existe e você deseja criá -lo automaticamente no primeiro lançamento do programa. O código abaixo criará uma nova “configurações.arquivo conf ”no diretório do qual o programa Python foi executado.

Importar ConfigParser
config = configParser.ConfigParser ()
config ['default'] = "Sound": "1", "Music": "1",
"Volume": "0.8 "," Resolução ":" 1920x1080 "
config ['usuário'] = "Sound": "1", "Music": "1",
"Volume": "0.8 "," Resolução ":" 1920x1080 "
Com o Open ('Configurações.conf ',' w ') como configfile:
Config.Escreva (configfile)

A primeira declaração no código acima importa o módulo ConfigParser. A segunda declaração cria um objeto semelhante ao dicionário chamado "config". Agora você pode usar a sintaxe do dicionário Python padrão para definir seções e variáveis ​​incluídas em eles, como evidente nas próximas duas declarações. Por fim, a declaração "com aberto" cria uma nova "configurações.Conf ”arquivo e grava seções de configuração no arquivo.

O código acima funciona, mas há um pequeno problema com ele. Ele cria um novo arquivo de configurações sempre que o programa é executado, resultando em sobrescrita de qualquer usuário feito edições no arquivo de configurações. Para corrigir esse problema, você precisa verificar duas condições:

• O arquivo de configurações existe? Caso contrário, crie um novo arquivo de configurações apenas se o arquivo não existir.
• O arquivo de configurações existe, mas contém quaisquer dados? Está vazio? Escreva novos dados de configuração para configurações apenas se estiver vazio.

O código modificado abaixo verificará as duas condições e só criará um novo arquivo de configurações se essas duas condições forem atendidas.

Importar ConfigParser
OS de importação
config = configParser.ConfigParser ()
config ['default'] = "Sound": "1", "Music": "1",
"Volume": "0.8 "," Resolução ":" 1920x1080 "
config ['usuário'] = "Sound": "1", "Music": "1",
"Volume": "0.8 "," Resolução ":" 1920x1080 "
Settings_File = OS.caminho.Dirname (OS.caminho.RealPath (__ file__))
+ OS.SEP + "Configurações.confis "
se não OS.caminho.Existe (Settingts_File)
ou os.Stat (Settings_file).st_size == 0:
Com o Open ('Configurações.conf ',' w ') como configfile:
Config.Escreva (configfile)

A segunda declaração no código acima importa o módulo "SO". A variável “Settings_File” armazena caminho completo para as “Configurações.arquivo conf ”a ser criado no diretório do script python. A próxima declaração verifica duas condições mencionadas acima. A primeira cláusula na declaração é auto -explicativa. A segunda cláusula verifica se o tamanho do arquivo é "0 bytes". Um arquivo de byte zero significaria um arquivo vazio sem dados armazenados nele. O restante do código é o mesmo que o primeiro exemplo declarado acima.

Até agora, as amostras de código explicadas acima salve o arquivo de configuração no diretório do próprio script python. No entanto, é uma prática comum e o padrão Freedesktop para salvar arquivos de configuração no “.Diretório de configuração ”na pasta doméstico. O exemplo de código abaixo criará uma nova “configurações.arquivo conf ”em“ ~/.Pasta Config/TestApp ”.

Importar ConfigParser
OS de importação
app_name = "testapp"
config_folder = os.caminho.Junte -se (OS.caminho.Expanduser ("~"), '.config ', app_name)
OS.makes (config_folder, exist_ok = true)
Settings_file = "Configurações.confis "
Full_config_file_path = os.caminho.Join (config_folder, Settings_file)
config = configParser.ConfigParser ()
config ['default'] = "Sound": "1", "Music": "1",
"Volume": "0.8 "," Resolução ":" 1920x1080 "
config ['usuário'] = "Sound": "1", "Music": "1",
"Volume": "0.8 "," Resolução ":" 1920x1080 "
se não OS.caminho.Existe (Full_config_file_path)
ou os.Stat (Full_config_file_path).st_size == 0:
com open (full_config_file_path, 'w') como configfile:
Config.Escreva (configfile)

O código acima é quase o mesmo que o exemplo anterior, exceto que muda a localização de “Configurações.arquivo conf ”para“ ~/.Config/TestApp/Configurações.conf ”. A variável "config_folder" armazena o caminho completo para a pasta de aplicativos a ser criada em ".diretório de configuração "(" ~//.config/testapp/”). O “os.A declaração de Makedirs ”só criará uma nova pasta de aplicativos se ainda não existir. A variável "Full_Config_File_Path" armazena o caminho completo do arquivo de configurações ("~//.Config/TestApp/Configurações.Conf ”). O restante do código é auto -explicativo.

Lendo um arquivo confy usando o ConfigParser

Analisar um arquivo de configuração é bem direto. O configparser tenta ler um valor usando os métodos get (), getfloat (), getBoolean () ou sintaxe do dicionário. No caso de um erro -chave, os valores da seção padrão ou dos valores de fallback são usados. É uma boa prática definir valores de seção ou fallback padrão para evitar erros importantes. Você também pode usar declarações de tentativa de exceção para suprimir erros.

config = configParser.ConfigParser ()
Config.Leia (Full_config_file_path)
is_sound_on = config ['usuário'].getBoolean ('som')
volume_level = config ['usuário'].getfloat ('volume')
Resolução = config ['usuário'] ['Resolução']
# Valor de Fallback "false" será ignorado, pois já existe uma seção padrão.
# Na ausência de seção padrão, o valor de fallback será devidamente usado.
is_music_on = config ['usuário'].getBoolean ('Music', falso)
print (is_sound_on, is_music_on, volume_level, resolução)

Na amostra de código acima, “Config.Leia ”a declaração é usada para ler dados de um arquivo de configuração. Nas declarações a seguir, vários métodos de GET integrados e notações de dicionário são usadas para ler os dados. Na variável Declaração “is_music_on”, o segundo argumento é o valor de fallback (false). Observe que os valores de fallback terão menor precedência do que os valores definidos na seção padrão. Em termos simples, os valores de fallback não terão efeito quando um par de valores-chave já estiver presente na seção padrão.

Código completo

Abaixo está o código inteiro combinando a criação da primeira execução do arquivo de configuração e a leitura do arquivo de configuração.

#! /usr/bin/python3
Importar ConfigParser
OS de importação
app_name = "testapp"
config_folder = os.caminho.Junte -se (OS.caminho.Expanduser ("~"), '.config ', app_name)
OS.makes (config_folder, exist_ok = true)
Settings_file = "Configurações.confis "
Full_config_file_path = os.caminho.Join (config_folder, Settings_file)
config = configParser.ConfigParser ()
config ['default'] = "Sound": "1", "Music": "1",
"Volume": "0.8 "," Resolução ":" 1920x1080 "
config ['usuário'] = "Sound": "1", "Music": "1",
"Volume": "0.8 "," Resolução ":" 1920x1080 "
se não OS.caminho.Existe (Full_config_file_path)
ou os.Stat (Full_config_file_path).st_size == 0:
com open (full_config_file_path, 'w') como configfile:
Config.Escreva (configfile)
Config.Leia (Full_config_file_path)
is_sound_on = config ['usuário'].getBoolean ('som')
volume_level = config ['usuário'].getfloat ('volume')
Resolução = config ['usuário'] ['Resolução']
# Valor de Fallback "false" será ignorado, pois já existe uma seção padrão.
# Na ausência de seção padrão, o valor de fallback será devidamente usado.
is_music_on = config ['usuário'].getBoolean ('Music', falso)
print (is_sound_on, is_music_on, volume_level, resolução)

Conclusão

O ConfigParser em Python fornece uma maneira útil de lidar com as configurações da linha de comando e dos aplicativos GUI Python. Esses arquivos de configuração também podem ser usados ​​como bancos de dados leves baseados em texto, mas não podem ser adequados para dados avançados de dados, grandes conjuntos de dados e grande número de consultas.