Python学习7——抽象

将语句组合成函数，可以告诉计算机如何完成任务，且只需说一次，而不用反复向计算机传达详细指令。

斐波那契数（一种数列，其中每个数都是前两个数的和）：

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

    
>>> fibs
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

优化一下代码，使其指定动态的范围：

>>> fibs = [0,1]
>>> num = input('enter:')
enter:10
>>> for i in range(int(num)-2):
    fibs.append(fibs[-2]+fibs[-1])

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

如果不从用户那里读取数字，而是通过参数来获取，可以继续优化代码：

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

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

def语句定义函数，return语句用于从函数返回值。num是一个形参，可以在其他地方多次调用fibs()，而不用每次都要将代码再敲一遍。

除了#注释之外，还有一种编写注释的方式，就是添加独立的字符串。放在函数开头的字符串称为文档字符串。

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

>>> square.__doc__     #访问文档字符串
'Calculates the square of the number x.'

__doc__是函数的属性。

>>> help(square)    #内置函数help可以获取有关函数的信息
Help on function square in module __main__:

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

修改参数

当参数为可变的数据结构（列表）时，在函数内修改参数，在外面调用函数。

>>> def change(n):
    n[0] = 'Mr.Gumby'

    
>>> names = ['Mrs.Entity','Mrs.Thing']
>>> change(names)
>>> names
['Mr.Gumby', 'Mrs.Thing']

上面栗子也可以这么写：

>>> names = ['Mrs.Entity','Mrs.Thing']
>>> n = names      #假装传递名字作为参数
>>> n[0] = 'Mr.Gumby'     #修改列表，这步上面是在函数内进行的
>>> names
['Mr.Gumby', 'Mrs.Thing']    

将同一个列表赋给两个变量时，这两个变量将同时指向这个列表。想避免这种结果，必须创建列表的副本。

>>> names = ['Mrs.Entity','Mrs.Thing']
>>> n = names[:]    #对序列进行切片操作时，返回的切片是副本。现在n和names包含2个相等但不同的列表。这里也可以用names.copy()来创建副本。
>>> n[0] = 'Mr.Gumby'
>>> names
['Mrs.Entity', 'Mrs.Thing']
>>> n
['Mr.Gumby', 'Mrs.Thing']

将切片参数传给函数，也不会影响：

>>> def change(n):
    n[0] = 'Mr.Gumby'

    
>>> names = ['Mrs.Entity','Mrs.Thing']
>>> change(names[:])
>>> names
['Mrs.Entity', 'Mrs.Thing']

栗子：假设编写一个程序，让它储存姓名，并让用户能够根据名字，中间名或姓找人。

创建初始化数据结构的函数：

>>> def init(data):
    data['first'] = {}
    data['middle'] = {}
    data['last'] = {}

    
>>> storage = {}
>>> init(storage)   #这个函数承担了初始化职责，提高了代码的可读性。
>>> storage
{'first': {}, 'middle': {}, 'last': {}}

然后需要一个函数来获取人员姓名：

>>> def lookup(data,label,name):
    return data[label].get(name)

接着要将人员存储到数据结构中：

>>> def store(data,full_name):    #将参数data和full_name提供给这个函数。
    names = full_name.split()   #通过拆分full_name创建1个名为names的列表。
    if len(names) == 2 : names.insert(1,'')  #如果只有名字和姓，没有中间名，就将中间名设为空字符串
    labels = 'first','middle','last'    #将label存储到元组中（也可以是列表）
    for name,label in zip(names,labels):   #zip函数将label和name合并，可以对label-name对执行一些操作
        people = lookup(data,label,name) 
        if people:
            people.append(full_name)  #将full_name插入一个新列表
        else:
            data[label][name]=[full_name]

现在运行看看：

>>> me = {}
>>> init(me)
>>> me
{'first': {}, 'middle': {}, 'last': {}}
>>> store(me,'Magnus Lie Hetland')
>>> me
{'first': {'Magnus': ['Magnus Lie Hetland']}, 'middle': {'Lie': ['Magnus Lie Hetland']}, 'last': {'Hetland': ['Magnus Lie Hetland']}}
>>> lookup(me,'middle','Lie')
['Magnus Lie Hetland']
>>> store(me,'Robin Hood')
>>> store(me,'Robin Locksley')
>>> store(me,'Mr. Gumby')
>>> lookup(me,'first','Robin')
['Robin Hood', 'Robin Locksley']
>>> lookup(me,'middle','')
['Robin Hood', 'Robin Locksley', 'Mr. Gumby']

关键字参数

当函数需要传多个参数时，参数的位置就变的非常重要，比名字还重要。

>>> def hello_1(greeting,name):
    print('{},{}!'.format(greeting,name))

    
>>> def hello_2(name,greeting):
    print('{},{}!'.format(name,greeting))

    
>>> hello_1('hello','world')
hello,world!
>>> hello_2('hello','world')
hello,world!

为了避免遗忘参数的位置，可以用关键字参数（用名称指定参数）：

>>> hello_1(greeting='hello',name='world')
hello,world!
>>> hello_2(greeting='hello',name = 'world')
world,hello!

给参数指定默认值：

>>> def hello_3(greeting = 'hello',name='world'):   #给参数指定默认值后，调用函数时可不提供它。
    print('{},{}!'.format(greeting,name))

    
