verschachteln - python mit listen rechnen




Wie verkette ich zwei Listen in Python? (16)

Als allgemeinere Möglichkeit für weitere Listen können Sie sie in eine Liste itertools.chain.from_iterable() und itertools.chain.from_iterable() 1 Funktion, die basierend auf dieser Antwort die beste Möglichkeit ist, eine verschachtelte Liste zu glätten:

>>> 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. Beachten Sie, dass chain.from_iterable() in python => 2.6 verfügbar ist. In anderen Versionen verwenden Sie chain(*l)

Wie verknüpfe ich zwei Listen in Python?

Beispiel:

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

Erwartetes Ergebnis:

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

Das ist ziemlich einfach, ich denke, es wurde sogar im tutorial :

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

Eine wirklich prägnante Möglichkeit, eine Liste von Listen hinzuzufügen, ist

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

Das gibt uns

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

Es ist auch möglich, einen Generator zu erstellen, der einfach über die Elemente in beiden Listen iteriert. Dadurch können Sie Listen (oder beliebige iterierbare) für die Verarbeitung aneinanderreihen, ohne die Elemente in eine neue Liste zu kopieren:

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

Fügen Sie zwei Listen in Python hinzu:

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

Wenn Sie keine Duplizierung wünschen:

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

Mit Python 3.3+ können Sie Ertrag von :

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]

Oder wenn Sie eine beliebige Anzahl von Iteratoren unterstützen wollen:

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]

Sie können auch extend verwenden, um eine list hinzuzufügen, indem Sie das Ende eines anderen hinzufügen:

listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

Sie können den Operator + , um sie zu kombinieren:

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

mergedlist = listone + listtwo

Ausgabe:

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

Sie können einfach den Operator + oder += wie folgt verwenden:

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

c = a + b

Oder:

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

c += (a + b)

Wenn Sie möchten, dass die Werte in der zusammengeführten Liste eindeutig sind, können Sie Folgendes tun:

c = list(set(a + b))

Sie können für extend gehen.

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

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


Wenn Sie den __add__ ( + ) nicht verwenden können, können Sie die Funktion __add__ verwenden:

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

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

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

Wenn Sie die Verwendung von dunders gern nicht mögen, dunders Sie dunders den operator import verwenden:

import operator

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

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

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

Man könnte argumentieren, dass dies etwas lesbarer ist.


Wenn Sie die beiden Listen in sortierter Form zusammenführen möchten, können Sie die Zusammenführungsfunktion aus der heapq-Bibliothek verwenden.

from heapq import merge

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

print list(merge(a,b))

Wenn Sie zwei geordnete Listen mit komplizierten Sortierungsregeln zusammenführen müssen, müssen Sie sie möglicherweise wie im folgenden Code selbst rollen (mit einer einfachen Sortierregel für Lesbarkeit :-)).

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

Wie bereits von vielen gezeigt, ist itertools.chain() der itertools.chain() Weg, wenn man genau dieselbe Behandlung auf beide Listen anwenden muss. In meinem Fall hatte ich ein Label und eine Flagge, die sich von einer Liste zur anderen unterschieden, also brauchte ich etwas etwas Komplexeres. Wie sich herausstellt, tut itertools.chain() hinter den Kulissen einfach folgendes:

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

(siehe https://docs.python.org/2/library/itertools.html ), also habe ich mich von hier inspirieren lassen und etwas in diese Richtung geschrieben:

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

Die wichtigsten Punkte, die hier zu verstehen sind, sind, dass Listen nur ein Spezialfall von iterierbar sind, also Objekte wie jedes andere; und dass for ... in Schleifen in Python mit Tuple-Variablen arbeiten kann, ist es einfach, mehrere Variablen gleichzeitig zu durchlaufen.


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

Ausgabe:

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]

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

Der obige Code behält die Reihenfolge nicht bei, entfernt Duplikate aus jeder Liste (aber nicht aus der verketteten Liste)





list