Python List, Dict & Set Comprehensions

The Story That Explains Comprehensions 🧃Comprehensions समझाने वाली कहानी 🧃一个讲清推导式的故事 🧃

A comprehension is Python's way of building a new collection — a list, dict or set — from an existing iterable in one readable expression. It replaces the classic "make an empty container → loop → append" pattern with one line that reads almost like English.

Comprehension Python का तरीका है जिससे किसी मौजूदा iterable से एक नया collection — list, dict या set — एक पढ़ने लायक expression में बनाया जाता है। यह पुराने "ख़ाली container बनाओ → loop → append" pattern की जगह एक line देता है जो लगभग अंग्रेज़ी जैसी पढ़ी जाती है।

推导式 是 Python 用一个易读的表达式、从已有可迭代对象构建新集合 — 列表、字典 或 集合 — 的方式。它用一行几乎像英语一样的代码，取代了经典的"建空容器 → 循环 → append"模式。

The Universal Syntax 🧠सबके लिए एक Syntax 🧠通用语法 🧠

List, dict and set comprehensions share the same skeleton. Learn one shape and you know all three. Only the brackets and the output part change.

List, dict और set comprehensions का ढाँचा एक ही है। एक आकार सीखें और तीनों आ जाते हैं। सिर्फ़ brackets और output वाला हिस्सा बदलता है।

列表、字典和集合推导式共用同一个骨架。学会一种，三种都会了。只有括号和输出部分不同。

List Comprehensions — The Workhorse 🐎List Comprehensions — मेहनती घोड़ा 🐎列表推导式 — 主力军 🐎

List comprehensions are the most common kind. Use one anywhere you would otherwise write a for loop that appends to a list.

List comprehensions सबसे आम हैं। जहाँ भी आप list में append करने वाला for loop लिखते, वहाँ इसे इस्तेमाल करें।

列表推导式最常见。凡是你本来要写一个往列表 append 的 for 循环的地方，都可以用它。

The Loop You Have Always Writtenवह Loop जो आप हमेशा लिखते आए हैं你一直在写的循环

# The old way - 4 lines to square 10 numbers
squares = []
for n in range(10):
    squares.append(n ** 2)

print(squares)

The Comprehension That Replaces Itउसकी जगह लेने वाली Comprehension取代它的推导式

# One line. Same result. Clearer intent.
squares = [n ** 2 for n in range(10)]

print(squares)

Adding a FilterFilter जोड़ना加上过滤

# Only even numbers, squared
even_squares = [n ** 2 for n in range(10) if n % 2 == 0]

# Cleaning a list of user inputs
raw = ["  Aarav ", "", "Meera", None, "  Kabir", "   "]
clean = [name.strip() for name in raw if name and name.strip()]

print(even_squares)
print(clean)

Notice the filter if name and name.strip(): name alone drops None and "", and name.strip() also drops " " (only spaces). Without it, an empty string would sneak into the result.

Filter if name and name.strip() पर ध्यान दें: अकेला name, None और "" हटाता है, और name.strip(), " " (सिर्फ़ spaces) भी हटाता है। इसके बिना एक ख़ाली string नतीजे में घुस जाती।

注意过滤条件 if name and name.strip()：单独的 name 能去掉 None 和 ""，name.strip() 还能去掉 " "（只有空格）。少了它，一个空字符串就会混进结果。

Dict Comprehensions — Building Mappings 🔑Dict Comprehensions — Mappings बनाना 🔑字典推导式 — 构建映射 🔑

Dict comprehensions are perfect for transforming, inverting or filtering key-value data. The shape is the same as a list comprehension, but the output is a key: value pair.

Dict comprehensions key-value data को बदलने, उलटने या filter करने के लिए बढ़िया हैं। आकार list comprehension जैसा ही है, पर output एक key: value जोड़ी है।

字典推导式非常适合转换、反转或过滤键值数据。形状与列表推导式相同，只是输出是一个 key: value 对。

Building a Lookup TableLookup Table बनाना构建查找表

