一、函数对象

1、函数对象:函数名存放的就是函数的地址,所以函数名也是对象,称之为函数对象

  1. a = 10
  2. print(a,id(a))
  3.  
  4. def fn():
  5. num = 10
  6. print('fn fuction run')
  7. print(fn())
  8.  
  9. b = a
  10. print(b,id(b))

2、函数对象的四个应用

①可以直接被引用fn=cp_fn

  1. def fn():
  2. num = 10
  3. print('fn function run')
  4. print(fn)
  5.  
  6. def fn():
  7. num = 10
  8. print('fn function run')
  9.  
  10. func = fn
  11. print(fn)
  12. print(func)

②可以当做函数参数传递computed(cp_fn,a,b)

  1. # 通过该函数可以对任意两个数的四则运算某一运算
  2. def add(a,b):
  3. return a+b
  4. def low(a,b):
  5. return a-b
  6. def jump(a,b):
  7. return a*b
  8. def full(a,b):
  9. return a/b
  10. def computed(fn,a,b): # fn代表四则运算的一种,res为运算结果
  11. res = fn(a,b)
  12. return res
  13.  
  14. while True:
  15. cmd = input('cmd:>>>')
  16. if cmd =='add':
  17. result=computed(add,100,200)
  18. elif cmd =='low':
  19. result=computed(low,100,200)
  20. elif cmd =='jump':
  21. result=computed(jump,100,200)
  22. elif cmd =='full':
  23. result=computed(full,100,200)
  24. else:
  25. print('输入有误')
  26. print(result)

③可以作为容器类型的元素

  1. def add(a,b):
  2. return a+b
  3. def low(a,b):
  4. return a-b
  5. def jump(a,b):
  6. return a*b
  7. def full(a,b):
  8. return a/b
  9. def quyu(a,b):
  10. return a %b
  11. def computed(fn,a,b):
  12. res = fn(a,b)
  13. return res
  14. method_map={
  15. 'add':add,
  16. 'low':low,
  17. 'jump':jump,
  18. 'full':full,
  19. 'quyu':quyu,
  20. }
  21.  
  22. while True:
  23. cmd = input('cmd:') # 用户输入的指令只要有对应关系,就会自动取走计算方法
  24. if cmd in method_map: # 这样外界就不关心有哪些计算方法
  25. cp_f = method_map[cmd]
  26. result = computed(cp_fn,100,200)
  27. print(result)
  28. else:
  29. print('输入错误')
  30. break

④可以作为函数的返回值

  1. def add(a,b):
  2. return a +b
  3. def low(a,b):
  4. return a-b
  5. def jump(a,b):
  6. return a*b
  7. def full(a,b):
  8. return a/b
  9. def quyu(a,b):
  10. return a%b
  11.  
  12. def computed(fn,a,b):
  13. res = fn(a,b)
  14. return res
  15.  
  16. method_map = {
  17. 'add':add,
  18. 'low':low,
  19. 'jump':jump,
  20. 'full':full,
  21. 'quyu':quyu,
  22. }
  23. # 根据指令获取计算方法
  24. def get_cp_fn(cmd):
  25. if cmd in method_map:
  26. return method_map[cmd] # 返回的是method_map中的’cmd’对应的值cmd
  27. return jump # 输入有误就采用jump
  28.  
  29. while True:
  30. cmd = input('cmd:')
  31. if cmd =='quit':
  32. break
  33. cp_fn = get_cp_fn(cmd)
  34. result = computed(cp_fn,100,200)
  35. print(result)

二、名称空间

  1. print(len('abc')) # 结果为 3
  2. len = len('abcsdf')
  3. print(len) # 结果为 6
  4. del len
  5. print(len('abc')) # 结果为 3
  6.  
  7. def fn1():
  8. len = 100
  9. print(len)
  10.  
  11. def fn2():
  12. len = 200
  13. print(len)
  14. fn1()
  15. fn2()

1、定义:存放名字与内存空间地址对应关系的容器

2、作用:解决由于名字有限,导致名字重复发送冲突的问题

3、三种名称空间:

  1. build-in:内置名称空间,系统级,一个,随解释器执行而产生,解释器停止而销毁
  2. global:全局名称空间,文件级,多个,随所属文件加载而产生,文件运行完毕而终止
  3. local:局部名称空间,函数级,多个,随所属函数执行而产生,函数执行完毕而销毁
  4. 加载顺序:build-in>global>local

