案例参考：廖雪峰——Python教程

基础知识

基本数据类型

用type()来判断数据类型：

数据类型检查可以用内置函数isinstance():

isinstance()后面也可以跟多个类型，多个类型之间是或的关系：

等价于isinstance(3.14, int) or isinstance(3.14, float)：

id()函数返回对象的唯一标识符，标识符是一个整数。CPython中id()函数用于获取对象的内存地址。

坚持使用4个空格的缩进:

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

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

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

你没有看错，整数的地板除//永远是整数，即使除不尽。要做精确的除法，使用/就可以。

因为//除法只取结果的整数部分，所以Python还提供一个余数运算，可以得到两个整数相除的余数：

对于很大的数，例如10000000000，很难数清楚0的个数。

Python允许在数字中间以_分隔，因此，写成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4

用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5

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

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

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

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

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量。

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

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

a = 'ABC' Python解释器干了两件事情：

1. 在内存中创建了一个'ABC'的字符串
2. 在内存中创建了一个名为a的变量，并把它指向'ABC'

b = a实际上是把变量b指向变量a所指向的数据。

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。

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

但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变。

所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。

字符串

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

如果字符串里面有很多字符都需要转义，就需要加很多\。

为了简化，Python还允许用r''表示''内部的字符串默认不转义。

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

多行字符串'''...'''还可以在前面加上r使用：

UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节。

常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。

在最新的Python3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言。

对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：

如果知道字符的整数编码，还可以用十六进制这么写str

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。

如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。

Python对bytes类型的数据用带b前缀的单引号或双引号表示：

要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。

以Unicode表示的str通过encode()方法可以编码为指定的bytes：

纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。

含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes;

要把bytes变为str，就需要用decode()方法：

如果bytes中包含无法解码的字节，decode()方法会报错；

如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节：

要计算str包含多少个字符，可以用len()函数：

len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数。

可见，1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节。

在操作字符串时，我们经常遇到str和bytes的互相转换。为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。

由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。

当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

Python字符串拼接有下面几种常用方式：

列表

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

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

比如，武林大会所有侠客的名字，就可以用一个list表示：

用len()函数可以获得list元素的个数：

用索引来访问list中每一个位置的元素，记得索引是从0开始的：

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

以此类推，可以获取倒数第2个：

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

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

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

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

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

元组

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

tuple和list非常类似，但是tuple一旦初始化就不能修改。

注意：这里的元组是小括号()，上面的列表是中括号[]。

它没有append()，insert()这样的方法。

其他获取元素的方法和list是一样的，你可以正常地使用heros[0]，heros[-1]，但不能赋值成另外的元素。

不可变的tuple有什么意义？

因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。

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

定义只有1个元素的tuple必须加一个逗号,

如果缺少逗号，看看会怎样？

字典

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

举个例子，假设要根据武侠人物的名字查找擅长的武功招式，就适合用dict实现。

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

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

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

要避免key不存在的错误，有两种办法：

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

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

请务必注意:

• dict内部存放的顺序和key放入的顺序是没有关系的；
• dict是用空间来换取时间的一种方法；
• dict的key必须是不可变对象；
• 在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。

集合

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

添加元素：

删除元素：

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

set和dict的唯一区别仅在于没有存储对应的value。

set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”

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

条件判断与循环

根据Python的缩进规则，如果if语句判断是True，就把缩进的两行print语句执行了，否则，什么也不做；

也可以给if添加一个else语句，意思是，如果if判断是False，不要执行if的内容，去把else执行了。

if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else：

if判断条件还可以简写。只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False：

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

为了让计算机能计算成千上万次的重复运算，我们就需要循环语句。

Python的循环有两种，一种是for...in循环，依次把list、tuple、dict、set中的每个元素迭代出来。

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

再比如我们想计算1-10的整数之和，可以用一个sum变量做累加：

如果要计算1-100的整数之和，从1写到100有点困难。

幸好Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。

比如range(5)生成的序列是从0开始小于5的整数：

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

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

与其他编程语言类似：

• break可以在循环过程中直接退出循环；
• continue可以提前结束本轮循环，并直接开始下一轮循环

函数

调用函数

Python内置了很多有用的函数，我们可以直接调用。可以在交互式命令行通过help(abs)查看abs函数的帮助信息：

调用abs函数：

max函数可以传入多个参数, 返回最大的元素：

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

