1 A Brief History of Programming

The laptop in front of you is, at heart, billions of tiny switches, each either on or off. That sounds nothing like writing a Python program, and closing the gap between those two worlds took two ideas. The first is old: that a machine could follow a stored set of instructions without a person guiding its every move. The second is physical: that you could build such a machine out of something that simply switches on and off. This chapter tells both stories, and shows how they collided in the 1940s to produce the machine on your desk. Class time will only sample this story; here it is in full, so skim where it overlaps with the lecture and linger where your curiosity takes you.

1.1 The Idea of a Programmable Machine

Long before electronic computers existed, people had already discovered one of the central ideas of programming: a machine’s behaviour could be controlled by instructions encoded separately from the machine itself.

In 1804, the Jacquard loom used punched cards to control the pattern of a weave automatically. Change the cards, and the same machine produced a different pattern. The loom was not a computer, but the idea behind it was remarkably familiar: instead of rebuilding the machine for every new task, change the instructions it follows.

In the nineteenth century, Charles Babbage designed the Analytical Engine, a mechanical general-purpose computer that was never completed. Ada Lovelace translated an article about it and added her own notes. In Note G she described an algorithm for computing Bernoulli numbers, making it the first published algorithm intended for a machine. She also noticed that the engine could one day compose music if the rules of harmony could be expressed as operations.

Charles Babbage (1791–1871), designer of the Analytical Engine	Ada Lovelace (1815–1852), wrote the first published algorithm for a machine

Lovelace saw what a machine that followed instructions could become, but no one yet had a fast, reliable way to build one. That problem starts somewhere completely different: electricity.

1.2 From Electricity to Switches

To do anything useful with electricity, we first need a way to control its flow through a wire. The switch was invented for exactly this purpose: to open and close a circuit, allowing current to pass or stopping it entirely. At first, controlling these switches was a manual task: a person flipped a lever, pressed a button, or turned a dial. Over time, we learned to control switches electronically, using one electrical signal to operate another. That step, letting electricity control itself, is the foundation of all computing.

1.3 Vacuum Tubes: The First Electronic Switches

The vacuum tube was the first practical electronic switch. Electromechanical relays, switches operated by an electrical signal, had come before it, but a vacuum tube could be turned on and off by another electrical signal with no moving parts at all. This opened the door to a wave of inventions that reshaped the twentieth century. With vacuum tubes we built radio, television, radar, sound recording and reproduction, large telephone networks, industrial process control, and, crucially for our story, the first analog and digital computers.

1.4 Analog vs. Digital

Early electronic devices worked with information in two different ways. Analog signals are translated into electrical impulses of varying amplitudes: that is, the strength of the signal carries the information, in a continuous range. A vinyl record is an analog medium: the shape of the groove varies continuously to represent the sound wave.

Digital information, by contrast, is represented using discrete values: there is no “in between”, and each piece of information is represented as one of a fixed set of values. Modern computers overwhelmingly use binary, representing those values with 0s and 1s. This distinction matters because digital representation is what makes modern computers possible. When your phone stores a photo or a song, there is no groove, no continuous physical trace. There is only a long pattern of 0s and 1s. Because the representation is discrete, copying that pattern reproduces the original exactly, without the gradual generation loss associated with analog media. Storage and communication systems can also use error-detection and correction techniques to protect that information, so the file can travel anywhere and be processed without degrading.

Modern digital computers overwhelmingly use the simplest possible code: two symbols. And that idea is much older than electronics.

1.5 Binary: The Language of Computers

Electronic digital computers use binary. Inside the hardware, a 1 and a 0 correspond to two distinguishable electrical states, such as two different voltage levels; the exact representation depends on the hardware. These 0s and 1s are known as bits, short for binary digits.

Binary itself is not a new idea. As far back as 1605, the English philosopher Francis Bacon devised a cipher in which each letter of the alphabet was represented by a sequence of five symbols drawn from a set of just two: the two typefaces of his biliteral cipher, conventionally written today as a and b, and mapped just as naturally to 0 and 1 (so aaaaa for one letter, aaaab for the next, and so on). Bacon was encoding text, not building a computer, but the underlying idea is exactly what makes digital computing work: any information can be represented using just two symbols.

Two breakthroughs are now in place: the idea of a machine that follows stored instructions, and a way to represent information with on-off switches. In the 1930s and 1940s, these two threads finally met.

1.6 A Universal Machine

In 1936, the British mathematician Alan Turing described a universal Turing machine: a theoretical device that reads symbols, follows a table of rules, and moves between states as it works. He proved that a single such machine could, in principle, compute anything that is computable. He was not building hardware; he was working out what “computation” itself means. Nearly a century after Lovelace’s notes, Turing had given the idea of a programmable machine a rigorous mathematical foundation.

A decade later, in 1945, the Hungarian-American mathematician John von Neumann helped articulate the stored-program computer architecture in the First Draft of a Report on the EDVAC. In a von Neumann machine, both the program (the instructions) and the data (the information the program works on) are stored in the same memory. This is such a fundamental idea that it can be hard to imagine computing any other way, but it was a genuine breakthrough at the time. Here the two threads of this chapter meet: the idea of a machine that follows instructions, built out of electronic switches, storing both instructions and data as 0s and 1s.

1.7 Managing Complexity

To see what the stored-program idea replaced, picture the earliest electronic computers: enormous machines, filling entire rooms and containing thousands of vacuum tubes. Configuring them to perform a task was a manual, painstaking process: technicians rewired the machine or set banks of switches by hand for each new computation. This approach did not scale.

In the stored-program computer, the CPU, or central processing unit, is the part that executes a list of instructions, each of which performs a small calculation. Instead of rewiring the machine, you change the list of instructions, the program, and let the CPU carry it out. The results of those calculations are stored in memory, a circuit that holds 0s and 1s in addressed locations, so that the CPU can read and write them as needed.

This separation is the heart of the von Neumann architecture, and it is how we manage complexity: we break a large problem down into a long list of small, simple steps, and let the machine carry them out one at a time. That is the same move you will make as a programmer. When a problem looks overwhelming, you will break it into steps small enough for the machine to execute, and solve them one at a time.

1.8 Miniaturization

Computers did not stand still. The vacuum tube gave way to the transistor, transistors were packed together into the integrated circuit, and integrated circuits shrank until an entire CPU fit on a single microprocessor. Each step made computers smaller, faster, and more reliable, and the laptop from this chapter’s opening, billions of switches on a few chips of silicon, is where that line of development leads.

1.9 Summary

Programmable machines separate instructions from the machinery that follows them. The Jacquard loom demonstrated this through punched cards; Babbage’s Analytical Engine and Lovelace’s notes explored more general possibilities. Turing later established a mathematical foundation for computation.

Electronic switches and binary representation made electronic computing practical. In a stored-program computer, instructions and data share memory, and the CPU executes the instructions. Vacuum tubes gave way to transistors, integrated circuits, and microprocessors, making computers smaller, faster, and more reliable.

1.10 References and Further Reading

• Lovelace’s Notes on the Analytical Engine (1843): the translation containing Note G, the first published algorithm for a machine
• Turing, On Computable Numbers (1936): the paper behind the universal machine
• Von Neumann architecture
• History of computing hardware

2 Programming Languages

A CPU (central processing unit) executes instructions for operations such as moving values, adding numbers, comparing values, and jumping to another instruction. But programmers want to express larger ideas, such as “calculate the average of these grades” or “print a message if the password is wrong.” Programming languages help bridge that gap.

Abstraction hides lower-level details so you can focus on the problem you want to solve.

2.1 Programming Language Levels

Programming languages express instructions at different levels of abstraction. We will start with machine language, move to assembly, and then see how high-level languages such as Python let programmers focus on the problem instead of processor details.

2.1.1 Machine Language: Programming in Binary

A CPU executes machine instructions encoded in binary: patterns of 0s and 1s. These instructions form its machine language. Each instruction tells the CPU to perform an operation, such as adding two values or moving a value into a register.

Different processor families can use different instruction sets and binary encodings. Machine code built for one instruction set generally cannot run directly on a processor with a different instruction set.

2.1.2 Assembly Language: A Human-Readable Step Up

Assembly language represents machine instructions using readable names. An assembler translates those instructions into machine code.

For example, these two forms represent the same instruction on an x86 processor:

10110000 01100001

MOV AL, 61h

Both tell the processor to put the value 61h (97 in decimal) into AL, a register. Registers are small, fast storage locations inside the CPU.

Assembly is easier to read than binary, but programmers still work closely with the processor’s instructions and storage. You will not write assembly in COMP 1510; this example shows what high-level languages let you leave behind.

2.1.3 High-Level Languages and Abstraction

Machine language and assembly are each a low-level language because they expose hardware details. A high-level language, such as Python, lets you express a solution without specifying individual processor instructions.

For example, calculating an average in Python can look like this:

average = sum(grades) / len(grades)

For a non-empty collection of grades, this adds the grades and divides by how many there are. You do not have to decide which CPU registers hold the values or which machine instructions perform the calculation.

The diagram compares how a programmer approaches an average calculation in Python and assembly. The assembly branch uses illustrative pseudocode and shows only the final division step, assuming the total and count have already been calculated.

Abstraction lets you express a calculation while leaving more of its implementation to language tools.

2.1.4 Compilers and Interpreters

A compiler translates source code into another form, often machine code or an intermediate form called bytecode.

An interpreter executes a program by carrying out the operations described in its source code or intermediate form. Compilation and interpretation can work together.

When you run a Python program, its source code is typically compiled into bytecode, which the Python interpreter executes. These steps happen automatically.

Python also provides an interactive interpreter called the REPL (Read-Eval-Print Loop). You enter some code, Python evaluates it, displays a result when appropriate, and waits for your next input. This makes it convenient to try small expressions and explore how the language works.

2.1.5 Different Languages for Different Problems

High-level languages serve different purposes. Fortran was developed for scientific calculations, SQL expresses queries over data, and Python supports a wide range of programming tasks.

These languages are not successive steps on a single ladder. They make different choices about how programmers express solutions. Python’s readability and interactive environment make it useful for learning the fundamentals in this course.

2.2 Programming Paradigms

Language levels describe how much hardware detail a programmer must manage. Programming paradigms describe how a programmer organizes a solution.

A paradigm is a way of organizing a program and expressing a solution.

A problem can often be approached through more than one paradigm.

2.2.1 Procedural Programming

Procedural programming describes what the computer should do through explicit instructions, grouped into reusable procedures or functions.

A program might read a temperature, convert it from Celsius to Fahrenheit, and display the result. As programs grow, they can make decisions, repeat instructions, and call functions to perform particular tasks.

This is the style you will spend most of COMP 1510 practising.

2.2.2 Object-Oriented Programming

Object-oriented programming organizes code around an object, which combines data and behaviour.

In a game, a Player object might store its health and position and provide actions such as move() and attack(). This approach helps organize programs containing interacting things, each with its own data and actions. You will explore it in later programming courses.

2.2.3 Functional Programming

Functional programming emphasizes computing results through functions and limiting changes to state, the data a program holds at a particular time.

A temperature-conversion function, for example, can take a Celsius value and return a Fahrenheit value without changing anything outside the function. A pure function produces the same result for the same input and has no side effect, such as modifying outside data or printing a message. These properties make its behaviour easier to reason about.

Calling a function does not, by itself, make a program functional; procedural programs use functions too. The distinction is the emphasis on pure calculations and combining their results.

2.2.4 Logic Programming

Logic programming expresses facts and rules that a system uses to answer questions.

In Prolog, for example, you could state which courses Alex has passed and which prerequisites a course requires. The system can then use those facts and rules to determine whether Alex meets the prerequisites.

2.2.5 Multi-Paradigm Languages

Many languages support more than one paradigm. Python supports procedural and object-oriented programming, as well as functional techniques.

In COMP 1510, we begin procedurally: writing clear instructions and grouping related work into functions. Other approaches become useful as you encounter different kinds of problems.

2.3 Summary

Abstraction lets programmers focus on a problem while language tools handle lower-level details. Machine language contains the instructions a CPU executes; assembly gives those instructions readable names. High-level languages such as Python let us express calculations without specifying individual processor operations.

Compilers translate code; interpreters execute it. Python typically combines both approaches by compiling source code into bytecode and executing it through an interpreter.

Programming paradigms describe how we organize solutions. Procedural programming uses instructions grouped into functions; other approaches emphasize objects, pure calculations, or facts and rules. Python supports several paradigms, and COMP 1510 begins with procedural programming.

2.4 References and Further Reading

• Python glossary: bytecode: the intermediate form used when running Python programs.
• Using the Python interpreter: running Python, including interactive mode.
• Kathleen Booth: her contributions to early computing.
• Grace Hopper: her work on early programming systems.
• Programming paradigms: further examples of ways to organize programs.
• History of programming languages: an optional survey of how languages developed.

3 Getting Started with Python

In the previous two chapters we traced the history of computing hardware and surveyed the landscape of programming languages and paradigms. Now it is time to get our hands on a language. This chapter introduces Python, the language we will use throughout COMP 1510, and walks you through installing it, running it, and understanding its basic building blocks.

