Chapter 5

Computational Thinking and Getting Started with Python

Deep-Dive Study Guide — Pages 95–118 | Computer Science Exam Prep

What this covers:

• 5.1 Introduction
• 5.2 Computational Thinking
• 5.3 Python – Pluses (Advantages)
• 5.4 Python – Some Minuses ("So Human Like")
• 5.5 Working in Python (CPython, Anaconda, Linux Command Line)
• 5.6 Understanding First Program/Script

Every concept below includes a plain-English explanation, a real-world analogy, and a worked example —
exactly the kind of detail examiners expect in a 3–5 mark answer.
 5.1 Introduction
This chapter has one big goal: teach you to think like a problem-solver before you touch code, and then
show you how to actually get Python running on a machine.

Programming is NOT "knowing syntax." Syntax is just grammar. The real skill examiners are testing in this
chapter is: given a messy real-world problem, can you (a) think about it in a structured way, and (b) translate
that structure into a language a computer understands (Python)?

So the chapter is split into two halves:

• Theory half (5.2–5.4): How to think computationally, and why Python specifically is a good/imperfect
tool for that thinking.
• Practical half (5.5–5.6): How to install Python, set up an environment (CPython vs Anaconda), run it
from the command line, and write your very first script.
■ Exam Tip: Introduction sections rarely carry their own marks, but examiners often lift 1-mark "define
programming" or "what is Python used for" questions straight from this intro. Skim it once, don't over-invest time
here.

5.2 Computational Thinking

Definition (memorize this): Computational thinking is the mental process of formulating a problem and
expressing its solution in a way that a computer — human or machine — can effectively carry out.

In simple words: it's the skill of breaking down a problem and describing its solution so clearly and logically
that even a machine (which has zero common sense) could follow it.

It rests on four pillars. This is the single most important list in the chapter — expect a direct question like
"Explain the four pillars of computational thinking with examples" (often 4–5 marks, one mark per pillar +
example).

1. Decomposition
Breaking a large, complex problem into smaller, more manageable sub-problems that are easier to
understand, solve, and test individually.

Example:
Building a school management system feels impossible as one giant task. Decomposed, it becomes: (1)
Student registration module, (2) Attendance module, (3) Fee management module, (4) Report card generator.
Each of these is small enough to code and test on its own.

2. Pattern Recognition
Looking at problems (or sub-problems) and noticing similarities, trends, or repeated structures — so a solution
built for one part can be reused for another.

Example:
Suppose in the school system above, both "Fee module" and "Attendance module" need to search for a
student by roll number. Recognizing this pattern means you write ONE reusable "find_student(roll_no)"
function instead of duplicating that logic in both modules.
3. Abstraction
Filtering out details that are irrelevant to solving the problem and focusing only on the information that actually
matters.

Example:
When you design the "Student" part of the system, you don't care about a student's favorite color or shoe size.
You abstract the student down to what matters for the system: roll number, name, class, marks, attendance.
Everything else is ignored.

4. Algorithm Design
Creating a precise, ordered, step-by-step set of instructions/rules that solves the problem or sub-problem,
which can later be turned into code.

Example:
For the "calculate final grade" sub-problem: Step 1: Take marks in all subjects. Step 2: Sum them. Step 3:
Divide by number of subjects to get average. Step 4: Compare average to grade boundaries. Step 5: Output
the grade letter.

Putting it together — one running example:

Problem: "Build an app that recommends a movie to a user."

