and, or, not w Pythonie: operatory logiczne, skracanie i truthiness

Trzy słowa zamiast symboli

Operatory logiczne w Pythonie to angielskie słowa and, or i not. Inne języki zapisują je jako &&, || i !. W Pythonie && i || dają SyntaxError, a ! pojawia się tylko jako część != ("różne od").

has_ticket = True
is_adult = False

print(has_ticket and is_adult)   # False: obie strony muszą być prawdziwe
print(has_ticket or is_adult)    # True: przynajmniej jedna jest prawdziwa
print(not is_adult)              # True: odwraca wartość

Dla True i False reguły są takie, jakich się spodziewasz:

and wymaga, żeby obie strony były prawdziwe. or wymaga przynajmniej jednej. not przyjmuje jedną wartość i ją odwraca.

W prawdziwym kodzie po obu stronach stoją zwykle porównania, a wynik trafia do if albo 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")

Wynik:

eligible
standard ticket

Tyle wystarczy do większości warunków. Reszta tej strony opisuje, co operatory robią z wartościami innymi niż True i False, oraz reguły, które decydują, która strona wyrażenia zostanie wykonana.

Wartości truthy i falsy

and, or i not przyjmują dowolne wartości, nie tylko logiczne. Python decyduje, czy wartość liczy się jako prawda, na podstawie jej truthiness. Te wartości są falsy:

• False i None
• zero dowolnego typu liczbowego: 0, 0.0
• puste kontenery i napisy: "", [], (), {}, set(), range(0)

Wszystko inne jest truthy, także "0", "False", [0] i -1. To, jak Python klasyfikuje wartość, sprawdzisz przez bool():

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

Wynik:

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

Napis "0" jest truthy, bo to niepusty napis. To łapie osoby, które wczytują liczby z wejścia i sprawdzają je przed konwersją. Strona o liczbach i wartościach logicznych wyjaśnia, jak bool ma się do int.

and i or zwracają operand

Tu Python różni się od większości języków. and i or nie tworzą nowego True ani False. Zwracają jedną z dwóch wartości, które im przekazujesz:

• x or y zwraca x, jeśli x jest truthy, a w przeciwnym razie zwraca y.
• x and y zwraca x, jeśli x jest falsy, a w przeciwnym razie zwraca 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, bez ZeroDivisionError

Gdy oba operandy są wartościami logicznymi, "zwróć operand" i "zwróć wartość logiczną" to to samo. Dlatego różnica pozostaje niezauważona, dopóki nie wmieszasz innych typów.

Wyjątkiem jest not: zawsze zwraca True albo False.

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

Jeśli potrzebujesz prawdziwej wartości logicznej z wyrażenia and/or, na przykład żeby ją zapisać albo zwrócić z funkcji, która obiecuje bool, opakuj je w bool():

name = "Ada"
email = ""

print(name and email)         # wypisuje pustą linię: wartość to ""
print(bool(name and email))   # False

Obliczanie skrócone (short-circuit)

Python oblicza and i or od lewej do prawej i zatrzymuje się, gdy tylko odpowiedź jest znana:

• and zatrzymuje się na pierwszej wartości falsy, bo nic dalej nie sprawi, że całe wyrażenie będzie prawdziwe.
• or zatrzymuje się na pierwszej wartości truthy, bo nic dalej nie sprawi, że całe wyrażenie będzie fałszywe.

Pominięta strona w ogóle się nie wykonuje. Zobaczysz to na funkcjach, które wypisują komunikat przy wywołaniu:

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))

Wynik:

and:
  checking A
False
or:
  checking A
True

W żadnym z przypadków B nie jest sprawdzane. Dzięki obliczaniu skróconemu warunki ochronne są bezpieczne. Druga połowa każdego warunku poniżej sama by się wysypała, ale uruchamia się dopiero wtedy, gdy pierwsza połowa wykluczy zły przypadek:

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")

Tani albo ochronny test stawiaj na początku. Odwrócona kolejność, user.startswith("admin") and user is not None, zgłasza AttributeError, gdy user to None.

Wzorce oparte na or i and

Ponieważ or zwraca swój pierwszy operand truthy, daje jednolinijkową wartość domyślną:

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

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

Wynik:

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

Haczyk polega na tym, że or zastępuje każdą wartość falsy, a nie tylko None. Jeśli 0, "" albo [] to poprawne dane wejściowe, or je wyrzuci:

