පයිතන් හි ලැයිස්තු දෙකක් සංයුක්ත කරන්නේ කෙසේද?

උදාහරණයක්:

listone = [1, 2, 3]
listtwo = [4, 5, 6]

අපේක්ෂිත ප්‍රති come ලය:

>>> joinedlist
[1, 2, 3, 4, 5, 6]

+ඒවා ඒකාබද්ධ කිරීම සඳහා ඔබට ක්‍රියාකරු භාවිතා කළ හැකිය :

listone = [1,2,3]
listtwo = [4,5,6]

joinedlist = listone + listtwo

ප්‍රතිදානය:

>>> joinedlist
[1,2,3,4,5,6]

ලැයිස්තු දෙකේම ඇති අයිතම භාවිතයෙන් සරලව පුනරාවර්තනය වන උත්පාදක යන්ත්රයක් නිර්මාණය කිරීමට ද හැකිය itertools.chain(). නව ලැයිස්තුවකට අයිතම පිටපත් නොකර සැකසීම සඳහා දාම ලැයිස්තු (හෝ ඕනෑම නැවත කළ හැකි) එකට සැකසීමට මෙය ඔබට ඉඩ දෙයි:

import itertools
for item in itertools.chain(listone, listtwo):
    # Do something with each list item

පයිතන් >= 3.5විකල්පය:[*l1, *l2]

PEP 448සඳහන් කළ යුතු පිළිගැනීම තුළින් තවත් විකල්පයක් හඳුන්වා දී ඇත .

අතිරේක ඉවත් කිරීම සාමාන්‍යකරණයන් ලෙස නම් කර ඇති PEP, සාමාන්‍යයෙන් *පයිතන්හි තරු ලකුණු කළ ප්‍රකාශනය භාවිතා කරන විට සමහර සින්ටැක්ටික් සීමාවන් අඩු කළේය; එය සමඟ, ලැයිස්තු දෙකකට සම්බන්ධ වීම (ඕනෑම නැවත කළ හැකි දේකට අදාළ වේ) දැන් කළ හැක්කේ:

>>> l1 = [1, 2, 3]
>>> l2 = [4, 5, 6]
>>> joined_list = [*l1, *l2]  # unpack both iterables in a list literal
>>> print(joined_list)
[1, 2, 3, 4, 5, 6]

මෙම ක්‍රියාකාරීත්වය පයිතන් සඳහා අර්ථ දක්වා ඇති අතර3.5 එය 3.xපවුලේ පෙර සංස්කරණ වලට ආපසු යවා නොමැත . සහාය නොදක්වන අනුවාද වල a SyntaxErrorමතු කිරීමට යන්නේ ය.

අනෙක් ප්‍රවේශයන් මෙන්ම, මෙයද අනුරූප ලැයිස්තුවල ඇති මූලද්‍රව්‍යවල නොගැඹුරු පිටපතක් ලෙස නිර්මාණය කරයි .

මෙම උඩු යටිකුරු මෙම ප්රවේශය සඳහා ඔබ ඇත්තටම එය ඉටු කිරීම සඳහා ලැයිස්තු අවශ්ය, iterable කරන්නේ ඕනෑම දෙයක් නැති බව ය. PEP හි සඳහන් පරිදි:

මෙම වැනි, ද ලැයිස්තුවට iterables කෘතියේ මෙසේ වඩාත් හොඳින් කියවිය හැකි ක්රමයක් ලෙස ප්රයෝජනවත් වේ my_list + list(my_tuple) + list(my_range)මේ නිසා, සමාන වන [*my_list, *my_tuple, *my_range].

එබැවින් එකතු කිරීම වර්ගය නොගැලපීම නිසා +මතු TypeErrorවේ:

l = [1, 2, 3]
r = range(4, 7)
res = l + r

පහත සඳහන් දෑ සිදු නොවේ:

res = [*l, *r]

මක්නිසාද යත්, එය මුලින්ම පුනරාවර්තනවල listඅන්තර්ගතය ඉවත් කර පසුව අන්තර්ගතයෙන් සරලව නිර්මාණය කරන බැවිනි.

