ලැයිස්තු ක්‍රම append()සහ වෙනස extend()කුමක්ද?

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]

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

ලැයිස්තු ක්‍රම එකතු කිරීම හා දිගු කිරීම අතර වෙනස කුමක්ද?

• appendලැයිස්තුවක අවසානයට තනි මූලද්‍රව්‍යයක් ලෙස එහි තර්කය එක් කරයි. ලැයිස්තුවේ දිග එකින් එක වැඩි වේ.
• extendඑක් එක් මූලද්‍රව්‍යයන් ලැයිස්තුවට එකතු කරමින් ලැයිස්තුව දීර් ing කරමින් එහි තර්කය මත නැවත ප්‍රකාශ වේ. නැවත සැකසිය හැකි තර්කයේ බොහෝ මූලද්‍රව්‍යයන් පැවතියද ලැයිස්තුවේ දිග වැඩි වේ.

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 මතකයේ තුන්වන ලැයිස්තුවක් සාදයි, එවිට ඔබට එහි ප්‍රති result ලය ලබා දිය හැකිය, නමුත් එයට දෙවන අනුක්‍රමික ලැයිස්තුවක් විය යුතුය.

my_list += another_listතැනින් තැන ලැයිස්තුව වෙනස් කරයි (එය එසේ ය තුළ ස්ථානයක් ක්රියාකරු, අපි දැකලා තියෙනවා ලෙස ලැයිස්තු, mutable වස්තූන් වේ) ඒ නිසා නව ලැයිස්තුවක් නිර්මාණය කරන්නේ නැහැ. එය ද දිගු කිරීම මෙන් ක්‍රියා කරයි, දෙවන අනුකාරකය ඕනෑම ආකාරයක නැවත කළ හැකි ය.

ව්යාකූල නොවන්න - my_list = my_list + another_listසමාන නොවේ+= - එය ඔබට my_list වෙත පවරා ඇති නවතම ලැයිස්තුවක් ලබා දෙයි.

කාල සංකීර්ණත්වය

උපග්‍රන්ථයට නියත කාල සංකීර්ණතාවයක් ඇත , ඕ (1).

විස්තාරණයට කාල සංකීර්ණතාවයක් ඇත, O (k).

බහුවිධ ඇමතුම් හරහා appendසංකීර්ණතාවයට එකතු කිරීම, එය විස්තාරණයට සමාන වන අතර, විස්තාරණය නැවත ක්‍රියාත්මක කිරීම C හි ක්‍රියාත්මක වන බැවින්, අනුක්‍රමික අයිතම ලැයිස්තුවක් වෙත එකතු කිරීමට ඔබ අදහස් කරන්නේ නම් එය සැමවිටම වේගවත් වේ.

කාර්ය සාධනය

විස්තාරණය කිරීමේ ප්‍රති come ල ලබා ගැනීම සඳහා උපග්‍රන්ථය භාවිතා කළ හැකි බැවින් වඩා කාර්ය සාධනය කුමක්දැයි ඔබ කල්පනා කළ හැකිය. පහත සඳහන් කාර්යයන් එකම දේ කරයි:

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අපට ඇත්තේ එක් අංගයක් පමණක් ඇති විට භාවිතා කිරීමෙන් කිසිවක් නොලැබෙන බව අපි මෙයින් ඉගෙන ගනිමු .

එසේම, මෙම වේලාවන් එතරම් වැදගත් නොවේ. මම, ඒ Python දී, ශබ්දාර්ථයෙන් නිවැරදි දේ දේවල් කරන්නේ කරන්නේ කාරණය කිරීමට ඔවුන් පෙන්වන අයිතිය මාර්ගය ™.

සැසඳිය හැකි මෙහෙයුම් දෙකක වේලාවන් පරීක්ෂා කර අපැහැදිලි හෝ ප්‍රතිලෝම ප්‍රති .ලයක් ලබා ගත හැකි යැයි සිතිය හැකිය. අර්ථාන්විතව නිවැරදි දේ කිරීම කෙරෙහි අවධානය යොමු කරන්න.

නිගමනය

extendඑය අර්ථ නිරූපණයෙන් පැහැදිලි වන අතර append, ඔබ එක් එක් මූලද්‍රව්‍යයන් ලැයිස්තුවකට නැවත සැකසිය හැකි පරිදි එකතු කිරීමට අදහස් කරන විට වඩා වේගයෙන් ධාවනය කළ හැකි බව අපට පෙනේ .

