UPDATE

With Python3, you can do it in one line, using SimpleNamespace and object_hook:

import json
from types import SimpleNamespace

data = '{"name": "John Smith", "hometown": {"name": "New York", "id": 123}}'

# Parse JSON into an object with attributes corresponding to dict keys.
x = json.loads(data, object_hook=lambda d: SimpleNamespace(**d))
# Or, in Python 3.13+:
#   json.loads(data, object_hook=SimpleNamespace)
print(x.name, x.hometown.name, x.hometown.id)

OLD ANSWER (Python2)

In Python2, you can do it in one line, using namedtuple and object_hook (but it's very slow with many nested objects):

import json
from collections import namedtuple

data = '{"name": "John Smith", "hometown": {"name": "New York", "id": 123}}'

# Parse JSON into an object with attributes corresponding to dict keys.
x = json.loads(data, object_hook=lambda d: namedtuple('X', d.keys())(*d.values()))
print x.name, x.hometown.name, x.hometown.id

or, to reuse this easily:

def _json_object_hook(d): return namedtuple('X', d.keys())(*d.values())
def json2obj(data): return json.loads(data, object_hook=_json_object_hook)

x = json2obj(data)

If you want it to handle keys that aren't good attribute names, check out namedtuple's rename parameter.

Since it sounds like your data might be expected to be dynamic and you want the freedom to add more fields in the JSON object without reflecting the same changes in the model, I'd also suggest to check out typing.TypedDict instead a dataclass.

Here's an example with TypedDict, which should work in Python 3.7+. Since TypedDict was introduced in 3.8, I've instead imported it from typing_extensions so it's compatible with 3.7 code.

from __future__ import annotations

import json
from io import StringIO
from typing_extensions import TypedDict


class Account(TypedDict):
    email: str
    password: str
    name: str
    salary: int


json_data = StringIO("""{
    "acc1":{
        "email":"[email protected]",
        "password":"acc1",
        "name":"ACC1",
        "salary":1
    },
    "acc2":{
        "email":"[email protected]",
        "password":"acc2",
        "name":"ACC2",
        "salary":2,
        "someRandomKey": "string"
    }
}
""")

data = json.load(json_data)
name_to_account: dict[str, Account] = data

acct = name_to_account['acc2']

# Your IDE should be able to offer auto-complete suggestions within the
# brackets, when you start typing or press 'Ctrl + Space' for example.
print(acct['someRandomKey'])

If you are set on using dataclasses to model your data, I'd suggest checking out a JSON serialization library like the dataclass-wizard (disclaimer: I am the creator) which should handle extraneous fields in the JSON data as mentioned, as well as a nested dataclass model if you find your data becoming more complex.

It also has a handy tool that you can use to generate a dataclass schema from JSON data, which can be useful for instance if you want to update your model class whenever you add new fields in the JSON file as mentioned.

The basic problem is that the JSON encoder json.dumps() only knows how to serialize a limited set of object types by default, all built-in types. List here: https://docs.python.org/3.3/library/json.html#encoders-and-decoders

One good solution would be to make your class inherit from JSONEncoder and then implement the JSONEncoder.default() function, and make that function emit the correct JSON for your class.

A simple solution would be to call json.dumps() on the .__dict__ member of that instance. That is a standard Python dict and if your class is simple it will be JSON serializable.

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}

The above approach is discussed in this blog posting:

    Serializing arbitrary Python objects to JSON using _dict_

And, of course, Python offers a built-in function that accesses .__dict__ for you, called vars().

So the above example can also be done as:

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

Use object_hook special parameter in load functions of json module:

import json

class JSONObject:
  def __init__( self, dict ):
      vars(self).update( dict )

#this is valid json string
data='{"channel":{"lastBuild":"2013-11-12", "component":["test1", "test2"]}}'

jsonobject = json.loads( data, object_hook= JSONObject)

print( jsonobject.channel.component[0]  )
print( jsonobject.channel.lastBuild  )

This method have some issue, like some names in python are reserved. You can filter them out inside __init__ method.

Using the ** operator is probably the preferred way to do it, as long as your constructor parameters match the names of your JSON attributes exactly (like they do in your example) and as long as there's not additional parameters on the constructor that could wreak havoc:

def Message:
    def __init__(greeting: str, wipe_c_drive: bool = False):
        self.greeting = greeting
        if wipe_c_drive:
            shutil.rmtree('C:/')


workfile = json.load(open('greetings.json', 'r'))
hello = Message(**workfile['hello'])

And the data in greetings.json:

{
  "hello": {
    "greeting": "Hello there!"
  }
}

What could possibly go wrong, right?

The ** operator is a 'spreading' operator, it take a key/value pair data object like a dictionary, and spreads it - typically to provide keyword arguments for a function:

def say(greeting, name):
    print(f'{greeting} to you, {name}!')


d = {'greeting': 'hello', 'name': 'AnFa')
say(**d)

This works in your case as well, since a JSON object is loaded as a dictionary and thus can be spread using the ** operator. And since the attributes of your JSON object exactly match the names of your keyword parameters for the constructor, it works.

Similarly, the * operators spreads a list:

xs = ['hello', 'AnFa']
say(*xs)

This has the same result, but tries to pass the values as positional parameters.

Knowing the above, you may also understand why you sometimes see this:

def some_func(x, *args, **kwargs):
    print(x)
    some_other_func(*args, **kwargs)

Here, the *args and **kwargs work to capture positional and keyword parameters in args (arguments) and kwargs (keyword arguments) and the second time, they spread them back into the call to some_other_func. Those names args and kwargs are not magical, they're just conventions.

If you want something a bit less risky (because of the reasons explained above), you could give your class 'to_json' and 'from_json' methods, but fairly soon things will get complicated and you may want to look into existing libraries instead, as user @LeiYang suggests (and there are many of those).