重构：将类还是函数拆分到新文件？

Question

在用Python重构代码时，有哪些最佳实践或者更符合Python风格的方法呢？

1. 是像在Java中那样，把一个类拆分出来，还是
2. 直接把函数拆分出来（在Java中是做不到的）？

举个例子：

假设我有下面这个文件：

**large_file.py**

def large_function(x):
    # ...lots of code...
    return foo(y)

def foo(y):
    # ...lots of code...
    return function_only_called_by_foo(z)        

def function_only_called_by_foo(z):
    # ...lots of code...
    return output 

一个自然的重构方式是把 foo() 和 function_only_called_by_foo() 拆分到各自的文件里。但在Java中，我的选择不多，而在Python中，我可以考虑两种方法来实现这个目标。

方案一：

**large_file.py**

from fooer import Fooer
def large_function(x):
    # ...lots of code...
    fooer = Fooer()
    return fooer.foo(y)


**fooer.py**

class Fooer:

    def foo(y):
        # ...lots of code...
        return _function_only_called_by_foo(z)        

    def _function_only_called_by_foo(z):
        # ...lots of code...
        return output 

方案二：

**large_file.py**

from foo_file import foo
def large_function(x):
    # ...lots of code...
    return foo(y)


**foo_file.py**

def foo(y):
    # ...lots of code...
    return _function_only_called_by_foo(z)        

def _function_only_called_by_foo(z):
    # ...lots of code...
    return output 

哪种方案更好，为什么呢？（或者有没有更好的选择？）

这几种方法都没有共享任何实例变量。

Answer 1

选择方案二显然更好——如果你得不到任何好处，为什么还要增加类的开销呢？

不过，如果你真的想这么做，可以考虑把Fooer的函数设置为@staticmethod：

class Fooer(object):

    @staticmethod
    def foo(x):
        ...
        return _foo_helper(x)

    @staticmethod
    def _foo_helper(x):
        ...
        return y

这样你就不需要创建一个实例，也不需要那些你根本不使用的self或cls参数了：

from fooer import Fooer

y = Fooer.foo(x)