如何让 json.dumps 将我的 class 视为字典？

Question

I would like to create a custom Python class that JSON-serializes like a dict. Taking Python's duck-typing at its name, I thought I could create a class that looks and quacks exactly like a dict. However, the class shown below is apparently not dict-like enough for json.dumps -- the code below produces the error TypeError: Object of type TotallyADict is not JSON serializable . What can I change about TotallyADict so that the default encoder for json.dumps will output {"a": 1, "b": 2, "c": 3} ?

I know this immediate issue can be resolved by creating a custom encoder, but that is not an acceptable solution in the larger issue this specific problem has been distilled from.

Another attempted solution is to have TotallyADict inherit from dict rather than MutableMapping. This does not throw any exceptions, but in that case json.dumps(x) yields {} ; apparently the data source the default encoder for json.dumps uses for dicts is not any of the overridden methods below.

What I want here is to able to use attribute semantics ( x.c = xa + xb ) but still serialize into a JSON object. So, a possible suggestion that does not seem to work is TypedDict (would have to be x['c'] = x['a'] + x['b'] ). Intercepting attribute assignment and retrievals via __setattr__ and __getattribute__ and redirecting to entries self which inherits from dict seems to work well enough, so that's my default solution. But I'm surprised that the one time I actually want to use duck-typing rather than strict(ish) typing, it doesn't seem to work.

from collections.abc import MutableMapping
import json


class TotallyADict(MutableMapping):
  def __init__(self, a, b, c):
    self.a = a
    self.b = b
    self.c = c
    self._fields = {'a', 'b', 'c'}

  def __getitem__(self, key):
    if key in self._fields:
      return getattr(self, key)
    else:
      raise KeyError('"{}" is not a field in {}'.format(key, type(self).__name__))

  def __setitem__(self, key, value):
    if key in self._fields:
      setattr(self, key, value)
    else:
      raise KeyError('"{}" is not a field in {}'.format(key, type(self).__name__))

  def __delitem__(self, key):
    raise RuntimeError('Cannot delete fields from {}'.format(type(self).__name__))

  def __iter__(self):
    return iter(self._fields)

  def __len__(self):
    return len(self._fields)

  def __contains__(self, k):
    return k in self._fields

  def copy(self):
    return type(self)(**{k: getattr(self, k) for k in self._fields})

  def __repr__(self):
    return '{' + ', '.join('"{}": {}'.format(k, repr(getattr(self, k))) for k in self._fields) + '}'

  def get(self, key, default=None):
    if key in self._fields:
      value = getattr(self, key)
      if value is None:
        value = default
      return value
    else:
      raise KeyError('"{}" is not a field in {}'.format(key, type(self).__name__))

  def setdefault(self, key, default=None):
    if key in self._fields:
      value = getattr(self, key)
      if value is None:
        value = default
        setattr(self, key, value)
      return value
    else:
      raise KeyError('"{}" is not a field in {}'.format(key, type(self).__name__))

  def pop(self, key, value=None):
    raise RuntimeError('Cannot delete fields from {}'.format(type(self).__name__))

  def keys(self):
    return self._fields

  def items(self):
    return [(k, getattr(self, k)) for k in self._fields]

  def values(self):
    return [getattr(self, k) for k in self._fields]

  def __eq__(self, other):
    if type(self) is type(other):
      for k in self._fields:
        if getattr(self, k) != getattr(other, k):
          return False
      return True
    else:
      return False

  def __ne__(self, other):
    return not self.__eq__(other)


x = TotallyADict(1, 2, 3)
print(json.dumps(x))

Answer 1

In some instances, the easiest solution is the best one. In this case, create a to_dict() function that returns the data inside your custom class as a Python dictionary before json dumping it.

This way, you can manipulate the data within your class at your leisure, and convert it to a dictionary when other libraries expect a dictionary. Then if you need the opposite, just write another function that parses dict into your custom class.

Since this class is intended to hold data, I recommend using DataClasses .

Then you can just add this function to your class to get its attributes as a dict:

from dataclasses import dataclass, asdict

def get_as_dict(self):
        return {k: v for k, v in asdict(self).items() if self._dataclass_fields_[k].repr}

Answer 2

The issue here is your _fields variable. This wont serialize to a JSON object as {'c', 'b', 'a'} is not valid json. If you look at the x.__dict__ property you can see what this object will be represented as.

{'a': 1, 'b': 2, 'c': 3, '_fields': {'c', 'b', 'a'}}

If you change _fields to a list you could also use the default parameter in JSON.dumps

These are the changes I made to get what you are looking for to work

self._fields = ['a', 'b', 'c']
print(json.dumps(x, default=vars))

Here is the full code with my canges.

from collections.abc import MutableMapping
import json


class TotallyADict(MutableMapping):
  def __init__(self, a, b, c):
    self.a = a
    self.b = b
    self.c = c
    self._fields = ['a', 'b', 'c']

  def __getitem__(self, key):
    if key in self._fields:
      return getattr(self, key)
    else:
      raise KeyError('"{}" is not a field in {}'.format(key, type(self).__name__))

  def __setitem__(self, key, value):
    if key in self._fields:
      setattr(self, key, value)
    else:
      raise KeyError('"{}" is not a field in {}'.format(key, type(self).__name__))

  def __delitem__(self, key):
    raise RuntimeError('Cannot delete fields from {}'.format(type(self).__name__))

  def __iter__(self):
    return iter(self._fields)

  def __len__(self):
    return len(self._fields)

  def __contains__(self, k):
    return k in self._fields

  def copy(self):
    return type(self)(**{k: getattr(self, k) for k in self._fields})

  def __repr__(self):
    return '{' + ', '.join('"{}": {}'.format(k, repr(getattr(self, k))) for k in self._fields) + '}'

  def get(self, key, default=None):
    if key in self._fields:
      value = getattr(self, key)
      if value is None:
        value = default
      return value
    else:
      raise KeyError('"{}" is not a field in {}'.format(key, type(self).__name__))

  def setdefault(self, key, default=None):
    if key in self._fields:
      value = getattr(self, key)
      if value is None:
        value = default
        setattr(self, key, value)
      return value
    else:
      raise KeyError('"{}" is not a field in {}'.format(key, type(self).__name__))

  def pop(self, key, value=None):
    raise RuntimeError('Cannot delete fields from {}'.format(type(self).__name__))

  def keys(self):
    return self._fields

  def items(self):
    return [(k, getattr(self, k)) for k in self._fields]

  def values(self):
    return [getattr(self, k) for k in self._fields]

  def __eq__(self, other):
    if type(self) is type(other):
      for k in self._fields:
        if getattr(self, k) != getattr(other, k):
          return False
      return True
    else:
      return False

  def __ne__(self, other):
    return not self.__eq__(other)


x = TotallyADict(1, 2, 3)

print(json.dumps(x, default=vars))

You could also try using a UserDict

https://docs.python.org/3/library/collections.html#collections.UserDict