How do I implement **kwargs to omit arguments in a function?

I'm looking for someone who can explain a solution as simply as possible

When making a function, I was wondering if it was possible to optionalize certain arguments in a function. Usually I would get an error saying missing 1 required positional argument: 'arg1'. using **kwargs may work, any way someone can explain this to me?

This is what I'm trying to accomplish.

def myFunc(arg1, arg2, arg3):
    print(arg1)
    print(arg2)
    print(arg3)

myFunc(arg3)

> How do I implement **kwargs to omit args in a function?

**kwargs collects keyword arguments that do not correspond arguments explicitly named in the function definition. This is a fair way to accept, and possibly ignore, extra keyword arguments, but it does not provide for the caller to omit arguments. Note also that the name kwargs is just a convention. It is the ** that is functionally important; the name can be anything.

The analogous syntax for positional arguments is *args, but again, this does not provide for callers to omit arguments; rather, it provides for callers to provide extra positional arguments.

In your particular example, it seems that arg1, arg2, and arg3 all have equivalent significance, so you could consider something like this:

def myFunc(*args):
    for arg in args:
        print(arg)

That will accept any number of positional arguments, including zero, and print each one given. You could even generalize that to

def myFunc(*args, **kwargs):
    for arg in args:
        print(arg)
    for arg in kwargs.values():
        print(arg)

, which prints both positional and keyword argument values.

But in your example, you suggest

myFunc(arg3)

, and if the significance to myFunc() of the third argument is different than the significance of the first then there's no way for that to work as you want. How can Python distinguish it from myFunc(arg1)? But you can support that by

1. Giving some or all arguments default values. None is often a good choice for this purpose. AND

2. Expecting the caller to exercise this case by use of a keyword argument.

Example:

def myFunc(arg1=None, arg2=None, arg3=None):
    if arg1 is not None:
        print(f'arg1 is {arg1}')
    if arg2 is not None:
        print(f'arg2 is {arg2}')
    if arg3 is not None:
        print(f'arg3 is {arg3}')

myFunc(arg3='foo')

you should use fo(*argv) if the elements are like a list and fo(**kwargs) if you want key-value pairs (dictionary).

An example

def fo(**kwargs):
    for key, value in kwargs.items():
        print(value)

fo(name="Alice", name2="Bob")

will print you

Alice
Bob

You can do the same thing with

def fo(*args):
    value in args:
        print(value)

fo("Alice", "Bob")

Make all of the args keyword args:

def myFunc(arg1=None, arg2=None, arg3=None):
    ...

Then call the function with as many or as few of the args as you like:

myFunc(arg1="hello", arg2="apple")
myFunc(arg2="goodbye")
myFunc(arg3="abc")

The canonical way to make arguments optional would be to define a default.
If you set the default to None, you could then proceed by checking if they are None and handle them accordingly.

def myFunc(arg1=None, arg2=None, arg3=None):
    print(arg1)
    print(arg2)
    print(arg3)

myFunc(arg3=arg3)

This doesn't work with positional arguments though, because myfunc(arg3) would assign the value of arg3 to arg1 in the context of your scope.
To make sure this doesn't happen, you could enforce keyword arguments by using the "*".

def myFunc(*, arg1=None, arg2=None, arg3=None):
    print(arg1)
    print(arg2)
    print(arg3)

this would raise an Exception when you are calling myFunc(arg3) without using the keyword.
Of course, **kwargs would work as well. You could then use kwargs.get("arg1", None) to get a default value of None (or something else).