educpder_python：5-2-函数 初级第一关 函数的参数-搭建函数房子的砖第二关 函数的返回值-可有可无的return第三关 函数的使用范围-Python作用域

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道 Python 提供了许多内建函数，比如 print() 。但你也可以自己创建函数，这被叫做用户自定义函数

任务描述
相关知识
必选参数
默认参数
可变参数
关键字参数
参数组合
小结
编程要求
测试说明

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

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

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

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

定义函数以def关键词开头，后面跟着函数名、圆括号()、括号中的参数、冒号；
接着，在缩进块中编写函数体，函数的第一行语句一般是写文档字符串，用于存放函数说明，也可以选择不写；
Return[expression]表示结束函数，并返回值。而不带表达式的return相当于返回空值。
本关的重点就是研究函数的参数parameters。定义函数的时候，参数的名字和位置定下来了，函数的接口定义也就完成了。我们在调用函数时，只用知道该传递什么样的参数，函数内部的运行情况已经被封装，使用者不必了解。

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

必选参数；
默认参数；
可变参数；
关键字参数。
必选参数
必选参数也叫位置参数，是函数中最常用的参数，必选参数就是在调用函数的时候必须指定参数值，例如：

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

定义加法函数plus，参数a,b就是必选参数

def plus(a,b):  
   c=a+b  
   return (c)

调用函数plus时，必须给参数a,b传递值

d=plus(1,2)
# 输出结果d  
print(d)

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

# 定义加法函数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)  

从上面的例子可以看出，在函数调用过程中可以不用给默认参数传递参数值。但在使用默认参数时，有两点需要注意：
默认参数要放在所有必选参数的后面；
默认参数必须指向不变对象。
可变参数
在有些情况下，我们在定义函数的时候，还不能确定函数应该包含多少个参数，这时我们可以使用可变参数，可变参数就是传入的参数数量是可变的。例如：

# 定义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 就是一个可变参数，可变参数前面加一个标识符*，在函数内部，可变参数numbers接收到的值是一个 tuple。

我们在调用参数是可变参数的函数时，可以给该函数传递任意个数的参数，包括0个参数。

关键字参数
可变参数允许我们在调用函数时传入任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

而关键字参数允许我们传入任意个含参数名的参数，这些关键字参数在函数调用时自动组装为一个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

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

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

例如：

# 定义一个包含必选参数、默认参数、可变参数和关键字参数的函数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接收的是一个字典。

第1关：函数的参数 - 搭建函数房子的砖

#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 *********#
d=sum(numbers)

#********** End **********#

print(d)

第二关 函数的返回值-可有可无的return

#coding=utf-8

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

# 请在此添加代码，求两个正整数的最大公约数
#********** Begin *********#
#方法一
# def gcd(a,b):
#     Maxs=max(a,b)
#     Mins=min(a,b)
#     if(Maxs%Mins==0):
#         return Mins  # 以小数除大数，如果能整除，那么小数就是所求的最大公约数.
#     return gcd(Maxs%Mins,Mins)#否则就用余数来除刚才的除数;再用这新除法的余数去除刚才的余数，递归一下子搞定

#  (2)辗转相除法. 当两个数都较大时，采用辗转相除法比较方便.其方法是:
# 以小数除大数，如果能整除，那么小数就是所求的最大公约数.否则就用余数来除刚才的除数;
# 再用这新除法的余数去除刚才的余数.依此类推，直到一个除法能够整除，这时作为除数的数就是所求的最大公约数. 
# 例如:求4453和5767的最大公约数时，可作如下除法.
#  5767÷4453=1余1314 
#  4453÷1314=3余511 
#  1314÷511=2余292 
#  511÷292=1余219 
#  292÷219=1余73 
#  219÷73=3 
#  于是得知，5767和4453的最大公约数是73.
#方法二
def gcd(a,b):
    if(b>a):
        a,b=b,a
    temp=a%b
    while(temp):
        a=b
        b=temp
        temp=a%b
    return b
#********** End **********#

# 调用函数，并输出最大公约数
print(gcd(a,b))

任务描述
函数在进行运算处理后，返回的值被称为返回值。函数返回的值是通过return语句执行。返回值能够让我们直接得到函数处理的结果，而不必关心函数内部复杂繁重的运算过程，大大提高了编程效率。

本关的主要目标是让读者了解并掌握函数返回值的相关知识。

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

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

def f():  
    return 1,'abc','1234'
print(f())  
输出结果：

(1, 'abc', '1234')

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

将函数作为返回值
我们除了可以将各种类型的值作为返回值外，也可以将函数作为返回值。

例如，我们要定义一个函数来求列表中数值元素的和，一般情况下我们是这样定义的：

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时，才真正计算求和的结果：

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

15

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

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

如果您想了解更多有关列表操作知识，请参考:【美】Eric Matthes著《Python编程——从入门到实践》第八章。

第3关：函数的使用范围：Python作用域

#coding=utf-8

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

# 请在此添加代码，求两个正整数的最小公倍数
#********** Begin *********#
def lcm(a,b):
    if a>b:
        k=b
    else:
        k=a
    for i in range(k,a*b+1,k):
        if i%a==0 and i%b==0:
            return i
#********** End **********#

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

任务描述
函数是有使用范围的，在一个模块中，我们可以定义很多函数和变量，但我们希望有的函数和变量别人可以使用，有的函数和变量仅仅可以在模块内部使用。这就是Python作用域的相关问题。

本关的目标就是让读者了解并掌握函数的使用范围，即Python作用域的相关知识。

相关知识
在Python中，正常的函数和变量名是公开的（public），都是可以被直接引用的，比如：abs()、abc、dir()等。

类似__xxx__这种格式的变量是特殊变量，允许被直接引用，但是会被用作特殊用途，比如__author__、__name__就是属于特殊变量。hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己编程定义的变量一般不会用这种变量名。

类似_xxx和__xxx这种格式的函数和变量就是非公开的（private），不应该被直接引用。

补充：_xxx的函数和变量是protected，我们直接从外部访问不会产生异常。__xxx的函数和变量是private，我们直接从外部访问会报异常，我们要注意前缀符号的区别。

我们要注意用词的区别，我们说的是private函数和变量是“不应该”被直接引用，而不是“不能”被直接引用，这是因为在Python中并没有一种方法可以真正完全限制访问private函数或变量。但是我们为了养成良好的编程习惯，是不应该引用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()函数，读者并不需要知道greeting()函数中的内部实现细节。所以我们可以将内部逻辑用private函数隐藏起来。这是一种十分常用的代码封装的方法。

小结：为了让程序的封装性更好，我们一般都限定函数的使用范围，一般我们把外部需要使用的函数定义为public函数，而把只在内部使用，而外部不需要引用的函数定义成private函数。

编程要求
本关的编程任务是补全src/step3/scope.py文件的代码，实现相应的功能。具体要求如下：

编写程序，功能是求两个正整数的最小公倍数；
要求实现方法：先定义一个private函数 _gcd()求两个正整数的最大公约数，再定义public函数lcm()调用 _gcd()函数求两个正整数的最小公倍数；
调用函数lcm()，并将输入的两个正整数的最小公倍数输出。
本关涉及的代码文件src/step3/scope.py的代码框架如下：

#coding=utf-8
# 输入两个正整数a,b  
a = int(input())  
b = int(input())
# 请在此添加代码，求两个正整数的最小公倍数  
#********** Begin *********#
#********** End **********#
# 调用函数，并输出a,b的最小公倍数  
print(lcm(a,b))