4、global关键词

  可以将local的名字提升为global的名字。一个文件中的global名字就是一个,所以函数内外部使用的名字都是一个

  注意:一定要调用函数,才能产生函数,并提升

  1. # part1
  2. len =1000
  3. def fn():
  4. len = 200
  5. print(len)
  6. fn() # 结果为200
  7. print(len) # 结果为1000
  8.  
  9. # part2
  10. l = []
  11. def fn():
  12. l=[]
  13. l.append(200)
  14. print(l)
  15. fn() # 结果为 [200]
  16. print(l) # 结果为[]
  17.  
  18. # 定义一个函数,函数中有一个变量
  19. def fn1():
  20. num = 200
  21. return num
  22. fn1()
  23. # 在定义一个函数,该函数使用上一个函数的变量
  24. def fn2():
  25. print(num)
  26. num = fn1()
  27. fn2()
  28.  
  29. # part3
  30. num = 100
  31. def fn1():
  32. global num #100 # 将logal:num>global:num # 将局部上升到全局
  33. num=200
  34. num=300
  35. # num=300
  36. def fn2(): # logal中的名字一旦global,就变成global的名字,一个文件中的global就是一个
  37. global num #
  38. num = 400
  39. print(num)
  40. # num=400
  41. fn1()
  42. print(num) # 结果为300
  43. fn2()
  44. print(num) # 结果为300 400 400

三、作用域

1、定义:名字起作用的范围

2、作用:解决名字可以共存问题

3、四种作用域

  1. build-in:内置作用域,所有文件所有函数
  2. global:全局作用域,当前文件所有函数
  3. local:局部作用域,当前函数
  4. enclosing:嵌套作用域,当前函数与当前函数的内部函数
  1. len = 100
  2. def outer():
  3. len = 200
  4. def inner():
  5. len =300
  6. print('',len) # 结果为300
  7. inner()
  8. print('',len) # 结果为200
  9. outer()
  10. print('',len) # 结果为100
  11.  
  12. del len
  13. print('',len) # 4 <built-in function len>

4、不同作用域之间名字不冲突,以达到名字的重用

  1. 查找顺序:local>enclosing>glocal>build-in

四、函数的嵌套定义和闭包

1、函数的嵌套定义:将函数直接定义到另一个函数的内部,可以使用外部函数中的名字

  1. def fn1():
  2. num = 200
  3. def fn2(): # fn2就可以直接使用fn1中的名字
  4. print(num)
  5. fn2()
  6. fn1()

2、闭包:

①closure:被包裹的函数称之为闭包。定义在函数内部的函数

②完整的闭包结构:

将函数进行闭包处理

提升函数名的作用域,将内部函数对象作为外部函数的返回值

  1. def a():
  2. def b():
  3. print("cc")
  4. return b
  5. a() #a()=b
  6. y = a()() # a()() =b()
  7. y # 结果为 cc
  8.  
  9. def a():
  10. def b():
  11. def c():
  12. def d():
  13. print('dddd')
  14. return d
  15. print("ccc")
  16. return c
  17. return b
  18. a() # b
  19. a()() #b()
  20. a()()() #b()() = c()
  21. a()()()
  22. y=a()()()()
  23. y # 结果为 dddd

day11 十一、函数对象,名称空间,作用域,和闭包的更多相关文章

  1. python12--字符串的比较 函数的默认值的细节 三元表达式 函数对象 名称空间 作用域 列表与字典的推导式 四则运算 函数的嵌套

     复习   1.字符串的比较; 2.函数的参数; ******实参与形参的分类: 3.函数的嵌套调用:     # 字符串的比较#  -- 按照从左往右比较每一个字符,通过字符对应的ascii进行比较 ...

  2. day_12函数默认值,数据类型的补充,函数对象名称空间与作用域,函数的嵌套定义

    复习, 昨天讲了字符串的比较,按照从左往右比较每一个字符,通过字符对应的ASCII码进行比较 函数的参数,‘ 实参与形参 形参:在函数定义时()中出现的参数 实参,在函数调用时()中出现的参数 实参的 ...

  3. Python记录9:函数4:名称空间作用域+闭包函数+装饰器

    ''' 一: 名称空间namespaces     名称空间就是存放名字与值绑定关系的内存空间 二: 名称空间分为三种     内置名称空间:         1. 特点: 存放是python解释器自 ...

  4. Day11名称空间,作用域,闭包函数

    Day11 1.函数对象: ①可以被引用 ​ ②可以作为另一个函数的参数 ​ ③可以作为另一个函数的返回值0 ​ ④可以被存储到容器类型中 2.函数嵌套: ①嵌套调用:在一个函数中调用了另一个函数 ​ ...

  5. Python 函数对象-函数嵌套-名称空间与作用域-闭包函数

    今日内容: 1. 函数对象 函数是第一类对象: 指的是函数名指向的值可以被当中数据去使用 1.可以被引用 2.可以当做参数传给另一个函数 3.可以当做一个函数的返回值 4.可以当做容器类型的元素 2. ...

  6. 搞懂Python的类和对象名称空间

    代码块的分类 python中分几种代码块类型,它们都有自己的作用域,或者说名称空间: 文件或模块整体是一个代码块,名称空间为全局范围 函数代码块,名称空间为函数自身范围,是本地作用域,在全局范围的内层 ...

  7. day 22 面向对象 类与对象 名称空间操作

    一.面向对象 1.面向过程编程 核心是"过程"二字,过程指的是解决问题的步骤,即先干什么再干什么 基于该思想编写程序就好比在编写一条流水线,是一种机械式的思维方式. 优点:复杂的问 ...

  8. python基础学习Day17 面向对象的三大特性之继承、类与对象名称空间小试

    一.课前回顾 类:具有相同属性和方法的一类事物 实例化:类名() 过程: 开辟了一块内存空间 执行init方法 封装属性 自动的把self返回给实例化对象的地方 对象:实例 一个实实在在存在的实体 组 ...

  9. 函数的名称空间,函数的嵌套(global, nonlocal),函数名的运用

    一 函数的名称空间 内置空间:存放python解释器内置函数的空间 全局空间:py文件运行时开辟的,存放的是执行的py文件(出去函数内部)的所有的变量与值的对用关系,整个py文件结束后才会消失. 局部 ...

  10. Python入门之函数的嵌套/名称空间/作用域/函数对象/闭包函数

    本篇目录: 一.函数嵌套 二.函数名称空间与作用域 三.函数对象 四.闭包函数 ============================================================ ...

随机推荐

  1. 每天一个linux命令(3):ls命令

    1.命令简介 ls(list 列出目录内容)命令用来列出显示指定目录里的文件及文件夹清单,缺省下ls用来打印出当前目录的清单.通过ls 命令不仅可以查看linux文件夹包含的文件,而且可以查看文件权限 ...

  2. 五分钟搞清楚MySQL事务隔离级别

    好久没碰数据库了,只是想起自己当时在搞数据库的时候在事务隔离级别这块老是卡,似懂非懂的.现在想把这块整理出来,尽量用最简洁的语言描述出来,供新人参考. 首先创建一个表account.创建表的过程略过( ...

  3. Android Data Recovery for Mac(安卓数据恢复软件)破解版安装

    1.软件简介    Android Data Recovery 是 macOS 系统上一款 Android 设备数据恢复软件,能够帮助我们在 mac 电脑上对 Android 设备进行数据恢复,文档. ...

  4. 在 OC 中调用 Swift 代码

    1.在 Objective-C 项目中使用 Swift 代码 1)在 OC 项目中创建 .Swift 文件,文件中的格式为其本有的格式. 2)Xcode 提示是否创建 Objective-C brid ...

  5. 检查死锁与Locked ownable synchronizers(转载)

    通过jstack可快速检查线程的死锁信息,用法如下: # 获取JVM ID(JAVA 进程ID),通过参数lv可以获取更详细的JAVA方法调用信息 jps -lv # 得到JVM ID后,执行jsta ...

  6. Gradle环境变量的配置

    配置GRADLE_HOME: 找到Android Studio中gradle的位置 E:\Android_Studio\gradle\gradle-2.10 配置GRADLE_USER_HOME: 找 ...

  7. 基于mindwave脑电波进行疲劳检测算法的设计(5)

    时隔两个多月了,前段时间在弄Socket,就没有弄这个了.现在好了,花了几天的时间,终于又完成了一小部分了.这一小节主要讲α,β,δ,θ等等波段之间的关系.废话不多说,直接给出这几天的成果. 上一次, ...

  8. 【iCore4 双核心板_FPGA】例程八:乘法器实验——乘法器使用

    实验现象: 程序运行时,绿色led闪烁(目前,具体的乘法器调用请参考iCore3乘法器例程) 核心代码: module multiplier_ctrl( input clk_25m, input rs ...

  9. Spring Session Redis

    http://www.infoq.com/cn/articles/Next-Generation-Session-Management-with-Spring-Session

  10. 【Linux】防火墙与CentOS中的iptables

    [iptables] 参考好文:http://www.zsythink.net/archives/1199.这个博客的作者写了深入浅出的iptables介绍,基本上我就是做个他的读书笔记. ■ 基本介 ...