python中的属性文件（类似于Java Properties）

Question

给定以下格式（.properties 或 .ini）：

propertyName1=propertyValue1
propertyName2=propertyValue2
...
propertyNameN=propertyValueN

对于 Java，有 Properties 类，提供解析/与上述格式交互的功能。

python 的 标准 库 (2.x) 中有类似的东西吗？

如果没有，我还有什么其他选择？

Answer 1

增强@mvallebr的非常好的答案：

def readConfig(filepath: str, delim: str = '=') -> dict:
    try:
        with open(filepath) as f:
            l = [line.split("=") for ln in f.readlines() \
                 if (line := ln.strip()) and not line.startswith('#')]
            return {key.strip().strip('"'): value.strip().strip('"') for key, value in l}
    except FileNotFoundError as e:
        print(e)
        sys.exit(1)

Answer 2

尝试 ConfigParser

我能够让它与 ConfigParser 一起使用，没有人展示任何有关如何执行此操作的示例，因此这里是属性文件的简单 python 阅读器和属性文件的示例。请注意，扩展名仍然是 .properties，但我必须添加一个类似于您在 .ini 文件中看到的节标题......有点混蛋，但它有效。

python 文件：PythonPropertyReader.py

#!/usr/bin/python    
import ConfigParser
config = ConfigParser.RawConfigParser()
config.read('ConfigFile.properties')

print config.get('DatabaseSection', 'database.dbname');

属性文件：ConfigFile.properties

[DatabaseSection]
database.dbname=unitTest
database.user=root
database.password=

有关更多功能，请阅读：https://docs.python.org/2/library/configparser.html

Answer 3

我知道这是一个非常老的问题，但我现在需要它，我决定实现我自己的解决方案，一个纯 python 解决方案，涵盖大多数用例（不是全部）：

def load_properties(filepath, sep='=', comment_char='#'):
    """
    Read the file passed as parameter as a properties file.
    """
    props = {}
    with open(filepath, "rt") as f:
        for line in f:
            l = line.strip()
            if l and not l.startswith(comment_char):
                key_value = l.split(sep)
                key = key_value[0].strip()
                value = sep.join(key_value[1:]).strip().strip('"') 
                props[key] = value 
    return props

您可以更改 sep 到 ':' 以解析以下格式的文件：

key : value

代码正确解析如下行：

url = "http://my-host.com"
name = Paul = Pablo
# This comment line will be ignored

您将得到一个带有以下内容的字典：

{"url": "http://my-host.com", "name": "Paul = Pablo" }

Answer 4

对于 .ini 文件，有 configparser< /a> 模块，提供与 .ini 文件兼容的格式。

无论如何，没有任何东西可用于解析完整的 .properties 文件，当我必须这样做时，我只需使用 jython （我正在谈论脚本）。

Answer 5

java 属性文件通常也是有效的 python 代码。您可以将 myconfig.properties 文件重命名为 myconfig.py。然后只需导入您的文件，就像这样

import myconfig

并直接访问属性

print myconfig.propertyName1

Answer 6

如果你没有多行属性并且需求非常简单，几行代码就可以为你解决：

文件t.properties：

a=b
c=d
e=f

Python代码：

with open("t.properties") as f:
    l = [line.split("=") for line in f.readlines()]
    d = {key.strip(): value.strip() for key, value in l}

Answer 7

如果您可以选择文件格式，我建议使用 .ini 和 Python 的 ConfigParser（如上所述）。如果您需要与 Java .properties 文件兼容，我已经为其编写了一个名为 jprops 的库。我们使用的是 pyjavaproperties，但在遇到各种限制后，我最终实现了自己的。它完全支持 .properties 格式，包括 unicode 支持和对转义序列的更好支持。 Jprops 还可以解析任何类似文件的对象，而 pyjavaproperties 仅适用于磁盘上的真实文件。

Answer 8

我用过这个，这个库非常有用

from pyjavaproperties import Properties
p = Properties()
p.load(open('test.properties'))
p.list()
print(p)
print(p.items())
print(p['name3'])
p['name3'] = 'changed = value'

Answer 9

这不完全是属性，但 Python 确实有一个用于解析配置文件的不错的库。另请参阅此食谱： A python replacement for java.util.Properties 。

Answer 10

这是一个一对一的替换java.util.Propeties

