วิธีการสลับค่าใน Python

วิธีใดเป็นวิธีที่มีประสิทธิภาพที่สุดในการสลับระหว่าง0และ1?

วิธีแก้ปัญหาโดยใช้ NOT

หากค่าเป็นบูลีนวิธีที่เร็วที่สุดคือใช้ตัวดำเนินการ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

(ความคิดนี้ส่งโดย 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

หากคุณมีค่ามากกว่าสองค่าฟังก์ชัน 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__

ฉันมักจะใช้:

p^=True

ถ้า p เป็นบูลีนค่านี้จะสลับไปมาระหว่างจริงและเท็จ

นี่เป็นอีกวิธีหนึ่งที่ไม่ใช้งานง่าย ความงามคือคุณสามารถหมุนเวียนค่าได้หลายค่าไม่ใช่แค่สองค่า [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'

ทำสิ่งนี้ระหว่าง 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

ไม่น่าแปลกใจที่ไม่มีใครพูดถึง 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

โปรดทราบว่ามันเทียบเท่ากับx = x - 1แต่ข้อดีของเทคนิคโมดูโลคือขนาดของกลุ่มหรือความยาวของช่วงเวลาอาจใหญ่กว่าจากนั้นมีเพียง 2 องค์ประกอบจึงทำให้คุณมีลักษณะคล้ายกับรูปแบบการสอดแทรกแบบ Round-robin เพื่อวนซ้ำ

ตอนนี้สำหรับ 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

วิธีที่ง่ายที่สุดในการสลับระหว่าง 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)

Zero ก็ใช้งานได้เช่นกัน:

>>> 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 อาจเป็นค่าใดก็ได้ 2 ค่าเช่น 0 และ 1 หรือ 117 และ 711 หรือ "head" และ "tail" ไม่มีการใช้คณิตศาสตร์เพียงแค่สลับค่าอย่างรวดเร็วทุกครั้งที่ต้องการสลับ

a = True   
b = False   

a,b = b,a   # a is now False
a,b = b,a   # a is now True

ฉันใช้ฟังก์ชัน abs ซึ่งมีประโยชน์มากกับลูป

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 สามารถหาได้โดยการคูณแบบอินไลน์ ใช้สำหรับการคำนวณ pi ทาง 'Leibniz' (หรือคล้ายกัน):

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

คุณสามารถใช้ประโยชน์indexจากlists

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"

ข้อดี : ไม่มีไลบรารีเพิ่มเติมรหัสอธิบายตนเองและการทำงานกับประเภทข้อมูลที่กำหนดเอง

จุดด้อย : not duplicate-save. toggleValues(["one","two","duped", "three", "duped", "four"], "duped") จะกลับมาเสมอ"three"