Python Sets — The Complete Guide to Methods

The Story That Explains Sets 🎟️Sets समझाने वाली कहानी 🎟️一个解释集合的故事 🎟️

A Python set is an unordered collection of unique, hashable items. It borrows union, intersection and difference from mathematics, and adds very fast membership tests. Every duplicate you give it is quietly dropped. Most membership questions are answered in one hop.

Python का set अनोखे, hashable items का बिना क्रम वाला संग्रह है। यह गणित से union, intersection और difference लेता है, और साथ में बहुत तेज़ membership जाँच देता है। आप जो भी duplicate देते हैं, वह चुपचाप हटा दिया जाता है। ज़्यादातर membership सवालों का जवाब एक ही छलाँग में मिल जाता है।

Python 的 set 是由不重复、可哈希元素组成的无序集合。它从数学中借来了并集、交集和差集，再加上非常快的成员检查。你放进去的每个重复项都会被悄悄丢掉。大多数成员检查一步就能得到答案。

The Three Laws of Every Set ⚖️हर Set के तीन नियम ⚖️每个 set 的三条定律 ⚖️

Before the syntax, learn the three properties that define every set. Every method, every operation and every edge case comes from these rules.

Syntax से पहले वे तीन गुण सीखें जो हर set को परिभाषित करते हैं। हर method, हर operation और हर ख़ास स्थिति इन्हीं नियमों से निकलती है।

在学语法之前，先记住定义每个 set 的三个性质。每个方法、每个运算和每种特殊情况都来自这些规则。

Creating a Set — Four Ways 🛠️Set बनाना — चार तरीके 🛠️创建 set — 四种方法 🛠️

# 1) Literal — the cleanest and most common
colours = {"red", "green", "blue"}

# 2) From an iterable using the set() constructor
letters = set("hello")          # 'l' appears twice, kept once
nums    = set([1, 2, 2, 3, 3])   # {1, 2, 3}

# 3) Set comprehension — filter + transform in one step
squares = {n ** 2 for n in range(6)}

# 4) Empty set — the ONE case where the {} literal fails
empty = set()      # CORRECT — empty set
oops  = {}         # WRONG — this is an empty DICT, not a set!

print(colours)     # string order changes from run to run
print(letters)
print(nums)
print(squares)
print(empty)
print(type(oops).__name__)  # dict, not set

One Surprise: 1, 1.0 and True Are the Same Itemएक हैरानी: 1, 1.0 और True एक ही Item हैं一个意外：1、1.0 和 True 是同一个元素

A set decides "duplicate" with two checks: same hash and ==. Numbers that are equal also have equal hashes, so they collapse into one item even if their types differ.

Set "duplicate" का फ़ैसला दो जाँचों से करता है: hash बराबर और ==। बराबर numbers के hash भी बराबर होते हैं, इसलिए अलग types होने पर भी वे एक ही item बन जाते हैं।

set 用两个检查来判断 "重复"：hash 相同 和 ==。相等的数字 hash 也相等，所以即使类型不同，它们也会合并成一个元素。

# 1, 1.0 and True are equal AND have the same hash
print(1 == 1.0 == True)
print(hash(1), hash(1.0), hash(True))

# So a set keeps only the first one it sees
print({1, 1.0, True})
print({True, 1, 1.0})
print(len({0, 0.0, False, "0"}))   # "0" is text, so it stays

Try It — Set Builder (Inside the Hash Table)करके देखें — Set Builder (Hash Table के अंदर)动手试试 — Set Builder（哈希表内部）

Why does set([3, 1, 4, 1, 5]) print in its own order? Build a set one item at a time and watch. Each item is hashed, the hash picks a slot, and duplicates are caught when they land on an equal item. Printing walks the slots in order — that is the "unordered" order.

set([3, 1, 4, 1, 5]) अपने ही क्रम में क्यों print होता है? एक-एक item डालकर set बनाइए और देखिए। हर item का hash बनता है, hash एक slot चुनता है, और बराबर item पर पहुँचते ही duplicate पकड़ा जाता है। Print slots को क्रम से पढ़ता है — यही "बिना क्रम" वाला क्रम है।