来自文档：

  def __parse(self, lines):
        """ Parse a list of lines and create
        an internal property dictionary """

        # Every line in the file must consist of either a comment
        # or a key-value pair. A key-value pair is a line consisting
        # of a key which is a combination of non-white space characters
        # The separator character between key-value pairs is a '=',
        # ':' or a whitespace character not including the newline.
        # If the '=' or ':' characters are found, in the line, even
        # keys containing whitespace chars are allowed.

        # A line with only a key according to the rules above is also
        # fine. In such case, the value is considered as the empty string.
        # In order to include characters '=' or ':' in a key or value,
        # they have to be properly escaped using the backslash character.

        # Some examples of valid key-value pairs:
        #
        # key     value
        # key=value
        # key:value
        # key     value1,value2,value3
        # key     value1,value2,value3 \
        #         value4, value5
        # key
        # This key= this value
        # key = value1 value2 value3

        # Any line that starts with a '#' is considerered a comment
        # and skipped. Also any trailing or preceding whitespaces
        # are removed from the key/value.

        # This is a line parser. It parses the
        # contents like by line.

Answer 11

这是我的项目的链接：https://sourceforge.net/projects/pyproperties/。它是一个库，包含用于处理 Python 3.x 的 *.properties 文件的方法。

但它不是基于 java.util.Properties

Answer 12

您可以在此处定义的 ConfigParser.RawConfigParser.readfp 中使用类似文件的对象 -> https://docs.python.org/2/library/ configparser.html#ConfigParser.RawConfigParser.readfp

定义一个覆盖 readline 的类，该类在属性文件的实际内容之前添加节名称。

我已将其打包到返回所有已定义属性的 dict 的类中。

import ConfigParser

class PropertiesReader(object):

    def __init__(self, properties_file_name):
        self.name = properties_file_name
        self.main_section = 'main'

        # Add dummy section on top
        self.lines = [ '[%s]\n' % self.main_section ]

        with open(properties_file_name) as f:
            self.lines.extend(f.readlines())

        # This makes sure that iterator in readfp stops
        self.lines.append('')

    def readline(self):
        return self.lines.pop(0)

    def read_properties(self):
        config = ConfigParser.RawConfigParser()

        # Without next line the property names will be lowercased
        config.optionxform = str

        config.readfp(self)
        return dict(config.items(self.main_section))

if __name__ == '__main__':
    print PropertiesReader('/path/to/file.properties').read_properties()

Answer 13

在 python 模块中创建一个字典，并将所有内容存储到其中并访问它，例如：

dict = {
       'portalPath' : 'www.xyx.com',
       'elementID': 'submit'}

现在要访问它，您只需执行以下操作：

submitButton = driver.find_element_by_id(dict['elementID'])

Answer 14

我的 Java ini 文件没有节标题，因此我想要一个字典。所以我只是注入了一个“[ini]”部分并让默认配置库完成其工作。

以eclipse IDE .metadata目录下的version.ini文件为例：

#Mon Dec 20 07:35:29 CET 2021
org.eclipse.core.runtime=2
org.eclipse.platform=4.19.0.v20210303-1800

# 'injected' ini section
[ini]
#Mon Dec 20 07:35:29 CET 2021
org.eclipse.core.runtime=2
org.eclipse.platform=4.19.0.v20210303-1800

结果转换为dict：

from configparser import ConfigParser

@staticmethod
    def readPropertyFile(path):
        # https://stackoverflow.com/questions/3595363/properties-file-in-python-similar-to-java-properties
        config = ConfigParser()
        s_config= open(path, 'r').read()
        s_config="[ini]\n%s" % s_config
        # https://stackoverflow.com/a/36841741/1497139
        config.read_string(s_config)
        items=config.items('ini')
        itemDict={}
        for key,value in items:
            itemDict[key]=value
        return itemDict

Answer 15

这就是我在项目中所做的：我只是创建另一个名为properties.py的.py文件，其中包含我在项目中使用的所有常用变量/属性，并且在任何需要引用这些变量的文件中，放入

from properties import *(or anything you need)

使用此方法当我经常更改开发位置并且一些常见变量与本地环境相当相关时，保持 svn 和平。对我来说效果很好，但不确定是否会建议这种方法用于正式的开发环境等。

Answer 16

import json
f=open('test.json')
x=json.load(f)
f.close()
print(x)

test.json的内容：
{“主机”：“127.0.0.1”，“用户”：“jms”}

Answer 17

我创建了一个Python模块，它几乎类似于Java的Properties类（实际上它就像Spring中的PropertyPlaceholderConfigurer，它允许您使用${variable-reference}来引用已经定义的属性）

编辑：您可以通过以下方式安装这个包运行命令（当前针对 python 3 进行了测试）。
pip install property

该项目托管在 GitHub

示例：（详细文档可以可以在此处找到）

假设您在 my_file.properties 文件中定义了以下属性

foo = I am awesome
bar = ${chocolate}-bar
chocolate = fudge

加载上述属性的代码

from properties.p import Property

