পাইথনে আপনি দুটি ভেরিয়েবলের লজিকাল জোর পাবেন কীভাবে?

647

পাইথনে আপনি দুটি ভেরিয়েবলের লজিকাল জোর পাবেন কীভাবে ?

উদাহরণস্বরূপ, আমার কাছে দুটি পরিবর্তনশীল রয়েছে যা আমি স্ট্রিং হওয়ার আশা করি। আমি পরীক্ষা করতে চাই যে তাদের মধ্যে একটির মধ্যেই সত্যিকারের মান রয়েছে (কোনওটি নয় বা খালি স্ট্রিং নয়):

str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")
if logical_xor(str1, str2):
    print "ok"
else:
    print "bad"

^অপারেটর, bitwise মনে করা হয়, এবং সমস্ত বস্তুর উপর সংজ্ঞায়িত করা:

>>> 1 ^ 1
0
>>> 2 ^ 1
3
>>> "abc" ^ ""
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for ^: 'str' and 'str'
python  logical-operators 
— জাচ হিরশ
সূত্র
3
আপনি কয়েকটি স্ট্রিংয়ের জন্য "xor" কীভাবে সংজ্ঞায়িত করবেন? আপনি কি "abc" ^ "" এমনটি ফেরান যাবেন যা তা নয়?
— মেহরদাদ আফশারি
18
এটি একটি ব্যতিক্রম বাড়াতে না গিয়ে সত্যটি প্রত্যাবর্তন করা উচিত, যেহেতু সাধারণ পাইথনের বোলের ধরণের সংজ্ঞা অনুসারে কেবল একটি মাত্র স্ট্রিং সত্য।
— জাচ হিরশ
38
আমি অবাক হয়েছি যে পাইথনের "xor" নামে একটি ইনফিক্স অপারেটর নেই, এটি হবে সবচেয়ে স্বজ্ঞাত, পাইথোনিক বাস্তবায়ন। "^" ব্যবহার অন্যান্য ভাষার সাথে সামঞ্জস্যপূর্ণ, তবে বেশিরভাগ পাইথনের মতো স্পষ্টভাবে পাঠযোগ্য নয়।
— মার্ক ই। হাজেস
13
@ মেহরদাদআফশারি আপনার প্রশ্নের সুস্পষ্ট উত্তর a xor aহ'ল সংক্ষিপ্তসার হিসাবে সংজ্ঞা দেওয়া হয়েছে (a and not b) or (not a and b), এবং তাই a xor b, যখন aএবং bচরিত্রের স্ট্রিংগুলি বা অন্য কোনও ধরণের হয়, যা (a and not b) or (not a and b)ফলন দেয় should
— কাজ
1
বিষয়টি হ'ল ডকুমেন্টেশনগুলি দরিদ্র। "" বিটওয়াইজ এক্সক্লুসিভ বা ", যা আক্ষরিক অর্থে ব্যাখ্যার অর্থ কিছুটা হলেও, বুল দ্বারা বিল নয়। সুতরাং x'FFFF00 '^ x'FFFF00' হওয়া উচিত x'000000 '। বা এটি কেবল চর ভিত্তিতে কোনও চরে ঘটানো বোঝানো হয়েছে? সংখ্যা হিসাবে নিক্ষেপ? লম্বা স্ট্রিংয়ের দৈর্ঘ্যের সাথে মিল রাখতে আমাদের সংক্ষিপ্ত স্ট্রিং অক্ষরগুলি পুনরাবৃত্তি করতে হবে। সকল এই সালে নির্মিত হবে।
— mckenzm

উত্তর:

1187

আপনি যদি ইতিমধ্যে বুলিয়ানগুলিতে ইনপুটগুলিকে সাধারন করে থাকেন তবে = = xor।

bool(a) != bool(b)
— উঃ কোডি
সূত্র
148
যদিও এটি চালাক এবং সংক্ষিপ্ত, আমি নিশ্চিত না যে এটি পরিষ্কার। যখন কেউ কোডটিতে এই নির্মাণটি পড়েন, তখনই কি তাদের কাছে তাত্ক্ষণিকভাবে স্পষ্ট হয় যে এটি একটি জোর অপারেশন? আমি একটি মন্তব্য যুক্ত করতে বাধ্য বোধ করি - আমার জন্য একটি চিহ্ন যে আমি অস্পষ্ট কোড লিখছি এবং একটি মন্তব্যে ক্ষমা চাওয়ার চেষ্টা করব।
47
সম্ভবত "এটি কি এটি একটি এক্সওর স্পষ্ট?" ভুল প্রশ্ন। আমরা কেবল দুটি প্রশ্নের উত্তর একই কিনা তা দেখার চেষ্টা করছিলাম এবং ভেবেছিলাম আমরা এটি বাস্তবায়নের জন্য এক্সওআর ব্যবহার করব। উদাহরণস্বরূপ, আমরা যদি নিশ্চিত করতে চাই যে আমরা কমলাগুলির সাথে আপেলের তুলনা করছি না, তবে "যদি xor (isApple (x), isapple (y))" isapple (x)! = IsApple (y) "এর চেয়ে সত্যই পরিষ্কার হয়? আমার কাছে না!
— অ্যামিগনিকো
106
"! =" কে জোর হিসাবে ব্যবহার করতে সমস্যা আছে। আপনি সম্ভবত বুল (ক)! = বুল (বি)! = বুল (সি) বুল (ক) ool বুল (খ) ^ বুল (সি) এর সমান হওয়ার প্রত্যাশা করবেন। সুতরাং কুলকে বুল করুন, তবে আমি সুপারিশ করব ^ প্রথম উদাহরণে কী ঘটছে তা জানতে "অপারেটর চেইনিং" সন্ধান করুন।
— এলমো
19
@ ইলমো: পার্থক্যটি নির্দেশ করার জন্য +1 এবং অপারেটর চেইন কী তা আমাকে শেখানোর জন্য +1! আমি শিবিরে আছি যে বলছে যে! = Read এর মতো পঠনযোগ্য নয় ^
— মার্ক ই। হাজেস
13
এটি bool(a) is not bool(b)পরিবর্তে হওয়া উচিত ?
— আরএনএ
485

