पायथन की सूची के तरीकों के बीच अंतर क्या है, इसे बढ़ाएँ और बढ़ाएँ?

Question

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

Answer 1

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]

Comments

extendउपरोक्त उदाहरण में, इसके अलावा और बस ऑपरेटर के बीच अंतर क्या है x = x + [4, 5]?

— रोहन

वास्तव में एक बड़ा अंतर है - x + [4, 5]आपको एक नई सूची सौंपी गई है x.extend()जो मूल सूची को बदल देती है। मैं यहाँ नीचे अपने जवाब में विस्तार से बताता हूं।

— हारून हॉल

@AaronHall @ रोहन लेकिन यह वैसा ही है x += [4,5]।

— अस्तित्वा श्रीवास्तव

वास्तव में, मैं विस्तार लगता है @AstitvaSrivastava बाईटकोड के मामले में तेजी से होता है

— MilkyWay90

कीवर्ड का उपयोग करते समय appendहै वस्तु । यदि आप उपयोग करने का प्रयास करते हैं extendऔर आप एक शब्दकोश में पास करते हैं , तो यह कुंजी को जोड़ देगा , और सरणी के अंत में पूरे हैश नहीं।

— एंथनी

Answer 2

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.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

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

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

Answer 3

सूची के तरीकों को बढ़ाने और बढ़ाने के बीच क्या अंतर है?

• 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 at the end of the list.

extend

list.extendविधि एक iterable से तत्वों जोड़कर एक सूची लागू होता है:

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)।

एक्सटेंड में समय की जटिलता है, ओ (के)।

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।

Comments

@ एरॉन हॉल टाइमिंग के लिए एल्गोरिथम में एक छोटी टिप्पणी। "Extended_one" वापस "थोड़ा गलत" समय आ सकता है क्योंकि एक सूची का निर्माण भी शामिल है। संभवत: बेहतर है कि यदि आप अधिक सख्त होना चाहते हैं, तो आइटम को चर ( ex1 = 0और ex2 = [0]) के रूप में बनाएं और इन चर को पास करें।

— इलियास iliadis

बिल्कुल सही जवाब। l1 += l2बनाम प्रदर्शन के बारे में क्या l1.extend(l2)?

— जीन-फ्रेंकोइस टी।

@ जीन-फ्रैंकोइस टी .: l1 += l2और l1.extend(l2)अंततः एक ही कोड ( list_extendफ़ंक्शन में listobject.c) निष्पादित करते हैं । केवल अंतर हैं: 1. +=reassigns l1(खुद के लिए lists, लेकिन reassignment अपरिवर्तनीय प्रकारों का समर्थन करता है जो बाद में एक ही वस्तु नहीं हैं), जो इसे अवैध बनाता है यदि l1वास्तव में एक अपरिवर्तनीय वस्तु की विशेषता है; उदाहरण के लिए, t = ([],), t[0] += lstअसफल होता है, जबकि t[0].extend(lst)काम करेगा। 2. l1 += l2समर्पित बायोटेक का उपयोग करता है, जबकि l1.extend(l2)सामान्यीकृत विधि प्रेषण का उपयोग करता है; यह +=तेजी से बनाता है extend।

— शैडो रेंजर

तथ्य यह है कि +=पुनर्मूल्यांकन l1का मतलब यह है कि कुछ मामलों में, धीमी गति से प्रेषण extendआंशिक रूप से या पूर्ण रूप से बाएं हाथ की ओर वापस असाइन नहीं किया जाता है। उदाहरण के लिए यदि listएक वस्तु की एक विशेषता है, self.l1 += l2और self.l1.extend(l2)मेरी अजगर 3.6 स्थापित पर समान प्रदर्शन किया है, बस क्योंकि वास्तविक संचालन और अधिक की तरह है self.l1 = self.l1.__iadd__(l2), जिसका अर्थ है कि यह एक मामूली महंगा करनी होगी STORE_ATTRकि self.l1.extend(l2)करने के लिए नहीं है।

— शैडो रेंजर

