CPX17Python Basics: Data Types, Variables, Operators, Input and Output

Paper 2 is on screen. You open Pearson’s starting files in your own IDE, change or add code, and save your work. Every file Pearson gives you uses the same layout.

• Each section starts with a banner comment: # Import libraries, # Constants, # Global variables, # Subprograms, # Main program.
• Lines that start # =====> are Pearson’s instructions. Put your code where they say. Don’t delete, rewrite or move the code you’re given.
• Pearson’s code style: a space between a name and its brackets, as in print ("Hi") and int (input ("Age: ")), and brackets round every condition, as in if (total > 100):. Python runs fine either way. The style just makes code easier to read.
• The Programming Language Subset (PLS) lists every part of Python that Pearson uses. You get it on paper and on screen in the exam, so look things up in it. Pearson never sets a task that needs more than the PLS, but valid code from outside it still earns marks.
• Anything after # on a line is a comment. Comment each block of code to say what it does, not every line.

Only the sections a program needs are included, but always in this order

# -------------------------------------------------------------------
# Constants
# -------------------------------------------------------------------
SEED_PER_M2 = 35                # Grams of seed per square metre

# -------------------------------------------------------------------
# Global variables
# -------------------------------------------------------------------
length = 0.0
width = 0.0
seedNeeded = 0.0

# -------------------------------------------------------------------
# Main program
# -------------------------------------------------------------------
length = float (input ("Length of lawn in metres: "))
width = float (input ("Width of lawn in metres: "))

seedNeeded = length * width * SEED_PER_M2
print ("You need", seedNeeded, "grams of seed")

PLS

Programming Language Subset: Pearson’s list of the parts of Python 3 used in Paper 2. You have a copy in the exam.

Comment

Text after # that Python ignores. It explains the code to people reading it.

Every value has a data type. Pearson names four primitive data types. The PLS gives the Python name for each.

• Python has no separate character type. A character is a str holding one character. A string, such as a name, is a sequence of characters, also str.
• Choose the type from the values and what the program does with them. A phone number or a code with a leading 0 is a string: it is never used in arithmetic, and an integer would lose the 0.
• The first value you give a variable sets its type: total = 0.0 makes a real, total = 0 makes an integer. Keep a variable the same type for the whole program.
• You can also declare a variable with its type and no value: count = int () gives 0, price = float () gives 0.0, name = str () gives an empty string.

Use the general name (integer, real…) or the Python name (int, float…) in comments

Integer (int)

A whole number, negative or positive.

Real (float)

A number with a fractional part (a decimal number).

Boolean (bool)

A value that can only be True or False.

Character (str)

A single letter, digit or symbol. Python stores it as a string of length 1.

A variable is a named location in memory that holds a value. The value can change while the program runs.

• Assignment uses =. Python works out the right-hand side first, then stores the result in the variable on the left: total = total + price.
• Initialisation is giving a variable its first value. Pearson’s files initialise every global variable at the top: total = 0.0, name = "", found = False.
• Assigning a new value replaces the old one, which is lost.
• Identifiers (names) may use letters, digits and underscores, must start with a letter and can’t contain spaces. Upper and lower case are different: Total and total are two variables.
• Pearson writes variable names in camelCase: numTickets, averageSpeed. Make names meaningful. x or a2 tell a reader nothing.
• = assigns a value. == compares two values.

apples = 5
pears = apples * 2
apples = pears - 3
pears = pears + apples

Variable

A named memory location holding a value that can change while the program runs.

Assignment

Setting or changing the value of a variable, using =.

Initialisation

Giving a variable its first (starting) value.

Identifier

The name of a variable, constant or subprogram.

camelCase

Writing a name with no spaces, each new word starting with a capital: numTickets.

A constant holds a value that is set once and doesn’t change while the program runs.

• Python has no true constants. By convention a name in CAPITALS (with underscores between words) is treated as a constant: MAX_SEATS = 52. Never assign it a new value later.
• Put constants in the Constants section at the top of the program.
• Why use a constant? If the value changes (a new price, say), you edit one line and every use updates. The name says what the number means, so the code is easier to read. And you can’t mistype the value in one of many places.
• A constant can be any type: VAT_RATE = 0.2, SHOP = "Bike Hub", LF = "\n".
• When a question gives you constants, use them. Typing the number itself instead (a literal) doesn’t get the mark.

cost = tickets * 4.50
if (tickets > 52):
    print ("Not enough seats")

TICKET_PRICE = 4.50
MAX_SEATS = 52

cost = tickets * TICKET_PRICE
if (tickets > MAX_SEATS):
    print ("Not enough seats")

Constant

A named value that is set once and not changed while the program runs. Named in CAPITALS in Python.

Literal

A value typed straight into the code, such as 52 or "Yes".

input (prompt) shows the prompt and waits for the user to type a line. It always returns a string, even if the user types a number.

