पायथन शब्दकोशों का भंडारण

Question

मैं .csv फ़ाइलों का उपयोग करके पायथन में और बाहर डेटा लाने के लिए उपयोग किया जाता हूं, लेकिन इसके लिए स्पष्ट चुनौतियां हैं। एक शब्दकोश (या शब्दकोशों के सेट) को जोंस या पीक फ़ाइल में संग्रहीत करने के सरल तरीकों पर कोई सलाह? उदाहरण के लिए:

data = {}
data ['key1'] = "keyinfo"
data ['key2'] = "keyinfo2"

मैं यह जानना चाहूंगा कि इसे कैसे बचाया जाए, और फिर इसे वापस कैसे लोड किया जाए।

Comments

क्या आपने json या अचार मानक मॉड्यूल के लिए प्रलेखन पढ़ा है ?

— ग्रेग हेवगिल

पायथन में फ़ाइल (अचार के विकल्प) के लिए एक शब्दकोश सहेजें

— मार्टिन थोमा

Answer 1

अचार की बचत:

try:
    import cPickle as pickle
except ImportError:  # python 3.x
    import pickle

with open('data.p', 'wb') as fp:
    pickle.dump(data, fp, protocol=pickle.HIGHEST_PROTOCOL)

तर्क के संबंध में अतिरिक्त जानकारी के लिए अचार मॉड्यूल प्रलेखन देखें protocol।

अचार लोड:

with open('data.p', 'rb') as fp:
    data = pickle.load(fp)

---

JSON सहेजें:

import json

with open('data.json', 'w') as fp:
    json.dump(data, fp)

अतिरिक्त परिणाम की आपूर्ति sort_keysया indentएक सुंदर परिणाम प्राप्त करने के लिए। तर्क Sort_keys कुंजी को वर्णानुक्रम से सॉर्ट करेगा और इंडेंटindent=N रिक्त स्थान के साथ आपकी डेटा संरचना को इंडेंट करेगा ।

json.dump(data, fp, sort_keys=True, indent=4)

JSON लोड:

with open('data.json', 'r') as fp:
    data = json.load(fp)

Comments

JSON मूल रूप से शब्दकोशों करता है (हालांकि वे स्पष्ट रूप से व्यवहार नहीं करते हैं जैसा कि एक अजगर शब्दकोश स्मृति में रहता है, दृढ़ता उद्देश्यों के लिए, वे समान हैं)। वास्तव में, json में मूलभूत इकाई "ऑब्जेक्ट" है, जिसे {<string>: <value>} के रूप में परिभाषित किया गया है। परिचित दिखता है? मानक पुस्तकालय में json मॉड्यूल प्रत्येक पायथन देशी प्रकार का समर्थन करता है और इसे आसानी से उपयोगकर्ता-परिभाषित कक्षाओं का समर्थन करने के लिए json के न्यूनतम ज्ञान के साथ बढ़ाया जा सकता है। JSON होमपेज केवल 3 से अधिक मुद्रित पृष्ठों में पूरी तरह से भाषा को परिभाषित करता है, इसलिए इसे जल्दी से अवशोषित / पचाना आसान है।

— Jonathanb

यह तीसरे तर्क के बारे में भी जानने लायक pickle.dumpहै। यदि फ़ाइल को मानव-पठनीय होने की आवश्यकता नहीं है, तो यह चीजों को बहुत तेज़ कर सकती है।

— स्टीव जेसप

यदि आप डंप कॉल में sort_keys और इंडेंट तर्क जोड़ते हैं तो आपको बहुत ही सुंदर परिणाम मिलता है। उदाहरण के लिए: json.dump(data, fp, sort_keys=True, indent=4)। अधिक जानकारी यहां

— juliusmh

आपको शायद उपयोग करना चाहिएpickle.dump(data, fp, protocol=pickle.HIGHEST_PROTOCOL)

— मार्टिन थोमा

अजगर 3 के लिए, उपयोग करेंimport pickle

— खतरे 89 ९

Answer 2

न्यूनतम उदाहरण, सीधे फाइल में लिखना:

import json
json.dump(data, open(filename, 'wb'))
data = json.load(open(filename))

या सुरक्षित रूप से खोलना / बंद करना:

import json
with open(filename, 'wb') as outfile:
    json.dump(data, outfile)
with open(filename) as infile:
    data = json.load(infile)

यदि आप फ़ाइल के बजाय इसे स्ट्रिंग में सहेजना चाहते हैं:

import json
json_str = json.dumps(data)
data = json.loads(json_str)

Answer 3

इसके अलावा स्पीड-अप पैकेज ujson देखें। https://pypi.python.org/pypi/ujson

