有没有类似python的方法来处理这种范围映射

能不能把这个做得更像蟒蛇

if joyx > 50:
   joyx = 100
elif joyx < -50:
   joyx = -100
else:
   joyx = 0

如果joyx>50：
乔伊斯=100
elif joyx<-50：
joyx=-100
其他：
joyx=0

您可以使用和函数编写它：

In [30]: from math import copysign

In [31]: joyx = copysign(100, joyx) if abs(joyx) > 50 else 0

例如：

In [32]: joyx = lambda x: copysign(100, x) if abs(x) > 50 else 0

In [33]: joyx(51), joyx(-51), joyx(50), joyx(-50), joyx(0)
Out[33]: (100.0, -100.0, 0, 0, 0)

---

在我看来，你所拥有的是完美的蟒蛇

因为您使用的是小于和大于比较，所以我们无法通过使用字典或我能想到的任何其他技巧来真正改善这一点

我想你可以把它分解成一个函数，然后调用这个函数：

def clean_up_joystick(x, y, xbound, ybound, on_value):
    if x > xbound:
        x = on_value
    elif x < -xbound:
        x = -on_value
    else:
        x = 0
    if y > ybound:
        y = on_value
    elif y < -ybound:
        y = -on_value
    else:
        y = 0
    return (x, y)

def清理操作手柄（x、y、x、y、y、on值）：
如果x>xbound：
x=开_值
elif x<-xBond：
x=-在_值上
其他：
x=0
如果y>ybound：
y=on_值
elif y<-ybound:
y=-在_值上
其他：
y=0
返回（x，y）

对于一个实际的程序，我建议您应该创建一个管理操纵杆的类，并使用希望用于任何特定操纵杆的边界值初始化该类

也许是这样的：

class Joystick(object):
    def __init__(self,
            x_low=-50, x_high=50,
            y_low=-50, y_high=50,
            on_value=100):
        self.x_low = x_low
        self.x_high = x_high
        self.y_low = y_low
        self.y_high = y_high
        self.on_value = on_value

    def read(self):
        # do something here that reads the joystick value
        # joystick value saved in x, y variables
        x, y = 0,0  # dummy init for example

        if x > self.x_high:
            x = self.on_value
        elif x < -self.x_low:
            x = -self.on_value
        else:
            x = 0
        if y > self.x_high:
            y = self.on_value
        elif y < self.x_low:
            y = -self.on_value
        else:
            y = 0
        return (x, y)

j = Joystick()
x, y = j.read()

类操纵杆（对象）：
定义初始化（自我，
x_低=50，x_高=50，
y_低=50，y_高=50，
on_值=100）：
self.x_low=x_low
self.x_high=x_high
self.y_low=y_low
self.y_high=y_high
self.on_值=on_值
def读取（自）：
#在此处执行读取操纵杆值的操作
#保存在x、y变量中的操纵杆值
x、 例如，y=0,0#dummy init
如果x>self.x_高：
x=自开_值
elif x<-self.x_低：
x=-self.on_值
其他：
x=0
如果y>self.x_高：
y=自开_值
elif y

---

然后在实际程序中，只需使用

j.read（）

读取操纵杆并清除输入数据。如果你需要改变它的工作方式，你只有一个地方（班级）。只要确保每个实际操纵杆都有一个不同的类实例，这样，如果你有不同的操纵杆，你就可以清理不同的操纵杆。

也许你会觉得这更像python：

def get(joyx):
   joyx_min = -200
   joyx_max = 200
   from collections import namedtuple
   wheel_section = namedtuple("wheel_section", "min, max, output_value")
   roulette_wheel = [ wheel_section(joyx_min, -50, -100),  wheel_section(-50,51,0), wheel_section(51, joyx_max,100) ]
   for section in roulette_wheel:
     if  section.min <= joyx <  section.max:
       return section.output_value
   return 255

---

我认为这是一种更优雅的方式，但原始的已经足够清楚了。很好：）我已经加载了数学（这是一个2000行的程序！）不知道copysign-这将非常有用：）喜欢它，但真的在寻找一行（如果存在的话）-ta:）@SimpleSi这是对遗传算法轮盘赌的改编。这些东西主要是用Java/C++编写的。如果您的值多于3（即，如果您希望将浮点范围转换为10个不同的整数值），则此选项非常有用。您还可以执行二进制搜索（最小值大于阈值），并将找到的索引映射到一组离散值。我可以把它放进一个（相当不可读的）lambda中。：）我想你知道我的意思：）例如，使用Python功能使它更短/更复杂。正如你所说——我在BBC基础课程中学习的老方法仍然是一种不错的做事方式：）

from bisect import bisect_left

# an intentionally larger: maps also 50 and -50 for demonstrational purposes.
data = { -200 : -100, -100 : -50, -50 : 0, 50 : 50, 220 : 100 }
keys = list(data.keys())


print data[  keys[ bisect_left(keys, -79)  ]  ] # prints -100
print data[  keys[ bisect_left(keys,  15)  ]  ] # prints 0
print data[  keys[ bisect_left(keys,  67)  ]  ] # prints 50
print data[  keys[ bisect_left(keys,  250) ]  ] # prints 100