# Number -> its square (classic use case)
square_map = {n: n ** 2 for n in range(6)}
print(square_map)

Inverting a Dict (Keys ↔ Values)Dict उलटना (Keys ↔ Values)反转字典（键 ↔ 值）

country_capital = {"India": "New Delhi", "France": "Paris", "Japan": "Tokyo"}

# Flip it - capitals become keys
capital_country = {v: k for k, v in country_capital.items()}
print(capital_country)

# Careful: if two keys share a value, the LAST one wins
team = {"Aarav": "red", "Meera": "blue", "Kabir": "red"}
by_colour = {colour: name for name, colour in team.items()}
print(by_colour)          # Aarav was silently overwritten

Filtering a Dict by ValueValue से Dict Filter करना按值过滤字典

prices = {"apple": 120, "bread": 45, "milk": 60, "paneer": 420}

# Keep items under Rs 100
affordable = {item: price for item, price in prices.items() if price < 100}

print(affordable)

Building a Dict from Two Listsदो Lists से Dict बनाना用两个列表构建字典

names = ["Aarav", "Meera", "Kabir"]
scores = [85, 92, 78]

# zip() pairs them; the comprehension builds the dict
report = {name: score for name, score in zip(names, scores)}
print(report)

# For a plain pairing, dict(zip(...)) does the same job
print(dict(zip(names, scores)))

Set Comprehensions — Instant Deduplication 🎯Set Comprehensions — तुरंत Duplicates हटाना 🎯集合推导式 — 瞬间去重 🎯

Set comprehensions look like dict comprehensions without the colon. They build a set — a collection of unique items with no fixed order. Perfect whenever you want distinct results.

Set comprehensions बिना colon वाली dict comprehensions जैसी दिखती हैं। ये set बनाती हैं — अनोखे items का collection, बिना तय क्रम के। जब भी अलग-अलग नतीजे चाहिए, बढ़िया।

集合推导式看起来像 没有冒号 的字典推导式。它构建集合 — 元素唯一、没有固定顺序 的集合。需要去重结果时非常合适。

Unique Words from a Sentenceएक वाक्य के अनोखे शब्द句子中的不重复单词

text = "The quick brown fox jumps over the lazy dog the fox is quick"

# Unique words, all lowercase
unique_words = {w.lower() for w in text.split()}

print(unique_words)                  # order is not fixed!
print(sorted(unique_words))          # sort when you need a stable order
print(f"Distinct word count: {len(unique_words)}")

Unique File Extensions in a FolderFolder के अनोखे File Extensions文件夹中不重复的扩展名

files = [
    "report.pdf", "data.csv", "summary.pdf",
    "chart.png", "raw.csv", "notes.md", "logo.png",
]

# Grab the extension of each file, dedupe automatically
extensions = {f.split(".")[-1] for f in files}
print(sorted(extensions))

How a Comprehension Runs — Step by Step ⚙️Comprehension कैसे चलती है — कदम-दर-कदम ⚙️推导式如何运行 — 一步一步 ⚙️

Try It — Comprehension Machineकरके देखें — Comprehension Machine动手试试 — 推导式机器

Build any comprehension from the parts below, then press Play. Watch each item leave the conveyor, meet the filter, get transformed and land in the container. The equivalent for loop lights up in step. Try dups with a set, and n % 3 with {expr: n}, to see duplicates and overwritten keys.

नीचे के हिस्सों से कोई भी comprehension बनाएँ, फिर चलाएँ दबाएँ। हर item को conveyor छोड़ते, filter से मिलते, बदलते और container में पहुँचते देखें। बराबर का for loop साथ-साथ जलता है। Duplicates और overwrite होती keys देखने के लिए dups के साथ set, और n % 3 के साथ {expr: n} आज़माएँ।

用下面的部件搭出任意推导式，然后点 播放。看每个元素离开传送带、经过过滤、被转换、落入容器。等价的 for 循环会同步高亮。试试 dups 配 set，以及 n % 3 配 {expr: n}，观察重复和被覆盖的键。

