函数的基本使用（三）

目录

• 函数基本使用（三）
• 1、名称空间的作用域
  • global与nonlocal关键字使用
• 2、函数对象（函数名）
  • 思维导图：
  • 1、函数名可以当做变量值赋值
  • 2、函数名还可以当作函数的实参
  • 3、函数名还可以当做函数返回值
  • 4、函数名可以作为容器类型的元素
• 3、函数的嵌套
  • 1、定义
  • 2、嵌套使用
• 4、闭包函数
  • • 1、定义：
    • 2、闭包函数的使用方式（传参）
      • • 方式一：
        • 方式二：
• 5、装饰器
  • 1、定义
  • 2、原则
  • 3、装饰器核心思想

---

函数基本使用（三）

---

1、名称空间的作用域

---

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

分类：

内置名称空间：程序任何阶段、位置均可使用，全局有效

全局名称空间：程序任何阶段、位置均可使用，全局有效

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

---

global与nonlocal关键字使用

• global关键字：不可变类型变量，声明global关键字，局部可以修改全局变量；可变类型无序global关键字声明，可直接修改
• nonlocal关键字：不可变类型变量，声明nonlocal关键字，内部局部可以修改外部局部。

实例如下：

1. global示例：

# 不可变类型，局部修改全局需要global关键字声明
x = 1

def func():
    global x
    x = 2
    print('x是：', x)

func()  
# x是： 2

# 可变类型，局部修改全局不需要global关键字声明
a = [1, 2]

def func1():
    a.append(3)
    print(a)

func1()  # [1, 2, 3]

2. nonlocal示例：

# nonlocal
# 不可变类型，内局部想要修改外局部需要nonlocal关键字声明
def func2():
    num = 123
    def func3():
        nonlocal num
        num = 456
        print(num)
    func3()
func2()
# 结果
#456
# 可变类型，内局部想要修改外局部不需要nonlocal关键字声明
def func4():
    num1  = [1,2,3]
    def func5():
        nonlocal num1
        num1.append(4)
        print(num1)
    func5()
func4()
#结果
# [1, 2, 3, 4]

2、函数对象（函数名）

思维导图：

注意！所有情况的变量名不要加括号使用，除非调用

1、函数名可以当做变量值赋值

实例如下：

def func1():
    s = '赋值给变量了'
    print(s)

a = func1
# a 为函数的内存地址
print(a)
# a()就是在调用函数func1
a()

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

实例如下：

# 函数名可以当做实参传递
def fun2(a):
    print(a)
    a()

def fun3():
    print('当做实参传递')

fun2(fun3)

# 结果
# <function fun3 at 0x00000264A8C4BD08>
# 当做实参传递

3、函数名还可以当做函数返回值

实例如下：

def func():
    print('确实作为返回值了')
def func1():
    print('函数名作为返回值')
    return func

res = func1()  # 调用func1函数，返回值func函数赋给res
res()    # res()就是调用func函数，打印了func里面的内容
print(res)  # 输出func函数的内存地址
# 结果
# 函数名作为返回值
# 确实作为返回值了
# <function func at 0x000002671C602EA0>

4、函数名可以作为容器类型的元素

实例如下：

def func():
    print('作为容器的元素')
    return '作为容器的元素'
# 不加括号返回函数内存地址
lst = [1,2,3,4,func]
# 加括号返回函数的返回值
lst1 = [1,2,3,4,func()]
print(lst)
print(lst1)

3、函数的嵌套

1、定义

• 函数体内部定义其他函数，作用是将复杂的功能全部隐藏起来，暴露一个简单的接口

2、嵌套使用

实例如下：

# 函数的嵌套使用
# 原理，函数定义的时候都是全局名称所以可以相互调用
def func():
    print('func函数')
def func1():
    func()
    print('func1函数')
    
func1()

练习题：

# 函数嵌套，比较四个数大小
def two_max(a,b):
    if a>b:
        return a
    return b
def four_max(a,b,c,d):
    res = two_max(a,b)
    res1 = two_max(res,c)
    res2 = two_max(res1,d)
    return res2
fournum_max = four_max(1,2,3,4)
print(fournum_max)

4、闭包函数

1、定义：

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

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

  符合了上述两个条件的函数才可以被称为闭包函数！

实例如下：

def fun():
    x = 1
    def fun1():
        print('x:',x)
    return fun1
res = fun()
res()
# 结果
x: 1

2、闭包函数的使用方式（传参）

方式一：

• 函数体代码需要用到数据，直接在括号内定义形参即可，需要什么样的参数就定义什么样的形参

实例如下：

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

#函数体代码需要a，b两个参数那么就在形参定义的时候直接定义

方式二：

• 利用闭包函数传参，只需传一次参数就可以多次调用

实例如下：

def num(a,b):
    def max():
        if a>b:
            return a
        return b
    return max
res = num(1,2)
print(res())
print(res())
res = num(3,5)
print(res())
print(res())
print(res())

'''穿一次参数就可以多次调用'''

5、装饰器

1、定义

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

2、原则

开放封闭的原则

• 开放：对扩展开放
• 封闭：对修改封闭

3、装饰器核心思想

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

实例如下：

# 计算程序的执行时间
import time

# 获取的结果叫时间戳(运行代码的那一刻距离1970-1-1所经历的秒数)
print(time.time())


def index():
    time.sleep(3)
    print('计算时间停止了3秒后的结果！')


# 统计开始时间
start_time = time.time()
index()
# 统计结束的时间
end_time = time.time()
# 输出时间差
print(end_time-start_time)
# 时间运行的时间
print(end_time-start_time-3)

---

还有下一篇哦，持续更新中·····

---