python 学习笔记（函数结构）

当我们需要在程序中多次执行同一类型的任务时，不需要反复编写代码段来完成任务，而是可以利用函数工具来大大方便我们的编程工作。函数是可重复使用的、用来实现相关联功能的代码段。

本实训的目标是让学习者了解并掌握函数结构的相关知识，本关的小目标则是让学习者先了解并掌握函数参数的有关知识。

相关知识

我们在使用函数前，得先定义一个满足自己使用要求的函数。定义函数的基本结构是：

1. def functionname( parameters ):
2. "函数_文档字符串"
3. function_suite
4. return [expression]

• 定义函数以def关键词开头，后面跟着函数名、圆括号()、括号中的参数、冒号；
• 接着，在缩进块中编写函数体，函数的第一行语句一般是写文档字符串，用于存放函数说明，也可以选择不写；
• Return[expression]表示结束函数，并返回值。而不带表达式的return相当于返回空值。

本关的重点就是研究函数的参数parameters。定义函数的时候，参数的名字和位置定下来了，函数的接口定义也就完成了。我们在调用函数时，只用知道该传递什么样的参数，函数内部的运行情况已经被封装，使用者不必了解。

Python 的函数参数主要包含以下几种：

• 必选参数；
• 默认参数；
• 可变参数；
• 关键字参数。

必选参数

必选参数也叫位置参数，是函数中最常用的参数。必选参数就是在调用函数的时候必须指定参数值。例如：

1. # 定义加法函数plus，参数a,b就是必选参数
2. def plus(a,b):
3. c=a+b
4. return(c)
6. # 调用函数plus时，必须给参数a,b传递值
7. d=plus(1,2)
9. # 输出结果d
10. print(d)

输出结果：

1. 3

如果调用plus函数时，传入的参数不符合要求，则会出现错误。例如：

1. >>d = plus()
3. TypeError: plus() missing 2 required positional arguments: 'a' and 'b'
5. >>d = plus(1)
6. TypeError: plus() missing 1 required positional argument: 'b'

默认参数

默认参数是指给函数参数提供默认值，如果在调用函数的时候没有给该参数传递值，则该参数使用默认值。例如：

1. # 定义加法函数plus，参数a是必选参数，参数b是默认值2的参数
2. def plus(a,b=2):
3. c=a+b
4. return(c)
6. # 调用函数plus时，必须给参数a传递值，若不给b传递值，则b默认为2
7. d=plus(1)
10. # 输出结果d
11. print(d)

从上面的例子可以看出，在函数调用过程中可以不用给默认参数传递参数值。但在使用默认参数时，有两点需要注意：

• 默认参数要放在所有必选参数的后面；
• 默认参数必须指向不变对象。

可变参数

在有些情况下，我们在定义函数的时候，还不能确定函数应该包含多少个参数，这时我们可以使用可变参数，可变参数就是传入的参数数量是可变的。例如：

1. # 定义plus函数，完成的功能是返回输入的整数之和。
2. # 参数numbers是可变参数，表示输入的参数个数可以为任意值
3. def plus(*numbers):
4. add = 0
5. for i in numbers:
6. add += i
7. return(add)
9. # 调用3次plus函数，每次的参数个数都不相同
10. d1 = plus(1,2,3)
11. d2 = plus(1,2,3,4)
12. d3 = plus(1,3,5,7,9)
14. # 向函数中可以传递任意参数，包括0个参数
15. d4 = plus()
17. # 输出结果
18. print(d1)
19. print(d2)
20. print(d3)
21. print(d4)

输出结果：

1. 6
2. 10
3. 25
4. 0

在上面的例子中，numbers就是一个可变参数，可变参数前面加一个标识符*。在函数内部，可变参数numbers接收到的值是一个tuple。我们在调用参数是可变参数的函数时，可以给该函数传递任意个数的参数，包括0个参数。

关键字参数

可变参数允许我们在调用函数时传入任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许我们传入任意个含参数名的参数，这些关键字参数在函数调用时自动组装为一个dict。也就是说，关键字参数将长度任意的键-值对，作为参数传递给函数。例如：

