Make class castable to both tuple and dict

Question

I would like to define a class so that its instances can be casted to both tuple and dict. An example:

class Point3:
    ...

p = Point(12, 34, 56)

tuple(p)  # gives (12, 34, 56)
dict(p)   # gives { 'x': 12, 'y': 34, 'z': 56 }

I have found that if I define __iter__ as an iterator that yields single values then the instance can be casted to tuple and if it instead yields double values then it can be casted to dict:

class Point3:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    # This way makes instance castable to tuple
    def __iter__(self):
        yield self.x
        yield self.y
        yield self.z

    # This way makes instance castable to dict
    def __iter__(self):
        yield 'x', self.x
        yield 'y', self.y
        yield 'z', self.z

Is there any way to make instances castable to both tuple and dict in Python 2.7?

Answer 1

You could just subclass NamedTuple (Other types are available, ask your doctor.):

from typing import NamedTuple


class Point(NamedTuple):
    x: float
    y: float
    z: float

    def __add__(self, p):
        return Point(self.x+p.x, self.y+p.y, self.z+p.z)


p = Point(1, 2, 3)
q = Point(5, 5, 5)

print(p.x, p.y, p.z)
print(p+q)
print(tuple(p))

.

$ python pointless.py
1 2 3
Point(x=6, y=7, z=8)
(1, 2, 3)

If the tool you are using has any regard for idiomatic Python, the named tuple should be acceptable as is, anyway. I would try it!

If you were to use dictionaries, I would recommend using the explicit tuple(p.values()) (when subclassing) or maybe p.coordinates or p.xyz as property (when wrapping), rather than relying on some magic behing the scenes.

---

Legacy version, no warranty.

from collections import namedtuple


_Point = namedtuple('Point', 'x y z')


class Point(_Point):
    __slots__ = ()

    def __add__(self, p):
        return Point(self.x+p.x, self.y+p.y, self.z+p.z)

Answer 2

You can't do what you originally wanted to do (ie, have two different __iter__ methods) because it doesn't make any sense. But you can fake it using the mapping protocol (see below).

However before going into that, if you really want to cast to a dict, have a look at this answer for some better options.

---

My suggestion is to either:

1. Do what was suggested in the other answer and utilize namedtuple, which gives you the _asdict() method "for free".
2. Implement the class utilizing the mapping protocol (as explained in the previous link above). If you do that, you can circumvent the __iter__ method entirely when casting to dict.

You might do that like this; however this is a little bit odd:

class Point3:
    _fields = tuple("xyz")
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
    def __iter__(self):
        for f in self._fields:
            yield getattr(self, f)
    def keys(self):
        return self._fields
    def __getitem__(self, i):
        if i in self._fields:
            return getattr(self, i)
        raise KeyError("{!r} is not a valid field".format(i))

With the above, the dict is created using the keys() and __getitem__() rather than __iter__:

>>> dict(Point3(1, 2, 3))
{'x': 1, 'y': 2, 'z': 3}

Using the mapping protocol can also come in handy because you can "cast"- that is, unpack your object in the form of keyword arguments- to any other type that accepts the same field names as keyword arguments, e.g.:

point= XYZer(**point3_instance)

---

For other people (not the OP) who are able to benefit from the latest version of Python 3 (3.7): I highly recommend using the dataclasses module:

from dataclasses import dataclass, asdict, astuple

@dataclass
class Point:
    x: float
    y: float
    z: float

Use it like so:

>>> p = Point(1,2,3)
>>> asdict(p)
{'x': 1, 'y': 2, 'z': 3}
>>> astuple(p)
(1, 2, 3)