Wie füge ich alle Ganzzahlen in einer Liste zu ganzen Zahlen in einer anderen Liste mit unterschiedlicher Länge in der gleichen Reihenfolge in Python hinzu?

Question

Gegeben:

ListA = [1,2,3,4,5]

ListB = [10,20,30,40,50,60,70]

Wie kann ich es so machen, dass ListC = [11,22,33,44,55,60,70], wo C[0] = B[0] + A[0] ... C[5] = nil + B[5] und so weiter? Ich kann einfach nicht eine for-Schleife in diesem Fall verwenden, da wird es eine IndexError sein als ListB zwei Einträge hat mehr im Vergleich zu ListA?

Answer 1

Sie können itertools.zip_longest(..., fillvalue=0):

from itertools import zip_longest 
[x + y for x, y in zip_longest(ListA, ListB, fillvalue=0)] 
# [11, 22, 33, 44, 55, 60, 70] 

# or in python 2 
from itertools import izip_longest 
[x + y for x, y in izip_longest(ListA, ListB, fillvalue=0)] 
# [11, 22, 33, 44, 55, 60, 70] 

Wenn Sie eine numpy Lösung bevorzugen

import numpy as np 

def add_np(A, B): 
    m = max(len(A), len(B)) 
    return np.pad(A, (0, m-len(A)), 'constant') + np.pad(B, (0, m-len(B)), 'constant') 

add_np(ListA, ListB) 
# array([11, 22, 33, 44, 55, 60, 70]) 

Answer 2

Da Sie die numpy Tag setzen: Sie können numpy.pad aufzufüllen die beiden Listen auf die gleiche Länge verwenden

C = np.array(ListB) 
C[:len(ListA)] += ListA 
C 
# array([11, 22, 33, 44, 55, 60, 70]) 

Wenn Sie nicht im Voraus wissen, welche die kürzere und längere ist:

short, long_ = sorted([ListA, ListB], key=len) 
C = np.array(long_) 
C[:len(short)] += short 

Answer 3

Sie können eine for-Schleife verwenden, aber Sie müssen für den Unterschied in der Länge der Listen berücksichtigen. In eine if-Anweisung, die überprüft, dass es bei A ein Element vorhanden ist [5] oder was auch immer:

` 
i = 0 
for i in range(len(B)): 
    if A[i]: 
     C[i] = A[i] + B[i] 
    else: 
     C[i] = B[i] 
` 

Denken Sie daran, dies nur im Sinne arbeiten Sie so lange die Absicht, wie Sie die laufen Schleife auf dem längsten Liste.

Answer 4

könnten Sie zip(), dies zu tun:

def zip_lists(l1, l2): 
    if len(l1) == len(l2): 
     return [x + y for x, y in zip(l1, l2)] 

    s, b = min(l1, l2), max(l1, l2) 

    rest = len(s) 

    return [x + y for x, y in zip(s, b)] + b[rest:] 

Above Logik:

• Wenn beide Listen die gleiche Länge haben, zip() sie nur normal.
• Andernfalls finden Sie die kleinste Liste s, und die größte Liste b.
• Berechnen Sie die Länge von s, die rest ist.
• Dann zip() aus beiden Listen, und fügen Sie die Trailing-Elemente, rest aus der größeren Liste b.

Das Verhalten von zip_lists() ist unten dargestellt:

>>> print(zip_lists([1,2,3,4,5], [10,20,30,40,50,60,70])) 
[11, 22, 33, 44, 55, 60, 70] 
>>> print(zip_lists([1,2,3,4,5], [10,20,30,40,50])) 
[11, 22, 33, 44, 55] 

Answer 5

Sie so etwas wie dies versuchen:

Erste jene Elemente hinzufügen, die Paar bilden und dann verbleibenden Elemente:

ListA = [1,2,3,4,5] 

ListB = [10,20,30,40,50,60,70] 


your_data=list(map(lambda x,y:x+y,ListA,ListB)) 
your_data.extend(ListB[len(ListA):]) 
print(your_data) 

Ausgabe:

[11, 22, 33, 44, 55, 60, 70] 

Answer 6

Sie könnten den Slicing-Operator verwenden.

op = sum 
len_a, len_b = len(ListA), len(ListB) 
min_len, max_len = min(len_a,len_b), max(len_a,len_b) 
ListC = list(map(op,zip(ListA[:min_len],ListB[:min_len]))) + ListA[min_len:max_len] + ListB[min_len:max_len] 

Die letzte Zeile verkettet den Rest der beiden Listen. Wenn sie die gleiche Länge haben, dann wird es nichts tun. Wenn sie nicht die gleiche Länge haben dann die ListSmaller[min_len:max_len] wird eine leere Liste sein: []