Python——day11 函数（对象、名称空间、作用域、嵌套、闭包）

佚名 5年前 (2019-04-01) Python 1203人围观抢沙发百度已收录

一、函数对象

函数名就是存放了函数的内存地址，存放了内存地址的变量都是对象，即函数名就是函数对象函数对象的应用
1、可以直接被引用 fn = cp_fn
2 、可以当作函数参数传递 computed(cp_fn, 100, 20)
3、可以作为函数的返回值 get_cp_fn(cmd): return add
4、可以作为容器类型的元素 method_map: 对应关系中的值

函数名存放的就是函数的地址，所以函数名也是对象，称之为函数对象 a=10 def fn(): num=10 print('fn function run') print(fn) b= a print(b)

1、可以直接被引用 func=fn print(func) fn() func() 2、可以当作函数参数传递 def add(a,b): # +
  return a+b def low(a,b): # -
    return a - b def jump(a,b): return a * b    # * def full(a,b): return a / b    # /

SRE实战互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

计算：通过该函数可以完成对任意两个数的四则运算
def computed(fn,n1,n2):
    # fn 代表四则运算中的一种
    # res代表运算结果
    res=fn(n1,n2)
    return res

完成两个数的某一运算，拿到结果： 方法一： result=computed(add,100,20) print(result) 方法二： while True: cmd=input('cmd:') if cmd=='add': result=computed(add,100,20) elif cmd=='low': result=computed(low,100,20) else: print('输入有误') print(result)

 3、可以作为容器类型的元素 def add(a,b): # +
  return a+b def low(a,b): # -
    return a - b def jump(a,b): return a * b         # * def full(a,b): return a / b        # / def quyu(a,b): return a%b           # % def computed(fn,n1,n2): res=fn(n1,n2) return res method_map={ 'add':add, 'low':low, 'jump':jump, 'full':full, 'quyu':quyu, } while True: cmd=input('cmd:') # 用户输入的指令只有有对应的关系,就会自动去走对应的计算方法 # 这样外界就不能失去关系到底有哪些计算方法 if cmd in method_map: cp_fn=method_map[cmd] #拿到计算方法 result=computed(cp_fn,100,20) # 通过计算方法得到计算 结果 print(result) else: print('输入有误，退出') break

 4、 可以作为函数的返回值 def add(a,b): # +
  return a+b def low(a,b): # -
    return a - b def jump(a,b): return a * b         # * def full(a,b): return a / b        # / def quyu(a,b): return a %b def computed(fn,n1,n2): res=fn(n1,n2) return res method_map={ 'add':add, 'low':low, 'jump':jump, 'full':full, 'quyu':quyu, } # 根据指令获取计算方法 def get_cp_fn(cmd): if cmd in method_map: return method_map[cmd] return add # 输入有误默认方法处理 while True: cmd=input('cmd:') if cmd in method_map: if cmd=='quit': break cp_fn=get_cp_fn(cmd) result=computed(cp_fn,100,20) print(result)

二、名称空间

名称空间：存放名字与内存空间地址对应关系的容器
作用：解决由于名字有限，导致名字重复发送冲突的问题

三种名称空间
Built-in：内置名称空间；系统级，一个；随解释器执行而产生，解释器停止而销毁
Global：全局名称空间；文件级，多个；随所属文件加载而产生，文件运行完毕而销毁
Local：局部名称空间；函数级，多个；随所属函数执行而产生，函数执行完毕而销毁

注： del 名字：可以移除查找最近的名字与内存空间地址的对应关系 加载顺序：Built-in > Global > Local print(len('abcd')) len=len('asdbnmm') print(len) del len # 删除上面赋值的len那最下面的'ndknwk'就可以打印出长度 print(len('ndknwk'))

def fn1():
    len=10
    print(len)
def fn2():
    len=20
    print(len)
fn1()
fn2()

三、作用域

作用域：名字起作用的范围
作用：解决同名字可以共存问题四种作用域
Built-in：内置作用域，所有文件所有函数
Global：全局作用域，当前文件所有函数
Enclosing：嵌套作用域，当前函数与当前函数的内部函数
Local：局部作用域，当前函数注
不同作用域之间名字不冲突，以达到名字的重用
查找顺序：Local > Enclosing > Global > Built-in

len=10 def outer(): len=20 def inner(): len=30 print('1:',len) # 输出30  inner -> outer -> global -> built-in inner() print('2:',len) # 输出20 outer -> global -> built-in outer() print('3:',len) # 输出10 lobal -> built-in del len print('4:',len)  # 输出的是内部地址 built-in

四、嵌套使用

将函数直接定义到另一个函数内部，就可以使用外部函数的中的名字
def outer():
    num = 20
    def inner():
        print(num) # inner就可以直接使用outer中的名字
    inner()
outer()

1、global关键词
def fn():
    global  num
    num=20
    print(num)
global关键词可以将local的名字提升为Global的名字
 一个文件中的Global名字就是一个，所以函数内部外部使用的名字都是一个
fn ()  #:一定要调用函数，才能产生名字，并提升
print(num)

2、 函数的嵌套定义
 将函数直接定义到另一个函数内部，就可以使用外部函数中的名字
def outer():
    num=20
    def inner():
        print(num)  # inner就是可以直接使用outer中的名字
outer()
传值方向：内置地址——内部的值——外部的值

方法一

print(len)
len(10)
def fn():
    len=20
    print(len)
fn()
print(len)

方式二：
ls=[] def fn1(): ls=[] ls.append(100) print(ls) fn1() print(ls) 定义一个函数，函数中有一个变量 def fn2(): num=20 return num # 如果下一个要运行成功 在定义一个函数，该函数要使用上一个函数中的变量 def fn3(): print(num) # 报错因为上个函数运行后变量就被销毁了 num=fn2() # 定义一个新的num然后赋值给上一个函数，fn3则就可以运行成功 fn3()

方法三
num=10 def fn2(): global num # Local:num=>>Golbal:num num=20 #将20 num=30 local的名字一旦golbal，就变成Global的名字，一个文件中的Global名字就是一个 def fn3(): global num # 全局作用域作用全局，并将两个文件中的值变为同一个值输出 num=40 print(num) # 输出20 20 fn2() print(num) # 输出30 20 20 fn3() print(num) # 输出30 40 40 20 20

将函数直接定义到另一个函数的内部,就可以使用外部函数中的名字
def fn4():
    num=20
    def fn5():
        print(num)
    fn5()
fn4()  #输出结果为20

五、闭包

1、定义：closure：被包裹的函数，称之为闭包
2、完整的闭包结构：1.将函数进行闭包处理；2.提升函数名的作用域，将内部函数对象作为外部函数的返回值

def outer(url):
    def get_html():
        html = requests.get(url)
        print(html.text)
    return get_html

先预定义多个爬虫方法，爬页面操作并未执行
baidu = outer('https://www.baidu.com')
python = outer('https://www.python.org')
sina = outer('https://www.sina.com.cn')
# 什么时候想爬什么页面就调用指定页面的爬虫方法
baidu()
sina()
baidu()