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]])     #调用函数（还提供需要传递给函数的参数）