Invisible function attributes

Discussion in 'Python' started by Olivier Lefevre, Sep 3, 2003.

  1. Python 2.3
    >>> def foo():

    .... foo.a = 1
    ....
    >>> vars(foo)

    {}
    >>> foo()
    >>> vars(foo)

    {'a': 1}
    >>>


    So it would appear that function attributes are not really
    there until the first call to the function. If that is the
    intended behaviour, it is really weird. I couldn't find any
    explicit discussion of this topic in the LRM.

    Thanks if anyone can shed some light on this,

    -- O.L.
     
    Olivier Lefevre, Sep 3, 2003
    #1
    1. Advertising

  2. Olivier Lefevre

    Tom Lee Guest

    Olivier Lefevre wrote:

    > Python 2.3
    >
    >>>>def foo():

    >
    > ... foo.a = 1
    > ...
    >
    >>>>vars(foo)

    >
    > {}
    >
    >>>>foo()
    >>>>vars(foo)

    >
    > {'a': 1}
    >
    >
    > So it would appear that function attributes are not really
    > there until the first call to the function. If that is the
    > intended behaviour, it is really weird. I couldn't find any
    > explicit discussion of this topic in the LRM.
    >
    > Thanks if anyone can shed some light on this,
    >
    > -- O.L.


    Makes sense to me.

    The foo.a = 1 line should never be executed until foo() is executed.
    Thus, foo.a is never set before the call to foo.

    - TL
     
    Tom Lee, Sep 3, 2003
    #2
    1. Advertising

  3. Olivier Lefevre

    Peter Otten Guest

    def foo():
    try:
    foo.a += 1 # executed every time you call the function
    except AttributeError:
    foo.a = 1 # set to one if it's not already there

    foo.b = 1 # executed once

    print vars(foo) # function body not yet called {'b': 1}

    for i in range(3):
    foo()
    print vars(foo)

    Loop output is

    {'a': 1, 'b': 1}
    {'a': 2, 'b': 1}
    {'a': 3, 'b': 1}

    That is all perfectly sane as code in the function body is never executed
    unless you call the function, whereas code on the module level is executed
    immediately as the module is imported. So put foo.attr = ... into the
    function body iff you want it to execute every time the function is
    invoked; otherwise put it into the module startup code, i. e. do not indent
    it.

    Peter
     
    Peter Otten, Sep 3, 2003
    #3
  4. Olivier Lefevre

    Terry Reedy Guest

    "Olivier Lefevre" <> wrote in message
    news:...
    > Python 2.3
    > >>> def foo():

    > ... foo.a = 1


    If you want foo to be attributed before it is called, move the setter
    outside the function.

    >>> def foo(): pass

    ....
    >>> foo.a = 1
    >>> vars(foo)

    {'a': 1}

    Terry J Reedy
     
    Terry Reedy, Sep 3, 2003
    #4
  5. Olivier Lefevre

    Bob Gailer Guest

    Of course the inevitable question is why do you want to do this? Consider
    creating a class instead (with a __call__ method if you want to call the
    instance as a function).

    class Foo:
    a = 1 # pre-initialized property
    def __call__(self):
    print self.a

    foo = Foo()
    foo()
    # prints 1

    Bob Gailer

    303 442 2625


    ---
    Outgoing mail is certified Virus Free.
    Checked by AVG anti-virus system (http://www.grisoft.com).
    Version: 6.0.506 / Virus Database: 303 - Release Date: 8/1/2003
     
    Bob Gailer, Sep 3, 2003
    #5
  6. Olivier Lefevre

    John J. Lee Guest

    (Olivier Lefevre) writes:
    [...]
    > So it would appear that function attributes are not really
    > there until the first call to the function. If that is the


    Not function attributes in general, just those that are first assigned
    to in the function body. No special rule here, though, because...


    > intended behaviour, it is really weird. I couldn't find any
    > explicit discussion of this topic in the LRM.
    >
    > Thanks if anyone can shed some light on this,


    ....what I'm guessing you haven't figured out yet is that everything
    works like this in Python. For example, what might be called a 'class
    declaration' in other languages isn't really a declaration in Python,
    it's code that gets executed at runtime. Same is true of functions:

    if WANT_SPAM:
    def sayhello(): print "spam"
    else:
    def sayhello(): print "eggs"

    sayhello()


    And your foo.a = 1 isn't a declaration (Python doesn't have them,
    really), it's just an attribute assignment.


    John
     
    John J. Lee, Sep 4, 2003
    #6
  7. Thanks to all those who replied.

    > ...what I'm guessing you haven't figured out yet is that everything
    > works like this in Python.


    Very possibly. I am coming to python from Java and I want to investigate
    the weird stuff precisely because either it's a one-off (in which case
    I'll make a note to myself to ignore it and not use it) or it holds the
    key to what is specific about the language. I seem to have hit pay dirt
    with this one ;-)

    Nudged by the dot syntax, I was thinking of this function attribute as
    if it were a sort of class member (i.e., pretending for a while this
    function is a class) and, since functions can't have instances, treating
    it as a sort of static member of the function, which should be available
    as soon as declared. Obviously I got it all wrong. Instead, they work
    like local variables except that they "persist" after the function has
    exited. That still feels weird to me. What are they used for? Give me
    a compelling reason to have such a beast in the language.

    OTOH, does this behaviour have anything to do with so-called "futures"?

    -- O.L.
     
    Olivier Lefevre, Sep 4, 2003
    #7
  8. Olivier Lefevre

    John Roth Guest

    "Olivier Lefevre" <> wrote in message
    news:...
    > Thanks to all those who replied.
    >
    > > ...what I'm guessing you haven't figured out yet is that everything
    > > works like this in Python.

    >
    > Very possibly. I am coming to python from Java and I want to investigate
    > the weird stuff precisely because either it's a one-off (in which case
    > I'll make a note to myself to ignore it and not use it) or it holds the
    > key to what is specific about the language. I seem to have hit pay dirt
    > with this one ;-)
    >
    > Nudged by the dot syntax, I was thinking of this function attribute as
    > if it were a sort of class member (i.e., pretending for a while this
    > function is a class) and, since functions can't have instances, treating
    > it as a sort of static member of the function, which should be available
    > as soon as declared. Obviously I got it all wrong. Instead, they work
    > like local variables except that they "persist" after the function has
    > exited. That still feels weird to me. What are they used for? Give me
    > a compelling reason to have such a beast in the language.


    I don't know of a really compelling reason, other than it simply
    works that way. Like everything else in the language, functions
    are objects, which means that they have a dictionary at their
    core. Therefore, functions can have attributes.

    The only use I can think of would be definitely advanced
    programming. Functions are first class objects, which means
    they can be rebound anywhere you want them. If you find
    a good reason to do that, then as an extension you might find
    a reason to add attributes to classify what you've got so you
    can manage the process.

    As I said, I'm reaching with this one...

    >
    > OTOH, does this behaviour have anything to do with so-called "futures"?


    No. Future is a feature so that experimental features can be added to the
    language in one release, and then made standard in a future release.

    John Roth
    >
    > -- O.L.
     
    John Roth, Sep 4, 2003
    #8
  9. (Olivier Lefevre) writes:

    > Nudged by the dot syntax, I was thinking of this function attribute as
    > if it were a sort of class member (i.e., pretending for a while this
    > function is a class) and, since functions can't have instances, treating
    > it as a sort of static member of the function, which should be available
    > as soon as declared.


    There is no declaration in Python; you just create attributes by
    binding objects to names.

    > Obviously I got it all wrong. Instead, they work like local
    > variables except that they "persist" after the function has exited.


    Hmmm. No. Functions are first class objects, and you can dynamically
    add attributes to them as you go along (as is the case for many, but
    not all, other types of objects).

    Do you realize that the foo identifier you used in your example is not
    inextricably linked to any function whose name is foo? The name of a
    function, and the variables to which it is bound are two different
    concepts.

    Consequently, the foo.a in the function body only _coincidentally_
    refers to an attribute of the function in which it appears.

    Consider:

    >>> def foo(arg): foo.a = arg

    ....
    >>> bar = foo # Now the function is known by two different names
    >>> bar(3)
    >>> foo.a

    3
    >>> foo = 1 # Now the function called "foo" can only be accessed via bar !
    >>> bar(4)

    Traceback (most recent call last):
    File "<stdin>", line 1, in ?
    File "<stdin>", line 1, in foo
    TypeError: 'int' object has only read-only attributes (assign to .a)
    >>> bar # I call it "bar", bit it thinks it's called "foo"

    <function foo at 0x815e71c>
    >>>


    The error at "bar(4)" in the above should hint at the fact that the
    "foo" in "foo.a" in the definition of the function foo, does not refer
    to the function itself but to whatever object which happens to be
    bound to the name "foo" at the time the function is being exectuted.

    > What are they used for? Give me a compelling reason to have such a
    > beast in the language.


    Now there's a good question :) I haven't found a use for these
    myself ... but then I haven't looked very hard for one.

    Given that function attributes were added to the language (in version
    2.1 or 2.2 ?), I guess someone felt a need for them, and Guido agreed.
     
    Jacek Generowicz, Sep 5, 2003
    #9
  10. > Python has no declarations, only executable statements.

    I think this was the key to my confusion in this case.

    > >>> bar(4)

    > Traceback (most recent call last):
    > TypeError: 'int' object has only read-only attributes (assign to .a)


    The way I read this, it says that a was bound to the name foo,
    not to the function foo stood for at the time of that function's
    definition; you are saying as much. Thus "foo.a" has to be looked
    up and resolved anew for each call. This must be costly. Why was
    it done this way?

    OTOH I read the func attr PEP and it says that they are
    implemented via a dict inside the function object. If so,
    shouldn't they be bound to the function object rather than
    to its name?? Or is func_dict itself an attribute?

    -- O.L.
     
    Olivier Lefevre, Sep 11, 2003
    #10
  11. Olivier Lefevre

    John J. Lee Guest

    Crumbs, is this thread still running?

    (Olivier Lefevre) writes:
    > > Python has no declarations, only executable statements.

    >
    > I think this was the key to my confusion in this case.


    Certainly part of it.


    > > >>> bar(4)

    > > Traceback (most recent call last):
    > > TypeError: 'int' object has only read-only attributes (assign to .a)

    >
    > The way I read this, it says that a was bound to the name foo,


    I'm not sure what's in your mind, and I'm only looking at this one
    message (the rest aren't in my newsreader) but that traceback says you
    tried to assign to an attribute on an integer, like so:

    3.a = "bananas"


    Doesn't make a lot of sense!

    (Of course, you probably were assigning to a named integer, not a
    literal

    foo = 3
    foo.a = "bananas"
    )

    [...]
    > OTOH I read the func attr PEP and it says that they are
    > implemented via a dict inside the function object. If so,
    > shouldn't they be bound to the function object rather than
    > to its name??


    They are.


    > Or is func_dict itself an attribute?


    It is.


    John
     
    John J. Lee, Sep 11, 2003
    #11
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Max
    Replies:
    1
    Views:
    519
    Joe Kesselman
    Sep 22, 2006
  2. P4trykx
    Replies:
    2
    Views:
    1,897
    bruce barker
    Jan 31, 2007
  3. james_027

    class attributes & data attributes

    james_027, Jun 20, 2007, in forum: Python
    Replies:
    2
    Views:
    417
    Bruno Desthuilliers
    Jun 20, 2007
  4. Andy B
    Replies:
    5
    Views:
    630
    Andy B
    May 29, 2008
  5. alice
    Replies:
    10
    Views:
    2,149
    Allodoxaphobia
    Jun 11, 2008
Loading...

Share This Page