답변:
값이 부울 인 경우 가장 빠른 방법은 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-precomputed-constant로 대체됩니다.
>>> 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'
Python 3에서는 next()
메서드가로 변경 __next__()
되었으므로 첫 번째 줄은 다음과 같이 작성됩니다.toggle = itertools.cycle(['red', 'green', 'blue']).__next__
.next()
전역 next()
함수 로 대체되었습니다 . 위의 예는 다음과 같습니다.toggle = itertools.cycle(...); next(toggle)
toggle = itertools.cycle(['red', 'green', 'blue'])
next(toggle)
a
및 b
사용 x = x ^ (a ^ b)
.
int(not 0)
그리고 int(not 1)
... hrmmm
나는 항상 다음을 사용합니다.
p^=True
p가 부울이면 true와 false 사이에서 전환됩니다.
p
이 메서드가 작동하기 위해 두 번 참조 할 필요가 없습니다 !! 긴 참조로 값을 토글하는 경우 아이디어.
^=
비트 XOR의 할당은이다
직관적이지 않은 또 다른 방법이 있습니다. 아름다움은 단지 두 개의 값이 아닌 여러 값을 순환 할 수 있다는 것입니다. [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
운영자가 당신의 변수를 부정 (이미이 아닌 경우 부울로 변환). 당신은 할 수 아마도 사용 1
과 0
상호 교환과 함께 True
하고 False
그래서 그냥 그것을 부정 :
toggle = not toggle
그러나 두 개의 임의 값을 사용하는 경우 인라인을 사용하십시오 if
.
toggle = 'a' if toggle == 'b' else 'b'
toggle = 0 if toggle else 1
더 짧고 일반적이다
if
을 사용하여 및 뿐만 아니라 두 개의 임의 변수 사이를 전환했습니다 . 1
0
삼각 접근 , 단지 때문에 sin
와 cos
기능이 시원하다.
>>> 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
놀랍게도 모듈로 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
전환하는 한 가지 방법은 다중 할당을 사용하는 것입니다.
>>> 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
예외 처리기 사용
>>> 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
좋아, 내가 최악이야
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)
현재 토글뿐만 아니라 이와 관련된 몇 가지 다른 값을 저장 하는 가상 토글은 어떻습니까?
toggle = complex.conjugate
+ 또는-값을 왼쪽에 저장하고 부호없는 값을 오른쪽에 저장합니다.
>>> x = 2 - 3j
>>> toggle(x)
(2+3j)
제로도 작동합니다.
>>> y = -2 - 0j
>>> toggle(y)
(-2+0j)
쉽게 현재의 토글 값을 검색 ( True
및 False
대표 +와 -), 좌을 (실제) 값 또는 우 (가상) 값 :
>>> 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)
... 그러나 RHS를 조심스럽게 조작하십시오.
>>> z = 1-1j
>>> z += 2j
>>> z
(1+1j) # whoops! toggled it!
변수 a와 b는 0과 1, 117과 711, 또는 "heads"와 "tails"와 같은 두 값이 될 수 있습니다. 수학이 사용되지 않고 토글이 필요할 때마다 값을 빠르게 교체 할 수 있습니다.
a = True
b = False
a,b = b,a # a is now False
a,b = b,a # a is now True
프레임 해킹을 해봅시다. 이름으로 변수를 전환합니다. 참고 : 이것은 모든 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
당신은 사용 할 수 index
의 list
들.
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"