SDD11 — Predefined Functions | N5 Computing Science

Learning intentions

Understand what a predefined function is and why programmers use them
Use Python's built-in functions: round(), abs(), int(), float(), str(), len(), max(), and min()
Use random.randint() to generate a random integer within a given range

Success criteria

I can explain what a predefined function is and state the benefit of using one
I can use round(value, decimal_places) to round a number to a specified number of decimal places
I can use abs() to find the absolute (positive) value of a number
I can use int(), float(), and str() to convert between data types
I can use len() to find the number of characters in a string
I can use max() and min() to find the largest or smallest of a set of values
I can import the random module and use random.randint(low, high) to generate a random integer

Key vocabulary

predefined function

A function that is already written and built into the programming language. You call it by name rather than writing the code yourself.

argument

A value passed into a function when it is called. For example, in round(3.7, 1) the arguments are 3.7 and 1.

return value

The result that a function sends back to the program after it has been called. For example, round(3.7, 1) returns 3.7.

type conversion

Changing a value from one data type to another. Also called casting. Python's int(), float(), and str() perform type conversion.

module

A file of pre-written Python code that adds extra functions. The random module must be imported with import random before its functions can be used.

absolute value

The distance of a number from zero — always positive. The absolute value of −7 is 7; the absolute value of 7 is also 7. Found using abs().

Predefined Functions

What is a predefined function?

A predefined function (also called a built-in function) is a piece of code that has already been written for you by the language designers. Instead of writing the logic yourself, you simply call the function by name, pass in any values it needs (called arguments), and receive a return value back.

For example, to round a number to two decimal places you could write many lines of arithmetic — or you could just call round(number, 2). Predefined functions save time, reduce errors, and make code easier to read.

Python's predefined functions fall into two groups: those built directly into the language (like round(), len(), int()) which are always available, and those in modules (like random.randint()) which must be imported first using an import statement.

Type conversion: int(), float(), str()

These three functions convert a value from one data type to another. This is also called casting.

Function	Purpose	Example	Result
`int(x)`	Converts x to an integer (truncates — does not round)	`int(3.9)`	`3`
`int(x)`	Converts a string of digits to an integer	`int("42")`	`42`
`float(x)`	Converts x to a decimal number	`float("3.14")`	`3.14`
`str(x)`	Converts x to a string	`str(100)`	`"100"`

The most common use is wrapping input() to convert user input from a string to a number: age = int(input("Enter your age: ")). Without int(), any arithmetic on age would fail because you cannot add strings to numbers.

Note that int(3.9) gives 3, not 4. int() truncates — it removes the decimal part entirely without rounding. To round to a whole number, use round() instead.

Rounding: round()

The round() function rounds a number to a specified number of decimal places.

round(value, decimal_places)

Examples:

round(3.14159, 2) → 3.14
round(3.14159, 4) → 3.1416
round(3.7) → 4 (no second argument — rounds to nearest integer, returns an int)

Rounding is especially important when displaying the result of a division. For example, computing an average often produces many decimal places; round() tidies the output for the user.

In SQA pseudocode this is written as ROUND(value, decimalPlaces) — the same argument pattern, just capitalised.

Absolute value: abs()

abs(x) returns the absolute value of x — that is, its distance from zero, always positive or zero.

abs(-15) → 15
abs(15) → 15
abs(-3.7) → 3.7

A common use is calculating the difference between two values regardless of which is larger: abs(temp1 - temp2) gives the temperature difference whether temp1 is bigger or smaller.

String length: len()

len(s) returns the number of characters in string s. It counts every character including spaces and punctuation.

len("hello") → 5
len("Computing!") → 10
len("") → 0 (empty string)

A typical use is password validation — checking that a password is at least 8 characters long: if len(password) < 8:. In SQA pseudocode this is written as LEN(string).

Maximum and minimum: max() and min()

max() returns the largest value from a set of arguments; min() returns the smallest.

max(34, 17, 28) → 34
min(34, 17, 28) → 17
max(score1, score2, score3) — works with variables too

You can pass two or more arguments. When working with lists (covered in SDD13), you can also pass the list directly: max(scores).

Random numbers: random.randint()

Python does not include random number generation by default. You must first import the random module at the top of your program, then call random.randint(low, high).

