Restando 2 listas en Python

Question

Ahora he vector3 valores representados como listas. hay una manera para restar 2 de éstos como valores vector3, como

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

¿Debo usar tuplas?

Si ninguna de ellas define estos operandos en estos tipos, puedo definirlo en su lugar?

Si no es así, debería crear una nueva clase vector3?

Answer 1

Si esto es algo que termina haciendo con frecuencia, y con diferentes operaciones, probablemente debería crear una clase para manejar casos como este, o mejor utilizar alguna biblioteca como Numpy .

De lo contrario, busque listas por comprensión se utiliza con el postal función incorporada:

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

Answer 2

Esto es una alternativa a las listas por comprensión. Mapa itera a través de la lista (s) (este último argumentos), el hacerlo condiciones simultáneamente, y pasa sus elementos como argumentos de la función (el primer argumento). Devuelve la lista resultante.

map(operator.sub, a, b)

Este código, porque tiene menos de sintaxis (que es más estético para mí), y al parecer es 40% más rápido para las listas de longitud 5 (véase el comentario de bobince). Sin embargo, cualquiera de las soluciones funcionará.

Answer 3

Si sus listas son a y b, que puede hacer:

map(int.__sub__, a, b)

Sin embargo, es probable que no debería. Nadie sabrá lo que significa.

Answer 4

tendría que recomendar NumPy así

No sólo es más rápido para hacer matemáticas vector, pero también tiene un montón de funciones de confort.

Si quieres algo aún más rápido para los vectores 1d, prueba a VOP

Es similar a Matlab, pero libre y esas cosas. He aquí un ejemplo de lo que haría

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

Si tiene dos listas de llamadas 'a' y 'b', que puede hacer: [m - n for m,n in zip(a,b)]

Answer 6

Una clase Vector ligeramente diferente.

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

Si planea realizar más simples trazadores de líneas uno, sería mejor para implementar su propia clase y anular los agentes correspondientes que se apliquen a su caso.

Matemáticas 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

Answer 8

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

Answer 9

Para el que utiliza para codificar el PyCharm, también revive los demás.

 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 combinación de funciones y map lambda en Python es una buena solución para este tipo de problema:

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

Función zip es otra buena opción, como se demuestra por @UncleZeiv

Answer 12

Prueba esto:

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