How to rewrite anonymous functions? [closed]

Answer 1

The thing to remember is a function is defined (via def or lambda) in a certain environment or scope. In your example function, the lambdas are defined inside of foo() and therefore have access to foo's local variables (like n). When smaller_then_ten is defined outside of foo, it doesn't have access to the variable n. Kwarrtz and Nikita each showed ways to solve that issue. However, the easiest way is to define the new function in the same environment that the lambdas where in, like so:

def foo(los, n=None):
    def smaller_than_n(tpl):
        return tpl[0] < n

    def item1(tpl):
        return tpl[1]

    def const1(i):
        return 1

    def count(key, values):
        return key, sum(map(const1, values))

    n = n or len(los)
    h = it.takewhile(smaller_than_n, enumerate(los))
    s = sorted(h, key=item1)
    g = it.groupby(s, key=item1)
    return dict(it.starmap(count, g))

As you are learning Python, get familiar with the standard library. It is a great resource. To pique your interest: the first two lines of foo() could be replaced by itertools.islice, item1() could be replaced by operator.itemgetter, and the whole foo function could be replaced by collections.Counter.

Answer 2

Your first problem is a simple typo. Your defined your "smaller than" function as smaller_then_ten but called it as smaller_then_n. I'm going to go out on a limb here and say that you meant to call it smaller_than_len. Next is that your function smaller_then_ten doesn't take your variable n into account at all, it only uses the length of the input list. What you really want is a function that accepts an upper bound and returns a function which checks the first element of the list against it. Something like this.

def smaller_than_len(n):
    def f(e):
        return e[0] < n
    return f

def foo(los, n=None):
    n = n or len(los)
    h = it.takewhile(smaller_than_len(n), enumerate(los))
    ...

Your final problem is that you removed the key argument from the sorted and groupby functions. Since you said that you didn't want to use lambdas for your adjustment, you can replace them with a new function named "key_func".

def smaller_than_len(n):
    def f(e):
        return e[0] < n
    return f

def key_func(e):
    return e[1]

def foo(los, n=None):
    n = n or len(los)
    h = it.takewhile(smaller_than_len(n), enumerate(los))
    s = sorted(h, key=key_func)
    g = it.groupby(s, key=key_func)
    return dict(it.starmap(lambda k, vs: (k, sum(map(lambda i: 1, vs))), g))

Now your function should work correctly.

Answer 3

You can rewrite it like this...

For:

lambda args: expression_with_args

a function would look like:

def func_name(args):
    return expression_with_args

E.g.

lambda p: p[0] < n

becomes:

def compare_func(p, n):
    return p[0] < n

to use it as a function for key, which takes only one argument it has to be modified a little to save the value of n:

compare_func = ft.partial(compare_func, n=n)

E.g.

lambda p: p[1]

becomes:

def get_first(p):
    return p[1]

E.g.

lambda k, vs: (k, sum(map(lambda i: 1, vs)))

becomes:

def as_one(i):
    return 1

def get_tuple(k, vs):
    vs_with_ones = map(as_one, vs)
    vs_sum = sum(vs_with_ones)
    return (k, vs_sum)

Finally:

def foo(los, n=None):
    n = n or len(los)
    compare_func = ft.partial(compare_func, n=n)
    h = it.takewhile(compare_func, enumerate(los))
    s = sorted(h, key=get_first)
    g = it.groupby(s, get_first)
    return dict(it.starmap(get_tuple, g))