给定以下格式（ .properties 或 .ini ）：
propertyName1=propertyValue1
propertyName2=propertyValue2
...
propertyNameN=propertyValueN
对于 Java ，Properties类提供了解析/与上述格式交互的功能。
python 的标准库（2.x）中是否有类似内容？
如果没有，我还有其他选择吗？
答案 0 :(得分：61)
我能够使用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
答案 1 :(得分：58)
对于.ini文件，ConfigParser模块提供与.ini文件兼容的格式。
无论如何，没有什么可用于解析完整的.properties文件，当我必须这样做时，我只是使用jython（我在谈论脚本）。
答案 2 :(得分：57)
java属性文件通常也是有效的python代码。您可以将myconfig.properties文件重命名为myconfig.py。然后只需导入您的文件，就像这样
import myconfig
直接访问属性
print myconfig.propertyName1
答案 3 :(得分：46)
我知道这是一个非常古老的问题，但我现在需要它，我决定实现我自己的解决方案，一个纯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更改为＆＃39;：＆＃39;解析格式为：
key : value
代码正确解析如下行：
url = "http://my-host.com"
name = Paul = Pablo
# This comment line will be ignored
你将获得一个词典：
{"url": "http://my-host.com", "name": "Paul = Pablo" }
答案 4 :(得分：15)
如果您有文件格式选项，我建议使用.ini和Python的ConfigParser。如果您需要与Java .properties文件兼容，我已经为它编写了一个名为jprops的库。我们使用pyjavaproperties，但在遇到各种限制后，我最终实现了自己的。它完全支持.properties格式，包括unicode支持和对转义序列的更好支持。 Jprops还可以解析任何类似文件的对象，而pyjavaproperties只能处理磁盘上的真实文件。
答案 5 :(得分：6)
这不是完全属性，但Python确实有nice library来解析配置文件。另请参阅此食谱：A python replacement for java.util.Properties。
答案 6 :(得分：6)
如果您没有多行属性并且非常简单，则只需几行代码即可为您解决：
文件RegNo：
t.propertiesPython代码：
a=b
c=d
e=f
答案 7 :(得分：4)
以下是我的项目的链接：https://sourceforge.net/projects/pyproperties/。它是一个库，其中包含使用Python 3.x的* .properties文件的方法。
但它不是基于java.util.Properties
答案 8 :(得分：2)
This是java.util.Propeties
的一对一替代品来自doc：
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.
答案 9 :(得分：2)
这就是我在项目中所做的事情：我只是创建另一个名为properties.py的.py文件，其中包含我在项目中使用的所有常见变量/属性，并且在任何文件中都需要引用这些变量，put
from properties import *(or anything you need)
当我经常更改dev位置时，使用此方法来保持svn和平，并且一些常见变量与本地环境相关。对我来说工作正常，但不确定这种方法是否适用于正式的开发环境等。
答案 10 :(得分：2)
我创建了一个类似于Java的Properties类的python模块（实际上它就像Spring中的PropertyPlaceholderConfigurer，它允许你使用$ {variable-reference}来引用已定义的属性）
编辑：你可以通过运行命令（目前为python 3测试）来安装这个软件包
pip install property
该项目托管于GitHub
示例:(可以找到详细的文档here）
假设您在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')
答案 11 :(得分：2)
如果需要以简单的方式读取属性文件中某个部分的所有值：
您的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']
（此处＆＃39; DB＆＃39;是配置文件中的部分名称 和＆＃39; port＆＃39;是“DB＆＃39;。”
下的一个关键字答案 12 :(得分：2)
您可以在此处定义的ConfigParser.RawConfigParser.readfp中使用类似文件的对象 - ＆gt; 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()
答案 13 :(得分：1)
我的Java ini文件没有节头，因此我想要一个字典。因此，我只是注入了一个“ [ini]”部分，然后让默认的配置库完成其工作。结果转换为字典：
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
答案 14 :(得分：1)
您可以将参数“ 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"
答案 15 :(得分：1)
在python模块中创建一个字典，并将所有内容存储到其中并进行访问，例如：
dict = {
'portalPath' : 'www.xyx.com',
'elementID': 'submit'}
现在要访问它，您只需执行以下操作：
submitButton = driver.find_element_by_id(dict['elementID'])
答案 16 :(得分：1)
以下两行代码显示了如何使用Python List Comprehension来加载“java风格”。属性文件。
split_properties=[line.split("=") for line in open('/<path_to_property_file>)]
properties={key: value for key,value in split_properties }
答案 17 :(得分：1)
import json
f=open('test.json')
x=json.load(f)
f.close()
print(x)
test.json的内容： {“host”：“127.0.0.1”，“user”：“jms”}
答案 18 :(得分：0)
Lightbend发布了Typesafe Config库，它解析属性文件以及一些基于JSON的扩展。 Lightbend的库仅适用于JVM，但它似乎被广泛采用，现在有许多语言的端口，包括Python：https://github.com/chimpler/pyhocon
答案 19 :(得分：0)
您可以使用以下功能，这是@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
答案 20 :(得分：0)
这对我有用。
from pyjavaproperties import Properties
p = Properties()
p.load(open('test.properties'))
p.list()
print p
print p.items()
print p['name3']
答案 21 :(得分：0)
我用过这个，这个库非常有用
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'
答案 22 :(得分：0)
我遵循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
答案 23 :(得分：0)
这是我写的解析文件并将其设置为env变量，这些变量跳过注释和非键值行添加开关指定 汞柱：d
并指定需要解析的属性文件，例如：python EnvParamSet.py -c＃-s = env.properties
import pipes
import sys , getopt
import os.path
class Parsing :
def __init__(self , seprator , commentChar , propFile):
self.seprator = seprator
self.commentChar = commentChar
self.propFile = propFile
def parseProp(self):
prop = open(self.propFile,'rU')
for line in prop :
if line.startswith(self.commentChar)==False and line.find(self.seprator) != -1 :
keyValue = line.split(self.seprator)
key = keyValue[0].strip()
value = keyValue[1].strip()
print("export %s=%s" % (str (key),pipes.quote(str(value))))
class EnvParamSet:
def main (argv):
seprator = '='
comment = '#'
if len(argv) is 0:
print "Please Specify properties file to be parsed "
sys.exit()
propFile=argv[-1]
try :
opts, args = getopt.getopt(argv, "hs:c:f:", ["help", "seprator=","comment=", "file="])
except getopt.GetoptError,e:
print str(e)
print " possible arguments -s <key value sperator > -c < comment char > <file> \n Try -h or --help "
sys.exit(2)
if os.path.isfile(args[0])==False:
print "File doesnt exist "
sys.exit()
for opt , arg in opts :
if opt in ("-h" , "--help"):
print " hg:d \n -h or --help print usage summary \n -c Specify char that idetifes comment \n -s Sperator between key and value in prop file \n specify file "
sys.exit()
elif opt in ("-s" , "--seprator"):
seprator = arg
elif opt in ("-c" , "--comment"):
comment = arg
p = Parsing( seprator, comment , propFile)
p.parseProp()
if __name__ == "__main__":
main(sys.argv[1:])
答案 24 :(得分：0)
我使用ConfigParser做了如下操作。该代码假定在放置BaseTest的同一目录中有一个名为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