Python Working with JSON Exercises

The "s" in dumps and loads stands for String.

Memory vs. Storage:

• json.dumps(obj): Useful when you want to send JSON over a network or store it in a database as a string.
• json.dump(obj, file_ptr): Useful when you want to save your data directly into a .json file on your hard drive.

JSON is a language-independent format, and it does not have a "Tuple" type. It only has Arrays.

Type Translation:

• Python list → JSON array
• Python tuple → JSON array
• Python dict → JSON object

Note: This means that if you serialize a tuple and then deserialize it back into Python, it will come back as a list, not a tuple!

To read from a file, you must first open the file to create a file-like object, and then pass that object to json.load().

Common Pitfalls:

• Using json.loads() with a filename string will fail because loads expects the actual JSON content, not a path.
• Option 4 is the safest method because the with statement ensures the file is closed immediately after the data is loaded.

JSON follows JavaScript's naming conventions for its primitive values.

This is a major difference between Python dictionaries and JSON objects.

Key Constraints:

• In Python, a dictionary key can be any immutable type (int, float, string, tuple).
• In JSON, every key must be a string.

If you have a Python dict {101: "Active"} and you dump it to JSON, it will become {"101": "Active"}. When you load it back, your integer key 101 will have become the string "101"!

By default, Python's json library produces "compact" JSON to save space during transmission. While efficient for machines, it is a single, long line of text that is hard for humans to read.

The Indent Parameter:

Setting indent to a non-negative integer or a string (like "\t") enables pretty-printing. It adds newlines and the specified number of spaces per level of nesting.

# Compact: {"a": 1, "b": 2}
# Pretty:
# {
#     "a": 1,
#     "b": 2
# }

By default, json.dumps() escapes all non-ASCII characters by turning them into \uXXXX sequences. This ensures the output can be safely transmitted over older systems that only support 7-bit ASCII.

If you set ensure_ascii=False, Python will output the actual Unicode characters. This makes the JSON much easier to read for international users and supports emojis natively.

In modern Python (3.7+), dictionaries maintain their insertion order. However, if two different scripts build the same dictionary in a different order, their resulting JSON strings will not match byte-for-byte.

Deterministic Output:

Setting sort_keys=True forces the JSON object keys to be output in alphabetical order. This is highly recommended when you are saving configuration files to Git, as it prevents "noisy" diffs where the data is the same but the order changed.

The separators parameter takes a tuple: (item_separator, key_separator).

Customizing Space:

• The default is (", ", ": "), which adds spaces after commas and colons for readability.
• By using (",", "="), you removed the spaces and changed the colon to an equals sign.

Warning: Changing the key separator to "=" produces Invalid JSON. Most other programs will not be able to read this file. This parameter is usually only used to remove spaces (",", ":") to create the most compact output possible for network efficiency.

While Python has many built-in types, the JSON Standard is very limited. It only supports: Strings, Numbers, Objects (dicts), Arrays (lists), Booleans, and Null.

The Set Problem:

A Python set has no direct equivalent in JSON. Unlike a tuple (which Python can lazily convert to an array), the json library will not assume a set should be an array because sets are unordered and unique. You must convert a set to a list manually before dumping.

# Fails:
json.dumps({1, 2, 3}) 

# Works:
json.dumps(list({1, 2, 3}))

The default parameter is a fallback function. When the JSON encoder encounters an object it doesn't recognize (like a datetime or a custom User class), it calls this function.

The Workflow:

The function receives the "unserializable" object. Your job is to convert it into something JSON does understand, such as an ISO-formatted string.

import json
from datetime import datetime

def my_converter(obj):
    if isinstance(obj, datetime):
        return obj.isoformat() # Returns a string
    raise TypeError("Type not serializable")

json.dumps({"now": datetime.now()}, default=my_converter)

Subclassing JSONEncoder is the "Enterprise" way to handle custom types. It allows you to bundle all your conversion rules into one object.

class MyEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, MyCustomClass):
            return obj.__dict__
        return super().default(obj)

# Usage:
json.dumps(data, cls=MyEncoder)

Note: Calling super().default(obj) at the end is vital—it allows the standard library to raise the proper TypeError if the object is truly unknown.

The object_hook is a powerful feature for Data Hydration (turning raw data back into logic-rich objects).

How it works:

Every time the decoder creates a dictionary from the JSON string, it passes that dictionary to your object_hook function before returning it. If your function returns a class instance, that instance replaces the dictionary in the final output.

def make_user(d):
    if "name" in d and "id" in d:
        return User(d["name"], d["id"])
    return d

data = json.loads(json_str, object_hook=make_user)
# data is now a User object!

Standard floats in Python (and JSON) suffer from binary rounding errors (e.g., 0.1 + 0.2 != 0.3). This is unacceptable for banking or scientific apps.

By passing decimal.Decimal to the parse_float parameter, you tell the decoder to bypass the standard float conversion and create high-precision Decimal objects directly from the raw string in the JSON.

This is a common issue with "streaming" JSON data or log files. raw_decode allows you to decode an object and tells you exactly where that object ended in the string.

You can then use that index to start decoding the next object from the remaining string. This is the only way to parse a file that isn't wrapped in a single top-level array or object.

JSON is a tree structure, not a graph. It cannot represent an object that contains itself (directly or indirectly).

The 'check_circular' flag:

By default, json.dumps() has check_circular=True. It tracks every object it visits; if it sees the same object twice in the same branch, it raises a ValueError to prevent an infinite loop.

If you were to set check_circular=False, the code would eventually result in a RecursionError as the stack overflows.

Python prioritizes utility over strict RFC compliance by default. It uses the allow_nan=True parameter.

The Compatibility Trap:

While json.loads() in Python can read back these values, most other languages (like JavaScript or Java) will crash because NaN (unquoted) is invalid JSON. If you are sending data to a web browser, you should set allow_nan=False to force a ValueError in Python before sending bad data.

The standard json decoder is a recursive descent parser. This means every new level of [ or { creates a new frame on the Python call stack.

Most Python installations have a limit of 1,000. For deeply nested malicious JSON (a "JSON Bomb"), this can crash your application. In production environments, it is often necessary to use sys.setrecursionlimit() or a non-recursive parser like ijson for untrusted data.

This is the most granular way to control the json library's internals.

The JSONDecoder constructor accepts several parse_xxx arguments. By passing str to parse_int, the low-level scanner will pass the raw string of digits directly to the str() constructor instead of int(), allowing you to handle extremely large numbers that might otherwise exceed Python's integer-to-string conversion limits or specific data requirements.

This is a fundamental limitation of the JSON format. JSON is a Tree-based format, meaning every piece of data is treated as an independent branch.

The "Identity" Problem:

In the original Python dictionary, module_1 and module_2 both pointed to the exact same memory address of shared_resource. If you changed one, the other would reflect it.

When you convert to JSON, the library simply sees two identical lists. It writes the data twice: {"module_1": ["connection_pool", "active"], "module_2": ["connection_pool", "active"]}.

When you load it back, Python creates two entirely separate list objects. The "link" between them is permanently broken. This is why for complex object graphs where identity matters, pickle or a graph-database approach is required.