Python之函数

    1. 调用函数

Python内置了很多有用的函数，我们可以直接调用

要调用一个函数，需要知道函数名称和参数，比如求绝对值的函数abs，只有一个参数。

https://docs.python.org/3/library/functions.html#abs

也可以在交互式命令行通过help（abs）查看abs函数的帮助信息

调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，并且Python会明确的告诉你：abs()有且仅有1个参数

如果传入的参数数量是对的，但参数类型不能被接受也会报typeError的错误，并且给出错误信息

数据类型转换：

函数名其实就是指向一个函数对象的引用，完全可以把函数名符给一个变量，相当于给这个函数起了一个别名

2. 定义函数

在Python中，定义一个函数要使用def语句，依次写出函数名，括号，括号中的参数和冒号：然后在缩进块中编写函数体，函数返回值用return语句返回：

def my_abs(x):
    if x>=0:
        return x
    else:
        return -x

空函数：

如果定义一个什么也不做的函数，可以用pass语句：

def nop():
    pass

pass也可以当做占位符来使用

参数检查：

调用函数时，如果参数不对，Python解释器会自动检查出来，并抛出TypeError

但是如果参数类型不对，Python解释器就无法帮我们检查。需要我们自己在函数里实现：

def my_abs(x):

    ifnot isinstance(x,(int,float)):

       raise TypeError('bad operand type')

    ifx>=0:

       return x

   else:

       return -x

Python的函数返回多值其实就是返回一个tuple. 在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值.

Practice:

定义一个函数quadratic(a,b,c)接收3个参数返回一元二次方程：ax2 + bx + c = 0 的来两个解

import math

def quadratic(a,b,c):

    ifb**2-4*a*c<0:

       return 'No answer'

   else:

       x1=((-b)+math.sqrt(b*b-4*a*c)/(2*a))

       x2=((-b)-math.sqrt(b*b-4*a*c)/(2*a))

       return x1,x2

while True:

   a=input("a:")

   b=input("b:")

   c=input("c:")

   print(a+"x2+"+b+"x+"+c+"=0\n",quadratic(int(a),int(b),int(c)))

3.函数的参数

     位置参数：

计算X2的函数：

>>> defpower(x):

 return x*x

>>> power(5)

25

对于power(x)函数，参数x就是一个位置参数，当我们调用power函数时，必须传入有且仅有的一个参数x:

当我们想要计算x的多次幂次方时我们需要增加一个参数来实现

>>> defpower(x,n):

 s=1

 while n>0:

  n=n-1

  s=s*x

 return s

>>> power(9,3)

729

>>> power(3,3)

27

>>>

修改后的power(x,n)有两个参数：x和n,这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n

默认参数：

新的power(x, n)函数定义没有问题，但是，旧的调用代码失败了，原因是我们增加了一个参数，导致旧的代码因为缺少一个参数而无法正常调用,这个时候，默认参数就排上用场了。由于我们经常计算x2，所以，完全可以把第二个参数n的默认值设定为2：

>>> defpower(x,n=2):

 s=1

 while n>0:

  n=n-1

  s=s*x

 return s

>>> power(6)

36

>>> power(6,2)

36

>>>

默认参数可以简化参数的调用，设置默认参数时需要注意的几点：

1. 必须参数在前，默认参数在后，否则Python的解释器会报错

2. 当函数有多个参数时，把变化大的参数放在前面，变化小的参数放在后面，变化小的参数可以作为默认参数

使用默认参数最大的好处就是可以降低调用函数的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现，无论是简单调用还是复杂调用，函数只需要定义一个。

有多个默认参数时，调用的时候既可以按照顺序提供部分默认参数，也可以不按顺序。

定义默认参数时必须牢记一点：默认参数必须指向不变的对象

为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

可变参数：

在Python函数中，还可以定义可变参数，即传入的参数个数是可变的，可以是1，2，任意个或者0个。

定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：

>>> defcalc(*numbers):

 sum =0

 for n in numbers:

  sum = sum +n*n

 return sum

>>>calc(1,2,3)

14

>>>calc(2,4,5,7,8)

158

>>>

关键字参数：

关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

关键字参数允许传入0个或者任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

>>> defperson(name, age, **kw):

 print('name:',name, 'age:', 'other:', kw)

 

>>>person('Alice', 23)

name: Alice age: other:{}

>>>person('Johnny', 26, boyfirend='Timmy')

name: Johnny age:other: {'boyfirend': 'Timmy'}

>>>person('Timmy', 26, BF='Johnny', fans='baobao')

name: Timmy age: other:{'BF': 'Johnny', 'fans': 'baobao'}

>>>

命名关键字参数：

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数，至于到底传入了哪些，就需要在函数内部通过kw检查。

如果要限制关键字参数的名字，就可以用命名关键字参数，例如只接收city和job作为关键字参数：

>>> defperson(name, age, * , city, job):

 print(name, age,city, job)

 

>>>person('Orao', 24, city='Xian', job='Engineer')

Orao 24 Xian Engineer

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*

参数组合：

在Python中定义函数，可以用必选参数，默认参数，可变参数，关键字参数和命名关键字参数，这5种参数都可以组合使用，但参数定义的顺序必须是：必选参数，默认参数，可变参数，命名关键字参数和关键字参数。

虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

总结：

1. Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数

2. 默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误

3. 注意定义可变参数和关键字参数的语法：

   *args 是可变参数，args接收的是一个tuple

  **kw是关键字参数，kw接收的是一个dict

4. 调用函数时传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1,2,3)又可以先组装成list或tuple,再通过*args传入func(*(1,2,3));

 关键字参数既可以直接传入：func(a=1,b=2) 又可以先组装dict，再通过**kw传入： func(**{'a':1, 'b':2})

5. 命名的关键字参数是为了限制调用者可以传入的参数名，同时提供默认值

6. 定义命名的关键字参数子啊没有可变参数的情况下不要忘记写分隔符*，否则定义的将是位置参数

Practice: 让一个函数可以接收一个或者多个数并计算乘积：

>>> defproduct(*numbers):

 num=1

 for n in numbers:

  num = num*n

 return num

>>>product(4,5)

20

4. 递归函数



如果一个函数在内部调用自身本身，这个函数就是递归函数

>>> deffact(n):

 if n==1:

  return 1

 returnn*fact(n-1)

>>> fact(5)

120

递归函数的优点就是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

Practice：汉诺塔的移动

编写move(n,a,b,c)函数，它接收参数n，表示3个柱子A,B,C中第1个柱子A的盘子数量，然后打印出把所有盘子从A借助B移动到C的方法：

>>> defmove(n,a,b,c):

 if n==1:

  print(a,'--->',c)

 else:

  move(n-1,a,c,b)  //把n-1个盘从a杆移动到b杆

  move(1,a,b,c)     //把最大的那个盘从a移动到c

  move(n-1,b,a,c) //把剩下的n-1个盘从b移动到c

  

>>>move(2,'A','B','C')

A ---> B

A ---> C

B ---> C

>>>move(3,'A','B','C')

A ---> C

A ---> B

C ---> B

A ---> C

B ---> A

B ---> C

A ---> C

>>>