《Python基础教程》第六章--读书笔记

摘要：第六章抽象本章会介绍如何将语句组织成函数。关键字参数和默认值目前为止，我们使用的参数都是位置参数，因为它们的位置很重要，事实上比它们的名字更重要。参数前的星号将所有值放置在同一个元祖中。函数内的变量被称为局部变量。

本章会介绍如何将语句组织成函数。还会详细介绍参数（parameter）和作用域（scope）的概念，以及递归的概念及其在程序中的用途。

斐波那契数列：任何一个数都是前两个数之和的数字序列。

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

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

注：函数callable在python3.0中不再可用，需要使用表达式hasattr(func,__call__)代替。
创建斐波那契数列列表的函数：

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

如果想要给函数写文档，让其他使用函数人能理解的话，可以加入注释（以#开头）。

另外一个方式就是直接写上字符串。这类字符串在其他地方可能会非常有用，比如在def语句后面。

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

def square(x):
    "Calculate the square of the number"
    return x*x
>>>square.__doc__
"Calculate the square of the number"

注：__DOC__是函数属性。第七章会介绍更多关于属性的知识。属性名中的双下划线是个特殊属性。这类特殊和“魔法”属性会在第9章讨论。

help内建函数是非常有用的。可以得到关于函数，包括它的文档字符串信息：

Help on function square in module __main__:
 
square(x)
    Calculate the square of the number

数学意义上的函数，总在计算其参数后返回点什么。python有些函数却并不返回任何东西。

python的函数就是函数，即便它从学术上讲并不是函数。没有return语句，或者虽然有return语句，但是return后边乜有跟任何值得函数不返回值：

def test():
    print "this is michael"
    return
    print "this is not"
>>>x = test()
this is michael
>>>x
>>>print x
None

