web-dev-qa-db-fra.com

Soustraction de 2 listes en Python

À l'heure actuelle, j'ai des valeurs vector3 représentées sous forme de listes. existe-t-il un moyen de soustraire 2 de ces valeurs telles que vector3, comme

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

Devrais-je utiliser des n-uplets?

Si aucun d’eux ne définit ces opérandes sur ces types, puis-je le définir à la place?

Si non, devrais-je créer une nouvelle classe vector3?

pythonlisttuplesvector
68
Joan Venge

Si c'est quelque chose que vous finissez souvent par faire et avec différentes opérations, vous devriez probablement créer une classe pour traiter de tels cas, ou mieux utiliser une bibliothèque comme Numpy .

Sinon, recherchez list comprehensions utilisé avec la fonction Zip builtin:

[a_i - b_i for a_i, b_i in Zip(a, b)]
112
UncleZeiv

Voici une alternative à la liste des compréhensions. Map parcourt la ou les listes (ces derniers arguments) simultanément et transmet leurs éléments en tant qu'arguments à la fonction (le premier argument). Il retourne la liste résultante.

map(operator.sub, a, b)

Ce code a moins de syntaxe (ce qui est plus esthétique pour moi) et apparemment, il est 40% plus rapide pour les listes de longueur 5 (voir le commentaire de bobince). Reste que l'une ou l'autre solution fonctionnera.

76
Nikhil Chelliah

Si vos listes sont a et b, vous pouvez faire:

map(int.__sub__, a, b)

Mais vous ne devriez probablement pas. Personne ne saura ce que cela signifie.

11
recursive

Je devrais recommander NumPy aussi

Non seulement il est plus rapide pour les mathématiques vectorielles, mais il a aussi une tonne de fonctions pratiques.

Si vous voulez quelque chose d'encore plus rapide pour les vecteurs 1d, essayez vop

C'est similaire à MatLab, mais gratuit et tout. Voici un exemple de ce que vous feriez

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

Boom.

10
mikelikespie

Si vous avez deux listes appelées 'a' et 'b', vous pouvez faire: [m - n for m,n in Zip(a,b)]

6
Andy Mikula

Une classe de vecteur légèrement différente.

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)
4
S.Lott

Si vous envisagez de réaliser plus que de simples ligneurs, il serait préférable d'implémenter votre propre classe et de remplacer les opérateurs appropriés en fonction de votre cas.

Tiré de Mathématiques en 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
3
codelogic
import numpy as np
a = [2,2,2]
b = [1,1,1]
np.subtract(a,b)
2
user3503711

Pour celui qui codait auparavant sur Pycharm, cela ravive également les autres.

 import operator
 Arr1=[1,2,3,45]
 Arr2=[3,4,56,78]
 print(list(map(operator.sub,Arr1,Arr2)))
1
Sahil Nagpal
arr1=[1,2,3]
arr2=[2,1,3]
ls=[arr2-arr1 for arr1,arr2 in Zip(arr1,arr2)]
print(ls)
>>[1,-1,0]
0
ravi tanwar

La combinaison des fonctions map et lambda en Python est une bonne solution à ce type de problème:

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

La fonction Zip est un autre bon choix, comme l'a démontré @UncleZeiv.

0
BioCoder