අද්විතීය අගයන් ඒකාබද්ධ කරන ලද ලැයිස්තුවක් ලබා ගැනීමට ඔබට කට්ටල භාවිතා කළ හැකිය

mergedlist = list(set(listone + listtwo))

තවත් එකක අවසානයට list.extend()එකතු කිරීම සඳහා ඔබට මෙම ක්‍රමය භාවිතා කළ හැකිය list:

listone = [1,2,3]
listtwo = [4,5,6]

listone.extend(listtwo)

ඔබට මුල් ලැයිස්තුව නොවෙනස්ව තබා ගැනීමට අවශ්‍ය නම්, ඔබට නව listවස්තුවක් නිර්මාණය කළ හැකි අතර ඒ සඳහා extendලැයිස්තු දෙකම:

mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

පයිතන් හි ලැයිස්තු දෙකක් සංයුක්ත කරන්නේ කෙසේද?

3.7 වන විට, මේවා පයිතන්හි ලැයිස්තු දෙකක් (හෝ වැඩි ගණනක්) සංයුක්ත කිරීම සඳහා වඩාත් ජනප්‍රිය ස්ටඩ්ලිබ් ක්‍රම වේ.

පාද සටහන්

1. මෙය සාරාංශගත විසඳුමකි. නමුත් sumයුගල වශයෙන් මෝස්තරයක් සිදු කරයි, එයින් අදහස් වන්නේ මෙය එක් එක් පියවර සඳහා මතකය වෙන් කළ යුතු බැවින් මෙය චතුරස්රාකාර මෙහෙයුමක් බවයි. ඔබගේ ලැයිස්තු විශාල නම් භාවිතා නොකරන්න.

2. බලන්න chain සහ chain.from_iterable ලියකියවිලි වලින්. ඔබට import itertoolsපළමුව අවශ්‍ය වනු ඇත . සංක්ෂිප්ත කිරීම මතකයේ රේඛීය වේ, එබැවින් කාර්ය සාධනය සහ අනුවාද අනුකූලතාව අනුව මෙය හොඳම වේ. chain.from_iterable2.6 දී හඳුන්වා දෙන ලදී.

3. මෙම ක්‍රමය මඟින් අතිරේක ඇසුරුම්කරණ සාමාන්‍යකරණයන් (PEP 448) භාවිතා කරයි , නමුත් ඔබ එක් එක් ඒවා අතින් ඉවත් නොකරන්නේ නම් N ලැයිස්තු වලට සාමාන්‍යකරණය කළ නොහැක.

4. a += bසහ a.extend(b)සියලු ප්‍රායෝගික අරමුණු සඳහා වැඩි හෝ අඩු සමාන වේ. +=ලැයිස්තුවකට කැඳවූ විට අභ්‍යන්තරව අමතනු ඇත list.__iadd__, එය පළමු ලැයිස්තුව දෙවනුව දක්වා විහිදේ.

කාර්ය සාධනය

2-ලැයිස්තු සම්මුතිය ¹

මෙම ක්‍රම අතර එතරම් වෙනසක් නැති නමුත් ඒවා සියල්ලටම එකම සංකීර්ණ අනුපිළිවෙලක් (රේඛීය) ඇති බැවින් එය අර්ථවත් කරයි. ශෛලිය පිළිබඳ කාරණයක් හැරෙන්නට එකිනෙකාට වඩා කැමති වීමට විශේෂ හේතුවක් නැත.

N- ලැයිස්තු සම්මුතිය

Perfplot මොඩියුලය භාවිතයෙන් බිම් කොටස් ජනනය කර ඇත . කේතය, ඔබේ යොමු කිරීම සඳහා.

_{1. iadd( +=) සහ extendක්‍රම නිසි පරිදි ක්‍රියාත්මක වන බැවින් පරීක්ෂා කිරීමට පෙර සෑම අවස්ථාවකදීම පිටපතක් ජනනය කළ යුතුය. දේවල් සාධාරණව තබා ගැනීම සඳහා, සියලු ක්‍රම වම් පස ලැයිස්තුව සඳහා පූර්ව පිටපත් කිරීමේ පියවරක් ඇති අතර එය නොසලකා හැරිය හැකිය.}

