نوع دادهٔ Set در پایتون + بررسی جامع

Set(مجموعه) در زبان پایتون یک نوع داده برای نگهداری مجموعه‌ای از اقلام یکتا(بدون تکرار) و بدون ترتیب مشخص است(برعکس لیست) . به بیان ساده، در یک Set هیچ عنصر تکراری وجود ندارد و ترتیب خاصی برای عناصر در نظر گرفته نمی‌شود . این ویژگی باعث می‌شود Set برای کاربردهایی مانند بررسی عضویت (چک کردن سریع وجود یا عدم وجود یک مقدار در مجموعه) و حذف موارد تکراری از لیست‌ها یا سایر ساختارها بسیار مفید باشد. در واقع Set شبیه به مفهوم مجموعه در ریاضیات است؛ یعنی مجموعه‌ای از اعضا که هر کدام تنها یک‌بار در آن ظاهر می‌شوند.

به عنوان مثال، در کد زیر یک Set حاوی اسامی میوه‌ها تعریف شده که برخی اقلام در آن بیش از یک‌بار تکرار شده‌اند. مشاهده می‌کنید که در خروجی تکراری‌ها حذف می‌شوند و عملگر عضویت نتیجه‌ی درستی را بسیار سریع برمی‌گرداند:

				
					
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)            # {'orange', 'banana', 'pear', 'apple'}  (عناصر تکراری حذف شده‌اند)
print('orange' in basket)   # True  (بررسی عضویت)
print('crabgrass' in basket)  # False (عدم وجود عنصر در مجموعه)

در مثال بالا، مقدار ‘apple’ و ‘orange’ چند بار در تعریف مجموعه آمده‌اند اما در ساختار نهایی Set تنها یک‌بار ذخیره شده‌اند . همچنین دستور orange’ in basket’ به سرعت بررسی می‌کند که ‘orange’ یکی از اعضای مجموعه است یا خیر (در اینجا خروجی True است). در مقابل، crabgrass’ in basket’ در اینجا False برمی‌گرداند چون این مقدار در مجموعه وجود ندارد.

نحوه ساخت Set

در پایتون می‌توان به روش‌های مختلفی یک Set ایجاد کرد :

با قرار دادن عناصر به صورت لیست‌شده و جداشده با کاما داخل آکولاد { } یک Set Literals می‌سازیم. به عنوان مثال: {‘red’, ‘green’, ‘blue’} یک Set با سه رشته می‌سازد.
با استفاده از دستور ()set می‌توان مجموعه ساخت. برای نمونه: set([1, 2, 3, 3]) یک Set از اعداد می‌سازد (در اینجا مقدار 3 تکراری بوده و فقط یک‌بار در Set نهایی خواهد بود).

با به‌کارگیری set comprehension نیز می‌توان مجموعه‌های جدید تعریف کرد؛ برای مثال: {x for x in range(5)} که در بخش‌های بعد دربارهٔ آن توضیح می‌دهیم.

نکته: برای ایجاد یک مجموعه‌ی خالی باید از تابع ()set استفاده کنید و نوشتن {} به تنهایی یک دیکشنری خالی می‌سازد نه Set . در واقع {} در پایتون نوع داده‌ی دیکشنری است.

در کد زیر چند روش ساخت Set نمایش داده شده است:

				
					
# ۱) ایجاد ست با استفاده از آکولاد و عناصر ثابت
colors = {'red', 'green', 'blue'}
print(colors)   # {'blue', 'red', 'green'} (مثال خروجی، ترتیب ممکن است متفاوت باشد)

# ۲) تبدیل یک لیست به ست برای حذف موارد تکراری
numbers = [1, 2, 2, 3, 3, 3]
unique_numbers = set(numbers)
print(unique_numbers)   # {1, 2, 3}

# ۳) ساخت مجموعهٔ خالی
empty_set = set()
print(empty_set)        # set()

# ۴) توجه: {} یک دیکشنری خالی ایجاد می‌کند، نه یک ست
empty_dict = {}
print(type(empty_dict))  # <class 'dict'>

