Confessions of a Python fanboy

[Steven D'Aprano]

On Thu, 30 Jul 2009 18:06:31 -0500, Robert Kern wrote:

> On 2009-07-30 16:44, r wrote:
>> On Jul 30, 4:29 pm, Emmanuel Surleau<emmanuel.surl... at gmail.com> wrote:
>>>> 1.) No need to use "()" to call a function with no arguments. Python
>>>> -->  "obj.m2().m3()" --ugly
>>>>    Ruby -->  "obj.m1.m2.m3"  -- sweeet!
>>>> Man, i must admit i really like this, and your code will look so much
>>>> cleaner.
>>> It has benefits - code does look better. It has also significant cons
>>> - it is ambiguous.
>>> For instance:
>>>
>>> a = b
>>>
>>> Is b a variable or a method called without parameter?
>>
>> Hello Emanuel,
>> Again, who so ever names a method with such a non-descriptive name will
>> get whats coming to him. And if you did for some reason use such a
>> cryptic name as "b", do yourself (and everyone else) a favor and follow
>> it with "()" to denote the method call. Remember when something is
>> optional that means you have an option to use it OR not use it.
> 
> I believe his point is that it is ambiguous to the compiler, not humans
> reading the code. Python functions and methods are first class objects.
> They can be passed around. If they were auto-called, then you could not
> do this.

Oh my, "r" is still around is he??? And now he's singing the praises of 
Ruby, the language which he treated as the Devil's Spawn when he first 
arrived. That's hilarious.

But back on topic... "r" has missed the point. It's not that a=b is hard 
to understand because b is a poor name. The example could have been:

def factory_function():
    magic = time.time()  # or whatever
    def inner():
        return magic
    return inner

my_function = factory_function

It's still ambiguous. Does the programmer intend my_function to become 
factory_function itself, or the output of factory_function?

In Python, it's not ambiguous at all -- my_function is set to 
factory_function, and *not* the output of factory_function, because you 
haven't called the function.

Python's model is consistent and simple: given a function "func", you 
*always* refer to the function object itself as func and you *always* 
call it with func(). This applies no matter how many arguments the 
function takes, or what it returns, or where it is defined.

I think it's telling that "r" the fanboy has rejected Python's advantages 
(simplicity, consistency, unambiguity) in favour of lazily saving two 
keystrokes.



-- 
Steven