Python Language
सेट

वाक्य - विन्यास

• खाली_सेट = सेट () # एक खाली सेट इनिशियलाइज़ करें
• शाब्दिक_सेट = {'फू', 'बार', 'बाज'} # इसके अंदर 3 तार के साथ एक सेट का निर्माण
• set_from_list = set (['foo', 'bar', 'baz']] # नए सेट के लिए सेट फ़ंक्शन को कॉल करें
• set_from_iter = set (x के लिए x सीमा में (30)) # सेट बनाने के लिए मनमाने पुनरावृत्तियों का उपयोग करें
• set_from_iter = {x in x के लिए [random.randint (0,10) के लिए मैं सीमा में (10)]} # वैकल्पिक संकेतन

टिप्पणियों

किसी सूची के अनन्य तत्व प्राप्त करें

मान लीजिए कि आपको रेस्तरां की एक सूची मिल गई है - शायद आप इसे एक फ़ाइल से पढ़ते हैं। आप सूची में अद्वितीय रेस्तरां की परवाह करते हैं। एक सूची से अद्वितीय तत्वों को प्राप्त करने का सबसे अच्छा तरीका है कि इसे एक सेट में बदल दिया जाए:

restaurants = ["McDonald's", "Burger King", "McDonald's", "Chicken Chicken"]
unique_restaurants = set(restaurants)
print(unique_restaurants)
# prints {'Chicken Chicken', "McDonald's", 'Burger King'}

ध्यान दें कि सेट मूल सूची के समान क्रम में नहीं है; ऐसा इसलिए है क्योंकि सेट अनियंत्रित होते हैं, जैसे कि dict ।

यह आसानी से एक में वापस तब्दील किया जा सकता List अजगर में निर्मित के साथ list एक और सूची है कि मूल रूप में, लेकिन डुप्लिकेट के बिना एक ही सूची है दे रही है समारोह,:

list(unique_restaurants)
# ['Chicken Chicken', "McDonald's", 'Burger King']

इसे एक पंक्ति के रूप में देखना भी आम है:

# Removes all duplicates and returns another list
list(set(restaurants))

अब कोई भी ऑपरेशन जो मूल सूची पर किया जा सकता था, उसे फिर से किया जा सकता है।

सेट पर संचालन

अन्य सेटों के साथ

# Intersection    
{1, 2, 3, 4, 5}.intersection({3, 4, 5, 6})  # {3, 4, 5}
{1, 2, 3, 4, 5} & {3, 4, 5, 6}              # {3, 4, 5}

# Union
{1, 2, 3, 4, 5}.union({3, 4, 5, 6})  # {1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5} | {3, 4, 5, 6}       # {1, 2, 3, 4, 5, 6}

# Difference
{1, 2, 3, 4}.difference({2, 3, 5})  # {1, 4}
{1, 2, 3, 4} - {2, 3, 5}            # {1, 4}

# Symmetric difference with
{1, 2, 3, 4}.symmetric_difference({2, 3, 5})  # {1, 4, 5}
{1, 2, 3, 4} ^ {2, 3, 5}                      # {1, 4, 5}

# Superset check
{1, 2}.issuperset({1, 2, 3})  # False
{1, 2} >= {1, 2, 3}           # False

# Subset check
{1, 2}.issubset({1, 2, 3})  # True
{1, 2} <= {1, 2, 3}         # True

# Disjoint check
{1, 2}.isdisjoint({3, 4})  # True
{1, 2}.isdisjoint({1, 4})  # False

एकल तत्वों के साथ

# Existence check
2 in {1,2,3}      # True
4 in {1,2,3}      # False
4 not in {1,2,3}  # True

# Add and Remove
s = {1,2,3}
s.add(4)        # s == {1,2,3,4}

s.discard(3)    # s == {1,2,4}
s.discard(5)    # s == {1,2,4}

s.remove(2)     # s == {1,4}
s.remove(2)     # KeyError!

सेट ऑपरेशंस नए सेट लौटाते हैं, लेकिन इसके स्थान पर संस्करण होते हैं:

उदाहरण के लिए:

s = {1, 2}
s.update({3, 4})   # s == {1, 2, 3, 4}

मल्टीसेट्स बनाम सेट

