函数的对象和装饰器概念

名称空间的作用域

名称空间

作用域：

　　变量能够作用的范围

1. 内置的名称空间

　　在程序的任何阶段任何位置都可以使用（全局有效）

2. 全局的名称空间

　　在程序的任何阶段任何位置都可以使用（全局有效）

3. 局部的名称空间

　　在函数内部有效（局部有效）

 

global和nonlocal关键字的使用

global

在函数的内部不能直接修改外部的变量

　　1. 在函数的内部修改外部的不可变的数据类型需要使用global关键字声明。

　　2. 在函数的内部修改外部的可变类型的数据不需要使用global关键字的声明

name_list = ['kevin', 'jason', 'tank']

def index():
    name_list.append('tony')

index()
print(name_list)  # 111 222

nonlocal

nonlocal的使用：

　　1. 在函数内部的局部修改外部的局部的不可变类型的数据使用关键字nonlocal关键字声明

　　2. 在函数内部修改外部的局部的可变类型的护具不需要使用关键字nonlocal声明

#######################nonlocals
def outer():
    name_list = ['kevin', 'tank']

    def inner():
        name_list.append('tony')
        print('inner')

    inner()
    print(name_list)  # 1  2  ['kevin', 'tank', 'tony']

outer()

 

函数对象（函数名）

函数名的使用有四种用法

1. 函数名可以当成变量名来使用

def index():  # index它是属于全局的
    print('index')
"""函数名就是函数的内存地址"""
# print(globals())  # 'index': <function index at 0x00000123F32BE310> value值就是函数的内存地址
# print(index)
# index() # 直接调用函数
a = index
a()  # index()

2. 函数名也可以当成函数的实参

def index():
    print('from index')
def func(func_name):
    # func_name----->index
    print('from func')
    func_name() # 相当于是index()
func(index)

3. 函数名也可以当成函数的返回值

def index():
    print('from index')
def func():
    print('from func')
    # return index()  # None
    return index
res=func()  # res是函数的内存地址
res()  # index()
print(res)

4. 函数名也可以当成容器类型的元素

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


# l = [1, 2, 3, index()]
l = [1, 2, 3, index] # [1, 2, 3, <function index at 0x0000021226FCE310>]
print(l)
l[3]()  # 调用index函数

案例：把注册、登录功能封装成函数版本

def register():
    print('register')


def login():
    print('login')


def transfer():
    print('login')


def withdraw():
    print('login')


def shopping():
    print('login')
def shopping1():
    print('login')

func_dict = {
    '1': register,
    '2': login,
    '3': transfer,
    '4': withdraw,
    '5': shopping,
    '6': shopping1
}
while True:
    print("""
        1. 注册功能
        2. 登录功能
        3. 转账功能
        4. 提现功能
        5. 购物功能
    """)
    choice = input('请输入你的选择：').strip()
    if choice in func_dict:
        # func_name = func_dict.get(choice)
        # func_name()
        func_dict.get(choice)()

函数的嵌套调用

函数之间相互调用，函数里面调用函数

# 1. 定义一个函数，功能是比较两个数的大小
def my_max(a, b):
    if a > b:
        return a
    return b

# res = my_max(1, 10)
# print(res)

# 2. 定义一个函数，比较4个数的大小
def many_max(a, b, c, d):
    res = my_max(a, b)  # res是a和b中的最大的
    res1 = my_max(res, c)  # res1就是abc中的最大值
    res2 = my_max(res1, d)  # res2就是abcd中的最大值
    print(res2)
    return res2
ret=many_max(1, 2, 3, 4)
print(ret)

函数的嵌套定义（了解）

# 给外部的用户暴露出来一个接口，告诉他都有什么功能
def all_func(type):
    def login():
        print('login')

    def transfer():
        print('login')

    def withdraw():
        print('login')

    def shopping():
        print('login')

    def shopping1():
        print('login')

    if type == 1:
        login()
    elif type == 2:
        transfer()
    elif type == 3:
        withdraw()
    elif type == 4:
        shopping()


all_func(1)
all_func(2)
all_func(3)

闭包函数

1. 什么是闭包函数？

# 闭：就是函数内部定义函数，至少两层函数
def outer():
    def inner():
        pass
# 包：内部的函数使用外部函数名称空间的名字
'''只有同时满足以上两个条件才能称之为闭包函数'''
# 闭包函数有什么用？使用场景？
# 闭包函数其实是给函数传参的第二种方式！
# 方式1：
# def index(username):
#     print(username)
#
#
# index('kevin')
# 比较两个数的大小---------->使用闭包函数该一下


def outer(a, b):
    # a = 1
    # b = 10

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

    return my_max


res=outer(2, 20)  # my_max的内存地址，res----->my_max
print(res())  # my_max()
print(res())  # my_max()
print(res())  # my_max()
res1 = outer(3, 30)
print(res1())
print(res1())
print(res1())
'''一次传值，多次调用'''


# 爬虫：爬取网页上的数据
# 爬取百度首页的数据
import requests # 把你刚才安装的模块导入到我们的py文件中
def outer(url):
    # url = ''
    def get_content():
        res=requests.get(url)
        with open('bbb.html', 'wb') as f:
            f.write(res.content)
    return get_content
# get_content('http://www.baidu.com')
# get_content('http://www.jd.com')


res=outer('http://www.baidu.com') # get_content
res() # get_content()
res() # get_content()
res() # get_content()
res() # get_content()
res() # get_content()
res1 = outer('http://www.jd.com')
res1()
res1()
res1()
res1()
res1()

装饰器（难点、重点）

'''

装饰器这个是十点是我们之前学的：名称空间、闭包函数、函数嵌套调用等知识点汇总而来的知识点。

'''什么是装饰器？

器：就是工具

装饰：给被装饰的对象添加额外的功能

装饰器的核心思想：

　　就是在不改变被装饰对象内部的代码和原有调用方式的基础之上再添加额外的功能

# 背景知识
def index():
    print("from index")
index()
# 现在让你统计index函数执行完毕之后的执行时间

# 时间模块
import time  # 内置模块，可以直接拿来使用

def index():
    time.sleep(3)
    print('from index')


# 1. 在函数执行之前打印一个时间点
start_time = time.time()
index()

# 2. 在函数执行完毕之后在打印一个时间点
end_time = time.time()

# 3. 两者的差就是函数的执行时间
print("index函数一共执行了：%s秒" % (end_time - start_time))