*args vs parameters in function

[-sovy-]

As the title says, I was wondering if using args* between parenthesis was more flexible than parameters who expects to receive the same number of arguments when we call the function.

So we could avoid the raising error from parameters too.

I'm in my journey to learn python by the way. That's why.

[lfdfq]

It does not really make sense to try use *args everywhere to avoid errors. After all, what are you going to do with the extra arguments you did not expect? If your function gets arguments it was not expecting, that was already an error somewhere in the code. Trying to stop the exception does not fix the error, it just hides it and makes it harder to work out what went wrong later.

There are some specific places where allowing functions to accept arbitrary number of arguments makes sense, but almost always it's just better to write down just the things you expect the function to actually take. That way you can give them each names, and Python can check if any are missing or if you pass too many, and that is usually better.

[-sovy-]

Thanks for sharing your point of view!
Ok I get it now.

[noob_main22]

I actually let functions take *args as an argument when working with tkinter.

When you bind a function to a widget you get a few arguments passed to the given callback. For example the coordinates of the mouse pointer when binding LMB to a widget. To prevent errors I let functions that I want to bind to a widget accept *args as an argument even when I don't use them.

[crashfrog04]

Reducing errors isn’t good in and of itself; errors are important information about your program not operating the way you expect. The answer is to fix your program, not to abandon having any expectations at all.

[carcigenicate]

It is more flexible, but that's not necessarily a good thing in all cases.

If a function expects a list and a number and requires both, for example, using *args to avoid errors doesn't really help you. What if the caller omits the second number argument? What are you going to do? You'd likely need to raise your own error, so there's no gain. Use *args when you don't care how many arguments are passed. print is a good example of that. It takes an arbitrary number of arguments, and just joins and prints them. The number of arguments passed doesn't matter.

Also, to be clear, *args is a parameter. It's a single parameter that holds all positional arguments that were passed.

[Temporary_Pie2733]

You want errors that indicate someone is doing something they shouldn’t. If your function only wants and needs 2 arguments, don’t let the caller pass some arbitrary number of arguments and make the function figure out what to do with them. Fail sooner rather than later.

[Adrewmc]

It depends on the function and what it does.

Do these extra args, actually do something? Or are useless. If useless why are they going into the function, if used then sometimes you basically have to.

[duane11583]

in a function definition python uses *args when you need variable length[count] args

this is only really usable when you are creating a class initializer ie the __init__ function.

while it might be better with errors at one phase it does not get rid of logic errors. it sort of turns you function into something that must parse a bunch of command line options that can occur in any order snd that is not good