3.1 What Is Python?

Python is a high-level, general-purpose, multi-paradigm programming language designed for readability: Python code often reads almost like English, so the ideas stay front and centre while you learn. It is also genuinely practical, used across the industry in web development, data analysis, and automation, and it ships with a large standard library, meaning that many common tasks (working with files, fetching data from the web, doing math) can be done without installing anything extra.

For an introductory course, three reasons stand out:

• Readable syntax lets you focus on programming concepts rather than language mechanics.
• A large standard library means you can do a great deal without installing third-party packages.
• A huge community means tutorials, documentation, and help are easy to find.

3.2 Installing Python

Before you can write Python, you need to install it: download Python 3.14.x for your operating system from python.org and run the installer. Windows offers more than one installer, so follow the installation instructions for the one you choose; if it offers an “Add Python to PATH” checkbox, select it so your system can find Python from the command line.

3.3 The Python Interpreter

Once Python is installed, you can interact with it through the interpreter: the program that reads, evaluates, and executes your Python code.

3.3.1 Opening the Interpreter

1. Open a Terminal (on macOS or Linux) or PowerShell (on Windows).

2. Type the following to confirm that Python is installed and check its version:

   python3 --version
   

   You should see a version number starting with Python 3.14 (for example, Python 3.14.7). On Windows, type py --version instead; the py launcher takes the place of python3 on Windows, and that one substitution covers every command in this chapter.

3. To start the interpreter, type:

   python3
   

   (On Windows, use py.)

3.3.2 The REPL

When the interpreter starts, you are in the REPL: the Read-Eval-Print Loop. The REPL does exactly what its name says:

• Read an instruction you type.
• Evaluate (execute) it.
• Print the result.
• Loop back and wait for the next instruction.

You will see the >>> prompt, which means the interpreter is waiting for you to type something. Try your very first Python instruction:

>>> print("Hello, COMP 1510!")
Hello, COMP 1510!

Congratulations: you have just run your first Python program.

3.3.3 Basic Output

The print function displays values on the screen. It can print the result of an expression, and it can print several values at once, separated by commas:

print("Hello, COMP 1510!")
print(2 + 3)

name = "Ada"
print("Hello,", name)

Running this program produces:

Hello, COMP 1510!
5
Hello, Ada

Notice that 2 + 3 was evaluated before being printed, and that the comma in print("Hello,", name) simply puts a space between the two values. You will use print constantly, both to make programs talk to their users and to see what your own code is doing while you develop it.

3.3.4 Evaluating Expressions

The REPL is not limited to running commands like print. It also evaluates expressions and displays their results automatically. Try a few simple calculations:

>>> 2 + 3
5
>>> 10 * 4
40

You type an expression, press Enter, and the REPL shows you the result. This makes the REPL an excellent tool for experimenting and learning: you can try things out one at a time and see immediately what happens.

3.3.5 Exiting the Interpreter

When you are done experimenting, you can exit the REPL in a few ways:

• Type quit() and press Enter.
• On Windows, press Ctrl-Z then Enter.
• On macOS or Linux, press Ctrl-D.

3.3.6 Source Files

The REPL is great for quick experiments, but real programs are usually too long to type interactively. Python programs can also be stored in a source file: a plain text file with a .py extension, such as hello.py. You write your code in the file, save it, and then run it as a program:

python3 hello.py

(On Windows, run py hello.py.) Save your hello.py into a folder you can find again, such as a comp1510 folder inside your Documents. Locating that folder and running the file from the command line is exactly the next chapter’s job.

3.4 Python Keywords

A keyword is a reserved word with a predefined meaning in the language. You cannot use keywords as variable names, because Python has already claimed them for specific purposes.

Here is the full table of Python keywords:

A few soft keywords, such as match, case, and type, are contextual: Python treats them as keywords only inside specific constructs, so they can still be used as names elsewhere.

Do not try to memorize all of these at once. You will learn them naturally as they become relevant: if, else, for, and while will show up almost immediately, while others like async and nonlocal you may not need for a while. For now, just know that these words are reserved, and if you ever get an error when trying to name a variable, check whether you accidentally used a keyword. The official list lives in the language reference.

3.5 The Zen of Python

Python has a set of design aphorisms known as the Zen of Python. They capture some of the values that have shaped Python and its programming culture.

You can display the full Zen at any time in the interpreter:

>>> import this

You do not need to memorize it. A few of its ideas are especially useful as you begin programming:

• Readability counts. Code is read by people as well as computers. Choose names and structures that make your intentions clear.
• Simple is better than complex. Prefer a straightforward solution when one is available.
• Explicit is better than implicit. Make important behaviour visible rather than relying on assumptions or hidden details.
• Beautiful is better than ugly. Well-organized code should be pleasant to read and work with.
• Now is better than never. You do not need to understand everything before you start writing programs. Experiment, inspect the result, and keep learning.

These principles will make more sense as you write larger programs. For now, keep one idea close at hand: readability counts.

3.6 Summary

Python is a high-level, general-purpose language designed for readability. Its standard library provides tools for many common tasks without requiring additional packages.

The REPL lets you enter code and inspect results immediately. A source file saves code in a .py file so you can run and revise a program. In both settings, print() displays messages and calculated results.

Python’s keywords have reserved roles in the language. Its design principles, collected in the Zen of Python, encourage clear, simple, readable code. You will become familiar with both through practice.

3.7 References and Further Reading

• PEP 20 — The Zen of Python
• Python 3.14 documentation
• Built-in functions
• A brief history of Python
• Beej’s Guide to Python Programming, chapter 3: installing Python and running your first commands

4 The Command Line

Chapter 3 left you with a hello.py saved in a folder such as Documents/comp1510. A saved file is only useful if you can get back to it: if you close the terminal and return tomorrow, how do you find that folder and run the program again? As your scripts pile up, you need a way to move around, name things clearly, and run them without retyping everything. That is what the command line gives you.

The command line is a text-based interface for interacting with an operating system and its tools. Where a graphical desktop lets you point and click, the command line asks you to type what you want done. Programmers use it to run programs, inspect files, create directories, use version control, manage packages, and automate repetitive tasks. You open it with Terminal on macOS or Linux, or PowerShell on Windows. This chapter’s examples use Terminal on macOS; readers on Windows can follow along in PowerShell, where the everyday commands in the table below use the same spellings.

This chapter introduces the ideas you need to navigate the command line confidently: paths, the difference between absolute and relative locations, and the essential commands you will use every day.

4.1 Paths

When you open the command line, you usually start at your home directory, a personal folder reserved for your user account. From there, every file on the computer can be reached by following a path: a list of nested folders, read from left to right, that leads to the file or folder you want.

The details depend on your operating system. On macOS and Linux, the root directory is written /. Home-directory paths commonly look like:

macOS:

/Users/moose

Linux:

/home/moose

On Windows, paths usually begin with a drive root such as C:\, and the same home path looks like:

C:\Users\moose

The delimiting character differs too: Windows accepts both \ and /, while macOS and Linux use / exclusively. The differences that matter are called out as they come up.

4.2 Absolute vs Relative Paths

Paths come in two flavours, and understanding the distinction will save you a great deal of confusion.

An absolute path points to the same location no matter where you happen to be working. It always begins from the root directory, so there is no ambiguity. For example:

cd /Users/moose/exams

This command takes you to exams regardless of your current directory, because the path starts at /.

A relative path, by contrast, starts from your current working directory. If you are already inside /Users/moose, you can reach the same exams folder with:

cd exams

Relative paths are shorter and convenient, but they only make sense relative to where you are. From /Users, cd exams would look for /Users/exams, not /Users/moose/exams. A relative path is interpreted from your current directory. Absolute paths are longer but unambiguous: cd /Users/moose/exams reaches the very same exams folder from anywhere. As you work, you will learn to choose whichever fits the moment.

4.3 Essential Commands

Most day-to-day command-line work comes down to a small set of commands, and the same spellings work in Terminal and in PowerShell:

A few of these are worth a second look. The single dot . always refers to the current directory, while the double dot .. refers to its parent. These two shorthand symbols are the foundation of relative paths and appear constantly in real work: for example, cd .. to back out of a folder, or cd ../.. to climb two levels at once.

You will also meet one more shorthand, the tilde ~. It is shorthand for your home directory, the folder your account starts in, so ~/Documents means the Documents folder inside your home directory.

One command deserves a warning before you use it: rm deletes a file immediately. Unlike dragging a file to the Recycle Bin or Trash, deleting from the command line generally cannot be undone, so check the filename before pressing Enter.

You do not need to memorize every command at once. Pick a handful (pwd, ls, cd, and mkdir are a fine starting set) and practise them until they become muscle memory. The rest will follow naturally as your projects grow more ambitious.

Command Prompt, the older Windows shell, still appears on some machines. If one greets you, the survival kit is dir to list files, del to delete, rename to rename, and cls to clear the screen; typing bare cd prints the current directory. Typing powershell there launches PowerShell, the shell Windows readers can follow along in.

4.4 From Folder to Program

Here is the whole round trip, from a freshly opened terminal to a running program. On macOS or Linux:

cd ~/Documents/comp1510
ls
python3 hello.py

On Windows (PowerShell):

cd ~\Documents\comp1510
ls
py hello.py

The cd moves you into the project folder, ls confirms that hello.py is there, and the last line runs it. The path spelling (/ versus \) and the Python launcher (python3 versus py) are the only differences.

Use the location where you actually saved your file; the paths here are examples. If a folder name contains spaces, enclose the path in quotes, such as cd "COMP 1510".

Three habits make all of this faster:

• Tab completion: type the first few letters of a file or folder name and press Tab, and the terminal completes it. cd Doc followed by Tab becomes cd Documents.
• Command history: press the up arrow to bring back a previous command, edit it if you need to, and run it again.
• Drag and drop: dragging a folder from Finder or File Explorer into the terminal window inserts its path right at the prompt, which saves typing long paths by hand.

4.5 Summary

The command line lets you interact with your computer by typing commands. Your current working directory is the starting point for relative paths. Absolute paths identify locations independently of it, while ., .., and ~ refer to the current directory, its parent, and your home directory.

The essential navigation commands are pwd to check your location, ls to list its contents, and cd to move elsewhere. Use mkdir to create a directory, and take care with rm: deleted files generally do not go to the Trash or Recycle Bin.

To run a Python source file, navigate to its folder and enter python3 hello.py, or py hello.py on Windows. Tab completion and command history reduce repeated typing.

The next chapter introduces variables, which let a program name values and reuse them as it runs.

4.6 References and Further Reading

• Command-line interface
• Path (computing)
• Windows commands reference and Linux man pages

5 Variables and Assignment

You can now navigate the file system and run a Python program. As programs grow, they need to reuse values and carry results from one step to the next. Variables give those values names so we can refer to them throughout a calculation. This chapter introduces variables and explains how assignment binds names to values while a program runs.

5.1 Statements

The text you write to create a program is called code. A single row of text in that code is called a line of code.

A statement is a complete instruction that Python executes. It tells Python to do something: assign a value, display output, import a module, and so on. An expression is code that produces a value; 2 + 2 is an expression that evaluates to 4. The two are related, not opposed: statements often contain expressions. In area = pi * radius ** 2, the whole line is an assignment statement, while pi * radius ** 2 is the expression whose value it stores. A Python program (sometimes called a script) is a sequence of statements, evaluated and executed one at a time, in order, by the Python interpreter.

Consider the following statements:

print('Able was I ere I saw Elba')
print('Out darn spot, out!')
print('Buckle up, buckaroos!')
print(4 + 8)
print(3 * 2.5 ** 2 + 2.5 * 2 + 4)

When the interpreter runs this script, it reads the first print statement, carries it out, moves to the second, carries it out, and continues down the list. Each statement is a complete instruction. Some print text, some print the result of an arithmetic expression, but all of them are executed in the order they appear. This top-to-bottom flow is the simplest model of how a program runs, and it is the foundation everything else is built upon.

5.2 Variables

Printing values is useful, but a program that prints only literal values, written directly into the code, is limited. What we really want is a way to remember values so we can use them again later, perhaps in many places. This is what a variable provides: a name bound to a value.

Here is a simple example:

pi = 3.1415926535
colour = "red"

The first line binds the name pi to the value 3.1415926535. The second binds the name colour to the value "red", the string of three characters r, e, and d. Once a name is bound, we can use it anywhere in the program, and Python works with the value it refers to. It helps to picture a variable as a label attached to a value rather than a box containing it.

The two assignments from the example above, drawn as bindings rather than boxes:

Physically, those values live in the computer’s memory, the RAM (random access memory), along with everything else the machine is working on right now. Python chooses exactly where each value sits and keeps track of it for you: when you use the name pi, Python follows the binding to the value’s place in memory and fetches it. You never see or type a memory address. The name is the only handle you need.

5.3 Assignment

A variable is just a name. On its own, a name is not very useful: we must assign a value to it. An assignment statement associates the value on the right of the equals sign (=) with the variable on the left.