Conditionals — Filter vs Transform 🔀Conditionals — Filter बनाम Transform 🔀条件 — 过滤 vs 转换 🔀

An if can appear in two very different places in a comprehension. Mixing them up is the #1 beginner mistake.

Comprehension में if दो बिल्कुल अलग जगहों पर आ सकता है। इन्हें मिला देना शुरुआती लोगों की नंबर 1 ग़लती है।

if 可以出现在推导式中 两个完全不同的位置。把它们搞混是初学者的头号错误。

Side-by-Side Comparisonआमने-सामने तुलना并排比较

nums = [1, 2, 3, 4, 5, 6, 7, 8]

# FILTER: only keep even numbers -> shorter output
evens = [n for n in nums if n % 2 == 0]

# TRANSFORM: mark each number as "even" or "odd" -> same length
labels = ["even" if n % 2 == 0 else "odd" for n in nums]

# BOTH: label only numbers greater than 3
mixed = ["even" if n % 2 == 0 else "odd" for n in nums if n > 3]

print(evens)
print(labels)
print(mixed)

Try It — If-Position Labकरके देखें — If-Position Lab动手试试 — if 位置实验室

Pick a filter, a transform and where they go. The tiles show what happens to each of the numbers 1–8: dropped (✗), kept, or changed. The last two buttons are the broken forms — see the real error Python gives.

एक filter, एक transform और उनकी जगह चुनें। Tiles दिखाती हैं कि 1–8 की हर संख्या का क्या होता है: हटाई गई (✗), रखी गई, या बदली गई। आख़िरी दो buttons टूटे हुए रूप हैं — Python का असली error देखें।

选一个过滤、一个转换以及它们的位置。方块显示 1–8 每个数字的结果：被丢弃（✗）、保留或被改变。最后两个按钮是错误写法 — 看看 Python 给出的真实报错。

Here are the three classic mistakes and the exact messages Python gives:

ये तीन मशहूर ग़लतियाँ हैं और Python के ठीक-ठीक संदेश:

下面是三个经典错误，以及 Python 给出的确切信息：

bad = [
    "[n if n > 3 for n in nums]",              # if/else on the left needs else
    "[n for n in nums if n > 3 else 0]",       # a filter cannot have else
    "{k, v for k, v in pairs}",                # missing colon in a dict
]
for src in bad:
    try:
        compile(src, "demo", "eval")
    except SyntaxError as e:
        print(f"{src:36} -> SyntaxError: {e.msg}")

Nested Comprehensions — Flattening and Grids 🧮Nested Comprehensions — Flatten करना और Grids 🧮嵌套推导式 — 展平与网格 🧮

A comprehension can have several for clauses. The rule is simple: they run left to right in the same order as nested for loops written top to bottom.

एक comprehension में कई for clauses हो सकते हैं। नियम सरल है: वे बाएँ से दाएँ, उसी क्रम में चलते हैं जैसे ऊपर से नीचे लिखे nested for loops।

一个推导式可以有多个 for 子句。规则很简单：它们 从左到右运行，顺序与从上到下书写的嵌套 for 循环完全相同。

Flattening a Matrix (List of Lists → List)Matrix को Flatten करना (Lists की List → List)展平矩阵（列表的列表 → 列表）

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

# Outer loop first, inner loop second - same order as nested for loops
flat = [n for row in matrix for n in row]
print(flat)

Building a Matrix (a Comprehension Inside a Comprehension)Matrix बनाना (Comprehension के अंदर Comprehension)构建矩阵（推导式中的推导式）

# A 3x3 multiplication table - a list of lists
mult_table = [[i * j for j in range(1, 4)] for i in range(1, 4)]

for row in mult_table:
    print(row)

# Transpose: turn rows into columns
transposed = [[row[c] for row in mult_table] for c in range(3)]
print(transposed)

Careful — these two look alike but are different. [x for a in A for x in a] has two fors in one comprehension and gives a flat list. [[x for x in a] for a in A] puts a whole comprehension in the output part and gives a list of lists.

