JSON: load, dump and custom types

Practice that adapts to you

Practise this lesson

18 questions about 6 ideas of this lesson. Each answer is explained at once, and what you get right is kept in this browser.

1. Question 1 of 18 A dict with the int key 3 goes through json.dumps() and back through json.loads(). What is the key now?

   Choose one answer.

   The int 3 The float 3.0 dumps() refuses the key with TypeError The string "3"

   Show the answer: Question 1 of 18

   Answer: The string "3"

   The json documentation says it directly: loads(dumps(x)) != x if x has non-string keys. Code that reads JSON should expect string keys, whatever the code that wrote it used.

2. Question 2 of 18 What does this print?

   Read the code, then choose one answer.

   import json
   
   order = {"items": ("pen", "notebook")}
   back = json.loads(json.dumps(order))
   print(back["items"] == ("pen", "notebook"), back["items"] == ["pen", "notebook"])

   True False True True False True False False

   Show the answer: Question 2 of 18

   Answer: False True

   JSON has only arrays, and loads() turns every array into a list. Compare with a list, or convert with tuple() after loading when the code needs a tuple.

3. Question 3 of 18 Two services exchange orders as JSON. One stores order lines as tuples and uses the int product code as a dict key. Which plan keeps both sides working?

   Choose one answer.

   Send the data as it is, because loads() restores tuples and int keys Agree on what the JSON holds, lists and string keys, and convert to tuples and ints on the reading side if the code needs them Switch to json.dump(), which keeps Python types Use eval() on the reading side, because it understands tuples

   Show the answer: Question 3 of 18

   Answer: Agree on what the JSON holds, lists and string keys, and convert to tuples and ints on the reading side if the code needs them

   JSON describes data, not Python objects, so the format between two programs is a contract: decide what the text holds, and let each side convert to and from its own types.

4. Question 4 of 18 What does json.dump(settings, f, indent=2) return?

   Choose one answer.

   The JSON text as a str The settings dict, unchanged None; it writes the JSON text into the file f The number of characters written

   Show the answer: Question 4 of 18

   Answer: None; it writes the JSON text into the file f

   The functions with an s work on strings, the ones without on file objects. dump(obj, f) writes the text into f, and load(f) reads and parses a whole file.

5. Question 5 of 18 What does this print?

   Read the code, then choose one answer.

   DEFAULTS = {"theme": "light", "font_size": 14, "recent": []}
   saved = {"theme": "dark"}
   print(DEFAULTS | saved)

   It raises TypeError, because | is for numbers and sets {'theme': 'light', 'font_size': 14, 'recent': []} {'theme': 'dark'} {'theme': 'dark', 'font_size': 14, 'recent': []}

   Show the answer: Question 5 of 18

   Answer: {'theme': 'dark', 'font_size': 14, 'recent': []}

   Merging the saved settings over the defaults gives every setting a value, including settings added in a later version of the program, which an older file does not hold.

6. Question 6 of 18 A network library hands you the response body as bytes. What does json.loads(body) do with them?

   Choose one answer.

   It treats each byte as one character, like Latin-1 It decodes them itself, as UTF-8, UTF-16 or UTF-32, and parses the text It raises TypeError, because loads() needs a str It decodes them with the locale encoding

   Show the answer: Question 6 of 18

   Answer: It decodes them itself, as UTF-8, UTF-16 or UTF-32, and parses the text

   json.loads() accepts str, bytes and bytearray. For a file, open it in text mode with encoding="utf-8" and use load(): RFC 8259 requires UTF-8 for JSON that systems exchange.

7. Question 7 of 18 Why does a settings file written with sort_keys=True work better in version control?

   Choose one answer.

   The same data always gives the same text, so a diff shows only the values that really changed loads() reads sorted keys faster Git cannot store unsorted JSON Sorted files are smaller

   Show the answer: Question 7 of 18

   Answer: The same data always gives the same text, so a diff shows only the values that really changed

   With sort_keys=True and indent=2, every key of every object comes out in the same order on its own line, so tests can compare output with expected text and diffs stay small.

