Major Practical 3 Notes | B.Sc. (Information Technology) Semester 3 | Mumbai University | munotes

Three things in that table are worth saying out loud.

The two programming questions are not equal. Q1 carries 13 and Q2 carries 12. It is a single mark, but it tells you which module to start with if you are short of time: Module 1, the Python half, is worth marginally more, and it is also the half where a program either runs or does not, with less to argue about.

Q3 is not a formality. Five marks out of thirty is a sixth of the external paper, and it is awarded for your journal and for what you say at the table. That is more than the difference between Q1 and Q2 five times over. [The Viva: the Questions Asked at the Table] is a whole chapter on it, because no other chapter in the book owns it.

The journal is counted twice. It earns part of the 20 internal marks through item 13, and it is examined again inside Q3 of the external slip. One document, two sets of marks.

The rule that stops you at the door

MU's item 14 prints this in the same breath as the format:

Certified copy of Journal is compulsory to appear for the practical examination.

Certified means signed. A journal that is complete but not signed by your practical teacher is not a certified journal, and the requirement is to appear, not merely to score. This is the one line in the whole scheme that can cost a student an entire paper, and it is settled weeks before the examination, in the laboratory, by getting each entry signed as it is completed. [Keeping the Journal, and What Goes on the Page] sets out the form of an entry and what the signature is given for.

What the two modules are

MU sets ten exercises in each module, and they are two different subjects. This paper is the practical half of two theory papers you are sitting in the same semester.

MU's own description of this paper is "a comprehensive exploration of advanced Python programming concepts", which is written about Module 1, and her Course Objectives then run on into arrays, linked lists, stacks, queues, trees and graphs, which is Module 2. One paper, two halves, one slip.

The language question, answered

Module 1 is Python and there is nothing to decide: every row MU prints names a Python feature, from NumPy indexing to the calendar module.

Module 2 does not name a language, and MU leaves the choice to you in writing. The Data Structures theory paper that this module pairs with prints, as its third Course Outcome:

Translate algorithmic solutions into correctly functioning code using their chosen

programming language.

This book writes Module 2 in Python, because it is the language of the other half of the same slip and of the theory paper you are sitting alongside it. But three of MU's five text books for this paper are C books, and this degree taught you Programming with C in Semester 1, so some colleges run the Module 2 laboratory in C. If yours does, [If Your College Runs Module 2 in C] gives all ten exercises in C, compiled and run, so nothing in this book is out of reach.

Write your journal in the language your own laboratory uses, and answer Q2 in that language. The structures and the algorithms are identical either way, and an examiner marks the structure, not the syntax.

How the 30 marks of a practical question are earned

MU does not print a breakdown inside Q1 and Q2, and no honest book can invent one. What every practical examiner in this system looks for is the same five things, and they are what the journal format in this book is built around:

1. The aim, in MU's own words where possible.
2. The program, written out, correctly indented, with the variable names a reader can

follow.

1. The run, the output as it actually appeared, not as it should have.
2. The conclusion, one or two sentences saying what the exercise showed.
3. Being able to answer for it, which is Q3.

A program that runs and prints the right answer, with no aim and no conclusion written underneath, leaves marks on the table in every one of those five.

Where marks are lost

• No certified journal, so no examination. The worst and the most avoidable.
• Eighteen practicals instead of twenty. Item 13's own arithmetic is 2.5 times 20.
• Writeups submitted in a heap at the end instead of at the following session.
• Treating Q3 as a formality. It is five marks, more than the gap between Q1 and Q2.
• Starting with Module 2 out of habit when Module 1 carries the extra mark and is

faster to finish.

• Assuming the 15 and 15 split from another course's practical paper. This one is

13, 12 and 5.

• Writing the program and not the output. The output is the evidence the program ran.

For the journal

This chapter is not a practical and has no journal entry. Copy the three-row table of Q1, Q2 and Q3 into the front of your journal anyway, on the page before the index, with the line about the certified copy under it. It takes two minutes and it is the only part of the scheme you need to remember.

Quick revision

• Major Practical 3, Semester 3, 2 credits, 50 marks: 20 internal and 30 external.
• Individual passing in internal and external, standard of passing 40 per cent.
• Internal: 2.5 marks per practical performance and writeup, 20 practicals, total 50,

converted to 20. The writeup is due at the next session.

• External: a two hour practical examination for 30 marks.
• The slip: Q1 Module 1 13 marks, Q2 Module 2 12 marks, Q3 Journal and Viva 5 marks.
• A certified copy of the journal is compulsory to appear. Signed, not just complete.
• Module 1 is Python, ten exercises. Module 2 is data structures, ten exercises.
• Module 2's language is yours to choose: MU's own Data Structures OC 3 says so.
• Source: MU item 6.9 (N), AC 28 March 2025, in force from 2025-26.

Questions you should be able to answer

1. What are the three questions on the practical slip, and what is each worth? Q1 on Module 1 for 13 marks, Q2 on Module 2 for 12 marks, and Q3 on the journal and the viva for 5 marks. Thirty in all, in two hours.

2. How many marks is the journal worth? More than one figure. It earns part of the 20 internal marks under item 13, at 2.5 marks per practical and writeup, and it is examined again inside Q3 of the 30 mark external slip.

3. What happens if your journal is complete but unsigned? It is not a certified copy, and a certified copy is compulsory to appear for the practical examination.

4. How many practicals does MU expect in the journal, and how do you know? Twenty. Item 13 awards 2.5 marks for each practical performance and writeup to a total of 50 marks, and 2.5 multiplied by 20 is exactly 50.

5. Which module is worth more, and by how much? Module 1, by one mark: 13 against 12.

6. What language should Module 2 be written in? The one your laboratory uses. MU does not fix it: the Data Structures theory paper's Course Outcome 3 is expressly "using their chosen programming language". This book uses Python and gives the C versions in a chapter of their own.

7. What is the standard of passing, and why does it matter here? Forty per cent, with individual passing in internal and external. So the journal and the examination cannot cover for each other.

The two ways to run Python, and when each is right

The interactive prompt. Type python3 and you get >>>. Every line you type runs at once and its value is printed back. It is the right tool for checking one thing:

>>> 17 % 5
2
>>> "munotes"[0]
'm'
>>> exit()

Nothing typed at >>> is saved. It is a calculator, not a place to write a practical.

A saved file. A file called practical1.py holds the program, and

python3 practical1.py

runs it from top to bottom. This is what the examination expects, this is what goes in your journal, and this is what every listing in this book is.

IDLE, the editor MU's laboratories have

IDLE arrives with Python and needs nothing installed. Open it and you get the same >>> shell. To write a program, choose File, then New File, type the program, save it with a .py ending, and press F5 to run it. The output appears in the shell window.

Three things about IDLE that save time in a laboratory:

• F5 saves before it runs. If it asks, say yes. Running an unsaved file is not

possible, which is a feature: what ran is what is on disk.

• The Tab key indents, and IDLE indents for you after a line ending in a colon.

Python decides what is inside a block by indentation alone, so this matters more than in any language you have used before.

• File, then Save As, into your own folder. A file saved into the Python

installation folder is a file you will not find again on a shared machine.

Any editor works. VS Code, Notepad++, nano and gedit are all fine. IDLE is described here because it is what is installed on a machine you did not set up.

Your first program, and what each line does

print("munotes")
print("Major Practical 3")
print(2 + 2)

munotes
Major Practical 3
4

Three statements, run in order, each printing one line. print puts a newline at the end by itself, which is why three calls give three lines.

Indentation is the syntax

This is the one rule that catches every student moving from C to Python. C marks a block with braces and the indentation is decoration. In Python the indentation IS the block, and there are no braces at all.

total = 0
for n in [1, 2, 3, 4]:
    total = total + n
    print("running total", total)
print("final", total)

running total 1
running total 3
running total 6
running total 10
final 10

The two indented lines are inside the loop and run four times. The last line is not indented, so it is outside the loop and runs once. Move that last line four spaces right and the program prints five lines instead of one. Nothing else changes.

Use four spaces for one level. Do not mix spaces and tabs in one file: Python 3 refuses to run a file that does, with TabError, and the two look identical on screen.

Reading an error message

Python prints errors as a traceback, and the useful line is the last one. Read from the bottom up.

numbers = [10, 20, 30]
print(numbers[3])

IndexError: list index out of range

That is the last line of the traceback, and it is the one that matters: it names the kind of error, IndexError, and what was wrong, list index out of range. On your own screen several lines come before it, giving the file and the line number, and this book prints only the last line because the lines above it are laid out slightly differently in different versions of Python. Read from the bottom up and most errors are fixed in seconds.

Here are the four you will meet in week one, with what they actually mean.

The last of those four is the single commonest error in this whole paper, and [Practical 1: Input, Output, and the Year You Turn 100] is where it is met and killed.

Why the prompts in this book look run together

Every output block in this book is what the program actually printed, captured by feeding the input in from a file rather than typing it. That changes how a prompt looks, and it is worth understanding once so it never puzzles you again.

At your own keyboard, a program that asks two questions shows this, where the values in bold are what you typed:

What is your name? Aarti
How old are you? 19
Hello, Aarti

The same program, fed from a file, prints this, which is what a proved output block in this book holds:

What is your name? How old are you? Hello, Aarti

Nothing is wrong. A prompt has no newline at the end, and when nobody is typing there is nothing to push the next prompt onto its own line, and the typed value is never echoed because it was never typed. So the two prompts sit side by side. Your own run will put your answers in between.

What to put in the journal when a program will not run

Not nothing, and not a blank page. An entry that records a failure honestly is worth marks; a missing entry is worth none.

Write the aim, write the program as you wrote it, write the error message in full, and then one or two sentences on what you think it means and what you tried. If you fix it later, add the corrected program underneath with a line saying what the fix was. A teacher signing your journal is looking for evidence that you sat and worked on it, and a traceback with your own diagnosis under it is exactly that.

Procedure

1. Install Python 3 and confirm the version with python3 --version.
2. Install NumPy with python3 -m pip install numpy and confirm it imports.
3. Open IDLE, create a new file, save it as first.py in your own folder.
4. Type the three line print program, press F5, and read the output in the shell.
5. Add a for loop with an indented body and confirm the indentation decides what

repeats.

1. Cause an IndexError on purpose and read the traceback from the bottom line up.

Result

Python, NumPy and an editor are installed and working, a program has been saved and run from a file, the role of indentation is understood, and a traceback can be read.

Where marks are lost

• Working at the >>> prompt and then having nothing to show. A practical is a file.
• Not adding Python to PATH on Windows, then spending laboratory time on it.
• Installing NumPy into a different Python than the one being run. Use

python3 -m pip.

• Mixing tabs and spaces, which produces TabError and looks like nothing at all on

screen.

• Reading a traceback from the top. The bottom line is the error.
• Leaving a failed practical out of the journal instead of recording the error.

For the journal

This is the setup and it has no numbered entry. On the page facing your index, write the version of Python and the version of NumPy on your laboratory machine, and the command that runs a file on it. Every entry afterwards can then say "run as before" instead of repeating it twenty times.

Quick revision

• Python 3, any version from 3.10, and python3 --version proves it.
• NumPy is separate: python3 -m pip install numpy. MU's practicals 3 and 4 need it.
• >>> is for checking one thing. A practical is a saved .py file run as

python3 file.py.

• IDLE: File, New File, save with .py, F5 to run. F5 saves first.
• Indentation is the block. Four spaces, never tabs mixed with spaces.
• A traceback is read from the bottom line, which names the error and the reason.
• The four week one errors: SyntaxError (missing colon or bracket),

IndentationError, NameError (typo or used too early), TypeError (a string added to a number, usually an unconverted input()).

• A program that will not run still gets a journal entry, with the error message in full.

Questions you should be able to answer

1. What is the difference between the interactive prompt and a saved file? At >>> each line runs as it is typed and nothing is kept. A saved file is a program that runs top to bottom, can be re-run, and is what the journal and the examination require.

2. Why does python3 -m pip install numpy avoid a common problem? It installs into the interpreter you named. A bare pip may belong to a different Python, and then import numpy fails in the one you are running.

3. What decides which statements are inside a loop in Python? The indentation, and nothing else. There are no braces.

4. Which line of a traceback do you read first, and what does it tell you? The last one. It gives the kind of error and the reason, for example IndexError: list index out of range.

5. You wrote if marks > 40 and Python said SyntaxError: invalid syntax. Why? The colon is missing. if, elif, else, for, while and def all end their line with a colon.

6. age = input("Age: ") then age + 1 gives a TypeError. What is the fix? input() always returns a string. Convert it: age = int(input("Age: ")).

7. Why do the prompts in this book's output blocks run together on one line? Because the input was fed from a file rather than typed, so nothing was echoed and no newline was added after a prompt. At a keyboard your answers appear in between.

8. What goes in the journal for a practical that would not run? The aim, the program as written, the complete error message, and your own sentence or two on what it means and what you tried.

from datetime import date

this_year = date.today().year
print("the current year is", this_year)
print("a 19 year old turns 100 in", this_year + 100 - 19)

the current year is 2026
a 19 year old turns 100 in 2107

date.today() gives today's date and .year takes the year out of it, as an ordinary integer you can do arithmetic with.

The two numbers in that output block were true on the day this page was built and they will not be true when you read it, which is exactly the point of the section: the program is right in every year because it asks the machine. Every other output in this chapter is a number that does not move, and is printed in full.

The program

from datetime import date

name = input("What is your name? ")
age = int(input("How old are you? "))

this_year = date.today().year
years_to_go = 100 - age
century_year = this_year + years_to_go

print(f"Hello {name}, you are {age} years old.")
print(f"You have {years_to_go} years to go until you are 100.")
print(f"You will turn 100 in the year {century_year}.")

Aarti
19

What is your name? How old are you? Hello Aarti, you are 19 years old.
You have 81 years to go until you are 100.
You will turn 100 in the year 2107.

That is the answer, and it is the version that goes in your journal.

The year in the last line moved on the day this page was built and will move again, so here is the same arithmetic with the year held still, which is how you check your own result and how you explain it at the table:

name = "Aarti"
age = 19
this_year = 2026

years_to_go = 100 - age
century_year = this_year + years_to_go

print(f"{name} is {age}, so {100} - {age} = {years_to_go} years to go")
print(f"and {this_year} + {years_to_go} = {century_year}")

Aarti is 19, so 100 - 19 = 81 years to go
and 2026 + 81 = 2107

100 - 19 = 81, and 2026 + 81 = 2107. A person who is 19 in 2026 turns 100 in 2107.

The mark almost everybody misses: the birthday this year

The program above is the answer MU's row asks for, and it is what goes in the journal. But it is only exactly right for somebody whose birthday has already passed this year.

Think about it with a date. If Aarti is 19 today and her birthday was in March, she turns 20 next March, 21 the March after, and 100 in the year 2026 + 81 = 2107. Correct. But if her birthday is in December and she is still 19 in this calendar year, she turns 20 this December, and she will reach 100 one year earlier than the simple sum says.

The complete version asks for the date of birth instead of the age, and then there is nothing to guess:

from datetime import date

dob = date(2006, 12, 15)
today = date(2026, 3, 1)

age = today.year - dob.year - ((today.month, today.day) < (dob.month, dob.day))
century_year = dob.year + 100

print(f"born {dob}, so today the age is {age}")
print(f"the 100th birthday falls in {century_year}")
print(f"the simple sum would have said {today.year + (100 - age)}")

born 2006-12-15, so today the age is 19
the 100th birthday falls in 2106
the simple sum would have said 2107

The comparison (today.month, today.day) < (dob.month, dob.day) is worth understanding, because it is a neat Python idiom and a viva question. Python compares two tuples item by item: it looks at the months first and only looks at the days if the months are equal. So the whole expression is True when this year's birthday has not happened yet, and True counts as 1 when subtracted, which takes one year off the age.

The last two lines show the point. Born in December 2006, the hundredth birthday is in December 2106, but the naive sum from an age of 19 in March 2026 says 2107. One year out.

Put the simple version in your journal, because that is what MU's row asks for, and add two sentences underneath saying that the answer assumes this year's birthday has passed, and that using the date of birth removes the assumption. That sentence is worth a mark and takes fifteen seconds.

Procedure

1. Open a new file and save it as practical1a.py.
2. Read the name with input().
3. Read the age with input() and convert it with int().
4. Take the current year from date.today().year.
5. Compute the years to go as 100 minus the age, and add them to the current year.
6. Print the message with an f-string so the name is inside the sentence.
7. Run it with your own name and age, and check the sum by hand.

Result

The program accepts a name and an age and prints a message addressed to the user giving the year in which they will turn 100. Checked: age 19 in 2026 gives 2107, and 2026 + 81 = 2107.

Where marks are lost

• Forgetting int() around the age, so the program dies with a TypeError.
• Hard coding the current year. The answer is then wrong from the next 1st of January.
• Not addressing the user by name. MU's row says "addressed to them", so the name

goes inside the sentence, not on a line of its own.

• Writing print("Hello " + name + ", you are " + age) with age a number, which is

the same TypeError from the other direction.

• Using input without a prompt, so the run shows a blank screen and nobody knows

what to type.

• No output written in the journal. The output is the evidence that it ran.

For the journal

Write the aim in MU's own words. Then the program, the one that reads the year from date.today(). Then the run, with your own name and age and the year it printed. Then two sentences: that input() returns a string so the age must be converted with int(), and that the answer assumes this year's birthday has passed, which reading the date of birth would remove. The conclusion: a program that reads the year from the system rather than having it typed in stays correct next year.

Quick revision

• input(prompt) prints the prompt and returns the line typed, always as a string.
• int() converts it. Without that, age + 1 is a TypeError.
• Three ways to print a sentence with a value in it: + with str(), print with

commas which inserts spaces, and the f-string, which is the one to use.

• from datetime import date, then date.today().year is the current year. Never type

the year into the program.

• Years to go = 100 - age. Year of the 100th birthday = current year + years to go.
• Worked: 19 years old in 2026 gives 100 - 19 = 81 and 2026 + 81 = 2107.
• The simple sum assumes this year's birthday has passed. From a date of birth,

age = today.year - dob.year - ((today.month, today.day) < (dob.month, dob.day)).

• Python compares tuples item by item, which is why that one line works.

Questions you should be able to answer

1. What type does input() return? A string, always, even when the user types digits.

2. Why does int(input(...)) appear so often in this paper? Because almost every exercise does arithmetic on what was typed, and arithmetic on a string either fails with a TypeError or does something unwanted: multiplying the string "2" by 3 gives "222", not 6.

3. Write the line that prints a name and a year in one sentence. print(f"Hello {name}, you will turn 100 in {year}.")

4. Why is year = 2026 in the program a defect? Because the program gives a wrong answer from the next 1st of January. date.today().year asks the machine instead.

5. A student is 19 in 2026. In which year do they turn 100, and show the sum. 100 - 19 = 81 years to go, and 2026 + 81 = 2107.

6. When is that answer one year out, and why? When this year's birthday has not happened yet. The person is still 19 but will turn 20 later this year, so they reach 100 one year sooner than the sum from the age says.

7. What does the tuple comparison in the date version do? (today.month, today.day) < (dob.month, dob.day) compares item by item, months first and days only if the months are equal, so it is True exactly when this year's birthday is still to come. True counts as 1, so subtracting it takes one year off the age.

8. What is the difference between print(a, b) and print(a + b) for two strings? The first prints them with a space between; the second joins them with no space. The first also works when b is a number and the second does not.

try and except are worth one sentence in the journal and one line of code. MU does not ask for them in this row, so the plain version is the answer, and this is the improvement to mention underneath.

Part two: MU's SGPI grade ladder

The table MU prints

This is her own table, reproduced exactly as the rows appear in the syllabus:

SGPI is the Semester Grade Performance Index, the weighted average of the grade points you earned in one semester, on a ten point scale. O is Outstanding, A+ and A are the two first classes, B+ and B the two seconds, C is a pass class, P is a bare pass and F is a fail.

The idea that makes the program short

Eight bands sounds like eight tests. It is not, and seeing why is the whole exercise.

Work downwards from the top. If the SGPI is 9.00 or more, the grade is O and nothing else needs testing. If it was not, then it is below 9.00, so "8.00 or more" is enough to mean 8.00 to 8.99 without ever writing the upper limit. Each rung of the ladder only has to name its own floor, because every rung above it has already been ruled out.

That is what elif is for. It means "else, if", and only the first branch whose condition is true runs.

The program

sgpi = float(input("Enter your SGPI: "))

if sgpi > 10:
    grade = "invalid, the scale ends at 10.00"
elif sgpi >= 9.00:
    grade = "O"
elif sgpi >= 8.00:
    grade = "A+"
elif sgpi >= 7.00:
    grade = "A"
elif sgpi >= 6.00:
    grade = "B+"
elif sgpi >= 5.50:
    grade = "B"
elif sgpi >= 5.00:
    grade = "C"
elif sgpi >= 4.00:
    grade = "P"
else:
    grade = "F"

print(f"SGPI {sgpi:.2f} gives grade {grade}")

7.85

Enter your SGPI: SGPI 7.85 gives grade A

Three things to notice in that listing.

float, not int. An SGPI is 7.85, not 7. int("7.85") raises ValueError, and int(7.85) would throw the decimals away and turn an A into an A. Every mark in the middle of a band would land on the wrong rung.

The bands are written in descending order. Write them ascending and the first condition, sgpi >= 4.00, is true for almost everybody, so almost everybody gets a P. That is the single commonest wrong answer to this exercise.

The sgpi > 10 guard comes first. Without it, an SGPI of 47 quietly gets an O.

Every band tested, which is what proves it

One run proves one band. Testing all eight, and both sides of every junction, is what turns a program into an answer:

def grade_for(sgpi):
    if sgpi > 10:
        return "invalid"
    if sgpi >= 9.00:
        return "O"
    if sgpi >= 8.00:
        return "A+"
    if sgpi >= 7.00:
        return "A"
    if sgpi >= 6.00:
        return "B+"
    if sgpi >= 5.50:
        return "B"
    if sgpi >= 5.00:
        return "C"
    if sgpi >= 4.00:
        return "P"
    return "F"


for value in [10.00, 9.00, 8.99, 8.00, 7.99, 7.00, 6.99, 6.00,
              5.99, 5.50, 5.49, 5.00, 4.99, 4.00, 3.99, 0.00]:
    print(f"{value:>6.2f} -> {grade_for(value)}")

 10.00 -> O
  9.00 -> O
  8.99 -> A+
  8.00 -> A+
  7.99 -> A
  7.00 -> A
  6.99 -> B+
  6.00 -> B+
  5.99 -> B
  5.50 -> B
  5.49 -> C
  5.00 -> C
  4.99 -> P
  4.00 -> P
  3.99 -> F
  0.00 -> F

Read that output against MU's table row by row. Every band's floor and every band's ceiling appears, and each lands where her table says it should.

Notice that a series of plain if statements with a return in each does the same job as the elif ladder. It works because return leaves the function at once, so nothing below it can run. Either form is correct; the elif ladder is the one to write when there is no function.

The hole in MU's table, and what to do about it

Look at the two middle bands again: C is 5.00 to 5.49 and B is 5.50 to 5.99. Now ask what grade an SGPI of exactly 5.495 gets. It is above 5.49 and below 5.50, so MU's table does not say. The same gap sits between every pair of bands: 8.99 to 9.00, 7.99 to 8.00, and so on.

This is not a trick question, it is how marks are actually recorded: an SGPI is published to two decimal places, so 5.495 never occurs. The program above handles it anyway, and it is worth knowing how, because it is a viva question.

def grade_for(sgpi):
    if sgpi >= 9.00:
        return "O"
    if sgpi >= 8.00:
        return "A+"
    if sgpi >= 5.50:
        return "B"
    if sgpi >= 5.00:
        return "C"
    return "below C"


for value in [5.495, 5.50, 8.995, 9.00]:
    print(f"{value:>7.3f} -> {grade_for(value)}")

  5.495 -> C
  5.500 -> B
  8.995 -> A+
  9.000 -> O

Because each rung tests "greater than or equal to its own floor" and the ladder runs downwards, a value in a gap falls through to the band below it: 5.495 gets a C and 8.995 gets an A+. That is a decision the program makes, so say it out loud in the journal: at a value between two bands this ladder awards the lower grade, and at an exact band floor it awards the higher one. An examiner who asks about the gap is checking whether you know your own program's behaviour, not whether you can recite MU's table.

Procedure

1. Save the even or odd program as practical1b.py. Read the number with int(input()).
2. Test number % 2 == 0 and print with an f-string in each branch.
3. Run it with an odd number, an even number, zero and a negative number.
4. Save the grade program as practical1c.py. Read the SGPI with float(input()).
5. Write the eight bands as an elif ladder in descending order, each testing only

its own floor, with a guard above 10 and else for F.

1. Run it once for each of MU's eight bands and at both ends of each band.
2. Write both programs, both runs, and the note about the band boundaries in the journal.

Result

Even or odd is decided by n % 2 == 0, proved on positive, negative and zero. The grade ladder was run at the floor and the ceiling of all eight of MU's bands and every value landed in the band her table gives, with the boundary rule stated.

Where marks are lost

• Writing the bands in ascending order. Then sgpi >= 4.00 catches nearly everybody

and the program prints P for an SGPI of 9.

• Using int() for the SGPI. It refuses 7.85 outright, and truncating would put

marks in the wrong band.

• Writing each band as two tests, if 8.00 <= sgpi <= 8.99, which is not wrong but is

twice the code and leaves the gaps between bands unhandled, so an SGPI of 8.995 gets no grade at all.

• A chain of separate if statements instead of elif with no return in them: then

several branches run and the last one wins, which is usually F.

• No guard above 10, so an SGPI of 47 gets an O.
• Testing n % 2 == 1 for odd out of C habit. It happens to work in Python, but the

reason it works is worth knowing and == 0 for even is the safer habit.

• Only one run. Eight bands need eight runs to be an answer.

For the journal

Two entries under one practical number. For the even or odd program: the aim in MU's words, the program, runs with an odd number, an even number, zero and a negative number, and the conclusion that % gives the remainder and zero is even. For the grade program: the aim, MU's own eight band table copied out, the program, a run for each band, and two sentences saying that the ladder is written downwards so each band needs only its floor, and that a value between two bands takes the lower grade.

Quick revision

• % is the remainder. Even is n % 2 == 0, odd is anything else. Zero is even.
• In Python the remainder takes the sign of the divisor, so -7 % 2 is 1, not -1 as in C.
• == compares, = assigns.
• int(input()) for a whole number, float(input()) for an SGPI.
• elif means else-if, and only the first true branch runs.
• Write the bands downwards, each testing only its own floor: >= 9.00 is O, and if

that failed then >= 8.00 already means 8.00 to 8.99.

• MU's bands: 9.00 O, 8.00 A+, 7.00 A, 6.00 B+, 5.50 B, 5.00 C, 4.00 P, below 4 F.
• Guard above 10.00 first, else for F last.
• A value in a gap between bands falls to the lower band; a value on a floor takes the

higher. Say so in the journal.

• {value:>6.2f} in an f-string right aligns a number in 6 characters with 2 decimals.

Questions you should be able to answer

1. How do you test whether a number is even? n % 2 == 0. The remainder on dividing by 2 is zero.

2. Is zero even or odd? Even. Zero divided by 2 leaves no remainder.

3. What is -7 % 2 in Python, and why does that differ from C? It is 1. Python's remainder takes the sign of the divisor, so it is never negative for a positive divisor. C's takes the sign of the dividend, giving -1.

4. Why must the SGPI be read with float and not int? Because an SGPI has decimals. int("7.85") raises ValueError, and truncating to 7 would move a mark into the wrong band.

5. Why are the grade bands written in descending order? Because each elif then only needs its own floor: if >= 9.00 has already failed, >= 8.00 can only mean 8.00 to 8.99. Written upwards, the first test catches almost every value and everyone gets a P.

