Python gets introduced early in most engineering careers, often dismissed as "the scripting language" before engineers move on to whatever framework is fashionable. That framing does real damage. The control structures in Python are not just beginner material. They carry semantic weight, performance implications, and failure modes that show up in production systems years after the basics were supposedly mastered.
This article covers Python lists, conditionals, and loop constructs from the ground up, but the framing is aimed at engineers who have already written code that broke at 2 AM. Every concept here is grounded in the question: why does it work this way, and what goes wrong when you misuse it?
Lists: Ordered, Mutable, and Occasionally Surprising
A Python list is an ordered, mutable sequence that can hold heterogeneous types. You already know that. What engineers underestimate is the word "mutable" and everything it implies.
Start with the basics so we share a common vocabulary.
tenants = ["Sato", "Suzuki", "Takahashi", "Watanabe", "Yamamoto"]Indexing starts at zero. The first element lives at index 0, the last at index len(tenants) - 1. This is not arbitrary. CPython represents lists as arrays of pointers, and pointer arithmetic from a base address is zero-based by definition. The language did not invent this convention; it inherited it from C.
Access is O(1). Appending to the end is amortized O(1). Inserting or deleting from the middle is O(n) because every subsequent element must shift. That cost matters when your list holds millions of records and you call list.insert(0, item) inside a loop.
tenants = ["Sato", "Suzuki", "Takahashi", "Watanabe", "Yamamoto"]
# Direct index access
print(tenants[0]) # Sato
print(tenants[-1]) # Yamamoto -- negative indexing wraps from the end
# Length
print(len(tenants)) # 5
# Slice: returns a new list, does not modify the original
print(tenants[1:3]) # ['Suzuki', 'Takahashi']Negative indexing deserves a moment. tenants[-1] is not a separate feature. Python translates it to tenants[len(tenants) - 1] internally. It is syntactic sugar, but it is the idiomatic way to access the last element and you should use it.
Mutation and the Aliasing Trap
This is where production bugs live.
original = ["Sato", "Suzuki", "Takahashi"]
alias = original # both names point to the same list object
shallow_copy = original[:] # a new list with the same element references
alias.append("Watanabe")
print(original) # ['Sato', 'Suzuki', 'Takahashi', 'Watanabe']
print(shallow_copy) # ['Sato', 'Suzuki', 'Takahashi'] -- unaffectedAssigning one list variable to another does not copy the list. It creates a second reference to the same object. Mutation through either name affects the same underlying data. This is not a bug in Python; it is the intended behavior of a reference-based object model. But it catches experienced engineers off guard when lists are passed into functions, stored as default argument values, or embedded inside class instances.
The shallow copy via [:] only solves one level. If the list contains mutable objects (nested lists, dicts, custom class instances), those inner objects are still shared. For deep independence, use copy.deepcopy().
Takumi's Take: The most expensive production incident I have debugged involving Python lists came from a default mutable argument:
def process(items=[]). Every call without an explicit argument shared the same list object across invocations. The list silently accumulated state across requests in a long-running service. The fix is triviallydef process(items=None)and thenitems = items or []inside the function body. Python evaluates default argument values once at function definition time, not at call time. This trips up engineers who come from languages where default arguments are re-evaluated per call.
Iterating Over Lists the Right Way
The range()-based loop works, but it is not the idiomatic Python approach for simple iteration.
tenants = ["Sato", "Suzuki", "Takahashi", "Watanabe", "Yamamoto"]
# C-style: works, but not idiomatic
for i in range(len(tenants)):
print(tenants[i])
# Pythonic: iterate directly over the sequence
for tenant in tenants:
print(tenant)
# When you need both index and value, use enumerate
for index, tenant in enumerate(tenants):
print(f"{index}: {tenant}")The direct iteration form is cleaner and less error-prone. There is no off-by-one risk with range(), no chance of an IndexError from a wrong upper bound. The enumerate() function is the right answer whenever you genuinely need the index. It avoids the mental overhead of managing i separately.
Using range(len(sequence)) when you do not actually need the index is a code smell in Python. It does not fail, but it signals that the engineer is mentally translating from a different language rather than writing in Python.
# Combining len() with while -- valid but verbose
tenants = ["Sato", "Suzuki", "Takahashi", "Watanabe", "Yamamoto"]
i = 0
while i < len(tenants):
print(tenants[i])
i += 1The while version above is correct. The len(tenants) call in the condition is evaluated on each iteration, which is fine because len() on a list is O(1) in CPython. If you were mutating the list during iteration (adding or removing elements), this would matter. Iterating over a list while modifying it is a separate class of bugs entirely and worth a dedicated article.
Conditionals: if, elif, else
The if statement evaluates an expression and routes execution based on truthiness. The syntax is minimal.
def classify_score(score: int) -> str:
if score >= 90:
return "A"
elif score >= 80:
return "B"
elif score >= 70:
return "C"
else:
return "F"
print(classify_score(85)) # B
print(classify_score(72)) # C
print(classify_score(50)) # FPython evaluates elif branches in order and stops at the first one that is true. The else block runs only if every preceding condition was false. There is no switch/case statement in Python before version 3.10. For Python 3.10 and later, match/case is available and worth knowing for structural pattern matching, but if/elif/else remains the backbone of conditional logic for most codebases.
Truthiness Is Not Just True and False
Python's conditional evaluation uses the concept of "truthiness." Many values that are not boolean evaluate to False in a conditional context: 0, 0.0, "", [], {}, None, and any object whose __bool__ or __len__ method returns zero or false. Everything else is truthy.
tenants = []
# Checking for empty list
if not tenants:
print("No tenants registered")
# This is equivalent to:
if len(tenants) == 0:
print("No tenants registered")The first form is idiomatic. The second is explicit and equally valid. For most list checks, the first form is preferred. For cases where zero versus empty are semantically different, be explicit.
Comparison Operators
Python's comparison operators map closely to standard mathematical notation.
| Operator | Meaning |
|---|---|
== | Equal to |
!= | Not equal to |
< | Less than |
<= | Less than or equal to |
> | Greater than |
>= | Greater than or equal to |
is | Identity (same object in memory) |
in | Membership test |
The is versus == distinction matters. == tests value equality. is tests object identity. For None checks, always use is None or is not None. Using == with None works in practice but is semantically wrong and will trigger linter warnings.
x = None
# Correct
if x is None:
print("x is not set")
# Incorrect (works but misleading)
if x == None:
print("x is not set")Small integers (-5 to 256) and interned strings are cached by CPython, meaning is comparisons for those values will return True even for separately assigned variables. This is an implementation detail, not a language guarantee. Never rely on is for value comparison.
for Loops: Iteration Over Sequences
Python's for statement is a foreach loop. It iterates over any iterable object, extracting one element per iteration.
for variable in iterable:
# bodyThe range() function generates an integer sequence. It accepts one, two, or three arguments.
range(stop) # 0 to stop-1
range(start, stop) # start to stop-1
range(start, stop, step) # start to stop-1, incrementing by stepThe stop value is always exclusive. range(1, 11) produces integers 1 through 10. This follows the same convention as Python slice notation, and it is consistent across the language.
# Sum of squares from 1 to 10
total = sum(i ** 2 for i in range(1, 11))
print(total) # 385The generator expression inside sum() is more efficient than building an intermediate list. It produces values lazily, one at a time. For large ranges, this matters.
Nested Loops and the Multiplication Table
Nested loops are the standard approach for two-dimensional iteration. The outer loop controls rows, the inner loop controls columns.
# Multiplication table from 1 to 9
for x in range(1, 10):
row = []
for y in range(1, 10):
row.append(x * y)
print(" ".join(f"{val:3d}" for val in row))Output:
1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81The f"{val:3d}" format specifier right-aligns each integer in a field three characters wide. Small formatting detail, but it makes tabular output readable without external libraries.
The time complexity of this nested loop is O(n²) where n is 9. For small fixed sizes this is fine. If n grew to millions, you would restructure the problem, likely with NumPy for vectorized operations rather than Python loops.
break and continue
Both keywords alter loop flow. They are legitimate tools, not hacks, when used deliberately.
scores = [72, 85, 91, 60, 78, 88, 95, 55]
# continue: skip scores below 70, process only passing scores
passing_scores = []
for score in scores:
if score < 70:
continue
passing_scores.append(score)
print(passing_scores) # [72, 85, 91, 78, 88, 95]
# break: stop at the first score above 90
for score in scores:
if score > 90:
print(f"First high score found: {score}")
break
# Output: First high score found: 91continue skips the rest of the current iteration body and moves to the next iteration. break exits the loop entirely. In the continue example above, a list comprehension would be cleaner: passing_scores = [s for s in scores if s >= 70]. But when the loop body is complex, explicit continue statements can make the flow easier to follow than deeply nested conditions.
One pattern that confuses engineers coming from other languages: Python's for and while loops both support an else clause. The else block runs when the loop completes normally, meaning it was not terminated by a break.
def find_tenant(tenants: list, target: str) -> None:
for tenant in tenants:
if tenant == target:
print(f"Found: {tenant}")
break
else:
print(f"{target} not found in tenant list")
find_tenant(["Sato", "Suzuki", "Takahashi"], "Suzuki")
# Found: Suzuki
find_tenant(["Sato", "Suzuki", "Takahashi"], "Yamamoto")
# Yamamoto not found in tenant listThe loop else is underused. It cleanly encodes the "searched and found nothing" pattern without requiring an external flag variable. Most engineers who encounter it for the first time find the semantics counterintuitive, but after a few uses it reads naturally.
while Loops: Condition-Driven Repetition
A while loop runs as long as its condition evaluates to true. It requires explicit state management inside the body.
while condition:
# body
# condition must eventually become False, or include a breakThe classic case where while outperforms for is when you do not know in advance how many iterations you need.
import random
def roll_until_six() -> int:
attempts = 0
result = 0
while result != 6:
result = random.randint(1, 6)
attempts += 1
return attempts
print(f"Rolled a 6 after {roll_until_six()} attempt(s)")You cannot express this cleanly with for and range() because the termination condition depends on runtime data, not a predetermined count.
Infinite Loops and the Sentinel Pattern
Sometimes an infinite loop with an explicit break is the right structure.
def interactive_score_checker() -> None:
while True:
raw = input("Enter a score (or 'quit' to exit): ")
if raw.lower() == "quit":
break
try:
score = int(raw)
except ValueError:
print("Please enter a valid integer.")
continue
if score >= 80:
print("Pass")
else:
print("Fail")
interactive_score_checker()The while True pattern with a break on a sentinel value is standard for interactive loops, server polling loops, and event-processing loops. The alternative, pre-evaluating the condition before the loop and then re-evaluating it at the bottom, produces duplicated code or awkward do-while emulation.
Takumi's Take: In long-running services,
while Trueloops require careful attention to what happens whenbreaknever fires. A missing termination condition does not manifest during unit tests. It surfaces at 3 AM when a connection drops and the loop stalls waiting for data that never arrives. Always pairwhile Trueloops in production code with a timeout, a maximum retry count, or a circuit-breaker condition. The interactive example above is fine for a CLI tool. It is not a pattern to copy directly into a background worker.
Combining Lists and Control Structures
The real power of these constructs comes from composition. A practical example: filtering and classifying a dataset without importing anything.
student_scores = [
("Sato", 92),
("Suzuki", 74),
("Takahashi", 85),
("Watanabe", 61),
("Yamamoto", 88),
("Nakamura", 55),
]
def classify_students(records: list) -> dict:
result = {"A": [], "B": [], "C": [], "F": []}
for name, score in records:
if score >= 90:
result["A"].append(name)
elif score >= 80:
result["B"].append(name)
elif score >= 70:
result["C"].append(name)
else:
result["F"].append(name)
return result
classified = classify_students(student_scores)
for grade, students in classified.items():
if students:
print(f"Grade {grade}: {', '.join(students)}")Output:
Grade A: Sato
Grade B: Takahashi, Yamamoto
Grade C: Suzuki
Grade F: Watanabe, NakamuraThis pattern, iterating a list of tuples and routing each element based on a condition, appears constantly in data processing pipelines. The tuple unpacking in for name, score in records is idiomatic Python. It is cleaner than records[i][0] and records[i][1], and it names your intent.
Notice the if students: guard before printing. An empty list is falsy, so grade categories with no students are silently skipped. This is the kind of small but deliberate use of Python's truthiness model that separates idiomatic code from mechanically correct code.
Indentation Is Not Style, It Is Syntax
Python uses indentation to define code blocks. This is not a convention. The interpreter enforces it. A missing or inconsistent indent is a SyntaxError or, worse, a logic error that runs without crashing.
# This does NOT print "done" inside the loop
for i in range(3):
print(i)
print("done") # outside the loop -- runs once after the loop completes
# This prints "done" inside the loop
for i in range(3):
print(i)
print("done") # inside the loop -- runs on every iterationThe PEP 8 style guide specifies four spaces per indent level. Tabs and spaces must not be mixed. Most editors handle this automatically, but code pasted from web browsers or PDFs sometimes carries invisible inconsistencies. The python -tt flag at runtime will raise an error on mixed tab/space indentation if you suspect contamination in a legacy codebase.
Where This Leads
Lists, conditionals, and loops form the substrate that everything else in Python is built on. List comprehensions are syntactic sugar over for loops with optional if filters. Generator expressions are lazy versions of the same pattern. Dictionary comprehensions extend the model to key-value pairs. Understanding how the underlying constructs work makes all of these derived forms easier to read, debug, and optimize.
The next layer from here is understanding how Python's data model makes these constructs work for custom types. Any object that implements __iter__ and __next__ can be iterated with for. Any object that implements __bool__ or __len__ participates in conditional evaluation. That protocol-based extensibility is where Python's design philosophy becomes visible, and it shapes how well-structured Python libraries and frameworks are built.
Control structures are not beginner content. They are the foundation, and the foundation is worth understanding precisely.