আপনি অন্যান্য যুক্তিসঙ্গত ক্রিয়াকলাপ থেকে এটির গণনা করতে সর্বদা জোরের সংজ্ঞাটি ব্যবহার করতে পারেন:

(a and not b) or (not a and b)

তবে এটি আমার কাছে কিছুটা ভারবস, এবং প্রথম নজরে বিশেষভাবে পরিষ্কার নয়। এটি করার আরেকটি উপায় হ'ল:

bool(a) ^ bool(b)

দুটি বুলিয়ান্সের জোর অপারেটরটি লজিকাল জোর (এটি অন্তর্নিহিত, ইন্টসের থেকে আলাদা নয়)। যা বোঝায়, যেহেতু boolএটি কেবল একটি সাবক্লাসint , তবে কেবলমাত্র মানগুলি 0এবং প্রয়োগ করার জন্য প্রয়োগ করা হয় 1। আর যৌক্তিক XOR, bitwise XOR সমতূল্য যখন ডোমেনে সীমাবদ্ধ হয় 0এবং 1।

সুতরাং logical_xorফাংশনটি যেমন বাস্তবায়িত হবে:

def logical_xor(str1, str2):
    return bool(str1) ^ bool(str2)

পাইথন -3000 মেলিং তালিকায় নিক কোঘলানকে ক্রেডিট ।

— জাচ হিরশ
সূত্র
7
দুর্দান্ত পোস্ট, তবে আপনার প্যারামিটারগুলির নাম দেওয়ার সমস্ত উপায়, কেন 'str1' এবং 'str2'?
— সিঙ্গেলাইজেশন এলোমিনেশন
1
@ টোকেন কেন নেই। আপনার অর্থ কি কারণ তারা খুব অজগর নয়?
— orokusaki
1
@ জাচ হিরশ আপনি কি পড়ার জন্য (খ এবং ক নয়) এর পরিবর্তে (ক এবং খ না) ব্যবহার করতে পারবেন বা সংজ্ঞাটি জোরের সাথে অসামঞ্জস্যপূর্ণ হবে?
— orokusaki
10
আপনার প্রথমে নোটগুলি এইভাবে রাখা উচিত (not b and a) or (not a and b)যাতে এটি উপস্থিত থাকলে স্ট্রিংটি ফিরে আসে যা ফাংশনটি পরিচালনা করার জন্য পাইথোনিকের মতো বলে মনে হয়।
— rjmunro
2
@ টোকেনম্যাকগুই: আপনি কীসের পরামর্শ দিচ্ছেন যে পরিবর্তে তাঁর নাম রাখা উচিত?
— ব্যবহারকারী541686
180

বিটওয়াইজ এক্সক্লুসিভ-বা ইতিমধ্যে পাইথনের অন্তর্নির্মিত, operatorমডিউলে (যা ^অপারেটরের সাথে অভিন্ন ):

from operator import xor
xor(bool(a), bool(b))  # Note: converting to bools is essential
— singingwolfboy
সূত্র
3
এই আমার প্রয়োজন ছিল। বিপরীত প্রকৌশল ম্যালওয়্যার যখন একটি এক্সওআর অপারেশন হওয়া পর্যন্ত প্রচুর বার স্ট্রিংগুলি ম্যাঙ্গেল করা হয়। এই সিআরটি ব্যবহার করে (এক্সওর (অর্ডার ("এন"), 0x1 এ)) = 'টি'
— ril3y
75
সতর্কতা অবলম্বন করুন, এটি কিছুটা দিক থেকেও: xor(1, 2)ফিরে আসে 3। ডক্টরসিং থেকে: xor(a, b) -- Same as a ^ b. মনে রাখবেন যে আমদানি করা যে কোনও কিছুই operatorবিদ্যমান বিল্টিন ইনফিক্স অপারেটরের কেবলমাত্র একটি কার্যকরী রূপ।
— জিজ্ঞাসা সেচ
5
@ এস্কেবাচান: বুলিয়ানগুলি ফেরত দেওয়ার জন্য boolটাইপ ওভারলোড __xor__। এটি ঠিক কাজ করবে, তবে যখন ওভারকিল bool(a) ^ bool(b)ঠিক একই জিনিসটি করে।
— মার্টিজন পিটারস
@ মার্তিজ্নপিটার্স ^অপারেটর __xor__অভ্যন্তরীণ কল করে।
— কোয়ান্টাম 7
5
@ কোয়ান্টাম:: হ্যাঁ, আপনি এখনও আমাকে কেন এটি বলছেন তা আমি নিশ্চিত নই। আমি কেবল বলেছি যে boolপ্রকারটি বিশেষত__xor__ পদ্ধতিটি প্রয়োগ করে কারণ ^এটি কল করে । পয়েন্টটি যে ভাল bool(a) ^ bool(b)কাজ করে, operator.xor()এখানে ফাংশনটি ব্যবহার করার দরকার নেই।
— মার্টিজন পিটারস
43