6. What is the difference between eight if statements and an elif ladder? In a ladder only the first true branch runs. With eight separate if statements every true one runs, so several assignments happen and the last wins, which for a high SGPI is F. Separate if statements are safe only when each one ends in return.

7. MU's table jumps from 5.49 to 5.50. What grade does 5.495 get, and why? A C. Each rung tests "greater than or equal to its own floor" going downwards, so a value in a gap falls through to the band below. Real SGPIs are published to two decimals, so the case does not arise, but the program has an answer for it.

8. What does the guard if sgpi > 10 protect against? An impossible SGPI silently getting the top grade. Without it, 47 is greater than 9.00 and prints O.

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
[0]
[]

series[-1] is the last item and series[-2] the one before it. The [:count] at the end handles the small cases: the list starts with two terms, so asking for one or for none would otherwise give too many.

Up to a limit rather than a count, which MU's wording also permits:

limit = 100
a, b = 0, 1
while a <= limit:
    print(a, end=" ")
    a, b = b, a + b
print()

0 1 1 2 3 5 8 13 21 34 55 89

By recursion, which is the version to know about and not to use:

def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)


print([fib(n) for n in range(10)])

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

That is a direct translation of the definition and it is beautifully short. It is also wasteful in a way worth measuring, because the examiner's question is "why is this slow".

calls = 0


def fib_counted(n):
    global calls
    calls += 1
    if n <= 1:
        return n
    return fib_counted(n - 1) + fib_counted(n - 2)


for n in [5, 10, 15, 20, 25, 30]:
    calls = 0
    value = fib_counted(n)
    print(f"fib({n:>2}) = {value:>6}   and it took {calls:>7} calls to work out")

fib( 5) =      5   and it took      15 calls to work out
fib(10) =     55   and it took     177 calls to work out
fib(15) =    610   and it took    1973 calls to work out
fib(20) =   6765   and it took   21891 calls to work out
fib(25) =  75025   and it took  242785 calls to work out
fib(30) = 832040   and it took 2692537 calls to work out

The call count is the explanation, and it is the same on every machine. Recursion recomputes the same terms over and over. To get fib(25) it computes fib(23) twice, fib(22) three times and so on down the tree, which is why the calls run into the hundreds of thousands. Look at the column: the calls roughly multiply by 11 each time n goes up by 5, while the loop version does n additions and nothing more.

That is what makes recursion here the wrong tool for a series, and saying it with the call count is a much better answer than saying it is slow.

Part two: the sum of the digits

The arithmetic method

Two operators do the whole job. % 10 gives the last digit, and // 10 throws the last digit away. // is floor division, which divides and discards the remainder; plain / would give a float and break everything.

n = 4729
while n > 0:
    print(f"n = {n:>5}   last digit {n % 10}   rest {n // 10}")
    n = n // 10

n =  4729   last digit 9   rest 472
n =   472   last digit 2   rest 47
n =    47   last digit 7   rest 4
n =     4   last digit 4   rest 0

So the program is that loop with the digits added up instead of printed:

number = int(input("Enter a number: "))

n = abs(number)
total = 0
while n > 0:
    total = total + n % 10
    n = n // 10

print(f"The sum of the digits of {number} is {total}.")

4729

Enter a number: The sum of the digits of 4729 is 22.

Check it by hand: 4 + 7 + 2 + 9 = 22.

Three details in that program earn marks.

abs(number) first. Without it, a negative number never enters the loop, because -4729 > 0 is false, and the program prints a sum of 0. With abs, the digits of -4729 add to 22.

The original number is kept for the message, and a separate n is consumed by the loop. Print number after the loop without that and it prints 0, because the loop ate it.

Zero. 0 > 0 is false, so the loop never runs and the total stays 0, which is the right answer for zero. That is luck rather than design, so it is worth one sentence in the journal saying you checked it.

The string method

number = int(input("Enter a number: "))

total = sum(int(digit) for digit in str(abs(number)))
print(f"The sum of the digits of {number} is {total}.")

4729

Enter a number: The sum of the digits of 4729 is 22.

str(abs(number)) turns the number into its digits as characters, int(digit) turns each character back into a number, and sum adds them. One line, and perfectly correct.

Which to put in the journal? The arithmetic one, with the string one underneath as an alternative. The arithmetic version is what the exercise is teaching, because % 10 and // 10 are how digits are taken apart in every language, and an examiner may well ask for it "without converting to a string".

Every case tested

def digit_sum(number):
    n = abs(number)
    total = 0
    while n > 0:
        total = total + n % 10
        n = n // 10
    return total


for value in [4729, 0, 7, -4729, 1000, 999999999]:
    digits = " + ".join(str(d) for d in str(abs(value)))
    print(f"{value:>10}  ->  {digits} = {digit_sum(value)}")

      4729  ->  4 + 7 + 2 + 9 = 22
         0  ->  0 = 0
         7  ->  7 = 7
     -4729  ->  4 + 7 + 2 + 9 = 22
      1000  ->  1 + 0 + 0 + 0 = 1
 999999999  ->  9 + 9 + 9 + 9 + 9 + 9 + 9 + 9 + 9 = 81

The digit sum is also useful to know for its own sake: a number is divisible by 3 exactly when its digit sum is, and by 9 exactly when its digit sum is. 4 + 7 + 2 + 9 = 22, which is not divisible by 3, so 4729 is not either.

Procedure

1. Save the series program as practical2a.py. Read the number of terms with

int(input()).

1. Set a, b = 0, 1 and loop count times, printing a and then doing

a, b = b, a + b.

1. Run it for 10 terms and check the first eight against the table by hand.
2. Deliberately replace the tuple assignment with two separate assignments and see the

wrong answer, then put it back.

1. Save the digit sum as practical2b.py. Read the number, take abs, and loop with

% 10 and // 10.

1. Run it with a positive number, zero and a negative number, and check the sum by hand.

Result

The series program printed 0 1 1 2 3 5 8 13 21 34 for ten terms, which matches the table term by term. The digit sum of 4729 was 22, and 4 + 7 + 2 + 9 = 22. Zero gave 0 and -4729 gave 22.

Where marks are lost

• Two separate assignments instead of a, b = b, a + b, which prints the powers of

two and looks almost right.

• Printing one term too many or too few. Ten terms means ten numbers; count the

output.

• Using / instead of // for the digit sum, which turns the number into a float and

loops for ever or crashes.

• No abs(), so a negative number gives a sum of 0.
• Consuming the number in the loop and then printing it, so the message says 0.
• Offering the recursive version as the answer without being able to say why it is

slow. The reason is that it recomputes the same terms, and the call count proves it.

• Only one run. Zero and a negative number are two more lines of output and two more

marks.

For the journal

Two entries under practical 2. For the series: the aim, the table of the first eight terms worked from the two before, the program, the run for ten terms, and one sentence saying that a, b = b, a + b works because the right hand side is evaluated in full before anything is assigned. For the digit sum: the aim, the program, runs for a positive number, zero and a negative number, the hand check 4 + 7 + 2 + 9 = 22, and one sentence on why abs is needed.

Quick revision

• Fibonacci: each term is the sum of the two before. Starts 0, 1, then 1, 2, 3, 5, 8, 13.
• a, b = 0, 1 and a, b = b, a + b. The right side is built before anything is

assigned, so no temporary variable is needed.

• Two separate assignments give the powers of two. That is the bug to recognise.
• series[-1] is the last item, series[-2] the one before.
• Recursive Fibonacci is the definition written out, and it recomputes terms, so it is

exponential. The call count is the evidence.

• Digit sum: % 10 takes the last digit, // 10 removes it. Loop while the number is

greater than 0.

• // is floor division. Plain / gives a float and breaks the loop.
• abs() first, or negative numbers give 0. Keep the original number for the message.
• One line alternative: sum(int(d) for d in str(abs(n))).
• 4 + 7 + 2 + 9 = 22, so the digit sum of 4729 is 22.

Questions you should be able to answer

1. Write the Fibonacci series in one loop. a, b = 0, 1, then repeat: print a, and a, b = b, a + b.

2. Why does a, b = b, a + b not need a temporary variable? Because Python builds the whole right hand side first, as a tuple, and only then unpacks it into a and b. So a + b uses the old a.

3. What does the program print if you write a = b and then b = a + b? The powers of two: 0 1 2 4 8 and so on. The old a has already been lost when the second line runs.

4. Why is the recursive Fibonacci slow? It recomputes the same terms many times. Computing fib(25) recomputes fib(23) twice, fib(22) three times and so on, which here came to hundreds of thousands of calls.

5. Which two operators take a number apart into digits? % 10 gives the last digit, // 10 removes it.

6. Why // and not /? / always gives a float in Python 3, so the number never becomes exactly 0 and the loop misbehaves. // divides and discards the remainder.

7. What does your digit sum program print for -4729, and why? 22, because abs() is applied first. Without it the loop condition is false straight away and the answer would be 0.

8. What is the digit sum of 4729, and one thing it tells you? 22. Since 22 is not divisible by 3, neither is 4729.

The difference between arange and linspace is a favourite question: arange takes a step and excludes the stop, linspace takes a count and includes it.

Indexing

import numpy as np

a = np.array([10, 20, 30, 40, 50, 60])

print("the whole array   ", a)
print("a[0]  first       ", a[0])
print("a[3]               ", a[3])
print("a[-1] last        ", a[-1])
print("a[-2] second last ", a[-2])
print("len(a)            ", len(a))

the whole array    [10 20 30 40 50 60]
a[0]  first        10
a[3]                40
a[-1] last         60
a[-2] second last  50
len(a)             6

Indexing starts at 0, so the first item is a[0] and the last is a[len(a) - 1]. A negative index counts from the end, so a[-1] is the last item. This is worth learning properly because it removes a whole class of off by one errors: to get the last item you never need to know the length.

Going past the end raises an error rather than returning rubbish:

import numpy as np

a = np.array([10, 20, 30])
print(a[5])

IndexError: index 5 is out of bounds for axis 0 with size 3

For a two dimensional array, one pair of brackets holds both indexes, separated by a comma:

import numpy as np

m = np.array([[1, 2, 3, 4],
              [5, 6, 7, 8],
              [9, 10, 11, 12]])

print(m)
print("m[1, 2] row 1 column 2 :", m[1, 2])
print("m[0]    the whole row 0:", m[0])
print("m[:, 1] the whole col 1:", m[:, 1])
print("m[-1, -1] bottom right :", m[-1, -1])

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
m[1, 2] row 1 column 2 : 7
m[0]    the whole row 0: [1 2 3 4]
m[:, 1] the whole col 1: [ 2  6 10]
m[-1, -1] bottom right : 12

m[1][2] also works and gives the same value, but m[1, 2] is the NumPy way and is faster, because m[1][2] builds the whole row as an intermediate array first.

Slicing

A slice takes a piece of the array. It is written start:stop:step, and every part may be left out.

The stop is excluded. a[1:4] gives items 1, 2 and 3, not 4. This is the single most important fact about slicing, and the reason it is designed that way is worth knowing: a[:n] and a[n:] between them give the whole array exactly once, with nothing repeated and nothing missed.

import numpy as np

a = np.array([10, 20, 30, 40, 50, 60, 70])

print("a          ", a)
print("a[1:4]     ", a[1:4])
print("a[:3]      ", a[:3])
print("a[4:]      ", a[4:])
print("a[:]       ", a[:])
print("a[::2]     ", a[::2])
print("a[1::2]    ", a[1::2])
print("a[::-1]    ", a[::-1])
print("a[-3:]     ", a[-3:])
print("a[2:2]     ", a[2:2], "an empty slice, not an error")
print("a[1:100]   ", a[1:100], "an out of range stop is clipped, not an error")

a           [10 20 30 40 50 60 70]
a[1:4]      [20 30 40]
a[:3]       [10 20 30]
a[4:]       [50 60 70]
a[:]        [10 20 30 40 50 60 70]
a[::2]      [10 30 50 70]
a[1::2]     [20 40 60]
a[::-1]     [70 60 50 40 30 20 10]
a[-3:]      [50 60 70]
a[2:2]      [] an empty slice, not an error
a[1:100]    [20 30 40 50 60 70] an out of range stop is clipped, not an error

Two behaviours in that output are worth remembering because they are the opposite of indexing: an empty slice is not an error, and nor is a stop past the end. a[5] on a three item array raises IndexError; a[1:100] quietly gives what there is. That is deliberate, and it is why slicing is the safe way to take a piece of something whose length you are not sure of.

Slicing a two dimensional array takes a slice in each direction:

import numpy as np

m = np.arange(1, 13).reshape(3, 4)

print(m)
print("m[0:2, 1:3] first two rows, middle two columns")
print(m[0:2, 1:3])
print("m[:, ::2] every second column")
print(m[:, ::2])
print("m[::-1] the rows reversed")
print(m[::-1])

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
m[0:2, 1:3] first two rows, middle two columns
[[2 3]
 [6 7]]
m[:, ::2] every second column
[[ 1  3]
 [ 5  7]
 [ 9 11]]
m[::-1] the rows reversed
[[ 9 10 11 12]
 [ 5  6  7  8]
 [ 1  2  3  4]]

The one that will be asked: a slice is a view

Slicing a Python list gives a new list. Slicing a NumPy array gives a view, which is a window onto the same memory. Write through the window and the original changes.

import numpy as np

py = [10, 20, 30, 40, 50]
piece = py[1:4]
piece[0] = 999
print("list  :", py, "and the slice", piece)

arr = np.array([10, 20, 30, 40, 50])
window = arr[1:4]
window[0] = 999
print("array :", arr, "and the slice", window)
print("does the slice own its data?", window.base is None)

list  : [10, 20, 30, 40, 50] and the slice [999, 30, 40]
array : [ 10 999  30  40  50] and the slice [999  30  40]
does the slice own its data? False

The list is untouched and the array is changed. This is the most important difference between a list and a NumPy array, and it is the whole subject of the next chapter, which is MU's own third bullet on aliasing and copying. It is also not a defect: a view costs no memory and no copying, which is why NumPy is fast on large data.

window.base is the array a view looks into, and it is None for an array that owns its own memory. That one line is the quickest way to answer "is this a view or a copy" at the table.

The basic operations MU asks for

import numpy as np

a = np.array([3, 1, 4, 1, 5, 9, 2, 6])

print("array        ", a)
print("length       ", len(a), "or a.size", a.size)
print("sum          ", a.sum())
print("smallest     ", a.min(), "at index", a.argmin())
print("largest      ", a.max(), "at index", a.argmax())
print("mean         ", a.mean())
print("sorted       ", np.sort(a))
print("the original is untouched:", a)
print("reversed     ", a[::-1])
print("is 5 present ", 5 in a)
print("where a > 3  ", np.where(a > 3)[0])
print("cumulative   ", a.cumsum())
print("unique       ", np.unique(a))
print("append 7     ", np.append(a, 7))
print("insert 0 at 3", np.insert(a, 3, 0))
print("delete idx 2 ", np.delete(a, 2))
print("and still    ", a)

array         [3 1 4 1 5 9 2 6]
length        8 or a.size 8
sum           31
smallest      1 at index 1
largest       9 at index 5
mean          3.875
sorted        [1 1 2 3 4 5 6 9]
the original is untouched: [3 1 4 1 5 9 2 6]
reversed      [6 2 9 5 1 4 1 3]
is 5 present  True
where a > 3   [2 4 5 7]
cumulative    [ 3  4  8  9 14 23 25 31]
unique        [1 2 3 4 5 6 9]
append 7      [3 1 4 1 5 9 2 6 7]
insert 0 at 3 [3 1 4 0 1 5 9 2 6]
delete idx 2  [3 1 1 5 9 2 6]
and still     [3 1 4 1 5 9 2 6]

Two things in that run are the marks.

np.sort(a) returns a sorted copy and leaves a alone. a.sort(), with no np. in front, sorts in place and returns None. Writing a = a.sort() therefore destroys the array, which is a classic mistake.

append, insert and delete all return a new array. They do not change the original, as the last line proves. A NumPy array has a fixed size: there is no such thing as growing one. If you need to add items repeatedly, build a Python list and convert it once at the end.

Procedure

1. Save the program as practical3a.py and import numpy as np.
2. Create arrays with np.array, np.zeros, np.arange and np.linspace and print each.
3. Index the first, the last and a middle item, using a negative index for the last.
4. Take at least six slices, including a[::2] and a[::-1], and print each with a label.
5. Slice a two dimensional array in both directions.
6. Show that a list slice is a copy and an array slice is a view, by writing through both.
7. Run the basic operations: sum, min, max, mean, sort, search, append, insert, delete.
8. Record the dtype and itemsize your own machine printed.

Result

Arrays were created five ways, indexed from both ends, sliced eleven ways including reversal and step, and sliced in two dimensions. Writing through a list slice left the list unchanged; writing through an array slice changed the array, proving the slice is a view. Every basic operation ran and np.sort, append, insert and delete all left the original array untouched.

Where marks are lost

• Not saying which kind of array you used. Name it: a NumPy array, or array.array.
• Expecting a[1:4] to include item 4. The stop is always excluded.
• a = a.sort(), which sets a to None because the in place sort returns nothing.
• Expecting np.append to change the array. It returns a new one.
• Trying to grow an array in a loop. Build a list, then convert once.
• Not knowing a slice is a view. This is the question on this exercise.
• Using m[1][2] and not knowing that m[1, 2] is the NumPy form.

For the journal

The aim in MU's words. A short table of the three things called an array in Python, with one line on each. The program, with every print labelled so the output can be read against the code. The full output. Then the list against array comparison, with both printed before and after writing through the slice, and one sentence: a list slice is a copy, a NumPy slice is a view onto the same memory. The conclusion: indexing a single item raises an error when out of range, while slicing clips silently, and a NumPy array has a fixed size so append, insert and delete all return new arrays.

Quick revision

• Three arrays in Python: list (anything, flexible), array.array (one numeric type,

standard library, type code such as 'i'), numpy.ndarray (one type, n dimensions, the mathematics). MU's exercises mean NumPy.

• Create: np.array, np.zeros, np.ones, np.full, np.arange, np.linspace,

np.eye.

• arange takes a step and excludes the stop; linspace takes a count and

includes it.

• Index from 0. a[-1] is the last. Out of range raises IndexError.
• Two dimensions: m[row, col]. m[:, 1] is a whole column.
• Slice start:stop:step, stop excluded. a[::-1] reverses, a[::2] steps.
• An empty slice and a stop past the end are not errors.
• A list slice is a copy. A NumPy slice is a VIEW. x.base is None tells them apart.
• np.sort(a) returns a copy; a.sort() sorts in place and returns None.
• np.append, np.insert, np.delete all return new arrays. Array size is fixed.

Questions you should be able to answer

1. Name the three things in Python that get called an array, and what each holds. A list, which holds anything; an array.array, a compact array of one numeric type from the standard library; and a NumPy ndarray, one type with n dimensions and mathematics built in.

2. What does a[1:4] give? Items at indexes 1, 2 and 3. The stop is excluded.

3. How do you reverse an array in one expression? a[::-1].

4. a[5] on a three item array raises an error, but a[1:100] does not. Why? Indexing asks for one item that must exist. Slicing asks for whatever is in a range and clips to what there is, so that code can take a piece of something of unknown length.

5. What is the difference between slicing a list and slicing a NumPy array? A list slice is a new list, so writing to it leaves the original alone. A NumPy slice is a view onto the same memory, so writing to it changes the original.

6. How do you find out whether an array is a view or owns its data? x.base is the array it looks into, and it is None when the array owns its own memory.

7. What is wrong with a = a.sort()? a.sort() sorts in place and returns None, so a becomes None. Use b = np.sort(a) for a sorted copy, or a.sort() on its own line.

8. Why does np.append not grow the array? A NumPy array is one fixed block of memory. np.append makes a new, bigger array and copies into it, which is why appending in a loop is slow and building a list first is right.

9. What is the difference between arange(0, 1, 0.25) and linspace(0, 1, 5)? The first takes a step of 0.25 and stops before 1, giving four values. The second asks for five values evenly spaced and includes 1.

element by element, m * n
[[ 5 12]
 [21 32]]
matrix product, m @ n
[[19 22]
 [43 50]]
the top left of the product is 1*5 + 2*7 = 19

The universal functions

A universal function, or ufunc, is a mathematical function that NumPy applies to every element. There is one for everything the mathematics paper needs.

import numpy as np

a = np.array([1.0, 4.0, 9.0, 16.0])
angles = np.array([0.0, np.pi / 6, np.pi / 4, np.pi / 2])

print("sqrt     ", np.sqrt(a))
print("square   ", np.square(a))
print("exp      ", np.round(np.exp(np.array([0.0, 1.0, 2.0])), 4))
print("log      ", np.round(np.log(a), 4))
print("log10    ", np.log10(np.array([1.0, 10.0, 100.0, 1000.0])))
print("sin      ", np.round(np.sin(angles), 4))
print("cos      ", np.round(np.cos(angles), 4))
print("degrees  ", np.degrees(angles))
print("abs      ", np.abs(np.array([-3, 4, -5])))
print("floor    ", np.floor(np.array([1.2, 1.8, -1.2])))
print("ceil     ", np.ceil(np.array([1.2, 1.8, -1.2])))
print("round    ", np.round(np.array([1.24, 1.25, 1.26]), 1))
print("power    ", np.power(np.array([2, 3, 4]), 3))

sqrt      [1. 2. 3. 4.]
square    [  1.  16.  81. 256.]
exp       [1.     2.7183 7.3891]
log       [0.     1.3863 2.1972 2.7726]
log10     [0. 1. 2. 3.]
sin       [0.     0.5    0.7071 1.    ]
cos       [1.     0.866  0.7071 0.    ]
degrees   [ 0. 30. 45. 90.]
abs       [3 4 5]
floor     [ 1.  1. -2.]
ceil      [ 2.  2. -1.]
round     [1.2 1.2 1.3]
power     [ 8 27 64]

np.round(x, 4) is used above so the output fits the page and does not depend on how many digits a version chooses to print. In your own journal print them unrounded once, so you have seen the full values.

Look at the round row: 1.24 gave 1.2, 1.26 gave 1.3, and 1.25 gave 1.2, not 1.3. That is not a bug. NumPy, like Python's own round, rounds a value sitting exactly halfway to the nearest even last digit, so 1.25 goes down to 1.2 and 2.25 would go up to 2.2 as well. It is called round half to even, and it exists because always rounding halves upward makes a long column of figures drift high. Expect it, and do not treat it as an error in your program.

sin 30 degrees is 0.5, and the second value in the sin row is exactly that, which is the check that the angles were given in radians. NumPy's trigonometric functions take radians, never degrees. np.radians() converts if your input is in degrees.

Aggregate functions, and the axis

An aggregate reduces many numbers to one. On a two dimensional array you can reduce down the columns, along the rows, or over everything.

import numpy as np

marks = np.array([[78, 65, 80],
                  [55, 72, 60],
                  [90, 88, 95],
                  [40, 51, 45]])

print(marks)
print("total of everything      ", marks.sum())
print("mean of everything       ", round(marks.mean(), 4))
print("axis=0, down the columns ", marks.sum(axis=0))
print("axis=1, along the rows   ", marks.sum(axis=1))
print("each student's mean      ", marks.mean(axis=1))
print("each subject's highest   ", marks.max(axis=0))
print("each subject's lowest    ", marks.min(axis=0))
print("standard deviation       ", round(marks.std(), 4))
print("row 2 is the best student, index", marks.sum(axis=1).argmax())

[[78 65 80]
 [55 72 60]
 [90 88 95]
 [40 51 45]]
total of everything       819
mean of everything        68.25
axis=0, down the columns  [263 276 280]
axis=1, along the rows    [223 187 273 136]
each student's mean       [74.33333333 62.33333333 91.         45.33333333]
each subject's highest    [90 88 95]
each subject's lowest     [40 51 45]
standard deviation        17.5979
row 2 is the best student, index 2

axis=0 goes down, axis=1 goes across. That is the fact to memorise, and here is the way to keep it straight: the axis you name is the one that disappears. marks has shape (4, 3); marks.sum(axis=0) removes the 4 and leaves 3 numbers, one per column.

Check the first column by hand: 78 + 55 + 90 + 40 = 263, and that is the first number in the axis=0 row.

Broadcasting

Two arrays of different shapes can still be combined, if one of them can be stretched to fit. That stretching is called broadcasting, and it is what makes a * 2 work: the 2 is broadcast to every element.

The rule, in one line: compare the shapes from the right, and a dimension of 1, or a missing dimension, is stretched.

import numpy as np

marks = np.array([[78, 65, 80],
                  [55, 72, 60],
                  [90, 88, 95]])
weights = np.array([2, 1, 1])

print("marks shape  ", marks.shape)
print("weights shape", weights.shape)
print("weighted marks, each column scaled")
print(marks * weights)
print("add 5 to everybody")
print(marks + 5)
print("subtract each subject's mean from its column")
print(np.round(marks - marks.mean(axis=0), 4))

marks shape   (3, 3)
weights shape (3,)
weighted marks, each column scaled
[[156  65  80]
 [110  72  60]
 [180  88  95]]
add 5 to everybody
[[ 83  70  85]
 [ 60  77  65]
 [ 95  93 100]]
subtract each subject's mean from its column
[[  3.6667 -10.       1.6667]
 [-19.3333  -3.     -18.3333]
 [ 15.6667  13.      16.6667]]

And when the shapes cannot be made to fit, NumPy says so rather than guessing:

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([1, 2])
print(a + b)

ValueError: operands could not be broadcast together with shapes (2,3) (2,)

Read that message: it names both shapes. (2, 3) and (2,) compared from the right gives 3 against 2, and neither is 1, so there is nothing to stretch. b of shape (3,) would have worked.

Part two: aliasing, views and copying

This is MU's third bullet and it is the part of this practical that gets asked about. There are three cases, not two, and they have to be told apart by writing through each one and looking at the original.

An alias is a second name

import numpy as np

a = np.array([1, 2, 3, 4, 5])
b = a

print("a is", a)
print("b is", b)
print("are they the same object?", b is a)
print("same id?", id(a) == id(b))

b[0] = 999
print("after b[0] = 999")
print("a is", a)
print("b is", b)

a is [1 2 3 4 5]
b is [1 2 3 4 5]
are they the same object? True
same id? True
after b[0] = 999
a is [999   2   3   4   5]
b is [999   2   3   4   5]

There is one array in that program and two names for it. b = a copies nothing at all; it writes the same reference into a second name. So of course changing one changes the other, and b is a proves they are the same object.

This is not special to NumPy. A Python list behaves identically, and it is the source of one of the nastiest bugs a beginner writes:

first = [1, 2, 3]
second = first
second.append(4)
print("first ", first)
print("second", second)
print("the same object?", second is first)

first  [1, 2, 3, 4]
second [1, 2, 3, 4]
the same object? True

A view is a window

import numpy as np

a = np.array([1, 2, 3, 4, 5, 6])
window = a[1:4]
reshaped = a.reshape(2, 3)

print("a       ", a)
print("window  ", window, " is it a view?", window.base is not None)
print("reshaped\n", reshaped, " is it a view?", reshaped.base is not None)

window[0] = 999
print("after window[0] = 999, a is", a)

reshaped[1, 2] = 777
print("after reshaped[1, 2] = 777, a is", a)
print("are they the same object? ", window is a, reshaped is a)

a        [1 2 3 4 5 6]
window   [2 3 4]  is it a view? True
reshaped
 [[1 2 3]
 [4 5 6]]  is it a view? True
after window[0] = 999, a is [  1 999   3   4   5   6]
after reshaped[1, 2] = 777, a is [  1 999   3   4   5 777]
are they the same object?  False False

Note the last line: a view is not the same object as the array, so is says False, and yet writing through it still changes the array. That is exactly why is is not the test here. base is.

A copy is a new array

import numpy as np

a = np.array([1, 2, 3, 4, 5])

shallow_name = a
sliced_view = a[:]
real_copy = a.copy()
also_a_copy = np.array(a)

