一、函数对象

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. centos7安装配置mysql5.6

    1. 下载mysql的repo源 $ wget http://repo.mysql.com/mysql-community-release-el7-5.noarch.rpm 2. 安装mysql-co ...

  2. shell编程中的控制判断语句

    if 单格式与嵌套 if 条件表达式;then #当条件为真时执行以下语句 命令列表 else #为假时执行以下语句 命令列表 fi if 语句也可以嵌套使用 if 条件表达式1;then if 条件 ...

  3. Duplicate复制数据库并创建物理StandBy(pfile版本)

    1设定环境如下: Primary数据库 IP 172.17.22.16 SID orcl Standby数据库 IP 172.17.22.17 SID orcl 设置提示,以区分操作的位置 prima ...

  4. 基于spring-mybatis-data-common基架快速搭建web应用

    spring-mybatis-data-common做了哪些操作 1.日志依据层级归类输出,支持扩展 2.spring-mybatis持久层基础接口集成,支持扩展 3.常用业务接口定义,支持扩展. 只 ...

  5. RDLC 图形报表预览时 “本地报表处理期间错误”

    在RDLC报表中有图形报表的导出和打印都正常,但预览时"本地报表处理期间错误",这是因为你设置的图形太宽已经超过默认的A4 纸的宽度,解决办法:报表页面的报表--->报表属性 ...

  6. 格雷码(Gray code)仿真

    作者:桂. 时间:2018-05-12  16:25:02 链接:http://www.cnblogs.com/xingshansi/p/9029081.html 前言 FIFO中的计数用的是格雷码, ...

  7. 【LINUX】——如何配置宿主机和虚拟机IP在同一网段

    宿主机:win7  10.8.2.50 255.255.255.0 虚拟机:redhat 如果使用 NAT 的网络连接方式,虚拟机的 IP 会被分配为 192.168.*.* 网段,从虚拟机 ping ...

  8. React Native常用组件之ScrollView

    1. 两个要点 1.1 ScrollView必须有一个确定的高度才能正常工作 它实际上所做的就是将一系列不确定高度的子组件装进一个确定高度的容器(通过滚动操作) 通常有两种做法: 第一种: 直接给该S ...

  9. Java知多少(30)多态和动态绑定

    在Java中,父类的变量可以引用父类的实例,也可以引用子类的实例. 请大家先看一段代码: public class Demo { public static void main(String[] ar ...

  10. 关于ECMP 等价路由

    1.ECMP简介 Equal-CostMultipathRouting,等价多路径.即存在多条到达同一个目的地址的相同开销的路径.当设备支持等价路由时,发往该目的 IP 或者目的网段的三层转发流量就可 ...