一,复习

  1. '''
  2. 1.函数对象:函数名 => 存放的是函数的内存地址
  3.   1)函数名 - 找到的是函数的内存地址
  4.   2)函数名() - 调用函数 => 函数的返回值 eg:fn()() => fn的返回值一定是函数
  5.  
  6. 使用:
  7.   1)直接被其他变量接收 - 将函数的内存地址直接给其他变量 => 被赋值的变量也是函数对象
  8.   2)可以作为函数的参数 - 函数的形参接收到的实参是函数对象 => 形参被赋值后也是函数对象
  9.   3)可以作为函数的返回值 - 用变量在外界调用并接受这个函数的值 => 用来接收的变量也是函数对象
  10.   4)可以作为容器对象的成员 - 可以作为list、dict等的成员 => 函数对象作为成员的那个成员被取出就是函数对象
  11.   def add(n1, n2): return n1 + n2
  12.   method_map = {
  13.    'add': add
  14.   }
  15.  
  16. 2.名称空间与作用域
  17. # LEGB
  18.  
  19. # 名称空间:名字与地址的对应关系
  20.   内置:系统级,一个
  21.   全局:文件级,多个
  22.   局部:函数级,多个
  23.   加载顺序: 内置 > 全局 > 局部
  24.  
  25. # 作用域:名字起作用的范围
  26.   局部:只在局部可见
  27.   嵌套:在外层函数的局部与内部函数的局部可见
  28.   全局:在当前文件的任意位置可见
  29.   内置:在所有位置可见
  30.   查找顺序:局部 > 嵌套 > 全局 > 内置
  31.  
  32. 3.函数的嵌套定义:在函数的内部定义函数
  33. '''

二,今日内容

  1. ''' *****
  2. 1.函数的嵌套定义
  3.  
  4. 2.global、nonlocal关键字
  5.  
  6. 3.闭包及闭包的运用场景
  7.  
  8. 4.装饰器
  9. '''

三,函数的嵌套定义

  1. # 概念:在一个函数的内部定义另一个函数
  2.  
  3. # 为什么要有函数的嵌套定义:
  4. # 1)函数fn2想直接使用fn1函数的局部变量,可以将fn2直接定义到fn1的内部,这样fn2就可以直接访问fn1的变量
  5. def fn1():
  6. num = 10
  7. def fn2():
  8. print(num)
  9. fn2()
  10. fn1()
  11. #-----------------------------------------------------------
  12. def fn1():
  13. num = 10
  14. fn2(num) # fn2可以看到fn1的局部变量,但fn2的调用位置不在全局了
  15. print('fn1 end')
  16.  
  17. def fn2(num):
  18. print(num)
  19. fn1()
  20.  
  21. # 2)函数fn2名字就变成fn1的局部变量了,正常只能在fn1中使用,想在外部使用,可以将fn2函数对象作为fn1函数的返回值
  22.  
  23. # 3)在外部也用同名的变量fn2来接收fn1函数的执行结果(fn1函数的返回值),那么fn2也就是可以在外部被调用
  24. def fn1():
  25. num = 10
  26. return num
  27. num = fn1()
  28.  
  29. def fn2():
  30. print(num) # 本质访问的函数全局变量
  31. fn2()
  32.  
  33. # 闭包
  34. def fn1():
  35. num = 10
  36. def fn2():
  37. print(num)
  38. return fn2
  39. fn2 = fn1()
  40. fn2()

四,global关键字

  1. # 作用:将局部的变量提升为全局变量
  2.   # 1.全局没有同名变量,直接提升局部变量为全局变量
  3.   # 2.有同名全局变量,就是统一全局与局部的同名变量
  4.   # -- 如果局部想改变全局变量的值(发生地址的变化),可以用global声明该变量
  5.  
  6. # num = 888
  7. def fn1():
  8. global num
  9. # print(num)
  10. # 没有global修饰,num就是自己局部的变量
  11. # 有global修饰,num就是全局的num,全局中只能出现一个num,如果出现了值的改变,大家一起变
  12. num = 666
  13. def fn2():
  14. print(num) #
  15. fn1()
  16. fn2()

五,nonlocal关键字

  1. # 作用:将局部的变量提升为嵌套局部变量(向上提升一级)
  2.   # 1.必须有同名嵌套局部变量,就是统一嵌套局部与局部的同名变量
  3.   #   -- 如果局部想改变嵌套局部变量的值(发生地址的变化),可以用nonlocal声明该变量
  4.  
  5. def outer():
  6. num = 888
  7. def inner():
  8. nonlocal num
  9. num = 666
  10. print(num) #
  11. inner()
  12. print(num) #
  13. outer()

