Sottraendo 2 liste in Python

Question

In questo momento ho Vector3 valori rappresentati come liste. c'è un modo per sottrarre 2 di questi valori come Vector3, come

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

Dovrei usare tuple?

Se nessuno di loro definisce questi operandi su questi tipi, posso definirlo, invece?

In caso contrario, dovrei creare una nuova classe vector3?

Answer 1

Se questo è qualcosa che si finisce per fare di frequente, e con diverse operazioni, probabilmente si dovrebbe creare una classe per gestire casi come questo, o meglio utilizzare alcuni biblioteca come Numpy .

In caso contrario, cercare list comprehension utilizzato con il zip funzione built-in:

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

Answer 2

Ecco un'alternativa per elencare comprensioni. Mappa scorre la lista (s) (questi ultimi argomenti), facendo in modo simulataneously e passa loro elementi come argomenti della funzione (il primo arg). Esso restituisce la lista risultante.

map(operator.sub, a, b)

Questo codice, perché ha meno sintassi (che è più estetica per me), ea quanto pare è più veloce del 40% per le liste di lunghezza 5 (vedi il commento di bobince). Eppure, entrambe le soluzioni funzionerà.

Answer 3

Se le liste sono A e B, si può fare:

map(int.__sub__, a, b)

Ma probabilmente non dovrebbe. Nessuno sa che cosa significa.

Answer 4

avrei dovuto raccomandare NumPy così

Non solo è più veloce per fare matematica vettoriale, ma ha anche un sacco di funzioni comfort.

Se volete qualcosa di ancora più veloce per i vettori 1d, prova a VOP

E 'simile a MatLab, ma libera e roba. Ecco un esempio di quello che faresti

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

Boom.

Answer 5

Se si dispone di due liste chiamate 'a' e 'b', si può fare: [m - n for m,n in zip(a,b)]

Answer 6

Una classe Vector leggermente diverso.

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)

Answer 7

Se si prevede di eseguire più di una semplice fodere, sarebbe meglio per implementare la propria classe e sovrascrivere gli operatori appropriati come si applicano al vostro caso.

Matematica 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

Answer 8

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

Answer 9

Per chi usata per codificare il PyCharm, fa rivivere anche altri pure.

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

Answer 10

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

Answer 11

La combinazione di funzioni map e lambda in Python è una buona soluzione per questo tipo di problema:

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

funzione zip è un'altra buona scelta, come dimostrato da @UncleZeiv

Answer 12

Prova questo:

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