オプション機能パラメータが設定されているか確認する方法

Pythonで、オプションのパラメーターの値がデフォルト値からのものかどうか、またはユーザーが関数呼び出しで明示的に設定したためかどうかを確認する簡単な方法はありますか？

多くの回答には完全な情報の一部が含まれているので、すべてを私のお気に入りのパターンと一緒にまとめたいと思います。

デフォルト値はmutableタイプです

デフォルト値が可変オブジェクトの場合、幸運です。関数が定義されたときにPythonのデフォルト引数が1回評価されるという事実を利用できます（これについては、前のセクションの回答の最後にあります）。

これはis、関数またはメソッドとして次の例のように、を使用してデフォルトの可変値を簡単に比較して、引数として渡されたか、デフォルトで残されたかを確認できることを意味します。

def f(value={}):
    if value is f.__defaults__[0]:
        print('default')
    else:
        print('passed in the call')

そして

class A:
    def f(self, value={}):
        if value is self.f.__defaults__[0]:
            print('default')
        else:
            print('passed in the call')

不変のデフォルト引数

さて、デフォルトが値であると予想されるimmutable場合（そして文字列でさえ不変であることを忘れないでください！）、トリックをそのまま利用することはできませんが、まだできることがあり、可変性を利用しているため、少しエレガントではありませんタイプ; 基本的に、関数のシグネチャに変更可能な「偽の」デフォルト値を設定し、関数の本体に目的の「実際の」デフォルト値を設定します。

def f(value={}):
    """
    my function
    :param value: value for my function; default is 1
    """
    if value is f.__defaults__[0]:
        print('default')
        value = 1
    else:
        print('passed in the call')
    # whatever I want to do with the value
    print(value)

実際のデフォルトがNoneである場合は特におかしいと感じますが、None不変なので...関数のデフォルトパラメータとして明示的に可変を使用し、コードで[なし]に切り替える必要があります。

Default不変のデフォルトにクラスを使用する

または、@ czの提案と同様に、Pythonドキュメントでは不十分な場合:-)、間にオブジェクトを追加して、APIをより明示的にすることができます（ドキュメントを読まなくても）。used_proxy_ Defaultクラスインスタンスは変更可能であり、使用する実際のデフォルト値が含まれます。

class Default:
    def __repr__(self):
        return "Default Value: {} ({})".format(self.value, type(self.value))

    def __init__(self, value):
        self.value = value

def f(default=Default(1)):
    if default is f.__defaults__[0]:
        print('default')
        print(default)
        default = default.value
    else:
        print('passed in the call')
    print("argument is: {}".format(default))

今：

>>> f()
default
Default Value: 1 (<class 'int'>)
argument is: 1

>>> f(2)
passed in the call
argument is: 2

上記は、に対してもうまく機能しDefault(None)ます。

その他のパタ​​ーン

明らかに、上記のパターンは、それらがprintどのように機能するかを示すためだけに存在するため、本来よりも醜く見えます。そうでなければ、私はそれらが簡潔で十分に再現可能であると思います。

あなたは追加するデコレータを書くことができ__call__、より合理化された方法で@dmgによって提案されたパターンが、これは関数定義そのものに奇妙なトリックを使用して、まだリージュ意志を-あなたはアウト分割する必要があるだろうvalueし、value_defaultあなたのコードの必要性は、それらを区別する場合には、そう私はあまり利点が見当たらず、例を書きません:-)

Pythonのデフォルト値としての可変型

＃1 pythonの落とし穴についてもう少し！、上記のあなた自身の喜びのために虐待されました。次の手順を実行すると、定義時の評価によって何が起こるかを確認できます。

def testme(default=[]):
    print(id(default))

何度でも実行できtestme()、常に同じデフォルトインスタンスへの参照が表示されます（したがって、基本的にデフォルトは不変です:-)）。

Pythonであることを覚えておいてくださいのみ3可変ビルトインタイプ：set、list、dict; 他のすべて-文字列さえ！-不変です。

あんまり。標準的な方法は、ユーザーが渡すことを期待されないデフォルト値を使用することです。object例：インスタンス：

DEFAULT = object()
def foo(param=DEFAULT):
    if param is DEFAULT:
        ...

通常None、ユーザーが渡したい値として意味がない場合は、デフォルト値として使用できます。

別の方法は、以下を使用することkwargsです。

def foo(**kwargs):
    if 'param' in kwargs:
        param = kwargs['param']
    else:
        ...

ただし、これは非常に冗長であり、ドキュメントにparamパラメータが自動的に含まれないため、関数の使用がより困難になります。

次の関数デコレータはexplicit_checker、明示的に指定されたすべてのパラメータのパラメータ名のセットを作成します。結果を追加のパラメーター（explicit_params）として関数に追加します。'a' in explicit_paramsパラメータaが明示的に指定されているかどうかを確認するだけです。

def explicit_checker(f):
    varnames = f.func_code.co_varnames
    def wrapper(*a, **kw):
        kw['explicit_params'] = set(list(varnames[:len(a)]) + kw.keys())
        return f(*a, **kw)
    return wrapper

@explicit_checker
def my_function(a, b=0, c=1, explicit_params=None):
    print a, b, c, explicit_params
    if 'b' in explicit_params:
        pass # Do whatever you want


my_function(1)
my_function(1, 0)
my_function(1, c=1)

