# 函数的参数 定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就算完成了。 对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了 函数内政部的复杂逻辑被封装起来，调用者无需了解。 python的函数定义非常简单，单灵活度却非常大。除了正常定义的必选参数外， 还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数 还可以简化调用者的代码。 一、位置参数 我们先写一个计算x的平方的函数 def power(x): return x * x 对于power(x)函数，参数想就是一个位置参数。当我们调用power函数时，必须传入有且仅有的一个参数x >>> power(5) 25 >>> power(15) 225 >>> power(125) 15625 那么，如果我们现在要计算x的立方怎么办？可以再定义一个power3函数，但是如果要计算x的四次方，五次方怎么办？ 假设x的n次方，可以把x和n都设为参数 def powerful(x, n): result = 1 if n == 0: return result elif n > 0: while n >= 1: result = result * x n-=1 return result elif n < 0: while n >= 1: result = result * x result = 1 / result return result 对于这个修改后的powerful(x, n)函数，可以计算任意N次方 修改后的powerful(x, n)函数有两个参数，x和n，这两个参数都是位置参数，调用函数时，传入的两个值 按照位置顺序一次赋给参数x和n 二、默认参数 如果我们经常计算x的平方，那么我们完全可以把第二个参数的默认值设定为2 def powerful(x, n = 2): result = 1 if n == 0: return result elif n > 0: while n >= 1: result = result * x n-=1 return result elif n < 0: while n >= 1: result = result * x result = 1 / result return result >>> powerful(5) 25 >>> powerful(5,3) 125 这样如果我们给n赋值，n就会成为被赋的值，如果不给n赋值，默认就是n=2，默认计算平方。 从以上的例子可以看出，默认参数可以简化函数的调用。 设置默认参数时，有几点问题需要注意： 一是必选参数在前，默认参数在后，否则python的解释器会报错。 二是如何设置默认参数。 当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。 变化小的参数就可以作为默认参数。使用默认参数最大的好处就是能够降低使用函数的难度。 举个例子，我们写一个小学一年级学生注册的函数，需要传入name和gender两个参数 def enroll(name, gender): print("name:", name) print("gender:", gender) 这样，调用enroll()函数只需要传入两个参数 >>> enroll("Sarah", "F") name: Sarah gender: F 如果要继续传入年龄，城市信息怎么办？ 我们如果规定一大堆位置参数，会使得调用函数的难度大大增加 因为位置参数需要严格按照位置传入，python默认从左到右给参数赋值，而位置参数一旦增多， 必然会要求函数调用者必须严格按照一定的顺序来，这样会导致出错的概率大大增加。 在本例中，由于年龄、城市信息绝大多数学生是一致的，因此可以设定为默认值 这样，大多数学生注册时不需要提供年龄和城市，只需提供必须的两个参数 只有与默认参数不符的学生才需要提供额外的信息 def enroll(name, gender, age = 6, city = "BeiJing"): print("name:",name) print("gender:",gender) print("age:",age) print("city:",city) >>> enroll("xiaowang", "M") name: xiaowang gender: M age: 6 city: BeiJing >>> enroll("xiaoshitou", "F", 8, "shanghai") name: xiaoshitou gender: F age: 8 city: shanghai >>> enroll("xiaojuzi","F", 12) name: xiaojuzi gender: F age: 12 city: BeiJing >>> enroll("ligoudan","M", city="LA") name: ligoudan gender: M age: 6 city: LA 可见，默认参数降低了函数调用的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现 无论是简单调用还是复杂调用，函数只需要定义一个。 有多个默认参数时，调用的时候，既可以按顺序提供默认参数 比如enroll("Bob","M",7) 意思是, 除了name和gender这两个参数外，最后一个参数应用在age上， city参数由于没有提供，仍然使用默认值。 也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上，相当于指名道姓的给某某赋值 比如调用enroll("Adam", "M", city= "tianjin") 意思是， city参数用穿进去的值，其他默认参数继续使用默认值。 注意：默认参数很有用，但使用不当也会掉坑里。默认参数有个最大的坑，演示如下： 先定义一个函数，传入一个list，添加一个END再返回。 def add_end(L=[]): L.append("END") return L 当你正常调用时，结果似乎不错 >>> add_end([1,2,3]) [1, 2, 3, 'END'] >>> add_end(["anything you want","shuzu","data",1985]) ['anything you want', 'shuzu', 'data', 1985, 'END'] 当时使用默认参数时，一开始的结果也是对的： >>> add_end() ['END'] 但是，当你再次调用时，结果就不对了 >>> add_end() ['END', 'END'] >>> add_end() ['END', 'END', 'END'] 很多人开始疑惑，默认参数是一个空列表[], 但是函数似乎每次都记住了上次添加了“END”后的list 原因解释如下： python函数在定义的时候，默认参数L的值就被计算出来了，即[] 因为默认参数 L 也是一个变量，他指向对象[], 每次调用该函数，如果改变了 L 的内容， 则下次调用时， 默认参数的内容就变了，不再是函数定义时的[]了。 也就是说，如果你的默认参数是一个变量，而这个变量在函数执行的过程中会发生改变，那么 当你下一次重新调用这个函数意图使用函数定义时的默认参数时，就不可能了，因为默认参数已经变了 所以说，默认参数应该是一个固定的值，是大多数情况下不需要修改的值，必须指向不变对象！ 要修改上面的例子，可以用None这个不变对象来实现： def add_end(L = None): if L == None: L = [] L.append("END") return L else: L.append("END") return L 这样，无论调用多少次，都不会有问题，这样传入的参数会先进行判断，如果为空，则创建一个空列表，添加一个END返回 >>> add_end([1,2,3]) [1, 2, 3, 'END'] >>> add_end() ['END'] >>> add_end() ['END'] >>> add_end() ['END'] 为什么要设计str、None这样的不可变对象呢？ 因为不可变对象一旦创建，对象内部的数据就不能修改， 这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取不需要加锁。 同时读取一点问题都没有。 我们在编写程序时，如果可以设计一个不可变对象，那就尽量设计成不变对象。 什么是不可变对象？ 比如你创建一个字符串"李狗蛋"，李狗蛋就是李狗蛋，不能变成其他的，至于你说，可以拆分成"李狗"或"李蛋" 这不是发生了对字符串的更改，而是重新生成了两个字符串"李狗"或"李蛋"，他们与原来字符串"李狗蛋"的关系 仅仅是在原来字符串基础上衍生的新字符串，并没有对原字符串发生更改。 三、可变参数 在python函数中，还可以定义可变参数。 顾名思义，可变参数就是传入的参数个数是可变的，可以是1个，2个，任意个。也可以0个。 我们以数学题为例子： 给定一组数字a, b, c....,请计算a的平方 + b的平方 + c的平方 要定义出这个函数，我们必须确定输入的参数。然而，很悲伤，我们竟不知道有多少参数， 即使知道有多少个，但是总不能在函数定义时全部写出来吧！ 我们可以显而易见的想到一个比较好的方法：把参数用一个列表或者元组传进来，然后遍历，再做运算，听起来不错。 def sum(numbers): sum = 0 for n in numbers: sum = sum + n return sum 但是调用的时候，需要先组装出一个list或者tuple >>> sum([1,2,3,4,5]) 15 还有更好的方法：函数定义时，设置可变参数。同 样可以遍历传入的*numbers def sum(*numbers): sum = 0 for n in numbers: sum += n return sum >>> sum(1,3,5,7) 16 >>> sum() 0 定义可变参数和定义一个list或者tuple参数相比，仅仅在参数前面加了一个 * 号。 在函数内部， 参数number接受到的是一个tuple，因此，函数的代码完全不变。 但是调用该函数时，额可以传入任意个参数，包括0个参数。 着重理解一下：*numbers 在函数内部是一个元组形式，具备元组的一些功能。 如果已经有一个现成的list或者tuple，要调用一个可变参数怎么办？ 可以这样做： >>> nums= [1, 2, 3] >>> sum(nums[0], nums[1], nums[2]) 6 这种写法是可行的，但是相当繁琐。 真正好的方法是在list或者tuple前面加一个 * ，好像一个反运算，又把list或者tuple的元素拆解出来传进去了 >>> sum(*nums) 6 *nums表示把nums这个list的所有元素作为可变参数穿进去。这种写法相当有用，而且很常见。 四、关键字参数 可变参数允许你传入0个或者任意个参数，这些可变参数在函数调用时自动组装成为一个tuple。 但是，你传入的这些不确定个数的参数仅仅是一个值，至于这个值是干什么，什么属性，一切都无从得知 比如传入可变参数[1,3,5,7] 这是可以的，但是你想传入一个x，并且准备让x=9 也就是说你想传成这样的形式[1,3,5,7,x = 9] 这样该怎么办？ 使用关键字参数。 关键字参数允许你传入0个或者任意个含参数名的参数，这些参数可以说有名有姓，有键有值 这些关键字参数在函数内部自动组装为一个dict 还是举小学生注册的例子： def person(name, age, **kwargs): print("name:",name, "age:",age, "other:",kwargs) 函数person出了必选参数name和age外， 还接受关键字参数kwargs 在调用该函数时，可以只传入必选参数 >>> person("stephen curry", 29) name: stephen curry age: 29 other: {} 当然咯，作为一个信息录入的函数，我们也十分喜欢用户传的信息详细些，比如这样 >>> person("stephen curry", 29, gender = "M", tags="the famous basketball star") name: stephen curry age: 29 other: {'gender': 'M', 'tags': 'the famous basketball star'} 所以， 关键字参数有什么用呢？ 它可以扩展函数的功能。 比如，在person函数里，我们保证能接受到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。 试想，你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数 就能满足注册的需求。 当然，也可以先组装一个dict，然后用 ** 分解开传进去 >>> extra = {"reward":"twice mvp of NBA", "hobby":"golf"} >>> person("stephen curry", 29 **extra) name: stephen curry age: 29 other: {'reward': 'twice mvp of NBA', 'hobby': 'golf'} ** extra表示把extra这个dict的所有key-value用关键字参数传入到函数的 **kwargs kwargs将获得一个dict 注意kwargs获得的dict是extra的一份拷贝，对kwargs的改动不会影响函数外的extra。 五、命名关键字参数 对于关键字参数，函数的调用者可以传入任意不收限制的关键字参数，至于到底传入了哪些 就需要在函数内部通过kwargs检查 仍以person为例，我们希望检查时候有city和job参数 def person(name, gender, **kwargs): if "city" in kwargs: print("有city参数传入") if "job" in kwargs: print("有job参数传入") print("name:",name, "gender:",gender, "other:",kwargs) 但是调用者仍然可以传入不受限制的关键字参数 >>> person("stephen curry", "M", hobby="basketball", city="Golden States") 有city参数传入 name: stephen curry gender: M other: {'hobby': 'basketball', 'city': 'Golden States'} 如果要限制关键字参数的名字，就可以用命名关键字参数， 例如，只接收city和job作为关键字参数。 这种方式定义的函数如下： def person(name, age, *, city, job): print(name, age, city, job) 命名关键字参数必须传入参数名，这和位置参数不同。 >>> person("stephen curry",29, city="Colden States",job="basketball") stephen curry 29 Colden States basketball 如果没有传入参数名，调用将报错 >>> person("stephen curry",29,"GS","basketball") Traceback (most recent call last): File "<pyshell#85>", line 1, in <module> person("stephen curry",29,"GS","basketball") TypeError: person() takes 2 positional arguments but 4 were given 由于调用时缺少参数名city和job，python解释器把这4个参数均视为位置参数， 但是person（）函数仅接受了2个位置参数。 正所谓不传不行，不指名也不行。 >>> person("xiaowang",24) Traceback (most recent call last): File "<pyshell#92>", line 1, in <module> person("xiaowang",24) TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job' >>> person("xiaowang",24, "beijing","program") Traceback (most recent call last): File "<pyshell#93>", line 1, in <module> person("xiaowang",24, "beijing","program") TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job' 命名关键字参数可以有缺省值，从而简化调用： def person(name, age, *, city="BeiJing", job): print(name, age, city, job) 由于命名关键字参数city具有默认值，调用时，可不传入city参数。 >>> person("Jack",24,job="Engineer") Jack 24 BeiJing Engineer 使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个 * ，如果缺少 * ， python解释器将无法是被位置参数和命名关键字参数 def person(name, age, city, job): # 缺少 * city和job被视为位置参数 pass 命名关键字参数表示，只接收命名的关键字，多余的不再接受 六、参数组合 在python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。 但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。 比如定义一个函数，包含上述若干种参数： def f1(a, b, c=0, *args, **kwargs): print("a = ", a, "b = ", b, "c = ", c, "args = ", args, "kwargs = ", kwargs) def f2(a, b, c=0, *, d, **kwargs): print("a = ", a, "b = ", b, "c = ", c, "d = ", d, "kwargs = ", kwargs) 在函数调用的时候，python解释器会自动按照参数位置和参数名把对应的参数传进去。 >>> f1(1,2) a = 1 b = 2 c = 0 args = () kwargs = {} >>> f1(1,2,c=3) a = 1 b = 2 c = 3 args = () kwargs = {} >>> f1(1,2,3) a = 1 b = 2 c = 3 args = () kwargs = {} >>> f1(1,2,3,4) a = 1 b = 2 c = 3 args = (4,) kwargs = {} >>> f1(1,2,3,4,5) a = 1 b = 2 c = 3 args = (4, 5) kwargs = {} >>> f1(1,2,3,4,5,6,7) a = 1 b = 2 c = 3 args = (4, 5, 6, 7) kwargs = {} >>> f1(1,2,3,4,5,6,x=10) a = 1 b = 2 c = 3 args = (4, 5, 6) kwargs = {'x': 10} >>> f2(1,2,3, d= 108, extra=None) a = 1 b = 2 c = 3 d = 108 kwargs = {'extra': None} 最神奇的是通过一个tuple和dict，你也可以调用上述函数： >>> f1(*args, **kwargs) a = 1 b = 2 c = 3 args = (4,) kwargs = {'d': 99, 'x': None} >>> f2(*args,**kwargs) a = 1 b = 2 c = 3 d = 99 kwargs = {'tags': 'basketball'} 所以，对于任意函数都可以通过类似func（*args， **kwargs）的形式调用它，因为加入星号*作为参数传入进函数时 就相当于把参数拆解成一个个，如果传入的参数正确，函数会自动进行一一赋值。 总结： python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。 注意：默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误。 注意：定义可变参数和关键字参数的语法 *args是可变参数， args接收的是一个tuple **kwargs 是关键字参数，kwargs接收的是一个dict 注意：调用函数时如何传入可变参数和关键字参数的语法 可变参数既可以直接传入：func（1,2,3），又可以先组装成list或者tuple通过*args传入：func（*（1,2,3）） 关键字参数既可以直接传入：func（a = 1, b = 2）,又可以先组装dict，再通过**kwargs传入：func(**{"a":1,"b":2}) 使用*args 和 **kwargs 是python的习惯写法，当然也可用其他的写法，不过最好用习惯写法。 命名的关键字参数是为了限制调用者可以传入的参数，同时可以提供默认值。 注意：定义命名关键字参数在没有可变参数的情况下不要忘了写分隔符 * ，否则定义的将是位置参数。