Python requires specifying self. The result is there’s never any confusion over what’s a member and what’s not, even without the full class definition visible. This leads to useful properties, such as: you can’t add members which accidentally shadow non-members and thereby break code. One extreme example: you can write a class without any knowledge … Read more
When you write a class block, you create class attributes (or class variables). All the names you assign in the class block, including methods you define with def become class attributes. After a class instance is created, anything with a reference to the instance can create instance attributes on it. Inside methods, the “current” instance … Read more
Would something like this do what you need? class Test(object): def _decorator(foo): def magic( self ) : print “start magic” foo( self ) print “end magic” return magic @_decorator def bar( self ) : print “normal call” test = Test() test.bar() This avoids the call to self to access the decorator and leaves it hidden … Read more
One way to keep track of instances is with a class variable: class A(object): instances = [] def __init__(self, foo): self.foo = foo A.instances.append(self) At the end of the program, you can create your dict like this: foo_vars = {id(instance): instance.foo for instance in A.instances} There is only one list: >>> a = A(1) >>> … Read more
I like to quote Peters’ Zen of Python. “Explicit is better than implicit.” In Java and C++, ‘this.‘ can be deduced, except when you have variable names that make it impossible to deduce. So you sometimes need it and sometimes don’t. Python elects to make things like this explicit rather than based on a rule. … Read more
In Python, this: my_object.method(“foo”) …is syntactic sugar, which the interpreter translates behind the scenes into: MyClass.method(my_object, “foo”) …which, as you can see, does indeed have two arguments – it’s just that the first one is implicit, from the point of view of the caller. This is because most methods do some work with the object … Read more
In this code: class A(object): def __init__(self): self.x = ‘Hello’ def method_a(self, foo): print self.x + ‘ ‘ + foo … the self variable represents the instance of the object itself. Most object-oriented languages pass this as a hidden parameter to the methods defined on an object; Python does not. You have to declare it … Read more
The reason you need to use self. is because Python does not use the @ syntax to refer to instance attributes. Python decided to do methods in a way that makes the instance to which the method belongs be passed automatically, but not received automatically: the first parameter of methods is the instance the method … Read more