本文详细介绍了Python中的函数和变量。从函数的基本定义、调用、参数类型（位置参数、关键字参数、缺省参数、不定长参数）到返回值的使用，深入探讨了函数的各个方面。此外，还讲解了局部变量和全局变量的区别，以及如何在函数中修改全局变量。通过实例展示了函数嵌套和匿名函数（lambda）的运用。
目录
一、函数
1、什么是函数？
在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块，组织为一个小模块，这就是函数
2、函数的定义和调用
格式：
def 函数名():执行语句函数名() #调用函数
代码：
def hello():
print("hello word")
hello()输出结果：
注意：
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它，调用函数很简单的，通过 函数名() 即可完成调用，每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了，当然了如果函数中执行到了return也会结束函数。
3、函数参数
代码：
def add2num():
a = 11
b = 22
c = a + b
print(c)
add2num()输出结果：
4、位置参数
格式：
def 函数名(参数1,参数2):代码块函数名(值1,值2)
代码：
def fun(a, b):
print("a:", a)
print("b:", b)
fun(2, 3)输出结果：
小总结：
定义时小括号中的参数，用来接收参数用的，称为
“
形参
” ；调用时小括号中的参数，用来传递给函数用的，称为 “
实参
”
5、关键字参数
格式：
def 函数名(参数1,参数2):代码块函数名(参数1=值1,参数2=值2)
代码：
#案例1
def fun(a, b):
print("a:", a)
print("b:", b)
fun(a=2, b=3)
##############
#案例2
def fun(a, b):
print("a:", a)
print("b:", b)
fun(3, b=2)
###################
#错误案例
def fun(a, b):
print("a:", a)
print("b:", b)
fun(a=3, 2)输出结果：
案例1：
案例2：
错误案例：
注意：参数调用时,可以改变传参顺序，如果有位置参数需要位置参数放在关键字参数前面
6、缺省参数
在形参中默认有值的参数，称之为缺省参数
代码：
1、
def printinfo(name, age=20):
print("name:", name)
print("age:", age)
printinfo(name="jack")
#################
2、
def printinfo(name, age=20):
print("name:", name)
print("age:", age)
printinfo(name="jack", age=10)
######################
3、错误案例
def printinfo(age=20,name):
print("name:", name)
print("age:", age)
printinfo(name="jack", age=10)输出结果：
1、
2、
3、错误案例
总结：
调用函数时，缺省参数的值如果没有传入，则取默认值（形式参数），如果传入，则取实际参数，缺省参数一定要位于位置参数的最后面
7、不定长参数
有时可能需要一个函数能处理比当初声明时更多的参数
,
这些参数叫做不定长参数，声明时不会命名。
格式：
def printinfo(*args,**kwargs):print("args:",args)print("kwargs:",kwargs)printinfo(参数)
注意：
加了星号（
*
）的变量
args
会存放所有未命名的变量参数，
args
为元组
而加
**
的变量
kwargs
会存放命名参数，即形如
key=value
的参数，
kwargs
为字典
代码：
#1、不定长参数* args
def printinfo(*args):
print("args:", args)
printinfo(100, 200, 300, 400)
###########################
#2、* args不能接收key=value类型的参数
def printinfo(*args):
print("args:", args)
printinfo(100, 200, 300, b=400)
########################
#3、不定长参数* * kwargs
def printinfo(**kwargs):
print("kwargs:", kwargs)
printinfo(a=100, b=200, c=300, d=400)
#######################
#4、* * kwargs不能接收未命名的变量参数
def printinfo(**kwargs):
print("kwargs:", kwargs)
printinfo(100, b=200, c=300, d=400)输出结果：
1、
2、
3、
4、
8、参数位置顺序
格式：
def fun ( 位置参数 , * args , 缺省参数 , ** kwargs ):代码块fun ( 参数值 )
代码：
def sun(a, *args, b=22, **kwargs):
print("a：", a)
print("args：", args)
print("b：", b)
print("kwargs：", kwargs)
sun(100, 200, 300, b=2, m=3, n=4)输出结果：
注意：
如果很多个值都是不定长参数，那么这种情况下，可以将缺省参数放到
*args
的后面， 但如果有 **kwargs的话，
**kwargs
必须是最后的
9、函数返回值
格式：
def sum ():代码块return 值sum ()
代码：
def sum(a, b):
return a + b
result = sum(1,2) #保存函数的返回值
print(result)
sum(1, 2)输出结果：
10、多个return
代码：
def create_nums(num):
print("---1---")
if num == 100:
print("---2---")
# 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还 有一个隐藏的功能：结束函数
return num + 1
print("return执行之后不会继续执行")
print("1231223")
else:
print("---3---")
return num + 2
print("---4---")
result1 = create_nums(100)
print(result1) # 打印101
result2 = create_nums(200)
print(result2) # 打印202
注意:
一个函数中可以有多个
return
语句，但是只要有一个
return
语句被执行到，那么这个函数就会结束了，因此后面的return
没有什么用处
11、返回多个数据
代码：
def divid(a, b):
shang = a // b # 取模
yushu = a%b #取余
return shang, yushu #默认是元组
result = divid(5, 2)
print(result)输出结果：
12、函数类型
分类：
1. 无参数，无返回值2. 无参数，有返回值3. 有参数，无返回值4. 有参数，有返回值
1、无参数，无返回值的函数
此类函数，不能接收参数，也没有返回值，一般情况下，打印提示灯类似的功能，使用这类的函数
代码：
def printMenu():
print('--------------------------')
print(' xx涮涮锅 点菜系统')
print('')
print(' 1. 羊肉涮涮锅')
print(' 2. 牛肉涮涮锅')
print(' 3. 猪肉涮涮锅')
print('--------------------------')
printMenu()输出结果：
2、无参数，有返回值的函数
此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数
代码：
def getTemperature():
# 这里是获取温度的一些处理过程
# 为了简单起见，先模拟返回一个数据
return 243、有参数，无返回值的函数
此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数
4、有参数，有返回值的函数
此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数
代码：
def calculateNum(num):
result = 0
i = 1
while i <= num:
result = result + i
i += 1
return result17、函数的嵌套
一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用
代码：
def testb():
print("testb start")
print("testb testb 执行")
print("testb end")
def testa():
print("testa start")
testb()
print("testa end")输出结果：
testa starttestb starttestb testb 执行testb endtesta end
注意：
如果函数
A
中，调用了另外一个函数
B
，那么先把函数
B
中的任务都执行完毕之后才会回到上次 函数
A
执行的位置
拓展：
代码：
# 打印一条横线
def printOneLine():
print("-"*30)
# 打印多条横线
def printNumLine(num):
i=0
# 因为printOneLine函数已经完成了打印横线的功能
# 只需要多次调用此函数即可
while i<num:
printOneLine()
i+=1
printNumLine(3)输出结果：
18、匿名函数
lambda
函数也叫匿名函数，即函数没有具体的名称
代码：
g = lambda x :x+1
print(g(1))
#############
def g(x):
return x + 1
print(g(1))注意：
lambda
函数可以赋值给变量，默认是返回的，所以不用再加
return
关键字
注释：
例如
g = lambda x:x+1,
可以看成如下函数，冒号前是参数，可以有多个，用逗号隔开，冒号右边的返回值
二、变量
1、局部变量
定义：
局部变量，就是在函数内部定义的变量
约束：
其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的
代码：
def test1():
a = 120
print("我是局部变量a:", a)
a = 240
print("修改之后的局部变量a:", a)
def test2():
a = 360
print("我是test02函数中的局部变量a", a)
test1()
test2()输出结果：
2、全局变量
定义：
在函数外边定义的变量叫做全局变量
约束：
全局变量能够在所有的函数中进行访问
代码：
a = 100
def test1():
print(a) # 虽然没有定义变量a但是依然可以获取其数据
def test2():
print(a) # 虽然没有定义变量a但是依然可以获取其数据
# 调用函数
test1()
test2()输出结果：
3、全局变量和局部变量名字相同
代码：
a = 100
# 全局变量
def test1():
a= 300
print("修改后的a:",a)
def test2():
print(a)
# 调用函数
test1()
test2()输出结果：
注意：
函数中的变量修改不会导致全局变量改变
4、全局变量的修改
代码:
a = 100
#全局变量
def test1():
global a
#将a变成全局变量
a= 300
print("修改后的a",a)
def test2():
print(a)
# 调用函数
test1()
test2()输出结果:
注意:
在函数中出现
global
全局变量的名字 那么这个函数中即使出现和全局变量名相同的变量名
=
数据，也理解为对全局变量进行修改，而不是定义局部变量
拓展：
在一个函数中需要对多个全局变量进行修改，那么可以使用
global a, b
# 还可以用多次global声明都是可以的
global a
global b
扫一扫
2673
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
