Python Curly Brackets: Dictionaries, Sets, and f-Strings

Quick answer: Python curly brackets create dictionaries and sets, and they also delimit replacement fields in f-strings. Use colons for dictionary key-value pairs, commas for set items, and doubled braces when a formatted string must display a literal brace.

Python curly brackets infographic comparing dictionaries, sets, f-string replacement fields, literal braces, and container choices — Curly brackets have different jobs in Python; choose the container or formatting rule that matches the data.

Python curly brackets are used in a few specific places, but they do not define code blocks the way they do in languages such as JavaScript, C, or Java. Python uses indentation for blocks. Curly brackets mainly appear in dictionary literals, set literals, comprehensions, f-strings, and str.format() templates.

This distinction matters because braces can mean different things depending on context. An empty pair creates a dictionary, a pair with comma-separated values creates a set, and a pair inside a string can mark a replacement field. Reading the surrounding syntax tells you which meaning Python is using.

A good rule is to look for colons, commas, and string prefixes. Colons inside braces usually point to a dictionary. Commas without colons usually point to a set. Braces after an f string prefix belong to formatting, not collection syntax.

If you are comparing bracket types, square brackets normally create lists or index into a sequence, parentheses group expressions or create tuples, and curly brackets create mappings, sets, or string-format placeholders. For list-specific cleanup, see the remove brackets from list in Python guide.

Contents

Curly Brackets Create Dictionaries

The most common use of curly brackets is a dictionary. A dictionary stores key-value pairs and lets you look up a value by key. The official Python dictionary documentation covers the core behavior.

student = {
    "name": "Maya",
    "language": "Python",
    "score": 92,
}

print(student["name"])
print(student.get("score"))

Each key appears before a colon, and each value appears after it. Keys are commonly strings, numbers, or tuples of immutable values. A dictionary is a good fit when each item has a label and you need fast lookup by that label.

Empty Curly Brackets Mean Dictionary

A common gotcha is that {} creates an empty dictionary, not an empty set. To create an empty set, call set(). If there is at least one value and no colon, Python treats the braces as a set literal.

empty_dict = {}
empty_set = set()
numbers = {2, 3, 5, 7}

print(type(empty_dict).__name__)
print(type(empty_set).__name__)
print(3 in numbers)

Sets are useful when uniqueness matters. They automatically remove duplicate values and support membership checks, unions, intersections, and differences. Dictionaries and sets both use braces, but the colon separates dictionary syntax from set syntax.

Python Pool infographic showing curly braces creating dictionaries, keys, values, and lookup — Dictionary: Curly braces creating dictionaries, keys, values, and lookup.

Curly Brackets In Comprehensions

Curly brackets also appear in set comprehensions and dictionary comprehensions. A set comprehension builds a set from a loop expression. A dictionary comprehension builds key-value pairs and therefore includes a colon inside the braces.

words = ["python", "pool", "python", "guide"]

unique_lengths = {len(word) for word in words}
word_lengths = {word: len(word) for word in words}

print(unique_lengths)
print(word_lengths)

This form is compact but still should stay readable. If the expression becomes hard to scan, expand it into a normal loop. Curly brackets do not make the loop run differently; they only choose the collection that the comprehension returns.

Curly Brackets In F-Strings

In an f-string, single curly brackets evaluate an expression. To show a literal brace in the final string, double it. The Python f-string documentation explains the full replacement-field grammar.

name = "Maya"
score = 92

message = f"{name} scored {score}%"
literal = f"Use {{name}} as a placeholder in docs"

print(message)
print(literal)

F-strings are usually the clearest choice when the values are already in scope. Keep expressions inside braces short. If a calculation needs more than a quick lookup or simple formatting, compute it before building the string.

Python Pool infographic comparing set literals, duplicates, membership, and empty set syntax — Set values: Set literals, duplicates, membership, and empty set syntax.

Curly Brackets With str.format()

The older str.format() method also uses curly brackets as replacement fields. You can pass positional or named arguments, and you can escape literal braces with doubled braces. The format string syntax documentation lists the available options.

template = "{name} has {count} open tasks"
result = template.format(name="Maya", count=3)

escaped = "Set literal example: {{1, 2, 3}}"

print(result)
print(escaped.format())

This method remains useful when a template is stored separately from the values used to fill it. As with f-strings, braces in the template are not dictionary or set syntax because they are inside a string.

Python Pool infographic mapping braces inside f-strings to expressions, formatting, and output — f-Strings: Braces inside f-strings to expressions, formatting, and output.

Python Does Not Use Braces For Blocks

Curly brackets do not replace indentation in Python. A colon starts a block header such as if, for, while, def, or class, and indentation defines the body. Braces inside that body still keep their normal dictionary, set, or formatting meaning.

results = {"passed": 3, "failed": 1}

if results["passed"] > results["failed"]:
    print("Most checks passed")
else:
    print("Review the failing checks")

If you see an error after copying code from another language, check for unnecessary braces around blocks. Python expects indentation instead. For a related bracket-related error, see the tuple object is not callable guide.

The safest way to read Python curly brackets is to ask where they appear. Outside strings, braces usually create dictionaries, sets, or comprehensions. Inside strings, braces usually mark replacement fields. They never define Python blocks, so indentation remains part of the language syntax.

Dictionary Braces And Set Braces

{key: value} creates a dictionary entry, while {item1, item2} creates a set. An empty pair of braces creates an empty dictionary; use set() for an empty set. That small distinction prevents a common type mistake.

record = {"name": "Karan", "visits": 3}
tags = {"python", "seo", "docs"}
empty_dict = {}
empty_set = set()

print(record["name"])
print(tags)

Python Pool infographic testing braces, nesting, quoting, unpacking, and validation — Syntax checks: Braces, nesting, quoting, unpacking, and validation.

Braces Inside f-Strings

In an f-string, a single pair of braces evaluates an expression. To display a literal opening or closing brace, double it as {{ or }}. Keep expressions readable and avoid using formatting syntax as a substitute for validation or escaping.

Choose The Container And Escape Policy

Use a dictionary when keys map to values, a set when uniqueness and membership matter, and a list when order and duplicates are part of the data. When braces appear in JSON-like text or templates, distinguish Python syntax from the output format and test both the data and its rendered representation.