Solution utilisant NOT
Si les valeurs sont booléennes, l'approche la plus rapide consiste à utiliser l'opérateur NOT:
>>> x = True
>>> x = not x # toggle
>>> x
False
>>> x = not x # toggle
>>> x
True
>>> x = not x # toggle
>>> x
False
Solution utilisant la soustraction
Si les valeurs sont numériques, la soustraction au total est un moyen simple et rapide de changer les valeurs:
>>> 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
Solution utilisant XOR
Si la valeur bascule entre 0 et 1, vous pouvez utiliser un bitwise exclusif-or :
>>> x = 1
>>> x ^= 1
>>> x
0
>>> x ^= 1
>>> x
1
La technique se généralise à toute paire d'entiers. L'étape xor-by-one est remplacée par une constante 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
(Cette idée a été soumise par Nick Coghlan et généralisée par @zxxc.)
Solution utilisant un dictionnaire
Si les valeurs sont hashable, vous pouvez utiliser un dictionnaire:
>>> 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'
Solution utilisant une expression conditionnelle
Le moyen le plus lent consiste à utiliser un expression conditionnelle :
>>> 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]
Solution utilisant itertools
Si vous avez plus de deux valeurs, la fonction itertools.cycle () fournit un moyen générique de basculer entre les valeurs successives:
>>> import itertools
>>> toggle = itertools.cycle(['red', 'green', 'blue']).next
>>> toggle()
'red'
>>> toggle()
'green'
>>> toggle()
'blue'
>>> toggle()
'red'
>>> toggle()
'green'
>>> toggle()
'blue'
Notez que dans Python 3, la méthode next() a été changée en __next__(), de sorte que la première ligne serait maintenant écrite sous la forme toggle = itertools.cycle(['red', 'green', 'blue']).__next__
J'utilise toujours:
p^=True
Si p est un booléen, cela bascule entre vrai et faux.
Voici un autre moyen non intuitif. La beauté est que vous pouvez parcourir plusieurs valeurs et pas seulement deux [0,1]
Pour deux valeurs (bascule)
>>> x=[1,0]
>>> toggle=x[toggle]
Pour plusieurs valeurs (disons 4)
>>> x=[1,2,3,0]
>>> toggle=x[toggle]
Je ne m'attendais pas à ce que cette solution soit également la plus rapide
>>> 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
L'opérateur not nie votre variable (la convertissant en un booléen si ce n'est pas déjà le cas). Vous pouvez probablement utiliser 1 et 0 de manière interchangeable avec True et False, donc il suffit de l’annuler:
toggle = not toggle
Mais si vous utilisez deux valeurs arbitraires, utilisez un inline if:
toggle = 'a' if toggle == 'b' else 'b'
Juste entre 1 et 0, faites ceci
1-x
x peut prendre 1 ou 0
Approche trigonométrique, simplement parce que les fonctions sin et cos sont cool.
>>> 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
Étonnamment, personne ne mentionne la bonne vieille division modulo 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
Notez que cela équivaut à x = x - 1, mais l’avantage de la technique modulo réside dans le fait que la taille du groupe ou la longueur de l’intervalle peuvent être plus grandes que 2 éléments seulement, ce qui vous donne un schéma d’entrelacement circulaire similaire à boucler.
Maintenant, juste pour 2 personnes, le basculement peut être un peu plus court (à l’aide d’un opérateur binaire):
x = x ^ 1
une façon de basculer consiste à utiliser l'affectation multiple
>>> a = 5
>>> b = 3
>>> t = a, b = b, a
>>> t[0]
3
>>> t = a, b = b, a
>>> t[0]
5
Utiliser 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
Le moyen le plus simple de basculer entre 1 et 0 consiste à soustraire de 1.
def toggle(value):
return 1 - value
Utilisation du gestionnaire d'exceptions
>>> 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, je suis le pire:
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 diriez-vous d’un imaginaire bascule qui stocke non seulement la bascule actuelle, mais quelques autres valeurs qui lui sont associées?
toggle = complex.conjugate
Stockez toute valeur + ou - à gauche et toute valeur non signée à droite:
>>> x = 2 - 3j
>>> toggle(x)
(2+3j)
Zéro fonctionne aussi:
>>> y = -2 - 0j
>>> toggle(y)
(-2+0j)
Récupérez facilement la valeur de basculement actuelle (True et False représentent + et -), la valeur LHS (réelle) ou la valeur RHS (imaginaire):
>>> 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
Échangez facilement LHS et RHS (mais notez que le signe des deux valeurs ne doit pas être important):
>>> swap = lambda i: i/-1j
>>> swap(2+0j)
2j
>>> swap(3+2j)
(2+3j)
Facilement permuter LHS et RHS et aussi bascule en même temps:
>>> swaggle = lambda i: i/1j
>>> swaggle(2+0j)
-2j
>>> swaggle(3+2j)
(2-3j)
Protège contre les erreurs:
>>> toggle(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: descriptor 'conjugate' requires a 'complex' object but received a 'int'
Effectuer les modifications dans LHS et RHS:
>>> x += 1+2j
>>> x
(3+5j)
... mais soyez prudent en manipulant le RHS:
>>> z = 1-1j
>>> z += 2j
>>> z
(1+1j) # whoops! toggled it!
J'utilise la fonction abs, très utile sur les boucles
x = 1
for y in range(0, 3):
x = abs(x - 1)
x sera 0.
Les variables a et b peuvent être TOUTES deux valeurs, comme 0 et 1, ou 117 et 711, ou "têtes" et "queues". Aucun calcul n'est utilisé, juste un échange rapide des valeurs chaque fois qu'une bascule est souhaitée.
a = True
b = False
a,b = b,a # a is now False
a,b = b,a # a is now True
Faisons du piratage d'image. Basculer une variable par nom. Remarque: Cela peut ne pas fonctionner avec tous les environnements d'exécution Python.
Disons que vous avez une variable "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
Si vous avez affaire à une variable entière, vous pouvez incrémenter 1 et limiter votre ensemble à 0 et 1 (mod)
X = 0 # or X = 1
X = (X + 1)%2
La commutation entre -1 et +1 peut être obtenue par multiplication en ligne; utilisé pour le calcul de pi de la manière 'Leibniz' (ou similaire):
sign = 1
result = 0
for i in range(100000):
result += 1 / (2*i + 1) * sign
sign *= -1
print("pi (estimate): ", result*4)