There are two rules to keep in mind:

• In the simple assignments we use for now, the left side is a variable name.
• The right side can be a value or an expression.

When Python encounters an assignment, it first evaluates the right side completely, then binds the resulting value to the name on the left. This is why an expression like area = pi * (radius ** 2) works: Python computes the value of the expression using whatever pi and radius currently refer to, and only then stores the result under the name area. The expression is the circle-area formula you know from geometry, $A = \pi r^2$, translated into Python: each quantity gets a descriptive name, multiplication becomes *, and the superscript becomes ** 2.

5.4 Variable Names (Identifiers)

Every variable needs a meaningful name, and that name is called its identifier. For COMP 1510, use the following rules when choosing one:

• Identifiers can be composed of letters (a–z, A–Z), underscores (_), and digits (0–9).
• An identifier may not start with a digit. player1 is fine; 1player is not.
• Python is case sensitive, so Python and python are two completely different names.

(Python itself permits a broader range of Unicode letters; the rules above are the ones we follow in this course.)

These rules define what is legal, but they do not define what is good. That is a matter of convention. Python’s official style guide, PEP 8, codifies it in detail, and that brings us to naming practices.

5.5 Naming Conventions

Identifiers must describe their purpose. A name is documentation: it tells the next person reading your code, perhaps you, three weeks from now, what a variable represents. Compare the following two versions of the same calculation:

Both versions produce the same result, but only the second one is readable. The vague names cost you every time the code is read: weeks later, a could be anything and must be decoded anew; nothing says whether 20.18 is a radius, an angle, or an age; and the formula itself is unrecognizable, so you cannot check it against the problem it is supposed to solve.

A few practical guidelines follow from this principle:

• Avoid single-character variable identifiers. They rarely communicate purpose, and a reader has nothing to go on when the code is revisited weeks later.
• Use abbreviations only when they are widely understood. Names like app or faq are common enough to be clear; abbreviations like usr for “user” or tmp for “temporary” save only a few keystrokes while costing readability.
• Be specific. If a variable in a game stores a non-player character’s age, age_in_years is better than a, and better even than age, because it removes all ambiguity about the unit.

5.6 Naming Cases in Python

Identifiers can be written in several typographic styles, and the programming community has names for the most common ones:

• snake_case: in_python_we_do_this, Python’s convention for variables and functions. (Python, the snake, uses snake case: folklore, but a memorable one.)
• UPPER_CASE: THIS_IS_UPPER_CASE, Python’s convention for constants: names for fixed values, such as TAX_RATE, that you do not intend to rebind.
• CapWords (ThisIsCapWords, also called CamelCase): Python’s convention for class names, which you will meet in a later course. Classes are not something you write yet, but you will recognize the style the moment you see it.

For the variables you write now, snake_case is the expected choice. Following it makes your code feel native to the language and easier for other Python programmers to read.

5.7 Summary

A statement is an instruction Python executes; an expression evaluates to a value. Statements often contain expressions, as in area = pi * radius ** 2.

A variable is a name bound to a value. Assignment evaluates the entire right-hand expression before binding its result to the name on the left. Assigning again can make that name refer to a different value.

Good names explain what values represent. Follow the course’s identifier rules, choose descriptive names, and use snake_case for variables. UPPER_CASE indicates constants by convention, while CapWords is used for class names.

The next chapter puts those named values to work through arithmetic, comparisons, and other expressions.

5.8 References and Further Reading

• PEP 8, the official style guide, naming conventions section
• Assignment statements, language reference
• Snake case
• Beej’s Guide to Python Programming, chapter 5: data, variables, and assignment

6 Operators and Expressions

The previous chapter gave you a way to name values so a program can remember them. But a name on its own doesn’t do much. The real work starts when you combine those values: add them, compare them, test conditions, and build up results. That is what operators do. This chapter looks at the families of operators Python provides, sees how they combine into expressions, and finishes with the rules that decide which operator goes first when several appear together.

6.1 Operators and Operands

The phrase to remember is simple: operators operate on operands. Consider the familiar plus sign. In an expression like 5 + 5, each 5 is an operand and + is the operator. Because it sits between two operands, + is called a binary infix operator: “binary” because it takes two operands, and “infix” because it appears in between them.

The operands in 5 + 5 are literals: raw values written directly in the code. Python has several kinds of literals:

• Numeric literals, such as 5 or 3.14
• String literals, such as "Hello"
• Boolean literals, namely True and False

Literals are the raw material of expressions; operators are the tools that shape them.

6.2 Arithmetic Operators

Arithmetic operators do what you expect from mathematics, with a couple of additions that reflect how computers work with numbers.

Two of these deserve special attention. The / operator always produces a floating-point result, even when the division is exact: 6 / 3 yields 2.0. The // operator, by contrast, performs floor division (older books sometimes call it integer division): it rounds the quotient down to a whole number, in the sense of the floor function $\lfloor x \rfloor$, the greatest whole number at or below $x$:

$$\lfloor 7 / 2 \rfloor = \lfloor 3.5 \rfloor = 3 \qquad \lfloor -7 / 2 \rfloor = \lfloor -3.5 \rfloor = -4$$

So 7 // 2 is 3, while -7 // 2 is -4, not -3: “down” means down the number line, past zero when the quotient is negative.

One caution: floor describes the value, not the type of the result. Floor division of two integers gives an integer: 7 // 2 is the int 3. But if either operand is a float, the result is a float: 7.0 // 2 is 3.0, rounded down just the same. The rounding is the operator’s job; the type follows the operands.

The % operator returns the remainder after floor division. Quotient and remainder always reassemble into the number you started with; dividing 10 by 4 gives the quotient 2 and the remainder 2:

$$10 = 4 \times 2 + 2$$

In Python, 10 // 4 computes the quotient and 10 % 4 the remainder. For a positive divisor $d$, the remainder $r$ always satisfies $0 \le r < d$: divided by 2, a whole number leaves a remainder of 0 or 1 and nothing else, which is why n % 2 == 0 tests whether a number is even. The remainder is just as useful for cycling through a fixed set of values.

6.3 Comparison Operators

Comparison operators examine two values and produce a Boolean result: True or False.

Notice that comparison is not limited to numbers. Strings can be compared too, and Python orders them lexicographically, roughly alphabetically, using the numeric codes of each character. That is why "z" > "Z" is True: lowercase letters sort after uppercase ones in the character encoding. Also note the equality operator ==, which tests for equal value, is distinct from the assignment operator =. Confusing the two is one of the most common early mistakes, so keep them straight: = assigns, == compares.

The distinction is quickest to see in the REPL, where the assignment produces nothing to print while the comparison answers a question:

>>> age = 19
>>> age
19
>>> age == 19
True

The first line binds the name age to the value 19, silently. The last line stores nothing: it asks whether the two values are equal and evaluates to a Boolean, True here, and False whenever the sides differ.

6.4 Boolean Operators

Preview: You will see these operators in simple conditions soon; we will study Boolean logic in more depth in Week 5.

Boolean operators (some books call them logical operators) combine Boolean values, letting you build richer conditions.

and yields True only when both operands are true. or yields True when at least one operand is true. not flips a Boolean value: not True is False, and not False is True. These descriptions assume Boolean operands, the True and False values that comparisons produce; handed values of other types, and and or behave a little differently, a detail we will meet much later. For now, the three operators are the glue that holds compound conditions together, letting you combine simple comparisons into richer ones.

6.5 Expressions

Operators and operands together form expressions. A value all by itself is the simplest possible expression: the literal 64738 evaluates to 64738. More generally, in mathematics and computing, an expression is a sequence of operators and their operands that specifies a computation.

Evaluating an expression produces a result (also called a value). The expression 2 + 2 generates the result 4. One built-in deserves a short note: the expression print("Hello") displays text, and the display is the whole point, but its own result is a special value, None, meaning “no useful value”. You will meet None again later in the course.

6.6 Operator Precedence

When an expression contains several operators, Python does not simply evaluate them left to right. Instead, it follows precedence rules that determine the order of evaluation. From highest to lowest, the order is:

