抽象

• 编写一小段代码来计算裴波那契数列:
  

  fibs = [0, 1]
  for i in range(8):
  fibs.append(fibs[-2] + fibs[-1])
  print fibs
  

创建函数

• 函数是可以调用(可能包含参数)，他它执行某种行为并且返回一个值。一般来说，内建的callable函数可以用来判断函数是否可以调用:
  

  >>>import math
  >>>x = 1
  >>>y = math.sqrt
  >>>callable(x)
  False
  >>>callable(y)
  True
  

• 使用def语句定义函数
  

  def hello(name):
  return 'Hello, ' + name + '!'
  >>>print hello('world')
  Hello, world!
  >>>print hello('Gumby')
  Hello, Gumby!
  

• 编写返回裴波那契数列的函数:
  

  def fibs(num):
  result = [0, 1]
  for i in range(num - 2):
  result.append(result[-2] + result[-1])
  return result
  

记录函数

• 文档字符串: 如果在函数的开头写下字符串，它就会作为函数的一部分进行存储，这称为文档字符串。
  

  def square(x):
  'Calculates the square of the number x.'
  return x * x
  >>>print square.__doc__
  'Calculates the square of the number x.'
  

  __doc__是函数属性
  

• 内建的help函数
  

  def square(x):
  'Calculates the square of number x.'
  return x * x
  help(square)
  Help on function square in module __main__:
  square(x)
  Calculates the square of x.
  (END)
  

• 如果参数不可变，又要改变参数:
  

  1. 从函数中返回所需要修改的值，如果值多于一个的话就以元组的形式返回
     

  2. 如果真的想改变参数，那么可以使用一点小技巧，即将值放置在列表中
     

关键字参数和默认值

• 这类使用参数名提供的参数叫做关键字参数。它的主要作用在于可以明确每个参数的作用，也就避免了下面这样奇怪的函数调用:
  

  def hello(greeting, name):
  print greeting + ', ' + name
  hello('Hello', 'world')
  hello(greeting = 'Hello', name = 'world')
  hello(name = 'world', greeting = 'Hello')
  

• 关键字参数最厉害的地方在于可以在函数中给参数提供默认值:
  def hello(greeting = 'Hello', name = 'world'):print greeting + ', ' + name + '!'

  hello()
  

收集参数

• 星号(*)的意思就是"收集其余的位置参数"。如果不提供任何供收集的元素，params就是一个空元组
  

  def print_params(*params):
  print params
  print_params()
  print_params('Testing')
  print_params(1, 2, 3)
  $./test.py
  ()
  ('Testing', )
  (1, 2, 3)
  def print_params(title, *params):
  print title
  print params
  print_params('Params:', 1, 2, 3)
  $./test.py
  Params:
  (1, 2, 3)
  

• 星号(*)不能处理关键字参数
  

• 双星号(**)能处理关键字参数
  

反转过程

• 分配参数在"另一端"。使用*运算符就简单了--不过是在调用而不是定义时使用:
  

  def add(x, y):
  return x + y
  params = (1, 2)
  print add(*params)
  $./test.py
  3
  

作用域

• 变量和所对应的值用的是个"不可见"的字典。内建的vars函数可以返回这个字典:
  

  >>>x = 1
  >>>scope = vars()
  >>>scope['x']
  1
  >>>scope['x'] += 1
  >>>x
  2
  

• 这个"不可见字典"叫做命名空间或作用域。
  

• 在函数内全局变量的使用:
  

  def combine(parameter):
  print parameter + globals()['parameter']
  combine(2)
  $./test.py
  3
  

• 如果在函数内部将值赋予一个变量，它会自动成为局部变量--除非告知python将其声明为全局变量
  

  x = 1
  def change_global():
  global x
  x = x + 1
  change_global()
  print x
  $./test.py
  2
  

• python很奇葩，函数是可以嵌套的。
  

递归

• 自己引用(或调用)自身。
  

• 一个让程序崩溃的函数
  

  def recursion():
  return recursion()
  

  这个递归叫做无穷递归。
  

两个经典: 阶乘和幂

• 计算数n的阶乘:
  

  1. 使用循环:
     

     def factorial(n):
     result = n
     for i in range(1, n):
     result *= i
     return result
     

  2. 使用递归:
     

     def factorial(n):
     if n <= 1:
     return 1
     else:
     return n * factorial(n - 1)
     

• 幂
  

  1. 使用循环:
     

     def power(x, n):
     result = 1
     for i in range(n):
     result *= x
     return result
     

  2. 使用递归:
     

     def power(x, n):
     if n == 0:
     return 1
     else:
     return x * power(x, n - 1)
     

另一个经典: 二元查找

• 二元搜索

  def b_search(seq, number, low, hi):if low == hi:assert number == seq[hi] #只有条件为真，程序才能正常活动return hielse:mid = (low + hi) // 2if number > seq[mid]:return b_search(seq, number, mid + 1, hi)else:return b_search(seq, number, low, mid - 1)

新函数

函数 & 描述 \\
map(func, seq [, seq, ...]) & 对列表中的每个元素应用函数 \\
filter(func, seq) & 返回其函数为真的元素的列表 \\
reduce(func, seq [, initial]) & 等同于func(func(func(seq[0], seq[1]), seq[2]), ...) \\
sum(seq) & 返回seq中所有元素的和 \\
apply(func[, args[, kwargs]]) & 调用函数，可以提供参数 \\