为什么 set([3, 1, 4, 1, 5]) 按它自己的顺序打印？一个一个地加入元素来建 set 并观察。每个元素先计算 hash，hash 选出一个 slot，落到相等元素上时就发现了重复。打印时按 slot 顺序走 — 这就是 "无序" 的顺序。

Adding & Removing — The Mutation Methods ✏️जोड़ना और हटाना — बदलने वाले Methods ✏️添加与删除 — 修改方法 ✏️

fruits = {"apple", "banana"}

fruits.add("cherry")          # adds one item
fruits.add("apple")           # no change — silent duplicate

fruits.update(["kiwi", "mango"]) # adds both from a list
fruits.update("AB")              # adds 'A' AND 'B' — strings are iterable!
print(len(fruits))

fruits.discard("kiwi")          # removes safely, silent if absent
fruits.discard("grape")         # NOT there — but no error

try:
    fruits.remove("grape")      # NOT there — raises KeyError
except KeyError as e:
    print(f"KeyError: {e}")

random_fruit = fruits.pop()      # removes one arbitrary item
print(f"Popped: {random_fruit}")

fruits.clear()                   # now empty
print(f"After clear: {fruits}")

Try It — Mutation Method Simulatorकरके देखें — Mutation Method Simulator动手试试 — 修改方法模拟器

Run each method on fruits and compare before and after. Green items were added, red ones removed. Try the traps: add("apple") twice, update("AB") and remove("grape").

fruits पर हर method चलाएँ और पहले व बाद में की तुलना करें। हरे items जुड़े, लाल हटे। जाल आज़माएँ: add("apple") दो बार, update("AB") और remove("grape")।

在 fruits 上运行每个方法，对比 之前 和 之后。绿色的是加入的，红色的是删除的。试试这些陷阱：两次 add("apple")、update("AB") 和 remove("grape")。

Membership Testing — The Superpower ⚡Membership जाँच — असली ताक़त ⚡成员检查 — 超能力 ⚡

This is why sets exist. Checking whether an item is inside a collection is one of the most common jobs in programming, and sets do it in constant time on average — the size of the set does not matter.

Sets इसी काम के लिए बने हैं। कोई item संग्रह में है या नहीं, यह जाँचना programming का सबसे आम काम है, और sets इसे औसतन constant time में करते हैं — set का आकार मायने नहीं रखता।

这就是 set 存在的原因。检查某个元素是否在集合中，是编程中最常见的工作之一，而 set 能在 平均常数时间 内完成 — 与 set 的大小无关。

allowed_users = {"alice", "bob", "charlie", "diana"}

# The 'in' operator — O(1) on average, whatever the set size
print("alice" in allowed_users)     # True
print("eve" not in allowed_users)   # True

# Same test on a 1-million-item set — still about one step
big_set = set(range(1_000_000))
print(999_999 in big_set)          # True — instant

Worst case for the list (the last item), measured on Python 3.13.16. Your numbers will differ, but the shape will not: 1,000× more items means about 1,000× more time for the list, and no change for the set.

List का सबसे बुरा मामला (आख़िरी item), Python 3.13.16 पर नापा गया। आपके numbers अलग होंगे, पर रुझान नहीं: 1,000 गुना ज़्यादा items यानी list के लिए लगभग 1,000 गुना ज़्यादा समय, और set के लिए कोई बदलाव नहीं।

list 的最坏情况（最后一个元素），在 Python 3.13.16 上实测。你的数字会不同，但规律不变：元素多 1,000 倍，list 大约慢 1,000 倍，而 set 不变。

Try It — Membership Race: List vs Setकरके देखें — Membership दौड़: List बनाम Set动手试试 — 成员检查赛跑：list 对 set

Both hold the same numbers. Press Race and watch: the list looks at items one by one; the set computes one hash and jumps to a slot. Try a missing value to see the list's worst case.

दोनों में वही numbers हैं। Race दबाएँ और देखें: list एक-एक item देखती है; set एक hash निकालकर slot पर छलाँग लगाता है। List का सबसे बुरा मामला देखने के लिए कोई ग़ायब value आज़माएँ।

两者存着相同的数字。按 Race 观察：list 逐个查看元素；set 计算一次 hash 就跳到一个 slot。试一个不存在的值，看看 list 的最坏情况。

Set Operations — Visual Reference 🔵🔴Set Operations — चित्रों में 🔵🔴集合运算 — 图示 🔵🔴

