函数的基础与用

目录

• 名称空间的作用域

• global与nonlocal关键字使用

• 函数对象（函数名）

• 函数的嵌套调用

• 函数的嵌套定义

• 闭包函数（重点）

• 装饰器的概念（重点）

---

 

名称空间的作用域

作用域：名称空间所能作用的范围

内置名称空间

程序任何阶段任何位置均可使用（全局有效）

全局名称空间

程序任何阶段任何位置均可使用（全局有效）

局部名称空间

一般情况下只在各自的局部名称空间中有效

 

global与nonlocal关键词的使用

# x = 111
# def index():
#     # 局部修改全局变量 需要使用关键字声明
#     global x
#     x = 222
# index()
# print(x)


# name_list = ['jason', 'kevin']
# def index():
#     name_list.append('heiheihei')
# index()
# print(name_list)
"""
如果想在局部修改全局数据
    如果数据为不可变类型则需要关键字global声明
    如果数据为可变类型则无需关键字global声明
"""
def index():
    # x = 111
    l1 = [11,22]
    def func():
        # 内部局部修改外部局部
        # nonlocal x
        # x = 333
        l1.append(333)
    func()
    print(l1)
index()
"""
如果想要在内部的局部修改外部局部的不可变类型数据
需要关键字nonlocal声明
"""

　　

函数对象（函数名）

函数名遇到括号就会调用！！！

1. 函数名可以当作变量名赋值
   
   

   def index():
       print('from index')
   a = index
   a()  # 本质就是在调用index函数
   

   　　

2. 函数名还可以当作函数的实参
   

   def index():
       print('from index')
   def func(a):
       print(a)
       a()
       print('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)
   

   　　

5. 案例
   

   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_name = func_dic.get(choice)
           # 函数名加括号调用
           func_name()
       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)7

　　

函数的嵌套定义

函数体内部定义其他函数

将复杂的功能全部隐藏起来 暴露一个简单的接口

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('3')

　　

闭包函数

闭：定义在函数内部的函数

包：内部函数使用了外部函数名称空间中的名字

只有符合了上述两个特征的函数才可以称之为闭包函数

def outer():
    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 outer(x,y):
    # x = 2
    # y = 40
    def my_max():
        if x > y:
            return x
        return y
    return my_max
res = outer(2,40)
print(res())
print(res())

　　

 

装饰器的概念

装饰器并不是一个新的知识 而是由我们之前所学习的 名称空间 函数对象 闭包函数组合而来

器:指的是工具 装饰:给被装饰对象添加额外的功能

装饰器的原则 开放封闭原则 开发:对扩展开放 封闭:对修改封闭 装饰器核心思想 在不改变被"装饰对象内部代码"和"原有调用方式"的基础之上添加额外功能

def index():
    print('from 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)