import ujson
with open('data.json', 'wb') as fp:
    ujson.dump(data, fp)

Answer 4

फ़ाइल में लिखने के लिए:

import json
myfile.write(json.dumps(mydict))

किसी फ़ाइल से पढ़ने के लिए:

import json
mydict = json.loads(myfile.read())

myfile उस फ़ाइल के लिए फ़ाइल ऑब्जेक्ट है जिसे आपने डिक्टेट में संग्रहीत किया है।

Comments

आप वेयर हैं कि जोंस के पास फाइलें हैं जो तर्कों के रूप में लेते हैं और उन्हें सीधे लिखते हैं?

json.dump(myfile)औरjson.load(myfile)

— निकल्स आर

Answer 5

यदि आप क्रमांकन के बाद हैं, लेकिन मुझे अन्य कार्यक्रमों में डेटा की आवश्यकता नहीं होगी, तो मैं shelveमॉड्यूल की दृढ़ता से अनुशंसा करता हूं । इसे लगातार शब्दकोश के रूप में सोचें।

myData = shelve.open('/path/to/file')

# check for values.
keyVar in myData

# set values
myData[anotherKey] = someValue

# save the data for future use.
myData.close()

Comments

यदि आप एक पूरे हुक्म चलाना चाहते हैं, या एक पूरे हुक्म को लोड करना चाहते हैं, jsonतो अधिक सुविधाजनक है। shelveएक समय में एक कुंजी तक पहुँचने के लिए बेहतर है।

— अगफ

Answer 6

यदि आप pickleया के लिए एक विकल्प चाहते हैं json, तो आप उपयोग कर सकते हैं klepto।

>>> init = {'y': 2, 'x': 1, 'z': 3}
>>> import klepto
>>> cache = klepto.archives.file_archive('memo', init, serialized=False)
>>> cache        
{'y': 2, 'x': 1, 'z': 3}
>>>
>>> # dump dictionary to the file 'memo.py'
>>> cache.dump() 
>>> 
>>> # import from 'memo.py'
>>> from memo import memo
>>> print memo
{'y': 2, 'x': 1, 'z': 3}

के साथ klepto, यदि आपने उपयोग किया होता serialized=True, तो शब्दकोश को लिखा जाताmemo.pkl एक मसालेदार शब्दकोश के रूप में के बजाय स्पष्ट पाठ के साथ।

आप kleptoयहाँ प्राप्त कर सकते हैं: https://github.com/uqfoundation/klepto

dillशायद अचार बनाने का एक बेहतर विकल्प pickleहै, खुद के रूप dillमें, अजगर में लगभग कुछ भी धारावाहिक कर सकते हैं। kleptoभी उपयोग कर सकते हैंdill ।

आप dillयहाँ प्राप्त कर सकते हैं: https://github.com/uqfoundation/dill

पहले कुछ लाइनों पर अतिरिक्त मुंबो-जंबो हैं क्योंकि kleptoकिसी फ़ाइल के शब्दकोशों को एक निर्देशिका संदर्भ या SQL डेटाबेस में संग्रहीत करने के लिए कॉन्फ़िगर किया जा सकता है। बैकएंड आर्काइव के रूप में आप जो भी चुनते हैं, एपीआई वही है। यह आपको एक "संग्रहणीय" शब्दकोश प्रदान करता है जिसके साथ आप उपयोग कर सकते हैं loadऔर dumpसंग्रह के साथ बातचीत कर सकते हैं ।

Answer 7

यह एक पुराना विषय है, लेकिन पूर्णता के लिए, हमें configParser और configparser को शामिल करना चाहिए जो क्रमशः पायथन 2 और 3 में मानक पुस्तकालय का हिस्सा हैं। यह मॉड्यूल एक config / ini फ़ाइल को पढ़ता है और लिखता है (और कम से कम पायथन 3 में) एक शब्दकोश की तरह बहुत व्यवहार करता है। इसमें जोड़ा गया लाभ है कि आप अपने डिफॉल्ट / आईएनआई फ़ाइल के अलग-अलग वर्गों में कई शब्दकोशों को स्टोर कर सकते हैं और उन्हें याद कर सकते हैं। मिठाई!

पायथन 2.7.x उदाहरण।

import ConfigParser

config = ConfigParser.ConfigParser()

dict1 = {'key1':'keyinfo', 'key2':'keyinfo2'}
dict2 = {'k1':'hot', 'k2':'cross', 'k3':'buns'}
dict3 = {'x':1, 'y':2, 'z':3}

# make each dictionary a separate section in config
config.add_section('dict1')
for key in dict1.keys():
    config.set('dict1', key, dict1[key])

