开始Python -- 抽象化（1）

1、创建自己的函数
l Callable()函数：检查是否可以调用

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

l 创建函数：用def关键字定义，用return语句返回结果

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

（1） 函数Doc
l 函数开始处的一个String（称为docstring）

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

l 使用help()函数显示函数Doc

>>> help(square)
Help on function square in module __main__:

square(x)
Calculates the square of the number x.

（2） keyword参数和缺省值
l 函数的参数在调用时是有顺序的，但使用keyword参数不用关心顺序问题：

>>> def hello_1(greeting, name): print '%s, %s!' % (greeting, name)
>>> hello_1(name='world', greeting='Hello')
Hello, world!

l 在创建函数时可以为参数指定缺省值：

def hello_3(greeting='Hello', name='world'): print '%s, %s!' % (greeting, name)

l 下面各种调用的情况：

>>> hello_3()
Hello, world!
>>> hello_3('Greetings')
Greetings, world!
>>> hello_3('Greetings', 'universe')
Greetings, universe!

l 如果只使用greeting的缺省值，可以使用keyword参数：

>>> hello_3(name='Gumby')
Hello, Gumby!

l 可以混合使用必选参数和带缺省值的参数，但前者必须放在最前面：

>>> def hello_4(name, greeting='Hello', punctuation='!'):
... print '%s, %s%s' % (greeting, name, punctuation)

（3） 集合参数
l 在参数前面加“*”，表示调用时其后的值放到Tuple中

>>> def print_params_2(title, *params):
... print title,
... print params
>>> print_params_2('Params:', 1, 2, 3)
Params: (1, 2, 3)

l Tuple集合参数不能使用keyword参数：

>>> print_params_2('Hmm...', something=42)
Traceback (most recent call last):
File "<interactive input>", line 1, in ?
TypeError: print_params_2() got an unexpected keyword argument 'something'

l 可以使用Dictionary集合参数（在参数前面加“**”）

>>> def print_params_3(title, **params):
... print title,
... print params
>>> print_params_3('Hmm...', something=42)
Hmm... {'something': 42}

l “*”、“**”的逆向使用：

>>> params = ('Sir Robin', 'Well met')
>>> hello_3(*params)
Sir Robin, Well met!
>>> params = {'name': 'Sir Robin', 'greeting': 'Well met'}
>>> hello_3(**params)
Well met, Sir Robin!

2、范围（或者namespace）
l 除了全局范围之外，每个函数的调用都会创建一个范围，vars()函数返回当前范围中所有的变量及其值的Dictionary：

>>> def foo():
... x = 42
... print vars()
...
>>> x = 1
>>> foo()
{'x': 42}
>>> vars()
{'__builtins__': <module '__builtin__' (built-in)>, 'pywin': <module 'pywin' from 'D:/workshop/Python24/Lib/site-packages/pythonwin/pywin/__init__.pyc'>, 'x': 1, '__name__': '__main__', 'foo': <function foo at 0x00FF5BB0>, '__doc__': None}

l 当函数中的变量和全局变量同名时，可以使用globals()函数（返回Dictionary）来访问全局变量：

>>> def combine(parameter):
print parameter + globals()['parameter']
...
>>> parameter = 'berry'
>>> combine('Shrub')
Shrubberry

3、有用的函数
（1） map
l LAMBDA表达式：以关键字lambda开始，后面跟参数，然后是“:”，最后是表达式

lambda x, y, z: x + y + z

l map()：通过指定函数应用到每个元素，将一个Sequence映射成另一个Sequence

>>> numbers = [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33]
>>> map(lambda n: 2*n, numbers)
[144, 202, 216, 216, 222, 88, 64, 238, 222, 228, 216, 200, 66]

l 由于String是字符Sequence，可以直接使用，但要注意返回的是List

>>> map(ord, 'Hello, world!')
[72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33]

（2） filter
l filter()：通过指定函数应用到每个元素，将一个Sequence符合的元素组成另一个Sequence

>>> numbers = [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33]
>>> filter(lambda n: n % 2 == 0, numbers)
[72, 108, 108, 44, 32, 114, 108, 100]

l 使用List包含可以实现map()和flter()的相同功能：

>>> [chr(n) for n in numbers] # characters corresponding to numbers
['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!']
>>> [n for n in numbers if n % 2 == 0] # filters out the odd numbers
[72, 108, 108, 44, 32, 114, 108, 100]

（3） reduce
l reduce()：使用Sequence中开始的两个元素调用指定的函数，然后用结果和第3个元素调用指定的函数，依次类推到最后的元素，最后返回结果值
l 典型的例子是求和：

>>> numbers = [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33]
>>> reduce(lambda x, y: x+y, numbers)
1161