শর্তসাপেক্ষে আমি একটি ত্রুটি পাচ্ছি। আমি কি ভুল করছি?
আপনি যেটি পেয়েছেন তার কারণ পাইথনে SyntaxErrorকোনও &&অপারেটর নেই । অনুরূপভাবে ||এবং !হয় বৈধ নয় পাইথন অপারেটর।
আপনি অন্যান্য ভাষাগুলি থেকে জানতে পারেন এমন কিছু অপারেটরের পাইথনের আলাদা নাম রয়েছে। লজিকাল অপারেটর &&এবং ||প্রকৃতপক্ষে বলা হয় andএবং or। তেমনি লজিকাল নেগেশন অপারেটর !বলা হয় not।
সুতরাং আপনি শুধু লিখতে পারে:
if len(a) % 2 == 0 and len(b) % 2 == 0:
অথবা এমনকি:
if not (len(a) % 2 or len(b) % 2):
কিছু অতিরিক্ত তথ্য (এটি কার্যকর হতে পারে):
আমি এই টেবিলটিতে অপারেটর "সমতুল্য" সংক্ষেপিত করেছি:
+------------------------------+---------------------+
| Operator (other languages) | Operator (Python) |
+==============================+=====================+
| && | and |
+------------------------------+---------------------+
| || | or |
+------------------------------+---------------------+
| ! | not |
+------------------------------+---------------------+
আরও দেখুন পাইথন ডকুমেন্টেশন: 6.11। বুলিয়ান অপারেশন ।
লজিকাল অপারেটর ছাড়াও পাইথনের বিটওয়াইজ / বাইনারি অপারেটর রয়েছে:
+--------------------+--------------------+
| Logical operator | Bitwise operator |
+====================+====================+
| and | & |
+--------------------+--------------------+
| or | | |
+--------------------+--------------------+
পাইথনে কোনও বিটওয়াইজ অবহেলা নেই (কেবল বিটওয়াস ইনভার্স অপারেটর ~- তবে এটি সমান নয়not )।
6.6 দেখুন । অ্যানারি গণিত এবং বিটওয়াইজ / বাইনারি অপারেশন এবং 7.7। বাইনারি গাণিতিক অপারেশন ।
লজিকাল অপারেটরগুলির (অন্যান্য অনেক ভাষায়) এর সুবিধা রয়েছে যে এগুলি সংক্ষিপ্ত প্রচারিত। এর অর্থ যদি প্রথম অপারেন্ড ইতিমধ্যে ফলাফলটি সংজ্ঞায়িত করে, তবে দ্বিতীয় অপারেটরটি মোটেও মূল্যায়ন করা হয় না।
এটি দেখানোর জন্য আমি এমন একটি ফাংশন ব্যবহার করি যা কেবল একটি মান নেয়, এটি মুদ্রণ করে এবং এটি আবার প্রদান করে। মুদ্রণ বিবৃতিগুলির কারণে বাস্তবে যা মূল্যায়ন করা হয় তা দেখার সুবিধাজনক:
>>> def print_and_return(value):
... print(value)
... return value
>>> res = print_and_return(False) and print_and_return(True)
False
আপনি দেখতে পাচ্ছেন যে কেবলমাত্র একটি মুদ্রণ বিবৃতি কার্যকর করা হয়েছে, তাই পাইথন সত্যিকার অর্থে সঠিক অপারেণ্ডের দিকেও তাকাননি।
বাইনারি অপারেটরদের ক্ষেত্রে এটি হয় না। যারা সর্বদা উভয় অপারেশনকে মূল্যায়ন করে:
>>> res = print_and_return(False) & print_and_return(True);
False
True
তবে যদি প্রথম অপারেন্ডটি পর্যাপ্ত না হয় তবে অবশ্যই দ্বিতীয় অপারেটরটি মূল্যায়ন করা হয়:
>>> res = print_and_return(True) and print_and_return(False);
True
False
এটি সংক্ষেপে এখানে অন্য সারণি:
+-----------------+-------------------------+
| Expression | Right side evaluated? |
+=================+=========================+
| `True` and ... | Yes |
+-----------------+-------------------------+
| `False` and ... | No |
+-----------------+-------------------------+
| `True` or ... | No |
+-----------------+-------------------------+
| `False` or ... | Yes |
+-----------------+-------------------------+
Trueএবং Falseপ্রতিনিধিত্ব কি bool(left-hand-side), তারা হতে হবে না আয় Trueবা Falseতারা শুধু ফিরে করতে হবে, Trueঅথবা Falseযখন boolতাদের (1) তে বলা হয়।
সুতরাং সিউডো কোডে (!) এ andএবং orফাংশনগুলি এগুলির মতো কাজ করে:
def and(expr1, expr2):
left = evaluate(expr1)
if bool(left):
return evaluate(expr2)
else:
return left
def or(expr1, expr2):
left = evaluate(expr1)
if bool(left):
return left
else:
return evaluate(expr2)
দ্রষ্টব্য যে এটি সিউডো কোড নয় পাইথন কোড। পাইথন আপনি ফাংশন বলা তৈরি করতে পারবেন না andবা orকারণ এই কীওয়ার্ড আছে। এছাড়াও আপনার কখনই "মূল্যায়ন" বা ব্যবহার করা উচিত নয় if bool(...)।
আপনার নিজের ক্লাসের আচরণ কাস্টমাইজ করা
এই অন্তর্নিহিত boolকল কাস্টমাইজ কিভাবে আপনার ক্লাস সঙ্গে আচরণ ব্যবহার করা যেতে পারে and, orএবং not।
এটি কীভাবে কাস্টমাইজ করা যায় তা দেখানোর জন্য আমি এই ক্লাসটি ব্যবহার করছি যা আবার printঘটছে তা ট্র্যাক করার জন্য কিছু:
class Test(object):
def __init__(self, value):
self.value = value
def __bool__(self):
print('__bool__ called on {!r}'.format(self))
return bool(self.value)
__nonzero__ = __bool__ # Python 2 compatibility
def __repr__(self):
return "{self.__class__.__name__}({self.value})".format(self=self)
সুতরাং আসুন দেখুন এই অপারেটরের সাথে সম্মিলন করে সেই শ্রেণীর সাথে কী ঘটে:
>>> if Test(True) and Test(False):
... pass
__bool__ called on Test(True)
__bool__ called on Test(False)
>>> if Test(False) or Test(False):
... pass
__bool__ called on Test(False)
__bool__ called on Test(False)
>>> if not Test(True):
... pass
__bool__ called on Test(True)
যদি আপনার কোনও __bool__পদ্ধতি না থাকে তবে পাইথন এটিও পরীক্ষা করে দেখায় যে কোনও বস্তুর কোনও __len__পদ্ধতি আছে এবং যদি এটি শূন্যের চেয়ে বেশি মান দেয়। আপনি সিকোয়েন্স পাত্রে তৈরি করার ক্ষেত্রে এটি জেনে রাখা কার্যকর হতে পারে।
এছাড়াও দেখুন 4.1। সত্য মান পরীক্ষা ।
NumPy অ্যারে এবং সাবক্লাস
সম্ভবত আসল প্রশ্নের ক্ষেত্রের বাইরে কিছুটা হলেও আপনি যদি NumPy অ্যারে বা সাবক্লাস (যেমন পান্ডা সিরিজ বা ডেটা ফ্রেমস) এর সাথে কাজ করছেন তবে অন্তর্নিহিত boolকলটি ভয়ঙ্কর উত্থাপন করবে ValueError:
>>> import numpy as np
>>> arr = np.array([1,2,3])
>>> bool(arr)
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
>>> arr and arr
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
>>> import pandas as pd
>>> s = pd.Series([1,2,3])
>>> bool(s)
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
>>> s and s
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
এই ক্ষেত্রে আপনি NumPy থেকে যৌক্তিক এবং ফাংশনটি ব্যবহার করতে পারেন যা একটি উপাদান-ভিত্তিক and(বা or) সম্পাদন করে :
>>> np.logical_and(np.array([False,False,True,True]), np.array([True, False, True, False]))
array([False, False, True, False])
>>> np.logical_or(np.array([False,False,True,True]), np.array([True, False, True, False]))
array([ True, False, True, True])
আপনি যদি কেবল বুলিয়ান অ্যারে ব্যবহার করে থাকেন তবে আপনি বাইনারি অপারেটরগুলিও নুমপাইয়ের সাহায্যে ব্যবহার করতে পারেন, এগুলি উপাদান-ভিত্তিক (তবে বাইনারি) তুলনাও করে:
>>> np.array([False,False,True,True]) & np.array([True, False, True, False])
array([False, False, True, False])
>>> np.array([False,False,True,True]) | np.array([True, False, True, False])
array([ True, False, True, True])
(1)
যে booloperands এই কল আসতে হয়েছে Trueবা Falseসম্পূর্ণরূপে সঠিক নয়। এটি কেবল প্রথম অপারেন্ড যার __bool__পদ্ধতিতে একটি বুলিয়ান ফিরিয়ে আনতে হবে :
class Test(object):
def __init__(self, value):
self.value = value
def __bool__(self):
return self.value
__nonzero__ = __bool__ # Python 2 compatibility
def __repr__(self):
return "{self.__class__.__name__}({self.value})".format(self=self)
>>> x = Test(10) and Test(10)
TypeError: __bool__ should return bool, returned int
>>> x1 = Test(True) and Test(10)
>>> x2 = Test(False) and Test(10)
কারণ andপ্রথম অপারেন্ডটি যদি প্রথম অপারেন্ডকে মূল্যায়ন করে Falseএবং যদি এটি মূল্যায়ন করে Trueতবে এটি দ্বিতীয় অপারেন্ডকে ফেরত দেয়:
>>> x1
Test(10)
>>> x2
Test(False)
একইভাবে orতবে চারপাশে কেবল অন্যভাবে:
>>> Test(True) or Test(10)
Test(True)
>>> Test(False) or Test(10)
Test(10)
তবে আপনি যদি কোনও ifবিবৃতিতে এগুলি ব্যবহার করেন তবে ifফলাফলটিও স্পষ্টতই কল করবে bool। সুতরাং এই সূক্ষ্ম পয়েন্টগুলি আপনার পক্ষে প্রাসঙ্গিক নাও হতে পারে।