Python函数结构

1.函数参数

（1）必选参数

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

（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）可变参数

#定义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。

（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}

#定义一个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的方法，可以大大提高参数传递的效率。

2.函数的返回值

(1)将值作为返回值

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

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

输出结果：

(1, 'abc', '1234')

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

(2)将函数作为返回值

当我们调用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）”。

3.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函数。