Python 如何切换值？

在

0

和

1

之间切换最有效的方法是什么？

非

运算符会对变量求反（如果变量还不是布尔值，则将其转换为布尔值）。您可能可以将
1
和
0
与
True
和
False
互换使用，因此只需将其否定即可：

toggle = not toggle

但如果您使用两个任意值，请使用内联
if
：

toggle = 'a' if toggle == 'b' else 'b'

仅在1和0之间，执行此操作

1-x 

x可以取1或0，这是另一种非直观的方法。美妙之处在于，您可以在多个值上循环，而不仅仅是两个[0,1]

对于两个值（切换）

对于多个值（例如4）

我也没想到这个解决方案几乎是最快的

>>> stmt1="""
toggle=0
for i in xrange(0,100):
    toggle = 1 if toggle == 0 else 0
"""
>>> stmt2="""
x=[1,0]
toggle=0
for i in xrange(0,100):
    toggle=x[toggle]
"""
>>> t1=timeit.Timer(stmt=stmt1)
>>> t2=timeit.Timer(stmt=stmt2)
>>> print "%.2f usec/pass" % (1000000 * t1.timeit(number=100000)/100000)
7.07 usec/pass
>>> print "%.2f usec/pass" % (1000000 * t2.timeit(number=100000)/100000)
6.19 usec/pass
stmt3="""
toggle = False
for i in xrange(0,100):
    toggle = (not toggle) & 1
"""
>>> t3=timeit.Timer(stmt=stmt3)
>>> print "%.2f usec/pass" % (1000000 * t3.timeit(number=100000)/100000)
9.84 usec/pass
>>> stmt4="""
x=0
for i in xrange(0,100):
    x=x-1
"""
>>> t4=timeit.Timer(stmt=stmt4)
>>> print "%.2f usec/pass" % (1000000 * t4.timeit(number=100000)/100000)
6.32 usec/pass

使用NOT的解决方案
如果值是布尔值，最快的方法是使用运算符：

>>> x = True
>>> x = not x        # toggle
>>> x
False
>>> x = not x        # toggle
>>> x
True
>>> x = not x        # toggle
>>> x
False

用减法求解
如果值是数值，则从总数中减去是切换值的简单而快速的方法：

>>> A = 5
>>> B = 3
>>> total = A + B
>>> x = A
>>> x = total - x    # toggle
>>> x
3
>>> x = total - x    # toggle
>>> x
5
>>> x = total - x    # toggle
>>> x
3

使用XOR的解决方案
如果该值在0和1之间切换，则可以使用：

该技术可推广到任何一对整数。一步异或替换为预计算常数的异或：

>>> A = 205
>>> B = -117
>>> t = A ^ B        # precomputed toggle constant
>>> x = A
>>> x ^= t           # toggle
>>> x
-117
>>> x ^= t           # toggle
>>> x
205
>>> x ^= t           # toggle
>>> x
-117

（这一想法由Nick Coghlan提交，后来由@zxxc推广。）

使用字典的解决方案
如果值是可散列的，则可以使用字典：

>>> A = 'xyz'
>>> B = 'pdq'
>>> d = {A:B, B:A}
>>> x = A
>>> x = d[x]         # toggle
>>> x
'pdq'
>>> x = d[x]         # toggle
>>> x
'xyz'
>>> x = d[x]         # toggle
>>> x
'pdq'

使用条件表达式的解决方案
最慢的方法是使用：

使用itertools解决方案
如果有两个以上的值，则该函数提供了在连续值之间切换的通用快速方法：

>>> import itertools
>>> toggle = itertools.cycle(['red', 'green', 'blue']).next
>>> toggle()
'red'
>>> toggle()
'green'
>>> toggle()
'blue'
>>> toggle()
'red'
>>> toggle()
'green'
>>> toggle()
'blue'

请注意，在Python 3中，
next（）
方法更改为
\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

>>> a = 5
>>> b = 3

>>> t = a, b = b, a
>>> t[0]
3

>>> t = a, b = b, a
>>> t[0]
5

使用itertools：

In [12]: foo = itertools.cycle([1, 2, 3])

In [13]: next(foo)
Out[13]: 1

In [14]: next(foo)
Out[14]: 2

In [15]: next(foo)
Out[15]: 3

In [16]: next(foo)
Out[16]: 1

In [17]: next(foo)
Out[17]: 2

令人惊讶的是，没有人提到好的旧除法模2：

In : x = (x + 1)  % 2 ; x
Out: 1

In : x = (x + 1)  % 2 ; x
Out: 0

In : x = (x + 1)  % 2 ; x
Out: 1

In : x = (x + 1)  % 2 ; x
Out: 0

请注意，它相当于
x=x-1
，但模技术的优点是，组的大小或间隔的长度可以大于2个元素，从而提供类似于循环交织方案的循环

现在仅针对2，切换可以稍微短一点（使用位运算符）：

我总是使用：

p^=True

如果p是布尔值，则会在真与假之间切换。
三角法，这只是因为
sin
和
cos
函数很酷


使用异常处理程序

>>> def toogle(x):
...     try:
...         return x/x-x/x
...     except  ZeroDivisionError:
...         return 1
... 
>>> x=0
>>> x=toogle(x)
>>> x
1
>>> x=toogle(x)
>>> x
0
>>> x=toogle(x)
>>> x
1
>>> x=toogle(x)
>>> x
0

好吧，我是最差的：


在1和0之间切换的最简单方法是从1中减去

def toggle(value):
    return 1 - value

我使用abs功能，对循环非常有用

