Best practice: handle functions with lots of parameters and reserved names

Question

i am working on a python client for the api of uwsgi.it and i found the necessity to write methods that accept lots of (optional) parameters that will be sent via http requests.

Initially i wanted to declare which parameters the user can insert, since they are so many i thought it was easier, and safer, for the user to have a list as parameters instead of leave him free to insert anything inside a dict and i ended up with something like this:

def alarms(self, container=None, _class=None, color=None,
           vassal=None, level=None, line=None, filename=None, 
           func=None, with_total=None, range=None):
    params = {k: v for k, v in locals().iteritems() if k != 'self' and v}
    if '_class' in params:
        params['class'] = params['_class']
        del params['_class']
    return self.get('alarms', params)

But it is pretty ugly and i really don't like this way to handle '_class' parameter. So the other possibility that comes to my mind is to accept a dictionary that can contain anything (or **kwargs), list the accepted keys in the docstring and then to sanitize the input. A possible way would be to declare a "private" method that accept only the allowed params. But then the same problems appears again! Any suggestion? Any best-practice for methods with so many parameters?

Why do you need special processing for `_class`? Why wouldn't just `class=None` in the argument list work? I can answer this for myself: because `class` is a keyword in Python, so it would be a syntax error. — pts, Nov 15 '14 at 11:22
Do you need any arguments work as positional arguments? If not, I'd go with your `**kwargs` approach. — pts, Nov 15 '14 at 11:25
a better name for `_class` would be `class_` or `cls`. You're puting all in a dictionary at once. So why don't you use `**kwargs` instead? — Daniel, Nov 15 '14 at 11:26
`if v` should be `if v is not None`. Otherwise setting any of the parameters to a False value, such as `level=0`, is not possible. — unutbu, Nov 15 '14 at 11:29
Yes, i can use **kwargs but then i need to sanitize the keys to be sure that i send only the accepted values (or advice the user if there are typos in a key, that would cause the server that receive the request to ignore it). And i can't image a 'clean' way to do it. — Jiloc, Nov 15 '14 at 11:30
@Dorian: As Daniel mentioned, `cls` is a common substitute for `class`. Are you free to choose the parameter name? If so, I would just change `_class` to `cls` and keep the explicit call signature. — unutbu, Nov 15 '14 at 12:03
'class' its a fixed parameter that the server accept. anyway his value is just a string, not a real class. — Jiloc, Nov 15 '14 at 12:19

PM 2Ring · Accepted Answer · 2014-11-16T07:35:13.793

I agree that using **kwargs is a good idea, and you can easily sanitize its keys using a set. I'm using Python 2.6, so I don't have set comprehensions, but my code should be easy to translate to more modern versions.

FWIW, I actually posted a version of this program late last night, but then I decided it ought to do something about bad parameters, so I temporarily deleted it. Here's the revised version.

validate_params.py

#! /usr/bin/env python

''' Validate the keys in kwargs

    Test keys against a container (set, tuple, list) of good keys,
    supplying a value of None for missing keys

    Also, if a key ends with an underscore, strip it.

    Written by PM 2Ring 2014.11.15

    From 
    http://stackoverflow.com/questions/26945235/best-practice-handle-functions-with-lots-of-parameters-and-reserved-names

'''

import sys

def test(**kwargs):
    good_keys = ("container", "class_", "color", 
        "vassal", "level", "line", "filename", 
        "func", "with_total", "range")
    new_kwargs = validate_keys(kwargs, good_keys)
    for t in new_kwargs.items():
        print "%-12s : %r" % t


#def alarms(**kwargs):
    #good_keys = ("container", "class_", "color", 
        #"vassal", "level", "line", "filename", 
        #"func", "with_total", "range")
    #return self.get('alarms', validate_keys(kwargs, good_keys))


def validate_keys(kwargs, good_keys):
    good_keys = set(good_keys)
    bad_keys = set(kwargs.keys()) - good_keys
    if bad_keys:
        bad_keys = ', '.join(bad_keys)
        print >>sys.stderr, "Unknown parameters: %s\n" % bad_keys
        raise KeyError, bad_keys

    new_kwargs = {}  
    for k in good_keys:
        new_kwargs[k.rstrip('_')] = kwargs.get(k, None)
    return new_kwargs


test(color="red", class_="top",
    #bar=1, foo=3,  #Some bad keys
    level=2, func="copy",filename="text.txt")

output

container    : None
with_total   : None
level        : 2
color        : 'red'
filename     : 'text.txt'
vassal       : None
range        : None
func         : 'copy'
line         : None
class        : 'top'

score 1 · Answer 2 · answered Nov 15 '14 at 14:43

one thing you could do to tidy up the logic is change your dict comprehension to:

params = {k.strip("_"): v for k, v in locals().iteritems() if k != 'self' and v is not None}
#          ^^^^^^^^^^^

Then you don't need to do anything about class; Also, I would probably use class_ in favor of _class, since the latter indicates that the argument is "private", but the former is often a hint that "i need to use a keyword as an identifier"

score 1 · Answer 3 · edited May 23 '17 at 12:20

When a method begins to require many inputs, one software design practice to consider is to declare a special class which contains properties for each of those input values and then you can instantiate and populate it separately from it's use. That way you only need to pass a single reference into your method signature (to the encapsulating class) instead of references to each property. As your object model grows you can even add builder and validation methods to help you easily generate your new class and verify it's properties if needed.

How to define a class in Python

Also, consider design patterns and SOLID design principals as ways to improve your code's form, function and maintainability. Get intimately familiar with these patterns and you will have the knowledge you need to truly up your game and move from a software programmer to a lead or engineer.

http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29

http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29

http://en.wikipedia.org/wiki/Software_design_pattern

Best practice: handle functions with lots of parameters and reserved names

3 Answers3