Operators are the command words of the Python language. They instruct Python to perform specific actions on data, which is stored in variables. Think of variables as the ingredients, and operators as the instructions in a recipe.
Let’s dive into the fundamental types of operators you’ll use in Python: arithmetic, comparison, logical, and membership operators.
1. Arithmetic Operators: Doing the Math
These are the operators you probably recognize from everyday math:
- Addition (+): Combines two values (e.g.,
1 + 1 = 2). - Subtraction (-): Finds the difference (e.g.,
5 - 3 = 2). - Multiplication (*): Calculates the product (e.g.,
3 * 4 = 12). - Division (/): Calculates the quotient (e.g.,
10 / 2 = 5.0). - Exponentiation ():** Raises a number to a power (e.g.,
2 ** 3 = 8). - Modulo (%): Returns the remainder after division (e.g.,
20 % 6 = 2).
Example:
result = 5 + 3 * 2 # result is 11 (order of operations applies)
2. Comparison Operators: Checking Relationships
Comparison operators compare two values and return a Boolean result (True or False):
- Equal to (==): Checks if two values are equal.
- Not equal to (!=): Checks if two values are different.
- Greater than (>): Checks if the left value is larger than the right.
- Less than (<): Checks if the left value is smaller than the right.
- Greater than or equal to (>=): Checks if the left value is larger or equal.
- Less than or equal to (<=): Checks if the left value is smaller or equal.
Example:
is_equal = 5 == 5 # True
is_greater = 10 > 3 # True
3. Logical Operators: Combining Boolean Expressions
Logical operators combine multiple Boolean expressions and return a Boolean result:
- and: True only if both expressions are True.
- or: True if at least one expression is True.
- not: Reverses the truth value of the expression.
Example:
is_sunny = True
is_warm = False
good_weather = is_sunny and is_warm # False
go_outside = is_sunny or is_warm # True
not_sunny = not is_sunny # False
4. Membership Operators: Testing for Existence
Membership operators check if a value exists within a sequence (e.g., a string, list, or tuple):
- in: True if the value is found.
- not in: True if the value is not found.
Example:
text = "Hello, world!"
is_in = "Hello" in text # True
is_not_in = "Python" not in text # True
String Operations:
- Concatenation (+): Joins strings together (e.g.,
"Hello" + " World"). - Repetition (*): Repeats a string multiple times (e.g.,
"Ha" * 3).
Frequently Asked Questions (FAQ)
1. What’s the difference between the assignment operator (=) and the equality operator (==)?
The assignment operator (=) assigns a value to a variable, while the equality operator (==) compares two values and returns True if they are equal.
2. How do I remember the order of operations in Python?
The acronym PEMDAS or BODMAS helps: Parentheses/Brackets, Exponents/Orders, Multiplication and Division (from left to right), Addition and Subtraction (from left to right).
3. Can I use operators with different data types (e.g., strings and numbers)?
Some operators work with different data types (like + for concatenation or * for string repetition), but others may not (like > or < for comparing strings and numbers).
4. Are there more operators in Python?
Yes, Python has other operators for bitwise operations, identity checks, and more. These are used in specialized scenarios.