for label, other in [("b = a          ", shallow_name),
                     ("a[:]           ", sliced_view),
                     ("a.copy()       ", real_copy),
                     ("np.array(a)    ", also_a_copy)]:
    print(f"{label} same object {other is a!s:>5}   owns its data {other.base is None!s:>5}")

real_copy[0] = 999
also_a_copy[1] = 888
print("after writing 999 and 888 into the two copies, a is", a)

sliced_view[2] = 777
print("after writing 777 into a[:], a is         ", a)

b = a           same object  True   owns its data  True
a[:]            same object False   owns its data False
a.copy()        same object False   owns its data  True
np.array(a)     same object False   owns its data  True
after writing 999 and 888 into the two copies, a is [1 2 3 4 5]
after writing 777 into a[:], a is          [  1   2 777   4   5]

There is the whole exercise in one output. a.copy() and np.array(a) own their data and leave a alone. a[:] does not, and this is the line that catches people. On a Python list a[:] is the classic way to make a copy. On a NumPy array it is a view. A student who carries the list habit across corrupts their data silently.

Deep copy, and when you actually need it

a.copy() is enough for any array of numbers. It is not enough for an array or a list holding other containers, because copying the outer one still leaves the inner ones shared.

from copy import deepcopy

original = [[1, 2], [3, 4]]
shallow = list(original)
deep = deepcopy(original)

shallow[0][0] = 999
print("after writing through the shallow copy:", original)

deep[1][1] = 888
print("after writing through the deep copy   :", original)
print("the deep one changed only itself      :", deep)

after writing through the shallow copy: [[999, 2], [3, 4]]
after writing through the deep copy   : [[999, 2], [3, 4]]
the deep one changed only itself      : [[1, 2], [3, 888]]

list(original) made a new outer list, but its two slots still refer to the same two inner lists, so writing into shallow[0][0] reached the original. deepcopy copied all the way down. For NumPy numeric arrays this never arises, because the numbers are stored in the array itself rather than referred to.

The one line summary to say at the table

import numpy as np

a = np.arange(6)

for label, other in [("alias  b = a   ", a),
                     ("view   a[1:4]  ", a[1:4]),
                     ("copy   a.copy()", a.copy())]:
    print(f"{label}  is a: {other is a!s:>5}"
          f"   shares memory: {np.shares_memory(other, a)!s:>5}")

alias  b = a     is a:  True   shares memory:  True
view   a[1:4]    is a: False   shares memory:  True
copy   a.copy()  is a: False   shares memory: False

is a true means an alias. False but sharing memory means a view, and false and sharing nothing means a copy. Two tests, three answers.

One caution about base, because [Practical 4: NumPy Slicing, Basic and Advanced Indexing] meets it head on. base says whether an array owns its own buffer, which for a plain slice or a plain copy is the same question as "is this a view of that array". For a subscript that mixes a slice with a list of positions it is not the same question, and base is then not None even though nothing is shared. Where the answer matters, ask np.shares_memory(x, a).

Procedure

1. Save as practical3b.py. Apply +, -, *, /, //, % and ** to an array and

to two arrays, and print each result.

1. Show that list 2 repeats and array 2 multiplies.
2. Apply sqrt, exp, log, sin, cos, abs, floor, ceil and power, and check

that sin of pi over 6 is 0.5.

1. Build a two dimensional array of marks. Take sum, mean, max and min over

everything, then with axis=0 and axis=1. Check one column total by hand.

1. Show broadcasting with a row of weights, and show the shape error when it cannot work.
2. Save as practical3c.py. Make an alias, a view and a copy of one array. For each, print

whether it is the same object and whether it shares memory with the original, then write through it and print the original.

1. Show that a[:] copies a list but views an array.

Result

Every operator and nine mathematical functions were applied element by element; sin of pi over 6 came out 0.5, confirming radians. Column totals matched the hand check 78 + 55 + 90 + 40 = 263. Broadcasting worked for shapes (3, 3) and (3,) and raised ValueError for (2, 3) and (2,). Writing through the alias and through the view both changed the original; writing through a.copy() and np.array(a) did not; and a[:] behaved as a view on the array and as a copy on the list.

Where marks are lost

• Using a loop to apply a function to an array. The whole point is that you do not.
• Calling a * b matrix multiplication. It is element by element. @ is the product.
• Giving degrees to np.sin. It takes radians.
• Getting axis backwards. The axis you name is the one that disappears.
• Calling a view a copy. a[1:4] is a view, and writing to it changes a.
• Using a[:] to copy an array out of list habit. On an array it is a view.
• Testing with is to tell a view from a copy. A view is a different object; use

np.shares_memory.

• Showing only the code. Aliasing is only proved by printing the original after the

write.

For the journal

Two entries under practical 3. For the mathematical functions: the aim, a table of the operators with one example each, the ufunc program and its output, and the axis table of marks with one column total checked by hand. One sentence on broadcasting: shapes are compared from the right and a dimension of 1 is stretched.

For aliasing and copying: the aim, the three row table of alias, view and copy, then the program that writes through each one, and the original printed after each write. Record np.shares_memory for each of the three, because that is the line that proves the table. The conclusion in one sentence: b = a makes a second name, a slice makes a window, and only copy() makes a new array, so the first two change the original and the third does not.

Quick revision

• An operation on an array applies to every element. No loop.
• list 2 repeats the list; array 2 multiplies each element.
• Between two arrays every operator is element by element. a * b is NOT the matrix

product; a @ b is.

• ufuncs: sqrt, square, exp, log, log10, sin, cos, abs, floor, ceil,

round, power. Trigonometry takes radians; np.radians() converts.

• Aggregates: sum, mean, min, max, std, argmax.

axis=0 goes down the columns and axis=1 along the rows, and the axis named is the one that disappears.

• Broadcasting: compare shapes from the right; a 1 or a missing dimension stretches.

Otherwise ValueError, and the message names both shapes.

• Alias b = a: one array, two names. b is a is True.
• View a[1:4], a.reshape(), a.T: different object, same memory.
• Copy a.copy() or np.array(a): new memory.
• The test is np.shares_memory(x, a). x.base is a quick indicator only: on a mixed

subscript such as m[1:, [0, 2]] the base is a temporary, so it is not None while nothing is shared.

• Writing through an alias or a view changes the original. Through a copy it does not.
• a[:] copies a list and views an array.
• deepcopy is only needed for containers holding containers.

Questions you should be able to answer

1. Why does an array not need a loop to add 1 to every element? Because arithmetic on a NumPy array is applied element by element by the library itself, in compiled code. That is called vectorising.

2. What does [1, 2] 3 give, and what does np.array([1, 2]) 3 give? [1, 2, 1, 2, 1, 2], because multiplying a list repeats it, and [3 6], because multiplying an array scales every element.

3. What is the difference between a b and a @ b? a b multiplies element by element. a @ b is the matrix product.

4. marks has shape (4, 3). What does marks.sum(axis=0) give? An array of shape (3,): one total per column, that is, per subject. The axis named is the one that disappears.

5. State the broadcasting rule. Compare the shapes from the right. A dimension that is 1, or absent, is stretched to match. If two dimensions differ and neither is 1, it is an error.

6. What are the three ways a second name can relate to an array? An alias, which is the same object; a view, a different object sharing the same memory; and a copy, a different object with its own memory.

7. How do you tell a view from a copy at the keyboard? np.shares_memory(x, a), which is True exactly when writing to one is seen in the other. x.base is a quick indicator of whether x owns its buffer, but on a mixed subscript the base is a temporary array, so it can be not None while nothing at all is shared.

8. Why is b = a never a copy? Because assignment binds a name to the object that is already there. Nothing is duplicated, so both names reach one array.

9. A student writes backup = a[:] and then changes backup. What happens? The array a changes too, because on a NumPy array a[:] is a view. On a Python list the same line would have made a real copy, which is why the mistake is so easy.

10. When do you need deepcopy rather than copy? Only when the container holds other containers. copy duplicates the outer one and leaves the inner ones shared. An array of numbers never needs it.

The shape a slice returns, which is the part students get wrong

import numpy as np

m = np.arange(1, 25).reshape(4, 6)

print("m         shape", m.shape, "ndim", m.ndim)
print("m[1]      shape", m[1].shape, "ndim", m[1].ndim, "  one index removes a dimension")
print("m[1:2]    shape", m[1:2].shape, "ndim", m[1:2].ndim, "  a slice KEEPS it")
print("m[1, 3]   shape", np.shape(m[1, 3]), "a single element, no dimensions at all")
print("m[:, 2]   shape", m[:, 2].shape, "  a column comes back as a flat row")
print("m[:, 2:3] shape", m[:, 2:3].shape, "  as a column, because it is a slice")

m         shape (4, 6) ndim 2
m[1]      shape (6,) ndim 1   one index removes a dimension
m[1:2]    shape (1, 6) ndim 2   a slice KEEPS it
m[1, 3]   shape () a single element, no dimensions at all
m[:, 2]   shape (4,)   a column comes back as a flat row
m[:, 2:3] shape (4, 1)   as a column, because it is a slice

An integer index removes that dimension. A slice keeps it. m[1] is a one dimensional array of six numbers; m[1:2] is a two dimensional array with one row. They print differently and they behave differently in arithmetic, and knowing which you have is what prevents a broadcasting error later.

Note also that m[:, 2] gives a flat array, not a column. If you need it shaped as a column, slice instead of indexing: m[:, 2:3].

The ellipsis

... stands for "as many full slices as are needed here". On a three dimensional array it saves writing the colons out:

import numpy as np

cube = np.arange(24).reshape(2, 3, 4)

print("cube.shape", cube.shape)
print("cube[0, :, :] and cube[0, ...] are the same:")
print(cube[0, ...])
print("the last element along the last axis, cube[..., -1]")
print(cube[..., -1])
print("same thing written out, cube[:, :, -1]")
print(cube[:, :, -1])
print("equal?", np.array_equal(cube[..., -1], cube[:, :, -1]))

cube.shape (2, 3, 4)
cube[0, :, :] and cube[0, ...] are the same:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
the last element along the last axis, cube[..., -1]
[[ 3  7 11]
 [15 19 23]]
same thing written out, cube[:, :, -1]
[[ 3  7 11]
 [15 19 23]]
equal? True

Part two: advanced indexing

With an array of integers

Give NumPy a list of positions and it gives back those elements, in the order you asked for, including repeats.

import numpy as np

a = np.array([10, 20, 30, 40, 50, 60, 70])

print("a                 ", a)
print("a[[0, 2, 4]]      ", a[[0, 2, 4]])
print("a[[4, 2, 0]]      ", a[[4, 2, 0]], "the order you asked for")
print("a[[1, 1, 1]]      ", a[[1, 1, 1]], "repeats are allowed")
print("a[[-1, -2]]       ", a[[-1, -2]], "negatives work too")
print("shares with a?    ", np.shares_memory(a[[0, 2, 4]], a))

a                  [10 20 30 40 50 60 70]
a[[0, 2, 4]]       [10 30 50]
a[[4, 2, 0]]       [50 30 10] the order you asked for
a[[1, 1, 1]]       [20 20 20] repeats are allowed
a[[-1, -2]]        [70 60] negatives work too
shares with a?     False

Three things a slice cannot do are in that output. Out of order, repeated, and from any list of positions. That is what advanced indexing buys, and the price is the copy.

On two dimensions, two index arrays are paired element by element:

import numpy as np

m = np.arange(1, 13).reshape(3, 4)
print(m)

rows = [0, 1, 2]
cols = [3, 2, 0]
print("m[rows, cols] pairs them up:", m[rows, cols])
print("which is m[0,3], m[1,2], m[2,0] =", m[0, 3], m[1, 2], m[2, 0])

print("whole rows, in a chosen order")
print(m[[2, 0]])

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
m[rows, cols] pairs them up: [4 7 9]
which is m[0,3], m[1,2], m[2,0] = 4 7 9
whole rows, in a chosen order
[[ 9 10 11 12]
 [ 1  2  3  4]]

Two index arrays are zipped, not crossed. m[[0, 1, 2], [3, 2, 0]] gives three elements, not a three by three block. Expecting a block is the commonest wrong answer here. To get the block, index the rows and then the columns with a slice between:

import numpy as np

m = np.arange(1, 13).reshape(3, 4)

print("zipped, three elements :", m[[0, 2], [1, 3]])
print("crossed, a 2 by 2 block:")
print(m[np.ix_([0, 2], [1, 3])])
print("or with a reshaped row index:")
print(m[[[0], [2]], [1, 3]])

zipped, three elements : [ 2 12]
crossed, a 2 by 2 block:
[[ 2  4]
 [10 12]]
or with a reshaped row index:
[[ 2  4]
 [10 12]]

With a boolean mask

A boolean array of the same shape picks out the elements where it is True. This is the form that is actually used in real work, because the mask is usually a comparison.

import numpy as np

a = np.array([15, 42, 8, 23, 4, 16, 50])

mask = a > 20
print("a          ", a)
print("a > 20     ", mask, "a boolean array of the same length")
print("a[a > 20]  ", a[mask])
print("how many   ", mask.sum(), "because True counts as 1")
print("any? all?  ", mask.any(), mask.all())
print("even ones  ", a[a % 2 == 0])
print("between    ", a[(a > 10) & (a < 45)])
print("either or  ", a[(a < 10) | (a > 45)])
print("not        ", a[~mask])
print("shares?    ", np.shares_memory(a[mask], a))

a           [15 42  8 23  4 16 50]
a > 20      [False  True False  True False False  True] a boolean array of the same length
a[a > 20]   [42 23 50]
how many    3 because True counts as 1
any? all?   True False
even ones   [42  8  4 16 50]
between     [15 42 23 16]
either or   [ 8  4 50]
not         [15  8  4 16]
shares?     False

Use &, | and ~, not and, or and not. The words work on one True or False at a time and cannot handle a whole array; the symbols work element by element. And the brackets around each comparison are not optional, because & binds more tightly than >.

import numpy as np

a = np.array([15, 42, 8])
print(a[a > 10 and a < 45])

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

Read that message. It is one of NumPy's most recognisable errors and it always means the same thing: a word operator was used where a symbol was needed.

A mask can also be assigned through, and that is how a whole class of values is changed at once:

import numpy as np

marks = np.array([78, 32, 65, 18, 90, 39])
print("before      ", marks)

marks[marks < 40] = 0
print("fails zeroed", marks)

grades = np.where(marks >= 75, "distinction", np.where(marks >= 40, "pass", "fail"))
print("grades      ", grades)

before       [78 32 65 18 90 39]
fails zeroed [78  0 65  0 90  0]
grades       ['distinction' 'fail' 'pass' 'fail' 'distinction' 'fail']

np.where(condition, a, b) picks from a where the condition is True and from b where it is False, element by element. Nested, as above, it is a whole grade ladder in one line.

Mixing the two

When a slice and an index array appear in the same subscript, the result is a copy, because advanced indexing is present.

import numpy as np

m = np.arange(1, 13).reshape(3, 4)

mixed = m[1:, [0, 2]]
print("m[1:, [0, 2]]")
print(mixed)
print("shares memory with m?", np.shares_memory(mixed, m))

mixed[0, 0] = 999
print("after writing 999 into it, m is unchanged:")
print(m)

m[1:, [0, 2]]
[[ 5  7]
 [ 9 11]]
shares memory with m? False
after writing 999 into it, m is unchanged:
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

The test that lies, and the one that does not

Earlier chapters used x.base is None to ask whether an array owns its memory, and for a plain slice or a plain copy it answers correctly. On a mixed subscript it does not answer the question you think you asked, and it is worth seeing once:

import numpy as np

m = np.arange(1, 13).reshape(3, 4)
mixed = m[1:, [0, 2]]

print("mixed.base is None?          ", mixed.base is None)
print("but np.shares_memory(mixed, m)", np.shares_memory(mixed, m))
print("and mixed.base is actually:")
print(mixed.base)

mixed.base is None?           False
but np.shares_memory(mixed, m) False
and mixed.base is actually:
[[ 5  9]
 [ 7 11]]

mixed.base is not m. It is a temporary array NumPy built while working the subscript out, and mixed is a view onto that, which is itself a copy. So base is not None is true and yet nothing is shared with m.

np.shares_memory(x, y) is the test that answers the real question, which is whether writing into one will be seen in the other. Use base as a quick look at whether an array owns its buffer, and np.shares_memory whenever the answer matters.

Summary of every form

Procedure

1. Save as practical4a.py. Build a 4 by 6 array with np.arange(1, 25).reshape(4, 6).
2. Take one row, one column, one element and two blocks by slicing, printing each labelled.
3. Print the shape of m[1] and of m[1:2] and say why they differ.
4. Use ... on a three dimensional array and prove it equals the written out form.
5. Index with a list of positions, out of order and with a repeat.
6. Index a two dimensional array with two lists and show they are zipped, then get the

crossed block with np.ix_.

1. Build a boolean mask from a comparison, combine masks with &, | and ~, and assign

through a mask.

1. For each result print np.shares_memory(result, m), and write through it to show what

changes.

Result

Slicing and integer indexing returned views: writing 999 through a[2:6] changed the array. A list of positions, a boolean mask and a mixed subscript all returned copies: writing through them left the array unchanged. m[1] had shape (6,) and m[1:2] had shape (1, 6), confirming that an integer removes a dimension and a slice keeps it. m[[0, 1, 2], [3, 2, 0]] gave three elements, the pairs (0,3), (1,2) and (2,0), and np.ix_ gave the crossed block instead.

Where marks are lost

• Not knowing which family is which. Slices are basic and give views; index arrays and

masks are advanced and give copies. That is the exercise.

• Expecting m[[0, 1], [2, 3]] to be a block. It is two elements, zipped.
• Using and, or and not on arrays. It raises the ambiguous truth value error.
• Forgetting the brackets in (a > 10) & (a < 45).
• Expecting m[:, 2] to be a column. It comes back flat; m[:, 2:3] is the column.
• Showing the code and not the memory check. The view against copy claim has to be

demonstrated, by writing through the result and printing the original.

• Trusting base on a mixed subscript. Use np.shares_memory.

For the journal

The aim in MU's words. The two row table of basic against advanced with what each returns. The 4 by 6 array printed once, then every slice labelled with its output. The shape comparison of m[1] and m[1:2] with one sentence on why. Then advanced indexing: the list of positions out of order and repeated, the zipped pair, and the boolean mask with &, | and ~. For each one, the np.shares_memory line and the write through test. The conclusion in one sentence: basic indexing gives a view onto the same memory, advanced indexing gives a copy, so writing through the first changes the original and writing through the second does not.

Quick revision

• Basic indexing: integers, slices, ..., np.newaxis. Returns a view.
• Advanced indexing: a list or array of integers, or a boolean array. Returns a

copy.

• np.shares_memory(x, a) is the honest test of whether writing to x changes a.

x.base is None is a quick look at whether x owns its buffer, and on a mixed subscript its base is a temporary, so it is not None even though nothing is shared.

• An integer index removes a dimension; a slice keeps it. m[1] is (6,), m[1:2] is

(1, 6).

• m[:, 2] is flat. m[:, 2:3] is a column.
• ... fills in as many : as are needed.
• An index array may be out of order, may repeat, and may use negatives.
• Two index arrays are zipped, not crossed. np.ix_(rows, cols) crosses them.
• A boolean mask must be the same shape. Combine with &, |, ~, each comparison in

brackets. and, or, not raise the ambiguous truth value error.

• mask.sum() counts the Trues. a[mask] = 0 assigns through a mask.
• np.where(cond, a, b) chooses element by element and nests.
• A subscript mixing a slice and an index array gives a copy.

Questions you should be able to answer

1. What is the difference between basic and advanced indexing? Basic indexing uses integers and slices and returns a view onto the same memory. Advanced indexing uses an integer array or a boolean array and returns a copy.

2. Why does that difference matter? Because writing to a view changes the original array and writing to a copy does not.

2a. Which test tells you which you have? np.shares_memory(result, original). base is not enough: for m[1:, [0, 2]] the base is a temporary array NumPy built, so it is not None even though the result shares nothing with m.

3. a is [10 20 30 40 50]. What does a[[3, 1, 1]] give? [40 20 20]. An index array gives the elements in the order asked for and may repeat them.

4. m is 3 by 4. What does m[[0, 1], [2, 3]] give? Two elements, m[0, 2] and m[1, 3]. The two lists are paired, not crossed.

5. How do you get the crossed 2 by 2 block instead? m[np.ix_([0, 1], [2, 3])].

6. Why can you not write a[a > 10 and a < 45]? and needs a single True or False and an array of several is ambiguous, so it raises ValueError. Use a[(a > 10) & (a < 45)].

7. What shape does m[1] have, and what shape does m[1:2] have, for a 4 by 6 array? (6,) and (1, 6). The integer removes the first dimension; the slice keeps it with a length of 1.

8. How do you set every mark below 40 to zero? marks[marks < 40] = 0. A mask can be assigned through.

9. How many elements are True in a mask, in one expression? mask.sum(), because True counts as 1.

10. Is m[1:, [0, 2]] a view or a copy, and why? A copy. The subscript contains an index array, so advanced indexing applies to the whole thing.

None of these is a method, so none of them takes brackets. m.shape is the shape; m.shape() raises TypeError: 'tuple' object is not callable. This is the single most common error on this exercise.

import numpy as np

m = np.arange(6).reshape(2, 3)
print(m.shape())

TypeError: 'tuple' object is not callable

The two that ARE methods are m.reshape(...), m.ravel(), m.flatten(), m.astype(...), m.sum() and the other calculations. The rule is simple: an attribute describes the array as it is, and a method does something.

dtype, and what it costs

An array holds one type, and the type decides the memory.

import numpy as np

for dtype in [np.int8, np.int16, np.int32, np.int64,
              np.float32, np.float64, np.bool_]:
    a = np.ones(1000, dtype=dtype)
    print(f"{str(a.dtype):<9} itemsize {a.itemsize}   1000 elements use {a.nbytes:>5} bytes")

int8      itemsize 1   1000 elements use  1000 bytes
int16     itemsize 2   1000 elements use  2000 bytes
int32     itemsize 4   1000 elements use  4000 bytes
int64     itemsize 8   1000 elements use  8000 bytes
float32   itemsize 4   1000 elements use  4000 bytes
float64   itemsize 8   1000 elements use  8000 bytes
bool      itemsize 1   1000 elements use  1000 bytes

The same thousand numbers take 1000 bytes as int8 and 8000 as int64. That is the reason NumPy exists and the reason it asks you to choose.

Changing the type is done with astype, which makes a copy:

import numpy as np

a = np.array([1.7, 2.3, -1.7, 3.9])

print("a          ", a, a.dtype)
print("astype(int)", a.astype(int), a.astype(int).dtype, "  it TRUNCATES, it does not round")
print("np.round   ", np.round(a).astype(int), "  round first to round")
print("a is unchanged:", a)

b = np.array([1, 0, 3, 0])
print("astype(bool)", b.astype(bool), "  zero is False, anything else True")

a           [ 1.7  2.3 -1.7  3.9] float64
astype(int) [ 1  2 -1  3] int64   it TRUNCATES, it does not round
np.round    [ 2  2 -2  4]   round first to round
a is unchanged: [ 1.7  2.3 -1.7  3.9]
astype(bool) [ True False  True False]   zero is False, anything else True

astype(int) truncates towards zero. 1.7 becomes 1 and -1.7 becomes -1, not -2. If you want rounding, round first. Marks are lost here every year.

Reshaping

reshape gives the same data a different shape. The total size must not change.

import numpy as np

a = np.arange(12)

print("a            ", a)
print("reshape(3, 4)")
print(a.reshape(3, 4))
print("reshape(4, 3)")
print(a.reshape(4, 3))
print("reshape(2, 2, 3)")
print(a.reshape(2, 2, 3))
print("reshape(-1, 4), the -1 is worked out for you")
print(a.reshape(-1, 4))
print("reshape(2, -1)")
print(a.reshape(2, -1))
print("shares memory with a?", np.shares_memory(a.reshape(3, 4), a))

a             [ 0  1  2  3  4  5  6  7  8  9 10 11]
reshape(3, 4)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
reshape(4, 3)
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
reshape(2, 2, 3)
[[[ 0  1  2]
  [ 3  4  5]]

 [[ 6  7  8]
  [ 9 10 11]]]
reshape(-1, 4), the -1 is worked out for you
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
reshape(2, -1)
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
shares memory with a? True

A single -1 means "work this one out from the others". It saves arithmetic and it saves a bug when the length changes. Two of them is an error, because then there is nothing to work out from.

import numpy as np

a = np.arange(12)
print(a.reshape(5, 3))

ValueError: cannot reshape array of size 12 into shape (5,3)

Read the message: it names the size and the shape asked for. 5 × 3 = 15 and there are only 12 elements.

reshape returns a view where it can, as the last line of the run above shows. So reshaping is free, and writing into the reshaped array writes into the original.

Flattening, and the one difference that matters

import numpy as np

m = np.arange(1, 7).reshape(2, 3)

print(m)
print("ravel   ", m.ravel(), "   shares memory?", np.shares_memory(m.ravel(), m))
print("flatten ", m.flatten(), "   shares memory?", np.shares_memory(m.flatten(), m))

r = m.ravel()
f = m.flatten()
r[0] = 999
f[1] = 888
print("after writing 999 through ravel and 888 through flatten")
print(m)

[[1 2 3]
 [4 5 6]]
ravel    [1 2 3 4 5 6]    shares memory? True
flatten  [1 2 3 4 5 6]    shares memory? False
after writing 999 through ravel and 888 through flatten
[[999   2   3]
 [  4   5   6]]

ravel gives a view where it can, and flatten always gives a copy. They print the same thing, so the only way to tell them apart is to write through them, which the run above does. Use ravel when you only want to read, and flatten when you want your own copy.

Transpose, and the axes of a three dimensional array

import numpy as np

m = np.arange(1, 7).reshape(2, 3)
cube = np.arange(24).reshape(2, 3, 4)

print("m shape", m.shape)
print(m)
print("m.T shape", m.T.shape)
print(m.T)
print("m.T shares memory with m?", np.shares_memory(m.T, m))
print()
print("cube shape       ", cube.shape)
print("cube.T shape     ", cube.T.shape, "  T reverses ALL the axes")
print("transpose(1, 0, 2)", cube.transpose(1, 0, 2).shape, " or name the order you want")
print("swapaxes(0, 1)   ", cube.swapaxes(0, 1).shape)

m shape (2, 3)
[[1 2 3]
 [4 5 6]]
m.T shape (3, 2)
[[1 4]
 [2 5]
 [3 6]]
m.T shares memory with m? True

cube shape        (2, 3, 4)
cube.T shape      (4, 3, 2)   T reverses ALL the axes
transpose(1, 0, 2) (3, 2, 4)  or name the order you want
swapaxes(0, 1)    (3, 2, 4)

For two dimensions the transpose is what you expect: rows become columns. For three, T reverses every axis, so (2, 3, 4) becomes (4, 3, 2). When you want something else, name the new order with transpose or swap one pair with swapaxes.

The transpose is a view, which surprises people: no data moves at all. NumPy simply records that the axes are to be read in a different order.

Adding and removing a dimension

import numpy as np

a = np.array([1, 2, 3])

print("a               shape", a.shape)
print("a[np.newaxis, :] shape", a[np.newaxis, :].shape, "a row")
print(a[np.newaxis, :])
print("a[:, np.newaxis] shape", a[:, np.newaxis].shape, "a column")
print(a[:, np.newaxis])
print("np.expand_dims   shape", np.expand_dims(a, 0).shape, "the same thing, named")

fat = np.array([[[1, 2, 3]]])
print("fat             shape", fat.shape)
print("squeeze         shape", fat.squeeze().shape, "every length 1 axis dropped")

a               shape (3,)
a[np.newaxis, :] shape (1, 3) a row
[[1 2 3]]
a[:, np.newaxis] shape (3, 1) a column
[[1]
 [2]
 [3]]
np.expand_dims   shape (1, 3) the same thing, named
fat             shape (1, 1, 3)
squeeze         shape (3,) every length 1 axis dropped

