Question

我需要检测函数是否为空定义。它可以像：

def foo():
    pass

或者喜欢：

def foo(i, *arg, **kwargs):
    pass

或者喜欢：

foo = lambda x: None

使用'inspect'模块检测它们的最优雅方法是什么？有没有比这更好的方法：

def isEmptyFunction(func):
    e = lambda: None
    return func.__code__.co_code == e.__code__.co_code

Answer 1

您提出的方法并不常用，因为具有文档字符串的空函数具有稍微不同的字节码。

没有docstring的空函数的func.__code__.co_code值为'd\x00\x00S'，而具有docstring的函数的值为'd\x01\x00S'。

就我的目的而言，它仅用于添加额外的案例来测试：

def isEmptyFunction(func):
    def empty_func():
        pass

    def empty_func_with_doc():
        """Empty function with docstring."""
        pass

    return func.__code__.co_code == empty_func.__code__.co_code or \
        func.__code__.co_code == empty_func_with_doc.__code__.co_code

Answer 2

你正在使用的方式。一个或许更“优雅”的解决方案是拥有一个函数列表，并在所有空（或所有非空）函数中将它添加到列表中，然后检查函数是否在列表中。

Answer 3

要回答最初的问题：我认为没有更好的方法，但是绝对有弹性。

在@kcon的this答案之上：

def isEmptyFunction(func): 
    def empty_func(): 
        pass

    def empty_func_with_doc(): 
        """Empty function with docstring.""" 
        pass 

    return func.__code__.co_code == empty_func.__code__.co_code or \
        func.__code__.co_code == empty_func_with_doc.__code__.co_code

由于以下原因而失败：

def not_empty_returning_string():
    return 'not empty'

isEmptyFunction(just_return_string) # True

以及lambda：

not_empty_lambda_returning_string = lambda x: 'not empty'

isEmptyFunction(not_empty_lambda_returning_string) # True

我构建了扩展版本，该扩展版本还检查了文档字符串以外的常量：

def is_empty_function(f):
    """Returns true if f is an empty function."""

    def empty_func():
        pass

    def empty_func_with_docstring():
        """Empty function with docstring."""
        pass

    empty_lambda = lambda: None

    empty_lambda_with_docstring = lambda: None
    empty_lambda_with_docstring.__doc__ = """Empty function with docstring."""

    def constants(f):
        """Return a tuple containing all the constants of a function without:
            * docstring
        """
        return tuple(
            x
            for x in f.__code__.co_consts
            if x != f.__doc__
        )

    return (
            f.__code__.co_code == empty_func.__code__.co_code and
            constants(f) == constants(empty_func)
        ) or (
            f.__code__.co_code == empty_func_with_docstring.__code__.co_code and
            constants(f) == constants(empty_func_with_docstring)
        ) or (
            f.__code__.co_code == empty_lambda.__code__.co_code and
            constants(f) == constants(empty_lambda)
        ) or (
            f.__code__.co_code == empty_lambda_with_docstring.__code__.co_code and
            constants(f) == constants(empty_lambda_with_docstring)
        )

测试：

#
# Empty functions (expect: is_empty_function(f) == True)
#

def empty():
    pass

def empty_with_docstring():
    """this is just an example docstring."""
    pass

empty_lambda = lambda: None

empty_lambda_with_docstring = lambda: None
empty_lambda_with_docstring.__doc__ = """this is just an example docstring."""

#
# Not empty functions (expect: is_empty_function(f) == False)
#

def not_empty():
    print('not empty');

def not_empty_with_docstring():
    """this is just an example docstring."""
    print('not empty');

not_empty_lambda = lambda: print('not empty')

not_empty_lambda_with_docstring = lambda: print('not empty')
not_empty_lambda_with_docstring.__doc__ = """this is just an example docstring."""

#
# Not empty functions returning a string (expect: is_empty_function(f) == False)
#

def not_empty_returning_string():
    return 'not empty'

def not_empty_returning_string_with_docstring():
    return 'not empty'

not_empty_lambda_returning_string = lambda: 'not empty'

not_empty_lambda_returning_string_with_docstring = lambda: 'not empty'
not_empty_lambda_returning_string_with_docstring.__doc__ = """this is just an example docstring."""


all([
  is_empty_function(empty) == True,
  is_empty_function(empty_with_docstring) == True,
  is_empty_function(empty_lambda) == True,
  is_empty_function(empty_lambda_with_docstring) == True,

  is_empty_function(not_empty) == False,
  is_empty_function(not_empty_with_docstring) == False,
  is_empty_function(not_empty_lambda) == False,
  is_empty_function(not_empty_lambda_with_docstring) == False,

  is_empty_function(not_empty_returning_string) == False,
  is_empty_function(not_empty_returning_string_with_docstring) == False,
  is_empty_function(not_empty_lambda_returning_string) == False,
  is_empty_function(not_empty_lambda_returning_string_with_docstring) == False,

]) # == True

Answer 4

你为什么这样做？它看起来像糟糕的设计。我敢打赌你不会做得更快。

python -m timeit -s'def a(): pass' -s'def b(): pass' 'if a.__code__.co_code == b.__code__.co_code: pass'
1000000 loops, best of 3: 0.293 usec per loop

python -m timeit -s 'def a(): pass' -s 'def b(): pass' 'a()'
10000000 loops, best of 3: 0.0941 usec per loop

看起来比较只比调用要慢得多，因为在后一个时间内循环次数要多10倍。 equals运算符实际上肯定会调用。代码 .co_code。 eq 。所以你只是让事情变得更慢。

在python中检测空函数定义

4 个答案: