and وor وnot في بايثون: المعاملات المنطقية والتقييم القصير

ثلاث كلمات بدلًا من الرموز

المعاملات المنطقية في بايثون هي الكلمات الإنجليزية and وor وnot. وتكتبها لغات أخرى بالرموز && و|| و!. في بايثون يسبب && و|| خطأ SyntaxError، ولا يظهر ! إلا كجزء من != ("لا يساوي").

has_ticket = True
is_adult = False

print(has_ticket and is_adult)   # False: both must be true
print(has_ticket or is_adult)    # True: at least one is true
print(not is_adult)              # True: flips the value

مع True وFalse تكون القواعد كما تتوقعها:

يحتاج and إلى أن يكون الطرفان صحيحين. ويحتاج or إلى طرف واحد على الأقل. أما not فيأخذ قيمة واحدة ويعكسها.

في الكود الحقيقي يكون الطرفان عادةً عمليتي مقارنة، وتذهب النتيجة إلى if أو while:

age = 34
country = "CA"

if age >= 18 and country in ("US", "CA"):
    print("eligible")

if age < 13 or age > 65:
    print("discounted ticket")
else:
    print("standard ticket")

المخرجات:

eligible
standard ticket

هذا القدر يكفي لمعظم الشروط. يتناول باقي هذه الصفحة ما تفعله المعاملات مع القيم التي ليست True أو False، والقواعد التي تحدد أي طرف من التعبير يُنفَّذ.

القيم truthy وfalsy

تقبل and وor وnot أي قيمة، وليس القيم المنطقية وحدها. تحدد بايثون ما إذا كانت القيمة تُعدّ صحيحة بحسب "صوابها" (truthiness). هذه القيم falsy، أي تُعامل على أنها خاطئة:

• False وNone
• الصفر من أي نوع عددي: 0 و0.0
• الحاويات والنصوص الفارغة: "" و[] و() و{} وset() وrange(0)

كل ما عدا ذلك truthy، أي يُعامل على أنه صحيح، بما في ذلك "0" و"False" و[0] و-1. يمكنك أن ترى كيف تصنّف بايثون قيمة ما باستخدام bool():

for value in [0, 1, -1, "", "0", [], [0], None, 0.0]:
    print(repr(value), bool(value))

المخرجات:

0 False
1 True
-1 True
'' False
'0' True
[] False
[0] True
None False
0.0 False

النص "0" قيمة truthy لأنه نص غير فارغ. وهذه النقطة توقع من يقرأ الأرقام من الإدخال ويختبرها قبل تحويلها. تشرح صفحة الأعداد والقيم المنطقية العلاقة بين bool وint.

and وor يُرجعان أحد الطرفين

هنا تختلف بايثون عن معظم اللغات. لا يُنتج and وor قيمة True أو False جديدة، بل يُرجعان إحدى القيمتين اللتين أعطيتهما:

• x or y تُرجع x إذا كانت x قيمة truthy، وإلا تُرجع y.
• x and y تُرجع x إذا كانت x قيمة falsy، وإلا تُرجع y.

print(0 or 5)            # 5
print(3 or 5)            # 3
print("" or "guest")     # guest
print([] or None)        # None

print(0 and 5)           # 0
print(3 and 5)           # 5
print("a" and "b")       # b
print(None and 1 / 0)    # None, and no ZeroDivisionError

عندما يكون الطرفان قيمتين منطقيتين، فإن "إرجاع أحد الطرفين" و"إرجاع قيمة منطقية" شيء واحد، ولهذا يمر الفرق دون أن يلاحظه أحد حتى تمزج أنواعًا أخرى.

not هو الاستثناء: يُرجع دائمًا True أو False.

print(not 0)        # True
print(not "hi")     # False
print(not [])       # True

إذا احتجت إلى قيمة منطقية حقيقية من تعبير and/or، مثلًا لتخزينها أو لإرجاعها من دالة تَعِد بإرجاع bool، فضعه داخل bool():