در بخش اول، مجموعه‌ای از رشته‌ها با سه رنگ مختلف ایجاد شده است. ترتیب چاپ شده ممکن است لزوماً به همان ترتیبی که تعریف کرده‌ایم نباشد (در مثال بالا ترتیب متفاوت است) چرا که Set ترتیب را حفظ نمی‌کند. در بخش دوم، یک لیست شامل اعداد تکراری به Set تبدیل شده و مشاهده می‌کنید که خروجی تنها شامل اعداد یکتاست. بخش سوم یک مجموعه‌ی خالی می‌سازد که خروجی آن به صورت ()set نمایش داده می‌شود. در نهایت، بخش چهارم نشان می‌دهد که {} در پایتون یک دیکشنری خالی است و برای ساخت مجموعه‌ی خالی باید از ()set استفاده کرد.

متدها و عملیات پرکاربرد روی Set در پایتون

یکی از دلایل کاربرد زیاد و محبوبیت Set در پایتون، پشتیبانی از عملیات ریاضی مجموعه‌ها (مانند اجتماع و اشتراک) و توابع کاربردی متنوع برای مدیریت اعضاست . در این بخش، متداول‌ترین توابع و عملگرهای مربوط به Set را بررسی می‌کنیم:

عملگرهای ریاضی مجموعه

اجتماع (Union): اجتماع دو مجموعه تمامی اعضای هر دو مجموعه را شامل می‌شود (تکراری‌ها را یکی می‌کند). در پایتون از عملگر | برای اجتماع استفاده می‌شود. به عنوان مثال A | B مجموعه‌ای حاوی تمام اعضای A و B را برمی‌گرداند . متد این عمل، تابع A.union(B) است.
اشتراک (Intersection): اشتراک دو مجموعه شامل اعضایی است که در هر دو مجموعه مشترک هستند. عملگر اشتراک در پایتون & می‌باشد؛ مثلاً A & B فقط عناصر مشترک A و B را نتیجه می‌دهد . متد متناظر، A.intersection(B) است.
تفاضل (Difference): تفاضل مجموعه A از B شامل عناصر A است که در B وجود ندارند. عملگر – برای این منظور به کار می‌رود (A – B). متد متناظر A.difference(B) است.
تفاضل متقارن (Symmetric Difference): این عملیات مجموعه‌ای از عناصری را نتیجه می‌دهد که در یکی از دو مجموعه قرار دارند ولی در هر دو نیستند. عملگر ^ (xor) یا متد A.symmetric_difference(B) برای این منظور است. به عنوان نمونه، A ^ B عناصری را که تنها در یکی از A یا B وجود دارند (و نه در هر دو) برمی‌گرداند .

اسم عملیات	Operator	متد (Method)	نام انگلیسی عملیات
اجتماع	\|	set.union(other)	Union
اشتراک	&	set.intersection(other)	Intersection
تفاضل	-	set.difference(other)	Difference
تفاضل متقارن	^	set.symmetric_difference(other)	Symmetric Difference

در زیر یک مثال جامع آمده است که عمده‌ی این عملیات را روی دو مجموعه‌ی نمونه نشان می‌دهد:

				
					
A = {1, 2, 3}
B = {3, 4, 5}
print(A | B)   # خروجی: {1, 2, 3, 4, 5}  (اجتماع A و B)
print(A & B)   # خروجی: {3}       (اشتراک A و B)
print(A - B)   # خروجی: {1, 2}    (تفاضل A از B)
print(B - A)   # خروجی: {4, 5}    (تفاضل B از A)
print(A ^ B)   # خروجی: {1, 2, 4, 5}  (تفاضل متقارن A و B)

متدها و توابع set

- s.add(x): عنصر x را به مجموعه s اضافه می‌کند. اگر x از قبل در مجموعه باشد، تغییری رخ نخواهد داد.
- s.remove(x): عنصر x را از مجموعه حذف می‌کند. اگر چنین عنصری وجود نداشته باشد، خطای KeyError رخ می‌دهد .
- s.discard(x): مشابه remove عمل می‌کند با این تفاوت که در صورت نبود عنصر در مجموعه خطایی ایجاد نمی‌شود . این متد برای حذف با خیال راحت به کار می‌رود وقتی نمی‌دانیم عضو موردنظر حتماً وجود دارد یا خیر.
- ()s.pop: یک عنصر (به صورت تصادفی انتخاب‌شده به دلیل عدم ترتیب) را از مجموعه حذف کرده و همان را برمی‌گرداند اگر مجموعه خالی باشد، KeyError رخ می‌دهد. توجه کنید که چون Set ترتیب ندارد، نمی‌توان حدس زد کدام عنصر به عنوان اولین المان خارج می‌شود – این متد اغلب زمانی استفاده می‌شود که ترتیب خروج اهمیتی ندارد.
- ()s.clear: تمام عناصر مجموعه را حذف کرده و مجموعه‌ی خالی باقی می‌گذارد .

