0এবং এর মধ্যে টগল করার সবচেয়ে কার্যকর উপায় কোনটি 1?
উত্তর:
মান বুলিয়ান হন, দ্রুততম পদ্ধতির ব্যবহার করা না অপারেটর:
>>> 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মধ্যে মান টগল তাহলে 0 এবং 1 , আপনি একটি ব্যবহার করতে পারেন , bitwise একচেটিয়া বা :
>>> x = 1
>>> x ^= 1
>>> x
0
>>> x ^= 1
>>> x
1কৌশলটি কোনও জোড় সংখ্যায় সাধারণীকরণ করে। জোর-ও-ওয়ান স্টেপটি একটি জোর-বাই-প্রম্পম্পিউটেড-ধ্রুবক দ্বারা প্রতিস্থাপন করা হয়েছে:
>>> 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]আপনার যদি দুটিরও বেশি মান থাকে তবে এটিরটোউলসাইকেল () ফাংশন ক্রমাগত মানগুলির মধ্যে টগল করার একটি জেনেরিক দ্রুত উপায় সরবরাহ করে:
>>> 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__
.next()একটি বিশ্বব্যাপী next()ফাংশন দ্বারা প্রতিস্থাপিত হয়েছে । উপরোক্ত উদাহরণে হবে:toggle = itertools.cycle(...); next(toggle)
toggle = itertools.cycle(['red', 'green', 'blue']) next(toggle)
aএবং bব্যবহারের মধ্যে টগল করার জন্য সাধারণীকরণ করা যেতে পারে x = x ^ (a ^ b)।
int(not 0)এবং int(not 1)...
আমি সবসময় ব্যবহার:
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/passnotঅপারেটরকে আপনার পরিবর্তনশীল negates (এটা একটি বুলিয়ান মধ্যে রূপান্তর এটি ইতিমধ্যেই এক নয়)। আপনি করতে পারেন সম্ভবত ব্যবহার 1এবং 0সঙ্গে অদলবদল করে Trueএবং False, তাই শুধু এটা অস্বীকার:
toggle = not toggleতবে আপনি যদি দুটি নির্বিচার মান ব্যবহার করছেন তবে একটি ইনলাইন ব্যবহার করুন if:
toggle = 'a' if toggle == 'b' else 'b'toggle = 0 if toggle else 1খাটো এবং আরও সাধারণ
ifইনলাইনটি কেবল এবং না হয়ে দুটি স্বেচ্ছাচারী ভেরিয়েবলের মধ্যে টগল করতে ব্যবহার করছিলাম । 10
মাত্র 1 এবং 0 এর মধ্যে, এটি করুন
1-x x 1 বা 0 নিতে পারে
Trueএবং Falseপ্রকৃতপক্ষে পূর্ণসংখ্যা হয়, তবে আশ্চর্যজনকভাবে ভার্বোজ __str__()পদ্ধতিতেও xএটি Trueবা Falseএখানেও হতে পারে । যদিও আপনি 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 টি বড় হতে পারে, এভাবে আপনাকে লুপ ওভার করতে রাউন্ড-রবিন ইন্টারলিভিং স্কিমের অনুরূপ দেয়।
এখন কেবল ২ এর জন্য, টগলিং কিছুটা খাটো হতে পারে (বিট-ওয়াইড অপারেটর ব্যবহার করে):
x = x ^ 1একাধিক অ্যাসাইনমেন্ট ব্যবহার করে টগল করার একটি উপায়
>>> a = 5
>>> b = 3
>>> t = a, b = b, a
>>> t[0]
3
>>> t = a, b = b, a
>>> t[0]
5ইটারটুলগুলি ব্যবহার করে:
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]: 21 এবং 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উপস্থাপনা + এবং -), এলএইচএস (বাস্তব) মান, বা আরএইচএস (কল্পিত) মানটি সহজেই পুনরুদ্ধার করুন :
>>> 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সহজেই এলএইচএস এবং আরএইচএস অদলবদল করুন (তবে লক্ষ্য করুন যে উভয় মানের সাইন অবশ্যই গুরুত্বপূর্ণ হবে না):
>>> swap = lambda i: i/-1j
>>> swap(2+0j)
2j
>>> swap(3+2j)
(2+3j)সহজেই এলএইচএস এবং আরএইচএস অদলবদল করুন এবং একই সাথে টগল করুন:
>>> 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'এলএইচএস এবং আরএইচএসে পরিবর্তনগুলি সম্পাদন করুন:
>>> x += 1+2j
>>> x
(3+5j)... তবে আরএইচএসে কৌশলে সাবধানতা অবলম্বন করুন:
>>> z = 1-1j
>>> z += 2j
>>> z
(1+1j) # whoops! toggled it!ভেরিয়েবল এ এবং বি এর মান দুটি হতে পারে যেমন 0 এবং 1, বা 117 এবং 711, বা "মাথা" এবং "লেজ"। কোনও গণিত ব্যবহার করা হয় না, প্রতিবার একটি টগল পছন্দ হলে মানগুলির কেবলমাত্র দ্রুত অদলবদল হয়।
a = True
b = False
a,b = b,a # a is now False
a,b = b,a # a is now Trueআসুন কিছু ফ্রেম হ্যাকিং করা যাক। নামে একটি ভেরিয়েবল টগল করুন। দ্রষ্টব্য: এটি প্রতিটি পাইথন রানটাইমের সাথে কাজ করতে পারে না।
বলুন আপনার একটি পরিবর্তনশীল "এক্স" রয়েছে
>>> 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 এর মধ্যে স্যুইচিং ইনলাইন গুন দ্বারা প্রাপ্ত করা যেতে পারে; পাই 'লাইবনিজ' উপায় (বা অনুরূপ) গণনার জন্য ব্যবহৃত:
sign = 1
result = 0
for i in range(100000):
result += 1 / (2*i + 1) * sign
sign *= -1
print("pi (estimate): ", result*4)আপনি ব্যবহার করতে পারেন indexএর listগুলি।
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"পেশাদাররা : কোনও অতিরিক্ত লাইব্রেরি, সেলফ এক্সপ্ল্যান্টরি কোড এবং যথেচ্ছ ডেটা ধরণের সাথে কাজ করে না।
কনস : ডুপ্লিকেট-সেভ নয়।
toggleValues(["one","two","duped", "three", "duped", "four"], "duped")
সর্বদা ফিরে আসবে"three"