Python 中的属性文件(类似于 Java 属性)

这不完全是属性，但 Python 确实有一个用于解析配置文件的 图书馆不错。

对于 .ini文件，有一个提供与 .ini文件兼容的格式的 configparser模块。

无论如何，没有什么可用于解析完整的 .properties文件，当我必须这样做时，我只是使用 jython (我说的是脚本)。

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

医生说:

  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.

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

import myconfig

直接进入房产

print myconfig.propertyName1

如果您有一个文件格式的选项，我建议使用。如上所述，使用 ini 和 Python 的 ConfigParser。如果你需要与 Java 兼容。我已经为它编写了一个名为 Jprops的库。我们使用 pyjavaproperties，但是在遇到各种限制之后，我最终实现了自己的属性。它完全支持。属性格式，包括 Unicode 支持和对转义序列的更好支持。Jprops 还可以解析任何类似文件的对象，而 pyjavaproperties 只能处理磁盘上的实际文件。

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

但是它不是基于 java.util.Properties 的

这就是我在我的项目中所做的: 我只是创建另一个。Py 文件，它包含了我在项目中使用的所有公共变量/属性，并且在任何文件中都需要引用这些变量

from properties import *(or anything you need)

当我频繁地更改开发位置并且一些公共变量与本地环境相关时，使用这种方法来保持 svn 的平静。对我来说工作很好，但不确定这种方法是否适用于正式的开发环境等。

我能够让它与 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

我使用 ConfigParser 完成了以下操作。这段代码假设 BaseTest 所在的目录中有一个名为 config.prop 的文件:

Config.prop

[CredentialSection]
app.name=MyAppName

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

我知道这是一个非常古老的问题，但是我现在就需要它，我决定实现我自己的解决方案，一个纯 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" }

我已经创建了一个几乎与 Java 的 Properties 类相似的 python 模块(实际上它类似于 Spring 中的 PropertyPlaceholderConfigrer，它允许您使用 ${ variable-reference }来引用已经定义的属性)

编辑: 您可以通过运行命令来安装这个包(目前正在测试 python3)。
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')

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

内容: {“ host”: “127.0.0.1”，“ user”: “ jms”}

这是我写的解析文件，并设置它为环境变量，跳过注释和非关键值行添加开关指定 Hg: d

• - h 或者...-帮忙打印用法摘要
• - c 指定标识注释的 char
• - 在道具文件中键和值之间的分隔符

• 并指定需要解析的属性文件，例如: python 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:])
  

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

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’部分下的一个键。)

您可以在这里定义的 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()

下面两行代码展示了如何使用 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-comprehension-and-generators/

Lightend 已经发布了 类型安全配置库，它解析属性文件和一些基于 JSON 的扩展。Lightbend 的库只适用于 JVM，但它似乎被广泛采用，而且现在有许多语言的端口，包括 Python: https://github.com/chimpler/pyhocon

如果你没有多行属性和一个非常简单的需求，几行代码就可以解决它:

文件 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}

您可以使用以下函数，它是@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

这对我有用。

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

我用过这个，这个图书馆很有用

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'

我遵循了配置解析器的方法，它对我来说工作得很好。创建一个 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')

属性文件的内容:

[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

在 python 模块中创建一个 dictionary，并将所有内容存储在其中，然后访问它，例如:

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

现在你可以简单地做:

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

您可以使用带有 argparse 的参数“ from file _ prefix _ chars”从配置文件中读取，如下所示——-

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"

我的 Javaini 文件没有节头，因此我想要一个 dict。所以我只是简单地注入了一个“[ ini ]”部分，让默认配置库完成它的工作。

以 eclipseIDE. 元数据目录的 version. ini fie 为例:

#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

结果转换为一个判决:

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