Каков наиболее эффективный способ переключения между 0 и 1?
Как переключить значение в Python
Ответ 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, вы можете использовать побитовое исключающее-или:
>>> 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
(Эта идея была представлена Ником Когланом и позже обобщена @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
Если у вас более двух значений, функция 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__
Ответ 2
Я всегда использую:
p^=True
Если p является булевым, оно переключается между истинным и ложным.
Ответ 3
Вот еще один неинтуитивный способ. Красота заключается в том, что вы можете циклически перебирать несколько значений, а не только две [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
Ответ 4
Оператор not отрицает вашу переменную (превращая ее в логическую, если она еще не одна). Вы можете использовать 1 и 0 взаимозаменяемо с True и False, поэтому просто отрицайте это:
toggle = not toggle
Но если вы используете два произвольных значения, используйте встроенный if:
toggle = 'a' if toggle == 'b' else 'b'
Ответ 5
Только между 1 и 0, сделайте это
1-x
x может принимать 1 или 0
Ответ 6
Тригонометрический подход, просто потому что функции 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
Ответ 7
Удивительно, что никто не упоминает хорошее старое разделение по модулю 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
Ответ 8
один из способов переключения - использование множественного присвоения
>>> 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
Ответ 9
Использование обработчика исключений
>>> 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)
Ответ 10
Самый простой способ переключения между 1 и 0 состоит в вычитании из 1.
def toggle(value):
return 1 - value
Ответ 11
Как насчет воображаемого переключателя, который хранит не только текущий переключатель, но и пару других значений, связанных с ним?
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!
Ответ 12
Я использую функцию abs, очень полезную для циклов
x = 1
for y in range(0, 3):
x = abs(x - 1)
x будет 0.
Ответ 13
Скорее сначала...
def toggle(x = []):
x.append('#')
return len(x) % 2
Ответ 14
Позвольте сделать некоторые кадры взлома. Переключить переменную по имени. Примечание: это может не работать с каждой средой исполнения Python.
Скажем, у вас есть переменная "х"
>>> 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
Ответ 15
Если вы имеете дело с целочисленной переменной, вы можете увеличить 1 и ограничить свой набор 0 и 1 (мод)
X = 0 # or X = 1
X = (X + 1)%2
Ответ 16
Переменные 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
Ответ 17
Переключение между -1 и +1 может быть получено с помощью встроенного умножения; используется для расчета числа Пи Лейбница (или аналогичного):
sign = 1
result = 0
for i in range(100000):
result += 1 / (2*i + 1) * sign
sign *= -1
print("pi (estimate): ", result*4)