स्थानीय परीक्षणों में सरल तुलना: एक स्थानीय चर के लिए (इसलिए +=यह सिर्फ उपयोग कर रहा है STORE_FAST, जो सुपर सस्ता है), जहां जोड़ा जा रहा मूल्य listइसमें एक आइटम के साथ मौजूदा है, ऑपरेशन के साथ 1000 बार दोहराया गया, +=औसतन लगभग 33 एनएस लिया। , जबकि extend78 ns, 45 ns का अंतर लिया। यदि l1एक वैश्विक (अधिक महंगी की आवश्यकता है STORE_GLOBAL), तो अंतर 17 एनएस तक पहुंच जाता है। यदि l1वास्तव में local.l1(और भी अधिक महंगी की आवश्यकता होती है STORE_ATTR), के बीच कोई सार्थक अंतर नहीं है +=और extend(लगभग समान समरूपता; extendकभी-कभी जीतता है)।

— शैडो रेंजर

Answer 4

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

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

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

Answer 5

परिशिष्ट बनाम बढ़ाएँ

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

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

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

>>> 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]

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

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

1 तत्व जोड़ें

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

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

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

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

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

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

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

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

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

Answer 6

निम्नलिखित दो स्निपेट शब्दार्थ के समतुल्य हैं:

for item in iterator:
    a_list.append(item)

तथा

a_list.extend(iterator)

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

Comments

विस्तार ~ मशीन में लूप में जोड़ने की तुलना में ~ 4x तेज है (शून्य के 100 छोरों के लिए 16us बनाम 4us)

— एलेक्स एल

extend()शायद प्रचार append()करता है , जबकि संभावना नहीं है।

— मैड फिजिसिस्ट

@MadPhysicist: पूर्णता की खातिर, ऐसे समय होते हैं, जहां समझदारी से प्रचार extend() नहीं किया जा सकता है क्योंकि कुछ पुनरावृत्तियाँ लागू नहीं होती हैं __len__(), लेकिन आप की तरह अगर यह कोशिश नहीं करता तो मुझे आश्चर्य होगा। कुछ प्रदर्शन लाभ भी पायथन के बजाय शुद्ध सी में पुनरावृत्ति भाग करने से आता है, जैसा कि आरोन के जवाब में बताया गया है ।

— सोरेन ब्योर्नस्टैड

Answer 7

append()विधि सूची के अंत में एक भी आइटम कहते हैं।

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

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

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

पाइव में डाइव से ।

Comments

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

— Aneroid

Answer 8

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

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जब यह फ़ंक्शन स्कैप में उपयोग किया जाता है, तो इस ब्लॉग पोस्ट को देखें ।

Comments

विस्तार को वापस करने के लिए '+' का उपयोग करने से समय की जटिलता पर कोई प्रभाव पड़ता है?

— फ्रैंकलिन

@franklin, विवरण के लिए इस उत्तर को देखें: stackoverflow.com/a/28119966/2230844

— denfromufa

मैं यह नहीं देखता कि यह सवाल का जवाब कैसे देता है

— pppery

Answer 9

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]

Answer 10

extend()एक पुनरावृत्ति तर्क के साथ इस्तेमाल किया जा सकता है। यहाँ एक उदाहरण है। आप इस तरह से सूचियों की सूची से एक सूची बनाना चाहते हैं:

से

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

तुम्हें चाहिए

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

आप ऐसा करने के itertools.chain.from_iterable()लिए उपयोग कर सकते हैं । इस पद्धति का आउटपुट एक पुनरावृत्त है। इसके कार्यान्वयन के बराबर है

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

हमारे उदाहरण पर वापस, हम कर सकते हैं

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

और वांछित सूची प्राप्त करें।

यहाँ बताया गया है कि कैसे extend()एक इटैलर तर्क के साथ इसका इस्तेमाल किया जा सकता है:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Comments

यह उत्तर परिशिष्ट के विपरीत नहीं है और इसलिए प्रश्न का उत्तर नहीं देता है

— pppery

Answer 11

यह ऑपरेटर के बराबर appendऔर extendउपयोग करने वाला +है:

>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]

Comments