prop = Property()
# Simply load it into a dictionary
dic_prop = prop.load_property_files('my_file.properties')

Answer 18

如果您需要以简单的方式读取属性文件中某个部分的所有值：

您的 config.properties 文件布局：

[SECTION_NAME]  
key1 = value1  
key2 = value2  

您编码：

   import configparser

   config = configparser.RawConfigParser()
   config.read('path_to_config.properties file')

   details_dict = dict(config.items('SECTION_NAME'))

这将为您提供一个字典，其中键与配置文件中的键相同，并且他们对应的值。

details_dict 是：

{'key1':'value1', 'key2':'value2'}

现在获取 key1 的值：
details_dict['key1']

将其全部放入一个方法中，该方法仅从配置文件中读取该部分一次（在程序运行期间第一次调用该方法）。

def get_config_dict():
    if not hasattr(get_config_dict, 'config_dict'):
        get_config_dict.config_dict = dict(config.items('SECTION_NAME'))
    return get_config_dict.config_dict

现在调用上面的函数并获取所需键的值：

config_details = get_config_dict()
key_1_value = config_details['key1'] 

-------------------------------------- -----------------------

扩展上述方法，自动逐节读取，然后按节名加键名进行访问。

def get_config_section():
    if not hasattr(get_config_section, 'section_dict'):
        get_config_section.section_dict = dict()

        for section in config.sections():
            get_config_section.section_dict[section] = 
                             dict(config.items(section))

    return get_config_section.section_dict

访问：

config_dict = get_config_section()

port = config_dict['DB']['port'] 

（此处“DB”是配置文件中的部分名称
并且“port”是“DB”部分下的键。）

Answer 19

下面两行代码展示了如何使用Python列表理解来加载“java风格”属性文件。