volume = 0
print(volume or 50)                           # 50: 0 zostało zastąpione

print(volume if volume is not None else 50)   # 0: zastępowane jest tylko None

Używaj x if x is not None else default, gdy zero albo pusta wartość jest poprawna. To wyrażenie warunkowe opisuje strona o if/else.

and ma odpowiadający wzorzec: "użyj tej wartości tylko wtedy, gdy pierwsza jest ustawiona". Jest rzadszy i często czytelniej wygląda jako if, więc sięgaj po niego oszczędnie:

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

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

Priorytety: najpierw not, potem and, potem or

Gdy wyrażenie łączy wszystkie trzy, Python stosuje najpierw not, potem and, a na końcu or. Porównania, takie jak ==, < i in, są stosowane przed każdym z nich.

a, b, c = True, False, False

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

a or b and c i (a or b) and c dają różne odpowiedzi dla tych samych wartości, więc mieszany warunek powinien mieć nawiasy, nawet gdy domyślna kolejność akurat jest właściwa. Nic nie kosztują, a następna osoba czytająca kod nie musi się zastanawiać.

and/or kontra &/|

& i | wyglądają podobnie do and i or i czasem dają tę samą odpowiedź, ale to różne operatory.

• and / or sprawdzają truthiness, obliczają się w sposób skrócony i zwracają jeden z operandów.
• & / | to operatory bitowe. Na liczbach całkowitych łączą bity obu liczb. Na zbiorach oznaczają część wspólną i sumę. Na True i False zwracają wartość logiczną. Nigdy nie skracają obliczeń: obie strony są zawsze obliczane.

print(6 and 3)   # 3: 6 jest truthy, więc and zwraca drugi operand
print(6 & 3)     # 2: 110 & 011 = 010 binarnie

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

Operatory bitowe mają też wyższy priorytet niż porównania, przez co warunek zapisany z & staje się czymś zupełnie innym:

x, y = 5, 5

print(x > 1 and y > 1)     # True
print(x > 1 & y > 1)       # False: czytane jako x > (1 & y) > 1
print((x > 1) & (y > 1))   # True, ale nawiasy są obowiązkowe

1 & y to 1 & 5, czyli 1, więc środkowa linia staje się łańcuchem 5 > 1 > 1, a 1 > 1 jest fałszem. W zwykłym kodzie Pythona do warunków używaj and, or i not.

Jedyne miejsce, gdzie &, | i ~ są właściwe w warunkach, to NumPy i pandas. Tablica przechowuje wiele wartości, więc nie ma jednej wartości logicznej, a and zgłasza ValueError: The truth value of an array ... is ambiguous. Biblioteki przeciążają & i |, żeby działały element po elemencie. Dlatego filtry w pandas wyglądają jak df[(df.age > 18) & (df.country == "CA")], z nawiasami wokół każdego porównania z powodu opisanych wyżej priorytetów.

any() i all(): and i or dla całej listy

Żeby połączyć całą sekwencję warunków, użyj wbudowanych funkcji all() (and dla wszystkich elementów) i any() (or dla wszystkich elementów). Obie skracają obliczenia w ten sam sposób:

scores = [72, 88, 95, 61]

print(all(s >= 60 for s in scores))   # True: każdy wynik zaliczony
print(any(s >= 90 for s in scores))   # True: przynajmniej jedna piątka
print(any(s < 50 for s in scores))    # False

print(all([]))   # True: nic nie oblało
print(any([]))   # False: nic nie zaliczyło

W przeciwieństwie do and i or, any() i all() zawsze zwracają wartość logiczną.

Częste błędy

Porównywanie jednej zmiennej z kilkoma wartościami przez or. Ten warunek jest zawsze prawdziwy:

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")

Python czyta pierwszy warunek jako (color == "red") or "blue". Porównanie daje False, więc or zwraca "blue", czyli niepusty napis, który jest truthy. Powtórz porównanie po obu stronach albo, jeszcze lepiej, sprawdź przynależność przez in.

Pisanie && albo ||. Oba dają SyntaxError. Używaj and i or.

Oczekiwanie wartości logicznej od and/or. x = a or b zapisuje samo a albo b. Często właśnie o to chodzi, ale jeśli funkcja ma zwrócić True albo False, zamień wynik przez bool().

Poleganie na priorytetach w mieszanych warunkach. a or b and c jest poprawne i dobrze zdefiniowane, ale dodaj nawiasy, żeby nikt nie musiał pamiętać reguły.