Introduction to Python Operators

Python operators are fundamental building blocks that enable programmers to perform operations on variables and values, forming the core of computational logic in Python programming. Understanding Python operators is essential for anyone learning Python, whether you’re a complete beginner taking your first steps in programming or an experienced developer looking to deepen your Python expertise.

Operators in Python are special symbols or keywords that perform specific operations on one, two, or more operands (values or variables) and produce a result. From simple arithmetic calculations to complex logical evaluations, operators power virtually every Python program you’ll write. They enable you to manipulate data, make decisions, perform comparisons, and control program flow with elegant and readable syntax.

Python supports a rich set of operator types including arithmetic operators for mathematical calculations, comparison operators for evaluating relationships between values, logical operators for combining conditions, assignment operators for storing values, bitwise operators for bit-level operations, membership operators for testing containment, and identity operators for comparing object identity. Each operator category serves specific purposes and understanding when and how to use them effectively is crucial for writing efficient, maintainable Python code.

This comprehensive guide explores all Python operator types in depth, providing clear explanations, practical examples, best practices, and common pitfalls to avoid. By mastering Python operators, you’ll build a solid foundation for more advanced programming concepts and develop the skills needed to write professional-quality Python code.

Arithmetic Operators: Performing Mathematical Operations

Arithmetic operators are the most intuitive and commonly used operators in Python programming, enabling you to perform standard mathematical calculations. These operators work with numeric data types including integers, floating-point numbers, and complex numbers, forming the foundation of computational logic.

Basic Arithmetic Operators

The addition operator (+) adds two operands together, working with numbers, strings (concatenation), and lists (concatenation). For example, 5 + 3 returns 8, while "Hello" + " World" produces "Hello World". This versatility makes addition one of Python’s most frequently used operators.

The subtraction operator (-) subtracts the right operand from the left operand. When used as 10 - 4, it returns 6. The subtraction operator also works as a unary operator to negate values, as in -5 which represents negative five. This dual functionality provides flexibility in mathematical expressions.

The multiplication operator (*) multiplies two operands together. Beyond simple multiplication like 4 * 3 returning 12, this operator can repeat sequences. For instance, "Python" * 3 produces "PythonPythonPython", and [1, 2] * 3 creates [1, 2, 1, 2, 1, 2]. This string and list repetition feature proves particularly useful in various programming scenarios.

The division operator (/) divides the left operand by the right operand, always returning a floating-point result even when dividing integers evenly. For example, 10 / 2 returns 5.0, not 5. This consistent float return behavior helps prevent subtle bugs that could arise from implicit type conversions.

Advanced Arithmetic Operators