8. Question 8 of 18 In readable.py, the students list took 122 bytes with the default spaces and 109 bytes with separators=(",", ":"). How many bytes did the compact form save?

   Type a number.

   Your answer bytes

   Show the answer: Question 8 of 18

   Answer: 13 bytes

   122 − 109 = 13 bytes, about 11 % of the default output. The default separators put a space after every comma and every colon; the compact ones drop both, which suits data sent over a network more than files that people read.

9. Question 9 of 18 A build script must stop when any JSON file of a project is broken. Which fact about python -m json makes it usable for that?

   Choose one answer.

   It repairs a broken file in place It always exits with status 0, printing what it can It exits with status 1 and prints the line and column when a file is not valid JSON It colours the error red

   Show the answer: Question 9 of 18

   Answer: It exits with status 1 and prints the line and column when a file is not valid JSON

   Command-line tools report failure through their exit status. python -m json returns 1 for invalid JSON, so a script can run it on every file and stop at the first failure.

10. Question 10 of 18 When does json.dumps() call the function given as default=?

    Choose one answer.

    For every value, so that it can change any of them Only when the value is a dict Once, for the whole object, before writing anything For every value it cannot write by itself, such as a Decimal, a set or a datetime

    Show the answer: Question 10 of 18

    Answer: For every value it cannot write by itself, such as a Decimal, a set or a datetime

    default must return something JSON can store, or raise TypeError as dumps() itself would. It is called for each value that has no JSON form, at any depth of the data.

11. Question 11 of 18 What does custom_types.py print?

    What does this program print? Choose one answer.

    import json
    from datetime import datetime, timezone
    from decimal import Decimal
    
    order = {"id": 501, "amount": Decimal("1999.90"), "tags": {"gift", "express"},
             "created_at": datetime(2025, 3, 14, 9, 30, tzinfo=timezone.utc)}
    
    try:
        json.dumps(order)
    except TypeError as err:
        print("TypeError:", err)
        print("notes:", err.__notes__)  # Python 3.14 says where the value was
    
    
    def encode(value):
        """Called by dumps() for every value it cannot write itself."""
        if isinstance(value, datetime):
            return value.isoformat()
        if isinstance(value, Decimal):
            return str(value)  # a string keeps every digit
        if isinstance(value, set):
            return sorted(value)  # a list, in a fixed order
        raise TypeError(f"cannot store {type(value).__name__} as JSON")
    
    
    text = json.dumps(order, default=encode)
    print(text)
    
    
    def decode(obj):
        """Called by loads() for every JSON object: turn the *_at fields back into datetimes."""
        for key, value in obj.items():
            if key.endswith("_at"):
                obj[key] = datetime.fromisoformat(value)
        return obj
    
    
    back = json.loads(text, object_hook=decode)
    print(repr(back["created_at"]))
    print(repr(back["amount"]), "and", back["tags"], "(JSON kept no record that they were a Decimal and a set)")

    TypeError: Object of type set is not JSON serializable notes: ["when serializing dict item 'tags'"] {"id": 501, "amount": "1999.90", "tags": ["express", "gift"], "created_at": "2025-03-14T09:30:00+00:00"} datetime.datetime(2025, 3, 14, 9, 30, tzinfo=datetime.timezone.utc) '1999.90' and ['express', 'gift'] (JSON kept no record that they were a Decimal and a set) TypeError: Object of type Decimal is not JSON serializable notes: ["when serializing dict item 'amount'"] {"id": 501, "amount": "1999.90", "tags": ["express", "gift"], "created_at": "2025-03-14T09:30:00+00:00"} datetime.datetime(2025, 3, 14, 9, 30, tzinfo=datetime.timezone.utc) Decimal('1999.90') and {'express', 'gift'} (JSON kept no record that they were a Decimal and a set) TypeError: Object of type Decimal is not JSON serializable notes: ["when serializing dict item 'amount'"] {"id": 501, "amount": "1999.90", "tags": ["express", "gift"], "created_at": "2025-03-14T09:30:00+00:00"} datetime.datetime(2025, 3, 14, 9, 30, tzinfo=datetime.timezone.utc) '1999.90' and ['express', 'gift'] (JSON kept no record that they were a Decimal and a set)

    Show the answer: Question 11 of 18

    Answer: it prints

    TypeError: Object of type Decimal is not JSON serializable
    notes: ["when serializing dict item 'amount'"]
    {"id": 501, "amount": "1999.90", "tags": ["express", "gift"], "created_at": "2025-03-14T09:30:00+00:00"}
    datetime.datetime(2025, 3, 14, 9, 30, tzinfo=datetime.timezone.utc)
    '1999.90' and ['express', 'gift'] (JSON kept no record that they were a Decimal and a set)

    Without default=, dumps() stops at amount and Python 3.14 notes where. encode() writes the Decimal as a string, the set as a sorted list and the datetime as ISO 8601 text, and object_hook can bring back only what its naming rule recognises.