متد / تابع	توضیح عملکرد
s.add(x)	افزودن `x` به مجموعه؛ در صورت وجود قبلی تغییری رخ نمی‌دهد.
s.remove(x)	حذف `x`؛ اگر عضو موجود نباشد `KeyError` ایجاد می‌شود.
s.discard(x)	حذف `x` بدون خطا حتی اگر عضو وجود نداشته باشد؛ مناسب حذف مطمئن.
()s.pop	حذف و برگرداندن یک عضو تصادفی (به دلیل بی‌ترتیبی مجموعه)؛ در مجموعهٔ خالی ایجاد `KeyError`.
()s.clear	حذف تمام اعضا و باقی‌گذاشتن مجموعهٔ خالی.

در قطعه کد زیر، کار با برخی از این متدها را مشاهده می‌کنید:

				
					
s = {1, 2}
s.add(3)
print(s)        # {1, 2, 3}

s.remove(2)
print(s)        # {1, 3}

s.discard(5)    # تلاش برای حذف عضوی که وجود ندارد (خطایی رخ نمی‌دهد)
s.add(1)        # افزودن ۱ که قبلاً در مجموعه هست (مجموعه تغییری نمی‌کند)
print(s)        # {1, 3}

removed_item = s.pop()
print("یک عضو حذف شد:", removed_item)
print("مجموعه پس از pop:", s)  
# توجه: عضو حذف‌شده می‌تواند ۱ یا ۳ باشد (در این اجرا ۱ حذف شد) و مجموعه‌ی باقی‌مانده {3} است.

s.clear()
print(s)        # set()

توابع کمکی و سایر متدها

علاوه بر موارد بالا، چند متد دیگر نیز وجود دارند که در شرایط خاص مفیدند:

- s.update(iterable): مجموعه‌ی s را با افزودن تمام عناصر iterable (مثلاً یک لیست یا Set دیگر) به‌روزرسانی می‌کند . این متد معادل اجتماع در جای خود است (عملگر =|).
- s.intersection_update(other), s.difference_update(other), s.symmetric_difference_update(other): این متدها اشتراک، تفاضل و تفاضل متقارن را در جای خود روی مجموعه اعمال کرده و نتیجه را در همان مجموعه‌ی اولیه ذخیره می‌کنند . به عنوان مثال، s.intersection_update(t) مجموعه‌ی s را به اشتراک s و t تبدیل می‌کند (معادل عملگر =&). این متدها زمانی کارآمدند که بخواهید نتیجه را در همان مجموعه داشته باشید و از ساخت یک Set جدید جلوگیری کنید.
- ()s.copy: یک کپی سطحی (shallow copy) از مجموعه می‌سازد. از آن‌جا که اعضای Set باید immutable باشند، معمولاً کپی سطحی کفایت می‌کند (چون اعضا خود تغییرناپذیرند).
- len(s): تابع داخلی پایتون که تعداد اعضای مجموعه را برمی‌گرداند. می‌توان از آن برای به‌دست آوردن اندازه‌ی Set استفاده کرد .
- x in s / x not in s: عملگر عضویت برای تشخیص وجود (یا عدم وجود) یک عنصر در مجموعه که پیش‌تر هم استفاده کردیم .

متد / تابع	توضیح عملکرد
`s.update(iterable)`	افزودن همهٔ عناصر iterable به `s` (معادل `s \|= iterable`).
`s.intersection_update(other)` `s.difference_update(other)` `s.symmetric_difference_update(other)`	اعمال اشتراک، تفاضل یا تفاضل متقارن روی خود `s` (معادل `=&`، `=-`، `=^`) بدون ساخت مجموعهٔ جدید.
`()s.copy`	ایجاد یک کپی سطحی (shallow) از مجموعهٔ `s`.
`len(s)`	بازگرداندن تعداد اعضای مجموعهٔ `s`.
`x in s` `x not in s`	بررسی وجود یا عدم وجود `x` در مجموعه (عملگر عضویت).

این‌ها رایج‌ترین عملیات و متدهای مرتبط با Set بودند. ترکیب این قابلیت‌ها باعث می‌شود بتوانیم بسیاری از مسائل رایج را به سادگی و با سرعت خوب حل کنیم. در بخش بعد چند مثال عملی ساده را خواهیم دید که چگونه از Set در حل مسائل استفاده می‌شود.