x = 1
for y in range(0, 3):
    x = abs(x - 1)

x将为0。
一个虚拟的切换如何，它不仅存储当前切换，而且还存储与之相关联的两个其他值

toggle = complex.conjugate

在左侧存储任意+或-值，在右侧存储任意无符号值：

>>> x = 2 - 3j
>>> toggle(x)
(2+3j)

零也行：

>>> y = -2 - 0j
>>> toggle(y)
(-2+0j)

轻松检索当前切换值（
True
和
False
表示+和-）、LHS（实）值或RHS（虚）值：

可以轻松地交换LHS和RHS（但请注意，这两个值的符号一定不重要）：

轻松交换左、右驾驶，同时切换：

>>> swaggle = lambda i: i/1j
>>> swaggle(2+0j)
-2j
>>> swaggle(3+2j)
(2-3j)

防止错误：

>>> toggle(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: descriptor 'conjugate' requires a 'complex' object but received a 'int'

…但操作RHS时要小心：

>>> z = 1-1j
>>> z += 2j
>>> z
(1+1j) # whoops! toggled it!

让我们做一些框架黑客。按名称切换变量。注意：这可能不适用于所有Python运行时

假设你有一个变量“x”

如果处理的是整数变量，则可以递增1，并将集合限制为0和1（mod）

变量a和b可以是任意两个值，如0和1，或117和711，或“正面”和“反面”。不使用数学，只需在每次需要切换时快速交换值

a = True   
b = False   

a,b = b,a   # a is now False
a,b = b,a   # a is now True

通过内联乘法可以在-1和+1之间切换；用于采用“莱布尼兹”法（或类似方法）计算pi：

您可以使用
列表的
索引

def toggleValues(values, currentValue):
    return values[(values.index(currentValue) + 1) % len(values)]

> toggleValues( [0,1] , 1 )
> 0
> toggleValues( ["one","two","three"] , "one" )
> "two"
> toggleValues( ["one","two","three"] , "three")
> "one"

优点：无需额外的库、自解释代码和处理任意数据类型

缺点：不重复保存。
切换值（[“一”、“二”、“复制”、“三”、“复制”、“四”]、“复制”）
将始终返回
“三个”
+1，但
toggle=0如果toggle else 1
较短且更通用，我将交换变量以使其更清晰。我用内联的
if
在两个任意变量之间切换，而不仅仅是
1
和
0
。是的，这是个难题。谢谢大家，看看不同的人如何处理这个问题很有趣（而且信息丰富。）很好，这是一个微型状态机。好吧，你的状态机是最有趣的，但这不是我个人所需要的，所以好吧，我想简单的数学状态机对我来说可能是最好的，应该是1-x吗？是的，但这不会使速度有任何不同。唉，但这会使它出错，不是吗？这里有一些很棒的答案，太棒了！因为（无论如何，在Python2.x中）
True
和
False
实际上是整数，尽管它们的
\uuu str\uu（）
方法非常详细，
x
在这里也可以是
True
或
False
。不过，你会得到1或0。我不确定这种（类似C的）模运算有多“pythonic”（即“pythonic”是否适用？）。我猜这只是一个算术运算，在其他任何有二进制的地方都能用。显然，有元组的有限状态机，比如x=（1,2,3,0）；令牌=0；token=x[token]非常令人兴奋，因为它甚至可以比单纯的组操作更为通用。太棒了
p
不需要引用两次，此方法才能工作！！如果您使用长引用切换值，请注意。这个运算符叫什么？这是XOR运算符。@mix3d确切地说，它是“按位异或”（与“逻辑异或”相反）。逻辑异或Pyth中的特定运算符
>>> x = 2 - 3j
>>> toggle(x)
(2+3j)

>>> y = -2 - 0j
>>> toggle(y)
(-2+0j)

>>> import math
>>> curr = lambda i: math.atan2(i.imag, -abs(i.imag)) > 0
>>> lhs = lambda i: i.real
>>> rhs = lambda i: abs(i.imag)
>>> x = toggle(x)
>>> curr(x)
True
>>> lhs(x)
2.0
>>> rhs(x)
3.0

>>> swap = lambda i: i/-1j
>>> swap(2+0j)
2j
>>> swap(3+2j)
(2+3j)

>>> swaggle = lambda i: i/1j
>>> swaggle(2+0j)
-2j
>>> swaggle(3+2j)
(2-3j)

>>> toggle(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: descriptor 'conjugate' requires a 'complex' object but received a 'int'

>>> x += 1+2j
>>> x
(3+5j)

>>> z = 1-1j
>>> z += 2j
>>> z
(1+1j) # whoops! toggled it!

>>> import inspect
>>> def toggle(var_name):
>>>     frame = inspect.currentframe().f_back
>>>     vars = frame.f_locals
>>>     vars[var_name] = 0 if vars[var_name] == 1 else 1

>>> x = 0
>>> toggle('x')
>>> x
1
>>> toggle('x')
>>> x
0

X = 0  # or X = 1
X = (X + 1)%2

a = True   
b = False   

a,b = b,a   # a is now False
a,b = b,a   # a is now True

sign = 1
result = 0
for i in range(100000):
    result += 1 / (2*i + 1) * sign
    sign *= -1
print("pi (estimate): ", result*4)

def toggleValues(values, currentValue):
    return values[(values.index(currentValue) + 1) % len(values)]

> toggleValues( [0,1] , 1 )
> 0
> toggleValues( ["one","two","three"] , "one" )
> "two"
> toggleValues( ["one","two","three"] , "three")
> "one"