You'd use str.join() on the list without string formatting, then interpolate the result:

"Hello %s" % ', '.join(my_args)

Demo:

>>> my_args = ["foo", "bar", "baz"]
>>> "Hello %s" % ', '.join(my_args)
'Hello foo, bar, baz'

If some of your arguments are not yet strings, use a list comprehension:

>>> my_args = ["foo", "bar", 42]
>>> "Hello %s" % ', '.join([str(e) for e in my_args])
'Hello foo, bar, 42'

or use map(str, ...):

>>> "Hello %s" % ', '.join(map(str, my_args))
'Hello foo, bar, 42'

You'd do the same with your function:

function_in_library("Hello %s", ', '.join(my_args))

If you are limited by a (rather arbitrary) restriction that you cannot use a join in the interpolation argument list, use a join to create the formatting string instead:

function_in_library("Hello %s" % ', '.join(['%s'] * len(my_args)), my_args)

If you know that the parameters will always be given in the format --name value or -name value you can do it easily

class ArgHolder(object):
    pass

name = None
for x in sys.argv[1:]:
    if name:
        setattr(ArgHolder, curname, x)
        name = None

    elif x.startswith('-'):
        name = x.lstrip('-')

Now you will have collected all arguments in the class ArgHolder which is a namespace. You may also collect the values in an instance of ArgHolder

You can use the star or splat operator (it has a few names): for p in product(*lists) where lists is a tuple or list of things you want to pass.

def func(a,b):
    print (a,b)

args=(1,2)
func(*args)

You can do a similar thing when defining a function to allow it to accept a variable number of arguments:

def func2(*args): #unpacking
   print(args)  #args is a tuple

func2(1,2)  #prints (1, 2)

And of course, you can combine the splat operator with the variable number of arguments:

args = (1,2,3)
func2(*args) #prints (1, 2, 3)

fmt=raw_input("what is the form? >>>")
nargs=fmt.count('{') #Very simple counting to figure out how many parameters to ask about
args=[]
for i in xrange(nargs):
    args.append(raw_input("What is the value for parameter {0} >>>".format(i)))

fmt.format(*args)
          #^ unpacking operator (sometimes called star operator or splat operator)

This way lies the path of madness. Good programs are built on reliable input. Saving a couple keystrokes is rarely worth the headaches that can be created down the road.

That said, here you go:

def foo( *args ):
    for arg in args:
        arg = arg if type(arg) is list else [arg]
        for word in arg:
             print word

Pretty much what it's doing is saying "if arg is a list, don't change it. If arg is not a list, make it one. Then do what you would do if it were a list (because everything is)".

I prefer this to the if/else option where they are handled differently because this way you're only maintaining one copy of the guts of the function, instead of trying to replicate it on both sides of the if/else.

I recently answered a question on S.O regarding this exact situation. You can't do this with traditional functions in Python.

You can do this by taking advantage of callables though, overloading the __call__ dunder of an int subclass.

In short, return a new instance of your self with the updated value (+ here):

class addByCallable(int):
    def __call__(self, v):
        return type(self)(self + v)

Now, you call it and get this 'form' of currying:

addByCallable(1)(2)(3)  # 6

Which is as close as you can get to doing this in Python.

You can use "*args":

>>> custom_function = lambda *args: all(args)
>>> custom_function(1, 2, 3)
True
>>> custom_function(1, 2, 3, 0)
False

Which indeed is the same as just using "all":

>>> all(1, 2, 3)
True
>>> all(1, 2, 3, 0)
False

To be general, you can use "functools.reduce" to use any "2-parameters" function with any number of parameters (if their order doesn't matter):

import operator
import functools

c = lambda *args: functools.reduce(operator.and_, args)

(same results as before)