{"id":535,"date":"2026-01-20T18:57:14","date_gmt":"2026-01-20T18:57:14","guid":{"rendered":"http:\/\/askpython.com\/?p=535"},"modified":"2026-01-25T15:03:46","modified_gmt":"2026-01-25T15:03:46","slug":"python-dictionary-dict-tutorial","status":"publish","type":"post","link":"https:\/\/www.askpython.com\/python\/dictionary\/python-dictionary-dict-tutorial","title":{"rendered":"Python Dictionary (Dict) Tutorial"},"content":{"rendered":"
\nuser = {"name": "Alice", "age": 30, "role": "developer"}\nprint(user["name"])  # Alice\n\n<\/pre><\/div>\n\n\n
That’s a Python dictionary. Key-value pairs wrapped in curly braces, and you’re done.<\/p>\n\n\n\n
If you’ve been programming for more than five minutes, you’ve probably used a dictionary without realizing it. They’re everywhere because they solve a fundamental problem: computers are great at remembering things, but only if you label them properly.<\/p>\n\n\n\n
Creating Python dictionaries from scratch<\/h2>\n\n\n\n
The basic syntax gives you three ways to create a dict. Pick whichever feels right for the situation.<\/p>\n\n\n
\n# Method 1: Literal notation\nperson = {"first": "John", "last": "Doe", "age": 28}\n\n# Method 2: dict() constructor\nperson = dict(first="John", last="Doe", age=28)\n\n# Method 3: Empty dict you'll populate later\nperson = {}\nperson["first"] = "John"\nperson["last"] = "Doe"\nperson["age"] = 28\n\n<\/pre><\/div>\n\n\n
All three produce identical results. The literal notation (method 1) is faster and more common in production code. The constructor (method 2) looks cleaner when you’re passing values as function arguments. The empty dict approach (method 3) makes sense when you’re building data iteratively.<\/p>\n\n\n\n
Keys can be strings, numbers, or tuples (anything immutable, really). Values can be absolutely anything.<\/p>\n\n\n
\nmixed = {\n    "string_key": "value",\n    42: "numeric key",\n    (1, 2): "tuple key",\n    "nested": {"another": "dict"}\n}\n\n<\/pre><\/div>\n\n\n
Accessing dictionary values in Python<\/h2>\n\n\n\n
You’ve got two options here, and they behave differently when keys don’t exist.<\/p>\n\n\n
\nconfig = {"debug": True, "port": 8080}\n\n# Square bracket notation\nprint(config["debug"])  # True\nprint(config["missing"])  # KeyError: 'missing'\n\n# get() method\nprint(config.get("debug"))  # True\nprint(config.get("missing"))  # None\nprint(config.get("missing", "default"))  # 'default'\n\n<\/pre><\/div>\n\n\n
The square bracket approach crashes hard when the key doesn’t exist. Sometimes that’s what you want (fail fast). The get() method returns None by default or whatever fallback value you specify. I use get() constantly in production because it prevents defensive coding nonsense.<\/p>\n\n\n\n
Modifying dictionary data in Python<\/h2>\n\n\n\n
Dictionaries are mutable, which means you can change them after creation. This is either convenient or dangerous depending on your perspective.<\/p>\n\n\n
\nsettings = {"theme": "dark", "lang": "en"}\n\n# Add new key-value pair\nsettings["notifications"] = True\n\n# Update existing value\nsettings["theme"] = "light"\n\n# Update multiple values\nsettings.update({"lang": "es", "timezone": "UTC"})\n\nprint(settings)\n# {'theme': 'light', 'lang': 'es', 'notifications': True, 'timezone': 'UTC'}\n\n<\/pre><\/div>\n\n\n
The update() method merges another dictionary into the existing one. Any overlapping keys get overwritten. Any new keys get added.<\/p>\n\n\n\n
Removing items from Python dictionaries<\/h2>\n\n\n\n
Four different ways to delete things, each with different behavior.<\/p>\n\n\n
\ndata = {"a": 1, "b": 2, "c": 3}\n\n# pop() removes and returns the value\nvalue = data.pop("a")  # Returns 1\nvalue = data.pop("missing", "not found")  # Returns "not found"\n\n# del keyword removes by key\ndel data["b"]\n\n# popitem() removes and returns the last item (Python 3.7+)\nitem = data.popitem()  # Returns ('c', 3)\n\n# clear() nukes everything\ndata.clear()  # {}\n\n<\/pre><\/div>\n\n\n
I almost always use pop() because it handles missing keys gracefully with a default value. The del keyword is fine for quick scripts. Avoid popitem() unless you specifically need LIFO behavior.<\/p>\n\n\n\n
Looping through Python dictionaries<\/h2>\n\n\n\n
Dictionaries give you three ways to iterate, depending on whether you need keys, values, or both.<\/p>\n\n\n
\nscores = {"alice": 95, "bob": 87, "charlie": 92}\n\n# Iterate over keys (default behavior)\nfor name in scores:\n    print(name)\n\n# Iterate over values\nfor score in scores.values():\n    print(score)\n\n# Iterate over key-value pairs\nfor name, score in scores.items():\n    print(f"{name} scored {score}")\n\n<\/pre><\/div>\n\n\n
The items() method is what you want 90% of the time. It unpacks each key-value pair into separate variables, making your code way more readable than scores[name] everywhere.<\/p>\n\n\n\n
Dictionary comprehensions in Python<\/h2>\n\n\n\n
List comprehensions are great. Dictionary comprehensions are the same idea but for dicts.<\/p>\n\n\n
\n# Create dict from sequence\nnumbers = [1, 2, 3, 4, 5]\nsquares = {n: n**2 for n in numbers}\n# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n\n# Filter while building\nevens = {n: n**2 for n in numbers if n % 2 == 0}\n# {2: 4, 4: 16}\n\n# Transform existing dict\nprices = {"apple": 1.2, "banana": 0.5, "orange": 0.8}\nrounded = {k: round(v) for k, v in prices.items()}\n# {'apple': 1, 'banana': 0, 'orange': 1}\n\n<\/pre><\/div>\n\n\n
Comprehensions run faster than loops because they’re optimized at the bytecode level. They also force you to think declaratively, which usually results in cleaner code.<\/p>\n\n\n\n
Checking if keys exist in Python dictionaries<\/h2>\n\n\n\n
Three approaches, each with different performance characteristics.<\/p>\n\n\n
\nuser = {"name": "Alice", "email": "alice@example.com"}\n\n# in operator (fastest)\nif "name" in user:\n    print("Name exists")\n\n# get() with default\nemail = user.get("email", "no-email@example.com")\n\n# keys() method (unnecessary, avoid)\nif "name" in user.keys():  # Don't do this\n    print("Slower than necessary")\n\n<\/pre><\/div>\n\n\n
The in<\/code> operator checks membership directly on the hash table. It’s fast and readable. Using user.keys() adds an extra method call for zero benefit.<\/p>\n\n\n\n
Common Python dictionary methods you’ll actually use<\/h2>\n\n\n
\ndata = {"x": 10, "y": 20}\n\n# Get all keys\nkeys = data.keys()  # dict_keys(['x', 'y'])\n\n# Get all values\nvalues = data.values()  # dict_values([10, 20])\n\n# Get all items\nitems = data.items()  # dict_items([('x', 10), ('y', 20)])\n\n# setdefault() adds key only if missing\ndata.setdefault("z", 30)  # Adds z: 30\ndata.setdefault("x", 99)  # Leaves x: 10 unchanged\n\n<\/pre><\/div>\n\n\n
The setdefault() method is weirdly useful for building nested structures without checking existence every time.<\/p>\n\n\n\n
Merging dictionaries in Python<\/h2>\n\n\n\n
Python 3.9 added the merge operator, which is cleaner than anything that came before.<\/p>\n\n\n
\ndefaults = {"color": "blue", "size": "medium"}\ncustom = {"size": "large", "material": "cotton"}\n\n# Merge operator (Python 3.9+)\nfinal = defaults | custom\n# {'color': 'blue', 'size': 'large', 'material': 'cotton'}\n\n# Old way (still works)\nfinal = {**defaults, **custom}\n\n# In-place update\ndefaults |= custom  # Modifies defaults directly\n\n<\/pre><\/div>\n\n\n
Values from the right side override the left. Simple as that.<\/p>\n\n\n\n
Dictionaries are fast because they use hash tables underneath. Lookup time is O(1) on average, meaning it takes the same time whether you have 10 items or 10 million. That’s why you see them everywhere in Python code, from argument parsing to caching to configuration management.<\/p>\n","protected":false},"excerpt":{"rendered":"
That’s a Python dictionary. Key-value pairs wrapped in curly braces, and you’re done. If you’ve been programming for more than five minutes, you’ve probably used a dictionary without realizing it. They’re everywhere because they solve a fundamental problem: computers are great at remembering things, but only if you label them properly. Creating Python dictionaries from […]<\/p>\n","protected":false},"author":6,"featured_media":65748,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5],"tags":[],"class_list":["post-535","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-dictionary"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/535","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/comments?post=535"}],"version-history":[{"count":0,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/535\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media\/65748"}],"wp:attachment":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media?parent=535"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/categories?post=535"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/tags?post=535"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}