مثال‌های کاربردی Set در پایتون

در این بخش، با چند مثال ساده و عملی نحوه‌ی استفاده از Set را در حل مسائل برنامه‌نویسی مشاهده می‌کنیم. این مثال‌ها برای مبتدیان طراحی شده تا درک بهتری از کاربردهای روزمره‌ی مجموعه‌ها به دست آورند.

مثال ۱: حذف عناصر تکراری از لیست
یکی از رایج‌ترین استفاده‌های Set، حذف اقلام تکراری در یک لیست است. فرض کنید لیستی از نام‌ها داریم که برخی نام‌ها چند بار تکرار شده‌اند و می‌خواهیم لیستی از نام‌های یکتا داشته باشیم:

				
					
names = ["Ali", "Reza", "Ali", "Sara", "Reza"]
unique_names = list(set(names))
print(unique_names)  # ممکن است خروجی: ['Reza', 'Ali', 'Sara']

در این مثال، ابتدا لیست names تعریف شده که در آن نام “Ali” و “Reza” دو بار تکرار شده‌اند. سپس با تبدیل این لیست به یک Set و دوباره به لیست (list(set(names)))، تمامی مقادیر تکراری حذف می‌شوند. نتیجه در متغیر unique_names یک لیست جدید است که فقط شامل اسامی یکتا است (مثلاً [‘Ali’, ‘Reza’, ‘Sara’] – توجه کنید که ترتیب ممکن است بر اساس ترتیب پیش‌فرض Set متفاوت باشد). با این ترفند ساده می‌توانیم به سرعت لیستی بدون عنصر تکراری تولید کنیم.

مثال ۲: یافتن اعضای مشترک بین دو لیست
فرض کنید دو لیست از اعداد داریم و می‌خواهیم اعداد مشترک بین این دو لیست را پیدا کنیم (مسئله‌ای شبیه به یافتن اشتراک در ریاضیات). انجام این کار با حلقه‌های تودرتو ممکن است زمان‌بر باشد، اما با استفاده از Set بسیار ساده می‌شود:

				
					
list_a = [1, 2, 3, 4, 5]
list_b = [4, 5, 6, 7]
common = set(list_a) & set(list_b)
print(common)  # خروجی: {4, 5}

در این کد، ابتدا دو لیست list_a و list_b تعریف شده‌اند. با تبدیل هر کدام به Set و استفاده از عملگر اشتراک &، مجموعه‌ای از عناصر مشترک به دست می‌آوریم و آن را در متغیر common قرار می‌دهیم. نتیجه‌ی چاپ common در این مثال {4, 5} است، چرا که فقط اعداد ۴ و ۵ بین دو لیست مشترک بودند. این روش بسیار کارآمدتر و کوتاه‌تر از پیمایش دستی دو لیست و بررسی تک‌تک عناصر است.

مثال ۳: شمارش تعداد یکتای اقلام
Set می‌تواند برای دانستن تعداد موارد یکتا در یک دیتاست نیز به کار رود. به طور مثال، فرض کنید لیستی از کلمات (مثلاً کلمات یک جمله یا یک فایل متنی) دارید و می‌خواهید بدانید چند کلمه‌ی منحصربه‌فرد در آن وجود دارد:

				
					
words = ["apple", "banana", "apple", "orange", "banana", "melon"]
unique_count = len(set(words))
print(unique_count)  # خروجی: 4

مثال 4: استفاده از Set برای جلوگیری از افزودن تکراری‌ها
گاهی می‌خواهیم در حین جمع‌آوری داده‌ها، مطمئن شویم که هر آیتم را فقط یک‌بار اضافه می‌کنیم. Set به خاطر جلوگیری خودکار از ورود عناصر تکراری، ساختاری مناسب برای این وضعیت است. مثلاً ساخت یک لیست از آیتم‌های یکتا هنگام پیمایش:

				
					
emails = ["a@example.com", "b@example.com", "a@example.com", "c@example.com"]
seen = set()
unique_list = []
for email in emails:
    if email not in seen:
        seen.add(email)
        unique_list.append(email)
print(unique_list)  # خروجی: ['a@example.com', 'b@example.com', 'c@example.com']