六,开放封闭原则

  1. # 开放封闭原则:在不修改源代码与调用方式的情况下为函数添加新功能 *****
  2. # 开放:有些事,你可以干 - 拓展功能
  3. # 封闭:有些事,你干不了 - 两个原则
  4.   # 1.不能修改源代码 - 1.无权修改 2.功能不特有 3.修改的位置多个,需要一一修改
  5.   # 2.不能修改原函数的调用方式 - 修改调用方式的弊端,原项目的所有函数调用都要修改

七,装饰器

  1. # 装饰器:满足开放封闭原则的一个闭包应用
  2.  
  3. # @outer语法来调用outer,规定传入被装饰的函数对象,所以参数固定为一个,接受被装饰的函数对象,
  4.  
  5. #公式:
  6. def outer(func):
  7. # 不能确定被装饰的函数的参数:来者不拒,用可变长参数来接受
  8. def inner(*args, **kwargs):
  9. pass # 新功能位1
  10. res = func(*args, **kwargs) # 解压带给原功能
  11. pass # 新功能位2
  12. return res
  13. return inner
  14.  
  15. # 使用装饰器(outer),得到新功能(inner)
  16.  
  17. # 用被装饰的函数名去接受装饰器的执行结果,调用装饰器时传入被装饰的函数对象
  18. @outer # fn = outer(fn) = inner
  19. def fn(): pass
  20.  
  21. # 表面感觉调用的是原函数,本质调用的是闭包(inner),使用fn调用和fn定义及inner需要参数统一
  22. fn()

八,一个函数被多次装饰

  1. #公式
  2. def outer(func):
  3. def inner(*args, **kwargs):
  4. res = func(*args, **kwargs)
  5. return res
  6. return inner
  7.  
  8. #验证账号
  9. def check_user(func):
  10. def inner(*args, **kwargs):
  11. # 账号的验证功能
  12. user = args[0] # type: str
  13. if not (user.isalpha() and len(user) >= 3):
  14. print('账号不合法')
  15. return False
  16.  
  17. res = func(*args, **kwargs)
  18. return res
  19. return inner
  20.  
  21. #验证密码
  22. def check_pwd(func):
  23. def inner(*args, **kwargs):
  24. pwd = args[1]
  25. if len(pwd) < 3:
  26. print('密码不合法')
  27. return False
  28.  
  29. res = func(*args, **kwargs)
  30. return res
  31. return inner
  32.  
  33. #打印结果
  34. def format_return(func):
  35. def inner(*args, **kwargs):
  36. res = func(*args, **kwargs)
  37. if res:
  38. return '登录成功'
  39. return '登录失败'
  40. return inner
  41.  
  42. # 登录的原功能
  43. @format_return
  44. @check_user
  45. @check_pwd
  46. def login(user, pwd):
  47. if user == 'owen' and pwd == '':
  48. return True
  49. return False
  50.  
  51. user = input('user: ')
  52. pwd = input('pwd: ')
  53. res = login(user, pwd)
  54. print(res)
  55.  
  56. # 执行过程:调用login => 进入第一个装饰器(format_return)的inner => 进入第二个装饰器(check_user)的inner => 进入第三个装饰器(check_pwd)的inner => 开始返回,
    从第三个返回到第二个再返回到第一个,最后返回到外界调用的位置