වෙනත් විසඳුම් පිළිබඳ අදහස්

• ඩන්ඩර් ක්‍රමය list.__add__කෙලින්ම කිසිම ආකාරයකින්, හැඩයකින් හෝ ආකාරයකින් භාවිතා නොකරන්න . ඇත්ත වශයෙන්ම, ඩන්ඩර් ක්‍රම වලින් stay ත්ව සිටින්න, සහ operatorඒවා නිර්මාණය කර ඇති ආකාරයට ක්‍රියාකරුවන් සහ කාර්යයන් භාවිතා කරන්න . පයිතන් පරිස්සමින් අර්ථ නිරූපණය කර ඇති අතර ඒවා කෙලින්ම ඩන්ඩර් ලෙස හැඳින්වීමට වඩා සංකීර්ණ වේ. මෙන්න උදාහරණයක් . එබැවින්, සාරාංශ කිරීමට, a.__add__(b)=> BAD; a + b=> හොඳයි.

• මෙහි සමහර පිළිතුරු reduce(operator.add, [a, b])යුගල වශයෙන් සංයුක්ත කිරීම සඳහා ඉදිරිපත් කරයි - මෙය sum([a, b], [])වඩා නරක වචන වලට සමාන වේ.

• භාවිතා කරන ඕනෑම ක්‍රමයක් setඅනුපිටපත් අතහැර ඇණවුම නැති කරයි. ප්‍රවේශමෙන් භාවිතා කරන්න.

• for i in b: a.append(i)a.extend(b)තනි ක්‍රියාකාරී ඇමතුමකට වඩා මුග්ධ හා වඩා මන්දගාමී වේ . appendලැයිස්තු සඳහා මතකය වෙන් කර වර්ධනය කරන අර්ථකථන නිසා මන්දගාමී වේ. සමාන සාකච්ඡාවක් සඳහා මෙහි බලන්න .

• heapq.mergeක්‍රියා කරනු ඇත, නමුත් එහි භාවිත අවස්ථාව වන්නේ වර්ග කළ ලැයිස්තු රේඛීය වේලාවට ඒකාබද්ධ කිරීමයි. වෙනත් ඕනෑම අවස්ථාවක එය භාවිතා කිරීම ප්‍රති-රටාවකි.

• yieldශ්‍රිතයක අඩංගු ලැයිස්තු මූලද්‍රව්‍ය පිළිගත හැකි ක්‍රමයකි, නමුත් chainමෙය වේගවත් හා වඩා හොඳ කරයි (එයට C හි කේත මාර්ගයක් ඇත, එබැවින් එය වේගවත් වේ).

• operator.add(a, b)යනු පිළිගත හැකි ක්‍රියාකාරී වේ a + b. එහි භාවිත අවස්ථා ප්‍රධාන වශයෙන් ගතික ක්‍රම යැවීම සඳහා වේ. එසේ නොමැති නම්, මගේ මතය අනුවa + b කෙටි හා වඩා කියවිය හැකි දේට වැඩි කැමැත්තක් දක්වන්න . වයි.එම්.එම්.වී.

මෙය තරමක් සරල ය, එය නිබන්ධනයේ පවා පෙන්වා ඇති බව මම සිතමි :

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]

මෙම ප්‍රශ්නය ලැයිස්තු දෙකකට සම්බන්ධ වීම ගැන කෙලින්ම අසයි. කෙසේ වෙතත්, ඔබ බොහෝ ලැයිස්තු වලට සම්බන්ධ වීමේ මාර්ගයක් සොයන විට පවා එය සෙවීමේ ඉතා ඉහළ මට්ටමක පවතී (ඔබ ශුන්‍ය ලැයිස්තු වලට සම්බන්ධ වන අවස්ථාව ද ඇතුළුව).

