Python में samauh (सेट) - विस्तृत जानकारी

1. samauh क्या है?

samauh, Python की एक Data Structure है जिसमें हम कई वैल्यू (maana) को एक साथ रख सकते हैं, लेकिन samauh में कोई भी वैल्यू दोबारा (duplicate) नहीं रखी जा सकती। साथ ही samauh में एलिमेंट्स का कोई निश्चित क्रम (order) नहीं होता।

samauh को curly brackets { } में लिखा जाता है और हर वैल्यू के बीच कॉमा , लगाया जाता है।

samauh_  = {10, 20, 30, "namastae", 3.5}
laiqae(samauh_)

2. samauh की मुख्य विशेषताएँ

• Unordered: samauh में एलिमेंट्स का कोई निश्चित क्रम नहीं होता, इसलिए Indexing/Slicing काम नहीं करती।
• nahi_ Duplicates: samauh में एक जैसी वैल्यू सिर्फ एक ही बार रखी जाती है, बाकी अपने आप हट जाती हैं।
• Mutable: samauh में नए एलिमेंट जोड़े या हटाए जा सकते हैं।
• Unindexed: samauh के एलिमेंट्स को इंडेक्स नंबर से एक्सेस नहीं किया जा सकता।

3. samauh बनाना (Creating a samauh)

AMk = {1, 2, 3, 4, 5}
naama = {"saioDaYaZ", "pazitai", "vainaita"}
# duplaikeT vaIlyau Apanae Aapa hT jaatai hI
maana = {1, 2, 2, 3, 3, 3}
laiqae(maana)   # {1, 2, 3}
# qaalai samauh  banaanae ke laiP samauh()  pafMKSana ka Upayaaega kreM, {}  nahi
nayaa_samauh = samauh()
laiqae(pazkar(nayaa_samauh))   # 
# {} laiqanae par vah qaalai SabDkaeSa bana jaatai hI, qaalai samauh nahi
nayaa_daTa = {}
laiqae(pazkar(nayaa_daTa))   # 

4. samauh में Indexing क्यों नहीं होती?

चूँकि samauh के एलिमेंट्स का कोई क्रम (order) तय नहीं होता, इसलिए my_set[0] जैसी Indexing samauh में काम नहीं करती और error देती है। samauh के एलिमेंट्स को access करने के लिए jaba loop या maeM ऑपरेटर का उपयोग किया जाता है।

kEZ_naama = {"saioDaYaZ", "pazitai", "vainaita"}
jaba naama maeM kEZ_naama:
    laiqae(naama)
laiqae("pazitai" maeM kEZ_naama)   # sahi

5. samauh के महत्वपूर्ण Methods

jaaedeM() - एक नया एलिमेंट जोड़ना

kEZ_naama = {"saioDaYaZ", "pazitai", "vainaita"}
kEZ_naama.jaaedeM("rahula")
laiqae(kEZ_naama)		#{"saioDaYaZ", "pazitai", "vainaita","rahula"}

taajaa_krae() - एक साथ कई एलिमेंट जोड़ना

kEZ_naama = {"saioDaYaZ", "pazitai"}
kEZ_naama.taajaa_krae(["vainaita", "rahula"])
laiqae(kEZ_naama)   # {'saioDaYaZ', 'pazitai', 'vainaita', 'rahula'}

pafaEla_hTaPM() - एलिमेंट हटाना (अगर वैल्यू मौजूद नहीं तो error)

kEZ_naama = {"saioDaYaZ", "pazitai","vainaita", "rahula"}
kEZ_naama.hTaPM("vainaita")
laiqae(kEZ_naama)   # {'saioDaYaZ', 'pazitai',  'rahula'}

Caed_DeM() - एलिमेंट हटाना (अगर वैल्यू मौजूद नहीं तो कोई error नहीं)

kEZ_naama = {"saioDaYaZ", "pazitai", "rahula"}
kEZ_naama.Caed_DeM("vainaita")
laiqae(kEZ_naama)   # {'saioDaYaZ', 'pazitai',  'rahula'} 

baahr_naikalaeM() - बेतरतीब (yaacCik) एलिमेंट हटाना और वापस देना

