A program that only runs top to bottom, one line after another, can do very little. Real software must decide ("is this payment above ₹2,00,000? then ask for OTP"), repeat ("send this reminder to every student in the batch"), and stop or skip ("if the file is empty, move on to the next one"). The set of language features that lets you decide, repeat, skip and stop is called control flow, and it is the subject of this lecture.

In Lecture 2 you learned about variables, data types, operators and strings — the raw materials. Control flow is where those materials become logic. Every Django view, every pandas cleaning script, every FastAPI endpoint and every automation job you will ever write is built from the handful of constructs covered here:

• Conditionals — if, elif, else, conditional expressions, and Python's idea of truthiness.
• Structural pattern matching — the match/case statement added in Python 3.10, which goes far beyond a C-style switch.
• Loops — for with range(), while, and the loop-control keywords break, continue and the rarely understood else clause on loops.
• Looping helpers — enumerate() and zip(), which replace clumsy index arithmetic.
• Comprehensions — list, dict and set comprehensions (plus generator expressions), the most "Pythonic" way to build collections, and the judgement to know when a nested comprehension has become unreadable.
• The walrus operator := (Python 3.8+) — assignment inside an expression.

Why does it matter beyond passing exams? Because Python's control flow is where readability lives. Two developers can produce the same output; the one who uses for item in items instead of for i in range(len(items)), enumerate instead of a manual counter, and a comprehension instead of a four-line append loop writes code that reviewers approve faster and that survives in production longer. Interviewers at Indian product companies and service firms alike test exactly these idioms, because they reveal whether you *think* in Python or merely translate from C or Java.

Everything in this lecture runs on Python 3.12 and above. Python 3.14 is the current stable series as this lecture is written (Python 3.15 is scheduled for October 2026), and we label features with the version that introduced them, such as "3.10+" for match. Run python --version to confirm what you have.

The if statement evaluates a condition; if the condition is true, the indented block runs. Python has no curly braces and no parentheses requirement around the condition — the colon and the indentation (4 spaces, per PEP 8) define the block. This is not cosmetic: wrong indentation is a syntax error or, worse, a silent logic bug.

The full form is if → zero or more elif ("else if") branches → an optional else. Python evaluates the conditions top to bottom and stops at the first true one. This has two practical consequences. First, order your conditions from most specific to most general: if you check marks >= 40 before marks >= 90, a 95 will be graded as "pass" and never reach the "distinction" branch. Second, at most one branch runs, so elif is not the same as a series of separate if statements — separate ifs can all fire, which is sometimes what you want (several independent discounts) and sometimes a bug (a customer getting both the "new user" and the "loyal user" message).

Python 3 has no limit on how many elif branches you may chain, but once you pass four or five, consider a dictionary lookup or a match statement (Section 5) instead — long elif ladders are a known readability smell.

Conditions can be any expression. Comparison operators (==, !=, <, <=, >, >=), membership tests (in, not in), identity tests (is, is not) and the logical operators and, or, not all return values Python can interpret as true or false. Chained comparisons such as 18 <= age < 60 are evaluated as 18 <= age and age < 60, exactly as a mathematician would read them, and they are the preferred way to express a range.

A few conventions used by professional Python teams:

• Compare against None with is None / is not None, never == None.
• Do not write if flag == True: — write if flag:. Do not write if len(items) > 0: — write if items: (see Section 3 on truthiness).
• Prefer early returns / guard clauses inside functions over deeply nested if blocks; the "happy path" should sit at the lowest indentation level.
• Use pass as a placeholder when a branch intentionally does nothing, and leave a comment saying why.

Python does not force you to put a bool inside an if. Any object can be tested for truth. The rule is simple and worth memorising, because it is asked in nearly every Python interview:

• These values are falsy: None, False, every numeric zero (0, 0.0, 0j, Decimal(0), Fraction(0, 1)), every empty sequence or collection ("", [], (), {}, set(), range(0)), and any object whose __bool__() returns False or, failing that, whose __len__() returns 0.
• Everything else is truthy — including the strings "0" and "False", negative numbers, non-empty lists containing only falsy items ([0] is truthy because it has one element), and every function, class and module object.

