廖雪峰Python（三）函数和高级特性

函数

• 多次的重复作业提取出固定流程成为某种模板即成为函数。
• 借助抽象，把底层的具体计算过程模糊，我们可以专注更高层次的思考。函数就是最基本的一种代码抽象的方式。

1. 调用函数

• 函数的帮助：官方文档
• 在交互式命令行通过help（abs）查看abs函数帮助信息。abs为求绝对值的函数。
• 使用函数时应注意传入函数的参数的数量，类型，顺序。

数据类型转换

• 熟练使用数据类型转换函数可以转换函数类型，例如：int(),把其他的类型转换为整数。

>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False

• 函数名可以赋值给任意变量，使该变量成为函数的引用。

>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1

• 调用函数 练习****

请利用Python内置的hex()函数把一个整数转换成十六进制表示的字符串：

# -*- coding: utf-8 -*-

n1 = 255
n2 = 1000
print(hex(n1),hex(n2))
-----------
0xff 0x3e8

2. 定义函数

• 定义：在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号
• 然后，在缩进块中编写函数体，函数的返回值用return语句返回。
• 函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。
• 定义好的函数保存为文件后，在别的文件中使用时使用**“ from 文件名 import 函数名 ”**来导入函数。

空函数

• 想要一个什么都不做的函数或者还没想好的时候可以先放一个 pass ，可以用做占位符。
• 而如果不放pass，就会出现错误。

参数检查

• 我们的函数传入参数的时候需要检查参数的个数，类型，顺序才能保证他的功能无误。
• 简单的检查如：修改一下my_abs的定义，对参数类型做检查，只允许整数和浮点数类型的参数。
  数据类型检查可以用内置函数isinstance()实现：

def my_abs(x):
if not isinstance(x, (int, float)): #检查x是否是后面的数据类型
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

添加了参数检查后，如果传入错误的参数类型，函数就可以抛出一个错误：

>>> my_abs('A')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in my_abs
TypeError: bad operand type

返回多个值

实质上是返回一个tuple。
例：

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0

>>> r = move(100, 100, 60, math.pi / 6)
>>> print(r)
(151.96152422706632, 70.0)

3.函数的参数

• 定义简单，参数的名字位置确定就成。
• 调用时传递正确的参数，获得返回值，内部封装无需了解。
• 但灵活度很大。除了必选参数，还有默认参数，可变参数，和关键字参数。

位置参数

• 对于计算x平方的函数power(x)，x即为一个位置参数。
• 对于计算任意数字的任意次方的函数，power(x,n)，x，n都是位置参数。

默认参数

• 我们使用了两个参数的函数，传入一个参数时函数失效。
• 我们可以把第二个参数设定为默认参数为2，传入一个参数时，默认第二个参数为2，传入两个参数时会覆盖掉默认参数。
• 注意事项：
  1. 必选参数在前，默认参数在后，否则会报错。
  2. 当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数（比如我们的次方经常使用的就是2，即可实现不大部分时候不修改默认2）。
  3. 传递参数的时候，可以按顺序也可以不按顺序，不按顺序要把默认参数的名字带上。
  4. 最大的坑：定义默认参数要牢记一点：默认参数必须指向不变对象！
  • 定义参数为可变对象时。
    Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

可变参数

• 即参数的个数可变。
• 在定义函数时，函数可变参数一个list或者tuple参数前面加一个星号*
• 传入的时候也可以把已有的list或者tuple名称前加一个星号作为可变参数传入。.

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
    
>>> calc(1, 2)
5
>>> calc()
0

关键字参数

• 即可以使用两个星号标记关键字参数，这个参数用户可任意传入0-任意变量，这些变量都将被整合成一个字典，dict。

def person(name, age, **kw):     //kw为关键字参数
    print('name:', name, 'age:', age, 'other:', kw)

>>> person('Michael', 30)   //0个
name: Michael age: 30 other: {}

>>> person('Bob', 35, city='Beijing')   //任意个
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

• 传入时**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
  #####命名关键字参数
• 关键字参数可以任意传入参数，命名关键字参数可以限制。

def person(name, age, *, city, job):
    print(name, age, city, job)

用 * 分割，后面的参数即为命名关键字参数，用户填了必选的姓名和年龄之后，city和job即为可选状态。
相当于给出了选择范围，而关键字参数可以任意传入。

• 调用函数传入命名关键字参数时必须有参数名。否则报错。

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

• 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符了：如果没有可变参数，必须加入分隔符，否则无法识别。

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

• 可以有默认值，从而在传入时可以缺省，简化。

参数组合

• 在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
• 在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

小结

• Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
• 默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
• 要注意定义可变参数和关键字参数的语法：*args是可变参数，args接收的是一个tuple；**kw是关键字参数，kw接收的是一个dict。
• 以及调用函数时如何传入可变参数和关键字参数的语法：可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过args传入：func((1, 2, 3))；关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kw传入：func({‘a’: 1, ‘b’: 2})。
• 使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
• 命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
• 定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

• 函数的参数 练习

以下函数允许计算两个数的乘积，请稍加改造，变成可接收一个或多个数并计算乘积：

# -*- coding: utf-8 -*-
def product(x, *numbers):
    product = x
    for y in numbers:
        product = product * y
    return product

# 测试
print('product(5) =', product(5))
print('product(5, 6) =', product(5, 6))
print('product(5, 6, 7) =', product(5, 6, 7))
print('product(5, 6, 7, 9) =', product(5, 6, 7, 9))
if product(5) != 5:
    print('测试失败!')