در این مثال، ما یک لیست از ایمیل‌ها داریم که برخی تکراری‌اند. با کمک یک Set کمکی (seen) بررسی می‌کنیم که هر ایمیل آیا قبلاً دیده شده یا نه. در صورت دیده نشدن، آن را به Set اضافه می‌کنیم و همچنین به لیست نهایی unique_list اضافه می‌نماییم. در پایان، unique_list شامل فقط ایمیل‌های یکتا به ترتیب اولین وقوع در لیست اصلی خواهد بود. این روش استفاده از Set، افزون بر حذف تکراری، ترتیب اولیه را نیز حفظ کرده است (چون ما خودمان ترتیب را در لیست کنترل کردیم).

این چند مثال نشان داد که چگونه Set می‌تواند در مسائل مختلفی به کمک ما بیاید: از حذف ساده‌ی موارد تکراری گرفته تا یافتن اشتراک و ساخت مجموعه‌های یکتا در حین پردازش داده. هرجا نیاز به مجموعه‌ای از اقلام یکتا با عملیات عضویت سریع داشتید، می‌توانید به سراغ Set بروید.

نکات و ترفندهای حرفه‌ای Set در پایتون

در این بخش به چند نکته و ترفند پیشرفته‌تر پیرامون Set در پایتون اشاره می‌کنیم که برای برنامه‌نویسان باتجربه مفید است:

سرعت Set

همان‌طور که اشاره شد، Set در پایتون با استفاده از hash table پیاده‌سازی شده‌است . به بیان دقیق‌تر، Set در واقع شبیه دیکشنری‌ای است که فقط کلید دارد (مقدار ندارد) و مقدار آن صرفاً نشانه‌ای خالی (مثل True یا None) است . به دلیل همین ساختار، عملیات افزودن، حذف و بررسی عضویت به طور میانگین در زمان ثابت O(1) انجام می‌شوند . با این حال، باید در نظر داشت که در بدترین حالت (مثلاً رخ دادن تعداد زیادی برخورد در جدول هش) پیچیدگی ممکن است به O(n) هم نزدیک شود، اما این شرایط نادر است. به طور کلی، برای مجموعه‌های بزرگ، Set از نظر سرعت عملکرد تفاوت چشمگیری نسبت به لیست نشان می‌دهد. برای نمونه، جستجوی یک عنصر در یک Set صدها هزار عضوی معمولاً تقریباً لحظه‌ای است، در حالی که همین جستجو در لیستی با همان تعداد عناصر خطی و کند خواهد بود.

مفهوم Hashable و نوع frozenset

همان‌گونه که پیش‌تر اشاره شد، اعضای Set باید hashable باشند، یعنی یک کد هش ثابت در طول عمر خود داشته باشند و قابل تغییر نباشند . این به این معناست که انواع تغییرناپذیر مانند اعداد (int، float)، رشته (str)، تاپل‌های بدون عضو متغیر، و … قابل استفاده در Set هستند. اما انواعی مانند لیست، دیکشنری یا مجموعه (که mutable هستند) قابل قرارگیری مستقیم در Set نیستند. اگر نیاز باشد یک مجموعه داخل مجموعه‌ی دیگری قرار گیرد (مثلاً مجموعه‌ای از مجموعه‌ها بسازیم)، باید از نوع frozenset استفاده کنیم . نوع frozenset دقیقاً شبیه Set است با این تفاوت که تغییرناپذیر (immutable) است؛ یعنی پس از ساخت نمی‌توان اعضای آن را تغییر داد یا عضو جدیدی به آن افزود. به همین خاطر frozenset خودش hashable است و می‌تواند به عنوان عضو یک Set یا کلید یک دیکشنری مورد استفاده قرار گیرد .

به طور خلاصه:

- set: قابل تغییر، خودش hashable نیست (چون قابل تغییر است)، بنابراین نباید به عنوان کلید دیکشنری یا عضو یک Set دیگر استفاده شود.
- frozenset: غیرقابل تغییر، hashable است و می‌تواند به عنوان کلید دیکشنری یا عضو یک Set دیگر به کار رود.

در کد زیر طرز استفاده از frozenset را مشاهده می‌کنید:

				
					# مثال: نگهداری وزن یال‌های یک گراف بدون جهت با frozenset

# the edge (u, v) is equivalent to (v, u).
# Therefore, we can use frozenset([u, v]) as a dictionary key.

