函数嵌套复习

1.函数对象:函数是第一类对象
特点
  1:可以被引用

1 def func():
2     pass
3 f =func
4 print(f is func)

可以被引用

  2:可以当做参数传给其它函数

1 def foo():
2     print(‘from foo‘)
3 def bar(func):
4     print(‘func‘)
5     func()
6 bar(foo)  #foo就相当于func

可以当做参数传给其他的函数

  3:可以当做函数的返回值

1 def foo():
2     print(‘foo‘)
3 def ddd(func):
4     print(func)
5     return func
6 ddd(foo)()

可以当做函数的返回值

  4:可以当做容器类型的一个元素

 1 def get():
 2     print(‘get‘)
 3 def put():
 4     print(‘put‘)
 5 def auth():
 6     print(‘auth‘)
 7 func_dic={
 8     ‘get‘:get,
 9     ‘put‘:put,
10     ‘auth‘:auth
11 }
12 # print(func_dic)
13 def main():
14     while True:
15         cmd = input(‘>>:‘).strip()
16         if not cmd :continue
17         if cmd in func_dic:
18             func_dic[cmd]()
19 if __name__ == ‘__main__‘:
20     main()

可以当做容器类型的一个元素

2.函数嵌套调用(可以吧大的问题分成一个个小的问题,然后调用,缩减代码)

 1 def my_max2(x,y):
 2     ‘‘‘两个数比较大小‘‘‘
 3     return x if x>y else y
 4 print(‘最大的数是:%s‘%my_max2(1,2))
 5 def my_max4(a,b,c,d):
 6     ‘‘‘四个数比较大小‘‘‘
 7     res1 = my_max2(a,b)
 8     res2 = my_max2(res1,c)
 9     res3 = my_max2(res2,d)
10     return res3
11 print(‘最大的数是:%s‘%my_max4(5,8,1,4))

比较大小

3.函数嵌套定义

1 def f1():
2     x=1
3     def f1():
4         def f3():
5             pass
6 f1()

嵌套定义

4.名称空间:指的是内存级别隔离的空间(存放名字与值绑定关系的地方)
分类:
  内置名称空间:会随着python解释器的运行而产生,如果解释器关闭则回收,存放python解释器自带的名字
  全局名称空间:执行python文件时产生,文件执行结束后回收,存放的文件级别的名字
  局部名称空间:只有在调用函数时才会临时产生,在函数调用结束后就回收了,存放的函数内部定义的名字
三类名称空间的加载顺序:内置名称空间-->全局名称空间-->局部名称空间
查找名字的顺序:
  在局部调用:局部命名空间--->全局命名空间--->内置命名空间
  站在全局范围找:全局----内置----局部
5.作用域:就是作用范围
  全局作用域:全局命名空间和内置命名空间(文件执行的时候生效,在文件执行结束后就失效了)
        全局存活,全局有效
  局部作用域:局部命名空间(只在函数调用时生效,函数调用结束后失效)
        临时存活,局部有效
强调:作用域关系在函数定义阶段就已经固定了,与调用位置无关

 1 x = 1
 2 def f1():
 3     x=2
 4     def f2():
 5         # x=3
 6         print(‘f2‘,x)
 7     return f2
 8 f = f1()
 9
10 def bar():
11     x = ‘bar‘  #x输出的还会上面函数里面的,如果x=3注释了,就输出2,
12     # 它不会输出bar,因为在函数定义阶段就已经固定了
13     f()
14 bar()

强调

6.global与nonlocalglobal:将局部变量强制转换成全局变量(一般不到迫不得已不要这样强转)

1 x=1
2 def func():
3     # global x
4     x=2
5     print(globals())  # 查看全局
6     print(locals())  # 查看局部
7 func()
8 print(x)  #打印的是全局变量1,如果加上global就成2了

global

nonlocal:让内部函数中的变量在上一层函数中生效,外部必须有

 1 x=5
 2 def o():
 3     x = 1
 4     def f1():
 5         # x= 2
 6         def f2():
 7             nonlocal x  #修改本层函数外的变量,如果本层函数外
 8             # 没有,就去找上一层的,但是不会去修改全局的
 9             x = 100
10         f2()
11         print(x)
12     f1()
13 o()
14 print(x)

nonloacal

7.闭包函数:定义在函数内部的函数,包含对外部作用域而非全局作用于的名字的引用,该函数就是闭包函数

 1 x = 1
 2 def f1():
 3     y =2222
 4     def f2():
 5         print(y)
 6     return f2
 7 f =f1()
 8 print(f)
 9 print(f.__closure__)  #判断是不是闭包函数
10 print(f.__closure__[0].cell_contents)  #输出2222 #查看闭包的内容

闭包函数举例1

