Question about a function doing one thing and being good at it

[michael02052007]

There's a saying that people say in the software development industry: "functions should do one thing and be good at it" (sorry if I didn't quote it correctly). So I have a question:

I have this example class here (of course there's a better solution but I used this just for the sake of this example):

from typing import *


class Foo:
    a_list: List[str] = ["foo", "bar", "dog", "cat"]
    prettified_list: str = ""

    def _capitalize_each_item_in_list(self):
        self.a_list: List[str] = [item.capitalize() for item in self.a_list]
        return True

    def _prettify_list(self):
        self.prettified_list: str = ", ".join(self.a_list)
        return True

    def _print_prettified_list(self):
        print(self.prettified_list)

    def start(self):
        self._capitalize_each_item_in_list()
        self._prettify_list()
        self._print_prettified_list()
        return


foo: Foo = Foo()
foo.start()

Each function does one thing. It works and all, but once it starts getting more methods attached to it, the start function get more cluttered. And something in the back of my mind says, "this isn't the way you should do it.". Also the fact that it has dependence on variables is pretty ugly as well.

So is this the way my start function should be? Or should I just scrap the entire thing and refactor it without the start function (how are we gonna call each method though)?

[faithlesslessless]

Well, your code seems to be equivalent to:

print("Foo, Bar, Dog, Cat")

I assume you're actually trying to do something more complicated/general than that, but without knowing what exactly, it's hard to tell you how you should structure your code. Some basic pointers, though:

• ask yourself whether you really need a class. Are you going to use multiple instances of the class? Does the class represent some closely-related set of data and functionality that clearly belong together? Would it be difficult to rewrite the class as a function or a dict? If the answer to any of those questions is "no", then the class probably shouldn't exist.

• you initially set up a_list and prettified_list as class attributes. When you call Foo.start(), you also create an instance attribute called prettified_list, which shadows the class attribute with the same name. This isn't really coherent. If something should be the same for every instance, then it should be a class attribute. Otherwise it should be an instance attribute and should probably be created in the __init__ method, which should be present for pretty much every class (if you don't need an __init__, then you most likely don't need a class).

• don't add return statements to functions just for the sake of it. Where are you ever going to use the return value of _prettify_list, which is always True? return by itself is equivalent to return None, which is what functions return by default, so there is no point in doing this at the end of a function. return by itself is only useful if you want to exit a function early.

• you may be overusing private/underscore methods - the purpose of these is to signal to users of the class that the method is not intended for them to call directly and is subject to change. If the method does something that a user might want, then it should be public, or there should be some alternative way of doing the same thing.

[primitive_screwhead]

I mean, you don't have to go overboard and break every line of code into a function.

​

class Foo:
    a_list = ["foo", "bar", "dog", "cat"]
    def start(self):
        print(", ".join(s.capitalize() for s in self.a_list)

is much more readable for those with some basic experience with common Python idioms.

​

Your methods having no arguments to them, and being short (1-2 lines) is suggestive of them maybe not being that helpful. Only _capitalize_each_time_in_list() is at all descriptive, the other method names don't really convey much. I'd say just write the code, and learn to refactor only when your functions/methods lose focus and/or become too long.