Sets in Python

Sets in Python – जैसाकि हमने पिछले Chapter में भी Discuss किया था, Python 2.4 में Sets नाम का एक नया Collection Type Introduce किया गया है, जो कि Unique व Immutable Objects के एक Collection को Represent करता है और Mathematics के SET Theory से सम्‍बंधित Operations को Support करता है। किसी Set Object में एक Data Item सिर्फ और सिर्फ एक ही बार Appear हो सकता है और सामान्‍यत: Sets का प्रयोग Database Focused कामों के लिए सबसे ज्‍यादा किया जाता है।

चूंकि Sets अन्‍य Objects का Collection होते हैं, इसलिए Sets, List व Dictionary के कुछ Behaviours को Share करते हैं। उदाहरण के लिए Sets भी Iterable होते हैं और जरूरत के अनुसार Grow व Shrink हो सकते हैं साथ ही विभिन्‍न Types के Objects को Hold कर सकते हैं। वास्‍तव में Sets एक तरह से Valueless Dictionary की Keys के समान होते हैं लेकिन कुछ Extra Operations को भी Support करते हैं।

क्‍योंकि Sets पूरी तरह से Unordered होते हैं और Keys को Values के साथ Map नहीं करते, इसलिए न तो ये Sequence Type के होते हैं न ही Mapping Type के होते हैं। एक प्रकार से Sets स्‍वयं Type Category के ही होते हैं।

Sets Create करने के लिए हम Literals का भी प्रयोग कर सकते हैं और Comprehensions का भी। Sets एक प्रकार से Valueless Dictionary के समान होते हैं क्‍योंकि Sets के Items Unordered, Unique व Immutable होते हैं इसलिए ये Items एक प्रकार से Dictionary की Keys के समान व्‍यवहार करते हैं। इनकी Operational Similarity और भी ज्‍यादा Special होती है जहां Dictionary Key का List एक प्रकार के View Object की तरह होता है और Intersection व Union जैसे Set Operations को Support करता है।

इस बात से कोई फर्क नहीं पड़ता कि एक Set किस प्रकार से बना है, Python द्वारा Output में किसी भी Set को एक नए Literal Format के माध्‍यम से ही Display किया जाता है। Set को Create व Display करने के विभिन्‍न तरीकों को निम्‍न Example द्वारा ज्‍यादा बेहतर तरीके से Display किया जा सकता है-

[code]
FileName: Sets.py
# Built-in way as in Python Version 2.6
print("Built-in Way of Python 2.6:", set([1, 2, 3, 4]))

# Add all items in an Iterable
print("Built-in Way of Python 2.6:", set('KRISHNA'))

# Set literals: new way in Python 3.X
print("Set Literals of Python 3.x:", {1, 2, 3, 4})
S = {'K', 'R', 'I', 'S', 'H', 'N', 'A'}
print("Set Literals of Python 3.x:", S)

# Methods work as before
S.add('MURARI')
print("After Adding new Item: ", S)

print()

newSet = {1, 2, 3, 4, 5}
print("Intersection:", newSet & {2, 4});
print("Union:", newSet | {2, 6});
print("Difference:", newSet - {2, 3});
print("Superset:", newSet > {1, 3});

Output
Built-in Way of Python 2.6: {1, 2, 3, 4}
Built-in Way of Python 2.6: {'I', 'A', 'H', 'S', 'N', 'R', 'K'}
Set Literals of Python 3.x: {1, 2, 3, 4}
Set Literals of Python 3.x: {'I', 'A', 'H', 'S', 'N', 'R', 'K'}
After Adding new Item:  {'I', 'A', 'MURARI', 'H', 'S', 'N', 'R', 'K'}
Intersection: {2, 4}
Union: {1, 2, 3, 4, 5, 6}
Difference: {1, 4, 5}
Superset: True
[/code]

हालांकि इस Example में हमने Set Create करने के लिए Curly Braces { } का प्रयोग किया है, लेकिन  { } वास्‍तव में Dictionary ही है।

Sets का प्रयोग सामान्‍यत: Duplicate Items की Filtering करने के लिए किया जाता है क्‍योंक‍ि किसी Set में कोई एक Item एक ही बार Present हो सकता है। इसलिए यदि किसी List या Dictionary में Duplicate Items हों, तो हम इस Sets के माध्‍यम से उस List / Dictionary के Duplicate Items को हटाकर Filter कर सकते हैं। लेकिन क्‍योंकि Sets के Data Items का कोई निश्चित क्रम नहीं होता, इसलिए हमें जो Output प्राप्‍त होता है, उसमें Exist Items का Positioning Random हो सकता है। जैसे-

[code]
FileName: DuplicateDeletion.py
lstIntegers = [3, 2, 1, 4, 6, 4, 5, 3, 2, 3]
print("Values in List:", lstIntegers)

# Order of Output Items May Change
convertedSet = set(lstIntegers)
print("Set After Duplicate Deletion:", convertedSet)