config.add_section('dict2')
for key in dict2.keys():
    config.set('dict2', key, dict2[key])

config.add_section('dict3')
for key in dict3.keys():
    config.set('dict3', key, dict3[key])

# save config to file
f = open('config.ini', 'w')
config.write(f)
f.close()

# read config from file
config2 = ConfigParser.ConfigParser()
config2.read('config.ini')

dictA = {}
for item in config2.items('dict1'):
    dictA[item[0]] = item[1]

dictB = {}
for item in config2.items('dict2'):
    dictB[item[0]] = item[1]

dictC = {}
for item in config2.items('dict3'):
    dictC[item[0]] = item[1]

print(dictA)
print(dictB)
print(dictC)

अजगर 3.X उदाहरण।

import configparser

config = configparser.ConfigParser()

dict1 = {'key1':'keyinfo', 'key2':'keyinfo2'}
dict2 = {'k1':'hot', 'k2':'cross', 'k3':'buns'}
dict3 = {'x':1, 'y':2, 'z':3}

# make each dictionary a separate section in config
config['dict1'] = dict1
config['dict2'] = dict2
config['dict3'] = dict3

# save config to file
f = open('config.ini', 'w')
config.write(f)
f.close()

# read config from file
config2 = configparser.ConfigParser()
config2.read('config.ini')

# ConfigParser objects are a lot like dictionaries, but if you really
# want a dictionary you can ask it to convert a section to a dictionary
dictA = dict(config2['dict1'] )
dictB = dict(config2['dict2'] )
dictC = dict(config2['dict3'])

print(dictA)
print(dictB)
print(dictC)

कंसोल आउटपुट

{'key2': 'keyinfo2', 'key1': 'keyinfo'}
{'k1': 'hot', 'k2': 'cross', 'k3': 'buns'}
{'z': '3', 'y': '2', 'x': '1'}

config.ini की सामग्री

[dict1]
key2 = keyinfo2
key1 = keyinfo

[dict2]
k1 = hot
k2 = cross
k3 = buns

[dict3]
z = 3
y = 2
x = 1

Answer 8

अगर किसी json फाइल को सेव करें, तो ऐसा करने का सबसे अच्छा और आसान तरीका है:

import json
with open("file.json", "wb") as f:
    f.write(json.dumps(dict).encode("utf-8"))

Comments

json.dump( )अन्य उत्तर में उल्लिखित की तुलना में यह आसान क्यों है ?

— बेक्सक्स

Answer 9

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

किसी फ़ाइल में कई प्रविष्टियों को सहेजने के लिए, किसी को पुरानी सामग्री (यानी लिखने से पहले पढ़ना) की जांच करनी चाहिए। एक ठेठ फ़ाइल पकड़े json डेटा या तो एक होगा listया एक objectरूट के रूप में। इसलिए मैंने माना कि मेरी json फ़ाइल में हमेशा एक list of objectsऔर हर बार जब मैं इसमें डेटा जोड़ता हूं, तो मैं बस सूची को पहले लोड करता हूं, इसमें अपना नया डेटा जोड़ता हूं और इसे वापस फ़ाइल के केवल लिखने योग्य (उदाहरण w) में डंप करता हूं :

def saveJson(url,sc): #this function writes the 2 values to file
    newdata = {'url':url,'sc':sc}
    json_path = "db/file.json"

    old_list= []
    with open(json_path) as myfile:  #read the contents first
        old_list = json.load(myfile)
    old_list.append(newdata)

    with open(json_path,"w") as myfile:  #overwrite the whole content
        json.dump(old_list,myfile,sort_keys=True,indent=4)

    return "sucess"

नई json फ़ाइल कुछ इस तरह दिखाई देगी:

[
    {
        "sc": "a11",
        "url": "www.google.com"
    },
    {
        "sc": "a12",
        "url": "www.google.com"
    },
    {
        "sc": "a13",
        "url": "www.google.com"
    }
]

नोट: यह काम करने के लिए इस दृष्टिकोण के लिए प्रारंभिक डेटा के रूप में नाम के file.jsonसाथ एक फ़ाइल होना आवश्यक है[]

पुनश्च: मूल प्रश्न से संबंधित नहीं है, लेकिन यह दृष्टिकोण पहले जाँच से और भी बेहतर हो सकता है यदि हमारी प्रविष्टि पहले से मौजूद है (1 / एकाधिक कुंजियों के आधार पर) और उसके बाद ही डेटा संलग्न करें और सहेजें। मुझे पता है कि अगर किसी को उस चेक की आवश्यकता है, तो मैं जवाब में जोड़ दूंगा