अजगर में गुण फ़ाइल (जावा गुण के समान)

Question

निम्नलिखित प्रारूप ( .properties या .ini ) को देखते हुए :

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

के लिए जावा है गुण वर्ग उपरोक्त प्रारूप के साथ पार्स / बातचीत करने के लिए प्रदान करता है कार्यक्षमता।

क्या अजगर के मानक में भी कुछ ऐसा ही है पुस्तकालय (2.x) ?

यदि नहीं, तो मेरे पास और क्या विकल्प हैं?

Comments

यह एक जावा प्रश्न नहीं है। आपने जावा टैग हटाने का रोलबैक क्यों किया?

— BalusC

Answer 1

.Ini फ़ाइलों के लिए configParser मॉड्यूल है जो .ini फ़ाइलों के साथ संगत प्रारूप प्रदान करता है।

वैसे भी पूरी तरह से .properties फ़ाइलों को पार्स करने के लिए कुछ भी उपलब्ध नहीं है, जब मुझे यह करना होगा कि मैं बस जीथन का उपयोग कर रहा हूं (मैं स्क्रिप्टिंग के बारे में बात कर रहा हूं)।

Comments

अगर आप Jython: bitbucket.org/jnoller/pyjavaproperties

— हंस-क्रिस्टोफ़ स्टेनर

जावा गुण फ़ाइल .ini फ़ाइल के बराबर नहीं है। pyjavaproperties सही उत्तर है

— इग्नि

एलेक्स मटेली ने कॉन्फ़िगर करने के लिए एक आसान तरीका सुझाया है। यहाँ विन्यासकर्ता के साथ .properties फ़ाइलों को stackoverflow.com/a/2819788/15274

— pi।

bitbucket.org/jnoller/pyjavaproperties को 2010 से बनाए नहीं रखा गया है। यह अजगर 3 के साथ संगत नहीं है। मैं @pi द्वारा लिंक किए गए समाधानों का उपयोग करूंगा।

— codyzu

यहाँ कहीं भी इसका उल्लेख नहीं किया गया है, मुझे फिर से जोड़ना है कि यह वही नहीं है। मैं जावा या Py3 के लिए बात नहीं कर सकता, और शायद यह सरल कुंजी / मूल्यों के लिए काम करता है। लेकिन स्ट्रिंग प्रक्षेप के लिए सिंटैक्स अलग है। यह समाधान पायथन स्वरूपण प्रदान करता है, अर्थात। % (स्ट्रिंग) जबकि (उदाहरण के लिए चींटी) मैं $ {string} का उपयोग करूंगा। pymotw.com/2/ConfigParser

— mpe

Answer 2

मैं इसके साथ काम करने में सक्षम था ConfigParser, किसी ने भी ऐसा करने के लिए कोई उदाहरण नहीं दिखाया, इसलिए यहां एक संपत्ति फ़ाइल का एक साधारण अजगर पाठक और संपत्ति फ़ाइल का उदाहरण है। ध्यान दें कि एक्सटेंशन अभी भी है.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

Comments

विन्यासकर्ता मॉड्यूल का नाम बदलकर अजगर 3. में किया गया है।

— गुरसेवक सिंह

यह .ini फ़ाइलों के लिए है, नहीं .properties फ़ाइलों के रूप में वे वर्गों में शामिल नहीं है, और configParser विफल रहता है अगर यह किसी भी अनुभाग शीर्ष लेख नहीं मिलता है। इसके अलावा, ini फाइलें वर्गों में शामिल नहीं हो सकती हैं इसलिए यह configParser बिल्कुल भी विश्वसनीय नहीं लगता है

— BiAiB

Answer 3

एक जावा गुण फ़ाइल अक्सर मान्य अजगर कोड के रूप में अच्छी तरह से है। आप अपनी myconfig.properties फ़ाइल का नाम बदलकर myconfig.py कर सकते हैं। तो बस इस तरह अपनी फ़ाइल आयात करें

import myconfig

और सीधे गुणों तक पहुँचें

print myconfig.propertyName1

Comments

