函数对象与闭包函数

一、函数对象

精髓:可以把函数当成变量去用

# func=内存地址
def func():
    print('from func')

1.可以赋值

f=func
print(f,func)
f()
<function func at 0x00000000026AC0D0> <function func at 0x00000000026AC0D0>
from func

2.可以当做函数当做参数传给另外一个函数

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

3.可以当做函数当做另外一个函数的返回值

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

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

res()
<function func at 0x000000000273C0D0>
from func

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

l=[func,]
# print(l)
l[0]()

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

from func
{'k1': <function func at 0x00000000026CC0D0>}
from func

函数对象的应用

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

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

二、函数嵌套

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函数的嵌套定义:在函数内定义其他函数

# 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)

res=circle(3,action=0)
print(res)

三、闭包函数

1.大前提

闭包函数=名称空间与作用域+函数嵌套+函数对象

核心点:名字的查找关系是以函数定义阶段为准

2.什么是闭包函数

"闭"函数指的该函数是内嵌函数

"包"函数指的该函数包含对外层函数作用域名字的引用(不是对全局作用域)

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

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()
print(f)

3.为何要有闭包函数

两种为函数体传参的方式

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

# def f2(x):
#     print(x)
#
# f2(1)
# f2(2)
# f2(3)

方式二、

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

x=f1(3)
print(x)

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/chenyoupan/p/12534046.html

时间: 2024-09-30 01:59:58

函数对象与闭包函数的相关文章

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

函数嵌套 嵌套调用是在函数内又调用其他函数 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(

python学习16——函数对象与闭包函数

一 函数对象 函数对象指的是函数可以被当做数据来处理,具体可以分为四个方面的使用,我们如下 1.1 函数可以被引用 >>> def add(x,y): ... return x+y ... >>> func=add >>> func(1,2) 3 1.2?函数可以作为容?类型的元素 >>> dic={'add':add,'max':max} >>> dic {'add': <function add at 0x

python基础——函数对象和闭包

关于函数对象和闭包 闭包(closure)是函数式编程的重要的语法结构.不同的语言实现闭包的方式不同.Python以函数对象为基础,为闭包这一语法结构提供支持的 (我们在特殊方法与多范式中,已经多次看到Python使用对象来实现一些特殊的语法).Python一切皆对象,函数这一语法结构也是一个对象.在函数对象中,我们像使用一个普通对象一样使用函数对象,比如更改函数对象的名字,或者将函数对象作为参数进行传递. 一.函数对象: 1.函数可以当参数传递 示例: #把函数当成参数传递 def foo()

22、Python之函数对象和闭包

目录 一.函数对象 1.1 可以被赋值 1.2 函数可以当作参数传给另一个函数 1.3 函数可以当作一个函数的返回值 1.4 函数可以当作容器类型的一个元素 二.函数嵌套 2.1 函数的嵌套调用:在调用一个函数的过程中又调用其他函数 2.2 函数的嵌套定义:在函数内定义其他函数 三.闭包函数 3.1 什么是闭包函数 3.2 闭包函数的应用 一.函数对象 可以把函数作为变量去使用,不加括号作为内存地址,加括号作为函数运行作为返回值 1.1 可以被赋值 # func=内存地址 def func():

Python中的函数对象与闭包

函数在Python中是第一类对象,可以当做参数传递给其他函数,放在数据结构中,以及作为函数的返回结果. 下面的例子为接受另外一个函数作为输入并调用它 1 #foo.py 2 def callf(func): 3 return func() 使用上面的函数: 1 import foo 2 def helloworld(): 3 return 'Hello,World' 4 5 print foo.callf(helloworld) >>>‘Hello,World’ 2.把函数当做数据处理时

函数对象和闭包的预习

创建对象: 1.对象直接量. var point = { x:0,y:0 }; //point就是一个对象,跟C#不同,它不需要一定有类才能创建对象. 2.通过new创建对象 var d = new Date(); //创建一个Date对象 3.原型 Object.prototype //用于获取对象原型的引用.所有对象都直接或间接继承自Object.prototype,相当于C#中的System.Object(); 通过new Date()创建的对象同时继承自Date.prototype和Ob

07-04 函数对象与闭包

[TOC] 一 函数对象 函数对象指的是函数可以被当做'数据'来处理,具体可以分为四个方面的使用,我们如下 插图:恶搞图26 1.1 函数可以被引用 >>> def add(x,y): ... return x+y ... >>> func=add >>> func(1,2) 3 1.2 函数可以作为容器类型的元素 >>> dic={'add':add,'max':max} >>> dic {'add': <f

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

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的内

函数进阶之闭包函数和装饰器

闭包函数 把函数A和变量x包在函数B内部,然后通过函数B的返回值返回除函数A对象 def B(x): # x = 1 def A(): print(x) pass return A 装饰器 用来给函数加功能,他的本质也是函数 1.不改变被装饰函数的源代码 2.不改变被装饰函数的调用方式 def outter(func): def wrapper(*args,**kwargs): #逻辑 res = func(*args,**kwargs) # func是被装饰的函数 return res ret