12. Question 12 of 18 After a round trip, amount is the string "1999.90" again, not a Decimal. Which change lets the reading side restore it?

    Choose one answer.

    Pass default=Decimal to loads() Write the Decimal as a float instead Agree on a rule both sides know, such as a field name, a field that names the type, or a shared schema, and convert in the hook Nothing can; JSON destroys Decimals

    Show the answer: Question 12 of 18

    Answer: Agree on a rule both sides know, such as a field name, a field that names the type, or a shared schema, and convert in the hook

    A naming rule such as _at, a type field such as {"$decimal": "1999.90"}, or a schema both sides share tells the reader what each string means. With that knowledge, object_hook turns it back into the right type.

13. Question 13 of 18 Which call reads {"price": 19.99} with the price as an exact Decimal?

    Choose one answer.

    json.loads(text, object_hook=Decimal) Decimal(json.loads(text)["price"]) json.loads(text, default=Decimal) json.loads(text, parse_float=Decimal)

    Show the answer: Question 13 of 18

    Answer: json.loads(text, parse_float=Decimal)

    parse_float=Decimal hands the number's own text to Decimal, before any float exists, so 19.99 stays exactly 19.99. That matters for money.

14. Question 14 of 18 What does json_numbers.py print?

    What does this program print? Choose one answer.

    import json
    from decimal import Decimal
    
    print(json.dumps([0.1 + 0.2, 10**20, float("nan"), float("inf")]))  # NaN and Infinity are not JSON
    
    try:
        json.dumps({"ratio": float("nan")}, allow_nan=False)  # strict JSON for other systems
    except ValueError as err:
        print("ValueError:", err)
    
    print(json.loads('{"price": 19.99}'))  # a float
    print(json.loads('{"price": 19.99}', parse_float=Decimal))  # the exact decimal value
    print(json.loads('{"x": 1, "x": 2}'))  # a repeated key: the last one wins
    
    big = 2**53 + 1  # an identifier just above 2**53
    print(big, int(float(big)))  # what a reader that stores numbers as 64-bit floats keeps

    [0.3, 100000000000000000000, null, null] ValueError: Out of range float values are not JSON compliant: nan {'price': 19.99} {'price': Decimal('19.99')} {'x': 1} 9007199254740993 9007199254740993 [0.30000000000000004, 1e+20, NaN, Infinity] {'ratio': NaN} {'price': 19.99} {'price': 19.99} {'x': 2} 9007199254740993 9007199254740992 [0.30000000000000004, 100000000000000000000, NaN, Infinity] ValueError: Out of range float values are not JSON compliant: nan {'price': 19.99} {'price': Decimal('19.99')} {'x': 2} 9007199254740993 9007199254740992

    Show the answer: Question 14 of 18

    Answer: it prints

    [0.30000000000000004, 100000000000000000000, NaN, Infinity]
    ValueError: Out of range float values are not JSON compliant: nan
    {'price': 19.99}
    {'price': Decimal('19.99')}
    {'x': 2}
    9007199254740993 9007199254740992

    dumps() writes the float exactly as Python holds it, any integer in full and NaN and Infinity as non-standard words. allow_nan=False refuses NaN with ValueError, parse_float=Decimal reads 19.99 exactly, a repeated key keeps its last value, and 2**53 + 1 does not survive a trip through a 64-bit float.

15. Question 15 of 18 An endpoint must refuse a body such as {"qty": 1, "qty": 50} instead of quietly using 50. How?

    Choose one answer.

    Check the parsed dict for two qty keys Nothing is needed, because loads() refuses repeated keys Pass strict=True to loads() Parse with an object_pairs_hook that raises ValueError when a key appears twice

    Show the answer: Question 15 of 18

    Answer: Parse with an object_pairs_hook that raises ValueError when a key appears twice

    The JSON standard leaves repeated names undefined, and Python keeps the last value without a warning. Only the pairs hook sees all of them, so that is where a strict parser refuses the body.

