Skip to content

Glossary

This glossary lists every technical term introduced on this site, in alphabetical order. Each term links to the page where it is first explained, and each page lists its new terms in a Terminology callout at the top.

A · B · C · D · E · F · I · L · M · N · O · P · Q · R · S · T · U · V · W

A

B

C

  • call – to run a function by using its name, after which the program comes back to where it was. (Lesson 7: Functions)
  • case sensitive – treating capital and lowercase letters as different, so age and Age are two different names. (Lesson 5: Variables)
  • code block – a group of lines indented by the same amount that belong together and run together. (Lesson 3: Iteration)
  • comment – a line starting with # that Python ignores, written to help humans understand the code. (Lesson 1: Thonny Introduction)
  • commenting out – adding # to the start of lines of code so Python ignores them, without deleting them. (Lesson 6: Coordinates)
  • comparison operator – a symbol such as ==, !=, > or < that compares two values and gives back True or False. (Lesson 10: While Loops)
  • condition – a check that gives back either True or False. (Lesson 9: Branching)
  • condition-controlled loop – a loop that runs until a condition changes, like a while loop. (Lesson 10: While Loops)
  • constant – a variable whose value never changes while the program runs, written in capital letters in Python. (Lesson 5: Variables)
  • control structure – code that changes the flow of a program, instead of just running from top to bottom. (Lesson 3: Iteration)
  • coordinates – a pair of numbers written as (x, y) that describe a position, with (0, 0) at the centre of the turtle window. (Lesson 6: Coordinates)
  • count-controlled loop – a loop that runs a set number of times, like a for loop. (Lesson 10: While Loops)

D

  • data type – the kind of value something is, such as a number or text, which tells Python what it can do with that value. (Lesson 8: User Input)
  • debugger – a tool that runs our code one step at a time so we can see what it is doing and find mistakes. (Lesson 3: Iteration)
  • debugging – the process of finding and fixing bugs in a program. (Debugging with Thonny)
  • decision block – a diamond in a flowchart that asks a question and splits the path based on the answer. (Flowcharts)
  • define – to create a function with def, giving it a name and a code block that Python remembers but doesn't run yet. (Lesson 7: Functions)
  • definite iteration – a loop where we know how many times it will run, usually written as a for loop. (Lesson 10: While Loops)
  • DRY – short for Don't Repeat Yourself, the principle that we shouldn't write the same code over and over again. (Lesson 3: Iteration)

E

  • element – one item in a list. (Lesson 3: Iteration)
  • elif – short for else if, a part of an if statement that checks another condition when the conditions before it were False. (Lesson 9: Branching)
  • else – the part of an if statement that runs when none of the conditions are True. (Lesson 9: Branching)

F

  • floating point number – a number with a decimal point, like 1.0 or 3.5, called float in Python. (Lesson 8: User Input)
  • flow arrow – an arrow in a flowchart that shows the path the program takes, in one direction only. (Flowcharts)
  • flowchart – a diagram that uses shapes and arrows to show each step in a program and how it moves from one step to the next. (Lesson 3: Iteration)
  • for loop – a loop that repeats its code once for each item in a list or sequence. (Lesson 3: Iteration)
  • function – a named block of code that we can run again and again whenever we need it. (Lesson 7: Functions)
  • function indicator – a red dashed box drawn around the steps of a function in a flowchart. (Flowcharts)

I

  • if statement – code that makes a decision by running its indented block only when its condition is True. (Lesson 9: Branching)
  • immutable – describes something that can't be changed once it has been created. (Lesson 6: Coordinates)
  • import – the command that tells Python to load a module so our program can use its commands. (Lesson 2: Introducing Turtle)
  • indefinite iteration – a loop where we don't know how many times it will run, usually written as a while loop. (Lesson 10: While Loops)
  • indentation – spaces at the start of a line (four in Python) that show which code belongs to a loop or other block. (Lesson 3: Iteration)
  • infinite loop – a loop whose condition is always True, so it never stops on its own. (Lesson 10: While Loops)
  • input – information that goes into a program, such as the user typing on a keyboard or clicking a mouse. (Lesson 3: Iteration)
  • input/output block – a parallelogram in a flowchart, also called an IO block, that shows information moving between the real world and the program. (Flowcharts)
  • integer – a whole number written without a decimal point, like 1 or 25, called int in Python. (Lesson 8: User Input)
  • interactive – describes a program that lets the user give it information while it runs, instead of changing the code. (Lesson 8: User Input)
  • iteration – repeating the same code again and again, often with a small change each time, also called looping. (Lesson 3: Iteration)

