Mappage d'objets de style de dictionnaire Python3 vers sérialisable JSON

Question

Je travaille sur un système d'employé simple pour apprendre la programmation orientée objet en Python3. Mon script fonctionne comme prévu, à l'exception de l'enregistrement et du chargement du dictionnaire de l'employé. Le problème est mon dictionnaire n'est pas un dictionnaire normal cause de ce code: Employees[eid] = Employee(eName,eSalary,eAge) Je veux faire de cette base de données JSON Serializeable mais je n'ai aucune idée ni je l'ai trouvé sur internet.

Malheureusement le code ajoutant système débordement de pile m'a donné le cancer donc je collais mon code essentiel: https://gist.github.com/ShockvaWe/d82d89f767506c1ff682a4cc387d1597

Et mon message d'erreur avec le code actuel est (son TypeEroor de base, mais ...): Désolé, mais Je gaspille mes 2 heures en essayant de coller mon code et j'échoue donc je me fâche. Merci pour l'édition et les réponses.

Voici le code:

## -*- coding=<utf-8> -*- 
import json 
from json import JSONEncoder 
Employees = {} 
print(type(Employees)) 
class Employee(object): 
    'Common base for all employes' 
    empCount = 0 
    def __init__(self,name,salary,age): 
     self.name = name 
     self.salary = salary 
     self.age = age 
     Employee.empCount += 1 

    def displayCount(self): 
     print ("Total Employee : " , Employee.empCount , "\n") 

    def displayEmployee(self): 
     print("Name : ", self.name ," Salary : " , self.salary ," Age : " , self.age, "\n") 
print ("NEVER FORGET TO SAVE YOUR CHANGES ! \n") 
print ("Press s to save your work ! \n") 
print ("Press l to load database. \n") 
print ("Press x for adding employee \n") 
print ("Press y for show employee count \n") 
print ("Press z for display employee \n") 
print ("Press q for quitting. \n") 
while True : 
    st = input("->> : ") 
    if (st == "x"): 
     eid = input ("Id : ") 
     eName = input ("\nName : ") 
     eSalary = input ("\nSalary : ") 
     eAge = input ("\nAge : \n") 
     Employees[eid] = Employee(eName,eSalary,eAge) 
    if (st == "y"): 
     print("Total Employee Count : " , Employee.empCount) 
    if (st == "z"): 
     wantedId = input("Give the id : ") 
     Employees[wantedId].displayEmployee() 
    if (st == "q"): 
     exit() 
    if (st == "s"): 
     with open('myfile.json','w') as f: 
      json.dump(dict(Employees),f) 
    if (st == "l"): 
     with open('myfile.json') as f: 
      Employees = json.load(f) 
    if (st == 'f'): 
     print("roger dodger") 

Answer 1

Voici un petit exemple qui reproduit probablement le TypeError que vous voyez:

class Foo(object): 
    def __init__(self, arg): 
    self.arg = arg 

d = {'key1': Foo('some arg')} 
import json 

print json.dumps(d) 

De par leur nature, les instances Python class ne sont pas sérialisables. En supposant que vous souhaitez que les données au sein de la classe, une option serait d'utiliser le dictionnaire par exemple au lieu de l'objet de classe:

class Foo(object): 
    def __init__(self, arg): 
    self.arg = arg 

f = Foo('some arg') 
d = {'key1': f.__dict__} 
import json 

print json.dumps(d) 

Résultat:

{"key1": {"arg": "some arg"}} 

Pour désérialiser, vous pouvez utiliser une séquence dans votre DB et obtenir ce pour construire de nouveaux objets du personnel, et de garder trace de cela dans votre JSON lorsque « reconstituant » eux plus tard:

import json 

class Employee(object): 
    def __init__(self, arg, emp_id=None): 
    self.emp_id = emp_id or self.get_id() 
    self.arg = arg 

    def get_id(self): 
    """ 
    This example assumes you have a db query module and some kind of Sequence 
    definition that looks like this (I am using postgres here) : 

     Sequence "your_app.employee_id_seq" 
     Column  | Type |   Value   
    ---------------+---------+-------------------------- 
    sequence_name | name | employee_id_seq 
    last_value | bigint | 1204 
    start_value | bigint | 1 
    increment_by | bigint | 1 
    max_value  | bigint | 9223372036854775807 
    min_value  | bigint | 1 
    cache_value | bigint | 1 
    log_cnt  | bigint | 31 
    is_cycled  | boolean | f 
    is_called  | boolean | t 
    """ 
    return your_db_module.query("SELECT nextval('employee_id_seq'::regclass)") 

A test:

f = Employee('some arg') 
d = {f.emp_id: f.__dict__} 
# We could add as many employees as we like to serialized, but I am just using one here: 
serialized = json.dumps(d) 
deserialized_employees = json.loads(serialized) 
print deserialized_employees 
employee_objects = [] 
for k, v in deserialized_employees.items(): 
    # assert int(k) == int(v['emp_id']) - a check if you want to be paranoid 
    # Now that we have an ID, we can use the kwarg for emp_id to construct the right object 
    e = Employee(v['arg'], emp_id=int(k)) 
    employee_objects.append(e) 

print employee_objects[0] 

Résultat:

<__main__.Employee object at 0x10dca6b50> 

Notez que vous devrez peut-être définir sur mesure __cmp__ et/ou __eq__ méthodes afin de permettre à votre unique, emp_id être la caractéristique d'un employé unique, car à ce courant état, nous sommes techniquement autorisés à créer de nombreuses instances du même employé en utilisant un seul ID (généralement une mauvaise chose.) Je ne sais pas si cela va entrer en jeu pour votre cas, mais il vaut la peine d'envisager.