廖雪峰Python教程学习笔记

发表于 | 分类于 | 热度: ℃
字数统计: 8.3k 字 | 阅读时长 ≈ 33 分钟

这篇文章是我学习廖雪峰Python教程时记的笔记，内容框架一致，但内容大部分都只记录了我之前没注意的知识点，其他部分可能有所遗漏。
要提醒自己时常取出复习，书要越读越薄。

Python 基础

数据类型和变量

print()函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出：

1
2
>>> print('The quick brown fox', 'jumps over', 'the lazy dog')
The quick brown fox jumps over the lazy dog

print()会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，输出的字符串是这样拼起来的：

Python程序是大小写敏感的 。

Python 数据类型

整数

整数运算永远是精确的（除法难道也是精确的？是的！） 。

浮点数

浮点数运算可能会有四舍五入的误差 。

在Python中，有两种除法，一种除法是/ ：

1
2
>>> 10 / 3
3.3333333333333335

/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：

1
2
>>> 9 / 3
3.0

还有一种除法是//，称为地板除，两个整数的除法仍然是整数：

1
2
>>> 10 // 3
3

你没有看错，整数的地板除//永远是整数，即使除不尽。

无论整数做//除法还是取余数，结果永远是整数，所以，整数运算结果永远是精确的。

字符串

字符串是以单引号'或双引号"括起来的任意文本 。

''或""本身只是一种表示方式，不是字符串的一部分 。

如果'本身也是一个字符，那就可以用""括起来 。

如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识，比如：

1
'I\'m \"OK\"!'

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\ 。

如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义。

如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容 。

注意...是提示符，不是代码的一部分 。

布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值 。

布尔值可以用and、or和not运算。

空值

空值是Python里一个特殊的值，用None表示。

None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

变量

变量名必须是大小写英文、数字和_的组合，且不能用数字开头 。

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。

静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。

常量

在Python中，通常用全部大写的变量名表示常量 。

格式化

在Python中，采用的格式化方式和C语言是一致的，用%实现：

1
2
3
4
>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

%运算符就是用来格式化字符串的。

有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略 。

常见的占位符有：

占位符 替换内容
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数

如果不确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串 。

字符串里面的%是一个普通字符，就需要转义，用%%来表示一个%：

1
2
>>> 'growth rate: %d%%' % 7
'growth rate: 7%'

format()

另一种格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……，不过这种方式写起来比%要麻烦得多：

1
2
>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'

list和tuple

list

Python内置的一种数据类型是列表：list。

list是一种有序的集合，可以随时添加和删除其中的元素。 

1
2
3
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']

变量classmates就是一个list。

可以用索引来访问list中每一个位置的元素，索引是从0开始的。

要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素 。

list是一个可变的有序表，所以，可以往list中追加元素到末尾：

1
2
3
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

也可以把元素插入到指定的位置，比如索引号为1的位置：

1
2
3
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要删除list末尾的元素，用pop()方法：

1
2
3
4
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

1
2
3
4
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

1
2
3
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

list里面的元素的数据类型也可以不同 。

list元素也可以是另一个list，比如：

1
2
3
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

如果一个list中一个元素也没有，就是一个空的list，它的长度为0：

1
2
3
>>> L = []
>>> len(L)
0

tuple

另一种有序列表叫元组：tuple。

tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：

1
>>> classmates = ('Michael', 'Bob', 'Tracy')

它没有append()，insert()这样的方法，其他获取元素的方法和list是一样的，可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素 。

定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来 。

如果要定义一个空的tuple，可以写成()：

1
2
3
>>> t = ()
>>> t
()

但是，要定义一个只有1个元素的tuple，如果这么定义：

1
2
3
>>> t = (1)
>>> t
1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

