Calling Function Without Parentheses!

[Kamilche]

What a debug nightmare! I just spent HOURS running my script through
the debugger, sprinkling in log statements, and the like, tracking down
my problem.

I called a function without the ending parentheses. I sure do WISH
Python would trap it when I try to do the following:
MyFunc

instead of:

MyFunc()

aaaaaaaaaaaah.

[Skip Montanaro]

Kamilche> I called a function without the ending parentheses. I sure do
Kamilche> WISH Python would trap it when I try to do the following:
Kamilche> MyFunc

Kamilche> instead of:

Kamilche> MyFunc()

Google for pychecker.

Skip

[Dan Bishop]

Kamilche wrote:

What a debug nightmare! I just spent HOURS running my script through
the debugger, sprinkling in log statements, and the like, tracking down my problem.

I called a function without the ending parentheses. I sure do WISH
Python would trap it when I try to do the following:
MyFunc

instead of:

MyFunc()

You're a former Pascal programmer, aren't you? ;-)

In Python, it's not an error, because you can do things like:

def simpson(f, a, b): .... "Simpson's Rule approximation of the integral of f on [a, b]."
.... return (b - a) * (f(a) + 4 * f((a + b) / 2.0) + f(b)) / 6.0
.... simpson(math.sin, 0.0, math.pi) # Note that math.sin is a function

2.0943951023931953

[John Machin]

Kamilche wrote:

What a debug nightmare! I just spent HOURS running my script through
the debugger, sprinkling in log statements, and the like, tracking down my problem.

I called a function without the ending parentheses. I sure do WISH
Python would trap it when I try to do the following:
MyFunc

instead of:

MyFunc()

aaaaaaaaaaaah.

Aaaaaaaaaaaah indeed. You must be using an extremely old version of
pychecker. The version I have in my Python22 directory gave the same
results as the current one; see below.

C:\junk>type noparens.py
[bangs inserted to defeat Google's lstrip()
!def bar():
! foo
!def foo():
! alist = []
! alist.sort

C:\junk>pychecker noparens.py

C:\junk>c:\python24\python.exe
c:\python22\Lib\site-packages\pychecker\checker.py noparens.py
Processing noparens...

Warnings...

noparens.py:2: Statement appears to have no effect
noparens.py:5: Statement appears to have no effect

[John Machin]

Dan Bishop wrote:

Kamilche wrote:

What a debug nightmare! I just spent HOURS running my script through

the debugger, sprinkling in log statements, and the like, tracking down

my problem.

I called a function without the ending parentheses. I sure do WISH
Python would trap it when I try to do the following:
MyFunc

instead of:

MyFunc()

You're a former Pascal programmer, aren't you? ;-)

In Python, it's not an error, because you can do things like:
def simpson(f, a, b): ... "Simpson's Rule approximation of the integral of f on [a, b]."
... return (b - a) * (f(a) + 4 * f((a + b) / 2.0) + f(b)) / 6.0
... simpson(math.sin, 0.0, math.pi) # Note that math.sin is a

function 2.0943951023931953

In Python, it's not an error, because functions are first class
citizens. The OP's problem is evaluating an expression and then doing
SFA with the result. Pychecker appears to be able to make the
distinction; see below:

C:\junk>type simpson.py
import math
def simpson(f, a, b):
return (b - a) * (f(a) + 4 * f((a + b) / 2.0) + f(b)) / 6.0
print simpson(math.sin, 0.0, math.pi)

C:\junk>python simpson.py
2.09439510239

C:\junk>pychecker simpson.py

C:\junk>c:\python24\python.exe
c:\python22\Lib\site-packages\pychecker\checker.py simpson.py
Processing simpson...
2.09439510239

Warnings...

None

[Kamilche]

Yep. Definitely time download PyChecker. Thanks for the tip!

[Terry Reedy]

"Kamilche" <kl*******@comcast.net> wrote in message
news:11**********************@f14g2000cwb.googlegr oups.com...

What a debug nightmare! I just spent HOURS running my script through
the debugger, sprinkling in log statements, and the like, tracking down
my problem.
Did you try PyChecker? (Don't know if
I called a function without the ending parentheses.
Which means you didn't call, and that was your problem ;-) In Python, the
(...) pair in the appropriate context (where an operator is expected) *is*
the infix/postfix call operator. It is equivalent to the call or gosub
prefix in some other languages. The call operator works with any callable,
not just function objects.
I sure do WISH Python would trap it when I try to do the following:
trap = raise an exception? nooooh.
MyFunc
instead of:
MyFunc()

In Python, non-keyword names resolve at runtime to the objects they are
then bound to. This simple, uniform rule is, to me, part of the beauty of
Python. There are lots of times that one wants to refer to a callable
without calling it. Indeed, because Python separates referring to an
object from calling the object, it can and does have a broader notion of
'callable' than other languages. This includes the option of making
instances of any user class callable (by including a __call__ method).

Terry J. Reedy

[Max M]

Kamilche wrote:

What a debug nightmare! I just spent HOURS running my script through
the debugger, sprinkling in log statements, and the like, tracking down
my problem.

I called a function without the ending parentheses. I sure do WISH
Python would trap it when I try to do the following:
MyFunc

Actually you want use a method as an ordinary variable without calling
it in many cases. It is often used in a dynamic language.

A simple example is:

result = []
a = result.append
if something:
a('some result')
elif something_else:
a('another result')
else:
a('default result')

--

hilsen/regards Max M, Denmark

http://www.mxm.dk/
IT's Mad Science

[Kamilche]

Yeah, but still. If they even had the most basic check, like 'an object
is being referred to on this line, but you're not doing anything with
it' would be handy in catching that. When you use an object like that,
usually you're doing something with it, like assigning it to a variable.

[Jeff Shannon]

Kamilche wrote:

Yeah, but still. If they even had the most basic check, like 'an object
is being referred to on this line, but you're not doing anything with
it' would be handy in catching that. When you use an object like that,
usually you're doing something with it, like assigning it to a variable.

In many cases, however, it's not possible to distinguish this.

def get_pi():
import math
return math.pi

print my_func(get_pi)

Now, am I trying to pass the function object get_pi into my_func(), or
do I want to call get_pi() and pass the return value?

There are also many times when it's sensible to do nothing with an
object reference -- i.e. ignoring the return value of a function which
you're calling for its side-effects.

It seems to me that it's reasonable for the Python interpreter to
*not* attempt to guess at whether a questionable usage is an error or
not. Better to have that done by a developer tool (pychecker) than
through runtime checks every time the program is used.

Jeff Shannon
Technician/Programmer
Credit International

[Kamilche]

Uh, you're right! I wouldn't want to bog Python down with even more
checking at run time. I guess I'm asking for syntax checks that are
typically done only with compiled languages.

It doesn't stop me from using Python, though! Since I don't have syntax
checking, I find I have to test supporting routines thoroughly, to make
sure it errs when it should err and runs when it should run. That's
something that's always good to do, but it's especially useful in
Python, which has no syntax checking before runtime.

[Nick Coghlan]

Kamilche wrote:

Uh, you're right! I wouldn't want to bog Python down with even more
checking at run time. I guess I'm asking for syntax checks that are
typically done only with compiled languages.

In that case, I can suggest having a look at Pychecker, which performs static
sanity checks on Python code.
http://pychecker.sourceforge.net/

Cheers,
Nick.

--
Nick Coghlan | nc******@email.com | Brisbane, Australia
---------------------------------------------------------------
http://boredomandlaziness.skystorm.net