edge_weights = {
    frozenset([1, 2]): 7,   # یال بین راس‌های 1 و 2 وزن 7 دارد
    frozenset([2, 3]): 5,   # یال بین 2 و 3 وزن 5
    frozenset([1, 3]): 10,  # یال بین 1 و 3 وزن 10
}

def get_edge_weight(u, v):
    """
    وزن یال بین راس‌های u و v را برمی‌گرداند
    اگر یال وجود نداشته باشد، None برمی‌گرداند
    """
    return edge_weights.get(frozenset([u, v]))

# استفاده‌ی ساده:
print(get_edge_weight(1, 2))  # خروجی: 7
print(get_edge_weight(2, 1))  # خروجی: 7  (چون frozenset ترتیب را نادیده می‌گیرد)
print(get_edge_weight(3, 2))  # خروجی: 5
print(get_edge_weight(3, 4))  # خروجی: None  (این یال تعریف نشده)

چرا frozenset؟

در گراف بدون جهت، یال بین دو راس، بدون توجه به ترتیب راس‌ها، یکسان است.
با frozenset([u, v]) می‌توانیم به سادگی کلید یکتا برای یال بسازیم که هم immutable است و هم hashable.
این روش از نیاز به نوشتن منطق اضافی برای ترتیب یا جستجوی دو طرفه جلوگیری می‌کند.

ساخت ست بصورت فشرده (Set Comprehension)

در پایتون همان‌طور که می‌توان List Comprehension یا دیکشنری کامپریهنشن نوشت، برای Set نیز این قابلیت وجود دارد . این سینتکس به شما اجازه می‌دهد به صورت کوتاه و خوانا مجموعه‌ای را بر اساس یک توالی یا شرط بسازید. به عنوان نمونه، فرض کنید می‌خواهیم مربع اعداد ۱ تا ۵ را در یک مجموعه داشته باشیم:

				
					
 squares = {x*x for x in range(1, 6)}
print(squares)  # خروجی: {1, 4, 9, 16, 25}

این عبارت {x*x for x in range(1, 6)} به سادگی یک Set از مقادیر $x^2$ برای $x$ از ۱ تا ۵ ساخته است. نتیجه یک مجموعه شامل 1, 4, 9, 16, 25 می‌شود. مزیت استفاده از Set Comprehension نسبت به List Comprehension در این حالت آن است که مستقیماً یک Set حاصل می‌شود (و طبیعتاً مقادیر تکراری در صورت وجود به طور خودکار حذف می‌شوند). برای مثال اگر بازه یا شرطی داشته باشیم که تکرار ایجاد کند، Set Comprehension به طور ضمنی آن‌ها را غربال می‌کند. نمونه‌ی دیگر، فیلتر کردن حروف یک رشته:

				
					

 letters = {ch for ch in "abracadabra" if ch not in "abc"}
print(letters)  # خروجی: {'r', 'd'}

در این قطعه کد، با استفاده از Set Comprehension حروف رشته‌ی “abracadabra” را پیمایش کرده‌ایم و فقط حروفی را جمع‌آوری کرده‌ایم که جزء “a”, “b”, “c” نیستند. نتیجه یک Set شامل {‘r’, ‘d’} است. دقت کنید که حروف تکراری مانند ‘a’، ‘b’ و ‘c’ که فیلتر هم نشده‌اند در هر صورت فقط یک‌بار می‌توانستند در Set ظاهر شوند. این مثال نشان می‌دهد چگونه Set comprehension می‌تواند برای استخراج یکتای داده‌ها تحت شرایط مشخص بسیار کارآمد باشد.

تبدیل Set به لیست مرتب

از آن‌جا که Set ترتیبی ندارد، اگر نیاز داشته باشید عناصر یک Set را به ترتیب خاصی (مثلاً مرتب‌شده) استفاده کنید، می‌توانید با تابع ()sorted روی مجموعه، یک لیست مرتب‌شده از اعضای آن به دست آورید. برای مثال:

				
					
 s = {5, 3, 8, 1}
sorted_list = sorted(s)
print(sorted_list)  # خروجی: [1, 3, 5, 8]

تابع sorted(s) تمامی اعضای مجموعه‌ی s را گرفته و آن‌ها را به صورت یک لیست مرتب‌شده برمی‌گرداند. به این ترتیب اگر لازم باشد خروجی قابل پیش‌بینی مرتب داشته باشید (مثلاً برای نمایش به کاربر یا پردازش‌های بعدی که ترتیب مهم است)، می‌توانید از این روش بهره ببرید. توجه کنید که خود مجموعه s بدون تغییر باقی می‌ماند و هنوز هم ترتیب داخلی خاصی ندارد؛ ما فقط یک لیست جدید مرتب‌شده از روی آن ساختیم.