函数名其实就是指向一个函数对象的引用。

完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”。

定义函数

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

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

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

return None可以简写为return。

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

pass语句什么都不做，那有什么用？

实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

pass还可以用在其他语句里, 如果缺少了pass，代码运行就会有语法错误：

Python中函数可以返回多个值：

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

原来返回值是一个tuple！

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

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

函数的参数

定义函数的时候，把参数的名字和位置确定下来，函数的接口定义就完成了。

Python的函数定义非常简单，但灵活度却非常大。

除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数。

使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。

先写一个计算x的平方的函数：

如果要计算x的3次方怎么办？

可以再定义一个power3函数，但是如果要计算x的4次方、5次方……怎么办？

可以把power(x)修改为power(x, n)，用来计算x的n次方：

调用函数时，传入的两个值按照位置顺序依次赋给参数x和n：

新的power(x, n)函数定义没有问题。但是，旧的调用代码失败了，原因是增加了一个参数，导致旧的函数因为缺少一个参数而无法正常调用。

这个时候，默认参数就排上用场了。由于我们经常计算x的平方，所以，完全可以把第二个参数n的默认值设定为2:

使用默认参数有什么好处？最大的好处是能降低调用函数的难度。

比如上面的例子: 在求一个数在平方时，我不需要传递n=2这个参数，而一旦需要更复杂的调用时，又可以传递更多的参数来实现。

无论是简单调用还是复杂调用，函数只需要定义一个。

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

1. 必选参数在前，默认参数在后；
2. 把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数；
3. 默认参数要牢记一点：默认参数必须指向不可变对象！

下面来看一个小案例：

对于上面的结果，有没有很疑惑？

原来，Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]。

每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

要修改上面的例子，可以用None这个不变对象来实现：

回过头来再看，为什么要设计str、None这样的不变对象呢？

因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。

此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。

在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

在Python函数中，还可以定义可变参数。

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

以数学题为例子，给定一组数字a，b，c...，请计算a*a + b*b + c*c + ...

要定义出这个函数，我们必须确定输入的参数。由于参数个数不确定，首先可以想到把参数设计为一个tuple传进来。

调用的时候，需要先组装出一个tuple：

但是这样对于调用方来说 可能显得有点麻烦，能不能有更方便的调用方式呢？

把函数的参数改为可变参数，仅仅在参数前面加了一个*号：

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

原来，在函数内部，可变参数nums接收到的是一个tuple。

如果已经有一个list或者tuple，要调用一个可变参数怎么办？

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

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

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

关键字参数有什么用？它可以扩展函数的功能。

比如，在person函数里，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

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

**d表示把d这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict。

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

下面来证明一下：

既然讲到这里，也同时来证明一下可变参数是否与关键字参数类似？

如果要限制关键字参数的名字，就可以用命名关键字参数。

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

例如，只接收skill和wife作为关键字参数：

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

命名关键字参数必须传入参数名，如果没有传入参数名，调用将报错。

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

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

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

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

最神奇的是通过一个tuple和dict，你也可以调用上述函数：

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

虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

小结：

• 默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
• *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的习惯写法，当然也可以用其他参数名，但最好使用习惯用法
• 命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值
• 定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数

递归函数

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

fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理：

高级特性

在Python中，代码不是越多越好，而是越少越好。代码不是越复杂越好，而是越简单越好。

基于这一思想，下面介绍Python中非常有用的高级特性，1行代码能实现的功能，决不写5行代码。请始终牢记，代码越少，开发效率越高。

切片

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

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

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

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

下面来个实战。

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

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

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

迭代

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

Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上。

list这种数据类型虽然有下标，但很多其他数据类型是没有下标的，但是，只要是可迭代对象，无论有无下标，都可以迭代。

下面看如何遍历字典：

默认情况下，dict迭代的是key。

字符串也是可迭代对象，因此，也可以作用于for循环：

所以，当使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行，而不需要关心该对象究竟是list还是其他数据类型。

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

如果要对list实现类似Java那样的下标循环怎么办？Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

列表生成式

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

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

但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？列表生成式则可以用一行语句生成：

写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来，十分有用，多写几次，很快就可以熟悉这种语法。

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

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

运用列表生成式，可以写出非常简洁的代码。下面看几个例子：

列表生成式也可以使用两个变量来生成list:

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

在一个列表生成式中，for前面的if ... else是表达式，而for后面的if是过滤条件，不能带else。

