Python Operators

Types of Python Operators

• Python divides operators into groups like arithmetic, assignment, comparison, logical, bitwise, identity, and membership operators.

Python Arithmetic Operators

• Used with numeric values for common mathematical operations.
• Addition (+) performs addition: x + y.
• Subtraction (-) performs subtraction: x - y.
• Multiplication (*) performs multiplication: x * y.
• Division (/) performs division: x / y.
• Modulus (%) returns the division remainder: x % y.
• Floor division (//) returns the integer part of division: x // y.
• Exponentiation (**) raises to a power: x ** y.

Python Assignment Operators

• Used to assign values to variables.
• Assignment (=) assigns a value: x = y.
• Addition Assignment (+=) adds and assigns: x += y is the same as x = x + y.
• Subtraction Assignment (-=) subtracts and assigns: x -= y is the same as x = x - y.
• Multiplication Assignment (*=) multiplies and assigns: x *= y is the same as x = x * y.
• Division Assignment (/=) divides and assigns: x /= y is the same as x = x / y.
• Modulus Assignment (%=) gets modulus and assigns: x %= y is the same as x = x % y.
• Floor Division Assignment (//=) performs floor division and assigns: x //= y is the same as x = x // y.
• Exponentiation Assignment (**=) raises to a power and assigns: x **= y is the same as x = x ** y.

Python Comparison Operators

• Used in logical statements to determine equality or difference.
• Comparison and logical operators return True or False.
• Equal (==) checks if values are equal: x == y.
• Not equal (!=) checks if values are not equal: x != y.
• Greater than (>) checks if one value is greater than the other: x > y.
• Less than (<) checks if one value is less than the other: x < y.
• Greater than or equal to (>=) checks if one value is greater than or equal to the other: x >= y.
• Less than or equal to (<=) checks if one value is less than or equal to the other: x <= y.

Python Logical Operators

• Used to determine logic between variables or values.
• and returns True if both statements are true: x < 5 and x < 10.
• or returns True if one of the statements is true: x < 5 or x < 4.
• not reverses the result, returning False if the result is true: not(x < 5 and x < 10).

Python Bitwise Operators

• Used to compare (binary) numbers; operations are performed on 32-bit binary numbers.
• Python converts numbers to 32-bit signed integers before a bitwise operation and converts the result back to a Python number.
• AND (&) sets each bit to 1 if both bits are 1, e.g., 5 & 1 results in 1.
• OR (|) sets each bit to 1 if one of two bits is 1, e.g., 5 | 1 results in 5.
• XOR (^) sets each bit to 1 if only one of two bits is 1, e.g., 5 ^ 1 results in 4.
• NOT (~) inverts all the bits, e.g., ~5 results in -6.
• Zero fill left shift (<<) shifts left by pushing zeros in from the right, letting leftmost bits fall off, e.g., 5 << 1 results in 10.
• Signed right shift (>>) shifts right by pushing copies of the leftmost bit in from the left, letting the rightmost bits fall off, e.g., 5 >> 1 results in 2.

Python Identity Operators

• Used to compare the objects, not if they are equal, but rather if they are actually the same object with the same memory location.
• is returns True if both variables are the same object: x is y.
• is not returns True if both variables are not the same object: x is not y.
• Example:
  • x = ["apple", "banana"]
  • y = ["apple", "banana"]
  • z = x
  • print(x is z) returns True because z is the same object as x.
  • print(x is y) returns False because x is not the same object as y, even if they have the same content.
  • print(x == y) returns True because x is equal to y.
  • print(x is not z) returns False because z is the same object as x.
  • print(x is not y) returns True because x is not the same object as y.
  • print(x != y) returns False because x is equal to y.

Python Membership Operators

• Used to test if a sequence is present in an object.
• in returns True if a sequence with the specified value is present in the object: x in y.
• not in returns True if a sequence with the specified value is not present in the object: x not in y.
• Example:
  • x = ["apple", "banana"]
  • print("banana" in x) returns True because a sequence with the value "banana" is in the list.
  • print("pineapple" not in x) returns True because a sequence with the value "pineapple" is not in the list.

Python Operator Precedence

• Describes the order in which operations are performed; determine the order of operations by priority when there is more than one operator in an expression.
• Multiplication (*) and division (/) have higher precedence than addition (+) and subtraction (-).
• As in traditional mathematics, multiplication is done first: print(100 + 50 * 3) results in 250.
• When using parentheses, operations inside the parentheses are computed first: print((100 + 50) * 3) results in 450.
• Operations with the same precedence (like * and /) are computed from left to right: print(100 / 50 * 3) results in 6.
• Precedence order (from highest to lowest):
  • Parentheses ()
  • Exponentiation **
  • Unary plus, unary minus, and bitwise NOT +x, -x, ~x
  • Multiplication, division, floor division, and modulus *, /, //, %
  • Addition and subtraction +, -
  • Bitwise left and right shifts <<, >>
  • Bitwise AND &
  • Bitwise XOR ^
  • Bitwise OR |
  • Comparisons, identity, and membership operators ==, !=, >, >=, <, <=, is, is not, in, not in
  • Logical NOT not
  • Logical AND and
  • Logical OR or
• Parentheses have the highest precedence, and need to be evaluated first: print((6 + 3) - (6 + 3)) is equal to 9 - 9 = 0.
• Example involving bitwise right shift and subtraction: first the subtraction must be completed, followed by bitwise right shift print(8 >> 4 - 2) is equivalent to print(8 >> 2) = 2.

Python Booleans

• Booleans represent one of two values: True or False.
• In programming, it's often necessary to know if an expression is True or False.
• Expressions in Python can be evaluated, returning one of these two answers.
• Comparison of two values results in a Boolean answer.
• Running a condition in an if statement returns True or False.
• The bool() function evaluates any value and returns True or False.
• Almost any value is evaluated to True if it has some sort of content.
• Any string is True, except empty strings.
• Any number is True, except 0.
• Any list, tuple, set, and dictionary are True, except empty ones.
• Example:
  • bool("abc") returns True.
  • bool(123) returns True.
  • bool(["apple", "cherry", "banana"]) returns True.
  • 10 > 9 is True.
  • 10 == 9 is False.
  • 10 < 9 is False.

Python Exercises

• Division operator (/) divides numbers.
• Modulus operator (%) returns the division remainder.
• Floor division (//) returns the division quotient.
• Example:
  • x = 12
  • y = 3
  • print(x / y) gives 4.0.
  • print(x % y) gives 0.
  • print(x // y) gives 4.
• Arithmetic assignment operators provide a shorthand way of performing arithmetic operations and assigning the result to a variable in a single step; += and -= are common.
• Given examples:
  • x = 5, y = 3
  • print(x > y) returns True because 5 is greater than 3.
  • print(x= 3 and x < 10) returns True because 5 is greater than 3 and less than 10.
  • print(x > 3 or x < 4) returns True because one of the conditions is met (5 is greater than 3).
  • print(not(x > 3 and x < 10)) returns False because not is used to reverse the result.
• With zero fill left shift, the << operator inserts the specified number of 0s from the right and let the same amount of leftmost bits fall off (binary operations).
  • If you push 00 in from the right: 3 = 0000000000000011 becomes 12 = 0000000000001100.
• Exponentiation has higher precedence than subtraction, evaluated first.
  • print(100 - 3 ** 3) is equal to print(100 - 27) giving 73.
• Bitwise right shift has a lower precedence than subtraction, requires completing subtraction first.
  • print(8 >> 4 - 2) translates to print(8 >> 2), meaning 2.
  • The >> operator moves each bit the specified number of times to the right, filling empty holes at the left with 0's. 8 = 0000000000001000 becomes 2 = 0000000000000010 if each bit is moved two times to the right.