Czy jest różnica między "i" i "&" w odniesieniu do zestawów Pythona?

Question

Mam bardzo dobrą pomoc na pytanie check if dictionary key has empty value. Ale zastanawiałem się, czy istnieje różnica między and i & w python? Zakładam, że powinny być podobne?

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 jest operator logiczny, który służy do porównywania dwóch wartości, a mianowicie:

> 2 > 1 and 2 > 3 
True 

& jest operatorem bitowym, który jest używany do wykonywania bitowego oraz eksploatacja

> 255 & 1 
1 

Aktualizacja

Odnośnie set operations operator & odpowiada operacji intersection() i tworzy nowy zbiór elementów wspólnych dla S i T:

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

and nadal tylko funkcją logiczną porównanie, i leczyć set Argument jako wartość niefałszywą.Będzie również przywrócić ostatnią wartość, jeżeli żaden z argumentów jest False:

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

---

Na co warto, uwaga również, że zgodnie z docs Pythona do Dictionary view objects, obiekt zwrócony przez dict1.viewkeys() jest obiektem widok że jest "set-like":

obiektów zwróconych przez dict.viewkeys(), dict.viewvalues() i dict.viewitems() są Wyświetlanie obiektów. Zapewniają dynamiczny widok na pozycje słownika, co oznacza, że ​​po zmianie słownika widok odzwierciedla te zmiany.

...

dictview & other

Powrót przecięcie dictview a drugi obiekt jako nowy zestaw.

...

Answer 2

• and jest logiczne i
• & jest bitowe i

logiczne and zwraca drugą wartość, jeśli obie wartości oceny true.

Dla zestawów & to przecięcie.

Jeśli zrobić:

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

to być spowodowane bool(a) == True i bool(b) == True tak and zwraca drugi zestaw. & zwraca przecięcie zestawów.

(set doc)

Answer 3

Tak and jest logiczną i że & jest bitowe i. Zobacz przykład -

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

Pierwszy wynik jest spowodowany zwarciem. Testy Python 1 i uzna za prawdziwe i zwraca 2. Ale druga część ma 01 (Binary 1) & 10 (Binary 2) stąd oceny do 00 (1 & 0, 0 & 1), który jest 0.

Answer 4

& jest operatorem bitowym i operatorem, and jest operatorem logicznym boolowskim. Są zupełnie inne, nie myl ich! Na przykład:

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