ไฟล์คุณสมบัติในหลาม (คล้ายกับคุณสมบัติของ Java)

รับรูปแบบต่อไปนี้ ( .propertiesหรือ. ini ):

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

สำหรับJavaมีคลาสPropertiesที่มีฟังก์ชั่นในการแยก / โต้ตอบกับรูปแบบข้างต้น

มีบางอย่างที่คล้ายกันในห้องสมุดมาตรฐานของไพ ธ อน (2.x) หรือไม่?

ถ้าไม่มีฉันมีทางเลือกอื่นอีกบ้าง?

สำหรับไฟล์. ini จะมีโมดูลConfigParserที่จัดรูปแบบที่เข้ากันได้กับไฟล์. ini

อย่างไรก็ตามไม่มีสิ่งใดสำหรับการวิเคราะห์ไฟล์. properties ที่สมบูรณ์เมื่อฉันต้องทำอย่างนั้นฉันก็ใช้ jython (ฉันกำลังพูดถึงการเขียนสคริปต์)

ฉันสามารถทำให้มันใช้งานได้โดยConfigParserไม่มีใครแสดงตัวอย่างใด ๆ เกี่ยวกับวิธีการทำเช่นนี้ดังนั้นนี่คือเครื่องอ่าน python ที่เรียบง่ายของไฟล์คุณสมบัติและตัวอย่างของไฟล์คุณสมบัติ โปรดทราบว่าส่วนขยายยังคงอยู่.propertiesแต่ฉันต้องเพิ่มส่วนหัวของส่วนที่คล้ายกับสิ่งที่คุณเห็นในไฟล์. ini ... บิตของการทิ้งระเบิด แต่มันใช้งานได้

ไฟล์ไพ ธ อน: 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 มักจะเป็นรหัสหลามที่ถูกต้องเช่นกัน คุณสามารถเปลี่ยนชื่อไฟล์ myconfig.properties เป็น myconfig.py จากนั้นเพียงนำเข้าไฟล์ของคุณเช่นนี้

import myconfig

และเข้าถึงคุณสมบัติโดยตรง

print myconfig.propertyName1

ฉันรู้ว่านี่เป็นคำถามที่เก่ามาก แต่ฉันต้องการมันในตอนนี้และฉันตัดสินใจที่จะใช้โซลูชันของฉันเองซึ่งเป็นโซลูชันงูหลามบริสุทธิ์ที่ครอบคลุมกรณีการใช้งานส่วนใหญ่ (ไม่ใช่ทั้งหมด):

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 แต่หลังจากพบข้อ จำกัด ต่าง ๆ ฉันก็ลงมือทำเอง มีการสนับสนุนอย่างสมบูรณ์สำหรับรูปแบบ. คุณสมบัติรวมถึงการสนับสนุน unicode และการสนับสนุนที่ดีกว่าสำหรับ escape sequences Jprops ยังสามารถแยกวิเคราะห์วัตถุใด ๆ ที่คล้ายกับไฟล์ในขณะที่ pyjavaproperties ใช้ได้กับไฟล์จริงบนดิสก์เท่านั้น

หากคุณไม่มีคุณสมบัติหลายบรรทัดและต้องการง่ายมากโค้ดสองสามบรรทัดสามารถแก้ปัญหาให้คุณได้:

ไฟล์t.properties:

a=b
c=d
e=f

รหัสหลาม:

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

นี่ไม่ใช่คุณสมบัติที่แน่นอน แต่ Python มีไลบรารีที่ดีสำหรับการวิเคราะห์ไฟล์การกำหนดค่า ยังเห็นสูตรนี้: ทดแทนหลามสำหรับ java.util.Properties

นี่คือการเชื่อมโยงกับโครงการของฉัน: https://sourceforge.net/projects/pyproperties/ เป็นไลบรารีที่มีวิธีการทำงานกับไฟล์ * .properties สำหรับ Python 3.x

แต่มันไม่ได้ขึ้นอยู่กับ java.util.Properties

นี่คือการแทนที่ java.util.Propities แบบหนึ่งต่อหนึ่ง

จากเอกสาร:

  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.

คุณสามารถใช้วัตถุคล้ายไฟล์ได้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()

ฉันใช้สิ่งนี้แล้วห้องสมุดนี้มีประโยชน์มาก

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'

นี่คือสิ่งที่ฉันทำในโครงการของฉัน: ฉันเพิ่งสร้างไฟล์. py ที่เรียกว่า Properties.py ซึ่งรวมถึงตัวแปร / คุณสมบัติทั่วไปทั้งหมดที่ฉันใช้ในโครงการและในไฟล์ใด ๆ จำเป็นต้องอ้างถึงตัวแปรเหล่านี้

from properties import *(or anything you need)

ใช้วิธีนี้เพื่อรักษาความสงบ svn เมื่อฉันเปลี่ยนสถานที่ dev บ่อยและตัวแปรทั่วไปบางอย่างค่อนข้างสัมพันธ์กับสภาพแวดล้อมในท้องถิ่น ใช้งานได้ดีสำหรับฉัน แต่ไม่แน่ใจว่าวิธีนี้จะแนะนำสำหรับสภาพแวดล้อม dev ทางการ ฯลฯ

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

เนื้อหาของ test.json: {"โฮสต์": "127.0.0.1", "ผู้ใช้": "jms"}

ฉันได้สร้างโมดูล python ที่เกือบจะคล้ายกับคลาส Properties ของ Java (จริง ๆ แล้วมันเหมือน PropertyPlaceholderConfigurer ในฤดูใบไม้ผลิซึ่งช่วยให้คุณใช้ $ {การอ้างอิงตัวแปร} เพื่ออ้างถึงคุณสมบัติที่กำหนดไว้แล้ว)

แก้ไข: คุณอาจติดตั้งแพคเกจนี้โดยใช้คำสั่ง (ทดสอบในปัจจุบันสำหรับหลาม 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']

วางทั้งหมดในวิธีการที่อ่านส่วนนั้นจากไฟล์ config เพียงครั้งเดียว (ครั้งแรกที่วิธีการที่เรียกว่าในระหว่างการเรียกใช้โปรแกรม)

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' เป็นชื่อส่วนในไฟล์กำหนดค่าและ 'พอร์ต' เป็นคีย์ภายใต้ส่วน 'DB')

โค้ดด้านล่าง 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/

คุณสามารถใช้พารามิเตอร์ "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"

ฉันทำสิ่งนี้โดยใช้ 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

• -h หรือ - ช่วยสรุปการใช้งานพิมพ์
• -c ระบุถ่านที่ระบุความคิดเห็น
• - ตัวคั่นระหว่างคีย์และค่าในไฟล์ prop

• และระบุไฟล์คุณสมบัติที่ต้องแยกวิเคราะห์เช่น: 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:])

Lightbend ได้เปิดตัวLibrary 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']

ฉันทำตามวิธีการของ 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

เนื้อหาของไฟล์ schema ที่อ่าน:

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

สร้างพจนานุกรมในโมดูลหลามของคุณและเก็บทุกอย่างไว้ในนั้นและเข้าถึงมันตัวอย่างเช่น:

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

ตอนนี้เพื่อเข้าถึงคุณสามารถทำได้:

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