Forcing immutability on an object

Before I start, I'm already aware that object immutability in Python is often a bad idea, however, I believe that in my case it would be appropriate.

Let's say I'm working with a coordinate system in my code, such that each coordinate uses a struct of X, Y, Z. I've already overloaded subtraction, addition, etc. methods to do what I want. My current problem is the assignment operator, which I've read cannot be overloaded. Problem is when I have the following, I do not want A to point to the same point as B, I want the two to be independent, in case I need to overwrite a coordinate of one but not the other later:

B = Point(1,2,3)
A = B

I'm aware that I can use deepcopy, but that seems like a hack, especially since I could have a list of points that I might need to take a slice of (in which case it would again have a slice of point references, not points). I've also considered using tuples, but my points have member methods I need, and a very large portion of my code already uses the structs.

My idea was to modify Point to be immutable, since it's really only 3 floats of data, and from doing some research _new _() seems like the right function to overwrite for this. I'm not sure how to a开发者_如何学运维chieve this though, would it be something like this or am I way off?

def __new__(self):
    return Point(self.x, self.y, self.z)

EDIT: My bad, I realized after reading katrielalex's post that I can't modify a parameter of immutable object once it has been defined, in which case it's not a problem that both A and B point to the same data since a reassignment would require creation of a new point. I'd say that katrielalex's and vonPetrushev's posts achieve what I want, I think I'll go with vonPetrushev's solution since I don't need to rewrite all my current code to use tuples (the extra set of parentheses and not being able to reference coordinates as point.x)

In conjunction with katrielalex's suggestion, making the Point a named tuple would be good as well. Here I've just replaced the tuple parent with namedtuple('Point', 'x y z') - and that's enough for it to work.

>>> from collections import namedtuple
>>> class Point(namedtuple('Point', 'x y z')):
...     def __add__(self, other):
...             return Point((i + j for i, j in zip(self, other)))
...
...     def __mul__(self, other):
...             return sum(i * j for i, j in zip(self, other))
...
...     def __sub__(self, other):
...             return Point((i - j for i, j in zip(self, other)))
...
...     @property
...     def mod(self):
...             from math import sqrt
...             return sqrt(sum(i*i for i in self))
...

Then you can have:

>>> Point(1, 2, 3)
Point(x=1, y=2, z=3)
>>> Point(x=1, y=2, z=3).mod
3.7416573867739413
>>> Point(x=1, y=2, z=3) * Point(0, 0, 1)
3
>>> Point._make((1, 2, 3))
Point(x=1, y=2, z=3)

(Thanks to katrielalex for suggesting to extend the namedtuple rather than copying the code produced.)

You can make Point a subclass of tuple -- remember, the built-in types (at least in recent Pythons) are just more classes. This will give you the desired immutability.

However, I'm slightly confused about your suggested use case:

in case I need to overwrite a coordinate of one but not the other later:

That doesn't make sense if Points are immutable...

>>> class Point(tuple):
...     def __add__(self, other):
...             return Point((i + j for i, j in zip(self, other)))
...
...     def __mul__(self, other):
...             return sum(i * j for i, j in zip(self, other))
...
...     def __sub__(self, other):
...             return Point((i - j for i, j in zip(self, other)))
...
...     @property
...     def mod(self):
...             from math import sqrt
...             return sqrt(sum(i*i for i in self))
...
>>> a = Point((1,2,3))
>>> b = Point((4,5,6))
>>> a + b
(5, 7, 9)
>>> b - a
(3, 3, 3)
>>> a * b
32
>>> a.mod
3.7416573867739413
>>> a[0] = 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'Point' object does not support item assignment

try this:

class Point(object):
    def __init__(self, x, y, z):
        self._x=x
        self._y=y
        self._z=z

    def __getattr__(self, key):
        try:
            key={'x':'_x','y':'_y','z':'_z'}[key]
        except KeyError:
            raise AttributeError
        else:
            return self.__dict__[key]

    def __setattr__(self, key, value):
        if key in ['_x','_y','_z']:
            object.__setattr__(self, key, value)
        else:
            raise TypeError("'Point' object does not support item assignment")

So, you can construct a Point object, but not change its attributes.