A graceful, shorter way to do the letter grade assignment problem

Question

I'm new to Python and want to learn the most optimized ways to code. I'm doing the classic intro problem of assigning letter grades to numerical grade; I already understand the simple way of chaining a bunch of elif, but is there a more optimized way out there? What if say I have a lot more sub-grades, or if later I need to change the criteria for each letter grade? Is there a way to create something similar to a dict for a range of values?

This is the problem in its whole:

Write a function named letter_grade that takes an integer argument, which represents a mark of a student. Return ‘A’ if mark ≥ 90, ‘B’ if 80 ≤ mark < 90, ‘C’ if 70 ≤ mark < 80, ‘D’ if 60 ≤ mark < 70, and ‘E’ if mark < 60. Return None if it is not a valid mark. A valid mark ranges from 0 to 100.

So the basic brute force method we were taught is simply:

def letter_grade(mark):
    if mark >100:
        grade = None
    elif mark >=90:
        grade = 'A'
    elif mark >= 80:
        grade = 'B'
    elif mark >= 70:
        grade = 'C'
    elif mark >= 60:
        grade = 'D'
    elif mark >= 0:
        grade = 'E'
    else:
        grade = None
    return grade

But now if let's say I have a lot more sub grades, like A+, A, A- etc all the way until F. I don't want to chain 20+ elif together for that. I want to know if there's a shorter way to handle this problem.

Answer 1

You could use next with a condition on a list of tuples representing the grade-cutoff-scores:

grades = ((100, None), (90, 'A'), (80, 'B'), (70, 'C'), (60, 'D'), (0, 'E'))
def get_grade(mark):
    return next((grade for score, grade in grades if mark >= score), None)

>>> get_grade(15)
'E'
>>> get_grade(75)
'C'
>>> get_grade(95)
'A'

The (100, None) and the default None are for scores greater than 100 or smaller than 0.

Or not quite as short, but IMHO better, with a range-check and raising a proper exception:

grades = ((90, 'A'), (80, 'B'), (70, 'C'), (60, 'D'), (0, 'E'))
def get_grade(mark):
    if 0 <= mark <= 100:
        return next(grade for score, grade in grades if mark >= score)
    raise ValueError("Mark must be between 0 and 100")

While this will loop over all the possible grades until it finds the right one, given that the number of grades is very low and constant, this can still be considered O(1). If the number of grades/intervals is much higher, you might consider using bisect to binary-search the right interval, as can be seen in some of the now-linked answers, but that's a bit less untuitive a easy to get nasty off-by-one errors.

Answer 2

Create a dict mapping letter and minimum score. Then loop through the possibilities in order and check if the score matches.

def get_grade(score):
    GRADES = {None: 100, 'A': 90, 'B': 80, 'C': 50, 'D': 20, 'F': 0}
    for grade, theshold in GRADES.items():
        if score > threshold:
            return grade
    return None

Note this relies on ordered dictionaries, a feature in 3.7. Before that, collections.OrderedDict is available. Alternatively, you can use two iterables, one for grade and one for score. You can zip(('grades here', None, 'A', 'B'), ('scores here', 100, 90, 80)) them to get a loop as above or directly create one in the form (('grade', 'score'), (None, 100), ('A', 90), ...).

Answer 3

A shorter solution would be something along the lines of the following code

def letter_grade(mark):
    if mark > 100 or mark <= 0:
        return None
    return chr(ord('E') - max(((mark - 50) // 10), 0))

What this works for every case (!), it's pretty tricky to follow. In particular, what I've done is computed the cutoff for 'mark' to the nearest multiple of 10, subtracted 50, and minimized that result at 0 (for instance, max(((75 - 50) // 10), 0) = max (25 // 10, 0) = max(2, 0) = 2). I then subtract this number from the integer representation of the letter 'E' and then send the result back to a character. Since, for instance, 'C' is two away from 'E', this produces the correct letter grade by going "that far down".

HOWEVER. Look how long it took me to explain this solution (and it's tricky to understand!) and compare that to how easy it is to understand your solution. I bet you there's an even more dense and 'short' solution in one line out there as well, but it's even harder to understand! The point is that shorter code is not necessarily more readable, and the solution you proposed is both clear and easy to follow, and would be what I would use MOST OF THE TIME :)

Answer 4

The 10 value ranges from 0 to 100 can be expressed by a single integer as the result of score / 10, this is O(1) complexity since not require interaction.

Using defaultdict:

from collections import defaultdict


lowest_grade = lambda: "E"
grades = defaultdict(lowest_grade)

grades.update({
    10: "A", 9: "A", 8: "B", 7: "C", 6: "D", # Lower values get "E" by default.
})

def letter_grade(score):
    # If the condition to not match function will return None.
    if 0 <= score <= 100:
        return grades[int(score / 10)]

if __name__ == "__main__":
    print(letter_grade(100))   # A
    print(letter_grade(85))    # B
    print(letter_grade(65))    # D
    print(letter_grade(43))    # E

Another possible answer ...

... having in to account all comments about performance, clarity, and extensibility this is another way you could tackle your problem with maximum extensibility and performance (speed).

Since all values can have a score are just a few (0-100), you can use memoization to store the corresponding letter-grade for each score value:

conf = (
    (0, 59, "E"),
    (60, 69, "D"),
    (70, 75, "C"),
    (76, 79, "C+"),
    (80, 85, "B"),
    (86, 89, "B+"),
    (90, 95, "A"),
    (96, 100, "A+"),
)

grade_memoization = [None] * 101

# This for loop is executed only once, just for setting
# "memoized" grades in grade_memoization.
for cfg in conf:
    for i in range(cfg[0], cfg[1] + 1):
        grade_memoization[i] = cfg[2]

# Then you can access letter-grade values on O(1), every time, simple, no 
# iterators, generators or for loops for each one.

# And you can extend the this as much as you want easily.

print(grade_memoization[100])   # A
print(grade_memoization[95])    # A+
print(grade_memoization[89])    # B+
print(grade_memoization[71])    # C
print(grade_memoization[76])    # C+