• Decomposition: Split into — collect user preferences, fetch movie database, rank movies, display top
5.
• Pattern Recognition: Notice that "ranking" logic is similar whether ranking movies, songs, or books —
so build one generic ranking function.
• Abstraction: Ignore irrelevant movie data (e.g., studio's tax filings); keep only genre, rating, runtime,
cast — what actually affects recommendation.
• Algorithm Design: Write the exact steps: get user's favorite genres → filter database by genre → sort
by rating → return top 5.
■ Exam Tip: If a question gives you a scenario and asks "identify the computational thinking technique used,"
match the KEYWORD: 'broke it into parts' = Decomposition, 'noticed it's similar to' = Pattern Recognition, 'ignored
irrelevant details' = Abstraction, 'wrote step-by-step instructions' = Algorithm Design.
 5.3 Python – Pluses (Advantages)
These are reasons Python is a popular first/general-purpose language. A "List the advantages of Python"
question is very common (5 marks = 5 points, one line each).

Simple & Readable Syntax

Python reads almost like plain English, with no mandatory semicolons or curly braces — indentation itself
defines code blocks.
print("Hello World") # Compare to Java: [Link]("Hello World");

Free and Open Source

Anyone can download, use, and even modify Python's source code at no cost, which is a major reason for its
widespread adoption in schools and industry alike.

Interpreted Language
Python code is executed line-by-line by an interpreter rather than being compiled all at once, which makes
debugging easier — you find out exactly which line failed.

Huge Standard Library + Third-Party Packages

Python ships with built-in modules for math, file handling, dates, etc., and has enormous external libraries like
NumPy (numeric computing), Pandas (data analysis), and Django (web apps).

Portable / Platform-Independent
The same Python script can run on Windows, Linux, or macOS with no changes, as long as Python is
installed.

Supports Multiple Programming Paradigms

Python lets you write code in a procedural style, object-oriented style, or functional style — whichever fits the
problem best.

Dynamically Typed
You don't need to declare a variable's data type in advance; Python figures it out automatically at runtime.

Dynamic typing example:

x = 10 # x is automatically treated as an integer
x = "hello" # now x is automatically treated as a string
# No error — Python re-decides the type on the fly
 5.4 Python – Some Minuses ("So Human Like")
The title "So Human Like" is the book's way of saying: Python's weaknesses resemble human weaknesses —
it's flexible and forgiving while you're working, but that same looseness means mistakes often surface late,
and it isn't the fastest or most disciplined performer.

Slower Execution Speed

Because Python is interpreted (translated line-by-line while running) rather than compiled ahead of time into
machine code, it generally runs slower than compiled languages like C or C++.
A loop running 10 million calculations in C might finish in under a second; the sam
e loop in pure Python can take noticeably longer.

High Memory Consumption

Python's flexibility (dynamic typing, automatic memory management) comes at the cost of using more RAM
than lower-level languages for equivalent tasks.

Runtime Errors (Late Error Detection)

Since Python doesn't check variable types before running the program (dynamic typing), many errors are only
caught while the program is actually executing — not beforehand, like a compiled/statically-typed language
would catch them. This is the 'human-like' trait: like a person who only realizes a mistake after acting on it.
def add(a, b):
return a + b

add(5, "hello") # No error until this exact line runs, then: TypeError

Not Ideal for Mobile App Development

Python is rarely used for building mobile apps compared to languages like Kotlin (Android) or Swift (iOS), due
to speed and mobile-specific tooling limitations.

Global Interpreter Lock (GIL)

A internal lock in the standard Python interpreter (CPython) that allows only one thread to execute Python
bytecode at a time, limiting true parallelism in multi-threaded programs.
■ Exam Tip: If asked to 'justify why Python minuses are called So Human Like,' the model answer is: because, like
humans, Python is flexible and easygoing while working, but that same flexibility means errors/mistakes are often
discovered only after the fact (at runtime), rather than being caught in advance.
 5.5 Working in Python
This section is about the ways you can actually set up and run Python. Expect a comparison-style question:
"Differentiate between CPython and Anaconda distribution."

5.5.1 Working in Default CPython Distribution

CPython is the original, standard, official implementation of Python, written in C, downloaded directly from
[Link]. It's the "default" Python most people mean when they just say "Python."

• Lightweight — installs quickly, minimal extra tools bundled in.

• Comes with IDLE, Python's simple built-in code editor.
• Additional libraries (NumPy, Pandas, etc.) must be installed manually using pip, Python's package
manager.
Installing a package in plain CPython:
pip install numpy

Running a script from CPython's IDLE or terminal:

python [Link]

5.5.2 Working in Anaconda Distribution

Anaconda is a "batteries-included" distribution of Python (and R) aimed at data science and scientific
computing. Instead of installing Python and then manually adding libraries one by one, Anaconda comes
pre-packaged with hundreds of popular libraries (NumPy, Pandas, Matplotlib, scikit-learn, etc.) plus extra tools
out of the box.

• Includes Jupyter Notebook — a browser-based interface for writing and running code in interactive
"cells," great for data analysis and visualization.
• Includes Spyder — a full-featured IDE similar to MATLAB's layout, popular for scientific work.
• Uses conda (its own package/environment manager) alongside pip, making it easy to create isolated
"environments" for different projects.
• Much larger install size than plain CPython, because of all the bundled libraries.
Creating and using a conda environment:
conda create -n myenv python=3.11
conda activate myenv
conda install pandas

Aspect CPython (default) Anaconda

Install size Small/lightweight Large (many libraries bundled)

Best for General-purpose programming Data science / scientific computing

Package manager pip only conda + pip

Bundled tools IDLE only Jupyter Notebook, Spyder, IDLE

Library setup Manual, one at a time Pre-installed by default

5.5.3 Writing and Compiling Python Program with Command Line in Linux
Even without an IDE, you can write and run Python entirely from a Linux terminal. Note: Python is interpreted,
not truly 'compiled' — the book's phrase "compiling" here loosely means "running/executing."

Typical workflow:
# 1. Open a text editor in the terminal to write the script
nano [Link]

# 2. Type the code inside the editor, then save and exit
print("Hello, World!")

# 3. Run the script from the terminal

python3 [Link]

# Output:
# Hello, World!

• nano / vi / gedit — common Linux text editors used to write the .py file.
• python3 [Link] — the command used to execute the script (python3 specifically, since many
Linux systems keep python2 and python3 separate).
• You can also check the installed version with: python3 --version
■ Exam Tip: Exam favorite: 'Which command is used to run a Python script named [Link] from the Linux terminal?'
→ Answer: python3 [Link]
 5.6 Understanding First Program/Script
The traditional "first program" in almost every language is printing a greeting to the screen. In Python:
print("Hello, World!")

Breaking this one line down completely, because examiners love asking you to 'explain the following line of
code':

• print() — a built-in Python function whose job is to display output on the screen.
• "Hello, World!" — a string literal (text data), passed as an argument to print(). Strings must be inside
quotes (single ' or double ").
• No semicolon needed — unlike C/Java, Python doesn't require a line-ending semicolon; a newline
itself ends the statement.
• No main() function required — Python scripts execute top to bottom directly; there's no mandatory
entry-point function like C's main().

A slightly bigger first script — taking input and using a variable:

name = input("Enter your name: ") # takes text typed by the user, stores it in th
e variable "name"
print("Hello,", name, "! Welcome to Python.") # combines fixed text and the variab
le value

What happens step by step:

• 1. input() pauses the program, shows the prompt "Enter your name: ", and waits for the user to type
something and press Enter.
• 2. Whatever the user types is returned as a string and stored in the variable name.
• 3. print() is called with three separate items — Python automatically inserts a space between each one
when printing.
• 4. The program then reaches the end of the file and terminates naturally — no explicit "return" or "exit"
needed.

Key beginner vocabulary to nail down:

Term Meaning

Script A file containing Python code, typically saved with a .py extension

Interpreter The program that reads your .py file and executes it line by line

Variable A named location in memory that stores a value (e.g., name)

Function A reusable named block of code that performs a task (e.g., print())

Comment Text starting with # that Python ignores — used to explain code to humans

■ Exam Tip: If given unfamiliar code and asked to 'trace the output' or 'explain each line,' always go top to bottom,
naming: what function is called, what it does, what gets stored/printed, in that order — that's exactly the structure
examiners award marks for.
 Quick Revision Sheet (Night-Before Recap)
Computational Thinking — 4 pillars:
• Decomposition — break problem into parts
• Pattern Recognition — spot reusable similarities
• Abstraction — ignore irrelevant detail
• Algorithm Design — write step-by-step solution

Python Pluses:
• Simple syntax
• Free/open-source
• Interpreted (easy debugging)
• Huge libraries
• Portable
• Multi-paradigm
• Dynamically typed

Python Minuses:
• Slower than compiled languages
• High memory use
• Runtime (late) errors due to dynamic typing
• Weak for mobile dev
• GIL limits multithreading

CPython vs Anaconda:
• CPython = lightweight, default, manual library install via pip
• Anaconda = data-science bundle, comes with Jupyter/Spyder, uses conda

Linux command line:

• Write script with nano/vi → save as .py → run with: python3 [Link]

First program:
• print("Hello, World!") — no semicolon, no main(), runs top-to-bottom
• input() reads user text as a string; store it in a variable to reuse it