मुझे यह विचार पसंद है, लेकिन यह उन गुणों के लिए काम नहीं करता है जिनमें डॉट्स होते हैं, अर्थात prop.name="val"इस मामले में काम नहीं करने वाला है।

— मैक्सजैकोब

A java properties file is valid python code: मुझे अलग करना है। कुछ जावा प्रॉपर्टीज फाइलें वैध अजगर कोड के लिए पास होंगी, लेकिन निश्चित रूप से सभी नहीं। जैसा कि @mmjj ने कहा कि डॉट्स एक समस्या है। तो अनारक्षित शाब्दिक तार हैं। -1।

— मनोज गोविंदन

ए बदर बैड आइडिया ... चूंकि यह टूट गया है। जावा प्रोप फाइलें "=" के बजाय ":" अनुमति देती हैं; लाइन-कंटीन्यूशन के बाद वे व्हॉट्सएप खाते हैं; वे तार नहीं उद्धृत करते हैं। उस में से कोई भी "वैध पायथन" नहीं है।

— दान एच

जावा गुण फाइलें सामान्य रूप से मान्य अजगर कोड के लिए पास नहीं होने वाली हैं। एक विकल्प सिर्फ एक पायथन फाइल में अपने गुणों को सेट करना है, और वैध अजगर का उपयोग करें (जैसे: MEDIA_ROOT = '/ foo') ...

— danbgray

यह एक हैक सबसे अच्छा बचा है। जब आप गुण बदलते हैं तो आपका दिन खराब होता है और फ़ाइल मान्य अजगर नहीं होती है।

— r_2

Answer 4

मुझे पता है कि यह एक बहुत पुराना प्रश्न है, लेकिन मुझे अभी इसकी आवश्यकता है और मैंने अपने स्वयं के समाधान को लागू करने का फैसला किया, एक शुद्ध अजगर समाधान, जिसमें अधिकांश उपयोग के मामले शामिल हैं (सभी नहीं):

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" }

Comments

शीर्ष पायदान समाधान और वास्तव में मैं क्या देख रहा था!

— रसेल

ध्यान दें कि यह प्रविष्टियों की तरह ही लाइन पर टिप्पणियों का समर्थन नहीं करता है foo = "bar" # bat।

— थॉमस डब्ल्यूवी

@ThomasW यदि हम जावा को वास्तविक मानक के रूप में उपयोग कर रहे हैं, तो गुण # लोड fooमान के साथ एक संपत्ति के रूप में व्यवहार करेगा "bar" # bat।

— bon

आपने सोचा कि एक पुराने प्रश्न के उत्तर को पोस्ट करने में क्या बात है? मुद्दा यह है कि मैं इसे कॉपी पेस्ट के द्वारा समय बचाने में सक्षम था, अपने स्वयं के क्रियान्वयन के बजाय मेरी azure पाइपलाइन में से एक में। इसलिए धन्यवाद :)

— पुराने भिक्षु

उत्तर को प्यार करो! केवल इनलाइन टिप्पणियों को संभालने के लिए मैंने जो परिवर्तन किया था, उसे बदलना l = line.strip()था l = line.split(comment_char)[0].strip()और उसके lबाद की लाइन के बजाय एक मान होने पर ही जांचें if l:।

— बेन डैलिंग

Answer 5

यदि आपके पास फ़ाइल स्वरूपों का एक विकल्प है जो मैं .ini और पायथन के कॉन्फिगरपैर का उपयोग करने का सुझाव देता हूं। यदि आपको Java .properties फ़ाइलों के साथ संगतता की आवश्यकता है, तो मैंने इसके लिए एक पुस्तकालय लिखा है जिसे jprops कहा जाता है । हम pyjavaproperties का उपयोग कर रहे थे, लेकिन विभिन्न सीमाओं का सामना करने के बाद मैंने अपने स्वयं के कार्यान्वयन को समाप्त कर दिया। इसमें .properties प्रारूप के लिए पूर्ण समर्थन है, जिसमें यूनिकोड समर्थन और भागने के दृश्यों के लिए बेहतर समर्थन शामिल है। Jprops किसी भी फाइल की तरह ऑब्जेक्ट को पार्स कर सकते हैं जबकि pyjavaproperties केवल डिस्क पर असली फाइलों के साथ काम करता है।