生成器

通过列表生成式，可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

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

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

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

可以使用for循环，因为generator也是可迭代对象：

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

比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

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

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(b)改为yield b就可以了：

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

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

迭代器

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

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

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

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

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

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

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

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

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

为什么list、dict、str等数据类型不是Iterator？

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

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

小结：

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

Python的for循环本质上就是通过不断调用next()函数实现的。

实际上完全等价于：

函数式编程

函数式编程（请注意多了一个“式”字）——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

高阶函数

变量可以指向函数, 函数本身也可以赋值给变量。

函数名也是变量, 函数名其实就是指向函数的变量！对于abs()这个函数，完全可以把函数名abs看成变量，它指向一个可以计算绝对值的函数！

把my_abs指向100后，就无法通过my_abs(-10)调用该函数了！因为my_abs这个变量已经不指向求绝对值函数而是指向一个整数10！

当然实际代码绝对不能这么写，这里是为了说明函数名也是变量。

注：实际上由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其它模块也生效，要用import builtins; builtins.abs = 10。

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

map

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

map()传入的第一个参数是f1，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

所以，map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x*x，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串

reduce

reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方说对一个序列求和，就可以用reduce实现,当然求和运算可直接用Python内建函数sum()

filter

filter()函数用于过滤序列。

和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

可见用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。

注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

sorted

排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。

此外，sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：

要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True

从上述例子可以看出，高阶函数的抽象能力是非常强大的，而且，核心代码可以保持得非常简洁。

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

上面在函数f(a, b)中又定义了函数y，并且，内部函数y可以引用外部函数的参数a, b，当f(a, b)返回函数y时，相关参数和变量都保存在返回的函数中，这种称为闭包（Closure）的程序结构拥有极大的威力。

请再注意一点，当我们调用f(a, b)时，每次调用都会返回一个新的函数，即使传入相同的参数：

闭包需要注意的问题是，返回的函数并没有立刻执行，而是直到被调用了才执行，下面看个例子。

你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果是：

全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

匿名函数

在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。下面看一个例子。

关键字lambda表示匿名函数，:前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。

此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数。

同样，也可以把匿名函数作为返回值返回，比如：

装饰器

函数对象有一个__name__属性，可以拿到函数的名字：

假设要增强hello()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改hello()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

本质上，decorator就是一个返回函数的高阶函数。所以，我们要定义一个能打印日志的decorator，可以定义如下：

观察上面的log，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。我们要借助Python的@语法，把decorator置于函数的定义处：

偏函数

在介绍函数参数的时候，我们知道通过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点。

int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换

但int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换：

如果要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，可以定义一个int2()的函数，默认把base=2传进去，如下：

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

所以，简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

注意到上面的新的int2函数，仅仅是把base参数重新设定默认值为2，但也可以在函数调用时传入其他值：

创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数，当传入：

实际上固定了int()函数的关键字参数base，也就是，int2('11')相当于：

再举个例子：

实际上会把10作为*args的一部分自动加到左边，也就是，my_max(1, 3, 5)相当于：

小结：当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

模块

开发过程中，随着程序代码越写越多，在一个文件里代码就会越来越长，越来越不容易维护。

为了编写可维护的代码，把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Python中，一个.py文件就称之为一个模块（Module）。

使用模块有什么好处？

• 大大提高了代码的可维护性。
• 编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用。我们在编写程序的时候，也经常引用其他模块，包括Python内置的模块和来自第三方的模块。
• 避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。

补充Python的所有内置函数：

https://docs.python.org/3/library/functions.html

如果不同的人编写的模块名相同怎么办？为了避免模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）。

举个例子，一个abc.py的文件就是一个名字叫abc的模块，一个xyz.py的文件就是一个名字叫xyz的模块。

现在，假设我们的abc和xyz这两个模块名字与其他模块冲突了，于是我们可以通过包来组织模块，避免冲突。方法是选择一个顶层包名，比如mycompany，按照如下目录存放：

mycompany

├─ __init__.py

├─ abc.py

└─ xyz.py

引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突。现在，abc.py模块的名字就变成了mycompany.abc，类似的，xyz.py的模块名变成了mycompany.xyz。

请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。

__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是mycompany。

类似的，可以有多级目录，组成多级层次的包结构。比如如下的目录结构：

