Estoy acostumbrado a llevar los datos en Python usando .archivos csv, pero hay evidencia de que los retos para este. Cualquier consejo sobre las maneras simples para almacenar un diccionario (o conjuntos de diccionarios) en un json o pck archivo? Por ejemplo:

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

Me gustaría saber cómo guardar y, a continuación, cómo cargar de nuevo.

InformationsquelleAutor mike | 2011-08-17

8 Comentarios

  1. 359

    Pickle guardar:

    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)

    Ver la documentación del módulo pickle para obtener información adicional acerca de la protocol argumento.

    Pickle de carga:

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

    JSON guardar:

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

    Suministro de argumentos adicionales como sort_keys o indent para conseguir un resultado bonito. El argumento sort_keys ordenará las teclas en orden alfabético y guión se guión de su estructura de datos con indent=N espacios.

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

    JSON de carga:

    with open('data.json', 'r') as fp:
        data = json.load(fp)
    • JSON ¿diccionarios de forma nativa (a pesar de que, obviamente, no se comportan exactamente como un diccionario de python que hace tiempo en la memoria, por la persistencia de los efectos, son idénticos). De hecho, la unidad fundamental en json es el «Objeto», que se define como { <cadena> : <valor>}. Familiar de la mirada? El json módulo en la biblioteca estándar es compatible con todos los Python tipo nativo y puede ser fácilmente ampliado con un mínimo de conocimientos de json para apoyar definido por el usuario de clases. JSON página de inicio completamente define el idioma en poco más de 3 páginas impresas, por lo que es fácil de absorber/digieren rápidamente.
    • Vale la pena saber sobre el tercer argumento para pickle.dump, demasiado. Si el archivo no debe ser legible, a continuación, puede acelerar las cosas un montón.
    • Parece que esto no funciona-de-la-caja con 3.x. Qué parte tiene que ser enyesado?
    • ¿Por qué estás usando el modo binario para el JSON archivos aquí? JSON es un formato de texto.
    • El json biblioteca produce un texto (tipo de str) de datos, por lo que los archivos no debe ser abierto en modo binario.
    • y Dror: estoy bastante seguro de que era un mal ejecutados copiar y pegar. Fijo en la más reciente edición, gracias por señalar el problema.
    • Si agrega sort_keys y guión de argumentos para el volcado de llamar conseguir un mucho mejor resultado. por ejemplo: json.dump(data, fp, sort_keys=True, indent=4). Puede encontrarse más información en aquí
    • Usted probablemente tendrá que usar pickle.dump(data, fp, protocol=pickle.HIGHEST_PROTOCOL)
    • Hay alguna ventaja de la utilización de pickle vs json? json es un archivo legible en lugar de una secuencia de bytes; tamaño de archivo resultante, etc?
    • Json no funciona con dict que han tuplas como llaves { (1,2): «abc» }, pero que son legibles por las personas. Pickle ahorrará dicts que han tuplas como llaves, pero no son tan readble por gente como Json.
    • Para python 3, uso import pickle

  2. 31

    Ejemplo mínimo, escrito directamente a un archivo:

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

    o seguridad de apertura /cierre:

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

    Si quieres guardarlo en una cadena en lugar de un archivo:

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

    Para escribir a un archivo:

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

    Leer desde un archivo:

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

    myfile es el objeto de archivo para el archivo que almacena el dict en.

    • usted es la vajilla que json tiene que tomar los archivos como argumentos y escribir directamente a ellos?
    • json.dump(myfile) y json.load(myfile)
  4. 5

    Si usted está después de la serialización, pero no necesita los datos en otros programas recomiendo la shelve módulo. Piense en ello como un persistente diccionario.

    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()
    • Si desea almacenar un conjunto dict, o cargar un conjunto dict, json es más conveniente. shelve sólo es mejor para acceder a una tecla a la vez.
  5. 3

    Si quieres una alternativa a pickle o json, puede utilizar 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}

    Con klepto, si hubiera utilizado serialized=True, el diccionario habría sido escrito para memo.pkl como un escabeche diccionario en lugar de con texto claro.

    Usted puede conseguir klepto aquí: https://github.com/uqfoundation/klepto

    dill es probablemente una mejor opción para el decapado, a continuación, pickle sí mismo, como dill puede serializar casi nada en python. klepto también puede utilizar dill.

    Usted puede conseguir dill aquí: https://github.com/uqfoundation/dill

    El adicional de pacotilla en las primeras líneas son porque klepto puede ser configurada para almacenar los diccionarios a un archivo, un directorio de contexto, o a una base de datos SQL. El API es el mismo para todo lo que usted elija como el servidor de archivado. Se le da una «archivable» diccionario con el que se puede utilizar load y dump para interactuar con el archivo.

  6. 2

    Este es un viejo tema, pero para la integridad, debemos incluir ConfigParser y configparser que son parte de la biblioteca estándar de Python 2 y 3, respectivamente. En este módulo se lee y se escribe en un archivo de configuración config/archivo ini y (al menos en Python 3) se comporta en muchas formas, como un diccionario. Tiene la ventaja añadida de que puede almacenar varios diccionarios en secciones separadas de su config/archivo ini y recordar. Dulce!

    Python 2.7.x ejemplo.

    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 ejemplo.

    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)

    salida de la consola

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

    contenido de config.ini

    [dict1]
    key2 = keyinfo2
    key1 = keyinfo
    
    [dict2]
    k1 = hot
    k2 = cross
    k3 = buns
    
    [dict3]
    z = 3
    y = 2
    x = 1
  7. 0

    Si guardar un archivo json, el mejor y más fácil manera de hacer esto es:

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

Dejar respuesta

Please enter your comment!
Please enter your name here