• Convert straight away: age = int (input ("Enter your age: ")), height = float (input ("Height in metres: ")).
• Conversion makes a converted copy. In balance = float (count), count keeps its own value and type.
• Without conversion, + joins the strings: if both inputs are "3" and "4", the ‘total’ is "34".
• If the user types ten when the program does int (input (…)), the program crashes with a ValueError. Checking input before converting it is validation (see the strings, files and validation topic).
• Write clear prompts that say what to type and in what units, ending with a space: "Weight in kg: ".

Convert the input before using it as a number

# Program A
first = input ("First: ")
second = input ("Second: ")
print (first + second)

# Program B
first = int (input ("First: "))
second = int (input ("Second: "))
print (first + second)

Conversion (casting)

Changing a value from one data type to another with int (), float (), str () or bool ().

ValueError

The runtime error when a value can’t be converted, e.g. int ("ten").

• / always gives a real: 8 / 2 is 4.0, not 4.
• // and % go together: 17 eggs in boxes of 5 is 17 // 5 = 3 full boxes and 17 % 5 = 2 eggs left over.
• number % 2 == 0 is True for even numbers. number % 10 gives the last digit.
• Order of operations is BIDMAS: brackets, indices (**), division and multiplication, then addition and subtraction. Add brackets to make the order clear.
• round (x, n) rounds to n decimal places, and round (x) to a whole number. Watch out: Python rounds an exact half to the nearest even number, so round (2.5) is 2.
• Round only what you display. Keep the full value in the variable if it’s used again later, or format the output instead (see Output).

Integer division (//)

Divides and keeps only the whole-number part: 17 // 5 is 3.

Modulus (%)

The remainder after integer division: 17 % 5 is 2.

Exponentiation (**)

Raising to a power: 2 ** 5 is 32.

BIDMAS

The order of operations: brackets, indices, division and multiplication, addition and subtraction.

Relational and logical operators make conditions. A condition is always True or False. Conditions control if and while (next topic).

• Put brackets round each test and round the whole condition, Pearson’s way: if ((age >= 11) and (age <= 16)):.
• A value inside a range needs and: (mark >= 0) and (mark <= 50). A value outside a range needs or: (mark < 0) or (mark > 50).
• Check the boundaries. ‘From 1 to 20’ includes 1 and 20, so use >= and <=. ‘Over 18’ means > 18.
• You can store a condition’s result in a Boolean variable: isTeenager = (age >= 13) and (age <= 19).
• Strings are compared by their character codes, so "Zara" < "amir" is True: every capital letter comes before every lower-case letter. Compare whole strings with ==.

Relational operator

Compares two values: ==, !=, >, >=, <, <=. The result is True or False.

Logical operator

Combines or inverts conditions: and, or, not.

Condition

An expression that is either True or False.

• print ("Total:", total): commas separate items and add a space between them. Items can be any type.
• + concatenates (joins) strings with no space added. Numbers must be converted first: print ("Total: " + str (total)). Without str () you get a TypeError.
• Don’t join strings with commas outside print. line = "Total:", total makes a tuple, not a string, and examiners penalise it.
• "=" * 20 gives a line of 20 equals signs. "\n" inside a string starts a new line.
• .format () puts values into placeholders { } in a string, in order. Inside a placeholder: alignment (< left, > right, ^ centre), width, precision (.2) and type (s string, d integer, f fixed-point real).
• Store a layout string once and reuse it so the columns line up: layout = "{:<10}{:>8.2f}", then print (layout.format (item, price)).
• .format () rounds what is shown. The variable keeps its full value.
• f-strings (f"{price:.2f}") aren’t in the PLS, but you may use them unless the question says to use .format ().

Each part of a placeholder is optional, but they always come in this order

Tea          1.80
Flapjack     2.35
=================
Total        4.15

layout = "{:<10}{:>7.2f}"
teaPrice = 1.80
flapjackPrice = 2.35
print (layout.format ("Tea", teaPrice))
print (layout.format ("Flapjack", flapjackPrice))
print ("=" * 17)
print (layout.format ("Total", teaPrice + flapjackPrice))

Concatenation

Joining strings end to end with +.

Placeholder

A { } in a string that .format () fills with a value, e.g. {:>8.2f}.

TypeError

The runtime error when an operation is used on the wrong type, e.g. "Total: " + 5.

A ‘name the part’ question gives you a working program and a table of comments to fill in: a name in some rows, a line number in others.

• Give exactly what the row asks for: a line number or a name. A name where a line number is needed scores nothing.
• Give one answer per row. Only the first answer is marked.
• The PLS on your desk has the words (constant, initialisation, iteration…) with examples. Use it to check.

 1  GRAMS_PER_GUEST = 75.0
 2  GRAMS_PER_BAG = 500
 3  
 4  bagsNeeded = 0.0
 5  guests = 0
 6  vegetarian = False
 7  
 8  guests = int (input ("Number of guests: "))
 9  vegetarian = (input ("Vegetarian menu (Y/N)? ") == "Y")
10  bagsNeeded = guests * GRAMS_PER_GUEST / GRAMS_PER_BAG
11  print ("Bags of rice:", bagsNeeded, "Vegetarian:", vegetarian)