La sauvegarde d'un Objet (la persistance des Données)

Vous pouvez utiliser le pickle module de la bibliothèque standard.
Voici un élémentaire d'application à votre exemple:

import pickle

class Company(object):
    def __init__(self, name, value):
        self.name = name
        self.value = value

with open('company_data.pkl', 'wb') as output:
    company1 = Company('banana', 40)
    pickle.dump(company1, output, pickle.HIGHEST_PROTOCOL)

    company2 = Company('spam', 42)
    pickle.dump(company2, output, pickle.HIGHEST_PROTOCOL)

del company1
del company2

with open('company_data.pkl', 'rb') as input:
    company1 = pickle.load(input)
    print(company1.name)  # -> banana
    print(company1.value)  # -> 40

    company2 = pickle.load(input)
    print(company2.name) # -> spam
    print(company2.value)  # -> 42

Vous pouvez également définir votre propre utilitaire simple comme la suivante, qui ouvre un fichier et écrit un seul objet:

def save_object(obj, filename):
    with open(filename, 'wb') as output:  # Overwrites any existing file.
        pickle.dump(obj, output, pickle.HIGHEST_PROTOCOL)

# sample usage
save_object(company1, 'company1.pkl')

Mise à jour:

Puisque c'est une réponse, j'aimerais toucher un peu légèrement utilisation avancée des sujets.

cPickle (ou _pickle) vs pickle

Il est presque toujours préférable d'utiliser effectivement le cPickle module plutôt que pickle parce que le premier est écrit en C et est beaucoup plus rapide. Il ya quelques différences subtiles entre eux, mais dans la plupart des cas elles sont équivalentes et la C version grandement les performances supérieures. Commutation de il ne pouvait pas être plus facile, il suffit de changer le import texte de la déclaration:

import cPickle as pickle

En Python 3, cPickle a été renommé _pickle, mais cela n'est plus nécessaire puisque la pickle module maintenant c'est fait automatiquement—voir Quelle est la différence entre un cornichon et _pickle en python 3?.

La réduction est vous pouvez utiliser quelque chose comme ce qui suit pour vous assurer que votre code toujours utiliser la version C quand il est disponible en Python 2 et 3:

try:
    import cPickle as pickle
except ModuleNotFoundError:
    import pickle

Flux de données formats (protocoles)

pickle peut lire et écrire des fichiers dans plusieurs différentes, Python-spécifiques, les formats, appelé protocoles comme décrit dans la la documentation, "Protocole de la version 0" est l'ASCII et donc "lisible". Les Versions > 1 sont binaires et le plus élevé disponible dépend de la version de Python est utilisé. La valeur par défaut dépend aussi de la version de Python. En Python 2 la valeur par défaut est la version du Protocole 0, mais en Python 3.7, c'est la version du Protocole 3. En Python 3.x le module a un pickle.DEFAULT_PROTOCOL ajouté à cela, mais qui n'existe pas en Python 2.

Heureusement, il y a un raccourci pour l'écriture pickle.HIGHEST_PROTOCOL lors de chaque appel (en supposant que c'est ce que vous voulez, et vous le faites habituellement), il suffit d'utiliser le nombre littéral -1 — similaire à référencer le dernier élément d'une séquence par l'intermédiaire d'un indice négatif.
Donc, au lieu d'écrire:

pickle.dump(obj, output, pickle.HIGHEST_PROTOCOL)

Vous pouvez simplement écrire:

pickle.dump(obj, output, -1)

De toute façon, il vous suffit de spécifier le protocole une fois, si vous avez créé un Pickler objet pour une utilisation dans de multiples pickle opérations:

pickler = pickle.Pickler(output, -1)
pickler.dump(obj1)
pickler.dump(obj2)
   etc...

Note: Si vous êtes dans un environnement qui exécutent différentes versions de Python, alors vous aurez probablement envie d'utiliser de manière explicite (c'est à dire coder en dur) un numéro de protocole que tous peuvent lire (les versions ultérieures peuvent généralement lire les fichiers produits par les précédents).

Plusieurs Objets

Tout un cornichon fichier peut contenir n'importe quel nombre de marinés objets, comme indiqué dans les échantillons ci-dessus, quand il y a un nombre inconnu d'entre eux, il est souvent plus facile de stocker toutes dans une sorte de variable contenant de la taille, comme un list, tuple, ou dict et les écrire dans le fichier en un seul appel:

tech_companies = [
    Company('Apple', 114.18), Company('Google', 908.60), Company('Microsoft', 69.18)
]
save_object(tech_companies, 'tech_companies.pkl')

et de restauration de la liste et tout de suite:

with open('tech_companies.pkl', 'rb') as input:
    tech_companies = pickle.load(input)

L'avantage majeur est que vous n'avez pas besoin de savoir combien d'instances de l'objet sont enregistrés dans l'ordre de charger les reprendre plus tard (bien que de le faire sans que les informations est possible, elle nécessite un petit peu de code spécialisé). Voir les réponses à la question relative à la Sauvegarde et chargement de plusieurs objets dans la saumure fichier? pour plus de détails sur les différentes façons de le faire. Personnellement je comme @Lutz Prechelt de réponse le meilleur. Ici, il est adapté pour les exemples ici:

class Company:
    def __init__(self, name, value):
        self.name = name
        self.value = value

def pickled_items(filename):
    """ Unpickle a file of pickled data. """
    with open(filename, "rb") as f:
        while True:
            try:
                yield pickle.load(f)
            except EOFError:
                break

print('Companies in pickle file:')
for company in pickled_items('company_data.pkl'):
    print('  name: {}, value: {}'.format(company.name, company.value))

Vous pouvez utiliser anycache pour faire le travail pour vous. Elle tient compte de tous les détails:

• Il utilise l'aneth comme backend,
  qui s'étend le python pickle module pour gérer lambda et toutes les belles
  python dispose d'.
• Il stocke des objets différents à différents fichiers et la recharge correctement.
• Les limites de taille de cache
• Permet de supprimer le cache
• Permet d'échanger des objets entre plusieurs pistes
• Permet à l'égard de fichiers d'entrée qui influence le résultat

En supposant que vous avez une fonction myfunc qui crée l'instance:

from anycache import anycache

class Company(object):
    def __init__(self, name, value):
        self.name = name
        self.value = value

@anycache(cachedir='/path/to/your/cache')    
def myfunc(name, value)
    return Company(name, value)

Anycache appels myfunc à la première fois et les cornichons le résultat d'une
fichier dans cachedir à l'aide d'un identifiant unique (selon le nom de la fonction et ses arguments) comme nom de fichier.
Sur une période consécutive de s'exécuter, le marinés objet est chargé.
Si le cachedir est conservé entre python exécute, le marinés objet est pris à partir de la précédente python exécuter.

Pour plus de détails voir le la documentation