මම හිතන්නේ හොඳම විකල්පය ලැයිස්තු අවබෝධය භාවිතා කිරීමයි:

>>> a = [[1,2,3], [4,5,6], [7,8,9]]
>>> [x for xs in a for x in xs]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

ඔබට ජනක යන්ත්‍රද සෑදිය හැකිය:

>>> map(str, (x for xs in a for x in xs))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

පැරණි පිළිතුර

මෙම වඩාත් පොදු ප්‍රවේශය සලකා බලන්න:

a = [[1,2,3], [4,5,6], [7,8,9]]
reduce(lambda c, x: c + x, a, [])

ප්‍රතිදානය කරයි:

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

සටහන විට මේ නිවැරදිව ක්රියා aවේ []හෝ [[1,2,3]].

කෙසේ වෙතත්, මෙය වඩාත් කාර්යක්ෂමව කළ හැක්කේ itertools:

a = [[1,2,3], [4,5,6], [7,8,9]]
list(itertools.chain(*a))

ඔබට අවශ්‍ය නැති listනමුත් නැවත කළ හැකි දෙයක් නම්, අතහරින්න list().

යාවත්කාලීන කරන්න

අදහස් දැක්වීමේදී පැට්‍රික් කොලින්ස් විසින් යෝජනා කරන ලද විකල්පයද ඔබට ප්‍රයෝජනවත් විය හැකිය:

sum(a, [])

ඔබට පහත පරිදි +හෝ +=ක්‍රියාකරු භාවිතා කළ හැකිය :

a = [1, 2, 3]
b = [4, 5, 6]

c = a + b

හෝ:

c = []
a = [1, 2, 3]
b = [4, 5, 6]

c += (a + b)

එසේම, ඒකාබද්ධ කළ ලැයිස්තුවේ අගයන් අද්විතීය වීමට ඔබට අවශ්‍ය නම් ඔබට කළ හැක්කේ:

c = list(set(a + b))

itertools.chainශ්‍රිතය විචල්‍ය තර්ක ගණනක් පිළිගන්නා බව සඳහන් කිරීම වටී :

>>> l1 = ['a']; l2 = ['b', 'c']; l3 = ['d', 'e', 'f']
>>> [i for i in itertools.chain(l1, l2)]
['a', 'b', 'c']
>>> [i for i in itertools.chain(l1, l2, l3)]
['a', 'b', 'c', 'd', 'e', 'f']

පුනරාවර්තනය කළ හැකි (ටුපල්, ලැයිස්තුව, උත්පාදක යනාදිය) ආදානය නම්, from_iterableපන්ති ක්‍රමය භාවිතා කළ හැකිය:

>>> il = [['a'], ['b', 'c'], ['d', 'e', 'f']]
>>> [i for i in itertools.chain.from_iterable(il)]
['a', 'b', 'c', 'd', 'e', 'f']

පයිතන් 3.3+ සමඟින් ඔබට අස්වැන්න භාවිතා කළ හැකිය :

listone = [1,2,3]
listtwo = [4,5,6]

def merge(l1, l2):
    yield from l1
    yield from l2

>>> list(merge(listone, listtwo))
[1, 2, 3, 4, 5, 6]

නැතහොත්, ඔබට අත්තනෝමතික අනුකාරක සංඛ්‍යාවක් සඳහා සහාය වීමට අවශ්‍ය නම්:

def merge(*iters):
    for it in iters:
        yield from it

>>> list(merge(listone, listtwo, 'abcd', [20, 21, 22]))
[1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 20, 21, 22]

ලැයිස්තු දෙක වර්ග කළ ආකාරයෙන් ඒකාබද්ධ කිරීමට ඔබට අවශ්‍ය නම්, ඔබට පුස්තකාලයෙන් mergeශ්‍රිතය භාවිතා කළ හැකිය heapq.

from heapq import merge

a = [1, 2, 4]
b = [2, 4, 6, 7]

print list(merge(a, b))

