Shulou(Shulou.com)05/31 Report--

This article focuses on "Python Namespace and scope instance Analysis". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn "Python Namespace and scope instance Analysis".

One namespace

A namespace is where the mapping / binding relationship between a name and an object is stored. For del 3, Python applies for memory space to store object 3, and then stores the binding relationship between name x and 3 in the namespace, and Python x means to clear the binding relationship.

There are up to three namespaces during program execution

1.1 built-in namespace

Generated / recycled with the startup / shutdown of the python interpreter, so it is the first namespace to be loaded to hold some built-in names, such as built-in function names

> max # built-in built-in 1.2 global namespace

Generated / recycled with the start / completion of the execution of the python file is the second loaded namespace, in which the names generated during the execution of the file are stored, as follows

Import sys # module name sysx=1 # variable name xif x = 1: yroom2 # variable name ydef foo (x): # function name foo yuan1 def bar (): passClass Bar: # class name Bar pass 1.3 local namespace

If the function is temporarily generated / recycled with the call / end of the function, the formal parameters of the function and the names defined in the function will be stored in the namespace

Def foo (x): the function code is executed only when yroom3 # calls the function, and the names x and y are stored in the local namespace of the function

The loading order of namespaces is: built-in namespaces-> global namespaces-> local namespaces, while finding a name must be found from one of the three namespaces. The search order is: local namespaces-> global namespaces-> built-in namespaces.

Scope 2.1 Global scope and local scope

The three namespaces can be divided into two areas according to the scope of the name:

Global scope: names in global namespaces, built-in namespaces belong to the global scope, and names in this scope survive globally (unless deleted, otherwise survive the entire file execution), globally valid (can be used anywhere)

Local scope: names in local namespaces belong to local scope. The names in this range are temporarily alive (that is, they are temporarily generated when the function call is called, and released after the function call is over), and are locally valid (can only be used within the function).

2.2 scope and priority of name lookup

When looking for a name in the local scope, the starting position is the local scope, so first look for the local namespace, do not find it, and then go to the global scope: first look for the global namespace, and then look for the built-in namespace. Finally, if you don't find anything, you'll throw an exception.

X scope 100 # name of global scope xdef foo (): X scope 300 # name of local scope x print (x) # find xfoo () # locally and the result is 300

When looking for a name in the global scope, the starting position is the global scope, so look for the global namespace first, then find the built-in namespace, and then throw an exception if you don't find it.

X=100def foo (): xroom300 # produces the local scope name xfoo () print (x) # when the function is called, looking for x globally, the result is 100

Tip: you can call the built-in functions locals () and globals () to view the names of the local scope and the global scope, respectively, and the results are in dictionary format. The result of locals () found in the global scope is equal to globals ()

Python supports the nested definition of functions. When looking for a name in an embedded function, it will first look for the name of its own local scope, and then find the scope of the external nested function definition layer by layer from the inside to the outside. If it is not found, it will find the global scope.

X=1def outer (): xSecret2 def inner (): # the function name inner belongs to the scope of the outer layer: Xfol3 print ('inner xinner% s'% x) inner () print ('outer xinner% s'% x) outer () # the result is inner x:3outer xinner 2

No matter how many layers are nested within the function, you can view the name of the global scope. If you want to modify the value of the name in the global namespace within the function, you need to use the global keyword when the value is immutable.

X=1def foo (): global x # declares x as the name of the global namespace x=2foo () print (x) # results in 2

When the value of the argument is of a variable type, the modification of the value in the function will directly reflect the original value.

Num_list= [1Jing 2 Jue 3] def foo (nums): nums.append (5) foo (num_list) print (num_list) # the result is [1 Jing 2 Jing 3, 5]

For nested multi-tier functions, use the nonlocal keyword to declare the name as a scope (non-global) from the external nested function definition

Def F1 (): def f2 (): nonlocal x xylene 3 f2 () # call f2 (), change the value of the name x in F1 scope print (x) # View xf1 () # result 3 in F1 scope

Nonlocal x looks up the name x from the outer function of the current function, and throws an exception if the outermost function cannot be found.

At this point, I believe you have a deeper understanding of "Python namespace and scope instance analysis". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.