مقایسه و شمول‌سنجی مجموعه‌ها

پایتون امکان مقایسه‌ی مجموعه‌ها را نیز فراهم کرده است. می‌توانید با عملگرهای مقایسه‌ای مانند <, <=, > و >= روابط زیرمجموعه (Subset) یا فوق‌مجموعه (Superset) را بررسی کنید :

A <= B True است اگر تمام اعضای مجموعه A در B نیز وجود داشته باشند (A زیرمجموعه‌ی B باشد). همچنین A < B زمانی True خواهد بود که A زیرمجموعه‌ی proper یا دقیق B باشد (یعنی A زیرمجموعه B و A≠B).
A >= B True است اگر تمام اعضای B در A باشند (A فوق‌مجموعه‌ی B). به طور مشابه A > B زمانی True است که A فوق‌مجموعه‌ی proper B باشد (و مساوی نباشند).
A.isdisjoint(B): اگر A و B هیچ عضو مشترکی نداشته باشند True برمی‌گرداند .
متدهای A.issubset(B) و A.issuperset(B) هم معادل عملگرهای بالا برای زیرمجموعه و فوق‌مجموعه هستند که برای خوانایی می‌توانند استفاده شوند.

به عنوان نمونه :

				
					

 A = {1, 2}
B = {1, 2, 3}
C = {4, 5}
print(A <= B)          # True  (A زیرمجموعه B است)
print(B >= A)          # True  (B فوق‌مجموعه A است)
print(A < B)           # True  (A زیرمجموعه proper B است چون A != B)
print(A.isdisjoint(C)) # True  (A و C هیچ اشتراکی ندارند)
print(B.isdisjoint(C)) # True  (B و C نیز عضو مشترک ندارند)

در این مثال، مجموعه‌ی A زیرمجموعه‌ی B است (چون تمام اعضای A در B هستند) و لذا نتیجه‌ی A <= B برابر True شده است. همچنین B فوق‌مجموعه A است (B >= A True) و چون A و B برابر نیستند، A < B نیز True است. از سوی دیگر A و C هیچ عضو مشترکی ندارند و A.isdisjoint(C) نتیجه True داده است؛ B و C نیز همین‌طور. این عملگرها وقتی با مجموعه‌های متعدد سر و کار داریم برای بررسی روابط بین آن‌ها بسیار سودمند هستند.

استفاده‌های الگوریتمیک از Set

برنامه‌نویسان باتجربه اغلب از مجموعه‌ها به‌عنوان بخش کلیدی پیاده‌سازی الگوریتم‌ها استفاده می‌کنند. برای مثال:

در حل مسائل گراف، از یک Set می‌توان برای نگهداری راس‌های بازدیدشده استفاده کرد تا از پیمایش تکراری جلوگیری شود.
در حل معماها یا مسائل مصاحبه‌ای (مانند پیداکردن اولین کاراکتر غیرتکراری در یک رشته)، Set می‌تواند به همراه ساختارهای دیگر به سرعت مشخص کند چه عناصری قبلاً دیده شده‌اند.
در عملیات روی دیتاست‌های بزرگ، استفاده از مجموعه برای تفاضل یا اشتراک می‌تواند راه ساده‌ای برای مقایسه دو مجموعه داده باشد (مثلاً پیدا کردن اینکه چه کاربران مشترک بین دو لیست وجود دارند یا چه آیتم‌هایی در یک مجموعه نیستند).
حتی در مواردی، از خاصیت حذف خودکار تکرار Set برای پاکسازی داده‌های ورودی (data cleaning) بهره گرفته می‌شود.

در پایان، یادگیری نوع داده Set و متدها و ترفندهای آن برای هر برنامه‌نویس پایتون بسیار سودمند است. این نوع داده به دلیل سادگی مفهوم و در عین حال کارایی بالا، در طیف گسترده‌ای از مسائل به کار می‌آید. با تمرین مثال‌های بیشتر و ترکیب این قابلیت‌ها، به تدریج می‌توانید از مجموعه‌ها برای نوشتن کدهایی تمیزتر، کوتاه‌تر و کارآمدتر در پایتون بهره ببرید.

منابع :‌ python.org geekforgeeks