Truthiness is why idiomatic Python says if items: instead of if len(items) > 0: and if not name: instead of if name == "":. It also powers the short-circuit tricks you will see in real code: display = nickname or full_name picks the first truthy value, and count = data and len(data) evaluates len only when data is non-empty. Note that and and or return one of their operands, not a bare True/False — "" or "guest" evaluates to "guest".

There is one important trap: truthiness cannot distinguish "no value" from "zero". If a function may legitimately return 0 (a balance, a count, an index) and None means "not found", you must write if result is not None:, not if result:. A rupee balance of 0 is a real balance, not a missing one.

Conditional expressions (often called Python's ternary operator) let you choose between two values in a single expression: value_if_true if condition else value_if_false. The condition is in the middle, which surprises people coming from C or JavaScript (cond ? a : b). Use it when both outcomes are short, simple values — a label, a default, a number. Do not chain more than two of them together, and never put side effects (function calls that change state) inside the branches; at that point an if block is clearer. Conditional expressions are especially handy inside f-strings, function arguments and comprehensions, where a statement is not allowed.

Python 3.10 introduced the match statement (PEP 634–636). Developers from Java or C often assume it is a switch, but it is much more powerful: it destructures data and binds variables as it matches, so it can look inside tuples, lists, dictionaries and even class instances. The subject after match is evaluated once, then each case pattern is tried from top to bottom, and the first pattern that fits runs its block. There is no fall-through and no break is needed.

The pattern types you will use most:

• Literal patterns — case 200:, case "quit":, case None:. Several alternatives are joined with |: case 401 | 403:.
• Capture patterns — a bare name such as case other: matches anything and binds it to other. This is the source of the most common match bug: writing case RED: to compare with a constant actually *captures* the value into a new variable named RED and matches everything. To compare with a constant, use a dotted name (case Color.RED:) which Python treats as a value, not a capture.
• Wildcard — case _: matches anything without binding; put it last as the default.
• Sequence patterns — case [x, y]: or case ("move", dx, dy): match lists and tuples of that length; case [first, *rest]: captures the remainder. Strings and bytes are deliberately *not* treated as sequences here.
• Mapping patterns — case {"type": "payment", "amount": amt}: matches a dict that has *at least* those keys (extra keys are ignored) and binds amt.
• Class patterns — case Point(x=0, y=0): matches an instance of Point with those attribute values; dataclasses support positional form too.
• Guards — case {"amount": amt} if amt > 200_000: adds an arbitrary condition after the pattern.
• AS patterns — case [int() as code, str() as msg]: binds a sub-pattern to a name.

When should you use match instead of if/elif? When you are branching on the shape of data (a parsed command, an event dict from a webhook, an AST node, a JSON message from a queue) or on one value with many fixed alternatives. For a single boolean condition or two numeric ranges, if is still clearer. Remember also that match is a statement, not an expression — it does not return a value.

A Python for loop is not a counter loop like C's for (i = 0; i < n; i++). It is a for-each loop: for item in iterable: asks the iterable for its elements one by one and assigns each to item. Anything iterable works — lists, tuples, strings (character by character), dictionaries (keys by default), sets, files (line by line), generators, and the result of functions like range(), enumerate(), zip(), sorted() and reversed().

When you *do* need a sequence of numbers, use range(). It takes up to three integers: range(stop) counts from 0 up to but not including stop; range(start, stop) begins at start; range(start, stop, step) moves by step, which may be negative to count down. range(5) therefore yields 0, 1, 2, 3, 4 — five numbers, never 5 itself. This half-open convention matches slicing (items[0:5]) and makes range(len(items)) always produce valid indices.

Three facts about range that beginners miss:

• It is lazy. range(10_000_000) does not allocate ten million integers; it stores just start, stop and step and produces values on demand. Wrap it in list() only if you really need a list.
• It is a full sequence type: len(range(0, 100, 7)) works, 5 in range(10) is an O(1) check, and range(10)[-1] returns 9.
• It only accepts integers. For floating-point steps (0.0, 0.1, 0.2 ...) use a loop with integer counts and divide, or numpy.arange/numpy.linspace.

The most important style rule: loop over the collection directly. for i in range(len(names)): print(names[i]) is the number-one sign of a developer who has not yet learned Python. Write for name in names:. If you also need the index, use enumerate() (Section 8). When iterating a dictionary, use .items() to get key–value pairs, .values() for values only. Tuple unpacking in the loop header (for name, marks in students:) keeps loops flat and readable.

Finally, the loop variable survives after the loop ends — after for i in range(3): pass, i is 2. Comprehensions (Section 9) do not leak their variable this way.

A while loop repeats as long as its condition is true, checking the condition *before* every iteration. Use it when you do not know in advance how many times to loop: reading user input until it is valid, polling an API until a job finishes, retrying a network call with back-off, running a game loop, or consuming a queue until it is empty. If you know the count or you are walking through a collection, a for loop is almost always the better tool.

The anatomy of a correct while loop has three parts: initialise a state variable before the loop, test it in the condition, and update it inside the body. Forget the update and you have an infinite loop — the most common while bug, and one that can freeze a server. Press Ctrl+C in the terminal to stop a runaway script (Python raises KeyboardInterrupt).

A deliberate infinite loop, while True:, is a legitimate and common pattern when the exit condition lives in the middle of the body rather than at the top; you leave it with break (Section 7) or return. Python has no do ... while statement; while True: with a break at the end of the body is the idiomatic substitute when the body must run at least once.

Good defensive habits for production while loops:

• Put a maximum attempt count or timeout in the condition for anything that waits on an external system: while not done and attempts < 5:.
• Use time.sleep() between polls so you do not hammer the API (and prefer exponential back-off: 1 s, 2 s, 4 s ...).
• Make the condition a clear boolean expression; if it needs three lines of logic, compute a named variable first.

The while statement also accepts an else clause, covered in the next section along with break and continue.

Both for and while loops accept three control keywords that change the normal flow.

break exits the innermost loop immediately; execution continues after the loop. Use it when you have found what you were looking for (searching a list for the first match), when a sentinel value arrives ("STOP" in a data stream), or to leave a while True: loop. Note that break only leaves one level of nesting. To exit nested loops, either put the loops in a function and return, raise an exception, use a flag variable, or restructure so the inner iteration is a single comprehension or any()/all() call.

continue skips the rest of the current iteration and jumps to the next one. It is ideal for filtering out items early ("if the row is a comment line, continue") so that the main body stays unindented — another form of the guard-clause style from Section 2. Over-using continue in long bodies hurts readability, so keep the skipped-case checks at the top of the loop.

else on a loop is a Python-specific feature that puzzles even experienced developers. The else block runs when the loop finishes normally — that is, without hitting break. For a for loop that means the iterable was exhausted; for a while loop that means the condition became false. If break fires, else is skipped. A helpful way to read it is "else = no break". The classic use case is a search: loop over candidates, break when you find one, and let else handle the "not found" case — without a separate found = False flag. Note that else *does* run when the loop body never executed at all (empty iterable), because no break happened.

Interviewers like this one: "What does for ... else do?" Most candidates guess that else runs when the loop did not execute. That is wrong, and the code below demonstrates the actual behaviour.

Two built-in functions remove almost every reason to write index-based loops in Python.

enumerate(iterable, start=0) yields pairs of (index, item). Use it whenever you need the position as well as the value — numbering output lines, locating the index of a match, or updating a list in place by index. The start argument lets you count from 1 for human-facing output ("1. Priya, 2. Rahul") without doing i + 1 everywhere. Combined with tuple unpacking in the loop header, for rank, (name, score) in enumerate(leaderboard, start=1): reads naturally and avoids off-by-one mistakes.

zip(*iterables) walks through several iterables in parallel, yielding a tuple with one element from each. It is the clean way to iterate two related lists (names and marks, questions and answers, columns and values), to build a dictionary from two lists (dict(zip(keys, values))), and to transpose a matrix (list(zip(*rows))). By default zip stops silently at the shortest input — a notorious source of silent data loss when two lists are supposed to be the same length. Since Python 3.10 you can pass strict=True to make zip raise a ValueError if the lengths differ; use it whenever the inputs are supposed to line up. When you intentionally want the longest length with fill values, itertools.zip_longest(a, b, fillvalue=None) does that.

Both functions return lazy iterators, not lists. They consume no extra memory even for huge inputs, but they can be iterated only once — if you need to loop twice, call them again or materialise with list(). You will also see enumerate and zip combined: for i, (a, b) in enumerate(zip(xs, ys)):.

Other iteration helpers worth knowing at this stage: reversed(seq) to iterate backwards without copying, sorted(iterable, key=..., reverse=...) to loop in a chosen order, and dict.items() for key–value pairs. Together with enumerate and zip, these are the "vocabulary" that makes Python loops short and self-explanatory.

A list comprehension builds a new list from an iterable in a single expression. The general form is [expression for item in iterable if condition], and it is exactly equivalent to creating an empty list, looping, optionally filtering with if, and appending the expression — but shorter, usually faster (CPython avoids the repeated .append() method lookup), and widely considered the most Pythonic way to transform or filter data.

Read a comprehension left to right as an English sentence: "give me name.title() for each name in names if name is not blank". The three parts are:

• The output expression — any expression using the loop variable: a method call, arithmetic, a tuple, an f-string, a conditional expression such as x if x > 0 else 0.
• The for clause — one or more loop variables; tuple unpacking works here too (for name, marks in students).
• An optional filter — if condition at the end; only items that pass are included. Note the difference between the filter if (at the end, no else allowed) and a conditional *expression* in the output position (which must have an else).

Since Python 3, comprehensions have their own scope: the loop variable does not leak into the surrounding function, unlike a plain for loop. That is a point of difference from Python 2 that interviewers still ask about.

When to use a comprehension: when the body of the loop is a single expression that produces one value per item, and you want the resulting list. When not to: when the loop has side effects (printing, writing to a file, calling an API), when you need break, when the logic needs multiple statements, or when you only want to iterate once and never need the whole list in memory — in that last case use a generator expression (Section 10). A comprehension written purely for side effects, such as [print(x) for x in xs], is a well-known anti-pattern: it builds a useless list of None values. Use a plain loop instead.

Performance note: comprehensions are not magic; they are still O(n). Their benefit is clarity and a modest constant-factor speed-up, not an algorithmic one.

The comprehension syntax is not limited to lists. Python offers three more forms, each producing a different kind of object:

Dict comprehensions: {key_expr: value_expr for item in iterable if condition}. They are the natural way to build a lookup table — mapping a student ID to a record, inverting an existing dictionary ({v: k for k, v in d.items()}), filtering a dictionary ({k: v for k, v in prices.items() if v < 500}), or transforming values ({k: v * 1.18 for k, v in prices.items()}). If two items produce the same key, the last one wins silently, because dictionary keys are unique; be deliberate about that when inverting a dict with duplicate values.

Set comprehensions: {expr for item in iterable if condition} — the same braces as a dict comprehension but without the colon. They produce a set, so duplicates are removed automatically and order is not guaranteed. Use them for "the unique X in this data": unique cities in a list of orders, unique file extensions in a directory, unique words in a text. Remember that {} on its own is an empty dict, not an empty set; use set() for that.

Generator expressions: (expr for item in iterable if condition) — parentheses instead of brackets. A generator expression does not build a collection; it produces values lazily, one at a time, as something consumes them. That makes it the right choice when you are going to feed the result straight into sum(), max(), min(), any(), all(), sorted(), ", ".join() or a for loop and never need the intermediate list. sum(x * x for x in range(10**7)) runs in constant memory; the list-comprehension version would allocate a list of ten million integers first. When a generator expression is the only argument to a function call, you can drop the extra parentheses, as in sum(x for x in xs). A generator can be consumed only once — after that it is empty.

A quick decision guide: need a list to index or reuse? List comprehension. Need key → value lookup? Dict comprehension. Need uniqueness or membership tests? Set comprehension. Only passing the values through once to another function? Generator expression. There is no tuple comprehension; tuple(x for x in xs) is the way to get a tuple.

Comprehensions may contain more than one for clause. Two patterns look similar but behave very differently, and confusing them is a classic interview trap.

Multiple for clauses in one comprehension produce a flat list. [(x, y) for x in range(3) for y in "ab"] yields six tuples — the clauses nest left to right exactly as if you had written the loops one inside the other, with the leftmost loop outermost. This is how you flatten a list of lists: [cell for row in matrix for cell in row] ("for each row, for each cell in that row"). A later for clause can refer to the variable of an earlier one, which is why the order matters: [cell for cell in row for row in matrix] raises NameError because row is not yet defined when the first clause runs.

A comprehension inside the output expression produces a nested list: [[row * col for col in range(1, 4)] for row in range(1, 4)] builds a list of three inner lists — a 2-D grid. This is the correct way to create a matrix of independent rows. The tempting shortcut [[0] * 3] * 3 creates three references to the *same* inner list, so changing one cell changes every row; a nested comprehension avoids that bug.

Now the judgement call. Python's own style guide (PEP 8) and every senior reviewer agree: a comprehension that needs more than about two clauses, or that no longer fits comfortably on one or two lines, should become a loop. A triple-nested comprehension with two filters and a conditional expression is technically valid and technically shorter, but the next developer (often you, three months later) will have to mentally unroll it. Practical rules of thumb used in code review:

• At most two for clauses, at most one if, and one simple output expression. Beyond that, write a function or a plain loop.
• If you need to name an intermediate value to explain it, you need a loop (or the walrus operator for the simplest cases — see Section 12).
• Break long comprehensions across lines, one clause per line, inside the brackets; Python allows this freely.
• Prefer built-ins that say what you mean over clever comprehensions: sum(...), any(...), all(...), sorted(...), itertools.chain.from_iterable(...) for flattening.

Readability is a feature. A comprehension exists to make intent obvious; the moment it hides intent, it has failed at its only job.

Python 3.8 introduced assignment expressions, written with := and nicknamed the walrus operator because the symbol looks like a walrus's eyes and tusks (PEP 572). A normal assignment (x = 5) is a *statement* — it cannot appear inside a condition or a comprehension. The walrus operator assigns and returns the value, so it can be used wherever an expression is allowed: inside an if or while condition, inside a comprehension, or inside a function call.

The operator exists to remove a specific kind of duplication. Before 3.8, "compute something, test it, and then use it" needed either two statements (assign, then if) or computing the same thing twice. Typical wins:

• Read-and-test loops: while (chunk := file.read(4096)): replaces the awkward while True: chunk = ...; if not chunk: break dance.
• Regex matching: if (m := pattern.search(line)): print(m.group(1)) — bind the match object and test it in one step.
• Comprehensions that reuse an expensive result: [y for x in data if (y := transform(x)) is not None] calls transform once per item instead of twice. Note the variable y is bound in the *enclosing* scope (unlike the loop variable), and you cannot use the walrus to assign to the comprehension's own iteration variable.
• Guarding on a length or a lookup: if (n := len(items)) > 10: print(f"too many: {n}").

Rules and restrictions that keep it from being abused:

• At the top level of an expression statement you must use parentheses: (y := 5) is allowed, bare y := 5 is a SyntaxError. The same applies to keyword arguments and the right side of a normal assignment.
• It cannot assign to attributes or subscripts — only to a plain name.
• It is not a replacement for =. If the value is not reused inside the same expression, a normal assignment on its own line is clearer.

Use the walrus when it removes a repeated call or a clumsy extra statement, and only when the result reads naturally. Overuse makes code look clever rather than clear, and many teams limit it to the while-read and regex-match patterns.

The constructs from this lecture appear in every corner of professional Python. Recognising the pattern behind each one helps you choose the right tool quickly.

Request routing and validation in web backends. A FastAPI or Django handler begins with guard clauses: if not user.is_active: raise HTTPException(403); if amount <= 0: return error. Webhook handlers from payment gateways (Razorpay, Stripe) receive JSON events of varying shape, and a match statement on {"event": "payment.captured", "payload": {...}} is the cleanest dispatcher — the mapping pattern pulls out exactly the keys needed and the guard enforces business rules.

Data cleaning in pandas and ETL scripts. Before data reaches a DataFrame, a Python loop with continue skips malformed rows, a dict comprehension renames columns ({col: col.strip().lower() for col in header}), a set comprehension finds unique categories, and zip(header, row, strict=True) turns CSV rows into records while catching ragged lines. Generator expressions stream gigabytes of log lines through sum() or max() without loading them into memory.

Automation and DevOps scripts. A deployment script polls a health endpoint with while not healthy and attempts < 10: plus exponential back-off; a backup job uses for path in Path("/data").rglob("*.csv"): with enumerate to report progress ("Processing file 37 of 212"); and for ... else decides whether any server in the fleet failed the check.

Retry loops around network calls. Every production HTTP client wraps httpx.get() in a bounded while/for loop with break on success and else to raise after the final attempt — exactly the pattern from Section 7.

Reporting and dashboards. Comprehensions aggregate: {city: sum(o.amount for o in orders if o.city == city) for city in cities} builds a per-city revenue summary in one readable line; sorted(..., key=...) plus enumerate(start=1) produces a ranked leaderboard.

Command-line tools and bots. A Telegram or Slack bot parses a command string into a tuple and dispatches with match ("remind", when, *text):, which is far more robust than a chain of startswith checks.

Interview coding rounds. Most "easy" and "medium" problems — two-sum, prime sieve, matrix transpose, grouping anagrams, parsing brackets — are solved with precisely these tools: for with enumerate, a while with two pointers, a dict comprehension, and early break. Fluency here is what lets you spend interview time on the algorithm instead of the syntax.

These are the errors that show up again and again in code reviews, student submissions and Stack Overflow questions. Each one has a simple fix.

1. Using = instead of == in a condition. if x = 5: is a SyntaxError in Python (a deliberate safety feature), but the confusion leads people to write if (x := 5): after learning the walrus, which *always* succeeds. Fix: use == for comparison; reserve := for cases where you genuinely need the assigned value.

2. Wrong elif order. Checking marks >= 40 before marks >= 90 means nobody ever gets a distinction. Fix: order branches from most specific to most general, and write a test with a boundary value for each branch.

3. Testing if value: when 0 or "" is a valid value. A balance of ₹0 or an empty search string is silently treated as "missing". Fix: if value is not None: when the sentinel is None.

4. Modifying a list while iterating over it. for x in items: if cond(x): items.remove(x) skips elements because the indices shift under the loop. Fix: build a new list with a comprehension (items = [x for x in items if not cond(x)]) or iterate over a copy (for x in items[:]). The same applies to adding or deleting dictionary keys during iteration, which raises RuntimeError: dictionary changed size during iteration.

5. range(len(items)) and manual counters. Not a crash, but a readability failure. Fix: for item in items:, enumerate() when you need the index, zip() for parallel lists.

6. Infinite while loops. Forgetting to update the loop variable, or updating it in a branch that is skipped by continue. Fix: keep init/test/update visible, and add a maximum-iteration guard for loops that depend on external state.

7. Misreading for ... else. Assuming else runs when the loop body never executed. Fix: remember "else means no break"; if you want "ran zero times", test the collection before the loop.

8. Capture pattern instead of value pattern in match. case RED: captures anything into a new RED variable. If it is the last case it silently matches everything; if another case follows it, Python refuses to compile with "SyntaxError: name capture 'RED' makes remaining patterns unreachable". Fix: use a dotted name such as case Color.RED: or a literal.

9. Confusing a filter if with a conditional expression in comprehensions. [x if x > 0 for x in xs] is a SyntaxError because an output-position conditional needs else. Fix: either [x for x in xs if x > 0] (filter) or [x if x > 0 else 0 for x in xs] (transform).

10. zip() silently truncating. Two lists that should match but do not lose data without any error. Fix: zip(a, b, strict=True) on Python 3.10+.

11. [[0] * n] * m for a grid. All rows are the same object. Fix: [[0] * n for _ in range(m)].

12. Comprehensions for side effects. [print(x) for x in xs] builds a list of None. Fix: a plain for loop.

13. Mixing tabs and spaces / inconsistent indentation. Python 3 raises TabError when tabs and spaces are mixed inconsistently in the same block. Fix: configure your editor to insert 4 spaces per Tab press (VS Code does this by default for Python) and never paste indented code from a browser without checking.

What is the difference between if-elif-else and multiple if statements in Python?

In an if/elif/else chain, Python stops at the first condition that is true, so exactly one branch runs. With separate if statements, every condition is tested independently and any number of them can run. Use elif for mutually exclusive choices (grade bands) and separate ifs for independent checks (several discounts that can all apply).

Does Python have a switch statement?

Not a classic switch, but Python 3.10 added the match/case statement, which does everything a switch does and more: it matches on literals, sequences, dictionaries and class instances, binds variables, supports | alternatives and if guards, and never falls through. For a simple value-to-action mapping, a dictionary of functions is also a common idiom.

What is the difference between a for loop and a while loop in Python?

A for loop iterates over the items of an iterable (list, string, range, file, generator) and stops when the items run out. A while loop repeats while a condition is true and needs you to manage the state yourself. Use for when you have a collection or a known count; use while for "until something happens" situations such as polling, retrying or reading input.

What does else do in a for loop in Python?

The else block after a for or while loop runs only when the loop ends without a break. It is useful for search loops: break when found, and the else handles "not found". It also runs when the iterable was empty, because no break occurred.

What is the difference between a list comprehension and a generator expression?

A list comprehension ([...]) builds the whole list in memory immediately and can be reused, indexed and sliced. A generator expression ((...)) yields one value at a time on demand, uses almost no memory and can be consumed only once. Use a generator when you only need to pass the values to sum, max, any, join or a single loop.

Are list comprehensions faster than for loops in Python?

Usually, by a modest constant factor (often 20–40% for simple transforms) because the interpreter avoids repeated .append lookups and runs a tighter bytecode loop. They are not algorithmically faster — both are O(n) — so choose a comprehension for clarity first and speed second, and fall back to a loop when the logic needs several statements.

What is the walrus operator in Python and when should I use it?

:= (Python 3.8+) assigns a value and returns it in the same expression, so you can bind and test in one step: if (m := re.search(p, s)): or while (chunk := f.read(1024)):. Use it to avoid calling the same function twice or to remove an awkward extra statement; avoid it when a plain assignment on its own line is just as clear.

Can I use break inside a list comprehension?

No. Comprehensions have no break or continue. To stop early, use a generator with itertools.takewhile, a plain loop, or next(x for x in xs if cond(x)) to fetch only the first match.

Q1. Which values are falsy in Python? How does Python decide the truth value of a custom object?

Falsy values are None, False, numeric zeros (0, 0.0, 0j, Decimal(0)), empty sequences and collections ("", [], (), {}, set(), range(0)). For a custom object Python calls __bool__(); if that is not defined it calls __len__() and treats zero as false; if neither is defined, the object is truthy.

Q2. What is the output of for i in range(3): pass; print(i) and of [i for i in range(3)]; print(i)?

The first prints 2 because a plain for loop's variable remains in the enclosing scope after the loop. The second raises NameError (if i was not defined earlier) because comprehensions have their own scope in Python 3 and do not leak the loop variable.

Q3. Explain for ... else with an example where it matters.

else runs if the loop completed without break. Primality test: loop over possible divisors, break on finding one; the else returns True only if no divisor was found. It removes the need for a found flag variable.

Q4. How does match differ from a switch statement in C or Java?

match performs structural pattern matching: it can destructure sequences, mappings and objects, bind sub-parts to names, add guards with if, combine alternatives with |, and matches the first fitting case with no fall-through. A switch compares a single value against constants only. Also, a bare name in a case is a capture pattern, not a constant comparison — use dotted names for constants.

Q5. What does zip do when the inputs have different lengths, and how do you make it safe?

It stops at the shortest iterable and silently discards the extra elements. On Python 3.10+ pass strict=True to raise ValueError on a mismatch; use itertools.zip_longest with a fillvalue if you want to pad instead.

Q6. What is wrong with grid = [[0] * 3] * 3?

The outer * 3 copies the *reference* to the same inner list three times, so grid[0][0] = 1 changes all three rows. Use a comprehension: [[0] * 3 for _ in range(3)], which creates three distinct inner lists.

Q7. Convert this loop to a comprehension and explain the scope of the variable: result = []; for row in matrix: for v in row: if v % 2: result.append(v * v).

result = [v * v for row in matrix for v in row if v % 2]. The for clauses appear in the same order as the nested loops (outer first), the filter goes last, and row/v are local to the comprehension.

Q8. When would you prefer a generator expression over a list comprehension?

When the values are consumed once by a function such as sum(), max(), any(), all(), str.join() or a single for loop, especially for large or infinite data streams, because a generator produces items lazily in O(1) memory. Prefer a list when you need indexing, slicing, len(), or multiple passes.

Q9. Why is if x == None discouraged, and what should be used instead?

None is a singleton, so identity (is None) is both faster and semantically correct; == can be overridden by a class's __eq__ and give surprising results (for example, NumPy arrays and pandas objects). PEP 8 mandates is None / is not None.

Q10. Show a case where the walrus operator removes a double computation.

[y for x in data if (y := expensive(x)) is not None] calls expensive once per element, whereas [expensive(x) for x in data if expensive(x) is not None] calls it twice. The walrus binds y in the enclosing scope, so it is also available after the comprehension.

Time to combine everything from this lecture in one complete, runnable program. You are building a small result-analysis tool for a coaching institute in Patna. The program holds a list of students with their marks in Physics, Chemistry and Maths and answers a sequence of text commands — exactly the shape of a real CLI or chatbot, but with the commands pre-loaded so the script runs unattended and the output is predictable.

What the program must do:

1. Compute each student's total and percentage with a comprehension, and assign a grade with an if/elif ladder.
2. Dispatch commands using match with sequence patterns, OR-patterns and guards: "top N", "subject <name>", "find <student>", "failed", "stats", and "quit".
3. Use enumerate(start=1) for ranked output and zip(strict=True) to pair subject names with marks.
4. Use for ... else in the find command to report "not found" without a flag variable.
5. Use a while loop with the walrus operator to pull commands from the queue until "quit".
6. Use a generator expression for averages, a set comprehension for the subjects in which anyone failed, and a dict comprehension for per-subject averages.

Copy the code into result_analyzer.py and run python result_analyzer.py. Then extend it on your own: add a "grade A" command that lists students with a given grade, make "subject" reject unknown subject names with a helpful message, and read the commands from input() instead of the queue so it becomes interactive. Try to break the program with odd commands ("top abc", "find") and make the match fallback handle them gracefully.

• Control flow is how a program decides, repeats and stops; Python expresses it with if/elif/else, match/case, for, while, break, continue, loop else, and comprehensions.
• if/elif/else runs the first true branch only; order conditions from specific to general and use guard clauses to keep the happy path unindented.
• Truthiness: None, False, zeros and empty collections are falsy, everything else is truthy. Use is None when zero is a legitimate value. and/or return operands, which makes x or default a handy idiom.
• Conditional expressions (a if cond else b) are for choosing between two simple values; nest them at most once.
• match/case (Python 3.10+) is structural pattern matching: literals, captures, _, sequences, mappings, class patterns, |, guards and as. A bare name captures; use dotted names for constants.
• for iterates over any iterable; range(start, stop, step) is lazy and excludes stop. Loop over collections directly instead of over indices.
• while repeats while a condition holds; keep init/test/update visible, cap retries, and use while True + break for do-while behaviour.
• break leaves one loop level, continue skips to the next iteration, and loop else runs only when there was no break.
• enumerate(iterable, start) gives indices; zip(*iterables, strict=True) (3.10+) walks parallel sequences safely.
• Comprehensions: list [...], dict {k: v ...}, set {...}, and generator expressions (...) for lazy, single-pass, memory-light pipelines. Comprehensions have their own scope.
• Multiple for clauses flatten; a comprehension inside the expression nests. Stop at two clauses and one filter — beyond that, write a loop or a function.
• The walrus operator := (3.8+) assigns inside an expression; use it for read-and-test loops, regex matches and avoiding double computation, with parentheses at statement level.

Next lecture: Functions — Parameters, Scope, Lambdas & Closures