Python异常处理 - 如何做到pythonic？

Question

I am still learning the Python programmimg language. I asked myself in terms of code exceptions, when it is neccessary to handle such situations in a pythonic way. I read a few times "you should never pass an error silently".

For example a little function:

def square(list_with_items):
    return [i**2 for i in list_with_items]

Is it neccessary to write an error-handler, if somebody passes a tuple as parameter? Or it is more senseful to do it, when I have to check the validation of user-input?

Answer 1

In the specific case of checking types, the "Pythonic" thing to do is not to check them. Unless there is a good reason, you should assume that the caller is passing in a sensible type (note: "sensible type" might be different from "the type you expect"), and do your best to return something sensible as well. If the caller passes in a type that isn't sensible, it's perfectly acceptable to let them deal with the consequences.

For example, someone might sensibly pass an iterator of Decimal numbers into your square function:

>>> from decimal import Decimal
>>> square(Decimal(line.strip()) for line in open("numbers.txt")
[Decimal("4.0"), Decimal("9.0"), ...]

And everything would work! But explicitly checking the types would make that use case more difficult.

And then, for example, if someone passes in something that isn't sensible, they can deal with the error:

>>> square(42)
…
TypeError: 'int' object isn't iterable

This error message will also (in a script) contain all the file names and line numbers necessary to debug the issue.

On the other hand, it is sometimes useful to explicitly check the arguments, when the caller might make a mistake with surprising consequences. For example, if you're writing a function which will exhibit very poor performance with a list because it expects a deque , then a check for if not isinstance(input, deque): raise TypeError("a deque must be used!") might be justified.

The name for this "method for dealing with types" is called Duck Typing .

Answer 2

You could use an assertion:

def square(list_with_items):
    assert(all([type(x) == int for x in list_with_items]))
    return [i**2 for i in list_with_items]

You could use two assertions:

def square(list_with_items):
    assert(type(list_with_items) in (list, tuple))
    assert(all([type(x) == int for x in list_with_items]))
    return [i**2 for i in list_with_items]

You could use an assertion and a try/catch:

def square(list_with_items):
    assert(type(list_with_items) in (list, tuple))
    try:
        return [i**2 for i in list_with_items]
    except TypeError:
        raise Exception("Each element of the argument must be a number.")

Answer 3

It depends. In that specific example, if you are going to use the return value of "square" in "read-only" manner, you shouldn't have a "real bug" passing a tuple as argument. That's because even if the tuple is immutable, your function will return a new tuple with the square of the elements of the first one.

Anyhow, I suggest you to use a simple if-else statement, to be more precise and to avoid issues (ie: if you are going to call this function in a different way in future):

def square(list_with_items):
    if isinstance(list_with_items, list): # True if list_with_items is a list - False otherwise
        return [i**2 for i in list_with_items]
    else:
        return 'Error: type(list_with_items) must be a list!'

EDIT: If you prefer (and if you are going to catch the exception with try-except statement), you could use "raise Exception" in the else-statement:

else:
    raise Exception('Error: type(list_with_items) must be a list!')