jsobj["a"]["b"]["e"].append({"f":var3, "g":var4, "h":var5})
jsobj["a"]["b"]["e"].append({"f":var6, "g":var7, "h":var8})

Python includes SimpleJSON via the json module. Use it to serialize/de-serialize from JSON strings and python dicts:

myJSON_d = json.loads(myJSON)

myJSON_d.['DataSet'].update({'values': values, 'timeStamps': timeStamps})

myJSON = json.dumps(myJSON_d)

model.fruits = {"id": 1, "name": "apple"}* defines a dictionary, you cannot append to a dictionary, you can add keys to it

You can append elements into a JSON array though, e.g. if model.fruits was an array (or a list, as it is called in Python), e.g.

model.fruits = [{"id": 1, "name": "apple"},]

which defines an array with 1 element in it, then you can append to it

model.fruits.append({"id": 2, "name": "banana"})

Some references:

https://docs.djangoproject.com/en/1.8/ref/contrib/postgres/fields/#hstorefield https://docs.djangoproject.com/en/1.8/ref/contrib/postgres/fields/#arrayfield

* To be honest it doesn't make sense to name something in the plural like fruits to hold a single object, should be a container, like a list

First, accidents is a dictionary, and you can't write to a dictionary; you just set values in it.

So, what you want is:

for accident in accidents:
    accident['Turn'] = 'right'

The thing you want to write out is the new JSON—after you've finished modifying the data, you can dump it back to a file.

Ideally you do this by writing to a new file, then moving it over the original:

with open('sanfrancisco_crashes_cp.json') as json_file:
    json_data = json.load(json_file)
accidents = json_data['accidents']
for accident in accidents:
    accident['Turn'] = 'right'
with tempfile.NamedTemporaryFile(dir='.', delete=False) as temp_file:
    json.dump(temp_file, json_data)
os.replace(temp_file.name, 'sanfrancisco_crashes_cp.json')

But you can do it in-place if you really want to:

# notice r+, not rw, and notice that we have to keep the file open
# by moving everything into the with statement
with open('sanfrancisco_crashes_cp.json', 'r+') as json_file:
    json_data = json.load(json_file)
    accidents = json_data['accidents']
    for accident in accidents:
        accident['Turn'] = 'right'
    # And we also have to move back to the start of the file to overwrite
    json_file.seek(0, 0)
    json.dump(json_file, json_data)
    json_file.truncate()

If you're wondering why you got the specific error you did:

In Python—unlike many other languages—assignments aren't expressions, they're statements, which have to go on a line all by themselves.

But keyword arguments inside a function call have a very similar syntax. For example, see that tempfile.NamedTemporaryFile(dir='.', delete=False) in my example code above.

So, Python is trying to interpret your accident['Turn'] = 'right' as if it were a keyword argument, with the keyword accident['Turn']. But keywords can only be actual words (well, identifiers), not arbitrary expressions. So its attempt to interpret your code fails, and you get an error saying keyword can't be an expression.

I would do this:

data["list"].append({'b':'2'})

so simply you are adding an object to the list that is present in "data"

You can try json library-

import json

js="""
{"widget": {
        "debug": "on",
        "window": {
            "title": "Sample Konfabulator Widget",
            "name": "main_window",
            "width": 500,
            "height": 500
        }  

    }}  

"""
l=[{"Name": "abcd"}, {"Name": "efgh"}, {"Name": "hijk"}]

l_dict=json.loads(json.dumps(l))

js_dict = json.loads(js)
js_dict['widget']['window']['name']=l_dict[0]['Name']


print js_dict
print js_dict['widget']['window']['name']

Prints- See printed JSON is with new name!

{u'widget': {u'debug': u'on', u'window': {u'width': 500, u'height': 500, u'name': 'abcd', u'title': u'Sample Konfabulator Widget'}}}
abcd

As mentioned in the comments, once loaded the json is a python dictionary. You should now iterate on the value of the 'data' key, extract the information and store them in a list.

Something like this should do the job:

json_obj = json.load(json1)

ips = []
for piece in json_obj['data']:
    this_ip = [piece['custom3'], piece['modemId']]
    ips.append(this_ip)

One line form:

ips = [[piece['custom3'], piece['modemId']] for piece in json_obj['data']]

Note that as user2357112 mentioned, you are creating a Python dict -- not a Python list (aka a JSON "array"). Thus, when you say "[title] right next to [title]" there is a bit of confusion. Dicts do not use the order you are expecting (they use a hash-ordering).

That, and you are attempting to add a field after you've dumped the JSON to a string. You should do that before you dump it. More so, you're throwing away both your dict and data variables every loop. As written, your code will only have access to the variables in the last iteration of the loop.

And another important note: don't overload dict. Rename your variable to something else.

Also, your line day==day will always return True...

Here is what I think you are trying to do: you are creating a "calendar" of sorts that is organized into years, then months, then days. Each day has a list of "titles."

# Variables I'm assuming exist:
# `title`, `year`, `month`, `day`, `someOtherDay`, `titles`, `someOtherTitle`

myDict = {}
for title in titles: #Renamed `x` to `titles` for clarity.
    # Make sure myDict has the necessary keys.
    if not myDict[year]:
        myDict[year] = {}
    if not myDict[year][month]: 
        myDict[year][month] = {}

    # Set the day to be a list with a single `title` (and possibly two).
    myDict[year][month][day] = [title]
    if day==someOtherDay:
        myDict[year][month][day].append(someotherTitle)

    # And FINALLY dump the result to a string.
    data = json.dumps(myDict)