2020-11-14

函数快速入门

1. 函数的格式

def fn(a,b):
‘’’
这是关于两个数求和的函数
:param a: 任意浮点数
:param b: 任意浮点数
:return: 返回两数之和
‘’’
res = a + b
print(‘打印计算结果：’,res)
return res
re = fn(-998,345.8)
print(re,10*re)
‘’’
通常来说，函数包括：关键词def, 函数名称fn，括号，冒号，函数内部运算及返回值六部分构成。其中根据需要，可变化的部分为函数名，括号内的参数，及函数内容等。函数名应符合变量的命名规则即可。

下面分别介绍括号内的参数、长字符串（文本文档）、函数的作用域、返回值和递归函数等。

2. 参数

2.1 一般形参

创建函数时括号内的参数叫形参（形式参数），调用函数时括号内的参数必须是实参（实际参数）。通常，形参的数量为0，1，2，…,调用函数时实参和形参要对应。实参可以是任意类型，解释器不会鉴别参数的类型。通常，括号内的一个字母表示一个形参，在调用是必须提供一个实参进行调用。如
‘’’
def fn1(a):
‘’’
这是一个一元二次函数
:param a: 为任意实数
:return: 返回该实数的平方
‘’’
return a ** 2
res = fn1(-0.356)
print(res)

2.2 不定长参数

不定长参数包括形如*a和**a两种。

2.2.1 *a（接受位置参数）

表示含有任意元素的元组，该形参通常放在最后位置，如：
def fn2(a,b,*c):
‘’’
只是一个含有不定长参数的函数
:param a: 实数
:param b: 实数
:param c: 实数
:return: 最大值
‘’’
print©
fn2(1,2,3,6,9,-3.6)
‘’‘其中，1和2分别是形参a和b对应的实参，其余数以元组的形式对应于不定长参数c.当不定长参数出现在前面时，其后面的所有参数均为关键字参数，不能时一般形参。如’’’
def fn2(a,*b,c):
print(b)
fn2(1,2,3,4,5,6)
‘’‘运行结果为TypeError: fn2() missing 1 required keyword-only argument: ‘c’
因此，正确形式为：’’’
def fn2(a,*b,c):
print(a,b,c)
fn2(1,2,3,4,5,c=6)
‘’‘调用函数时，形参a对应的实参是1，关键字参数c=6,其他为形参b所对应的实参，b为一个元组。
运行结果为1 (2, 3, 4, 5) 6。如下调用时，’’’
fn2(1,2,3,4,5,d=6)
‘’‘没有对应关键词参数c对应的实参，而报错为
TypeError: fn2() got an unexpected keyword argument ‘d’。如果将不定长参数写到最前面时，后面的所有形参都必须是关键字参数。如’’’
def fn3(*a,b,c,d):
print(a,b,c,d)
‘’‘调用该函数时，如下形式是正确的：’’’
fn3(1,2,3,4,5,6,7,b=2,c=4,d=0)
fn3(1,2,3,4,5,6,7,c=4,b=2,d=0)
fn3(1,2,3,4,5,6,7,c=4,d=0,b=2)
‘’'调用时，c为4，b为2，d为0，其余为不定长参数a对应的元组。注意：关键字变量一定要跟在位置参数的后面，不能出现在位置参数之前，或中间。

