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




list data-structures (20)

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


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

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


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

उदाहरण 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]

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

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

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

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

उदाहरण के लिए

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

append साथ हमें मिलता है:

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

extend पर होने पर हमें मिलता है:

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

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

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


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

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

विस्तार

    letters = ['a', 'b']
    letters.extend(['c', 'd'])
    print(letters) # ['a', 'b', 'c', 'd']

जोड़ना

    letters.append(['e', 'f'])
    print(letters) # ['a', 'b', 'c', 'd', ['e', 'f']]

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

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

पाइथन में गोता से।


केवल एक आइटम द्वारा सूची (जगह में) " append " append , एकल वस्तु उत्तीर्ण (तर्क के रूप में)।

ऑब्जेक्ट पास (तर्क के रूप में) के रूप में कई वस्तुओं द्वारा सूची (स्थान पर) "विस्तारित" बढ़ाएं।

यह 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,

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

>>> 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', 2]]

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

डाइव से पायथन में


इससे मुझे समझने में मदद मिली कि वास्तव में क्या होता है जब आप append और extend :

a = [[1,2,3],[4,5,6]]
print(a)
>>> [[1, 2, 3], [4, 5, 6]]
a.append([6,7,8])
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8]]
a.extend([0,1,2])
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2]
a=a+[8,9,10]
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2, 8, 9, 10]

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

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

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

1) append और extend बीच अंतर

append :

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

extend :

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

2) append और extend बीच समानता

  • दोनों वास्तव में एक तर्क लेता है।
  • दोनों जगह में सूची संशोधित करें।
  • नतीजतन, दोनों 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
lis.append(object)

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

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

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 विधि एक पुनरावृत्त से तत्वों को जोड़कर एक सूची बढ़ाती है:

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 करने के लिए कई कॉलों के माध्यम से जटिलता को 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 करें का उपयोग 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 से कुछ भी हासिल नहीं हुआ है जब हमारे पास संलग्न करने के लिए केवल एक तत्व है।

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

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

निष्कर्ष

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

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


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

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

जोड़ना और विस्तार करना पायथन में विस्तारशीलता तंत्र में से एक है।

संलग्न करें: सूची के अंत में एक तत्व जोड़ता है।

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

यदि हम pos 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]

यह + ऑपरेटर extend उपयोग करके 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]]

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

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

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

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

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]

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


संलग्न () विधि एक तत्व के रूप में इसे पारित तर्क जोड़ देगा।

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

list1 = [1,2,3,4,5]
list2 = [6,7,8]

list1.append(list2)
print(list1)
#[1,2,3,4,5,[6,7,8]]

list1.extend(list2)
print(list1)
#[1,2,3,4,5,6,7,8]

उन्हें सहजता से अलग करने के लिए

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'},
                }

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]

append : अंत में ऑब्जेक्ट 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]





extend