Python学习笔记（进阶篇一）

笔记整理出处：廖雪峰教程

• 进阶
  • 函数
    • 位置参数
    • 默认参数
    • 可变参数
    • 关键字参数
    • 命名关键字参数
    • 参数组合
    • 递归函数
  • 高级特性
    • 切片
    • 迭代
    • 列表生成式
    • 生成器
    • 迭代器

进阶

函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，而后，在缩进块中编写函数体，函数的返回值用return语句返回。

咱们以自定义一个求绝对值的my_abs函数为例：

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x复制代码

请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。所以，函数内部经过条件判断和循环能够实现很是复杂的逻辑。

若是没有return语句，函数执行完毕后也会返回结果，只是结果为None。
return None能够简写为return。
python中函数没有返回值类型声明，同时，函数名其实就是指向一个函数对象的引用，彻底能够把函数名赋给一个变量，至关于给这个函数起了一个“别名”：

>>> a = abs # 变量a指向abs函数
>>> a(-1) # 因此也能够经过a调用abs函数
1复制代码

位置参数

咱们先写一个计算x2的函数：

def power(x):
    return x * x复制代码

对于power(x)函数，参数x就是一个位置参数。

当咱们调用power函数时，必须传入有且仅有的一个参数x：

默认参数

def power(x , y = 2):
    return x * y复制代码

咱们调用时既能够这样用power(2,3），也能够这样用power(2),明显的，当咱们不传递y这个参数时，方法内部会去y的默认值进行运算，也就是2

默认参数能够简化函数的调用。设置默认参数时，有几点要注意：

• 必选参数在前，默认参数在后，不然Python的解释器会报错（思考一下为何默认参数不能放在必选参数前面）；

• 如何设置默认参数。
  当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就能够做为默认参数。

使用默认参数有什么好处？最大的好处是能下降调用函数的难度。由于有些参数，可能咱们大部分时间传递的是一样的值。
注意事项：

• 定义默认参数要牢记一点：默认参数必须指向不变对象！
• 定义默认参数要牢记一点：默认参数必须指向不变对象！
• 定义默认参数要牢记一点：默认参数必须指向不变对象！

举例说明，先定义一个函数，传入一个list，添加一个END再返回：

def add_end(L=[]):
    L.append('END')
    return L复制代码

当你正常调用时，结果彷佛不错：

>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']复制代码

当你使用默认参数调用时，一开始结果也是对的：

>>> add_end()
['END']复制代码

可是，再次调用add_end()时，结果就不对了：

>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']复制代码

不少初学者很疑惑，默认参数是[]，可是函数彷佛每次都“记住了”上次添加了'END'后的list。

缘由解释以下：

Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，由于默认参数L也是一个变量，它指向对象[]，每次调用该函数，若是改变了L的内容，则下次调用时，默认参数的内容就变了，再也不是函数定义时的[]了。

因此，定义默认参数要牢记一点：默认参数必须指向不变对象！

要修改上面的例子，咱们能够用None这个不变对象来实现：

def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L复制代码

如今，不管调用多少次，都不会有问题：

>>> add_end()
['END']
>>> add_end()
['END']复制代码

为何要设计str、None这样的不变对象呢？由于不变对象一旦建立，对象内部的数据就不能修改，这样就减小了因为修改数据致使的错误。此外，因为对象不变，多任务环境下同时读取对象不须要加锁，同时读一点问题都没有。咱们在编写程序时，若是能够设计一个不变对象，那就尽可能设计成不变对象。

可变参数

定义与java相似,基本使用方法以下：

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum复制代码

对于已经存在的list类型参数，可变参数的使用方法和java略有不一样，不能直接传入该变量，须要增长*

>>> nums = [1, 2, 3]
>>> calc(*nums)
14复制代码

*nums表示把nums这个list的全部元素做为可变参数传进去。这种写法至关有用，并且很常见。

关键字参数

可变参数容许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数容许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)复制代码

函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，能够只传入必选参数：

>>> person('Michael', 30)
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'}复制代码

和可变参数相似，也能够先组装出一个dict，而后，把该dict转换为关键字参数传进去：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}复制代码

**extra表示把extra这个dict的全部key-value用关键字参数传入到函数的kw参数，kw将得到一个dict，

注意kw得到的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

命名关键字参数

对于关键字参数，函数的调用者能够传入任意不受限制的关键字参数。至于到底传入了哪些，就须要在函数内部检查。
若是要限制关键字参数的名字，就能够用命名关键字参数，例如，只接收city和job做为关键字参数。这种方式定义的函数以下：

def person(name, age, *, city, job):
    print(name, age, city, job)
和关键字参数**kw不一样，命名关键字参数须要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

调用方式以下：
~~~python
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer复制代码

若是函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就再也不须要一个特殊分隔符*了：

def person(name, age, *args, city, job):
    print(name, age, args, city, job)复制代码

