Format an English-language count of items

Question

I started reading Robert Martin's Clean Code. I'm trying to "translate" all his examples into Python, so I can understand them better since my knowledge of Python is greater than that of Java.

This class formats a count in into a natural English sentence:

Java original code of the book

public class GuessStatisticsMessage {
    private String number;
    private String verb;
    private String pluralModifier;

    public String make(char candidate, int count) {
        createPluralDependentMessageParts(count);
        return String.format(
            "There %s %s %s%s", 
            verb, number, candidate, pluralModifier);
    }

    private void createPluralDependentMessageParts(int count) {
        if (count == 0) {
            thereAreNoLetters();
        } else if (count == 1) {
            thereIsOneLetter();
        } else {
            thereAreManyLetters(count);
        }
    }

    private void thereAreManyLetters(int count) {
        number = Integer.toString(count);
        verb = "are";
        pluralModifier = "s";
    }

    private void thereIsOneLetter() {
        number = "1";
        verb = "is";
        pluralModifier = "";
    }

    private void thereAreNoLetters() {
        number = "no";
        verb = "are";
        pluralModifier = "s";
    }
}

My Python version

class GuessStatsMessage:
    def __init__(self, candidate, count):
        self.candidate = candidate
        self.count = count
        self.__number = self.__verb = self.__plural_modifier = ''

    def make_message(self):
        self.__create_pluraldependant_message_parts()
        guess_message = (f'There {self.__verb} '
                         f'{self.__number} '
                         f'{self.candidate}{self.__plural_modifier} ')
        print(guess_message)

    def __create_pluraldependant_message_parts(self):
        if self.count == 0:
            self.__there_are_no_letters()
        elif self.count == 1:
            self.__there_is_one_letter()
        else:
            self.__there_are_many_letters()

    def __there_are_no_letters(self):
        self.__number = 'no'
        self.__verb = 'are'
        self.__plural_modifier = 's'

    def __there_is_one_letter(self):
        self.__number = '1'
        self.__verb = 'is'
        self.__plural_modifier = ''

    def __there_are_many_letters(self):
        self.__number = str(self.count)
        self.__verb = 'are'
        self.__plural_modifier = 's'

It should be used as follows:

message = GuessStatsMessage('Foo', 10)
message.make_message()
# output: There are 10 Foos 

Answer 1

IMO, the python implementation reads like Java, and isn't Pythonic. How can we improve it?

This isn't a class

It looks like one, and it has a class definition, but it's really two functions, one of which is __init__. The other "private" methods are just if statements.

Let's refactor this as a single function:

def make_message(candidate, count):
    if not count:
        number, verb, plural = 'no', 'are', 's'
    elif count == 1:
        number, verb, plural = count, 'is', ''
    else:
        number, verb, plural = count, 'are', 's'

    message = f'There {verb} {number} {candidate}{plural}'

    return message

Now you can simply do:

print(make_message('Foo', 2))
There are 2 Foos

Or

msg = make_message('Bar', 3)
print(msg)
There are 3 Bars

Now, the number, verb and plural names aren't able to be accessed by anything outside the function, not that we needed the privacy model anyways. There are also fewer methods to read and maintain, your eye isn't jumping between code blocks.

The naming is short and concise, and the code is pretty easy to reason about.

We've also used the if not count idiom, where a 0 behaves like False and nonzero values act like True.

Lastly, the tuple unpacking used for number, verb, plural is a very common technique for defining multiple variables inline.

Docstrings and Type Hints

We could further enhance the readability of this function by adding a docstring and type annotations for our variables:

def make_message(candidate: str, count: int) -> str:
    """Returns a message for a number of objects with the name candidate"""
    ...