ලැයිස්තුවට එක් කිරීමට ඔබට ඇත්තේ තනි මූලද්‍රව්‍යයක් (නැවත සැකසිය නොහැකි) නම්, භාවිතා කරන්න append.

appendතනි අංගයක් එකතු කරයි. extendමූලද්රව්ය ලැයිස්තුවක් එකතු කරයි.

එකතු කිරීම සඳහා ඔබ ලැයිස්තුවක් සම්මත කළහොත්, එය තවමත් එක් අංගයක් එක් කරන බව සලකන්න:

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

එකතු කරන්න එදිරිව දිගු කරන්න

උපග්‍රන්ථය සමඟ ඔබට ලැයිස්තුව දීර් extend කරන තනි අංගයක් එකතු කළ හැකිය:

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

එබැවින්, තවත් මූලද්‍රව්‍ය සමඟ, තවත් අයිතම සමඟ ලැයිස්තුවක් ලබා ගැනීම සඳහා ඔබ දිගුව භාවිතා කරනු ඇත. කෙසේ වෙතත්, ලැයිස්තුවක් එකතු කිරීමෙන් ලැයිස්තුවට තවත් අංග එකතු නොවනු ඇත, නමුත් කේතයේ ප්‍රතිදානයේ ඔබට පැහැදිලිව දැකිය හැකි පරිදි කූඩු ලැයිස්තුවක් වන එක් අංගයක්.

පහත දැක්වෙන කොටස් දෙක අර්ථාන්විතව සමාන වේ:

for item in iterator:
    a_list.append(item)

හා

a_list.extend(iterator)

C හි ලූපය ක්‍රියාත්මක වන බැවින් දෙවැන්න වේගවත් විය හැකිය.

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

කිමිදුම් සිට පයිතන් දක්වා .

ස්ථානය දීර් ing කිරීම වෙනුවට දිගු කිරීම සඳහා ඔබට "+" භාවිතා කළ හැකිය.

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එය කාර්යය විෂය පථ දී භාවිතා කරන විට වන අතර, බලන්න මේ බ්ලොග් .

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]

extend()iterator තර්කයක් සමඟ භාවිතා කළ හැකිය. මෙන්න උදාහරණයක්. මේ ආකාරයෙන් ලැයිස්තු ලැයිස්තුවෙන් ලැයිස්තුවක් සෑදීමට ඔබ කැමති:

සිට

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]

මෙය ක්‍රියාකරුට සමාන 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]]

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]

ඉඟි කර ඇති නමුත් පැහැදිලි කර නැති සිත්ගන්නා කරුණක් නම් විස්තාරණය එකතු කිරීමට වඩා වේගවත් වීමයි. ඇතුළත එකතු කර ඇති ඕනෑම ලූපයක් list.extend (processed_elements) මගින් ප්‍රතිස්ථාපනය කිරීමට සැලකිය යුතුය.

නව මූලද්‍රව්‍යයන් අගය කිරීමෙන් සමස්ත ලැයිස්තුවම මතකයේ වඩා හොඳ ස්ථානයකට යථා තත්ත්වයට පත් කළ හැකි බව මතක තබා ගන්න. අපි වරකට මූලද්‍රව්‍ය 1 ක් එකතු කරන නිසා මෙය කිහිප වතාවක් සිදු කළ හොත්, සමස්ත ක්‍රියාකාරිත්වය දුක් විඳියි. මෙම අර්ථයෙන් ගත් කල, list.extend "" .ජයින් (stringlist) ට සමානය.

උපග්‍රන්ථය මුළු දත්ත එකවරම එක් කරයි. සම්පූර්ණ දත්ත අලුතින් සාදන ලද දර්ශකයට එකතු වේ. අනිත් අතට,extend එහි නමට අනුව, වත්මන් අරාව විහිදේ.

උදාහරණයක් වශයෙන්

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

සමග appendඅපි ලබා ගන්න:

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

මත වන අතර extendඅප ලබා ගන්න:

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

ඉංග්‍රීසි ශබ්දකෝෂයක් වචන අර්ථ දක්වන්නේ appendසහ extend:

append : ලිඛිත ලේඛනයක අවසානයට (යමක්) එක් කරන්න.
දිගු කරන්න : විශාල කරන්න. විශාල කිරීම හෝ පුළුල් කිරීම

