Does Python have equivalent to MATLAB "varargin", "varargout" , "nargin", "nargout"?

[openopt]

Thank you in advance for your response.
Dmitrey

[Jorge Godoy]

op*****@ukr.net writes:

Thank you in advance for your response.

And those do ... ?

--
Jorge Godoy <jg****@gmail.c om>

[Andrew McLean]

Where you would use varargin and nargin in Matlab, you would use the
*args mechanism in Python.

Try calling

def t1(*args):
print args
print len(args)

with different argument lists

Where you would use varargout and nargout in Matlab you would use tuple
unpacking in Python.

Play with this

def t2(n):
return tuple(range(n))

a, b = t2(2)

x = t2(3)

[Dan Bishop]

On Feb 18, 12:58 pm, [e-mail] wrote:

Thank you in advance for your response.
Dmitrey

The Python equivalent to "varargin" is "*args".

def printf(format, *args):
sys.stdout.writ e(format % args)

There's no direct equivalent to "varargout" . In Python, functions
only have one return value. However, you can simulate the effect of
multiple return values by returning a tuple.

"nargin" has no direct equivalent either, but you can define a
function with optional arguments by giving them default values. For
example, the MATLAB function

function [x0, y0] = myplot(x, y, npts, angle, subdiv)
% MYPLOT Plot a function.
% MYPLOT(x, y, npts, angle, subdiv)
% The first two input arguments are
% required; the other three have default values.
...
if nargin < 5, subdiv = 20; end
if nargin < 4, angle = 10; end
if nargin < 3, npts = 25; end
...

would be written in Python as:

def myplot(x, y, npts=25, angle=10, subdiv=20):
...

[openopt]

Ok, thx
But can I somehow determing how many outputs does caller func require?
for example:
MATLAB:
function [objFunVal firstDerive secondDerive] = simpleObjFun(x)
objFunVal = x^3;
if nargout>1
firstDerive = 3*x^2;
end
if nargout>2
secondDerive = 6*x;
end

So if caller wants only
[objFunVal firstDerive] = simpleObjFun(15 )
than 2nd derivatives don't must to be calculated with wasting cputime.
Is something like that in Python?

[Peter Otten]

op*****@ukr.net wrote:

Ok, thx
But can I somehow determing how many outputs does caller func require?
for example:
MATLAB:
function [objFunVal firstDerive secondDerive] = simpleObjFun(x)
objFunVal = x^3;
if nargout>1
firstDerive = 3*x^2;
end
if nargout>2
secondDerive = 6*x;
end

So if caller wants only
[objFunVal firstDerive] = simpleObjFun(15 )
than 2nd derivatives don't must to be calculated with wasting cputime.
Is something like that in Python?

For a sequence whose items are to be calulated on demand you would typically
use a generator in Python. You still have to provide the number of items
somehow (see the head() helper function).

from itertools import islice

def derive(f, x0, eps=1e-5):
while 1:
yield f(x0)
def f(x, f=f):
return (f(x+eps) - f(x)) / eps

def head(items, n):
return tuple(islice(it ems, n))

if __name__ == "__main__":
def f(x): return x**6
print head(derive(f, 1), 4)

Peter

[Robert Kern]

op*****@ukr.net wrote:

Ok, thx
But can I somehow determing how many outputs does caller func require?
for example:
MATLAB:
function [objFunVal firstDerive secondDerive] = simpleObjFun(x)
objFunVal = x^3;
if nargout>1
firstDerive = 3*x^2;
end
if nargout>2
secondDerive = 6*x;
end

So if caller wants only
[objFunVal firstDerive] = simpleObjFun(15 )
than 2nd derivatives don't must to be calculated with wasting cputime.
Is something like that in Python?

Return an object with each of the results objFunVal, firstDerive, and
secondDerive as attributes (or a dictionary). Use keyword arguments to inform
the function of which ancillary computations it needs to perform.

If at all possible, don't change the number of return values. It's annoying to
deal with such an API.

--
Robert Kern

"I have come to believe that the whole world is an enigma, a harmless enigma
that is made terrible by our own mad attempt to interpret it as though it had
an underlying truth."
-- Umberto Eco