Comments

मैंने बस यही कोशिश की। एक जादू की तरह काम करता है। मैटगूड के लिए +1!

— डैन एच

यदि आप पाइप इंस्टॉल और एक कोड उदाहरण जोड़ते हैं, तो आपका उत्तर बेहतर पाइप स्थापित होगा jprops, ओपन (पथ) के साथ fp के रूप में: गुण = jprops.load_properties (fp) प्रिंट (गुण)

— रबर बतख

Answer 6

यदि आपके पास मल्टी लाइन प्रॉपर्टी और बहुत सरल आवश्यकता नहीं है, तो कोड की कुछ लाइनें आपके लिए इसे हल कर सकती हैं:

फ़ाइल 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}

Answer 7

यह बिल्कुल गुण नहीं है, लेकिन कॉन्फ़िगरेशन फ़ाइलों को पार्स करने के लिए पायथन में एक अच्छा पुस्तकालय है । यह नुस्खा भी देखें: java.util.Properties के लिए एक अजगर प्रतिस्थापन ।

Comments

दूसरे लिंक के लिए ... यह अब सक्रिय रूप से विकसित नहीं हुआ है। जेसी नोलर ने इस रेसिपी से एक प्रोजेक्ट बनाया है जिसमें कुछ फ़िक्स यहाँ उपलब्ध नहीं हैं। लेखक इस नुस्खा का उपयोग करके किसी को भी उस परियोजना की सिफारिश करता है। pypi.python.org/pypi/pyjavaproperties

— बिग अल

Answer 8

यहाँ मेरी परियोजना का लिंक है: https://sourceforge.net/projects/pyproperties/ । यह एक ऐसी लाइब्रेरी है जिसमें * * के साथ काम करने के तरीके हैं। पायथन 3.x के लिए फाइल।

लेकिन यह java.util.Properties पर आधारित नहीं है

Answer 9

यह 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 10

आप 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 11

मैंने इसका उपयोग किया है, यह पुस्तकालय बहुत उपयोगी है

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 12

यह वही है जो मैं अपने प्रोजेक्ट में कर रहा हूं: मैं बस एक और .py फ़ाइल बनाता हूं, जिसे properties.py कहा जाता है, जिसमें प्रोजेक्ट में उपयोग किए जाने वाले सभी सामान्य चर / गुण शामिल हैं, और किसी भी फ़ाइल में इन वेरिएबल्स को संदर्भित करने की आवश्यकता है,

from properties import *(or anything you need)

इस विधि का उपयोग svn शांति रखने के लिए किया जाता है जब मैं अक्सर देव स्थानों को बदल रहा था और कुछ सामान्य चर स्थानीय वातावरण के सापेक्ष काफी थे। मेरे लिए ठीक काम करता है लेकिन यकीन नहीं होता कि यह विधि औपचारिक देव पर्यावरण आदि के लिए सुझाई जाएगी।

Answer 13

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

Test.json की सामग्री: {"host": "127.0.0.1", "उपयोगकर्ता": "jms"}

Answer 14

मैंने एक पायथन मॉड्यूल बनाया है जो लगभग जावा के गुण वर्ग के समान है (वास्तव में यह वसंत में प्रॉपर्टीहोल्डरकॉन्फिगरर की तरह है जो आपको पहले से परिभाषित संपत्ति को संदर्भित करने के लिए $ {चर-संदर्भ} का उपयोग करता है)

संपादित करें: आप इस पैकेज को कमांड चलाकर (वर्तमान में अजगर 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')

Comments

मान लें कि आपके पास my_file.properties फ़ाइल foo = में परिभाषित निम्नलिखित गुण हैं = मैं उपरोक्त गुणों के गुण लोड करने के लिए $ = चॉकलेट} -बार चॉकलेट = ठगना कोड हूं = संपत्ति () प्रोप.लोड ('पथ / टू / my_file' .प्रक्रियाएं) प्रोप.गेट ('फू') # मैं कमाल का प्रोपगेट हूं ('बार') # ठगना-बार