জাচ ব্যাখ্যা হিসাবে , আপনি ব্যবহার করতে পারেন:

xor = bool(a) ^ bool(b)

ব্যক্তিগতভাবে, আমি কিছুটা আলাদা উপভাষার পক্ষে:

xor = bool(a) + bool(b) == 1

এই ডায়ালিকটি স্কুলে লজিক্যাল ডায়াগ্রামিং ভাষা থেকে অনুপ্রাণিত হয়েছিল যেখানে "ওআর" একটি বাক্স দ্বারা চিহ্নিত হয়েছিল ≥1(1 এর চেয়ে বড় বা সমান) এবং "এক্সওআর" সমন্বিত একটি বাক্স দ্বারা চিহ্নিত করা হয়েছিল =1।

এটি একচেটিয়াভাবে বা একাধিক অপারেশনগুলিতে সঠিকভাবে প্রয়োগ করার সুবিধা রয়েছে।

  • "1 = a ^ b ^ c ..." এর অর্থ সত্যিকারের অপারেন্ডগুলির সংখ্যা বিজোড়। এই অপারেটরটি "সমতা"।
  • "1 = a + b + c ..." এর অর্থ হ'ল একটি অপরেন্ড সত্য। এটি "এক্সক্লুসিভ বা", যার অর্থ "একে অপরের বাদে"।
— ddaa
সূত্র
12
সুতরাং, সত্য + সত্য + মিথ্যা + সত্য == 3, এবং 3! = 1, তবে সত্য XOR সত্য XOR মিথ্যা XOR সত্য == সত্য। আপনি কি "একাধিক অপারেশনগুলিতে XOR সঠিকভাবে প্রয়োগ" এর বিস্তারিত বর্ণনা করতে পারেন?
— tzot
3
@tzot আপনার উদাহরণটি ব্যর্থ হয়েছে, কারণ ডিডিএ এর সমাধান অনুসারে আপনি একবারে দুটি মাত্র ভেরিয়েবলের উপর সংযোজনটি প্রয়োগ করেন। তাই সব লিখতে সঠিক উপায় হতে হবে (((((True + True)==1)+False)==1)+True)==1। এখানে দেওয়া উত্তর সম্পূর্ণরূপে একাধিক অপারেশনগুলিকে সাধারণীকরণ করে।
— ইলিশ
6
এছাড়াও, ত্রি-মুখী XOR বনাম-ক্রিয়াকলাপ-ক্রিয়াকলাপে দুটি এক্সওআর-এর গোষ্ঠীভুক্ত সেট মধ্যে পার্থক্য রয়েছে। সুতরাং 3-ওয়ে-এক্সর (এ, বি, সি) এক্সওআর (এক্সওআর (এ, বি), সি) এর মতো জিনিস নয় । এবং ডিডিএর উদাহরণটি পূর্ববর্তী, যদিও আপনার পরবর্তীটি ধরে নেওয়া হয়েছে।
— ইলিশ
3
@ মিঃ এফ। পাইথন, যদি আপনি শুধু না True + True + False + True, আপনি না পেতে 3, এবং True + True + False + True == 3ফিরিয়ে দেয় Trueযখন True + True + False + True == 1ফিরিয়ে দেয় False। অন্য কথায়, এখানে উত্তর সঠিকভাবে সাধারণীকরণ করে না; এটি করার জন্য, আপনাকে অতিরিক্ত কাজ করতে হবে। এদিকে True ^ True ^ False ^ Trueপ্রত্যাশা মতো একটি সাধারণ কাজ
— jpmc26
3
@ jpmc26 আমি আপনার মন্তব্য বুঝতে পারি না। সংযোজন পদ্ধতির বোঝাপড়াটি সেই ক্রিয়াকলাপটিকে সাধারণকরণের উদ্দেশ্যে যা আপনি যাচাই করতে চান ঠিক একটি অপারেন্ড True, একটি বহু-তাত্পর্য XOR। উদাহরণস্বরূপ, এর চেয়ে এটি আলাদা অপারেশন A XOR B XOR ... XOR Z। অন্য কথায়, যদি আপনি সংযোজন ভিত্তিক সংস্করণটি ব্যবহার করার পরিকল্পনা করেন তবে আপনার অপারেশনগুলি জমা দেওয়ার True + True + False + Trueপরে ফলাফলটি আশা করা উচিত Falseযেহেতু ফলাফলগুলির মধ্যে একটির বেশি রয়েছে True, যা শর্তটি পরীক্ষা করে যদি কাজ করে == 1।
— এলী
26
  • পাইথন যৌক্তিক or: A or B: আয় Aযদি bool(A)হয় True, অন্যথায় আয়B
  • পাইথন যৌক্তিক and: A and B: আয় Aযদি bool(A)হয় False, অন্যথায় আয়B

