In Python, how to not contaminate the global space when monkey patching a class?

Question

The background is, there is a method most_common() for the class Counter but not a method least_common(). As an exercise, if I were to add it to the class:

import collections

def least_common(self, n=None):
    return (counter.most_common()[:-n-1:-1] if n != None 
                else counter.most_common()[::-1])

collections.Counter.least_common = least_common

but then it will contaminate the global space by creating an extra least_common function. Is there a way to use an IIFE like in JavaScript, or use a lambda? But lambda doesn't seem to take default arguments?

P.S. and update: Initially, I tried default parameter value like this:

collections.Counter.least_common = lambda self, n=None:
    return (counter.most_common()[:-n-1:-1] if n != None
            else counter.most_common()[::-1])

And it won't work. It seems like I have to move the second line to the end of the : on the first line, and I have to remove the return for it to work.

Answer 1

If I understand the question correctly, you want to know how to do the monkey-patching in the question without creating a function named least_common in the current namespace.

I think there are three possible solutions. The first is to use a lambda to create the function as an expression as you're assigning it. Python's lambdas are not as fully functioned as some other language's anonymous functions, but they're perfectly good enough for this. As jonrsharpe commented, they can be declared with default arguments, so your monkey patching code could be:

collections.Counter.least_common = lambda self, n=None: (counter.most_common()[:-n-1:-1]
                                                         if n != None else
                                                         counter.most_common()[::-1])

Another solution would be to use the code you're currently using, but then use a del statement to remove the function from the current namespace.

def least_common(self, n=None):
    return ...
collections.Counter.least_common = least_common
del leadst_common

The last option is to define the function and do the monkey patching in a namespace you don't care much about. An obvious one would be the local namespace of some other function, where the local variable name will go away as soon as the function ends:

def do_monkey_patching():
    def least_common(self, n=None):
        ...
    collections.Counter.least_common = least_common

But that's not the only option for an alternative namespace. An important thing to understand in Python is that there isn't one single global namespace. Rather, each module has its own global namespace, which other modules can access by importing it. So, perhaps you do not need to do anything about the extra name in "the global namespace" if its the global namespace of a module that doesn't contain any other important code.

Answer 2

I am not sure if this is what you want, but:

from collections import Counter

class MyCounter(Counter):
    def least_common(self, n=None):
        return (counter.most_common()[:-n-1:-1] if n != None 
                    else counter.most_common()[::-1])

try:
    my_counter = MyCounter(some_iterable)
    print list(my_counter.least_common())
except Exception as e:
    # this should really be AttributeError, but I am too lazy to check
    print "bombed"

try:
    normal_counter = Counter(some_iterable)
    print list(normal_counter.least_common())
except Exception as e:
    print "bombed"

Normal counter is bombed and yours isn't. Is this what you want?

=================

In reply to one of the comments below, from collections import Counter is an idiom provided in Python to get references from a module without invoking member search through dot every time you need it. For example, the following codes are equivalent:

Code 1:

from collections import Counter
for it in some_iterables:
    counter = Counter(it)
    # do something to counter

Code 2:

import collections
counter_class_reference = collections.Counter
for it in some_iterables:
    counter = counter_class_reference(it)

However, the following code may have worse performance than the previous two:

import collections
for it in some_iterables:
    counter = collections.Counter(it)

This is because of the membership reference search invoked inside the loop, which is discussed more in https://wiki.python.org/moin/PythonSpeed/PerformanceTips#Avoiding_dots... https://blog.newrelic.com/2015/01/21/python-performance-tips/

Another point worth noticing is that activities in global scope in Python takes a bit longer because of the implementation of CPython. This suggests you wouldn't want to monkey-patch in a loop. More discussion found on Why does Python code run faster in a function?

And I still think not monkey-patching is the best way, if you don't have a problem with just subclassing, which is more pythonic.