ඔබට ප්ලස් ක්‍රියාකරු ( +) භාවිතා කළ නොහැකි නම් , ඔබට operatorආනයනය භාවිතා කළ හැකිය :

import operator

listone = [1,2,3]
listtwo = [4,5,6]

result = operator.add(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

විකල්පයක් ලෙස, ඔබට __add__ ඩන්ඩර් ශ්‍රිතය ද භාවිතා කළ හැකිය :

listone = [1,2,3]
listtwo = [4,5,6]

result = list.__add__(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

තවත් ලැයිස්තු සඳහා වඩාත් පොදු ක්‍රමයක් ලෙස ඔබට ඒවා ලැයිස්තුවක් තුළට දමා itertools.chain.from_iterable()¹ ශ්‍රිතය භාවිතා කළ හැකිය. මෙම පිළිතුර මත පදනම්ව කැදැලි ලැයිස්තුවක් පැතලි කිරීම සඳහා හොඳම ක්‍රමය වේ:

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

_{1. chain.from_iterable()පයිතන් 2.6 සහ ඊට පසුව ලබා ගත හැකි සටහන . වෙනත් අනුවාද වල, භාවිතා කරන්න chain(*l).}

ඇණවුම් කරන ලද ලැයිස්තු දෙකක් සංකීර්ණ වර්ග කිරීමේ නීති සමඟ ඒකාබද්ධ කිරීමට ඔබට අවශ්‍ය නම්, පහත දැක්වෙන කේතය මෙන් ඔබට එය පෙරළීමට සිදුවේ (කියවීමේ හැකියාව සඳහා සරල වර්ග කිරීමේ රීතියක් භාවිතා කරමින් :-)).

list1 = [1,2,5]
list2 = [2,3,4]
newlist = []

while list1 and list2:
    if list1[0] == list2[0]:
        newlist.append(list1.pop(0))
        list2.pop(0)
    elif list1[0] < list2[0]:
        newlist.append(list1.pop(0))
    else:
        newlist.append(list2.pop(0))

if list1:
    newlist.extend(list1)
if list2:
    newlist.extend(list2)

assert(newlist == [1, 2, 3, 4, 5])

වස්තූන් append()මත අර්ථ දක්වා ඇති ක්‍රමය ඔබට භාවිතා කළ listහැකිය:

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)

list(set(listone) | set(listtwo))

ඉහත කේතය, ඇණවුම ආරක්ෂා නොකරයි, එක් එක් ලැයිස්තුවෙන් අනුපිටපත් ඉවත් කරයි (නමුත් සංයුක්ත ලැයිස්තුවෙන් නොවේ)

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

for it in iterables:
    for element in it:
        yield element