সেই ভাবনার বেশিরভাগ উপায় ধরে রাখার জন্য, আমার যৌক্তিক জোরের সংজ্ঞাটি হ'ল:

def logical_xor(a, b):
    if bool(a) == bool(b):
        return False
    else:
        return a or b

এই ভাবে এটি আসতে পারেন a, bঅথবা False:

>>> logical_xor('this', 'that')
False
>>> logical_xor('', '')
False
>>> logical_xor('this', '')
'this'
>>> logical_xor('', 'that')
'that'
— nosklo
সূত্র
5
এটি আমার কাছে খারাপ বা কমপক্ষে অদ্ভুত বলে মনে হচ্ছে। অন্য অন্তর্নির্মিত লজিকাল অপারেটরগুলির মধ্যে তিনটিই সম্ভাব্য তিনটি মানের একটিও ফেরত দেয় না।
— জাচ হিরশ
2
@ জাচ হির্শ: এ কারণেই আমি বলেছিলাম " বেশিরভাগ চিন্তাভাবনা চালিয়ে যেতে " - যেহেতু উভয়ই সত্য বা মিথ্যা যখন কোনও ভাল ফল হয় না
— nosklo
লজিকাল অপারেশনে অবশ্যই যৌক্তিক মানটি ফেরত দিতে হবে, সুতরাং দ্বিতীয় "রিটার্ন এ বা বি" অদ্ভুত দেখাচ্ছে, সুতরাং দ্বিতীয় রিটার্নটি অবশ্যই সত্যটি ফিরে আসতে হবে।
— ডেনিস বারমেনকভ
9
@ ডেনিস বারমেনকোভ: আচ্ছা, লক্ষ করুন যে অজগরটি লজিকাল অপারেটরগুলি andএবং orযৌক্তিক মান ফিরে আসবে না। 'foo' and 'bar'প্রত্যাবর্তন 'bar'...
— nosklo
6
প্রথম দর্শনে, পূর্ববর্তী 2 টি উত্তরগুলি সর্বোত্তম বলে মনে হয়, তবে দ্বিতীয় চিন্তায়, এই উত্তরটি আসলে একমাত্র সত্যিকারের সঠিক, অর্থাৎ এটি কেবলমাত্র এমন একটি যা xorবাস্তবায়নের উদাহরণ দেয় যা অন্তর্নির্মিত andএবং এর সাথে সামঞ্জস্যপূর্ণ or। তবে, অবশ্যই, ব্যবহারিক পরিস্থিতিতে bool(a) ^ bool(b)বা এমনকি a ^ b(যদি aএবং bএটি পরিচিত হয় bool) অবশ্যই আরও সংক্ষিপ্ত হয়।
— এরিক কাপলুন
23

আমি বেশ কয়েকটি পদ্ধতির পরীক্ষা করেছি এবং not a != (not b) দ্রুততম হিসাবে উপস্থিত ।

এখানে কিছু পরীক্ষা দেওয়া হল

%timeit not a != (not b)
10000000 loops, best of 3: 78.5 ns per loop

%timeit bool(a) != bool(b)
1000000 loops, best of 3: 343 ns per loop

%timeit not a ^ (not b)
10000000 loops, best of 3: 131 ns per loop

সম্পাদনা করুন: উপরে 1 এবং 3 টি উদাহরণের মধ্যে প্রথম বন্ধনী অনুপস্থিত তাই ফলাফলটি ভুল। truth()শ্যাডোর্যাঙ্গার প্রস্তাবিত হিসাবে নতুন ফলাফল + ফাংশন।

%timeit  (not a) ^  (not b)   # 47 ns
%timeit  (not a) != (not b)   # 44.7 ns
%timeit truth(a) != truth(b)  # 116 ns
%timeit  bool(a) != bool(b)   # 190 ns
— Rugnar
সূত্র
6
এটি আমার জীবনের 100 এনএস আমি ফিরে পাব না ;-)
— আরেল
4
একটি মধ্যবর্তী সময়সীমার জন্য, আপনি from operator import truthমডিউলটির শীর্ষে এবং পরীক্ষা করতে পারেন truth(a) != truth(b)। boolকনস্ট্রাক্টর হওয়ার কারণে সি স্তরে অনেকগুলি অপ্রয়োজনীয় ওভারহেড থাকে (এটি অবশ্যই যুক্তিগুলির সমতুল্য হিসাবে গ্রহণ করতে পারে *args, **kwargsএবং পার্স করতে হবে tupleএবং dictসেগুলি বের করতে হবে), যেখানে truth(একটি ক্রিয়াকলাপ) এমন একটি অনুকূলিত পথ ব্যবহার করতে পারে যার প্রয়োজন হয় না tupleএবং একটি dict, এবং boolভিত্তিক সমাধানের প্রায় অর্ধেক সময় চলে (তবে এখনও notভিত্তিক সমাধানের চেয়ে বেশি দীর্ঘ )।
— শেডোএ্যাঞ্জার
9

পুরষ্কার থ্রেড:

আনোডার ধারণা ... কেবলমাত্র আপনি চেষ্টা করতে পারেন (হতে পারে) অজানা এক্সপ্রেশন on তা নয় log লজিক্যাল «xor of এর আচরণ পেতে

সত্য সারণী হবে:

