python - पायथन में दो सूचियों को कैसे सम्मिलित करें?




list (21)

यदि आप क्रमबद्ध रूप में दो सूचियों को मर्ज करना चाहते हैं, तो आप हेपैक लाइब्रेरी से मर्ज फ़ंक्शन का उपयोग कर सकते हैं।

from heapq import merge

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

print list(merge(a,b))

मैं पायथन में दो सूचियों को कैसे जोड़ूं?

उदाहरण:

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

अनुमानित परिणाम:

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

यह काफी सरल है, मुझे लगता है कि यह tutorial में भी दिखाया गया था:

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

एक जनरेटर बनाना भी संभव है जो दोनों सूचियों में आइटमों पर आसानी से पुनरावृत्त हो। यह आपको एक नई सूची में आइटम कॉपी किए बिना प्रोसेसिंग के लिए चेन सूचियों (या किसी भी पुनरावर्तनीय) को एक साथ करने की अनुमति देता है:

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

यदि आप दो पुरानी सूचियां रखते हुए एक नई सूची चाहते थे:

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

sorted(joinedList)

return joinedList

आप extend समारोह के लिए जा सकते हैं।

l1 = [1,2,3]
l2 = [4,5,6]
l1.extend(l2)
print l1

आउटपुट: [1,2,3,4,5,6]


पायथन 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]

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

उपर्युक्त कोड, आदेश को संरक्षित नहीं करता है, प्रत्येक सूची से डुप्लिकेट हटा देता है (लेकिन समेकित सूची से नहीं)


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]

mergedlist = listone + listtwo

आउटपुट:

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

पायथन में दो सूचियों में शामिल होना:

>>> a = [1, 2, 3, 4]
>>> b = [1, 4, 6, 7]
>>> c = a + b
>>> c
[1, 2, 3, 4, 1, 4, 6, 7]

यदि आप कोई डुप्लिकेशन नहीं चाहते हैं:

>>> a = [1, 2, 3, 4, 5, 6]
>>> b = [5, 6, 7, 8]
>>> c = list(set(a + b))
>>> c
[1, 2, 3, 4, 5, 6, 7, 8]

यह ध्यान देने योग्य है कि 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']

यदि एक पुनरावृत्त (tuple, सूची, जेनरेटर, आदि) इनपुट है, तो from_iterable वर्ग विधि का उपयोग किया जा सकता है:

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

यह सवाल सीधे दो सूचियों में शामिल होने के बारे में पूछता है। हालांकि, जब आप कई सूचियों में शामिल होने का तरीका ढूंढ रहे हैं, तब भी यह खोज में बहुत अधिक है (जब आप शून्य सूचियों में शामिल होते हैं)। इस अधिक सामान्य दृष्टिकोण पर विचार करें:

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() छोड़ दें list()

अद्यतन करें

टिप्पणियों में पैट्रिक कॉलिन्स द्वारा सुझाए गए वैकल्पिक भी आपके लिए काम कर सकते हैं:

sum(a, [])

आप list वस्तुओं पर परिभाषित append() विधि का उपयोग कर सकते हैं:

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

जैसा कि पहले से ही कई लोगों द्वारा इंगित किया गया है, 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 पायथन for ... in लूप में ट्यूपल चर के साथ काम कर सकते हैं, इसलिए एक ही समय में एकाधिक चर पर लूप करना आसान है।


अधिक सूचियों के लिए एक सामान्य तरीका के रूप में आप उन्हें एक सूची में डाल सकते हैं और itertools.chain.from_iterable() 1 फ़ंक्शन का उपयोग कर सकते हैं जो THIS उत्तर पर आधारित है, नेस्टेड सूची को फ़्लैट करने का सबसे अच्छा तरीका है:

>>> 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() python => 2.6 में उपलब्ध है। अन्य संस्करणों में chain(*l) उपयोग करें chain(*l)


सूचियों की सूची जोड़ने का एक संक्षिप्त तरीका है

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

जो हमें देता है

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

यदि आपको जटिल सॉर्टिंग नियमों के साथ दो आदेशित सूचियों को मर्ज करने की आवश्यकता है, तो आपको इसे निम्न कोड (जैसे पठनीयता :-) के लिए एक सरल सॉर्टिंग नियम का उपयोग करके) में स्वयं को रोल करना पड़ सकता है।

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

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

mergedlist = list(set(listone + listtwo))

आप फ़ंक्शन का extends कर सकते हैं

listone.extends(listtwo)

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]

इस उत्तर का उत्तर दिया गया है, लेकिन मैंने सोचा कि मैं अपने सजावटी वर्ग को साझा करूंगा जो नए सजावटी लिखने को आसान और कॉम्पैक्ट बनाता है।

from abc import ABCMeta, abstractclassmethod

class Decorator(metaclass=ABCMeta):
    """ Acts as a base class for all decorators """

    def __init__(self):
        self.method = None

    def __call__(self, method):
        self.method = method
        return self.call

    @abstractclassmethod
    def call(self, *args, **kwargs):
        return self.method(*args, **kwargs)

एक के लिए मुझे लगता है कि यह सजावटी के व्यवहार को बहुत स्पष्ट बनाता है, लेकिन यह नए सजावटकारों को बहुत संक्षेप में परिभाषित करना भी आसान बनाता है। ऊपर सूचीबद्ध उदाहरण के लिए, आप इसे हल कर सकते हैं:

class MakeBold(Decorator):
    def call():
        return "<b>" + self.method() + "</b>"

class MakeItalic(Decorator):
    def call():
        return "<i>" + self.method() + "</i>"

@MakeBold()
@MakeItalic()
def say():
   return "Hello"

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

class ApplyRecursive(Decorator):
    def __init__(self, *types):
        super().__init__()
        if not len(types):
            types = (dict, list, tuple, set)
        self._types = types

    def call(self, arg):
        if dict in self._types and isinstance(arg, dict):
            return {key: self.call(value) for key, value in arg.items()}

        if set in self._types and isinstance(arg, set):
            return set(self.call(value) for value in arg)

        if tuple in self._types and isinstance(arg, tuple):
            return tuple(self.call(value) for value in arg)

        if list in self._types and isinstance(arg, list):
            return list(self.call(value) for value in arg)

        return self.method(arg)


@ApplyRecursive(tuple, set, dict)
def double(arg):
    return 2*arg

print(double(1))
print(double({'a': 1, 'b': 2}))
print(double({1, 2, 3}))
print(double((1, 2, 3, 4)))
print(double([1, 2, 3, 4, 5]))

कौन से प्रिंट:

2
{'a': 2, 'b': 4}
{2, 4, 6}
(2, 4, 6, 8)
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

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







python list