1

I have a class which contains data as attributes and which has a method to return a tuple containing these attributes:

class myclass(object):
    def __init__(self,a,b,c):
        self.a = a
        self.b = b
        self.c = c

    def tuple(self):
        return (self.a, self.b, self.c)

I use this class essentially as a tuple where the items (attributes) can be modified/read through their attribute name. Now I would like to create objects of this class, which would be constants and have pre-defined attribute values, which I could then assign to a variable/mutable object, thereby initializing this variable object's attributes to match the constant object, while at the same time retaining the ability to modify the attributes' values. For example I would like to do this:

constant_object = myclass(1,2,3)
variable_object = constant_object
variable_object.a = 999

Now of course this doesn't work in python, so I am wondering what is the best way to get this kind of functionality?

Improve this question
8
  • Why not just copy your constant_object into variable_object? Commented Jan 17, 2014 at 22:36
  • Obviously constant_object isn't actually constant, but… how could you expect Python to magically figure that out from the name of the variable? Commented Jan 17, 2014 at 22:36
  • @abarnert: really? My python3.3.3 changes both Commented Jan 17, 2014 at 22:37
  • 2
    The = assignment in Python doesn't "copy" anything, it just assigns the same value to another name. And it's not an operator that you can overload. There is no way that v and c could possibly refer to different objects after you write v = c, because v = c means that they refer to the same object. Commented Jan 17, 2014 at 22:39
  • Meanwhile, there's nothing "constant" about your constant_object. So when you put the same value into variable_object, it's still not constant. So, despite what the question says, variable_object.a = 999 actually works just fine. Commented Jan 17, 2014 at 22:41

3 Answers 3

Reset to default
1

Now I would like to create objects of this class, which would be constants and have pre-defined attribute values, which I could then assign to a variable/mutable object, thereby initializing this variable object's attributes to match the constant object,

Well, you can't have that. Assignment in Python doesn't initialize anything. It doesn't copy or create anything. All it does is give a new name to the existing value.

If you want to initialize an object, the way to do that in Python is to call the constructor.

So, with your existing code:

new_object = myclass(old_object.a, old_object.b, old_object.c)

If you look at most built-in and stdlib classes, it's a lot more convenient. For example:

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

How do they do that? Simple. Just define an __init__ method that can be called with an existing instance. (In the case of set, this comes for free, because a set can be initialized with any iterable, and sets are iterable.)

If you don't want to give up your existing design, you're going to need a pretty clumsy __init__, but it's at least doable. Maybe this:

_sentinel = object()
def __init__(myclass_or_a, b=_sentinel, c=_sentinel):
    if isinstance(a, myclass):
        self.a, self.b, self.c = myclass_or_a.a, myclass_or_a.b, myclass_or_a.c
    else:
        self.a, self.b, self.c = myclass_or_a, b, c

… plus some error handling to check that b is _sentinel in the first case and that it isn't in the other case.

So, however you do it:

constant_object = myclass(1,2,3)
variable_object = myclass(constant_object)
variable_object.a = 999
Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

In many cases, None fills the role of _sentinel just fine, which makes code prettier.
This is an interesting option, then my 3 line code example above would look like: constant_object = myclass(1,2,3); variable_object = myclass(constant_object)...I do wish there was a way to define a given object as constant/immutable though as then it would be more elegant with just variable_object = constant_object
@delnan: I used to always use None and add a footnote at the end explaining that you can use a custom sentinel if you need it, but every time I did that, someone commented that None can be a valid value for many cases. So now I use a custom sentinel, and someone comments that None is a perfectly good sentinel for many cases. :) But I think having one in the answer and the other in a comment works nicely.
@user3208430: Yes, exactly. I edited your example into the answer to make it more obvious (since code in comments is unreadable in SO).
@user3208430: For the other part of your question: there are (slightly hacky) ways to make different kinds of things immutable in Python, but that's usually a bad idea. The cost of copying 3 ints around is nothing, so just make a copy. If you want lots of enforced-immutable instances around, what you really want is probably two separate types—like frozenset and set, tuple and list, etc.
1 
import copy

class myclass(object):
    def __init__(self,a,b,c):
        self.a = a
        self.b = b
        self.c = c

    def tuple(self):
        return (self.a, self.b, self.c)

constant_object = myclass(1,2,3)
variable_object = copy.deepcopy(constant_object)
variable_object.a = 999
print constant_object.a
print variable_object.a

Output:

1
999
Improve this answer

Comments

1

Deepcopying is not entirely necessary in this case, because of the way you've setup your tuple method

class myclass(object):
    def __init__(self,a,b,c):
        self.a = a
        self.b = b
        self.c = c

    def tuple(self):
        return (self.a, self.b, self.c)

constant_object = myclass(1,2,3)
variable_object = myclass(*constant_object.tuple())
variable_object.a = 999

>>> constant_object.a
1
>>> variable_object.a
999

Usually (as others have suggested), you'd want to deepcopy. This creates a brand new object, with no ties to the object being copied. However, given that you are using only ints, deepcopy is overkill. You're better off doing a shallow copy. As a matter of fact, it might even be faster to call the class constructor on the parameters of the object you already have, seeing as these parameters are ints. This is why I suggested the above code.

Improve this answer

5 Comments

This will not for mutable objects like lists, dicts etc.
Note that this is essentially a class-specific way to make a shallow copy (also implemented as copy.copy()), which has different semantic from a deep copy (as implemented by copy.deepcopy()).
Yup. This works only because of the specific way in which this class is setup
I don't think the OP necessarily wants a deep copy. (In fact, I'm pretty sure that, even if he does, he doesn't know he wants one…) So the fact that this won't deep-copy mutable a, b, and c isn't really a problem, as long as it's noted.
@abarnert: good point. I've just added some text to that effect

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.