Die Speicherung von Python-dictionaries

Ich bin verwendet, um die Erhebung von Daten in und aus Python mit .csv-Dateien, aber es gibt offensichtliche Herausforderungen für diese. Jede Beratung über einfache Möglichkeiten zum speichern eines Wörterbuchs (oder Sätze von Wörterbuch) in einem json-oder pck-Datei? Zum Beispiel:

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

Ich würde gerne wissen, wie dieses zu retten, und dann laden Sie es wieder in.

Haben Sie Lesen Sie die Dokumentation json oder Gurke - standard-Module?
Siehe Speichern eines Wörterbuchs in eine Datei (alternative zu Gurke) in Python?

InformationsquelleAutor mike | 2011-08-17

368

Gurke sparen:
```
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)
```
Sehen das pickle-Modul-Dokumentation für weitere Informationen über die protocol argument.

Gurke laden:
```
with open('data.p', 'rb') as fp:
    data = pickle.load(fp)
```
JSON sparen:
```
import json

with open('data.json', 'w') as fp:
    json.dump(data, fp)
```
Liefern zusätzliche Argumente wie sort_keys oder indent um ein hübsches Ergebnis. Das argument sort_keys Sortieren die Tasten alphabetisch und Einzug wird Rücken deine Daten-Struktur mit indent=N Räume.
```
json.dump(data, fp, sort_keys=True, indent=4)
```
JSON laden:
```
with open('data.json', 'r') as fp:
    data = json.load(fp)
```
- JSON erlaubt Wörterbücher nativ (obwohl Sie ganz offensichtlich nicht Verhalten sich genau so, wie ein python-dictionary ist, während im Speicher, die für die Persistenz Zwecke, Sie sind identisch). In der Tat, die grundlegende Einheit in json ist das "Objekt", die definiert ist als { <string> : <Wert>}. Schauen Sie vertraut? Das json-Modul in der standard-Bibliothek unterstützt alle Python-native-Typ, und kann einfach erweitert werden, mit minimalen Kenntnissen von json-Unterstützung benutzerdefinierte Klassen. Der JSON-homepage ganz bestimmt die Sprache, in etwas mehr als 3 Druckseiten, so ist es leicht zu absorbieren/schnell verdauen.
- Es lohnt sich zu wissen, über das Dritte argument pickle.dump auch. Wenn Sie die Datei nicht brauchen, um menschlich-lesbare dann es kann die Dinge beschleunigen eine Menge.
- Scheint, wie dieses funktioniert nicht out-of-the-box mit 3.x. Das Teil muss gegossen werden?
- Wieso benutzen Sie den binary-Modus für die JSON-Dateien hier? JSON ist ein text-format.
- Die json Bibliothek erzeugt text - (Typ str) Daten, also die Dateien sollten nicht geöffnet werden im Binär-Modus.
- und Dror: ich bin mir ziemlich sicher, dass war eine schlecht ausgeführte kopieren und einfügen. Feste in der jüngsten Bearbeiten, danke für den Hinweis auf das problem.
- Wenn Sie fügen Sie sort_keys und Einzug Argumente, um die dump-Aufruf erhalten Sie einen viel schöneren Ergebnis. z.B.: json.dump(data, fp, sort_keys=True, indent=4). Mehr Infos finden Sie hier
- Sie sollten wahrscheinlich verwenden Sie pickle.dump(data, fp, protocol=pickle.HIGHEST_PROTOCOL)
- Gibt es irgendeinen Vorteil bei der Verwendung von pickle vs json? json ist eine lesbare Datei anstelle von einem byte-stream, Größe der resultierenden Datei, etc?
- Json funktioniert nicht mit dict, die Tupel als Schlüssel { (1,2): "abc" }, aber Sie sind lesbar durch den Menschen. Gurke sparen dicts, die Tupel als Schlüssel, aber Sie sind nicht so readble von den Menschen als Json.
- Für python 3 verwenden Sie import pickle
- Ist es nur mich oder ist das speichern von json-sehr langsam? Versuchen, zu speichern ca 100mb json.
InformationsquelleAutor Marty