import random

dice = random.randint(1, 6)   # returns 1, 2, 3, 4, 5, or 6
print(dice)

random.randint(low, high) returns a random integer including both endpoints — so random.randint(1, 6) can return 1, 2, 3, 4, 5, or 6 with equal probability.

In SQA pseudocode this is written as RANDOM(low, high). No import line is needed in pseudocode — it is a Python-specific requirement.

The import statement must appear once, at the very top of the program, before any code that uses the module. Forgetting to import is the most common error when using random.randint().

Quick reference

Function	What it returns	Pseudocode equivalent
`round(x, d)`	x rounded to d decimal places	`ROUND(x, d)`
`abs(x)`	absolute value of x (always ≥ 0)	`ABS(x)`
`int(x)`	x as an integer (truncates)	`INT(x)`
`float(x)`	x as a float	`FLOAT(x)`
`str(x)`	x as a string	`STRING(x)`
`len(s)`	number of characters in string s	`LEN(s)`
`max(a, b, …)`	largest of the arguments	`MAX(a, b, …)`
`min(a, b, …)`	smallest of the arguments	`MIN(a, b, …)`
`random.randint(l, h)`	random integer from l to h inclusive	`RANDOM(l, h)`

Worked examples

Example 1 — Using round() to tidy an average

Three test scores are 85, 92, and 71. Write a program that calculates the average and displays it rounded to one decimal place.

Calculate mentally first: (85 + 92 + 71) ÷ 3 = 248 ÷ 3 = 82.666… — many decimal places, not suitable to display directly.

Python code:

score1 = 85
score2 = 92
score3 = 71
average = (score1 + score2 + score3) / 3
average = round(average, 1)
print("Average score:", average)

Output: Average score: 82.7 — round(82.666…, 1) rounds to one decimal place. The second argument to round() is always the number of decimal places required. Note that round() returns the value; we must assign it back to average to store the result.

Example 2 — Using random.randint() for a dice simulation

Write a program that simulates rolling a six-sided die and displays the result.

The import random line must come first — before any other code in the file. Without it, Python does not know what random.randint means and will raise a NameError.

Python code:

import random

roll = random.randint(1, 6)
print("You rolled:", roll)

random.randint(1, 6) returns one of 1, 2, 3, 4, 5, or 6 with equal probability. Both endpoints are included. Each run of the program may give a different result. In SQA pseudocode: SET roll TO RANDOM(1, 6) — no import statement needed in pseudocode.

Example 3 — Type conversion: float() and str()

A program asks the user for a temperature in Celsius and converts it to Fahrenheit, displaying the result rounded to one decimal place.

The formula: Fahrenheit = (Celsius × 9 / 5) + 32. Verified: 0°C → 32°F; 100°C → 212°F.

Python code:

celsius = float(input("Enter temperature in Celsius: "))
fahrenheit = (celsius * 9 / 5) + 32
fahrenheit = round(fahrenheit, 1)
print(str(celsius) + "°C is " + str(fahrenheit) + "°F")

Trace for input 100: float("100") → 100.0. Fahrenheit = (100.0 × 9 / 5) + 32 = 180.0 + 32 = 212.0. round(212.0, 1) → 212.0. The str() calls convert the numbers to strings so they can be joined with + in the print. Output: 100.0°C is 212.0°F

Example 4 — Using len() for password validation

A website requires passwords to be between 8 and 20 characters inclusive. Write a program that checks whether a password meets this requirement.

len(password) counts every character in the string — letters, digits, symbols, and spaces all count as one character each.

Python code:

password = input("Enter a password: ")
length = len(password)
if length < 8 or length > 20:
    print("Invalid — password must be 8 to 20 characters.")
    print("Your password is", length, "characters long.")
else:
    print("Password accepted.")

For input "hello": len("hello") = 5. The condition 5 < 8 is true — program prints the rejection message and reports 5 characters. For input "SecurePass1": len("SecurePass1") = 11. The condition is false — program prints Password accepted.

Now you try

A program asks the user for two integers: a starting balance and a finishing balance for a bank account. The program should display the change in balance (finishing minus starting), the absolute change (always positive, regardless of direction), and whether the balance has increased, decreased, or stayed the same.

