Python函数深入解析-CSDN博客

本文详细讲解了Python函数的使用，包括return返回值的概念、局部与全局变量的区别、函数名的运用、函数的嵌套及LEGB原则。同时，介绍了如何使用nonlocal关键字修改局部变量，以及locals和globals函数的使用技巧。

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

return 返回值

自定义函数的返回值,return 可以把值返回到函数的调用处
(1) return + 六大标准数据类型 , 还有类和对象,函数
如果不定义return , 默认返回的是None
(2) 在执行完return之后,立刻终止函数,后面的代码不执行
1.return的返回类型

def func():
	# return 1
	# return 3.14
	# return "abc"
	# return []
	# return ()
	# return {"a":1}
	pass
res = func()
# 如果不定义return , 默认返回的是None
print(res) # None

2.在执行完return之后,立刻终止函数,后面的代码不执行

def func():
	print(1)
	print(2)
	return 3
	print(4)
	print(5)
res = func()
print(res)     #1,2,3

3.模拟简单的计算器 + - * /

def func(sign,num1,num2):
	if sign == "+":
		res = num1 + num2
	elif sign =="-":
		res = num1 - num2
	elif sign == "*":
		res = num1 * num2
	elif sign == "/":
		if num2 == 0:
			return "除数不能为0  , 脑弟!"
		res = num1 / num2
	else:
		return "这个本计算器真算不了"

	return res
res = func("+",3,5)
res = func("-",10,20)
res = func("*",10,20)
res = func("/",20,10)
res = func("/",20,0)
res = func("&",20,0)
print(res)

全局变量和局部变量

局部变量 : 在函数内部定义的变量(局部命名空间)
全局变量 : 在函数外部定义的或者使用global在函数内部定义(全局命名空间)
作用域: 作用的范围
局部变量作用域: 在函数的内部
全局变量作用域: 横跨整个文件
生命周期:
内置变量 > 全局变量 > 局部变量
总结:
可以使用global 关键字在函数内部定义一个全局变量
也可以使用global关键字在函数内部修改一个全局变量
1.局部变量

def func():
	# 定义局部变量
	a = 5
	# 获取局部变量
	print(a)
	# 修改局部变量
	a = 10
	print(a)
func()
print(a) error 不能再全局调用局部变量

2.全局变量

 定义全局变量
b = 10
 获取全局变量
print(b)
 修改全局变量
b = 20
def func():
	# 可以在函数内部获取全局变量
	print(b)
func()

3.使用global在函数内部创建全局变量

def func():
	global c
	c = 200
func()
print(c)

4.使用global在函数内部修改全局变量

d = 300
def func():
	global d
	d = 400
func()
print(d)

函数名的使用

def func():
	print("我是func函数")
	return 1111
 1.函数名是个特殊的变量,可以当做变量赋值
a = "你好"
print(a)
a = func
a()

函数可以像变量一样销毁
del a

2.函数名可以作为容器类型数据的元素
def func1():
	print("我是func1函数")
def func2():
	print("我是func2函数")	
def func3():
	print("我是func3函数")
lst = [func1,func2,func3]
for i in lst:
	print(i)
	i() # func1() func2() func3()

3.函数名可以作为函数的参数
def func4(f):
	f()
func4(func3)

4.函数名可作为函数的返回值
def func(f):
	return f	
res = func(func2) # f <=> func2 =>  res = func2()
res()

__doc__ 或者  help 查看文档
def eat_fruit(something):
	"""
	功能:吃水果
	参数:水果名字
	返回值:吃的状态
	"""
	print("先把{}洗一洗".format(something))
	print("放嘴里")
	print("啃!")
	return "吃完了"
res= eat_fruit("苹果")
print(res)
help(eat_fruit)
res= eat_fruit.__doc__
print(res)

函数的嵌套

函数之间可以互相嵌套
外层的叫做外函数
内层的叫做内函数
(1)内部函数不能直接在函数外部调用
(2)调用外部函数后,内部函数不可以在函数外部调用
(3)内部函数可以在函数内部调用
(4)内部韩式在函数内部调用时,有先后顺序,必须先定义再调用

LEGB 原则 (就近找变量原则)

找寻变量的调用顺序采用LEGB原则(就近原则)
B – Builtin(Python);python内置模块的命名空间 (内建作用域)
G – Global(module);函数外部所在的命名空间 (全局作用域)
E – Enclosing function locals ;外部嵌套函数的作用域 (嵌套作用域)
L – Local(function); 当前函数内的作用域 (局部作用域)
依据就近原则,从下往上,从里向外依次寻找

nonlocal 修改局部变量

nonlocal遵循LEGB就近找变量原则
(1)找当前空间上一层的局部变量进行修改
(2)如果找不到,会继续向上寻找
(3)最后什么也没有,直接报错

1)找当前空间上一层的局部变量进行修改
def outer():
	a = 100
	def inner():
		nonlocal a
		a = 200
		print(a)
	inner()
	print(a)
outer()

(2) 如果找不到,会继续向上寻找
def outer():
	a = 100
	def inner():	
 		def smaller():
			nonlocal a 
			a = 400
			print(a)
		smaller()
		print(a)
	inner()
	print(a)
outer()

(3) 注意点:nonlocal只能修改局部变量
# 最后什么也没有,直接报错
a = 100
def outer():
	def inner():
		def smaller():
			nonlocal a 
			a = 400
			print(a)
		smaller()
		print(a)
	inner()
	print(a)
outer()

(4) 不使用nonlocal 修改局部变量
def func():
	lst = [1,2,3,4]
	def inner():
		lst[-1] = 10
	inner()
	print(lst)
func()

locals 和 globals

locals 获取当前作用域中所有变量
locals 如果在全局,调用locals之后,获取的是打印之前的所有变量,返回字典,全局空间作用域
locals 如果在局部,调用locals之后,获取的是调用之前的所有变量,返回字典,局部空间作用域

例子1:
def func():
	ff = 123
a = 1
b = 2
res = locals()
c = 3
print(res)
d = 4

 例子2
a1 = 10
def func():
	a = 1 
	b = 2
	res = locals()
	c = 3
	print(res)
	d = 4
a2 = 20
func()
a3 = 30

globals 只获取全局空间中所有变量
globals 如果在全局,调用globals之后,获取的是打印之前的所有变量,返回字典,全局空间作用域
globals 如果在局部,调用globals之后,获取的是调用之前的所有变量,返回字典,全局空间作用域

 例子1
def func():
	ff = 123
a = 1
b = 2
res = globals()
c = 3
print(res)
d = 4

例子2
a1 = 10
def func():
	a = 1 
	b = 2
	res = globals()
	c = 3
	print(res)
	d = 4
a2 = 20
func()  # globals
a3 = 30

globals 动态批量创建全局变量
1.用字符串定义全局变量

dic = globals()
print(dic) # 返回的是系统的字典
 在全局的字典当中,通过添加键值对,自动创建全局变量
 对应的键时变量名,对应的值是变量指向的值
dic["name"] = "致和"
print(name)

2.批量定义全局变量

def func():
	dic = globals()
	# 通过在全局系统字典当中,添加键值对,批量创建变量
	for i in range(1,6):
		# "a%d" % (1) => "a1"  "a%d" % (2) => "a2"  
		dic["a%d" % (i)] = i #  1~5 		
func()