一、名称空间与作用域
名称空间：存放名字的地方，准确的说名称空间是存放名字与变量值绑定关系的地方 内置名称空间：在python解释器启动时产生，存放一些python内置的名字 全局名称空间：在执行文件时产生，存放文件级别定义的名字 x=1 def func(): y=2 def f1():pass print import os class Foo: pass if x==1:z=3 del x 局部名称空间:在执行文件的过程中，如果调用了函数，则会产生该函数的局部名称空间 用来存放该函数内定义的名字，该名字在函数调用时生效，在函数调用结束后失效 加载顺序：内置---》全局---》局部 优先掌握一：名字的查找顺序是：局部-》全局-》内置 # max=1 def foo(): max=2 # print(max) foo() print(max) x=0 def f1(): x=1 def f2(): x=2 def f3(): x=3 print(x) f3() f2() print('=f1========',x) f1() def func1(): print('from func1') def func1(): print('=====?>') func1() x=1 x=10 print(x)
1、什么是名称空间？
#名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方）
2、名称空间的加载顺序
python test.py #1、python解释器先启动，因而首先加载的是：内置名称空间 #2、执行test.py文件，然后以文件为基础，加载全局名称空间 #3、在执行文件的过程中如果调用函数，则临时产生局部名称空间
3、名字的查找顺序
局部名称空间--->全局名称空间--->内置名称空间
#需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例
# max=1
def f1():
# max=2
def f2():
# max=3
print(max)
f2()
f1()
print(max)
二、作用域
作用域：作用的范围， 全局作用域：全局存活，全局有效:globals() max=1111111 def f1(): def f2(): def f3(): def f4(): # print(x) print(max) f4() f3() f2() f1() 局部作用域：临时存活，局部有效:locals() x=11111111111111111111111111111111111111111111 def f1(): x=1 y=2 def f2():pass # print(locals()) print(globals()) f1() print(locals() is globals()) print(locals()) print(dir(globals()['__builtins__'])) -------------------------------------------------- global nonlocal掌握 ：global 修改全局的 x=1 def f1(): global x 明确声明x就是全局的x ，所以就会把全局的x=1，改成局部的x=2。 x=2 f1() print(x) ----------------------------------------------- l=[] def f2(): l.append('f2') 能直接把l的值改‘f2’,因为l是列表，列表是可变类型。 f2() print(l) ---------------------------------------------------- x=0 def f1(): # x=1 def f2(): # x=2 def f3(): # global x nonlocal x //修改的是函数内部正上方的那个X，所有x被修改成2.只在函数内部有效。 x=3 f3() # print(x) f2() print(x) f1() print(x) ----------------------------------------------------- 优先掌握二：作用域关系，在函数定义时就已经固定 ，与调用位置无关,在调用函数时，必须必须必须 回到函数原来定义的位置去找作用域关系 x=1 def f1(): def f2(): print(x) return f2 def foo(func): x=300000 func() res=f1() print(res) func=f1() print(func) x=10000000 func() x=10000000 def foo(func): x=300000000 func() #f2() x=10000000000000000000000 foo(f1()) # x=10000000000000000000000 # foo(f1()) x=1 def f1(): global x x=2 f1() print(x)
#1、作用域即范围
- 全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效
- 局部范围（局部名称空间属于该范围）：临时存活，局部有效
#2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下
x=1
def f1():
def f2():
print(x)
return f2
x=100
def f3(func):
x=2
func()
x=10000
f3(f1())
#3、查看作用域：globals(),locals()
LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
locals 是函数内的名字空间，包括局部变量和形参
enclosing 外部嵌套函数的名字空间（闭包中常见）
globals 全局变量，函数定义所在模块的名字空间
builtins 内置模块的名字空间
三、global与nonlocal关键字
global nonlocal掌握 ：global 修改全局的
x=1
def f1():
global x 明确声明x就是全局的x ，所以就会把全局的x=1，改成局部的x=2。
x=2
f1()
print(x)
-----------------------------------------------
l=[]
def f2():
l.append('f2') 能直接把l的值改‘f2’,因为l是列表，列表是可变类型。
f2()
print(l)
----------------------------------------------------
x=0
def f1():
# x=1
def f2():
# x=2
def f3():
# global x
nonlocal x //修改的是函数内部正上方的那个X，所有x被修改成2.只在函数内部有效。
x=3
f3()
# print(x)
f2()
print(x)
f1()
print(x)
四、闭包函数
1、什么是闭包？
#内部函数包含对外部作用域而非全局作用域的引用
#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来喽，包起呦，包起来哇
def counter():
n=0
def incr():
nonlocal n
x=n
n+=1
return x
return incr
c=counter()
print(c())
print(c())
print(c())
print(c.__closure__[0].cell_contents) #查看闭包的元素
2、闭包的意义与应用
#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
#应用领域：延迟计算（原来我们是传参，现在我们是包起来）
from urllib.request import urlopen
def index(url):
def get():
return urlopen(url).read()
return get
baidu=index('http://www.baidu.com')
print(baidu().decode('utf-8'))
大前提：作用域关系，在函数定义时就已经固定 ，与调用位置无关,在调用函数时，必须必须必须 回到函数原来定义的位置去找作用域关系 闭包函数： 1. 定义在函数内部的函数 2. 包含对外部作用域名字的引用，而不是对全局作用域名字的引用 那么该内部函数就称为闭包函数 x=1 def f1(): x=11111111111 def f2(): print(x) return f2 func=f1() x=1000 func() def foo(): x=12312312312312312312312312312312312313123 func() foo() def deco(): x=123123123123 def wrapper(): print(x) return wrapper func=deco() func() #闭包函数的应用:惰性计算 import requests #pip3 install requests 安装pip3 def get(url): return requests.get(url).text print(get('https://www.python.org')) print(get('https://www.python.org')) print(get('https://www.python.org')) print(get('https://www.python.org')) def index(url): # url='https://www.python.org' def get(): # return requests.get(url).text print(requests.get(url).text) return get python_web=index('https://www.python.org') baidu_web=index('https://www.baidu.com') python_web() baidu_web() name='egon' def index(url): x=1 y=2 def wrapper(): # x # y # return requests.get(url).text print(name) return wrapper python_web=index('https://www.python.org') # print(python_web.__closure__[0].cell_contents) print(python_web.__closure__) # print(python_web.__closure__[0].cell_contents) # print(python_web.__closure__[1].cell_contents) # print(python_web.__closure__[2].cell_contents)
五、嵌套函数
函数的嵌套调用：在调用一个函数的过程中，又调用了其他函数
def bar():
print('from nbar')
def foo(): #再调用一个函数的过程中，又去调用了另外一个函数
print('from foo')
bar()
foo()
-----------------------------------------
求两个值最大的函数
def max2(x,y):
if x > y:
return x
else:
return y
def max4(a,b,c,d): 求四个值的最大值
res1=max2(a,b) 把a b 传进去会得到第一个结果
res2=max2(res1,c) 再调用一次，拿着这一次得到的结果在跟c进行比较
res3=max2(res2,d)
return res3 得到res3最终的结果
print(max4(1,2,3,-1))
-------------------------------------------------
函数的嵌套定义：在一个函数的内部，又定义另外一个函数
def f2():
print('from f2')
def f1():
x=1 函数内部定义的名字，只是在函数被调用的时候生效。
# def f2()
# print('from f2')
f2()
f1()