क्यों नहीं = +!? अधिक संक्षिप्त विवरण

— denfromufa

Answer 12

append () : यह मूल रूप से पायथन में एक तत्व को जोड़ने के लिए उपयोग किया जाता है।

उदाहरण 1:

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

उदाहरण 2:

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

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

उदाहरण 1:

>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]

उदाहरण 2:

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

Answer 13

एक दिलचस्प बिंदु जो संकेत दिया गया है, लेकिन समझाया नहीं गया है, यह है कि विस्तार परिशिष्ट की तुलना में तेज है। किसी भी लूप के लिए जिसके अंदर एपेंड है, को list.extend (संसाधित_बेल) द्वारा प्रतिस्थापित किया जाना चाहिए।

इस बात को ध्यान में रखें कि नए तत्वों को शामिल करने से पूरी सूची को याद रखने के लिए बेहतर स्थान प्राप्त हो सकता है। यदि यह कई बार किया जाता है क्योंकि हम एक समय में 1 तत्व जोड़ रहे हैं, तो समग्र प्रदर्शन ग्रस्त है। इस अर्थ में, list.extend "" .join (stringlist) के अनुरूप है।

Answer 14

एपेंड एक ही बार में पूरा डेटा जोड़ता है। पूरा डेटा नए बनाए गए इंडेक्स में जोड़ा जाएगा। दूसरी ओर,extend जैसा कि यह नाम से पता चलता है, वर्तमान सरणी का विस्तार करता है।

उदाहरण के लिए

list1 = [123, 456, 678]
list2 = [111, 222]

हमारे साथ append:

result = [123, 456, 678, [111, 222]]

जबकि extendहमें मिलता है:

result = [123, 456, 678, 111, 222]

Answer 15

एक अंग्रेजी शब्दकोश शब्दों को परिभाषित करता है appendऔर इस extendप्रकार है:

परिशिष्ट : एक लिखित दस्तावेज़ के अंत में (कुछ) जोड़ें।
विस्तार : बड़ा बनाओ। बढ़ाना या बढ़ाना

---

उस ज्ञान के साथ, अब समझते हैं

1) और के बीच का अंतरappendextend

append:

• जोड़ता किसी भी अजगर वस्तु के रूप में-है सूची के अंत (यानी एक के रूप में सूची में अंतिम तत्व) के लिए।
• परिणामी सूची नेस्टेड हो सकती है और इसमें विषम तत्व (यानी सूची, स्ट्रिंग, टपल, शब्दकोश, सेट, आदि) हो सकते हैं।

extend:

• किसी भी चलने योग्य को इसके तर्क के रूप में स्वीकार करता है और सूची को बड़ा बनाता है ।
• परिणामी सूची हमेशा एक आयामी सूची होती है (अर्थात कोई नेस्टिंग नहीं) और इसमें लागू करने के परिणामस्वरूप इसमें विषम तत्व (जैसे वर्ण, पूर्णांक, फ्लोट) हो सकते हैं list(iterable)।

2) और के बीच समानताappendextend

• दोनों बिल्कुल एक तर्क लेते हैं।
• दोनों सूची को जगह में संशोधित करते हैं ।
• नतीजतन, दोनों लौटते हैं None।

---

उदाहरण

lis = [1, 2, 3]

# 'extend' is equivalent to this
lis = lis + list(iterable)

# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
list.append(object)

Answer 16

मुझे आशा है कि मैं इस प्रश्न का एक उपयोगी पूरक बना सकता हूं। यदि आपकी सूची एक विशिष्ट प्रकार की वस्तु को संग्रहीत करती है, उदाहरण के लिए Info, यहां एक ऐसी स्थिति है जो extendविधि उपयुक्त नहीं है: एक forलूप में और Infoहर बार किसी वस्तु को उत्पन्न करना और extendइसे अपनी सूची में संग्रहीत करने के लिए उपयोग करना, यह विफल हो जाएगा। अपवाद नीचे की तरह है:

TypeError: 'Info' ऑब्जेक्ट पुनरावृत्त नहीं है

