python 函数圈复杂度

什么是函数圈复杂度？
如何计算圈复杂度？
如何控制圈复杂度？
如何使用工具来计算圈复杂度？
理想的圈复杂度范围

什么是函数圈复杂度？

函数圈复杂度是由 Thomas McCabe 在 1976 年提出的一种用于衡量代码复杂度的指标。它通过计算程序中独立的执行路径数量，来衡量代码的复杂性。换句话说，它表示一个函数可以执行的所有不同路径的数量。圈复杂度越高，函数中的逻辑越复杂，维护和测试的难度也就越大。

如何计算圈复杂度？

可以通过以下简单的规则来计算圈复杂度：

每个 if、elif、else 语句增加 1。
每个 for、while 循环增加 1。
每个 and、or 逻辑运算符增加 1。
每个 except 块增加 1。

通过一个简单的例子来计算 Python 函数的圈复杂度：

def process_data(data):
    if data is None:
        return "No data provided"
    elif data == []:
        return "Empty data"
    
    for item in data:
        if isinstance(item, int):
            if item > 10:
                print(f"Large number: {
      
      item}")
            else:
                print(f"Small number: {
      
      item}")
        elif isinstance(item, str):
            print(f"String value: {
      
      item}")
        else:
            print(f"Unknown type: {
      
      type(item)}")

在这个例子中，圈复杂度的计算如下：

一个 if data is None 语句 +1。
一个 elif data == [] 语句 +1。
一个 for 循环 +1。
一个 if isinstance(item, int) 语句 +1。
一个 if item > 10 语句 +1。
一个 elif isinstance(item, str) 语句 +1。
一个 else 块（尽管没有额外条件，但也是一个分支） +1。

总计：1（起始路径） + 1（if） + 1（elif） + 1（for） + 1（if） + 1（if） + 1（elif） + 1（else） = 8

如何控制圈复杂度？

1. 拆分函数

当一个函数的逻辑过于复杂时，可以通过将它拆分为多个较小的函数来降低每个函数的复杂度。这不仅有助于降低圈复杂度，也使得每个函数的职责更加明确。

def process_number(item):
    if item > 10:
        print(f"Large number: {
      
      item}")
    else:
        print(f"Small number: {
      
      item}")

def process_data(data):
    if data is None:
        return "No data provided"
    elif data == []:
        return "Empty data"
    
    for item in data:
        if isinstance(item, int):
            process_number(item)
        elif isinstance(item, str):
            print(f"String value: {
      
      item}")
        else:
            print(f"Unknown type: {
      
      type(item)}")

减少嵌套

深层次的嵌套结构会大大增加代码的复杂度。通过合理使用早期返回或继续来减少嵌套的层次，可以有效降低圈复杂度。

def process_data(data):
    if data is None:
        return "No data provided"
    if data == []:
        return "Empty data"
    
    for item in data:
        if isinstance(item, int):
            if item > 10:
                print(f"Large number: {
      
      item}")
            else:
                print(f"Small number: {
      
      item}")
            continue
        if isinstance(item, str):
            print(f"String value: {
      
      item}")
            continue
        print(f"Unknown type: {
      
      type(item)}")

使用多态代替条件判断

在面向对象编程中，使用多态可以替代过多的条件判断逻辑。通过将不同的行为封装到不同的类中，可以减少复杂的 if-else 逻辑，从而降低圈复杂度。

class ItemProcessor:
    def process(self, item):
        raise NotImplementedError()

class NumberProcessor(ItemProcessor):
    def process(self, item):
        if item > 10:
            print(f"Large number: {
      
      item}")
        else:
            print(f"Small number: {
      
      item}")

class StringProcessor(ItemProcessor):
    def process(self, item):
        print(f"String value: {
      
      item}")

def process_data(data, processors):
    for item in data:
        processor = processors.get(type(item), ItemProcessor())
        processor.process(item)

processors = {
    
    
    int: NumberProcessor(),
    str: StringProcessor()
}

如何使用工具来计算圈复杂度？

Python 有一些工具可以帮助我们自动计算代码的圈复杂度，其中最常用的是 Radon：

pip install radon

radon cc your_code.py -a

理想的圈复杂度范围

虽然圈复杂度并没有硬性规定的标准，但一般的经验法则是：

1-5：代码的复杂度较低，易于维护。
6-10：代码复杂度中等，需要留意是否有优化空间。
11-20：代码复杂度较高，推荐拆分或重构。
20以上：代码非常复杂，强烈建议重构，否则难以维护和测试。