Als ik dit doe:
>>> False in [False, True]
True
Dat levert True
op. Simpelweg omdat False
in de lijst staat.
Maar als ik dat doe:
>>> not(True) in [False, True]
False
Dat levert False
op. Terwijl not(True)
gelijk is aan False
:
>>> not(True)
False
Waarom?
Antwoord 1, autoriteit 100%
Operatorvoorrang2. x, 3.x. De prioriteit van not
is lager dan die van in
. Het is dus gelijk aan:
>>> not ((True) in [False, True])
False
Dit is wat je wilt:
>>> (not True) in [False, True]
True
Zoals @Ben aangeeft: het wordt aanbevolen om nooit not(True)
te schrijven, maar liever not True
. De eerste laat het eruit zien als een functieaanroep, terwijl not
een operator is, geen functie.
Antwoord 2, autoriteit 10%
not x in y
wordt geëvalueerd als x not in y
Je kunt precies zien wat er gebeurt door de code te demonteren. Het eerste geval werkt zoals je verwacht:
>>> x = lambda: False in [False, True]
>>> dis.dis(x)
1 0 LOAD_GLOBAL 0 (False)
3 LOAD_GLOBAL 0 (False)
6 LOAD_GLOBAL 1 (True)
9 BUILD_LIST 2
12 COMPARE_OP 6 (in)
15 RETURN_VALUE
Het tweede geval evalueert tot True not in [False, True]
, wat duidelijk False
is:
>>> x = lambda: not(True) in [False, True]
>>> dis.dis(x)
1 0 LOAD_GLOBAL 0 (True)
3 LOAD_GLOBAL 1 (False)
6 LOAD_GLOBAL 0 (True)
9 BUILD_LIST 2
12 COMPARE_OP 7 (not in)
15 RETURN_VALUE
>>>
Wat je in plaats daarvan wilde uitdrukken was (not(True)) in [False, True]
, wat zoals verwacht True
is, en je kunt zien waarom:
>>> x = lambda: (not(True)) in [False, True]
>>> dis.dis(x)
1 0 LOAD_GLOBAL 0 (True)
3 UNARY_NOT
4 LOAD_GLOBAL 1 (False)
7 LOAD_GLOBAL 0 (True)
10 BUILD_LIST 2
13 COMPARE_OP 6 (in)
16 RETURN_VALUE
Antwoord 3, autoriteit 5%
Voorrang van operator. in
bindt strakker dan not
, dus je uitdrukking is gelijk aan not((True) in [False, True])
.
Antwoord 4, autoriteit 4%
Het draait allemaal om operatorvoorrang(in
is sterker dan not
). Maar het kan eenvoudig worden gecorrigeerd door haakjes op de juiste plaats toe te voegen:
(not(True)) in [False, True] # prints true
schrijven:
not(True) in [False, True]
is hetzelfde als:
not((True) in [False, True])
die kijkt of True
in de lijst staat en de “niet” van het resultaat retourneert.
Antwoord 5, autoriteit 2%
Het evalueert als not True in [False, True]
, wat False
retourneert omdat True
in [False, True]
Als je het probeert
>>>(not(True)) in [False, True]
True
Je krijgt het verwachte resultaat.
Antwoord 6, autoriteit 2%
Naast de andere antwoorden die vermeldden dat de prioriteit van not
lager is dan in
, is uw verklaring in feite gelijk aan:
not (True in [False, True])
Maar houd er rekening mee dat als u uw toestand niet van de andere scheidt, python 2 rollen (precedence
of chaining
) zal gebruiken om dat te scheiden, en in dit geval gebruikte python voorrang. Houd er ook rekening mee dat als u een voorwaarde wilt scheiden, u alle voorwaarden tussen haakjes moet plaatsen, niet alleen het object of de waarde:
(not True) in [False, True]
Maar zoals gezegd, er is nog een wijziging door python op operators die ketenenis:
Gebaseerd op python documentatie:
Houd er rekening mee dat vergelijkingen, lidmaatschapstests en identiteitstests allemaal dezelfde prioriteit hebben en een links-naar-rechts keten-functie hebben, zoals beschreven in het gedeelte Vergelijkingen.
Het resultaat van de volgende instructie is bijvoorbeeld False
:
>>> True == False in [False, True]
False
Omdat python de statements als volgt koppelt:
(True == False) and (False in [False, True])
Wat precies False and True
is, dat is False
.
U kunt ervan uitgaan dat het centrale object wordt gedeeld tussen 2 bewerkingen en andere objecten (in dit geval False).
En merk op dat dit ook geldt voor alle vergelijkingen, inclusief lidmaatschapstests en identiteitstestbewerkingen die de volgende operanden volgen:
in, not in, is, is not, <, <=, >, >=, !=, ==
Voorbeeld:
>>> 1 in [1,2] == True
False
Een ander beroemd voorbeeld is nummerreeks:
7<x<20
wat gelijk is aan :
7<x and x<20
Antwoord 7
Laten we het zien als een controleoperatie voor de insluiting van een collectie: [False, True]
is een lijst die enkele elementen bevat.
De uitdrukking True in [False, True]
retourneert True
, aangezien True
een element in de lijst is.
Daarom geeft not True in [False, True]
het “booleaanse tegenovergestelde”, not
resultaat van de bovenstaande uitdrukking (zonder haakjes om de prioriteit te behouden, zoals in
heeft een grotere prioriteit dan de operator not
).
Daarom zal not True
resulteren in False
.
Aan de andere kant is (not True) in [False, True]
gelijk aan False in [False, True]
, wat True
(False
staat in de lijst).
Antwoord 8
Om enkele van de andere antwoorden te verduidelijken, verandert het toevoegen van haakjes naeen unaire operator de prioriteit niet. not(True)
zorgt ervoor dat not
niet sterker bindt aan True
. Het is gewoon een overbodige set haakjes rond True
. Het is vrijwel hetzelfde als (True) in [True, False]
. De haakjes doen niets. Als je wilt dat de binding strakker is, moet je de haakjes rond de hele uitdrukking plaatsen, wat zowel de operator als de operand betekent, dwz (not True) in [True, False]
.
Als je dit op een andere manier wilt zien, overweeg dan
>>> -2**2
-4
**
bindt strakker dan -
, daarom krijg je de min van twee kwadraat, niet het kwadraat van min twee (wat een positieve vier zou zijn).
Wat als je het kwadraat van min twee wel wilt? Uiteraard zou je haakjes toevoegen:
>>> (-2)**2
4
Het is echter niet redelijk om van het volgende te verwachten dat 4
>>> -(2)**2
-4
omdat -(2)
hetzelfde is als -2
. De haakjes doen helemaal niets. not(True)
is precies hetzelfde.