Question

目标：以调用者请求的单位（或任何微不足道的修改）中的函数返回值。

背景

我在Raspberry Pi 3上运行Python 2.7，并使用函数distance()来获取旋转编码器已转动的距离。我需要不同单位的距离，具体取决于调用函数的位置。那么，如果这是蟒蛇式写的（即简短，易于维护）。

首次尝试：

我的第一次尝试是在函数中使用米的单位，并使用一个很长的elif树来选择要返回的正确单位。

def distance(units='m'):
    my_distance = read_encoder()

    if units == 'm':
        return my_distance * 1.000
    elif units == 'km':
        return my_distance / 1000.
    elif units == 'cm':
        return my_distance * 10.00
    elif units == 'yd':
        return my_distance * 1.094
    else:
        return -1

这种方法的好处在于它有一种方法来识别一个不可用的单元。

第二次尝试：

我的第二次尝试是创建一个字典来包含各种multipliers。

def distance(units='m'):
    multiplier = {
        'm': 1.000,
        'km': 0.001,
        'cm': 10.00
        'yd': 1.094
    }

    try:
        return read_encoder() * mulitplier[units]
    except KeyError:
        return -1

此处，无法识别的单位会被KeyError抓住。

相关性：

我知道像Pint这样的现有库，但我正在寻找这个编程问题的解决方案。当你在Python中有一个函数时，你需要以可重用的方式对输出稍作修改。我有其他函数，例如speed()使用'm / s'作为基本单元，需要一个类似的units参数。根据我的经验，结构良好的程序在每个return语句之前不涉及elif个分支段落。在这种情况下，如果我想改变计算单位的方式，我必须仔细grep通过我的代码，并确保我改变每个实例的单位计算方式。一个适当的解决方案只需要改变计算一次。

这可能过于宽泛，但这是我一直遇到的模式。

Answer 1

如何使用装饰器：

def read_encoder():
    return 10

multiplier = {
    'm': 1.000,
    'km': 0.001,
    'cm': 10.00,
    'yd': 1.094,
}

def multiply(fn):
    def deco(units):
        return multiplier.get(units, -1) * fn(units)
    return deco

@multiply
def distance(units='m'):  
    my_distance = read_encoder()
    return my_distance

print distance("m")
print distance("yd")
print distance("feet")

输出：

10.0
10.94
-10

或者，作为一个更通用的包装器，可以解决任何无单位函数：

multiplier = {
    'm': 1.000,
    'km': 0.001,
    'cm': 10.00,
    'yd': 1.094,
}

def multiply(fn):
    def deco(units, *args, **kwds):
        return multiplier.get(units, -1) * fn(*args, **kwds)
    return deco


@multiply
def read_encoder(var):
    #I've added a variable to the function just to show that
    #it can be passed through from the decorator
    return 10 * var

print read_encoder("m", 1)
print read_encoder("yd", 2)
print read_encoder("feet", 3)

输出：

 10.0
 21.88
 -30

关于提高KeyError vs -1的一点是味道问题。就个人而言，如果没有找到，我会返回* 1（如果接收者不在乎）。或抛出一个KeyError。 -1并不是显而易见的。

上次迭代，使单位参数可选：

def multiply(fn):
    def deco(*args, **kwds):
        #pick up the unit, if given
        #but don't pass it on to read_encoder
        units = kwds.pop("units", "m")

        return multiplier.get(units, -1) * fn(*args, **kwds)
    return deco


@multiply
def read_encoder(var):
    return 10 * var

print read_encoder(1, units="yd")
print read_encoder(2)
print read_encoder(3, units="feet")


10.94
20.0  
-30

Answer 2

字典查找很好，但是不要返回sentinel值来表示错误;只是提出一个适当的例外。它可以像让查找中的KeyError传播一样简单（尽管不透明）。但是，更好的解决方案是提出自定义异常：

class UnknownUnitError(ValueError):
    pass

def distance(unit='m'):
    multiplier = {
        'm': 1.000,
        'km': 0.001,
        'cm': 10.00
    }

    try:
        unit = multiplier[unit]
    except KeyError:
        # Include the problematic unit in the exception
        raise UnknownUnitError(unit)

    return read_encoder() * unit

Answer 3

对于你的例子，它可能是：

class DistanceUnits():
    """
    Enum class for indicating measurement units and conversions between them.
    Holds all related logic.
    """
    M = 'm'
    KM = 'km'
    CM = 'cm'


def distance(units=DistanceUnits.M):
    multiplier = {
        DistanceUnits.M: 1.000,
        DistanceUnits.KM: 0.001,
        DistanceUnits.CM: 10.00
    }
    return read_encoder() * mulitplier[units] if units in multiplier else -1

但是，将multipliers移到distance函数之外并使其成为DistanceUnits的一部分是合理的。

UPD：“怎么样......”有很多不同的方式，所有这些方式都取决于你的需求，但有一个主要原则 DRY 。即使很多elif s也足够好（在每个函数调用中创建字典实例会消耗一些ram ..）如果你不忘记不重复自己。

Pythonic方法以适当的单位返回值

3 个答案: