函数2

函数

1.关键字介绍

# global关键字
x=1
def fun():
     x=2
fun()
print(x)  # 1

# x=1
l = [1,2]
def fun():
    # 使用global关键字声明要在局部名称空间里对全局变量x进行修改
    # global x
    # x=2
    l.append(33)
# fun()
# print(x)  # 2
fun()
print(l)  # [1, 2, 33]
'''当在局部要对全局的变量进行修改时：
    若为不可变类型，则需要用global关键字声明
    若为可变类型，则可以直接进行操作
'''
# nonlocal关键字
def fun():
    x=1
    def index():
        x=2
    index()
    print(x)
fun()  # 1

def fun():
    # x=1
    l = [1,23]
    def index():
        # 使用nonlocal关键字声明要在内部局部名称空间对外部名称空间里的变量x进行修改
        # nonlocal x
        # x=2
        l.append(33)
    index()
    print(l)
# fun()  # 2
fun()  # [1, 23, 33]
'''当在内部局部空间要对外部局部空间的变量进行修改时：
    若为不可变类型，则需要用nonlocal关键字声明
    若为可变类型，则可以直接进行操作
'''
# global关键字是在局部空间来改变全局空间的变量
x=1
def fun():
    global x
    x=100


fun()
print(x)
# nonlocal是在内部局部空间对外部局部空间里的变量进行修改
def fun():
    x = 1
    def index():
        nonlocal x
        x=100

    index()
    print(x)
fun()

2.函数对象

# 函数对象简单来说就是函数名
# 1、函数名可以被其他变量名引用（函数名可以赋值给其他变量）
def fun():
    print('这是一个函数')

a = fun  # 函数名一旦加括号就是函数调用
a()  # 实际上就是在调用fun函数
# 2、函数名可以作为其他函数的参数
def fun():
    print('这是一个函数')
def index(x):
    a=x()
index(fun)  # 这是一个函数
def fun(x):
    a = x()

def index():
    name = 'jason'
    print(name)

fun(index)  # jason
# 3、函数可以作为其他函数的返回值
def fun():
    def index():
        print('这是一个函数')
    return index()
fun()  # 这是一个函数
# 4、函数名可以作为元素存放在可变数据类型里
def register():
    print('这是注册界面')
def login():
    print('这是登录界面')
def modify():
    print('这是修改界面')
def delete():
    print('这是删除界面')


function_dic = {'1': register,
                '2': login,
                '3': modify,
                '4': delete
                }
while True:
    print('''
        1,注册界面
        2,登陆界面
        3,查看界面
        4,删除界面
    ''')
    choice = input('请输入你想要操作的功能编号')
    if choice in function_dic:
        fun_name = function_dic.get(choice)
        fun_name()
    else:
        print('功能暂未开放')

3.函数的嵌套调用

# 函数的嵌套调用
# 函数体内部调用其他函数
# 比大小
def fun(x,y):
    if x > y:
        return x
    return y
def max_fun(x,y,z,m):
    res1 = fun(x,y)
    res2 = fun(z,res1)
    res3 = fun(m,res2)
    return res3
a = max_fun(1,2,3,4)  # 当return有返回值时，必须要有变量接收才有效果
print(a)

4.函数的嵌套定义

# 函数的嵌套定义
# 函数体内部定义其他函数
# 可以将其他函数隐藏起来，只暴露一个简单的接口
def fun():
    def register():
        print('这是注册界面')
    def login():
        print('这是登录界面')
    def modify():
        print('这是修改界面')
    def delete():
        print('这是删除界面')
    function_dic = {'1': register,
                    '2': login,
                    '3': modify,
                    '4': delete
                    }
    while True:
        print('''
            1,注册界面
            2,登陆界面
            3,查看界面
            4,删除界面
        ''')
        choice = input('请输入你想要操作的功能编号:')
        if choice in function_dic:
            fun_name = function_dic.get(choice)
            fun_name()
        else:
            print('功能暂未开放')

fun()

5.闭包函数

# 闭包函数
# 闭：定义在函数内的函数
# 包：在函数的局部名称空间使用了外部函数局部名称空间里的参数
# 只有同时满足上诉两个条件才能被叫做闭包函数
def fun(msg):
    # m = msg
    def index():
        print('这是闭包函数',msg)
    return index
a = fun('快快乐乐每一天')
a()  # 这是闭包函数 快快乐乐每一天
a()  # 这是闭包函数 快快乐乐每一天
a()  # 这是闭包函数 快快乐乐每一天
a()  # 这是闭包函数 快快乐乐每一天
a()  # 这是闭包函数 快快乐乐每一天
# 函数传参的两种方式
# 方式一，通过定义函数时填入参数，每次定调用时传入实参进行调用
def fun(name):
    print(f'我的名字是{name}')

fun('jason')  # 我的名字是jason
# 方式二：通过闭包函数传参，且传过一次值以后，以后可以重复调用函数来输出相同的内容
def fun(name):
    def msg():
        print(f'我的名字是{name}')
    return msg

a = fun('jason')
a()  # 我的名字是jason
def fun(x,y,z):
    print(x,y,z)
list = [1,2,3]
fun(*list)
# 利用闭包函数爬取网站
import requests
url = 'https://www.baidu.com'
def outer(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 = outer('https://www.baidu.com')
res()
res()
res()
res1 = outer('https://www.jd.com')
res1()
res1()
res1()
res1()

6.初见装饰器

# 装饰器
# 装饰器就是利用闭包函数的特点来完成的
# 器：就是工具的意思
# 装饰：在不改变装饰对象的内部代码和原有的调用方式的前提下，给被装饰对象增加功能
# 且该功能可扩展性强，在遇到有相同附加功能的函数时，都可以采用调用装饰器可以大大减少代码量，提高代码的可读性
# 装饰器原则
# 开放封闭原则
# 开放：对扩展开放
# 封闭：对修改封闭
# 例，计算代码运行所需要的时间
def index():
    print('from index')


index()
# 统计index函数的执行时间


import time

print(time.time())  # 1637036293.0609405
# 获取的结果叫时间戳(运行代码的那一刻距离1970-1-1所经历的秒数)
time.sleep(3)  # 让程序原地等待3秒
print('睡饱了')


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


# 统计index函数的执行时间
# 在函数运行之前统计一次时间
start_time = time.time()
index()
# 在函数运行完毕之后再次统计
end_time = time.time()
# 计算差值
print(end_time - start_time)