합계와 같은 Python 요소별 튜플 작업

합계와 같은 Python 요소별 튜플 작업

Python에서 튜플 작업을 다음과 같이 수행할 수 있는 방법이 있습니까?

>>> a = (1,2,3)
>>> b = (3,2,1)
>>> a + b
(4,4,4)

다음 대신:

>>> a = (1,2,3)
>>> b = (3,2,1)
>>> a + b
(1,2,3,3,2,1)

나는 그것이 그렇게 작동한다는 것을 안다 왜냐하면.__add__그리고.__mul__방법은 그렇게 작동하도록 정의됩니다.그래서 유일한 방법은 그것들을 재정의하는 것일까요?

모든 기본 제공 기능 사용...

tuple(map(sum, zip(a, b)))

import operator
tuple(map(operator.add, a, b))

이 솔루션은 가져오기가 필요하지 않습니다.

tuple(map(lambda x, y: x + y, tuple1, tuple2))

from numpy import array

a = array( [1,2,3] )
b = array( [3,2,1] )

print a + b

기브즈array([4,4,4]).

http://www.scipy.org/Tentative_NumPy_Tutorial 을 참조하십시오.

처음 두 개의 답을 결합한 것과 같이, 철개구리의 코드를 수정하여 튜플을 반환합니다.

import operator

class stuple(tuple):
    def __add__(self, other):
        return self.__class__(map(operator.add, self, other))
        # obviously leaving out checking lengths

>>> a = stuple([1,2,3])
>>> b = stuple([3,2,1])
>>> a + b
(4, 4, 4)

참고: 사용self.__class__대신에stuple하위 분류를 쉽게 하기 위해.

지도 대신 제너레이터 이해를 사용할 수 있습니다.내장된 지도 기능은 오래된 것은 아니지만, 대부분의 사람들이 목록/생성기/독어보다 읽기 쉬우므로 지도 기능은 일반적으로 사용하지 않는 것이 좋습니다.

tuple(p+q for p, q in zip(a, b))

튜플을 반환하는 클래스 정의가 없는 단순 솔루션

import operator
tuple(map(operator.add,a,b))

모든 제너레이터 솔루션.성능에 대한 확신이 없음(iter tools가 빠르긴 하지만)

import itertools
tuple(x+y for x, y in itertools.izip(a,b))

훨씬 간단하고 지도를 사용하지 않고도 그렇게 할 수 있습니다.

>>> tuple(sum(i) for i in zip((1, 2, 3), (3, 2, 1)))
(4, 4, 4)

네. 하지만 기본 제공 유형을 재정의할 수는 없습니다.하위 클래스로 분류해야 합니다.