# Set to List Conversion
lstFromConvertedSet = list(convertedSet)
print("List without Duplication:", lstFromConvertedSet)
print()
lstString = ["KRISHNA","MURARI","SHYAM","MURARI","SHYAM"]
print("Values in List:", lstString)

# Order of Output Items May Change
convertedStrSet = set(lstString)
print("Set After Duplicate Deletion:", convertedStrSet)

Output
Values in List: [3, 2, 1, 4, 6, 4, 5, 3, 2, 3]
Set After Duplicate Deletion: {1, 2, 3, 4, 5, 6}
List without Duplication: [1, 2, 3, 4, 5, 6]
Values in List: ['KRISHNA', 'MURARI', 'SHYAM', 'MURARI', 'SHYAM']
Set After Duplicate Deletion: {'KRISHNA', 'SHYAM', 'MURARI'}
[/code]

Sets का प्रयोग किसी List, String या Iterable Object को Isolate Differences के लिए भी कर सकते हैं जो कि एक प्रकार का Mathematical Set Operation है और ऐसा करने के लिए हमें इन List, String या Iterable Objects को Sets में Convert करके Deference Operation Apply करना होता है।

हालांकि यहां भी हमें इस बात का ध्‍यान रखना जरूरी होता है कि क्‍योंकि Sets हमेंशा Unordered Result Return करते हैं, इसलिए Return होने वाला Result, Original Result के पूरी तरह से Equal नहीं होता। Sets के माध्‍यम से Use की जा सकने वाली इस प्रक्रिया को हम निम्‍न Example द्वारा बेहतर तरीके से समझ सकते हैं।

[code]
FileName: IsolateDifferences.py
setInt1 = set([1,2,5,6,7])
setInt2 = set([3,4,6,7,1])
print("Integer List Set1:", setInt1)
print("Integer List Set2:", setInt2)
print("Integer List Sets Difference: Set1-Set2:", setInt1-setInt2 )

print()

setLstStr1 = set(["KRISHNA", "MURARI", "SHYAM", "MOHAN"])
setLstStr2 = set(["SHYAM", "KRISHNA", "BIHARI"])
print("String List Set1:", setLstStr1)
print("String List Set2:", setLstStr2)
print("String List Sets Difference: Set1-Set2:", setLstStr1-setLstStr2 )

print()

setStr1 = set('KRISHNA')
setStr2 = set('ABC')
print("String Set1:", setStr1)
print("String Set2:", setStr2)
print("String Sets Difference: Set1-Set2:", setStr1-setStr2 )

Output
Integer List Set1: {1, 2, 5, 6, 7}
Integer List Set2: {1, 3, 4, 6, 7}
Integer List Sets Difference: Set1-Set2: {2, 5}
String List Set1: {'SHYAM', 'KRISHNA', 'MURARI', 'MOHAN'}
String List Set2: {'KRISHNA', 'BIHARI', 'SHYAM'}
String List Sets Difference: Set1-Set2: {'MURARI', 'MOHAN'}
String Set1: {'N', 'S', 'R', 'K', 'H', 'I', 'A'}
String Set2: {'A', 'C', 'B'}
String Sets Difference: Set1-Set2: {'N', 'S', 'H', 'K', 'R', 'I'}
[/code]

इस Example में सबसे पहले हमने Integers की List पर Set Differential Operation Apply किया जिसके परिणामस्‍वरूप Output के रूप में मिलने वाले Set में हमें {2,5} मिल रहे हैं क्‍योंकि Set1 में से जब Set2 को घटाया जाता है, तब Set1 में जो भी Integers हैं, उनसे Matching Integers Delete हो जाने के बाद जो Integers बचते हैं, वे केवल {2,5} ही होते हैं।

ठीक इसी तरह से जब हमने setLstStr1 में से setLstStr2 को घटाया, तो String ‘SHYAM’ व ‘KRISHNA’ दोनों Sets में Exist होने की वजह से Cancel हो गए और अन्‍त में Result के रूप में केवल {‘MURARI’,’MOHAN’} नाम ही बचे।

चूंकि String भी एक प्रकार का Iterator ही है, इसलिए हमने अन्त में  setStr1 में से setStr2 को घटाया, तो Character ‘A’ दोनों Sets में Exist होने की वजह से Cancel हो गया और अन्‍त में Result के रूप में केवल {‘K’,’R’,’I’,’S’,’H’,’N’} ही बचे और जैसाकि हमने पहले भी बताया कि Sets के Data Items किसी निश्चित क्रम में Store नहीं होते, इसीलिए यदि हम इस Program को चार बार Execute करें, तो हमें मिलने वाला Output चारों बार अलग हो सकता है।

यदि हम दो अलग Lists को Equality के लिए Check करें, तो ये जरूरी होता है कि दोनों Lists के सभी Item भी समान Positioning पर हों, अन्‍यथा Equality Check False Return करेगा। हालांकि यदि दो Lists को Sort करके Compare किया जाए, तो उस स्थिति में सभी Items समान Positioning पर होंगे और उस स्थि‍ति में दोनों Lists Equal माने जाऐंगे। लेकिन एक बहुत ज्‍यादा Data Items वाले List की Sorting करना काफी Resource Intensive Task हो सकता है, इसलिए Processional Development के दौरान इस प्रक्रिया को पूरी तरह से Avoid किया जाता है।