elif product(5, 6) != 30:
    print('测试失败!')
elif product(5, 6, 7) != 210:
    print('测试失败!')
elif product(5, 6, 7, 9) != 1890:
    print('测试失败!')
else:
    try:
        product()
        print('测试失败!')
    except TypeError:
        print('测试成功!')
product(5) = 5
product(5, 6) = 30
product(5, 6, 7) = 210
product(5, 6, 7, 9) = 1890
测试成功!

4. 递归函数

• 在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
• 递归函数的优点是定义简单，逻辑清晰。
• 使用递归函数需要注意防止栈溢出。
• 解决递归调用栈溢出的方法是通过尾递归优化，尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)
 
===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120

• 递归函数 练习

• 汉诺塔的移动可以用递归函数非常简单地实现。
• 请编写move(n, a, b, c)函数，它接收参数n，表示3个柱子A、B、C中第1个柱子A的盘子数量，然后打印出把所有盘子从A借助B移动到C的方法，例如：

# -*- coding: utf-8 -*-
def move(n, a, b, c):
if n == 1:
        print(a, '-->', c)  //基线条件
    else:
        move(n - 1,a,c,b) // 递归条件
        print(a, '-->',c)
        move(n - 1,b,a,c)


move(3, 'A', 'B', 'C')

A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C

---

高级特性

请始终牢记，代码越少，开发效率越高

1. 切片 Slice

• 满足于取出指定索引范围的数据。
• L[0:3] 取出list前三个元素，记住左开右闭原则。
• L[:3] 0可以省略。
• L[-1]为末尾元素，那L[-2:-1]也可取出倒数第二个元素。
• 前10个数，每两个取一个：

>>> L[:10:2]
[0, 2, 4, 6, 8]

• 所有数，每5个取一个：

>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

• 甚至什么都不写，只写[:]就可以原样复制一个list：

>>> L[:]
[0, 1, 2, 3, ..., 99]

• list切片仍是一段list [] ，tuple切片仍是tuple (),字符串也是。
  -可以取代很多地方的循环。

• 切片 练习

利用切片操作，实现一个trim()函数，去除字符串首尾的空格，注意不要调用str的strip()方法：

# -*- coding: utf-8 -*- 
def trim(s):
    while s[-1:] == ' ':  
        s = s[:-1]  
    while s[:1] == ' ':  
        s = s[1:] 
    return s

2.迭代 Iteration

• 如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。
• python中的迭代是可以对很多对象的，list，tuple，字符串，dict（因为是无序的所以每次的结果可能不一样）。。。
• dict 默认迭代key，用for value in d.values()迭代value，如果要同时迭代key和value，可以用for k, v in d.items()。
• 通过collections模块的Iterable类型判断是否可以迭代

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

• Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身。
• 任何可迭代对象都可以作用于for循环，包括我们自定义的数据类型，只要符合迭代条件，就可以使用for循环。

• 迭代 练习

请使用迭代查找一个list中最小和最大值，并返回一个tuple：

# -*- coding: utf-8 -*-
def findMinAndMax(L):
    if L == []:
        return (None,None)
    min = max = L[0]
    for x in L:
        if min > x:
            min= x
        elif max < x:
            max = x
    return (min,max)

列表生成式 list comprehensions

• 用来创建list的生成式
• 格式为

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

• 可以加入if判断

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

• 两层

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

• 两个变量

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

• 前面为函数

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

生成器中的if…else

• 在一个列表生成式中，for前面的if … else是表达式必须有if else全套，而for后面的if是过滤条件，不能带else。

• 列表生成式 练习

• 如果list中既包含字符串，又包含整数，由于非字符串类型没有lower()方法，所以列表生成式会报错：

>>> L = ['Hello', 'World', 18, 'Apple', None]
>>> [s.lower() for s in L]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <listcomp>
AttributeError: 'int' object has no attribute 'lower'

• 使用内建的isinstance函数可以判断一个变量是不是字符串：

>>> x = 'abc'
>>> y = 123
>>> isinstance(x, str)
True
>>> isinstance(y, str)
False

• 请修改列表生成式，通过添加if语句保证列表生成式能正确地执行：

# -*- coding: utf-8 -*-
L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = [x.lower() for x in L1 if isinstance(x, str) ]

# 测试:
print(L2)
if L2 == ['hello', 'world', 'apple']:
    print('测试通过!')
else:
    print('测试失败!')
    
    
['hello', 'world', 'apple']
测试通过!

3.生成器 Generator

• 在Python中，这种一边循环一边计算的机制，称为生成器：generator。
• 生成了一百万个数据，我们只用了前几个太浪费了，可以边用边生成，相当于边缓冲边看视频，不会因为看了几秒退出了浪费了空间。

生成器1

将列表生成式的 [] 改为 ()

• next() 可以一个一个打印出来generator的返回值
• 同样是可迭代对象，可以用for in 迭代

生成器2

• 如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator
• 每次执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
• 普通函数调用直接返回结果 。generator函数的“调用”实际返回一个generator对象
• 如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中。

小结

要理解generator的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。

4.迭代器 Iterator

• 可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
• 可以使用isinstance()判断一个对象是否是Iterator对象：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

• 生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
• 把list、dict、str等Iterable变成Iterator可以使用iter()函数：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

• 凡是可作用于for循环的对象都是Iterable类型；
• 凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列，需要的时候才计算。