Answer the following:

Which predefined function gives you the absolute value of the change?
Write the complete Python code for this program.
What does the program display if the starting balance is 350 and the finishing balance is 200?

abs() — it returns the absolute value of a number, making any negative result positive. abs(200 - 350) = abs(-150) = 150.

start = int(input("Enter starting balance: "))
finish = int(input("Enter finishing balance: "))
change = finish - start
absolute_change = abs(change)
if change > 0:
    print("Balance increased by £" + str(absolute_change))
elif change < 0:
    print("Balance decreased by £" + str(absolute_change))
else:
    print("Balance unchanged.")

change = 200 − 350 = −150. absolute_change = abs(−150) = 150. Since change < 0, the output is: Balance decreased by £150

Common mistakes

Forgetting to import the random module. Writing roll = random.randint(1, 6) without import random at the top of the file causes a NameError: name 'random' is not defined. The import must appear before any code that uses the module. In pseudocode there is no import, but in Python it is always required.

Reversing the arguments in round(). round(2, 3.14) is wrong — the number to be rounded comes first, the number of decimal places comes second. Always: round(value, decimal_places). The same order applies in SQA pseudocode: ROUND(value, decimalPlaces).

Confusing int() with round(). int(3.9) gives 3, not 4. int() truncates — it simply removes the decimal part without any rounding. round(3.9) gives 4 because it rounds to the nearest whole number. When an exam question asks you to round, always use round().

Using len() on a number. len(42) causes a TypeError — len() only works on strings (and lists, which are covered in SDD13). To find how many digits a number has, first convert it to a string: len(str(42)) returns 2.

Forgetting to store the return value. round(price, 2) returns a rounded value but does not modify price itself. To update the variable, you must reassign: price = round(price, 2). This applies to all predefined functions — they return a value, they do not change the original variable in place.

Exam tip

The SQA most commonly tests round(), random.randint() / RANDOM(), and len() / LEN(). Make sure you know the exact argument order for each: round(value, decimal_places), random.randint(low, high), and len(string) (only one argument).

When a question asks you to "use a predefined function" and gives a context such as "round the result to 2 decimal places", the marker is looking for the correct function call with both arguments in the right order. Showing the correct syntax earns full marks; a vague description of rounding does not.

For random number questions, remember that random.randint(1, 6) includes both endpoints — 1 and 6 are both possible results. If a question says "generate a random number between 1 and 6 inclusive", the arguments are exactly 1 and 6.

In pseudocode questions, predefined functions use the same argument pattern as Python but capitalised: ROUND(result, 2), RANDOM(1, 6), LEN(password). No import statement is needed in pseudocode.

Teacher notes — Shift+T to hide

Suggested timing: 60 minutes. Warm up 10 min; notes + reference table 15 min; worked examples 15 min; now you try 5 min; task set 15 min.

Key misconception to address: Pupils frequently confuse int() and round(). Reinforce that int() truncates (chops off the decimal) and is primarily a type-conversion tool, while round() is a mathematical rounding function. A useful check: "If you have £3.99, does int(3.99) give the right rounded value?" — no, it gives 3, not 4. round(3.99) gives 4.

Live demo suggestion: Open a Python REPL and demonstrate each function live. Start with 10 / 3 producing a long float, then show round(10 / 3, 2) giving 3.33. Then generate several random numbers with random.randint(1, 6) in quick succession to show the randomness. Deliberately trigger the "forgetting to import" error so pupils see exactly what the NameError message looks like — then fix it live.

Extension question: Ask pupils to roll a die 6 times using a FOR loop, storing each result in a separate variable, then use max() and min() to display the highest and lowest roll. This combines random.randint(), a fixed loop (SDD9), and max()/min().

Note on round() and banker's rounding: Python 3 uses "round half to even" for exact halfway cases, so round(2.5) = 2 and round(3.5) = 4. This is mathematically correct but can surprise pupils who expect .5 always to round up. For N5 exam purposes this detail is not examined — pupils will not encounter exact halfway cases in exam questions. Do not over-explain this unless pupils ask.

SQA command words covered: "state" (Q4), "explain" (Q6, Q8), "write" (Q7 pseudocode, Q9, Q10 Python), "identify" (Q8 errors).