I understand the sense of using an Enum when it's converting a human-readable string into an underlying (e.g. numeric) value, with the FederalHoliday class in this answer being a good example of that.
But the use-case I'm considering is just where a function parameter is restricted to a set of possible values, which are currently passed as "magic strings". So implementing an Enum here wouldn't really improve code readability (if anything, it would make the code more cluttered). And turning a string into an Enum, only to compare on what is effectively the same string (i.e. the name of the Enum) feels like overkill.
This answer has a fantastic list of general advantages of enums, but I'm not sure how many of them apply in this case.
To clarify the case I'm meaning, there is an example of it here, with a function that prints a string with certain capitalization as specified by mode:
def print_my_string(my_string, mode):
if mode == 'l':
print(my_string.lower())
elif mode == 'u':
print(my_string.upper())
elif mode == 'c':
print(my_string.capitalize())
else:
raise ValueError("Unrecognised mode")
To see this in action, running this:
for mode in ['l', 'u', 'c']:
print_my_string("RaNdoM CAse StRING", mode)
gives:
random case string
RANDOM CASE STRING
Random case string
So my question is:
What advantage does an Enum bring when the strings don't represent another value underneath? Is there any way that it makes the code more robust? Does it add anything?
Other things I've read:
Mainly about Enums in general, especially when the strings represent another value underneath:
This seems to have an example similar to mine (under Enums are interoperable), but I struggled to understand the technical discussion around it, and it only shows setting the Enum, not using it:
You are right that, non being a statically typed language, the benefits of enums are not as strong in Python. Many APIs still use strings for these kind of things and are just fine. However I think there are still benefits to it, specially from the point of view of IDE support (autocompletion) and static analysis (code linting). Imagine you have a function that allows you to compute the norm of a vector, using different methods. Were the options 'Euclidean', 'Absolute' and 'Manhattan', 'EUCLIDEAN', 'ABSOLUTE_VALUE' and 'TAXICAB' or just 'e', 'a', and 'm'? If you have an enum and a nice enough IDE, you can probably write NormType. and press Ctrl+Space to see the options, instead of having to check out the documentation once again. And if you write the wrong one, a code linter will probably let you know. More over, if you happen to rename one of the options it should be easier to find all the places that need changing.
That said, I agree that it may just make the code more cluttered in some cases. In your example, the options are probably simple enough to use a string without problem. In any case, the benefits of enums become more relevant when they are used in several places, like several functions with similar parameters where you want to enforce uniformity and want to avoid silly string typos in the code. It is harder to justify the need for an enum for a single parameter of a single function.