一、调用内置函数

  1. 官方文档查看函数

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

二、自定义函数

  1. 定义一个函数
  1. def my_abs(x):
  2.     if x >= 0:
  3.         return x
  4.     else:
  5.         return -x
  7. #调用
  8. my_abs(12)
  1. 参数检查
  • 数据类型检查可以用内置函数isinstance()实现：
  1. def my_abs(x):
  2.     if not isinstance(x, (int, float)):
  3.         raise TypeError('bad operand type')
  4.     if x >= 0:
  5.         return x
  6.     else:
  7.         return -x
  1. 默认参数
  • 注意：默认参数必须指向不变对象！
  1. def power(x, n=2):
  2.     s = 1
  3.     while n > 0:
  4.         n = n - 1
  5.         s = s * x
  6.     return s
  8. #调用时
  9. power(2)  #实际是调用power(2,2)
  1. 可变参数
  1. # 可变参数
  2. #定义可变参数需要在参数前加*符号
  3. def calc(*numbers):
  4.     sum = 0
  5.     for n in numbers:
  6.         sum = sum + n * n
  7.     return sum
  9. #已经有一个list或者tuple，要调用一个可变参数
  10. a=[1,2,3]
  11. #方法一，可以单独取出list或tuple中的元素传入
  12. calc(a[0],a[1],a[2])
  13. #方法二 在变量前加符号*； *a表示把a这个list的所有元素作为可变参数传进去。
  14. calc(*a)
  1. 关键字参数
  • 关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
  • 关键字参数,它可以扩展函数的功能
  1. # 关键字参数
  2. def person(name, age, **kw):
  3.     print('name:', name, 'age:', age, 'other:', kw)
  6. person("张三", 18, weight=40)
  8. #先组装好一个dict;当作关键字参数传入
  9. extra = {'city': 'Beijing', 'job': 'Engineer'}
  10. #可以一个个单独传入
  11. person('Jack', 24, city=extra['city'], job=extra['job'])
  12. #也可以使用**符号标志位关键参数传入； **extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意
  13. # kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
  14. person('Jack', 24, **extra)
  1. 命名关键参数
  • 命名关键字参数必须传入参数名
  • 命名关键字参数可以有缺省值
  • 用于限制用户输入的关键参数
  1. # 命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
  2. def person(name, age, *, city, job):
  3.     print(name, age, city, job)
  8. # 已经有了可变参数，那么后边的参数会被识别为命名关键参数；不需要再使用特殊分隔符*标识
  9. def person(name, age, *args, city, job):
  10.     print(name, age, city, job)
  13. # 调用
  14. person("abc",20,city="123",job="123")
  1. 参数组合
  • 参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

三、递归函数

  1. 简单的递归函数;计算阶乘
  1. def fact(n):
  2.     if n == 1:
  3.         return 1
  4.     return n * fact(n - 1)
  1. 解决递归调用栈溢出的方法是通过尾递归优化; 主要是要把每一步的乘积传入到递归函数中：
  1. def fact_iter(num, product=1):
  2.     if num == 1:
  3.         return product
  4.     return fact_iter(num - 1, num * product)
  1. 递归的优缺点
  • 使用递归函数的优点是逻辑简单清晰
  • 缺点是过深的调用会导致栈溢出。