Subtrahieren von 2 Listen in Python

Im Moment habe ich vector3-Werte als Listen dargestellt. Gibt es eine Möglichkeit, 2 dieser ähnlichen Vektor-3-Werte zu subtrahieren?

[2,2,2] - [1,1,1] = [1,1,1]

Soll ich Tupel verwenden?

Wenn keiner von ihnen diese Operanden für diese Typen definiert, kann ich sie stattdessen definieren?

Wenn nicht, sollte ich eine neue vector3-Klasse erstellen?

Wenn Sie dies häufig und mit unterschiedlichen Vorgängen tun, sollten Sie wahrscheinlich eine Klasse erstellen, um Fälle wie diesen zu behandeln, oder besser eine Bibliothek wie Numpy verwenden .

Suchen Sie andernfalls nach Listenverständnissen, die mit der integrierten Zip- Funktion verwendet werden:

[a_i - b_i for a_i, b_i in zip(a, b)]

Hier ist eine Alternative zum Listenverständnis. Map durchläuft gleichzeitig die Liste (n) (die letzteren Argumente) und übergibt ihre Elemente als Argumente an die Funktion (das erste Argument). Es gibt die resultierende Liste zurück.

map(operator.sub, a, b)

Dieser Code hat weniger Syntax (was für mich ästhetischer ist) und ist anscheinend 40% schneller für Listen mit einer Länge von 5 (siehe Bobince's Kommentar). Trotzdem wird jede Lösung funktionieren.

Wenn Ihre Listen a und b sind, können Sie Folgendes tun:

map(int.__sub__, a, b)

Aber du solltest es wahrscheinlich nicht. Niemand wird wissen, was es bedeutet.

Ich würde empfehlen NumPy auch

Es ist nicht nur schneller für die Vektormathematik, sondern verfügt auch über eine Vielzahl von praktischen Funktionen.

Wenn Sie etwas noch schnelleres für 1d-Vektoren wollen, versuchen Sie es mit vop

Es ist ähnlich wie MatLab, aber kostenlos und so. Hier ist ein Beispiel dafür, was Sie tun würden

from numpy import matrix
a = matrix((2,2,2))
b = matrix((1,1,1))
ret = a - b
print ret
>> [[1 1 1]]

Boom.

Wenn Sie zwei Listen mit den Namen "a" und "b" haben, können Sie Folgendes tun: [m - n for m,n in zip(a,b)]

Eine etwas andere Vektorklasse.

class Vector( object ):
    def __init__(self, *data):
        self.data = data
    def __repr__(self):
        return repr(self.data) 
    def __add__(self, other):
        return tuple( (a+b for a,b in zip(self.data, other.data) ) )  
    def __sub__(self, other):
        return tuple( (a-b for a,b in zip(self.data, other.data) ) )

Vector(1, 2, 3) - Vector(1, 1, 1)

import numpy as np
a = [2,2,2]
b = [1,1,1]
np.subtract(a,b)

Wenn Sie mehr als nur einfache Einzeiler ausführen möchten, ist es besser, eine eigene Klasse zu implementieren und die entsprechenden Operatoren zu überschreiben, die für Ihren Fall gelten.

Entnommen aus der Mathematik in Python :

class Vector:

  def __init__(self, data):
    self.data = data

  def __repr__(self):
    return repr(self.data)  

  def __add__(self, other):
    data = []
    for j in range(len(self.data)):
      data.append(self.data[j] + other.data[j])
    return Vector(data)  

x = Vector([1, 2, 3])    
print x + x

Für denjenigen, der früher auf Pycharm programmiert hat, werden auch andere wiederbelebt.

 import operator
 Arr1=[1,2,3,45]
 Arr2=[3,4,56,78]
 print(list(map(operator.sub,Arr1,Arr2)))

Die Kombination von mapund lambdaFunktionen in Python ist eine gute Lösung für diese Art von Problem:

a = [2,2,2]
b = [1,1,1]
map(lambda x,y: x-y, a,b)

zip Funktion ist eine weitere gute Wahl, wie @UncleZeiv zeigt

arr1=[1,2,3]
arr2=[2,1,3]
ls=[arr2-arr1 for arr1,arr2 in zip(arr1,arr2)]
print(ls)
>>[1,-1,0]

Diese Antwort zeigt, wie man "normalen / leicht verständlichen" Python-Code schreibt.

Ich schlage vor, nicht zu verwenden, zipda nicht wirklich jeder davon weiß.


Die Lösungen verwenden Listenverständnisse und allgemeine integrierte Funktionen.

Alternative 1 (empfohlen):

a = [2, 2, 2]
b = [1, 1, 1]
result = [a[i] - b[i] for i in range(len(a))]

Empfohlen, da nur die grundlegendsten Funktionen in Python verwendet werden

Alternative 2:

a = [2, 2, 2]
b = [1, 1, 1]
result = [x - b[i] for i, x in enumerate(a)]

Alternative 3 (wie von BioCoder erwähnt ):

a = [2, 2, 2]
b = [1, 1, 1]
result = list(map(lambda x, y: x - y, a, b))

Versuche dies:

list(array([1,2,3])-1)