Iată un mic exemplu de expresii booleene (nu trebuie să-l tastați):
a = 6
b = 7
c = 42
print(1, a == 6)
print(2, a == 7)
print(3, a == 6 and b == 7)
print(4, a == 7 and b == 7)
print(5, not a == 7 and b == 7)
print(6, a == 7 or b == 7)
print(7, a == 7 or b == 6)
print(8, not (a == 7 and b == 6))
print(9, not a == 7 and b == 6)
Cu ieșirea fiind:
1 True 2 False 3 True 4 False 5 True 6 True 7 False 8 True 9 False
Ce se întâmplă? Programul constă dintr-o mulțime de declarații print
cu aspect amuzant. Fiecare instrucțiune print
afișează un număr și o expresie. Numărul este pentru a ajuta la urmărirea declarației cu care am de-a face. Observați cum fiecare expresie ajunge să fie False
sau
. În Python,
TrueFalse
poate fi scris și ca 0 și True
ca 1.
Liniile:
print(1, a == 6)
print(2, a == 7)
tipărește un True
și, respectiv, un False
, așa cum se aștepta, deoarece primul este adevărat și al doilea este fals. A treia imprimare, print(3, a == 6 and b == 7)
, este puțin diferită. Operatorul and
înseamnă că dacă atât afirmația de dinainte, cât și afirmația de după sunt adevărate, atunci întreaga expresie este adevărată, în caz contrar, întreaga expresie este falsă. Următoarea linie, print(4, a ==
, arată cum, dacă o parte a unei expresii
7 and b == 7)and
este falsă, totul este fals. Comportamentul and
poate fi rezumat după cum urmează:
expresia | rezulat |
---|---|
true and true |
true |
true and false |
false |
false and true |
false |
false and false |
false |
Observați că, dacă prima expresie este falsă, Python nu verifică a doua expresie, deoarece știe că întreaga expresie este falsă. Încercați să rulați False and print("Hi")
și comparați acest lucru cu rularea
Termenul tehnic pentru aceasta este evaluarea scurtcircuitului
True and print("Hi").
Următoarea linie, print(5, not a == 7 and b == 7)
, folosește operatorul not
. not
doar dă opusul expresiei. (Expresia poate fi rescrisă ca print(5, a != 7 and b == 7)
). Iată tabelul:
expresia | rezultat |
---|---|
not true |
false |
not false |
true |
Următoarele două linii, print(6, a == 7 or b == 7)
și
, folosesc operatorul
print(7, a == 7 or b == 6)or
. Operatorul or
returnează adevărat dacă prima expresie este adevărată sau dacă a doua expresie este adevărată sau ambele sunt adevărate. Dacă niciuna nu este adevărată, returnează fals. Iată tabelul:
expresia | rezultat |
---|---|
true or true |
true |
true or false |
true |
false or true |
true |
false or false |
false |
Observați că, dacă prima expresie este adevărată, Python nu verifică a doua expresie, deoarece știe că întreaga expresie este adevărată. Acest lucru funcționează deoarece or
este adevărat dacă cel puțin jumătate din expresie este adevărată. Prima parte este adevărată, așa că a doua parte poate fi fie falsă, fie adevărată, dar întreaga expresie este încă adevărată.
Următoarele două rânduri, print(8, not (a == 7 and b == 6))
și print(9, not a == 7 and b == 6)
, arată că parantezele pot fi folosite pentru a grupa expresii și a forța o parte să fie evaluată mai întâi. Observați că parantezele au schimbat expresia de la fals la adevărat. Acest lucru s-a întâmplat deoarece parantezele au forțat ca not
să se aplice întregii expresii în loc de doar porțiunii a == 7
.
Iată un exemplu de utilizare a unei expresii booleene:
list = ["Life", "The Universe", "Everything", "Jack", "Jill", "Life", "Jill"]
# make a copy of the list. See the More on Lists chapter to explain what [:] means.
copy = list[:]
# sort the copy
copy.sort()
prev = copy[0]
del copy[0]
count = 0
# go through the list searching for a match
while count < len(copy) and copy[count] != prev:
prev = copy[count]
count = count + 1
# If a match was not found then count can't be < len
# since the while loop continues while count is < len
# and no match is found
if count < len(copy):
print("First Match:", prev)
Și iată ieșirea:
First Match: Jill
Acest program funcționează continuând să verifice potrivirea while
. Când oricare
count < len(copy) and copy[count] is not equal to prevcount
este mai mare decât ultimul index al copy
sau a fost găsită o potrivire, și nu mai este adevărat, bucla se termină. if
pur și simplu verifică pentru a se asigura că while
a ieșit deoarece a fost găsită o potrivire.
Celălalt „truc” al lui and
este folosit în acest exemplu. Dacă te uiți la tabel pentru and
observi că a treia intrare este „false and false”. Dacă count >= len(copy)
(cu alte cuvinte count <
este fals), atunci
len(copy)copy[count]
nu este niciodată analizat. Acest lucru se datorează faptului că Python știe că, dacă primul este fals, atunci nu pot fi amândouă adevărate. Acest lucru este cunoscut sub numele de scurtcircuit și este util dacă a doua jumătate a lui and
va provoca o eroare dacă ceva nu este în regulă. Am folosit prima expresie (count
) pentru a verifica și a vedea dacă
< len(copy)count
a fost un index valid pentru copy
. (Dacă nu mă credeți, eliminați potrivirile „Jill” și „Life”, verificați dacă încă funcționează și apoi inversați ordinea lui count < len(copy) and copy[count] != prev
to copy[count] != prev and count < len(copy)
.)
Expresiile booleene pot fi folosite atunci când trebuie să verificați două sau mai multe lucruri diferite simultan.
O notă despre operatorii booleeni
O greșeală obișnuită pentru începătorii în programare este o înțelegere greșită a modului în care funcționează operatorii booleeni, care provine din modul în care interpretorul Python citește aceste expresii. De exemplu, după ce a învățat inițial despre declarațiile „and” și „or”, ar putea presupune că expresia x == ('a' or 'b')
ar verifica pentru a vedea dacă variabila x
a fost echivalentă cu unul dintre șirurile de caractere 'a'
sau 'b'
. Nu este așa. Pentru a vedea despre ce vorbesc, începeți o sesiune interactivă cu interpretorul și introduceți următoarele expresii:
>>> 'a' == ('a' or 'b') >>> 'b' == ('a' or 'b') >>> 'a' == ('a' and 'b') >>> 'b' == ('a' and 'b')
Și acesta va fi rezultatul neintuitiv:
>>> 'a' == ('a' or 'b') True >>> 'b' == ('a' or 'b') False >>> 'a' == ('a' and 'b') False >>> 'b' == ('a' and 'b') True
În acest moment, operatorii and
și or
par să fie defectați. Nu are sens ca, pentru primele două expresii, 'a'
este echivalent cu 'a'
sau 'b'
, în timp ce 'b'
nu este. În plus, nu are niciun sens ca 'b'
să fie echivalent cu 'a'
și 'b'
. După ce ați examinat ce face interpretorul cu operatorii booleeni, aceste rezultate fac de fapt exact ceea ce le cereți, pur și simplu nu este același lucru cu ceea ce credeți că le cereți.
Când interpretorul Python se uită la o expresie or
, ia prima declarație și verifică dacă este adevărată. Dacă prima declarație este adevărată, atunci Python returnează valoarea acelui obiect fără a verifica a doua declarație. Acest lucru se datorează faptului că pentru o expresie or
, totul este adevărat dacă una dintre valori este adevărată; programul nu trebuie să se deranjeze cu a doua afirmație. Pe de altă parte, dacă prima valoare este evaluată ca fiind falsă, Python verifică și a doua valoare și returnează acea valoare. Acea a doua valoare determină valoarea de adevăr a întregii expresii, deoarece prima valoare a fost falsă. Această „lene” din partea interpretorului se numește „scurtcircuit” și este o modalitate comună de evaluare a expresiilor booleene în multe limbaje de programare.
În mod similar, pentru o expresie and
, Python utilizează o tehnică de scurtcircuit pentru a accelera evaluarea valorii de adevăr. Dacă prima afirmație este falsă, atunci totul trebuie să fie fals, deci returnează acea valoare. În caz contrar, dacă prima valoare este adevărată, o verifică pe a doua și returnează acea valoare.
Un lucru de remarcat în acest moment este că expresia booleană returnează o valoare care indică True
sau False
, dar că Python consideră că un număr de lucruri diferite au o valoare de adevăr atribuită acestora. Pentru a verifica valoarea de adevăr a oricărui obiect dat x
, puteți utiliza funcția bool(x)
pentru a vedea valoarea de adevăr. Mai jos este un tabel cu exemple de valori de adevăr ale diferitelor obiecte:
True | False |
---|---|
True | False |
1 | 0 |
Numere altele decât zero | Șirul ‘None’ |
Șiruri negoale | Șiruri goale |
Liste negoale | Liste goale |
Dicționare negoale | Dicționare goale |
Acum este posibil să înțelegem rezultatele surprinzătoare pe care le obțineam când am testat acele expresii booleene înainte. Să aruncăm o privire la ce „vede” interpretorul în timp ce parcurge acel cod:
Primul caz:
>>> 'a' == ('a' or 'b') # Look at parentheses first, so evaluate expression "('a' or 'b')" # 'a' is a nonempty string, so the first value is True # Return that first value: 'a' >>> 'a' == 'a' # the string 'a' is equivalent to the string 'a', so expression is True True
Al foilea caz:
>>> 'b' == ('a' or 'b') # Look at parentheses first, so evaluate expression "('a' or 'b')" # 'a' is a nonempty string, so the first value is True # Return that first value: 'a' >>> 'b' == 'a' # the string 'b' is not equivalent to the string 'a', so expression is False False
Al treilea caz:
>>> 'a' == ('a' and 'b') # Look at parentheses first, so evaluate expression "('a' and 'b')" # 'a' is a nonempty string, so the first value is True, examine second value # 'b' is a nonempty string, so second value is True # Return that second value as result of whole expression: 'b' >>> 'a' == 'b' # the string 'a' is not equivalent to the string 'b', so expression is False False
Al patrulea caz:
>>> 'b' == ('a' and 'b') # Look at parentheses first, so evaluate expression "('a' and 'b')" # 'a' is a nonempty string, so the first value is True, examine second value # 'b' is a nonempty string, so second value is True # Return that second value as result of whole expression: 'b' >>> 'b' == 'b' # the string 'b' is equivalent to the string 'b', so expression is True True
Deci, Python își făcea cu adevărat treaba când a dat acele rezultate aparent false. După cum am menționat anterior, lucrul important este să recunoașteți ce valoare va returna expresia dvs. booleană atunci când este evaluată, deoarece nu este întotdeauna evidentă.
Revenind la acele expresii inițiale, iată cum le-ați scrie astfel încât să se comporte așa cum doriți:
>>> 'a' == 'a' or 'a' == 'b' True >>> 'b' == 'a' or 'b' == 'b' True >>> 'a' == 'a' and 'a' == 'b' False >>> 'b' == 'a' and 'b' == 'b' False
Când aceste comparații sunt evaluate, ele returnează valori de adevăr în termeni de Adevărat sau Fals, nu șiruri, astfel încât obținem rezultatele potrivite.
Exemple
password1.py
## Acest program cere unui utilizator un nume și o parolă.
# Apoi le verifică pentru a se asigura că utilizatorul are voie să intre.
name = input("What is your name? ")
password = input("What is the password? ")
if name == "Josh" and password == "Friday":
print("Welcome Josh")
elif name == "Fred" and password == "Rock":
print("Welcome Fred")
else:
print("I don't know you.")
Exemple de rulări
What is your name? Josh What is the password? Friday Welcome Josh
What is your name? Bill What is the password? Money I don't know you.
Exerciții
Scrieți un program în care un utilizator să vă ghicească numele, dar are doar 3 șanse să facă acest lucru până când programul se închide.
(Include texte din Wikibooks traduse și adaptate de Nicolae Sfetcu)
Lasă un răspuns