The floor division operator (//) performs division and rounds down to the nearest integer, effectively discarding the decimal portion. When you calculate 10 // 3, you get 3 instead of 3.333.... This operator proves invaluable when you need integer results from division operations, such as calculating how many complete groups you can form from a collection.

The modulus operator (%) returns the remainder after division, essential for many programming tasks. For example, 10 % 3 returns 1 because 10 divided by 3 equals 3 with a remainder of 1. Common applications include determining if numbers are even or odd (n % 2 == 0 checks for even numbers), implementing circular buffers, and distributing items into groups.

The exponentiation operator ()** raises the left operand to the power of the right operand. The expression 2 ** 3 calculates 2 cubed, returning 8. Similarly, 5 ** 2 computes 5 squared, yielding 25. This operator eliminates the need for importing math libraries for basic power operations, making exponential calculations clean and readable.

Arithmetic Operator Precedence

Understanding operator precedence ensures expressions evaluate in the intended order. Python follows mathematical conventions where exponentiation has the highest precedence, followed by unary operators (positive/negative signs), then multiplication, division, floor division, and modulus (all equal precedence), and finally addition and subtraction (equal precedence).

When operators have equal precedence, Python evaluates them left to right. For example, in the expression 10 - 5 + 2, Python first calculates 10 - 5 to get 5, then adds 2 to get 7. Using parentheses to explicitly control evaluation order improves code readability even when not strictly necessary: (10 - 5) + 2 makes the intention crystal clear.

Practical Arithmetic Examples

Calculating averages combines several operators: average = (num1 + num2 + num3) / 3. Converting temperatures from Fahrenheit to Celsius demonstrates formula implementation: celsius = (fahrenheit - 32) * 5 / 9. Computing compound interest showcases exponentiation: final_amount = principal * (1 + rate) ** years.

These real-world examples illustrate how arithmetic operators combine to solve practical problems. Understanding operator behavior and precedence enables you to translate mathematical formulas directly into working Python code with confidence and clarity.

Comparison Operators: Evaluating Relationships Between Values

Comparison operators, also called relational operators, compare two values and return Boolean results (True or False). These operators form the foundation of conditional logic, enabling programs to make decisions based on data relationships.

Understanding Comparison Operators

The equal to operator (==) checks if two operands have the same value. For example, 5 == 5 returns True, while 5 == 6 returns False. Be careful not to confuse this with the assignment operator (=). A common beginner mistake is writing if x = 5: instead of if x == 5:, which causes a syntax error.

The not equal to operator (!=) returns True when operands have different values. The expression 5 != 6 evaluates to True, while 5 != 5 returns False. This operator is particularly useful for validation checks and filtering operations where you want to identify values that don’t match expected criteria.

The greater than operator (>) checks if the left operand exceeds the right operand. For instance, 10 > 5 returns True, but 5 > 10 returns False. This operator enables comparisons in sorting algorithms, validation checks ensuring values exceed minimums, and range checks.

The less than operator (<) determines if the left operand is smaller than the right operand. The expression 3 < 7 evaluates to True, while 7 < 3 returns False. Common uses include checking if values fall below thresholds, implementing upper bounds in loops, and performing range validations.

The greater than or equal to operator (>=) returns True if the left operand is greater than or equal to the right operand. For example, 5 >= 5 and 6 >= 5 both return True, while 4 >= 5 returns False. This operator is essential for inclusive range checks and boundary conditions.

The less than or equal to operator (<=) checks if the left operand is less than or equal to the right operand. The expression 5 <= 5 and 4 <= 5 both evaluate to True, but 6 <= 5 returns False. This operator complements >= for defining ranges and implementing boundary conditions.

Chaining Comparison Operators

Python supports chaining comparison operators, a feature that makes range checks more readable. Instead of writing x > 0 and x < 10, you can write 0 < x < 10. Both expressions check if x is between 0 and 10 (exclusive), but the chained version reads more naturally, resembling mathematical notation.

Chained comparisons can include multiple operators: a < b <= c < d checks that a is less than b, b is less than or equal to c, and c is less than d. Python evaluates each comparison and returns True only if all conditions are true. This feature enables elegant expression of complex conditions that would otherwise require multiple logical operators.

Comparing Different Data Types

Comparison operators work with various data types beyond numbers. String comparisons use lexicographic (dictionary) order based on character Unicode values. For example, "apple" < "banana" returns True because ‘a’ comes before ‘b’ alphabetically. Case matters: uppercase letters come before lowercase in Unicode, so "Apple" < "apple" returns True.

List comparisons occur element by element from left to right. Python compares the first elements; if they’re equal, it compares the second elements, and so on. For instance, [1, 2, 3] < [1, 2, 4] returns True because the third elements differ and 3 < 4. This lexicographic comparison extends to tuples and other sequence types.

Practical Comparison Examples

Age verification demonstrates basic comparison: if age >= 18: print("Adult"). Grade classification uses multiple comparisons: if score >= 90: grade = "A" elif score >= 80: grade = "B". Password validation might check length: if len(password) >= 8: print("Valid length").

These practical examples show how comparison operators enable decision-making in programs. Whether validating user input, implementing business logic, or controlling program flow, comparison operators provide the foundation for conditional execution.

Logical Operators: Combining Conditions

Logical operators combine multiple conditions or Boolean values, enabling complex decision-making logic. Python provides three logical operators: and, or, and not, which work with Boolean values or expressions that evaluate to Boolean results.

The AND Operator

The and operator returns True only if both operands are True. If either operand is False, the entire expression evaluates to False. For example, True and True returns True, but True and False, False and True, and False and False all return False.

In practical use, and validates that multiple conditions hold simultaneously. Consider age and license verification: if age >= 18 and has_license: print("Can drive"). Both conditions must be true for the message to print. This operator enables implementing multiple requirement checks elegantly.

Python’s and operator uses short-circuit evaluation, meaning if the first operand is False, Python doesn’t evaluate the second operand because the result is already determined to be False. This behavior improves performance and enables safe conditional access patterns like if user and user.is_active: where the second condition is only checked if user exists.

The OR Operator

The or operator returns True if at least one operand is True. Only when both operands are False does the expression evaluate to False. For example, True or False returns True, as do True or True and False or True. Only False or False returns False.

Common use cases include providing alternatives or defaults. For instance, color = user_choice or "blue" assigns the user’s choice if provided (truthy), otherwise defaults to “blue”. Similarly, if is_admin or is_moderator: grant_access() grants access if either condition is true.

Like and, the or operator short-circuits: if the first operand is True, Python doesn’t evaluate the second operand because the result is already True. This optimization enables patterns like value = cache_lookup() or expensive_calculation() where the expensive operation only executes if the cache miss occurs.

The NOT Operator

The not operator is a unary operator that inverts Boolean values. It returns True if the operand is False, and False if the operand is True. For example, not True returns False, while not False returns True. This operator negates conditions, enabling reverse logic checks.

Practical applications include checking for absence: if not user_logged_in: redirect_to_login(). Validating that lists aren’t empty: if not empty_list: process_items() (empty lists are falsy in Python). Toggling Boolean flags: enabled = not enabled switches between True and False.

The not operator works with Python’s truthiness concept where various values evaluate to True or False in Boolean contexts. Empty sequences, zero, None, and False are falsy; everything else is truthy. Therefore, not [] returns True because empty lists are falsy.

Combining Logical Operators

Complex conditions often combine multiple logical operators. Parentheses clarify precedence and group conditions: if (age >= 18 and has_license) or is_supervised: allow_driving(). Without parentheses, not has highest precedence, followed by and, then or, but explicit grouping improves readability.

De Morgan’s Laws help simplify logical expressions. The law states that not (A and B) equals (not A) or (not B), and not (A or B) equals (not A) and (not B). Understanding these equivalences enables refactoring complex conditions for clarity or efficiency.

Practical Logical Operator Examples

User authentication combines conditions: if username == stored_user and password == stored_pass: login(). Form validation ensures all required fields are completed: if name and email and age >= 18: submit_form(). Access control checks multiple permissions: if user.is_admin or (user.is_author and owns_resource): grant_edit_access().

These examples demonstrate how logical operators enable sophisticated decision-making by combining simple conditions into complex Boolean expressions that model real-world requirements accurately and efficiently.

Assignment Operators: Storing and Updating Values

Assignment operators store values in variables, forming the foundation of stateful programming. Python provides a basic assignment operator and several compound assignment operators that combine arithmetic operations with assignment, enabling concise value updates.

Basic Assignment Operator

The assignment operator (=) stores the value on the right side into the variable on the left side. For example, x = 5 assigns the value 5 to variable x. Unlike mathematical equations, assignment is not bidirectional; x = 5 makes sense, but 5 = x causes an error.

Python supports multiple assignment patterns. Parallel assignment assigns multiple variables simultaneously: x, y, z = 1, 2, 3. This feature enables elegant value swapping: a, b = b, a exchanges values without temporary variables. Unpacking sequences into variables leverages this capability: first, second, third = [10, 20, 30].

Chain assignment assigns the same value to multiple variables: x = y = z = 0 initializes three variables to zero. While convenient, use chain assignment cautiously with mutable objects because all variables reference the same object. For example, list1 = list2 = [] creates one list referenced by both variables, so modifying one affects both.

Compound Assignment Operators

Addition assignment (+=) adds the right operand to the variable and stores the result. The expression x += 5 is equivalent to x = x + 5 but more concise. This operator works with numbers, strings, and lists: text += " more" appends to strings, while my_list += [4, 5] extends lists.

Subtraction assignment (-=) subtracts the right operand from the variable. For example, x -= 3 is shorthand for x = x - 3. Common uses include countdown counters, reducing inventory quantities, and adjusting running totals. This operator only works with numeric types that support subtraction.

Multiplication assignment (*=) multiplies the variable by the right operand. The expression x *= 2 doubles the value of x, equivalent to x = x * 2. This operator also repeats sequences: text *= 3 triples a string’s content, useful for creating separator lines or padding.

Division assignment (/=) divides the variable by the right operand, storing the floating-point result. For instance, x /= 4 is equivalent to x = x / 4. Remember that this always produces a float, even when dividing evenly: x = 10; x /= 2 results in x being 5.0, not 5.

Floor division assignment (//=) performs floor division and assigns the integer result. The expression x //= 3 is shorthand for x = x // 3. This operator is useful when you need integer division results, such as calculating how many complete groups fit into a quantity.

Modulus assignment (%=) applies the modulus operator and assigns the remainder. For example, x %= 3 is equivalent to x = x % 3. Applications include implementing circular buffers, rotating through array indices, and extracting digits from numbers.

Exponentiation assignment (=)** raises the variable to the power of the right operand. The expression x **= 2 squares x, equivalent to x = x ** 2. This operator provides concise syntax for iterative power calculations and exponential growth scenarios.

Also Read: How to Become a Programmer

Bitwise Compound Assignment Operators

Python also provides compound assignment operators for bitwise operations: &= (bitwise AND), |= (bitwise OR), ^= (bitwise XOR), >>= (right shift), and <<= (left shift). While less common in everyday programming, these operators are essential for low-level operations, flag manipulation, and performance-critical code.

Best Practices for Assignment Operators

Use compound assignment operators for clarity and conciseness when updating variables based on their current values. They signal intent clearly: counter += 1 obviously increments a counter, while counter = counter + 1 requires more mental parsing. Compound operators also marginally improve performance by avoiding duplicate name lookups.

Be mindful of operator precedence when using compound assignments in complex expressions. The right side evaluates completely before assignment: x += 1 + 2 adds 3 to x, not 1. Use parentheses when necessary to ensure correct evaluation order.

Avoid overly complex expressions with compound assignments. While x += y * z // 2 - 1 is valid, breaking it into multiple steps improves readability: temp = y * z // 2 - 1; x += temp. Clear code beats clever code.

Bitwise Operators: Manipulating Binary Representations

Bitwise operators perform operations on the binary representations of integers, manipulating individual bits. While less commonly used in high-level programming, these operators are essential for low-level operations, performance optimization, and working with binary data.

Understanding Binary Representation

Before exploring bitwise operators, understanding binary representation is crucial. Computers store integers as sequences of bits (0s and 1s). The decimal number 5 is represented as 0101 in binary (4-bit), calculated as 0×8 + 1×4 + 0×2 + 1×1 = 5. Python’s bin() function converts integers to binary string representation: bin(5) returns '0b101'.

Bitwise AND Operator (&)

The bitwise AND operator (&) compares corresponding bits of two integers, returning 1 only if both bits are 1, otherwise 0. For example, 5 & 3 converts to binary as 0101 & 0011, resulting in 0001 (decimal 1). Each bit position is ANDed: position 0 is 1 & 1 = 1, position 1 is 0 & 1 = 0, position 2 is 1 & 0 = 0, and position 3 is 0 & 0 = 0.

Common applications include extracting specific bits (masking), checking if numbers are even (n & 1 == 0 checks if the least significant bit is 0), and implementing flags. Bitwise AND with a mask isolates desired bits: value & 0x0F extracts the lower 4 bits.

Bitwise OR Operator (|)

The bitwise OR operator (|) compares bits, returning 1 if either bit is 1. For instance, 5 | 3 in binary is 0101 | 0011, resulting in 0111 (decimal 7). Each position ORs: 1 | 1 = 1, 0 | 1 = 1, 1 | 0 = 1, 0 | 0 = 0.

Applications include setting specific bits and combining flags. To set the third bit of a number: value | 0b100. To combine permission flags: permissions = READ | WRITE | EXECUTE where each permission is a power of 2.

Bitwise XOR Operator (^)

The bitwise XOR (exclusive OR) operator (^) returns 1 if bits differ, 0 if they’re the same. For example, 5 ^ 3 is 0101 ^ 0011, yielding 0110 (decimal 6). Each position XORs: 1 ^ 1 = 0, 0 ^ 1 = 1, 1 ^ 0 = 1, 0 ^ 0 = 0.

XOR has interesting properties: any number XORed with itself is 0 (n ^ n = 0), and any number XORed with 0 is itself (n ^ 0 = n). These properties enable elegant solutions like finding the unique element in an array where all others appear twice, or swapping values without temporary variables.

Bitwise NOT Operator (~)

The bitwise NOT operator (~) is a unary operator that inverts all bits, changing 1 to 0 and 0 to 1. However, Python uses two’s complement representation for negative numbers, so ~n equals -(n + 1). For instance, ~5 returns -6 because inverting 0101 and interpreting with two’s complement yields -6.

This operator is less commonly used in application code but appears in low-level programming and bitwise arithmetic algorithms. Understanding two’s complement representation is essential for predicting NOT operation results.

Bit Shift Operators

The left shift operator (<<) shifts bits left by specified positions, filling right side with zeros. For example, 5 << 1 shifts 0101 left by 1, yielding 1010 (decimal 10). Left shifting by n positions multiplies by 2^n: 5 << 2 equals 5 * 4 = 20.

The right shift operator (>>) shifts bits right, discarding rightmost bits. For instance, 5 >> 1 shifts 0101 right by 1, resulting in 0010 (decimal 2). Right shifting by n positions divides by 2^n (floor division): 20 >> 2 equals 20 // 4 = 5.

Bit shifting provides efficient multiplication and division by powers of 2, though modern compilers optimize regular multiplication/division, making explicit bit shifting primarily useful for algorithm implementation and bit manipulation tasks.

Practical Bitwise Examples

Permission systems use bitwise operations: HAS_READ = user_permissions & READ_FLAG. Toggling bits: value ^= (1 << bit_position). Checking if a power of 2: is_power_of_2 = n > 0 and (n & (n - 1)) == 0. Setting a bit: value |= (1 << n). Clearing a bit: value &= ~(1 << n).

While high-level Python programming rarely requires bitwise operators, understanding them proves valuable for performance optimization, working with binary protocols, implementing algorithms, and understanding low-level computer operations.

Membership Operators: Testing Containment

Membership operators test whether a value exists within a sequence (string, list, tuple, set, or dictionary). Python provides two membership operators: in and not in, which return Boolean values indicating presence or absence.

The IN Operator

The in operator returns True if the specified value exists in the sequence, otherwise False. For strings: 'y' in 'Python' returns True. For lists: 3 in [1, 2, 3, 4] returns True. For dictionaries: 'name' in user_dict checks if the key exists (not the value).

Common applications include validation: if user_input in valid_options: process(). Filtering: filtered = [x for x in items if x in allowed]. Conditional logic: if '@' in email: validate_email(). The in operator provides readable, Pythonic syntax for containment checks.

For dictionaries, in checks keys by default. To check values, use: value in dict.values(). To check key-value pairs, use: ('name', 'John') in dict.items(). Understanding these distinctions prevents common mistakes when working with dictionaries.

The NOT IN Operator

The not in operator returns True if the value doesn’t exist in the sequence. For example, 'z' not in 'Python' returns True. This operator combines containment checking with negation, providing readable syntax for absence checks.

Practical uses include validation: if username not in banned_users: allow_login(). Filtering exclusions: cleaned = [x for x in data if x not in outliers]. Avoiding duplicates: if item not in collection: collection.append(item).

The not in operator is equivalent to not (x in y) but more readable. Prefer x not in y over not x in y for clarity, though both work identically due to operator precedence.

Performance Considerations

Membership operators have different performance characteristics for different data structures. For lists and tuples, containment checking is O(n) – Python must potentially check every element. For sets and dictionaries, it’s O(1) on average due to hash-based lookups.

When performing frequent containment checks, convert lists to sets for better performance: valid_set = set(valid_list) then if x in valid_set:. This conversion has overhead but pays off when checking multiple values. For single checks on small sequences, lists work fine.

String membership checking uses efficient algorithms but still requires scanning, so performance depends on string length. For pattern matching beyond simple substring containment, use the re module’s regular expressions.

Practical Membership Examples

Input validation: if option in ['yes', 'no', 'maybe']: process_option(). Removing vowels: consonants = ''.join([c for c in text if c not in 'aeiou']). Checking file extensions: if filename.endswith('.txt') or '.txt' in filename:. Finding common elements: common = [x for x in list1 if x in list2].

Membership operators provide elegant, readable syntax for common programming patterns involving containment checks, making Python code more expressive and maintainable.

Identity Operators: Comparing Object Identity

Identity operators compare object identity rather than equality, determining whether variables reference the same object in memory. Python provides two identity operators: is and is not, which are distinct from equality operators == and !=.

Understanding Object Identity vs. Equality

In Python, every object has an identity (memory address), a type, and a value. The id() function returns an object’s identity as an integer. Two variables can have equal values (checked with ==) while referencing different objects (different id() values), or they can reference the same object (same id(), checked with is).

Consider: a = [1, 2, 3] and b = [1, 2, 3]. Here a == b returns True (equal values) but a is b returns False (different objects). However, c = a makes c reference the same object as a, so c is a returns True.

The IS Operator

The is operator returns True if both operands reference the same object. For example, x is y checks if x and y point to identical memory locations. Common usage includes checking for None: if value is None: is the preferred idiom rather than if value == None:.

Python caches small integers (typically -5 to 256) and string literals for efficiency, so a = 5; b = 5 results in a is b returning True because both reference the cached integer object. However, this optimization is implementation-specific and shouldn’t be relied upon for logic.

Checking for singleton objects (like None, True, False) should use is rather than == because there’s only one instance of each. The pattern if value is None: is both more efficient and more explicit than if value == None:.

The IS NOT Operator

The is not operator returns True if operands reference different objects. For example, x is not y checks if x and y point to different memory locations. This operator combines identity checking with negation.

Common usage: if value is not None: process(value) ensures value is not the None singleton before processing. List copying: new_list = old_list[:] creates a copy where new_list is not old_list returns True.

Like not in, prefer is not over not is for readability: x is not y reads more naturally than not x is y, though both work identically.

When to Use Identity vs. Equality

Use identity operators (is, is not) when checking for specific singleton objects (None, True, False) or when you specifically need to know if two variables reference the same object. Use equality operators (==, !=) when comparing values regardless of object identity.

For example, comparing lists should usually use == to check if contents match: list1 == list2. Use is only when you need to verify they’re the same list object: list1 is list2. Misusing identity operators can cause subtle bugs.

Common Pitfalls and Best Practices

Never use is to compare numbers, strings, or other values unless specifically checking for singleton objects. The expression x is 5 might work with small integers due to caching but fails with larger numbers: x = 1000; x is 1000 might return False depending on implementation.

Always use is None rather than == None when checking for None. This is a PEP 8 recommendation and the standard Python idiom. Tools like linters flag == None as problematic code.

Understanding the distinction between identity and equality prevents bugs and enables writing more precise, Pythonic code that clearly expresses intent through appropriate operator selection.

Operator Precedence and Associativity

Operator precedence determines the order in which operations execute when expressions contain multiple operators. Associativity determines evaluation order for operators with equal precedence. Understanding these concepts is crucial for writing correct expressions and debugging unexpected results.

Python Operator Precedence Hierarchy

Python evaluates operators in the following order from highest to lowest precedence:

Highest Precedence: Parentheses () force evaluation order, overriding other precedence rules. Use parentheses liberally to make intentions explicit even when not strictly necessary.

Exponentiation: The ** operator has the second-highest precedence. For example, 2 * 3 ** 2 calculates as 2 * 9 = 18 because exponentiation occurs before multiplication.

Unary operators: Unary plus +, unary minus -, and bitwise NOT ~ come next. For instance, -3 ** 2 equals -9 (not 9) because unary minus has lower precedence than exponentiation.

Multiplication, division, and related: Operators *, /, //, and % share equal precedence, evaluated left to right. For example, 10 / 2 * 3 calculates as (10 / 2) * 3 = 15.

Addition and subtraction: Operators + and - have equal precedence below multiplication. For instance, 10 + 5 * 2 calculates as 10 + 10 = 20.

Bitwise shifts: Operators << and >> come next, below arithmetic operators.

Bitwise AND: The & operator follows shifts in precedence.

Bitwise XOR: The ^ operator follows AND.

Bitwise OR: The | operator follows XOR.

Comparison operators: All comparison operators (<, <=, >, >=, ==, !=) share equal precedence and can be chained.

Identity and membership: Operators is, is not, in, and not in share precedence with comparisons.

Logical NOT: The not operator has higher precedence than and and or.

Logical AND: The and operator comes next.

Lowest Precedence: The or operator has the lowest precedence among operators discussed.

Associativity Rules

When operators have equal precedence, associativity determines evaluation order. Most Python operators are left-associative, meaning they evaluate from left to right. For example, 10 - 5 - 2 calculates as (10 - 5) - 2 = 3, not 10 - (5 - 2) = 7.

The exponentiation operator ** is right-associative, evaluating right to left. Therefore, 2 ** 3 ** 2 calculates as 2 ** (3 ** 2) = 2 ** 9 = 512, not (2 ** 3) ** 2 = 8 ** 2 = 64. This right associativity matches mathematical convention.

Practical Precedence Examples

Consider the expression result = 10 + 5 * 2 ** 3 // 4 - 1. Python