命名关键字参数必须传入参数名，这和位置参数不一样。若是没有传入参数名，调用将报错：

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() takes 2 positional arguments but 4 were given复制代码

因为调用时缺乏参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数。

命名关键字参数能够有缺省值，从而简化调用：

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)
因为命名关键字参数city具备默认值，调用时，可不传入city参数：
~~~python
>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer复制代码

使用命名关键字参数时，要特别注意，若是没有可变参数，就必须加一个做为特殊分隔符。若是缺乏，Python解释器将没法识别位置参数和命名关键字参数：

def person(name, age, city, job):
    # 缺乏 *，city和job被视为位置参数
    pass复制代码

参数组合

在Python中定义函数，能够用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数均可以组合使用。可是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

好比定义一个函数，包含上述若干种参数：

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)复制代码

在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

递归函数

使用递归函数须要注意防止栈溢出。在计算机中，函数调用是经过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。因为栈的大小不是无限的，因此，递归调用的次数过多，会致使栈溢出。
解决递归调用栈溢出的方法是经过尾递归优化，事实上尾递归和循环的效果是同样的，因此，把循环当作是一种特殊的尾递归函数也是能够的。

高级特性

切片

对常常取指定索引范围的操做，用循环十分繁琐，所以，Python提供了切片（Slice）操做符，能大大简化这种操做。
取前3个元素，用一行代码就能够完成切片：

>>> L[0:3]
['Michael', 'Sarah', 'Tracy']复制代码

前开后闭原则。默认从第一个开始取时能够省略不写0.
相似的，Python支持L[-1]取倒数第一个元素，那么它一样支持倒数切片：

>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']复制代码

记住倒数第一个元素的索引是-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]复制代码

tuple也是一种list，惟一区别是tuple不可变。所以，tuple也能够用切片操做，只是操做的结果还是tuple：

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)复制代码

字符串'xxx'也能够当作是一种list，每一个元素就是一个字符。所以，字符串也能够用切片操做，只是操做结果还是字符串：

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'复制代码

迭代

只要是可迭代对象，不管有无下标，均可以迭代，好比dict就能够迭代：

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b复制代码

默认状况下，dict迭代的是key。若是要迭代value，能够用for value in d.values()，若是要同时迭代key和value，能够用for k, v in d.items()。
因为字符串也是可迭代对象，所以，也能够做用于for循环。

那么，如何判断一个对象是可迭代对象呢？方法是经过collections模块的Iterable类型判断：

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

最后一个小问题，若是要对list实现相似Java那样的下标循环怎么办？Python内置的enumerate函数能够把一个list变成索引-元素对，这样就能够在for循环中同时迭代索引和元素自己：

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C复制代码

上面的for循环里，同时引用了两个变量，在Python里是很常见的，好比下面的代码：

>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
...     print(x, y)
...
1 1
2 4
3 9复制代码

任何可迭代对象均可以做用于for循环，包括自定义的数据类型，只要符合迭代条件，就可使用for循环。

列表生成式

若是要生成[1x1, 2x2, 3x3, ..., 10x10]怎么作？方法一是循环：

>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]复制代码

可是循环太繁琐，而列表生成式则能够用一行语句代替循环生成上面的list：

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

写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就能够把list建立出来。
还可使用两层循环，能够生成全排列：

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

鉴于列表生成式的便捷性，过于复杂的逻辑不建议直接使用生成式来写（我的观点）

生成器

经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要建立一个generator，有不少种方法。第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>复制代码

建立L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。
若是要一个一个打印出来，能够经过next()函数得到generator的下一个返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
...
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration复制代码

咱们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

固然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，由于generator也是可迭代对象：

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1复制代码

定义generator的另外一种方法。若是一个函数定义中包含yield关键字，那么这个函数就再也不是一个普通函数，而是一个generator：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>复制代码

这里，最难理解的就是generator和函数的执行流程不同。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

举个简单的例子，定义一个generator，依次返回数字1，3，5：

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)复制代码

调用该generator时，首先要生成一个generator对象，而后用next()函数不断得到下一个返回值：

>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration复制代码

能够看到，odd不是普通函数，而是generator，在执行过程当中，遇到yield就中断，下次又继续执行。执行3次yield后，已经没有yield能够执行了，因此，第4次调用next(o)就报错。

回到fib的例子，咱们在循环过程当中不断调用yield，就会不断中断。固然要给循环设置一个条件来退出循环，否则就会产生一个无限数列出来。

一样的，把函数改为generator后，咱们基本上历来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8复制代码

可是用for循环调用generator时，发现拿不到generator的return语句的返回值。若是想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done复制代码

迭代器

能够直接做用于for循环的数据类型有如下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些能够直接做用于for循环的对象统称为可迭代对象：Iterable。

可使用isinstance()判断一个对象是不是Iterable对象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance(100, Iterable)
False复制代码

而生成器不但能够做用于for循环，还能够被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示没法继续返回下一个值了。

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

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False复制代码

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

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True复制代码