来自python函数的返回类型不一致 - 真的吗？

Question

I am new to Python, but not new to programming. To pick up on Python, I am going through an online introductory tutorial. I have worked through multiple examples of functions which return an inconsistent type of result, depending on arguments. EG, the result may be an integer or a boolean, as in by_three() in this example:

def cube(number):
    return number**3

def by_three(number):
    if (number%3) == 0:
        return cube(number)
    else:
        return False

This sends up red flags to me. Is this acceptable practice in the Python world? Obviously the language allows it, it can be done, but should it be done?

Answer 1

I spent some time thinking about why python "allows" inconsistent return types and realized it is not just python, but pretty much any OO language.

In python everything is an object, even class definitions are objects. As far as I remember the only thing that is not an object is the type() function.

So we can now assume that all types have a topmost super type that every other type inherits from. Like Object in Java. Which leads me to this hypothetical Java code example where you have a service tier querying a repository for users with a specific last name

Object getUsersByLastname(String lastname) {
    List<User> users = repository.getUsersByLastname(lastname);
    if (user.size() == 1) {
        return users.get(0);
    } else {
        return users;
    }
}

Anyone who has ever worked in Java will see this as a pretty poor piece of code. Whatever is calling this will always have to do type checking before continuing.

My opinion is that the Python example shown above is also poor code and that you will end with a maintenance nightmare. At the end of the day good design is something that is easy to maintain and does not require a ton of if... else... statements to work. It certainly feels like it break Open / Close principle in SOLID anyway, since at any time another return type can be added to that function and the calling code will need to be modified.

Just because you can do something does not mean you should.