Function closures and meaning of <locals> syntax in object name in Python

user_10919349 0
Viewed 63

Suppose I have the following code:

def outer(information):
    print(locals())
    def inner():
        print("The information given to me is: ", information)
    return inner


func1 = outer("info1")
print(func1)

It returns:

{'information': 'info1'}
<function outer.<locals>.inner at 0x1004d9d30>

Of course, if I call func1, it will print with info1 in the statement. So, from printing the locals() in the outer function, I can see that there is some relationship between the local scope and the storage of the argument.

I was expecting func1 to simply be outer.inner, why does the syntax instead say outer.<locals>.inner? Is this a syntactical way of clarifying that there are different local scopes associated to each of these functions - imagine I made another one func2 = outer("info2") - I return using the outer function?

Also, is there something special about the enclosing <> syntax when used around a name? I see it around both the object and locals.

syntax python
2 Answers

See PEP 3155 -- Qualified name for classes and functions and the example with nested functions.

For nested classes, methods, and nested functions, the __qualname__ attribute contains a dotted path leading to the object from the module top-level. A function's local namespace is represented in that dotted path by a component named <locals>.

Since the __repr__ of a function uses the __qualname__ attribute, you see this extra component in the output when printing a nested function.

I was expecting func1 to simply be outer.inner

That's not a fully qualified name. With this repr you might mistakenly assume you could import the name outer and dynamically access the attribute inner. Remember the qualname is a "dotted path leading to the object", but in this case attribute access is not possible because inner is a local variable.

Also, is there something special about the enclosing <> syntax when used around a name?

There is nothing special about it, but it gives a pretty strong hint to the programmer that you can't access this namespace directly, because the name is not a valid identifier.

user_6740390

You can think of outer.<locals>.inner as saying that inner is a local variable created by the function. inner is what is referred to a closure in computer science. Roughly speaking a closure is like a lambda in that it acts as a function, but it requires non-global data be bundled with it to operate. In memory it acts as a tuple between information and a reference to the function being called.

foo = outer("foo")
bar = outer("bar")

# In memory these more or less looks like the following:
("foo", outer.inner)
("bar", outer.inner)

# And since it was created from a local namespace and can not be accessed
# from a static context local variables bundled with the function, it
# represents that by adding <local> when printed.

# While something like this looks a whole lot more convenient, it gets way
# more annoying to work with when the local variables used are the length of
# your entire terminal screen.
<function outer."foo".inner at 0x1004d9d30>

There is nothing inherently special about the <> other than informing you that <local> has some special meaning.


Edit:

I was not completely sure when writing my answer, but after seeing @wim's answer <local> not only applies to closures created consuming variables within a local context. It can be applied more broadly to all functions (or anything else) created within a local namespace. So in summary foo.<local>.bar just means that "bar was created within the local namespace of foo".

user_59876690
Related