This is where sets shine. Four jobs that would need nested loops with lists become a single symbol. The next four sections use the same two sets, a = {1, 2, 3, 4} and b = {3, 4, 5, 6}, so you can compare the results. In each Venn diagram the coloured region is the result.

यहीं sets चमकते हैं। चार काम जिनके लिए lists में nested loops लगते, एक अकेला चिह्न बन जाते हैं। अगले चार sections में वही दो sets हैं, a = {1, 2, 3, 4} और b = {3, 4, 5, 6}, ताकि आप results की तुलना कर सकें। हर Venn चित्र में रंगीन हिस्सा ही result है।

这正是 set 的强项。用 list 需要嵌套循环的四件事，变成了 一个符号。接下来四节都用同样的两个 set：a = {1, 2, 3, 4} 和 b = {3, 4, 5, 6}，方便你比较结果。每个韦恩图中，着色部分就是结果。

Union — A | B — Everything from BothUnion — A | B — दोनों से सब कुछ并集 — A | B — 两边的全部

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# Operator form — clean and Pythonic
print(a | b)              # {1, 2, 3, 4, 5, 6}

# Method form — accepts ANY iterable, not just sets
print(a.union(b, [7, 8])) # {1, 2, 3, 4, 5, 6, 7, 8}

# In-place version — changes a
a |= b
print(a)                  # {1, 2, 3, 4, 5, 6}

Intersection — A & B — Common Items Only 🤝Intersection — A & B — सिर्फ़ साझा Items 🤝交集 — A & B — 只要共同元素 🤝

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# Operator form
print(a & b)                       # {3, 4}

# Method form
print(a.intersection(b))            # {3, 4}

# Real use: users who are BOTH admins AND active
admins = {"alice", "bob", "charlie"}
active = {"bob", "charlie", "diana", "eve"}
active_admins = admins & active
print(f"Active admins: {sorted(active_admins)}")

Difference — A - B — In A but Not in B ➖Difference — A - B — A में, पर B में नहीं ➖差集 — A - B — 在 A 中但不在 B 中 ➖

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a - b)                       # {1, 2}  — in a, not in b
print(b - a)                       # {5, 6}  — in b, not in a
print(a.difference(b))              # {1, 2}

# Real use: which requested features are NOT yet built?
requested = {"dark_mode", "exports", "api_v2", "webhooks"}
built     = {"dark_mode", "exports"}
pending   = requested - built
print(f"Still to build: {sorted(pending)}")

Symmetric Difference — A ^ B — In One but Not Both 🔀Symmetric Difference — A ^ B — एक में, दोनों में नहीं 🔀对称差集 — A ^ B — 只在其中一个中 🔀

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a ^ b)                              # {1, 2, 5, 6}
print(a.symmetric_difference(b))          # {1, 2, 5, 6}
print((a | b) - (a & b))                  # same thing, the long way

# Real use: what changed between two snapshots?
yesterday = {"file_a.csv", "file_b.csv", "file_c.csv"}
today     = {"file_b.csv", "file_c.csv", "file_d.csv"}
changes = yesterday ^ today
print(f"Changed files: {sorted(changes)}")   # deleted + new

Operators vs Methods, and the In-Place VersionsOperators बनाम Methods, और In-Place रूप运算符与方法，以及原地修改版本

Each operation comes in three forms. The operator (|) needs sets on both sides. The method (.union()) accepts any iterable. The in-place form (|=, .update()) changes the set itself instead of building a new one.

हर operation के तीन रूप हैं। Operator (|) को दोनों तरफ़ sets चाहिए। Method (.union()) कोई भी iterable लेता है। In-place रूप (|=, .update()) नया set बनाने की जगह उसी set को बदल देता है।

每种运算都有三种形式。运算符（|）要求两边都是 set。方法（.union()）接受任何可迭代对象。原地形式（|=、.update()）直接修改这个 set，而不是创建新的。

a = {1, 2, 3}

# Operators need a set on BOTH sides...
try:
    print(a | [3, 4])
except TypeError as e:
    print("TypeError:", e)

# ...but the methods accept any iterable
print(a.union([3, 4]))             # list
print(a.intersection([2, 3, 9]))  # list
print(a.intersection("123"))       # set() — "1" is text, not the number 1
print(a.difference(range(2)))      # range

