函数是可重复使用的、用来实现相关联功能的代码段。
一、定义函数
定义函数的基本结构是:
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
def 函数名( 参数 ):
- 定义函数以
def
关键词开头,后面跟着函数名、圆括号()
、括号中的参数、冒号; - 接着,在缩进块中编写函数体,函数的第一行语句一般是写文档字符串,用于存放函数说明,也可以选择不写;
return[expression]
表示结束函数,并返回值。而不带表达式的return
相当于返回空值。
二、函数的参数
1.必选参数
必选参数也叫位置参数,是函数中最常用的参数。必选参数就是在调用函数的时候必须指定参数值。
# 定义加法函数plus,参数a,b就是必选参数
def plus(a,b):
c=a+b
return(c)
# 调用函数plus时,必须给参数a,b传递值
d=plus(1,2)
# 输出结果d
print(d)
#输出的结果
3
如果调用plus
函数时,传入的参数不符合要求,则会出现错误。
d = plus()
TypeError: plus() missing 2 required positional arguments: 'a' and 'b'
d = plus(1)
TypeError: plus() missing 1 required positional argument: 'b'
2.默认参数
默认参数是指给函数参数提供默认值,如果在调用函数的时候没有给该参数传递值,则该参数使用默认值。
# 定义加法函数plus,参数a是必选参数,参数b是默认值2的参数
def plus(a,b=2):
c=a+b
return(c)
# 调用函数plus时,必须给参数a传递值,若不给b传递值,则b默认为2
d=plus(1)
# 输出结果d
print(d)
#输出的结果
3
从上面的例子可以看出,在函数调用过程中可以不用给默认参数传递参数值。但在使用默认参数时,有两点需要注意:
- 默认参数要放在所有必选参数的后面;
- 默认参数必须指向不变对象。
3.可变参数
在有些情况下,我们在定义函数的时候,还不能确定函数应该包含多少个参数,这时我们可以使用可变参数,可变参数就是传入的参数数量是可变的。
# 定义plus函数,完成的功能是返回输入的整数之和。
# 参数numbers是可变参数,表示输入的参数个数可以为任意值
def plus(*numbers):
add = 0
for i in numbers:
add += i
return(add)
# 调用3次plus函数,每次的参数个数都不相同
d1 = plus(1,2,3)
d2 = plus(1,2,3,4)
d3 = plus(1,3,5,7,9)
# 向函数中可以传递任意参数,包括0个参数
d4 = plus()
# 输出结果
print(d1)
print(d2)
print(d3)
print(d4)
#输出的结果
6
10
25
0
在上面的例子中,numbers
就是一个可变参数,可变参数前面加一个标识符*
。 可变参数允许我们在调用函数时传入任意个参数,这些可变参数在函数调用时自动组装为一个tuple。
4.关键字参数
关键字参数允许我们传入任意个含参数名的参数,这些关键字参数在函数调用时自动组装为一个dict。也就是说,关键字参数将长度任意的键-值对,作为参数传递给函数。
# 定义一个包含关键字参数的函数,返回值为参数值
def plus(**kw):
return kw
# 调用plus函数,参数值为空
d1 = plus()
# 调用plus函数,参数值为x=1
d2 = plus(x=1)
# 调用plus函数,参数值为x=1,y=2
d3 = plus(x=1, y=2)
# 输出d1,d2,d3
print(d1)
print(d2)
print(d3)
#输出的结果
{}
{'x': 1}
{'x': 1, 'y': 2}
在上面的例子中,kw
就是一个关键字参数,关键字参数前面加**
表示。关键字参数可以扩展函数功能,使传递参数过程更为简便。
# 定义一个plus函数,有3个参数,返回值是3个参数之和
def plus(x,y,z):
return x+y+z
# 有一个dict列表,当中3个键的值分别为1,2,3
dict = {'x':1, 'y':2, 'z':3}
# 将dict列表中的3个值传入plus函数中,得到返回值d
d = plus(dict['x'],dict['y'],dict['z'])
# 输出d
print(d)
#输出的结果
6
但在上述例子中,将字典中的值向plus
函数中传递参数的方法过于累赘,可以采取关键字参数的方法。
# 定义一个plus函数,有3个参数,返回值是3个参数之和
def plus(x,y,z):
return x+y+z
# 有一个dict列表,当中3个键的值分别为1,2,3
dict = {'x':1, 'y':2, 'z':3}
# 用关键字参数的方法将dict列表中的3个值传入plus函数中,得到返回值d
d = plus(**dict)
# 输出d
print(d)
#输出的结果
6
5.参数组合
使用顺序:
必选参数——>默认参数——>可变参数——>关键字参数
# 定义一个包含必选参数、默认参数、可变参数和关键字参数的函数plus
def plus(x, y, z=0, *args, **kw):
print('x=',x)
print('y=',y)
print('z=',z)
print('args=',args)
print('kw=',kw)
# 调用函数plus,输入两个参数1,2
plus(1,2)
#输出的结果
x= 1
y= 2
z= 0
args= ()
kw= {}
上面这个例子中,向plus
函数中传入了两个必选参数1
和2
。必选参数必须得提供值,但是默认参数、可变参数和关键字参数可以不用提供值,我们还可以给默认参数、可变参数和关键字参数传递值。
# 定义一个包含必选参数、默认参数、可变参数和关键字参数的函数plus
def plus(x, y, z=0, *args, **kw):
print('x=',x)
print('y=',y)
print('z=',z)
print('args=',args)
print('kw=',kw)
# 调用函数plus,输入参数x=1,y=2,z=3,args=(4,5,6),kw={}
plus(1,2,3,4,5,6)
print('\n')
# 调用函数plus,输入参数x=1,y=2,z=3,args=(4,5,6),kw={'k':7, 'm':8}
plus(1,2,3,4,5,6,k=7,m=8)
#输出的结果
x= 1
y= 2
z= 3
args= (4, 5, 6)
kw= {}
x= 1
y= 2
z= 3
args= (4, 5, 6)
kw= {'k': 7, 'm': 8}
注意:
- 不同类型的参数是有顺序的,依次是必选参数、默认参数、可变参数和关键字参数;
- 默认参数一定要用不可变对象,用可变对象容易产生逻辑错误;
*args
表示的是可变参数,*args
接收的是一个元组;**kw
表示的是关键字参数,**kw
接收的是一个字典。
例:实现相应的功能。具体要求如下:
定义并调用一个函数,功能是对输入的列表中的数值元素进行累加,列表中元素的个数没有确定;
将累加结果存储到变量d中;
输出累加结果d。
# coding=utf-8
# 创建一个空列表numbers
numbers = []
# str用来存储输入的数字字符串,lst1是将输入的字符串用空格分割,存储为列表
str = input()
lst1 = str.split(' ')
# 将输入的数字字符串转换为整型并赋值给numbers列表
for i in range(len(lst1)):
numbers.append(int(lst1.pop()))
# 请在此添加代码,对输入的列表中的数值元素进行累加求和
########## Begin ##########
def plus(*numbers):
add = 0
for i in numbers:
add +=i
return(add)
d = plus(*numbers)
########## End ##########
print(d)
三、函数的返回值(return)
函数在进行运算处理后,返回的值被称为返回值。函数返回的值是通过return
语句执行,返回值能够让我们直接得到函数处理的结果
return
语句将值返回到调用函数的出口,函数中一定要有return
返回值才是完整的函数。如果我们没有在函数中定义函数返回值,那么程序会自动让函数返回一个结果,该结果是None
对象,而None
对象表示没有任何值。
1.将值作为返回值
函数的返回值只有一个(函数返回一列表,里面包含很多个元素值。)
def f():
return 1,'abc','1234'
print(f())
#输出结果
(1, 'abc', '1234')
调用f()
函数,程序输出为一个元组,所以函数返回值表面上是3个值,其实是返回一个元组,元组里面有三个不同元素(元组语法上不需要一定带上圆括号)。
2.将函数作为返回值
我们除了可以将各种类型的值作为返回值外,也可以将函数作为返回值。例如,我们要定义一个函数来求列表中数值元素的和,一般情况下我们是这样定义的:
def plus(*args):
s = 0
for n in args:
s = s + n
return s
定义的函数可以不返回求和的结果,而是返回计算求和的函数。所以我们还可以用如下方法定义函数:
def lazy_plus(*args):
def plus():
s = 0
for n in args:
s = s + n
return s
return plus
当我们调用lazy_plus()
时,返回的并不是求和结果,而是计算求和的函数:
# 定义求和函数,返回的并不是求和结果,而是计算求和的函数
def lazy_plus(*args):
def plus():
s = 0
for n in args:
s = s + n
return s
return plus
# 调用lazy_plus()时,返回的并不是求和结果,而是求和函数
f = lazy_plus(1,2,3,4,5)
print(f)
#输出结果
<function lazy_plus.<locals>.plus at 0x000001DAC97F9950>
#调用函数f时,才真正计算求和的结果:
print(f())
#输出结果
15
在上述例子中,我们在函数lazy_plus
中又定义了函数plus
,而且内部函数plus
是可以引用外部函数lazy_plus
的参数和局部变量的。当函数lazy_plus
返回函数plus
时,相关参数和变量也将会保存在返回的函数中,这种方式也称为“闭包”(Closure)。
例:实现相应的功能。具体要求如下:
定义一个函数gcd,功能是求两个正整数的最大公约数;
调用函数gcd,得到输入的两个正整数的最大公约数,并输出这个最大公约数。
# coding=utf-8
# 输入两个正整数a,b
a = int(input())
b = int(input())
# 请在此添加代码,求两个正整数的最大公约数
########## Begin ##########
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b,a%b)
########## End ##########
# 调用函数,并输出最大公约数
print(gcd(a,b))
四、函数的使用范围(Python作用域)
在 Python 中,正常的函数和变量名是公开的(public
),是可以被直接引用的。比如abs()
、abc
、dir()
等。
-
类似
__xxx__
这种格式的变量是特殊变量,允许被直接引用,但是会被用作特殊用途。比如__author__
、__name__
就是属于特殊变量。hello
模块定义的文档注释也可以用特殊变量__doc__
访问,我们自己编程定义的变量一般不会用这种变量名。 -
类似
_xxx
和__xxx
这种格式的函数和变量就是非公开的(private
),不应该被直接引用。 -
补充:
_xxx
的函数和变量是protected
,我们直接从外部访问不会产生异常。__xxx
的函数和变量是private
,我们直接从外部访问会报异常,我们要注意前缀符号的区别。
在 Python 中并没有一种方法可以真正完全限制访问private
函数或变量。private
函数的作用是隐藏函数的内部逻辑,让函数有更好的封装性。
def _private_1(name):
return 'Hello, %s' % name
def _private_2(name):
return 'Hi, %s' % name
def greeting(name):
if len(name) > 3:
return _private_1(name)
else:
return _private_2(name)
在上述程序块里公开了greeting()
函数,greeting()
函数需要使用_private_1()
和_private_2()
函数。将内部逻辑用private
函数隐藏起来,这是一种十分常用的代码封装的方法。
一般把外部需要使用的函数定义为public
函数,而把只在内部使用而外部不需要引用的函数定义成private
函数。
例:实现相应的功能。具体要求如下:
编写程序,功能是求两个正整数的最小公倍数;
要求实现方法:先定义一个private函数 _gcd()求两个正整数的最大公约数,再定义public函数lcm()调用 _gcd()函数求两个正整数的最小公倍数;
调用函数lcm(),并将输入的两个正整数的最小公倍数输出。
# coding=utf-8
# 输入两个正整数a,b
a = int(input())
b = int(input())
# 请在此添加代码,求两个正整数的最小公倍数
########## Begin ##########
def _private_gcd(a,b):
if b == 0:
return a
else:
return _private_gcd(b,a%b)
def lcm(a,b):
return int((a*b) / _private_gcd(a,b))
########## End ##########
# 调用函数,并输出a,b的最小公倍数
print(lcm(a,b))