JSON实际上并不用于序列化任意的Python对象。它非常适合序列化dict对象，但pickle模块才是你真正应该使用的。pickle的输出实际上不是人类可读的，但它应该可以解腌。如果坚持使用JSON，可以查看jsonpickle模块，这是一种有趣的混合方法。

https://github.com/jsonpickle/jsonpickle

你可以在json.dumps()函数中指定默认的命名参数:

json.dumps(obj, default=lambda x: x.__dict__)

解释:

从文档(2.7,3.6):

``default(obj)`` is a function that should return a serializable version
of obj or raise TypeError. The default simply raises TypeError.

(适用于Python 2.7和Python 3.x)

注意:在这种情况下，您需要实例变量而不是类变量，正如问题中的示例所尝试做的那样。(我假设请求者意味着类实例是类的对象)

我首先从@phihag的回答中了解到这一点。发现这是最简单、最干净的工作方式。

我认为，与其像公认的答案中建议的那样继承，不如使用多态。否则你必须有一个大的if else语句来自定义每个对象的编码。这意味着为JSON创建一个通用的默认编码器:

def jsonDefEncoder(obj):
   if hasattr(obj, 'jsonEnc'):
      return obj.jsonEnc()
   else: #some default behavior
      return obj.__dict__

然后在你想序列化的每个类中都有一个jsonEnc()函数。如。

class A(object):
   def __init__(self,lengthInFeet):
      self.lengthInFeet=lengthInFeet
   def jsonEnc(self):
      return {'lengthInMeters': lengthInFeet * 0.3 } # each foot is 0.3 meter

然后调用json.dumps(classInstance,default=jsonDefEncoder)

基本的问题是JSON编码器JSON .dumps()默认情况下只知道如何序列化有限的对象类型集，所有的内置类型。名单在这里:https://docs.python.org/3.3/library/json.html#encoders-and-decoders

一个好的解决方案是让您的类继承自JSONEncoder，然后实现JSONEncoder.default()函数，并使该函数为您的类发出正确的JSON。

一个简单的解决方案是在该实例的.__dict__成员上调用json.dumps()。这是一个标准的Python字典，如果你的类很简单，它将是JSON序列化的。

class Foo(object):
    def __init__(self):
        self.x = 1
        self.y = 2

foo = Foo()
s = json.dumps(foo) # raises TypeError with "is not JSON serializable"

s = json.dumps(foo.__dict__) # s set to: {"x":1, "y":2}

上述方法在这篇博文中进行了讨论:

使用_dict_将任意Python对象序列化为JSON

当然，Python提供了一个内置函数，为您访问.__dict__，称为vars()。

所以上面的例子也可以这样做:

s = json.dumps(vars(foo)) # s set to: {"x":1, "y":2}

你可以使用Jsonic将几乎任何东西序列化为JSON:

https://github.com/OrrBin/Jsonic

例子:

class TestClass:
def __init__(self):
    self.x = 1
    self.y = 2

instance = TestClass()
s = serialize(instance): # instance s set to: {"x":1, "y":2}
d = deserialize(s) # d is a new class instance of TestClass

Jsonic有一些不错的特性，比如声明类属性为瞬态的和类型安全的反序列化。

(晚了几年才有答案，但我认为这可能会对其他人有所帮助)

这里有两个简单的函数，用于序列化任何不复杂的类，没有前面解释的那么复杂。

我将此用于配置类型的东西，因为我可以向类添加新成员而无需进行代码调整。

import json

class SimpleClass:
    def __init__(self, a=None, b=None, c=None):
        self.a = a
        self.b = b
        self.c = c

def serialize_json(instance=None, path=None):
    dt = {}
    dt.update(vars(instance))

    with open(path, "w") as file:
        json.dump(dt, file)

def deserialize_json(cls=None, path=None):
    def read_json(_path):
        with open(_path, "r") as file:
            return json.load(file)

    data = read_json(path)

    instance = object.__new__(cls)

    for key, value in data.items():
        setattr(instance, key, value)

    return instance

# Usage: Create class and serialize under Windows file system.
write_settings = SimpleClass(a=1, b=2, c=3)
serialize_json(write_settings, r"c:\temp\test.json")

# Read back and rehydrate.
read_settings = deserialize_json(SimpleClass, r"c:\temp\test.json")

# results are the same.
print(vars(write_settings))
print(vars(read_settings))

# output:
# {'c': 3, 'b': 2, 'a': 1}
# {'c': 3, 'b': 2, 'a': 1}