Each Answer to this Q is separated by one/two green lines.

I came across the following code

```
numdigits = len(cardNumber)
oddeven = numdigits & 1
```

what exactly is going on here? I’m not sure what the “&” is doing.

## Answer

The `&`

symbol is a bitwise AND operator. Used with 1, it basically masks the value to extract the lowest bit, or in other words will tell you if the value is even or odd.

## More Info on Python’s `&`

operator

For more information, see: http://wiki.python.org/moin/BitwiseOperators

## Why it Works to check Odd vs. Even

*EDIT: Adding this section since this answer is getting some love*

The reason why ANDing a value with 1 tells if the value is odd or even may not be obvious at first.

The binary representation of a number is essentially the sum of a series of YES or NO for each power of 2 moving leftward starting in the rightmost digit with 1, 2, 4, 8, …

There is only one way to represent any number in this way. E.g. the number 13 (base 10) can be written in binary as “1101” (or hexadecimal as 0xD, but that’s beside the point). See here:

```
1 1 0 1
x x x x
8 4 2 1
= = = =
8 + 4 + 0 + 1 = 13
```

Notice that aside from the rightmost binary digit, all other `1`

digits will add an even number (i.e. a multiple of 2) to the sum. So the only way to get an odd final sum is to add that odd 1 from the rightmost digit. So if we’re curious if a number is odd or even, we can look at its binary representation and ignore everything except for the rightmost digit.

To do this, we use the bitwise AND operator. The value `1`

in binary is expressed as `1`

:

```
0 0 0 1
x x x x
8 4 2 1
= = = =
0 + 0 + 0 + 1 = 1
```

ANDing a value with `1`

like this will result in `1`

if the value’s rightmost bit is set, and `0`

if it is not.

And because `0`

is generally considered “false” in most languages, and non-zero values considered “true”, we can simply say as a shortcut:

```
if (value & 1): do_something_with_odd_value()...
```

`&`

is also used for taking the intersection of two Python sets:

```
set1 = {0,1,2,3}
set2 = {2,3,4,5}
print(set1 & set2)
>>>set([2, 3])
```

More generally, Python allows operator overloading, meaning you can write classes that re-interpret what the `&`

operator does. This is how libraries such as Pandas and Numpy hijack `&`

.

It’s a bitwise operation, in this case assigning zero to `oddeven`

if `cardNumber`

has an even number of elements (and one otherwise).

As an example: suppose `len(cardNumber) == 235`

. Then `numdigits == 235`

, which is `0b11101011`

in binary. Now `1`

is `'0b00000001'`

in binary, and when you “AND” them, bitwise, you’ll get:

```
11101011
&
00000001
----------
= 00000001
```

Similarly, if `numdigits`

were 234, you would get:

```
11101010
&
00000001
----------
= 00000000
```

So, it’s basically a obfuscated way of checking if `len(cardNumber) % 2`

. Probably written by someone with a C background, because it is not very pythonic – readability counts!

`&`

is a bitwise and, which is an efficient way to do bit-level calculations. It is taking `numdigits`

and and-ing it with `1`

, bit-by-bit.

It’s a binary bitwise AND operator.