函数对象(函数名)

函数对象

""" 函数名遇到货号就会调用 """
用法1： 函数名可以当作变量名赋值
def index():
print('from index')
a = index
a()     # from index		本质就是在调用index函数

用法2：函数名还可以当做函数的实参
def index():
	print('from index') # from index
def func(a):
    print(a)    # <function index at 0x000002AE572B1EA0>
    a()
    print('from func')  # from func
func(index)

方法3：函数名还可以当做函数返回值
def index():
print('from index')
def func():
    print('from func')
    return index
res = func()		# 调用func并接受func的返回值
res()

方式4：函数名可以当做容器类型（内部可以存放多个数据）的元素
def index():
    print('from index')
l = [111, 222, 333, index()]
print(l)

ATM+购物车模板

def register():
    print('注册功能')
def login():
    print('登录功能')
def shopping():
    print('购物功能')
def transfer():
    print('转账功能')
def withdraw():
    print('提现功能')
def check_order():
    print('查看订单')
func_dic = {
    '1': register,
    '2': login,
    '3': shopping,
    '4': transfer,
    '5': withdraw,
    '6': check_order
}
while True:
    print("""
    1. 注册功能
    2. 登录功能
    3. 购物功能
    4. 转账功能
    5. 体现功能
    6. 查看订单
    """)
    choice = input('请输入功能编号:').strip()
    # 判断用户输入的编号在不在字典的k中
    if choice in func_dic:
        # 根据键获取值（函数名）
        func_dic = func_dic.get(choice)
        # 函数名加括号调用
        func_dic()
    else:
        print('功能编号不存在')

    # 下列代码的弊端在于功能较多时，代码过于复杂
    if choice == '1':
        register()
    elif choice == '2':
        login()
    elif choice == '3':
        shopping()
    else:
        print('写累了')

函数的嵌套调用

嵌套调用：函数内部调用其他函数

def index():
    print('from index')
def func():
    index()
    print('from func')
func()

def my_max(a, b):
    if a > b:
        return a
    return b

def many_max(x, y, z, m):
    res = my_max(x ,y)
    res1 = my_max(res, z)
    res2 = my_max(res1, m)
    return res2
ret = many_max(1, 2, 3, 4)
print(ret)  # 4

函数的嵌套定义

函数嵌套定义满足以下条件：
	1. 函数体内部定义其他函数
	2. 将复杂的功能全部隐藏起来，暴露一个简单的接口
	
def all_func(type):
   def register():
        print("注册功能")

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

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

    def shopping():
        print("购物功能")

    # 这里仅仅是延时嵌套定义的现象，暂不考虑
    if type == "1":
        register()
    elif type == "2":
        login()
    elif type == "3":
        transfer()
    elif type == "4":
        shopping()
    else:
        print("没有该功能")


all_func("1")

闭包函数

什么是闭包函数
	闭：定义在函数内部的函数
	包：内部函数使用了外部函数名称空间中的名字
注意：
	只有符合上述两个特征的函数才可以称之为”闭包函数“



# def outter():
#     x = 222
#     def index():
#         print('from index', x)
#     return index

# 闭包函数其实是给函数传参的第二种方式
# 方式1:函数体代码需要用到数据，直接在括号内定义形参即可
def index(username):
    print(username)
def my_max(a, b):
    if a > b:
        return a
    return b

# 方式2:利用闭包函数
def outter(x, y):
    # x = 2
    # y = 40
    def my_max():
        if x > y:
            return x
        return y
    return my_max
res = outter(2, 40)
print(res())    # 40

闭包函数简易版爬虫
import requests
url = 'http://www.baidu.com'
def outter(url):
    def get_content():
        # 爬取百度首页数据
        res = requests.get(url)
        if res.status_code == 200:
            with open(r'xxx.html', 'wb')as f:
                print('*'.center(30))
                f.write(res.content)
    return get_content
res = outter('https://www.baidu.com')
res()
res()
res()
res1 = outter('https://www.jd.com')
res1()
res1()
res1()