Simple Python Problems

Why practise with small problems?

Watching someone code feels easy. Writing it yourself, from a blank cell, is where you find out what you really know. Small problems are the fastest way to get there: each one takes a few minutes, tells you straight away whether you got it right, and uses only the ideas from Python Fundamentals.

This module has two parts. First, eight problems we wrote for you. They look like everyday Python, but each one is secretly a machine learning idea you will meet again later, so solving them now makes those modules much easier. Then, problem sets from HackerRank, CS50P and CodeChef with hundreds more, at the bottom of the page.

You do not need to do everything. If the first four of our problems and a couple of the Easy sets below feel comfortable, move on.

How to solve a problem

Most beginners get stuck because they start typing too early. Try this instead:

Work one example by hand. Before any code, write down what the answer should be for a small input. If you cannot do it by hand, the code will not help.
Write the simplest version that works. Loops and if are fine. Clever one-liners can come later.
Test it. Run it on your example and check the answer. assert does the checking for you: it does nothing when the test passes and stops with an error when it fails.
Try an awkward input. An empty list, a list with one item, all values the same. These are where bugs hide.

Here is step 3 in practice:

INPUTPython

def mean(values):
    return sum(values) / len(values)

assert mean([2, 4, 9]) == 5.0
assert mean([7]) == 7.0
print("all tests passed")
# all tests passed

If a test fails, you can add a message saying what you expected, and Python prints it: AssertionError: mean([1, 2]) should be 1.5.

Eight problems from machine learning

Try each one before opening the answer. There is no single correct solution; if yours gives the same results, it is right. Two tools will help:

zip(a, b) walks through two lists side by side: zip(["cat", "dog"], ["cat", "cat"]) gives the pairs ("cat", "cat") and ("dog", "cat").
counts.get(key, 0) reads a value from a dictionary, or gives 0 if the key is not there yet (you saw this in Python Fundamentals).

1. Accuracy (Easy)

Exercise: Accuracy

A model made some predictions. Write accuracy(predictions, labels) that returns the fraction of predictions that match the true labels.

accuracy(["cat", "dog", "dog"], ["cat", "cat", "dog"]) should give 0.667 (rounded): two out of three are right.

Show answer

INPUTPython

def accuracy(predictions, labels):
    correct = 0
    for p, t in zip(predictions, labels):
        if p == t:
            correct += 1
    return correct / len(labels)

print(round(accuracy(["cat", "dog", "dog"], ["cat", "cat", "dog"]), 3))
# 0.667

You will meet this again in Model Evaluation Metrics. It is the most common score in classification tasks.

2. The most common label (Easy)

Exercise: Majority label

Write most_common(labels) that returns the label that appears most often. For ["spam", "ham", "spam", "ham", "spam"] it should return "spam".

Then use your accuracy function: what accuracy do you get by predicting "spam" for all five messages?

Show answer

INPUTPython

def most_common(labels):
    counts = {}
    for label in labels:
        counts[label] = counts.get(label, 0) + 1
    return max(counts, key=counts.get)

labels = ["spam", "ham", "spam", "ham", "spam"]
print(most_common(labels))
# spam
print(accuracy(["spam"] * 5, labels))
# 0.6

max(counts, key=counts.get) finds the key with the largest count. ["spam"] * 5 makes a list of five "spam"s.

Always predicting the most common label is called a majority baseline. It gets 60% here without learning anything, so any real model must beat 60% to be worth using. See Terminology.

3. Mean squared error (Easy)

Exercise: Mean squared error

For number predictions, a common way to measure how wrong a model is: for each prediction, take (prediction − true value), square it, and then average all of those squares. Write mse(predictions, targets).

mse([2, 4], [3, 4]) should give 0.5, and mse([10, 20, 30], [12, 18, 30]) should give about 2.667.

Show answer

INPUTPython

def mse(predictions, targets):
    total = 0
    for p, t in zip(predictions, targets):
        total += (p - t) ** 2
    return total / len(targets)