# In-place versions change the set itself and return None
s = {1, 2, 3, 4}
s &= {2, 3, 9}                      # same as s.intersection_update(...)
print(s)
s -= {3}                            # same as s.difference_update(...)
print(s)
s ^= {2, 7}                         # same as s.symmetric_difference_update(...)
print(s)
print(s.update([8]))                # in-place methods return None

Try It — Venn Operation Lab (All Four Operations)करके देखें — Venn Operation Lab (चारों Operations)动手试试 — 韦恩运算实验室（全部四种运算）

Type two sets and pick an operation. The diagram sorts every item into its region, then the lab walks through the items the same way CPython does — for example, & loops over the smaller set. The green regions are the result.

दो sets लिखें और एक operation चुनें। चित्र हर item को उसके हिस्से में रखता है, फिर lab items पर वैसे ही चलता है जैसे CPython — उदाहरण के लिए, & छोटे set पर loop चलाता है। हरे हिस्से result हैं।

输入两个 set 并选择一种运算。图会把每个元素放进它的区域，然后实验室按 CPython 的方式逐个处理元素 — 例如 & 遍历 较小的 set。绿色区域就是结果。

Set Relationships — Subset, Superset, Disjoint 🧩Set के रिश्ते — Subset, Superset, Disjoint 🧩集合关系 — 子集、超集、不相交 🧩

Sets can also be compared as wholes. Is one set completely inside another? Do two sets share nothing at all? Each question has a one-call answer.

Sets की पूरी तरह तुलना भी हो सकती है। क्या एक set पूरी तरह दूसरे के अंदर है? क्या दो sets में कुछ भी साझा नहीं? हर सवाल का जवाब एक call में मिलता है।

set 也可以作为整体来 比较。一个 set 是否完全在另一个里面？两个 set 是否完全没有共同元素？每个问题都只需一次调用。

a = {1, 2, 3, 4, 5}
b = {2, 3}
c = {7, 8, 9}

# Subset — is every item of b also in a?
print(b.issubset(a))          # True
print(b <= a)                  # True  (operator form)
print(b < a)                   # True  (STRICT subset — b != a)
print(a < a, a <= a)           # False True — never a strict subset of itself

# Superset — the mirror question
print(a.issuperset(b))        # True
print(a >= b)                  # True

# Disjoint — do they share ZERO items?
print(a.isdisjoint(c))        # True — nothing in common
print(a.isdisjoint(b))        # False — they overlap

Try It — Relationship Checkerकरके देखें — Relationship Checker动手试试 — 关系检查器

Pick a comparison and see how Python answers it. Notice the shortcuts: a size check first, and the loop stops at the first item that fails.

कोई तुलना चुनें और देखें कि Python उसका जवाब कैसे देता है। Shortcuts पर ध्यान दें: पहले आकार की जाँच, और पहला असफल item मिलते ही loop रुक जाता है।

选择一种比较，看 Python 怎样回答。注意其中的捷径：先做 大小检查，遇到第一个不满足的元素循环就停止。

Frozenset — The Unchangeable Cousin 🧊Frozenset — न बदलने वाला भाई 🧊Frozenset — 不可变的兄弟 🧊

A normal set can change — you can add and remove items. Sometimes you need a hashable, unchangeable version: an item inside another set, a dictionary key, or a value that must never change. That is frozenset.

साधारण set बदल सकता है — आप items जोड़ और हटा सकते हैं। कभी-कभी आपको hashable, न बदलने वाला रूप चाहिए: किसी दूसरे set के अंदर item, dictionary key, या ऐसी value जो कभी न बदले। वही frozenset है।

普通 set 可以修改 — 你可以添加和删除元素。有时你需要一个 可哈希、不可变 的版本：作为另一个 set 的元素、作为字典的 key，或作为永远不变的值。这就是 frozenset。

# Create a frozenset from any iterable
permissions = frozenset(["read", "write", "delete"])

# All non-changing operations still work
print("read" in permissions)               # True
bigger = permissions | {"admin"}           # returns a NEW frozenset
print(type(bigger).__name__, len(bigger))

# But changing it is forbidden
try:
    permissions.add("admin")
