C'è una differenza tra "e" e "&" rispetto ai set Python?

Question

Ho ricevuto un ottimo aiuto per la domanda check if dictionary key has empty value. Ma mi chiedevo se c'è una differenza tra and e & in python? Suppongo che dovrebbero essere simili?

dict1 ={"city":"","name":"yass","region":"","zipcode":"", 
    "phone":"","address":"","tehsil":"", "planet":"mars"} 

whitelist = {"name", "phone", "zipcode", "region", "city", 
      "munic", "address", "subarea"} 

result = {k: dict1[k] for k in dict1.viewkeys() & whitelist if dict1[k]} 

Answer 1

and è un operatore logico che viene utilizzato per confrontare due valori, IE:

> 2 > 1 and 2 > 3 
True 

& è un operatore binario che viene utilizzato per eseguire un'operazione AND:

> 255 & 1 
1 

Aggiornamento

quanto riguarda set operations, l'operatore & è equivalente all'operazione intersection(), e crea un nuovo insieme con elementi comuni a s e t:

>>> a = set([1, 2, 3]) 
>>> b = set([3, 4, 5]) 
>>> a & b 
set([3]) 

and è ancora solo una funzione di confronto logico, e tratterà un Argomento set come valore non falso.Sarà anche restituire l'ultimo valore se nessuno degli argomenti è False:

>>> a and b 
set([3, 4, 5]) 
>>> a and b and True 
True 
>>> False and a and b and True 
False 

---

Per quanto il suo valore, nota anche che, secondo i documenti pitone per Dictionary view objects, l'oggetto restituito da dict1.viewkeys() è un oggetto vista cioè "set-like":

gli oggetti restituiti dalla dict.viewkeys(), dict.viewvalues() e dict.viewitems() sono sottofinestre. Forniscono una vista dinamica sulle voci del dizionario, il che significa che quando il dizionario cambia, la vista riflette queste modifiche.

...

dictview & other

ritorno l'intersezione della dictview e l'altro oggetto come un nuovo set.

...

Answer 2

• and è logico e
• & è bit a bit e

logica and restituisce il secondo valore se entrambi i valori restituiscono true.

Per i set & è l'intersezione.

Se lo fai:

In [25]: a = {1, 2, 3} 

In [26]: b = {3, 4, 5} 

In [27]: a and b 
Out[27]: set([3, 4, 5]) 

In [28]: a & b 
Out[28]: set([3]) 

Questo essere perché bool(a) == True e bool(b) == True così and restituisce il secondo set. & restituisce l'intersezione dei set.

(set doc)

Answer 3

Sì and è una logica e che & è un bit a bit e. Vedere l'esempio -

>>> 1 and 2 
2 
>>> 1 & 2 
0 

Il primo risultato è dovuto al cortocircuito. test pitone 1 e trova vero e restituisce il 2. Tuttavia, la seconda parte fa 01 (binario 1) & 10 (binario 2) quindi valutare a 00 (1 & 0, 0 & 1), che è 0.

Answer 4

& è l'operatore bit-saggio e l'operatore, and è l'operatore logico booleano. Sono abbastanza diversi, non li confondono! Ad esempio:

7 & 3 
=> 3 

True and False 
=> False 

Answer 5

>>> help('&') 

+-------------------------------------------------+---------------------------------------+ 
| Operator          | Description       | 
+=================================================+=======================================+ 
| ``lambda``          | Lambda expression      | 
+-------------------------------------------------+---------------------------------------+ 
| ``if`` -- ``else``        | Conditional expression    | 
+-------------------------------------------------+---------------------------------------+ 
| ``or``           | Boolean OR       | 
+-------------------------------------------------+---------------------------------------+ 
| ``and``           | Boolean AND       | 
+-------------------------------------------------+---------------------------------------+ 
| ``not`` ``x``         | Boolean NOT       | 
+-------------------------------------------------+---------------------------------------+ 
| ``in``, ``not in``, ``is``, ``is not``, ``<``, | Comparisons, including membership  | 
| ``<=``, ``>``, ``>=``, ``<>``, ``!=``, ``==`` | tests and identity tests,    | 
+-------------------------------------------------+---------------------------------------+ 
| ``|``           | Bitwise OR       | 
+-------------------------------------------------+---------------------------------------+ 
| ``^``           | Bitwise XOR       | 
+-------------------------------------------------+---------------------------------------+ 
| ``&``           | Bitwise AND       | 
+-------------------------------------------------+---------------------------------------+ 
| ``<<``, ``>>``         | Shifts        | 
+-------------------------------------------------+---------------------------------------+ 
| ``+``, ``-``         | Addition and subtraction    | 
+-------------------------------------------------+---------------------------------------+ 
| ``*``, ``/``, ``//``, ``%``      | Multiplication, division, remainder | 
|             | [8]         | 
+-------------------------------------------------+---------------------------------------+ 
| ``+x``, ``-x``, ``~x``       | Positive, negative, bitwise NOT  | 
+-------------------------------------------------+---------------------------------------+ 
| ``**``           | Exponentiation [9]     | 
+-------------------------------------------------+---------------------------------------+ 
| ``x[index]``, ``x[index:index]``,    | Subscription, slicing, call,   | 
| ``x(arguments...)``, ``x.attribute``   | attribute reference     | 
+-------------------------------------------------+---------------------------------------+ 
| ``(expressions...)``, ``[expressions...]``,  | Binding or tuple display, list  | 
| ``{key: value...}``, ```expressions...```  | display, dictionary display, string | 
|             | conversion       | 
+-------------------------------------------------+---------------------------------------+