Testing for presence of arguments

[Madhusudan Singh]

Hi

I know how to set optional arguments in the function definition. Is there an
intrinsic function that determines if a certain argument was actually
passed ? Like the fortran 95 present() logical intrinsic ?

My required functionality depends on whether a certain argument is specified
at all. (Setting default values is *not* good enough.).

Thanks.

[Peter Decker]

On 8/17/05, Madhusudan Singh <sp************ **@spam.invalid > wrote:

I know how to set optional arguments in the function definition. Is therean
intrinsic function that determines if a certain argument was actually
passed ? Like the fortran 95 present() logical intrinsic ?

My required functionality depends on whether a certain argument is specified
at all. (Setting default values is *not* good enough.).

Could you just write the function as:

myFunc(*args, **kwargs):

....and then figure out what was passed?

--

# p.d.

[Dan Sommers]

On Wed, 17 Aug 2005 11:13:03 -0400,
Madhusudan Singh <sp************ **@spam.invalid > wrote:

I know how to set optional arguments in the function definition. Is
there an intrinsic function that determines if a certain argument was
actually passed ? Like the fortran 95 present() logical intrinsic ?
def f(**kw):
if kw.has_key('req uired_argument' ):
print "require_argume nt was present"
else:
print "require_argume nt was not present"
My required functionality depends on whether a certain argument is
specified at all. (Setting default values is *not* good enough.).

You can very nearly achieve this with carefully planned default
arguments. Put this into a module:

class _SemiPrivateCla ss:
pass

def f(required_argu ment=_SemiPriva teClass):
if required_argume nt == _SemiPrivateCla ss:
print "required_argum ent was probably not present"
else:
print "required_argum ent was present"

It's not impossible fool f, but an external module has to try very hard
to do so.

(All code untested.)

Regards,
Dan

--
Dan Sommers
<http://www.tombstoneze ro.net/dan/>

[Benji York]

Madhusudan Singh wrote:

I know how to set optional arguments in the function definition. Is there an
intrinsic function that determines if a certain argument was actually
passed ? Like the fortran 95 present() logical intrinsic ?

People generally use a value that isn't a valid option, often None.

def my_func(a, b, c=None):
if c is None:
do something

If None is a valid value, make one that isn't:

unspecified = object()

def my_func(a, b, c=unspecified):
if c is unspecified:
do something
--
Benji York

[Diez B. Roggisch]

I don't have the details ready - but in the ASPN cookbook are recipes
to e.g. figure insied a function f out how many results the caller of f
expects - and act accordingly. This boils down to inspect the
call-stack. So it ceratinly is possible.

However, I'd say it is almost 100% a design flaw. Or can you give us a
compelling reason why you need this behaviour?

Diez

[Madhusudan Singh]

Diez B. Roggisch wrote:

I don't have the details ready - but in the ASPN cookbook are recipes
to e.g. figure insied a function f out how many results the caller of f
expects - and act accordingly. This boils down to inspect the
call-stack. So it ceratinly is possible.

However, I'd say it is almost 100% a design flaw. Or can you give us a
compelling reason why you need this behaviour?

Diez

I am writing some code for a measurement application (would have used
fortran 95 if a library had been available for linux-gpib, but python is a
lot friendlier than C without the irritating and utterly pointless braces)
where one of the input parameters for the GPIB command is optional, and
depending on whether it is specified at all, an entire sequence of commands
has to be sent to the GPIB bus plus some input parameters recalculated.
Further, the sequence of commands depends on the range of values of the
optional parameter. And some of these commands in turn have similar
optional arguments.

All in all, the above would have been a bunch of simple one-liners with a
simple if block if python had something like the fortran 95 present()
intrinsic, but I could not find it. Hence my query. Just because there is
no simple and direct way of doing something in a language does not mean
that the application that requires it has a design flaw.

Unrelated question, how does one call a fortran 95 subroutine from python ?
I need really high speed of execution for that call (needed for each
measurement point, and is used to calculate some parameters for the
excitation for the next measurement point) and a scripting language would
not cut it.

[Madhusudan Singh]