except AttributeError as e:
    print(f"Blocked: {e}")

# Because it's hashable, a frozenset can be:
# 1) an item of another set
role_bundles = {
    frozenset({"read"}),
    frozenset({"read", "write"}),
    frozenset({"read", "write", "admin"})
}
print(len(role_bundles))                    # 3

# 2) a dictionary key
cache = {
    frozenset(["a", "b"]): "result_ab",
    frozenset(["c", "d"]): "result_cd",
}
print(cache[frozenset(["b", "a"])])       # order doesn't matter

Try It — Frozenset Labकरके देखें — Frozenset Lab动手试试 — Frozenset 实验室

A small Python console with two variables: a frozenset perms and an empty set bundles. Click the lines in order, or type your own. Watch which ones Python blocks, and why.

दो variables वाला छोटा Python console: एक frozenset perms और एक खाली set bundles। Lines को क्रम से click करें, या अपनी लिखें। देखें Python किन्हें रोकता है, और क्यों।

一个带两个变量的小 Python 控制台：frozenset perms 和空 set bundles。按顺序点击这些行，或自己输入。观察 Python 拦下了哪些，以及原因。

Practical Real-World Examples 🌍असल ज़िंदगी के उदाहरण 🌍实际应用示例 🌍

Example 1 — Instant Deduplication of a Listउदाहरण 1 — List से तुरंत Duplicates हटाना示例 1 — 一步给 list 去重

emails = ["alice@ex.com", "bob@ex.com", "alice@ex.com",
          "eve@ex.com", "bob@ex.com"]

# One line — order NOT kept (it can change from run to run)
unique_emails = list(set(emails))
print(len(unique_emails), "unique")

# If order matters, keep the first time each one appears with dict.fromkeys()
unique_ordered = list(dict.fromkeys(emails))
print(unique_ordered)

list(set(emails)) loses the order, so its printed order changes from run to run. dict.fromkeys() keeps the first time each email appears, because dicts remember insertion order (Python 3.7+).

list(set(emails)) क्रम खो देता है, इसलिए उसका print क्रम हर run में बदलता है। dict.fromkeys() हर email के पहली बार आने का क्रम रखता है, क्योंकि dicts डालने का क्रम याद रखते हैं (Python 3.7+)।

list(set(emails)) 会丢失顺序，所以它的打印顺序每次运行都会变。dict.fromkeys() 保留每个邮箱 第一次 出现的顺序，因为 dict 会记住插入顺序（Python 3.7+）。

Example 2 — Permission Checkingउदाहरण 2 — Permission जाँच示例 2 — 权限检查

required_perms  = {"read", "write"}
user_perms      = {"read", "write", "delete", "share"}

# Does the user have EVERY required permission?
if required_perms <= user_perms:
    print("Access granted")
else:
    missing = required_perms - user_perms
    print(f"Missing: {missing}")

Example 3 — Tag-Based Recommendationsउदाहरण 3 — Tags पर आधारित सुझाव示例 3 — 基于标签的推荐

user_tags    = {"python", "data-science", "ml", "stats"}
article_tags = {"python", "ml", "deep-learning"}

# Match score = shared tags / all tags
overlap = user_tags & article_tags
score = len(overlap) / len(user_tags | article_tags)

print(f"Common interests: {sorted(overlap)}")
print(f"Jaccard similarity: {score:.2%}")

Example 4 — Finding What Changedउदाहरण 4 — क्या बदला, यह खोजना示例 4 — 找出变化

old_snapshot = {"config.yaml", "main.py", "utils.py", "data.csv"}
new_snapshot = {"config.yaml", "main.py", "helpers.py", "data.csv"}

added     = new_snapshot - old_snapshot
removed   = old_snapshot - new_snapshot
unchanged = old_snapshot & new_snapshot

print(f"Added:     {added}")
print(f"Removed:   {removed}")
print(f"Unchanged: {sorted(unchanged)}")

Example 5 — Fast Filtering Against a Blocklistउदाहरण 5 — Blocklist से तेज़ छँटाई示例 5 — 用黑名单快速过滤

import time

# A million user IDs coming through
incoming_ids = range(1_000_000)

# 50,000 banned IDs — as a SET for O(1) lookup
banned = set(range(0, 1_000_000, 20))

