《python基础教程》要点（六）：抽象

（一）创建函数：

1、内建的callable函数可以用来判断函数是否可调用：

（Python 2.7.4）

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

【注意】函数callable在Python 3.0中不再可用，需要使用表达式hasattr（func._call_）代替。有关hasattr更多信息，参见第7章。

2、使用def（或“函数定义”）语句创建函数：

如：返回斐波那契数列的函数：

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

>>> fibs(10)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
>>> fibs(5)
[0, 1, 1, 2, 3]
>>> 

3、记录函数：在函数开头写下字符串，它会作为函数的一部分进行存储，这称为文档字符串。

文档字符串可以按输入myfuction._doc_方式访问，但是读者发现在Python 2.7.4只有myfuction.func_doc能行：

 def myf():
    'i want this function return two character showing welcome'
    return "你好"

>>> print myf()
你好
>>> myf._doc_

Traceback (most recent call last):
  File "<pyshell#21>", line 1, in <module>
    myf._doc_
AttributeError: 'function' object has no attribute '_doc_'
>>> myf.func_doc
'i want this function return two character showing welcome'
>>> 

 【注意】_doc_是函数属性，详细看第7章。属性名下的双划线表示它是个特殊属性，详细看第9章。

4、内建help函数，在交互式解释器中使用，就可以得到关于函数、包括它的文档字符串的信息：

>>> def myf():
     'i want this function return two character showing welcome'
     return "你好"

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

myf()
    i want this function return two character showing welcome

>>> import math
>>> help(math.sqrt)
Help on built-in function sqrt in module math:

sqrt(...)
    sqrt(x)
    
    Return the square root of x.

（二）参数魔法

1、在函数内为参数赋予新值不会改变外部任何变量的值。

【注意】参数存储在局部作用域（local scope）内。

 2、字符串（以及数字和元组）是不可变的，即无法被修改（也就是说，只能用新的值覆盖）。所以它们做参数的时候也就无需多做介绍。

　　但是如果将可变的数据结构，如列表，作为参数的时候，会发生：参数被改变了。

>>> names = ['aaa','bbb']
>>> n = names
>>> n[0] = 'new'
>>> names
['new', 'bbb']

>>> names2 = ['aaa','bbb']
>>> n2 = names2[:]
>>> #现在n2和names2包含两个独立（不同）的列表，其值相等：
>>> n2 is names2
False
>>> n2 == names2
True
>>> #如果现在改变n2，就不会影响到names2了：
>>> n2[0] = 'new'
>>> n2
['new', 'bbb']
>>> names2
['aaa', 'bbb']

3、初始化数据结构的函数：

>>> def init(data):  #把初始化代码放到函数中
    data['first'] = {}
    data['middle'] = {}
    data['last'] = {}

    
>>> #使用：
>>> s = {}
>>> init(s)
>>> s
{'middle': {}, 'last': {}, 'first': {}}

 【注意】字典的键并没有具体顺序，每次在解释器中打印的顺序可能不同。

4、如果参数不可变，比如数字，想要改变值，只能从函数中返回你要的值了（多的话用元组返回）：

>>> def addself(x):
    return x + 1

>>> y = 1
>>> y = addself(y) #赋值为使用addself函数后返回的值
>>> y
2

【小技巧】如果真想改变参数，那么可以将值放在在列表中：

>>> def addself(x): #无需返回值哦
    x[0] = x[0] + 1

    
>>> y = [1]      #将值放在列表中
>>> addself(y)   #这样代码看起来比较清新
>>> y
[2] 

 5、关键字参数和默认值

目前为止我们使用的参数都叫位置参数。

关键字参数：可以明确每个参数的作用，避免参数多的时候很难记住参数的顺序。

>>> def myf(greet,name):
    print "%s,%s" % (greet,name)

    
>>> myf('hello','lisa')
hello,lisa
>>> myf(greet = 'hi',name = 'linda')
hi,linda

最厉害的是，可以在函数中给参数提供默认值。如果参数具有默认值，调用的时候，你可以不提供参数、提供一些或提供所有。

>>> def wel(greet = 'what',name = 'who'):
    print '%s,%s' % (greet,name)

    
