วิธีตรวจสอบว่ามีการตั้งค่าพารามิเตอร์ฟังก์ชันเสริมหรือไม่

มีวิธีง่ายๆใน Python ในการตรวจสอบว่าค่าของพารามิเตอร์ที่เป็นทางเลือกนั้นมาจากค่าเริ่มต้นหรือเนื่องจากผู้ใช้ตั้งค่าไว้อย่างชัดเจนในการเรียกใช้ฟังก์ชันหรือไม่

คำตอบจำนวนมากมีข้อมูลทั้งหมดเพียงเล็กน้อยดังนั้นฉันจึงต้องการนำมารวมกับรูปแบบที่ฉันชอบ

ค่าเริ่มต้นคือmutableประเภท

หากค่าเริ่มต้นเป็นวัตถุที่ไม่แน่นอนคุณจะโชคดี: คุณสามารถใช้ประโยชน์จากข้อเท็จจริงที่ว่าอาร์กิวเมนต์เริ่มต้นของ Python ได้รับการประเมินหนึ่งครั้งเมื่อกำหนดฟังก์ชัน (บางส่วนเพิ่มเติมเกี่ยวกับสิ่งนี้ในตอนท้ายของคำตอบในส่วนสุดท้าย)

ซึ่งหมายความว่าคุณสามารถเปรียบเทียบค่าเริ่มต้นที่เปลี่ยนแปลงได้อย่างง่ายดายโดยใช้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_ เริ่มต้นไม่แน่นอนและจะมีค่าเริ่มต้นจริงที่คุณต้องการใช้

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 gotcha! ทารุณกรรมเพื่อความสุขของคุณเองข้างต้น คุณสามารถดูว่าเกิดอะไรขึ้นเนื่องจากการประเมินตามคำจำกัดความโดยทำดังนี้

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

คุณสามารถเรียกใช้testme()กี่ครั้งก็ได้ตามที่คุณต้องการคุณจะเห็นการอ้างอิงถึงอินสแตนซ์เริ่มต้นเดียวกันเสมอ (ดังนั้นโดยพื้นฐานแล้วค่าเริ่มต้นของคุณจะไม่เปลี่ยนรูป :-))

โปรดจำไว้ว่าในหลามมีเพียง 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 ทำงานใน python 2 ใน python 3 รหัสต่อไปนี้ควรใช้งานได้:

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จากการ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

ฉันเห็นด้วยกับความคิดเห็นของ Volatility แต่คุณสามารถตรวจสอบในลักษณะต่อไปนี้:

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

นี่เป็นรูปแบบของคำตอบของ stefano แต่ฉันพบว่าอ่านได้มากกว่านี้เล็กน้อย:

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จะไม่ได้รับการจัดทำเป็นเอกสารโดยอัตโนมัติ