函数对象、函数嵌套、闭包函数

1、函数对象

精髓:可以把函数当成变量去用
func=内存地址

def func():
    print(‘from func‘)

1.1、可以赋值 

f=func
print(f,func)
f()

1.2、可以当做函数当做参数传给另外一个函数

def foo(x): # x = func的内存地址
    x()

foo(func) # foo(func的内存地址)

1.3、可以将函数当做另外一个函数的返回值

def foo(x): # x=func的内存地址
    return x # return func的内存地址

res=foo(func) # foo(func的内存地址)
print(res) # res=func的内存地址

res()

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

dic={‘k1‘:func}
print(dic)
dic[‘k1‘]()

函数对象应用示范

def login():
    print(‘登录功能‘)

def transfer():
    print(‘转账功能‘)

def check_banlance():
    print(‘查询余额‘)

def withdraw():
    print(‘提现‘)

def register():
    print(‘注册‘)

func_dic = {
    ‘0‘: [‘退出‘, None],
    ‘1‘: [‘登录‘, login],
    ‘2‘: [‘转账‘, transfer],
    ‘3‘: [‘查询余额‘, check_banlance],
    ‘4‘: [‘提现‘, withdraw],
    ‘5‘: [‘注册‘, register]
}

while True:
    for k in func_dic:
        print(k, func_dic[k][0])

    choice = input(‘请输入命令编号:‘).strip()
    if not choice.isdigit():
        print(‘必须输入编号,傻叉‘)
        continue

    if choice == ‘0‘:
        break

    if choice in func_dic:
        func_dic[choice][1]
    else:
        print(‘输入的指令不存在‘)

2、函数嵌套

2.1、函数的嵌套调用:在调用一个函数的过程中又调用其他函数

def max2(x,y):
    if x > y:
        return x
    else:
        return y

def max4(a,b,c,d):
    # 第一步:比较a,b得到res1
    res1=max2(a,b)
    # 第二步:比较res1,c得到res2
    res2=max2(res1,c)
    # 第三步:比较res2,d得到res3
    res3=max2(res2,d)
    return res3

res=max4(1,2,3,4)
print(res)

2.2、函数的嵌套定义:在函数内定义其他函数

def f1():
    def f2():
        pass
# 圆形
# 求圆形的求周长:2*pi*radius
def circle(radius,action=0):
    from math import pi

    def perimiter(radius):
        return 2*pi*radius

    # 求圆形的求面积:pi*(radius**2)
    def area(radius):
        return pi*(radius**2)

    if action == 0:
        return 2*pi*radius

    elif action == 1:
        return area(radius)

circle(33,action=0)

3、闭包函数

一:大前提:
  闭包函数=名称空间与作用域+函数嵌套+函数对象
  核心点:名字的查找关系是以函数定义阶段为准

二:什么是闭包函数
  "闭"函数指的该函数是内嵌函数
  "包"函数指的该函数包含对外层函数作用域名字的引用(不是对全局作用域)

闭包函数:名称空间与作用域的应用+函数嵌套

def f1():
    x = 33333333333333333333
    def f2():
        print(x)
    f2()

x=11111
def bar():
    x=444444
    f1()

def foo():
    x=2222
    bar()

foo()

闭包函数:函数对象

def f1():
    x = 33333333333333333333
    def f2():
        print(‘函数f2:‘,x)
    return f2

f=f1()

def foo():
    x=5555
    f()

foo()  

三:为何要有闭包函数--->闭包函数的应用
两种为函数体传参的方式

方式一:直接把函数体需要的参数定义成形参

def f2(x):
    print(x)

f2(1)
f2(2)
f2(3)

方式二:

def f1(x): # x=3
    def f2():
        print(x)
    return f2

x=f1(3)
x()
import requests

# 传参的方案一:
# def get(url):
#     response=requests.get(url)
#     print(len(response.text))
#
# get(‘https://www.baidu.com‘)
# get(‘https://www.cnblogs.com/linhaifeng‘)
# get(‘https://zhuanlan.zhihu.com/p/109056932‘)

# 传参的方案二:
def outter(url):
    # url=‘https://www.baidu.com‘
    def get():
        response=requests.get(url)
        print(len(response.text))
    return get