start = time.perf_counter()
allowed = [uid for uid in incoming_ids if uid not in banned]
secs = time.perf_counter() - start

print(f"Allowed: {len(allowed):,}")
print(f"Blocked: {len(banned):,}")
print(f"Time with a set: {secs:.2f} s")

Try It — Pattern Stepperकरके देखें — Pattern Stepper动手试试 — 模式步进器

Step through the real-world patterns one line at a time. Edit the inputs to test your own data. The first tab shows the classic "remove duplicates but keep the order" loop, which pairs a set with a list.

असल ज़िंदगी के patterns को एक-एक line करके चलाएँ। अपने data से जाँचने के लिए inputs बदलें। पहला tab मशहूर "duplicates हटाओ पर क्रम रखो" loop दिखाता है, जिसमें set और list साथ काम करते हैं।

一行一行地执行这些实际模式。修改输入来测试你自己的数据。第一个标签页展示经典的 "去重但保留顺序" 循环，它把 set 和 list 搭配使用。

Performance — List vs Set for Membership 🏁Performance — Membership में List बनाम Set 🏁性能 — 成员检查中的 list 与 set 🏁

import timeit

# Same 100,000 items — stored as list vs set
data_list = list(range(100_000))
data_set  = set(data_list)

# Worst case for the list: search for the last item
target = 99_999

t_list = timeit.timeit(lambda: target in data_list, number=10_000)
t_set  = timeit.timeit(lambda: target in data_set,  number=10_000)

print(f"List lookup: {t_list:.4f}s")
print(f"Set lookup:  {t_set:.4f}s")
print(f"Set is about {t_list / t_set:,.0f}x faster")

Real run on Python 3.13.16. The ratio depends on your machine, but the set always wins by thousands of times for this worst case.

Python 3.13.16 पर असली run। अनुपात आपकी मशीन पर निर्भर है, पर इस सबसे बुरे मामले में set हमेशा हज़ारों गुना आगे रहता है।

在 Python 3.13.16 上的真实运行。倍数取决于你的机器，但在这种最坏情况下，set 总是快几千倍。

Memory is sys.getsizeof() of the container only: a set keeps a hash table with empty slots and a stored hash per item, so it needs more room than a list.

Memory सिर्फ़ container का sys.getsizeof() है: set खाली slots वाली hash table और हर item का hash रखता है, इसलिए उसे list से ज़्यादा जगह चाहिए।

内存只算容器本身的 sys.getsizeof()：set 要维护一张带空 slot 的哈希表，还要为每个元素存 hash，所以比 list 占更多空间。

When NOT to Use a Set 🚫Set कब इस्तेमाल न करें 🚫什么时候不要用 set 🚫

# Lists inside a set fail with TypeError: unhashable type
try:
    bad = {[1, 2], [3, 4]}
except TypeError as e:
    print(f"Nope: {e}")

# FIX — convert inner lists to tuples (immutable, hashable)
good = {(1, 2), (3, 4)}
print(good)                            # works!

# A set inside a set fails too — use frozenset
try:
    nested = {{1, 2}}
except TypeError as e:
    print(f"Nope: {e}")
print({frozenset({1, 2})})

Complete Method Reference 📚सभी Methods की सूची 📚方法完整参考 📚

Python 3.13.16 sets have 17 public methods. The (*iters) methods accept several iterables at once, for example s.union([1], (2,), "ab"). A frozenset has only the 8 methods that do not change it.

Python 3.13.16 के sets में 17 public methods हैं। (*iters) वाले methods एक साथ कई iterables लेते हैं, जैसे s.union([1], (2,), "ab")। Frozenset में सिर्फ़ वे 8 methods हैं जो उसे बदलते नहीं।

Python 3.13.16 的 set 有 17 个公共方法。带 (*iters) 的方法可以一次接收多个可迭代对象，例如 s.union([1], (2,), "ab")。frozenset 只有不修改自身的 8 个方法。

Golden Rules 🏆सुनहरे नियम 🏆黄金法则 🏆

Quick Checkछोटी जाँच小测验

Seven questions on sets. Pick an answer to see why.

Sets पर सात सवाल। जवाब चुनें और कारण देखें।

关于 set 的七道题。选择答案查看解释。