print(mse([2, 4], [3, 4]))
# 0.5
print(round(mse([10, 20, 30], [12, 18, 30]), 3))
# 2.667

** is "to the power of", so (p - t) ** 2 is the square.

This is the loss that Linear Regression minimises, and Loss Functions compares it with others.

4. Scaling to 0–1 (Medium)

Exercise: Min–max scaling

Write scale(values) that stretches or squeezes a list so the smallest value becomes 0 and the largest becomes 1: each value v becomes (v - smallest) / (largest - smallest).

scale([2, 4, 6]) should give [0.0, 0.5, 1.0]. What should scale([5, 5, 5]) give, and why does the formula break there?

Show answer

INPUTPython

def scale(values):
    low, high = min(values), max(values)
    if high == low:
        return [0.0 for v in values]
    return [(v - low) / (high - low) for v in values]

print(scale([2, 4, 6]))
# [0.0, 0.5, 1.0]
print(scale([5, 5, 5]))
# [0.0, 0.0, 0.0]
print(scale([10, 0, 5]))
# [1.0, 0.0, 0.5]

When every value is the same, high - low is 0, and dividing by 0 is an error. Returning all zeros is one sensible choice. This is exactly the kind of awkward input step 4 of "How to solve a problem" is about.

Many models work better when every feature is on a similar scale. See Scaling in Scikit-learn Basics and why K-NN needs it.

5. Train and test split (Medium)

Exercise: Split the data

Write split(rows, test_fraction) that returns two lists: the first part of rows for training and the last test_fraction of it for testing.

split(list(range(10)), 0.2) should give [0, 1, 2, 3, 4, 5, 6, 7] and [8, 9].

Then shuffle a copy of the rows first, so the test set is a random sample. Use random.seed(0) so you get the same shuffle every time.

Show answer

INPUTPython

import random

def split(rows, test_fraction):
    n_test = int(len(rows) * test_fraction)
    n_train = len(rows) - n_test
    return rows[:n_train], rows[n_train:]

train, test = split(list(range(10)), 0.2)
print(train, test)
# [0, 1, 2, 3, 4, 5, 6, 7] [8, 9]

rows = list(range(10))
random.seed(0)
shuffled = rows[:]
random.shuffle(shuffled)
train, test = split(shuffled, 0.2)
print(train, test)
# [7, 8, 1, 5, 3, 4, 2, 0] [9, 6]

rows[:] makes a copy, because random.shuffle changes the list you give it. int(...) rounds down to a whole number of rows.

Why a test set at all? A model must be scored on data it never saw while training, or the score means nothing. See Training, validation and test sets.

6. Confusion counts (Medium)

Exercise: Confusion counts

In a yes/no task, 1 means "yes" and 0 means "no". Write confusion_counts(predictions, labels) that returns four numbers:

TP: predicted 1, truly 1
FP: predicted 1, truly 0
FN: predicted 0, truly 1
TN: predicted 0, truly 0

confusion_counts([1, 0, 1, 1, 0], [1, 0, 0, 1, 1]) should give (2, 1, 1, 1).

Show answer

INPUTPython

def confusion_counts(predictions, labels):
    tp = fp = fn = tn = 0
    for p, t in zip(predictions, labels):
        if p == 1 and t == 1:
            tp += 1
        elif p == 1 and t == 0:
            fp += 1
        elif p == 0 and t == 1:
            fn += 1
        else:
            tn += 1
    return tp, fp, fn, tn

print(confusion_counts([1, 0, 1, 1, 0], [1, 0, 0, 1, 1]))
# (2, 1, 1, 1)

tp = fp = fn = tn = 0 sets all four to 0 in one line. Returning several values with commas gives a tuple.

These four counts make up the confusion matrix, and almost every classification score is built from them.

7. The nearest neighbour (Medium)

Exercise: Nearest label

Each point is a number with a label: points = [(1.0, "A"), (2.5, "B"), (4.0, "B")]. Write nearest_label(points, query) that returns the label of the point closest to query.

nearest_label(points, 1.6) should give "A" and nearest_label(points, 3.1) should give "B".