1. # 定义一个包含关键字参数的函数，返回值为参数值
2. def plus(**kw):
3. return kw
5. # 调用plus函数，参数值为空
6. d1 = plus()
8. # 调用plus函数，参数值为x=1
9. d2 = plus(x=1)
11. # 调用plus函数，参数值为x=1,y=2
12. d3 = plus(x=1, y=2)
14. # 输出d1,d2,d3
15. print(d1)
16. print(d2)
17. print(d3)

输出结果：

1. {}
2. {'x': 1}
3. {'x': 1, 'y': 2}

在上面的例子中，kw就是一个关键字参数，关键字参数前面加**表示。关键字参数可以扩展函数功能，使传递参数过程更为简便。例如：

1. # 定义一个plus函数，有3个参数，返回值是3个参数之和
2. def plus(x,y,z):
3. return x+y+z
5. # 有一个dict列表，当中3个键的值分别为1,2,3
6. dict = {'x':1, 'y':2, 'z':3}
8. # 将dict列表中的3个值传入plus函数中，得到返回值d
9. d = plus(dict['x'],dict['y'],dict['z'])
11. # 输出d
12. print(d)

输出结果：

1. 6

但在上述例子中，将字典中的值向plus函数中传递参数的方法过于累赘，可以采取关键字参数的方法。例如：

1. # 定义一个plus函数，有3个参数，返回值是3个参数之和
2. def plus(x,y,z):
3. return x+y+z
5. # 有一个dict列表，当中3个键的值分别为1,2,3
6. dict = {'x':1, 'y':2, 'z':3}
8. # 用关键字参数的方法将dict列表中的3个值传入plus函数中，得到返回值d
9. d = plus(**dict)
11. # 输出d
12. print(d)

输出结果：

1. 6

使用关键字参数**dict的方法，可以大大提高参数传递的效率。

参数组合

我们在函数定义过程中，可以同时用到必选参数、默认参数、可变参数、关键字参数中的一种或几种。但是需要特别注意的是，这四种参数在使用的过程中是有顺序的，顺序依次应该是必选参数、默认参数、可变参数和关键字参数。例如：

1. # 定义一个包含必选参数、默认参数、可变参数和关键字参数的函数plus
2. def plus(x, y, z=0, *args, **kw):
3. print('x=',x)
4. print('y=',y)
5. print('z=',z)
6. print('args=',args)
7. print('kw=',kw)
9. # 调用函数plus，输入两个参数1,2
10. plus(1,2)

输出结果：

1. x= 1
2. y= 2
3. z= 0
4. args= ()
5. kw= {}

上面这个例子中，向plus函数中传入了两个必选参数1和2。必选参数必须得提供值，但是默认参数、可变参数和关键字参数可以不用提供值，我们还可以给默认参数、可变参数和关键字参数传递值。例如：

1. # 定义一个包含必选参数、默认参数、可变参数和关键字参数的函数plus
2. def plus(x, y, z=0, *args, **kw):
3. print('x=',x)
4. print('y=',y)
5. print('z=',z)
6. print('args=',args)
7. print('kw=',kw)
9. # 调用函数plus，输入参数x=1,y=2,z=3,args=(4,5,6),kw={}
10. plus(1,2,3,4,5,6)
12. print('\n')
14. # 调用函数plus，输入参数x=1,y=2,z=3,args=(4,5,6),kw={'k':7, 'm':8}
15. plus(1,2,3,4,5,6,k=7,m=8)

输出结果：

1. x= 1
2. y= 2
3. z= 3
4. args= (4, 5, 6)
5. kw= {}
8. x= 1
9. y= 2
10. z= 3
11. args= (4, 5, 6)
12. kw= {'k': 7, 'm': 8}

小结

• 不同类型的参数是有顺序的，依次是必选参数、默认参数、可变参数和关键字参数；
• 默认参数一定要用不可变对象，用可变对象容易产生逻辑错误；
• *args表示的是可变参数，*args接收的是一个元组；
• **kw表示的是关键字参数，**kw接收的是一个字典。