day13(函数嵌套定义,global,nonlocal关键字,闭包,装饰器)的更多相关文章

  1. 跟着太白老师学python day10 函数嵌套, global , nonlocal

    函数嵌套: 第一种嵌套方法 def func(): count = 123 def inner(): print(count) inner() func() 第二种嵌套方法 count = 123 d ...

  2. Day 10 动态参数&名称空间,局部全部.函数嵌套&global nonlocal关键字.

    一.动态参数#形参 有3种动态参数#*args 动态参数,不定长参数def func (*args): print(args,type(args))func(1,2,"alex", ...

  3. day20 Python 高阶函数,函数,嵌套,闭包 装饰器

    高阶函数定义 1.函数接收的参数是一个函数名 2.函数的返回值是一个函数名 3.满足上述条件任意一个都可以称之为高阶函数 一.函数的接收参数是一个函数名 import time def foo(): ...

  4. python笔记--3--函数、生成器、装饰器、函数嵌套定义、函数柯里化

    函数 函数定义语法: def 函数名([参数列表]): '''注释''' 函数体 函数形参不需要声明其类型,也不需要指定函数返回值类型 即使该函数不需要接收任何参数,也必须保留一对空的圆括号 括号后面 ...

  5. python函数闭包-装饰器-03

    可调用对象 callable()  # 可调用的(这个东西加括号可以执行特定的功能,类和函数) 可调用对象即  callable(对象)  返回为  True  的对象 x = 1 print(cal ...

  6. python 全栈开发,Day11(函数名应用,闭包,装饰器初识,带参数以及带返回值的装饰器)

    一.函数名应用 函数名是什么?函数名是函数的名字,本质:变量,特殊的变量. 函数名(),执行此函数. python 规范写法 1. #后面加一个空格,再写内容,就没有波浪线了. 2.一行代码写完,下面 ...

  7. python高级-闭包-装饰器

    闭包内容: 匿名函数:能够完成简单的功能,传递这个函数的引用,只有功能 普通函数:能够完成复杂的功能,传递这个函数的引用,只有功能 闭包:能够完成较为复杂的功能,传递这个闭包中的函数以及数据,因此传递 ...

  8. python 全栈开发,Day12(函数的有用信息,带参数的装饰器,多个装饰器装饰一个函数)

    函数的执行时,*打散.函数的定义时,*聚合. from functools import wraps def wrapper(f): # f = func1 @wraps(f) def inner(* ...

  9. 闭包&装饰器详解

    闭包 先不着急看闭包的定义,让我们从一段示例代码开始.如果将上一个示例稍微修改下: >>> def outer(): ... x = 1 ... def inner(): ... p ...

  10. 【Python】 闭包&装饰器

    python中的函数本身就是对象,所以可以作为参数拿来传递.同时其允许函数的层级嵌套定义,使得灵活性大大增加. 闭包 闭包的定义:将函数的语句块与其运行所需要的环境打包到一起,得到的就是闭包对象.比如 ...

随机推荐

  1. java中并发下的集合类

    java中常见的集合类大部分是非线程安全的,在多线程情况下会报并发修改异常(ConcurrentModificationException) 并发下的ArrayList类: //集合类不安全的例子 p ...

  2. Android开发:UI相关(一)自定义样式资源

    一.自定义样式资源:   1.在drawble中新建xml资源文件:     如果新建的xml文件没有自动放置在drawable文件夹下,就手动移动到drawable下. 2.编写样式代码: < ...

  3. Docker最全教程之Ubuntu下安装Docker(十四)

    前言 Ubuntu是一个以桌面应用为主的开源GNU/Linux操作系统,应用很广.本篇主要讲述Ubuntu下使用SSH远程登录并安装Docker,并且提供了Docker安装的两种方式,希望对大家有所帮 ...

  4. SLAM+语音机器人DIY系列:(一)Linux基础——2.安装Linux发行版ubuntu系统

    摘要 由于机器人SLAM.自动导航.语音交互这一系列算法都在机器人操作系统ROS中有很好的支持,所以后续的章节中都会使用ROS来组织构建代码:而ROS又是安装在Linux发行版ubuntu系统之上的, ...

  5. 纯手写springIOC

    大家好啊- 那么今天来带大家写一下spring的ioc. 其实也很简单,首先我们明白两点,java解析xml和java的反射机制,因为ioc就是主要是基于这两个来实现,今天只是简单的来大家实现下. 废 ...

  6. Poj1543

    Perfect Cubes Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 16522   Accepted: 8444 De ...

  7. jQuery元素操作

    jQuery中创建元素及追加元素 DOM中可以动态创建元素:document.createElement(“标签的名字”); jQuery中同样可以创建元素标签,并且返回的就是jQuery对象,可以直 ...

  8. <%@ Register TagPrefix="uc1" TagName="user" Src="../Control/user.ascx" %>什么意思?

    TagPrefix定义控件位置的命名空间.有了命名空间制约,就可以在同一个网页里使用不同功能的同名控件. TagName指向所使用控件的名字.在同一个命名空间里的控件名是唯一的.控件名一般都表明控件的 ...

  9. Docker JDK镜像

    Docker jdk镜像 说明 使用alpine-glibc作为基础镜像 JAVA JDK/JRE以1.8为基准 下载文件 1.下载JDK/JRE压缩包. jre-8u201-linux-x64.ta ...

  10. ASP.NET没有魔法——目录(完结)

    ASP.NET没有魔法——开篇-用VS创建一个ASP.NET Web程序 ASP.NET没有魔法——为什么使用ASP.NET ASP.NET没有魔法——第一个ASP.NET应用<MyBlog&g ...