understaning "self"

[7stud]

On Feb 21, 11:49 am, 7stud <bbxx789_0... at yahoo.com> wrote:
> On Feb 21, 6:34 am, "Poppy" <znfmail-pythonl... at yahoo.com> wrote:
>
>
>
> > I've been searching online to try get a better understanding of what "self"
> > does when I define this parameter in my class functions. All I'm finding is
> > debates on whether  "self" has any value to the language but that doesn't
> > help me in my newbie question. So the code excerpt below is from "Beginning
> > Python" Norton, Samuel, Aitel, Foster-Johnson, Richardson, Diamon, Parker,
> > and Roberts.
>
> > What I think "self" is doing is limiting the function call to only function
> > in "this" class. So in the function below "has" calls self.has_various(), if
> > I had a function called "has_various" in my program or another included
> > class using "self" insures that the "has_various" below is the one used. Am
> > I correct in my understanding?
>
> > thanks,
>
> > Zach-
>
> >     def has(self, food_name, quantity=1):
> >         """
> > has(food_name, [quantity]) - checks if the string food_name is in the
> > fridge. quantity defaults to 1
> > returns True if there is enough, false otherwise.
> > """
>
> >         return self.has_various({food_name:quantity})
>
> >     def has_various(self, foods):
> >         """
> > has various(foods) determines if the dictionary food_name
> > has enough of every element to satisfy a request.
> > returns true if there's enough, Fasle if there's not or if an element does
> > not exist.
> > """
> >         try:
> >             for food in foods.keys():
> >                 if self.items[food] < foods[food]:
> >                     return False
> >             return True
> >         except KeyError:
> >             return False
>
> def bark():
>     print "Yip, yip."
>
> class Dog(object):
>     def __init__(the_obj_that_called_this_method):
>         the_obj_that_called_this_method.name = "Blackie"
>         print "Initializing a dog object."
>
>     def bark(the_obj_that_called_this_method):
>         print 'My name is', the_obj_that_called_this_method.name
>         print "Woof, woof."
>
> d = Dog()
> d.bark()
>
> Because the variable name: 'the_obj_that_called_this_method' is too
> hard to type, by convention people use the variable name: 'self'
> instead.
>
> > What I think "self" is doing is limiting the function
> > call to only function in "this" class.
>
> No.  Whenever you write obj.method_name, the '.' directs python to
> look inside obj's class definition for the specified method.  When you
> call a function like this:
>
> def show(x):
>     print x
>
> show('hello')
>
> python assigns the argument 'hello' to the parameter variable x.  When
> you write:
>
> d.bark()
>
> even though there are no arguments specified in that method call,
> python secretly passes one argument to the method: the object on the
> left side of the '.'.

self is just a parameter variable in a function definition, and just
like any other parameter variable in a function definition, self
stands ready to have any argument passed to the function assigned to
it.   It just so happens, that *you* aren't the one specifying the
*first* argument when you call a function in a class.  Functions in a
class are called 'methods', and all method calls of the form:

d.bark()

are transformed into this:

d.bark(d)

so bark() in d's class needs to be defined with one parameter
variable--even though the method call looks like bark() should be
defined with no parameter variables.  On the other hand, if bark()
were defined like this:


class Dog(object):
    def __init__(the_obj_that_called_this_method):
        the_obj_that_called_this_method.name = "Blackie"
        print "Initializing a dog object."

    def bark(the_obj_that_called_this_method, sound):
        print 'My name is', the_obj_that_called_this_method.name
        print sound


Then you would call bark() like this:

d = Dog()
d.bark('Woof!')

and the call:

d.bark('Woof!')

would be transformed into:

d.bark(d, 'Woof!')

As a result, bark() must be defined with two parameter variables: one
for d and one for the string.