मैं एक सेट में चलने योग्य की सामग्री कैसे जोड़ूं?

Question

किसी मौजूदा के सभी आइटम्स को जोड़ने के लिए "एक [...] स्पष्ट तरीका" क्या है set?

Answer 1

आप इस तरह listसे एक के तत्वों को जोड़ सकते हैं set:

>>> foo = set(range(0, 4))
>>> foo
set([0, 1, 2, 3])
>>> foo.update(range(2, 6))
>>> foo
set([0, 1, 2, 3, 4, 5])

Comments

बस अपने दुभाषिया सत्र को वापस देखा और मैंने वास्तव में यह कोशिश की, लेकिन यह सोचा कि इसने पूरी सूची को सेट के तत्व के वर्ग कोष्ठक के कारण सेट के तत्व के रूप में जोड़ दिया था। मैंने पहले कभी नहीं देखा था कि वे इस तरह का प्रतिनिधित्व करते हैं।

— इयान मैकिनॉन

यह प्रतिनिधित्व आपको एक इंटरैक्टिव सत्र में इसे वापस पेस्ट करने की अनुमति देता है, क्योंकि setनिर्माता अपने तर्क के रूप में एक पुनरावृत्ति लेता है।

— फ्रैंक केलर्स

ध्यान दें कि प्रतिनिधित्व केवल {1, 2, 3}3 पायथन में है, जबकि यह set([1, 2, 3])पायथन 2 में था

— रेडॉन रोसबोरो

Answer 2

किसी ऐसे व्यक्ति के लाभ के लिए, जो यह मान सकता है कि aset.add()पाश में करने से प्रदर्शन प्रतिस्पर्धी होगा aset.update(), यहां एक उदाहरण है कि आप सार्वजनिक होने से पहले अपनी मान्यताओं का परीक्षण कैसे कर सकते हैं:

>\python27\python -mtimeit -s"it=xrange(10000);a=set(xrange(100))" "a.update(it)"
1000 loops, best of 3: 294 usec per loop

>\python27\python -mtimeit -s"it=xrange(10000);a=set(xrange(100))" "for i in it:a.add(i)"
1000 loops, best of 3: 950 usec per loop

>\python27\python -mtimeit -s"it=xrange(10000);a=set(xrange(100))" "a |= set(it)"
1000 loops, best of 3: 458 usec per loop

>\python27\python -mtimeit -s"it=xrange(20000);a=set(xrange(100))" "a.update(it)"
1000 loops, best of 3: 598 usec per loop

>\python27\python -mtimeit -s"it=xrange(20000);a=set(xrange(100))" "for i in it:a.add(i)"
1000 loops, best of 3: 1.89 msec per loop

>\python27\python -mtimeit -s"it=xrange(20000);a=set(xrange(100))" "a |= set(it)"
1000 loops, best of 3: 891 usec per loop

ऐसा लगता है कि लूप एप्रोच की प्रति आइटम लागत उस एप्रोच से तीन गुना अधिक है update।

|= set()1.5x के बारे में लागत का उपयोग करते updateहुए एक लूप में प्रत्येक अलग-अलग वस्तु को जोड़ने पर क्या होता है।

Answer 3

आप सेट में उपयोग करने के लिए सेट () फ़ंक्शन का उपयोग कर सकते हैं, और फिर अपने नए सेट से मौजूदा मानों में अद्वितीय मान जोड़ने के लिए मानक सेट अपडेट ऑपरेटर (= =) का उपयोग कर सकते हैं।

>>> a = { 1, 2, 3 }
>>> b = ( 3, 4, 5 )
>>> a |= set(b)
>>> a
set([1, 2, 3, 4, 5])

Comments

उपयोग करने .updateसे यह लाभ होता है कि तर्क किसी भी चलने योग्य हो सकता है-जरूरी नहीं कि वह एक सेट हो - |=आपके उदाहरण में ऑपरेटर के आरएचएस के विपरीत ।

— tzot

अच्छी बात। यह सेट के बाद से सिर्फ एक सौंदर्य पसंद है () सेट में एक पुनरावृत्त को बदल सकते हैं, लेकिन कीस्ट्रोक्स की संख्या समान हैं।

— gbc

मैंने उस ऑपरेटर को पहले कभी नहीं देखा है, मैं इसे भविष्य में पॉप अप करने पर इसका उपयोग करने का आनंद लूंगा; धन्यवाद!

— 20

