सवाल पाइथन में परिशिष्ट बनाम सूची विधियों के बीच अंतर


सूची विधियों के बीच क्या अंतर है append() तथा extend()?


2690
2017-10-31 05:55


मूल




जवाब:


append: अंत में वस्तु को जोड़ता है।

x = [1, 2, 3]
x.append([4, 5])
print (x)

आपको देता है: [1, 2, 3, [4, 5]]


extend: पुनरावृत्तियों से तत्वों को जोड़कर सूची बढ़ाता है।

x = [1, 2, 3]
x.extend([4, 5])
print (x)

आपको देता है: [1, 2, 3, 4, 5]


4090
2017-10-31 06:02



के बीच क्या अंतर है extend और बस अतिरिक्त ऑपरेटर का उपयोग कर - उपर्युक्त उदाहरण में, x = x + [4, 5]? - Rohan
असल में एक है बड़ा अंतर - x + [4, 5] आपको एक्स को असाइन की गई एक नई सूची देता है - x.extend() मूल सूची को बदलता है। मैं नीचे अपने जवाब में विस्तार से बताता हूं। - Aaron Hall♦


append एक सूची में एक तत्व जोड़ता है, और extend दूसरी सूची के साथ पहली सूची को जोड़ती है (या एक अन्य पुनरावर्तनीय, जरूरी नहीं कि एक सूची।)

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

से पायथन में कूदो


525
2017-10-31 05:57





सूची विधियों के विस्तार और विस्तार के बीच क्या अंतर है?

  • append एक सूची के अंत में एक तत्व के रूप में अपनी तर्क जोड़ता है। सूची की लंबाई स्वयं एक से बढ़ेगी।
  • extend सूची में विस्तार करने, प्रत्येक तत्व को सूची में जोड़ने के अपने तर्क पर पुनरावृत्त करता है। सूची की लंबाई में वृद्धि होगी हालांकि कई तत्व पुनरावर्तनीय तर्क में थे।

append

list.append विधि किसी ऑब्जेक्ट को सूची के अंत में जोड़ती है।

my_list.append(object) 

वस्तु जो भी हो, चाहे कोई संख्या, एक स्ट्रिंग, दूसरी सूची, या कुछ और, यह अंत में जोड़ा जाता है my_list सूची में एक ही प्रविष्टि के रूप में।

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

तो ध्यान रखें कि एक सूची एक वस्तु है। यदि आप सूची में एक और सूची जोड़ते हैं, तो सूची के अंत में पहली सूची एक ही वस्तु होगी (जो आप जो चाहते हैं वह हो सकता है):

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item on end of list.

extend

list.extend विधि एक पुनरावृत्त से तत्वों को जोड़कर एक सूची फैली हुई है:

my_list.extend(iterable)

तो विस्तार के साथ, पुनरावृत्त के प्रत्येक तत्व सूची में संलग्न हो जाता है। उदाहरण के लिए:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

ध्यान रखें कि एक स्ट्रिंग एक पुनरावर्तनीय है, इसलिए यदि आप एक स्ट्रिंग के साथ एक सूची का विस्तार करते हैं, तो आप प्रत्येक वर्ण को जोड़ देंगे जैसे आप स्ट्रिंग पर पुनरावृत्त करते हैं (जो आप जो चाहते हैं वह नहीं हो सकता है):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

ऑपरेटर अधिभार, __add__, (+) तथा __iadd__ (+=)

दोनों + तथा += ऑपरेटरों के लिए परिभाषित हैं list। वे विस्तार से समान रूप से समान हैं।

my_list + another_list स्मृति में तीसरी सूची बनाता है, ताकि आप इसका परिणाम वापस कर सकें, लेकिन इसकी आवश्यकता है कि दूसरा पुनरावर्तनीय एक सूची हो।

my_list += another_list सूची में सूची को संशोधित करता है (यह है इन-प्लेस ऑपरेटर, और सूचियां म्यूटेबल ऑब्जेक्ट्स हैं, जैसा कि हमने देखा है) इसलिए यह एक नई सूची नहीं बनाता है। यह विस्तार की तरह काम करता है, जिसमें दूसरा पुनरावर्तनीय किसी भी प्रकार का पुनरावर्तनीय हो सकता है।

उलझन में मत जाओ - my_list = my_list + another_list के बराबर नहीं है += - यह आपको my_list को सौंपा गया एक नई सूची देता है।

समय जटिलता

संलग्न है निरंतर समय जटिलता, ओ (1)।

विस्तारित समय जटिलता है, ओ (के)।