— आनंद जोशी

किया हुआ । आशा है कि यह मदद करता है

— आनंद जोशी

Answer 15

यदि आपको गुणनखंड में एक अनुभाग से सभी मानों को सरल तरीके से पढ़ने की आवश्यकता है:

आपकी 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'}

अब की 1 का मान पाने के लिए: 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 16

कोड की 2 पंक्तियों से पता चलता है कि 'जावा स्टाइल' प्रॉपर्टी फ़ाइल को लोड करने के लिए पायथन लिस्ट कॉम्प्रिहेंशन का उपयोग कैसे करें।

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/

Comments

कोड फ़ाइल ऑब्जेक्ट को बंद नहीं करता है, यह भी लिंक केवल उत्तर का स्वागत नहीं है।

— अरस्तू

वह समाधान बहु-रेखा मानों या मानों को कवर नहीं करता है जिसमें समान चिह्न शामिल होता है।

— कॉन्स्टेंटिन ताराशांस्कियां

Answer 17

आप निम्न के रूप में विन्यास फाइल से पढ़ने के लिए argparse के साथ पैरामीटर "fromfile_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"

Answer 18

मैंने निम्नानुसार कॉन्फिगरेशन का उपयोग करके ऐसा किया। कोड मानता है कि एक फ़ाइल है जिसे 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

Answer 19

यह वही है जो मैंने फ़ाइल को पार्स करने के लिए लिखा था और इसे env वेरिएबल्स के रूप में सेट किया था जो hg को निर्दिष्ट करने के लिए टिप्पणियों और गैर-कुंजी मान लाइनों को स्विच करता था।

• -h या --help प्रिंट उपयोग सारांश
• -c निर्दिष्ट करें चार कि टिप्पणी की पहचान करता है
• प्रो फ़ाइल में कुंजी और मूल्य के बीच -s सेपरेटर

• और गुण फ़ाइल निर्दिष्ट करें जिसे पार्स करने की आवश्यकता है जैसे: 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:])

Answer 20

Lightbend जारी किया है typesafe कॉन्फ़िग पुस्तकालय है, जो गुण फ़ाइलों और भी कुछ JSON आधारित एक्सटेंशन पार्स करता है। लाइटबेंड की लाइब्रेरी केवल JVM के लिए है, लेकिन इसे व्यापक रूप से अपनाया गया लगता है और अब पायथन सहित कई भाषाओं में पोर्ट हैं: https://github.com/chimpler/pyhocon

Answer 21

आप निम्न फ़ंक्शन का उपयोग कर सकते हैं, जो @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 22

यह मेरे लिए काम करता है।

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

Comments

कृपया इस डुप्लिकेट पोस्टिंग को हटा दें। btw मैंने आपका एक और काम किया;)

— javadba

Answer 23

मैंने विन्यासकर्ता दृष्टिकोण का पालन किया और यह मेरे लिए काफी अच्छा काम किया। प्रत्येक प्रॉपर्टी के लिए तैयार प्रॉपर्टी के लिए एक प्रॉपर्टी राइडर फाइल बनाई और उसमें कॉन्फिगर पार्सर का इस्तेमाल किया।

** इस्तेमाल किया गया पायथन 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

Comments

यह एक ini फ़ाइल है, गुण फ़ाइल में कोई अनुभाग हेडर नहीं होगा

— अक्षय

Answer 24

अपने अजगर मॉड्यूल में एक शब्दकोश बनाएं और उसमें सब कुछ स्टोर करें और इसे एक्सेस करें, उदाहरण के लिए:

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

अब इसे एक्सेस करने के लिए आप बस यह कर सकते हैं:

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

Comments

यह कुछ कोड नमूना साझा करने के लिए अत्यधिक अनुशंसित है। अभी के लिए आपका जवाब बहुत ही खराब है

— निकोलाई शेवचेंको

खराब फॉर्मेटिंग के लिए @NikolayShevchenko क्षमा करें, मैंने अपना उत्तर अपडेट कर दिया है

— विनीत सिंह