如何切换值？

在 0和 1之间切换的最有效方法是什么？

125247 次浏览
小开

not操作符将否定您的变量(如果变量还不是布尔值，则将其转换为布尔值)。可能吧可以与 True和 False交替使用 1和 0，所以只要抵消它:

toggle = not toggle

但是，如果使用两个任意值，则使用内联 if:

toggle = 'a' if toggle == 'b' else 'b'
小开

在1到0之间，做这个

1-x

X 可以取1或0

小开

这里还有另一种非直观的方法，美妙之处在于你可以在多个值之间循环，而不仅仅是两个[0,1]

用于两个值(切换)

>>> x=[1,0]
>>> toggle=x[toggle]

多重价值(例如4)

>>> x=[1,2,3,0]
>>> toggle=x[toggle]

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

>>> 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 的解决方案

如果值是布尔值，最快的方法是使用 布尔操作(boolean-operation) rel = “ noReferrer”> 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

使用异或的解决方案

如果该值在 0和 1之间切换，则可以使用 按位独占-或:

>>> x = 1
>>> x ^= 1
>>> x
0
>>> x ^= 1
>>> x
1

这种技术推广到任何一对整数。 xor-by-one 步骤被替换为 xor-by-pre計算常数:

>>> 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'

使用条件表达式的解决方案

最慢的方法是使用 条件表达式:

>>> A = [1,2,3]
>>> B = [4,5,6]
>>> x = A
>>> x = B if x == A else A
>>> x
[4, 5, 6]
>>> x = B if x == A else A
>>> x
[1, 2, 3]
>>> x = B if x == A else A
>>> x
[4, 5, 6]

使用 itertools 的解决方案

如果您有两个以上的值，Cycle ()函数提供了一种通用的快速方法来在连续的值之间切换:

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

注意，在 Python3中，next()方法被更改为 __next__()，因此第一行现在将被编写为 toggle = itertools.cycle(['red', 'green', 'blue']).__next__

小开

切换的一种方法是使用多重赋值

>>> 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，切换可以稍微短一点(使用位运算符) :

x = x ^ 1
小开

我总是用:

p^=True

如果 p 是布尔值，则在 true 和 false 之间切换。

小开

三角函数法 ，仅仅因为 sin和 cos函数很酷。

enter image description here

>>> import math
>>> def generator01():
...     n=0
...     while True:
...         yield abs( int( math.cos( n * 0.5 * math.pi  ) ) )
...         n+=1
...
>>> g=generator01()
>>> g.next()
1
>>> g.next()
0
>>> g.next()
1
>>> g.next()
0
小开

使用异常处理程序

>>> 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

好吧，我是最差的:

enter image description here

import math
import sys


d={1:0,0:1}
l=[1,0]


def exception_approach(x):
try:
return x/x-x/x
except  ZeroDivisionError:
return 1


def cosinus_approach(x):
return abs( int( math.cos( x * 0.5 * math.pi  ) ) )


def module_approach(x):
return  (x + 1)  % 2


def subs_approach(x):
return  x - 1


def if_approach(x):
return 0 if x == 1 else 1


def list_approach(x):
global l
return l[x]


def dict_approach(x):
global d
return d[x]


def xor_approach(x):
return x^1


def not_approach(x):
b=bool(x)
p=not b
return int(p)


funcs=[ exception_approach, cosinus_approach, dict_approach, module_approach, subs_approach, if_approach, list_approach, xor_approach, not_approach ]


f=funcs[int(sys.argv[1])]
print "\n\n\n", f.func_name
x=0
for _ in range(0,100000000):
x=f(x)
小开

在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)

Zero 也有效:

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

轻松获取当前切换值(True和 False表示 + 和 -)、 LHS (实数)值或 RHS (虚数)值:

>>> 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

轻松地交换 LHS 和 RHS (但注意，这两个值的符号一定不重要) :

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

轻松地同时交换 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'

改变 LHS 和 RHS:

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

但要小心操纵皇家医疗服务系统:

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

让我们做一些框架修改。按名称切换一个变量。注意: 这可能不适用于每个 Python 运行时。

假设你有一个变量“ x”

>>> 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
小开

如果您正在处理一个整数变量，您可以递增1并将您的集合限制为0和1(mod)

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

变量 a 和 b 可以是任意两个值，比如0和1，或者117和711，或者“ head”和“ tail”。没有使用数学，只是在每次需要切换时快速交换值。

a = True
b = False


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

在 -1和 + 1之间切换可以通过内联乘法获得; 用莱布尼茨方法(或类似方法)计算圆周率:

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

你可以利用 list的 index。

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"

优点 : 不需要额外的库、自解释代码和任意数据类型。

缺点 : 不重复-保存。 toggleValues(["one","two","duped", "three", "duped", "four"], "duped") 总是返回 "three"


提交答案