np.newaxis inserts an axis of length 1 wherever you put it, which is how a flat array is turned into a row or into a column. squeeze does the opposite and drops every axis of length 1. Both are views.

The whole analysis, as one program

This is the program for the journal: it takes any array and reports everything.

import numpy as np


def describe(name, a):
    print(f"--- {name}")
    print(a)
    print(f"  ndim      {a.ndim}")
    print(f"  shape     {a.shape}")
    print(f"  size      {a.size}   (the shape multiplied out)")
    print(f"  dtype     {a.dtype}")
    print(f"  itemsize  {a.itemsize} bytes")
    print(f"  nbytes    {a.nbytes} bytes  ({a.size} x {a.itemsize})")
    print(f"  T shape   {a.T.shape}")


describe("one dimension, 4 integers", np.array([10, 20, 30, 40]))
describe("two dimensions, 2 by 3 floats", np.array([[1.5, 2.5, 3.5], [4.5, 5.5, 6.5]]))
describe("three dimensions, 2 by 2 by 2", np.arange(8).reshape(2, 2, 2))

--- one dimension, 4 integers
[10 20 30 40]
  ndim      1
  shape     (4,)
  size      4   (the shape multiplied out)
  dtype     int64
  itemsize  8 bytes
  nbytes    32 bytes  (4 x 8)
  T shape   (4,)
--- two dimensions, 2 by 3 floats
[[1.5 2.5 3.5]
 [4.5 5.5 6.5]]
  ndim      2
  shape     (2, 3)
  size      6   (the shape multiplied out)
  dtype     float64
  itemsize  8 bytes
  nbytes    48 bytes  (6 x 8)
  T shape   (3, 2)
--- three dimensions, 2 by 2 by 2
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
  ndim      3
  shape     (2, 2, 2)
  size      8   (the shape multiplied out)
  dtype     int64
  itemsize  8 bytes
  nbytes    64 bytes  (8 x 8)
  T shape   (2, 2, 2)

Procedure

1. Save as practical4c.py. Build arrays of zero, one, two and three dimensions.
2. For each, print ndim, shape and size, and confirm ndim equals len(shape) and

size is the shape multiplied out.

1. Print dtype, itemsize and nbytes, and check that nbytes is size times

itemsize.

1. Build the same thousand values as int8, int32, int64, float32 and float64 and

compare nbytes.

1. Use astype and show that converting a float to an int truncates rather than rounds.
2. Reshape one array three ways, use -1 once, and show the size mismatch error.
3. Compare ravel with flatten by writing through each one.
4. Print T for a two and a three dimensional array and show it is a view.
5. Add an axis with np.newaxis to make a row and a column, and drop axes with squeeze.
6. Write the describe function and run it on three arrays.

Result

ndim equalled len(shape) for every array, and size equalled the shape multiplied out, 2 × 3 × 4 = 24 for the three dimensional case. nbytes equalled size times itemsize in every run. int8 used 1000 bytes for a thousand elements against 8000 for int64. astype(int) turned 1.7 into 1 and -1.7 into -1, confirming truncation. reshape(5, 3) on 12 elements raised ValueError. ravel shared memory with the array and flatten did not: writing 999 through ravel changed the array and writing 888 through flatten did not. T was a view for both two and three dimensions, and cube.T turned (2, 3, 4) into (4, 3, 2).

Where marks are lost

• Writing m.shape() with brackets. These are attributes, not methods.
• Confusing shape with size. Shape is a tuple, size is one number.
• Saying astype(int) rounds. It truncates towards zero.
• Claiming ravel and flatten are the same. One is a view, one is a copy, and only a

write through each one shows it.

• Expecting cube.T to swap only the first two axes. It reverses all of them.
• Reshaping to a size that does not match and not being able to read the error.
• Copying a book's int64 instead of recording what your own machine printed.

For the journal

The aim in MU's words. The three word table of dimension, shape and size. The describe function and its output for arrays of one, two and three dimensions, which covers every attribute in one place. Then the nbytes = size × itemsize check written out with your own machine's numbers, the dtype memory comparison, and the ravel against flatten write through test. The conclusion in one sentence: ndim is the length of shape, size is the shape multiplied out, nbytes is size × itemsize, and reshape, ravel and T are views while flatten and astype are copies.

Quick revision

• dimension is a direction, shape is the length in each direction, size is the

total count.

• ndim equals len(shape). size is the shape multiplied out.
• nbytes is always size × itemsize.
• dtype is one type for the whole array. itemsize is 8 for int64, 4 for int32,

1 for int8.

• These are attributes, so no brackets: ndim, shape, size, dtype, itemsize,

nbytes, T, flags.

• astype makes a copy and truncates when going from float to int. Round first if you

want rounding.

• reshape keeps the size and returns a view. One -1 is worked out for you; two is an

error.

• ravel is a view where it can be; flatten is always a copy.
• T is a view. On three dimensions it reverses all the axes; use transpose or

swapaxes to choose.

• np.newaxis adds an axis of length 1; squeeze removes every axis of length 1.

Questions you should be able to answer

1. What is the difference between shape and size? Shape is a tuple giving the length in each direction. Size is one number, the total count of elements, which is the shape multiplied out.

2. How is ndim related to shape? ndim is the length of the shape tuple.

3. An array has shape (3, 4) and dtype int64. What is nbytes? 3 × 4 = 12 elements, and 12 × 8 = 96 bytes.

4. Why does m.shape() fail? shape is an attribute holding a tuple, not a method. The brackets try to call a tuple.

5. What does np.array([1.7, -1.7]).astype(int) give? [1 -1]. It truncates towards zero rather than rounding.

6. What does the -1 in reshape(-1, 4) mean? Work that length out from the size and the other dimensions. Only one -1 is allowed.

7. What is the difference between ravel and flatten? Both give a flat array. ravel returns a view where possible, so writing to it changes the original; flatten always returns a copy.

8. Is the transpose a copy? No, it is a view. No data moves; NumPy records that the axes are read in a different order.

9. cube has shape (2, 3, 4). What shape is cube.T? (4, 3, 2). T reverses every axis.

10. How do you turn a flat array of three numbers into a column? a[:, np.newaxis], which gives shape (3, 1).

Look at the last three rows. The power is the number of digits, not always 3. Every single digit number is an Armstrong number, because any number to the power 1 is itself. A function written for three digits only gets 9474 and 8208 wrong and 9 wrong too.

The function

def is_armstrong(number):
    """True when the digits raised to the count of digits sum to the number."""
    digits = str(abs(number))
    power = len(digits)
    total = sum(int(d) ** power for d in digits)
    return total == abs(number)


for value in [153, 370, 371, 407, 123, 9474, 8208, 9, 0, 1, 100]:
    print(f"{value:>5}  armstrong? {is_armstrong(value)}")

  153  armstrong? True
  370  armstrong? True
  371  armstrong? True
  407  armstrong? True
  123  armstrong? False
 9474  armstrong? True
 8208  armstrong? True
    9  armstrong? True
    0  armstrong? True
    1  armstrong? True
  100  armstrong? False

Three lines do the work. str(abs(number)) gives the digits as characters, power = len(digits) counts them, and the sum(...) adds each digit raised to that power.

Showing the working, which is what the journal needs

A function that answers yes or no is correct. A function that shows the sum is a better journal entry, because the examiner can see that you know what is being computed.

def armstrong_working(number):
    digits = str(abs(number))
    power = len(digits)
    parts = [f"{d}^{power}" for d in digits]
    values = [int(d) ** power for d in digits]
    total = sum(values)
    sums = " + ".join(str(v) for v in values)
    verdict = "IS an Armstrong number" if total == abs(number) else "is not"
    return f"{number}: {' + '.join(parts)} = {sums} = {total}, so {number} {verdict}"


for value in [153, 9474, 8208, 123, 9]:
    print(armstrong_working(value))

153: 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153, so 153 IS an Armstrong number
9474: 9^4 + 4^4 + 7^4 + 4^4 = 6561 + 256 + 2401 + 256 = 9474, so 9474 IS an Armstrong number
8208: 8^4 + 2^4 + 0^4 + 8^4 = 4096 + 16 + 0 + 4096 = 8208, so 8208 IS an Armstrong number
123: 1^3 + 2^3 + 3^3 = 1 + 8 + 27 = 36, so 123 is not
9: 9^1 = 9 = 9, so 9 IS an Armstrong number

Check one against the table by hand: for 8208 the parts are 8^4, 2^4, 0^4, 8^4, which is 4096 + 16 + 0 + 4096, and 4096 + 16 + 0 + 4096 = 8208.

Without converting to a string

An examiner may ask for it with arithmetic only, which is the same digit peeling as [Practical 2: the Fibonacci Series, and the Sum of the Digits].

def is_armstrong_arithmetic(number):
    n = abs(number)
    power = 0
    counting = n
    while counting > 0:
        power += 1
        counting //= 10
    if n == 0:
        power = 1

    total = 0
    left = n
    while left > 0:
        total += (left % 10) ** power
        left //= 10

    return total == n


for value in [153, 9474, 8208, 123, 9, 0]:
    print(value, is_armstrong_arithmetic(value))

153 True
9474 True
8208 True
123 False
9 True
0 True

Two loops: the first counts the digits, the second raises and adds them. The if n == 0 guard is needed because zero has no digits to count but is one digit long.

Every Armstrong number up to 10000

def is_armstrong(number):
    digits = str(number)
    power = len(digits)
    return sum(int(d) ** power for d in digits) == number


found = [n for n in range(10000) if is_armstrong(n)]
print("how many:", len(found))
print(found)

how many: 17
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407, 1634, 8208, 9474]

That list is worth putting in the journal, because it makes a point no single test does. There are only 17 Armstrong numbers below 10000: the ten single digit numbers 0 to 9, then nothing at all until 153, then four in the whole three digit range (153, 370, 371, 407), then three in the whole four digit range (1634, 8208, 9474).

Note 1634, which is in that list and is not in the table above: 1^4 + 6^4 + 3^4 + 4^4 = 1 + 1296 + 81 + 256 = 1634. A program written for three digits misses it, and so does a student who memorised four examples.

Part two: the palindrome

The definition

A palindrome reads the same forwards and backwards. For a number, 121 is one and 123 is not. For a string, "level" is one, and "Madam" is one once case is ignored, and "A man a plan a canal Panama" is one once case, spaces and punctuation are ignored.

MU's row does not say whether she means a number or a string, so a complete answer does both.

For a number

def is_palindrome_number(number):
    """True when the number reads the same in reverse."""
    text = str(abs(number))
    return text == text[::-1]


for value in [121, 123, 1221, 7, 10, 1001, -121]:
    print(f"{value:>6}  reversed {str(abs(value))[::-1]:>6}  palindrome? "
          f"{is_palindrome_number(value)}")

   121  reversed    121  palindrome? True
   123  reversed    321  palindrome? False
  1221  reversed   1221  palindrome? True
     7  reversed      7  palindrome? True
    10  reversed     01  palindrome? False
  1001  reversed   1001  palindrome? True
  -121  reversed    121  palindrome? True

text[::-1] is the reversed string, and comparing a string with its own reverse is the whole test. Note what abs does to -121: it makes the answer yes. Whether a negative number can be a palindrome is a matter of definition, so say which you chose. Written strictly, "-121" reversed is "121-", so it is not one, and dropping abs gives that answer instead.

For a string

def is_palindrome_text(text):
    """True when the letters and digits read the same in reverse, ignoring case."""
    cleaned = "".join(ch.lower() for ch in text if ch.isalnum())
    return cleaned == cleaned[::-1]


tests = ["level", "Madam", "Munotes", "A man, a plan, a canal: Panama",
         "Was it a car or a cat I saw?", "hello world", "", "a"]
for text in tests:
    cleaned = "".join(ch.lower() for ch in text if ch.isalnum())
    print(f"{text!r:<35} cleaned {cleaned!r:<25} palindrome? {is_palindrome_text(text)}")

'level'                             cleaned 'level'                   palindrome? True
'Madam'                             cleaned 'madam'                   palindrome? True
'Munotes'                           cleaned 'munotes'                 palindrome? False
'A man, a plan, a canal: Panama'    cleaned 'amanaplanacanalpanama'   palindrome? True
'Was it a car or a cat I saw?'      cleaned 'wasitacaroracatisaw'     palindrome? True
'hello world'                       cleaned 'helloworld'              palindrome? False
''                                  cleaned ''                        palindrome? True
'a'                                 cleaned 'a'                       palindrome? True

ch.isalnum() is True for a letter or a digit and False for a space, a comma or a colon, so the join keeps only what should be compared. ch.lower() makes the comparison ignore case.

The empty string comes out as a palindrome, which is correct: there is nothing in it that differs from its reverse. Say so in the journal rather than treating it as a bug.

Without slicing, which is the version to know

text[::-1] is Python being generous. An examiner who wants to see the algorithm asks for two pointers, one from each end, walking inwards.

def is_palindrome_two_pointers(text):
    cleaned = [ch.lower() for ch in text if ch.isalnum()]
    left = 0
    right = len(cleaned) - 1
    steps = 0
    while left < right:
        steps += 1
        if cleaned[left] != cleaned[right]:
            return False, steps
        left += 1
        right -= 1
    return True, steps


for text in ["level", "Madam", "hello", "A man, a plan, a canal: Panama"]:
    answer, steps = is_palindrome_two_pointers(text)
    print(f"{text!r:<35} palindrome? {answer!s:<6} after {steps} comparison(s)")

'level'                             palindrome? True   after 2 comparison(s)
'Madam'                             palindrome? True   after 2 comparison(s)
'hello'                             palindrome? False  after 1 comparison(s)
'A man, a plan, a canal: Panama'    palindrome? True   after 10 comparison(s)

Two things to say about it at the table. The loop runs while left < right, so it stops in the middle and never compares a character with itself. And it returns as soon as a pair differs, so "hello" is decided in one comparison, while the slicing version always builds the whole reversed string first.

The reverse of a number by arithmetic

The same idea without strings, which is how it is done in C:

def reverse_number(number):
    n = abs(number)
    reversed_value = 0
    while n > 0:
        reversed_value = reversed_value * 10 + n % 10
        n //= 10
    return reversed_value


for value in [121, 123, 1200, 7]:
    print(f"{value:>5} reversed is {reverse_number(value):>5}  "
          f"palindrome? {reverse_number(value) == value}")

  121 reversed is   121  palindrome? True
  123 reversed is   321  palindrome? False
 1200 reversed is    21  palindrome? False
    7 reversed is     7  palindrome? True

reversed_value * 10 + n % 10 pushes each digit on at the right hand end. Note 1200 becomes 21, because the leading zeros of a reversed number do not exist, and 1200 is correctly not a palindrome.

Procedure

1. Save as practical5a.py.
2. Write is_armstrong(number) with a docstring, using the count of digits as the power.
3. Test it on 153, 370, 371, 407, 9474, 8208, 9 and 123, and print the verdict for each.
4. Write a version that prints the working, and check 8208 against the table by hand.
5. Write is_palindrome_number(number) and test it on 121, 123, 1221 and 7.
6. Write is_palindrome_text(text) that ignores case, spaces and punctuation, and test it

on "level", "Madam" and a full sentence.

1. Write the two pointer version and print the number of comparisons.
2. Both functions must return, not print, and be called from a loop of test values.

Result

is_armstrong reported yes for 153, 370, 371, 407, 9474, 8208, 9, 0 and 1 and no for 123 and 100. The working for 8208 was 4096 + 16 + 0 + 4096 = 8208, matching the table. Counted by the program, there are 17 Armstrong numbers below 10000. is_palindrome_number was correct on 121, 1221, 7 and 1001 and rejected 123 and 10. is_palindrome_text accepted "level", "Madam" and "A man, a plan, a canal: Panama" after cleaning, and rejected "Munotes" and "hello world". The two pointer version rejected "hello" after one comparison.

Where marks are lost

• Not writing a function. MU's row says function, twice.
• print instead of return, so the answer cannot be used in a test.
• Hard coding the power as 3. Then 9474, 8208 and every single digit number are wrong.
• Forgetting that every single digit number is an Armstrong number.
• Not cleaning the string for a palindrome, so "Madam" fails on the capital and a

sentence fails on the spaces.

• Testing once. A function is proved by a table of values, not by one call.
• No docstring. It costs one line and it is what a function is expected to have.

For the journal

The aim in MU's words. The Armstrong table with the working shown for at least 153, 9474 and 8208, and one sentence saying the power is the count of digits so every one digit number qualifies. Both functions in full, with docstrings. The loop of test values and its output for each. For the palindrome, the cleaned string printed beside the original so the cleaning is visible, and one sentence on the two pointer version returning early. The conclusion: a function returns a value so it can be tested and reused, and both of these are one line of real work around a definition that has to be got right first.

Quick revision

• def name(parameter): then a docstring then return. An argument is passed, a

parameter receives.

• A function with no return gives back None, which cannot be used in an if.
• return leaves the function at once.
• Armstrong: each digit raised to the count of digits, summed, equals the number.
• 153, 370, 371, 407 are the three digit ones. 1634, 8208 and 9474 are the four digit ones.

Every one digit number is one. Counted: 17 below 10000.

• sum(int(d) ** len(s) for d in s) where s = str(n) is the whole function.
• Palindrome: reads the same reversed. text == text[::-1].
• For a string, clean first: "".join(ch.lower() for ch in text if ch.isalnum()).
• The two pointer version walks in from both ends while left < right and returns False at

the first mismatch.

• Reversing a number by arithmetic: rev = rev * 10 + n % 10, then n //= 10.

Questions you should be able to answer

1. What is the difference between an argument and a parameter? The parameter is the name in the def line; the argument is the value passed in when the function is called.

2. What does a function return if it has no return statement? None.

3. Why is print inside the function not good enough here? Because the caller gets None, so the answer cannot be used in an if, stored, or tested in a loop.

4. Define an Armstrong number. A number equal to the sum of its own digits, each raised to the power of the number of digits.

5. Is 8208 an Armstrong number? Show it. Yes. It has four digits, and 8^4 + 2^4 + 0^4 + 8^4 = 4096 + 16 + 0 + 4096 = 8208.

6. Is 7 an Armstrong number? Yes. It has one digit and 7^1 = 7. Every single digit number qualifies.

7. Write the palindrome test in one line. return text == text[::-1], after cleaning the text if it may contain case or punctuation.

8. Why must a string be cleaned before the test? Because a capital letter, a space or a comma is a character like any other, so "Madam" and any sentence would fail on characters that a reader does not count.

9. What advantage does the two pointer version have? It stops at the first mismatch, so a long string that differs early is decided at once, and it builds no reversed copy.

10. What does reversing 1200 by arithmetic give, and is 1200 a palindrome? 21, because the trailing zeros become leading zeros and do not exist. 1200 is not a palindrome.

Each waiting call is held on the call stack, which is a real, finite piece of memory. That is what the next section is about.

Where recursion stops

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)


print(factorial(5000))

RecursionError: maximum recursion depth exceeded

Python refuses at around a thousand nested calls, and it says so rather than crashing the machine. The limit is a guard: each call holds its own variables on the stack, and a runaway recursion would otherwise use all the memory there is.

import sys

print("the limit is", sys.getrecursionlimit())

the limit is 1000

The limit can be raised with sys.setrecursionlimit, and you should not, because the real answer is a loop.

The same factorial three other ways

from math import factorial as math_factorial


