Variables and Basic Data Types

A variable is a named location in your computer's memory where you store a value. Think of it as a labelled box. You give the box a name (the variable name), and then you put something inside it (the value). In Python, you create a variable by writing its name, an equals sign, and the value you want to store. For example: age = 25. This tells Python to find an empty memory slot, label it 'age', and store the number 25 there. From that point on, whenever you write 'age' in your code, Python will fetch the value 25.

Variables exist because without them, every piece of data in a program would have to be written directly into the code, and the program could never adapt or respond to user input. Variables allow a program to be dynamic—to ask for a user's name and remember it, to count how many times a loop has run, to store the result of a calculation.

Python tracks the type of data inside each variable. A data type defines what kind of value a variable holds and what operations you can perform on it. PCEP-30-02 focuses on four fundamental types:

You can check the type of any variable using the type() function. For example, type(age) would return <class 'int'>. Python is dynamically typed, meaning a variable can change its type during a program. You can write x = 10 (integer) and later x = 'hello' (string) without any error. This is convenient but can lead to bugs if you're not careful.

A variable name must follow rules: it can only contain letters, digits, and underscores; it cannot start with a digit; it cannot be a Python keyword (like if, else, for, while, True, False, None). Variable names are case-sensitive: score, Score, and SCORE are three different variables. The convention (PEP 8) is to use snake_case: all lowercase with underscores between words, like total_score.

When you assign one variable to another, Python copies the value (for simple types). For example: a = 5; b = a; a = 10 leaves b as 5 because when you ran b = a, Python copied the current value 5 into b. Changing a afterwards doesn't affect b. This is different from compound types like lists, but for the basic data types in this chapter, assignment always copies the value.

Literal values are the raw values you write in your code: 42 is an integer literal, 3.14 is a float literal, 'hello' is a string literal, True is a boolean literal. You assign these literals to variables. Python also supports special number systems: binary (prefix 0b, like 0b1010 for 10), octal (prefix 0o), and hexadecimal (prefix 0x). You won't need to use them for PCEP, but recognising them is helpful.

The input() function returns whatever the user types as a string. If you need to do maths with that input, you must convert it using int() or float(). Forgetting this conversion is one of the most common beginner errors tested on the exam. Similarly, the print() function can output any type, but it converts everything to a string for display.

Finally, the None value is its own type (NoneType). It means 'no value' or 'empty'. It is not zero and not False. Variables are often initialised to None when their real value hasn't been determined yet.

Imagine you are an IT support analyst at a small insurance company. Your job is to write a script that processes new customer applications. The company receives a CSV file each morning with names, ages, policy types, and premium amounts. You need to extract each row, validate the data, and calculate a discounted premium for certain age groups.

Your first step is to read the CSV file into your Python program. Each row becomes a list of strings. But you need to treat the 'age' column as a number so you can compare it to thresholds (like 'if age > 65, apply a senior discount'). You assign the age string to a variable raw_age = row[2]. Then you convert it: age = int(raw_age). If the conversion fails (someone typed 'thirty' instead of '30'), your program will crash—so you wrap it in a try/except block to handle that gracefully.

Next, you need to store the premium amount. The CSV gives you a string like '145.50'. You use premium = float(raw_premium). Then you can do calculations: discounted = premium * 0.9 for a 10% discount. You store the result in a new variable discounted_premium. Finally, you build a confirmation message using string concatenation: message = 'Dear ' + name + ', your discounted premium is ' + str(discounted_premium) + ' euros.' Notice you must convert discounted_premium (a float) back to a string to join it with other strings.

You also track whether a customer is eligible for a special offer. You create a boolean variable is_eligible = (age > 60 or premium > 200). This boolean will be True or False. Later, you use it in an if statement to decide whether to print the offer line in the email.

During testing, you find a bug: one customer's premium appears as 310.00000000000006 instead of 310.0. This is the floating-point precision issue. You learn to round() the value before storing it: premium = round(float(raw_premium), 2). This keeps your output tidy and avoids confusing call centre staff.

Day to day, you use variables constantly—tracking counters (how many rows processed, how many errors found), storing filenames, holding configuration values (like discount rate = 0.15). You debug by printing variable values at key points. You rename variables when the business rules change (like renaming 'old_discount' to 'senior_discount' to match the new policy document).

Your script works flawlessly for weeks, until a new intern sends a file where the 'age' column has some values as 'N/A' for non-applicants. Your int() conversion crashes. You add a check: if raw_age.isdigit(): age = int(raw_age) else: age = 0. This is real-world variable handling—defensive coding that assumes data will be messy and plans for it using type checking and conditional logic.