名称空间的作用域

作用域

    名称空间所能够作用的范围

内置名称空间

    程序任何阶段任何位置均可使用

全局名称空间

     程序任何阶段任何位置均可使用

局部名称空间

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

global与nonlocal关键字

global关键字使用与不使用的比较
x = 11

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

使用global的案例

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

name_list = ['jason', 'lili']
def index():
    name_list.append('hh')
index()print(name_list)  #['jason', 'lili', 'hh']

"""
如果想在局部修改全局数据
    如果数据为不可变类型则需要关键字global  整型 浮点  字符串 
    如果数据为可变类型则无需关键字global声明
"""

nonlocal关键字的使用
      
def index():
    # x = 111
    l1 = [11,22]
    def func():
        # 内部局部修改外部局部
        l1.append(333)
    func()
    print(l1)
index()
"""
如果想要在内部的局部修改外部局部的不可变类型数
需要关键字nonlocal声明
"""

函数对象（函数名）

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

用法2：函数名还可以当作函数实参
def index():
    print('form index')
def func(a):
    print(a)
    a()#所以a 在这里就调用了函数index
    print('form func')
func(index)   # 实参中index= a
# form index
# form func


用法3：函数名还可以当作函数返回值

def index():
    print('from index')
def func():
    print('from func')
    return index
res = func()#调用func并接受func 的返回值

用法4.
函数名可以当做容器类型（内部可以存放多个数据）的元素

 #def index():
#     print('from index')
# l = [111, 222, 333, index()]
# print(l)
    


实际应用中的函数做对比  要简单省事很多
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('4')

闭包函数

 

闭：定义在函数内部的函数
包：内部函数使用了外部函数名称空间中的名字
#只有符合上述两个特征的函数才可以称之为”闭包函数“ def outer():
#     x = 222
#     def index():
#         print('from index', x)
#     return index

#闭包函数其实是给函数传参的第二种方式
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())


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

 装饰器

"""
装饰器并不是一个新的知识  
     而是有我们之前学习的 名称空间  函数对象  闭包函数组合而来
"""
器：值得是工具
装饰：给被装置对象添加额外的功能


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

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)