Hoe sla je een woordenboek op in een bestand?

Ik heb problemen met het wijzigen van een dictaatwaarde en het opslaan van het dictaat in een tekstbestand (het formaat moet hetzelfde zijn), ik wil alleen het veld member_phonewijzigen.

Mijn tekstbestand heeft de volgende indeling:

memberID:member_name:member_email:member_phone

en ik splitste het tekstbestand met:

mdict={}
for line in file:
    x=line.split(':')
    a=x[0]
    b=x[1]
    c=x[2]
    d=x[3]
    e=b+':'+c+':'+d
    mdict[a]=e

Als ik probeer de member_phoneopgeslagen in dte wijzigen, is de waarde niet veranderd door de sleutel,

def change(mdict,b,c,d,e):
    a=input('ID')
    if a in mdict:
        d= str(input('phone'))
        mdict[a]=b+':'+c+':'+d
    else:
        print('not')

en hoe sla je het dictaat op in een tekstbestand met hetzelfde formaat?

Antwoord 1, autoriteit 100%

Python heeft speciaal voor dit soort dingen de module augurk.

Deze functies zijn alles wat je nodig hebt om bijna elk object op te slaan en te laden:

def save_obj(obj, name ):
    with open('obj/'+ name + '.pkl', 'wb') as f:
        pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)
def load_obj(name ):
    with open('obj/' + name + '.pkl', 'rb') as f:
        return pickle.load(f)

Deze functies gaan ervan uit dat je een map objin je huidige werkmap hebt, die zal worden gebruikt om de objecten op te slaan.

Merk op dat pickle.HIGHEST_PROTOCOLeen binair formaat is, wat niet altijd handig kan zijn, maar goed is voor de prestaties. Protocol 0is een tekstformaat.

Om collecties van Python op te slaan is er de shelve-module.

Antwoord 2, autoriteit 64%

Pickle is waarschijnlijk de beste optie, maar voor het geval iemand zich afvraagt hoe een woordenboek met NumPy kan worden opgeslagen en in een bestand kan worden geladen:

import numpy as np
# Save
dictionary = {'hello':'world'}
np.save('my_file.npy', dictionary) 
# Load
read_dictionary = np.load('my_file.npy',allow_pickle='TRUE').item()
print(read_dictionary['hello']) # displays "world"

Ter info: NPY-bestandsviewer

Antwoord 3, autoriteit 16%

We kunnen ook de json-modulegebruiken in het geval dat woordenboeken of andere gegevens eenvoudig kunnen worden toegewezen aan JSON-indeling.

import json
# Serialize data into file:
json.dump( data, open( "file_name.json", 'w' ) )
# Read data from file:
data = json.load( open( "file_name.json" ) )

Deze oplossing biedt veel voordelen, bijvoorbeeld werkt voor Python 2.xen Python 3.xin ongewijzigde vormen bovendien kunnen gegevens die zijn opgeslagen in JSON-indeling gemakkelijk worden overgedragen tussen veel verschillende platforms of programma’s. Deze gegevens zijn ook door mensen leesbaar.

Antwoord 4, autoriteit 7%

Ik weet niet zeker wat uw eerste vraag is, maar als u een woordenboek in een bestand wilt opslaan, moet u de json-bibliotheek gebruiken. Zoek de documentatie van de load- en puts-functies op.

Antwoord 5, autoriteit 5%

Opslaan en dictaat in bestand laden:

def save_dict_to_file(dic):
    f = open('dict.txt','w')
    f.write(str(dic))
    f.close()
def load_dict_from_file():
    f = open('dict.txt','r')
    data=f.read()
    f.close()
    return eval(data)

Antwoord 6, autoriteit 4%

Ik zou willen voorstellen om uw gegevens op te slaan in het JSON-formaat in plaats van het augurk-formaat, aangezien de bestanden van JSON door mensen leesbaar zijn, wat het opsporen van fouten gemakkelijker maakt omdat uw gegevens klein zijn. JSON-bestanden worden ook door andere programma’s gebruikt om gegevens te lezen en te schrijven. Je kunt er hier

