Cách kiểm tra xem thông số chức năng tùy chọn đã được đặt chưa

Có cách nào dễ dàng trong Python để kiểm tra xem giá trị của một tham số tùy chọn đến từ giá trị mặc định của nó hay do người dùng đã đặt nó một cách rõ ràng khi gọi hàm?

Rất nhiều câu trả lời có rất ít thông tin đầy đủ, vì vậy tôi muốn tổng hợp tất cả lại với (các) mẫu yêu thích của mình.

giá trị mặc định là một mutableloại

Nếu giá trị mặc định là một đối tượng có thể thay đổi, bạn thật may mắn: bạn có thể khai thác thực tế là các đối số mặc định của Python được đánh giá một lần khi hàm được xác định (một số thông tin thêm về điều này ở cuối câu trả lời trong phần cuối cùng)

Điều này có nghĩa là bạn có thể dễ dàng so sánh một giá trị có thể thay đổi mặc định bằng cách sử dụng isđể xem liệu nó được chuyển dưới dạng đối số hay được để mặc định, như trong các ví dụ sau dưới dạng hàm hoặc phương thức:

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

và

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

Đối số mặc định bất biến

Bây giờ, sẽ kém thanh lịch hơn một chút nếu mặc định của bạn được mong đợi là một immutablegiá trị (và hãy nhớ rằng ngay cả các chuỗi cũng không thay đổi!) Bởi vì bạn không thể khai thác thủ thuật như nó vốn có, nhưng vẫn có điều bạn có thể làm, vẫn khai thác có thể thay đổi kiểu; về cơ bản, bạn đặt mặc định "giả" có thể thay đổi trong chữ ký hàm và giá trị mặc định "thực" mong muốn trong thân hàm.

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)

Cảm giác đặc biệt buồn cười nếu mặc định thực của bạn là None, nhưng Nonekhông thay đổi được, vì vậy ... bạn vẫn cần sử dụng rõ ràng một biến có thể thay đổi làm tham số mặc định của hàm và chuyển sang Không có trong mã.

Sử dụng một Defaultlớp cho các giá trị mặc định không thể thay đổi

hoặc, tương tự như đề xuất @cz, nếu tài liệu python không đủ :-), bạn có thể thêm một đối tượng vào giữa để làm cho API rõ ràng hơn (mà không cần đọc tài liệu); cá thể lớp used_proxy_ Default có thể thay đổi được và sẽ chứa giá trị mặc định thực mà bạn muốn sử dụng.

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))

hiện nay:

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

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

Các công trình trên cũng độc đáo cho Default(None).

Các mẫu khác

Rõ ràng là các mẫu ở trên trông xấu hơn chúng nên làm vì tất cả những mẫu printđó chỉ để hiển thị cách chúng hoạt động. Nếu không, tôi thấy chúng ngắn gọn và đủ lặp lại.

Bạn có thể viết trình trang trí để thêm __call__mẫu do @dmg đề xuất theo cách hợp lý hơn, nhưng điều này vẫn bắt buộc phải sử dụng các thủ thuật kỳ lạ trong chính định nghĩa hàm - bạn sẽ cần phải tách ra valuevà value_defaultnếu mã của bạn cần phân biệt chúng, vì vậy Tôi không thấy nhiều lợi thế và tôi sẽ không viết ví dụ :-)

Các loại có thể thay đổi làm giá trị mặc định trong Python

Thông tin thêm về # 1 python gotcha! , bị lạm dụng vì niềm vui của riêng bạn ở trên. Bạn có thể thấy những gì xảy ra do đánh giá ở định nghĩa bằng cách thực hiện:

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

Bạn có thể chạy testme()bao nhiêu lần tùy thích, bạn sẽ luôn thấy một tham chiếu đến cùng một trường hợp mặc định (vì vậy về cơ bản mặc định của bạn là không thay đổi :-)).

Hãy nhớ rằng trong Python chỉ có 3 có thể thay đổi được xây dựng trong các loại : set, list, dict; mọi thứ khác - ngay cả chuỗi! - là bất biến.

Không hẳn. Cách tiêu chuẩn là sử dụng một giá trị mặc định mà người dùng không mong đợi sẽ chuyển, ví dụ: một objectví dụ:

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

Thông thường, bạn có thể chỉ sử dụng Nonelàm giá trị mặc định, nếu nó không có ý nghĩa như một giá trị mà người dùng muốn chuyển.

Cách thay thế là sử dụng kwargs:

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

Tuy nhiên, điều này quá dài dòng và làm cho hàm của bạn khó sử dụng hơn vì tài liệu của nó sẽ không tự động bao gồm paramtham số.

Trình trang trí hàm sau đây explicit_checker, tạo một tập hợp các tên tham số của tất cả các tham số được cung cấp rõ ràng. Nó thêm kết quả như một tham số phụ ( explicit_params) vào hàm. Chỉ cần làm 'a' in explicit_paramsđể kiểm tra xem tham số acó được cung cấp rõ ràng hay không.

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)

Đôi khi tôi sử dụng một chuỗi duy nhất (như UUID).

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

Bằng cách này, không người dùng nào thậm chí có thể đoán được giá trị mặc định nếu họ đã thử, vì vậy tôi có thể rất tự tin rằng khi tôi thấy giá trị đó cho arg, nó đã không được chuyển vào.

Tôi đã nhìn thấy mô hình này một vài lần (ví dụ như thư viện unittest, py-flags, jinja):

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

DEFAULT = Default()

... hoặc một lớp lót tương đương ...:

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

Không giống như DEFAULT = object(), điều này hỗ trợ kiểm tra kiểu và cung cấp thông tin khi lỗi xảy ra - thường là biểu diễn chuỗi ( "DEFAULT") hoặc tên lớp ( "Default") được sử dụng trong thông báo lỗi.

Câu trả lời của @ Ellioh hoạt động trong python 2. Trong python 3, mã sau sẽ hoạt động:

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

Phương thức này có thể giữ các tên đối số và giá trị mặc định (thay vì ** kwargs) với khả năng đọc tốt hơn.

Bạn có thể kiểm tra nó từ foo.__defaults__vàfoo.__kwdefaults__

xem một ví dụ đơn giản dưới đây

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

sau đó bằng cách sử dụng toán tử =và isbạn có thể so sánh chúng

và đối với một số trường hợp, mã dưới đây là đủ

Ví dụ: bạn cần tránh thay đổi giá trị mặc định, sau đó bạn có thể kiểm tra tính bình đẳng và sau đó sao chép nếu có

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

Ngoài ra, nó khá thuận tiện để sử dụng getcallargstừ inspectvì nó trả về các đối số thực mà hàm sẽ được gọi. Bạn truyền một hàm và args và kwargs cho nó ( inspect.getcallargs(func, /, *args, **kwds)), nó sẽ trả về các đối số của phương thức thực được sử dụng để gọi, có tính đến các giá trị mặc định và những thứ khác. Hãy xem một ví dụ dưới đây.

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

Tôi đồng ý với nhận xét của Volatile. Nhưng bạn có thể kiểm tra theo cách sau:

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

Đây là một biến thể trong câu trả lời của stefano, nhưng tôi thấy dễ đọc hơn một chút:

not_specified = {}

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

Một cách tiếp cận hơi kỳ quặc sẽ là:

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()

Đầu ra nào:

passed default
z
passed different
b
not passed
z

Bây giờ, điều này, như tôi đã đề cập, khá kỳ lạ, nhưng nó thực hiện được công việc. Tuy nhiên, điều này khá khó đọc và tương tự như gợi ý của ecatmur sẽ không được tự động ghi lại.