系统学习编程笔记（十六）

• 完成 Python 教程。

4.   函数

• 定义函数时，需要确定函数名和参数个数；
• 如果有必要，可以先对参数的数据类型做检查；
• 函数体内部可以用return随时返回函数结果；
• 函数执行完毕也没有return语句时，自动return None。
• 函数可以同时返回多个值，但其实就是一个tuple。

• 请定义一个函数quadratic(a, b, c)，接收3个参数，返回一元二次方程：

  ax2 + bx + c = 0

  的两个解。

def quadratic(a, b, c):
    for i in (a, b, c):
        if not (isinstance(i, (int, float))):
            raise TypeError('bad operand type')
    if a == 0:
        return -c / b
    delta = b**2 - 4 * a * c
    if delta < 0:
        return '方程无实数根，但有2个共轭复根'
    x1 = (-b + math.sqrt(delta))/(2 * a)
    x2 = (-b - math.sqrt(delta))/(2 * a)
    if delta > 0:
        return x1, x2
    if delta == 0:
        return x1

• 使用默认参数有什么好处？最大的好处是能降低调用函数的难度。
• 定义默认参数要牢记一点：默认参数必须指向不变对象！

• #定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。
  def calc(*numbers):
      sum = 0
      for n in numbers:
          sum = sum + n * n
      return sum

   *nums表示把nums这个list的所有元素作为可变参数传进去。

• #关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：
  def person(name, age, **kw):
      print('name:', name, 'age:', age, 'other:', kw)
  
  #调用
  person('Adam', 45, gender='M', job='Engineer')
  
  >>> extra = {'city': 'Beijing', 'job': 'Engineer'}
  >>> person('Jack', 24, **extra)
  name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

  关键字参数有什么用？它可以扩展函数的功能。**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

• #如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
  
  def person(name, age, *, city, job):
      print(name, age, city, job)
  
  #如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
  def person(name, age, *args, city, job):
      print(name, age, args, city, job)
  
  #命名关键字参数必须传入参数名，这和位置参数不同。

  参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。 

 

• 使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
• 递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
• 使用递归函数需要注意防止栈溢出。
• 解决递归调用栈溢出的方法是通过尾递归优化，尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

• def fact(n):
      if n==1:
          return 1
      return n * fact(n - 1)
  
  #改造成尾递归方式
  
  def fact(n):
      return fact_iter(n, 1)
  
  def fact_iter(num, product):
      if num == 1:
          return product
      return fact_iter(num - 1, num * product)

• 练习：汉诺塔的移动可以用递归函数非常简单地实现。

  def move(n,a,b,c):
      if n == 1:
          print(a,'-->',c)
          return
      move(n-1,a,c,b)
      move(1,a,b,c)
      move(n-1,b,a,c)