@eipxen: |संघ के लिए, &चौराहे के लिए, और ^उन तत्वों को प्राप्त करने के लिए जो एक या दूसरे में हैं लेकिन दोनों नहीं। लेकिन एक गतिशील रूप से टाइप की गई भाषा में, जहां कभी-कभी कोड पढ़ना और आसपास उड़ने वाली वस्तुओं को जानना मुश्किल होता है, मुझे इन ऑपरेटरों का उपयोग करने में संकोच होता है। कोई है जो उन्हें नहीं पहचानता है (या शायद यह भी महसूस नहीं करता है कि पायथन इन जैसे ऑपरेटरों के लिए अनुमति देता है) भ्रमित हो सकता है और सोच सकता है कि कुछ अजीब बिटवाइज़ या लॉजिकल ऑपरेशन चल रहे हैं। अच्छा होगा अगर ये ऑपरेटर अन्य पुनरावृत्तियों पर भी काम करें ...

— ArtOfWarfare

इस बनाम पर कुछ समय परीक्षण चलाएं .update()और व्यक्तिगत तत्वों को एक लूप में जोड़ें। पाया कि .update()तेज था। मैंने अपने परिणामों को इस मौजूदा उत्तर में जोड़ दिया: stackoverflow.com/a/4046249/901641

— ArtOfWarfare

Answer 4

बस एक त्वरित अद्यतन, अजगर 3 का उपयोग कर समय:

#!/usr/local/bin python3
from timeit import Timer

a = set(range(1, 100000))
b = list(range(50000, 150000))

def one_by_one(s, l):
    for i in l:
        s.add(i)    

def cast_to_list_and_back(s, l):
    s = set(list(s) + l)

def update_set(s,l):
    s.update(l)

परिणाम हैं:

one_by_one 10.184448844986036
cast_to_list_and_back 7.969255169969983
update_set 2.212590195937082

Answer 5

सूची समझ का उपयोग करें।

उदाहरण के लिए एक सूची का उपयोग करके चलने के निर्माण का लघु परिपथ :)

>>> x = [1, 2, 3, 4]
>>> 
>>> k = x.__iter__()
>>> k
<listiterator object at 0x100517490>
>>> l = [y for y in k]
>>> l
[1, 2, 3, 4]
>>> 
>>> z = Set([1,2])
>>> z.update(l)
>>> z
set([1, 2, 3, 4])
>>> 

[संपादित करें: प्रश्न के सेट भाग को याद किया]

Comments

मुझे कोई सेट नहीं दिख रहा है? क्या मैं कुछ भूल रहा हूँ?

— इयान मैकिनन

Answer 6

for item in items:
   extant_set.add(item)

रिकॉर्ड के लिए, मुझे लगता है कि दावा है कि "एक होना चाहिए - और अधिमानतः इसे करने के लिए केवल एक ही - स्पष्ट तरीका।" फर्जी है। यह एक धारणा है कि कई तकनीकी दिमाग वाले लोग बनाते हैं, कि हर कोई एक जैसा सोचता है। एक व्यक्ति के लिए जो स्पष्ट है वह दूसरे के लिए इतना स्पष्ट नहीं है।

मैं तर्क दूंगा कि मेरा प्रस्तावित समाधान स्पष्ट रूप से पठनीय है, और वही करता है जो आप पूछते हैं। मुझे विश्वास नहीं है कि इसके साथ कोई प्रदर्शन हिट शामिल है - हालांकि मैं मानता हूं कि मुझे कुछ याद आ रहा है। लेकिन उस सब के बावजूद, यह स्पष्ट नहीं हो सकता है और किसी अन्य डेवलपर के लिए बेहतर है।

Comments

अरे! लूप के लिए एक लाइन पर होने की तरह मेरे जवाब में स्वरूपण है - मैं ऐसा कभी नहीं करूंगा। कभी।

— जायदेल

आप बिल्कुल सही हैं। मैंने अपनी क्षति को ठीक करने के लिए पोस्ट को संपादित किया। धन्यवाद :)

— jaydel

आप उस बिंदु को याद कर रहे हैं जो कि पाइथन गति से लूप करता है, aset.update(iterable)जबकि for item in iterable: aset.add(item)प्रति आइटम लुकअप और एक विधि कॉल (aarrgghh !!) प्रति आइटम के साथ।

— जॉन मैकिन

क्षमा करें, उन्होंने अपने प्रश्न में प्रदर्शन के बारे में कुछ नहीं कहा, इसलिए मुझे इसकी चिंता नहीं थी।

— जायदेल