1. ( ): parentheses are always evaluated first
2. Arithmetic operators (**, *, //, /, %, +, -): remember BEDMAS (Brackets, Exponents, Division and Multiplication, Addition and Subtraction)
3. Comparison operators (<, <=, >, >=, ==, !=)
4. not: Boolean NOT
5. and: Boolean AND
6. or: Boolean OR

Consider z - 45 * y < 53. Python evaluates the multiplication 45 * y first, then the subtraction z - ..., and finally the comparison ... < 53. The result is not the same as reading left to right, so precedence matters.

When several operators share a tier, Python evaluates them from left to right, so 12 / 3 * 4 divides first and then multiplies, giving 16.0. Exponentiation is the exception: it groups from right to left, so 2 ** 3 ** 2 means 2 ** (3 ** 2).

Exponentiation carries one wrinkle worth knowing: -2 ** 2 is -4, not 4, because ** binds more tightly than the unary minus. In mathematical notation, Python reads the expression as $-(2^2) = -4$, not $(-2)^2 = 4$; the two differ only in where the minus sign sits. If you mean the square of negative two, write (-2) ** 2.

To see the whole order at once, draw the earlier example, z - 45 * y < 53, as a tree:

The tree makes the order visible: 45 * y is evaluated first, the subtraction second, and the comparison last.

Precedence can also surprise you with Boolean operators. The expression x == 5 or y == 10 and z != 10 evaluates as (x == 5) or ((y == 10) and (z != 10)), because and binds more tightly than or. If that is what you intended, fine, but it is easy to misread.

The remedy is simple: use parentheses to make your intended order explicit. Writing (x == 5) or (y == 10 and z != 10) removes all doubt, both for Python and for the next person who reads your code. As the Python community likes to say, “Readability counts.” When precedence is unclear, parentheses are not redundant: they are a courtesy to your reader, and often to your future self.

6.7 Compound Operators

One assignment comes up so often that Python gives it its own shorthand. Suppose a variable already holds a value, and you want to increase it by one:

age_years = 19
age_years = age_years + 1    # age_years now refers to 20

The right side is evaluated first, using the value age_years currently refers to, and the name is then bound to the result. Because this read-then-update pattern is so common, Python provides a compound operator for each arithmetic operator, combining the operation with assignment:

age_years = 19
age_years += 1    # 20:  age_years = age_years + 1

account_balance = 100.00
account_balance -= 50.00    # 50.0:  subtraction

number_of_calls = 4
number_of_calls *= 2    # 8:  multiplication

average = 7.5
average /= 2    # 3.75:  division

slices = 7
slices //= 2    # 3:  floor division

remainder = 10
remainder %= 4    # 2:  the remainder of 10 by 4

For the simple numerical examples above, each compound operator behaves exactly like its longhand form: age_years += 1 does the same thing as age_years = age_years + 1, just shorter. After each line above, the name refers to the freshly computed value. Whenever you find yourself writing x = x <op> y, there is a compound operator that lets you write x <op>= y instead.

6.8 Summary

Operators act on operands to produce results. Arithmetic operators perform calculations, comparisons produce Boolean values, and Boolean operators let us combine or negate conditions. An expression evaluates to a value, even when its main job is something else: print("Hello") displays text and evaluates to None.

Division needs particular care. For the integer and float operands used here, / produces a float, while // rounds the quotient down, including for negative numbers. Floor division produces an integer when both operands are integers and a float when either is a float. The % operator gives the remainder.

Precedence determines how an expression is grouped. Multiplication takes precedence over addition, comparisons follow arithmetic, and the Boolean operators follow in the order not, and, or. Parentheses make the intended grouping clear. Compound operators such as += combine an operation with assignment, making common numerical updates shorter to write.

So far, we have supplied values directly in our code. The next chapter introduces programs that ask users for information and convert their responses into values we can calculate with.

6.9 References and Further Reading

• Operator precedence, the full table
• Modulo operation
• Beej’s Guide to Python Programming, appendix A: order of operations, floor division, and modulo

7 Input and Types

So far, every value in our programs has been written directly into the code. Real programs also need to work with information provided by users. This chapter introduces input() for reading what a user types, then looks at the different types of values Python can work with.

7.1 Basic Input

The input() function pauses the program and waits for the user to type something and press Enter. When it finishes waiting, the function returns the typed text: it hands the value back to your program, where it can be stored in a variable.

input() can also display a prompt: a short message that tells the user what to enter.

user_input = input()
user_age_years = input("Enter your age in years: ")

In the first line, the program waits silently for input. In the second, it displays Enter your age in years: before waiting.

Whatever the user types is accepted as input. The important detail is what Python does with that input, which we look at next.

7.2 input() Always Returns a String

The most important thing to remember about input() is simple: it always returns a string, even when the user types something that looks like a number.

If the user types 42, Python receives the string "42", not the integer 42. The string contains two characters: '4' and '2'.

For example:

age = input("Enter your age in years: ")

If the user enters 42, the variable age refers to the string "42".

This matters when we want to perform calculations. Python treats text and numbers differently, so we first need to understand the different types of values it can work with.

7.3 Data Types

Every value in Python has a type. A value’s type determines what kind of information it represents and which operations make sense for it.

You will work with four basic types from the beginning of this course:

An int represents a whole number. A float represents a floating-point number and can represent fractional values, although many decimal fractions cannot be represented exactly. A str represents text as a sequence of characters. A bool represents one of two truth values: True or False.

Python provides the built-in type() function when you want to check the type of a value:

print(type(42))
print(type(3.14))
print(type("hello"))
print(type(True))

The program prints:

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

We can now use type() to confirm what happens with user input:

age = input("Enter your age in years: ")
print(type(age))

If the user enters 42, Python prints:

<class 'str'>

The characters look like a number to us. Python still sees the value returned by input() as a string.

7.4 Data Conversion

If we want to use numerical input in a calculation, we need to convert it from a string to a numeric type. This is called type conversion.

Python provides several built-in functions for conversion:

The value you pass to a function is called an argument. Each of these functions takes one argument and produces a value of the requested type.

int("42")       # 42
int(3.14)       # 3
float("3.14")   # 3.14
str(42)         # "42"

A float argument to int() simply loses its fractional part. A string argument has to make sense as the requested type. For example:

int("42")       # works
float("3.14")   # works
int("3.14")     # ValueError
int("hello")    # ValueError

int("3.14") fails because the string does not contain an integer. int("hello") fails because the string does not represent a number at all.

These invalid string conversions raise a ValueError: Python accepts a string as an argument to int(), but the string must represent an integer. We will study errors and exceptions in more detail later in the course.

7.5 Implicit Conversion

Sometimes Python performs a conversion automatically.

Consider an expression that combines an int and a float:

result = 5 + 2.5
print(result)

Python produces:

7.5

For this operation, Python treats the integer 5 as the floating-point value 5.0, then performs the addition. The result is therefore a float.

This kind of automatic conversion is called implicit conversion, or coercion.

In mixed int and float arithmetic, Python converts the integer operand to a float for the operation. Converting the float to an integer could discard its fractional part.

7.6 Putting It Together

We can now combine input and conversion in a small program:

price = input("Price: ")
quantity = input("Quantity: ")

total = float(price) * int(quantity)

print(total)

Suppose the user enters:

Price: 19.99
Quantity: 3

input() gives us two strings:

"19.99"
"3"

The program then converts "19.99" to the float 19.99 and "3" to the integer 3. Once both values are numeric, Python can multiply them and produce:

59.97

If we tried this instead:

total = price * quantity

Python would raise a TypeError because both values are strings and string-by-string multiplication is not defined.

The pattern is worth remembering:

1. Read input as a string.
2. Convert it to the type you need.
3. Compute with the converted value.

You will use this pattern throughout the course.

7.7 Built-ins So Far

A built-in function is a function Python makes available automatically. No import is required.

You have now met these built-in functions:

Python provides many more built-in functions. You can find the complete list in the official built-in functions reference.

7.8 Summary

input() returns a string, even when the user enters a number. It can display a prompt before waiting for the user to type and press Enter.

Every value has a type that determines which operations it supports. The four types introduced here are int, float, str, and bool; type() reports a value’s type.

Type conversion lets us turn input into values suitable for calculations. Use int() for integers, float() for floating-point numbers, and str() for text. Invalid string conversions, such as int("hello"), raise a ValueError. Python also performs some conversions automatically during mixed numeric arithmetic.

The practical pattern is read → convert → compute: collect the input, convert it to the type you need, and use the result.

The next chapter introduces the tools you will use to write, run, and share those programs: an editor, an IDE, and version control.

7.9 References and Further Reading

• Built-in functions: includes input(), type(), int(), float(), and str()
• Type system
• Floating-point arithmetic
• Beej’s Guide to Python Programming, chapter 5: user input, data types, and converting between them

8 Text Editors, PyCharm, and Version Control

Our first chapters were about ideas: the history of computing, the levels of programming languages, and the core building blocks of Python itself. This chapter is about the workshop. Writing programs for real means writing, running, fixing, and sharing files, and for that you need tools. In COMP 1510 we use three: a code editor, an integrated development environment called PyCharm, and the version control system git together with the GitHub service. This chapter explains what each tool is for and why it matters.

8.1 From Text Editor to IDE

A Python source file is nothing more than plain text, so in principle any text editor can write one. In practice, the choice of editor makes an enormous difference:

• A plain editor (like Notepad) shows raw text and offers no help at all.
• A programmer’s editor adds conveniences aimed at code: syntax highlighting colours keywords, strings, and numbers so mistakes stand out, and automatic indentation keeps your program’s structure visible.
• An integrated development environment (IDE) goes further still: it combines an editor with tools to run and debug programs, manage projects, and work with version control, all in one application.

We use PyCharm, an IDE built specifically for Python. Among other things, it will:

• Highlight syntax and flag likely errors as you type, before you ever run the program.
• Run your programs with a single click.
• Include a built-in terminal, so the command-line skills from an earlier chapter are always one keystroke away.
• Integrate with git.

8.2 Projects

PyCharm organizes your work into a project: a folder on disk that holds your code plus PyCharm’s own settings, including which Python interpreter to use. Creating a project and choosing its Python interpreter takes only a few minutes. After that, opening PyCharm and opening your project is all it takes to pick up where you left off.

When you create a new project, PyCharm normally creates a virtual environment, usually stored in a folder named .venv inside the project folder. A virtual environment is an isolated Python environment for that project, so each project can manage its own packages without interfering with other projects or your system. We will only take a brief look at it this week; it will become more important later in the course, when we begin installing packages.

8.3 Version Control with git

Sooner or later, every programmer loses a working version of a program to a careless edit. Saving copies by hand (assignment01.py, assignment01_v2.py, assignment01_final.py, assignment01_final_FINAL.py) only postpones the problem.

git solves it. A git repository records a series of snapshots of your project, each called a commit. A commit stores a snapshot of the exact state of the files git is tracking, along with a short message you write describing what changed and why. A commit does not automatically sweep in every file in the folder: git records only the files you have told it to track, and staging chooses which of their current edits belong in the snapshot. Work that has been committed can normally be recovered from the repository’s history, even if the current files get deleted or damaged. At any moment you can look back through the history, compare versions, or return to any earlier snapshot.

The workflow is a small loop you will repeat thousands of times:

1. Edit your files.
2. Stage your changes: tell git which edits belong in the next snapshot.
3. Commit: take a snapshot with a message, such as “add input validation”.
4. Keep working.

Commit early and commit often. Small commits are easy to understand and easy to roll back; big ones are neither. This is “now is better than never” applied to your work history.

Drawn as a loop, the workflow looks like this:

The highlighted step is the one that matters: the commit is the snapshot that makes your work recoverable. Push and pull just move commits between your machine and GitHub (pull also integrates what it fetches into your copy), which the next section explains. PyCharm runs most of this loop for you: it stages your changed files, commits them with your message, and pushes, all from a few clicks.

8.4 GitHub

git works entirely on your own machine, which raises an obvious question: what happens if your laptop dies the night before a deadline? GitHub is the answer. It is a website that hosts git repositories in the cloud, giving you backup, sharing, and collaboration.

Here is the three-way distinction, stated plainly. A commit records a snapshot in your repository’s history, on your machine. A push transfers your new commits from your machine to a remote copy. GitHub is the hosting service where that remote copy lives: git is the tool, GitHub is a place to store repositories that use it.

The daily loop gains two steps:

1. Push: send your new commits from your machine to GitHub.
2. Pull: fetch any new commits from GitHub and integrate them into your local copy. Pulling is really two steps in one: it fetches the new commits, then combines them with your own work so your copy is up to date.

8.5 Summary

PyCharm brings programming tools into one workspace. Its editor helps you read and write code, while its other tools let you run programs, investigate errors, and manage projects. Each project uses a selected Python interpreter, often through a virtual environment that keeps its packages separate from other projects.

git records your project’s history. Staging selects the changes for the next commit; committing records them with a message. Small, regular commits make it easier to understand how your program developed and return to earlier work.

GitHub hosts a remote copy of your repository. Pushing sends your commits to GitHub, while pulling fetches remote commits and integrates them into your local copy.

8.6 References and Further Reading

• Pro Git, the definitive book on git, free to read online
• Official git documentation
• GitHub Docs
• PyCharm documentation

9 Computational Thinking and Program Design

In Week 1, you learned the basic pieces of a Python program: expressions, names, input() and print(), and type conversions such as int() and float(). You also learned how to write and run a program.

Most of those programs followed a simple path from top to bottom: read some input, perform a calculation, and display a result. The steps were either given to you or simple enough that the design was almost invisible.

Real programming problems rarely arrive that way. Before a request can become Python, someone has to decide what information matters, what steps are needed, and what should happen in different situations. That is the focus of Week 2.

In this chapter, we will make a problem precise, design a solution, and represent that solution with an algorithm and a flowchart. We will turn the design into Python in the next chapter.

9.1 From Writing Programs to Designing Them

Before writing a program, we need to understand the problem and work out how to solve it. Choosing the steps, their order, and the decisions they involve is design. Translating that solution into Python is implementation.

For a very small program, the two can feel like the same activity. As programs become larger, separating them becomes increasingly useful. A few minutes spent reasoning about a solution before coding can prevent much more time being spent debugging a program that implements the wrong idea.

Design and implementation are parts of a larger programming lifecycle. We design a solution, implement it, run and test the program, and revise our work when the result differs from what we expected:

Testing gives us evidence about both the program and its design. When the program behaves as expected, it has passed that particular check. When it does not, we investigate why. The code may not follow the design correctly, or the design may not solve the original problem as intended.

The programming lifecycle is therefore flexible rather than strictly linear. We can check a design before implementing it, revise code after testing it, or return to the design when implementation exposes a missing detail. Each stage helps us understand the problem and improve the solution.

As programs grow, their instructions need a clear organization. A long, tangled sequence of instructions is difficult to understand, test, and change. Structured programming organizes control flow using three main structures: sequence, selection, and repetition.

Indirection provides another form of organization. It allows one part of a solution to refer to another operation by name without showing all of its steps at that point. You have used it already: when you write input(), the steps that actually read the keyboard live inside Python, and you refer to that whole job by a single name.

In this chapter, we will focus on sequence and selection, and we will meet repetition in flowchart form. We will implement repetition in Python when we study loops. We will return to indirection when we learn how to define and use functions.

9.2 Computational Thinking

Computational thinking is a way of analyzing problems and expressing solutions precisely enough that a person or computer can carry them out.

In her 2006 article Computational Thinking, computer scientist Jeannette Wing argued that this way of thinking belongs alongside reading, writing, and arithmetic as a skill for everyone. Its value lies in making difficult problems manageable: choosing a useful representation, separating a task into smaller parts, and finding an approach that can work in other situations too.

That argument has new relevance now that generative AI can produce code from a description of a problem. A 2026 systematic review of generative AI in computing education found that AI often helps students complete programming tasks faster, but those gains do not reliably transfer to independent performance. The authors identify verification, including reading, testing, modifying, and explaining code, as essential to learning. Doing that well still requires students to understand the problem and reason about the proposed solution.

In this course, we will organize computational thinking around four useful techniques:

• Decomposition breaks a larger problem into smaller pieces that can be understood and solved separately.
• Pattern recognition notices similarities between the current problem and problems or structures we have seen before. Recognizing a familiar shape can suggest a familiar solution.
• Abstraction decides which details matter and which can be ignored. A transit map, for example, preserves stations and connections while leaving out most streets, buildings, and geographic detail.
• Algorithm design turns a solution into precise steps. The result is an algorithm: a procedure that can be followed to solve a problem. When those steps are expressed as a program, a computer can carry them out automatically.

These techniques work together. Deciding which details matter can make a problem easier to break apart, and recognizing a familiar pattern can help us design the steps of a solution.

Precision is especially important when the solution will be carried out by a computer. People often follow instructions that leave room for judgment, such as:

Cook until golden brown.

A person may understand that instruction from experience. A computer cannot act on it unless “golden brown” is represented using something it can evaluate or measure.

The same issue appears in a request such as:

Choose the shipping rate.

A shipping clerk may already know the rate policy and apply it without describing every decision. A program needs the policy stated explicitly: which information determines the rate, where the rate changes, and what result should be produced.

We will use this shipping problem to see how the four techniques help turn an informal request into a design that we can inspect before writing Python.

9.3 Designing the Shipping Algorithm

Imagine a local courier with these shipping rates:

We want to build a small shipping calculator. The customer enters the package weight, and the program displays the shipping rate.

Before thinking about Python, we can make the problem precise:

Identifying the input, output, and assumptions is an example of abstraction. For this simplified policy, we keep the package weight and ignore details that do not affect the rate, such as the colour of the box or the customer’s payment method.

We can then use decomposition to divide the task into smaller steps:

1. Read the package weight.
2. Determine which shipping rule applies.
3. Use the rate from that rule.
4. Display the rate.

The rate table also reveals a useful pattern: the result depends on which range contains the input. The same pattern appears when deciding whether an order qualifies for free delivery or whether a temperature is below freezing. This pattern recognition tells us that the solution needs a choice between alternatives.

These steps form an algorithm. They describe what the solution must accomplish without committing us to Python syntax.

The algorithm combines two of the structures introduced earlier. Reading the weight, choosing a rate, and displaying it happen in sequence. Choosing between the two rates requires selection.

9.4 Representing the Algorithm

A flowchart represents an algorithm visually. Shapes describe different kinds of operations, while arrows show how control moves between them. This movement is called control flow: the order in which instructions run.

The most useful flowchart symbols for this course are:

Symbol	Name	Use
	Termini (START and END)	Pill-shaped symbols that mark where the algorithm begins and ends; they are not ovals
	Rectangle	A process step, such as a calculation or an assignment
	Diamond	A decision containing a condition that evaluates to True or False
	Parallelogram	Input or output, such as reading keyboard input into a variable or displaying output on the screen
	Arrow	Movement from one step to the next

Flow normally moves from top to bottom and left to right. In this course, write each decision as a Boolean condition without a question mark, and label its outgoing paths True and False. This notation closely matches the conditions used in Python.

Flowcharts can also describe processes carried out by people. Use process rectangles for actions performed as part of the process. In our program flowcharts, use input/output parallelograms when the program reads input or displays output.

Consider a temperature-conversion program like those from Week 1:

This algorithm uses sequence: each step runs once, in order, along a single path.

The shipping algorithm also uses selection. It allows a condition to determine which path is followed. In this example, one condition is enough to choose between the two rates:

A package weighing 2 kg or less follows the True path. A heavier package follows the False path. Both paths set a rate before joining at the shared display step. At this stage, the important point is the shape of the solution: one condition separates two possible actions. Chapter 10 will explain how Python expresses this choice and will extend the idea to a problem with three alternatives.

A decision and a loop-back arrow can also express repetition. Suppose the shipping calculator must reject weights of zero or less. The validation part of the algorithm displays an error and returns to the input step until the user enters a positive weight:

A weight of zero or less follows the True path, displays an error, and returns to the input step. A positive weight follows the False path and continues to rate selection. The same steps can run as many times as needed. We will implement this behaviour in Python when we study loops; for now, the loop-back arrow is enough to represent it in a flowchart.

These familiar shapes make the structure visible. A straight path represents sequence, a decision diamond introduces selection, and a loop-back arrow represents repetition. More complex programs can be assembled from the same small set of structures.

Algorithms can also be written as pseudocode: a compact, code-like description that communicates the logic without requiring the exact syntax of a programming language. There is no universal pseudocode language. Its purpose is to make the steps and their order clear.

For example, the temperature-conversion algorithm could be written as:

READ celsius
SET fahrenheit TO celsius * 9 / 5 + 32
DISPLAY fahrenheit

The temperature-conversion flowchart and pseudocode represent the same sequence. The flowchart emphasizes shapes and connections, while the pseudocode emphasizes actions and order. We can choose the representation that makes a design easiest to understand and discuss.

9.5 Checking the Design

A design should be checked against the original problem before it becomes code. For the shipping calculator, we can ask:

• Does the design use the package weight as its input?
• Does each accepted weight follow one path?
• Does each path lead to the correct rate?
• Do both paths display a rate?
• Are the assumptions about the input stated clearly?

We can also trace the flowchart by choosing an input and following its path by hand. Useful checks include a weight below the point where the rate changes, the value at that point, and a weight above it:

Following each value through the flowchart connects the proposed algorithm back to the rate table. These examples do not establish that the design works for every possible weight, but they help us check both paths and the point where the result changes. Chapter 10 will examine such boundary values more carefully.

9.6 Summary

Program design begins by identifying the input, output, rules, and assumptions. Computational thinking supports this work through decomposition, pattern recognition, abstraction, and algorithm design. Structured programming organizes control flow through sequence, selection, and repetition; indirection lets one part of a solution refer to another operation by name.

A flowchart makes the structure of an algorithm visible, while pseudocode records its steps without requiring programming-language syntax. In the next chapter, we will express selection in Python and extend it from two paths to several alternatives.

9.7 References and Further Reading

• Wing, Jeannette M. “Computational Thinking.” Communications of the ACM 49, no. 3 (2006): 33–35. Argues that computational thinking is a fundamental skill for everyone, not only computer scientists.

• Kumar, Arun, Thakerng Wongsirichot, and Aziz Nanthaamornphong. “Generative AI in Computing Education: A Systematic Review and a Framework for Responsible Integration.” Computers and Education: Artificial Intelligence 11 (2026): 100677. Reviews evidence on learning, over-reliance, assessment, and responsible uses of generative AI in computing education.

• Wikipedia: Flowchart. An accessible overview of flowcharts and the common symbols used to represent processes, decisions, input/output, and control flow.

• Beej’s Guide to Python Programming, chapter 2: Pólya’s problem-solving process, from understanding the problem to looking back, and breaking large problems into subproblems.

10 Selection in Python

In Chapter 9, we used a flowchart to choose between two shipping rates. This chapter expresses that design in Python, then extends it to a cinema-ticket problem with three possible prices. We will examine how if, elif, and else express decisions, how indentation organizes their statements, and how to test each path.

10.1 From a Flowchart to Python

The shipping calculator from Chapter 9 charges $8 for a package weighing 2 kg or less and $14 for a heavier package. Here is that flowchart expressed in Python:

weight = float(input("Enter the package weight in kilograms: "))

if weight <= 2:
    shipping_rate = 8
else:
    shipping_rate = 14

print("Shipping rate: $", shipping_rate, sep="")

We continue to assume that the input is a number greater than zero. As you learned in Week 1, input() returns a string, so float() converts that string to a number and allows a weight such as 1.5. The decision diamond has become the condition weight <= 2, and the two assignments correspond to its paths. The final display statement follows both paths. A weight of 1.5 or 2 produces the lower rate, while a weight of 3 produces the higher rate.

You also met comparison operators in Week 1. A comparison produces True or False; here, that result can determine which path the program follows.

An expression that produces True or False is a Boolean expression. Here, weight <= 2 determines which path runs. Remember that = assigns a value, while == compares values for equality.

10.2 The if Statement and Indentation

An if statement runs one or more statements when its condition is True. Consider a program that displays a message for packages in the lower weight range:

weight = float(input("Enter the package weight in kilograms: "))

if weight <= 2:
    print("The lower shipping rate applies.")

print("Thank you for checking our shipping rates.")

For a weight of 1.5, both messages appear. For a weight of 3, the first message is skipped, but the thank-you message still appears.

In Python, the statements controlled by an if form a block. Indentation shows which statements belong to that block. The if header ends with a colon, and every statement in its block is indented beneath it at the same level. Use four spaces for each indentation level.

Returning to the previous indentation level ends the block. A statement at that level is outside the if block. Moving a statement into the block therefore changes when it runs:

weight = float(input("Enter the package weight in kilograms: "))

if weight <= 2:
    print("The lower shipping rate applies.")
    print("Thank you for checking our shipping rates.")

Now both messages belong to the if block. For a weight of 3, neither appears. Both versions are valid Python, but their indentation gives them different behaviour.

An if statement on its own either runs its block or skips it. Adding else gives the program an alternative block, as in our shipping calculator:

if weight <= 2:
    shipping_rate = 8
else:
    shipping_rate = 14

Exactly one assignment runs. The else has no condition of its own: it covers every case rejected by the if condition. Its header ends with a colon and aligns with the if to which it belongs.

The display statement belongs after the entire selection because both paths need it. This combines selection with the surrounding sequence of input, processing, and output.

10.3 Choosing Among Several Paths

Now consider a fictional cinema with three ticket prices:

The customer enters an age, and the program displays the corresponding price. For now, we assume the input is a whole number greater than or equal to zero. We will handle negative ages later in this chapter.

One condition separates two paths. To choose among three prices, we need another condition. The keyword elif means “else if.” Python checks its condition only when the earlier conditions in the same chain were False:

age = int(input("Enter your age: "))

if age < 13:
    ticket_price = 8
elif age >= 65:
    ticket_price = 10
else:
    ticket_price = 14

print("Ticket price: $", ticket_price, sep="")

Python checks the conditions from top to bottom and runs only the first matching branch, one of the chain’s alternative paths. For an age of 70, age < 13 is False and age >= 65 is True, so Python assigns the senior price. For an age of 10, the first condition is True, so Python does not check the elif. For an age of 30, both conditions are False, so the else block assigns the adult price.

An if-elif-else chain can contain several elif clauses. The final else is optional, but when present it must come last. Without an else, no branch runs when every condition is False. In this program, the earlier conditions leave ages 13 through 64 for else. The shared display statement then runs after the chain.

Condition order matters when conditions overlap. Consider this incorrect attempt:

if age >= 13:
    ticket_price = 14
elif age >= 65:
    ticket_price = 10
else:
    ticket_price = 8

An age of 70 satisfies age >= 13, so the first branch assigns the adult price. Python never reaches the senior condition. Arrange overlapping conditions so that an earlier branch does not capture a case intended for a later one.

10.4 Combining Conditions

In Week 1, you previewed the Boolean operators and, or, and not: and requires both conditions to be True, or requires at least one of them, and not reverses its condition. We can now use them to combine comparisons in a single condition. We will study Boolean logic in more depth later in the course.

For example, an adult ticket applies when the age is at least 13 and at most 64:

if age >= 13 and age <= 64:
    print("The adult ticket price applies.")

Both comparisons must be True. An age of 30 satisfies both, while an age of 70 fails the second.

For a non-negative age, either the child condition or the senior condition identifies a customer who does not pay the adult price:

if age < 13 or age >= 65:
    print("A child or senior ticket price applies.")

The result is True when either comparison is True. In this example, that means the age is in the child or senior range.

A common mistake is to leave out part of a comparison. To check whether an age is exactly 12 or exactly 65, write each comparison in full:

age == 12 or age == 65

Do not write:

age == 12 or 65

The second expression does not compare age with 65. As a condition, it succeeds for every age; we will see why later in the course.

10.5 Independent and Nested Decisions

An if-elif chain chooses at most one branch. Separate if statements make independent decisions, so more than one block can run.

Suppose the cinema displays one message for a child ticket and another for a booking of five or more tickets:

age = int(input("Enter your age: "))
ticket_count = int(input("How many tickets are you buying? "))

if age < 13:
    print("A child ticket is needed for this customer.")

if ticket_count >= 5:
    print("Please collect this booking at the group counter.")

For an age of 10 and a ticket count of 5, both messages appear. Changing the second if to elif would make Python skip the ticket-count check whenever the child condition was True. Use separate if statements when both actions may occur. Use an elif chain when the branches are alternatives.

A nested decision places one decision inside another decision’s block. This is useful when the inner decision should happen only on a particular outer path.

We can use nesting to check whether an age is valid before choosing a ticket price. The first decision separates invalid ages from valid ones. Ticket selection happens only on the valid path, so it is nested inside that path. Here is that design expressed in Python:

age = int(input("Enter your age: "))

if age < 0:
    print("Age must be zero or greater.")
else:
    if age < 13:
        ticket_price = 8
    elif age >= 65:
        ticket_price = 10
    else:
        ticket_price = 14

    print("Ticket price: $", ticket_price, sep="")

The outer decision checks whether the age is negative. If it is, the program displays an error; otherwise, the inner selection chooses the ticket price. Its headers are indented four spaces, and their blocks are indented eight spaces. The final print() returns to four spaces, so it follows the inner selection but remains inside the outer else. A negative age therefore never reaches the price display.

This program checks one input and then ends. Asking again after an error will require a loop; Chapter 9 represented that repetition with a loop-back arrow. The program also assumes that int() can convert the input. We will handle failed conversions separately.

10.6 Testing Decision Paths

Testing compares what a program does with what it should do. Debugging finds and fixes the cause when those results differ.

In Chapter 9, we checked a design by following a path through its flowchart. Now we can run the Python program with chosen inputs and compare the displayed results with the cinema’s rules.

For the version that checks negative ages, predict the expected output for each age below before reading the table’s second column:

These boundary cases sit at or beside the points where behaviour changes. They help expose mistakes such as using <= where < was intended.

Ordinary values such as 10, 30, and 70 are also useful because they exercise each price branch. Passing these tests provides evidence that the program follows the requirements, although a finite set of tests cannot cover every possible input.

Choose the expected result from the requirements before running the program. Otherwise, it is easy to accept the program’s answer simply because it produced one.

When a result differs from what you expected, trace that input through the code. Check:

• The conditions: do the comparisons include the correct boundaries?
• The branch order: does an earlier condition capture the input unexpectedly?
• The indentation: does each statement belong to the intended path?

For independent decisions, include cases where both conditions are True, only one is True, and neither is True. This can reveal an accidental change from two if statements to an if-elif chain.

10.7 Summary

Selection chooses which statements run for a given input. An if statement can run or skip a block, else provides an alternative, and elif extends the choice to more paths. Indentation defines the blocks, and a chain runs only its first matching branch.

Boolean operators combine conditions. Separate decisions allow multiple actions, while nesting makes one decision depend on another. Test each path and the values where behaviour changes, using the requirements to determine the expected results.

10.8 References and Further Reading

• Python Tutorial: if Statements: examples of if, elif, and else.
• Python Language Reference: The if Statement: the formal structure and execution rules for selection.
• PEP 8: Style Guide for Python Code: conventions for indentation and naming.
• Beej’s Guide to Python Programming, chapter 6: flow control, Boolean expressions, and the if statement.

11 Working with Strings

So far, we have used strings mainly to read input and display messages. Working more closely with text requires us to look inside those values. A string is an ordered sequence of characters: we can find its length, select a character by its position, and examine the text it contains.

We can also combine strings, adjust capitalization, remove surrounding spaces, and insert calculated values into messages. These operations produce new values without changing the original string. Understanding that distinction will help us use strings correctly as our programs become more involved.

11.1 Strings and String Literals

Chapter 6 introduced string literals, and Chapter 7 introduced str as the type used for strings. We can now distinguish the notation written in code from the value it produces.

A string literal is the quoted notation used to write a string value directly in source code. The surrounding quotes mark the literal’s boundaries; they are not part of the value.

>>> "COMP 1510"
'COMP 1510'
>>> 'hello'
'hello'

You can use single or double quotes. Choosing the outer quotes lets you include the other kind inside the text:

print("It's easy")
print('She said "hi"')

The empty string, written "", contains no characters. It is still a string, just as zero is still a number.

11.2 Escape Sequences

Some characters affect how text is displayed. A newline moves text to the next line, and a tab adds horizontal spacing. Python writes these characters inside a literal with an escape sequence: a backslash followed by a character with a special meaning. For example, \n represents one newline character.

print("Line one\nLine two")
print("Name:\tAda")

The first statement displays its text on two lines. The second inserts a tab between Name: and Ada. Although \n is written with two characters in the source code, it represents one newline character in the string.

Often, choosing the other quote style is easier than using an escape. For example, the apostrophe in "It's easy" does not need to be escaped because the string literal uses double quotes.

11.3 Characters, Length, and Indexes

Each letter, digit, space, or punctuation mark in a string counts as one character. The built-in len() function returns the number of characters.

Each character sits at a numbered position called an index. Python numbers indexes from zero:

The string "Python" contains six characters, with indexes from 0 through 5. In a non-empty string, the first index is 0 and the final non-negative index is one less than the length.

Square brackets after a string select the character at an index:

>>> word = "Python"
>>> len(word)
6
>>> word[0]
'P'
>>> word[1]
'y'
>>> word[len(word) - 1]
'n'

Asking for an index outside the string raises an IndexError. The valid indexes of this six-character string run from 0 to 5, so word[6] fails.

The expression len(word) - 1 calculates the final index without assuming a particular string length. When text comes from input, we must first check that it contains at least one character:

name = input("Name: ")

if len(name) > 0:
    print("The first character is", name[0])
    print("The final character is", name[len(name) - 1])
else:
    print("No name was entered.")

The condition protects both indexing expressions. An empty string has length 0 and has no valid indexes, so trying name[0] without checking would raise an IndexError.

Negative indexes count from the end of a string. The index -1 refers to the final character:

>>> word[-1]
'n'

Python can also extract several characters at once. We will study that operation, called slicing, alongside lists later in the course.

11.4 Strings Are Immutable

Selecting a character does not mean that you can replace it. This assignment fails:

>>> word[0] = "J"

Python raises a TypeError. Strings are immutable, which means that an existing string value cannot be changed in place.

If a string cannot be changed in place, how can a program produce different text? A method is a function that belongs to a value, and strings provide many of them. Some methods return a new string while leaving the original unchanged.

You have already seen calls such as len(course), where the value goes inside the parentheses. A method call uses a different form: course.upper(). Here, course refers to a string, the dot connects it to the method named upper, and the parentheses call that method. The call returns an uppercase version of the string, which you can assign to a name:

course = "Introduction to Programming"
uppercase_course = course.upper()

print(course)            # Introduction to Programming
print(uppercase_course)  # INTRODUCTION TO PROGRAMMING

You can also assign the result back to the same name:

course = course.upper()

This does not change the original string. It makes course refer to the new string.

This difference explains a common surprise:

>>> name = "Ada"
>>> name.upper()
'ADA'
>>> name
'Ada'

The method produces a result, but this example does not store it. If the program needs the uppercase value later, it must assign the result to a name:

>>> uppercase_name = name.upper()
>>> uppercase_name
'ADA'

The same principle applies throughout this chapter: an operation can inspect a string or produce another value, but it does not edit the original string.

11.5 Combining Strings

Joining strings is concatenation. Python uses the + operator for it:

>>> first = "COMP"
>>> course = first + " 1510"
>>> course
'COMP 1510'

The * operator repeats a string a whole number of times:

>>> "ha" * 3
'hahaha'

The + operator cannot directly combine a string and a number. Although str() can convert a number first, f-strings are usually a clearer way to mix text with values.

11.6 A Few Useful String Methods

We have already used upper() to produce uppercase text. Here are six useful string methods. In the table, s is the string being used and t is the text to search for:

>>> course = "  Comp 1510  "
>>> course.strip()
'Comp 1510'
>>> course.lower()
'  comp 1510  '
>>> "COMP 1510".isupper()
True
>>> "comp 1510".islower()
True
>>> "Comp 1510".islower()
False
>>> "COMP 1510".find("M")
2
>>> "COMP 1510".find("z")
-1

These methods leave the original string unchanged, but their results have different types. upper(), lower(), and strip() return strings; isupper() and islower() return True or False; find() returns an integer position, or -1 when the text is absent. That -1 reports a failed search; it does not mean that a match was found at the final character.

strip() removes whitespace from the beginning and end, including spaces and tabs. It leaves spaces inside the text intact, so " Comp 1510 ".strip() preserves the space between Comp and 1510.

What a method returns determines how you can use it. A method that returns a string can provide cleaned or normalized text:

name = input("Name: ")
name = name.strip()
print("Hello,", name)

Methods are also useful in conditions. Converting text to lowercase before comparing it lets the program accept several capitalizations:

answer = input("Continue? ")
answer = answer.strip()
answer = answer.lower()

if answer == "yes":
    print("Continuing")
else:
    print("Stopping")

First, strip() removes surrounding whitespace. Then lower() produces lowercase text, allowing "yes", "YES", and " Yes " to satisfy the same condition. Each assignment makes answer refer to the next result.

Python provides many more string methods. You do not need to memorize a large list. Learn a small useful set now, and consult the string methods documentation when a program needs something else.

11.7 Formatting Output with F-Strings

An f-string is a string literal prefixed with f. Expressions inside braces are evaluated and placed into the text:

>>> name = "Ada"
>>> age = 19
>>> f"{name} is {age} years old"
'Ada is 19 years old'
>>> f"Age next year: {age + 1}"
'Age next year: 20'

The braces can contain a variable or another expression that produces a value.

Compare two ways to display the same result:

name = "Ada"
score = 92

print(name, "scored", score)
print(f"{name} scored {score}")

Both statements work. The f-string keeps the spaces and wording together, making the intended output easier to see in the program.

A colon after an expression introduces a format specification. Writing :.2f displays a number with exactly two digits after the decimal point, rounding the displayed value when needed:

>>> shipping_rate = 8
>>> f"Shipping rate: ${shipping_rate:.2f}"
'Shipping rate: $8.00'

Formatting changes the text produced for display; it does not change the value stored in the variable.

Here is the shipping calculator from Chapter 10 with its output formatted using f-strings. As before, this version assumes the user enters a positive numeric weight:

weight = float(input("Enter the package weight in kilograms: "))

if weight <= 2:
    shipping_rate = 8
else:
    shipping_rate = 14

print("COMP Couriers")
print(f"Weight: {weight} kg")
print(f"Shipping rate: ${shipping_rate:.2f}")

Use f-strings when output combines text with values. They keep the output pattern readable and give you control over how numbers appear.

F-strings create strings; they do not print by themselves. In the REPL, Python displays the resulting value, but a program normally passes the f-string to print() or assigns it to a name:

customer = "Ada"
message = f"Welcome, {customer}!"
print(message)

This prints Welcome, Ada!. Building a string and displaying it are separate operations, even when a program performs them in the same statement.

11.8 Summary

A string is an immutable sequence of characters. A string literal is text written directly in source code to create a string value. len() returns the number of characters, and an index selects one character from the sequence.

Strings cannot be changed in place, but expressions and methods can produce new strings. The methods upper(), lower(), and strip() return new strings, while find() returns an integer index. An f-string places the values of expressions into text, and :.2f displays a number with two digits after the decimal point.

11.9 References and Further Reading

• String methods: the complete list of methods supported by strings.
• F-strings in the language reference: the formal syntax of formatted string literals.
• Beej’s Guide to Python Programming, chapter 7: strings, immutability, and f-string formatting.

12 Using Python Modules

Python programs often use code that is already available. You have called built-in functions such as input() to read text, int() to convert a value, and print() to display it. Python also includes a standard library of reusable tools.

A module groups related functions and values. To use functions from a module such as math, you first import it. We will use math and random to see how to access their tools and use the results in calculations.

12.1 Importing a Module

The import statement makes a module available under its name. Imports normally appear at the top of the file, before the statements that use them. This example uses math.sqrt() to calculate a square root:

import math

number = float(input("Enter a non-negative number: "))
root = math.sqrt(number)
print(f"Square root: {root:.2f}")

The expression math.sqrt(number) uses dot notation: math identifies the module, sqrt selects its square-root function, and the parentheses call that function with number.

The example assumes that the user enters a number greater than or equal to zero. The prompt describes the expected input; it does not check it. We will add input checks when we study loops.

The dot also appeared with string methods in Chapter 11. The name before the dot tells you where the operation comes from:

• name.upper() calls a method on the string referred to by name.
• math.sqrt(25) calls a function provided by the imported math module.

After import math, write math.sqrt(25); the import does not create a separate name called sqrt.

12.2 The math Module

The math module contains mathematical functions and constants. We will use two of them here:

math.pi is a value, so it is used without parentheses. math.sqrt is a function, so parentheses call it:

>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(81)
9.0

12.2.1 Calculating the Area of a Circle

For a circle with radius $r$, the area is $A = \pi r^2$. This program uses math.pi for $\pi$ and assumes the user enters a positive numeric radius:

import math

radius = float(input("Enter the circle radius: "))
area = math.pi * radius ** 2
print(f"Area: {area:.2f}")

Python squares radius with ** 2 and multiplies the result by math.pi. The f-string displays two decimal places without changing the value stored in area.

12.2.2 Calculating Distance with math.sqrt()

Suppose two points are 3 units apart horizontally and 4 units apart vertically. By the Pythagorean theorem, the distance between them is $\sqrt{3^2 + 4^2} = 5$. The program first stores the sum of the squares in squared_distance, then passes that value to math.sqrt():

import math

horizontal = 3
vertical = 4
squared_distance = horizontal ** 2 + vertical ** 2
distance = math.sqrt(squared_distance)

print(f"Distance: {distance:.2f}")

horizontal and vertical are starting values. squared_distance is an intermediate variable holding 25. math.sqrt() returns 5.0, which is assigned to distance and displayed. You could pass the sum directly as math.sqrt(horizontal ** 2 + vertical ** 2); the name lets you inspect it.

12.3 The random Module

The random module provides randint(a, b) for choosing an integer between two limits:

>>> import random
>>> random.randint(1, 6)
4
>>> random.randint(1, 6)
1

Both limits are included, so random.randint(1, 6) can return any integer from 1 through 6, like a six-sided die. The limits must be integers, and the first must not exceed the second.

12.3.1 Choosing a Random Point

A program can import more than one module. This example chooses a point at random and calculates its distance from the origin:

import math
import random

x = random.randint(-5, 5)
y = random.randint(-5, 5)
distance = math.sqrt(x ** 2 + y ** 2)

print(f"Point: ({x}, {y})")
print(f"Distance from the origin: {distance:.2f}")

The names before the dots identify which module supplies each function. Two calls to random.randint() choose the point’s x and y coordinates; math.sqrt() uses them to calculate the distance. A later run may choose a different point, or the same one again.

When you need more from a module, check its documentation for available functions, the arguments they take, and the values they return.

12.4 Summary

The standard library is ready-made code that comes with Python. An import statement makes a module available, and dot notation selects a function or value from that module.

The math module provides math.sqrt() and the value math.pi. The random module provides random.randint(a, b), which returns a whole number from the inclusive range a through b. Keeping the module name visible makes the source of each library tool clear.

12.5 References and Further Reading

• The Python Standard Library: the official index of modules that ship with Python.
• math: Mathematical functions
• random: Generate pseudo-random numbers
• Beej’s Guide to Python Programming, chapter 12: importing and using modules.

13 Repetition in Python

A program often needs to perform the same work more than once. It might ask again after invalid input, examine each character in a string, or keep a running total. Writing a separate statement for every repetition becomes impractical when the input determines how many are needed.

A loop lets us write the repeated steps once and control how often they run. Chapter 9 showed this idea with a loop-back arrow in a flowchart. We will now express it in Python using while and for.

13.1 From Repeated Statements to Loops

Suppose a program needs to display the numbers from one through five. One approach is to write five separate statements:

print(1)
print(2)
print(3)
print(4)
print(5)

This works, but the program describes every repetition separately. Extending it to one hundred would require ninety-five more statements. If the counting rule changed, many lines might need to change with it.

The repeated lines can be replaced by a rule: display the current number, increase it, and stop after five. One pass through a loop’s block is an iteration.

Before writing a loop, answer three questions:

1. What values, if any, must be set before the repetition begins?
2. Which statements need to run during each iteration?
3. What will change from one iteration to the next, and how will the loop know when to stop?

Python provides two loop statements. A while loop repeats as long as a Boolean condition is True. A for loop takes items from a sequence one at a time; in this chapter, the sequence will be a string. We will begin with while because its condition makes the decision to repeat or stop explicit.

13.2 The while Statement

The while loop repeats its block while its condition is True. This loop counts from one to five:

count = 1
while count <= 5:
    print(count)
    count += 1

Three parts make this loop work:

1. Before the loop, count is initialized to 1.
2. At the top of every pass, Python tests count <= 5. If it is True, the indented block runs. If it is False, the loop ends.
3. The statement count += 1 increases count by one before the next condition check.

Trace each condition check to see how count changes and why the loop stops:

Python checks the condition six times, but the body runs only five times. At the final check, count is 6, so count <= 5 is False and no sixth iteration begins.

The condition is tested before every pass, including the first. If it is False immediately, the body does not run. A while loop therefore runs its body zero or more times.

The flowchart below shows the two possible paths after a condition check:

In the counting example above, the diamond represents count <= 5 and the loop body contains print(count) and count += 1. After both statements run, execution returns to the condition for another check. The False path leaves the loop without running its body.

Indentation determines which statements repeat. Adding a statement after the loop makes the difference visible:

count = 1
while count <= 3:
    print(count)
    count += 1
print("Done")

Both indented statements belong to the loop, so both repeat. print("Done") is dedented, which ends the loop’s block. It runs once, after the condition becomes False.

Chapter 10 used boundary cases to check selection. Loop boundaries require the same care: predict what the loop just above would print if you changed count <= 3 to count < 3, then check yourself in the REPL. Getting a boundary like this wrong causes an off-by-one error, where a loop repeats once too often or once too few.

13.2.1 Avoiding Infinite Loops

If nothing in a loop changes the condition, the loop may never stop:

count = 1
while count <= 5:
    print(count)

An infinite loop keeps repeating without ending on its own. Here, count never changes, so count <= 5 remains True and the program repeatedly prints 1. Press Ctrl-C in the terminal to interrupt a program stuck in a loop.

An update can be present and still move in the wrong direction:

count = 1
while count <= 5:
    print(count)
    count -= 1

After the first iteration, count becomes 0, then -1, then -2. All these values are still less than or equal to 5, so the condition never becomes False. The starting value, condition, and update must work together for a counting loop to stop.

13.2.2 Validating Input with while and break

Chapter 9’s shipping flowchart keeps asking for a package weight until the weight is positive. We can now express that behaviour in Python by reading and checking a new weight inside a loop.

For this task, the decision to stop comes after reading the input. We use while True to keep the loop running while we read and check each weight. Its condition is always True, so it cannot become False and end the loop.

To end the loop after a successful check, we use the break statement. When Python reaches break, it leaves the loop immediately. Placing break inside if weight > 0: lets a positive weight end the repetition.

As before, assume the input can be converted to a number. The loop checks whether it is positive; handling text that cannot be converted comes later.

The input statement runs at the start of every iteration:

while True:
    weight = float(input("Enter the package weight in kilograms: "))
    if weight > 0:
        break
    print("Weight must be positive.")

if weight <= 2:
    shipping_rate = 8
else:
    shipping_rate = 14

print(f"Shipping rate: ${shipping_rate:.2f}")

Suppose the user enters 0, then -2, then 1.5. Trace the decision after each input:

After break, execution continues with if weight <= 2:. The program can now choose a shipping rate using the accepted weight.

The same pattern applies to other inputs:

1. Start a while True loop and read a value inside it.
2. If the value is valid, use break to leave the loop.
3. Otherwise, explain the problem and let the next iteration ask again.

13.3 The for Statement

Suppose you want to display every character in a string. A for loop visits the characters one at a time, so you can describe what to do with each one:

course = "COMP"
for letter in course:
    print(letter)

Read the header as “for each letter in course.” Here, letter is the loop variable. On each iteration, Python automatically assigns the next character to it and runs the indented block. When there are no characters left, the loop ends.

An empty string contains no characters, so a for loop over "" runs zero times. A one-character string produces exactly one iteration.

As with while, the header ends with a colon and the loop’s block is indented. Use a singular name such as letter for the loop variable because it refers to one character at a time.

A for loop can contain more than one statement:

word = "Code"
for letter in word:
    print(letter)
    print(letter.lower())
print("Done")

Both indented statements run for each character. print("Done") is outside the loop, so it runs once after the final character.

A condition inside the loop can choose how to handle each character:

course = "COMP 1510"

for character in course:
    if character == " ":
        print("space")
    else:
        print(character)

The loop still visits every character, including the space. The if statement chooses which print() call runs during each iteration.

13.4 A Simple Accumulator

The previous for examples display something during each iteration. You can also use a loop to build one result and display it after the loop finishes.

An accumulator is a variable initialized before a loop and updated inside it to build a running result. This example counts lowercase "a" characters in a word:

word = "banana"
count = 0

for letter in word:
    if letter == "a":
        count += 1

print(count)

In the earlier while loop, count controlled when repetition stopped. Here, it begins at 0 and increases for each matching letter; its final value is the result.

Each statement has a deliberate position. Initialization belongs before the loop; placing count = 0 inside the loop would erase the earlier work on every iteration. The update belongs inside the if because only a matching character should increase the count. The final print(count) belongs after the loop because the program should report the completed result once.

Trace the value carefully:

The loop checks every letter, while the if statement changes count only for a match.

The comparison matches lowercase "a" only. Convert the input to lowercase first to count uppercase and lowercase forms:

word = input("Word: ")
word = word.lower()
count = 0

for letter in word:
    if letter == "a":
        count += 1

print(f"The word contains the letter a {count} times.")

The counting loop is unchanged; the program now reads and lowercases the word first.

13.5 Tracing Loops by Hand

Chapters 9 and 10 showed how to trace a flowchart or a decision with a chosen input. The tables above use the same technique to follow loops. When you trace a loop yourself, record the small set of values that change. For a while loop, record its condition and changing value; if it uses break, record when that statement runs. For a for loop, record the current character and any accumulator.

A useful trace does not need to reproduce every line of the program. It only needs enough information to answer three questions:

1. What value controls or advances the loop?
2. What changes during this iteration?
3. What must eventually cause the loop to stop?

For a while loop, pay particular attention to the first pass and the condition check or break that ends it. For a for loop, follow the first and last items, and consider what happens with an empty string. These cases help reveal incorrect initial values, comparisons, and updates.

13.6 Choosing Between while and for

Use for when you need to work through the items in a sequence. To count the "a" characters in a word, you need to examine every character, so for is a natural choice.

Use while when you need to repeat an action based on a condition or until a decision inside the loop tells you to stop. To get a positive package weight, the program asks on each pass and uses break when the weight is valid. The values the user enters determine how many times the loop repeats.

13.7 Summary

A loop repeats an indented block. A while loop checks its condition before each pass. It stops when the condition becomes False or a break statement ends it. Input validation can use while True to ask again until the value is valid.

A for loop visits a string’s characters one at a time; its loop variable holds each character in turn. An accumulator starts before a loop and builds a running result inside it.

13.8 References and Further Reading

• Python Language Reference: The while statement
• Python Language Reference: The break statement
• Python Language Reference: The for statement
• Beej’s Guide to Python Programming, chapter 6: while loops, for loops, and choosing between them.

14 Functions

You can now write programs that make decisions and repeat steps. As those programs grow, keeping every step in one long sequence makes it harder to see how the pieces fit together. Functions let you give a name to a particular job, then use that name wherever the program needs the job done.

You already work this way when you call len(word) or random.randint(1, 6): you supply the information a function needs and use the result without writing its steps yourself. You will now define your own functions. You will begin with a function that displays a greeting, then write functions that receive values, calculate results, and work together.

As you read, follow the information through each call: what goes into the function, what happens inside it, and what comes back. That same pattern will help you understand both a short calculation and a program built from several functions.

14.1 Defining and Calling a Function

To display a welcome message at several points in a program, put that job in a function, a reusable block of code. Write a function definition using def, a descriptive name, parentheses, and a colon:

def display_welcome():
    print("Welcome!")

display_welcome()
display_welcome()

The indented statement is the function’s body. Defining the function makes it available, but does not run it. Each display_welcome() is a function call: Python runs the body, then continues after the call. Two calls display the message twice.

A call placed above the definition stops the program, because the name does not exist until the def runs:

NameError: name 'display_welcome' is not defined

Python simply has not reached the definition yet. Keep definitions above the calls that use them.

To personalize the greeting, the function needs to receive a name. A parameter is a name in the definition that receives a value when the function is called:

def display_greeting(name):
    print(f"Hello, {name}!")

display_greeting("Maya")
display_greeting("Sam")

Each call supplies an argument, a value passed to the function. The parameter name receives "Maya" for the first call and "Sam" for the second. The body stays the same while the supplied value changes.

To display a person’s name alongside a message, give the function two parameters. Arguments are matched to parameters by position:

def display_message(name, message):
    print(f"{name}: {message}")

student_name = "Maya"
display_message(student_name, "Ready to begin")

Here, name receives the value of student_name, and message receives "Ready to begin". The calling code’s variable and the function’s parameter do not need matching names.

These definitions require one argument per parameter. If one is missing, Python stops with a TypeError, and the message names the parameter that received nothing:

TypeError: display_message() missing 1 required positional argument: 'message'

Choose names that describe the job, as display_welcome, display_greeting, and display_message do here. A reader should understand what a call does without opening its definition.

14.2 Returning a Value

Displaying a greeting finishes that function’s job. Other functions produce values that you can store or use in further calculations, such as a duration converted from minutes to seconds.

The return statement sends a return value back to the caller, the code that made the call. The caller can store that value or use it as part of an expression:

def minutes_to_seconds(minutes):
    return minutes * 60

seconds = minutes_to_seconds(3)
print(seconds)
print(minutes_to_seconds(3) + 30)

Assigning the result of minutes_to_seconds(3) to seconds stores 180 for later use. In the final line, the same call is part of a larger calculation that produces 210. Change the argument to 5 in both calls and predict the results before running them.

A function can have more than one return. You can use the selection statements you already know to choose what to return. This function selects the longer of two words, choosing the first when their lengths are equal:

def longer_word(first, second):
    if len(first) >= len(second):
        return first
    return second

print(longer_word("sun", "planet"))
print(longer_word("tree", "moon"))

Executing return ends that call immediately. When the condition is true, Python returns first without reaching the final statement. Otherwise, it returns second. Putting the final return in an else branch is also valid; leaving out else here is a style choice.

14.3 Printing Is Not Returning

When a function displays the answer you expected, it is easy to assume that the caller received that answer too. But displaying a value and passing it back are separate actions: print() produces output for a person, while return supplies a value to the calling code. To see the difference, assign the result of a function that only prints its calculation:

def display_seconds(minutes):
    print(minutes * 60)

result = display_seconds(3)
print(f"Stored result: {result}")

Although 180 appears on screen, the assignment receives None, the special value used here to indicate no useful result. The final line therefore displays Stored result: None.

Python returns None whenever a call reaches the end without executing a return. A bare return, with no expression after it, also ends the call and returns None.

Printed output and returned values can look the same in the REPL. These two functions both make 180 appear:

>>> def minutes_to_seconds(minutes):
...     return minutes * 60
...
>>> def display_seconds(minutes):
...     print(minutes * 60)
...
>>> minutes_to_seconds(3)
180
>>> display_seconds(3)
180

The REPL echoes the first call’s returned 180. The second call prints 180 and returns None, which the REPL does not echo. Storing and displaying the result, as the first program in this section does, reveals what the caller received.

14.3.1 Returning on Every Path

Checking that a function contains a return is not enough. If selection allows a call to reach the end without executing that statement, the caller still receives None. Consider this unfinished version of longer_word(), which is meant to follow the same rule as before:

def longer_word(first, second):
    if len(first) >= len(second):
        return first

print(longer_word("planet", "sun"))

14.4 Documenting a Function

Once a function has a clear job, you should be able to explain how to use it without walking through its code. Someone calling minutes_to_seconds() needs to know what values it accepts and what its result means. A docstring records that information inside the function, where both readers and Python’s help tools can find it.

Place the docstring as the first statement in the body, enclosed in triple quotation marks. Write one short sentence for the job. Add :param and :return: entries only when the inputs or the result need explanation, such as a unit or a limit on the values:

def minutes_to_seconds(minutes):
    """
    Convert a duration in minutes to seconds.

    :param minutes: a non-negative number of minutes
    :return: the equivalent duration in seconds
    """
    return minutes * 60

print(minutes_to_seconds(3))

From the docstring, you can tell which units the function accepts and returns. Its first line alone carries most of that explanation; the entries help when a reader could misunderstand a unit or an input limit. The docstring does not enforce the expectation: negative arguments still produce negative results. Input checks require executable code.

14.4.1 Reading Docstrings

The built-in help() function displays a function’s name, parameters, and docstring. A file can carry a docstring too: a module docstring is a triple-quoted string placed as the first statement in the file to describe its purpose. Calling help() on an imported module displays that description along with information about its functions.

14.5 Functions That Answer Questions

So far, your functions have returned numbers and strings. A function can also answer a question, such as whether some text is long enough. Giving that check a name lets you use it wherever the program needs to make the same decision.

A predicate function answers a yes-or-no question by returning True or False. longer_word() chose between two values with an if. Since a comparison already produces a Boolean value, you can return it directly. Names beginning with is_ or has_ make the call itself read like the question:

def has_minimum_length(text, minimum):
    return len(text) >= minimum

print(has_minimum_length("hello", 5))
if has_minimum_length("hello", 5):
    print("The text is long enough.")

has_minimum_length("hello", 5) returns True, which you can display with print() or use directly as an if condition. Adding == True compares True with True, or False with False, and changes nothing.

14.6 Using Loops Inside Functions

In Chapter 13, you used an accumulator to count matching characters. You can put that same pattern inside a function so the caller supplies the text and receives the completed count. Here, the function counts spaces:

def count_spaces(text):
    count = 0
    for character in text:
        if character == " ":
            count += 1
    return count

print(count_spaces("one two three"))
print(count_spaces("word"))
print(count_spaces(""))

Each call starts with count = 0, so it does not carry over the previous call’s count. The return sits after the loop because the function must examine every character before the total is ready. An empty string still returns 0: the loop runs zero times, but execution reaches the return.

This is also where return differs from break: inside a function, break ends only the loop it sits in, while return ends the whole call, even from inside a loop.

14.7 Decomposing a Program

In Chapter 9, you used decomposition to plan a solution as a series of smaller steps. Functions now let you organize the code around those jobs. Look for steps that serve one clear purpose, then consider what information that job needs and what result it should produce. These choices give each function a responsibility and define how it works with its callers.

Preparing a duration message involves two jobs: converting minutes to seconds and building the text. Keeping the conversion separate lets other code use its numeric result:

def minutes_to_seconds(minutes):
    return minutes * 60

def duration_message(minutes):
    seconds = minutes_to_seconds(minutes)
    return f"Duration: {seconds} seconds"

print(duration_message(3))

To build the message, duration_message() calls minutes_to_seconds(). The conversion returns 180, which the message function uses to build and return "Duration: 180 seconds". The outer print() displays that string. Arguments carry information into each job, and return values carry the results back to its caller.

Here, minutes_to_seconds() acts as a helper function: it handles a smaller job that duration_message() needs.

Separating these responsibilities gives each function a reason to exist. The conversion can serve another calculation without producing a message, and the message wording can change without changing the conversion. Because both functions return their results, the caller decides whether to display, store, or use them in further work.

14.8 Running and Importing a File

You have used functions from math and random by importing those modules. Your own Python file can also act as a module, allowing another program to use its functions. For example, the duration conversion can be useful even when a program does not need a duration message.

During the first import in a running program, Python executes the file’s statements from top to bottom. Each def makes a function available without running its body. In the previous example, the final print(duration_message(3)) call would also run, displaying a message even if the importing program only wanted the conversion.

14.8.1 Why the Main Guard Matters

A main function, conventionally named main(), gathers the work needed to run the program into one place. It gives you one call to control. A main guard makes that call only when the file is run directly, so importing the file does not start that work.

In durations.py below, main() coordinates the duration program, and the final if statement controls its call:

def minutes_to_seconds(minutes):
    return minutes * 60

def duration_message(minutes):
    seconds = minutes_to_seconds(minutes)
    return f"Duration: {seconds} seconds"

def main():
    minutes = 3
    message = duration_message(minutes)
    print(message)

if __name__ == "__main__":
    main()

The guard tests __name__, which Python sets according to how the file is used. When you run durations.py directly, its value is "__main__". The condition is True, so main() runs and displays Duration: 180 seconds.

When another program imports durations, the module’s __name__ is "durations". The condition is False, so Python skips the call to main(). Its functions are still available to the importing program. A file named use_duration.py in the same folder can use the conversion like this:

import durations

print(durations.minutes_to_seconds(2))

This program displays:

120

The call uses the same dot notation as math.sqrt(25): durations names the module, and minutes_to_seconds names its function. The returned value goes to this caller, which displays it with print().

The guard controls only the call indented beneath it. A print() outside the functions and the guard would still run during import. Keeping the program’s starting work inside main() lets the importing program choose which functions to call and how to use their results.

14.9 Reassigning a Parameter

Returning a result gives the caller a value to use. It does not automatically update the variable supplied as an argument. To update that variable, the caller must assign the returned value to it.

Here, score receives the value of points when increment_score() is called. The function adds 1 to score and returns the new value. Compare what happens when the caller ignores that result and when it stores it:

def increment_score(score):
    score += 1
    return score

points = 42
increment_score(points)
print(points)
points = increment_score(points)
print(points)

After the first call, points is still 42: the function returned 43, but the caller did not store it. In the second call, points = increment_score(points) assigns that returned 43 to points.

The parameter score and the caller’s variable points are separate names. Reassigning score changes its value inside the function, leaving points unchanged. Chapter 15 explores where names are available and how this separation works.

14.10 Summary

A function names a reusable job. Parameters receive arguments, and return ends the call and sends a result to the caller. Printing only displays output; without an explicit return value, a call produces None. Check every expected path, and give the function a docstring that says what it does.

Decomposition connects smaller jobs into a program. By convention, a main function coordinates the program’s work. A main guard lets the file run directly while keeping its functions available for import. Each call has its own local names, so reassigning a parameter does not change the caller’s variable. The caller must store the returned result when it needs to keep it.

14.11 References and Further Reading

• Python Tutorial: Defining Functions
• Python Language Reference: Function Definitions
• Python Library Reference: __main__
• PEP 257: Docstring Conventions
• Edsger W. Dijkstra: On the Nature of Computing Science (EWD 896)
• Python Data Model: User-Defined Functions

15 Variable Scope and Constants

Dividing a program into functions separates the work, but it also separates the names used to do it. A variable created inside one function is not automatically available to the rest of the program. This is why Chapter 14’s functions used arguments and return values to exchange information.

Knowing where a name is available helps you decide where to keep a value. A calculation may need a value only during a function call, while a fixed discount rate may be useful throughout a module. This chapter explains those boundaries so you can follow how functions use and update values.

15.1 Local Names and Function Calls

Suppose a function calculates the total price for a purchase. It needs names for the price, the quantity, and the result of multiplying them. The caller needs the final value, but it does not need access to every name used along the way.

The scope of a name determines where in a program Python can use it. A parameter or a name assigned inside a function is a local variable. The name stays within the function’s local scope. In the example below, price, quantity, and subtotal all belong to the call to calculate_total():

def calculate_total(price, quantity):
    subtotal = price * quantity
    return subtotal

total = calculate_total(6, 4)
print(total)

The caller receives 24 and assigns it to total. The value has come back from the function, but the name subtotal remains local to the call. Adding this line below print(total) stops the program with a NameError:

print(subtotal)

Python cannot find subtotal outside calculate_total(), so the report ends with NameError: name 'subtotal' is not defined.

Each call has its own values for these local names. Another function can use names such as price or subtotal for its own work without changing the values in this call. That separation lets you understand a function’s calculation on its own.

A function you call cannot see the local names of the function that called it. In the following program, main() passes its total as an argument so that display_total() can use the value:

def display_total(total):
    print(f"Total: ${total}")

def main():
    total = 24
    display_total(total)

main()

There are two names spelled total: one in main() and one in display_total(). The argument passes the value between them. Their matching spelling is convenient, but it is not what connects them.

15.1.1 Scope and Indented Blocks

You have also created names inside if statements and loops. Those blocks are indented, just like a function body, but they do not create separate scopes. A name assigned inside an if, while, or for block within a function still belongs to that function call.

This lets a decision or loop prepare a value for the statements that follow it. Here, the if statement chooses a label, and the function returns that label after the branches rejoin:

def length_label(text):
    if len(text) >= 8:
        label = "Long"
    else:
        label = "Short"
    return label

print(length_label("notebook"))
print(length_label("pen"))

Both branches assign the same local name, label. The return can use label even though it sits outside the if block.

Being in scope does not guarantee that a name has a value. An UnboundLocalError means Python tried to use a local name before that call had assigned it a value. Scope tells you where the name belongs; the path through the code determines whether an assignment has happened.

15.2 Global Names and Constants

Local names keep each function’s work separate, but some values are useful to several functions. A fixed discount rate, for example, can sit at the top level of the module so those functions have one named setting to read.

A name assigned at the top level, outside any function, is a global variable. The following function receives a price through its parameter and reads the discount rate from a global name:

DISCOUNT_RATE = 0.10

def discounted_price(price):
    discount = price * DISCOUNT_RATE
    return price - discount

print(discounted_price(20))

DISCOUNT_RATE has global scope in this module. The parameter price and the calculated discount are local to each call of discounted_price(). A name assigned inside a top-level if statement or loop is global too, because those blocks do not create separate scopes.

A constant is a name the program intends not to reassign. The ALL_CAPS spelling communicates that intention to readers; Python does not enforce it. Constants usually appear after imports and before function definitions, so you can find the program’s fixed settings together.

When discounted_price() runs, Python looks up each name in this order:

This lets discounted_price() read DISCOUNT_RATE without receiving it as an argument. It also raises a question: what happens if the function has a local name with the same spelling?

15.3 When One Name Hides Another

Using the same name in different scopes does not make it one shared variable. If a function assigns to a name that also exists globally, Python normally treats that name as local throughout the function. Inside that function, the local name hides the global one. This is called shadowing.

Follow the output before, during, and after display_x() to see whether its assignment changes the global x:

x = 5

def display_x():
    x = 9
    print(f"Inside display_x: {x}")

print(f"Before display_x: {x}")
display_x()
print(f"After display_x: {x}")

Before display_x: 5
Inside display_x: 9
After display_x: 5

The assignment changes only the local x. The repeated spelling can make this look like an update to one variable, but the function call and the module each have their own x.

Names can hide built-ins too. If you assign a value to print or str, later code in that scope will find your value instead of the built-in function. Choose names that describe your data and leave familiar function names available.

15.4 Keeping Changing Values Local

Shadowing can be especially confusing when you intend to update a value. In display_x(), the assignment supplies a new value directly. An update such as +=, however, needs to read the old value first. Consider this attempt to increase a global task count:

task_count = 2

def add_task():
    task_count += 1
    return task_count

print(add_task())

Running this program stops with an UnboundLocalError:

UnboundLocalError: cannot access local variable 'task_count' where it is not associated with a value

The += update is an assignment, so Python treats task_count as local throughout add_task(). Adding 1 requires reading that local value first, but the call has not assigned it a starting value. The global value of 2 does not supply the missing local value.

You can avoid this confusion by making the exchange explicit. Let the caller keep the count, pass it to the function, and assign the returned result:

def add_task(task_count):
    return task_count + 1

def main():
    number_of_tasks = 2
    number_of_tasks = add_task(number_of_tasks)
    print(number_of_tasks)

main()

Now main() holds the count and decides when to update it. add_task() receives a starting value and returns the new one. Neither function needs access to the other’s local names, and neither name needs to be global.

Keeping a name within the part of the program that needs it is called minimizing scope. Here, the count changes in main(), so you know where to look for its updates. A global constant is useful for a fixed setting; a changing count is easier to follow when the code responsible for updating it keeps it locally.

15.5 Summary

Scope determines where Python can use a name. Parameters and names assigned inside a function are local, and each call has its own values for those names. Names assigned at the top level are global to the module. Arguments and return values let functions exchange information while keeping their local names separate.

Selection and loop blocks do not create separate scopes. A name assigned in one of those blocks remains part of the surrounding function or module, but the assignment must happen before you use it. Trying to read an unassigned local name raises UnboundLocalError, even when a global name has the same spelling.

Use ALL_CAPS for constants whose values the program intends not to change. Avoid accidental shadowing of global names or built-ins, and keep changing values local where possible. Passing values in and returning results makes it clear which part of the program is responsible for an update.

15.6 References and Further Reading