सावधान — ये दोनों एक जैसे दिखते हैं पर अलग हैं। [x for a in A for x in a] में एक comprehension में दो for हैं और यह flat list देता है। [[x for x in a] for a in A] output हिस्से में पूरी comprehension रखता है और lists की list देता है।

注意 — 这两种写法看似相同，其实不同。[x for a in A for x in a] 是一个推导式里有两个 for，得到 扁平 列表。[[x for x in a] for a in A] 把整个推导式放在输出部分，得到 列表的列表。

Cartesian Product (All Pairs)Cartesian Product (सारी जोड़ियाँ)笛卡尔积（所有组合）

colours = ["red", "blue"]
sizes = ["S", "M", "L"]

# Every colour x every size = 6 T-shirts
skus = [f"{c}-{s}" for c in colours for s in sizes]
print(skus)

Try It — Nested Loop Visualizerकरके देखें — Nested Loop Visualizer动手试试 — 嵌套循环可视化

Step through four nested comprehensions. The orange chip is the current value of each loop variable. Notice how the inner loop restarts every time the outer loop moves one step.

चार nested comprehensions को कदम-दर-कदम चलाएँ। नारंगी chip हर loop variable की मौजूदा value है। देखें कि बाहरी loop के एक कदम बढ़ते ही अंदरूनी loop फिर से शुरू होता है।

逐步执行四个嵌套推导式。橙色方块是每个循环变量的当前值。注意外层循环每前进一步，内层循环都会从头开始。

Practical Real-World Examples 🛠️असली दुनिया के उदाहरण 🛠️实用的真实示例 🛠️

Example 1 — Cleaning Messy CSV Dataउदाहरण 1 — गंदे CSV Data को साफ़ करना示例 1 — 清洗杂乱的 CSV 数据

raw_rows = [
    "  Aarav, 25 , aarav@example.com  ",
    "Meera,30,meera@example.com",
    "  Kabir , 28,kabir@example.com  ",
    "",  # blank row
]

# Split, strip whitespace, skip blanks - all in one pass
clean = [
    [field.strip() for field in row.split(",")]
    for row in raw_rows if row.strip()
]

for row in clean:
    print(row)

For real CSV files, use the built-in csv module — it handles commas inside quotes, which a simple split(",") cannot.

असली CSV files के लिए built-in csv module इस्तेमाल करें — यह quotes के अंदर के commas संभालता है, जो सीधा split(",") नहीं कर सकता।

处理真实 CSV 文件请用内置的 csv 模块 — 它能处理引号内的逗号，而简单的 split(",") 做不到。

Example 2 — Counting Word Frequenciesउदाहरण 2 — शब्दों की गिनती示例 2 — 统计词频

from collections import Counter

text = "the cat sat on the mat the cat is fat"
words = text.split()

# Works, but counts the whole list again for EVERY unique word
freq = {w: words.count(w) for w in words}
print(freq)

# Better: one pass, made for exactly this job
print(Counter(words).most_common(3))

Example 3 — Grouping Users by Domainउदाहरण 3 — Domain के हिसाब से Users को समूह में रखना示例 3 — 按域名分组用户

emails = ["aarav@gmail.com", "meera@yahoo.com",
          "kabir@gmail.com", "dev@outlook.com",
          "isha@yahoo.com", "rohan@notgmail.com"]

# Split once into (user, domain) pairs
pairs = [e.split("@") for e in emails]

# Group users under each domain (sorted, so the order is stable)
grouped = {
    d: [user for user, dom in pairs if dom == d]
    for d in sorted({dom for _, dom in pairs})
}

for domain, users in grouped.items():
    print(f"{domain}: {users}")

Example 4 — A Small Data Pipelineउदाहरण 4 — एक छोटी Data Pipeline示例 4 — 一个小型数据管道

transactions = [
    {"id": 1, "amount": 100, "status": "paid"},
    {"id": 2, "amount": 250, "status": "pending"},
    {"id": 3, "amount": 75,  "status": "paid"},
    {"id": 4, "amount": 500, "status": "paid"},
]