2.2.2 **a(接受关键字参数）

不定长参数除了*a用来处理多个位置参数外，用**a处理多个关键字参数。如’’’
def fn4(**a):
print(a)
fn4(a=1,c=3)
fn4(c=1,d=3,a=9,e=0)
‘’‘上述两次调用函数的结果为：
{‘a’: 1, ‘c’: 3}
{‘c’: 1, ‘d’: 3, ‘a’: 9, ‘e’: 0}
当形参和不定长形参同时出现在一个函数中时，其顺序是：a,b,*c,**d,**e等顺序。如’’’
def fn5(a,d,*b,**c):
print(‘a=’,a,‘b=’,b,‘d=’,d,‘c=’,c)
fn5(1,3,5,7,c=56)
‘’‘调用结果为：a= 1 b= (5, 7) d= 3 c= {‘c’: 56}。’’’

3. 文档字符串

‘’‘文档字符串也叫长字符串，用来对函数变量和返回值，以及函数的用途和功能进行介绍。文档字符串出现在函数执行语句前面，用三对引号包括。当定义函数的参数确定后，其后自动出现param a,等参数及return 的提示，方便注释。当三个单引号打出并按回车键后，这些格式自动出现。如’’’
def fn5(a,c,e):
‘’’
:param a:
:param c:
:param e:
:return:
‘’’

4. 函数的作用域

‘’‘函数外的变量默认为全局变量，而函数内部的变量为区域变量。函数内部可以访问函数外的全局
变量，而函数外不能访问函数内的局部变量。如’’’
a = 20
b = 30
e = 80
def fn6():
a=10
e=40
print(‘函数内访问的变量a=’,a)
print(‘函数内访问的变量b=’,b)
fn6()
print(‘函数外访问的变量a=’,a)
print(‘函数外访问的变量e=’,e)
‘’‘运行的结果为：
函数内访问的变量a= 10
函数内访问的变量b= 30
函数外访问的变量a= 20
说明：函数内访问变量时，优先访问函数内部，如果函数内部有，则访问该变量，如果没有，则访问函数外的变量。函数外的变量只能在函数外进行访问，不能访问函数内部的变量。即，函数有权访问函数内外的变量，先内后外，而函数外无权访问函数内的变量。好比函数是党中央，函数外为地方政府的关系。函数内要对函数外的变量进行修改时，需要将该变量声明为全局变量后即可。如’’’
a = 20
def fn7():
global a
a = 40
print(‘调用函数之前a=’,a)
fn7()
print(‘调用函数之后a=’,a)
‘’‘运行结果为：
调用函数之前a= 20
调用函数之后a= 40。
尽管函数内对a声明为全局变量，并重新赋值为40，但该函数没有调用前，该声明没有执行，所以a值并没有改变。当该函数调用之后，全局变量a被函数重新赋值为40，此时a值改变。但是，如果
函数内部对全局变量中某一对象进行修改时，该对象在函数为也一同改变。如’’’
a = [1,2,3]
def fn8():
a[0]=10
print(‘函数内访问对象a:’,a)
fn8()
print(‘函数外访问对象a:’,a)
‘’'运行结果为：
函数内访问对象a: [10, 2, 3]
函数外访问对象a: [10, 2, 3]
可见，函数内可以对函数外的对象进行修改，却不需要像变量那样做global a样的声明。

怎样才能实现内部无法修改函数外的对象？需要使用copy()方法，如：
‘’’
a = [1,2,3]
def fn9():
b = a.copy()
b[0] = 10
print(‘函数内访问对象a=’,a)
fn9()
print(‘函数外访问对象a=’,a)
‘’‘运行结果为：
函数内访问对象a= [1, 2, 3]
函数外访问对象a= [1, 2, 3]。’’’

5. 函数的返回值

‘’’
函数的返回值以return为标志，其后给出函数的返回值。如
‘’’
a =9
def fn10():
return 10
global a
a = 0
print(fn10())
print(a)
‘’‘运行结果为：
10
9
该函数类似于常函数y=10，返回值出现在return之后。return给出返回值的同时，终止函数，其后的语句不执行。故a = 0没有被函数的global a的声明强行赋值为0。在循环语句中，break表示结束本层循环，continue表示结束本次循环。如’’’
for i in range(1,5):
print(i)
if i == 2:
break
运行结果为：
1
2
将break换为continue时，如

for i in range(1,5):
print(i)
if i == 2:
print(‘hello’)
continue
print(‘haha’)
‘’‘运行结果为：
1
2
hello
3
4
continue语句之后的print(‘haha’)没有打印。
‘’’

6. 递归函数

‘’‘递归函数就是在函数内部继续调用当前函数的函数，直到调用到不能继续调用为止，类似于
循环语句那样。因此，递归函数包括基样条件和递归条件两部分。如：要求n！（n的阶乘）时，需要
递归条件:n!=n*(n-1)!直到2！为止。于是，基样条件为1！=1。该递归函数为：’’’
def fn11(n):
# 基样条件
if n==1:
return 1
#递归条件
return n * fn11(n-1)
print(fn11(5))
print(54321)
‘’‘运行结果为：
120
120
再如，求任意数的任意次方ni，用递归函数定义时，递归条件为ni=n*n**(i-1)，直到
n**1为止。于是，基样条件为i=1时，返回n值。该递归函数为：’’’

def fn12(n,i):
#基样条件
if i==1:
return n
res = n * fn12(n,i-1)
return res
print(fn12(4,5))
print(4**5)
‘’‘运行结果为：
1024
1024’’’