# Python Programming/Operators

## Basics

Python math works as expected:

``` {.python .numberLines}
>>> x = 2
>>> y = 3
>>> z = 5
>>> x * y
6
>>> x + y
5
>>> y - x
1
>>> x * y + z
11
>>> (x + y) * z
25
>>> 3.0 / 2.0 # True division
1.5
>>> 3 // 2 # Floor division
1
>>> 2 ** 3 # Exponentiation
8
```

Note that Python adheres to the  PEMDAS order of
operations.

## Powers

There is a built in exponentiation operator *\*\**, which can take
either integers, floating point or complex numbers. This occupies its
proper place in the order of operations.

``` python
>>> 2**8
256
```

## Floor Division and True Division

In Python 3.x, slash operator (\"/\") does *true division* for all types
including integers, and therefore, e.g. `3/2==1.5`[^1][^2]. The result
is of a floating-point type even if both inputs are integers: 4 / 2
yields 2.0.

In Python 3.x and latest 2.x, *floor division* for both integer
arguments and floating-point arguments is achieved by using the double
slash (\"//\") operator. For negative results, this is unlike the
integer division in the C language since -3 // 2 == -2 in Python while
-3 / 2 == -1 in C: C rounds the negative result toward zero while Python
toward negative infinity.

Beware that due to the limitations of floating point
arithmetic, rounding errors can cause
unexpected results. For example:

`>>> print(0.6/0.2)`\
`3.0`\
`>>> print(0.6//0.2)`\
`2.0`

For Python 2.x, dividing two integers or longs using the slash operator
(\"/\") uses *floor division* (applying the floor
function after division) and results in an
integer or long. Thus, 5 / 2 == 2 and -3 / 2 == -2. Using \"/\" to do
division this way is deprecated; if you want floor division, use \"//\"
(available in Python 2.2 and later). Dividing by or into a floating
point number will cause Python to use true division. Thus, to ensure
true division in Python 2.x: `x=3; y=2; float(x)/y == 1.5`.

Links:

-   6.7. Binary arithmetic
    operations,
    in The Python Language Reference, docs.python.org
-   Python-style integer division & modulus in
    C,
    stackoverflow.com
-   Integer division rounding with negatives in
    C++,
    stackoverflow.com
-   In Python, what is a good way to round towards zero in integer
    division?,
    stackoverflow.com
-   Why Python\'s Integer Division
    Floors,
    python-history.blogspot.com

## Modulus

The modulus (remainder of the division of the two operands, rather than
the quotient) can be found using the *%* operator, or by the *divmod*
builtin function. The *divmod* function returns a *tuple* containing the
quotient and remainder.

``` python
>>> 10 % 7
3
>>> -10 % 7
4
```

Note that -10 % 7 is equal to 4 while it is equal to -3 in the C
language. Python calculates the remainder as one after floor division
while the C language calculates the remainder after C integer division,
which differs from Python\'s floor division on integers: C integer
division rounds negative results toward zero.

Links:

-   6.7. Binary arithmetic
    operations,
    in The Python Language Reference, docs.python.org

## Negation

Unlike some other languages, variables can be negated directly:

``` python
>>> x = 5
>>> -x
-5
```

## Comparison

  Operation   Means
  ----------- --------------------------
  \<          Less than
  \>          Greater than
  \<=         Less than or equal to
  \>=         Greater than or equal to
  ==          Equal to
  !=          Not equal to
              

Numbers, strings and other types can be compared for equality/inequality
and ordering:

``` python
>>> 2 == 3
False
>>> 3 == 3
True
>>> 3 == '3'
False
>>> 2 < 3
True
>>> "a" < "aa"
True
```

## Identity

The operators `is` and `is not` test for object identity and stand in
contrast to == (equals): `x is y` is true if and only if x and y are
references to the same object in memory. `x is not y` yields the inverse
truth value. Note that an identity test is more stringent than an
equality test since two distinct objects may have the same value.

``` python
>>> [1,2,3] == [1,2,3]
True
>>> [1,2,3] is [1,2,3]
False
```

For the built-in immutable data
types
(like int, str and tuple) Python uses caching mechanisms to improve
performance, i.e., the interpreter may decide to reuse an existing
immutable object instead of generating a new one with the same value.
The details of object caching are subject to changes between different
Python versions and are not guaranteed to be system-independent, so
identity checks on immutable objects like `'hello' is 'hello'`,
`(1,2,3) is (1,2,3)`, `4 is 2**2` may give different results on
different machines.

In some Python implementations, the following results are applicable:

``` python
print(8 is 8)           # True
print("str" is "str")   # True
print((1, 2) is (1, 2)) # False - whyever, it is immutable
print([1, 2] is [1, 2]) # False
print(id(8) == id(8))   # True
int1 = 8
print(int1 is 8)        # True
oldid = id(int1)
int1 += 2
print(id(int1) == oldid)# False
```

Links:

-   3. Data model,
    python.org
-   2. Built-in Functions \#
    id, python.org
-   5. Expressions \#
    is,
    python.org

## Augmented Assignment

There is shorthand for assigning the output of an operation to one of
the inputs:

``` python
>>> x = 2
>>> x # 2
2
>>> x *= 3
>>> x # 2 * 3
6
>>> x += 4
>>> x # 2 * 3 + 4
10
>>> x /= 5
>>> x # (2 * 3 + 4) / 5
2
>>> x **= 2
>>> x # ((2 * 3 + 4) / 5) ** 2
4
>>> x %= 3
>>> x # ((2 * 3 + 4) / 5) ** 2 % 3
1

>>> x = 'repeat this  '
>>> x  # repeat this
repeat this
>>> x *= 3  # fill with x repeated three times
>>> x
repeat this  repeat this  repeat this
```

## Logical Operators

Logical operators are operators that act on booleans.

### or

The or operator returns true if any one of the booleans involved are
true. If none of them are true (in other words, they are all false), the
or operator returns false.

``` python
if a or b:
    do_this
else:
    do_this
```

### and

The and operator only returns true if all of the booleans are true. If
any one of them is false, the and operator returns false.

``` python
if a and b:
    do_this
else:
    do_this
```

### not

The not operator only acts on one boolean and simply returns its
opposite. So, true turns into false and false into true.

``` python
if not a:
    do_this
else:
    do_this
```

The order of operations here is: *not* first, *and* second, *or* third.
In particular, \"True or True and False or False\" becomes \"True or
False or False\" which is True.

Warning, logical operators can act on things other than booleans. For
instance \"1 and 6\" will return 6. Specifically, \"and\" returns either
the first value considered to be false, or the last value if all are
considered true. \"or\" returns the first true value, or the last value
if all are considered false. In Python, (floating-point) number with
value *zero*, and *empty* strings, lists, sets, etc. are considered to
be false. You may use `bool()` to check whether a thing is considered to
be true or false in Python. For instance, `bool(0.0)` and `bool([])`
both return `False`.

## Bitwise Operators

Python operators for bitwise arithmetic are like those in the C
language. They include & (bitwise and), \| (bitwise or), \^ (exclusive
or AKA xor), \<\< (shift left), \>\> (shift right), and \~ (complement).
Augmented assignment operators (AKA compound assignment operators) for
the bitwise operations include &=, \|=, \^=, \<\<=, and \>\>=. Bitwise
operators apply to integers, even negative ones and very large ones; for
the shift operators, the second operand must be non-negative. In the
Python internal help, this is covered under the topics of EXPRESSIONS
and BITWISE.

Examples:

-   0b1101 & 0b111 == 0b101
    -   Note: 0b starts a binary literal, just like 0x starts a
        hexadecimal literal.
-   0b1 \| 0b100 == 0b101
-   0b111 \^ 0b101 == 0b10
-   1 \<\< 4 == 16
-   7 \>\> 1 == 3
-   1 \<\< 100 == 0x10000000000000000000000000
    -   Large results are supported.
-   1 \<\< -1
    -   An error: the 2nd operand must be non-negative.
-   -2 & 15 == 14
    -   For bitwise operations, negative integers are treated as if
        represented using two\'s complement with an infinite sequence of
        leading ones. Thus -2 is as if 0x\...FFFFFFFFFE, which ANDed
        with 15 (0xF) yields 0xE, which is 14.
-   format(-2 % (1 \<\< 32), \"032b\")
    -   Determines a string showing the last 32 bits of the implied
        two\'s complement representation of -2.
-   \~-2 == 1
    -   The above note about treatment of negative integers applies. For
        the complement (\~), this treatment yields \~x == -1 \* (x + 1).
        This can be verified: min((\~x == -1 \* (x + 1) for x in
        range(-10 \*\* 6, 10 \*\* 6))) == True.
-   \~1 == -2
    -   The formula \~x == -1 \* (x + 1) mentioned above applies. In the
        bitwise complement interpretation, all the imaginary leading
        leading zeros of 1 are toggled to leading ones, which is then
        interpreted as two\'s complement representation of -2, which is
        as if 0x\...FFFFFFFFFE.
-   x = 0b11110101; x &= \~(0xF \<\< 1); x == 0b11100001
    -   A common idiom clears the least significant bits 5 to 2 using
        complement, showing the usefulness of the infinite-leading-ones
        two\'s complement implied representation of negative numbers for
        bitwise operations. Works for arbitrarily large x.
-   \~2 & 0xFFFFFFFF == 0xFFFFFFFD
    -   We can emulate bitwise complement on 32-bit integers by ANDing
        the complement with the maximum unsigned 32-bit integer,
        0xFFFFFFFF. We can proceed similarly for 8-bit complement,
        16-bit complement, etc., by ANDing the complement with 0xFF,
        0xFFFF, etc.
-   2 \^ 0xFFFFFFFF == 0xFFFFFFFD
    -   Another way to emulate fixed-size bitwise complement is by
        XORing with all Fs for the size.
-   v = 2.0 & 2
    -   Yields an error: no automatic conversion of floats to ints, and
        no operation on the underlying representation of the float.
-   int.bit_length(0x8000) == 16
    -   Determines how many bits are needed to represent the integer.
        Therefore, min((int.bit_length(1 \<\< x) == x + 1 for x in
        range(100000))) == True.

Examples of augmented assignment operators:

-   a = 0b1101; a &= 0b111; a == 0b101
-   a = 0b1; a \|= 0b100; a == 0b101
-   a = 0b111; a \^= 0b101; a == 0b10
-   a = 1; a \<\<= 4; a == 16
-   a = 7; a \>\>= 1; a == 3

Class definitions can overload the operators for the instances of the
class; thus, for instance, sets overload the pipe (\|) operator to mean
set union: {1,2} \| {3,4} == {1,2,3,4}. The names of the override
methods are \_\_and\_\_ for &, \_\_or\_\_ for \|, \_\_xor\_\_ for \^,
\_\_invert\_\_ for \~, \_\_lshift\_\_ for \<\<, \_\_rshift\_\_ for \>\>,
\_\_iand\_\_ for &=, \_\_ior\_ for \|=, \_\_ixor\_\_ for \^=,
\_\_ilshift\_\_ for \<\<=, and \_\_irshift\_\_ for \>\>=.

Examples of use of bitwise operations include calculation of CRC and
MD5. Admittedly, these would usually be implemented in C rather than
Python for maximum speed; indeed, Python has libraries for these written
in C. Nonetheless, implementations in Python are possible and are shown
in the links to Rosetta Code below.

Links:

-   BitwiseOperators,
    wiki.python.org

-   BitManipulation,
    wiki.python.org

-   Bitwise Operations on Integer
    Types
    in Library Reference, docs.python.org

-   2.5.
    Operators
    in The Python Language Reference, docs.python.org

-   6.
    Expressions
    in The Python Language Reference, docs.python.org

-   3. Data model
    in in The Python Language Reference, docs.python.org

    :   \"Integers (int) \[\...\] For the purpose of shift and mask
        operations, a binary representation is assumed, and negative
        numbers are represented in a variant of 2's complement which
        gives the illusion of an infinite string of sign bits extending
        to the left.\"

-       , wikipedia.org

-       , wikipedia.org

-   PEP 203 -- Augmented
    Assignments, python.org

-   Bitwise operation and
    usage,
    stackoverflow.com

-   CRC-32 \# Python,
    rosettacode.org

-   MD5/Implementation \#
    Python,
    rosettacode.org

-   longobject.c
    at python/cpython, github.com - functions long_bitwise, long_rshift,
    long_lshift, and long_invert

## References

## External Links

-   3.1.1.
    Numbers
    in The Python Tutorial, docs.python.org
-   6.
    Expressions
    in The Python Language Reference, docs.python.org


[^1]: What\'s New in Python
    2.2

[^2]: PEP 238 \-- Changing the Division
    Operator
