값을 전환하는 방법?

값을 전환하는 방법?

사이를 전환하는 가장 효율적인 방법은 무엇입니까?0그리고.1?

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 사이에서 전환되는 경우 비트 단위로 exclusive-또는 다음을 사용할 수 있습니다.

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

ITER 도구를 사용한 솔루션

값이 두 개 이상인 경우 itertools.cycle() 함수는 연속된 값을 전환하는 일반적인 빠른 방법을 제공합니다.

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

에서는 참로에는 3서썬파가 됩니다.next()가 방이로변습니다었되경법으로 되었습니다.__next__()그래서 첫 번째 줄은 이제 다음과 같이 쓰여질 것입니다.toggle = itertools.cycle(['red', 'green', 'blue']).__next__

항상 사용하는 항목:

p^=True

p가 부울 값이면 true와 false 사이에서 전환됩니다.

여기 직관적이지 않은 또 다른 방법이 있습니다.장점은 두 개의 값이 아니라 여러 개의 값을 순환할 수 있다는 것입니다 [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와바꿀수없과 는▁withablychange를 바꾸어True그리고.False그러니 그냥 부정하세요.

toggle = not toggle

두 값을 그나두임값의사을용는경사다용니합인을라인우하러를 합니다.if:

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

1과 0 사이에서, 이렇게 합니다.

1-x 

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

iiter 도구 사용:

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

1과 0 사이를 전환하는 가장 쉬운 방법은 1에서 빼는 것입니다.

def toggle(value):
    return 1 - value

예외 처리기 사용

>>> 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+ 및 -), 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)

하지만 RHS를 조작할 때는 주의해야 합니다.

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

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

저는 루프에서 매우 유용한 복근 기능을 사용합니다.

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

x는 0이 됩니다.

프레임 해킹을 해보겠습니다.이름을 기준으로 변수를 전환합니다.참고: 모든 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

-1과 +1 사이의 전환은 인라인 곱셈을 통해 얻을 수 있으며, 파이 'Leibniz' 방식(또는 유사한 방식)을 계산하는 데 사용됩니다.

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

언급URL : https://stackoverflow.com/questions/8381735/how-to-toggle-a-value