लेकिन अगर आप appendविधि का उपयोग करते हैं , तो परिणाम ठीक है। क्योंकि हर बार extendविधि का उपयोग करते हुए , यह हमेशा इसे एक सूची या किसी अन्य संग्रह प्रकार के रूप में मानता है, इसे पुनरावृत्त करता है, और इसे पिछली सूची के बाद रखता है। एक विशिष्ट वस्तु को पुनरावृत्त नहीं किया जा सकता है, जाहिर है।

Answer 17

उन्हें सहज रूप से भेदने के लिए

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

यह l1उसके शरीर के अंदर एक शरीर को पुन: उत्पन्न करने जैसा है (नेस्टेड)।

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

यह ऐसा है कि दो अलग-अलग व्यक्ति विवाह करते हैं और एक संयुक्त परिवार का निर्माण करते हैं।

इसके अलावा मैं आपके संदर्भ के लिए सभी सूची के तरीकों की एक विस्तृत धोखा देती हूं।

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }

Answer 18

extend(L) दी गई सूची में सभी वस्तुओं को जोड़कर सूची का विस्तार करता है L ।

>>> a
[1, 2, 3]
a.extend([4])  #is eqivalent of a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]

Answer 19

appendकेवल एक आइटम द्वारा सूची (जगह में) फैली हुई है , एकल ऑब्जेक्ट पास किया गया (तर्क के रूप में)।

extendके रूप में कई वस्तुओं द्वारा सूची (जगह में) "फैली हुई" वस्तु (तर्क के रूप में है।

यह strवस्तुओं के लिए थोड़ा भ्रमित हो सकता है ।

1. यदि आप एक स्ट्रिंग को तर्क के रूप में पास करते हैं: appendअंत में एक भी स्ट्रिंग आइटम जोड़ देगा लेकिन extend जोड़ देगा, उस स्ट्रिंग की लंबाई के रूप में कई "एकल" 'str' आइटम जोड़ देगा।
2. यदि आप स्ट्रिंग्स की एक सूची को तर्क के रूप में पास करते हैं: तब appendभी अंत में एक एकल 'सूची' आइटम extendजोड़ देगा और पारित सूची की लंबाई के रूप में कई 'सूची' आइटम जोड़ देगा।

def append_o(a_list, element):
    a_list.append(element)
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()

def extend_o(a_list, element):
    a_list.extend(element)
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()
append_o(['ab'],'cd')

extend_o(['ab'],'cd')
append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])
append_o(['ab'],['cd'])
extend_o(['ab'],['cd'])

पैदा करता है:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

Answer 20

अजगर में एक्स्टेंसिबिलिटी मैकेनिज्म में से एक है एपेंड और एक्सटेंड।

परिशिष्ट: सूची के अंत में एक तत्व जोड़ता है।

my_list = [1,2,3,4]

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

my_list.append(5)

नया तत्व जोड़ा जाएगा डिफ़ॉल्ट स्थान हमेशा (लंबाई + 1) की स्थिति में है।

सम्मिलित करें: सम्मिलित विधि का उपयोग परिशिष्ट की सीमाओं को पार करने के लिए किया गया था। डालने के साथ, हम स्पष्ट रूप से उस सटीक स्थिति को परिभाषित कर सकते हैं जिस पर हम चाहते हैं कि हमारा नया तत्व डाला जाए।

डालने का विधि विवरण (इंडेक्स, ऑब्जेक्ट)। यह दो तर्क लेता है, पहला सूचकांक जिसे हम अपना तत्व सम्मिलित करना चाहते हैं और दूसरा तत्व।

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

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

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

यदि हम तत्व 2 पर पहुंचने की कोशिश करते हैं, तो हमें तत्व के बजाय एक सूची ([3]) मिलती है। दो सूचियों में शामिल होने के लिए, हमें परिशिष्ट का उपयोग करना होगा।

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

कई सूचियों में शामिल होने के लिए

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]

Comments

आप एक सवाल का जवाब क्यों दे रहे हैं जो पहले ही कई बार जवाब दे चुका है। यह प्रश्न 10 साल पुराना है ...

— माइक - श्रीमती