>>> hello_3()   #不提供参数
hello,world!
>>> hello_3('Greetings','universe')    #提供全部参数值
Greetings,universe!
>>> hello_3(name='Gumby')    #提供部分参数值

收集参数

>>> def print_params(*params):  #参数前面的星号将提供的所有值都放在一个元组中，也就是将这些值收集起来。
    print(params)

    
>>> print_params('Testing')
('Testing',)
>>> print_params(1,2,3)
(1, 2, 3)
>>> x,*y,z = 1,2,3,4,5,6   #上面的情况与赋值时的星号有点相似，不过赋值时带星号的变量收集多余的值
>>> x,y,z
(1, [2, 3, 4, 5], 6)    #并且是将收集的值放在列表中
>>> def print_params_2(title,*params):
    print(title)
    print(params)

    
>>> print_params_2('Params:',1,2,3)   #星号意味着收集余下的位置参数
Params:
(1, 2, 3)
>>> print_params_2('Nothing:')   #如果没有可收集的参数，params将是一个空元组
Nothing:
()

当带星号的参数位置不在末尾：

>>> def in_the_middle(x,*y,z,f):
    print(x,y,z,f)

    
>>> in_the_middle(1,2,3,4,5,z=6,f=7)   #需要使用名称来指定后续参数
1 (2, 3, 4, 5) 6 7
>>> in_the_middle(1,2,3,4,5,6,7)
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    in_the_middle(1,2,3,4,5,6,7)
TypeError: in_the_middle() missing 2 required keyword-only arguments: 'z' and 'f'

单个星号不会收集关键字参数，要收集关键字参数，可使用两个星号：

>>> def print_params_3(**params):
    print(params)

    
>>> print_params_3(x=1,y=2,z=3)    #两个星号得到的是一个字典
{'x': 1, 'y': 2, 'z': 3}
>>> def print_params_4(x,y,z=3,*pospar,**keypar):
    print(x,y,z)
    print(pospar)
    print(keypar)

    
>>> print_params_4(1,2,3,4,5,6,foo=1,bar=2)
1 2 3
(4, 5, 6)
{'foo': 1, 'bar': 2}

结合这些技术，可以将上面存储姓名的栗子再次优化：

>>> def store(data,*full_names):
    for full_name in full_names:
        names = full_name.split()
        if len(names)==2:names.insert(1,'')
        labels = 'first','middle','last'
        for name,label in zip(names,labels):
            people = lookup(data,label,name)
            if people:
                people.append(full_name)
            else:
                data[label][name] = [full_name]

                
>>> init(me)
>>> store(me,'Luke Skywalker','Anakin Skywalker')
>>> lookup(me,'first','Luke')
['Luke Skywalker']

优化之后，store里可以一次存储多个名字。

分配参数

>>> def hello(greeting='hello',name='Toney'):
    print('{},{}!'.format(greeting,name))

    
>>> params = {'name':'Mary','greeting':'Greet'}
>>> hello(**params)
Greet,Mary!

通过使用运算符**可将字典中的值分配给关键字参数。

只有在定义函数（允许可变数量的参数）或调用函数时（拆分字典或序列）使用，星号才能发挥作用。

综合的栗子：

>>> def story(**kwds):
    return 'Once upon a time,there was a '
           '{job} called {name}'.format_map(kwds)

>>> def power(x,y,*others):
    if others:
        print('Received redundant parameters:',others)
    return pow(x,y)
        
>>> def interval(start,stop=None,step=1):
    'Imitates range() for step > 0'
    if stop is None:   #如果没有给参数stop指定值
        start,stop = 0,start    #就调整参数start和stop的值

    result = [] 
    i = start                #从start开始往上数
    while i < stop:        #数到stop位置
        result.append(i)     #将当前数的数加到result列表末
        i += step              # i=i+1
    return result

>>> print(story(job='king',name='Gumby'))
Once upon a time,there was a king called Gumby
>>> print(story(name='Sir Robin',job='brave knight'))
Once upon a time,there was a brave knight called Sir Robin
>>> params = {'job':'language','name':'Python'}            
>>> print(story(**params))
Once upon a time,there was a language called Python
>>> power(2,3)
8
>>> power(y=3,x=2)
8
>>> params = (5,)*2
>>> power(*params)
3125
>>> power(3,3,'hello,world')
Received redundant parameters: ('hello,world',)
27
>>> interval(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

作用域

当局部变量中有一个与全局变量命名相同的变量时，可用函数globals来访问全局变量。

>>> def combine(paramter):
    print(paramter + globals()['paramter'])

    
>>> paramter = 'berry'
>>> combine('Shrub')
Shrubberry

在函数内给变量赋值时，该变量默认是局部变量，但可以指定该变量是全局变量。

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

    
>>> change()
>>> x
2

递归

函数可调用自身，称为递归。可使用递归完成的任何任务都可使用循环来完成，但有时使用递归函数的可读性更高。

>>> def fac(n):
    result = n   #将result设置为n
    for i in range(1,n):
        result *= i    #依次乘以1到n-1的每个数字
    return result    #返回result

>>> fac(5)
120
>>> def fac(n):
    if n == 1:
        return 1
    else:
        return n * fac(n-1)

    
>>> fac(5)
120

上面两个函数的功能一致，都是计算数字n的阶乘，貌似在这种场景下，递归的可读性比较高。