1 from urllib.request import urlopen
2 def index(url):
3     def inner():
4         return urlopen(url).read()
5     return inner
6 baidu = index(‘http://www.baidu.com‘)
7 print(baidu())
8 print(baidu())
9 print(baidu())

缓存网页利用闭包函数举例2

1 from urllib.request import urlopen
2 def index(url):
3     return urlopen(url).read()
4 print(index(‘http://www.baidu.com‘))
5 print(index(‘http://www.baidu.com‘))
6 print(index(‘http://www.baidu.com‘))
7 print(index(‘http://www.baidu.com‘))

缓存网页不用闭包函数




时间: 2024-10-09 20:02:43

函数嵌套复习的相关文章

函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式,列表解析,生成器表达式 递归与二分法, 内置函数

函数嵌套名称空间与作用域闭包函数装饰器迭代器生成器三元表达式,列表解析,生成器表达式递归与二分法内置函数--------------------------------------------函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数def max(x,y): if x>y: return x else: return ydef max1(a,b,c,d): res=max(a,b) res2=max(res,c) res3=ma

python--函数的返回值、函数参数的使用、名称空间与作用域、函数嵌套、函数对象

今天学习内容有函数的返回值.函数参数的使用.名称空间与作用域.函数嵌套. 下来我们一一查看. 函数的返回值 看几个栗子: def func(x): return x**2 y=func(10) print(y) def foo(): return None res=foo() print(res) def foo(): return{'a':1} res=foo() print(res['a']) def foo(): return {'a':1},1,'a',[1,2] res=foo() p

5.初识python装饰器 高阶函数+闭包+函数嵌套=装饰器

一.什么是装饰器? 实际上装饰器就是个函数,这个函数可以为其他函数提供附加的功能. 装饰器在给其他函数添加功能时,不会修改原函数的源代码,不会修改原函数的调用方式. 高阶函数+函数嵌套+闭包 = 装饰器 1.1什么是高阶函数? 1.1.1函数接收的参数,包涵一个函数名. 1.1.2 函数的返回值是一个函数名. 其实这两个条件都很好满足,下面就是一个高阶函数的例子. def test1(): print "hamasaki ayumi" def test2(func): return t

不使用回调函数的ajax请求实现(async和await简化回调函数嵌套)

在常规的服务器端程序设计中, 比如说爬虫程序, 发送http请求的过程会使整个执行过程阻塞,直到http请求响应完成代码才会继续执行, 以php为例子 $url = "http://www.google.com.hk"; $result = file_get_contents($url); echo $result; 当代码执行到第二行时,程序便陷入了等待,直到请求完成,程序才会继续往下跑将抓取到的html输出.这种做法的好处是代码简洁明了,运行流程清晰, 容易维护. 缺点就是程序的运

Python函数嵌套的例子

有关Python函数嵌套的实例,Python中的函数嵌套特性. 在Python中函数可以作为参数进行传递,而也可以赋值给其他变量(类似Javascript,或者C/C++中的函数指针):类似Javascript,Python支持函数嵌套,Javascript嵌套函数的应用模式对Python适用: >>> def multiplier(factor): ... def multiple(number): ... return number * factor ... return multi

js执行顺序/Promise优雅解决回调函数嵌套

先执行同步 然后把settimeout(function xx(){}放进堆栈 然后执行回调 function xx() /** * Created by Administrator on 2016/10/28. */ // nodejs 封装操作文件的功能 fs var fs = require('fs'); //同步读取 // var str = '' // str += fs.readFileSync('./data/01','utf-8'); // str += fs.readFileS

Oracle之分组函数嵌套以及表连接

--1 数据环境准备 scott 用户下面的emp,dept表 --2 要求 :求平均工资最高的部门编号,部门名称,部门平均工资 select d.deptno,d.dname,e.salfrom(select avg(sal) sal,deptnofrom emp egroup by deptnohaving avg(sal) = (select max(avg(sal)) from emp group by deptno))eleft join dept don e.deptno=d.dep

python基础之名称空间和作用域、函数嵌套

一.名称空间 1.定义:存放名字与值的绑定关系 2.名称空间分为:内置名称空间.全局名称空间.局部名称空间 内置名称空间:python解释器自带的名字,python解释器启动就会生成 全局名称空间:文件级别定义的名字都会存放与全局名称空间,执行python文件时会产生 局部名称空间:定义在函数内部的名字,局部名称空间只有在调用函数时才会生效,函数调用结束则失效 3.加载的顺序:三者的加载顺序:内置名称空间->全局名称空间->局部名称空间 4.取值的顺序:局部名称空间->全局名称空间-&g

python 全栈 python基础 (九)作用域 函数嵌套 闭包

名称空间与作用域 变量,函数 分成三种 #内置名称空间  内置函数, 系统函数内部自定义的. python查看内置函数,命令: import builtins dir(builtins) #全局名称空间  文件中 顶头写,没有任何缩进定义的函数或是变量. 定义之后,在整个文件的任何位置都可以用. #局部名称空间 定义之后,在局部环境内可以调用,例如在一个定义函数中定义的变量,只能在当前函数内部调用,往外全局或是其他函数均不能调用. 在外部,或是其他定义的函数调用的话,会报错! 内置和全局名称空间