जबकि यदि हम चाहें तो दो Sets को Equality के लिए Check कर सकते हैं और यदि दोनों Sets में सभी Data Items Exist हों, फिर चाहे वे किसी भी Position पर Exist क्‍यों न हों, Test का Result True ही प्राप्‍त होता है। इन विभिन्‍न प्रकार के Equality Comparisons को अगले Example द्वारा आसानी से समझा जा सकता है-

[code]
FileName: SetEqualityComparision.py
lst1, lst2 = [1, 4, 3, 5, 2], [1, 3, 2, 5, 4]

# Order of Items is Important for List Equality Test
print("List1:", lst1, "\nList2:", lst2)
print("Equality Comparison List1==List2:", lst1==lst2)

print()

# List Equality Test After Sorting
sortedList1 = set(lst1)
sortedList2 = set(lst2)
print("Sorted List1:", sortedList1, "\nSorted List1:", sortedList2)
print("Equality Comparison Sorted List1==List2:", end='')
print(sortedList1==sortedList2)

print()

# Order of Items is Not Important for Set Equality Test
set1 = set(lst1)
set2 = set(lst2)
print("Set1:", set1, "\nSet2:", set2)
print("Equality Comparison Set1==Set2:", set1==set2)

print()

# Different String Equality Comparisons. Same as Above.
print("MURARI==IRMURA:", 'MURARI' == 'IRMURA')
print("set('MURARI')==set('IRMURA'):", set('MURARI')==set('IRMURA'))
print("sorted('MURARI')==sorted('IRMURA'):", end='')
print(sorted('MURARI')==sorted('IRMURA'))

Output
List1: [1, 4, 3, 5, 2]
List2: [1, 3, 2, 5, 4]
Equality Comparison List1==List2: False
Sorted List1: {1, 2, 3, 4, 5}
Sorted List1: {1, 2, 3, 4, 5}
Equality Comparison Sorted List1==List2: True
Set1: {1, 2, 3, 4, 5}
Set2: {1, 2, 3, 4, 5}
Equality Comparison Set1==Set2: True
MURARI==IRMURA: False
set('MURARI')==set('IRMURA'): True
sorted('MURARI')==sorted('IRMURA'): True
[/code]

इस Example में हमने सबसे पहला Statement निम्‍नानुसार एक Comma Separated List के रूप में लिखा है-

     lst1, lst2 = [1, 4, 3, 5, 2], [1, 3, 2, 5, 4]

Python इस तरह से हमें एक ही Line में Multiple Objects को Declare व Initialize करने की सुविधा देता है और हम जिस क्रम में Object का Variable Name लिखते हैं, उसी क्रम में उनमें Values भी Initialize होती हैं। इसलिए जिस Variable को सबसे पहले Declare किया जाता है, उस Variable में Assignment Operation के बाद Specified सबसे पहली Value Assign हो जाती है और जिस Variable को सबसे बाद में Declare किया जाता है, उस Variable में Assignment Operation के बाद Specified सबसे अन्तिम Value Assign हो जाती है। इसके अलावा इस Program के अन्‍य Statements Self Explained हैं, जिन्‍हें अलग से Discuss करने की कोई जरूरत नहीं है।

Sets का प्रयोग Tracking करने के लिए उस समय काफी उपयोगी होता है जब हम किसी Cyclic Structure जैसे कि Binary Tree, Linked List अथवा Graph जैसे किसी Data Structure में Traversing Operation Perform कर रहे होते हैं। क्‍योंकि इन Data Structures पर विभिन्‍न प्रकार के Insert, Update, Delete जैसे Operations Perform करने के लिए Traversing करना पड़ता है और Traversing करने के लिए हमें Linear Searching Operation Perform करना पड़ता है जबकि List जैसे Data Structure पर Searching Operation Perform करना काफी Inefficient होता है।

हालांकि इस तरह के Data Structures के साथ हम Dictionary का प्रयोग कर सकते हैं क्‍योंकि इसमें Keys का Concept होता है और हम जिस भी Data Item को Traverse कर लेते हैं, उसकी Key को Mark कर सकते हैं ताकि उन Mark किए गए Data Items को Searching हेतु Use किए जाने वाले Looping के दौरान फिर से Check न किया जाए।

Sets उस स्थिति में भी काफी उपयोगी होते हैं, जब हम बहुत बड़े Data Set के साथ Deal कर रहे होते हैं और सामान्‍यत: ये Dataset किसी Database Query के Result के रूप में Generate हो सकता है, दो Sets के Intersection से Generate हो सकता है या दो Sets को Union करने पर Generate हो सकता है।

Sets अपने आप में काफी बड़ा है और इस Chapter में पर्याप्‍त Discussion करने के बावजूद अभी भी काफी कुछ है, जिसे ठीक से समझने के लिए Python के Documentation Manual को देख सकते हैं और विभिन्‍न प्रकार के Set Operations को और गहराई से समझ सकते हैं।