Show answer

INPUTPython

def nearest_label(points, query):
    best_label = None
    best_distance = None
    for x, label in points:
        distance = abs(x - query)
        if best_distance is None or distance < best_distance:
            best_distance = distance
            best_label = label
    return best_label

points = [(1.0, "A"), (2.5, "B"), (4.0, "B")]
print(nearest_label(points, 1.6))
# A
print(nearest_label(points, 3.1))
# B

abs gives the distance without a minus sign. None means "nothing found yet", so the first point always becomes the best so far.

Congratulations: you just wrote a 1-nearest-neighbour classifier. K-NN does the same with several neighbours and several features.

8. The most common words (Medium)

Exercise: Top words

Write top_words(text, k) that returns the k most common words in text with their counts, ignoring upper and lower case.

top_words("The cat and the dog and the bird", 2) should give [('the', 3), ('and', 2)].

Show answer

INPUTPython

def top_words(text, k):
    counts = {}
    for word in text.lower().split():
        counts[word] = counts.get(word, 0) + 1
    ordered = sorted(counts, key=counts.get, reverse=True)
    return [(word, counts[word]) for word in ordered[:k]]

print(top_words("The cat and the dog and the bird", 2))
# [('the', 3), ('and', 2)]

lower() makes "The" and "the" the same word, and split() cuts the text at spaces. sorted(..., key=counts.get, reverse=True) orders the words from most to least common; words with equal counts keep the order they first appeared in.

Counting words is the first step of Bag of Words, one of the simplest ways to turn text into numbers a model can use.

More practice

The table below lists problem sets from HackerRank, CS50P and CodeChef, easiest first. Tick a set when you finish it; your ticks are saved on this device, and on every device if you log in.

Start with the Easy sets. HackerRank's Introduction and Basic Data Types problems are short and are checked as soon as you submit. CS50P problem sets 0 and 1 and the problems in CodeChef's Learn Python course are the same level.
Medium when Easy feels boring. CS50P problem sets 2 to 4, HackerRank's Strings and Errors and Exceptions, and CodeChef's Practice Python problems need a bit more thought.
Stuck for more than 20 minutes? Look at a hint, or ask in the SOTA Discord. Then come back to the problem a day later and solve it again without help. That second solve is where it sticks.

What comes next

Jupyter Notebook Interface and Basics: the notebook format every IOAI task uses.
Pandas: the library that does most of this counting and splitting for you, on whole tables at once.

Source	Title	Why read it
HackerRank	Python practice	Short problems sorted by topic, checked as soon as you submit. Start with Introduction and Basic Data Types.
CodeChef	Learn Python	A beginner course with practice problems after each lesson.
CodeChef	Practice Python	195+ Python problems, for when you want more after the course.
Harvard	CS50P problem sets	Small programs with automatic checking. Sets 0 to 4 match the fundamentals.

Source	Problem	Difficulty	Tags
HackerRank	Python: Introduction	Easy	basics
HackerRank	Python: Basic Data Types	Easy	lists, strings
CS50P	Problem Set 0	Easy	functions
CS50P	Problem Set 1	Easy	conditions
CodeChef	Learn Python: practice problems	Easy	basics, loops, lists
HackerRank	Python: Strings	Medium	strings
CS50P	Problem Set 2	Medium	loops, strings
CS50P	Problem Set 3	Medium	exceptions, dictionaries
CS50P	Problem Set 4	Medium	libraries
HackerRank	Python: Errors and Exceptions	Medium	exceptions
CodeChef	Practice Python	Medium	mixed

2.1.3 Simple Python Problems

Why practise with small problems?

How to solve a problem

Eight problems from machine learning

1. Accuracy (Easy)

2. The most common label (Easy)

3. Mean squared error (Easy)

4. Scaling to 0–1 (Medium)

5. Train and test split (Medium)

6. Confusion counts (Medium)

7. The nearest neighbour (Medium)

8. The most common words (Medium)

More practice

What comes next

Resources

Practice problems

Comments