Python

Much to unpack here...

coin == 25 | 10 | 5

...will evaluate as True if coin is equal to the bitwise OR of 25, 10 and 5 - i.e. 31. In other word, it's equivalent to coin == 31. That's because the bitwise OR has precedence over the == operator. See operator precedence in Python.

If I replace the ‘|’ with ‘or’ the code runs just fine.

It probably doesn't. If you replace | with or, you have the statement coin == 25 or 10 or 5 which is always True in the if statement because it's evaluated as (coin == 25) or (not 0) or (not 0) in an if statement.

coin == 25 | coin == 10 | coin == 5

...will evaluate as coin == (25 | coin) == (10 | coin) == 5. Again, operator precedence.

What you want to do is this:

if coin in [25, 10, 5]:

or

if coin in (25, 10, 5):

or simply

if coin == 25 or coin == 10 or coin == 5:

Don't create problems and confusion for the next guy who reads your code for nothing. Simple and readable are your friends 🙂

|| is the logical OR in most languages I know of, but I'm pretty sure python only has the or keyword, no shorthand.

Bitwise OR applies the logic to the individual bits in the underlying data. Think about how you would add two large numbers by hand. Write one number above the other and add at each position. Bitwise or is like that, except you OR the two bits in each position instead of adding them.

In your example (you can do an OR with n inputs, the result is 1 if any input is 1):

11001 25
01010 10
00101 5
----- OR
11111 31

So your code is actually being interpreted as if coin == 31:

| is not equivalent to "or". In bitwise operations the integer is converted into bits and the operation is done on a per-bit level. See: https://www.geeksforgeeks.org/python-bitwise-operators/

Eg. 1 | 2 is 3 where as 1 or 3 is 1

You want the keyword "or" rather than the bitwise operator. Alternatively, use "if coin in {25, 10, 5}". The curly braces denote a set, which is implemented as a hash table, so the lookup will be fast even when the number of choices is large.

a use case -- feature flags

Mix and match to plan your day

will i be going home today?

>>> OUTRAGED_BY_NEWS = 0b00000001
>>> GET_A_COFFEE = 0b00000010
>>> GO_FOR_A_HIKE = 0b00000100
>>> GO_FOR_A_RUN = 0b00001000
>>> GO_HOME = 0b00010000 
>>> various_flags_ored_together = GET_A_COFFEE | GO_FOR_A_RUN | GO_HOME
>>> various_flags_ored_together & GO_HOME == GO_HOME
True
>>> various_flags_ored_together & GO_FOR_A_HIKE == GO_FOR_A_HIKE
False
>>> various_flags_ored_together = GET_A_COFFEE | GO_FOR_A_RUN | GO_HOME
>>> bin(various_flags_ored_together)
'0b11010'
>>> various_flags_ored_together & OUTRAGED_BY_NEWS == OUTRAGED_BY_NEWS
>>> False
>>> bin(OUTRAGED_BY_NEWS)
>>> '0b1'
>>> various_flags_ored_together >> OUTRAGED_BY_NEWS
>>> bin(various_flags_ored_together)
'0b1101'

Guess haven't gone for a hike today...maybe tomorrow

right shift removes bit at flag position. Which, in this case, happens to correspond to the right most bit.

use case -- file access permissions

For those looking to check file access permissions there is the stat module

>>> import stat
>>> from pathlib import Path
>>> path_f = Path.home().joinpath(".bashrc")
>>> stat.S_IRUSR
256
>>> path_f.stat().st_mode
33188
>>> is_owner_read = path_f.stat().st_mode & stat.S_IRUSR == stat.S_IRUSR
>>> is_owner_read
True
>>> path_f = Path("/etc/fstab")
>>> is_other_write = path_f.stat().st_mode & stat.S_IWOTH == stat.S_IWOTH
>>> is_other_write
False

Assumes ~/.bashrc exists, if not choose a different file you are owner and have read access to.

path_f.stat().st_mode & stat.S_IRUSR == stat.S_IRUSR

Looking thru the mundane file (not Linux access control list) permissions. All those flags are crammed into st_mode. In st_mode, on/off bit at 2^8 is that on?

Sources

read user access stat.S_IRUSR

write others access stat.S_IWOTH

os.stat_result

pathlib.Path.stat

I don't have the answer, but if you are looking to do something like that you could simply do :
if coin in (25, 10, 5):
Or use a list but I think using a tuple is better as your values are fixed.

Part of the problem is operator precedence - it's ORing together the three numbers, then comparing that to "coin".

5 = 00101
10= 01010
25= 11001
    11111 = 31 

It's testing if coin equals 31.

Have a look at the result of your bitwise operation.