JSON and CSV

import json

json.dumps(obj)                     # object  -> str
json.loads(text)                    # str, bytes, or bytearray -> object
json.dump(obj, fp)                  # object  -> file
json.load(fp)                       # file    -> object

with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, indent=2, ensure_ascii=False)

with open("data.json", encoding="utf-8") as f:
    data = json.load(f)

from pathlib import Path
data = json.loads(Path("data.json").read_text(encoding="utf-8"))
Path("out.json").write_text(json.dumps(data, indent=2), encoding="utf-8")

json.dumps({"a": 1, "b": [1, 2]}, separators=(",", ":"))   # '{"a":1,"b":[1,2]}'
json.dumps({"s": "ü"}, ensure_ascii=False)                 # '{"s": "ü"}'
json.dumps(float("nan"))                                   # 'NaN', INVALID JSON
json.dumps(float("nan"), allow_nan=False)
# ValueError: Out of range float values are not JSON compliant: nan

json.loads('{"x": 1.5}', parse_float=Decimal)      # {'x': Decimal('1.5')}
json.loads('{"a": 1}', object_pairs_hook=list)     # [('a', 1)]
json.loads("1e1000")                               # inf, silently

import json, dataclasses
from datetime import date, datetime
from decimal import Decimal
from uuid import UUID
from pathlib import Path

def json_default(o):
    if isinstance(o, (datetime, date)):
        return o.isoformat()
    if isinstance(o, Decimal):
        return str(o)                       # str, not float, to keep precision
    if isinstance(o, (set, frozenset)):
        return sorted(o)
    if isinstance(o, (UUID, Path)):
        return str(o)
    if isinstance(o, bytes):
        return o.decode("utf-8", "replace")
    if dataclasses.is_dataclass(o) and not isinstance(o, type):
        return dataclasses.asdict(o)
    raise TypeError(f"{type(o).__name__} is not JSON serializable")

json.dumps({"u": User("a", date(2026, 1, 1)), "d": Decimal("1.5"), "s": {2, 1}},
           default=json_default)
# '{"u": {"name": "a", "joined": "2026-01-01"}, "d": "1.5", "s": [1, 2]}'

# Same logic as a reusable class
class Encoder(json.JSONEncoder):
    def default(self, o):
        return json_default(o)

json.dumps(payload, cls=Encoder, indent=2)

from dataclasses import dataclass, fields

@dataclass
class User:
    name: str
    joined: date

def to_user(d: dict) -> User:
    return User(name=d["name"], joined=date.fromisoformat(d["joined"]))

user = to_user(json.loads(text))

# Ignore unknown keys instead of blowing up on **d
known = {f.name for f in fields(User)}
User(**{k: v for k, v in raw.items() if k in known})

try:
    data = json.loads(text)
except json.JSONDecodeError as e:      # subclass of ValueError
    print(e.msg, e.pos, e.lineno, e.colno)
    print(e.doc[max(0, e.pos - 40):e.pos + 40])    # the offending window

# Write, appending safely
with open("events.jsonl", "a", encoding="utf-8") as f:
    for rec in records:
        f.write(json.dumps(rec, ensure_ascii=False) + "\n")

# Read lazily, one record at a time, constant memory
def read_jsonl(path):
    with open(path, encoding="utf-8") as f:
        for lineno, line in enumerate(f, 1):
            line = line.strip()
            if not line:
                continue
            try:
                yield json.loads(line)
            except json.JSONDecodeError as e:
                print(f"skipping line {lineno}: {e.msg}")

for rec in read_jsonl("events.jsonl"):
    process(rec)

import orjson
orjson.dumps(obj, option=orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS)  # bytes
orjson.loads(raw_bytes)

import csv

with open("data.csv", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    header = next(reader)                # consume the header row
    for row in reader:                   # row is a list[str], ALWAYS strings
        name, age = row[0], int(row[1])

with open("data.csv", newline="", encoding="utf-8") as f:
    for row in csv.DictReader(f):        # row is a dict keyed by the header
        print(row["name"], int(row["age"]))

# No header in the file? Supply one.
csv.DictReader(f, fieldnames=["name", "age"])
reader.line_num                          # physical lines consumed so far
reader.fieldnames                        # DictReader only

with open("out.csv", "w", newline="", encoding="utf-8") as f:
    w = csv.writer(f)
    w.writerow(["name", "age"])
    w.writerows([["Ada", 36], ["Alan", 41]])

with open("out.csv", "w", newline="", encoding="utf-8") as f:
    w = csv.DictWriter(f, fieldnames=["name", "age"],
                       extrasaction="ignore",     # drop unknown keys, default raises
                       restval="")                # fill missing keys
    w.writeheader()                               # easy to forget
    w.writerow({"name": "Ada", "age": 36})
    w.writerows(rows)

csv.writer(f, delimiter="\t", quoting=csv.QUOTE_MINIMAL)      # TSV
csv.reader(f, dialect="excel-tab")                             # same, by dialect
csv.list_dialects()                                            # ['excel', 'excel-tab', 'unix']
csv.register_dialect("pipes", delimiter="|", quoting=csv.QUOTE_ALL)

# Sniffer: guess the delimiter and whether there is a header
with open("unknown.csv", newline="", encoding="utf-8") as f:
    sample = f.read(4096)
    f.seek(0)
    dialect = csv.Sniffer().sniff(sample)          # dialect.delimiter -> ';'
    has_header = csv.Sniffer().has_header(sample)
    reader = csv.reader(f, dialect)

# One huge field, such as an embedded blob
csv.field_size_limit()                             # 131072 by default
csv.field_size_limit(10 * 1024 * 1024)
# _csv.Error: field larger than field limit (131072)

with open("excel.csv", newline="", encoding="utf-8-sig") as f:
    rows = list(csv.DictReader(f))

import pandas as pd

df = pd.read_csv("data.csv", dtype={"zip": str}, parse_dates=["created_at"])
df.to_csv("out.csv", index=False)                  # index=False, always
pd.read_csv("data.csv", chunksize=100_000)         # iterator of DataFrames
pd.read_json("data.jsonl", lines=True)