Python json.load(): Parse JSON from Files & Streams

Syntax & Parameters 🔝

The json.load() function requires a readable file-like stream object as its first argument:

import json

data = json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

JSON to Python Type Conversion Table 🔝

When deserializing JSON, Python automatically converts types according to the standard mapping:

Reading JSON from a File 🔝

Always manage file handles using a with statement and explicitly specify encoding="utf-8" to prevent cross-platform character corruption:

import json

# Sample configuration file: app_settings.json
with open("app_settings.json", "r", encoding="utf-8") as f:
    config = json.load(f)

print("Type:", type(config))
print("Application Name:", config["app_name"])
print("Database Port:   ", config["database"]["port"])

Type: <class 'dict'>
Application Name: Plus2Net Inventory
Database Port:    3306

json.load() vs. json.loads(): Key Differences 🔝

A frequent beginner confusion is choosing between load() and loads(). The s at the end stands for string:

Loading JSON from a URL or Network Stream 🔝

Because json.load() accepts any object with a .read() method, you can pass network streams directly from the standard library's urllib.request without saving intermediate files:

import json
from urllib.request import urlopen

try:
    with urlopen("https://httpbin.org/json", timeout=5) as response:
        payload = json.load(response)
        print("Fetched Slideshow Title:", payload["slideshow"]["title"])
except Exception as e:
    print("Network fetch failed:", e)

Handling JSONDecodeError & Missing Files 🔝

If the source file contains invalid syntax (such as single quotes, unquoted keys, or trailing commas), json.load() raises json.decoder.JSONDecodeError:

import json

try:
    with open("corrupted.json", "r", encoding="utf-8") as f:
        data = json.load(f)
except FileNotFoundError:
    print("Error: Specified file does not exist.")
except json.JSONDecodeError as err:
    print(f"Invalid JSON on line {err.lineno}, column {err.colno}: {err.msg}")

Advanced Parsing: Decimal Precision & Object Hooks 🔝

1. Financial Precision with parse_float=Decimal

Standard IEEE 754 binary floats suffer from small rounding inaccuracies (e.g. 0.1 + 0.2 != 0.3). For accounting or financial ledger JSON files, parse directly into exact Decimal objects:

import json
import io
from decimal import Decimal

finance_json = '{"item": "Laptop", "price": 999.99, "tax": 82.50}'
stream = io.StringIO(finance_json)

record = json.load(stream, parse_float=Decimal)
print("Price type:", type(record["price"]))
print("Total:     ", record["price"] + record["tax"])

2. Deserializing Directly into Custom Classes via object_hook

Use object_hook to convert plain dictionaries into domain classes during deserialization:

class Employee:
    def __init__(self, name, department):
        self.name = name
        self.department = department

def employee_decoder(dct):
    if "name" in dct and "department" in dct:
        return Employee(dct["name"], dct["department"])
    return dct

raw_data = io.StringIO('{"name": "Alice", "department": "Data Science"}')
emp = json.load(raw_data, object_hook=employee_decoder)
print("Decoded as:", type(emp), emp.name, "in", emp.department)

Hands-on Exercise: App Configuration Loader with Assertions 🔝

Let's build a configuration validator that streams and parses an application config file, enforcing required keys and verifying default fallbacks with self-checking assertions:

import json
import io

config_payload = """{
  "service": "billing_worker",
  "port": 9000,
  "max_workers": 8,
  "debug": false,
  "allowed_origins": ["https://plus2net.com", "http://localhost:3000"]
}"""

def load_and_validate_config(stream):
    config = json.load(stream)
    
    # Required keys validation
    required_keys = ["service", "port", "max_workers"]
    for key in required_keys:
        if key not in config:
            raise ValueError(f"Missing mandatory configuration key: {key}")
            
    return config

# Test with simulated stream
stream_obj = io.StringIO(config_payload)
parsed_cfg = load_and_validate_config(stream_obj)

# Unit Assertions
assert parsed_cfg["service"] == "billing_worker"
assert parsed_cfg["port"] == 9000
assert parsed_cfg["debug"] is False
assert len(parsed_cfg["allowed_origins"]) == 2

print("Validated Configuration:", parsed_cfg)
print("All configuration loader assertions passed successfully!")

Practice in Google Colab & GitHub 🔝

Open in Google Colab View on GitHub

Run all json.load() examples interactively, test stream parsing, custom class hooks, and verify the practice exercise with assertions directly in Google Colab with zero local setup.

More Details & Related Guides 🔝

• Python JSON Overview — Master serialization, formatting, and file exports in Python.
• json.dump() Method — Serialize Python objects directly into JSON files.
• json.loads() Method — Deserialize JSON data from strings into Python objects.
• json.dumps() Method — Convert Python objects into formatted JSON strings.
• Python File Handling — File opening modes, context managers, and stream lifecycles.
• file.readline() Method — Read text and log records line by line efficiently.

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author   Watch on YouTube

Connect: