空间名称和作用域

  • global和nonlocal关键字的使用

  • 函数对象（函数名）

  • 函数的嵌套

  • 函数的嵌套定义

  • 闭包函数

 

名称空间的作用域

# 名称空间所作用的范围

1. 内置名称空间
	在任意位置都可以使用（全局有效）
2. 全局名称空间
	在整个py文件中都可以使用(全局有效)
3. 局部名称空间
	一般情况下在自己的函数中使用

 global和nonlocal关键字的使用

# x = 111
#
#
# def index():
#     # 局部修改全局的变量
#     global x
#     x = 222
#
#
# index()
# print(x)


# name_list = [11, 22]
#
#
# def index():
#     # 局部修改全局的变量
#     name_list.append(33)
#
#
# index()
# print(name_list)
'''
    在局部修改全局的变量：
        1. 修改的变量时不可变的类型，需要global关键字声明
        2. 修改的变量是可变的类型，不需要global关键字声明
'''


def index():
    # x = 222
    name_list = [1, 2, 3]

    def func():
        # 内部的局部修改外部的局部的变量
        # nonlocal x
        # x = 333
        name_list.append(4)
    func()
    print(name_list)


index()

 函数对象（函数名）

 

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


# 函数名
# 玩法1：函数名可以当成变量赋值
# def index():
#     print('from index')
#
# a = index
# a()
# print(a)  # 函数名就是内存地址


# 玩法2：函数名可以当成函数的参数
# def index():
#     print('from index')
#
#
# def func(a):
#     # a => index
#     a()
#     print('from func')
#
#
# func(index)

# 玩法3：函数名也可以当成函数的返回值
# def index():
#     print('from index')
#
#
# def func():
#     print('from func')
#     return index
#
# res = func()
# res()

# 玩法4：函数名也可以当成容器(可以存放多个元素)类型的元素
# def index():
#     print('from index')
#
#
# l = [1, 2, 3, index]
# print(l)

# 小案例
# 注册功能
def register():
    print('注册')


# 登录功能
def login():
    print('登录')


# 转账功能
def transfer():
    print('转账')


# 购物功能
def shopping():
    print('购物')


# 提现功能
def withdraw():
    print('提现')


func_dict = {
    '1': register,
    '2': login,
    '3': transfer,
    '4': shopping,
    '5': withdraw
}
while True:
    print("""
        1. 注册
        2. 登录
        3. 转账
        4. 购物
        5. 提现
    """)

    choice = input('请输入序号：>>>').strip()
    if choice in func_dict:
        func_name = func_dict[choice]  # 得到的就是函数的内存地址，函数名
        func_name()
    else:
        print('请好好输入')
    
    # 以下方式太复杂了，优化一下
    # if choice == '1':
    #     register()
    # elif choice == '2':
    #     login()
    # elif choice == '3':
    #     transfer()
    # elif choice == '4':
    #     shopping()
    # elif choice == '5':
    #     withdraw()
    # else:
    #     print('请好好输入')

 函数的嵌套调用

# 函数里面调用其他函数

# 实际应用
# 1.比较两个数的大小
def my_max(a, b):
    if a > b:
        return a
    return b


# my_max(1, 2)


# 2. 比较4个数的大小
def many_max(a, b, c, d):
    # 先两两比较，a,b
    res = my_max(a, b)
    res1 = my_max(res, c)
    res2 = my_max(res1, d)
    return res2

print(many_max(1,2,3,4))

 函数的嵌套定义

 1 # 在函数里面定义其他函数
 2 # 把复杂的功能隐藏起来了
 3 def all_func(type):
 4     def register():
 5         print('注册')
 6 
 7     def login():
 8         print('登录')
 9 
10     def transfer():
11         print('转账')
12 
13     def withdraw():
14         print('提现')
15 
16     if type == 1:
17         register()
18     elif type == 2:
19         login()
20     elif type == 3:
21         transfer()
22     elif type == 4:
23         withdraw()
24     else:
25         print('好好输入')
26 
27 
28 # all_func(1)
29 all_func(2)

闭包函数

闭：
    定义在函数内部的函数
包：
    内部函数必须使用外部函数的数据

# 只有符合以上两个条件的函数才称之为闭包函数
# 第二种传参方式：闭包函数

 1 def outer(a, b):
 2     # a = 1
 3     # b = 10
 4 
 5     def my_max():
 6         if a > b:
 7             return a
 8         return b
 9     return my_max
10 
11 res = outer(2, 20) # res => my_max的内存地址
12 print(res())  # my_max()
13 print(res())  # my_max()
14 print(res())
15 print(res())
16 print(res())

装饰器的概念（重点）

'''
    装饰器不是一个新的知识，而是名称空间，闭包函数等等的组合就是装饰器
'''

装饰：给函数增加额外的功能
器：就是工具


装饰器的核心思想：在"不改变原有函数的代码"和"原有调用方式"的基础上"增加额外"的功能

def index():
    pass

index()

'''给index函数统计执行时间'''

储备知识：
    time模块
    import time  # 模块


# 1. 时间戳， 它是执行的这一刻距离1970-1-1 的秒数
# print(time.time())  # 1641528030.2125015

# 2. 在原地等待3秒
# time.sleep(3)
# print(123)

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

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

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

# 3. 总的执行时间就是两个的差值
print(end_time - start_time)

 

 

posted @ 2022-01-07 18:03  Damon1899  阅读(83)  评论(0)    收藏  举报