name = "Ada"
email = ""

print(name and email)         # prints an empty line: the value is ""
print(bool(name and email))   # False

التقييم القصير

تقيّم بايثون and وor من اليسار إلى اليمين، وتتوقف بمجرد أن تُعرف الإجابة:

• يتوقف and عند أول قيمة falsy، لأن لا شيء بعدها يمكن أن يجعل التعبير كله صحيحًا.
• يتوقف or عند أول قيمة truthy، لأن لا شيء بعدها يمكن أن يجعل التعبير كله خاطئًا.

الطرف المتخطّى لا يُنفَّذ إطلاقًا. يمكنك أن تشاهد ذلك يحدث باستخدام دوال تطبع شيئًا عند استدعائها:

def check(label, result):
    print(f"  checking {label}")
    return result

print("and:")
print(check("A", False) and check("B", True))

print("or:")
print(check("A", True) or check("B", False))

المخرجات:

and:
  checking A
False
or:
  checking A
True

لا يُفحص B في أي من الحالتين. التقييم القصير هو ما يجعل شروط الحماية آمنة. النصف الثاني من كل شرط أدناه سينهار لو نُفّذ وحده، لكنه لا يُنفَّذ إلا بعد أن يستبعد النصف الأول الحالة السيئة:

user = None
items = []

if user is not None and user.startswith("admin"):
    print("admin")
else:
    print("not an admin")

if items and items[0] > 10:
    print("first item is large")
else:
    print("no large first item")

ضع الاختبار الرخيص أو الحامي أولًا. أما عكس الترتيب، user.startswith("admin") and user is not None، فيطلق AttributeError عندما تكون user هي None.

أنماط مبنية على or وand

لأن or يُرجع أول طرف truthy، فهو يعطيك قيمة افتراضية في سطر واحد:

def greet(name):
    name = name or "guest"
    print(f"Hello, {name}!")

greet("Ada")
greet("")
greet(None)

المخرجات:

Hello, Ada!
Hello, guest!
Hello, guest!

المشكلة أن or يستبدل كل قيمة falsy، وليس None وحدها. فإذا كانت 0 أو "" أو [] مدخلًا مشروعًا، سيتخلص منه or:

volume = 0
print(volume or 50)                           # 50: the 0 was replaced

print(volume if volume is not None else 50)   # 0: only None is replaced

استخدم x if x is not None else default عندما يكون الصفر أو القيمة الفارغة قيمة صالحة. تشرح صفحة if/else هذا التعبير الشرطي.

ولـand نمط مقابل: "استخدم هذه القيمة فقط إذا كانت الأولى موجودة". وهو أقل شيوعًا، وغالبًا يكون أوضح إذا كُتب بـif، فاستخدمه باعتدال:

user = {"name": "Ada"}
print(user and user["name"])   # Ada

user = None
print(user and user["name"])   # None

الأولوية: not ثم and ثم or

عندما يمزج تعبير المعاملات الثلاثة، تطبّق بايثون not أولًا، ثم and، ثم or. وتُطبَّق المقارنات مثل == و< وin قبلها جميعًا.

a, b, c = True, False, False

print(a or b and c)      # True: read as a or (b and c)
print((a or b) and c)    # False
print(not a or b)        # False: read as (not a) or b
print(not (a or b))      # False
print(not 1 == 2)        # True: read as not (1 == 2)

a or b and c و(a or b) and c تعطيان إجابتين مختلفتين من القيم نفسها، لذا ينبغي أن يحمل الشرط المختلط أقواسًا حتى لو كان الترتيب الافتراضي صحيحًا بالصدفة. الأقواس لا تكلّف شيئًا، وتُعفي القارئ التالي من السؤال.

and/or مقابل &/|

يشبه & و| في الشكل and وor، وقد يعطيان الإجابة نفسها أحيانًا، لكنهما معاملان مختلفان.