1
2
3
>>> t = (1,)
>>> t
(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免误解成数学计算意义上的括号。

tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

条件判断

用elif做更细致的判断：

1
2
3
4
5
6
7
age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

if判断条件还可以简写，比如写：

1
2
if x:
    print('True')

只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

再议 input

用input()读取用户的输入，程序运行得更有意思：

1
2
3
4
5
birth = input('birth: ')
if birth < 2000:
    print('00前')
else:
    print('00后')

输入1982，结果报错：

1
2
3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() > int()

这是因为input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。Python提供了int()函数来完成这件事情：

1
2
3
4
5
6
s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')

循环

for…in循环

Python的循环有两种，一种是for…in循环，依次把list或tuple中的每个元素迭代出来：

1
2
3
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

for x in ...循环就是把每个元素代入变量x，然后执行缩进块的语句。

Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数：

1
2
>>> list(range(5))
[0, 1, 2, 3, 4]

while循环

第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。

比如计算100以内所有奇数之和，可以用while循环实现：

1
2
3
4
5
6
sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

在循环内部变量n不断自减，直到变为-1时，不再满足while条件，循环退出。

break

在循环中，break语句可以提前退出循环。

continue

在循环过程中，可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。

dict和set

dict

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

用Python写一个dict如下：

1
2
3
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：

1
2
3
>>> d['Adam'] = 67
>>> d['Adam']
67

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

1
2
3
4
5
6
>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88
>>> d['Jack']
88

如果key不存在，dict就会报错：

1
2
3
4
>>> d['Thomas']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Thomas'

要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

1
2
>>> 'Thomas' in d
False

二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：

1
2
3
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1

注意：返回None的时候 Python 的交互环境不显示结果。

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

1
2
3
4
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

与list的比较

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

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

而list相反：

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

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

注意：dict的key必须是不可变对象。

在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。

set

set和dict类似，也是一组key的集合，但不存储value。

由于key不能重复，所以，在set中，没有重复的key。

要创建一个set，需要提供一个list作为输入集合：

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

注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。

重复元素在set中自动被过滤：

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

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

1
2
3
4
5
6
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

通过remove(key)方法可以删除元素：

1
2
3
>>> s.remove(4)
>>> s
{1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

1
2
3
4
5
6
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。

再议不可变对象

str是不变对象，而list是可变对象。

对于不可变对象，比如str，对str进行操作：

1
2
3
4
5
6
>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

要始终牢记的是，a是变量，而'abc'才是字符串对象！有些时候，我们经常说，对象a的内容是'abc'，但其实是指，a本身是一个变量，它指向的对象的内容才是'abc'：

1
2
3
┌───┐                  ┌───────┐
│ a │─────────────────>│ 'abc' │
└───┘                  └───────┘

当我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象'abc'上的，而这个方法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace方法创建了一个新字符串'Abc'并返回，用变量b指向该新字符串，，变量a仍指向原有的字符串'abc'，但变量b却指向新字符串'Abc'：

1
2
3
4
5
6
┌───┐                  ┌───────┐
│ a │─────────────────>│ 'abc' │
└───┘                  └───────┘
┌───┐                  ┌───────┐
│ b │─────────────────>│ 'Abc' │
└───┘                  └───────┘

所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。

这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

函数

函数是最基本的一种代码抽象的方式。

调用函数

数据类型转换

Python内置的常用函数还包括数据类型转换函数，比如int()函数可以把其他数据类型转换为整数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> 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

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

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

定义函数

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

函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。

如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。

如果已经把my_abs()的函数定义保存为abstest.py文件了，那么，可以在该文件的当前目录下启动Python解释器，用from abstest import my_abs来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）。

空函数

如果想定义一个什么也不做的空函数，可以用pass语句：

1
2
def nop():
    pass

参数检查

数据类型检查可以用内置函数isinstance()实现：

1
2
3
4
5
6
7
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

返回多个值

比如在游戏中需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的新的坐标：

1
2
3
4
5
import math
def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

然后，我们就可以同时获得返回值：

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

但其实这只是一种假象，Python函数返回的仍然是单一值：

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

返回值是一个tuple！但在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值。

所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

函数的参数

位置参数

1
2
def power(x):
    return x * x

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

可以把power(x)修改为power(x, n)，用来计算xn，说干就干：

1
2
3
4
5
6
def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

修改后的power(x, n)函数有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。

默认参数

完全可以把第二个参数n的默认值设定为2：

1
2
3
4
5
6
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

这样，当调用power(5)时，相当于调用power(5, 2)。

设置默认参数时，有几点要注意：

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

  • 二是如何设置默认参数。当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

调用的时候，既可以按顺序提供默认参数，也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。

定义默认参数要牢记一点：默认参数必须指向不变对象！若一定要使用，则需要将默认参数指向None

可变参数

可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

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

在参数前面加了一个*号。

调用该函数时，可以传入任意个参数，包括0个参数：

1
2
3
4
>>> calc(1, 2)
5
>>> calc()
0

如果已经有一个list或者tuple，Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

1
2
3
>>> nums = [1, 2, 3]
>>> calc(*nums)
14

*nums表示把nums这个list的所有元素作为可变参数传进去。

关键字参数

可变参数允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

关键字参数允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

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

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

1
2
>>> person('Michael', 30)
name: Michael age: 30 other: {}

也可以传入任意个数的关键字参数：

1
2
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

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

1
2
3
>>> 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作为关键字参数。这种方式定义的函数如下：

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

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

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

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

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

1
2
def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

由于命名关键字参数city具有默认值，调用时，可不传入city参数：

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

使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数。

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数组合使用。

但是参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。

递归函数

在函数内部，可以调用其他函数。

如果一个函数在内部调用自身本身，这个函数就是递归函数。

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

1
2
3
4
5
6
7
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)

可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。

高级特性

切片

对经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。

一个list如下：

1
>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

取前3个元素，用一行代码就可以完成切片：

1
2
>>> L[0:3]
['Michael', 'Sarah', 'Tracy']

L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。

如果第一个索引是0，还可以省略：

1
2
>>> L[:3]
['Michael', 'Sarah', 'Tracy']

Python支持L[-1]取倒数第一个元素，也同样支持倒数切片：

1
2
>>> L[-2:]
['Bob', 'Jack']

记住倒数第一个元素的索引是-1。

前10个数，每两个取一个：

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

所有数，每5个取一个：

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

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

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

tuple也是一种list，唯一区别是tuple不可变。tuple也可以用切片操作，只是操作的结果仍是tuple：

1
2
>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

字符串'xxx'也可以看成是一种list，每个元素就是一个字符。字符串也可以用切片操作，只是操作结果仍是字符串：

1
2
3
4
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

在很多编程语言中，针对字符串提供了很多各种截取函数（例如，substring），其实目的就是对字符串切片。Python没有针对字符串的截取函数，只需要切片一个操作就可以完成。

迭代

通过for循环来遍历list或tuple，这种遍历我们称为迭代（Iteration）。

在Python中，迭代是通过for ... in来完成的，不仅可以用在list或tuple上，还可以作用在其他可迭代对象上。

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

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

Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

1
2
3
4
5
6
>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

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

列表生成式

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

举个例子，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))。

