Call function without optional arguments if they are None

There's a function which takes optional arguments.

def alpha(p1="foo", p2="bar"):
     print('{0},{1}'.format(p1, p2))

Let me iterate over what happens when we use that function in different ways:

>>> alpha()
foo,bar
>>> alpha("FOO")
FOO,bar
>>> alpha(p2="BAR")
foo,BAR
>>> alpha(p1="FOO", p2=None)
FOO,None

Now consider the case where I want to call it like alpha("FOO", myp2) and myp2 will either contain a value to be passed, or be None. But even though the function handles p2=None, I want it to use its default value "bar" instead.
Maybe that's worded confusingly, so let me reword that:

If myp2 is None, call alpha("FOO"). Else, call alpha("FOO", myp2).

The distinction is relevant because alpha("FOO", None) has a different result than alpha("FOO").

How can I concisely (but readably) make this distinction?

One possibility would usually be to check for None within alpha, which would be encouraged because that would make the code safer. But assume that alpha is used in other places where it is actually supposed to handle None as it does.

I'd like to handle that on the caller-side.

One possibility is to do a case distinction:

if myp2 is None:
    alpha("FOO")
else:
    alpha("FOO", myp2)

But that can quickly become much code when there are multiple such arguments. (exponentially, 2^n)

Another possibility is to simply do alpha("FOO", myp2 or "bar"), but that requires us to know the default value. Usually, I'd probably go with this approach, but I might later change the default values for alpha and this call would then need to be updated manually in order to still call it with the (new) default value.

I am using python 3.4 but it would be best if your answers can provide a good way that works in any python version.

The question is technically finished here, but I reword some requirement again, since the first answer did gloss over that:
I want the behaviour of alpha with its default values "foo", "bar" preserved in general, so it is (probably) not an option to change alpha itself.
In yet again other words, assume that alpha is being used somewhere else as alpha("FOO", None) where the output FOO,None is expected behaviour.

Pass the arguments as kwargs from a dictionary, from which you filter out the None values:

kwargs = dict(p1='FOO', p2=None)

alpha(**{k: v for k, v in kwargs.items() if v is not None})

But assume that alpha is used in other places where it is actually supposed to handle None as it does.

To respond to this concern, I have been known to have a None-like value which isn't actually None for this exact purpose.

_novalue = object()

def alpha(p1=_novalue, p2=_novalue):
    if p1 is _novalue:
        p1 = "foo"
    if p2 is _novalue:
        p2 = "bar"
    print('{0},{1}'.format(p1, p2))

Now the arguments are still optional, so you can neglect to pass either of them. And the function handles None correctly. If you ever want to explicitly not pass an argument, you can pass _novalue.

>>> alpha(p1="FOO", p2=None)
FOO,None
>>> alpha(p1="FOO")
FOO,bar
>>> alpha(p1="FOO", p2=_novalue)
FOO,bar

and since _novalue is a special made-up value created for this express purpose, anyone who passes _novalue is certainly intending the "default argument" behavior, as opposed to someone who passes None who might intend that the value be interpreted as literal None.