12

Take the following code:

import something

def Foo():
    something = something.SomeClass()
    return something

…this is apparently not valid code:

UnboundLocalError: local variable 'something' referenced before assignment

…as the local variable something is created, but not assigned, before the RHS of the = is evaluated. (See, for example, this related answer's comment.) This seems a bit odd to me, but sure, I'll go with it. Now, why is the following valid code?

class Foo(object):
    something = something.SomeClass()

My understanding was that the inside of a class definition was essentially a scope:

The class’s suite is then executed in a new execution frame (see section Naming and binding), using a newly created local namespace and the original global namespace.

So, then, why does that code act differently than that of a function?

Improve this question
2
  • something seems to have more than one meaning? Commented Jan 31, 2012 at 23:39
  • @Johnsyweb: Yes, kind of. But in both cases, it has the same kind of more-than-one-meaning. (Or, at least, all the docs I've read seem to say that.) Commented Feb 1, 2012 at 2:26

2 Answers 2

Reset to default
6

From the python class documentation:

Class definitions place yet another namespace in the local scope.

A special quirk of Python is that – if no global statement is in effect – assignments to names always go into the innermost scope. Assignments do not copy data — they just bind names to objects. The same is true for deletions: the statement del x removes the binding of x from the namespace referenced by the local scope. In fact, all operations that introduce new names use the local scope: in particular, import statements and function definitions bind the module or function name in the local scope. (The global statement can be used to indicate that particular variables live in the global scope.)

So within a function (or a scope) the assignment creates a local unbound variable that is accessed before it is bound, whereas in a class definition it creates an entry in the "namespace" dictionary of that class on assignment, allowing the resolution of something to the outer namespace (the module namespace).

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

5

Consider the following example which may help to clarify this:

import datetime

class Foo(object):
    datetime = datetime.datetime

>>> datetime
<module 'datetime' from '/usr/lib/python2.6/lib-dynload/datetime.so'>
>>> Foo.datetime
<type 'datetime.datetime'>

Note that the line datetime = datetime.datetime is actually assigning to the name Foo.datetime, which is not ambiguous with the global datetime (like it would be if the same code were in the function).

In summary, because class definitions create a new namespace as well as a new scope, you are allowed to directly access a name in an enclosing scope and assign to the same name in the local scope.

Improve this answer

4 Comments

"Note that the line datetime = datetime.datetime is actually assigning to the name Foo.datetime, which is not ambiguous with the global datetime" — No: it is assigning to the name datetime: If you add two print datetime statements, one before the datetime = , and one after, how is the datetime in that statement not ambiguous, in some manner that is different from the same statements in a function?
@Thanatos - Yeah I can see how that is unclear. What I was trying to say is that the namespace created by the class allows for an unambiguous way to access both the global and class attribute from other scopes, but you are right there is still ambiguity within the local scope of the class.
But the crux of the question is how is this any different than what happens in a function? You state, "because class definitions create a new namespace as well as a new scope" — do not functions create both a new namespace and a new scope? — "you are allowed to directly access a name in an enclosing scope" — I can do this in a function — "and assign to the same name in the local scope" — I can only do this in a class definition… why?
"do not functions create both a new namespace and a new scope?" — The namespace that functions create is deleted when the function returns or raises an exception, while the namespace that classes create persists after the class definition. This difference in namespace behavior is the basis for allowing that assignment in classes but not functions.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.