>>> wel()
what,who
>>> wel(name = 'Elizabeth')
what,Elizabeth
>>> wel('hah')
hah,who

位置参数和关键字参数可以联合使用，但要把位置参数放在前面。不然，解释器会不知道它们到底谁是谁（也就是它们应该处的位置）。

【注意】除非完全清楚程序的功能和参数的意义，否则避免混合使用位置参数和关键字参数。

6、收集参数

让用户提供任意数量的参数。

*：参数前的星号将所有值放在同一个元组中，如果有普通参数在前，星号的意思就是“收集其余位置的参数”（除了关键字的参数）。

**：处理关键字参数的“收集”操作。放在字典里，而不是元组。

>>> def print_params(x,y,z = 3,*pospar,**keypar):
    print x,y,z
    print pospar
    print keypar

    
>>> print_params(1,2,3,7,8,9,foo = 1,bar = 2)
1 2 3
(7, 8, 9)
{'foo': 1, 'bar': 2}

7、反转过程

使用*和**可以收集参数，放进元组和字典里，供函数使用。也可以执行相反的操作，将收集好的元组或字典里的参数通过*或**传进函数。

【注意】operator模块中包含此函数的效率更高版本。

使用*：

>>> def add(x,y):
    return x + y

>>> params = (1,2)
>>> add(*params)
3

 使用**：

>>> def hello(name,sex):
    print name + ' is a '+ sex

>>> params = {'name':'one','sex':'girl'}    
>>> hello(**params)
one is a girl

星号只在定义函数（允许使用不定数目的参数）或者调用“分隔”字典或序列时才有用：

>>> def wit(**k):    #在定义中使用星号
    print k['name'],' is',k['age'],' years old.'

    
>>> def nwit(k):     #在定义中不使用星号
    print k['name'],' is',k['age'],' years old.'

    
>>> args = {'name':'one','age':'36'}
>>> wit(**args)      #在使用中使用星号
one  is 36  years old.
>>> nwit(args)       #在使用中不使用星号
one  is 36  years old.
>>>                  #效果一样

（三）作用域

1、在执行 x = 1 后，名称 x 引用到值 1 。就像字典一样。当然，变量和所对应的值用的是个“不可见”的字典，叫做命名空间或者作用域。内建的vars函数可以返回这个作用域：

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

每个函数调用都会创建一个新的作用域。

函数内的变量被称为局部变量（local variable）。

>>> def myf():
    x = 32

    
>>> x = 1
>>> myf()
>>> x
1

这里 myf函数改变（重绑定）了变量 x ，但是调用myf的时候创建了新的命名空间，x = 32只在内部作用域（局部命名空间）其作用，没有影响到全局作用域的x。

【屏蔽（Shadowing）的问题】

同名的话，全局变量会被局部变量屏蔽，但是可以使用globals函数获取全局变量值，该函数的近亲是vars，它可以返回全局变量的字典：

>>> param = "哈哈"
>>> def myf(param):
    print param + globals()['param']

    
>>> myf('paramfrommyf')
paramfrommyf哈哈

使用globals函数，重绑定全局变量（使变量引用其他新值）：

>>> x = 1
>>> def change():
    global x
    x = x+1

    
>>> change()
>>> x
2

2、嵌套作用域

突出应用是，例如需要用一个函数“创建”另一个。详细见105页，不常用吧。

（四）递归

1、recursion：see recursion.

有用的递归函数包含：

（1）当函数直接返回值时有基本实例（最小可能性问题）。

（2）递归实例，包括一个或者多个问题最小部分的递归调用。

关键就是将问题分解为小部分。

经典应用：阶乘、幂、二分查找。

2、函数到处放

Python对“函数式编程”方面有一些有用的函数：map、filter和reduce函数（Python3.0中这些都被移至functools模块中）。filter函数可以基于一个返回布尔值的函数都会元素进行过滤。

>>> map(str,range(10))
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

>>> def func(x):
    return x.isalnum()

>>> seq = ['aaa','x35','?!','***','&%$#']
>>> filter(func,seq)
['aaa', 'x35']

还有个叫做lambda表达式的特性，可以创建短小的函数。

>>> filter(lambda x:x.isalnum(),seq)
['aaa', 'x35']

貌似都不常用。