廖雪峰Python的研读笔记（一） Python基础、函数、高级特性

前言

以前知道廖前辈的这个网站，但是今天是第一次拜读，我是通过《Python核心编程（第三版）》这本书入门Python的，感觉廖前辈的教程更加容易，总结的也很到位。下面记录的是此番学习Python时带给我的领悟，以及一些值得关注的东西。我将它们写入博客《廖雪峰Python的研读笔记》系列。

Python基础

字符串和编码

Unicode把所有语言都统一到一套编码里，其标准也在不断发展，但最常用的是用两个字节表示一个字符（如果要用到非常偏僻的字符，就需要4个字节）。现代操作系统和大多数编程语言都直接支持Unicode。

ASCII编码是1个字节，而Unicode编码通常是2个字节。虽然解决了乱码问题，但是用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上都很不划算。

本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间。

此外，UTF-8编码有一个额外的好处，就是ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

现在计算机系统通用的字符编码工作方式：
在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。比如，记事本程序和web服务器，它们都是这样工作的。

循环

仅在必要的时候使用break和continue，因为它们会造成代码执行逻辑分叉过多，容易出错。大多数情况下，我们都可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。

使用dict和set

dict

和list比较，dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而变慢；
2. 需要占用大量的内存，内存浪费多。

而list相反：

1. 查找和插入的时间随着元素的增加而增加；
2. 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

>>> s = set([1, 2, 3, 3])
>>> s
set([1, 2, 3])

添加用add(key)，删除用remove(key)，交集用&，并集用|。

再议不可变对象

对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

例如b = a.replace('a', 'A')。

本章小结

几种类型的增删改查：

type	可变	生成	工厂	增	删	改	查	连接
tuple	否	() 或 (1,)	tuple()	-	-	-	t1[index]	t1+t2
list	是	[] 或 [1]	list()	append()	pop()	l1[index]=value	l1[index]	l1+l2
dict	是	{} 或 {‘k’:’v’}	dict()	d1[key]=value	pop()	d1[key]=value	d1[key]	-
set	是	{1}	set()	add()	remove()	-	-	-

函数

调用函数

可以在交互式命令行通过help(abs)查看abs函数的帮助信息。

数据类型转换

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

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

参数检查

让我们修改一下my_abs的定义，对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现：

def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

练习

请定义一个函数quadratic(a, b, c)，接收3个参数，返回一元二次方程ax2 + bx + c = 0的两个解。

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

'''
请定义一个函数quadratic(a, b, c)，接收3个参数，返回一元二次方程 ax2 + bx + c = 0 的两个解。

提示：计算平方根可以调用`math.sqrt()`函数。
'''

import math

def quadratic(a, b, c):

    # args check
    for i in [a, b, c]:
        if not isinstance(i, (int,float)):
            raise TypeError('bad operand type for ', i)

    if a == 0:
        print '\'a\' should not be zero!'
        return 'Error'

    # calculate
    print 'Calculating \'x\' in %sx^2 + %sx + %s = 0;' % (a, b, c)
    delta = b ** 2 - 4 * a * c

    if delta > 0:
        x1 = (-b + math.sqrt(delta)) / (2 * a)
        x2 = (-b - math.sqrt(delta)) / (2 * a)
        return x1, x2

    elif delta == 0:
        x1 = (-b + math.sqrt(delta)) / (2 * a)
        return x1

    else:
        return None


if __name__ == '__main__':
    print quadratic(2, 3, 1)    # => (-0.5, -1.0)
    print quadratic(1, 3, -4)   # => (1.0, -4.0)
    print quadratic(1, 4, 4)    # => -2.0
    print quadratic(3, 3, 4)    # => None

    print '\nCalculating \'x\' in ax^2 + bx + c = 0;'

    a = input('Input a: ')
    b = input('Input b: ')
    c = input('Input c: ')

    print quadratic(a, b, c)

函数的参数

默认参数

当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

默认参数很有用，但使用不当，也会掉坑里。默认参数有个最大的坑，演示如下：

先定义一个函数，传入一个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这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

可变参数

把任意个参数传入函数中，需要定义一个tuple，例如def max(*numbers);
把一个list或tuple中的全部元素一起传入这样的函数，可以用max(*my_list)和max(*my_tuple)的形式调用函数。

关键字参数

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

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