Benji York wrote:

Madhusudan Singh wrote:

I know how to set optional arguments in the function definition. Is there
an intrinsic function that determines if a certain argument was actually
passed ? Like the fortran 95 present() logical intrinsic ?

People generally use a value that isn't a valid option, often None.

def my_func(a, b, c=None):
if c is None:
do something

If None is a valid value, make one that isn't:

unspecified = object()

def my_func(a, b, c=unspecified):
if c is unspecified:
do something
--
Benji York

Now, that was a very good suggestion. Thanks.

[Madhusudan Singh]

Dan Sommers wrote:

On Wed, 17 Aug 2005 11:13:03 -0400,
Madhusudan Singh <sp************ **@spam.invalid > wrote:

I know how to set optional arguments in the function definition. Is
there an intrinsic function that determines if a certain argument was
actually passed ? Like the fortran 95 present() logical intrinsic ?

def f(**kw):
if kw.has_key('req uired_argument' ):
print "require_argume nt was present"
else:
print "require_argume nt was not present"

My required functionality depends on whether a certain argument is
specified at all. (Setting default values is *not* good enough.).

You can very nearly achieve this with carefully planned default
arguments. Put this into a module:

class _SemiPrivateCla ss:
pass

def f(required_argu ment=_SemiPriva teClass):
if required_argume nt == _SemiPrivateCla ss:
print "required_argum ent was probably not present"
else:
print "required_argum ent was present"

It's not impossible fool f, but an external module has to try very hard
to do so.

(All code untested.)

Regards,
Dan

Thanks for the suggestion, but seems needlessly complicated for something
very simple.

[Madhusudan Singh]

Peter Decker wrote:

On 8/17/05, Madhusudan Singh <sp************ **@spam.invalid > wrote:

I know how to set optional arguments in the function definition. Is there
an intrinsic function that determines if a certain argument was actually
passed ? Like the fortran 95 present() logical intrinsic ?

My required functionality depends on whether a certain argument is
specified at all. (Setting default values is *not* good enough.).

Could you just write the function as:

myFunc(*args, **kwargs):

...and then figure out what was passed?

Seems a lot simpler than the other module suggestion, but another person has
posted a suggestion that is a lot more quick and elegant. Thanks anyways. I
might find this useful in some as yet unknown context.

[Diez B. Roggisch]

> I am writing some code for a measurement application (would have used

fortran 95 if a library had been available for linux-gpib, but python is a
lot friendlier than C without the irritating and utterly pointless braces)
where one of the input parameters for the GPIB command is optional, and
depending on whether it is specified at all, an entire sequence of commands
has to be sent to the GPIB bus plus some input parameters recalculated.
Further, the sequence of commands depends on the range of values of the
optional parameter. And some of these commands in turn have similar
optional arguments.
I still don't see why default arguments like None won't do the trick.
If The argument _can_
be some value (let's say an int) or None, you still could go for a
default value like () or any other value
from a different domain.
All in all, the above would have been a bunch of simple one-liners with a
simple if block if python had something like the fortran 95 present()
intrinsic, but I could not find it. Hence my query. Just because there is
no simple and direct way of doing something in a language does not mean
that the application that requires it has a design flaw.
Certainly, but as certainly thinking in terms of one language while
using another is prone to
creating design flaws.

So far you still haven't convinced me that default arguments don't work
for you. To me it seems that
your idiom of present() is modeld by python's

if arg is None:
whatever

pretty mich. It might help if you show'd us what your code would like
_if_ python
had present() available. Then we can see what alternatives there are.
Unrelated question, how does one call a fortran 95 subroutine from python ?
I need really high speed of execution for that call (needed for each
measurement point, and is used to calculate some parameters for the
excitation for the next measurement point) and a scripting language would
not cut it.

Didn't ever try that, but either do it in C, or if fortran code can be
exposed as C lib, use that (ctypes is your friend). I'm not aware of a
fortran binding - but I never tried to find one. Basically Python can
interface with everything that can behave like C - which is the least
common denominator I think, so there should be some way.

Regards,

Diez