Ptthon基础语法08 作用域回调函数返回函数闭包递归函数

本文链接：https://blog.youkuaiyun.com/qq_45183681/article/details/94471947

本文详细介绍了Python中的作用域，包括局部、全局、嵌套和内置作用域，以及变量搜索规则。此外，讲解了回调函数的概念，通过示例展示了如何将函数作为参数传递。还探讨了返回函数和闭包，特别是闭包的特点和装饰器的应用。最后，文章提到了递归函数，讨论了递归函数的工作原理和注意事项。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

变量的作用域:

在python程序中，我们变量的创建，更改以及删除都是在一个内存的命名空间中进行的，我们称这个命名空间为作用域
简单来说：作用域就是变量能使用的范围。

在python中定义的变量并不是在任何位置都可以使用的，它能使用的范围取决于变量定义的位置。

局部作用域：在函数体内部定义的变量都会产生一个新的局部作用域。
比如def模块中定义的，lambda中定义的变量。

嵌套作用域：函数体中又嵌套了一个函数，外函数的作用域称之为嵌套作用域

全局作用域：在当前.py文件中定义变量，定义在函数体之外的。

内置作用域：系统定义的，每个.py文件都可以使用的。

变量的划分：
局部变量：定义在函数体内部的变量我们称之为局部变量，
作用的范围：当前函数的函数体

全局变量：定义在.py文件中，并且定义在函数体外部的边变量我们称之为全局变量
作用范围：当前整个.py文件

内置变量：系统定义的
作用范围：项目中所有的.py文件

局部变量的生成以及销毁的时间：
当函数执行的时候生成，当函数执行结束则该变量销毁。

全局变量

变量搜索的规则：
先搜索局部作用域>嵌套作用域>全局作用域>内置作用域
若这几个作用域中都不存在此变量，这时候则报错。

global 关键字

使用global可以声明此变量为全局变量，在声明之后，可以在函数体内部
更改我们的全局变量，
若不声明的话，注意这个就不是更改，而是在函数内部创建了一个同名的局部变量而已。

结论：
在python中只有我们的模块，类以及函数的定义会产生新的作用域，而其他的语句块
比如if/else,try/except,while/for这些语句不会产生新的作用域，它的意思是
在这些语句块中定义的变量在外部是可以使用的。

for x in range(10):
pass

print(x)

num1 = 30

def outer():
num1 = 400
def func():
num = 20
global num1
num1 = 300
print(num1)
return func

outer()()
print(num1)

回调函数:就是把函数作为参数传递到另外一个函数中，这个被传递进去，
后来又被调用的函数我们称之为回调函数。

import functools

newint = functools.partial(int,base=2)

def nowouter(func): #func = now
def inner():
print("**********")
return func()
return inner

def now():
return “2019-4-29”

def func1(times):
print("%s以掐大腿的方式叫醒。。。"%times)

def func2(times):
print("%s以泼开水的方式叫醒。。。"%times)

def server(f,time):
f(time)

server(func1,“下午1点四十”)

inner = nowouter(now)

print(inner())

音乐播放器:
‘’’

欢迎来到酷我音乐播放器*

请选择以下功能：

1.播放 2.停止 *
3.下一曲 4.上一曲 *
5.增大音量 6.减少音量*

‘’’
import time
import pygame

def welcome():
print(’’’

欢迎来到酷我音乐播放器*

''')

def select():
print(’’’

1.播放 2.停止 *
3.下一曲 4.上一曲 *
5.增大音量 6.减少音量 *
```
 0.退出            *
```

''')
num = input("请输入您要选择的选项：")
return num

def playmusic(path):
pygame.mixer.init()
pygame.mixer.music.load(path)
pygame.mixer.music.play()

def stopmusic():
pygame.mixer.music.stop()

def nextmusic(musicList,index):
#判断index的值，若最后一曲则不再进行下一曲
if index>= len(musicList)-1:
print(“最后一曲了。。。”)
return index
else:
index += 1
playmusic(musicList[index])
return index

def prevmusic(musicList,index):
if index <=0:
print(“已经是第一首了”)
return index
else:
index -= 1
playmusic(musicList[index])
return index

def addvolume(val):
if val>=1.0:
print(“已经是最大音量了”)
return val
else:
val += 0.1
pygame.mixer.music.set_volume(val)
return val

def subvolume(val):
if val <=0:
print(“已经是最小音量了”)
return val
else:
val -= 0.1
pygame.mixer.music.set_volume(val)
return val

welcome()
musicList = [“X:\chuanqi.mp3”,“X:\dang.mp3”,r"X:\apple.mp3"]
index = 0
value = 0.5
while True:
time.sleep(1)
num = select()
if num == “1”:
print(“播放”)
playmusic(musicList[index])
elif num == “2”:
print(“停止”)
stopmusic()
elif num == “3”:
print(“下一曲”)
index = nextmusic(musicList,index)
elif num == “4”:
print(“上一曲”)
index = prevmusic(musicList,index)
elif num == “5”:
print(“增大音量”)
value = addvolume(value)
elif num == “6”:
print(“减小音量”)
value = subvolume(value)
elif num == “0”:
print(“退出”)
break
else:
print(“选择有误，请重新输入。。。”)

返回函数：
将函数作为返回值返回的时候，我们就称这个函数为返回函数。
在python中函数不但能够作为参数它还可以作为返回值返回。

import functools

newint = functools.partial(int,base=2)

print(newint)

def calc_sum(*args):
sum = 0
for i in args:
sum += i
return sum

print(calc_sum(1,2,3,4,5))

def lazy_sum(*args):
def inner():
sum = 0
for i in args:
sum += i
return sum
return inner

print(lazy_sum(1,2,3,4,5)())

闭包：
外函数中定义了一个内函数，内函数使用了外函数临时变量，
外函数的返回值是内函数的引用【内函数的函数名】，这时候就构成了一个闭包
特点：
一般情况下，函数在执行结束的时候，函数会将所占的内存归还，创建的局部变量也会消失
但是在闭包中出现一种特殊的情况，外函数在结束自己的时候，发现自己还有临时变量在
内函数中还会用到，这时候，它会将自己的临时变量绑定给内函数，然后自己再结束。

装饰器是闭包最典型的一个应用。
优点：
1.提高代码的复用性
2.减少函数参数的数目

def lazy_sum(*args):
def inner():
sum = 0
for i in args:
sum += i
return sum
return inner

def nowouter2(func): #func = now
def inner():
print(“")
res = func()
print(res)
print("”)
return res
return inner

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

def func():
list1 = []
for x in range(5):
def inner():
return x
list1.append(inner)
return list1

print(func())
list1 = func()
for f in list1:
print(f())

递归函数：
在函数的内部我们可以调用其他的函数，但当这个函数刚好是自己本身的时候，我们称这个函数递归函数。
换句话说：自己调用自己。

1.临界条件
2.找出这次与上次的关系
2.假设当前函数已经可以使用，使用当前的函数由上次结果求出本次的结果

优点：
1.定义简单
2.逻辑清晰

注意：使用递归的时候，我们要注意栈溢出，使用递归，本身使用是一种栈结构，每当调用一个函数
就会入一层栈，每当返回一次，出一层栈。但是栈层数是有限制的，因此使用的时候要注意防止栈溢出。

一般开发的过程中不建议使用递归。

1x2x3…n