python基础13

名称空间的作用域

名称空间

作用域：

　　变量能够作用的范围

　　1.内置名称空间

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

　　2.全局的名称空间

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

　　3.局部的名称空间

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

　　　　####局部变量一般都在函数的内部使用，外部一般不使用

　　　　####在全局的变量我们称之为全局变量，全局变量在任何位置任何阶段都可以使用

global 和 nonlocals关键字的使用

global

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

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

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

nonlocals

nonlocals的使用：

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

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

函数对象

　　函数对象就是函数名

函数名的四种使用方法

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

　　函数名就是函数的内存地址

def index（）：
    print（‘inde’）

a=index
a（）#相当于index（）

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

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

 def func(name):
     print('from func')
     
func（index）#name=index
name（）#等于index（）

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

def index（）：
    print（‘123’）

def  outer（）：
    print（‘345’）
    return index

outer（）#相当于outer（）=index
outer（）（）=index（）

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

def index（）
    print（‘1314’）

l=[1,2,index]
l[2]#相当于index
l[2]（）#等于index（）

5.　练习

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 index（a，b）：
    if a>b:
        return a
   return b
res=index(1,10)
print('res')

2.定义一个函数，比较4个数的大小

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

def index_max(a,b,c,d)
    res=index(a,b)
    res1=index(res,c)
    res2=index(res1,d)
    print(res2)

函数的嵌套定义（了解）

# 给外部的用户暴露出来一个接口，告诉他都有什么功能
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()

闭包函数

1.什么是闭包函数

闭：闭就是函数内部定义函数，至少两层函数

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

　　#####同时满足两个条件才能成为闭包函数

2.闭包函数有什么用

　　#####闭包函数其实是给函数传参的第二种方法

　　方式一：

　　　　def index（name）：

　　　　　　print（name）

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())
'''一次传值，多次调用'''

装饰器

　　#####饰器这个知识点它不是一个新的知识点，它是我们之前学的：名称空间、闭包函数、函数嵌套调用等知识点汇总而来的知识点.

什么是装饰器

器：就是工具

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

装饰器核心思想:

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

# 背景知识
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))