把任意个关键字参数传入函数中，需要定义一个dict，例如def person(**kw)；
把一个dict中的全部元素（此时key为变量名，它们必须是字符串）一起传入这样的函数，可以用person(**my_dict)的形式调用函数。（注意：kw将获得一个dict，它是my_dict的拷贝，对kw的改动不会影响到函数外的my_dict）

命名关键字参数（Python3）

对于关键字参数，在函数中我们需要判断它们是否存在，通常使用if 'city' in kw:这样的判断，但是调用者仍然可以传入不受限制的关键字参数；
如果要限制关键字参数的名字，可以用命名关键字参数，例如只接收city和job作为关键字参数时，可以定义为def person(name, age, *, city, job)；
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数；
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了，例如def person(name, age, *args, city, job)；
命名关键字参数也可以带有默认值，例如：def person(name, age, *, city='Beijing', job)；
命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

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

参数组合

参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。

小结

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的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

递归调用

小结

使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

练习

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

'''
汉诺塔的移动可以用递归函数非常简单地实现。

请编写move(n, a, b, c)函数，它接收参数n，表示3个柱子A、B、C中第1个柱子A的盘子数量，然后打印出把所有盘子从A借助B移动到C的方法。
'''

def move(n, a, b, c):
    if n == 1:
        print '%s --> %s' % (a, c)
    else:
        move(n - 1, a, c, b)    # 简化问题
        move(1, a, b, c)        # 移动最下面的大盘子
        move(n - 1, b, a, c)

if __name__ == '__main__':
    move(3, 'A', 'B', 'C')

高级特性

切片

有了切片操作，很多地方循环就不再需要了。Python的切片非常灵活，一行代码就可以实现很多行循环才能完成的操作。

tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple。
字符串'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串。在很多编程语言中，针对字符串提供了很多各种截取函数（例如，substring），其实目的就是对字符串切片。Python没有针对字符串的截取函数，只需要切片一个操作就可以完成，非常简单。

迭代

可以看出，Python的for循环抽象程度要高于Java的for循环，因为Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上。

因为dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样。
默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()，其迭代结果为('key1', 'value1')...

判断一个对象是可迭代对象，方法是通过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 i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

注意：函数enumerate()产生一个enumerate对象，它是一个类似生成器的对象，因此只能被for语句迭代一次。若将其保存在变量中再次迭代，将不会有任何输出。

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

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

列表生成器

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。

用法举例：

# 最简单的形式
>>> [ x for x in range(5) ]
[0, 1, 2, 3, 4]

# 引入表达式计算结果
>>> [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']

生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含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
 at 0x1022ef630>

generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的异常。更好的方法是使用for循环，因为generator也是可迭代对象，而且for语句将自动帮我们处理好StopIteration异常：

>>> g = ( x * x for x in range(3) )
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
Traceback (most recent call last):
  File "", line 1, in 
StopIteration
>>> 
>>> g = ( x * x for x in range(3) )
>>> for i in g:
...     print i
... 
0
1
4
>>> 

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。如果一个函数定义中包含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
0x104feaaa0>
>>> 
>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8
>>> 

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

用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration异常，返回值包含在StopIteration的value中（Python3）：

>>> 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

注意：在generator中使用带返回值的return语句只在Python3中支持，在Python2中会产生语法错误。

小结

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

练习

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

'''
杨辉三角定义如下：

          1
        1   1
      1   2   1
    1   3   3   1
  1   4   6   4   1
1   5   10  10  5   1

把每一行看做一个list，试写一个generator，不断输出下一行的list。
'''

def triangles(max_level = 20):

    level = 1
    L = [1]

    while level <= max_level:
        yield L
        level = level + 1
        L = [ L[0] ] + [ (L[i] + L[i + 1]) for i in range(len(L) - 1) ] + [ L[-1] ]

    return


if __name__ == '__main__':

    for t in triangles(10):
        print t

迭代器

可迭代对象与迭代器的区别：

名称	isinstance	for循环	next调用
可迭代对象	Iterable	支持	不支持
迭代器	Iterator	支持	支持

Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration异常。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

常见的可迭代对象：

分类	tuple	list	dict	set	str	generator	xrange
可迭代对象	是	是	是	是	是	是	是
迭代器	否	否	否	否	否	是	是

凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。