Elegante Art, Tupelarithmetik durchzuführen

Was ist die elegante und präzise Art und Weise (ohne meine eigene Klasse mit operator overloading), um Tupel Arithmetik in Python 2.7?

Können sagen, ich habe zwei Tupel:

a = (10, 10)
b = (4, 4)

Meine angestrebte Ergebnis ist

c = a - b = (6, 6)

Derzeit benutze ich:

c = (a[0] - b[0], a[1] - b[1])

Ich auch versucht:

c = tuple([(i - j) for i in a for j in b])

aber das Ergebnis war (6, 6, 6, 6). Ich glaube, die oben genannten arbeiten, wie eine verschachtelte for-Schleifen, resultierend in 4 Iterationen und 4 Werte in das Ergebnis.

InformationsquelleAutor der Frage | 2013-07-02

43

Wenn Sie auf der Suche nach schnellen, die Sie verwenden können, numpy:
```
>>> import numpy
>>> numpy.subtract((10, 10), (4, 4))
array([6, 6])
```
und wenn Sie möchten, um es in ein Tupel:
```
>>> tuple(numpy.subtract((10, 10), (4, 4)))
(6, 6)
```
InformationsquelleAutor der Antwort vroomfondel
28

Eine option wäre,
```
>>> from operator import sub
>>> c = tuple(map(sub, a, b))
>>> c
(6, 6)
```
Und itertools.imap dienen können, als Ersatz für map.

Natürlich können Sie auch andere Funktionen aus operator zu addmuldiv usw.

Aber ich würde ernsthaft in Erwägung ziehen in eine andere Daten-Struktur, da ich nicht glaube, dass diese Art von problem ist fit für tuples

InformationsquelleAutor der Antwort Jared

Verwenden zip - und einen generator-Ausdruck:

c = tuple(x-y for x, y in zip(a, b))

Demo:

>>> a = (10, 10)
>>> b = (4, 4)
>>> c = tuple(x-y for x, y in zip(a, b))
>>> c
(6, 6)

Verwenden itertools.izip für eine Speicher-effiziente Lösung.

Hilfe auf zip:

>>> print zip.__doc__
zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]

Return a list of tuples, where each tuple contains the i-th element
from each of the argument sequences.  The returned list is truncated
in length to the length of the shortest argument sequence.

InformationsquelleAutor der Antwort Ashwini Chaudhary

2

Dies ist auch nur so schön, ohne einen import überhaupt, obwohl lambda ist oft unerwünscht:
```
tuple(map(lambda x, y: x - y, a, b))
```
Wenn Sie suchen, um die Distanz zwischen zwei Punkten sagen, ein 2d-Koordinatensystem Sie verwenden sollten, ist der absolute Wert der Subtraktion der Paare.
```
tuple(map(lambda x ,y: abs(x - y), a, b))
```
InformationsquelleAutor der Antwort miigotu

meinem element-wise Tupel arithmetische Helfer

unterstützte Operationen: +, -, /, *, d

operation = " d " berechnet die Entfernung zwischen zwei Punkten auf einem 2D-Koordinatensystem

def tuplengine(tuple1, tuple2, operation):
    """ 
    quick and dirty, element-wise, tuple arithmetic helper,
    created on Sun May 28 07:06:16 2017
    ...
    tuple1, tuple2: [named]tuples, both same length
    operation: '+', '-', '/', '*', 'd'
    operation 'd' returns distance between two points on a 2D coordinate plane (absolute value of the subtraction of pairs)
    """
    assert len(tuple1) == len(tuple2), "tuple sizes doesn't match, tuple1: {}, tuple2: {}".format(len(tuple1), len(tuple2))
    assert isinstance(tuple1, tuple) or tuple in type(tuple1).__bases__, "tuple1: not a [named]tuple"
    assert isinstance(tuple2, tuple) or tuple in type(tuple2).__bases__, "tuple2: not a [named]tuple"
    assert operation in list("+-/*d"), "operation has to be one of ['+','-','/','*','d']"
    return eval("tuple( a{}b for a, b in zip( tuple1, tuple2 ))".format(operation)) \
    if not operation == "d" \
      else eval("tuple( abs(a-b) for a, b in zip( tuple1, tuple2 ))")

InformationsquelleAutor der Antwort internety

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.