私は時々（UUIDのような）普遍的にユニークな文字列を使用します。

import uuid
DEFAULT = uuid.uuid4()
def foo(arg=DEFAULT):
  if arg is DEFAULT:
    # it was not passed in
  else:
    # it was passed in

このように、ユーザーが試みてもデフォルトを推測することさえできなかったので、の値を見るとarg、それが渡されなかったと確信できます。

私は、このパターンを見てきました数回（例えばライブラリーunittest、py-flags、jinja）：

class Default:
    def __repr__( self ):
        return "DEFAULT"

DEFAULT = Default()

...または同等のワンライナー...：

DEFAULT = type( 'Default', (), { '__repr__': lambda x: 'DEFAULT' } )()

とは異なりDEFAULT = object()、これは型チェックを支援し、エラーが発生したときに情報を提供します。エラーメッセージでは、文字列表現（"DEFAULT"）またはクラス名（"Default"）のいずれかが使用されることがよくあります。

@Elliohの答えはPython2で機能します。Python3では、次のコードが機能するはずです。

import inspect
def explicit_checker(f):
    varnames = inspect.getfullargspec(f)[0]
    def wrapper(*a, **kw):
        kw['explicit_params'] = set(list(varnames[:len(a)]) + list(kw.keys()))
        return f(*a, **kw)
    return wrapper

@explicit_checker
def my_function(a, b=0, c=1, explicit_params=None):
    print a, b, c, explicit_params
    if 'b' in explicit_params:
        pass # Do whatever you want

このメソッドは、（** kwargsの代わりに）引数名とデフォルト値を読みやすく保つことができます。

あなたはからそれを確認することができますfoo.__defaults__し、foo.__kwdefaults__

以下の簡単な例を参照してください

def foo(a, b, c=123, d=456, *, e=789, f=100):
    print(foo.__defaults__)
    # (123, 456) 
    print(foo.__kwdefaults__)
    # {'e': 789, 'f': 100}
    print(a, b, c, d, e, f)

#and these variables are also accessible out of function body
print(foo.__defaults__)    
# (123, 456)  
print(foo.__kwdefaults__)  
# {'e': 789, 'f': 100}

foo.__kwdefaults__['e'] = 100500

foo(1, 2) 
#(123, 456)
#{'f': 100, 'e': 100500}
#1 2 123 456 100500 100

次に、演算子=を使用して、isそれらを比較できます

場合によっては、以下のコードで十分です

たとえば、デフォルト値の変更を回避する必要があります。次に、等しいかどうかを確認して、その場合はコピーします。

    def update_and_show(data=Example):
        if data is Example:
            data = copy.deepcopy(data)
        update_inplace(data) #some operation
        print(data)

また、関数が呼び出される実際の引数を返すためgetcallargs、fromを使用すると非常に便利inspectです。関数とargsおよびkwargsをそれに渡すと（inspect.getcallargs(func, /, *args, **kwds)）、デフォルト値やその他のものを考慮して、呼び出しに使用される実際のメソッドの引数が返されます。以下の例をご覧ください。

from inspect import getcallargs

# we have a function with such signature
def show_params(first, second, third=3):
    pass

# if you wanted to invoke it with such params (you could get them from a decorator as example)
args = [1, 2, 5]
kwargs = {}
print(getcallargs(show_params, *args, **kwargs))
#{'first': 1, 'second': 2, 'third': 5}

# here we didn't specify value for d
args = [1, 2, 3, 4]
kwargs = {}

# ----------------------------------------------------------
# but d has default value =7
def show_params1(first, *second, d = 7):
    pass


print(getcallargs(show_params1, *args, **kwargs))
# it will consider b to be equal to default value 7 as it is in real method invocation
# {'first': 1, 'second': (2, 3, 4), 'd': 7}

# ----------------------------------------------------------
args = [1]
kwargs = {"d": 4}

def show_params2(first, d=3):
    pass


print(getcallargs(show_params2, *args, **kwargs))
#{'first': 1, 'd': 4}

https://docs.python.org/3/library/inspect.html

ボラティリティのコメントに同意します。ただし、次の方法で確認できます。

def function(arg1,...,**optional):
    if 'optional_arg' in optional:
        # user has set 'optional_arg'
    else:
        # user has not set 'optional_arg'
        optional['optional_arg'] = optional_arg_default_value # set default

これはステファノの答えのバリエーションですが、もう少し読みやすくなっています。

not_specified = {}

def foo(x=not_specified):
    if x is not_specified:
            print("not specified")
    else:
            print("specified")

少し気まぐれなアプローチは次のようになります。

class CheckerFunction(object):
    def __init__(self, function, **defaults):
        self.function = function
        self.defaults = defaults

    def __call__(self, **kwargs):
        for key in self.defaults:
            if(key in kwargs):
                if(kwargs[key] == self.defaults[key]):
                    print 'passed default'
                else:
                    print 'passed different'
            else:
                print 'not passed'
                kwargs[key] = self.defaults[key]

        return self.function(**kwargs)

def f(a):
    print a

check_f = CheckerFunction(f, a='z')
check_f(a='z')
check_f(a='b')
check_f()

どの出力：

passed default
z
passed different
b
not passed
z

さて、私が言ったように、これはかなり気まぐれですが、それは仕事をします。ただし、これは非常に読みにくく、ecatmurの提案と同様に自動的に文書化されません。