एकाधिक कॉल के माध्यम से Iterating append जटिलता में जोड़ता है, जो इसे विस्तार के बराबर बनाता है, और चूंकि विस्तार का पुनरावृत्ति सी में लागू किया जाता है, इसलिए यदि आप लगातार वस्तुओं को एक सूची में पुन: सक्रिय करने का इरादा रखते हैं तो यह हमेशा तेज़ होगा।

प्रदर्शन

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

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

तो चलो उन्हें समय दें:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

समय पर एक टिप्पणी को संबोधित करते हुए

एक टिप्पणीकार ने कहा:

बिल्कुल सही जवाब, मैं केवल एक तत्व जोड़ने की तुलना करने के समय को याद करता हूं

अर्थात् सही चीज करें। यदि आप सभी तत्वों को एक पुनरावर्तनीय में जोड़ना चाहते हैं, तो उपयोग करें extend। यदि आप केवल एक तत्व जोड़ रहे हैं, तो उपयोग करें append

ठीक है, तो आइए यह देखने के लिए एक प्रयोग बनाएं कि यह समय पर कैसे काम करता है:

def append_one(a_list, element):
    a_list.append(element)

def extend_one(a_list, element):
    """creating a new list is semantically the most direct
    way to create an iterable to give to extend"""
    a_list.extend([element])

import timeit

और हम देखते हैं कि विस्तार का उपयोग करने के लिए एक पुनरावर्तनीय बनाने के हमारे रास्ते से बाहर निकलने का समय (मामूली) समय बर्बाद है:

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

हम इससे सीखते हैं कि उपयोग करने से कुछ भी हासिल नहीं हुआ है extend जब हमारे पास केवल तभी होता है एक संलग्न करने के लिए तत्व।

साथ ही, ये समय महत्वपूर्ण नहीं हैं। मैं बस उन्हें यह मुद्दा बनाने के लिए दिखा रहा हूं कि, पायथन में, अर्थात् सही काम करने से चीजें कर रही हैं सही मार्ग।

यह कल्पना की जा सकती है कि आप दो तुलनात्मक परिचालनों पर समय का परीक्षण कर सकते हैं और एक संदिग्ध या उलटा परिणाम प्राप्त कर सकते हैं। बस अर्थात् सही चीज करने पर ध्यान केंद्रित करें।

निष्कर्ष

हम देखते है कि extend अर्थात् स्पष्ट है, और यह इससे कहीं अधिक तेज़ दौड़ सकता है append, जब आप प्रत्येक तत्व को किसी सूची में पुनरावर्तनीय में जोड़ना चाहते हैं। 

यदि सूची में जोड़ने के लिए आपके पास केवल एक तत्व (एक पुनरावृत्त में नहीं) है, तो उपयोग करें append


268
2018-01-23 22:44



बिल्कुल सही जवाब, मैं केवल एक तत्व जोड़ने की तुलना करने के समय को याद करता हूं - David Sánchez
@Aaron Hall समय के लिए एल्गोरिदम में एक छोटी टिप्पणी। "expand_one" "थोड़ा गलत" समय लौटा सकता है क्योंकि सूची का निर्माण भी शामिल है। संभवतः आइटम को चर के रूप में बनाना बेहतर है (ex1 = 0 तथा ex2 = [0]) और यदि आप अधिक सख्त होना चाहते हैं, तो इन चरों को पास करें। - ilias iliadis
वास्तव में सही जवाब। के प्रदर्शन के बारे में क्या l1 += l2 बनाम l1.extend(l2)? - Jean-Francois T.


append एक तत्व जोड़ता है। extend तत्वों की एक सूची संलग्न करता है।

ध्यान दें कि यदि आप संलग्न करने के लिए एक सूची पास करते हैं, तो यह अभी भी एक तत्व जोड़ता है:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]

92
2017-10-31 05:57





निम्नलिखित दो स्निपेट अर्थात् समकक्ष हैं:

for item in iterator:
    a_list.append(item)

तथा

a_list.extend(iterator)

उत्तरार्द्ध तेज हो सकता है क्योंकि लूप को सी में लागू किया गया है।


42
2017-08-20 21:11



लूप में संलग्न होने की तुलना में मेरी मशीन पर विस्तार ~ 4x तेज है (शून्य के 100 लूप के लिए 16us बनाम 4us) - Alex L
extend() शायद, preallocates, जबकि append() संभावना नहीं है। - Mad Physicist