>>> True is not True
False
>>> True is not False
True
>>> False is not True
True
>>> False is not False
False
>>>

এবং আপনার উদাহরণ স্ট্রিং জন্য:

>>> "abc" is not  ""
True
>>> 'abc' is not 'abc' 
False
>>> 'abc' is not '' 
True
>>> '' is not 'abc' 
True
>>> '' is not '' 
False
>>>

যাহোক; যেমন তারা উপরের দিকে ইঙ্গিত করেছে, এটি যে কোনও স্ট্রিং সম্পর্কে আপনি আঁকতে চান এমন প্রকৃত আচরণের উপর নির্ভর করে, কারণ স্ট্রিংগুলি বুলিয়ান নয় ... এবং আরও অনেক কিছু: যদি আপনি Py পাইথনে প্রবেশ করুন »আপনি খুঁজে পাবেন« এর অদ্ভুত প্রকৃতি " এবং "এবং" বা " http://www.diveintopython.net/power_of_introspection/and_or.html

দুঃখিত, আমার লিখিত ইংরেজি, এটি আমার জন্মের ভাষা নয়।

শুভেচ্ছা।

— আগস্টিন মার্কোস
সূত্র
আমি এটি "কঠোরভাবে পৃথক" হিসাবে পড়তেও ব্যবহার করি। এর কারণ কিছু ভাষাগুলি বাইনারি উপস্থাপনের জন্য কিছুটা অপারেশন বিট বাস্তবায়ন করে এবং ফলাফলটি বিটওয়াইজ অপারেশনটির বুল নিতে। আমার ধারণা আপনার উত্তরটি আরও বেশি "টাইপ-বুলেটপ্রুফ" রয়েছে কারণ এটি বুলিয়ান স্থানের বাইরেও প্রসারিত।
— ইয়ুসার
আমি বলতে চাইছি যে আপনার উত্তরটি আলাদা নয়, মিথ্যা, '' কে তুলনা করার ক্ষেত্রে পৃথক জিনিস cover উদাহরণস্বরূপ: বুল (মিথ্যা)! = বুল ('') তবুও মিথ্যা নয় '' "এই"
— শব্দটি সম্পূর্ণ
8

পাইথন একটি bitwise একচেটিয়া-বা অপারেটর আছে, এটা ^:

>>> True ^ False
True
>>> True ^ True
False
>>> False ^ True
True
>>> False ^ False
False

আপনি জোওর ( ^) প্রয়োগ করার আগে ইনপুটগুলি বুলিয়ানগুলিতে রূপান্তর করে এটি ব্যবহার করতে পারেন :

bool(a) ^ bool(b)

(সম্পাদিত - ধন্যবাদ আরেল)

— টমর গাল
সূত্র
আপনার উত্তরটি পরিষ্কার করে দেওয়া উচিত যে ^এটি একটি বিটওয়াইজ জোর (প্রশ্ন জিজ্ঞাসার মতো লজিকাল জোর নয়) or bool(2) ^ bool(3)এর চেয়ে আলাদা উত্তর দেয় bool(2 ^ 3)।
— অ্যারেল
1
@ অ্যারেল কিন্তু ঘটনাটি নয়। a ^ bপলিমার্ফ হয়। যদি aএবং bহয় boolদৃষ্টান্ত, ফল কী হবে boolহিসাবে ভাল। এই আচরণকে খুব কমই "বিটওয়াইজ" জোর বলা যেতে পারে।
— Alfe
@Alfe গুরুত্বপূর্ণ পয়েন্টটি হ'ল মানগুলি প্রথমে বুলিয়ানদের কাছে দিতে হবে। পাইথন ডকুমেন্টেশন ^বিটওয়াইজ হিসাবে সংজ্ঞায়িত করে , যদিও এটি একটি আকর্ষণীয় বিন্দু যা প্রকারগুলি boolএবং intপ্রকারের জন্য সংরক্ষণ করা হয় । নোট: True ^ 2নয় 3প্রদর্শক কিভাবে এটা প্রকৃতপক্ষে, bitwise হয়।
— আরেল
@ অ্যারেল হ্যাঁ, কেসটি প্রথমে bool ^ intসবকিছু castালাইয়ের intমতো। এখনও, পাইথন বিল্ট-ইন করেছে ^অনেক বিট জন্য অপারেটর intএবং এক জন্য একটি প্রতিনিধিত্ব বিট bool, তাই উভয় , bitwise কিন্তু , bitwise একটি একক বিট জন্য XOR শুধু হয় লজিক্যাল Booleans জন্য XOR।
— আলফ
আমি এই অপারেটরটি ব্যবহার করা সর্বদা ঘৃণা করি, যদিও আমি বুঝতে পারি যে এটি xorইঞ্জিনিয়ারিং ব্যাকগ্রাউন্ড থেকে এসেছে, এটি আমার কাছে এই সহজাতভাবে গাণিতিক শক্তির মতো অনুভূত হয়, 2^3 = pow(2,3)যার অর্থ আমি বিভ্রান্তি রোধ করতে সর্বদা স্পষ্টভাবে মন্তব্য করি।
— নিকোলাস হ্যামিল্টন
8