# IDs of paid transactions over Rs 100
big_paid = [t["id"] for t in transactions
            if t["status"] == "paid" and t["amount"] > 100]

# Total amount by status
statuses = sorted({t["status"] for t in transactions})
total_by_status = {
    s: sum(t["amount"] for t in transactions if t["status"] == s)
    for s in statuses
}

print("Big paid IDs:", big_paid)
print("Totals:      ", total_by_status)

Note the generator expression inside sum(...) — no extra brackets needed. Section 11 explains why it uses less memory.

sum(...) के अंदर generator expression पर ध्यान दें — अतिरिक्त brackets की ज़रूरत नहीं। Section 11 बताता है कि यह कम memory क्यों लेता है।

注意 sum(...) 里的生成器表达式 — 不需要额外括号。第 11 节解释它为什么更省内存。

Performance — Are Comprehensions Actually Faster? ⚡Performance — क्या Comprehensions सच में तेज़ हैं? ⚡性能 — 推导式真的更快吗？⚡

Usually, yes — but by less than people claim. Here is a real measurement: squaring 100,000 numbers, 100 times, four ways.

आमतौर पर हाँ — पर लोग जितना कहते हैं उससे कम। यह असली माप है: 100,000 संख्याओं का square, 100 बार, चार तरीकों से।

通常是的 — 但没有人们说的那么夸张。下面是真实测量：对 100,000 个数求平方，重复 100 次，四种写法。

import timeit

# Squaring 100,000 numbers - four different ways, 100 runs each
setup = "nums = range(100_000)"

tests = {
    "for loop + append": "result = []\nfor n in nums: result.append(n * n)",
    "list comprehension": "result = [n * n for n in nums]",
    "map + lambda": "result = list(map(lambda n: n * n, nums))",
    "generator into list": "result = list(n * n for n in nums)",
}
for name, stmt in tests.items():
    t = timeit.timeit(stmt, setup=setup, number=100)
    print(f"{name:20} {t:.3f}s")

Generator Expressions — The Lazy Cousin 🌱Generator Expressions — आलसी चचेरा भाई 🌱生成器表达式 — 懒惰的表亲 🌱

Swap the square brackets for round brackets and you get a generator expression. It looks like a list comprehension, but it produces values one at a time, only when asked — so it uses almost no memory, even for millions of items.

Square brackets की जगह गोल brackets लगाएँ और आपको generator expression मिलता है। यह list comprehension जैसा दिखता है, पर values एक-एक करके, सिर्फ़ माँगने पर बनाता है — इसलिए लाखों items के लिए भी लगभग कोई memory नहीं लेता।

把方括号换成 圆括号，就得到 生成器表达式。它看起来像列表推导式，但 一次只产生一个值，而且只在被请求时才产生 — 所以即使有几百万个元素，也几乎不占内存。

import sys, tracemalloc

N = 10_000_000

tracemalloc.start()
squares_list = [n ** 2 for n in range(N)]          # builds ALL values now
list_mb = tracemalloc.get_traced_memory()[0] / 1_000_000
del squares_list
tracemalloc.stop()

squares_gen = (n ** 2 for n in range(N))           # builds nothing yet
print(f"list comprehension:   {list_mb:,.0f} MB")
print(f"generator expression: {sys.getsizeof(squares_gen)} bytes")

# Both work with sum() - but only the generator is memory-safe
total = sum(n ** 2 for n in range(N))
print(f"Sum of squares 0-9,999,999: {total:,}")

These numbers are real. The list needed about 409 MB; the generator object is 200 bytes and stays that size no matter how big N is. Both give the same sum.

ये numbers असली हैं। List को लगभग 409 MB चाहिए थे; generator object 200 bytes का है और N कितना भी बड़ा हो, उतना ही रहता है। दोनों एक ही जोड़ देते हैं।

这些数字是真实的。列表需要约 409 MB；生成器对象只有 200 字节，无论 N 多大都保持不变。两者求和结果相同。

Lazy Means "Not Until You Ask"आलसी मतलब "जब तक माँगो नहीं"懒惰就是"你不要就不算"

