Учитывая следующий формат (.properties или .ini):
propertyName1=propertyValue1
propertyName2=propertyValue2
...
propertyNameN=propertyValueN
Для Java существует класс Properties, который предлагает функциональные возможности для разбора/взаимодействия с указанным выше форматом.
Есть ли что-то подобное в python стандартной библиотеке (2.x)?
Если нет, то какие у меня альтернативы?
Для файлов .ini существует ConfigParser модуль, который поддерживает формат, совместимый с .ini файлами.
Во всяком случае нет ничего доступного для разбора полных файлов .properties, когда я должен это делать, я просто использую jython (я говорю о скриптах).
Мне удалось заставить это работать с 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
Файл свойств java часто является правильным кодом python. Вы можете переименовать файл myconfig.properties в файл myconfig.py. Затем просто импортируйте файл, например
import myconfig
и напрямую обращаться к свойствам
print myconfig.propertyName1
Я знаю, что это очень старый вопрос, но мне он нужен только сейчас, и я решил реализовать свое собственное решение, чистое решение 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" }
Если у вас есть опция форматов файлов, я предлагаю использовать .ini и Python ConfigParser, как упоминалось. Если вам нужна совместимость с файлами Java.properties, я написал для него библиотеку под названием jprops. Мы использовали pyjavaproperties, но, столкнувшись с различными ограничениями, я в конечном итоге реализовал свои собственные. Он имеет полную поддержку формата .properties, включая поддержку Unicode и лучшую поддержку escape-последовательностей. Jprops также может анализировать любой файл-подобный объект, в то время как pyjavaproperties работает только с реальными файлами на диске.
Это не точно свойства, но у Python есть хорошая библиотека для анализа файлов конфигурации. Также см. Этот рецепт: Замена python для java.util.Properties.
если у вас нет многострочных свойств и очень простая потребность, несколько строк кода могут решить эту проблему за вас:
Файл 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}
Вот ссылка на мой проект: https://sourceforge.net/projects/pyproperties/. Это библиотека с методами работы с *.properties файлами для Python 3.x.
Но он не основан на java.util.Properties
Это является индивидуальной заменой 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.
Это то, что я делаю в своем проекте: я просто создаю еще один .py файл с именем properties.py, который включает в себя все распространенные переменные/свойства, которые я использовал в проекте, и в любом файле нужно ссылаться на эти переменные,
from properties import *(or anything you need)
Используется этот метод, чтобы сохранить спокойствие, когда я часто менял места размещения, и некоторые общие переменные были относительно относительны к локальной среде. Хорошо работает для меня, но не уверен, что этот метод будет предложен для формальной среды разработки и т.д.
Я создал модуль python, который почти похож на класс свойств Java (на самом деле он похож на PropertyPlaceholderConfigurer в spring, который позволяет использовать ${variable-reference} для обозначения уже определенного свойства)
EDIT: этот пакет можно установить, выполнив команду (в настоящее время тестируется на 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')
Если вам нужно прочитать все значения из раздела в файле свойств простым способом:
Ваше расположение файла 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()
import json
f=open('test.json')
x=json.load(f)
f.close()
print(x)
Содержание test.json: { "host": "127.0.0.1", "user": "jms" }
Ниже 2 строки кода показывают, как использовать Python List Comprehension для загрузки файла свойств java style.
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/
Я сделал это с помощью ConfigParser следующим образом. Код предполагает, что есть файл с именем config.prop в том же каталоге, где размещается BaseTest:
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
Это то, что я написал для анализа файла и задал его как переменные env, которые пропускают комментарии, а строки с добавленным ключом добавили ключи для указания Hg: d
и укажите файл свойств, который необходимо проанализировать, например: python EnvParamSet.py -С# -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:])
Lightbend выпустил библиотеку Typesafe Config, которая анализирует файлы свойств, а также некоторые расширения на основе JSON. Библиотека Lightbend предназначена только для JVM, но, похоже, получила широкое распространение, и теперь есть порты на многих языках, включая Python: https://github.com/chimpler/pyhocon
Вы можете использовать следующую функцию, которая является измененным кодом @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'
Я следовал подходу configparser, и он работал довольно хорошо для меня. Создал один файл PropertyReader и использовал там парсер конфигурации до свойства ready, соответствующего каждому разделу.
** Используется 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
создайте словарь в вашем модуле python и сохраните все в нем и получите к нему доступ, например:
dict = {
'portalPath' : 'www.xyx.com',
'elementID': 'submit'}
Теперь для доступа к нему вы можете просто сделать:
submitButton = driver.find_element_by_id(dict['elementID'])