baidu=outter(‘https://www.baidu.com‘)
baidu()

cnblogs=outter(‘https://www.cnblogs.com/linhaifeng‘)
cnblogs()

zhihu=outter(‘https://zhuanlan.zhihu.com/p/109056932‘)
zhihu()

  

  

  

  

  

  

  

  

  

  

  

  

  

 

原文地址:https://www.cnblogs.com/BoyGc/p/12534219.html

时间: 2024-11-05 20:36:20

函数对象、函数嵌套、闭包函数的相关文章

可变长参数、函数对象、嵌套、名称空间和作用域

目录 可变长参数.函数对象.嵌套.名称空间和作用域 一.可变长参数 1.1 可变长形参之* 1.2 可变长实参之* 1.3 可变长形参之** 1.4 可变长实参之** 二.函数对象 2.1.引用 2.2.当做实参参数传给一个形参参数 2.3.可以作为容器类数据类型中的元素 2.4 可以当做函数的返回值 三.函数的嵌套 3.1 函数的嵌套定义 3.2 函数的嵌套调用 四.名称空间和作用域 4.1 名称空间 4.1.1 内置名称空间 4.1.2 全局名称空间 4.1.3 局部名称空间 4.1.4 三

命名关键字参数,函数对象,嵌套,名称空间与作用域,闭包

一.命名关键字参数 对于关键字参数,函数的调用者可以传入任意不受限制的关键字参数  .至于到底传入了哪些,就需要在函数内部通过kw检查. 仍以person()函数为例,我们希望检查是否有city和job参数: def person(name, age, **kw): if 'city' in kw: # 有city参数 pass if 'job' in kw: # 有job参数 pass print('name:', name, 'age:', age, 'other:', kw) 但是调用者仍

<04day>_函数嵌套--闭包函数--装饰器--迭代器--生成器

一.函数的嵌套定义 1.python函数支持嵌套 def f1(): #f1函数的定义 def f2(): #f2函数的定义 print('from f2') def f3(): #f3函数的定义 print('from f3') f2() f1() 嵌套函数--运行结果说明: 1首先调用f1()结果,f1函数为空.担保函f2函数,f2函数有内容打印并且有调用,f2函数包含f3函数,但f3函数无调用. 运行结果: 列子:多个数据之间的大小比较. #!/usr/bin/python # -*- c

python 函数的作用域,闭包函数的用法

一.三元表达式 if条件成功的值    if  条件   else else条件成功的值 #if条件成立的结果 if 条件 else else条件成立的结果 # a = 20 # b = 10 # c = 5 if a>b else 10 # print(c) 二.函数的命名空间 命名空间一共分为三种: 全局命名空间 局部命名空间 内置命名空间 *内置命名空间中存放了python解释器为我们提供的名字:input,print,str,list,tuple...它们都是我们熟悉的,拿过来就可以用的

(十六)闭包函数

函数嵌套+名称空间+函数对象 什么是闭包函数 条件1. 定义在函数内的函数 条件2. 该函数体代码包含对该函数外层作用域中名字的引用. 注意:函数外层指的不是全局作用域 满足两个条件,该函数称为闭包函数 基本结构如下 def outter(): x=1 def inner(): #函数嵌套 print(x) return inner() #函数对象 outter( ) #执行outter,本质上是执行intter() f=outter() def f1(): x=11111111111111 #

函数嵌套,名称空间,作用域,函数对象,闭包函数

函数嵌套 嵌套调用是在函数内又调用其他函数 def max(x,y): return x if x > y else y def max4(a,b,c,d): res1=max(a,b) res2=max(res1,c) res3=max(res2,d) return res3 print(max4(1,2,3,4)) 嵌套定义是在函数内又定义其他函数 # def f1(): # print('f1') # def f2(): # print('f2') # def f3(): # print(

函数对象/嵌套和闭包函数

一.函数对象 二.函数嵌套 三.闭包函数 一.函数对象 精髓:可以把函数当成变量去用 1.可以赋值 # func=内存地址 def func(): print('from func') f=func # 函数func赋值给变量f print(f,func) # 打印f和func的内存地址,完全相同 f() # 相当于调用了函数func() 输出: <function func at 0x02F434A8> <function func at 0x02F434A8> from fun

函数对象、函数嵌套、名称空间与作用域、装饰器

一 函数对象 1.函数是第一类对象,即函数可以当作数据传递 #1 可以被引用 #2 可以当作参数传递 #3 返回值可以是函数 #3 可以当作容器类型的元素 2.利用该特性,优雅的取代多分支的if def foo(): print('foo') def bar(): print('bar') dic={ 'foo':foo, 'bar':bar, } while True: choice=input('>>: ').strip() if choice in dic: dic[choice]()

python基础之====函数对象、函数嵌套、名称空间与作用域、装饰器

阅读目录 一 函数对象 二 函数嵌套 三 名称空间与作用域 四 闭包函数 五 装饰器 六 练习题 一 函数对象 一 函数是第一类对象,即函数可以当作数据传递 #1 可以被引用 #2 可以当作参数传递 #3 返回值可以是函数 #3 可以当作容器类型的元素 二 利用该特性,优雅的取代多分支的if def foo(): print('foo') def bar(): print('bar') dic={ 'foo':foo, 'bar':bar, } while True: choice=input(

函数嵌套、函数对象、命名空间

一:函数对象 函数是第一类对象,即表示函数可以当做数据传递 #可以被引用 把函数内存地址赋值给一个变量名,仍然遵循函数的调用规则 #可以被当做参数传递 传递的是函数的运行的结果 #可以当做返回值 把函数作为返回值返回的话,返回的结果是函数的内存地址 #可以当做容器类型的元素 意思就是可以作为列表和字典的元素 利用函数的特性,可以取代多分枝的if def auth(): print("登陆......") def register(): print("注册.......&quo