I want to refactor a big Python function into smaller ones. For example, consider this following code snippet:
x = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9
Of course, this is a trivial example. In practice, the code is more complex. My point is that it contains many local-scope variables that would have to be passed to the extracted function, which could look like:
def mysum(x1, x2, x3, x4, x5, x6, x7, x8, x9):
x = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9
return x
The problem is that pylint would trigger a warning about too many arguments. I could avoid the warning by doing something like:
def mysum(d):
x1 = d['x1']
x2 = d['x2']
...
x9 = d['x9']
x = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9
return x
def mybigfunction():
...
d = {}
d['x1'] = x1
...
d['x9'] = x9
x = mysum(d)
but this approach loos ugly to me, it requires writing a lot of code that is even redundant.
Is there a better way to do it?
This question is related to
python
refactoring
pylint
You can easily change the maximum allowed number of arguments in pylint. Just open your pylintrc file (generate it if you don't already have one) and change:
max-args=5
to:
max-args = 6 # or any value that suits you
From pylint's manual
Specifying all the options suitable for your setup and coding standards can be tedious, so it is possible to use a rc file to specify the default values. Pylint looks for /etc/pylintrc and ~/.pylintrc. The --generate-rcfile option will generate a commented configuration file according to the current configuration on standard output and exit. You can put other options before this one to use them in the configuration, or start with the default values and hand tune the configuration.
I do not like referring to the number, the sybolic name is much more expressive and avoid having to add a comment that could become obsolete over time.
So I'd rather do:
#pylint: disable-msg=too-many-arguments
And I would also recommend to not leave it dangling there: it will stay active until the file ends or it is disabled, whichever comes first.
So better doing:
#pylint: disable-msg=too-many-arguments
code_which_would_trigger_the_msg
#pylint: enable-msg=too-many-arguments
I would also recommend enabling/disabling one single warning/error per line.
Simplify or break apart the function so that it doesn't require nine arguments (or ignore pylint, but dodges like the ones you're proposing defeat the purpose of a lint tool).
EDIT: if it's a temporary measure, disable the warning for the particular function in question using a comment as described here: http://lists.logilab.org/pipermail/python-projects/2006-April/000664.html
Later, you can grep for all of the disabled warnings.
Perhaps you could turn some of the arguments into member variables. If you need that much state a class sounds like a good idea to me.
Python has some nice functional programming tools that are likely to fit your needs well. Check out lambda functions and map. Also, you're using dicts when it seems like you'd be much better served with lists. For the simple example you provided, try this idiom. Note that map would be better and faster but may not fit your needs:
def mysum(d):
s = 0
for x in d:
s += x
return s
def mybigfunction():
d = (x1, x2, x3, x4, x5, x6, x7, x8, x9)
return mysum(d)
You mentioned having a lot of local variables, but frankly if you're dealing with lists (or tuples), you should use lists and factor out all those local variables in the long run.
Do you want a better way to pass the arguments or just a way to stop pylint
from giving you a hard time? If the latter, I seem to recall that you could stop the nagging by putting pylint
-controlling comments in your code along the lines of:
#pylint: disable=R0913
or, better:
#pylint: disable=too-many-arguments
remembering to turn them back on as soon as practicable.
In my opinion, there's nothing inherently wrong with passing a lot of arguments and solutions advocating wrapping them all up in some container argument don't really solve any problems, other than stopping pylint
from nagging you :-).
If you need to pass twenty arguments, then pass them. It may be that this is required because your function is doing too much and a re-factoring could assist there, and that's something you should look at. But it's not a decision we can really make unless we see what the 'real' code is.
You could try using Python's variable arguments feature:
def myfunction(*args):
for x in args:
# Do stuff with specific argument here
I came across the same nagging error, which I realized has something to do with a cool feature PyCharm automatically detects...just add the @staticmethod decorator, and it will automatically remove that error where the method is used
First, one of Perlis's epigrams:
"If you have a procedure with 10 parameters, you probably missed some."
Some of the 10 arguments are presumably related. Group them into an object, and pass that instead.
Making an example up, because there's not enough information in the question to answer directly:
class PersonInfo(object):
def __init__(self, name, age, iq):
self.name = name
self.age = age
self.iq = iq
Then your 10 argument function:
def f(x1, x2, name, x3, iq, x4, age, x5, x6, x7):
...
becomes:
def f(personinfo, x1, x2, x3, x4, x5, x6, x7):
...
and the caller changes to:
personinfo = PersonInfo(name, age, iq)
result = f(personinfo, x1, x2, x3, x4, x5, x6, x7)
Source: Stackoverflow.com