එම දැනුමෙන්, දැන් අපි තේරුම් ගනිමු

1) සහ අතර වෙනසappendextend

append:

• Appends ඕනෑම Python වස්තුව-වන පරිදි ලැයිස්තුව අවසන් කිරීමට (එනම් ලැයිස්තුව තුළ පසුගිය අංගයක් ලෙස).
• එහි ප්‍රති ing ලයක් ලෙස ලැයිස්තුගත කර ඇති අතර විෂමජාතීය මූලද්‍රව්‍ය අඩංගු විය හැකිය (එනම් ලැයිස්තුව, නූල්, ටුපල්, ශබ්ද කෝෂය, කට්ටලය යනාදිය)

extend:

• ඕනෑම නැවත කළ හැකි දේ එහි තර්කය ලෙස පිළිගෙන ලැයිස්තුව විශාල කරයි කරයි.
• එහි ප්‍රති ing ලයක් ලෙස ඇති ලැයිස්තුව සෑම විටම එක්-මාන ලැයිස්තුවක් (එනම් කැදැල්ලක් නැත) සහ එය යෙදීමේ ප්‍රති result ලයක් ලෙස එහි විෂමජාතීය මූලද්‍රව්‍ය (උදා: අක්ෂර, පූර්ණ සංඛ්‍යා, පාවෙන) අඩංගු විය හැකිය list(iterable).

2) අතර සමාන appendහාextend

• දෙදෙනාම හරියටම එක් තර්කයක් ගනී.
• දෙකම ලැයිස්තුව වෙනස් කරයි තැනින් තැන .
• ප්රති result ලයක් වශයෙන්, දෙකම ආපසු පැමිණේ 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)

මෙම ප්‍රශ්නයට ප්‍රයෝජනවත් අතිරේකයක් සෑදිය හැකි යැයි මම බලාපොරොත්තු වෙමි. ඔබේ ලැයිස්තුව නිශ්චිත වර්ගයේ වස්තුවක් ගබඩා කරන්නේ නම්, උදාහරණයක් ලෙස Info, extendක්‍රමයට නුසුදුසු තත්වයක් මෙහි දැක්වේ : forලූපයක් තුළ සහ Infoසෑම විටම වස්තුවක් උත්පාදනය කර extendඑය ඔබේ ලැයිස්තුවට ගබඩා කිරීමට භාවිතා කළහොත් එය අසාර්ථක වනු ඇත. ව්යතිරේකය පහත පරිදි වේ:

TypeError: 'තොරතුරු' වස්තුව නැවත යෙදිය නොහැක

නමුත් ඔබ appendක්රමය භාවිතා කරන්නේ නම් , ප්රති result ලය හරි. මන්දයත් සෑම විටම extendක්‍රමය භාවිතා කරන විට , එය සෑම විටම එය ලැයිස්තුවක් හෝ වෙනත් එකතු කිරීමේ වර්ගයක් ලෙස සලකනු ඇත, එය නැවත කියවීම සහ පෙර ලැයිස්තුවෙන් පසුව තබන්න. නිශ්චිත වස්තුවක් නැවත සැකසිය නොහැක.

ඒවා බුද්ධිමත්ව වෙන්කර හඳුනා ගැනීම

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

extend(L)දී ඇති ලැයිස්තුවේ ඇති සියලුම අයිතම එකතු කිරීමෙන් ලැයිස්තුව දීර් s කරයි 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]

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,

එකතු කිරීම හා දිගු කිරීම පයිතන්හි විස්තාරණතා යාන්ත්‍රණයන්ගෙන් එකකි.

එකතු කරන්න: ලැයිස්තුවේ අවසානයට අංගයක් එක් කරයි.

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

දිගු කරන්න: අපට ලැයිස්තු දෙකකට හෝ වැඩි ගණනකට එක ලැයිස්තුවකට සම්බන්ධ වීමට අවශ්‍ය විට මෙය ඉතා ප්‍රයෝජනවත් වේ. දීර් extend නොකර, අපට ලැයිස්තු දෙකකට සම්බන්ධ වීමට අවශ්‍ය නම්, එහි ප්‍රති ing ලයක් වශයෙන් ඇති වස්තුවෙහි ලැයිස්තු ලැයිස්තුවක් අඩංගු වේ.

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]