mycompany

 ├─ web

 │  ├─ __init__.py

 │  ├─ utils.py

 │  └─ www.py

 ├─ __init__.py

 ├─ abc.py

 └─ utils.py

文件www.py的模块名就是mycompany.web.www，两个文件utils.py的模块名分别是mycompany.utils和mycompany.web.utils。

注意：自己创建模块时要注意命名，不能和Python自带的模块名称冲突。例如，系统自带了sys模块，自己的模块就不可命名为sys.py，否则将无法导入系统自带的sys模块。

总结：模块是一组Python代码的集合，可以使用其他模块，也可以被其他模块使用。

创建自己的模块时，要注意：

• 模块名要遵循Python变量命名规范，不要使用中文、特殊字符；
• 模块名不要和系统模块名冲突，最好先查看系统是否已存在该模块，检查方法是在Python交互环境执行import abc，若成功则说明系统存在此模块。

使用模块

Python本身就内置了很多非常有用的模块，只要安装完毕，这些模块就可以立刻使用。

以内建的sys模块为例，编写一个hello的模块

#!/usr/bin/env python3

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

' a test module '

__author__ = 'Michael Liao'

import sys

def test():

    args = sys.argv

    if len(args)==1:

        print('Hello, world!')

    elif len(args)==2:

        print('Hello, %s!' % args[1])

    else:

        print('Too many arguments!')

if __name__=='__main__':

    test()

• 第1行和第2行是标准注释，第1行注释可以让这个hello.py文件直接在Unix/Linux/Mac上运行，第2行注释表示.py文件本身使用标准UTF-8编码；
• 第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；
• 第6行使用__author__变量把作者写进去，这样当你公开源代码后别人就可以瞻仰你的大名；

以上就是Python模块的标准文件模板，当然也可以全部删掉不写，但是，按标准办事肯定没错。

后面开始就是真正的代码部分。

使用sys模块的第一步，就是导入该模块：import sys

导入sys模块后，我们就有了变量sys指向该模块，利用sys这个变量，就可以访问sys模块的所有功能。

sys模块有一个argv变量，用list存储了命令行的所有参数。argv至少有一个元素，因为第一个参数永远是该.py文件的名称，例如：

• 运行python3 hello.py获得的sys.argv就是['hello.py']；
• 运行python3 hello.py iflyendless获得的sys.argv就是['hello.py', 'iflyendless']。

最后，注意到这两行代码：

if __name__=='__main__':

    test()

当我们在命令行运行hello模块文件时，Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该hello模块时，if判断将失败，因此，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。

在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过_前缀来实现的。

正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等；

类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名；

类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等；

之所以我们说，private函数和变量不应该被直接引用，而不是“不能”被直接引用，是因为Python并没有一种方法可以完全限制访问private函数或变量，但是，从编程习惯上不应该引用private函数或变量。

为什么我们不应该引用private函数或变量呢？

内部逻辑用private对外隐藏，一般表示这属于内部的实现细节，而外部调用者只需要关心对外的公开的接口，这是一种非常有用的代码封装与抽象。如果你引用了别人的内部实现细节，就意味着别人的内部实现一旦发生变化，你的程序也就需要跟着去改动。这是非常糟糕的事！！！

总结：外部不需要引用的函数全部定义成private，只有外部需要引用的函数才定义为public。

安装第三方模块

安装第三方模块，可以通过包管理工具pip完成。

在使用Python时，我们经常需要用到很多第三方库，例如，MySQL驱动程序，Web框架Flask，科学计算Numpy等。用pip一个一个安装费时费力，还需要考虑兼容性。我们推荐直接使用Anaconda，这是一个基于Python的数据处理和科学计算平台，它已经内置了许多非常有用的第三方库，我们装上Anaconda，就相当于把许多常用第三方模块自动安装好了，非常简单易用。

下载后直接安装，Anaconda会把系统Path中的python指向自己自带的Python，并且，Anaconda安装的第三方模块会安装在Anaconda自己的路径下，不影响系统已安装的Python目录。

当我们试图加载一个模块时，Python会在指定的路径下搜索对应的.py文件，如果找不到，就会报错：ImportError: No module named xxx

默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块，搜索路径存放在sys模块的path变量中：

如果我们要添加自己的搜索目录，有两种方法：