但要生成[1x1, 2x2, 3x3, ..., 10x10]使用循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的list：

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

写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来。

for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：

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

还可以使用两层循环，可以生成全排列：

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

for循环其实可以同时使用两个甚至多个变量，列表生成式也可以使用两个变量来生成list：

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

最后把一个list中所有的字符串变成小写：

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

生成器

如果列表元素可以在循环的过程中不断推算出后续的元素,这样就不必创建完整的list，从而节省大量的空间。

在Python中，这种一边循环一边计算的机制，称为生成器：generator。

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

1
2
3
4
5
6
>>> L = [x * x for x in range(3)]
>>> L
[0, 1, 4]
>>> g = (x * x for x in range(3))
>>> g
<generator object <genexpr> at 0x00000242136AA990>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

通过next()函数获得generator的下一个返回值：

1
2
3
4
5
6
7
8
9
10
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

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

正确的方法是使用for循环，因为generator也是可迭代对象：

1
2
3
4
5
6
7
>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4

所以，创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

例如斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1
2
3
4
5
6
7
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。

要把fib函数变成generator，只需要把print(b)改为yield b：

1
2
3
4
5
6
7
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

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

1
2
3
>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

generator和函数的执行流程不一样。

函数是顺序执行，遇到return语句或者最后一行函数语句就返回。

变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。generator在执行过程中，遇到yield就中断，下次又继续执行。

同样，把函数改成generator后，基本上不用next()来获取下一个返回值，而是使用for循环迭代：

1
2
3
4
5
6
>>> for n in fib(3):
...     print(n)
...
1
1
2

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

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> g = fib(3)
>>> 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
Generator return value: done

迭代器

可以直接作用于for循环的数据类型有以下几种：

  • 一类是集合数据类型，如list、tuple、dict、set、str等；
  • 一类是generator，包括生成器和带yield的generator function。

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

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

1
2
3
4
5
6
7
8
9
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

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

可以使用isinstance()判断一个对象是否是Iterator对象：

1
2
3
4
5
6
7
>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用 iter()函数：

1
2
3
4
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。Iterator甚至可以表示一个无限大的数据流，例如全体自然数。

-------------本文结束感谢您的阅读-------------
您的支持将是我前进的动力！