##  4.2.  Naming and binding  Â¶

###  4.2.1.  Binding of names  Â¶

_Names_ refer to objects. Names are introduced by name binding operations.

The following constructs bind names:

  * formal parameters to functions, 

  * class definitions, 

  * function definitions, 

  * assignment expressions, 

  * [ targets  ](simple_stmts.html#assignment) that are identifiers if occurring in an assignment: 

    * [ ` for  ` ](compound_stmts.html#for) loop header, 

    * after ` as  ` in a [ ` with  ` ](compound_stmts.html#with) statement, [ ` except  ` ](compound_stmts.html#except) clause, [ ` except*  ` ](compound_stmts.html#except-star) clause, or in the as-pattern in structural pattern matching, 

    * in a capture pattern in structural pattern matching 

  * [ ` import  ` ](simple_stmts.html#import) statements. 

  * [ ` type  ` ](simple_stmts.html#type) statements. 

  * [ type parameter lists  ](compound_stmts.html#type-params) . 

The ` import  ` statement of the form ` from  ...  import  *  ` binds all
names defined in the imported module, except those beginning with an
underscore. This form may only be used at the module level.

A target occurring in a [ ` del  ` ](simple_stmts.html#del) statement is also
considered bound for this purpose (though the actual semantics are to unbind
the name).

Each assignment or import statement occurs within a block defined by a class
or function definition or at the module level (the top-level code block).

If a name is bound in a block, it is a local variable of that block, unless
declared as [ ` nonlocal  ` ](simple_stmts.html#nonlocal) or [ ` global  `
](simple_stmts.html#global) . If a name is bound at the module level, it is a
global variable. (The variables of the module code block are local and
global.) If a variable is used in a code block but not defined there, it is a
_free variable_ .

Each occurrence of a name in the program text refers to the _binding_ of that
name established by the following name resolution rules.

###  4.2.2.  Resolution of names  Â¶

A _scope_ defines the visibility of a name within a block. If a local variable
is defined in a block, its scope includes that block. If the definition occurs
in a function block, the scope extends to any blocks contained within the
defining one, unless a contained block introduces a different binding for the
name.

When a name is used in a code block, it is resolved using the nearest
enclosing scope. The set of all such scopes visible to a code block is called
the blockâs _environment_ .

When a name is not found at all, a [ ` NameError  `
](../library/exceptions.html#NameError "NameError") exception is raised. If
the current scope is a function scope, and the name refers to a local variable
that has not yet been bound to a value at the point where the name is used, an
[ ` UnboundLocalError  ` ](../library/exceptions.html#UnboundLocalError
"UnboundLocalError") exception is raised. [ ` UnboundLocalError  `
](../library/exceptions.html#UnboundLocalError "UnboundLocalError") is a
subclass of [ ` NameError  ` ](../library/exceptions.html#NameError
"NameError") .

If a name binding operation occurs anywhere within a code block, all uses of
the name within the block are treated as references to the current block. This
can lead to errors when a name is used within a block before it is bound. This
rule is subtle. Python lacks declarations and allows name binding operations
to occur anywhere within a code block. The local variables of a code block can
be determined by scanning the entire text of the block for name binding
operations. See [ the FAQ entry on UnboundLocalError
](../faq/programming.html#faq-unboundlocalerror) for examples.

If the [ ` global  ` ](simple_stmts.html#global) statement occurs within a
block, all uses of the names specified in the statement refer to the bindings
of those names in the top-level namespace. Names are resolved in the top-level
namespace by searching the global namespace, i.e. the namespace of t