Python Foundations: Intermediate

Make your code choose between paths

The if/elif/else structure evaluates conditions in order and executes the first block where the condition is True. If no conditions match, the else block runs.

score = 75
if score ___>=<=== 60:
    print("Pass")
else:
    print("Fail")

Python does not have a switch or case statement like some other languages. Instead, a chain of elif clauses handles multiple discrete conditions cleanly.

age = 20
___ age >= 18:
    status = "adult"
___:
    status = "minor"
print(status)

Conditions can be combined using the and, or, and not operators. A compound condition like age >= 18 and has_id must be True on both sides to pass.

Python evaluates conditions using short-circuit logic. In an and expression, if the first condition is False, Python skips evaluating the second one entirely.

Ternary expressions provide a single-line alternative for simple if/else assignments. The form value_if_true if condition else value_if_false is concise and readable.

Repeat actions across collections of data

for loops iterate over sequences like lists, strings, or ranges. They automatically handle the iteration, making them ideal when you know what to iterate over.

while loops continue executing as long as a condition remains True. Use break to exit early and continue to skip to the next iteration.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

for i in range(5)
  print(i)

for: known iterations

Best when you know the sequence or range to iterate over

while: condition-based

Best when you loop until a condition changes to False

break and continue

Control loop flow by exiting early or skipping iterations

The enumerate() function pairs each item with its index as you loop, eliminating the need to manually track a counter variable alongside the loop variable.

Package reusable logic into functions

Use def followed by a name and parentheses to define a function. Parameters inside the parentheses accept input values.

___deffuncreturn greet(name):
    print("Hello " + name)

greet("Alice")

def greet(name):
    ___ "Hello, " + ___
message = greet("Alice")
print(message)

Default parameter values let callers omit arguments that have sensible defaults. Define them in the function signature with an equals sign, such as def greet(name="World").

Get results back from your functions

Use return to send a value back to the caller. A function can return any type of value. Without a return statement, a function returns None by default.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

def double(x):
  result = x * 2
  print(result)

value = double(5)
print(value)

Control where variables are accessible

Variables defined inside a function are local and exist only during that function call. Variables defined outside functions are global and accessible throughout your code.

Use the global keyword inside a function to modify a global variable. Without it, assignment creates a new local variable instead.

Without the global keyword, Python would create a new local variable instead of modifying the outer one. This is a common source of confusion.

x = 10

def change_x():
    ___globallocalreturn x
    x = 20

change_x()
print(x)