kEZ_naama = {"saioDaYaZ", "pazitai", "rahula","vainaita"}
oaTk = kEZ_naama.baahr_naikalaeM()  # kae Bai Pk PlaimaeMT kzma taya nahi
laiqae(oaTk)     

saba_saapaf_krae() - पूरा samauh खाली करना

kEZ_naama = {"saioDaYaZ", "pazitai", "rahula","vainaita"}
oaTk = kEZ_naama.saba_saapaf_krae()
laiqae(oaTk)   

6. samauh की गणितीय (Mathematical) Operations

samauh का उपयोग गणित के "set Theory" जैसी operations करने के लिए भी होता है, जैसे saMoa, paztaicCeDna, pafrk आदि।

Union (मिलन) - दोनों samauh की सभी वैल्यू

A = {1, 2, 3}
ba = {3, 4, 5}
laiqae(A | ba)          # {1, 2, 3, 4, 5}
laiqae(A.saMoa(ba))     # {1, 2, 3, 4, 5}   

Intersection (सामान्य वैल्यू) - जो दोनों में मौजूद हैं

A = {1, 2, 3}
ba = {3, 4, 5}
laiqae(A & ba)                  # {3}
laiqae(A.paztaicCeDna(ba))      # {3} 

Difference (अंतर) - पहले samauh में जो दूसरे में नहीं है

A = {1, 2, 3}
ba = {3, 4, 5}
laiqae(A - ba)                # {1, 2}
laiqae(A.pafrk(ba))      # {1, 2}

Symmetric Difference (जो केवल एक ही samauh में है)

A = {1, 2, 3}
ba = {3, 4, 5}
laiqae(A ^ ba)                          # {1, 2, 4, 5}
laiqae(A.samamaita_AMtar(ba))      # {1, 2, 4, 5}

7. samauh की तुलना (Comparison) Methods

A = {1, 2}
ba = {1, 2, 3}
laiqae(A.Upasamauccaya_hI(ba))     # sahi  -> A, ba 
laiqae(ba.Aoaisamauccaya_hI?(A))   # sahi  -> ba, A 
laiqae(A.AsaMyautaf_hI(ba))   # galata -> 

8. Frozenset (Immutable samauh)

Frozenset भी samauh की तरह होता है, लेकिन इसे बनने के बाद बदला नहीं जा सकता (Immutable)। इसका उपयोग तब होता है जब हमें एक ऐसा samauh चाहिए जो dictionary की key बन सके।

sYairsamauh_ = sYairsamauh([1, 2, 3])
laiqae(sYairsamauh_)   # sYairsamauh({1, 2, 3})
sYairsamauh_.jaaedeM(4)   # yah Prr Degaa KyaaeMki sYairsamauh hI

9. सामान्य Operations

kEZ_naama = {"saioDaYaZ", "pazitai", "rahula","vainaita"}
laiqae(vaistaar(kEZ_naama))        # laMbaaEZ     -> 3
laiqae("pazitai" maeM kEZ_naama)  # vaIlyau hI yaa nahi      -> sahi
laiqae("manaaeja" nahiM maeM kEZ_naama)  # vaIlyau nahi hI     -> sahi

10. samauh का उपयोग कब करें?

• जब डेटा में duplicate वैल्यू न रखनी हो।
• जब किसी List से duplicate वैल्यू हटानी हो (List को samauh में बदलकर)।
• जब दो समूहों (groups) की comparison (saMoa, paztaicCeDna आदि) करनी हो।
• जब किसी वैल्यू का "in" चेक बहुत तेज़ी से करना हो (samauh में यह List से तेज़ होता है)।

saMqyaa = [1, 2, 2, 3, 3, 3, 4]
naEZ_saMqyaa = saucai(samauh(saMqyaa))
laiqae(naEZ_saMqyaa)   # [1, 2, 3, 4]

11. निष्कर्ष (Summary)

samauh Python की एक उपयोगी Data Structure है जो unique (बिना duplicate) और unordered डेटा को स्टोर करने के लिए इस्तेमाल होती है। यह mathematical operations जैसे saMoa, paztaicCeDna के लिए बहुत उपयोगी है और duplicate वैल्यू हटाने तथा तेज़ "in" चेकिंग के लिए बेहतरीन विकल्प है।