def square(n):
    print(f"  computing {n}")
    return n * n

print("list comprehension:")
lst = [square(n) for n in range(3)]       # all work happens NOW
print("built:", lst)

print("generator expression:")
gen = (square(n) for n in range(3))       # nothing computed yet
print("created")
print("next ->", next(gen))
print("next ->", next(gen))
print("rest ->", list(gen))
print("again ->", list(gen))              # exhausted: one-shot only

Try It — Lazy vs Eagerकरके देखें — Lazy बनाम Eager动手试试 — 惰性 vs 急切

Left: a list comprehension does all the work at once. Right: a generator does nothing until you call next(). Click the buttons and watch when computing … appears. Below, the memory meter shows measured sizes.

बाएँ: list comprehension सारा काम एक साथ करती है। दाएँ: generator तब तक कुछ नहीं करता जब तक आप next() न बुलाएँ। Buttons दबाएँ और देखें computing … कब आता है। नीचे memory meter नापे गए sizes दिखाता है।

左边：列表推导式一次做完所有工作。右边：生成器在你调用 next() 之前什么都不做。点按钮，看 computing … 何时出现。下方的内存表显示实测大小。

Scope — What Stays Inside, and the Walrus Exception 🔒Scope — क्या अंदर रहता है, और Walrus का अपवाद 🔒作用域 — 什么留在里面，以及海象运算符的例外 🔒

The loop variable of a comprehension belongs to the comprehension. It does not overwrite a variable with the same name outside. There is one deliberate exception: a name assigned with the walrus operator := (Python 3.8+) is stored in the surrounding scope.

Comprehension का loop variable comprehension का ही होता है। यह बाहर के उसी नाम वाले variable को overwrite नहीं करता। एक जान-बूझकर अपवाद है: walrus operator := (Python 3.8+) से दिया गया नाम आसपास के scope में रखा जाता है।

推导式的循环变量属于推导式本身，不会覆盖外部同名变量。有一个有意设计的例外：用海象运算符 :=（Python 3.8+）赋值的名字会保存在外层作用域中。

n = "outer"
squares = [n * n for n in range(4)]
print(n)                        # the loop variable did not leak

# The walrus operator := is the one exception: it DOES leak
data = [3, 8, 12, 5]
big = [y for x in data if (y := x * 10) > 50]
print(big, y)                   # y is visible outside

The walrus here computes x * 10 once and uses it twice — in the filter and in the output. Handy, but use it sparingly; it makes a comprehension harder to read.

यहाँ walrus x * 10 एक बार गिनकर दो बार इस्तेमाल करता है — filter में और output में। काम का है, पर कम इस्तेमाल करें; इससे comprehension पढ़ना मुश्किल होता है।

这里海象运算符只计算一次 x * 10，却用了两次 — 在过滤条件和输出中。很方便，但要少用；它会让推导式更难读。

When NOT to Use a Comprehension 🚫Comprehension कब इस्तेमाल न करें 🚫什么时候不该用推导式 🚫

Comprehensions are powerful, but they do not replace every loop. Use a plain for loop when the logic no longer fits comfortably in one expression.

Comprehensions ताक़तवर हैं, पर हर loop की जगह नहीं लेतीं। जब logic एक expression में आराम से न समाए, तो सामान्य for loop इस्तेमाल करें।

推导式很强大，但不能取代所有循环。当逻辑无法舒适地放进一个表达式时，就用普通 for 循环。

Bad Idea — A Comprehension for Side Effectsबुरा विचार — Side Effects के लिए Comprehension坏主意 — 为副作用写推导式

users = ["aarav", "meera", "kabir"]

# DON'T DO THIS - building a throwaway list just to run print()
result = [print(user) for user in users]
print(result)                  # a list of None values, nobody needs it

# DO THIS instead
for user in users:
    print(user.title())

Comparison Table — All Four at a Glance 📋तुलना Table — चारों एक नज़र में 📋对比表 — 四种一览 📋

Golden Rules and Quick Quiz 🏆सुनहरे नियम और छोटा Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题