在Python中，为同一事物的不同类型使用两个参数还是处理多个类型的一个参数更好？

Question

Please help resolve this debate on my team:

If we have a function that takes either a point (list of 3 values) or a list of points, then we have either:

def f(point=None, points=None):
    if points is None: points = []
    if point is not None: points.append(point)
    .... stuff with "points" ....

or

def g(points):
    if len(points) > 0 and not isinstance(points[0],list):
        points = [points]
    .... stuff with "points" ....

to be called as,

x = f(points=[[1,2,3],[4,5,6]])
y = f(point=[1,2,3])
z = g(points=[[1,2,3],[4,5,6]])
w = g(points=[1,2,3])

where x,y,z, and w should all be the same (if f and g are the same function).

That is to say, internally both f and g want a 2-dimensional array, but provide mechanisms to accept a single-dimensional array.

The difference is that f has an argument for each type, and therefore each argument expects a single, specific type, but g has a single argument that may be of multiple types.

The question is, which style is more "Pythonic"? (References to PEPs more than welcome.. I couldn't find anything.)

Edit: I forgot to mention that ostensibly the reason for supporting 1-dimensional input is backwards compatibility. That is to say, f(point, axis) already exists, and we are changing it to f(points, axes) .. and we are trying to changing the callers as they are external to this code base. I agree that perhaps the right answer is to not do this at all and force the caller to be consistent with their types, but I ask the reader to assume this would be difficult and to provide some clarity on the two choices I am asking about, if at all possible. Thanks!

Answer 1

As the signatures of your f and g differ, I'm assuming you control how the function is or will be called. In this case, the most logical thing to do would be to accept only two dimensional lists and call it like this:

x = h([[1,2,3], [4,5,6]])
y = h([[1,2,3]])

A list of points with only one element is no special case unless it is semantically diferent than a multipoint list in your context or it would change the functions behavior.

Answer 2

I'd suggest using *args (or, well, call it *points possibly) and making the user unpack his points on his end.

This allows you to call f(point) , f(point1, point2, point3) , or f(*list_of_points) , with all three options working fine and you can simply do:

def f(*points):
    ...
    for point in points:
        do_pointy_stuff(point)

...which is similar to g2 but without hacky isinstance checks which would fail if someone decided to throw in a tuple or something instead.

However, there is a minor potential pitfall here - the user must knowingly unpack his lists of points. If you don't pay attention when using a single argument, you may pass a *[points] rather than a *[[list of points]], which would result in the function treating each coordinate as a separate argument in itself and most likely throwing an error.