যেহেতু আমি ভেরিয়েবল আর্গুমেন্ট ব্যবহার করে জোরের সহজ রূপটি দেখতে পাচ্ছি না এবং কেবল সত্যের মান বা ট্রুসের উপর ক্রিয়াকলাপ ব্যবহার করছি, আমি যেহেতু কারও ব্যবহারের জন্য এটি এখানে ফেলে দেব। এটি অন্যের দ্বারা উল্লিখিত, খুব সুন্দর (খুব বেশি বলা হবে না) সোজা।

def xor(*vars):
    sum = False
    for v in vars:
        sum = sum ^ bool(v)
    return sum

এবং ব্যবহার পাশাপাশি সোজা:

if xor(False, False, True, False):
    print "Hello World!"

যেহেতু এটি সাধারণীকরণ করা এনআরি লজিকাল এক্সওআর, ততই সত্যের মানটি সত্য হবে যখনই সত্য অপারেটরের সংখ্যা বিজোড় হয় (এবং ঠিক যখন এটি সত্য হয় না, এটি কেবলমাত্র একটি ক্ষেত্রে এন-অ্যারি এক্সওর সত্য হয়) True

সুতরাং আপনি যদি কোনও এন-অ্যারি প্রিকেক্টের সন্ধানে থাকেন যা ঠিক তখনই এর অপারেশনগুলির মধ্যে একটি হয় তবে আপনি ব্যবহার করতে পারেন:

def isOne(*vars):
    sum = False
    for v in vars:
        if sum and v:
            return False
        else:
            sum = sum or v
    return sum
— micdah
সূত্র
এই উত্তরটি উন্নতি জন্য: (bool(False) is False) == True। আপনি কেবল Falseসেই লাইনে ব্যবহার করতে পারেন ।
— পাঠানস্ট্রোম
7

এক্সক্লুসিভ বা নিম্নলিখিত হিসাবে সংজ্ঞায়িত করা হয়

def xor( a, b ):
    return (a or b) and not (a and b)
— S.Lott
সূত্র
2
এটি xor ('এই', '') এর জন্য সত্য ফিরে আসবে এবং অজগরটির পথ অনুসরণ করতে 'এটি' ফেরত আসবে।
— নসক্লো
@ ননসক্লো: বিডিএফএল নিয়ে যান, দয়া করে, আমাকে নয়। পাইথন যেহেতু সত্য প্রত্যাবর্তন করে, তাই এটি অবশ্যই পাইথনের পথ।
— এস .লট
2
আমি অন্যান্য পাইথন লজিকাল অপারেটরগুলির সাথে ধারাবাহিকতা বোঝাতে চাইছি - পাইথন সত্যটি ফিরে আসে না যখন আমি ('এটি' বা '') করি, এটি 'এই' ফেরত দেয়। তবে আপনার ফাংশনে xor ('এটি', '') সত্য দেয়। পাইথন বিল্টিনের মতো এটি 'এটি' ফিরিয়ে আনতে হবে।
— nosklo
10
পাইথন andএবং orশর্ট সার্কিট করুন। কোনও xorপ্রয়োগ শর্ট সার্কিট করতে পারে না, সুতরাং ইতিমধ্যে একটি তাত্পর্য রয়েছে; সুতরাং, এমন কোনও কারণ নেই যা + xorকরণের মতো পরিচালনা করা উচিত । andor
— tzot
7

কখনও কখনও আমি নিজেকে বুলিয়ান ট্রু এবং ভুয়া মানগুলির পরিবর্তে 1 এবং 0 দিয়ে কাজ করতে দেখি। এই ক্ষেত্রে xor হিসাবে সংজ্ঞায়িত করা যেতে পারে

z = (x + y) % 2

যা নিম্নলিখিত সত্য ছক আছে:

     x
   |0|1|
  -+-+-+
  0|0|1|
y -+-+-+
  1|1|0|
  -+-+-+
— স্টিভ এল
সূত্র
7

আমি জানি এটি দেরি হয়ে গেছে, তবে আমার একটি ধারণা ছিল এবং এটি কেবলমাত্র ডকুমেন্টেশনের জন্যই উপযুক্ত। সম্ভবত এটি কাজ করবে: np.abs(x-y)ধারণাটি এটি

  1. যদি x = সত্য = 1 এবং y = মিথ্যা = 0 হয় তবে ফলাফলটি হবে | 1-0 | = 1 = সত্য
  2. যদি x = মিথ্যা = 0 এবং y = মিথ্যা = 0 হয় তবে ফলাফলটি হবে 0 0-0 | = 0 = মিথ্যা
  3. যদি x = সত্য = 1 এবং y = সত্য = 1 হয় তবে ফলাফলটি হবে | 1-1 | = 0 = মিথ্যা
  4. যদি x = মিথ্যা = 0 এবং y = সত্য = 1 হয় তবে ফলাফলটি 0 0-1 | = 1 = সত্য
— BarocliniCplusplus
সূত্র
7

সহজ, বোঝা সহজ:

