Qual é a maneira mais eficiente de alternar entre 0
e 1
?
Qual é a maneira mais eficiente de alternar entre 0
e 1
?
Respostas:
Se os valores forem booleanos, a abordagem mais rápida é usar o operador not :
>>> x = True
>>> x = not x # toggle
>>> x
False
>>> x = not x # toggle
>>> x
True
>>> x = not x # toggle
>>> x
False
Se os valores forem numéricos, a subtração do total é uma maneira simples e rápida de alternar valores:
>>> 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
Se o valor alternar entre 0 e 1 , você pode usar um exclusivo bit a bit - ou :
>>> x = 1
>>> x ^= 1
>>> x
0
>>> x ^= 1
>>> x
1
A técnica generaliza para qualquer par de números inteiros. A etapa xor-por-um é substituída por uma constante xor-por-pré-computada:
>>> 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
(Essa ideia foi enviada por Nick Coghlan e depois generalizada por @zxxc.)
Se os valores são hashable, você pode usar um dicionário:
>>> 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 maneira mais lenta é usar uma expressão condicional :
>>> 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]
Se você tiver mais de dois valores, a função itertools.cycle () fornece uma maneira rápida e genérica de alternar entre valores sucessivos:
>>> import itertools
>>> toggle = itertools.cycle(['red', 'green', 'blue']).next
>>> toggle()
'red'
>>> toggle()
'green'
>>> toggle()
'blue'
>>> toggle()
'red'
>>> toggle()
'green'
>>> toggle()
'blue'
Observe que no Python 3 o next()
método foi alterado para __next__()
, então a primeira linha seria agora escrita comotoggle = itertools.cycle(['red', 'green', 'blue']).__next__
.next()
foi substituído por uma next()
função global . O exemplo acima seria:toggle = itertools.cycle(...); next(toggle)
toggle = itertools.cycle(['red', 'green', 'blue'])
next(toggle)
a
e b
uso x = x ^ (a ^ b)
.
int(not 0)
e int(not 1)
... hrmmm
Eu sempre uso:
p^=True
Se p é um booleano, isso alterna entre verdadeiro e falso.
p
não precisa ser referenciado duas vezes para que este método funcione !! Idéia se você estiver alternando um valor com uma referência longa e longa.
^=
é XOR assigment
Aqui está outra maneira não intuitiva. A beleza é que você pode percorrer vários valores e não apenas dois [0,1]
Para dois valores (alternando)
>>> x=[1,0]
>>> toggle=x[toggle]
Para vários valores (digamos 4)
>>> x=[1,2,3,0]
>>> toggle=x[toggle]
Eu não esperava que esta solução fosse quase a mais rápida também
>>> 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
O not
operador nega sua variável (convertendo-a em um booleano, se ainda não for uma). Você provavelmente pode usar 1
e 0
alternar com True
e False
, portanto, negue:
toggle = not toggle
Mas se você estiver usando dois valores arbitrários, use um inline if
:
toggle = 'a' if toggle == 'b' else 'b'
toggle = 0 if toggle else 1
é mais curto e mais geral
if
para alternar entre duas variáveis arbitrárias , não apenas 1
e 0
.
Apenas entre 1 e 0, faça isso
1-x
x pode levar 1 ou 0
True
e False
na verdade são números inteiros, embora com um __str__()
método surpreendentemente detalhado , x
também pode ser True
ou False
aqui. Você receberá 1 ou 0 de volta, no entanto.
Abordagem trigonométrica , apenas porque sin
e cos
funções são legais.
>>> 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
Surpreendentemente, ninguém mencionou o bom e velho módulo de divisão 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
Observe que é equivalente a x = x - 1
, mas a vantagem da técnica de módulo é que o tamanho do grupo ou a duração do intervalo pode ser maior que apenas 2 elementos, proporcionando assim um esquema de intercalação de rodízio semelhante ao loop.
Agora, apenas para 2, alternar pode ser um pouco mais curto (usando o operador bit a bit):
x = x ^ 1
uma maneira de alternar é usando a atribuição Múltipla
>>> a = 5
>>> b = 3
>>> t = a, b = b, a
>>> t[0]
3
>>> t = a, b = b, a
>>> t[0]
5
Usando 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
Usando manipulador de exceção
>>> 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
Ok, eu sou o pior:
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)
Que tal uma alternância imaginária que armazena não apenas a alternância atual, mas alguns outros valores associados a ela?
toggle = complex.conjugate
Armazene qualquer valor + ou - à esquerda e qualquer valor não assinado à direita:
>>> x = 2 - 3j
>>> toggle(x)
(2+3j)
Zero também funciona:
>>> y = -2 - 0j
>>> toggle(y)
(-2+0j)
Recupere facilmente o valor atual de alternância ( True
e False
representa + e -), valor LHS (real) ou valor RHS (imaginário):
>>> 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
Troque facilmente LHS e RHS (mas observe que o sinal dos dois valores não deve ser importante):
>>> swap = lambda i: i/-1j
>>> swap(2+0j)
2j
>>> swap(3+2j)
(2+3j)
Troque facilmente LHS e RHS e também alterne ao mesmo tempo:
>>> swaggle = lambda i: i/1j
>>> swaggle(2+0j)
-2j
>>> swaggle(3+2j)
(2-3j)
Protege contra erros:
>>> toggle(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: descriptor 'conjugate' requires a 'complex' object but received a 'int'
Execute alterações no LHS e RHS:
>>> x += 1+2j
>>> x
(3+5j)
... mas tenha cuidado ao manipular o RHS:
>>> z = 1-1j
>>> z += 2j
>>> z
(1+1j) # whoops! toggled it!
As variáveis aeb podem ter QUALQUER dois valores, como 0 e 1, ou 117 e 711, ou "cara" e "coroa". Nenhuma matemática é usada, apenas uma troca rápida dos valores sempre que uma alternância é desejada.
a = True
b = False
a,b = b,a # a is now False
a,b = b,a # a is now True
Vamos fazer alguns hackers de quadro. Alterne uma variável por nome. Nota: Isso pode não funcionar com todos os tempos de execução do Python.
Digamos que você tenha uma variável "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
Se você está lidando com uma variável inteira, pode incrementar 1 e limitar seu conjunto a 0 e 1 (mod)
X = 0 # or X = 1
X = (X + 1)%2
Alternar entre -1 e +1 pode ser obtido por multiplicação em linha; usado para o cálculo de pi da maneira 'Leibniz' (ou similar):
sign = 1
result = 0
for i in range(100000):
result += 1 / (2*i + 1) * sign
sign *= -1
print("pi (estimate): ", result*4)
Você pode usar o index
de list
s.
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"
Prós : Não há bibliotecas adicionais, código autoexplicativo e trabalho com tipos de dados arbitrários.
Contras : não salvar duplicado.
toggleValues(["one","two","duped", "three", "duped", "four"], "duped")
sempre retornará"three"