TheFlyingDutchman a écrit : > On Sep 12, 4:40 am, Bjoern Schliessmann <usenet- > [EMAIL PROTECTED]> wrote: >> Ivan Voras wrote: >>> What does "self" have to do with an object model? It's an >>> function/method argument that might as well be hidden in the >>> compiler without ever touching the role it has (if not, why?). I >>> agree that it's needless noise in a language. >> If this was needless, why do C++ and Java have the "this" pointer? >> > "this" in C++ and Java is not shown in the parameter list, which was > what he was > complaining about. He wants > > class MyClass: > def SomeFunction(someParameter): > self.someParameter = someParameter > > not > > class MyClass: > def SomeFunction(self, someParameter): > self.someParameter = someParameter > > > The confusing way about the current Python method when you first > encounter it is > why is "self" being passed in when you write the function
At this stage, it's not "passed in", it's declared in the arguments list. > but not > when you call it. It *is* passed when you call the function. > If the compiler is smart enough to know that The compiler has absolutely nothing to do with it. It's the object model that takes care of this. Quick explanation: - functions objects implement the descriptor protocol. - when a function which is an attribute of a class is looked up on an instance of that class, the __get__ method of the function object is called with the instance (and class) as arguments. - this method returns a closure wrapping the instance, the class and the function object itself - when this closure is called, it itself prepends the instance to the args it receives, calls the function with these args, and returns the result. This is why you need tho declare the instance as the first argument, but don't need to pass it explicitely *when calling the function as a method of an object*. Notice that you can still use the function directly, passing the instance by yourself. And that you can define a function outside a class and then attach it to a class. To make a long story short, Python's methods are just thin temporary wrappers around plain functions. > a = MyClass() > a.SomeFunction(12) > > SomeFunction() has a "self" implicitly added to the parameter list, it > seems that it should be smart enough to know that a function defined > in a class has a "self" implicitly added to the parameter list. The compiler has nothing to do with it, and where you define the function is totally orthogonal: def truc(obj): print obj class Toto(object): pass Toto.trac = truc t = Toto() t.trac() -- http://mail.python.org/mailman/listinfo/python-list