클래스 MyTuple(튜플):def __add__(본인, 기타):if len(자체)!= len(기타):raise ValueError("두 개 길이가 일치하지 않음")내 튜플 반환(x + y(x, y)(zip(self, other))

저는 현재 "tuple" 클래스를 오버로드하기 위해 +, -, *. 하위 클래스로 분류하고 있습니다. 코드를 아름답게 만들고 코드를 더 쉽게 작성할 수 있습니다.

class tupleN(tuple):
    def __add__(self, other):
        if len(self) != len(other):
             return NotImplemented
        else:
             return tupleN(x+y for x,y in zip(self,other))
    def __sub__(self, other):
        if len(self) != len(other):
             return NotImplemented
        else:
             return tupleN(x-y for x,y in zip(self,other))
    def __mul__(self, other):
        if len(self) != len(other):
             return NotImplemented
        else:
             return tupleN(x*y for x,y in zip(self,other))


t1 = tupleN((1,3,3))
t2 = tupleN((1,3,4))
print(t1 + t2, t1 - t2, t1 * t2, t1 + t1 - t1 - t1)
(2, 6, 7) (0, 0, -1) (1, 9, 12) (0, 0, 0)

이미 사용 중인 경우 다음과 같은 유용한 솔루션이 있습니다.numpy이것은 컴팩트하며 추가 연산은 임의의 numpy 식으로 대체할 수 있습니다.

import numpy as np
tuple(np.array(a) + b)

저는 계속해서 이 질문에 답을 찾았는데, 그 대답들이 모두 일반적인 경우에 대한 질문에 답을 하고 있기 때문에 특별히 마음에 드는 것은 없습니다. 그리고 저는 보통 특별한 경우에 대한 답을 찾고 있습니다.저는 보통 n차원과 같은 고정 튜플 카운트를 사용합니다.

   # eg adding a dx/dy to an xy point.
   # if I have a point xy and another point dxdy
   x, y = xy
   dx, dy = dxdy
   return x+dx, y+dy

저는 보통 불필요한 변수에 몸서리를 치지만, 튜플을 푸는 이유는 보통 제가 개별적으로 요소 작업을 하고 있기 때문이며, 위의 요청대로 튜플 추가 작업이 진행되고 있습니다.

모든 공통 숫자 이진 및 단항 연산자에 대한 최소 클래스
은 무엇입니까?

from math import ceil,floor,trunc
from operator import (add,and_,eq,floordiv,ge,gt,invert,le,lshift,lt,mod,mul,ne,
  neg,or_,pos,rshift,sub,truediv,xor,)
from itertools import repeat
from typing import Iterable
class ntuple(tuple):
  def __lt__(a,b): return ntuple(map(lt,a,a._b(b)))
  def __le__(a,b): return ntuple(map(le,a,a._b(b)))
  def __eq__(a,b): return ntuple(map(eq,a,a._b(b)))
  def __ne__(a,b): return ntuple(map(ne,a,a._b(b)))
  def __gt__(a,b): return ntuple(map(gt,a,a._b(b)))
  def __ge__(a,b): return ntuple(map(ge,a,a._b(b)))
  def __add__(a,b): return ntuple(map(add,a,a._b(b)))
  def __sub__(a,b): return ntuple(map(sub,a,a._b(b)))
  def __mul__(a,b): return ntuple(map(mul,a,a._b(b)))
  def __matmul__(a,b): return sum(map(mul,a,a._b(b)))
  def __truediv__(a,b): return ntuple(map(truediv,a,a._b(b)))
  def __floordiv__(a,b): return ntuple(map(floordiv,a,a._b(b)))
  def __mod__(a,b): return ntuple(map(mod,a,a._b(b)))
  def __divmod__(a,b): return ntuple(map(divmod,a,a._b(b)))
  def __pow__(a,b,m=None): return ntuple(pow(a,b,m) for a,b in zip(a,a._b(b)))
  def __lshift__(a,b): return ntuple(map(lshift,a,a._b(b)))
  def __rshift__(a,b): return ntuple(map(rshift,a,a._b(b)))
  def __and__(a,b): return ntuple(map(and_,a,a._b(b)))
  def __xor__(a,b): return ntuple(map(xor,a,a._b(b)))
  def __or__(a,b): return ntuple(map(or_,a,a._b(b)))
  def __neg__(a): return ntuple(map(neg,a))
  def __pos__(a): return ntuple(map(pos,a))
  def __abs__(a): return ntuple(map(abs,a))
  def __invert__(a): return ntuple(map(invert,a))
  def __round__(a,n=None): return ntuple(round(e,n) for e in a)
  def __trunc__(a): return ntuple(map(trunc,a))
  def __floor__(a): return ntuple(map(floor,a))
  def __ceil__(a): return ntuple(map(ceil,a))
  def _b(a,b): return b if isinstance(b,Iterable) else repeat(b,len(a))

ntuple((-1, 0, 2)) + (6, 4, 2) = (5, 4, 4)

ntuple((-1, 0, 2)) +  2 = (1, 2, 4)
ntuple((-1, 0, 2)) ** 2 = (1, 0, 4)
ntuple(( 1, 2, 3)) << 2 = (4, 8, 12)

-ntuple((-1, 0, 2)) = (1, 0, -2)

round(ntuple((-1.5, 0.6, 2.4))) = (-2, 1, 2)

sum(ntuple(a...)*(b...)) == ntuple(a...)@(b...)

튜플 목록의 평균을 구해야 하는 경우:

import operator 
from functools import reduce
tuple(reduce(lambda x, y: tuple(map(operator.add, x, y)),list_of_tuples))

언급URL : https://stackoverflow.com/questions/497885/python-element-wise-tuple-operations-like-sum