16. Question 16 of 18 Why must JSON from outside be parsed with json.loads() and never with eval()?

    Choose one answer.

    eval() is slower eval() cannot read true, false and null eval() runs whatever the text contains as Python code, while loads() only builds data There is no difference for valid JSON

    Show the answer: Question 16 of 18

    Answer: eval() runs whatever the text contains as Python code, while loads() only builds data

    JSON is data, never code. json.loads() parses it into plain objects; eval() would execute any expression an attacker sends.

17. Question 17 of 18 What does validate.py print?

    What does this program print? Choose one answer.

    import json
    
    
    def check_order(data):
        """Raise ValueError unless data has the shape an order must have."""
        if not isinstance(data, dict):
            raise ValueError("an order must be a JSON object")
        if not isinstance(data.get("id"), int) or isinstance(data.get("id"), bool):
            raise ValueError("id must be a whole number")
        items = data.get("items")
        if not isinstance(items, list) or not items:
            raise ValueError("items must be a non-empty list")
        for i, item in enumerate(items):
            if not isinstance(item, dict) or not isinstance(item.get("sku"), str):
                raise ValueError(f"items[{i}] needs a text sku")
            qty = item.get("qty")
            if not isinstance(qty, int) or isinstance(qty, bool) or not 1 <= qty <= 100:
                raise ValueError(f"items[{i}].qty must be a whole number from 1 to 100")
        return data
    
    
    requests = [
        '{"id": 7, "items": [{"sku": "PEN-01", "qty": 2}]}',
        '[1, 2, 3]',
        '{"id": "7", "items": [{"sku": "PEN-01", "qty": 2}]}',
        '{"id": 8, "items": [{"sku": "PEN-01", "qty": true}]}',
        '{"id": 9, "items": [{"sku": "PEN-01", "qty": 5000}]}',
        '{"id": 10, "items": [{"sku": "PEN-01", "qty": 1}',
    ]
    for text in requests:
        try:
            order = check_order(json.loads(text))
            print("accepted order", order["id"])
        except json.JSONDecodeError as err:
            print("not JSON:", err.msg)
        except ValueError as err:
            print("refused:", err)

    accepted order 7 refused: an order must be a JSON object refused: id must be a whole number refused: items[0].qty must be a whole number from 1 to 100 refused: items[0].qty must be a whole number from 1 to 100 refused: an order must be a JSON object accepted order 7 refused: an order must be a JSON object refused: id must be a whole number refused: items[0].qty must be a whole number from 1 to 100 refused: items[0].qty must be a whole number from 1 to 100 not JSON: Expecting ',' delimiter accepted order 7 refused: an order must be a JSON object accepted order 7 accepted order 8 refused: items[0].qty must be a whole number from 1 to 100 not JSON: Expecting ',' delimiter

    Show the answer: Question 17 of 18

    Answer: it prints

    accepted order 7
    refused: an order must be a JSON object
    refused: id must be a whole number
    refused: items[0].qty must be a whole number from 1 to 100
    refused: items[0].qty must be a whole number from 1 to 100
    not JSON: Expecting ',' delimiter

    Parsing comes first: the cut-off body fails there, with JSONDecodeError. Every body that parses then meets check_order(), which refuses a list, an id in quotes, a quantity of true and one of 5000, each with its field.

18. Question 18 of 18 An endpoint receives JSON bodies from the internet. What should it do before calling json.loads()?

    Choose one answer.

    Run the body through eval() to see if it is safe Nothing; loads() rejects anything dangerous by itself Refuse bodies above a size limit, since the json documentation warns that a malicious document can use a lot of CPU and memory Validate the shape of the data first

    Show the answer: Question 18 of 18

    Answer: Refuse bodies above a size limit, since the json documentation warns that a malicious document can use a lot of CPU and memory

    Limit the size first, then parse inside a try statement, then check the shape and the ranges of the result, as check_order() does. Each step only lets through what the next one can handle.