सेट अलग-अलग तत्वों के अनियोजित संग्रह हैं। लेकिन कभी-कभी हम उन तत्वों के अनियंत्रित संग्रह के साथ काम करना चाहते हैं जो जरूरी नहीं कि अलग-अलग हों और तत्वों के गुणन पर नज़र रखें।

इस उदाहरण पर विचार करें:

>>> setA = {'a','b','b','c'}
>>> setA
set(['a', 'c', 'b'])

स्ट्रिंग्स 'a' , 'b' , 'b' , 'c' को एक सेट डेटा संरचना में सहेज कर हमने इस तथ्य की जानकारी खो दी है कि 'b' दो बार होता है। बेशक तत्वों को किसी सूची में सहेजना इस जानकारी को बनाए रखेगा

>>> listA = ['a','b','b','c']
>>> listA
['a', 'b', 'b', 'c']

लेकिन एक सूची डेटा संरचना एक अतिरिक्त अनावश्यक आदेश का परिचय देती है जो हमारी गणना को धीमा कर देती है।

मल्टीसेट्स लागू करने के लिए पायथन collections मॉड्यूल से Counter क्लास प्रदान करता है (संस्करण 2.7 से शुरू):

>>> from collections import Counter
>>> counterA = Counter(['a','b','b','c'])
>>> counterA
Counter({'b': 2, 'a': 1, 'c': 1})

Counter एक ऐसा शब्दकोश है जहाँ तत्वों को शब्दकोश कुंजियों के रूप में संग्रहीत किया जाता है और उनकी गणना को शब्दकोश मान के रूप में संग्रहीत किया जाता है। और सभी शब्दकोशों के रूप में, यह एक अनियोजित संग्रह है।

मेथड्स और बिलिंस का उपयोग करके संचालन सेट करें

हम दो सेटों को परिभाषित करते हैं a और b

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

नोट: {1} एक तत्व का एक सेट बनाता है, लेकिन {} एक खाली dict बनाता है। खाली सेट बनाने का सही तरीका set() ।

चौराहा

a.intersection(b) a और b दोनों में मौजूद तत्वों के साथ एक नया सेट लौटाता है

>>> a.intersection(b)
{3, 4}

संघ

a.union(b) a और b दोनों में मौजूद तत्वों के साथ एक नया सेट लौटाता है

>>> a.union(b)
{1, 2, 3, 4, 5}

अंतर

a.difference(b) में मौजूद तत्वों के साथ एक नया सेट देता है a लेकिन में नहीं b

>>> a.difference(b)
{1, 2}
>>> b.difference(a)
{5}

सममित अंतर

a.symmetric_difference(b) या तो में तत्वों वर्तमान के साथ एक नया सेट देता है a या b लेकिन दोनों में नहीं

>>> a.symmetric_difference(b)
{1, 2, 5}
>>> b.symmetric_difference(a)
{1, 2, 5}

नोट : a.symmetric_difference(b) == b.symmetric_difference(a)

सबसेट और सुपरसेट

c.issubset(a) कि c का प्रत्येक तत्व a में है a ।

a.issuperset(c) परीक्षण करता है कि c का प्रत्येक तत्व a में है a ।

>>> c = {1, 2}
>>> c.issubset(a)
True
>>> a.issuperset(c)
True

बाद के संचालन के बराबर ऑपरेटर हैं जैसा कि नीचे दिखाया गया है:

विघटन सेट

यदि कोई तत्व d और इसके विपरीत में भी है, तो a और d a से भिन्न हैं।

>>> d = {5, 6}
>>> a.isdisjoint(b) # {2, 3, 4} are in both sets
False
>>> a.isdisjoint(d)
True

# This is an equivalent check, but less efficient
>>> len(a & d) == 0
True

# This is even less efficient
>>> a & d == set()
True

परीक्षण सदस्यता

बिल्ट in कीवर्ड खोजता है

>>> 1 in a
True
>>> 6 in a
False

लंबाई

बिलिन len() फ़ंक्शन सेट में तत्वों की संख्या लौटाता है

>>> len(a)
4
>>> len(b)
3

सेट का सेट

{{1,2}, {3,4}}

फलस्वरूप होता है:

TypeError: unhashable type: 'set'

इसके बजाय, frozenset उपयोग frozenset :

{frozenset({1, 2}), frozenset({3, 4})}