Python基础 第6章 抽象

1. 引言及抽象和结构

生成斐波那契数列的代码如下：

 fibs = [0, 1]
 num = int(input('How many num you want:'))
 for x in range(num-2):
     fibs.append(fibs[-2] + fibs[-1])
 print(fibs)

 结果：
 How many num you want:8
 [0, 1, 1, 2, 3, 5, 8, 13]

（1）让程序更抽象，可以让人更容易理解。

（2）函数，是结构化编程的核心。

2. 自定义函数

（1）使用def 语句定义函数，以实现结构化编程

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

 number = int(input('how many num do you want:'))
 print(fibs(number))

 结果：
 how many num do you want:12
 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

（2）可使用内置函数callable 判断某个对象是否可调用，返回布尔值True，False

（3）return 语句非常重要，用于从函数返回值。

　　2.1 给函数编写文档

　　给函数编写文档，便于其他人能够理解函数。放在函数开头的字符串称为文档字符串（独立的字符串），将作为函数的一部分被存储起来。

　　可以使用 __doc__ 函数属性查询函数的解释，双下划线表示特殊属性。

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

 print(square.__doc__)

 结果：
 Caluates the square of the number x.

　　2.2  所有函数都返回值，如果你没有告诉函数该返回什么，将返回None.

　　***2.3 不要让这种默认返回行带来麻烦。如果你在if 之类的语句中返回值，务必确保其他纷至也返回值，以免在调用者期望函数返回一个序列时，不小心返回了None。

3. 参数魔法

（1）能修改参数吗？

 #能修改参数吗？下面的例子不能
 def try_to_change(n):
     n = 'Mr.Gumby'
     return n

 name = 'Mrs.Entity'
 try_to_change(name)
 print(name)

 结果：
 Mrs.Entity

 上述修改并未成功，原因是，执行过程等同如下：
 name = 'Mrs.Entity'

 n = name
 n = 'Mr.Gumby'
 try_to_change(name) 实际结果 改变的是n的值：'Mr.Gumby'

 name =  'Mrs.Entity' # name的指向并未发生改变
 print(name):  'Mrs.Entity'

如果换成列表，则结果会不一样

#能修改参数吗？下面的例子能
def change(n):
    n[0] = 'Mr.Gumby'
#    return n

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

结果：
['Mr.Gumby', 'Mrs.Thing']  #可以看出结果变了

原因，实际执行过程：
name 指向 列表['Mrs.Entity', 'Mrs.Thing']；
执行change(name)函数，n 指向 name，
n = name，n= ['Mrs.Entity', 'Mrs.Thing']，name = ['Mrs.Entity', 'Mrs.Thing']
n[0] = 'Mr.Gumby' 修改n列表的只，因为n和name实际指向同一个list，故即使是通过n修改的list，name输出的也是修改后的结果。
具体参看list修改。

　　1）为何要修改参数

　　因为在提高程序的抽象程度方面，使用函数来修改数据结构（如列表或字典）是一种不错的方式。

具体示例如下，需要认真理解：

 # 1. 定义一个初始化数据结构的函数
 def init(data):
     data['first'] = {}
     data['middle'] = {}
     data['last'] = {}

 # 2. 获取人员姓名的函数
 def lookup(data, lable, name):
     return data[lable].get(name)

 # 3. 存储人员姓名的函数
 def store(data, full_name):    # 将参数data和full_name提供给这个函数，这些参数被设置为从外部获得的值
     names = full_name.split()   # 通过拆分full_name创建一个名为names的列表
     if len(names) == 2:         # 如果names的长度为2（只有名和姓），就将中间名设置为空字符串
         names.insert(1, '')
     labels = 'first', 'middle', 'last'  # 将这几个元素存储在元组lables中

     for lable, name in zip(labels, names):  # 使用zip函数将标签和对应的名字合并，以便对每个标签-名字对 执行如下操作
         people = lookup(data, lable, name)  # 1）获取属于该标签和名字的列表
         if people:
             people.append(full_name)        # 2）将full_name附加到该列表末尾或插入一个新列表
         else:
             data[lable][name] = [full_name]

 mynames = {}
 init(mynames)
 store(mynames, 'Magnus Lie Hetland')
 look_result = lookup(mynames, 'middle', 'Lie')
 print(look_result)

　　2）如果参数不可变

（2）关键字参数和默认值

前述（1）中所使用的均是位置参数，因为这些参数的位置非常重要。

使用名称指定的参数，称之为关键字参数。主要有点是有助于澄清各个参数的作用。

通常，不应结合使用位置参数和关键字参数

（3）收集参数

参数前面加星号，可将提供的所有值都放在一个元组中，也即将这些值收集起来。

 def print_params(*params):
     print(params)

 print_params('Testing')
 结果：
 ('Testing',)

 def print_params2(title, *params):
     print(title, end=' ')
     print(params)

 print_params2('numbers:', 1, 2, 3)
 结果：
 numbers: (1, 2, 3)

带星号（*）的参数也可以放在其它位置，而不一定是最后，但是该情况下必须使用名称指定后续参数

 def in_the_middle(x, *y, z):
     print(x, y, z)
 in_the_middle(1, 2, 3, 4, 5, 6)
 结果：
 TypeError: in_the_middle() missing 1 required keyword-only argument: 'z'

 # 根据报错提示，修改为如下：
 def in_the_middle(x, *y, z):
     print(x, y, z)
 in_the_middle(1, 2, 3, 4, 5, z=6)
 结果：
 1 (2, 3, 4, 5) 6

星号（*）不会收集关键字参数，若要实现收集关键字参数，需使用两个星号（**）

 def print_params3(title, *pos, **params):
     print(title)
     print(pos)
     print(params)

 print_params3('dict:','a','b','c', x=1, y=2, z=3)

 结果：
 dict:
 ('a', 'b', 'c')
 {'x': 1, 'y': 2, 'z': 3}

（4）分配参数 - 不是很懂？？？

4.作用域

5. 递归

6. 本章小结

6.1 本章关键词

抽象：通过定义处理细节的函数，可让程序更抽象

函数定义：使用def语句定义函数。函数由语句块组成，它们从外部接受值（参数），并可能返回一个或多个值（计算结果）

参数：函数通过参数（调用函数时被设置的变量）接受所需的信息。在Python中，参数有两类：位置参数和关键字参数。通过给参数指定默认值，可使其变成可选的。

作用域：变量存储在作用域（命名空间）中。在Python中，作用域分两大类：全局作用域和局部作用域。作用域可以嵌套。

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

函数式编程：Python提供了一些编程工具，其中包括lambda表达式以及函数map、filter和reduec。

6.2 新介绍函数

 map(func, seq[, seq, ...])     #对序列中的所有元素执行函数
 filter(func, seq)     #返回一个列表，其中包含对其执行函数时结果为真的所有元素
 reduce(func, seq[, initial])     #等价于func(func(seq[0], seq[1], seq[2]), ...)
 sum(seq)     #返回seq中所有元素的和
 apply(func[, args[, kwargs]])     #调用函数（还提供需要传递给函数的参数）