Momentan habe ich vector3-Werte als Listen dargestellt. gibt es eine Möglichkeit, 2 dieser Werte wie vector3-Werte abzuziehen, wie
[2,2,2] - [1,1,1] = [1,1,1]
Soll ich Tupel verwenden?
Kann keiner von ihnen diese Operanden für diese Typen definieren, kann ich sie stattdessen definieren?
Wenn nicht, sollte ich eine neue vector3-Klasse erstellen?
Wenn Sie am Ende häufig arbeiten und verschiedene Vorgänge ausführen, sollten Sie wahrscheinlich eine Klasse erstellen, um Fälle wie diese zu behandeln, oder lieber eine Bibliothek wie Numpy .
Suchen Sie andernfalls nach Listenverständnissen , die mit der Funktion Zip builtin verwendet werden:
[a_i - b_i for a_i, b_i in Zip(a, b)]
Hier ist eine Alternative zum Auflisten von Listen. Map durchläuft die Liste (n) (die letzteren Argumente) gleichzeitig und übergibt ihre Elemente als Argument an die Funktion (das erste Argument). Die Ergebnisliste wird zurückgegeben.
map(operator.sub, a, b)
Dieser Code hat weniger Syntax (was für mich ästhetischer ist) und ist anscheinend 40% schneller für Listen der Länge 5 (siehe Kommentar von Bobince). Beide Lösungen funktionieren dennoch.
Wenn Ihre Listen a und b sind, können Sie Folgendes tun:
map(int.__sub__, a, b)
Aber das solltest du wahrscheinlich nicht. Niemand wird wissen, was es bedeutet.
Ich muss auch NumPy empfehlen
Es ist nicht nur schneller für die Vektor-Mathematik, sondern bietet auch eine Vielzahl von Komfortfunktionen.
Wenn Sie für 1d-Vektoren noch etwas schnelleres wollen, versuchen Sie vop
Es ist ähnlich wie MatLab, aber kostenlos und so. Hier ist ein Beispiel für das, 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 Vector-Klasse.
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)
Wenn Sie planen, mehr als einfache Liners auszuführen, sollten Sie Ihre eigene Klasse implementieren und die entsprechenden Operatoren überschreiben, wenn sie auf Ihren Fall zutreffen.
Aus 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
import numpy as np
a = [2,2,2]
b = [1,1,1]
np.subtract(a,b)
Für denjenigen, der früher auf Pycharm programmiert hat, belebt es auch andere.
import operator
Arr1=[1,2,3,45]
Arr2=[3,4,56,78]
print(list(map(operator.sub,Arr1,Arr2)))
arr1=[1,2,3]
arr2=[2,1,3]
ls=[arr2-arr1 for arr1,arr2 in Zip(arr1,arr2)]
print(ls)
>>[1,-1,0]
Die Kombination von map
und lambda
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)
Die Zip
-Funktion ist eine weitere gute Wahl, wie @UncleZeiv zeigt