Writing A Dictionary To A File Python

The Straight Answer

You open a file, serialize the dictionary, and close it. The most common way is json.dumps() for readable text output or pickle for binary preservation of Python-specific types. Most people jump straight to json because it produces something you can actually read and verify. I've done this enough times that I rarely think about it anymore, but the devil is in the details—especially when your data contains tuples, sets, or non-standard datetime objects. Here's the basic pattern without any ceremony: import json
data = {"name": "example", "values": [1, 2, 3]}
with open("output.json", "w") as f:
    json.dump(data, f, indent=2)

The with statement handles the file closing for you, even if an error occurs mid-write. That's not optional advice—it's just how you do it. Using open() without a context manager will leave files open on exceptions, and you'll spend hours debugging why your output file is truncated or locked. For JSON specifically, there's a trap that catches everyone at least once. JSON only supports dicts with string keys. If you try to dump a dict with integer or tuple keys, json.dump() raises a TypeError without warning. I learned this the hard way on a production script that processed sensor data with timestamp tuples as keys. The dictionary looked fine when I printed it to the console. It just died silently at the write step. My workaround was to convert all keys to strings before dumping—either by casting them directly or by using a custom default handler that recursively processes the structure. If your dictionary contains objects that JSON doesn't support—custom classes, datetime instances, sets, or frozensets—you have two real options. Option one is writing a custom encoder. Option two is using pickle. Pickle handles everything natively:

import pickle
with open("data.pkl", "wb") as f:
    pickle.dump(data, f) The catch with pickle is that it's Python-specific and has security implications if you load untrusted files. It also produces binary output, so you can't eyeball the contents. JSON is safer and more portable. Pickle is faster and more permissive. Pick your poison based on whether you need other languages to read the file. One thing people miss: indentation and formatting. json.dump() accepts sort_keys, separators, and indent parameters. If you're writing large dictionaries to disk and later comparing files with diff or reading them in another tool, setting sort_keys=True makes the output deterministic. Two runs with the same data produce identical files. Without it, dictionary insertion order is preserved in Python 3.7+, but that's an implementation detail, not a language guarantee for older versions. If your workflow involves version control or file comparison, sort the keys explicitly.

For massive dictionaries—hundreds of megabytes or more—json.dump() writes the entire serialized string to memory before flushing to disk. This doubles your memory footprint temporarily. If you're working with 2GB dictionaries on a machine with 8GB RAM, you'll feel it. In those cases, stream the output in chunks or use ijson for incremental writing. Or switch to a format like MessagePack or Protocol Buffers, which serialize more compactly and handle nested structures without the JSON string explosion. File encoding matters too. By default, open() uses your system's locale encoding, which is usually UTF-8 on modern systems. But if you're sharing files across platforms or working with legacy data, explicitly passing encoding="utf-8" prevents silent corruption. Non-ASCII characters in dict values will corrupt a JSON file if the writer and reader disagree on encoding. It's a three-second fix that saves a day of debugging. Here's the complete version I actually use in production:

import json
from datetime import datetime

def write_dict_to_json(filepath, data):
    class CustomEncoder(json.JSONEncoder):
        def default(self, obj):
            if isinstance(obj, datetime):
                return obj.isoformat()
            return super().default(obj)

    with open(filepath, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, sort_keys=True, ensure_ascii=False, cls=CustomEncoder) This handles datetime objects, sorts keys for reproducibility, uses UTF-8 encoding, and preserves Unicode characters in the output. It's not fancy. It just works every time. The ensure_ascii=False flag is particularly important if your dictionary values contain non-English text—without it, every non-ASCII character gets escaped to a Unicode escape sequence like \u00e9, which is valid JSON but completely unreadable for humans. If you need bidirectional serialization where you write the dict and read it back without any type information loss, pickle is simpler. You just dump and load with no custom encoder. But you trust the source, because unpickling arbitrary data is a well-known attack vector. I only use pickle for internal tooling where I control both ends. JSON everywhere else.