( https://docs.python.org/2/library/itertools.html බලන්න ), එබැවින් මම මෙතැන් සිට ආශ්වාදයක් ලබා ගෙන මෙම රේඛා ඔස්සේ යමක් ලිවීමි:

for iterable, header, flag in ( (newList, 'New', ''), (modList, 'Modified', '-f')):
    print header + ':'
    for path in iterable:
        [...]
        command = 'cp -r' if os.path.isdir(srcPath) else 'cp'
        print >> SCRIPT , command, flag, srcPath, mergedDirPath
        [...]

මෙහි දී වටහා ගත යුතු ප්‍රධාන කරුණු නම්, ලැයිස්තු යනු නැවත ලබා ගත හැකි විශේෂ අවස්ථාවක් පමණක් වන අතර ඒවා වෙනත් ඕනෑම වස්තුවක් වැනි ය; for ... inපයිතන් වල ඇති ලූප ටුපල් විචල්‍යයන් සමඟ ක්‍රියා කළ හැකි බැවින් එකවර බහුවිධ විචල්‍යයන් මත ලූප කිරීම පහසුය.

සරල ලැයිස්තු අවබෝධයක් භාවිතා කරන්න:

joined_list = [item for list_ in [list_one, list_two] for item in list_]

අතිරේක ඇසුරුම්කරණ සාමාන්‍යකරණයන් භාවිතා කිරීමේ නවතම ප්‍රවේශයේ සියලු වාසි එයට ඇත - එනම් ඔබට අත්තනෝමතික ලෙස විවිධ පුනරාවර්තන සංඛ්‍යාවක් (නිදසුනක් ලෙස ලැයිස්තු, ටුපල්, පරාස සහ ජනක යන්ත්‍ර) සංයුක්ත කළ හැකිය - එය පයිතන් 3.5 හෝ ඊට පසුව සීමා නොවේ. .

ලැයිස්තු ලැයිස්තුවක් ඒකාබද්ධ කිරීම සඳහා සැබවින්ම සංක්ෂිප්ත ක්‍රමයකි

list_of_lists = [[1,2,3], [4,5,6], [7,8,9]]
reduce(list.__add__, list_of_lists)

එය අපට ලබා දෙයි

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

පයිතන්හිදී ඔබට මෙම විධානය සමඟ අනුකූල මානයන්හි අරා දෙකක් සංයුක්ත කළ හැකිය

numpy.concatenate([a,b])

එබැවින් පහසු ක්‍රම දෙකක් තිබේ.

1. භාවිතා කිරීම+ : එය සපයා ඇති ලැයිස්තු වලින් නව ලැයිස්තුවක් නිර්මාණය කරයි

උදාහරණයක්:

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: a + b
Out[3]: [1, 2, 3, 4, 5, 6]

In [4]: %timeit a + b
10000000 loops, best of 3: 126 ns per loop

2. දිගුව භාවිතා කිරීම : එය පවතින ලැයිස්තුවට නව ලැයිස්තුවක් එක් කරයි. ඒ කියන්නේ එය වෙනම ලැයිස්තුවක් නිර්මාණය නොකරයි.

උදාහරණයක්:

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: %timeit a.extend(b)
10000000 loops, best of 3: 91.1 ns per loop

මේ අනුව වඩාත් ජනප්‍රිය ක්‍රම දෙකෙන් extendකාර්යක්ෂම බව අපට පෙනේ .

පයිතන් හි ලැයිස්තු සංයුක්ත කිරීමට විවිධ ක්‍රම තිබේ.

l1 = [1, 2, 3, 4]
l2 = [3, 4, 5, 6]

1. new_list = l1.copy()
new_list.extend(l2)

2. new_list = l1 + l2

3. new_list = [*l1, *l2]

import itertools

A = list(zip([1,3,5,7,9],[2,4,6,8,10]))
B = [1,3,5,7,9]+[2,4,6,8,10]
C = list(set([1,3,5,7,9] + [2,4,6,8,10]))

D = [1,3,5,7,9]
D.append([2,4,6,8,10])

E = [1,3,5,7,9]
E.extend([2,4,6,8,10])

F = []
for a in itertools.chain([1,3,5,7,9], [2,4,6,8,10]):
    F.append(a)


print ("A: " + str(A))
print ("B: " + str(B))
print ("C: " + str(C))
print ("D: " + str(D))
print ("E: " + str(E))
print ("F: " + str(F))

ප්‍රතිදානය:

A: [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
B: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
C: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
D: [1, 3, 5, 7, 9, [2, 4, 6, 8, 10]]
E: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
F: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

පැරණි ලැයිස්තු දෙක තබා ගනිමින් ඔබට නව ලැයිස්තුවක් අවශ්‍ය නම්:

def concatenate_list(listOne, listTwo):
    joinedList = []
    for i in listOne:
        joinedList.append(i)
    for j in listTwo:
        joinedList.append(j)

    sorted(joinedList)

    return joinedList

lst1 = [1,2]

lst2 = [3,4]

def list_combinationer(Bushisms, are_funny):

    for item in lst1:
        lst2.append(item)
        lst1n2 = sorted(lst2)
        print lst1n2

list_combinationer(lst1, lst2)

[1,2,3,4]

ඔබට කේතය අනුගමනය කළ හැකිය

listone = [1, 2, 3]
listtwo = [4, 5, 6]

for i in listone:
    listtwo.append(i)
print(listtwo)

[1,2,3,4,5,6]