L

  • list – a collection of items stored in a set order inside [ and ], with commas between them. (Lesson 3: Iteration)
  • local variable – a variable that only exists inside the function that created it. (Debugging with Thonny)
  • logic error – a mistake where the code runs without crashing but doesn't do what we expected. (Debugging with Thonny)
  • loop indicator – a grey dashed box drawn around the steps in a flowchart that repeat in a loop. (Flowcharts)
  • loop variable – the variable in a for loop that stores the item or number the loop is currently using. (Lesson 5: Variables)

M

  • magic number – a number written straight into our code with no name to explain what it means. (Lesson 5: Variables)
  • maintainability – how easy our code is for other people, or our future selves, to read, understand and change. (Lesson 6: Coordinates)
  • method – a built-in tool that belongs to a value, such as a string, and helps us work with it. (Lesson 9: Branching)
  • module – an extra group of commands that we can add to our program. (Lesson 2: Introducing Turtle)
  • mouse input – information a program gets from the mouse, such as where the user clicked. (Lesson 12: Mouse Input)

N

  • naming convention – an agreed habit for naming things that makes code easier to read, but doesn't cause an error if we break it. (Lesson 5: Variables)
  • not operator – a Boolean operator that flips a value, so not True is False and not False is True. (Lesson 11: Boolean Logic)

O

  • or operator – a Boolean operator that gives back True if at least one value is True. (Lesson 11: Boolean Logic)
  • output – information that a program sends out, such as text shown on the screen. (Lesson 3: Iteration)

P

  • parameter – a variable name in a function definition that receives a value sent into the function. (Lesson 7: Functions)
  • parentheses – the round brackets ( and ), which must always come in matching pairs. (Lesson 1: Thonny Introduction)
  • pixel – one of the tiny dots that make up a screen, also used to measure how far the turtle moves. (Lesson 2: Introducing Turtle)
  • process block – a rectangle in a flowchart that shows a step where the code does something, like setting a variable or doing a calculation. (Flowcharts)
  • Python – the programming language we use in this course to write instructions for the computer. (Lesson 1: Thonny Introduction)

Q

  • quadrant – one of the four sections a window is split into by lines through its centre. (Lesson 12: Mouse Input)

R

  • refactoring – changing our code to make it better without changing what it does. (Lesson 9: Branching)
  • return – to send a value back from a function to the code that called it, which also ends the function. (Lesson 9: Branching)
  • run-time error – an error that happens while the program is running, which makes it crash. (Debugging with Thonny)

S

  • scalable – describes code that still works well as the program gets bigger. (Lesson 3: Iteration)
  • screen – the window that the turtle draws in. (Lesson 2: Introducing Turtle)
  • script – a Python program saved as a text file. (Lesson 1: Thonny Introduction)
  • sequence – code running one line after the other, from the top of the program to the bottom. (Lesson 3: Iteration)
  • Shell – the panel in Thonny that shows what our program prints and any error messages. (Lesson 1: Thonny Introduction)
  • single point of truth – keeping each value in one place, so changing it there changes it everywhere it is used. (Lesson 5: Variables)
  • snake case – writing names in lowercase letters with _ instead of spaces, like side_length. (Lesson 5: Variables)
  • stack – the list Thonny shows of which parts of the program are currently running, such as the main program and any function it has called. (Debugging with Thonny)
  • step into – a debugger control that runs the next small piece of code and shows every step Python takes. (Debugging with Thonny)
  • step out – a debugger control that finishes the rest of the current piece of code and moves back out a level. (Debugging with Thonny)
  • step over – a debugger control that runs the highlighted code in one go without showing all the small steps. (Debugging with Thonny)
  • string – a group of characters, like letters, numbers or symbols, inside quotation marks. (Lesson 1: Thonny Introduction)
  • syntax error – an error that happens when our code doesn't follow Python's rules. (Lesson 1: Thonny Introduction)
  • syntax highlighting – colouring different parts of our code based on what they do, so it's easier to read and write correctly. (Lesson 1: Thonny Introduction)

T

  • terminal block – a rounded rectangle in a flowchart that shows where a program or function starts and ends. (Flowcharts)
  • Thonny – a program for writing, running and debugging Python code that is designed for beginners. (Lesson 1: Thonny Introduction)
  • tuple – a group of values written in round brackets that works like a list but can't be changed. (Lesson 6: Coordinates)
  • turtle – a small arrow on the screen that we can control and move around to draw. (Lesson 2: Introducing Turtle)

U

V

  • variable – a named place, like a labelled box, that stores a value our program can use and change. (Lesson 5: Variables)

W