def factorial_loop(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result


def factorial_while(n):
    result = 1
    while n > 1:
        result *= n
        n -= 1
    return result


for value in [0, 1, 5, 10, 20]:
    print(f"{value:>3}!  for loop {factorial_loop(value):<20} "
          f"while loop {factorial_while(value):<20} math {math_factorial(value)}")

  0!  for loop 1                    while loop 1                    math 1
  1!  for loop 1                    while loop 1                    math 1
  5!  for loop 120                  while loop 120                  math 120
 10!  for loop 3628800              while loop 3628800              math 3628800
 20!  for loop 2432902008176640000  while loop 2432902008176640000  math 2432902008176640000

All four agree. The loop has no depth limit and uses no stack, so factorial_loop(5000) works where the recursive one does not. math.factorial is the one to use in real work, and it is the one to mention and not submit, because MU asked for a recursive function.

Notice 20! in that output. Python integers have no fixed width, so a factorial that would overflow a 64 bit integer in C simply keeps going here. That is worth one sentence in the journal, because in C this exercise breaks at 21!.

from math import factorial

digits = str(factorial(100))
print("100! has", len(digits), "digits")
print("and it is exact, ending in", digits[-30:])

100! has 158 digits
and it is exact, ending in 916864000000000000000000000000

Recursion against iteration, honestly

Recursion is not a worse loop. It is the right tool when the data itself is nested, which is exactly what a tree is, and [Practical 6: Tree Traversal, Pre-order, In-order and Post-order] is where it earns its place.

Part two: the lambda

What a lambda is

A lambda is a function with no name, written in one expression. These two are the same function:

def starts_with_a(text):
    return text.startswith("a")


starts_with_a_lambda = lambda text: text.startswith("a")

print(starts_with_a("apple"), starts_with_a_lambda("apple"))
print(starts_with_a("banana"), starts_with_a_lambda("banana"))
print(type(starts_with_a), type(starts_with_a_lambda))

True True
False False
<class 'function'> <class 'function'>

The shape is lambda parameters: one expression. Three rules follow:

• There is no return. The expression IS the value handed back.
• It is one expression. No if statement, no loop, no assignment, no several lines.

A conditional expression, a if cond else b, is allowed because it is an expression.

• It is a function like any other, as type shows above, and it can be stored in a

variable, passed to another function, or put in a list.

MU's exercise

Her row asks for a lambda that checks whether a given string starts with a specific character, so the lambda takes two things: the string and the character.

starts_with = lambda text, char: text.startswith(char)

tests = [("munotes", "m"), ("munotes", "n"), ("Practical", "p"), ("Practical", "P"),
         ("", "a"), ("python", "py")]
for text, char in tests:
    print(f"does {text!r:<12} start with {char!r:<4}? {starts_with(text, char)}")

does 'munotes'    start with 'm' ? True
does 'munotes'    start with 'n' ? False
does 'Practical'  start with 'p' ? False
does 'Practical'  start with 'P' ? True
does ''           start with 'a' ? False
does 'python'     start with 'py'? True

Two results in there are worth a sentence each. "Practical" does not start with "p" because startswith is case sensitive, and "python" does start with "py" because startswith accepts a whole prefix, not only one character.

A case insensitive version, still one expression:

starts_with_ci = lambda text, char: text.lower().startswith(char.lower())

for text, char in [("Practical", "p"), ("MUNOTES", "m"), ("munotes", "X")]:
    print(f"{text!r:<12} starts with {char!r} ignoring case? {starts_with_ci(text, char)}")

'Practical'  starts with 'p' ignoring case? True
'MUNOTES'    starts with 'm' ignoring case? True
'munotes'    starts with 'X' ignoring case? False

And without startswith at all, which an examiner may ask for:

starts_with_index = lambda text, char: len(text) > 0 and text[0] == char

for text, char in [("munotes", "m"), ("munotes", "n"), ("", "m")]:
    print(f"{text!r:<10} {char!r} -> {starts_with_index(text, char)}")

'munotes'  'm' -> True
'munotes'  'n' -> False
''         'm' -> False

The len(text) > 0 is not decoration. ""[0] raises IndexError, and and stops as soon as the left side is False, so the guard protects the indexing. That is called short circuit evaluation and it is a viva question.

Where a lambda is actually used

A lambda is at its best as an argument to something else, and that is where you will meet it in the rest of this paper.

words = ["munotes", "apple", "Practical", "banana", "array", "Python"]

print("sorted plainly        ", sorted(words))
print("sorted ignoring case  ", sorted(words, key=lambda w: w.lower()))
print("sorted by length      ", sorted(words, key=lambda w: len(w)))
print("sorted by last letter ", sorted(words, key=lambda w: w[-1]))
print("only the a words      ", list(filter(lambda w: w.lower().startswith("a"), words)))
print("their lengths         ", list(map(lambda w: len(w), words)))
print("any starting with P?  ", any(map(lambda w: w.startswith("P"), words)))
print("all longer than 3?    ", all(map(lambda w: len(w) > 3, words)))

sorted plainly         ['Practical', 'Python', 'apple', 'array', 'banana', 'munotes']
sorted ignoring case   ['apple', 'array', 'banana', 'munotes', 'Practical', 'Python']
sorted by length       ['apple', 'array', 'banana', 'Python', 'munotes', 'Practical']
sorted by last letter  ['banana', 'apple', 'Practical', 'Python', 'munotes', 'array']
only the a words       ['apple', 'array']
their lengths          [7, 5, 9, 6, 5, 6]
any starting with P?   True
all longer than 3?     True

filter and map return an iterator, not a list, which is why list(...) is wrapped around them above. Print one without the list and you get <filter object at ...>, which is the commonest surprise here.

When NOT to use a lambda

# clear
by_length = sorted(["bb", "a", "ccc"], key=lambda w: len(w))
print(by_length)


# not clear: this should have been a def with a name and a docstring
def grade(mark):
    """The grade band for a mark out of 100."""
    if mark >= 75:
        return "distinction"
    if mark >= 60:
        return "first class"
    if mark >= 40:
        return "pass"
    return "fail"


print([grade(m) for m in [80, 65, 45, 30]])

['a', 'bb', 'ccc']
['distinction', 'first class', 'pass', 'fail']

The rule to state at the table. A lambda is for a one expression function used once, in place. Anything that needs a name, a docstring or a second line is a def. Writing the grade ladder as nested conditional expressions inside a lambda is legal and unreadable.

Procedure

1. Save as practical5b.py. Write factorial(n) with a base case of 0 returning 1 and a

recursive step of n * factorial(n - 1), with a docstring.

1. Print the factorial of 0 to 8 and check 5! = 120 by hand.
2. Add a depth parameter and print each call and each return, then draw the down and up

picture in the journal.

1. Call it with 5000 and record the RecursionError, and print

sys.getrecursionlimit().

1. Write the loop version and show that it agrees and that it has no depth limit.
2. Save as practical5c.py. Write starts_with = lambda text, char: text.startswith(char)

and test it, including a case difference and a two character prefix.

1. Write the case insensitive version and the version without startswith.
2. Use a lambda with sorted(key=), filter and map, and wrap the last two in list.

Result

The recursive factorial gave 1, 1, 2, 6, 24, 120, 720, 5040 and 40320 for 0 to 8, matching the table, and 5! = 120 by hand. The traced run showed four calls descending to the base case and the multiplications happening on the way back up. factorial(5000) raised RecursionError at a limit of 1000. The loop, the while loop and math.factorial all agreed with the recursion. The lambda reported that "munotes" starts with "m" and not with "n", that "Practical" does not start with a lower case "p", and that "python" does start with "py".

Where marks are lost

• No base case, so the function recurses until RecursionError.
• Saying 0! is 0. It is 1, and it is the base case.
• Writing return n * factorial(n) instead of n - 1, which never gets smaller.
• Using a loop when the row says recursive.
• Putting return inside a lambda. It is a syntax error; the expression is the value.
• Trying to fit an if statement into a lambda. Use the conditional expression, or a

def.

• Printing filter(...) without list(...) and reporting the object address.
• Not knowing where recursion stops. The limit is real; print it.

For the journal

Two entries under practical 5. For the recursion: the aim, the factorial table to 6, the two part table of base case and recursive step, the function, the run for 0 to 8, and the traced run with its indentation, which is the evidence that you know how the calls nest. Add the RecursionError and the limit. One sentence: the calls descend to the base case and the multiplications happen on the way back up.

For the lambda: the aim, the def and the lambda written side by side to show they are the same function, MU's starts_with lambda, the test table including the case difference, and one use of a lambda with sorted, filter and map. The conclusion: a lambda is a one expression function with no name, used where a function is being passed to something else.

Quick revision

• A recursive function calls itself. It needs a base case and a recursive step that

makes the problem smaller.

• Factorial: if n == 0: return 1 then return n * factorial(n - 1).
• 0! = 1. 5! = 120. 20! is exact in Python because integers have no fixed width.
• The calls go down to the base case and the answers come back up. Each waiting call sits on

the call stack.

• The recursion limit is about 1000 and RecursionError is what exceeding it raises.

sys.getrecursionlimit() prints it.

• A loop has no depth limit and uses no stack. Recursion is the right tool for nested data,

such as a tree.

• A lambda is lambda params: expression. No return, one expression.
• a if cond else b is allowed inside one, because it is an expression.
• startswith is case sensitive and accepts a whole prefix, not just one character.
• filter and map return iterators; wrap them in list() to print.
• Use a lambda for a one expression function passed in place. Anything needing a name or a

docstring is a def.

Questions you should be able to answer

1. What two parts does every recursive function have? A base case, the smallest problem answered without recursing, and a recursive step that calls itself on a smaller problem.

2. What is the base case of the factorial, and what does it return? n equal to 0, and it returns 1.

3. In the traced run, when does the first multiplication happen? Only after the base case is reached. The calls descend first, each waiting, and the multiplications happen on the way back up.

4. What happens if the base case is missing or never reached? The function recurses until Python's limit is exceeded and raises RecursionError.

5. What is the recursion limit, and can it be changed? Around 1000 by default, printed by sys.getrecursionlimit(). It can be raised with sys.setrecursionlimit, but a loop is the right answer.

6. Why does this program not overflow at 21! as the same program in C does? Python integers have no fixed width, so they grow as needed.

7. Write a lambda that says whether a string starts with a character. lambda text, char: text.startswith(char).

8. Why is there no return in a lambda? Because the single expression after the colon is what it hands back. A return there is a syntax error.

9. What can a lambda not contain? A statement of any kind: no if statement, no loop, no assignment, no second line. A conditional expression is allowed.

10. Why does printing a filter(...) show an object rather than the values? Because filter returns an iterator that produces values on demand rather than a list. Wrap it in list().

11. Does "Practical".startswith("p") return True? No. startswith is case sensitive. Use text.lower().startswith(char.lower()).

text                  "Well-known students don't stop; they keep going!"
characters with spaces 48
characters no spaces   42
letters only           38
words by split()       7  ->  ['Well-known', 'students', "don't", 'stop;', 'they', 'keep', 'going!']

Four different counts of the same sentence, and every one of them is correct for the question it answers. "Well-known" is one word to split() because there is no space in it, and "don't" is one word for the same reason. Say which definition you used and the marks are safe.

The letter frequency table, which is the natural extension

from collections import Counter

text = "Munotes makes notes for Mumbai University students"

letters = [ch.lower() for ch in text if ch.isalpha()]
counts = Counter(letters)

print("total letters:", len(letters))
print("distinct letters:", len(counts))
print("the five commonest:", counts.most_common(5))
print()
for letter, count in sorted(counts.items()):
    print(f"  {letter}  {'*' * count}  {count}")

total letters: 44
distinct letters: 16
the five commonest: [('s', 6), ('t', 5), ('e', 5), ('m', 4), ('u', 4)]

  a  **  2
  b  *  1
  d  *  1
  e  *****  5
  f  *  1
  i  ***  3
  k  *  1
  m  ****  4
  n  ****  4
  o  ***  3
  r  **  2
  s  ******  6
  t  *****  5
  u  ****  4
  v  *  1
  y  *  1

Counter counts anything countable and most_common(n) gives the top n in order. It is in the standard library, so nothing needs installing. Counting by hand with a dictionary is the version to know as well, because an examiner may forbid the import:

text = "Munotes makes notes"

counts = {}
for ch in text.lower():
    if ch.isalpha():
        counts[ch] = counts.get(ch, 0) + 1

print(sorted(counts.items()))
print("the same by hand, without Counter")

[('a', 1), ('e', 3), ('k', 1), ('m', 2), ('n', 2), ('o', 2), ('s', 3), ('t', 2), ('u', 1)]
the same by hand, without Counter

counts.get(ch, 0) returns the current count, or 0 if the letter has not been seen. Without the default, the first occurrence of each letter would raise KeyError.

Counting words, not just how many

from collections import Counter

text = ("the notes are the notes that the students read "
        "and the notes the students read are these notes")

words = text.lower().split()
counts = Counter(words)

print("words in all      :", len(words))
print("different words   :", len(counts))
print("commonest three   :", counts.most_common(3))
print("words used once   :", sorted(w for w, c in counts.items() if c == 1))
print("longest word      :", max(words, key=len))
print("average word length:", round(sum(len(w) for w in words) / len(words), 2))

words in all      : 18
different words   : 8
commonest three   : [('the', 5), ('notes', 4), ('are', 2)]
words used once   : ['and', 'that', 'these']
longest word      : students
average word length: 4.28

max(words, key=len) returns the longest word, and key=len is the lambda idea from [Practical 5 continued: Recursion, and the Lambda] without needing to write a lambda at all, because len is already a function.

Sentences, lines and the other counts an examiner may ask for

text = """Munotes makes notes. The notes are free to read.
They cover the whole syllabus! Do they cover yours?
"""

print("characters          :", len(text))
print("characters no spaces:", len(text.replace(" ", "").replace("\n", "")))
print("words               :", len(text.split()))
print("lines               :", len(text.splitlines()))
print("sentences           :", sum(1 for ch in text if ch in ".!?"))
print("vowels              :", sum(1 for ch in text.lower() if ch in "aeiou"))
print("consonants          :", sum(1 for ch in text.lower()
                                   if ch.isalpha() and ch not in "aeiou"))
print("digits              :", sum(1 for ch in text if ch.isdigit()))
print("upper case          :", sum(1 for ch in text if ch.isupper()))
print("punctuation         :", sum(1 for ch in text if not ch.isalnum()
                                   and not ch.isspace()))

characters          : 101
characters no spaces: 83
words               : 18
lines               : 2
sentences           : 4
vowels              : 31
consonants          : 48
digits              : 0
upper case          : 4
punctuation         : 4

splitlines() is the right way to count lines: it handles the last line whether or not the text ends with a newline, which split("\n") does not.

The string methods worth remembering, all of which return a value and none of which change the string:

A string cannot be changed. Every method above returns a new one, so text.replace(" ", "") on its own line does nothing at all: the result has to be assigned or used. That is worth a sentence in the journal.

text = "munotes"
text.upper()
print("after text.upper() on its own line:", text)
text = text.upper()
print("after assigning it back           :", text)

after text.upper() on its own line: munotes
after assigning it back           : MUNOTES

Procedure

1. Save as practical6a.py. Read a sentence with input().
2. Count characters with len, characters without spaces with len(text.replace(" ", "")),

letters with isalpha, and words with split().

1. Print all four, each labelled, and check them by hand against your own sentence.
2. Run split() and split(' ') on a string with double spaces and a leading space, and

record both results.

1. Add a letter frequency count, with Counter and then again with a plain dictionary and

get.

1. Add the line, sentence, vowel, consonant and punctuation counts.
2. Show that a string method returns a new string and does not change the original.

Result

For "To be or not to be" the program counted 18 characters including spaces, 13 excluding them, 13 letters and 6 words, all confirmed by hand. On " Munotes makes notes. ", split() gave 3 words and split(' ') gave 10 pieces of which 7 were empty strings, which is why split() is the right call. The letter frequency table and the word frequency table both ran, and text.upper() on its own line left the string unchanged, confirming that strings cannot be modified in place.

Where marks are lost

• One unlabelled character count. Say whether spaces are included. Both is better.
• split(' ') instead of split(), which counts empty strings between double spaces as

words.

• len(text.split(" ")) on a sentence with a trailing space, which counts one word too

many.

• Calling text.replace(" ", "") and expecting text to change. Strings are

unchangeable; assign the result.

• Counting punctuation as letters, or as words. Say which you counted.
• Using text.count(" ") + 1 for the word count. It is wrong for double spaces, for a

leading space and for an empty string.

• No hand check. One sentence counted by hand beside the output proves the program.

For the journal

The aim in MU's words. One sentence saying that "number of characters" has two answers and that both are given. The program, and the output with all four counts labelled. Your own sentence counted by hand beside it. Then the split() against split(' ') comparison with both outputs, and one sentence: split() with no argument treats any run of whitespace as one separator and never produces an empty word. The letter frequency table. The conclusion: len counts characters including spaces, split() counts words, and every string method returns a new string rather than changing the old one.

Quick revision

• len(s) counts every character, spaces included.
• Without spaces: len(s.replace(" ", "")). Letters only:

sum(1 for ch in s if ch.isalpha()).

• s.split() is the word count. Any whitespace, any amount, no empty words.
• s.split(' ') splits on each single space and produces empty strings. Do not use it to

count.

• s.count(" ") + 1 is not a word count.
• s.splitlines() counts lines correctly whether or not the text ends in a newline.
• Counter(items) counts, and most_common(n) ranks. Or a dictionary with

counts.get(ch, 0) + 1.

• max(words, key=len) is the longest word.
• A string cannot be changed. Every method returns a new one; assign it.
• Say which definition you counted by. That sentence is the mark.

Questions you should be able to answer

1. How many characters are in "To be or not to be"? 18 including the five spaces, 13 without them. Both are correct answers to different questions, so say which.

2. Why is split() better than split(' ') for counting words? split() treats any run of whitespace as one separator and ignores whitespace at the ends, so it never produces an empty word. split(' ') splits on each single space and returns empty strings between consecutive spaces.

3. What is wrong with text.count(" ") + 1 as a word count? It counts one word per space, so double spaces, a leading space, a trailing space and an empty string all give the wrong answer.

4. What does text.replace(" ", "") do to text? Nothing. It returns a new string. Strings cannot be changed, so the result must be assigned.

5. How do you count the letters only? sum(1 for ch in text if ch.isalpha()), which skips spaces, digits and punctuation.

6. How many words does split() find in "Well-known students don't stop"? Four. "Well-known" and "don't" each contain no space, so each is one word.

7. Which two calls give a letter frequency count? Counter(letters) from collections, or a plain dictionary built with counts[ch] = counts.get(ch, 0) + 1.

8. Why is the default needed in counts.get(ch, 0)? Because the first time a letter is seen it is not in the dictionary, and counts[ch] would raise KeyError.

9. How do you count lines, and why not split("\n")? splitlines(). Splitting on the newline gives an extra empty piece when the text ends with one.

10. Find the longest word in one expression. max(words, key=len).

The names are MU's, squareArea and circleArea, spelled exactly as she prints them. Python's own style would be square_area, and here the specification wins over the style guide. Say so; it shows you know both.

from math import pi, never pi = 3.14. The library value is exact to the last digit a computer can hold, and using 3.14 loses accuracy in the third decimal place of every answer.

Each function has a docstring, so help(geometry) is useful.

The if __name__ == "__main__": block at the end is the standard guard, and the next section is about what it does.

The second file, which is MU's pointyShapeVolume

from geometry import squareArea, circleArea


def pointyShapeVolume(x, y, squareBase):
    """The volume of a square pyramid when squareBase is True, else a cone.

    x is the edge of the square, or the radius of the circle.
    y is the height of the solid.
    """
    if squareBase:
        base = squareArea(x)
    else:
        base = circleArea(x)
    return base * y / 3


print("a square pyramid, edge 3, height 9")
print("  base area", squareArea(3))
print("  volume   ", pointyShapeVolume(3, 9, True))
print("a cone, radius 3, height 9")
print("  base area", round(circleArea(3), 6))
print("  volume   ", round(pointyShapeVolume(3, 9, False), 6))

a square pyramid, edge 3, height 9
  base area 9
  volume    27.0
a cone, radius 3, height 9
  base area 28.274334
  volume    84.823002

Check the pyramid by hand, because it comes out exact: the base is 3 × 3 = 9, the height is 9, and 9 × 9 / 3 = 27.

if squareBase: is MU's "first use squareBase to distinguish the cases", and it is written as a plain truth test rather than if squareBase == True. The two behave the same and the first is what Python programmers write.

The two shapes compared, which is the interesting part

from math import pi
from geometry import squareArea, circleArea


def pointyShapeVolume(x, y, squareBase):
    base = squareArea(x) if squareBase else circleArea(x)
    return base * y / 3


print(f"{'x':>3} {'y':>3}   {'pyramid':>12} {'cone':>12}   {'ratio':>8}")
for x, y in [(1, 1), (2, 6), (3, 9), (5, 12), (10, 10)]:
    pyramid = pointyShapeVolume(x, y, True)
    cone = pointyShapeVolume(x, y, False)
    print(f"{x:>3} {y:>3}   {pyramid:>12.4f} {cone:>12.4f}   {pyramid / cone:>8.6f}")

print()
print("the ratio never changes, and it is 1 / pi =", round(1 / pi, 6))
print("because the square of edge x has area x squared")
print("and the circle of RADIUS x has area pi times x squared, which is larger")

  x   y        pyramid         cone      ratio
  1   1         0.3333       1.0472   0.318310
  2   6         8.0000      25.1327   0.318310
  3   9        27.0000      84.8230   0.318310
  5  12       100.0000     314.1593   0.318310
 10  10       333.3333    1047.1976   0.318310

the ratio never changes, and it is 1 / pi = 0.31831
because the square of edge x has area x squared
and the circle of RADIUS x has area pi times x squared, which is larger

Every row has the same ratio, and it is 1 divided by pi, about 0.3183. The reason is worth one line in the journal because it is the kind of thing a viva asks. A square of edge x has area x squared. A circle of radius x has area pi × x squared, which is larger, because the circle reaches x in every direction while the square reaches x only along its edge. The one third and the height cancel, so the cone is always pi × the pyramid, and the pyramid is 1 over pi of the cone.

Note the trap. If MU's x had been the square's edge against the circle's diameter, the square would have been the larger of the two and the ratio would have been 4 over pi. Her row says radius, so it is 1 over pi. Read the specification, not the picture in your head.

import, and the four forms of it

import geometry
from geometry import squareArea
from geometry import squareArea, circleArea
from geometry import circleArea as areaOfCircle

print("import geometry            ->", geometry.squareArea(4))
print("from geometry import name  ->", squareArea(4))
print("renamed with as            ->", round(areaOfCircle(1), 6))
print("what the module knows      ->", [n for n in dir(geometry) if not n.startswith("_")])

import geometry            -> 16
from geometry import name  -> 16
renamed with as            -> 3.141593
what the module knows      -> ['circleArea', 'pi', 'squareArea']

There is a fifth form, from geometry import *, which imports everything. Do not use it. It hides where a name came from and it will silently overwrite one of your own functions with the module's. An examiner may ask why; that is why.

dir(module) lists what a module holds, which is how you check an import worked.

if __name__ == "__main__": and what it is for

Every module has a variable called __name__. When the file is run, it holds "__main__". When the file is imported, it holds the module's own name.

import geometry

print("inside this program, __name__ is  ", __name__)
print("inside the imported module it is  ", geometry.__name__)
print("so geometry's self test did not run when we imported it")

inside this program, __name__ is   __main__
inside the imported module it is   geometry
so geometry's self test did not run when we imported it

Look at what did not happen: geometry.py ends with a self test that prints two lines, and importing it printed nothing. That is the guard working. Without it, every import of geometry would run the test, so pointy.py would print geometry's output before its own.

That is the whole reason the idiom exists, and it is a standard viva question on any exercise that has two files.

The complete answer, with the checks MU's row implies

from geometry import squareArea, circleArea


def pointyShapeVolume(x, y, squareBase):
    """Volume of a square pyramid (squareBase True) or a right circular cone.

    x: the edge of the square, or the radius of the circle
    y: the height of the solid
    """
    if x < 0 or y < 0:
        raise ValueError("a length cannot be negative")
    if squareBase:
        base = squareArea(x)
        shape = "square pyramid"
    else:
        base = circleArea(x)
        shape = "right circular cone"
    volume = base * y / 3
    print(f"  {shape}: base area {base:.6f}, height {y}, "
          f"volume = {base:.6f} x {y} / 3 = {volume:.6f}")
    return volume


print("MU's two cases:")
pointyShapeVolume(3, 9, True)
pointyShapeVolume(3, 9, False)

print("a degenerate case, zero height:")
pointyShapeVolume(5, 0, True)

print("and a rejected one:")
try:
    pointyShapeVolume(-1, 5, True)
except ValueError as error:
    print("  refused:", error)

MU's two cases:
  square pyramid: base area 9.000000, height 9, volume = 9.000000 x 9 / 3 = 27.000000
  right circular cone: base area 28.274334, height 9, volume = 28.274334 x 9 / 3 = 84.823002
a degenerate case, zero height:
  square pyramid: base area 25.000000, height 0, volume = 25.000000 x 0 / 3 = 0.000000
and a rejected one:
  refused: a length cannot be negative

Procedure

1. Save geometry.py with squareArea(edge) and circleArea(radius), both with docstrings,

from math import pi at the top, and an if __name__ == "__main__": self test.

1. Run geometry.py on its own and confirm the self test prints.
2. Save a second file, pointy.py, in the same folder.
3. In it, write from geometry import squareArea, circleArea.
4. Write pointyShapeVolume(x, y, squareBase) with MU's exact name and parameter order.
5. Use if squareBase: to choose the area function, then return base times height over 3.
6. Call it for a pyramid of edge 3 and height 9 and check by hand that 9 × 9 / 3 = 27.
7. Call it for a cone of radius 3 and height 9 and note it is smaller by the factor 4 over pi.
8. Import geometry and confirm its self test did NOT run, which proves the guard.

Result

geometry.py and pointy.py were saved in one folder. squareArea(3) gave 9 and pointyShapeVolume(3, 9, True) gave 27.0, which matches the hand check 9 × 9 / 3 = 27. The cone of the same radius and height was LARGER, 84.823002 against 27.0, and the ratio of pyramid to cone was the same for every pair of values tried, 0.318310, which is 1 divided by pi. Importing geometry printed nothing from its self test, confirming the __name__ guard works. A negative length was refused with ValueError.

Where marks are lost

• Renaming the function. MU prints pointyShapeVolume; write that, not

pointy_shape_volume.

• Changing the parameter order. It is (x, y, squareBase).
• Renaming squareArea or circleArea to Python's snake case style. Her row names them.
• Writing everything in one file. Her row says "in another file", and the import is the

exercise.

• pi = 3.14. Use from math import pi.
• Forgetting the one third. Then you have computed a prism, not a pyramid.
• Using the square's edge as a radius or the reverse. x means both, and which one

depends on squareBase.

• from geometry import *, which hides where names came from.
• No if __name__ == "__main__": guard, so the module's test output appears inside your

program's output.

• Both files in different folders. The import then fails with ModuleNotFoundError.

For the journal

Two files, both written out in full, clearly labelled geometry.py and pointy.py. MU's own wording as the aim, because it is a specification. The volume rule stated once, one third times base area times height, and the two row table of what the base is in each case. The output of both calls, with the hand check 9 × 9 / 3 = 27 written beside the pyramid. One sentence on if __name__ == "__main__": and what it stopped from printing. One sentence on the ratio of the two volumes being 4 over pi whatever the numbers, and why. The conclusion: the base area lives in the module because it is useful on its own, and the volume function only has to choose which base to ask for.

Quick revision

• A module is a .py file you can import from. Both files must be in the same folder.
• from geometry import squareArea, circleArea is the form MU's row implies.
• Never from geometry import *.
• volume = one third × base area × height, for a pyramid and for a cone alike.
• Square pyramid: base is x x. Cone: base is pi x * x. y is the height in both.
• from math import pi, never 3.14.
• if squareBase: is the plain truth test, and it is MU's "first use squareBase".
• pointyShapeVolume(3, 9, True) is 27.0, because 9 × 9 / 3 = 27.
• The cone is always pi × the pyramid for the same x and y, because the circle of

radius x is the bigger base. The pyramid is 1 over pi of the cone, about 0.3183.

• __name__ is "__main__" when a file is run and the module's name when it is imported, so

the guard keeps a module's self test out of an importer's output.

• dir(module) lists what it holds.

Questions you should be able to answer

1. What is a module? A .py file whose names another file can import. Every file you write is one.

2. Why did MU's row split this into two files? Because the base areas are useful on their own, and separating them is the habit the exercise teaches. The volume function only has to decide which area to ask for.

3. State the volume rule for both shapes. One third × the base area × the height. The only difference is that the base is x x for the square and pi x * x for the circle.

4. In pointyShapeVolume(x, y, squareBase), what is x? The edge of the square when squareBase is True, and the radius of the circle when it is False.

5. Compute the volume of a square pyramid of edge 3 and height 9. The base is 3 × 3 = 9, so the volume is 9 × 9 / 3 = 27.

6. For the same x and y, which is bigger, and by how much? The cone. A square of edge x has area x squared; a circle of radius x has area pi × x squared, and pi is greater than 1. So the cone is exactly pi × the pyramid, and the ratio of pyramid to cone is 1 over pi, about 0.3183.

7. What does if __name__ == "__main__": do? The block runs only when the file is run directly, not when it is imported, because __name__ is "__main__" only in the file being run.

8. What happens without that guard? Whatever the module prints at the bottom is printed every time somebody imports it, so your program's output is preceded by the module's.

9. Why not pi = 3.14? Because math.pi is accurate to the full precision a float holds, and 3.14 is wrong in the third decimal place, which spoils every answer computed from it.

10. The import fails with ModuleNotFoundError: No module named 'geometry'. Why? The two files are not in the same folder, or the module file is not named exactly geometry.py.

no member in common    nested loops   answer False  comparisons 40000
no member in common    in operator    answer False  comparisons 40000
no member in common    sets           answer False  comparisons 0
the LAST items match   nested loops   answer True   comparisons 40000
the LAST items match   in operator    answer True   comparisons 40000
the LAST items match   sets           answer True   comparisons 1

Read those six lines carefully, because the figures are more extreme than most notes claim.

The nested loops and the in operator both did 40000 comparisons in both cases, which is 200 × 200, the whole product of the two lengths. That is the same whether the answer is no or whether the match is sitting at the very last pair.

The set version did 0 comparisons when nothing was in common and 1 when one pair matched. Not a few hundred: zero.

The reason is the general lesson of the whole Module 2 half of this paper. A set finds a member by hashing, not by comparing. It computes a hash of each item, uses it to go straight to a bucket, and only calls == when two items land in the same bucket. With no common member, no two items ever land together, so == is never called at all. With one common member, it is called exactly once, on the pair that matched.

So the rule is short. Write the any version for readability and the set version when the lists are large, and say which and why. That sentence is the difference between a correct answer and a good one.

A set cannot hold an unhashable item, so set([[1], [2]]) raises TypeError. Lists inside lists rule the set version out, and then the any version is the answer.

Part two: sorting a dictionary by value

What a dictionary is, in one paragraph

A dictionary holds pairs: a key and the value it maps to. Keys are unique, and a value is found from its key in about one step, by hashing, exactly as for a set. Since Python 3.7 a dictionary keeps the order in which keys were first inserted, which is what makes "sorting a dictionary" mean something at all.

marks = {"Aarti": 78, "Divya": 55, "Chetan": 90, "Bhavesh": 55, "Eshan": 67}

print("the dictionary      ", marks)
print("keys                ", list(marks.keys()))
print("values              ", list(marks.values()))
print("pairs               ", list(marks.items()))
print("one value by key    ", marks["Chetan"])
print("a missing key safely", marks.get("Farhan", "not enrolled"))
print("how many            ", len(marks))

the dictionary       {'Aarti': 78, 'Divya': 55, 'Chetan': 90, 'Bhavesh': 55, 'Eshan': 67}
keys                 ['Aarti', 'Divya', 'Chetan', 'Bhavesh', 'Eshan']
values               [78, 55, 90, 55, 67]
pairs                [('Aarti', 78), ('Divya', 55), ('Chetan', 90), ('Bhavesh', 55), ('Eshan', 67)]
one value by key     90
a missing key safely not enrolled
how many             5

items() is the one this exercise needs: it gives each pair as a tuple (key, value).

The point students miss

A dictionary has no sort method. A list does, a dictionary does not. sorted(anything) returns a list, so sorting a dictionary gives back a list of pairs, and if you want a dictionary again you build one from that list.

marks = {"Aarti": 78, "Bhavesh": 55, "Chetan": 90}

print("sorted(marks) sorts the KEYS and returns a list:", sorted(marks))
print("type of that                                   :", type(sorted(marks)).__name__)
print("sorted(marks.items()) sorts pairs by key       :", sorted(marks.items()))
print("marks itself is untouched                      :", marks)

sorted(marks) sorts the KEYS and returns a list: ['Aarti', 'Bhavesh', 'Chetan']
type of that                                   : list
sorted(marks.items()) sorts pairs by key       : [('Aarti', 78), ('Bhavesh', 55), ('Chetan', 90)]
marks itself is untouched                      : {'Aarti': 78, 'Bhavesh': 55, 'Chetan': 90}

Ascending, which is MU's first half

marks = {"Aarti": 78, "Divya": 55, "Chetan": 90, "Bhavesh": 55, "Eshan": 67}

pairs_ascending = sorted(marks.items(), key=lambda pair: pair[1])
print("as a list of pairs :", pairs_ascending)

ascending = dict(pairs_ascending)
print("as a dictionary    :", ascending)

print("printed as a table:")
for name, mark in pairs_ascending:
    print(f"  {name:<10} {mark:>3}")

as a list of pairs : [('Divya', 55), ('Bhavesh', 55), ('Eshan', 67), ('Aarti', 78), ('Chetan', 90)]
as a dictionary    : {'Divya': 55, 'Bhavesh': 55, 'Eshan': 67, 'Aarti': 78, 'Chetan': 90}
printed as a table:
  Divya       55
  Bhavesh     55
  Eshan       67
  Aarti       78
  Chetan      90

key=lambda pair: pair[1] is the whole answer. sorted calls that function on each pair and sorts by what it returns, and pair[1] is the value. Using pair[0] would sort by the name, which is the default anyway.

Descending, which is MU's second half

marks = {"Aarti": 78, "Divya": 55, "Chetan": 90, "Bhavesh": 55, "Eshan": 67}

descending = dict(sorted(marks.items(), key=lambda pair: pair[1], reverse=True))
print("reverse=True   :", descending)

also_descending = dict(sorted(marks.items(), key=lambda pair: -pair[1]))
print("negate the key :", also_descending)

print("the top scorer  :", max(marks, key=marks.get), max(marks.values()))
print("the lowest      :", min(marks, key=marks.get), min(marks.values()))
print("the top two     :", sorted(marks.items(), key=lambda p: p[1], reverse=True)[:2])

reverse=True   : {'Chetan': 90, 'Aarti': 78, 'Eshan': 67, 'Divya': 55, 'Bhavesh': 55}
negate the key : {'Chetan': 90, 'Aarti': 78, 'Eshan': 67, 'Divya': 55, 'Bhavesh': 55}
the top scorer  : Chetan 90
the lowest      : Divya 55
the top two     : [('Chetan', 90), ('Aarti', 78)]

reverse=True is the right way. Negating the key works for numbers and fails for strings and for dates, so it is a habit worth not forming.

Three ways to write the same key function

from operator import itemgetter

marks = {"Aarti": 78, "Divya": 55, "Chetan": 90}

print("lambda on the pair :", sorted(marks.items(), key=lambda pair: pair[1]))
print("itemgetter(1)      :", sorted(marks.items(), key=itemgetter(1)))
print("the KEYS by value  :", sorted(marks, key=marks.get))

lambda on the pair : [('Divya', 55), ('Aarti', 78), ('Chetan', 90)]
itemgetter(1)      : [('Divya', 55), ('Aarti', 78), ('Chetan', 90)]
the KEYS by value  : ['Divya', 'Aarti', 'Chetan']

itemgetter(1) from the operator module does exactly what the lambda does and is slightly faster. The third line sorts the keys by their values, which is often all you wanted, and it is the only one of the three with no pair in it.

One trap, and it is better met on the page than in the hall. key=marks.get looks as though it should work on the items too, and it does not:

marks = {"Aarti": 78, "Divya": 55, "Chetan": 90}
print(sorted(marks.items(), key=marks.get))

TypeError: '<' not supported between instances of 'NoneType' and 'NoneType'

sorted hands the key function each pair, and ("Aarti", 78) is not a key of the dictionary, so get returns None every time and the sort then tries to compare None with None. Read the message: it names the two NoneTypes. marks.get is a key function for sorted(marks, ...) only, never for the items.

Ties, and making the order predictable

Two students in the example share a mark of 55. Which comes first?

marks = {"Aarti": 78, "Divya": 55, "Chetan": 90, "Bhavesh": 55, "Eshan": 67}

print("by value only        :", sorted(marks.items(), key=lambda p: p[1]))
print("value then name      :", sorted(marks.items(), key=lambda p: (p[1], p[0])))
print("value down, name up  :", sorted(marks.items(), key=lambda p: (-p[1], p[0])))

by value only        : [('Divya', 55), ('Bhavesh', 55), ('Eshan', 67), ('Aarti', 78), ('Chetan', 90)]
value then name      : [('Bhavesh', 55), ('Divya', 55), ('Eshan', 67), ('Aarti', 78), ('Chetan', 90)]
value down, name up  : [('Chetan', 90), ('Aarti', 78), ('Eshan', 67), ('Bhavesh', 55), ('Divya', 55)]

Python's sort is stable, which means items that compare equal keep the order they were in. So sorting by value alone leaves the two 55s in dictionary order. To make the tie break explicit, sort by a tuple: (p[1], p[0]) sorts by value and then by name, because tuples are compared item by item.

The last line is the one an examiner likes: marks descending with names ascending inside each tie. Note that reverse=True cannot do it, because it would reverse the names too. That is the one place negating the number is the right tool.

Procedure

1. Save as practical7a.py. Write the nested loop version with a docstring, returning True

from inside the loops.

1. Write the in version, the any version and the set version, and print all four for the

same pairs of lists, including two empty lists.

1. Count the comparisons for 200 items with nothing in common and with only the last items

matching, and record both figures.

1. Save as practical7b.py. Build a dictionary of five names and marks with a tie in it.
2. Print keys(), values() and items().
3. Sort ascending with sorted(marks.items(), key=lambda p: p[1]), print the list of pairs

and then dict() of it.

1. Sort descending with reverse=True.
2. Sort by a tuple key to break the tie, and print the result.
3. Print the highest and lowest with max(marks, key=marks.get) and min.

Result

All four common member functions agreed on every pair of lists tested, including the empty list. The comparison counts were 40000 for the nested loops and for the in operator in both cases, the full 200 × 200 product, against 0 for the set version with nothing in common and 1 when a single pair matched. The dictionary sorted ascending and descending by value, dict() rebuilt a dictionary from the sorted list of pairs, and the two students tied on 55 kept their insertion order, Divya before Bhavesh, until a tuple key was used, after which the tie broke by name. sorted(marks) returned a list of keys, confirming that a dictionary has no sort of its own.

Where marks are lost

• Writing a script instead of a function for 7(a). MU's row says "returns True".
• print("True") instead of return True.
• Not stopping at the first match. A return inside the loop is the whole point.
• Calling marks.sort(). A dictionary has no sort method; that is an AttributeError.
• Forgetting .items() and sorting the keys by accident.
• Sorting by pair[0] and calling it sorted by value.
• Losing the dictionary. sorted gives a list; wrap it in dict() if a dictionary is

wanted.

• Giving only ascending. MU's row says ascending and descending.
• No tie in the test data, so the stability question never comes up.

For the journal

Two entries under practical 7. For the common member: the aim in MU's words, the nested loop version and the any version, the output for at least three pairs of lists including an empty one, the comparison counts for both the worst cases, and one sentence saying a set finds a member by hashing while a list looks at every item, so the set version wins on long lists and the any version reads best on short ones.

For the dictionary: the aim, the dictionary with a deliberate tie, the ascending sort as a list of pairs and then as a dictionary, the descending sort with reverse=True, and the tuple key that breaks the tie. One sentence: a dictionary cannot be sorted in place, sorted returns a list of pairs, and dict() turns it back.

Quick revision

• 7(a) is a function that returns True or False.
• Four ways: nested loops, a in second, any(a in second for a in first),

bool(set(first) & set(second)). set(first).isdisjoint(second) is the direct negative.

• A return inside the loop stops at the first match.
• & is set intersection. An empty set is falsy.
• A set finds a member by hashing; a list looks at every item. So use sets on long lists.

Counted on two lists of 200: 40000 comparisons for the list versions, 0 or 1 for the set.

• A set cannot hold an unhashable item such as a list.
• A dictionary maps a key to a value. items() gives (key, value) pairs.
• A dictionary has no sort method, and sorted(...) always returns a list.
• Ascending by value: sorted(marks.items(), key=lambda p: p[1]).
• Descending: add reverse=True. Back to a dictionary: dict(...) around it.
• itemgetter(1) is the other key function for pairs. marks.get is a key function for

sorted(marks, ...) only: handed a pair it returns None, and the sort then fails trying to compare None with None.

• Python's sort is stable, so equal items keep their order. Break a tie with a tuple key,

(p[1], p[0]), and use (-p[1], p[0]) for value down and name up.

• max(marks, key=marks.get) is the key with the largest value.

Questions you should be able to answer

1. Write the one line answer to MU's 7(a). return any(a in second for a in first).

2. Why does the nested loop version return from inside the loops? So that it stops at the first match instead of comparing every remaining pair.

3. What does set(first) & set(second) give? The intersection: the items that are in both. An empty result is falsy, so bool of it answers the question.

4. Why is the set version faster on long lists? Because a set finds a member by hashing rather than by comparing, and only calls == when two items land in the same bucket. Counted here on two lists of 200: the list versions did 40000 comparisons, the set version 0 with nothing in common and 1 with a single match.

5. When can the set version not be used? When the lists hold unhashable items, such as lists, because a set cannot contain them.

6. Does marks.sort() work? No. A dictionary has no sort method; that raises AttributeError. Use sorted(marks.items(), ...).

7. What does sorted(marks) return? A list of the keys, sorted. Not a dictionary, and not the values.

8. Sort a dictionary by value, ascending. dict(sorted(marks.items(), key=lambda p: p[1])).

9. Two students have the same mark. Which appears first, and why? The one that was inserted into the dictionary first, because Python's sort is stable and leaves equal items in the order they were already in.

10. Sort by mark descending with names alphabetical inside each tie. sorted(marks.items(), key=lambda p: (-p[1], p[0])). reverse=True cannot do it, because it would reverse the names as well.

Unpacking, which is how you use it

from math import pi


def circle(radius):
    """The area and the circumference of a circle, as a tuple."""
    return pi * radius * radius, 2 * pi * radius


area, circumference = circle(7)
print(f"unpacked: area {area:.4f}  circumference {circumference:.4f}")

both = circle(7)
print(f"indexed : area {both[0]:.4f}  circumference {both[1]:.4f}")

area_only, _ = circle(7)
print(f"only one: area {area_only:.4f}, the other thrown away")

unpacked: area 153.9380  circumference 43.9823
indexed : area 153.9380  circumference 43.9823
only one: area 153.9380, the other thrown away

area, circumference = circle(7) is tuple unpacking: the tuple on the right is taken apart and its items assigned to the names on the left, in order. The number of names must match the number of items, or Python says so:

def circle(radius):
    return radius * radius, 2 * radius


a, b, c = circle(7)

ValueError: not enough values to unpack (expected 3, got 2)

The _ in the third example is an ordinary name used by convention for a value you are deliberately ignoring.

Unpacking is the same mechanism as a, b = b, a + b in [Practical 2: the Fibonacci Series, and the Sum of the Digits], and the same as swapping two variables in one line:

first, second = "left", "right"
print("before:", first, second)
first, second = second, first
print("after :", first, second)

before: left right
after : right left

The program MU asks for

from math import pi


def circle_properties(radius):
    """Return the area and the circumference of a circle as a tuple.

    radius: the radius, which may not be negative
    """
    if radius < 0:
        raise ValueError("a radius cannot be negative")
    area = pi * radius * radius
    circumference = 2 * pi * radius
    return area, circumference


radius = float(input("Enter the radius: "))
area, circumference = circle_properties(radius)

print(f"radius        : {radius}")
print(f"area          : {area:.4f}")
print(f"circumference : {circumference:.4f}")

7

Enter the radius: radius        : 7.0
area          : 153.9380
circumference : 43.9823

Check one of them by hand: the circumference of a circle of radius 7 is 2 × 7 = 14 lots of pi, and 14 × 3.14159265 is about 43.98. The output agrees.

Why a tuple and not a list

An examiner asks this, and the answer is short.

A tuple says "this is exactly two things and they mean different things". A list says "this is a collection of similar things and there may be any number of them". Area and circumference are the first, so a tuple is right, and MU's bracketed "(using tuple)" is not an arbitrary requirement.

The unchangeability is not just a rule. Because a tuple cannot change, it can be hashed, so it can be a dictionary key or go in a set, which a list cannot:

cache = {}
cache[(7, "cm")] = "a circle of radius 7 centimetres"
print("a tuple as a dictionary key works:", cache)

try:
    cache[[7, "cm"]] = "this will not work"
except TypeError:
    print("a list as a key raises TypeError, because a list is unhashable")

print("hash of the tuple is a number:", isinstance(hash((7, "cm")), int))

a tuple as a dictionary key works: {(7, 'cm'): 'a circle of radius 7 centimetres'}
a list as a key raises TypeError, because a list is unhashable
hash of the tuple is a number: True

The wording of that TypeError changed between Python 3.12 and 3.14, so this listing prints a sentence of its own rather than the message. Your own run will show your version's wording, and the reason is the same in both: a key must be hashable, and only something that cannot change can safely be hashed.

The readable form: a named tuple

For three or more values, result[0] and result[1] stop being readable. A named tuple fixes that and is still a tuple.

from collections import namedtuple
from math import pi

Circle = namedtuple("Circle", ["radius", "area", "circumference"])


def circle_named(radius):
    """The same answer, with the fields named."""
    return Circle(radius, pi * radius * radius, 2 * pi * radius)


result = circle_named(7)
print("the whole thing :", f"Circle(radius={result.radius}, "
                           f"area={result.area:.4f}, "
                           f"circumference={result.circumference:.4f})")
print("by name         :", round(result.area, 4))
print("by index still  :", round(result[1], 4))
print("still a tuple?  :", isinstance(result, tuple))
print("unpacks too     :", [round(x, 4) for x in result])

the whole thing : Circle(radius=7, area=153.9380, circumference=43.9823)
by name         : 153.938
by index still  : 153.938
still a tuple?  : True
unpacks too     : [7, 153.938, 43.9823]

It is worth one sentence in the journal: a named tuple gives the fields names without giving up anything, because it still is a tuple, still unpacks, and still indexes.

A table of radii, which makes a better journal entry than one run

from math import pi


def circle_properties(radius):
    return pi * radius * radius, 2 * pi * radius


print(f"{'radius':>7} {'area':>12} {'circumference':>14} {'area/circ':>10}")
for radius in [0.5, 1, 2, 7, 10, 100]:
    area, circumference = circle_properties(radius)
    print(f"{radius:>7} {area:>12.4f} {circumference:>14.4f} "
          f"{area / circumference:>10.4f}")
print()
print("the last column is always half the radius, because")
print("area / circumference = (pi r r) / (2 pi r) = r / 2")

 radius         area  circumference  area/circ
    0.5       0.7854         3.1416     0.2500
      1       3.1416         6.2832     0.5000
      2      12.5664        12.5664     1.0000
      7     153.9380        43.9823     3.5000
     10     314.1593        62.8319     5.0000
    100   31415.9265       628.3185    50.0000

the last column is always half the radius, because
area / circumference = (pi r r) / (2 pi r) = r / 2

Read the last column against the radius. It is exactly half the radius every time, because the pi and one r cancel. That is the kind of check that shows an examiner you understand the formulas rather than having copied them.

Procedure

1. Save as practical8a.py. from math import pi at the top.
2. Write circle_properties(radius) with a docstring, computing the area and the

circumference, and return area, circumference with no brackets.

1. Read the radius with float(input()).
2. Unpack the result into two names on one line.
3. Print both to four decimal places, labelled.
4. Check the circumference by hand: for radius 7 it is 14 × pi, about 43.98.
5. Show that (7) is a number and (7,) is a tuple, and that a tuple cannot be assigned to.
6. Add the table of several radii and the area over circumference column.

Result

circle_properties(7) returned a tuple of length 2, which unpacked into the area and the circumference. The circumference matched the hand check, 2 × 7 = 14 lots of pi, about 43.98. (7) was an int and (7,) a tuple, assigning to pair[0] raised TypeError, and unpacking into the wrong number of names raised ValueError. Across six radii the ratio of area to circumference was exactly half the radius each time, as the algebra requires.

Where marks are lost

• Printing inside the function instead of returning. MU's row says "returns".
• Returning a list when the row says tuple.
• pi = 3.14. Use math.pi. The run above shows 3.14 is out by about 0.0016 and 22 over 7

by about 0.0013, and both errors are multiplied by the radius squared in an area.

• Two separate functions, one for area and one for circumference. The row asks for one that

returns both.

• (7) for a one item tuple. It needs the trailing comma, (7,).
• Unpacking into the wrong number of names, which raises ValueError.
• int(input()) for the radius, which refuses 2.5.
• No hand check. One formula checked by hand beside the output is a mark.

For the journal

The aim in MU's words, including "(using tuple)". The two formulas in a table. The function with its docstring, and return area, circumference with the comma visible. The unpacking line. The run for a radius you chose, with the circumference checked by hand. Then the three line demonstration that (7) is a number and (7,) is a tuple, and the TypeError from trying to change one. One sentence on why a tuple: it is exactly two different things, it cannot be changed, and so it can be a dictionary key. The conclusion: a Python function returns one value, and returning two means returning one tuple, which the caller unpacks.

Quick revision

• Area = pi × r × r. Circumference = 2 × pi × r. Both from math.pi.
• A tuple is ordered and cannot be changed. The comma makes it, not the brackets.
• (7) is a number. (7,) is a tuple of one. () is the empty tuple.
• return a, b returns one tuple of two items.
• x, y = f() is tuple unpacking. The count of names must match, or ValueError.
• _ is the conventional name for a value being ignored.
• a, b = b, a swaps in one line, and it is the same mechanism.
• A tuple can be a dictionary key because it cannot change; a list cannot.
• namedtuple gives the fields names and is still a tuple: it unpacks and indexes as before.
• area / circumference = r / 2, always. A useful self check.

Questions you should be able to answer

1. How many values can a Python function return? One. Returning two means returning one tuple with two items in it.

2. What makes a tuple, the brackets or the comma? The comma. 1, 2, 3 is a tuple with no brackets at all.

3. What is the difference between (7) and (7,)? (7) is the integer 7 in brackets. (7,) is a tuple of one item.

4. What is tuple unpacking? Assigning the items of a tuple to several names at once, as in area, circumference = circle(7). The names are filled in order.

5. What happens if the number of names does not match? ValueError, saying how many values there were and how many were expected.

6. Why does MU's row insist on a tuple rather than a list? Because the answer is exactly two different things, always two, and a tuple says that. A list says "any number of similar things".

7. Give one thing a tuple can do that a list cannot. Be a dictionary key, or go in a set, because it cannot be changed and so can be hashed.

8. Why not use 3.14, or 22 over 7? Because math.pi is exact to the full precision of a float. Measured in the first listing, 3.14 is out by about 0.0016 and 22 over 7 by about 0.0013, and in an area that error is multiplied by the radius squared.

9. What is the circumference of a circle of radius 7, without a calculator? Twice the radius is 2 × 7 = 14, so it is 14 lots of pi, about 43.98.

10. What is the area divided by the circumference, for any circle? Half the radius, because (pi r r) / (2 pi r) cancels to r / 2.

The loop is the right way to read a file you did not write. It never holds more than one line, so it works on a file bigger than the machine's memory, and it is also the shortest to write.

Every line from a text file ends with "\n" except possibly the last. strip() removes whitespace from both ends and rstrip() from the right only, which is what you usually want.

Writing and appending

with open("scratch.txt", "w") as handle:
    handle.write("first line\n")
    handle.write("second line\n")
    handle.writelines(["third\n", "fourth\n"])

with open("scratch.txt") as handle:
    print("after w:", repr(handle.read()))

with open("scratch.txt", "a") as handle:
    handle.write("appended\n")

with open("scratch.txt") as handle:
    print("after a:", repr(handle.read()))

with open("scratch.txt", "w") as handle:
    handle.write("everything before this is gone\n")

with open("scratch.txt") as handle:
    print("after w again:", repr(handle.read()))

after w: 'first line\nsecond line\nthird\nfourth\n'
after a: 'first line\nsecond line\nthird\nfourth\nappended\n'
after w again: 'everything before this is gone\n'

Three things to record in the journal.

write does not add a newline. print does; write does not. Forget the "\n" and the whole file is one line.

writelines does not add newlines either, despite the name. It writes the strings one after another, so each must carry its own.

The third block proves what "w" does. The file had five lines and after reopening in "w" it has one. That is the demonstration to put in the journal beside the mode table.

The other basic operations

import os

print("does notes.txt exist?  ", os.path.exists("notes.txt"))
print("how big is it?         ", os.path.getsize("notes.txt"), "bytes")
print("is it a file?          ", os.path.isfile("notes.txt"))

with open("scratch.txt", "w") as handle:
    handle.write("something to rename\n")

os.rename("scratch.txt", "renamed.txt")
print("after rename, old gone?", not os.path.exists("scratch.txt"))
print("and the new one exists?", os.path.exists("renamed.txt"))

os.remove("renamed.txt")
print("after remove, exists?  ", os.path.exists("renamed.txt"))

print("the .txt files here    :", sorted(f for f in os.listdir(".") if f.endswith(".txt")))

if os.path.exists("gone.txt"):
    os.remove("gone.txt")
else:
    print("checking before removing avoids FileNotFoundError")

does notes.txt exist?   True
how big is it?          194 bytes
is it a file?           True
after rename, old gone? True
and the new one exists? True
after remove, exists?   False
the .txt files here    : ['notes.txt']
checking before removing avoids FileNotFoundError

os.path.exists before os.remove is the habit to form: removing a file that is not there raises FileNotFoundError.

Binary files, and what actually differs

A text file holds characters, and Python encodes them to bytes on the way out and decodes them on the way in. A binary file holds bytes, and nothing is translated.

data = bytes([72, 101, 108, 108, 111, 10, 0, 1, 2, 255])

with open("raw.bin", "wb") as handle:
    handle.write(data)

with open("raw.bin", "rb") as handle:
    back = handle.read()

print("what we wrote  :", data)
print("what came back :", back)
print("identical?     :", back == data)
print("its type       :", type(back).__name__)
print("byte by byte   :", list(back))
print("one byte       :", back[0], "which is an int, not a string")

what we wrote  : b'Hello\n\x00\x01\x02\xff'
what came back : b'Hello\n\x00\x01\x02\xff'
identical?     : True
its type       : bytes
byte by byte   : [72, 101, 108, 108, 111, 10, 0, 1, 2, 255]
one byte       : 72 which is an int, not a string

In binary mode you read and write bytes, not str. That is the whole difference, and mixing them up is what the two errors below are:

with open("raw.bin", "wb") as handle:
    handle.write("this is a string, not bytes")

TypeError: a bytes-like object is required, not 'str'

with open("notes.txt", "w") as handle:
    handle.write(b"these are bytes, not a string")

TypeError: write() argument must be str, not bytes

To turn one into the other, encode and decode, and always name the encoding:

text = "Munotes"
encoded = text.encode("utf-8")

print("the string    :", repr(text), len(text), "characters")
print("encoded       :", encoded, len(encoded), "bytes")
print("decoded again :", repr(encoded.decode("utf-8")))

with open("written.bin", "wb") as handle:
    handle.write(text.encode("utf-8"))

with open("written.bin", "rb") as handle:
    print("read back     :", repr(handle.read().decode("utf-8")))

the string    : 'Munotes' 7 characters
encoded       : b'Munotes' 7 bytes
decoded again : 'Munotes'
read back     : 'Munotes'

seek and tell

tell() says where you are in the file, as a number of bytes from the start. seek() moves there.

with open("notes.txt", "rb") as handle:
    print("at the start, tell() =", handle.tell())
    print("first 7 bytes        =", handle.read(7))
    print("now tell() =", handle.tell())

    handle.seek(0)
    print("after seek(0), tell() =", handle.tell())

    handle.seek(8)
    print("after seek(8), read 5 =", handle.read(5))

    handle.seek(0, 2)
    print("seek(0, 2) is the END, tell() =", handle.tell())

    handle.seek(-20, 2)
    print("the last 20 bytes     =", handle.read())

at the start, tell() = 0
first 7 bytes        = b'Munotes'
now tell() = 7
after seek(0), tell() = 0
after seek(8), read 5 = b'makes'
seek(0, 2) is the END, tell() = 194
the last 20 bytes     = b'rnal is compulsory.\n'

The second argument to seek is where to measure from: 0 the start, 1 the current position, 2 the end. Seeking relative to the end needs binary mode, which is why this listing opens with "rb"; in text mode only seek(0) and a position tell() gave you are allowed.

pickle, for saving a Python object

pickle writes any Python object to a binary file and reads it back as the same object. It is the answer to "how do I save a dictionary".

import pickle

marks = {"Aarti": 78, "Divya": 55, "Chetan": 90}
series = [0, 1, 1, 2, 3, 5]

with open("saved.pkl", "wb") as handle:
    pickle.dump(marks, handle)
    pickle.dump(series, handle)

with open("saved.pkl", "rb") as handle:
    marks_back = pickle.load(handle)
    series_back = pickle.load(handle)

print("the dictionary came back:", marks_back, marks_back == marks)
print("the list came back      :", series_back, series_back == series)
print("and it is a dict again  :", type(marks_back).__name__)
print("so this works           :", marks_back["Chetan"])

the dictionary came back: {'Aarti': 78, 'Divya': 55, 'Chetan': 90} True
the list came back      : [0, 1, 1, 2, 3, 5] True
and it is a dict again  : dict
so this works           : 90

Note that the objects come back in the order they were written, one load per dump. The file is binary, so the mode is "wb" and "rb"; pickling to a text file is an error.

One warning that belongs in the journal: never unpickle a file you did not create. Loading a pickle can run code, so it is not a safe way to accept data from somebody else. For data that crosses between programs or machines, json is the right choice.

Part two: the last n lines

The simple way

def last_n_readlines(path, n):
    """The last n lines. Reads the WHOLE file into memory."""
    with open(path) as handle:
        return handle.readlines()[-n:]


for line in last_n_readlines("notes.txt", 3):
    print(line.rstrip())

Data structures come in Module 2.
Python comes in Module 1.
The journal is compulsory.

[-n:] is the last n items of a list, and it is safe when the file has fewer than n lines: a slice clips rather than raising, as [Practical 3: Arrays, Basic Operations, Indexing and Slicing] showed.

This is the answer to write in the journal, and it has one defect worth naming: it holds the whole file in memory to keep three lines of it.

The better way

from collections import deque


def last_n_deque(path, n):
    """The last n lines, holding only n lines in memory."""
    with open(path) as handle:
        return list(deque(handle, maxlen=n))


for line in last_n_deque("notes.txt", 3):
    print(line.rstrip())

print("and asking for more lines than the file has:")
print([line.rstrip() for line in last_n_deque("notes.txt", 100)])

Data structures come in Module 2.
Python comes in Module 1.
The journal is compulsory.
and asking for more lines than the file has:
['Munotes makes notes for MU students.', 'The notes follow the printed syllabus.', 'Every chapter is free to read.', 'Data structures come in Module 2.', 'Python comes in Module 1.', 'The journal is compulsory.']

A deque with maxlen=n is a queue that throws away from the front when it is full. Feed it every line and what is left at the end is the last n, and it never held more than n. It still reads every line, so the time is the size of the file, but the memory is n lines whatever the file's size.

The way that reads only the tail

def last_n_seek(path, n, block=1024):
    """The last n lines, reading only the end of the file."""
    with open(path, "rb") as handle:
        handle.seek(0, 2)
        size = handle.tell()
        data = b""
        read = 0
        while data.count(b"\n") <= n and read < size:
            read = min(read + block, size)
            handle.seek(size - read)
            data = handle.read(read)
    lines = data.decode("utf-8").splitlines()
    return lines[-n:]


for line in last_n_seek("notes.txt", 3):
    print(line)

print("one line :", last_n_seek("notes.txt", 1))
print("all of it:", len(last_n_seek("notes.txt", 100)), "lines")

Data structures come in Module 2.
Python comes in Module 1.
The journal is compulsory.
one line : ['The journal is compulsory.']
all of it: 6 lines

This one seeks to the end, then reads backwards a block at a time until it has counted more than n newlines. On a file of a gigabyte it touches a kilobyte. It is the answer to give when the examiner asks about a large file, and it is the version a tool like tail actually uses.

The three compared

All three were run on the same file above and printed the same three lines, which is what makes the comparison a comparison rather than a claim.

Procedure

1. Create notes.txt with six lines of your own.
2. Save as practical8b.py. Open it with with open(...) as handle and read it four ways:

read(), readlines(), readline() and a for loop.

1. Write a new file in "w" mode, append to it in "a" mode, then reopen it in "w" and show

that the contents are gone.

1. Use os.path.exists, os.path.getsize, os.rename and os.remove.
2. Write a bytes object to a .bin file in "wb" and read it back in "rb", and show that

it is identical and that one byte is an int.

1. Cause both mixing errors: a str written in binary mode and bytes written in text mode.
2. Use encode and decode with "utf-8" named explicitly.
3. Use tell() and seek(), including seek(0, 2) for the end.
4. Pickle a dictionary and a list into one file and load them back in order.
5. Save as practical8c.py. Write all three last n line functions and run all three on the

same file with n of 3, 1 and 100.

Result

All four read methods returned the same content of notes.txt. Writing in "w", appending in "a" and reopening in "w" showed the file emptied on the third open, which is the behaviour to remember. The binary round trip returned bytes identical to those written, and indexing one byte gave an int. Writing a str in binary mode and bytes in text mode each raised TypeError. seek(0, 2) reported the file size and a negative seek from the end returned the tail. pickle returned a dictionary and a list equal to the originals, in the order written. All three last n functions printed the same last three lines, and asking for 100 lines from a six line file returned six rather than raising.

Where marks are lost

• No with. Then a file stays open when something fails, and on a write the data may not

reach the disk.

• Opening in "w" to look at a file. It is empty before you read a byte.
• Forgetting "\n" in write. The whole file becomes one line.
• Expecting writelines to add newlines. It does not.
• Mixing str and bytes. Binary mode needs bytes; text mode needs str.
• Not naming the encoding in encode and decode.
• Seeking from the end in text mode, which is not allowed.
• Pickling to a text file. pickle needs "wb" and "rb".
• Only giving readlines()[-n:] with nothing to say about a large file.
• Not testing n larger than the file. A slice clips; say so.

For the journal

Two entries under practical 8. For the file operations: the aim, notes.txt written out as you made it, the mode table, and the four read methods with their output. Then the write, append and overwrite sequence with the file printed after each step, because that is the proof of what "w" does. Then the binary section: the bytes written and read back, the two TypeErrors, and one sentence saying text mode moves str and binary mode moves bytes. Then pickle with the dictionary that came back as a dictionary.

For the last n lines: all three functions, all three run on the same file, and the three row comparison table. One sentence: readlines() is clearest, deque(maxlen=n) holds only n lines, and seeking from the end touches only the tail, which is what a large file needs.

Quick revision

• open(path, mode), and always inside with, which closes even on an error.
• Modes: "r" read, "w" writes and EMPTIES first, "a" append, "x" create only,

"r+" both. Add "b" for binary.

• Reading: read() whole, read(n) n characters, readlines() a list, readline() one,

for line in handle one line at a time and the right way for a big file.

• write and writelines do not add newlines. print does.
• rstrip() removes the trailing newline.
• os.path.exists, os.path.getsize, os.rename, os.remove, os.listdir.
• Text mode moves str; binary mode moves bytes. s.encode("utf-8") and

b.decode("utf-8") convert.

• Indexing a bytes gives an int.
• tell() is the position, seek(n) moves, seek(0, 2) is the end. Seeking from the end needs

binary mode.

• pickle.dump(obj, handle) and pickle.load(handle), in "wb" and "rb", one load per

dump, in order. Never unpickle a file you did not create.

• Last n lines: readlines()[-n:] simplest, deque(handle, maxlen=n) for memory, seek from

the end for a huge file. A slice clips, so n bigger than the file is safe.

Questions you should be able to answer

1. Why is with open(...) better than open(...) and close()? Because with closes the file when the block ends even if an error is raised inside it, so a file is never left open and a write is never left unflushed.

2. What does opening a file in "w" do to what was in it? It empties it immediately, before anything is written.

3. Which read method should you use on a file too big for memory? for line in handle, which holds one line at a time.

4. Does write add a newline? No, and neither does writelines. Each string must carry its own "\n".

5. What is the difference between text mode and binary mode? Text mode reads and writes str, encoding and decoding on the way; binary mode reads and writes bytes with no translation.

6. handle.write("hello") on a file opened "wb" fails. Why? Binary mode needs bytes. Write b"hello" or "hello".encode("utf-8").

7. What does back[0] give for a bytes object? An int, the value of that byte, not a one character string.

8. What is seek(0, 2)? Move to the end: offset 0 measured from the end of the file. It needs binary mode.

9. Why pickle rather than write the text yourself? Because pickle returns the object as the same type, so a dictionary comes back a dictionary and can be indexed straight away.

10. What is the danger of pickle? Loading a pickle can execute code, so a pickle from somebody else is not safe. Use json for data that crosses between programs.

11. Give the three ways to read the last n lines and what each costs. readlines()[-n:] reads the whole file into memory; deque(handle, maxlen=n) reads it all but keeps only n lines; seeking from the end reads only the tail, which is the one to use on a very large file.

12. What happens if you ask for the last 100 lines of a 6 line file? You get 6. A slice clips rather than raising, and the deque and the seek versions were tested for it too.

\b is the whole exercise. It matches the empty place between a word character and a non-word character, so \bnote\b matches "note" standing alone and refuses it inside "notes", "notebook" and "denote". Notice in the output above that \bnote\b found exactly the standalone ones.

The raw string, and why every pattern has an r in front

import re

print("a plain string   :", "\bnote\b".encode("unicode_escape"))
print("a raw string     :", r"\bnote\b".encode("unicode_escape"))
print("with the r       :", re.findall(r"\bnote\b", "one note here"))
print("without the r    :", re.findall("\bnote\b", "one note here"))

a plain string   : b'\\x08note\\x08'
a raw string     : b'\\\\bnote\\\\b'
with the r       : ['note']
without the r    : []

In an ordinary Python string \b is the backspace character, so "\bnote\b" is not the pattern you typed at all and it matches nothing. The r prefix makes a raw string, in which a backslash is a backslash. Every regular expression in this book has the r, and writing a pattern without it is the second commonest error on this exercise after forgetting \b.

Python warns about an unrecognised escape in a plain string, so a pattern with \d in it and no r may raise a SyntaxWarning today and stop working in a future version. Use the r.

The program MU asks for

import re

word = "note"
pattern = re.compile(r"\b" + re.escape(word) + r"\b", re.IGNORECASE)

with open("report.txt") as handle:
    text = handle.read()

matches = pattern.findall(text)
print(f"the word {word!r} appears {len(matches)} time(s)")
print("the matches, exactly as they appeared:", matches)

the word 'note' appears 4 time(s)
the matches, exactly as they appeared: ['note', 'NOTE', 'Note', 'note']

Four things in those three lines of pattern.

r"\b" + word + r"\b" puts a boundary on each side, which is what makes it a word count.

re.escape(word) protects against a word containing a character the pattern language uses. Searching for "C++" without it is a broken pattern, because + means "one or more"; with it, the plus signs are treated as plain characters.

re.IGNORECASE makes it find "Note", "NOTE" and "note" alike. Whether you want that is a decision, so say which you chose in the journal. The output above shows the matches as they appeared in the file, which is how you demonstrate that the flag worked.

re.compile builds the pattern once. Inside a loop over thousands of lines, compiling each time is wasted work, and a compiled pattern also reads better: pattern.findall(text).

Case sensitive, for comparison

import re

with open("report.txt") as handle:
    text = handle.read()

for label, flags in [("case sensitive ", 0), ("ignoring case  ", re.IGNORECASE)]:
    found = re.findall(r"\bnote\b", text, flags)
    print(f"{label} {len(found)} match(es): {found}")

case sensitive  2 match(es): ['note', 'note']
ignoring case   4 match(es): ['note', 'NOTE', 'Note', 'note']

Two defensible answers, and the difference is one flag. An examiner who asks "how many times does the word appear" will accept either as long as you say which you counted.

findall, finditer, search and match

import re

with open("report.txt") as handle:
    text = handle.read()

pattern = re.compile(r"\bnote\b", re.IGNORECASE)

print("findall gives the matched strings:", pattern.findall(text))
print()
print("finditer gives match objects, with WHERE:")
for found in pattern.finditer(text):
    print(f"  {found.group()!r} at characters {found.start()} to {found.end()}")
print()
first = pattern.search(text)
print("search gives the first match only :", first.group(), "at", first.start())
print("match anchors at the start        :", pattern.match(text))
print("and that is None, because the file does not begin with 'note'")

findall gives the matched strings: ['note', 'NOTE', 'Note', 'note']

finditer gives match objects, with WHERE:
  'note' at characters 23 to 27
  'NOTE' at characters 105 to 109
  'Note' at characters 127 to 131
  'note' at characters 141 to 145

search gives the first match only : note at 23
match anchors at the start        : None
and that is None, because the file does not begin with 'note'

match is not "does it match"; it is "does it match here, at position zero". Confusing match with search is a standard trap, and the output above shows match returning None on a file that plainly contains the word.

Counting line by line, which is what a large file needs

import re

pattern = re.compile(r"\bnote\b", re.IGNORECASE)

total = 0
lines_with_it = 0
with open("report.txt") as handle:
    for number, line in enumerate(handle, 1):
        found = pattern.findall(line)
        if found:
            lines_with_it += 1
            total += len(found)
            print(f"  line {number}: {len(found)} -> {found}")

print(f"{total} occurrence(s) on {lines_with_it} line(s)")

  line 1: 1 -> ['note']
  line 3: 3 -> ['NOTE', 'Note', 'note']
4 occurrence(s) on 2 line(s)

This never holds more than one line, so it works on a file of any size, and it reports which lines matched, which is more useful than a single number. It is the version to put in the journal if you have room for only one.

Counting every word, with the same tool

import re
from collections import Counter

with open("report.txt") as handle:
    text = handle.read()

words = re.findall(r"\b\w+\b", text.lower())
counts = Counter(words)

print("words in all    :", len(words))
print("different words :", len(counts))
print("commonest five  :", counts.most_common(5))
print("'note' exactly  :", counts["note"])
print("'notes' exactly :", counts["notes"])
print("words containing note:", sorted(w for w in counts if "note" in w))

words in all    : 40
different words : 29
commonest five  : [('notes', 4), ('note', 4), ('the', 4), ('are', 3), ('help', 1)]
'note' exactly  : 4
'notes' exactly : 4
words containing note: ['denote', 'footnote', 'note', 'notebook', 'notes']

r"\b\w+\b" is "a run of word characters standing alone", which is a better definition of a word than splitting on spaces, because it drops the punctuation by itself. The last line is the proof of the whole chapter: several different words contain the letters, and only one of them is the word.

A few more patterns worth having

import re

sample = ("Contact 9820012345 or 022-24567890. Email help@munotes.in on 05/10/2026. "
          "Marks: 78, 92 and 45 out of 100.")

print("phone like 10 digits :", re.findall(r"\b\d{10}\b", sample))
print("any run of digits    :", re.findall(r"\d+", sample))
print("a date dd/mm/yyyy    :", re.findall(r"\b\d{2}/\d{2}/\d{4}\b", sample))
print("something@something  :", re.findall(r"\b[\w.]+@[\w.]+\b", sample))
print("capitalised words    :", re.findall(r"\b[A-Z]\w*", sample))
print("replace digits with #:", re.sub(r"\d", "#", "Marks: 78 and 92"))
print("split on punctuation :", re.split(r"[;,.]\s*", "one, two; three. four")[:4])

phone like 10 digits : ['9820012345']
any run of digits    : ['9820012345', '022', '24567890', '05', '10', '2026', '78', '92', '45', '100']
a date dd/mm/yyyy    : ['05/10/2026']
something@something  : ['help@munotes.in']
capitalised words    : ['Contact', 'Email', 'Marks']
replace digits with #: Marks: ## and ##
split on punctuation : ['one', 'two', 'three', 'four']

{10} means exactly ten of the thing before it, {2,4} means two to four, and {2,} means two or more. Those, with \b, \d, \w and the character class, cover almost everything this paper can ask for.

Procedure

1. Create report.txt with several lines in which the word appears alone, inside longer words,

in capitals and with punctuation attached.

1. Save as practical9a.py. First count with str.count and with split, and record both wrong

answers.

1. import re. Build the pattern up: the plain word, then [Nn], then \w*, then \bword\b,

printing findall for each so the difference is visible.

1. Show that "\bnote\b" without the r matches nothing, and that r"\bnote\b" works.
2. Write the answer: re.compile(r"\b" + re.escape(word) + r"\b", re.IGNORECASE), then

pattern.findall(text) and len(...).

1. Print the matches themselves, not only the count, so the flag can be seen working.
2. Run it once case sensitive and once ignoring case and record both numbers.
3. Rewrite it to count line by line and report which lines matched.

Result

str.count("note") and the two split counts all gave different and wrong answers on report.txt, because count finds the letters inside longer words and split leaves punctuation attached. re.findall(r"\bnote\b", text) with re.IGNORECASE gave the correct count, and printing the matches showed which capitalisations were included. Without the r prefix the same pattern found nothing, because \b in a plain string is a backspace character. match returned None while search found the word, confirming that match anchors at position zero. The line by line version gave the same total and also named the lines.

Where marks are lost

• No \b. Then "note" is found inside "notes", "notebook" and "denote", and the count is too

high. This is the exercise.

• No r prefix. "\b" is a backspace, so the pattern matches nothing at all.
• Using str.count and calling it a regular expression.
• split() and ==, which misses "note." and "note;".
• Not saying whether case was ignored. Two different answers; name yours.
• No re.escape around a word the user typed, which breaks on a word containing . or +.
• Confusing match with search. match only looks at the start.
• Compiling inside the loop. Compile once, outside.
• Printing only the number. Printing the matches is what proves the pattern.

For the journal

The aim in MU's words. report.txt written out as you made it, with the word appearing alone, inside another word, capitalised and next to punctuation, because the file is what makes the exercise real. Then the wrong counts from str.count and split, with one sentence on why each is wrong. Then the pattern built up piece by piece with its findall output at each step, which is the best single thing on this page for an examiner. Then the answer, the count and the matches themselves. Then the case sensitive and case insensitive totals, and the line by line version. The conclusion in one sentence: \b matches the boundary between a word character and a non-word character, so \bnote\b counts the word and not the letters, and the pattern must be a raw string or \b is a backspace.

Quick revision

• import re. Every pattern is a raw string, r"...", or \b is a backspace.
• \b is a word boundary and matches no character. r"\bword\b" is the word count.
• . any character, \. a real dot, [abc] one of these, [^abc] none of these.
• ? optional, * any number, + one or more, {n} exactly n, {n,m} n to m.
• \w word character, \s whitespace, \d digit. Capitals negate them: \W, \S, \D.
• ^ start, $ end.
• re.escape(word) before putting a user's word in a pattern.
• re.IGNORECASE as the third argument, or a flag to re.compile.
• findall the strings, finditer the positions, search the first anywhere.

match looks only at the start. sub replaces, split splits.

• re.compile once, outside any loop.
• r"\b\w+\b" with Counter is a word frequency table that drops punctuation by itself.

Questions you should be able to answer

1. Why is text.count("note") the wrong answer to MU's row? Because it counts the letters wherever they appear, so it also counts them inside "notes", "notebook" and "denote".

2. Why is splitting on whitespace and comparing also wrong? Because punctuation stays attached, so "note." and "note;" do not equal "note" and are missed.

3. What does \b match? A word boundary: the empty position between a word character and a non-word character. It consumes nothing.

4. Write the pattern that counts the word "note". r"\bnote\b".

5. Why must the pattern be a raw string? Because in a normal Python string \b is the backspace character, so the pattern is not what you typed and matches nothing.

6. What is re.escape for? To treat a word's characters as plain text. Without it, searching for "C++" is a broken pattern, since + means "one or more".

7. What is the difference between re.match and re.search? match only matches at the very start of the string; search looks anywhere. A file containing the word in the middle gives None from match.

8. Which call do you use to count, and which to find out where? findall to count, because it returns the list of matched strings. finditer for positions, through start() and end().

9. Why compile the pattern? So it is built once rather than on every line, and so the code reads as pattern.findall(line).

10. Give a pattern for a ten digit phone number and one for a date as dd/mm/yyyy. r"\b\d{10}\b" and r"\b\d{2}/\d{2}/\d{4}\b".

The capturing group is why findall returns the address and not the whole tag. With a group in the pattern, findall gives you the group; with no group, it gives the whole match. That is the single most useful thing to know about findall.

Greedy against lazy, which the naive pattern got right by luck

import re

line = '<a href="first.html">one</a> and <a href="second.html">two</a>'

print("greedy .*  :", re.findall(r'href="(.*)"', line))
print("lazy   .*? :", re.findall(r'href="(.*?)"', line))

greedy .*  : ['first.html">one</a> and <a href="second.html']
lazy   .*? : ['first.html', 'second.html']

is greedy: it takes as much as it can and then gives back only as much as it must, so . ran from the first quote all the way to the last one on the line and swallowed the tag in between. *? is lazy: it takes as little as possible, so it stops at the first closing quote.

Any pattern that matches up to a closing delimiter needs the lazy form, or the first and the last delimiter on the line are paired together. It is the commonest bug in this exercise after the quoting.

The character class [^"\'>\s]+ used in the answer above sidesteps the question entirely, because it cannot cross a quote or a > at all. That is why it is the better pattern: it does not depend on getting greediness right.

The answer

import re

pattern = re.compile(r'''<a\s[^>]*?href\s*=\s*(["']?)([^"'>\s]+)\1''', re.IGNORECASE | re.DOTALL)

with open("page.html") as handle:
    html = handle.read()

links = [match.group(2) for match in pattern.finditer(html)]

print(f"{len(links)} hyperlink(s) found:")
for number, link in enumerate(links, 1):
    print(f"  {number}. {link}")

7 hyperlink(s) found:
  1. https://www.munotes.in/notes/
  2. https://www.munotes.in/syllabus/
  3. https://www.munotes.in/aibe/
  4. /for-committees/
  5. /solved-papers/
  6. /blog/
  7. #top

Every piece of that pattern earns its place:

\1 is the clever part. It means "whatever group 1 matched", so a link opened with a double quote must close with a double quote, one opened with a single quote with a single quote, and one opened with nothing closes with nothing. One pattern, three quoting styles, and no chance of pairing a single quote with a double one.

Notice what the output does not contain: the <a name="bookmark"> tag, because it has no href, and the <img src=...>, because it is not an a tag. Both are in the file on purpose.

The same job with the standard library parser

A regular expression is what MU's row asks for. A parser is what the job actually deserves, and being able to say why is worth a mark.

from html.parser import HTMLParser


class LinkFinder(HTMLParser):
    """Collects the href of every anchor tag."""

    def __init__(self):
        super().__init__()
        self.links = []

    def handle_starttag(self, tag, attrs):
        if tag == "a":
            for name, value in attrs:
                if name == "href":
                    self.links.append(value)


with open("page.html") as handle:
    html = handle.read()

finder = LinkFinder()
finder.feed(html)

print(f"the parser found {len(finder.links)} link(s):")
for link in finder.links:
    print("  ", link)

the parser found 7 link(s):
   https://www.munotes.in/notes/
   https://www.munotes.in/syllabus/
   https://www.munotes.in/aibe/
   /for-committees/
   /solved-papers/
   /blog/
   #top

HTMLParser is in the standard library, so nothing needs installing. It reads the document as a document: it lower cases the tag and the attribute names itself, it handles every quoting style because that is the specification it implements, and it cannot be fooled by a > inside an attribute value.

Why the parser is right and the pattern is not, in one example

import re
from html.parser import HTMLParser


class LinkFinder(HTMLParser):
    def __init__(self):
        super().__init__()
        self.links = []

    def handle_starttag(self, tag, attrs):
        if tag == "a":
            for name, value in attrs:
                if name == "href":
                    self.links.append(value)


tricky = '''<a title="the > sign in a title" href="real.html">a link</a>
<!-- <a href="commented-out.html">this is inside a comment</a> -->
<a href="also-real.html">another</a>'''

by_pattern = re.findall(r'''<a\s[^>]*?href\s*=\s*(["']?)([^"'>\s]+)\1''',
                        tricky, re.IGNORECASE | re.DOTALL)
finder = LinkFinder()
finder.feed(tricky)

print("the pattern says:", [pair[1] for pair in by_pattern])
print("the parser says :", finder.links)

the pattern says: ['commented-out.html', 'also-real.html']
the parser says : ['real.html', 'also-real.html']

Read the two lines. The pattern lost real.html, because the > inside the title attribute looked to [^>]*? like the end of the tag. And it found commented-out.html, which is inside an HTML comment and is not a link on the page at all.

HTML is not a regular language, so no regular expression can parse it. That is the honest answer, and the right thing to write in the journal: the pattern is what the exercise asks for and it works on ordinary pages; a parser is what to reach for when the input is not under your control. Saying that, rather than defending the pattern, is what a good answer looks like.

What to do with the links once you have them

import re
from urllib.parse import urljoin, urlparse

with open("page.html") as handle:
    html = handle.read()

pattern = re.compile(r'''<a\s[^>]*?href\s*=\s*(["']?)([^"'>\s]+)\1''',
                     re.IGNORECASE | re.DOTALL)
links = [m.group(2) for m in pattern.finditer(html)]

absolute = [link for link in links if urlparse(link).scheme]
relative = [link for link in links if not urlparse(link).scheme
            and not link.startswith("#")]
fragments = [link for link in links if link.startswith("#")]

print("absolute  :", absolute)
print("relative  :", relative)
print("fragments :", fragments)
print()
base = "https://www.munotes.in/notes/"
print("resolved against", base)
for link in links:
    print("  ", urljoin(base, link))

absolute  : ['https://www.munotes.in/notes/', 'https://www.munotes.in/syllabus/', 'https://www.munotes.in/aibe/']
relative  : ['/for-committees/', '/solved-papers/', '/blog/']
fragments : ['#top']

resolved against https://www.munotes.in/notes/
   https://www.munotes.in/notes/
   https://www.munotes.in/syllabus/
   https://www.munotes.in/aibe/
   https://www.munotes.in/for-committees/
   https://www.munotes.in/solved-papers/
   https://www.munotes.in/blog/
   https://www.munotes.in/notes/#top

urlparse splits an address into its parts, and a scheme such as https is what makes an address absolute. urljoin resolves a relative address against the page it was found on, which is what a browser does and what a crawler has to do. Neither needs installing.

The link text as well as the address

import re

with open("page.html") as handle:
    html = handle.read()

pattern = re.compile(
    r'''<a\s[^>]*?href\s*=\s*(["']?)([^"'>\s]+)\1[^>]*>(.*?)</a\s*>''',
    re.IGNORECASE | re.DOTALL)

for match in pattern.finditer(html):
    address = match.group(2)
    words = re.sub(r"\s+", " ", match.group(3)).strip()
    print(f"  {address:<36} {words}")

  https://www.munotes.in/notes/        Notes, double quoted
  https://www.munotes.in/syllabus/     Syllabus, single quoted
  https://www.munotes.in/aibe/         AIBE, not quoted at all
  /for-committees/                     href is the SECOND attribute
  /solved-papers/                      the tag is spread over two lines
  /blog/                               the tag is in capitals
  #top                                 a fragment

Group 3 is the text between the opening and the closing tag, and re.sub(r"\s+", " ", ...) folds any run of whitespace into one space, which is what a browser does when it displays it. The closing </a\s*> allows a space before the >.

Procedure

1. Create page.html with links using double quotes, single quotes, no quotes, href as a later

attribute, a tag split across two lines, a tag in capitals, an a tag with no href, and an img tag. That file is the exercise.

1. Save as practical9b.py. Run the naive pattern r'<a href="(.*?)">' first and record how many

of your links it missed.

1. Note that the naive pattern also returns one address that is not an address, and say why.
2. Build the pattern up in four steps, printing findall at each: double quotes only, either

quote, quotes optional, then case insensitive.

1. Show greedy against lazy on one line holding two links.
2. Write the answer with the back reference \1 and both flags, and print every link numbered.
3. Confirm that the a tag with no href and the img tag are not in the output.
4. Write the HTMLParser version and show it gives the same answer.
5. Run both over the tricky sample with a > inside an attribute and a link inside a comment, and

record the two disagreements.

1. Split the links into absolute, relative and fragment, and resolve them with urljoin.

Result

The naive pattern returned two results out of seven links: it missed the single quoted, unquoted, later-attribute, multi-line and capitalised ones, and it mangled the fragment link into #top" title="to the top by running on to the "> at the end of the tag. The four step build recovered each family in turn. Greedy . swallowed the tag between two links on one line and lazy .? did not. The final pattern, with the back reference and both flags, found every hyperlink in page.html and did not report the a tag with no href or the img tag. HTMLParser gave the same list. On the tricky sample the pattern lost the link whose title attribute contained a > and wrongly reported a link inside an HTML comment, while the parser got both right.

Where marks are lost

• Only handling double quotes. Single quotes and no quotes are both ordinary HTML.
• Assuming href is the first attribute. <a class="..." href="..."> is everywhere.
• A case sensitive pattern. <A HREF= is valid.
• Greedy . instead of .?, which pairs the first quote with the last on the line.
• No capturing group, so findall returns whole tags instead of addresses.
• Reporting <a name="..."> as a link. It has no href.
• Reporting <img src="...">. It is not a hyperlink.
• Claiming a regular expression parses HTML. It does not, and saying so is the better answer.
• Not showing the naive pattern failing. The comparison is the evidence.

For the journal

The aim in MU's words, with her <a href="..."> copied exactly. page.html written out as you made it, and one line saying which awkward shape each link is there to test. The naive pattern and its output, with a count of what it missed. The four step build with the output at each step. The greedy against lazy pair. Then the answer, with the table explaining each piece of the pattern and the numbered list of links. One sentence on the back reference: \1 is whatever group 1 matched, so the closing quote is forced to be the same as the opening one. Then the parser version and the tricky sample where the two disagree, and the conclusion: HTML is not a regular language, so the pattern is right for an ordinary page and a parser is right when the input is not under your control.

Quick revision

• The naive r'<a href="(.*?)">' misses single quotes, no quotes, a later href, a multi-line

tag and capitals, and mangles a link followed by another attribute.

• A capturing group (...) makes findall return the group instead of the whole match.
• ["\']? is an optional quote of either kind. [^"'>\s]+ is an address: no quote, no >, no

space.

• is greedy and ? is lazy. Matching up to a delimiter needs the lazy form.
• \1 is a back reference to group 1, which forces the closing quote to match the opening

one.

• re.IGNORECASE for <A HREF=, re.DOTALL so a class may cross a newline.
• Use '''triple quotes''' for a pattern containing both quote characters.
• <a\s not <a, or the pattern also matches <abbr and <article.
• html.parser.HTMLParser with handle_starttag does the job properly, and is in the standard

library.

• HTML is not a regular language. A pattern fails on a > inside an attribute and on a link

inside a comment. Say so.

• urlparse(link).scheme tells absolute from relative; urljoin(base, link) resolves it.

Questions you should be able to answer

1. What is wrong with r'<a href="(.*?)">' on an ordinary page? It requires double quotes, requires href to be the first attribute, is case sensitive and cannot cross a newline. It also returns a wrong address when another attribute follows, because it runs on to the "> at the end of the tag.

2. What does a capturing group do to findall? It makes findall return what the group matched rather than the whole match. With two groups it returns tuples.

3. What is the difference between . and .? . is greedy and takes as much as it can; .? is lazy and takes as little as it can. Matching up to a closing quote needs the lazy form.

4. What does \1 mean in a pattern? Whatever group 1 matched. Here it forces the closing quote to be the same character as the opening one.

5. Why <a\s rather than <a? Because <a also matches the start of <abbr and <article. The \s requires whitespace after the tag name.

6. Why is [^"'>\s]+ better than .*? for the address? Because it cannot cross a quote, a > or a space at all, so it does not depend on getting greediness right.

7. What does re.DOTALL change? It lets . and a negated class match a newline, so a tag spread over two lines is still one match.

8. Give two cases where the pattern is wrong and the parser is right. A > inside an attribute value, which ends the tag as far as the pattern is concerned, and a link inside an HTML comment, which the pattern reports and the parser ignores.

9. Why can no regular expression parse HTML in general? Because HTML is not a regular language: it nests, and comments, attribute values and character references can all contain the characters a pattern uses as landmarks.

10. Which of these is a hyperlink: <a name="top">, <img src="x.png">, <a href="#top">? Only the last. The first has no href and the second is not an a tag.

Once the strings are dates, < means what you want it to mean, and so do >, ==, <= and >=. A date knows how to compare itself with another date.

Subtracting two dates gives a timedelta

from datetime import datetime, date

first = datetime.strptime("05/10/2026", "%d/%m/%Y").date()
second = datetime.strptime("12/03/2020", "%d/%m/%Y").date()

gap = first - second
print("first - second    :", gap)
print("its type          :", type(gap).__name__)
print("in days           :", gap.days)
print("in weeks          :", gap.days // 7, "weeks and", gap.days % 7, "days")
print("about years       :", round(gap.days / 365.25, 2))
print("the other way     :", (second - first).days, "which is negative")
print("always positive   :", abs((second - first).days))

first - second    : 2398 days, 0:00:00
its type          : timedelta
in days           : 2398
in weeks          : 342 weeks and 4 days
about years       : 6.57
the other way     : -2398 which is negative
always positive   : 2398

A timedelta is a length of time. Subtracting two dates gives one, and .days is the number of whole days in it. Note that subtracting the later from the earlier gives a negative number, so abs(...) is what you want when you only care how far apart they are.

Adding a timedelta to a date gives another date, which is how you answer "what is the date 90 days from now":

from datetime import date, timedelta

start = date(2026, 10, 5)

print("the day           :", start)
print("plus 1 day        :", start + timedelta(days=1))
print("plus 90 days      :", start + timedelta(days=90))
print("minus 30 days     :", start - timedelta(days=30))
print("plus 3 weeks      :", start + timedelta(weeks=3))
print("crossing a year   :", date(2026, 12, 25) + timedelta(days=10))

the day           : 2026-10-05
plus 1 day        : 2026-10-06
plus 90 days      : 2027-01-03
minus 30 days     : 2026-09-05
plus 3 weeks      : 2026-10-26
crossing a year   : 2027-01-04

timedelta takes days, weeks, hours, minutes and seconds. It does not take months or years, and the reason is worth a sentence in the journal: a month has no fixed length, so "one month after the 31st of January" has no single right answer.

What happens when the date is not valid

from datetime import datetime

try:
    print(datetime.strptime("31/02/2026", "%d/%m/%Y"))
except ValueError as error:
    print("refused, and the kind of error is", type(error).__name__)
    print("the wording of the message changed between Python 3.12 and 3.14,")
    print("so read your own; both say the day is out of range for February")

refused, and the kind of error is ValueError
the wording of the message changed between Python 3.12 and 3.14,
so read your own; both say the day is out of range for February

strptime checks the calendar, so it refuses the 31st of February. It also refuses a string that does not match the format at all:

from datetime import datetime

print(datetime.strptime("2026-10-05", "%d/%m/%Y"))

ValueError: time data '2026-10-05' does not match format '%d/%m/%Y'

The complete answer catches both:

from datetime import datetime


def parse(text):
    """A date from a DD/MM/YYYY string, or None when it cannot be read."""
    try:
        return datetime.strptime(text.strip(), "%d/%m/%Y").date()
    except ValueError:
        return None


for text in ["05/10/2026", "5/10/2026", "29/02/2024", "29/02/2023",
             "31/02/2026", "2026-10-05", "hello"]:
    answer = parse(text)
    if answer is None:
        print(f"  {text!r:<14} REFUSED")
    else:
        print(f"  {text!r:<14} -> {answer}")

  '05/10/2026'   -> 2026-10-05
  '5/10/2026'    -> 2026-10-05
  '29/02/2024'   -> 2024-02-29
  '29/02/2023'   REFUSED
  '31/02/2026'   REFUSED
  '2026-10-05'   REFUSED
  'hello'        REFUSED

In your own program print the message from the ValueError as well, because it says what was wrong. It is left out here only because its exact wording changed between Python 3.12 and 3.14 and this page has to be true on both.

Three of those lines deserve a note.

"5/10/2026" with one digit is accepted. %d is documented as zero padded, and strptime is lenient about the padding when it parses, though strftime always writes two digits.

"29/02/2024" is accepted and "29/02/2023" is not, because 2024 is a leap year and 2023 is not. That single pair is the best possible test of a date program and it belongs in the journal.

The refusals come from the library, not from our own checking. strptime applies the calendar itself, which is why the program has no leap year test in it at all.

Leap years, since the 29th of February decides this exercise

from calendar import isleap

for year in [2000, 1900, 2023, 2024, 2026, 2100]:
    divisible_by_4 = year % 4 == 0
    divisible_by_100 = year % 100 == 0
    divisible_by_400 = year % 400 == 0
    print(f"{year}  /4 {divisible_by_4!s:<5} /100 {divisible_by_100!s:<5} "
          f"/400 {divisible_by_400!s:<5} leap? {isleap(year)}")

2000  /4 True  /100 True  /400 True  leap? True
1900  /4 True  /100 True  /400 False leap? False
2023  /4 False /100 False /400 False leap? False
2024  /4 True  /100 False /400 False leap? True
2026  /4 False /100 False /400 False leap? False
2100  /4 True  /100 True  /400 False leap? False

The rule in one line. A year is a leap year when it divides by 4, except that a century year must divide by 400. So 2000 is a leap year and 1900 is not, which is the pair that catches a program written with only the divide-by-4 test. calendar.isleap applies the whole rule, so use it rather than writing the test out.

Printing a date the way you want it

from datetime import date

day = date(2026, 10, 5)

print("the default          :", day)
print("%d/%m/%Y             :", day.strftime("%d/%m/%Y"))
print("%d %B %Y             :", day.strftime("%d %B %Y"))
print("%A, %d %b %Y         :", day.strftime("%A, %d %b %Y"))
print("%Y-%m-%d, sortable   :", day.strftime("%Y-%m-%d"))
print("the ISO form         :", day.isoformat())
print("the weekday number   :", day.weekday(), "with Monday as 0")
print("or Monday as 1       :", day.isoweekday())
print("day of the year      :", day.timetuple().tm_yday)

the default          : 2026-10-05
%d/%m/%Y             : 05/10/2026
%d %B %Y             : 05 October 2026
%A, %d %b %Y         : Monday, 05 Oct 2026
%Y-%m-%d, sortable   : 2026-10-05
the ISO form         : 2026-10-05
the weekday number   : 0 with Monday as 0
or Monday as 1       : 1
day of the year      : 278

strptime reads a string into a date and strftime writes a date out as a string. The two names are almost identical and the p and the f are the only difference. P is for parse and f is for format. Getting them the wrong way round is the commonest error with dates in any language.

Sorting a list of DD/MM/YYYY dates

from datetime import datetime

dates = ["05/10/2026", "12/03/2020", "01/01/2026", "31/12/2019", "29/02/2024"]

print("sorted as STRINGS, which is wrong:")
print(" ", sorted(dates))

print("sorted as dates, which is right:")
print(" ", sorted(dates, key=lambda text: datetime.strptime(text, "%d/%m/%Y")))

parsed = [datetime.strptime(text, "%d/%m/%Y").date() for text in dates]
print("earliest :", min(parsed).strftime("%d/%m/%Y"))
print("latest   :", max(parsed).strftime("%d/%m/%Y"))
print("in order :", [d.strftime("%d/%m/%Y") for d in sorted(parsed)])

sorted as STRINGS, which is wrong:
  ['01/01/2026', '05/10/2026', '12/03/2020', '29/02/2024', '31/12/2019']
sorted as dates, which is right:
  ['31/12/2019', '12/03/2020', '29/02/2024', '01/01/2026', '05/10/2026']
earliest : 31/12/2019
latest   : 05/10/2026
in order : ['31/12/2019', '12/03/2020', '29/02/2024', '01/01/2026', '05/10/2026']

Read the two sorted lists against each other. The string sort puts the 1st of January 2026 before the 5th of October 2026 by luck and the 31st of December 2019 after both of them, which is wrong. A key that parses each string fixes it, and it is the same key= argument as in [Practical 7: a Common Member, and a Dictionary Sorted by Value].

Procedure

1. Save as practical10a.py. First compare the two dates as plain strings and record the wrong

answer, with one sentence saying why.

1. from datetime import datetime. Parse each string with

datetime.strptime(text, "%d/%m/%Y").date().

1. Read both dates with input().
2. Compare with < and print which is earlier, with an elif and an else for equal dates.
3. Subtract them and print abs(...).days.
4. Try an invalid date, 31/02/2026, and record the ValueError and its message on your machine.
5. Try 29/02/2024 and 29/02/2023 and record that one is accepted and one is not.
6. Print one of the dates back out with strftime("%d/%m/%Y").
7. Sort a list of five such strings as strings and then with a parsing key, and compare.

Result

Comparing "05/10/2026" with "12/03/2020" as strings said the first was earlier, which is wrong, because the string comparison reaches the day before the year. Parsed with strptime and compared as dates, the program correctly reported 12/03/2020 as the earlier and printed the gap in days. strptime refused 31/02/2026 and 2026-10-05 with ValueError, accepted 29/02/2024 and refused 29/02/2023, confirming that it checks the calendar including the leap year rule. isleap gave True for 2000 and False for 1900, which is the century rule. Sorting the five strings as strings gave a wrong order and sorting with a parsing key gave the right one.

Where marks are lost

• Comparing the strings. It reaches the day first and is wrong. This is the exercise.
• Splitting on / and comparing the pieces one at a time without converting them to numbers,

which has the same fault.

• %y instead of %Y. One is two digits, the other four.
• Getting the order wrong in the format, "%m/%d/%Y", which quietly reads the 5th of October

as the 10th of May.

• Confusing strptime with strftime. p parses, f formats.
• No try around the parse, so one bad input ends the program with a traceback.
• Not testing the 29th of February. It is the one test that proves the parse checks the

calendar.

• Using timedelta(months=1), which does not exist.

For the journal

The aim in MU's words, with her DD/MM/YYYY. The string comparison first, with its wrong answer and one sentence saying it compares the day because the day comes first. Then the parse with strptime and the format string explained code by code. The program, the run for two dates you chose, and the number of days between them. Then the three refusals: 31/02/2026, the wrong format, and 29/02/2023 against 29/02/2024 accepted. One sentence on leap years: divisible by 4, except a century year must divide by 400, and calendar.isleap applies the whole rule. The conclusion: a DD/MM/YYYY string cannot be compared as a string, and once parsed into a date the ordinary comparison operators are correct.

Quick revision

• A DD/MM/YYYY string compares wrongly as a string, because the day comes first. YYYY-MM-DD

compares correctly, which is why that format exists.

• datetime.strptime(text, "%d/%m/%Y") parses. .date() drops the time.
• %d day, %m month, %Y four digit year, %y two digit, %B month name, %A weekday

name.

• strptime parses, strftime formats. p for parse, f for format.
• Once parsed, <, >, == all work on dates.
• first - second gives a timedelta; .days is the whole days; it can be negative, so use

abs.

• timedelta(days=, weeks=, hours=). There is no months or years, because a month has no

fixed length.

• strptime checks the calendar: 31/02 and 29/02 in a non leap year both raise ValueError.
• Leap year: divisible by 4, except a century year must be divisible by 400. So 2000 yes, 1900 no.

calendar.isleap knows.

• weekday() has Monday as 0; isoweekday() has Monday as 1.
• Sort DD/MM/YYYY strings with key=lambda t: datetime.strptime(t, "%d/%m/%Y").

Questions you should be able to answer

1. Why can two DD/MM/YYYY strings not be compared directly? Because a string comparison goes character by character from the left, and the leftmost part is the day, so it compares the days first and never reaches the years unless the days are equal.

2. Which date format does compare correctly as a string, and why? YYYY-MM-DD, because its parts run from the largest unit to the smallest with fixed widths.

3. Write the line that turns "05/10/2026" into a date. datetime.strptime("05/10/2026", "%d/%m/%Y").date().

4. What is the difference between %Y and %y? %Y is a four digit year and %y a two digit one.

5. What is the difference between strptime and strftime? strptime parses a string into a date; strftime formats a date into a string. The p is for parse and the f for format.

6. What do you get by subtracting two dates? A timedelta, whose .days is the number of whole days. It is negative if you subtract the later from the earlier.

7. Why does timedelta have no months argument? Because a month has no fixed length, so adding one to the 31st of January has no single correct answer.

8. What does strptime("31/02/2026", "%d/%m/%Y") do? It raises ValueError, because it checks the calendar and February has no 31st.

9. State the leap year rule and give the pair that tests it. Divisible by 4, except that a century year must be divisible by 400. 2000 is a leap year and 1900 is not.

10. Sort a list of DD/MM/YYYY strings into date order. sorted(dates, key=lambda text: datetime.strptime(text, "%d/%m/%Y")).

The wrong way to compare two pieces of code

import time


def with_loop(n):
    total = 0
    for i in range(n):
        total += i
    return total


def with_sum(n):
    return sum(range(n))


for label, function in [("explicit loop", with_loop), ("built in sum", with_sum)]:
    start = time.perf_counter()
    answer = function(100_000)
    elapsed = time.perf_counter() - start
    print(f"{label:<14} answer {answer} in {elapsed * 1000:.3f} ms")

explicit loop  answer 4999950000 in 3.368 ms
built in sum   answer 4999950000 in 0.856 ms

Both answers are right and the two times are a single measurement each. That is not enough to conclude anything, and saying so is the difference between a measurement and a guess. The next section is the fix.

timeit, which is the right tool

import timeit


def with_loop(n):
    total = 0
    for i in range(n):
        total += i
    return total


def with_sum(n):
    return sum(range(n))


runs = 200
loop_total = timeit.timeit(lambda: with_loop(100_000), number=runs)
sum_total = timeit.timeit(lambda: with_sum(100_000), number=runs)

print(f"over {runs} runs")
print(f"  explicit loop {loop_total / runs * 1000:.3f} ms per run")
print(f"  built in sum  {sum_total / runs * 1000:.3f} ms per run")
print(f"  sum was about {loop_total / sum_total:.1f} times faster on this machine")

over 200 runs
  explicit loop 3.458 ms per run
  built in sum  0.973 ms per run
  sum was about 3.6 times faster on this machine

timeit runs the code many times and gives the total, so dividing by the count gives a per run figure that is far steadier than one reading. It also turns off the garbage collector during the run, which removes another source of noise.

The ratio is the finding, not the milliseconds. Your own machine will print different times and a similar ratio, and the reason the built in sum wins is that its loop runs in compiled code rather than in the interpreter.

The way to report a measurement honestly

import statistics
import timeit


def with_loop(n):
    total = 0
    for i in range(n):
        total += i
    return total


samples = [timeit.timeit(lambda: with_loop(50_000), number=20) / 20 * 1000
           for _ in range(7)]

print(f"seven samples, milliseconds each:")
print("  ", [round(s, 3) for s in samples])
print(f"  best    {min(samples):.3f} ms")
print(f"  median  {statistics.median(samples):.3f} ms")
print(f"  worst   {max(samples):.3f} ms")
print(f"  spread  {max(samples) - min(samples):.3f} ms")

seven samples, milliseconds each:
   [1.475, 1.554, 1.556, 1.492, 1.468, 1.439, 1.461]
  best    1.439 ms
  median  1.475 ms
  worst   1.556 ms
  spread  0.117 ms

Report the best or the median, never the mean, and never a single reading. The worst sample usually means something else on the machine took the processor for a moment, which says nothing about your program. Quoting the spread as well shows you know how much to trust the figure.

A decorator, which is the tidy way to time a function

import time
from functools import wraps


def timed(function):
    """Print how long the function took, every time it is called."""

    @wraps(function)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = function(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"  {function.__name__}{args} took {elapsed * 1000:.3f} ms")
        return result

    return wrapper


@timed
def factorial(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result


digits = len(str(factorial(1000)))
print("1000! has", digits, "digits")

  factorial(1000,) took 0.273 ms
1000! has 2568 digits

@timed above def factorial means "pass this function through timed and use what comes back". The wrapper times the call and passes the answer on, so nothing else in the program changes. @wraps copies the original name and docstring onto the wrapper, so function.__name__ still says factorial.

The digit count is exact and the same on every machine; the time is not.

Part two: the calendar module

MU's question

import calendar

year = 2026
month = 10

first_weekday, days_in_month = calendar.monthrange(year, month)

print(f"{calendar.month_name[month]} {year}")
print(f"  monthrange gives two values, unpacked above")
print(f"  the first day is weekday number {int(first_weekday)}")
print(f"  which is {calendar.day_name[first_weekday]}")
print(f"  and the month has {days_in_month} days")

October 2026
  monthrange gives two values, unpacked above
  the first day is weekday number 3
  which is Thursday
  and the month has 31 days

calendar.monthrange(year, month) returns a tuple of two things, which is [Practical 8: the Tuple Return, Area and Circumference] again: the weekday of the first day and the number of days in the month. That one call answers MU's row.

The int() around the weekday is not decoration. From Python 3.12 the weekday comes back as a member of an enumeration called calendar.Day, so printing the raw tuple shows (calendar.THURSDAY, 31) on a new Python and (3, 31) on an older one. It behaves as the number 3 in every way that matters, including indexing day_name, and int() makes the printed output the same on every version.

Monday is 0 and Sunday is 6 in the calendar module, and calendar.day_name is the list that turns the number into a name.

There is also a direct call:

import calendar

print("weekday(2026, 10, 5) =", calendar.weekday(2026, 10, 5),
      "which is", calendar.day_name[calendar.weekday(2026, 10, 5)])
print("weekday(2026, 10, 1) =", calendar.weekday(2026, 10, 1),
      "which is", calendar.day_name[calendar.weekday(2026, 10, 1)])
print()
print("the seven day names:", list(calendar.day_name))
print("abbreviated        :", list(calendar.day_abbr))
print("the month names    :", list(calendar.month_name)[1:])

weekday(2026, 10, 5) = 0 which is Monday
weekday(2026, 10, 1) = 3 which is Thursday

the seven day names: ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
abbreviated        : ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
the month names    : ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']

calendar.month_name has an empty string at index 0, so that month_name[1] is January and the index matches the month number. That is why the last line above slices from 1. It is a small thing and it produces a blank first entry in anybody's output who forgets it.

The program

import calendar


def first_day_of(year, month):
    """The name of the weekday on which the given month starts."""
    if not 1 <= month <= 12:
        raise ValueError("a month is 1 to 12")
    weekday_number, _ = calendar.monthrange(year, month)
    return calendar.day_name[weekday_number]


year = int(input("Enter the year  (for example 2026): "))
month = int(input("Enter the month (1 to 12)        : "))

print(f"{calendar.month_name[month]} {year} begins on a {first_day_of(year, month)}")
print(f"and has {calendar.monthrange(year, month)[1]} days")

2026
10

Enter the year  (for example 2026): Enter the month (1 to 12)        : October 2026 begins on a Thursday
and has 31 days

Printing the month, which is what makes it a journal entry

import calendar

print(calendar.month(2026, 10))

    October 2026
Mo Tu We Th Fr Sa Su
          1  2  3  4
 5  6  7  8  9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31

calendar.month(year, month) returns the whole month as a string, laid out as a calendar. Read the first row against the program above: the 1st sits under the column the program named.

import calendar

print("as a list of weeks, with 0 for a day in another month:")
for week in calendar.monthcalendar(2026, 10):
    print("  ", week)

print()
print("only the real days of the first week:",
      [day for day in calendar.monthcalendar(2026, 10)[0] if day != 0])

as a list of weeks, with 0 for a day in another month:
   [0, 0, 0, 1, 2, 3, 4]
   [5, 6, 7, 8, 9, 10, 11]
   [12, 13, 14, 15, 16, 17, 18]
   [19, 20, 21, 22, 23, 24, 25]
   [26, 27, 28, 29, 30, 31, 0]

only the real days of the first week: [1, 2, 3, 4]

monthcalendar gives the month as a list of weeks, each a list of seven day numbers. A day belonging to another month is printed as 0. That is the shape to use when a program needs to work with the weeks rather than print them.

The rest of the module, briefly

import calendar

print("is 2024 a leap year?     ", calendar.isleap(2024))
print("is 1900 a leap year?     ", calendar.isleap(1900))
print("leap years 2000 to 2030  :", calendar.leapdays(2000, 2030))
print("days in February 2024    :", calendar.monthrange(2024, 2)[1])
print("days in February 2023    :", calendar.monthrange(2023, 2)[1])
print("the first day of the week:", calendar.firstweekday(), "which is Monday")
print()
print("every month of 2026 and the day it starts on:")
for month in range(1, 13):
    starts, days = calendar.monthrange(2026, month)
    print(f"  {calendar.month_name[month]:<10} starts {calendar.day_name[starts]:<10} "
          f"{days} days")

is 2024 a leap year?      True
is 1900 a leap year?      False
leap years 2000 to 2030  : 8
days in February 2024    : 29
days in February 2023    : 28
the first day of the week: 0 which is Monday

every month of 2026 and the day it starts on:
  January    starts Thursday   31 days
  February   starts Sunday     28 days
  March      starts Sunday     31 days
  April      starts Wednesday  30 days
  May        starts Friday     31 days
  June       starts Monday     30 days
  July       starts Wednesday  31 days
  August     starts Saturday   31 days
  September  starts Tuesday    30 days
  October    starts Thursday   31 days
  November   starts Sunday     30 days
  December   starts Tuesday    31 days

calendar.leapdays(a, b) counts the leap years in a range, with the start included and the end excluded, which is worth noticing before you quote the number.

The February rows are the leap year rule showing up as a number of days, which is a neater demonstration than isleap on its own.

Procedure

1. Save as practical10b.py. Print the resolution and the monotonic flag of perf_counter and of

time, and say which you will use and why.

1. Time a loop that sums a million numbers with perf_counter, printing the elapsed time to four

decimal places.

1. Time two ways of doing the same work once each, and say why one reading each proves nothing.
2. Use timeit with number=200 and report the per run figure and the ratio.
3. Take seven samples and report the best, the median, the worst and the spread.
4. Save as practical10c.py. import calendar.
5. Read a year and a month with int(input()).
6. Call calendar.monthrange(year, month), unpack the two values, and print

calendar.day_name[first].

1. Print the month with calendar.month(year, month) and check that the 1st is in the column you

named.

1. Print every month of the year with the day it starts on, and the days in February for a leap

year and a common year.

Result

perf_counter reported itself monotonic and time did not, which is why the measurements use perf_counter. Sleeping for two tenths of a second was seen by perf_counter and not by process_time, confirming that sleeping uses no CPU. The built in sum was faster than the explicit loop over 200 runs of timeit, and the ratio rather than the milliseconds is the finding. Seven samples of the same work differed, which is why the median and the spread are reported and a single reading is not. On the calendar half, monthrange returned the weekday of the first day and the number of days, and the printed calendar put the 1st in the column the program named. monthrange(2024, 2)[1] was 29 and monthrange(2023, 2)[1] was 28.

Where marks are lost

• Using time.time() to measure. It is not monotonic; perf_counter is.
• One reading. A single measurement proves nothing; use timeit or take several.
• Reporting the mean of several samples. Use the best or the median: a slow sample is usually

another program on the machine.

• Printing fifteen digits of a measurement, which claims a precision the clock does not have.
• Quoting a time from a book as if it were yours. Say "on this machine".
• Forgetting that Monday is 0 in the calendar module.
• Forgetting the blank at index 0 of month_name, which prints an empty first entry.
• Using monthrange(year, month)[0] as the number of days. It is the weekday; the days are

[1].

• Reading the month as a name and not converting it. int(input()) gives a number.

For the journal

Two entries under practical 10. For the timing: the aim, the three clock table with one sentence on monotonic, the timed loop with the elapsed time to four decimal places, and then the timeit comparison with the ratio. The seven samples with the best, median, worst and spread. Write "on this machine" beside every time you record, and one sentence saying that the ratio is the result and the milliseconds are the machine's.

For the calendar: the aim in MU's words, the monthrange call with its tuple printed, the weekday name, and calendar.month(year, month) printed underneath so the answer can be checked by eye against the calendar. One sentence: Monday is 0 in the calendar module, and monthrange returns the weekday of the first day and the number of days as a tuple.

Quick revision

• Three clocks: time.time() the wall clock, time.perf_counter() for measuring,

time.process_time() for CPU used.

• perf_counter is monotonic; time.time() is not. A clock correction can make a time.time()

difference wrong or negative.

• Sleeping is seen by perf_counter and not by process_time.
• Pattern: start = perf_counter(), do the work, elapsed = perf_counter() - start.
• 1_000_000 is 1000000. The underscores are ignored.
• timeit.timeit(callable, number=n) gives the total for n runs; divide by n. It also disables

the garbage collector.

• Report the best or the median of several samples, plus the spread. Never one reading, never

the mean.

• The ratio is what transfers to another machine; the milliseconds do not.
• A timing decorator wraps a function; @wraps keeps its name and docstring.
• calendar.monthrange(year, month) returns (weekday of the 1st, number of days).
• Monday is 0 in calendar. calendar.day_name[n] is the name.
• calendar.month_name has a blank at index 0, so index 1 is January.
• calendar.month(y, m) prints the month; calendar.monthcalendar(y, m) gives weeks as lists with

0 for a day in another month.

• calendar.isleap, calendar.leapdays(a, b) with the end excluded.

Questions you should be able to answer

1. Which clock should you measure with, and why? time.perf_counter(), because it has the best resolution available and it is monotonic, so it never goes backwards.

2. What can go wrong with time.time() for a measurement? It follows the system clock, so a correction or a time server synchronisation during your measurement makes the difference wrong, and it can even come out negative.

3. What is the difference between perf_counter and process_time? perf_counter measures time passing; process_time measures CPU used by this process. A program that sleeps advances the first and not the second.

4. Why is timeit better than one perf_counter reading? It runs the code many times and disables the garbage collector, so the per run figure is far steadier than a single measurement.

5. Of several samples, which one should you report? The best or the median, with the spread. A slow sample usually means something else on the machine took the processor.

6. Why report a ratio rather than milliseconds? Because the milliseconds are your machine's and will not reproduce, while the ratio between two ways of doing the same work usually will.

7. What does calendar.monthrange(2026, 10) return? A tuple: the weekday number of the 1st and the number of days in the month.

8. What number is Monday in the calendar module? 0. Sunday is 6.

9. Write the two lines that print the day a month starts on. first, days = calendar.monthrange(year, month) then print(calendar.day_name[first]).

10. Why does calendar.month_name have an empty string at index 0? So that the index matches the month number, with January at 1.

11. How does monthcalendar show a day that belongs to the previous or next month? As a 0 in the week's list.

class Node:
    def __init__(self, data):
        self.data = data
        self.nxt = None

    def __repr__(self):
        return f"Node({self.data!r})"


first = Node("a")
second = Node("b")
first.nxt = second

print("first          :", first)
print("first.nxt      :", first.nxt)
print("second.nxt     :", second.nxt, "which is None, so this is the end")
print("the same object?", first.nxt is second)
print("how many nodes exist? two. How many names? three:",
      [first, second, first.nxt])
print("is second.nxt None?", second.nxt is None)

first          : Node('a')
first.nxt      : Node('b')
second.nxt     : None which is None, so this is the end
the same object? True
how many nodes exist? two. How many names? three: [Node('a'), Node('b'), Node('b')]
is second.nxt None? True

first -> [ a | * ] -> [ b | None ]

That picture is the whole of a linked list, and it is worth drawing in the journal for every structure that has nodes in it. The * is a reference and the None is the end.

Test for None with is, not with ==. is asks "are these the same object", and there is only one None in a running Python program. == can be redefined by a class and then the test means something else.

class Odd:
    def __eq__(self, other):
        return True


strange = Odd()
print("strange == None :", strange == None, "  which is a lie the class told")
print("strange is None :", strange is None, "  which is the truth")

strange == None : True   which is a lie the class told
strange is None : False   which is the truth

Raising an error rather than returning a sentinel

Every structure in this module has an operation that can fail: popping an empty stack, dequeuing an empty queue, deleting a node that is not there. There are two ways to report it and only one of them is right.

class BadStack:
    """Returns None on an empty pop, which cannot be told from a stored None."""

    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if not self.items:
            return None
        return self.items.pop()


class GoodStack:
    """Raises on an empty pop, which cannot be mistaken for anything."""

    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if not self.items:
            raise IndexError("pop from an empty stack")
        return self.items.pop()


bad = BadStack()
bad.push(None)
print("BadStack: pushed None, popped", bad.pop(), "and popping empty gives", bad.pop())
print("so the caller cannot tell a stored None from an empty stack")

good = GoodStack()
try:
    good.pop()
except IndexError as error:
    print("GoodStack: popping empty raised IndexError:", error)

BadStack: pushed None, popped None and popping empty gives None
so the caller cannot tell a stored None from an empty stack
GoodStack: popping empty raised IndexError: pop from an empty stack

Raise. The BadStack cannot distinguish "the item was None" from "there was no item", and the output above shows both printing the same thing. This is the rule for every structure in the rest of the module, and an examiner who asks "what does your pop do when the stack is empty" is asking exactly this.

MU's CO 9: dynamic memory allocation

Her Course Objective 9 is "dynamic memory allocation and efficient data management techniques". In C that is malloc and free, and [If Your College Runs Module 2 in C] shows them. In Python it is automatic, and you should still be able to say what happens.

Every object is allocated when it is created and freed when nothing refers to it any more. Python keeps a count of how many references each object has; when the count reaches zero the memory is released.

import sys


class Node:
    def __init__(self, data):
        self.data = data
        self.nxt = None


node = Node("a")
print("references to this node:", sys.getrefcount(node) - 1,
      "(getrefcount counts its own argument, so subtract one)")

alias = node
print("after alias = node    :", sys.getrefcount(node) - 1)

holder = [node, node]
print("after putting it in a list twice:", sys.getrefcount(node) - 1)

del alias
del holder
print("after deleting both   :", sys.getrefcount(node) - 1)

references to this node: 1 (getrefcount counts its own argument, so subtract one)
after alias = node    : 2
after putting it in a list twice: 4
after deleting both   : 1

That is why unlinking a node from a list is enough to free it: after before.nxt = here.nxt nothing refers to here, its count reaches zero and the memory goes back. There is no free to call and no free to forget.