Minimal-Beispiel, das direkte schreiben in eine Datei:

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

oder sicher öffnen /schließen:

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

Wenn Sie möchten, speichern Sie es in eine Zeichenfolge anstelle einer Datei:

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

InformationsquelleAutor agf

7

Siehe auch speeded-up-Paket ujson.
https://pypi.python.org/pypi/ujson
```
import ujson
with open('data.json', 'wb') as fp:
    ujson.dump(data, fp)
```
InformationsquelleAutor Elliott
5

In eine Datei schreiben:
```
import json
myfile.write(json.dumps(mydict))
```
Aus einer Datei zu Lesen:
```
import json
mydict = json.loads(myfile.read())
```
myfile ist das file-Objekt für die Datei, die Sie gespeichert, die in dict.
- Sie sind ware, dass json ist, dass die Dateien als Argumente und schreiben Sie direkt an Sie?
- json.dump(myfile) und json.load(myfile)
InformationsquelleAutor Rafe Kettler
5

Wenn Sie nach der Serialisierung aber nicht brauchen, die Daten in andere Programme, die ich dringend empfehlen, die shelve Modul. Betrachten Sie es als ein persistentes Wörterbuch.
```
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()
```
- Wenn Sie speichern möchten, eine ganze dict, oder laden Sie eine ganze dict, json bequemer ist. shelve ist nur besser für den Zugriff auf einen Schlüssel gleichzeitig.
InformationsquelleAutor g.d.d.c
3

Wenn Sie möchten, eine alternative zu pickle oder json verwenden, können Sie 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}
```
Mit klepto, wenn Sie verwendet hatte serialized=True, würde das Wörterbuch geschrieben worden zu memo.pkl als eine eingelegte Wörterbuch statt mit klaren text.

Erhalten Sie klepto hier: https://github.com/uqfoundation/klepto

dill ist wahrscheinlich eine bessere Wahl für Beizen dann pickle selbst, als dill serialisieren können fast alles in python. klepto auch verwenden kann dill.

Erhalten Sie dill hier: https://github.com/uqfoundation/dill

Zusätzliche mumbo-jumbo auf die ersten paar Zeilen sind, weil klepto werden kann, konfiguriert zum speichern von Wörterbüchern, um eine Datei, ein directory-Kontext oder in einer SQL-Datenbank. Die API ist die gleiche, für was auch immer Sie wählen Sie als backend-Archiv. Es gibt Ihnen eine "archivierbare" Wörterbuch mit, die Sie verwenden können load und dump Interaktion mit dem Archiv.

InformationsquelleAutor Mike McKerns

Dies ist ein altes Thema, aber der Vollständigkeit halber, sollten wir auch ConfigParser und configparser, die Teil der standard-Bibliothek von Python 2 und 3, beziehungsweise. Dieses Modul liest und schreibt eine config - /ini-Datei und (zumindest in Python 3) verhält sich in vielerlei Hinsicht wie ein Wörterbuch. Es hat den zusätzlichen Vorteil, dass Sie speichern können mehrere Wörterbücher in separate Abschnitte der config - /ini-Datei und rufen Sie ab. Süß!

Python 2.7.x Beispiel.

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)

Python 3.X Beispiel.

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)

Ausgabe der Konsole

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

Inhalt der config.ini

[dict1]
key2 = keyinfo2
key1 = keyinfo

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

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

InformationsquelleAutor bfris

0

Wenn Sie speichern, um eine json-Datei, die beste und einfachste Weg, dies zu tun ist:
```
import json
with open("file.json", "wb") as f:
    f.write(json.dumps(dict).encode("utf-8"))
```
InformationsquelleAutor Adam Liu

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.