आप विस्तार से लौटने के बजाय "+" का उपयोग कर सकते हैं, जगह में विस्तार करने के बजाय।

l1=range(10)

l1+[11]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]

l2=range(10,1,-1)

l1+l2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]

उसी प्रकार += जगह व्यवहार के लिए, लेकिन थोड़ा अंतर के साथ append और extend। सबसे बड़ा अंतर में से एक += से append तथा extend जब यह फ़ंक्शन स्कॉप्स में उपयोग किया जाता है, तो देखें यह ब्लॉग पोस्ट


29
2017-08-26 11:21



क्या वापसी के लिए '+' का उपयोग करने से समय जटिलता पर कोई असर पड़ता है? - franklin
@ फ्रैंकलिन, विवरण के लिए यह उत्तर देखें: stackoverflow.com/a/28119966/2230844 - denfromufa
मैं नहीं देखता कि यह सवाल का जवाब कैसे देता है - ppperry


परिशिष्ट () विधि सूची के अंत में एक ही आइटम जोड़ती है।

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

विस्तार () विधि एक तर्क, एक सूची लेती है, और मूल सूची में तर्क के प्रत्येक आइटम को जोड़ती है। (सूची कक्षाओं के रूप में लागू की जाती है। एक सूची बनाना "वास्तव में एक वर्ग को तुरंत चालू करना है। इस प्रकार, एक सूची में ऐसे तरीके होते हैं जो इस पर काम करते हैं।)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

से पाइथन में गोता लगाएँ


29
2017-10-31 13:12



आप केवल 6 के साथ विस्तार नहीं कर सकते क्योंकि यह पुन: प्रयोज्य नहीं है। और आपके उदाहरण में दूसरा आउटपुट गलत है। 'एबीसी' को एक तत्व के रूप में जोड़ा जाता है क्योंकि आपने इसे पास किया है extend एक तत्व के साथ एक सूची के रूप में ['abc']: [1, 2, 3, 4, 5, 'एबीसी']। अपना उदाहरण आउटपुट सही करने के लिए, एबीसी लाइन को यहां बदलें: x.extend('abc')। और हटा दें x.extend(6) या इसे बदल दें x.extend([6])। - aneroid


 विस्तार बढ़ाएं

enter image description here

संलग्न करने के साथ आप एक तत्व जोड़ सकते हैं जो सूची का विस्तार करेगा:

>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]

यदि आप एक से अधिक तत्वों को विस्तारित करना चाहते हैं तो आपको विस्तार का उपयोग करना चाहिए, क्योंकि आप केवल एक elment या तत्व की एक सूची जोड़ सकते हैं:

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

ताकि आपको घोंसला वाली सूची मिल सके

इसके विस्तार के साथ आप इस तरह के एक तत्व का विस्तार कर सकते हैं

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

या, अलग-अलग रूप से जोड़ने से, मूल में सूची को घोंसले किए बिना एक बार में अधिक तत्वों का विस्तार करें (यही नाम विस्तार का कारण है)

>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]

 दोनों विधियों के साथ एक तत्व जोड़ना

enter image description here

 1 तत्व संलग्न करें

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

 एक तत्व का विस्तार करें

>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]

 विभिन्न परिणामों के साथ ... और तत्व जोड़ना

यदि आप एक से अधिक तत्वों के लिए परिशिष्ट का उपयोग करते हैं, तो आपको तर्कों के रूप में तत्वों की एक सूची पास करनी होगी और आपको एक नेस्टेड सूची प्राप्त होगी!

>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]

विस्तार के साथ, आप तर्क के रूप में एक सूची पास करते हैं, लेकिन आप नए तत्व के साथ एक सूची प्राप्त करेंगे जो पुराने में घोंसला नहीं है।

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

इसलिए, अधिक तत्वों के साथ, आप अधिक वस्तुओं के साथ एक सूची प्राप्त करने के लिए विस्तार का उपयोग करेंगे। आप सूची में अधिक तत्व जोड़ने के लिए, एपेंड का उपयोग नहीं करेंगे, लेकिन एक तत्व जो नेस्टेड सूची है, जैसा कि आप स्पष्ट रूप से कोड के आउटपुट में देख सकते हैं।

enter image description here

enter image description here


17
2017-10-18 07:33



यह सबसे अच्छा जवाब है - Billal BEGUERADJ


append(object) - सूची में ऑब्जेक्ट जोड़कर सूची अपडेट करता है।

x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]

extend(list) - अनिवार्य रूप से दो सूचियों को जोड़ता है।

x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]

16
2018-05-12 19:51