sum( (bool(a), bool(b) ) == 1

যদি একচেটিয়া পছন্দ আপনার পরে যা হয় তবে এটি একাধিক যুক্তিতে প্রসারিত হতে পারে:

sum( bool(x) for x in y ) % 2 == 1
— CZ
সূত্র
1
sum(map(bool, y)) % 2 == 1
— ওয়ারওয়ারিয়াক
6

এ কেমন?

(not b and a) or (not a and b)

দিবে aযদি bমিথ্যা হয়
তা দিবে bযদি aমিথ্যা হয়
তা দিবেFalse অন্যথায়

বা পাইথন 2.5+ ত্রৈমাসিক অভিব্যক্তি সহ:

(False if a else b) if b else a
— মার্কাস জারদারোট
সূত্র
6

এখানে প্রস্তাবিত কিছু বাস্তবায়ন কিছু ক্ষেত্রে অপারেটরগুলির বারবার মূল্যায়ন ঘটাবে, যার ফলে অনিচ্ছাকৃত পার্শ্ব প্রতিক্রিয়া হতে পারে এবং তাই এড়ানো উচিত।

এটি বলেছিল, এমন একটি xorবাস্তবায়ন যা ফেরত দেয় Trueবা Falseমোটামুটি সহজ; অপারেন্ডগুলির মধ্যে একটি ফেরত দেয়, যদি সম্ভব হয় তবে তা অনেক বেশি জটিল, কারণ কোন অপারেন্ডকে বেছে নেওয়া উচিত কোনটি নিয়ে whenক্যমত্য বিদ্যমান নেই, বিশেষত যখন দুটিরও বেশি অপারেন্ড থাকে। উদাহরণস্বরূপ, xor(None, -1, [], True)ফিরে আসা উচিত None, []বাFalse ? আমি বাজি দিয়েছি প্রতিটি উত্তর কিছু লোকের কাছে সবচেয়ে স্বজ্ঞাত হিসাবে উপস্থিত হয়।

সত্য- বা মিথ্যা-ফলাফলের জন্য, পাঁচটি হিসাবে আরও বেশি পছন্দ রয়েছে: প্রথম অপারেন্ডটি ফিরে আসুন (যদি এটি শেষের মানটির সাথে মেলে তবে অন্য বুলিয়ান), প্রথম ম্যাচটি ফিরে আসুন (যদি কমপক্ষে একটি উপস্থিত থাকে তবে অন্য বুলিয়ান), সর্বশেষ অপারেন্ডটি (যদি ... অন্যথায় ...) প্রত্যাবর্তন করুন, শেষ ম্যাচটি (যদি ... অন্যথায় ...) ফিরে আসুন, বা সর্বদা বুলিয়ান ফিরে আসুন। একসাথে, এটি 5 ** 2 = 25 স্বাদ xor।

def xor(*operands, falsechoice = -2, truechoice = -2):
  """A single-evaluation, multi-operand, full-choice xor implementation
  falsechoice, truechoice: 0 = always bool, +/-1 = first/last operand, +/-2 = first/last match"""
  if not operands:
    raise TypeError('at least one operand expected')
  choices = [falsechoice, truechoice]
  matches = {}
  result = False
  first = True
  value = choice = None
  # avoid using index or slice since operands may be an infinite iterator
  for operand in operands:
    # evaluate each operand once only so as to avoid unintended side effects
    value = bool(operand)
    # the actual xor operation
    result ^= value
    # choice for the current operand, which may or may not match end result
    choice = choices[value]
    # if choice is last match;
    # or last operand and the current operand, in case it is last, matches result;
    # or first operand and the current operand is indeed first;
    # or first match and there hasn't been a match so far
    if choice < -1 or (choice == -1 and value == result) or (choice == 1 and first) or (choice > 1 and value not in matches):
      # store the current operand
      matches[value] = operand
    # next operand will no longer be first
    first = False
  # if choice for result is last operand, but they mismatch
  if (choices[result] == -1) and (result != value):
    return result
  else:
    # return the stored matching operand, if existing, else result as bool
    return matches.get(result, result)

testcases = [
  (-1, None, True, {None: None}, [], 'a'),
  (None, -1, {None: None}, 'a', []),
  (None, -1, True, {None: None}, 'a', []),
  (-1, None, {None: None}, [], 'a')]
choices = {-2: 'last match', -1: 'last operand', 0: 'always bool', 1: 'first operand', 2: 'first match'}
for c in testcases:
  print(c)
  for f in sorted(choices.keys()):
    for t in sorted(choices.keys()):
      x = xor(*c, falsechoice = f, truechoice = t)
      print('f: %d (%s)\tt: %d (%s)\tx: %s' % (f, choices[f], t, choices[t], x))
  print()
5

আমার সহ অনেক লোকের xorএমন একটি ফাংশন প্রয়োজন যা একটি এন-ইনপুট এক্সওর সার্কিটের মতো আচরণ করে, যেখানে এন পরিবর্তনশীল। ( Https://en.wikedia.org/wiki/XOR_gate দেখুন )। নিম্নলিখিত সহজ ফাংশন এটি প্রয়োগ করে।

def xor(*args):
   """
   This function accepts an arbitrary number of input arguments, returning True
   if and only if bool() evaluates to True for an odd number of the input arguments.
   """

   return bool(sum(map(bool,args)) % 2)

নমুনা I / O অনুসরণ করে:

In [1]: xor(False, True)
Out[1]: True

In [2]: xor(True, True)
Out[2]: False

In [3]: xor(True, True, True)
Out[3]: True
— ফিলিপ এম ফিল্ডম্যান
সূত্র
5

পাইথনে দুই বা ততোধিক ভেরিয়েবলের লজিকাল জোর পেতে:

  1. ইনপুটগুলি বুলিয়ানগুলিতে রূপান্তর করুন
  2. বিটওয়াইজ এক্সওর অপারেটর ( ^বা operator.xor) ব্যবহার করুন

উদাহরণ স্বরূপ,

bool(a) ^ bool(b)

আপনি যখন ইনপুটগুলি বুলিয়ানগুলিতে রূপান্তর করেন, বিটওয়াইস জোর যৌক্তিক হয়ে যায় জোরে ।

নোট করুন যে গৃহীত উত্তরটি ভুল: != পাইথনের জোরের মতো নয়, এর সূক্ষ্মতার কারণে অপারেটর শৃঙ্খলার ।

উদাহরণস্বরূপ, নীচের তিনটি মানের জোওর ব্যবহার করার সময় ভুল != :

True ^  False ^  False  # True, as expected of XOR
True != False != False  # False! Equivalent to `(True != False) and (False != False)`

(পিএস আমি এই সতর্কতাটি অন্তর্ভুক্ত করার জন্য স্বীকৃত উত্তরটি সম্পাদনা করার চেষ্টা করেছি, তবে আমার পরিবর্তন প্রত্যাখ্যান করা হয়েছিল))

— Arel
সূত্র
4

XOR কী করে তা আপনি জানলে এটি সহজ:

def logical_xor(a, b):
    return (a and not b) or (not a and b)

test_data = [
  [False, False],
  [False, True],
  [True, False],
  [True, True],
]

for a, b in test_data:
    print '%r xor %s = %r' % (a, b, logical_xor(a, b))
— ডেনিস বারমেনকভ
সূত্র
4

এটি দুটি (বা আরও) ভেরিয়েবলের জন্য লজিক্যাল এক্সক্লুসিভ এক্সওআর পায়

str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")

any([str1, str2]) and not all([str1, str2])

এই সেটআপটির সাথে প্রথম সমস্যাটি হ'ল এটি সম্ভবত পুরো তালিকাটি দু'বার ঘুরে বেড়ায় এবং সর্বনিম্ন, কমপক্ষে একটি উপাদানকে দু'বার পরীক্ষা করে দেখবে। সুতরাং এটি কোডের বোধগম্যতা বাড়িয়ে তুলতে পারে, তবে এটি গতিতে ndণ দেয় না (যা আপনার ব্যবহারের ক্ষেত্রে নির্ভর করে অবহেলিতভাবে পৃথক হতে পারে)।

এই সেটআপটির সাথে দ্বিতীয় সমস্যাটি হ'ল এটি ভেরিয়েবলের সংখ্যা নির্বিশেষে ব্যাতিক্রমের জন্য পরীক্ষা করে। এটি প্রথমে কোনও বৈশিষ্ট্য হিসাবে বিবেচিত হতে পারে তবে ভেরিয়েবলের সংখ্যা বৃদ্ধি হওয়ার সাথে সাথে (যদি তারা কখনও করে তবে) প্রথম সমস্যাটি আরও অনেক তাত্পর্যপূর্ণ হয়ে ওঠে।

— আঙ্গুরের ছিরড়া
সূত্র
4

জোর ^পাইথনে আছে। এটি ফিরে আসে:

  • Ints জন্য একটি বিটওয়াইস জোর
  • বুলসের জন্য লজিকাল জোর
  • সেট জন্য একচেটিয়া ইউনিয়ন
  • প্রয়োগকারী ক্লাসগুলির জন্য ব্যবহারকারী-সংজ্ঞায়িত ফলাফল __xor__ ।
  • স্ট্রিংস বা ডিকশনারির মতো অপরিজ্ঞাত প্রকারের জন্য টাইপরর।

যদি আপনি যাইহোক স্ট্রিংগুলিতে এগুলি ব্যবহার করার উদ্দেশ্যে থাকেন তবে boolএগুলিতে ingালাই আপনার ক্রিয়াকলাপটিকে দ্ব্যর্থহীন করে তোলে (আপনি এটিও বোঝাতে পারেন set(str1) ^ set(str2))।

— আর্থার হাভলিসেক
সূত্র
3

এইভাবে আমি কোনও সত্যের ছকটি কোড করব। বিশেষত xor এর জন্য আমাদের রয়েছে:

| a | b  | xor   |             |
|---|----|-------|-------------|
| T | T  | F     |             |
| T | F  | T     | a and not b |
| F | T  | T     | not a and b |
| F | F  | F     |             |

কেবলমাত্র উত্তর কলামে টি মানগুলি দেখুন এবং সমস্ত আসল কেসকে যৌক্তিক বা দিয়ে একসাথে স্ট্রিং করুন। সুতরাং, 2 বা 3 ক্ষেত্রে এই সত্য সারণী তৈরি করা যেতে পারে তাই,

xor = lambda a, b: (a and not b) or (not a and b)
— snagpaul
সূত্র
-6

এর সাহায্যে আমরা দুটি ভেরিয়েবলের এক্সওর সহজেই খুঁজে পেতে পারি:

def xor(a,b):
    return a !=b

উদাহরণ:

xor (সত্য, মিথ্যা) >>> সত্য

— মুহাম্মদ আবদুল্লাহ
সূত্র
1
বা xor("hey", "there")>>> সত্য, তবে আমরা যা চাই তা তা নয়
— Mayou36
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.