Lesson 23: JSON & Working with Data

JSON — The Internet's Language

JSON (JavaScript Object Notation) is the universal format for APIs, configs, and data files. It looks almost exactly like Python dicts and lists — strings in double quotes, booleans lowercase (true/false), and null instead of None.

Nearly every website you use talks JSON. When a browser fetches data from a server, when a mobile app syncs, when a machine-learning model receives training config — JSON is the lingua franca. Learning it opens the door to consuming real-world data.

What You'll Learn in This Lesson

• Convert between Python and JSON with the four functions
• Pretty-print JSON for readability
• Save and load JSON files
• Understand the type mapping

The Four Functions

Remember: dump goes to a string/file (serialize), load parses from a string/file (deserialize).

Memory trick: the "s" versions work on strings; the no-s versions work on file objects. dumps/loads ↔ strings; dump/load ↔ files.

Type Mapping

Not serializable by default: set, tuple, custom objects, datetime. You'll get a TypeError — convert them first or pass a default= function.

The default= escape hatch:

import json
from datetime import datetime

data = {"created": datetime.now()}

def convert(obj):
    if isinstance(obj, datetime):
        return obj.isoformat()
    raise TypeError(f"Not serializable: {obj!r}")

print(json.dumps(data, default=convert))  # {"created": "2026-08-11T..."}

Pretty Printing

json.dumps(data, indent=2) makes output readable — essential for debugging and sharing:

import json

student = {"name": "Riya", "courses": ["Python", "AI"], "active": True}
print(json.dumps(student, indent=2))

{
  "name": "Riya",
  "courses": [
    "Python",
    "AI"
  ],
  "active": true
}

Other useful options: sort_keys=True (sorted keys), ensure_ascii=False (keep non-English characters readable).

The Real-World Flow

# 1. API returns JSON text
api_response = '{"status": "ok", "data": [1, 2, 3]}'

# 2. Parse it into Python
payload = json.loads(api_response)
print(sum(payload["data"]))   # 6

# 3. Work with dicts/lists...
# 4. Save the result
with open("result.json", "w", encoding="utf-8") as f:
    json.dump(payload, f, indent=2)

This parse → transform → save pipeline is the backbone of every data engineer's day.

Mental model: dumps packs a suitcase (Python → JSON); loads unpacks it (JSON → Python). Draw the nesting outside-in: { = crate, [ = shelf.

Fetching live JSON from an API (with requests):

import requests
import json

response = requests.get("https://api.github.com/users/amolshukla")
data = response.json()          # requests parses JSON for you
print(data["public_repos"])     # work with it as plain Python

Validating with try/except

Real-world JSON is not always well-formed. Professional code wraps parsing:

import json

raw = '{"broken": '   # invalid JSON
try:
    data = json.loads(raw)
except json.JSONDecodeError as e:
    print("Bad JSON:", e)

This is the Lesson 21 pattern applied to data — one line of protection prevents a crash on every bad payload.

Common Mistakes to Avoid

• Mistake: json.dumps({1, 2, 3}) (a set) — Fix: TypeError; convert to a list first.
• Mistake: Forgetting that JSON booleans are true/false and null — Fix: Python parses them to True/False/None automatically.
• Mistake: Double-encoding — calling json.dumps on an already-dumped string — Fix: dump once, at the end.
• Mistake: json.load vs json.loads confusion — Fix: loads = string; load = file.
• Mistake: Not handling JSONDecodeError on external data — Fix: wrap loads in try/except.

Professional Tips & Tricks

• Use json.dumps(..., ensure_ascii=False) to keep non-English characters readable.
• Wrap json.loads in try/except json.JSONDecodeError for robust parsing.
• Flatten nested JSON with helper functions before analysis — pandas can take dicts directly.
• Use default= to serialize dates and custom objects.
• Use indent=2 and sort_keys=True for shareable, readable output.

Key Takeaways

• Four functions: dumps/loads (strings) and dump/load (files).
• Python and JSON map cleanly: dict↔object, list↔array, True↔true, None↔null.
• indent=2 pretty-prints; ensure_ascii=False keeps Unicode readable.
• Sets, tuples, and dates need conversion before serialization.
• Wrap parsing in try/except for robustness.

Next up: Testing & debugging — writing code that proves itself.