You'll need to import sys for that to work.

#!/usr/bin/python

import sys
print  sys.argv[1:]

Example

:/tmp% cat foo.py
#!/usr/bin/python

import sys
print (sys.argv[1:]);

:/tmp% python foo.py 'hello world' arg3 arg4 arg5
['hello world', 'arg3', 'arg4', 'arg5']

Essentially, I'm trying to work out how to, from within a function, get a completely populated *args and **kwargs, including the function's named parameters.

How about saving the arguments via locals() at the beginning of the function?

def my_func(a, *args, **kwargs):
    saved_args = {**locals()}  # Updated to make a copy per loco.loop
    print("saved_args is", saved_args)
    local_var = 10
    print("saved_args is", saved_args)
    print("But locals() is now", locals())
    
my_func(20, 30, 40, 50, kwarg1='spam', kwarg2='eggs')

It gives this output:

saved_args is {'a': 20, 'args': (30, 40, 50), 'kwargs': {'kwarg1': u'spam', 'kwarg2': u'eggs'}}
saved_args is {'a': 20, 'args': (30, 40, 50), 'kwargs': {'kwarg1': u'spam', 'kwarg2': u'eggs'}}
But locals is now {'a': 20, 'saved_args': {...}, 'args': (30, 40, 50), 'local_var': 10, 'kwargs': {'kwarg1': u'spam', 'kwarg2': u'eggs'}}

Hat tip: https://stackoverflow.com/a/3137022/2829764

Python tutorial explains it:

import sys

print(sys.argv)

More specifically, if you run python example.py one two three:

>>> import sys
>>> print(sys.argv)
['example.py', 'one', 'two', 'three']

There is no way to do this generically, help(<function>) will at a minimum return you the function signature (including the argument names), Python is dynamically typed so you don't get any types and arguments by themselves don't tell you what the valid values are. This is where a good docstring comes in.

However, the csv module does have a specific function for listing the dialects:

>>> csv.list_dialects()
['excel', 'excel-tab', 'unix']
>>> help(csv.excel)
Help on class excel in module csv:

class excel(Dialect)
 |  Describe the usual properties of Excel-generated CSV files.
 ... 

Since you have a set number of arguments just create an iterable out of them, for example, wrap the argument names in a tuple literal:

for arg in (arg1, arg2, arg3, arg4):
    # do stuff

If you don't mind your function being capable of being called with more args just use *args syntax:

def function1(*args):
    for arg in args:
        arg = function2(arg)

which then exposes the arguments with which the function was invoked as a tuple which can be iterated over.

If you need to store the results for every invocation, it is better to change the for-loop in a list comprehension creating a list of the returned values. For example, given a function that takes a value and simply adds 2 to it:

def add2(arg):
    return arg + 2

def function1(arg1, arg2, arg3, arg4):
    a1, a2, a3, a4 = [add2(arg) for arg in (arg1, arg2, arg3, arg4)]
    print(a1, a2, a3, a4)

We create a list comprehension that takes every arg and supplies it to add2 and then stores it as an entry in a list, then we unpack to a1,..,aN. The values now contain the results of the function calls:

function1(1, 2, 3, 4)
3, 4, 5, 6

In the previous examples (arg1, arg2, arg3, arg4) can always be replaced with args if you use the *args syntax when defining the function, the results will be similar.

As an addendum, if you're more a fan of functional programming, you could always map the arguments to the function and save a few characters :-). I'll add a *args definition of function1 this time:

def function1(*args):
    a1, a2, a3, a4 = map(add2, args)
    print(a1, a2, a3, a4)

Same result.

import sys

print("\n".join(sys.argv))

sys.argv is a list that contains all the arguments passed to the script on the command line. sys.argv[0] is the script name.

Basically,

import sys

print(sys.argv[1:])