📊 Day 02 : Operators and Expressions

🎯 Enterprise Objective

Operators are the verbs of Python — they act on data. Today we master every operator category, from basic arithmetic to bitwise manipulation and the modern walrus operator. You will learn not just what each operator does, but when and why to use it in professional data pipelines.

📋 Strategic Overview

Python has 7 built-in arithmetic operators: + (add), - (subtract), (multiply), / (true division), // (floor division), % (modulo), and * (exponentiation). These are the fundamental building blocks for all numerical computations.

Quick Reference:

• Financial calculations: profit = revenue - costs

• Metrics generation: margin = (profit / revenue) * 100

• Batch processing: Using modulo % to execute code every Nth row

The / operator always returns a float, even if the result is whole: 10 / 2 → 5.0. Use // for integer results.

Exponentiation evaluates right-to-left: 232 = 2(32) = 29 = 512, not (23)**2 = 64.

Assignment operators combine an arithmetic or bitwise operation with assignment. Instead of writing x = x + 5, you write x += 5. Python supports: +=, -=, =, /=, //=, %=, *=, and bitwise variants.

• Running totals: Accumulating sums in loops: total += row_value

• Counter patterns: count += 1 is the most common pattern in data pipelines

• Scaling: Normalize columns: col *= scale_factor

For immutable types like str and tuple, += creates a new object rather than modifying in-place. This can be a performance trap in tight loops.

Use x = -1 to flip the sign of a number. Use x *= 0.5 for square root.

Comparison operators evaluate two values and return a bool (True or False). Python supports: ==, !=, <, >, <=, >=. A unique Python feature is chained comparisons: 1 < x < 10.

• Data filtering: df[df['age'] >= 18] — core of pandas filtering

• Validation: Check thresholds: if revenue > target:

• Sorting logic: Custom sort keys rely on < and > comparisons

Python supports chained comparisons: 0 <= x < 100 is equivalent to 0 <= x and x < 100 but cleaner and faster.

Python has three logical operators: and, or, and not. They combine boolean expressions. Crucially, and and or use short-circuit evaluation — they stop evaluating as soon as the result is determined.

• Multi-condition filters: df[(df['age'] > 18) & (df['score'] > 90)]

• Data validation: if name and len(name) > 0: — safe null checking

• Default values: result = value or 'N/A' — using or for defaults

• Null checking: if value is None: — the Pythonic way to check for null

• Data validation: if col in df.columns: — safe column access

• Search & lookup: if key in my_dict: — O(1) dict membership

Python caches integers from -5 to 256. So a = 100; b = 100; a is b → True, but a = 1000; b = 1000; a is b → False (different objects, same value).

For dict and set, in is O(1). For list, in is O(n). Choose your data structure wisely for frequent membership tests.

Bitwise operators work on the binary (base-2) representation of integers. Python supports: & (AND), | (OR), ^ (XOR), ~ (NOT), << (left shift), >> (right shift).

• Flag management: Using bitmasks to store multiple boolean flags in one integer

• Performance: Left shift << 1 is faster multiplication by 2

• Hashing: XOR is used in hash functions and checksums

The ternary (conditional) operator provides a one-line if-else expression: value_if_true if condition else value_if_false. It is an expression (returns a value), not a statement.

status = 'Adult' if age >= 18 else 'Minor'

• Column creation: df['label'] = df['val'].apply(lambda x: 'High' if x > 50 else 'Low')

• Default handling: name = input_val if input_val else 'Unknown'

• Compact logic: Replace 4-line if/else blocks with clean one-liners

Nesting ternaries like 'A' if x > 90 else 'B' if x > 80 else 'C' works but reduces readability. Use sparingly.

When an expression has multiple operators, Python follows a strict precedence hierarchy. Higher-precedence operators are evaluated first. When precedence is equal, associativity (left-to-right or right-to-left) determines the order.

• Debugging: Understanding precedence prevents subtle calculation bugs

• Code clarity: Explicit parentheses make complex formulas readable

• Formula translation: Converting math formulas to code requires correct operator order

When in doubt, use parentheses. They cost nothing at runtime and prevent bugs: (a + b) * c is clearer than relying on precedence.

Short-circuit evaluation means Python stops evaluating a boolean expression as soon as the result is determined. For and, if the left operand is falsy, the right is never evaluated. For or, if the left is truthy, the right is skipped.

# If x is 0, (10/x) is NEVER executed — no error!
result = x != 0 and (10 / x) > 2

• Safe access: if key in d and d[key] > 0: — prevents KeyError

• Guard clauses: if obj is not None and obj.value > 0: — prevents AttributeError

• Performance: Skip expensive checks when a cheaper one already determines the result

If the right operand has side effects (printing, modifying state), short-circuiting may silently skip them. Never rely on side effects in boolean expressions.

Introduced in Python 3.8, the walrus operator := assigns a value to a variable as part of an expression. It eliminates the need to compute a value on one line and use it on the next.

# Before walrus
data = get_data()
if data:
    process(data)

# After walrus
if (data := get_data()):
    process(data)

• Loop optimization: Avoid calling expensive functions twice in while-loops

• List comprehensions: Filter and transform in one pass: [y for x in data if (y := transform(x)) > 0]

• Inline validation: if (n := len(data)) > 100: print(f'{n} records')

The walrus operator can reduce readability if overused. Only use it when it genuinely eliminates redundancy.

Theory is useless without muscle memory. Complete these tasks to solidify your understanding.

✅ Instructor's End-of-Day Checklist

• [ ] I understand the difference between / (true division) and // (floor division).

• [ ] I know that and/or return actual values, not just True/False.

• [ ] I can use is vs == correctly (identity vs equality).

• [ ] I understand operator precedence and use parentheses for clarity.

• [ ] I can leverage short-circuit evaluation for safe access patterns.

• [ ] I have completed all 5 practice tasks.

• [ ] I have reviewed all 25 interview questions.