可以在Python中使用模块常量作为默认函数参数吗？

Question

Basically something like this:

DEFAULT_TIMEOUT = 10
# or even: from my_settings import DEFAULT_TIMEOUT

def get_google(timeout=DEFAULT_TIMEOUT):
    return requests.get('google.com', timeout=timeout)

I would assume that as long as the constant really stays constant this should work just fine. Yet I sometimes see a pattern like this:

DEFAULT_TIMEOUT = 10

def get_google(timeout=None):
    if timeout is None:
        timeout = DEFAULT_TIMEOUT
    return requests.get('google.com', timeout=timeout)

Are these equivalent or should I prefer one over the other?

Answer 1

There's no problem with using the "constant" as a default value. As you say, as long as the "constant" is really constant, it won't matter. The only thing is that you do have to make sure the constant is defined before the function, but usually people put all their constants at the top of the file so that's not an issue.

The second pattern you describe is common when the desired default is a mutable value, such as a list. You often see things like this:

def foo(x=None):
    if x is None:
        x = []

instead of def foo(x=[]) . You can find many questions about this, but essentially it is because if you don't do it this way, the mutable default will persist across multiple calls to the function, which usually isn't desirable.

However, using this pattern for a mutable module-level constant wouldn't fix that problem. If you have:

SOME_CONSTANT = []

def foo(x=None):
    if x is None:
        x = SOME_CONSTANT

. . . then you're still reusing the same mutable value across multiple calls. (Of course, defining a mutable value as a "constant" is probably not a good idea anyway.) That's why I was asking in the comments if you've seen someone specifically doing this kind of thing with module constants.

This None-then-if pattern would also be used if the module-level default were actually not a constant, but a value intended to be changed by other code. If you do def foo(x=DEFAULT_TIMEOUT) , the default value of x is whatever DEFAULT_TIMEOUT was at the time you defined the function. But if you use the None-then-if pattern, the default will be whatever DEFAULT_TIMEOUT is at the time you call the function. Some libraries define module-level values that aren't meant to be constant, but are rather configuration values that may be changed in the course of execution. This allows users to do things like set DEFAULT_TIMEOUT = 20 to change the default timeout for all subsequent calls, rather than having to pass timeout=20 every time. In this case you would want the if check inside the function, to ensure that every call uses the "current" value of DEFAULT_TIMEOUT .

Answer 2

UPDATE: I highly recommend reading this post about instance and class attributes , it includes best practices of using both types of attributes, and when one is preferred over the other.

As you mentioned, second pattern can occur in modules, where keyword self is used, to define constant as instance attribute ( you can read more about attributes there and there ) for instance:

class Module:
    def __init__(self):
        self.DEFAULT_TIMEOUT = 10

    def get_google(timeout=self.DEFAULT_TIMEOUT):
        return requests.get('google.com', timeout=timeout)

would produce an error: NameError: name 'self' is not defined

class Module:
    def __init__(self):
        self.DEFAULT_TIMEOUT = 10

    def get_google(timeout=None):
        if timeout is None:
            timeout = self.DEFAULT_TIMEOUT
        return requests.get('google.com', timeout=timeout)

In another question problem is solved by mgilson in more clever way. It suggests creating sentinels :

The common idiom here is to set the default to some sentinel value (None is typical, although some have suggested Ellipsis for this purpose) which you can then check.

 class Example(object): #inherit from object. It's just a good idea. def __init__(self, data = None): self.data = self.default_data() if data is None else data def default_data(self): #probably need `self` here, unless this is a @staticmethod ... # .... return something 

You might also see an instance of object() used for the sentinel.

 SENTINEL = object() class Example(object): def __init__(self, data = SENTINEL): self.data = self.default_data() if data is SENTINEL else data 

This latter version has the benefit that you can pass None to your function but has a few downsides (see comments by @larsmans below). If you don't forsee the need to pass None as a meaningful argument to your methods, I would advocate using that.