• and وor يختبران صواب القيمة، ويطبّقان التقييم القصير، ويُرجعان أحد الطرفين.
• & و| معاملان على مستوى البت. مع الأعداد الصحيحة يدمجان بتات العددين. ومع المجموعات يعنيان التقاطع والاتحاد. ومع True وFalse يُرجعان قيمة منطقية. ولا يطبّقان التقييم القصير أبدًا: يُقيَّم الطرفان دائمًا.

print(6 and 3)   # 3: 6 is truthy, so and returns the second operand
print(6 & 3)     # 2: 110 & 011 = 010 in binary

print(6 or 3)    # 6
print(6 | 3)     # 7: 110 | 011 = 111

print({1, 2, 3} & {2, 3, 4})   # {2, 3}
print(True & False)             # False

ولمعاملات البت أيضًا أولوية أعلى من المقارنات، وهذا يحوّل شرطًا مكتوبًا بـ& إلى شيء مختلف تمامًا:

x, y = 5, 5

print(x > 1 and y > 1)     # True
print(x > 1 & y > 1)       # False: read as x > (1 & y) > 1
print((x > 1) & (y > 1))   # True, but the parentheses are required

1 & y هي 1 & 5، وتساوي 1، فيصبح السطر الأوسط السلسلة 5 > 1 > 1، و1 > 1 خاطئة. في كود بايثون العادي، استخدم and وor وnot في الشروط.

المكان الوحيد الذي تكون فيه & و| و~ صحيحة في الشروط هو NumPy وpandas. تحمل المصفوفة قيمًا كثيرة، فلا تملك قيمة صواب واحدة، ويطلق and الخطأ ValueError: The truth value of an array ... is ambiguous. تعيد المكتبتان تعريف & و| لتعملا عنصرًا بعنصر، ولهذا تبدو مرشّحات pandas بهذا الشكل df[(df.age > 18) & (df.country == "CA")]، مع أقواس حول كل مقارنة بسبب الأولوية المذكورة أعلاه.

any() وall(): and وor على قائمة كاملة

لدمج سلسلة كاملة من الشروط، استخدم الدالتين المدمجتين all() (أي and على كل العناصر) وany() (أي or على كل العناصر). وكلتاهما تطبّق التقييم القصير بالطريقة نفسها:

scores = [72, 88, 95, 61]

print(all(s >= 60 for s in scores))   # True: every score passed
print(any(s >= 90 for s in scores))   # True: at least one A
print(any(s < 50 for s in scores))    # False

print(all([]))   # True: nothing failed
print(any([]))   # False: nothing passed

على عكس and وor، تُرجع any() وall() دائمًا قيمة منطقية.

أخطاء شائعة

مقارنة متغير واحد بعدة قيم باستخدام or. هذا الشرط صحيح دائمًا:

color = "green"

if color == "red" or "blue":
    print("matched (wrong!)")

if color == "red" or color == "blue":
    print("matched")
else:
    print("no match")

if color in ("red", "blue"):
    print("matched")
else:
    print("no match")

تقرأ بايثون الشرط الأول على أنه (color == "red") or "blue". المقارنة تساوي False، فيُرجع or القيمة "blue"، وهي نص غير فارغ، أي قيمة truthy. كرر المقارنة في الطرفين، أو الأفضل أن تختبر العضوية باستخدام in.

كتابة && أو ||. كلاهما يسبب SyntaxError. استخدم and وor.

توقّع قيمة منطقية من and/or. x = a or b تخزّن a أو b نفسها. وهذا غالبًا ما تريده، لكن إذا كان يجب أن تُرجع الدالة True أو False، فحوّل النتيجة باستخدام bool().

الاعتماد على الأولوية في الشروط المختلطة. a or b and c تعبير صحيح ومعرّف جيدًا، لكن أضف الأقواس حتى لا يضطر أحد إلى تذكّر القاعدة.