split_properties=[line.split("=") for line in open('/<path_to_property_file>)]
properties={key: value for key,value in split_properties }

详细请看下面的帖子
https:// /ilearnonlinesite.wordpress.com/2017/07/24/reading-property-file-in-python-using-compressive-and-generators/

Answer 20

您可以使用参数“fromfile_prefix_chars”和argparse从配置文件中读取，如下所示---

temp.py

parser = argparse.ArgumentParser(fromfile_prefix_chars='#')
parser.add_argument('--a')
parser.add_argument('--b')
args = parser.parse_args()
print(args.a)
print(args.b)

配置文件

--a
hello
--b
hello dear

运行命令

python temp.py "#config"

Answer 21

您可以使用 - https://pypi.org/project/property/

例如 - my_file.properties

foo = I am awesome
bar = ${chocolate}-bar
chocolate = fudge
long = a very long property that is described in the property file which takes up \
multiple lines can be defined by the escape character as it is done here
url=example.com/api?auth_token=xyz
user_dir=${HOME}/test
unresolved = ${HOME}/files/${id}/${bar}/
fname_template = /opt/myapp/{arch}/ext/{objid}.dat

代码

from properties.p import Property


## set use_env to evaluate properties from shell / os environment
prop = Property(use_env = True)
dic_prop = prop.load_property_files('my_file.properties')

## Read multiple files
## dic_prop = prop.load_property_files('file1', 'file2')


print(dic_prop)

# Output

# {'foo': 'I am awesome', 'bar': 'fudge-bar', 'chocolate': 'fudge',
#  'long': 'a very long property that is described in the property file which takes up multiple lines
#  can be defined by the escape character as it is done here', 'url': 'example.com/api?auth_token=xyz',
#  'user_dir': '/home/user/test',
#  'unresolved': '/home/user/files/${id}/fudge-bar/',
#  'fname_template': '/opt/myapp/{arch}/ext/{objid}.dat'}

Answer 22

这是我编写的用于解析文件并将其设置为环境变量的内容，该变量会跳过注释和非键值行添加的开关来指定
hg:d

• -h 或 --help 打印用法摘要
• -c 指定标识注释的字符
• -s prop 文件中键和值之间的分隔
• 符

  并指定需要解析的属性文件 例如：python
  EnvParamSet.py -c # -s = env.properties

  导入管道
  导入系统
  导入操作系统路径
  
  类解析：
  
          def __init__(self , seperator , commentChar , propFile):
          self.separator = 分隔符
          self.commentChar = commentChar
          self.propFile = propFile
  
      def parseProp(自身):
          prop = open(self.propFile,'rU')
          对于 prop 中的行：
              如果 line.startswith(self.commentChar)==False 且 line.find(self.seprator) != -1 ：
                  keyValue = line.split(self.seprator)
                  键 = keyValue[0].strip() 
                  值 = keyValue[1].strip() 
                          print("导出 %s=%s" % (str (key),pipes.quote(str(value))))
  
  
  
  
  类 EnvParamSet：
  
      def 主要（argv）：
  
          分隔符 = '='
          评论='#'
  
          如果 len(argv) 为 0：
              print "请指定要解析的属性文件"
              sys.exit()
          propFile=argv[-1] 
  
  
          尝试 ：
              opts, args = getopt.getopt(argv, "hs:c:f:", ["help", "seprator=","comment=", "file="])
          除了 getopt.GetoptError，e：
              打印字符串(e)
              print " 可能的参数 -s <键值sperator > -c <注释字符 > <文件> \n 尝试 -h 或 --help "
              系统退出(2)
  
  
          如果 os.path.isfile(args[0])==False:
              打印“文件不存在”
              sys.exit()
  
  
          对于 opt ， opts 中的 arg ：
              如果选择加入（“-h”，“--help”）：
                  print " hg:d \n -h 或 --help 打印用法摘要 \n -c 指定识别注释的字符 \n -s prop 文件中键和值之间的分隔符 \n 指定文件 "
                  sys.exit()
              elif 选择加入（“-s”、“--seprator”）：
                  分隔符=arg 
              elif 选择加入（“-c”、“--comment”）：
                  评论=参数
  
          p = 解析（分隔符、注释、propFile）
          p.parseProp()
  
      如果 __name__ == "__main__":
              主要(sys.argv[1:])
  

Answer 23

Lightbend 发布了 Typesafe Config 库，它解析属性文件以及一些基于 JSON 的扩展。 Lightbend 的库仅适用于 JVM，但它似乎被广泛采用，并且现在有多种语言的移植，包括 Python：https://github.com/chimpler/pyhocon

Answer 24

可以使用下面的函数，这是@mvallebr的修改代码。它尊重属性文件注释，忽略空新行，并允许检索单个键值。

def getProperties(propertiesFile ="/home/memin/.config/customMemin/conf.properties", key=''):
    """
    Reads a .properties file and returns the key value pairs as dictionary.
    if key value is specified, then it will return its value alone.
    """
    with open(propertiesFile) as f:
        l = [line.strip().split("=") for line in f.readlines() if not line.startswith('#') and line.strip()]
        d = {key.strip(): value.strip() for key, value in l}

        if key:
            return d[key]
        else:
            return d

Answer 25

这对我有用。

from pyjavaproperties import Properties
p = Properties()
p.load(open('test.properties'))
p.list()
print p
print p.items()
print p['name3']

Answer 26

我遵循 configparser 方法，它对我来说效果很好。创建一个 PropertyReader 文件并在其中使用配置解析器来准备与每个部分相对应的属性。

**使用Python 2.7

PropertyReader.py 文件的内容：

#!/usr/bin/python
import ConfigParser

class PropertyReader:

def readProperty(self, strSection, strKey):
    config = ConfigParser.RawConfigParser()
    config.read('ConfigFile.properties')
    strValue = config.get(strSection,strKey);
    print "Value captured for "+strKey+" :"+strValue
    return strValue

读取模式文件的内容：

from PropertyReader import *

class ReadSchema:

print PropertyReader().readProperty('source1_section','source_name1')
print PropertyReader().readProperty('source2_section','sn2_sc1_tb')

.properties 文件的内容：

[source1_section]
source_name1:module1
sn1_schema:schema1,schema2,schema3
sn1_sc1_tb:employee,department,location
sn1_sc2_tb:student,college,country

[source2_section]
source_name1:module2
sn2_schema:schema4,schema5,schema6
sn2_sc1_tb:employee,department,location
sn2_sc2_tb:student,college,country

Answer 27

您可以尝试 python-dotenv 库。该库从 .env（因此不完全是 .properties 文件）文件读取键值对，并可以将它们设置为环境变量。

以下是官方文档中的示例用法：

from dotenv import load_dotenv

load_dotenv()  # take environment variables from .env.

# Code of your application, which uses environment variables (e.g. from `os.environ` or
# `os.getenv`) as if they came from the actual environment.

Answer 28

我使用 ConfigParser 执行此操作，如下所示。该代码假设在放置 BaseTest.py 的同一目录中有一个名为 config.prop 的文件：

config.prop:

[CredentialSection]
app.name=MyAppName

BaseTest.py：

import unittest
import ConfigParser

class BaseTest(unittest.TestCase):
    def setUp(self):
        __SECTION = 'CredentialSection'
        config = ConfigParser.ConfigParser()
        config.readfp(open('config.prop'))
        self.__app_name = config.get(__SECTION, 'app.name')
    
    def test1(self):
        print self.__app_name % This should print: MyAppName