meer over lezen

Je moet de JSON-module installeren, je kunt dit doen met pip:

pip install json
# To save the dictionary into a file:
json.dump( data, open( "myfile.json", 'w' ) )

Hiermee wordt een json-bestand gemaakt met de naam mijnbestand.

# To read data from file:
data = json.load( open( "myfile.json" ) )

Hiermee worden de myfile.json-gegevens in een gegevensobject gelezen en opgeslagen.

Antwoord 7, autoriteit 3%

Omdat Pickle wat beveiligingsproblemen heeft en traag is (bron), zou ik voor JSON gaan, omdat het snel is , ingebouwd, door mensen leesbaar en uitwisselbaar:

import json
data = {'another_dict': {'a': 0, 'b': 1}, 'a_list': [0, 1, 2, 3]}
# e.g. file = './data.json' 
with open(file, 'w') as f: 
    json.dump(data, f)

Lezen is vergelijkbaar eenvoudig:

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

Dit is vergelijkbaar met dit antwoord, maar implementeert de bestandsverwerking correct.

Antwoord 8

Voor een woordenboek van strings zoals degene waarmee je te maken hebt, zou dit kunnen worden gedaan met alleen de ingebouwde tekstverwerkingsmogelijkheden van Python.

(Let op: dit zou niet werken als de waarden iets anders zijn.)

with open('members.txt') as file:
    mdict={}
    for line in file:
        a, b, c, d = line.strip().split(':')
        mdict[a] = b + ':' + c + ':' + d
a = input('ID: ')
if a not in mdict:
    print('ID {} not found'.format(a))
else:
    b, c, d = mdict[a].split(':')
    d = input('phone: ')
    mdict[a] = b + ':' + c + ':' + d  # update entry
    with open('members.txt', 'w') as file:  # rewrite file
        for id, values in mdict.items():
            file.write(':'.join([id] + values.split(':')) + '\n')

Antwoord 9

Tenzij je het woordenboek echt wilt behouden, denk ik dat de beste oplossing is om de csvPython-module te gebruiken om het bestand te lezen.
Dan krijg je rijen met gegevens en kun je member_phoneof wat je maar wilt veranderen;
ten slotte kunt u de module csvopnieuw gebruiken om het bestand in hetzelfde formaat op te slaan
zoals je het opende.

Code om te lezen:

import csv
with open("my_input_file.txt", "r") as f:
   reader = csv.reader(f, delimiter=":")
   lines = list(reader)

Code om te schrijven:

with open("my_output_file.txt", "w") as f:
   writer = csv.writer(f, delimiter=":")
   writer.writerows(lines)

Natuurlijk moet je je change()-functie aanpassen:

def change(lines):
    a = input('ID')
    for line in lines:
      if line[0] == a:
        d=str(input("phone"))
        line[3]=d
        break
    else:
      print "not"

Antwoord 10

Ik heb het niet getimed, maar ik wed dat h5 sneller is dan augurk; de bestandsgrootte met compressie is vrijwel zeker kleiner.

import deepdish as dd
dd.io.save(filename, {'dict1': dict1, 'dict2': dict2}, compression=('blosc', 9))

Antwoord 11

file_name = open("data.json", "w")
json.dump(test_response, file_name)
file_name.close()

of gebruik contextmanager, wat beter is:

with open("data.json", "w") as file_name:
    json.dump(test_response, file_name)

Antwoord 12

Ik gebruik graag de mooie printmodule om het dictaat in een zeer gebruiksvriendelijke leesbare vorm op te slaan:

def store_dict(fname, dic):
    with open(fname, "w") as f:
        f.write(pprint.pformat(dic, indent=4, sort_dicts=False))
        # note some of the defaults are: indent=1, sort_dicts=True

Lees vervolgens tijdens het herstellen het tekstbestand en eval()het in om de string terug in een dictaat te veranderen:

def load_file(fname):
    try:
        with open(fname, "r") as f:
            dic = eval(f.read())
    except:
        dic = {}
    return dic