Course 3.1Lesson 5 of 5

Project: a class ranking

In this project we rank a class. The students are pairs of a name and a mark, and the ranking sorts by mark with the biggest first, and by name for equal marks, using a key that is a tuple. Ties get the same rank, and the next rank is skipped, as in a race. The program also shows the top three and uses binary search on the sorted marks to ask whether a mark is there. We plan the table of expected ranks by hand, build the program in steps, test the ties and the edges, and extend the ranking with a search by name and a median.

about 25 min1 simulation2 practice questions

Lesson 5 of 5Show all lessons

Try the code and the simulations beside the lesson.

What you will be able to do

After this lesson you can

sort records by two keys, with a key function,
give ranks that handle ties correctly,
take the top items of a sorted list, and
combine sorting and binary search in one program.

The goal

A class has six students, each with a mark. The teacher wants a ranking:

the students from the highest mark to the lowest, and for equal marks, by name,
a rank for each student, where students with the same mark share a rank,
the names of the top three, and
a quick answer to "is there a student with a mark of 85?".

Step 1: the expected ranking

The data is Asha 72, Ravi 85, Meera 72, Kabir 90, Ana 58 and Dev 85. Work out the table by hand.

Rank	Name	Mark
1	Kabir	90
2	Dev	85
2	Ravi	85
4	Asha	72
4	Meera	72
6	Ana	58

Look at the ranks. Dev and Ravi share rank 2. The next rank is 4, not 3, because three students are above Asha and Meera (Kabir, Dev and Ravi), so they are in fourth place. This is how a race works: if two runners tie for second, nobody is third, and the next runner is fourth. Ana is sixth, because five students are above her.

Step 2: the program

Run it, and compare with your table. Look at how it is built.

- The sort. The key (-pair[1], pair[0]) is a tuple: the mark with its sign turned, so that bigger marks come first, and then the name. For Dev and Ravi, with equal marks, the name decides. This is the "two keys" idea of the sorting lesson.

- The ranks. The loop goes through the sorted list with enumerate(..., start=1), which gives the position (1, 2, 3, ...) with each pair. The rule: if the mark is different from the one before, the rank is the position. If the mark is the same, the rank stays as it was. So Dev (position 2) gets rank 2, and Ravi (position 3, same mark) keeps rank 2. Asha (position 4, a new mark) gets rank 4.

- Unpacking in the loop. for position, (name, mark) in enumerate(...) unpacks the pair inside the tuple that enumerate gives. You learned this in the tuples course.

- The top three. A slice of the sorted list: ranked[:3].

- The binary search. The list of the marks is sorted, and the same loop as in the binary search lesson answers "is there an 85?". We only need True or False, so the loop sets found.

Step 3: test

Test the data that breaks the rules.

Test	Expected
everyone has the same mark	everyone has rank 1, in alphabetical order
one student only	rank 1, and the top three has one name
no ties at all	ranks 1, 2, 3, ...
a mark that is not there (such as 77)	`False`
the first and the last mark of the sorted list	`True`

The first row is the real test of the rank rule. If all the marks are equal, every student must have rank 1, and the program must not give rank 6 to the last one.

Give two students the same top mark. Both are rank 1, and the next student is rank 3, not 2.

Step 4: extend it

Pick one or two, and do them without looking at a solution. Write the expected answers first.

A search by name. Write a function find_rank(ranked, name) that gives the rank of a name, or None.
The median. Find the median mark from the sorted list of marks. Check it with statistics.median.
The bottom three. Show the three lowest marks, and the names.
A rank without gaps. Some schools give the next rank 3, not 4. Change the rule so that the rank goes up by one for each new mark.
More than one key. Add an age to each record. Sort by mark, then by age (younger first), then by name.

Common mistakes

Forgetting the minus sign in the key, and getting the lowest mark first.
Using reverse=True with the name: it reverses the names too, and Z comes before A for equal marks.
Giving the position as the rank and forgetting the ties.
Binary search on a list that is not sorted.
Changing students with .sort() when you still need the old order.

Practice

Start with two quick questions. Each New numbers gives you a fresh one, so you can practise as long as you like.

Then the labs and the problems:

Warm-up. Open the lab Sort the class. You sort a list of pairs by two keys, and the checker confirms the order.
Build. Open the lab Project: a class ranking. The checker runs your function on classes with ties.
Stretch. Open the problem The median by sorting and the problem The top three scores.