可以看到，return后边的语句被跳过了（类似于循环中的break`语句，不过这里是跳出函数）。

x貌似没东西，但是其实有个很熟悉的值None。所以，所有的函数的确否返回了东西：当不需要它们返回值得时候，它们返回None。看来刚才“有些函数并不是真的是函数”的说法有些不公平了。

函数使用起来简单，创建起来也并不复杂。但函数参数的用法有时候就有些神奇了。

参数错误的话显然会导致失败（一般来说，这时候就要用断言和异常）。

写在def语句中函数名后面的变量通常叫做函数的形参（parameter），而调用函数的时候提供的值是实参（argument）或者成为参数。

def try_to_change(n):
    n = "Mr. Michael"
name = "qq"
try_to_change(name)

具体的工作方式类似这样：

>>>name= "qq"
>>>n = name    #这句的作用基本上等于传参
>>>n = "qq"
>>>name
"michael"

上面的例子中，由于参数是字符串（不可变序列），即无法被修改（也就是说只能用新的值覆盖）。但是，如果将可变的数据结构如列表用作参数的话，那么就有可能改变了。

这里具体例子就不讲了，因为再看《js高级程序设计》时，有相关类似的概念。值传递，引用传递。

使用函数改变数据结构（比如列表或字典）是一种将程序抽象化的好方法。

目前为止，我们使用的参数都是位置参数，因为它们的位置很重要，事实上比它们的名字更重要。

def hello(greeting="hello",name="michael"):
    print "%s,%s"%(greeting,name)
>>>hello("qiuqiu",greeting="hah")
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
      1 def hello(greeting="hello",name="michael",):
      2     print "%s,%s"%(greeting,name)
----> 3 hello("qiuqiu",greeting="hah")
 
TypeError: hello() got multiple values for keyword argument "greeting"

错误的意思，按照我自己的理解就是，为参数greeting赋予了多个值。这时候肯定就会出错了！为什么会这样呢？

位置参数和关键字参数混合使用的情况，位置参数是要放在关键字参数之前的。这里，不是这个原因。

我猜想 位置参数和位置肯定有关系，当使用它时，它会默认赋值给它位置对应的参数，那么，这里就是greeting。所以呢，这里才会赋值两次。做修改：

def hello(name="michael",greeting="hello"):
    print "%s,%s"%(greeting,name)
>>>hello("qiuqiu",greeting="hah")
hah,qiuqiu

默认参数值在函数被定义时已经计算出来，而不是在程序运行时。Python程序员经常犯的一个错误是把可变的数据类型（例如列表或者字典）当做默认参数值。

有些时候可以让用户提供任意数量的参数是很有用的。

def print_params(*params):
    print params

参数前加*，结果打印出来是元祖。参数前的星号将所有值放置在同一个元祖中。可以说是将这些值收集起来。同时，也能和普通参数联合使用：

def print_params2(title,*params):
    print title
    print params
print_params2("test",1,2,3)
test
(1, 2, 3)

星号的意思就是“收集其余的位置参数”。如果不提供任何供收集的元素，params就是个空数组。

print_params2("nothing")  
nothing
()

能不能处理关键字参数呢？

>>>print_params2("humm",something=42)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 1 print_params2("humm",something=42)
 
TypeError: print_params2() got an unexpected keyword argument "something"

使用两个**，能处理关键字参数的“收集操作”。

def print_params3(**params):
    print params
print_params3(x=1,y=2,z=3)
{"y": 2, "x": 1, "z": 3}

返回的是字典而不是元祖了。放在一起看看：

def print_params4(x,y,z=3,*pospar,**keypar):
    print x,y,z
    print pospar
    print keypar
print_params4(1,2,4,"michael",name="michael",age="24")
1 2 4
("michael",)
{"age": "24", "name": "michael"}

如何将参数收集为元祖和字典已经讨论过了，但是事实上，如果使用*和**的话也可以执行相反的操作。看如下例子：

#定义函数
def add(x,y): 
    return x+y

有一个由两个数字组成的元祖：params=(1,2)

此时使用*元算符就简单多了——不过是在调用而不是在定义时使用，作用就相反了！
栗子1：

>>>add(*params)
3

栗子2：

def hello3(greeting="hello",name="world"):
    print "%s,%s"%(greeting,name)
params={"name":"michael","greeting":"well done"}
hello3(**params)
well done,michael    #结果

什么是变量？可以把它们看作是值的名字。在执行x=1赋值语句后，名称x引用到值1.这就像用字典一样，键引用值，当然，变量和所对应的值用的是个“不可见”的字典。实际上这么说已经很接近真实情况了。内建的vars函数可以返回这个字典：

>>>x=1
>>>y=1
>>>scope=vars()
>>>scope["x"]
1

vars可以返回全局变量的字典。

locals返回局部变量的字典。

vars函数官方说明
这类“不可见字典”叫做命名空间或者作用域。

除了全局作用域外，每个函数调用都会创建一个新的作用域：

>>>def foo():x=42
>>>x=1
>>>foo()
>>>x
1

当调用foo的时候，新的命名空间就被创建了，它作用于foo内的代码块。赋值语句x=42只在内部作用域（局部命名空间）起作用，它并不影响外部（全局）作用域中的x。

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

太痛苦了，这里的知识之前在学习JS时就已经了解的挺多，作用域链等等。还是记载以下我遗忘的知识好了。不赘述了。

x="michael"
def print_name(x):
    print x+x
print_name("qiuqiu")
qiuqiuqiuqiu    #结果

这里因为参数名和全局变量名重复了，因此，全局变量就被屏蔽了（如果不重复，是可以读取到全局变量值的）。我记得在JS中时，也有类似知识点，会逐步向上搜索作用域链中的变量值。

那么该怎么达成效果呢？怎么避免被屏蔽呢？使用globals函数获取全局变量值！

x="michael"
def print_name(x):
    print x+globals()["x"]
print_name("qiuqiu")
qiuqiumichael   #结果

除非告知python将其声明为全局变量，否则，在函数内的新变量赋值会自动成为局部变量：

x=2
def gl(x):
    global x
    x+=2
    print x
gl(3)
x
File "", line 2
    def gl(x):
SyntaxError: name "x" is local and global

为啥这里出错了呢？因为x作为形参，是局部变量，而函数里通过global又定义x是全局变量，因此出现了错误提示中的错误。

python的函数是可以嵌套的，也就是说可以将一个函数放在另一个里面。

万万没想到，又看到闭包了！python中也是有闭包的嘛，看来各个语言的机理概念都大同小异啊~

在其他函数内写函数：

def multiplier(factor):
    def multiplyByFactor(number):
        return number*factor
    return multiplyByFactor

每次调用外层函数（此处的multiplier),它内部的函数都被重新绑定，factor变量每次都有一个新值！

>>>double=multiplier(2)
>>>double(5)
10
>>>multiplier(5)(4)
20

类似multiplierByFactor函数存储子封闭作用域的行为叫做闭包（closure）。

外部作用域的变量一般是不能进行重新绑定的。但是python3中，nonlocal关键字被引入。它和global关键字的使用方式类似，可以让用户对外部作用域（但并非全局作用域）的变量进行赋值。

递归简单来说就是引用（或者调用）自身的意思。

def recursion():
    return recursion()

为了深入了解它，读者应该买本计算机科学方面的好书。常用python解释器也能帮助理解。

无穷递归（infinite recursion），类似于以white True开始的无穷循环，中间没有break或者return语句。

有用的递归函数包括以下部分：

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

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

这里的关键就是将问题分解为小部分，递归不能永远继续下去，因为它总是以最小可能性问题结束，而这些问题又存贮在基本实例中的。（就不能讲人话吗？！读不懂……）

可以使用循环：

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

关键在于阶乘的定义：

1的阶乘是1

大于1的数n的阶乘是n乘n-1的阶乘
现在看看递归的版本：

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

假设需要计算幂，就像内建函数pow函数或者**运算符一样。先看一个简单的例子：power(x,n)(x的n次幂）。

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

把它改为递归版本：

对于任意数字x来说，power(x,0)是1； 这就是上面递归条件的第一个，最小可能性问题吧

对于任意大于0的数来说，power(x,n)是x乘以power（x,n-1)的结果。

理解定义是最困难的部分——实现起来就简单了。

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

提示：如果函数或者算法很复杂而且难懂的话，在实现前用自己的话明确一下定义是很有帮助的。

python在应对“函数式编程”方面有一些有用的函数：

使用map函数将序列中的元素全部传递给函数

>>>map(str,range(10))    #Equivalent to [str(i) for i in range(10)]
["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]

map函数：

Apply function to every item of iterable and return a list of the results.

filter函数可以基于一个返回布尔值的函数对元素进行过滤：

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

>>>seq=["foo","x41","?!","***"]
>>>filter(func,seq)
["foo","x41"]

Note that filter(function, iterable) is equivalent to [item for item in iterable if function(item)]
str.isalpha()
Return true if all characters in the string are alphabetic and there is at least one character, false otherwise.

这章的知识确实有点多啊，递归一直不是特别灵活运用，或许真该找本书看看。