Should I use “self” to define variables / objects of class instanced which I will not need to reach from the outside?

Question

I am not a complete beginner but fairly new to Python. Whilst working on a project today I just had an idea and wondered regarding the usage of \"self

Answer 1

If you dont use self.some_temp_var, then you are defining a local variable which will be garbage collected after the constructor.

So yes you need self if you want to define an instance attribute that should persist with the instance. Whether you need it to be public or private is a matter of naming. Prefix it with an _ for protected or __ for private.

If some_temp_var is just a temp for the constructor and you never need it again then no, you dont need self. It is about persistence and member attributes. You do not need self for the pure fact of working with a variable within a single method.

Consider this... What if some_temp_var were some huge data structure that you build up to arrive at the real result value? You dont want to use self to store a temp variable because it wont free memory until you delete it or the instance. You want it to be cleaned up when it is no longer needed.

Answer 2

Looks like you don't need the variable at all then:

class C:
    def __init__(self, parent=None):
        super(C, self).__init__(parent)
        self.important_property = AnotherClass().bring_the_jewels()

In response to your comment:

do I need to put self. infront of it if it's gonna be created, referenced and used once during __init__.

No, you don't. Use a regular variable then, and the object will be garbage-collected after __init__ exits.

class C:
    def __init__(self, parent = None):
        super(C, self).__init__(parent)
        some_temp_var = AnotherClass()
        self.important_property = some_temp_var.bring_the_jewels()

Answer 3

Python does not really distinguish "public" from "private" variables. Anything you assign to a name in self using 'self.something = value' will be an instance variable for that instance.

Python does have two conventions that are relevant here:

1) Python fields or methods are prefixed with underscores('_') to tell users 'this is not a concern outside this class'. A single underscore is a conventional way of identifying more or less what a language like C# would call a 'protected' variable: it's internal to the implementation and should be left alone except by this class and derived classes. A double underscore is like a C# 'private' variable: it's internal and should be left alone even by derived classes, it can't be overridden

class Example(object):
    def __init__(self)
       self._protected= "protected"
       self.__private = "private"
       self.public = "public"

class Derived(Example):
    pass

d = Derived()
print d._protected
>> protected
print d.__private
>> AttributeError: 'Derived' object has no attribute '__private'

Strictly speaking the single underscore is just a typographical convention. The double underscore does actually mangle the name inside the class to prevent inheritance.

2) You example is potentially case for using the property decorator if AnotherClass is actually going to hang around, and if manipulating the AnotherClass instance affects the state of AnotherClass.

class C:
    def __init__(self, parent = None):
        super(C, self).__init__(parent)
        self._private = AnotherClass()

    @property
    def public(self):
       return self._private.some_method_on_AnotherClass()

    @public.setter
    def set_pub(self, val)
       self._private.set_value_on_AnotherClass(val)