• 直接修改sys.path，添加要搜索的目录：sys.path.append('...path/to/py_scripts...')，这种方法是在运行时修改，运行结束后失效;
• 设置环境变量PYTHONPATH，该环境变量的内容会被自动添加到模块搜索路径中。设置方式与设置Path环境变量类似。注意只需要添加你自己的搜索路径，Python自己本身的搜索路径不受影响。

异常处理

高级语言通常都内置了一套try...except...finally...的错误处理机制，Python也不例外。

try

先看个例子：

当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。

错误有很多种类，如果发生了不同类型的错误，应该由不同的except语句块处理，可以有多个except来捕获不同类型的错误：

正常执行的情况如下：

参数s转为int失败的情况如下：

除数为0的情况如下：

注意：Python所有的错误都是从BaseException类派生的，常见的错误类型和继承关系看这里。

https://docs.python.org/3/library/exceptions.html#exception-hierarchy

顺便提一句，与Java等高级语言类似，函数main()调用bar()，bar()调用foo()，结果foo()出错了，这时，只要main()捕获到了，就可以处理。

调用栈

如果错误没有被捕获，它就会一直往上抛，最后被Python解释器捕获，打印一个错误信息，然后程序退出。

出错并不可怕，可怕的是不知道哪里出错了。解读错误信息是定位错误的关键。我们从上往下可以看到整个错误的调用函数链。

注意：出错的时候，一定要分析错误的调用栈信息，才能定位错误的位置。

Python内置的logging模块可以非常容易地记录错误信息：

如果要手动抛出错误，首先根据需要，可以定义一个错误的class，选择好继承关系，然后，用raise语句抛出一个错误的实例：

只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型（比如ValueError，TypeError），尽量使用Python内置的错误类型。

与其他高级语言同样类似，如果不想处理异常，也可以抛出去让调用方去处理或者继续抛出。

面向对象

面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。上面介绍的大多属于面向过程编程的思想。

OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。

来个快速入门面向对象编程的案例，感受一下什么是面向对象。

如果用前面介绍的面向过程的思想来实现这一需求，是怎么做的呢？

咦，好像面向过程的代码更简单一些。实际情况是不是这样呢？如果还有其他的需求呢，比如说Hero要参加英雄大会，再比如说Hero在英雄大会上交战过哪几个对手，赢了几场，输了几场。用面向过程来实现的话，且不说每次都需要把name、skill等参数传到函数里面去，然后外层还需要用list数据结构存储交战过几个对手，外层也需要用2个变量存储该Hero赢了几场，输了几场。另外，如果要记录多个Hero的情况，用面向过程的思想，就需要在外部维护大量的描述信息与中间状态，程序的复杂度较大，扩展性也较差。而使用面向对象的思想来实现，外层不需要关心这些细节，只需要创建出来Hero对象，然后到哪一步了，直接调用对象的方法，不需要关心对象中间状态的存储与维护，因为这些信息都统一封装在对象内部了，非常符合软件编程高内聚的设计思想！

物以类聚，人以群分。面向对象的设计思想是从自然界中来的，因为在自然界中，类（Class）和实例（Instance）的概念是很自然的。Class是一种抽象概念，比如我们定义的Class——Hero，是指武侠人物这个概念，而实例（Instance）则是一个个具体的武侠人物，比如，李寻欢和令狐冲是两个具体的Hero。

一个Class既包含数据，又包含操作数据的方法。封装、继承和多态是面向对象的三大特性，随着程序学习的深入，你会自然理解。

类和实例

面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Hero类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

在Python中，定义类是通过class关键字：

class后面紧接着是类名，即Hero，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念后面再讲，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

定义好了Hero类，就可以根据Hero类创建出实例，创建实例是通过类名+()实现的：

可以自由地给一个实例变量绑定属性，比如，给实例hero1绑定一个name属性：

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，skill等属性绑上去：

注意：特殊方法__init__前后分别有两个下划线！！！

__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

既然Hero实例本身就拥有name、skill这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在Hero类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和Hero类本身是关联起来的，我们称之为类的方法：

要定义一个方法，除了第一个参数是self外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入：

这样一来，从外部看Hero类，就只需要知道，创建实例需要给出name和skill，而如何自我介绍，都是在Hero类的内部定义的，这些数据和逻辑被封装起来了，调用很容易，但却不用知道内部实现的细节。

小结：

• 类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；
• 方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；

和静态语言不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同：

访问限制

在Class内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，这样，就隐藏了内部的复杂逻辑。

外部代码还是可以自由地修改一个实例的属性

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把Hero类改一改：

