You can use a dictionary comprehension:

data = json.loads('{"foo":"5", "bar":""}')
res = {k: v if v != '' else None for k, v in data.items()}

{'foo': '5', 'bar': None}

This will only deal with the first level of a nested dictionary. You can use a recursive function to deal with the more generalised nested dictionary case:

def updater(d, inval, outval):
    for k, v in d.items():
        if isinstance(v, dict):
            updater(d[k], inval, outval)
        else:
            if v == '':
                d[k] = None
    return d

data = json.loads('{"foo":"5", "bar":"", "nested": {"test": "", "test2": "5"}}')

res = updater(data, '', None)

{'foo': '5', 'bar': None,
 'nested': {'test': None, 'test2': '5'}}

Use coalescing to pass it something valid.

json.loads('' or 'null')

Simply:

json.loads(request.POST.get('mydata', '{}'))

Or:

data = json.loads(request.POST['mydata']) if 'mydata' in request.POST else {}

Or:

if 'mydata' in request.POST:
    data = json.loads(request.POST['mydata'])
else:
    data = {} # or data = None

You can do this by defining an object_hook to pass to json.loads.

From the docs:

object_hook is an optional function that will be called with the result of any object literal decoded (a dict). The return value of object_hook will be used instead of the dict.

Given this dict:

>>> pprint(d)
{'campaign_id': '9c1c6cd7-fd4d-480b-8c80-07091cdd4103',
 'creation_date': 1530804132,
 'float': 1.2345,
 'objects': [{'full_name': '', 'id': 12345}],
 'strs': ['', 'abc', {'a': ''}],
 'top_str': ''}

This pair of functions will recurse over the result of json.loads and change instance of the empty string to 'N/A'.

def transform_dict(mapping=None):
    if mapping is None:
        mapping = {}
    for k, v in mapping.items():
        if v == '':
            mapping[k] = 'N/A'
        elif isinstance(v, dict):
            mapping[k] = transform_dict(v)
        elif isinstance(v, list):
            mapping[k] = transform_list(v)
        else:
            # Make it obvious that we aren't changing other values
            pass
    return mapping


def transform_list(lst):
    for i, x in enumerate(lst):
        if x == '':
            lst[i] = 'N/A'
        elif isinstance(x, dict):
            lst[i] = transform_dict(x)
        elif isinstance(x, list):
            lst[i] = transform_list(x)
        else:
            # Make it obvious that we aren't changing other values
            pass
    return lst

>>> res = json.loads(
        json.dumps(d), 
        parse_float=decimal.Decimal, 
        object_hook=transform_dict,
    )
>>> pprint(res)
{'campaign_id': '9c1c6cd7-fd4d-480b-8c80-07091cdd4103',
 'creation_date': 1530804132,
 'float': Decimal('1.2345'),
 'objects': [{'full_name': 'N/A', 'id': 12345}],
 'strs': ['N/A', 'abc', {'a': 'N/A'}],
 'top_str': 'N/A'}

Note that this approach depends on the input json being a json object ({...}).

data = json.loads(**your raw json string**)
nullify(data)
   
def nullify(container) :
 for key in container:
         if type(key) == list:
                 nullify(key)
         elif type(key) == dict:
                 nullify(key)
         elif type(container[key]) == dict or type(container[key]) == list:
                 nullify(container[key])
         elif container[key] == '':
                 container[key] = None

   

I believe this should work for you. Also, there is no null in python. Instead you can use None.

To remove the key altogether you must use container.pop(key,None). However you can't do it mid-iteration so you must store all such keys in a list and then pop them from the dictionary.

JSON is a string representation of data, such as lists and dictionaries. You don't append to the JSON, you append to the original data and then dump it.

Also, you don't use append() with dictionaries, it's used with lists.

data = {} # This is a dictionary
data["a"] = "1"; # Add an item to the dictionary
json_data = json.dumps(data) # Convert the dictionary to a JSON string
print(json_data)

Simply use dict.get(), i.e.:

return jStr.get(to_extract, '')

See https://docs.python.org/3/library/stdtypes.html#dict.get for more details.

UPD:

Thanks to @jez for pointing out, that jStr is not guaranteed to be a dictionary. However, the result for JSON parsing is known: if it's not a dictionary, then it's a list, number or a string. In this case, wrap it into a type checking routine, e.g.:

try:
    return jStr[to_extract]
except (KeyError, AttributeError):
    return ''

You can use the more flexible yaml to read in values not provided as None.

import yaml
from io import StringIO

mystr = StringIO("""{
  "empty_char":"",
  "empty_number": ,
  "char":"i'm a char",
  "number":0
}""")

# replace mystr with open('test.json', 'r')
with mystr as stream:
    res = yaml.load(stream)

print(res, type(res))

{'empty_char': '', 'empty_number': None, 'char': "i'm a char", 'number': 0}
<class 'dict'>

Note io.StringIO lets us read from a string as if it were a file.