# 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(*args):
   add = 0
   for i in numbers:
      add += i
   return(add)
d=plus(numbers)

########## End ##########

print(d)

return语句将值返回到调用函数的出口，函数中一定要有return返回值才是完整的函数。如果我们没有在函数中定义函数返回值，那么程序会自动让函数返回一个结果，该结果是None对象，而None对象表示没有任何值。

将值作为返回值

函数的返回值只有一个，但有时我们会发现有的函数好像有多个返回值，其实这里的“多个”并不是指多个返回值。比如函数返回一列表，里面包含很多个元素值。这就类似于，只能从超市带走一个箱子，但是允许我们把一些东西都装到箱子里面看做一个东西带走。例如：

1. def f():
2. return 1,'abc','1234'
4. print(f())

输出结果：

1. (1, 'abc', '1234')

调用f()函数，程序输出为一个元组，所以函数返回值表面上是3个值，其实是返回一个元组，元组里面有三个不同元素（元组语法上不需要一定带上圆括号）。

将函数作为返回值

我们除了可以将各种类型的值作为返回值外，也可以将函数作为返回值。例如，我们要定义一个函数来求列表中数值元素的和，一般情况下我们是这样定义的：

1. def plus(*args):
2. s = 0
3. for n in args:
4. s = s + n
5. return s

但是，如果我们不需要立刻求和，而是在后面的程序中，根据需求再计算，这种情况怎么办呢？这时我们定义的函数可以不返回求和的结果，而是返回计算求和的函数。所以我们还可以用如下方法定义函数：

1. def lazy_plus(*args):
2. def plus():
3. s = 0
4. for n in args:
5. s = s + n
6. return s
7. return plus

当我们调用lazy_plus()时，返回的并不是求和结果，而是计算求和的函数：

1. # 定义求和函数，返回的并不是求和结果，而是计算求和的函数
2. def lazy_plus(*args):
3. def plus():
4. s = 0
5. for n in args:
6. s = s + n
7. return s
8. return plus
10. # 调用lazy_plus()时，返回的并不是求和结果，而是求和函数
11. f = lazy_plus(1,2,3,4,5)
12. print(f)

输出结果：

1. <function lazy_plus.<locals>.plus at 0x000001DAC97F9950>

调用函数f时，才真正计算求和的结果：

1. # 定义求和函数，返回的并不是求和结果，而是计算求和的函数
2. def lazy_plus(*args):
3. def plus():
4. s = 0
5. for n in args:
6. s = s + n
7. return s
8. return plus
10. # 调用函数f时，得到真正求和的结果
11. f = lazy_plus(1,2,3,4,5)
12. print(f())

输出结果：

1. 15

在上述例子中，我们在函数lazy_plus中又定义了函数plus，而且内部函数plus是可以引用外部函数lazy_plus的参数和局部变量的。当函数lazy_plus返回函数plus时，相关参数和变量也将会保存在返回的函数中，这种方式也称为“闭包”（Closure）。

小结

我们除了可以将函数计算的值作为返回值外，也可以将函数作为返回值。

 

# coding=utf-8

# 输入两个正整数a,b
a = int(input())
b = int(input())

# 请在此添加代码，求两个正整数的最大公约数
########## Begin ##########

def gcd(a,b):
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a
    return b
    




########## End ##########

# 调用函数，并输出最大公约数

print(gcd(a,b))

# coding=utf-8

# 输入两个正整数a,b
a = int(input())
b = int(input())

# 请在此添加代码，求两个正整数的最小公倍数
########## Begin ##########
# coding=utf-8

# 输入两个正整数a,b

# 请在此添加代码，求两个正整数的最大公约数
########## Begin ##########
def gcd(a,b):
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a
    return b
n=gcd(a,b)
f=(a*b)/n


# 调用函数，并输出a,b的最小公倍数
print(int(f))