改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__skill了：

这样就确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮。

但是如果外部代码要获取name和skill怎么办？可以给Hero类增加get_name和get_skill这样的方法：

如果又要允许外部代码修改skill怎么办？可以再给Hero类增加set_skill方法：

需要注意的是，在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__skill__这样的变量名。

有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

双下划线开头的实例变量是不是一定不能从外部访问呢？

其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Hero__name，所以，仍然可以通过_Hero__name来访问__name变量：

但是强烈建议你不要这么干，因为不同版本的Python解释器可能会把__name改成不同的变量名。

总的来说就是，Python本身没有任何机制阻止你干坏事，一切全靠自觉。

最后注意下面的这种错误写法：

表面上看，外部代码“成功”地设置了__name变量，但实际上这个__name变量和class内部的__name变量不是一个变量！内部的__name变量已经被Python解释器自动改成了_Hero__name，而外部代码给该对象新增了一个__name变量。不信试试：

继承和多态

在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。

比如，我们已经编写了一个名为Animal的class，有一个run()方法可以直接打印：

当我们需要编写Dog和Cat类时，就可以直接从Animal类继承：

对于Dog来说，Animal就是它的父类，对于Animal来说，Dog就是它的子类。

继承有什么好处？最大的好处是子类获得了父类的全部功能。由于Animial实现了run()方法，因此，Dog和Cat作为它的子类，什么事也没干，就自动拥有了run()方法：

继承的第二个好处是允许我们对代码做一点改进。你看到了，无论是Dog还是Cat，它们run()的时候，显示的都是Animal is running...，符合逻辑的做法是分别显示Dog is running...和Cat is running...，因此，对Dog和Cat类改进如下：

再次运行，结果如下：

当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()。这样，我们就获得了继承的另一个好处：多态。

判断一个变量是否是某个类型可以用isinstance()判断：

对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat还是其他派生对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的开闭原则。

其实，一般情况下，在有了一定的项目经验后才能真正理解多态、灵活运用多态，并配合常用的一些设计模式，能极大地提高程序的扩展性与可维护性。应用多态的关键在于抽象，能够捕捉到程序中变化的行为、可扩展的地方。这就是所谓的面向抽象编程、面向接口编程。本质上属于一种内功心法，平时项目中应该多锻炼抽象的能力。

继承还可以一级一级地继承下来，就好比从爷爷到爸爸、再到儿子这样的关系。而任何类，最终都可以追溯到根类object，比如如下的继承树：

对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。

对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了。

这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

获取对象信息

当拿到一个对象的引用时，如何知道这个对象是什么类型、有哪些方法呢？

判断对象类型，使用type()函数：

对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数。

还可以判断一个变量是否是某些类型中的一种：

使用isinstance()判断类型，可以将指定类型及其子类“一网打尽”。

如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法：

类似__xxx__的属性和方法在Python中都是有特殊用途的，比如__len__方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的__len__()方法

自己写的类，如果也想用len(myObj)的话，就自己写一个__len__()方法

仅仅把属性和方法列出来是不够的，配合getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态。看起来有点像Java或者Golang语言里面的反射哦。

也可以获得对象的方法

要注意的是，只有在不知道对象信息的时候，才会去获取对象信息然后尝试操作对象状态。一个正确的用法的例子如下：

实例属性和类属性

给实例绑定属性的方法是通过实例变量，或者通过self变量。

如果Hero类本身需要绑定属性呢？可以直接在class中定义属性，这种属性是类属性，归Hero类所有：

这个属性虽然归类所有，但类的所有实例都可以访问到。

可以看出，在编写程序的时候，千万不要对实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是当你删除实例属性后，再使用相同的名称，访问到的将是类属性。程序的可读性非常差，给自己找麻烦。

使用slots

创建了一个class的实例后，我们可以给该实例绑定任何属性和方法，这就是动态语言的灵活性。

但是，如果我们想要限制实例的属性怎么办？比如，只允许对Hero实例添加name和skill属性。

为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性：

由于wife没有被放到__slots__中，所以不能绑定wife属性，试图绑定wife将得到AttributeError的错误。

使用__slots__要注意，__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的。

除非在子类中也定义__slots__，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__。

使用@property

在绑定属性时，如果直接把属性暴露出去，虽然写起来很简单，但是，没办法检查参数，导致可以把对象属性随便改：