Waarom geeft “not(True) in [False, True]” False terug?

Als ik dit doe:

>>> False in [False, True]
True

Dat levert Trueop. Simpelweg omdat Falsein de lijst staat.

Maar als ik dat doe:

>>> not(True) in [False, True]
False

Dat levert Falseop. Terwijl not(True)gelijk is aan False:

>>> not(True)
False

Waarom?

Antwoord 1, autoriteit 100%

Operatorvoorrang^{2. x, 3.x}. De prioriteit van notis 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 noteen operator is, geen functie.

Antwoord 2, autoriteit 10%

not x in ywordt 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 Falseis:

>>> 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 Trueis, 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. inbindt strakker dan not, dus je uitdrukking is gelijk aan not((True) in [False, True]).

Antwoord 4, autoriteit 4%

Het draait allemaal om operatorvoorrang(inis 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 Truein de lijst staat en de “niet” van het resultaat retourneert.

Antwoord 5, autoriteit 2%

Het evalueert als not True in [False, True], wat Falseretourneert omdat Truein [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 notlager 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 (precedenceof 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 Trueis, 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 Trueeen element in de lijst is.

Daarom geeft not True in [False, True]het “booleaanse tegenovergestelde”, notresultaat van de bovenstaande uitdrukking (zonder haakjes om de prioriteit te behouden, zoals inheeft een grotere prioriteit dan de operator not).
Daarom zal not Trueresulteren in False.

Aan de andere kant is (not True) in [False, True]gelijk aan False in [False, True], wat True(Falsestaat 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 notniet 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.