本文章中有部分代码为python2
慕课python入门
 慕课python进阶

布尔值

布尔值可以用and、or和not运算。
and运算是与运算，只有所有都为 True，and运算结果才是 True。
or运算是或运算，只要其中有一个为 True，or 运算结果就是 True。
not运算是非运算，它是一个单目运算符，把 True 变成 False，False 变成 True。
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

定义动态变量

（较类似指针#具体内容可以查看这个网址从C/C++软件工程师角度看Python的动态类型）

a=1
print (a)

同一个变量可以反复赋值，而且可以是不同类型的变量
- 当我们写：a = 'ABC'时，Python解释器干了两件事情：
  1. 在内存中创建了一个'ABC'的字符串；
  2. 在内存中创建了一个名为a的变量，并把它指向'ABC'。
- 也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据
这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。

静态语言

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

python字符串

Python字符串用\进行转义。
- 要表示字符串 Bob said "I'm OK".
```
'Bob said \"I\'m OK\".'
```
- \n 表示换行
- \t 表示一个制表符
- \ 表示 \ 字符本身
注意：转义字符 \ 不计入字符串的内容中。
如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。
例如:
```
r'\(~_~)/ \(~_~)/'
```
- 但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串
如果要表示多行字符串，可以用'''...'''表示：
```
'''Line 1 Line 2 Line 3'''
```
- 上面这个字符串的表示方法和下面的是完全一样的：
```
'Line 1\nLine 2\nLine 3'
```
还可以在多行字符串前面添加 r ，把这个多行字符串也变成一个raw字符串,但是要注意'''之后没有空格即使是这样（r''''xx''''）：
```
r'''Python is created by "Guido". It is free and easy to learn. Let's start learn Python in imooc!'''
```

Unicode

Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。
python3默认unicode，so,不用u'..'
Python2添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示，
比如：
```
print u'中文'
中文
```
- 注意:python2 不加 u ，中文就不能正常显示
Unicode字符串除了多了一个 u 之外，与普通字符串没啥区别，转义字符和多行表示法仍然有效：
- 转义：
```
u'中文\n日文\n韩文'
```
- 多行：
```
u'''第一行 第二行'''
```
- raw+多行：
```
ur'''Python的Unicode字符串支持"中文", "日文", "韩文"等多种语言'''
```
如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释
```
# -*- coding: utf-8 -*-
```
- 目的是告诉Python解释器，用UTF-8编码读取源代码。然后用Notepad++ 另存为... 并选择UTF-8格式保存。

and,or,not

在Python中，布尔类型还可以与其他数据类型做 and、or和not运算，
请看下面的代码：
```
a = True
print a and 'a=T' or 'a=F'
```
- 计算结果不是布尔类型，而是字符串 'a=T'，这是为什么呢？
- 因为Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True，所以： True and 'a=T' 计算结果是 'a=T' 继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'
- 要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：
  短路计算:
1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
1. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
  所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。
非运算：把True变为False，或者把False变为True：
- not True # ==> False
- not False # ==> True

List

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates # 打印classmates变量的内容
['Michael', 'Bob', 'Tracy']

由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据：
```
>>> L = ['Michael', 100, True]
```
一个元素也没有的list，就是空list：
```
>>> empty_list = []
```
-1 索引表示最后一个元素
```
>>> L = ['Adam', 'Lisa', 'Bart']
>>> print L[-1]
Bart
Bart同学表示躺枪。
```
- 类似的，倒数第二用 -2 表示，倒数第三用 -3 表示，倒数第四用 -4 表示：
```
>>> print L[-2]
Lisa
>>> print L[-3]
Adam
>>> print L[-4]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
```
  - L[-4] 报错了，因为倒数第四不存在，一共只有3个元素。
  - 使用倒序索引时，也要注意不要越界。
- 现在，班里有3名同学：
```
>>> L = ['Adam', 'Lisa', 'Bart']
```
- 今天，班里转来一名新同学 Paul，如何把新同学添加到现有的 list 中呢？
  1. 第一个办法是用 list 的 append() 方法，把新同学追加到 list 的末尾：
```
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.append('Paul')
>>> print L
['Adam', 'Lisa', 'Bart', 'Paul']
```
    - append()总是把新的元素添加到 list 的尾部。
  2. list的 insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：
```
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.insert(0, 'Paul')
>>> print L
['Paul', 'Adam', 'Lisa', 'Bart']
```
    - L.insert(0, 'Paul') 的意思是，'Paul'将被添加到索引为 0 的位置上（也就是第一个），而原来索引为 0 的Adam同学，以及后面的所有同学，都自动向后移动一位。
- Paul同学刚来几天又要转走了，那么我们怎么把Paul 从现有的list中删除呢？
  - 要把Paul踢出list，我们就必须先定位Paul的位置。由于Paul的索引是3，因此，用 pop(3)把Paul删掉：
```
>>> L.pop(3)
'Paul'
>>> print L
['Adam', 'Lisa', 'Bart']
```
  - 如果Paul同学排在最后一个，我们可以用list的pop()方法删除：
```
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L.pop()
'Paul'
>>> print L
['Adam', 'Lisa', 'Bart']
```
    - pop()方法总是删掉list的最后一个元素，并且它还返回这个元素，所以我们执行 L.pop() 后，会打印出 'Paul'。
- 假设现在班里仍然是3名同学：
```
>>> L = ['Adam', 'Lisa', 'Bart']
```
- 现在，Bart同学要转学走了，碰巧来了一个Paul同学，要更新班级成员名单，
  - 我们可以先把Bart删掉，再把Paul添加进来。
  - 另一个办法是直接用Paul把Bart给替换掉：
```
>>> L[2] = 'Paul'
>>> print L
L = ['Adam', 'Lisa', 'Paul']
```
  - 对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。
  - 由于Bart还可以用 -1 做索引，因此，下面的代码也可以完成同样的替换工作：
```
>>> L[-1] = 'Paul'
```

创建tuple

tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。
- 同样是表示班里同学的名称，用tuple表示如下：
```
>>> t = ('Adam', 'Lisa', 'Bart')
```
创建tuple和创建list唯一不同之处是用( )替代了[ ]。
- 现在，这个 t 就不能改变了，tuple没有 append()方法，也没有insert()和pop()方法。所以，新同学没法直接往 tuple 中添加，老同学想退出 tuple 也不行。
获取 tuple 元素的方式和 list 是一模一样的，我们可以正常使用 t[0]，t[-1]等索引方式访问元素，但是不能赋值成别的元素，
不信可以试试：
```
>>> t[0] = 'Paul'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
```
- 创建包含1个元素的 tuple 呢？来试试：
```
>>> t = (1)
>>> print t
1
```
  - 好像哪里不对！t 不是 tuple ，而是整数1。为什么呢？
  - 因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：
```
>>> t = (1,)
>>> print t
(1,)
```
- Python在打印单元素tuple时，也自动添加了一个“,”，为了更明确地告诉你这是一个tuple。
- 多元素 tuple 加不加这个额外的“,”效果是一样的：
```
>>> t = (1, 2, 3,)
>>> print t
(1, 2, 3)
```
可变”的tuple
- 前面我们看到了tuple一旦创建就不能修改。现在，我们来看一个“可变”的tuple：
```
>>> t = ('a', 'b', ['A', 'B'])
```
- 注意到 t 有 3 个元素：'a'，'b'和一个list：['A', 'B']。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到：
```
>>> L = t[2]
```
- 然后，我们把list的两个元素改一改： python >>> L[0] = 'X' >>> L[1] = 'Y'
- 再看看tuple的内容：
```
>>> print t
('a', 'b', ['X', 'Y'])
```
- 不是说tuple一旦定义后就不可变了吗？怎么现在又变了？
1. 定义的时候tuple包含的3个元素：当我们把list的元素'A'和'B'修改为'X'和'Y'后表面上看，tuple的元素确实变了，但其实变的不是 tuple 的元素，而是list的元素。
2. tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

Python代码的缩进规则

Python代码的缩进规则。具有相同缩进的代码被视为代码块，上面的3，4行 print 语句就构成一个代码块（但不包括第5行的print）。如果 if 语句判断为 True，就会执行这个代码块。缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。

if else

利用 if ... else ... 语句，我们可以根据条件表达式的值为 True 或者 False ，分别执行 if 代码块或者 else 代码块。
- 注意: else 后面有个“:”
用 if ... 多个elif ... else ... 的结构：
```
if age >= 18:
   print 'adult'
elif age >= 6:
   print 'teenager'
elif age >= 3:
   print 'kid'
else:
   print 'baby'
```
- elif 意思就是 else if。这样一来，我们就写出了结构非常清晰的一系列条件判断。

for

Python的 for 循环就可以依次把list或tuple的每个元素迭代出来：
```
L = ['Adam', 'Lisa', 'Bart']
for name in L:
    print name
```
- 注意: name 这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋值给 name，然后执行for循环体（就是缩进的代码块）。

while循环

和 for 循环不同的另一种循环是 while 循环，while 循环不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束。比如要从 0 开始打印不大于 N 的整数
```
n= 10
x = 0
while x < n:
    print x
    x = x + 1
```
- while循环每次先判断 x < n，如果为True，则执行循环体的代码块，否则，退出循环。
while True 就是一个死循环True要大写

break

break退出循环

continue

continue跳过后续循环代码，继续下一次循环。

dict

Python用 dict 表示“名字”-“成绩”的查找表如下：
　　　　 key:value
```
d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
```
我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。
花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。
由于dict也是集合，len() 函数可以计算任意集合的大小：
```
>>> len(d)
3
```

可以简单地使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key：

>>> print d['Adam']
95
>>> print d['Paul']
Traceback (most recent call last):
  File "index.py", line 11, in <module>
    print d['Paul']
KeyError: 'Paul'

注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。
- 要避免 KeyError 发生，有两个办法：
  1. 第一种是先判断一下 key 是否存在，用 in 操作符：
```
if 'Paul' in d:
print d['Paul']
```
    如果 'Paul' 不存在，if语句判断为False，自然不会执行 print d['Paul'] ，从而避免了错误。
  2. 第二种是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：
```
>>> print d.get('Bart')
59
>>> print d.get('Paul')
None
```
dict的特点
- dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。由于dict是按 key 查找，所以，在一个dict中，key不能重复。
- dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样：
```
d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
```
  当我们试图打印这个dict时
```
>>> print d
{'Lisa': 85, 'Adam': 95, 'Bart': 59}
```
  打印的顺序不一定是我们创建时的顺序，而且，不同的机器打印的顺序都可能不同，这说明dict内部是无序的，不能用dict存储有序的集合。
- dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。可以试试用list作为key时会报什么样的错误。
  - 不可变这个限制仅作用于key，value是否可变无所谓：
```
{
    '123': [1, 2, 3],  # key 是 str，value是list
    123: '123',  # key 是 int，value 是 str
    ('a', 'b'): True  # key 是 tuple，并且tuple的每个元素都是不可变对象，value是 boolean
}
```
  - 最常用的key还是字符串，因为用起来最方便。
更新dict
- dict是可变的，也就是说，我们可以随时往dict中添加新的 key-value。比如已有dict：
```
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
```
- 要把新同学'Paul'的成绩 72 加进去，用赋值语句：
```
>>> d['Paul'] = 72
```
  - 如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value

set

set 持有一系列元素，set的元素没有重复，而且是无序的。
创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：
```
>>> s = set(['A', 'B', 'C'])
```
- 因为set不能包含重复的元素，所以，当我们传入包含重复元素的 list 会怎么样呢？
```
>>> s = set(['A', 'B', 'C', 'C'])
>>> print s
set(['A', 'C', 'B'])
>>> len(s)
3
```
  - 结果显示，set会自动去掉重复的元素，原来的list有4个元素，但set只有3个元素。
set的特点
- set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。 set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。最后，set存储的元素也是没有顺序的。
  - 如果事先创建好一个set，包含'MON' ~ 'SUN'：
    weekdays = set(['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'])
    再判断输入是否有效，只需要判断该字符串是否在set中;
```
x = '???' # 用户输入的字符串
if x in weekdays:
    print 'input ok'
else:
    print 'input error'
```
    这样一来，代码就简单多了。
更新set
- 由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：
  - 一是把新的元素添加到set中，二是把已有元素从set中删除。
- 添加元素时，用set的add()方法：
  - 如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：
- 删除set中的元素时，用set的remove()方法：
  - 如果删除的元素不存在set中，remove()会报错：
- 所以用add()可以直接添加，而remove()前需要判断。

编写函数

在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
- 我们以自定义一个求绝对值的 my_abs 函数为例：
```
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
```
  - 如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None
    return None可以简写为return。
返回多值
```
import math
def move(x, y, step, angle):
    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.961524227 70.0
```
- 但其实这只是一种假象，Python函数返回的仍然是单一值：
```
>>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151.96152422706632, 70.0)
```
- 用print打印返回结果，原来返回值是一个tuple！
- 但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

汉诺塔问题：

汉诺塔

A	B	C
=\|	\|	\|
==\|	\|	\|
===\|	\|	\|
-----	----	--->

def move(n, a, b, c):
    if n ==1:
        print a, '-->', c
        return
    move(n-1, a, c, b)
    print a, '-->', c
    move(n-1, b, a, c)

move(n, a, b, c)表示的是有n个盘子，将要由a柱子转移到b柱子上面去
move(盘子数，起始地，中转地，目的地)
def move(n, a, b, c):
如果a柱子上面只有一个盘子，则直接移到c柱子上面去并输出路径，结束递归
```
if n == 1:
    print a, '-->', c
    return
```
表示的是将由上到下的n-1个盘子从a柱子上面移到b柱子上面去
```
    (a上 的n-1个,a---->b)
move(n-1        ,a, c, b)
```
输出最下面的那个盘子从a移到c的路径,（a上的第n个，a---->c）
```
print a, '-->', c
```

将b柱子上面的n-1个盘子移动到c柱子上面

    (b上n-1个,b---->c)
move(n-1     ,b, a, c)

定义默认参数
- 定义函数的时候，还可以有默认参数。
- 我们来定义一个计算 x 的N次方的函数并且计算平方的次数最多，我们就可以把 n 的默认值设定为 2：
```
def power(x, n=2):
s = 1
while n > 0:
    n = n - 1
    s = s * x
return s
```
- 这样一来，计算平方就不需要传入两个参数了：
```
>>> power(5)
25
```
- 由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：
定义（个数）可变参数
- 如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：
```
def fn(*args):
    print args
```
- 可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数：
```
>>> fn()
()
>>> fn('a')
('a',)
>>> fn('a', 'b')
('a', 'b')
```
- Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了
  例如：
```
def average(*args):
    sum=0.0
    if len(args) == 0:#使用的是args而不是*args
             return sum
    for n in args:
             sum=sum+n
     return sum/len(args)
```

对list进行切片

取一个list的部分元素是非常常见的操作。比如，一个list如下：
```
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
```
取前N个元素，也就是索引为0-(N-1)的元素，可以用循环：
```
>>> r = []
>>> n = 3
>>> for i in range(n):
        r.append(L[i])
```
- 对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。
对应上面的问题，取前3个元素，用一行代码就可以完成切片：
例：
注意：索引与索引所代表的元素的区别
L[起始索引a:b]，索引b - 索引a = 算上索引a所代表的一共取多少个元素（即由索引a所对应的开始取（b-a）个元素）
```
>>> L[0:3]
['Adam', 'Lisa', 'Bart']
```
- L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
- L[0:3]表示：由0开始一共取3-0个
- 如果第一个索引是0，还可以省略：
```
>>> L[:3]
['Adam', 'Lisa', 'Bart']
```
- 也可以从索引1开始，取出2个元素出来：
```
>>> L[1:3]
['Lisa', 'Bart']
```
- 只用一个 : ，表示从头到尾：
```
>>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul']
```
  - 因此，L[:]实际上复制出了一个新list。
切片操作还可以指定第三个参数：
```
>>> L[::2]
['Adam', 'Bart']
```
- 第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。即：
```
2：   0101010101
      0123456789
      0 2 4 6 8
```
  - 所以：2 是01，逢 0 就取
```
   3：	0120120120
         0123456789
         0  3  6  9
```
  - 所以：3 是012，逢 0 就取
如果把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。

倒序切片

    0 ，  1，  2，  3， 4，  5，  6， 7，  8，  9,
   -10， -9， -8， -7，-6， -5， -4，-3， -2， -1,一个邪恶的未知元素索引

所以，如果想表示最后一个元素的话，就必须L[-1:]

because，-1+1=0，and 0是最开始的地方，so,L[-1:](不可以写0)。但是，在大脑中计算时可以想象为0）其他方面和正常切片差不多

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L[-2:]
['Bart', 'Paul']
>>> L[:-2]#如果前方为空即为由起点开始不可以0进行计算，但是可以写为L[0:-2]
['Adam', 'Lisa']
>>> L[-3:-1]
['Lisa', 'Bart']
>>> L[-4:-1:2]
['Adam', 'Bart']

利用倒序切片对 1 - 100 的数列,取出最后10个5的倍数
```
L[4::5][-10:]
```
记住倒数第一个元素的索引是-1

对字符串切片

字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
```
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[-3:]
'EFG'
>>> 'ABCDEFG'[::2]
'ACEG'
```
Python没有针对字符串的截取函数，只需要切片一个操作就可以完成。

迭代

迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。

注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：
1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict
而迭代是一个动词，它指的是一种操作，在Python中，就是 for 循环。
迭代与按下标访问数组最大的不同是，后者是一种具体的迭代实现方式，而前者只关心迭代结果，根本不关心迭代内部是如何实现的。
索引迭代
- Python中，迭代永远是取出元素本身，而非元素的索引。
- 对于有序集合，元素确实是有索引的。有的时候，我们确实想在 for 循环中拿到索引，怎么办？
  - 方法是使用enumerate() 函数：
```
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
...     print index, '-', name
... 
0 - Adam
1 - Lisa
2 - Bart
3 - Paul
```
    - 使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name。但是，这不是 enumerate() 的特殊语法。实际上，enumerate() 函数把： ['Adam', 'Lisa', 'Bart', 'Paul']
    - 变成了类似：[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')] 把list每一个元素与对应的索引绑在了一起因此，迭代的每一个元素实际上是一个tuple
```
for t in enumerate(L):
index = t[0]
name = t[1]
print index, '-', name
```
      - 如果我们知道每个tuple元素都包含两个元素，for循环又可以进一步简写为：
        
        for index, name in enumerate(L): print index, '-', name
        
        这样不但代码更简单，而且还少了两条赋值语句。
      - 可见，索引迭代也不是真的按索引访问，而是由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple，再迭代，就同时获得了索引和元素本身。

迭代dict的value

如果我们希望迭代 dict 对象的value，应该怎么做？

dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value：

>>>d = { 
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
       }
>>>print d.values()
[85, 95, 59]
>>>for v in d.values():
 print v
<span class="hljs-number">85</span>
<span class="hljs-number">95</span>
<span class="hljs-number">59</span>

如果仔细阅读Python的文档，还可以发现，dict除了values()方法外，还有一个 itervalues()python3无此语法方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.itervalues()（python3无此语法）
<dictionary-valueiterator object at 0x106adbb50>
for v in d.itervalues()（python3无此语法）:
 print v
 85
 95
 59
</code></pre>
</li>
</ul>
<ol>
<li>
<p>values() 方法实际上把一个 dict 转换成了包含 value 的list。</p>
</li>
<li>
<p>但是 itervalues() （python3无此语法）方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。</p>
</li>
</ol>
<ul>
<li>如果一个对象说自己可迭代，那我们就直接用 for 循环去迭代它，
可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。</li>
</ul>
</li>
<li>
<p>迭代dict的key和value</p>
<p>-我们了解了如何迭代 dict 的key和value，那么，在一个 for 循环中，能否同时迭代 key和value？<br>
答案是肯定的。</p>
<ul>
<li>首先，我们看看 dict 对象的 items() 方法返回的值：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>d = { <span class="hljs-string">'Adam'</span>: <span class="hljs-number">95</span>, <span class="hljs-string">'Lisa'</span>: <span class="hljs-number">85</span>, <span class="hljs-string">'Bart'</span>: <span class="hljs-number">59</span> }
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">print</span> d.items()
[(<span class="hljs-string">'Lisa'</span>, <span class="hljs-number">85</span>), (<span class="hljs-string">'Adam'</span>, <span class="hljs-number">95</span>), (<span class="hljs-string">'Bart'</span>, <span class="hljs-number">59</span>)]
</code></pre>
</li>
<li>可以看到，items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">for</span> key, value <span class="hljs-keyword">in</span> d.items():
<span class="hljs-meta">... </span>    <span class="hljs-keyword">print</span> key, <span class="hljs-string">':'</span>, value
<span class="hljs-meta">... </span>
Lisa : <span class="hljs-number">85</span>
Adam : <span class="hljs-number">95</span>
Bart : <span class="hljs-number">59</span>
```python
</code></pre>
</li>
<li>和 values() 有一个 itervalues() 类似， items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>生成列表</h1>
<ul>
<li>
<p>要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们可以用range(1, 11)：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>range(<span class="hljs-number">1</span>, <span class="hljs-number">11</span>)
[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>, <span class="hljs-number">10</span>]
</code></pre>
</li>
<li>
<p>但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？</p>
<ol>
<li>方法一是循环：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>L = []
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(<span class="hljs-number">1</span>, <span class="hljs-number">11</span>):
<span class="hljs-meta">... </span>   L.append(x * x)
<span class="hljs-meta">... </span>
<span class="hljs-meta">&gt;&gt;&gt; </span>L
[<span class="hljs-number">1</span>, <span class="hljs-number">4</span>, <span class="hljs-number">9</span>, <span class="hljs-number">16</span>, <span class="hljs-number">25</span>, <span class="hljs-number">36</span>, <span class="hljs-number">49</span>, <span class="hljs-number">64</span>, <span class="hljs-number">81</span>, <span class="hljs-number">100</span>]
</code></pre>
</li>
<li>但是循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的list：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>[x * x <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(<span class="hljs-number">1</span>, <span class="hljs-number">11</span>)]
[<span class="hljs-number">1</span>, <span class="hljs-number">4</span>, <span class="hljs-number">9</span>, <span class="hljs-number">16</span>, <span class="hljs-number">25</span>, <span class="hljs-number">36</span>, <span class="hljs-number">49</span>, <span class="hljs-number">64</span>, <span class="hljs-number">81</span>, <span class="hljs-number">100</span>]
</code></pre>
</li>
</ol>
</li>
<li>
<p>提示：range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]，与切片类似
这种写法就是Python特有的列表生成式。利用列表生成式，可以以非常简洁的代码生成 list。</p>
</li>
<li>
<p>写列表生成式时，把要生成的元素 x * x 放到前面，后面跟 for 循环，就可以把list创建出来，十分有用，多写几次，很快就可以熟悉这种语法</p>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>复杂表达式</h1>
<ul>
<li>
<p>使用for循环的迭代不仅可以迭代普通的list，还可以迭代dict。</p>
<ul>
<li>
<p>假设有如下的dict：</p>
<pre class="hljs"><code>d = { <span class="hljs-string">'Adam'</span>: <span class="hljs-number">95</span>, <span class="hljs-string">'Lisa'</span>: <span class="hljs-number">85</span>, <span class="hljs-string">'Bart'</span>: <span class="hljs-number">59</span> }
</code></pre>
</li>
<li>
<p>完全可以通过一个复杂的列表生成式把它变成一个 HTML 表格：</p>
<pre class="hljs"><code>tds = [<span class="hljs-string">'&lt;tr&gt;&lt;td&gt;%s&lt;/td&gt;&lt;td&gt;%s&lt;/td&gt;&lt;/tr&gt;'</span> % (name, score) <span class="hljs-keyword">for</span> name, score <span class="hljs-keyword">in</span> d.items()]
<span class="hljs-keyword">print</span> <span class="hljs-string">'&lt;table&gt;'</span>
<span class="hljs-keyword">print</span> <span class="hljs-string">'&lt;tr&gt;&lt;th&gt;Name&lt;/th&gt;&lt;th&gt;Score&lt;/th&gt;&lt;tr&gt;'</span>
<span class="hljs-keyword">print</span> <span class="hljs-string">'\n'</span>.join(tds)
<span class="hljs-keyword">print</span> <span class="hljs-string">'&lt;/table&gt;'</span>
</code></pre>
</li>
<li>
<p>注：字符串可以通过 % 进行格式化，用指定的参数替代 %s。字符串的join()方法可以把一个 list 拼接成一个字符串。</p>
</li>
<li>
<p>把打印出来的结果保存为一个html文件，就可以在浏览器中看到效果了：</p>
  <table border="1">
  <tr><th>Name</th><th>Score</th><tr>
  <tr><td>Lisa</td><td>85</td></tr>
  <tr><td>Adam</td><td>95</td></tr>
  <tr><td>Bart</td><td>59</td></tr>
  </table>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>条件过滤</h1>
<ul>
<li>
<p>列表生成式的 for 循环后面还可以加上 if 判断。例如：</p>
<ul>
<li>如果我们想要偶数的平方，可以加上 if 来筛选：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>[x * x <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(<span class="hljs-number">1</span>, <span class="hljs-number">11</span>) <span class="hljs-keyword">if</span> x % <span class="hljs-number">2</span> == <span class="hljs-number">0</span>]
[<span class="hljs-number">4</span>, <span class="hljs-number">16</span>, <span class="hljs-number">36</span>, <span class="hljs-number">64</span>, <span class="hljs-number">100</span>]
</code></pre>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>多层表达式</h1>
<ul>
<li>
<p>for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。</p>
<ul>
<li>对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>[m + n <span class="hljs-keyword">for</span> m <span class="hljs-keyword">in</span> <span class="hljs-string">'ABC'</span> <span class="hljs-keyword">for</span> n <span class="hljs-keyword">in</span> <span class="hljs-string">'123'</span>]
[<span class="hljs-string">'A1'</span>, <span class="hljs-string">'A2'</span>, <span class="hljs-string">'A3'</span>, <span class="hljs-string">'B1'</span>, <span class="hljs-string">'B2'</span>, <span class="hljs-string">'B3'</span>, <span class="hljs-string">'C1'</span>, <span class="hljs-string">'C2'</span>, <span class="hljs-string">'C3'</span>]
</code></pre>
</li>
</ul>
</li>
<li>
<p>翻译成循环代码就像下面这样：</p>
<pre class="hljs"><code>L = []
<span class="hljs-keyword">for</span> m <span class="hljs-keyword">in</span> <span class="hljs-string">'ABC'</span>:
    <span class="hljs-keyword">for</span> n <span class="hljs-keyword">in</span> <span class="hljs-string">'123'</span>:
        L.append(m + n)
</code></pre>
</li>
<li>
<p>list 如下:</p>
<pre class="hljs"><code>L = [<span class="hljs-string">'Adam'</span>, <span class="hljs-string">'Lisa'</span>, <span class="hljs-string">'Paul'</span>, <span class="hljs-string">'Bart'</span>]
</code></pre>
<p>Paul的索引是2，Bart的索引是3，如果我们要把Paul和Bart都删掉，
请解释下面的代码为什么不能正确运行：</p>
<pre class="hljs"><code>L.pop(<span class="hljs-number">2</span>)
L.pop(<span class="hljs-number">3</span>)
</code></pre>
<p>怎样调整代码可以把Paul和Bart都正确删除掉？</p>
<ol>
<li>当首先删除索引为 2 的Paul时，L变成了：<pre class="hljs"><code>[<span class="hljs-string">'Adam'</span>, <span class="hljs-string">'Lisa'</span>, <span class="hljs-string">'Bart'</span>]
</code></pre>
这时，注意到Bart的索引已经从原来的3变成2了！</li>
</ol>
</li>
<li>
<p>参考代码:</p>
<pre class="hljs"><code>L = [<span class="hljs-string">'Adam'</span>, <span class="hljs-string">'Lisa'</span>, <span class="hljs-string">'Paul'</span>, <span class="hljs-string">'Bart'</span>]
L.pop(<span class="hljs-number">3</span>)<span class="hljs-comment">#由后到前</span>
L.pop(<span class="hljs-number">2</span>)
<span class="hljs-keyword">print</span> L
</code></pre>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>set,list,tuple,dict</h1>
<table><tbody><tr><th></th></tr><tr><td>
set</td><td>添加元素时，用set的add()方法<br>
	删除set中的元素时，用set的remove()方法</td></tr><tr><td>
list</td><td>append()总是把新的元素添加到 list 的尾部。<br>
	insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素<br>
	用 pop(索引)把索引对应的元素删掉，并且它还返回这个元素<br>
	pop()方法总是删掉list的最后一个元素，并且它还返回这个元素</tr><tr><td>
tuple</td><td>	tuple一旦创建完毕，就不能修改了。</tr><tr><td>
dict</td><td>用 pop(索引)把索引对应的元素删掉，并且它还返回这个元素
	dict[key]=value</td></tr></tbody></table></div>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<p><font size=5 color="yellow">注意python内层函数可以访问外层函数中定义 的变量，但不能重新赋值（rebind）</font></p>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>高阶函数</h1>
<ul>
<li>
<p>把函数作为参数<br>
例：</p>
<pre class="hljs"><code><span class="hljs-keyword">import</span> math
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add</span><span class="hljs-params">(x, y, f)</span>:</span>
    <span class="hljs-keyword">return</span> f(x) + f(y)
<span class="hljs-keyword">print</span> add(<span class="hljs-number">25</span>, <span class="hljs-number">9</span>,math.sqrt)
</code></pre>
</li>
<li>
<p>map()函数</p>
<ul>
<li>
<p>map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，
并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。</p>
</li>
<li>
<p>例如，对于<code>list [1, 2, 3, 4, 5, 6, 7, 8, 9]</code>
如果希望把list的每个元素都作平方，就可以用map()函数：</p>
</li>
<li>
<p>因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fun</span><span class="hljs-params">(x)</span>:</span>
    <span class="hljs-keyword">return</span> x*x

<span class="hljs-keyword">print</span> map(fun, [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>])<span class="hljs-comment">#python2的map()</span>
print(list(map(fun, [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>])))<span class="hljs-comment">#python3的map()</span>
</code></pre>
</li>
</ul>
</li>
<li>
<p>reduce()函数</p>
<ul>
<li>
<p>reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，
一个函数 f，一个list，但<font color="yellow">行为和 map()不同，reduce()传入的函数f 必须接收两个参数，
reduce()对list的每个元素反复调用函数f，并返回最终结果值。</font></p>
</li>
<li>
<p>例如，编写一个f函数，接收x和y，返回x和y的和：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">(x, y)</span>:</span>
    <span class="hljs-keyword">return</span> x + y
</code></pre>
</li>
<li>
<p>调用 reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：<br>
先计算头两个元素：f(1, 3)，结果为4；<br>
再把结果和第3个元素计算：f(4, 5)，结果为9；<br>
再把结果和第4个元素计算：f(9, 7)，结果为16；<br>
再把结果和第5个元素计算：f(16, 9)，结果为25；<br>
由于没有更多的元素了，计算结束，返回结果25。</p>
</li>
<li>
<p>上述计算实际上是对 list 的所有元素求和。虽然Python内置了求和函数sum()，但是，利用reduce()求和也很简单。</p>
</li>
<li>
<p>reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：</p>
<pre class="hljs"><code>reduce(f, [<span class="hljs-number">1</span>, <span class="hljs-number">3</span>, <span class="hljs-number">5</span>, <span class="hljs-number">7</span>, <span class="hljs-number">9</span>], <span class="hljs-number">100</span>)<span class="hljs-comment">###python2</span>
</code></pre>
<pre class="hljs"><code><span class="hljs-keyword">import</span> functools<span class="hljs-comment">###python3</span>
functools.reduce(f, [<span class="hljs-number">1</span>, <span class="hljs-number">3</span>, <span class="hljs-number">5</span>, <span class="hljs-number">7</span>, <span class="hljs-number">9</span>], <span class="hljs-number">100</span>)
</code></pre>
</li>
<li>
<p>结果将变为125，因为第一轮计算是：</p>
</li>
<li>
<p>计算初始值和第一个元素：f(100, 1)，结果为101。</p>
</li>
</ul>
</li>
<li>
<p>filter()函数</p>
<ul>
<li>
<p>filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，
这个函数 f 的作用是对每个元素进行判断，返回 True或 False，</p>
</li>
<li>
<p>filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。</p>
</li>
<li>
<p>例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，<br>
首先，要编写一个判断奇数的函数：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">is_odd</span><span class="hljs-params">(x)</span>:</span>
<span class="hljs-keyword">return</span> x % <span class="hljs-number">2</span> == <span class="hljs-number">1</span>
</code></pre>
</li>
<li>
<p>然后，利用filter()过滤掉偶数：</p>
<pre class="hljs"><code>filter(is_odd, [<span class="hljs-number">1</span>, <span class="hljs-number">4</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">9</span>, <span class="hljs-number">12</span>, <span class="hljs-number">17</span>])
</code></pre>
</li>
<li>
<p>结果：<code>[1, 7, 9, 17]</code></p>
</li>
<li>
<p>利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">is_not_empty</span><span class="hljs-params">(s)</span>:</span>
    <span class="hljs-keyword">return</span> s <span class="hljs-keyword">and</span> len(s.strip()) &gt; <span class="hljs-number">0</span>
filter(is_not_empty, [<span class="hljs-string">'test'</span>, <span class="hljs-keyword">None</span>, <span class="hljs-string">''</span>, <span class="hljs-string">'str'</span>, <span class="hljs-string">'  '</span>, <span class="hljs-string">'END'</span>])
</code></pre>
</li>
<li>
<p>结果：<code>['test', 'str', 'END']</code></p>
</li>
<li>
<p>注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。</p>
</li>
<li>
<p>当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下：</p>
<pre class="hljs"><code>a = <span class="hljs-string">'     123'</span>
a.strip()
</code></pre>
</li>
<li>
<p>结果：<code>'123'</code></p>
</li>
</ul>
<pre class="hljs"><code>a=<span class="hljs-string">'\t\t123\r\n'</span>
a.strip()
</code></pre>
<ul>
<li>结果：<code>'123'</code></li>
</ul>
</li>
<li>
<p>自定义排序函数</p>
<ul>
<li>
<p>Python内置的 sorted()函数可对list进行排序：</p>
<pre class="hljs"><code>&gt;&gt;&gt;sorted([<span class="hljs-number">36</span>, <span class="hljs-number">5</span>, <span class="hljs-number">12</span>, <span class="hljs-number">9</span>, <span class="hljs-number">21</span>])
[<span class="hljs-number">5</span>, <span class="hljs-number">9</span>, <span class="hljs-number">12</span>, <span class="hljs-number">21</span>, <span class="hljs-number">36</span>]
</code></pre>
</li>
<li>
<p>但 sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，</p>
</li>
<li>
<p>比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，
返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。</p>
</li>
<li>
<p>因此，如果我们要实现倒序排序，只需要编写一个reversed_cmp函数：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">reversed_cmp</span><span class="hljs-params">(x, y)</span>:</span>
    <span class="hljs-keyword">if</span> x &gt; y:
    <span class="hljs-keyword">return</span> <span class="hljs-number">-1</span>
<span class="hljs-keyword">if</span> x &lt; y:
    <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>
<span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
</code></pre>
</li>
<li>
<p>这样，调用 sorted() 并传入 reversed_cmp 就可以实现倒序排序：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>sorted([<span class="hljs-number">36</span>, <span class="hljs-number">5</span>, <span class="hljs-number">12</span>, <span class="hljs-number">9</span>, <span class="hljs-number">21</span>], reversed_cmp)
[<span class="hljs-number">36</span>, <span class="hljs-number">21</span>, <span class="hljs-number">12</span>, <span class="hljs-number">9</span>, <span class="hljs-number">5</span>]
</code></pre>
</li>
<li>
<p><font color="yellow">python3</font></p>
<pre class="hljs"><code>&gt;&gt;&gt;<span class="hljs-keyword">import</span> functools
&gt;&gt;&gt;sorted([<span class="hljs-number">36</span>, <span class="hljs-number">5</span>, <span class="hljs-number">12</span>, <span class="hljs-number">9</span>, <span class="hljs-number">21</span>], key=functools.cmp_to_key(reversed_cmp))
在python3中其实可以
&gt;&gt;&gt;sorted([<span class="hljs-number">36</span>, <span class="hljs-number">5</span>, <span class="hljs-number">12</span>, <span class="hljs-number">9</span>, <span class="hljs-number">21</span>], reverse=<span class="hljs-keyword">True</span>)<span class="hljs-comment">#记住True的T要大写</span>
可以用key=abs来排列绝对值
</code></pre>
</li>
<li>
<p>sorted()也可以对字符串进行排序，字符串默认按照ASCII大小来比较：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>sorted([<span class="hljs-string">'bob'</span>, <span class="hljs-string">'about'</span>, <span class="hljs-string">'Zoo'</span>, <span class="hljs-string">'Credit'</span>])
[<span class="hljs-string">'Credit'</span>, <span class="hljs-string">'Zoo'</span>, <span class="hljs-string">'about'</span>, <span class="hljs-string">'bob'</span>]
</code></pre>
<p>'Zoo'排在'about'之前是因为'Z'的ASCII码比'a'小。</p>
</li>
<li>
<p><font color="yellow">python3</font></p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>sorted([<span class="hljs-string">'bob'</span>, <span class="hljs-string">'about'</span>, <span class="hljs-string">'Zoo'</span>, <span class="hljs-string">'Credit'</span>])
如果想忽略大小写可以调用upper或lower函数
<span class="hljs-meta">&gt;&gt;&gt; </span>sorted([<span class="hljs-string">'bob'</span>, <span class="hljs-string">'about'</span>, <span class="hljs-string">'Zoo'</span>, <span class="hljs-string">'Credit'</span>],key=str.upper)
</code></pre>
</li>
</ul>
</li>
<li>
<p>返回函数</p>
<ul>
<li>Python的函数可以返回函数！</li>
<li>定义一个函数 f()，我们让它返回一个函数 g，可以这样写：<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">()</span>:</span>
    <span class="hljs-keyword">print</span> <span class="hljs-string">'call f()...'</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">g</span><span class="hljs-params">()</span>:</span>
    <span class="hljs-keyword">print</span> <span class="hljs-string">'call g()...'</span>
<span class="hljs-keyword">return</span> g <span class="hljs-comment"># 返回函数g</span>
</code></pre>
</li>
<li>返回函数可以把一些计算延迟执行。</li>
<li>由于可以返回函数，我们在后续代码里就可以决定到底要不要调用该函数</li>
</ul>
</li>
<li>
<p>闭包</p>
<ul>
<li>
<p>内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。</p>
</li>
<li>
<p>闭包的特点是返回的函数还引用了外层函数的局部变量，</p>
</li>
<li>
<p><font color="yellow">所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变</font></p>
</li>
<li>
<p>例如：具体细节请看错题2</p>
</li>
</ul>
</li>
<li>
<p>匿名函数</p>
<ul>
<li>
<p>以map()函数为例，计算 f(x)=x2 时，除了定义一个f(x)的函数外，
还可以直接传入匿名函数：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>map(<span class="hljs-keyword">lambda</span> x: x * x, [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>])<span class="hljs-comment">###python2</span>
[<span class="hljs-number">1</span>, <span class="hljs-number">4</span>, <span class="hljs-number">9</span>, <span class="hljs-number">16</span>, <span class="hljs-number">25</span>, <span class="hljs-number">36</span>, <span class="hljs-number">49</span>, <span class="hljs-number">64</span>, <span class="hljs-number">81</span>]

&gt;&gt;&gt;list( map(<span class="hljs-keyword">lambda</span> x: x * x, [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]))<span class="hljs-comment">###python3</span>
[<span class="hljs-number">1</span>, <span class="hljs-number">4</span>, <span class="hljs-number">9</span>, <span class="hljs-number">16</span>, <span class="hljs-number">25</span>, <span class="hljs-number">36</span>, <span class="hljs-number">49</span>, <span class="hljs-number">64</span>, <span class="hljs-number">81</span>]
</code></pre>
</li>
<li>
<p>通过对比可以看出，匿名函数 lambda x: x * x 实际上就是：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">(x)</span>:</span>
    <span class="hljs-keyword">return</span> x * x
</code></pre>
</li>
<li>
<p>关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。</p>
</li>
<li>
<p>匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。</p>
</li>
<li>
<p>返回函数的时候，也可以返回匿名函数：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>myabs = <span class="hljs-keyword">lambda</span> x: -x <span class="hljs-keyword">if</span> x &lt; <span class="hljs-number">0</span> <span class="hljs-keyword">else</span> x 
<span class="hljs-meta">&gt;&gt;&gt; </span>myabs(<span class="hljs-number">-1</span>)
<span class="hljs-number">1</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>myabs(<span class="hljs-number">1</span>)
<span class="hljs-number">1</span>
</code></pre>
</li>
</ul>
</li>
<li>
<p>装饰器decorator</p>
<ul>
<li>例：<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">(x)</span>:</span>
	<span class="hljs-keyword">return</span> x*<span class="hljs-number">2</span>

<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">new_fn</span><span class="hljs-params">(f)</span>:</span><span class="hljs-comment">#装饰器函数</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fn</span><span class="hljs-params">(x)</span>:</span>
	    <span class="hljs-keyword">print</span> f._name_+<span class="hljs-string">'say '</span>hello<span class="hljs-string">''</span>
	    <span class="hljs-keyword">return</span> f(x)
<span class="hljs-keyword">return</span> fn
</code></pre>
</li>
<li><font color="yellow">所以调用new_fn(f)时，</font>
<ul>
<li>1.定义了fn(x)</li>
<li>2.return fn即调用了fn</li>
<li>so,
<ul>
<li>3.print</li>
<li>4.return f(x)</li>
<li>5.f=new_fn(f)</li>
<li>6.print f1(5)#f1的原始定义函数被彻底隐藏了</li>
</ul>
</li>
</ul>
</li>
<li>python内置的@语法就是为了简化装饰器调用</li>
</ul>
</li>
<li>
<p>编写无参数decorator</p>
<ul>
<li>
<p>使用 decorator 用Python提供的 @ 语法，
这样可以避免手动编写 f = decorate(f) 这样的代码。</p>
</li>
<li>
<p>一个@log的定义：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">log</span><span class="hljs-params">(f)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fn</span><span class="hljs-params">(x)</span>:</span>
        <span class="hljs-keyword">print</span> <span class="hljs-string">'call '</span> + f.__name__ + <span class="hljs-string">'()...'</span>
        <span class="hljs-keyword">return</span> f(x)
<span class="hljs-keyword">return</span> fn
</code></pre>
</li>
<li>
<p>对于阶乘函数</p>
<pre class="hljs"><code><span class="hljs-meta">@log</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">factorial</span><span class="hljs-params">(n)</span>:</span>
    <span class="hljs-keyword">return</span> reduce(<span class="hljs-keyword">lambda</span> x,y: x*y, range(<span class="hljs-number">1</span>, n+<span class="hljs-number">1</span>))
<span class="hljs-keyword">print</span> factorial(<span class="hljs-number">10</span>)
</code></pre>
<p>结果：</p>
<pre class="hljs"><code>call factorial()...
<span class="hljs-number">3628800</span>
</code></pre>
</li>
<li>
<p>但是，对于参数不是一个的函数，调用将报错：</p>
<pre class="hljs"><code><span class="hljs-meta">@log</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add</span><span class="hljs-params">(x, y)</span>:</span>
    <span class="hljs-keyword">return</span> x + y
<span class="hljs-keyword">print</span> add(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>)
</code></pre>
</li>
<li>
<p>因为 add() 函数需要传入两个参数，但是 @log 写死了只含一个参数的返回函数。</p>
</li>
<li>
<p>要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，
保证任意个数的参数总是能正常调用：</p>
</li>
</ul>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">log</span><span class="hljs-params">(f)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fn</span><span class="hljs-params">(*args, **kw)</span>:</span>
        <span class="hljs-keyword">print</span> <span class="hljs-string">'call '</span> + f.__name__ + <span class="hljs-string">'()...'</span>
        <span class="hljs-keyword">return</span> f(*args, **kw)
    <span class="hljs-keyword">return</span> fn
</code></pre>
<p>现在，对于任意函数，@log 都能正常工作。</p>
</li>
<li>
<p>编写带参数decorator</p>
<ul>
<li>
<p>考察上一节的 @log 装饰器：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">log</span><span class="hljs-params">(f)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fn</span><span class="hljs-params">(x)</span>:</span>
        <span class="hljs-keyword">print</span> <span class="hljs-string">'call '</span> + f.__name__ + <span class="hljs-string">'()...'</span>
        <span class="hljs-keyword">return</span> f(x)
<span class="hljs-keyword">return</span> fn
</code></pre>
</li>
<li>
<p>发现对于被装饰的函数，log打印的语句是不能变的（除了函数名）。</p>
</li>
<li>
<p>如果有的函数非常重要，希望打印出'[INFO] call xxx()...'，有的函数不太重要，
希望打印出'[DEBUG] call xxx()...'，这时，log函数本身就需要传入'INFO'或'DEBUG'这样的参数，<br>
类似这样：</p>
<pre class="hljs"><code><span class="hljs-meta">@log('DEBUG')</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">my_func</span><span class="hljs-params">()</span>:</span>
    <span class="hljs-keyword">pass</span>

</code></pre>
</li>
<li>
<p>所以，带参数的log函数首先返回一个decorator函数，再让这个decorator函数接收my_func并返回新函数：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">log</span><span class="hljs-params">(name)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">log_decorator</span><span class="hljs-params">(fun)</span>:</span>
        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">wrapper</span><span class="hljs-params">(*args, **kw)</span>:</span>
            <span class="hljs-keyword">print</span> <span class="hljs-string">'[%s] %s()...'</span> % (name, fun.__name__)
            <span class="hljs-keyword">return</span> f(*args, **kw)
        <span class="hljs-keyword">return</span> wrapper
    <span class="hljs-keyword">return</span> log_decorator

<span class="hljs-meta">@log('DEBUG')</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">test</span><span class="hljs-params">()</span>:</span>
    <span class="hljs-keyword">pass</span>
<span class="hljs-keyword">print</span> test()
</code></pre>
<p>执行结果：</p>
<pre class="hljs"><code>&gt;&gt;&gt;test()
[DEBUG] test()...
<span class="hljs-keyword">None</span>
</code></pre>
</li>
</ul>
</li>
<li>
<p>完善decorator</p>
<ul>
<li>
<p>有decorator的情况下，打印函数名：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">log</span><span class="hljs-params">(f)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">wrapper</span><span class="hljs-params">(*args, **kw)</span>:</span>
        <span class="hljs-keyword">print</span> <span class="hljs-string">'call...'</span>
        <span class="hljs-keyword">return</span> f(*args, **kw)
    <span class="hljs-keyword">return</span> wrapper

<span class="hljs-meta">@log</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f2</span><span class="hljs-params">(x)</span>:</span>
    <span class="hljs-keyword">pass</span>
<span class="hljs-keyword">print</span> f2.__name__


&gt;&gt;&gt;f2._name_
wrapper

</code></pre>
</li>
<li>
<p>可见，由于decorator返回的新函数函数名已经不是'f2'，而是@log内部定义的'wrapper'。
这对于那些依赖函数名的代码就会失效。decorator还改变了函数的__doc__等其它属性。
如果要让调用者看不出一个函数经过了@decorator的“改造”，
就需要把原函数的一些属性复制到新函数中：</p>
</li>
<li>
<p>例：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">log</span><span class="hljs-params">(f)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">wrapper</span><span class="hljs-params">(*args, **kw)</span>:</span>
        <span class="hljs-keyword">print</span> <span class="hljs-string">'call...'</span>
        <span class="hljs-keyword">return</span> f(*args, **kw)
    wrapper.__name__ = f.__name__
    wrapper.__doc__ = f.__doc__<span class="hljs-comment">#############这里的__是两个_</span>
    <span class="hljs-keyword">return</span> wrapper
</code></pre>
</li>
<li>
<p>这样写decorator很不方便，因为我们也很难把原函数的所有必要属性都一个一个复制到新函数上，
所以Python内置的functools可以用来自动化完成这个“复制”的任务：</p>
</li>
<li>
<p>例：</p>
<pre class="hljs"><code><span class="hljs-keyword">import</span> functools
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">log</span><span class="hljs-params">(f)</span>:</span>
<span class="hljs-meta">    @functools.wraps(f)###记住@functools.wraps()的位置在刚把函数当作参数的函数的第一行</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">wrapper</span><span class="hljs-params">(*args, **kw)</span>:</span>
        <span class="hljs-keyword">print</span> <span class="hljs-string">'call...'</span>
        <span class="hljs-keyword">return</span> f(*args, **kw)
    <span class="hljs-keyword">return</span> wrapper
</code></pre>
</li>
<li>
<p>最后需要指出，由于我们把原函数签名改成了(*args, **kw)，
因此，无法获得原函数的原始参数信息。即便我们采用固定参数来装饰只有一个参数的函数：</p>
</li>
</ul>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">log</span><span class="hljs-params">(f)</span>:</span>
<span class="hljs-meta">    @functools.wraps(f)</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">wrapper</span><span class="hljs-params">(x)</span>:</span>
        <span class="hljs-keyword">print</span> <span class="hljs-string">'call...'</span>
        <span class="hljs-keyword">return</span> f(x)
    <span class="hljs-keyword">return</span> wrapper
</code></pre>
<ul>
<li>也可能改变原函数的参数名，因为新函数的参数名始终是 'x'，
原函数定义的参数名不一定叫 'x'。</li>
</ul>
</li>
<li>
<p>偏函数</p>
<ul>
<li>
<p>当一个函数有很多参数时，调用者就需要提供多个参数。
如果减少参数个数，就可以简化调用者的负担。
比如：</p>
</li>
<li>
<p>假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，
于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">int2</span><span class="hljs-params">(x, base=<span class="hljs-number">2</span>)</span>:</span>
    <span class="hljs-keyword">return</span> int(x, base)
</code></pre>
<p>这样，我们转换二进制就非常方便了：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>int2(<span class="hljs-string">'1000000'</span>)
<span class="hljs-number">64</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>int2(<span class="hljs-string">'1010101'</span>)
<span class="hljs-number">85</span>
</code></pre>
</li>
<li>
<p>functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，
可以直接使用下面的代码创建一个新的函数int2：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> functools
<span class="hljs-meta">&gt;&gt;&gt; </span>int2 = functools.partial(int, base=<span class="hljs-number">2</span>)<span class="hljs-comment">##（函数，参数）</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>int2(<span class="hljs-string">'1000000'</span>)
<span class="hljs-number">64</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>int2(<span class="hljs-string">'1010101'</span>)
<span class="hljs-number">85</span>
</code></pre>
</li>
<li>
<p>我们在sorted这个高阶函数中传入自定义排序函数就可以实现忽略大小写排序。
请用functools.partial把这个复杂调用变成一个简单的函数：</p>
<ul>
<li>要固定sorted()的cmp参数，需要传入一个排序函数作为cmp的默认值。
<ul>
<li>参考代码:<pre class="hljs"><code><span class="hljs-keyword">import</span> functools
sorted_ignore_case = functools.partial(sorted, cmp=<span class="hljs-keyword">lambda</span> s1, s2: cmp(s1.upper(), s2.upper()))
<span class="hljs-keyword">print</span> sorted_ignore_case([<span class="hljs-string">'bob'</span>, <span class="hljs-string">'about'</span>, <span class="hljs-string">'Zoo'</span>, <span class="hljs-string">'Credit'</span>])
</code></pre>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>模块和包</h1>
<pre class="hljs"><code><span class="hljs-comment">#test.py	&lt;-------------------------------自身模块名test</span>
<span class="hljs-keyword">import</span> math    &lt;--------------------------引用math模块
<span class="hljs-keyword">print</span> (math.pow(<span class="hljs-number">2</span>,<span class="hljs-number">10</span>))   &lt;-------------调用math模块的函数
</code></pre>
<pre><code>包
    {
        模块
            {
	        函数
            }
     }
</code></pre>
<p><code>bao.mo.fun</code></p>
<pre class="hljs"><code><span class="hljs-comment">#test.py	&lt;-------------------------------自身模块名test</span>
<span class="hljs-keyword">import</span>  bao.mo    &lt;-----------------------引用math模块
<span class="hljs-keyword">print</span> (bao.mo.fun(<span class="hljs-number">2</span>,<span class="hljs-number">10</span>))   &lt;------------调用math模块的函数
</code></pre>
<ul>
<li>
<p>在文件系统中<br>
包就是文件夹<br>
	模块就是xxx.py文件</p>
</li>
<li>
<p>但是包和普通文件夹的区别是：<br>
包下都会有__init__.py文件<br>
	注意：每层都必须有</p>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>导入模块</h1>
<pre class="hljs"><code><span class="hljs-keyword">import</span> math

<span class="hljs-meta">&gt;&gt;&gt; </span>math.pow(<span class="hljs-number">2</span>, <span class="hljs-number">0.5</span>) <span class="hljs-comment"># pow是函数</span>
<span class="hljs-number">1.4142135623730951</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>math.pi <span class="hljs-comment"># pi是变量</span>
<span class="hljs-number">3.141592653589793</span>
</code></pre>
<ul>
<li>
<p>如果我们只希望导入用到的math模块的某几个函数，而不是所有函数，可以用下面的语句：</p>
<pre class="hljs"><code><span class="hljs-keyword">from</span> math <span class="hljs-keyword">import</span> pow, sin, log
</code></pre>
</li>
<li>
<p>这样，可以直接引用 pow, sin, log 这3个函数，但math的其他函数没有导入进来：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>pow(<span class="hljs-number">2</span>, <span class="hljs-number">10</span>)
<span class="hljs-number">1024.0</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>sin(<span class="hljs-number">3.14</span>)
<span class="hljs-number">0.0015926529164868282</span>
</code></pre>
</li>
<li>
<p>如果遇到名字冲突怎么办？比如math模块有一个log函数，logging模块也有一个log函数，
如果同时使用，如何解决名字冲突？</p>
</li>
<li>
<p>如果使用import导入模块名，由于必须通过模块名引用函数名，因此不存在冲突</p>
</li>
<li>
<p>如果使用 from...import 导入 log 函数，势必引起冲突。这时，可以给函数起个“别名”来避免冲突：</p>
<pre class="hljs"><code><span class="hljs-keyword">from</span> math <span class="hljs-keyword">import</span> log
<span class="hljs-keyword">from</span> logging <span class="hljs-keyword">import</span> log <span class="hljs-keyword">as</span> logger   <span class="hljs-comment"># logging的log现在变成了logger</span>
<span class="hljs-keyword">print</span> log(<span class="hljs-number">10</span>)   <span class="hljs-comment"># 调用的是math的log</span>
logger(<span class="hljs-number">10</span>, <span class="hljs-string">'import from logging'</span>)   <span class="hljs-comment"># 调用的是logging的log</span>
</code></pre>
</li>
<li>
<p><font color="yellow">from在前</font></p>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>动态导入模块</h1>
<ul>
<li>如果导入的模块不存在，Python解释器会报 ImportError 错误：
有的时候，两个不同的模块提供了相同的功能，
比如 StringIO 和 cStringIO 都提供了StringIO这个功能。
<ul>
<li>同样的功能，StringIO 是纯Python代码编写的，而 cStringIO 部分函数是 C 写的，
因此 cStringIO 运行速度更快。<pre class="hljs"><code><span class="hljs-keyword">try</span>:
    <span class="hljs-keyword">from</span> cStringIO <span class="hljs-keyword">import</span> StringIO
<span class="hljs-keyword">except</span> ImportError:
    <span class="hljs-keyword">from</span> StringIO <span class="hljs-keyword">import</span> StringIO
</code></pre>
<ul>
<li>上述代码先尝试从cStringIO导入，如果失败了（比如cStringIO没有被安装），再尝试从StringIO导入。
这样，如果cStringIO模块存在，则我们将获得更快的运行速度，如果cStringIO不存在，
则顶多代码运行速度会变慢，但不会影响代码的正常执行。</li>
</ul>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>使用__future__</h1>
<ul>
<li>
<p>Python的新版本会引入新的功能，但是，实际上这些功能在上一个老版本中就已经存在了。
要“试用”某一新的特性，就可以通过导入__future__模块的某些功能来实现</p>
<ul>
<li>例如，Python 2.7的整数除法运算结果仍是整数：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-number">10</span> / <span class="hljs-number">3</span>
<span class="hljs-number">3</span>
</code></pre>
</li>
<li>但是，Python 3.x已经改进了整数的除法运算，“/”除将得到浮点数，“//”除才仍是整数：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-number">10</span> / <span class="hljs-number">3</span>
<span class="hljs-number">3.3333333333333335</span>
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-number">10</span> // <span class="hljs-number">3</span>
<span class="hljs-number">3</span>
</code></pre>
</li>
<li>要在Python 2.7中引入3.x的除法规则，导入__future__的division：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> __future__ <span class="hljs-keyword">import</span> division
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">print</span> <span class="hljs-number">10</span> / <span class="hljs-number">3</span>
<span class="hljs-number">3.3333333333333335</span>
</code></pre>
</li>
</ul>
</li>
<li>
<p>当新版本的一个特性与旧版本不兼容时，该特性将会在旧版本中添加到__future__中，
以便旧的代码能在旧版本中测试新特性。</p>
</li>
<li>
<p>在Python 3.x中，字符串统一为unicode，不需要加前缀 u，而以字节存储的str则必须加前缀 b。</p>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>安装第三方模块</h1>
<pre class="hljs"><code>pip install xxx.py
python
&gt;&gt;&gt;<span class="hljs-keyword">import</span> xxx
</code></pre>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>map,reduce,filter,sorted</h1>
<ul>
<li>
<p><font color="yellow">python2:</font>map(fun,alist)</p>
</li>
<li>
<p><font color="yellow">python3:</font>list(map(fun,alist))</p>
<ul>
<li>fun(x)函数分别作用于对list每一个元素
<ul>
<li>例：<pre class="hljs"><code>	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fun</span><span class="hljs-params">(x)</span>:</span>
	    <span class="hljs-keyword">return</span> x*x

	<span class="hljs-keyword">print</span> map(fun, [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>])		<span class="hljs-comment">###python2的map()</span>
	print(list(map(fun, [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>])))	<span class="hljs-comment">###python3的map()</span>
</code></pre>
</li>
</ul>
</li>
</ul>
</li>
<li>
<p>reduce(fun，alist,intializer)	(intializer：初始值)</p>
<ul>
<li>传入的函数fun(x,y)必须接收两个参数</li>
<li>reduce()对list的每两个个元素反复调用函数f，即(0,1)返回a，(a,2)返回b，(b,3)，(c,4),(d,5)。。。
<ul>
<li>例：<pre class="hljs"><code>                            时间线----------------&gt;-------------------&gt;
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">(x, y)</span>:</span>		<span class="hljs-comment"># x , y :    1.即 0 ，1	               2.即 a ，2</span>
    <span class="hljs-keyword">return</span> x + y	<span class="hljs-comment"># x+y   :              即 a	                 即 b</span>
				                   所以此时b=<span class="hljs-number">0</span>+<span class="hljs-number">1</span>+<span class="hljs-number">2</span>
reduce(f, [<span class="hljs-number">1</span>, <span class="hljs-number">3</span>, <span class="hljs-number">5</span>, <span class="hljs-number">7</span>, <span class="hljs-number">9</span>], <span class="hljs-number">100</span>)<span class="hljs-comment">###python2</span>

<span class="hljs-keyword">import</span> functools<span class="hljs-comment">###python3</span>
functools.reduce(f, [<span class="hljs-number">1</span>, <span class="hljs-number">3</span>, <span class="hljs-number">5</span>, <span class="hljs-number">7</span>, <span class="hljs-number">9</span>], <span class="hljs-number">100</span>)

        结果将变为<span class="hljs-number">125</span>，
        因为第一轮计算是：计算初始值和第一个元素：f(<span class="hljs-number">100</span>, <span class="hljs-number">1</span>)。
</code></pre>
</li>
</ul>
</li>
</ul>
</li>
<li>
<p>filter(fun,alist)</p>
<ul>
<li>接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，
filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
<ul>
<li>例:去除偶数<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">is_odd</span><span class="hljs-params">(x)</span>:</span>
    <span class="hljs-keyword">return</span> x % <span class="hljs-number">2</span> == <span class="hljs-number">1</span>

filter(is_odd, [<span class="hljs-number">1</span>, <span class="hljs-number">4</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">9</span>, <span class="hljs-number">12</span>, <span class="hljs-number">17</span>])
结果：[<span class="hljs-number">1</span>, <span class="hljs-number">7</span>, <span class="hljs-number">9</span>, <span class="hljs-number">17</span>]
</code></pre>
</li>
</ul>
</li>
</ul>
</li>
<li>
<p><font color="yellow">python2:</font>sorted(aliist,fun)</p>
</li>
<li>
<p><font color="yellow">python3:</font>sorted(alist,key,reverse)	#reverse:颠倒</p>
<ul>
<li>可以接收一个比较函数来实现自定义排序，
比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，
返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。
<code>sorted(alist)</code>函数还可以直接进行排序<pre class="hljs"><code>&gt;&gt;&gt;sorted([<span class="hljs-number">36</span>, <span class="hljs-number">5</span>, <span class="hljs-number">12</span>, <span class="hljs-number">9</span>, <span class="hljs-number">21</span>])`
[<span class="hljs-number">5</span>, <span class="hljs-number">9</span>, <span class="hljs-number">12</span>, <span class="hljs-number">21</span>, <span class="hljs-number">36</span>]
</code></pre>
<ul>
<li>例:倒序<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">reversed_cmp</span><span class="hljs-params">(x, y)</span>:</span>
    <span class="hljs-keyword">if</span> x &gt; y:
        <span class="hljs-keyword">return</span> <span class="hljs-number">-1</span>
    <span class="hljs-keyword">if</span> x &lt; y:
        <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>
    <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>sorted([<span class="hljs-number">36</span>, <span class="hljs-number">5</span>, <span class="hljs-number">12</span>, <span class="hljs-number">9</span>, <span class="hljs-number">21</span>], reversed_cmp)
[<span class="hljs-number">36</span>, <span class="hljs-number">21</span>, <span class="hljs-number">12</span>, <span class="hljs-number">9</span>, <span class="hljs-number">5</span>]

<span class="hljs-comment">###python3###</span>
&gt;&gt;&gt;<span class="hljs-keyword">import</span> functools
&gt;&gt;&gt;sorted([<span class="hljs-number">36</span>, <span class="hljs-number">5</span>, <span class="hljs-number">12</span>, <span class="hljs-number">9</span>, <span class="hljs-number">21</span>], key=functools.cmp_to_key(reversed_cmp))
在python3中其实可以
&gt;&gt;&gt;sorted([<span class="hljs-number">36</span>, <span class="hljs-number">5</span>, <span class="hljs-number">12</span>, <span class="hljs-number">9</span>, <span class="hljs-number">21</span>], reverse=<span class="hljs-keyword">True</span>)<span class="hljs-comment">#记住True的T要大写</span>
</code></pre>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>面向对象编程</h1>
<ul>
<li>
<p>类:</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">xxx</span><span class="hljs-params">(object)</span>:</span>
	...
</code></pre>
</li>
<li>
<p>实例：</p>
<pre class="hljs"><code>aclass=xxx()
</code></pre>
</li>
<li>
<p>创建实例属性</p>
<ul>
<li>由于Python是动态语言，对每一个实例，都可以直接给他们的属性赋值，
<ul>
<li>例如，给xiaoming这个实例加上name、gender和birth属性：<pre class="hljs"><code>xiaoming = Person()
xiaoming.name = <span class="hljs-string">'Xiao Ming'</span>
xiaoming.gender = <span class="hljs-string">'Male'</span>
xiaoming.birth = <span class="hljs-string">'1990-1-1'</span>
</code></pre>
</li>
</ul>
</li>
<li>实例的属性可以像普通变量一样进行操作：<pre class="hljs"><code>xiaohong.grade = xiaohong.grade + <span class="hljs-number">1</span>
</code></pre>
</li>
</ul>
</li>
<li>
<p>初始化实例属性</p>
<ul>
<li>
<p>在定义 Person 类时，可以为Person类添加一个特殊的<font color="yellow">__init__()</font>方法，
当创建实例时，__init__()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender, birth)</span>:</span>
        self.name = name
        self.gender = gender
        self.birth = birth
</code></pre>
</li>
<li>
<p><font color="yellow">__init__() 方法的第一个参数必须是 self</font>（也可以用别的名字，但建议使用习惯用法），
后续参数则可以自由指定，和定义函数没有任何区别。</p>
</li>
<li>
<p>除了可以直接使用self.name = 'xxx'设置一个属性外，还可以通过 setattr(self, 'name', 'xxx') 设置属性
相应地，创建实例时，就必须要提供除 self 以外的参数：</p>
<pre class="hljs"><code>xiaoming = Person(<span class="hljs-string">'Xiao Ming'</span>, <span class="hljs-string">'Male'</span>, <span class="hljs-string">'1991-1-1'</span>)
xiaohong = Person(<span class="hljs-string">'Xiao Hong'</span>, <span class="hljs-string">'Female'</span>, <span class="hljs-string">'1992-2-2'</span>)
</code></pre>
</li>
<li>
<p>有了__init__()方法，每个Person实例在创建时，
都会有 name、gender 和 birth 这3个属性，并且，被赋予不同的属性值，访问属性使用.操作符：</p>
<pre class="hljs"><code><span class="hljs-keyword">print</span> xiaoming.name
<span class="hljs-comment"># 输出 'Xiao Ming'</span>
<span class="hljs-keyword">print</span> xiaohong.birth
<span class="hljs-comment"># 输出 '1992-2-2'</span>
</code></pre>
</li>
<li>
<p>要特别注意的是，初学者定义__init__()方法常常忘记了 self 参数：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
<span class="hljs-meta">... </span>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(name, gender, birth)</span>:</span>
<span class="hljs-meta">... </span>        <span class="hljs-keyword">pass</span>
<span class="hljs-meta">... </span>
<span class="hljs-meta">&gt;&gt;&gt; </span>xiaoming = Person(<span class="hljs-string">'Xiao Ming'</span>, <span class="hljs-string">'Male'</span>, <span class="hljs-string">'1990-1-1'</span>)
Traceback (most recent call last):
  File <span class="hljs-string">"&lt;stdin&gt;"</span>, line <span class="hljs-number">1</span>, <span class="hljs-keyword">in</span> &lt;module&gt;
TypeError: __init__() takes exactly <span class="hljs-number">3</span> arguments (<span class="hljs-number">4</span> given)
</code></pre>
<ul>
<li>这会导致创建失败或运行不正常，因为第一个参数name被Python解释器传入了实例的引用，
从而导致整个方法的调用参数位置全部没有对上。</li>
</ul>
</li>
</ul>
</li>
<li>
<p>访问限制</p>
<ul>
<li>
<p>Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，
该属性就无法被外部访问。</p>
<ul>
<li>例：<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name)</span>:</span>
        self.name = name
        self._title = <span class="hljs-string">'Mr'</span>
        self.__job = <span class="hljs-string">'Student'</span>
        self.__a__ = <span class="hljs-number">0</span>
p = Person(<span class="hljs-string">'Bob'</span>)
<span class="hljs-keyword">print</span> p.name
<span class="hljs-comment"># =&gt; Bob</span>
<span class="hljs-keyword">print</span> p._title
<span class="hljs-comment"># =&gt; Mr</span>
<span class="hljs-keyword">print</span> b.__a__
<span class="hljs-comment"># =&gt; 0</span>
<span class="hljs-keyword">print</span> p.__job
<span class="hljs-comment"># =&gt; Error</span>
Traceback (most recent call last):
  File <span class="hljs-string">"&lt;stdin&gt;"</span>, line <span class="hljs-number">1</span>, <span class="hljs-keyword">in</span> &lt;module&gt;
AttributeError: <span class="hljs-string">'Person'</span> object has no attribute <span class="hljs-string">'__job'</span>
</code></pre>
</li>
</ul>
</li>
<li>
<p>可见，只有以双下划线开头的&quot;__job&quot;不能直接被外部访问。</p>
</li>
<li>
<p>但是，如果一个属性以__xxx__的形式定义，那它就又可以被外部访问了，
以__xxx__定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，
通常我们不要把普通属性用__xxx__定义。</p>
</li>
</ul>
</li>
<li>
<p>创建类属性</p>
<ul>
<li>
<p>类是模板，而实例则是根据类创建的对象。</p>
</li>
<li>
<p>绑定在一个实例上的属性不会影响其他实例，但是，类本身也是一个对象，
如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，
所有实例访问的类属性都是同一个！也就是说，实例属性每个实例各自拥有，
互相独立，而类属性有且只有一份。</p>
</li>
<li>
<p>定义类属性可以直接在 class 中定义：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    address = <span class="hljs-string">'Earth'</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name)</span>:</span>
        self.name = name
</code></pre>
</li>
<li>
<p>因为类属性是直接绑定在类上的，所以，访问类属性不需要创建实例，就可以直接访问：</p>
<pre class="hljs"><code><span class="hljs-keyword">print</span> Person.address
<span class="hljs-comment"># =&gt; Earth</span>
</code></pre>
</li>
<li>
<p>对一个实例调用类的属性也是可以访问的，所有实例都可以访问到它所属的类的属性：</p>
<pre class="hljs"><code>p1 = Person(<span class="hljs-string">'Bob'</span>)
p2 = Person(<span class="hljs-string">'Alice'</span>)
<span class="hljs-keyword">print</span> p1.address
<span class="hljs-comment"># =&gt; Earth</span>
<span class="hljs-keyword">print</span> p2.address
<span class="hljs-comment"># =&gt; Earth</span>
</code></pre>
</li>
<li>
<p>由于Python是动态语言，类属性也是可以动态添加和修改的：</p>
<pre><code>Person.address = 'China'
print p1.address
# =&gt; 'China'
print p2.address
# =&gt; 'China'
</code></pre>
</li>
<li>
<p>因为类属性只有一份，所以，当Person类的address改变时，所有实例访问到的类属性都改变了。</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    count=<span class="hljs-number">0</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self,name)</span>:</span>
        self.name=name
        Person.count+=<span class="hljs-number">1</span><span class="hljs-comment">###########</span>

p1 = Person(<span class="hljs-string">'Bob'</span>)
<span class="hljs-keyword">print</span> Person.count
</code></pre>
</li>
</ul>
</li>
<li>
<p>类属性和实例属性名字冲突怎么办</p>
<ul>
<li>
<p>修改类属性会导致所有实例访问到的类属性全部都受影响，
但是，如果在实例变量上修改类属性会发生什么问题呢？</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    address = <span class="hljs-string">'Earth'</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name)</span>:</span>
        self.name = name

p1 = Person(<span class="hljs-string">'Bob'</span>)
p2 = Person(<span class="hljs-string">'Alice'</span>)

<span class="hljs-keyword">print</span> <span class="hljs-string">'Person.address = '</span> + Person.address

p1.address = <span class="hljs-string">'China'</span>
<span class="hljs-keyword">print</span> <span class="hljs-string">'p1.address = '</span> + p1.address

<span class="hljs-keyword">print</span> <span class="hljs-string">'Person.address = '</span> + Person.address
<span class="hljs-keyword">print</span> <span class="hljs-string">'p2.address = '</span> + p2.address
</code></pre>
<ul>
<li>结果如下：</li>
</ul>
<pre class="hljs"><code>Person.address = Earth
p1.address = China
Person.address = Earth
p2.address = Earth
</code></pre>
</li>
<li>
<p>我们发现，在设置了 p1.address = 'China' 后，p1访问 address 确实变成了 'China'，
但是，Person.address和p2.address仍然是'Earch'，怎么回事？</p>
<ul>
<li>原因是 p1.address = 'China'并没有改变 Person 的 address，
而是给 p1这个实例绑定了实例属性address ，对p1来说，
它有一个实例属性address（值是'China'），而它所属的类Person也有一个类属性address，</li>
<li>所以:
<ul>
<li>
<p>访问 p1.address 时，优先查找实例属性，返回'China'。</p>
</li>
<li>
<p>访问 p2.address 时，p2没有实例属性address，但是有类属性address，因此返回'Earth'。</p>
</li>
<li>
<p>可见，当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。
当我们把 p1 的 address 实例属性删除后，访问 p1.address 就又返回类属性的值 'Earth'了：</p>
<pre><code>del p1.address
print p1.address
# =&gt; Earth
</code></pre>
</li>
<li>
<p>可见，千万不要在实例上修改类属性，它实际上并没有修改类属性，
而是给实例绑定了一个实例属性。</p>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li>
<p>定义实例方法</p>
<ul>
<li>
<p>虽然私有属性无法从外部访问，但是，从类的内部是可以访问的。
除了可以定义实例的属性外，还可以定义实例的方法。</p>
</li>
<li>
<p>实例的方法就是在类中定义的函数，它的第一个参数永远是 self，
指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name)</span>:</span>
        self.__name = name

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_name</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> self.__name
</code></pre>
<p>get_name(self) 就是一个实例方法，它的第一个参数是self</p>
</li>
<li>
<p>调用实例方法必须在实例上调用：</p>
<pre class="hljs"><code>p1 = Person(<span class="hljs-string">'Bob'</span>)
<span class="hljs-keyword">print</span> p1.get_name()  <span class="hljs-comment"># self不需要显式传入</span>
<span class="hljs-comment"># =&gt; Bob</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, score)</span>:</span>
        self.__name = name
        self.__score = score

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_grade</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">if</span> self.__score &gt;= <span class="hljs-number">80</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-string">'A'</span>
        <span class="hljs-keyword">if</span> self.__score &gt;= <span class="hljs-number">60</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-string">'B'</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">'C'</span>

p1 = Person(<span class="hljs-string">'Bob'</span>, <span class="hljs-number">90</span>)
p2 = Person(<span class="hljs-string">'Alice'</span>, <span class="hljs-number">65</span>)
p3 = Person(<span class="hljs-string">'Tim'</span>, <span class="hljs-number">48</span>)

<span class="hljs-keyword">print</span> p1.get_grade()
<span class="hljs-keyword">print</span> p2.get_grade()
<span class="hljs-keyword">print</span> p3.get_grade()
</code></pre>
</li>
</ul>
</li>
<li>
<p>方法也是属性</p>
<ul>
<li>
<p>我们在 class 中定义的实例方法其实也是属性，它实际上是一个函数对象：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, score)</span>:</span>
        self.name = name
        self.score = score
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_grade</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">'A'</span>

p1 = Person(<span class="hljs-string">'Bob'</span>, <span class="hljs-number">90</span>)
<span class="hljs-keyword">print</span> p1.get_grade
<span class="hljs-comment"># =&gt; &lt;bound method Person.get_grade of &lt;__main__.Person object at 0x109e58510&gt;&gt;</span>
<span class="hljs-keyword">print</span> p1.get_grade()
<span class="hljs-comment"># =&gt; A</span>
</code></pre>
<ul>
<li>也就是说，p1.get_grade 返回的是一个函数对象，但这个函数是一个绑定到实例的函数，
p1.get_grade() 才是方法调用。</li>
</ul>
</li>
<li>
<p>因为方法也是一个属性，所以，它也可以动态地添加到实例上，
只是需要用 types.MethodType() 把一个函数变为一个方法：</p>
<pre class="hljs"><code><span class="hljs-keyword">import</span> types
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fn_get_grade</span><span class="hljs-params">(self)</span>:</span>
    <span class="hljs-keyword">if</span> self.score &gt;= <span class="hljs-number">80</span>:
        <span class="hljs-keyword">return</span> <span class="hljs-string">'A'</span>
    <span class="hljs-keyword">if</span> self.score &gt;= <span class="hljs-number">60</span>:
        <span class="hljs-keyword">return</span> <span class="hljs-string">'B'</span>
    <span class="hljs-keyword">return</span> <span class="hljs-string">'C'</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, score)</span>:</span>
        self.name = name
        self.score = score

p1 = Person(<span class="hljs-string">'Bob'</span>, <span class="hljs-number">90</span>)
p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
<span class="hljs-keyword">print</span> p1.get_grade()
<span class="hljs-comment"># =&gt; A</span>
p2 = Person(<span class="hljs-string">'Alice'</span>, <span class="hljs-number">65</span>)
<span class="hljs-keyword">print</span> p2.get_grade()
<span class="hljs-comment"># ERROR: AttributeError: 'Person' object has no attribute 'get_grade'</span>
<span class="hljs-comment"># 因为p2实例并没有绑定get_grade</span>
</code></pre>
<p>给一个实例动态添加方法并不常见，直接在class中定义要更直观。</p>
</li>
<li>
<p><font color="yellow">函数调用不需要传入 self，但是方法调用需要传入 self。</font></p>
</li>
</ul>
</li>
<li>
<p>定义类方法</p>
<ul>
<li>
<p>和属性类似，方法也分实例方法和类方法。</p>
<ul>
<li>在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。
<ul>
<li>要在class中定义类方法，需要这么写：<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    count = <span class="hljs-number">0</span>
<span class="hljs-meta">    @classmethod</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">how_many</span><span class="hljs-params">(cls)</span>:</span>
        <span class="hljs-keyword">return</span> cls.count
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name)</span>:</span>
        self.name = name
        Person.count = Person.count + <span class="hljs-number">1</span>

<span class="hljs-keyword">print</span> Person.how_many()
p1 = Person(<span class="hljs-string">'Bob'</span>)
<span class="hljs-keyword">print</span> Person.how_many()
</code></pre>
通过标记一个<font color="yellow"> @classmethod</font>，该方法将绑定到 Person 类上，而非类的实例。
类方法的第一个参数将传入类本身，通常将参数名命名为 cls，
上面的 cls.count 实际上相当于 Person.count。</li>
</ul>
</li>
</ul>
</li>
<li>
<p>因为是在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。</p>
</li>
</ul>
</li>
<li>
<p>继承</p>
<ul>
<li>
<p>is 关系 即继承：student is person</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(Person)</span>:</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init</span><span class="hljs-params">(self,aaa)</span>:</span>
		super(Student,self).__init__(aaaa)
</code></pre>
</li>
<li>
<p>has关系 即组合：student has book</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(object)</span>:</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self,book_name)</span>:</span>
		self.book=Book(book_name)
</code></pre>
</li>
<li>
<p>继承一个类</p>
<ul>
<li>如果已经定义了Person类，需要定义新的Student和Teacher类时，可以直接从Person类继承：<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender)</span>:</span>
        self.name = name
        self.gender = gender
</code></pre>
</li>
<li>定义Student类时，只需要把额外的属性加上，例如score：<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(Person)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender, score)</span>:</span>
        super(Student, self).__init__(name, gender)
        self.score = score
</code></pre>
</li>
</ul>
</li>
<li>
<p>一定要用 super(Student, self).<strong>init</strong>(name, gender) 去初始化父类，
否则，继承自 Person 的 Student 将没有 name 和 gender。</p>
</li>
<li>
<p>函数super(Student, self)将返回当前类继承的父类，即 Person ，然后调用__init__()方法，
注意self参数已在super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）。</p>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>判断类型</h1>
<ul>
<li>
<p>函数<font color="yellow">isinstance()可以判断一个变量的类型</font>，
既可以用在Python内置的数据类型如str、list、dict，
也可以用在我们自定义的类，它们本质上都是数据类型。</p>
</li>
<li>
<p>假设有如下的 Person、Student 和 Teacher 的定义及继承关系如下：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender)</span>:</span>
        self.name = name
        self.gender = gender

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(Person)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender, score)</span>:</span>
        super(Student, self).__init__(name, gender)
        self.score = score

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Teacher</span><span class="hljs-params">(Person)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender, course)</span>:</span>
        super(Teacher, self).__init__(name, gender)
        self.course = course

p = Person(<span class="hljs-string">'Tim'</span>, <span class="hljs-string">'Male'</span>)
s = Student(<span class="hljs-string">'Bob'</span>, <span class="hljs-string">'Male'</span>, <span class="hljs-number">88</span>)
t = Teacher(<span class="hljs-string">'Alice'</span>, <span class="hljs-string">'Female'</span>, <span class="hljs-string">'English'</span>)
</code></pre>
<ul>
<li>
<p>当我们拿到变量 p、s、t 时，可以使用 isinstance 判断类型：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>isinstance(p, Person)
<span class="hljs-keyword">True</span>    <span class="hljs-comment"># p是Person类型</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>isinstance(p, Student)
<span class="hljs-keyword">False</span>   <span class="hljs-comment"># p不是Student类型</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>isinstance(p, Teacher)
<span class="hljs-keyword">False</span>   <span class="hljs-comment"># p不是Teacher类型</span>
</code></pre>
<ul>
<li>这说明在继承链上，一个父类的实例不能是子类类型，因为子类比父类多了一些属性和方法。</li>
</ul>
</li>
<li>
<p>我们再考察 s ：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>isinstance(s, Person)
<span class="hljs-keyword">True</span>    <span class="hljs-comment"># s是Person类型</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>isinstance(s, Student)
<span class="hljs-keyword">True</span>    <span class="hljs-comment"># s是Student类型</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>isinstance(s, Teacher)
<span class="hljs-keyword">False</span>   <span class="hljs-comment"># s不是Teacher类型</span>
</code></pre>
<ul>
<li>s 是Student类型，不是Teacher类型，这很容易理解。
但是，s 也是Person类型，因为Student继承自Person，
虽然它比Person多了一些属性和方法，但是，把 s 看成Person的实例也是可以的。</li>
<li>这说明在一条继承链上，一个实例可以看成它本身的类型，也可以看成它父类的类型。</li>
</ul>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>多态</h1>
<ul>
<li>类具有继承关系，并且子类类型可以向上转型看做父类类型，
如果我们从 Person 派生出 Student和Teacher ，并都写了一个 whoAmI() 方法：</li>
</ul>
<pre class="hljs"><code>    <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender)</span>:</span>
            self.name = name
            self.gender = gender
        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">whoAmI</span><span class="hljs-params">(self)</span>:</span>
            <span class="hljs-keyword">return</span> <span class="hljs-string">'I am a Person, my name is %s'</span> % self.name

    <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(Person)</span>:</span>
        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender, score)</span>:</span>
            super(Student, self).__init__(name, gender)
            self.score = score
        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">whoAmI</span><span class="hljs-params">(self)</span>:</span>
            <span class="hljs-keyword">return</span> <span class="hljs-string">'I am a Student, my name is %s'</span> % self.name

    <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Teacher</span><span class="hljs-params">(Person)</span>:</span>
        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender, course)</span>:</span>
            super(Teacher, self).__init__(name, gender)
            self.course = course
        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">whoAmI</span><span class="hljs-params">(self)</span>:</span>
            <span class="hljs-keyword">return</span> <span class="hljs-string">'I am a Teacher, my name is %s'</span> % self.name
</code></pre>
<ul>
<li>
<p>在一个函数中，如果我们接收一个变量 x，则无论该 x 是 Person、Student还是 Teacher，都可以正确打印出结果：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">who_am_i</span><span class="hljs-params">(x)</span>:</span>
    <span class="hljs-keyword">print</span> x.whoAmI()

p = Person(<span class="hljs-string">'Tim'</span>, <span class="hljs-string">'Male'</span>)
s = Student(<span class="hljs-string">'Bob'</span>, <span class="hljs-string">'Male'</span>, <span class="hljs-number">88</span>)
t = Teacher(<span class="hljs-string">'Alice'</span>, <span class="hljs-string">'Female'</span>, <span class="hljs-string">'English'</span>)

who_am_i(p)
who_am_i(s)
who_am_i(t)

运行结果：

I am a Person, my name <span class="hljs-keyword">is</span> Tim
I am a Student, my name <span class="hljs-keyword">is</span> Bob
I am a Teacher, my name <span class="hljs-keyword">is</span> Alice
</code></pre>
</li>
<li>
<p>这种行为称为多态。也就是说，方法调用将作用在 x 的实际类型上。
s 是Student类型，它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法，
但调用 s.whoAmI()总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，
直到在某个父类中找到为止。</p>
</li>
<li>
<p>由于Python是动态语言，所以，传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。
任何数据类型的实例都可以，只要它有一个whoAmI()的方法即可：</p>
</li>
</ul>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Book</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">whoAmI</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">'I am a book'</span>
</code></pre>
<ul>
<li>这是动态语言和静态语言（例如Java）最大的差别之一。<font color="yellow">动态语言调用实例方法，
不检查类型，只要方法存在，参数正确，就可以调用。</font></li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>多重继承</h1>
<ul>
<li>除了从一个父类继承外，Python允许从多个父类继承，称为多重继承。</li>
<li>多重继承的继承链就不是一棵树了，它像这样：<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">A</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, a)</span>:</span>
        <span class="hljs-keyword">print</span> <span class="hljs-string">'init A...'</span>
        self.a = a

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">B</span><span class="hljs-params">(A)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, a)</span>:</span>
        super(B, self).__init__(a)
        <span class="hljs-keyword">print</span> <span class="hljs-string">'init B...'</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">C</span><span class="hljs-params">(A)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, a)</span>:</span>
        super(C, self).__init__(a)
        <span class="hljs-keyword">print</span> <span class="hljs-string">'init C...'</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">D</span><span class="hljs-params">(B, C)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, a)</span>:</span><span class="hljs-comment">###</span>
        super(D, self).__init__(a)<span class="hljs-comment">###</span>
        <span class="hljs-keyword">print</span> <span class="hljs-string">'init D...'</span>
</code></pre>
</li>
<li>看下图:<pre><code>    爷   	     A
                   /   \
                  /     \
    父	         B       C
                  \     /
                   \   /
    孙               D
</code></pre>
<pre><code>  像这样，D 同时继承自 B 和 C，也就是 D 拥有了 A、B、C 的全部功能。
</code></pre>
</li>
<li>多重继承通过 super()调用__init__()方法时，A 虽然被继承了两次，但__init__()只调用一次：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>d = D(<span class="hljs-string">'d'</span>)
init A...
init C...
init B...
init D...
</code></pre>
</li>
<li>多重继承的目的是从两种继承树中分别选择并继承出子类，以便组合功能使用。</li>
</ul>
<br/>
<br/>
<ul>
<li>通过多重继承，请定义“会打篮球的学生”和“会踢足球的老师”。
<ul>
<li>多重继承需要从两个或更多的类派生。</li>
<li>参考代码:<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-keyword">pass</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(Person)</span>:</span>
    <span class="hljs-keyword">pass</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Teacher</span><span class="hljs-params">(Person)</span>:</span>
    <span class="hljs-keyword">pass</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">SkillMixin</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-keyword">pass</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">BasketballMixin</span><span class="hljs-params">(SkillMixin)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">skill</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">'basketball'</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">FootballMixin</span><span class="hljs-params">(SkillMixin)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">skill</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">'football'</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">BStudent</span><span class="hljs-params">(Student, BasketballMixin)</span>:</span>
    <span class="hljs-keyword">pass</span><span class="hljs-comment">###只有在父类需要参数时，调用super(BSTudent,self).__init(xxx,xxx)</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">FTeacher</span><span class="hljs-params">(Teacher, FootballMixin)</span>:</span>
    <span class="hljs-keyword">pass</span><span class="hljs-comment">###</span>

s = BStudent()
<span class="hljs-keyword">print</span> s.skill()

t = FTeacher()
<span class="hljs-keyword">print</span> t.skill()
</code></pre>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>获取对象信息</h1>
<ul>
<li>
<p>拿到一个变量，除了用 isinstance() 判断它是否是某种类型的实例外，
还有没有别的方法获取到更多的信息呢？</p>
<ul>
<li>例如，已有定义：<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender)</span>:</span>
        self.name = name
        self.gender = gender

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(Person)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender, score)</span>:</span>
        super(Student, self).__init__(name, gender)
        self.score = score
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">whoAmI</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">'I am a Student, my name is %s'</span> % self.name
</code></pre>
</li>
</ul>
</li>
<li>
<p>首先可以用 type() 函数获取变量的类型，它返回一个 Type 对象：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>type(<span class="hljs-number">123</span>)
&lt;type <span class="hljs-string">'int'</span>&gt;
<span class="hljs-meta">&gt;&gt;&gt; </span>s = Student(<span class="hljs-string">'Bob'</span>, <span class="hljs-string">'Male'</span>, <span class="hljs-number">88</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>type(s)
&lt;<span class="hljs-class"><span class="hljs-keyword">class</span> '<span class="hljs-title">__main__</span>.<span class="hljs-title">Student</span>'&gt;
</span></code></pre>
</li>
<li>
<p>其次，可以用 dir() 函数获取变量的所有属性：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>dir(<span class="hljs-number">123</span>)   <span class="hljs-comment"># 整数也有很多属性...</span>
[<span class="hljs-string">'__abs__'</span>, <span class="hljs-string">'__add__'</span>, <span class="hljs-string">'__and__'</span>, <span class="hljs-string">'__class__'</span>, <span class="hljs-string">'__cmp__'</span>, ...]

<span class="hljs-meta">&gt;&gt;&gt; </span>dir(s)
[<span class="hljs-string">'__class__'</span>, <span class="hljs-string">'__delattr__'</span>, <span class="hljs-string">'__dict__'</span>, <span class="hljs-string">'__doc__'</span>, <span class="hljs-string">'__format__'</span>, <span class="hljs-string">'__getattribute__'</span>, <span class="hljs-string">'__hash__'</span>, <span class="hljs-string">'__init__'</span>, 
<span class="hljs-string">'__module__'</span>, <span class="hljs-string">'__new__'</span>, <span class="hljs-string">'__reduce__'</span>, <span class="hljs-string">'__reduce_ex__'</span>, <span class="hljs-string">'__repr__'</span>, <span class="hljs-string">'__setattr__'</span>, <span class="hljs-string">'__sizeof__'</span>, <span class="hljs-string">'__str__'</span>, 
<span class="hljs-string">'__subclasshook__'</span>, <span class="hljs-string">'__weakref__'</span>, <span class="hljs-string">'gender'</span>, <span class="hljs-string">'name'</span>, <span class="hljs-string">'score'</span>, <span class="hljs-string">'whoAmI'</span>]
</code></pre>
</li>
<li>
<p>对于实例变量，dir()返回所有实例属性，包括<code>__class__</code>这类有特殊意义的属性。
注意到方法<code>whoAmI</code>也是 s 的一个属性。</p>
</li>
<li>
<p>如何去掉<code>__xxx__</code>这类的特殊属性，只保留我们自己定义的属性？回顾一下filter()函数的用法。</p>
</li>
<li>
<p>dir()返回的属性是字符串列表，如果已知一个属性名称，要获取或者设置对象的属性，
就需要用 getattr() 和 setattr( )函数了：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>getattr(s, <span class="hljs-string">'name'</span>)  <span class="hljs-comment"># 获取name属性</span>
<span class="hljs-string">'Bob'</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>setattr(s, <span class="hljs-string">'name'</span>, <span class="hljs-string">'Adam'</span>)  <span class="hljs-comment"># 设置新的name属性</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>s.name
<span class="hljs-string">'Adam'</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>getattr(s, <span class="hljs-string">'age'</span>)  <span class="hljs-comment"># 获取age属性，但是属性不存在，报错：</span>
Traceback (most recent call last):
  File <span class="hljs-string">"&lt;stdin&gt;"</span>, line <span class="hljs-number">1</span>, <span class="hljs-keyword">in</span> &lt;module&gt;
AttributeError: <span class="hljs-string">'Student'</span> object has no attribute <span class="hljs-string">'age'</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>getattr(s, <span class="hljs-string">'age'</span>, <span class="hljs-number">20</span>)  <span class="hljs-comment"># 获取age属性，如果属性不存在，就返回默认值20：</span>
<span class="hljs-number">20</span>
</code></pre>
</li>
<li>
<p>对于Person类的定义：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender)</span>:</span>
        self.name = name
        self.gender = gender
</code></pre>
</li>
<li>
<p>希望除了 name和gender 外，可以提供任意额外的关键字参数，
并绑定到实例，请修改 Person 的 __init__()定 义，完成该功能。</p>
</li>
<li>
<p>传入**kw 即可传入任意数量的参数，并通过 setattr() 绑定属性。</p>
<ul>
<li>参考代码:<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender, **kw)</span>:</span>
        self.name = name
        self.gender = gender
        <span class="hljs-keyword">for</span> k, v <span class="hljs-keyword">in</span> kw.iteritems():<span class="hljs-comment">###</span>
            setattr(self, k, v)

p = Person(<span class="hljs-string">'Bob'</span>, <span class="hljs-string">'Male'</span>, age=<span class="hljs-number">18</span>, course=<span class="hljs-string">'Python'</span>)
<span class="hljs-keyword">print</span> p.age
<span class="hljs-keyword">print</span> p.course
</code></pre>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>特殊方法</h1>
<ul>
<li>
<p>例</p>
<ul>
<li>打印 用于 print的__str__</li>
<li>长度 用于len的__len__</li>
<li>比较 用于cmp的__cmp__</li>
</ul>
</li>
<li>
<p>特殊方法定义在class中</p>
</li>
<li>
<p>不需要直接调用</p>
</li>
<li>
<p>Python的某些函数或操作符会调用对应的特殊方法</p>
</li>
<li>
<p>正确实现特殊方法</p>
<ul>
<li>有关联性的特殊方法都必须实现
<ul>
<li>如果定义了__getattr__方法，就必须要定义__setattr__方法和__delattr__方法</li>
</ul>
</li>
</ul>
</li>
<li>
<p>__str__和__repr__</p>
<ul>
<li>
<p>如果要把一个类的实例变成 str，就需要实现特殊方法__str__()：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender)</span>:</span>
        self.name = name
        self.gender = gender
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">'(Person: %s, %s)'</span> % (self.name, self.gender)
</code></pre>
</li>
<li>
<p>现在，在交互式命令行下用 print 试试：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>p = Person(<span class="hljs-string">'Bob'</span>, <span class="hljs-string">'male'</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">print</span> p
(Person: Bob, male)
</code></pre>
</li>
<li>
<p>但是，如果直接敲变量 p：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>p
&lt;main.Person object at <span class="hljs-number">0x10c941890</span>&gt;
</code></pre>
<pre><code>  似乎__str__() 不会被调用。
</code></pre>
</li>
<li>
<p>因为 Python 定义了__str__()和__repr__()两种方法，__str__()用于显示给用户，
而__repr__()用于显示给开发人员。</p>
</li>
<li>
<p>有一个偷懒的定义__repr__的方法：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender)</span>:</span>
        self.name = name
        self.gender = gender
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">'(Person: %s, %s)'</span> % (self.name, self.gender)
    __repr__ = __str__

</code></pre>
</li>
</ul>
</li>
<li>
<p>__cmp__</p>
<ul>
<li>
<p>对 int、str 等内置数据类型排序时，Python的 sorted() 按照默认的比较函数 cmp 排序，
但是，如果对一组 Student 类的实例排序时，就必须提供我们自己的特殊方法 <strong>cmp</strong>()：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, score)</span>:</span>
        self.name = name
        self.score = score
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">'(%s: %s)'</span> % (self.name, self.score)
    __repr__ = __str__
    
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__cmp__</span><span class="hljs-params">(self, s)</span>:</span>
        <span class="hljs-keyword">if</span> self.name &lt; s.name:
            <span class="hljs-keyword">return</span> <span class="hljs-number">-1</span>
        <span class="hljs-keyword">elif</span> self.name &gt; s.name:
            <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>
        <span class="hljs-keyword">else</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
</code></pre>
</li>
<li>
<p>上述 Student 类实现了__cmp__()方法，__cmp__用实例自身self和传入的实例 s 进行比较，
如果 self 应该排在前面（就是self比s小），就返回 -1，如果 s 应该排在前面，
就返回1，如果两者相当，返回 0。</p>
</li>
<li>
<p>Student类实现了按name进行排序：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>L = [Student(<span class="hljs-string">'Tim'</span>, <span class="hljs-number">99</span>), Student(<span class="hljs-string">'Bob'</span>, <span class="hljs-number">88</span>), Student(<span class="hljs-string">'Alice'</span>, <span class="hljs-number">77</span>)]
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">print</span> sorted(L)
[(Alice: <span class="hljs-number">77</span>), (Bob: <span class="hljs-number">88</span>), (Tim: <span class="hljs-number">99</span>)]
</code></pre>
</li>
<li>
<p>注意: 如果list不仅仅包含 Student 类，则 <strong>cmp</strong> 可能会报错：</p>
<pre class="hljs"><code>L = [Student(<span class="hljs-string">'Tim'</span>, <span class="hljs-number">99</span>), Student(<span class="hljs-string">'Bob'</span>, <span class="hljs-number">88</span>), <span class="hljs-number">100</span>, <span class="hljs-string">'Hello'</span>]
<span class="hljs-keyword">print</span> sorted(L)
</code></pre>
</li>
<li>
<p>请思考如何解决：个人认为在__cmp__中加入if判断是否为Student，isinstance（self,Student）</p>
</li>
</ul>
<pre class="hljs"><code>    <span class="hljs-comment">######python3</span>
    <span class="hljs-keyword">import</span> functools
    <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(object)</span>:</span>
        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, score)</span>:</span>
            self.name = name
            self.score = score
        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span><span class="hljs-params">(self)</span>:</span>
            <span class="hljs-keyword">return</span> <span class="hljs-string">'(%s: %s)'</span> % (self.name, self.score)
        __repr__ = __str__

        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__cmp__</span><span class="hljs-params">(self, s)</span>:</span>
            <span class="hljs-keyword">if</span> self.name &lt; s.name:
                <span class="hljs-keyword">return</span> <span class="hljs-number">-1</span>
            <span class="hljs-keyword">elif</span> self.name &gt; s.name:
                <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>
            <span class="hljs-keyword">else</span>:
                <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>

    L = [Student(<span class="hljs-string">'Tim'</span>, <span class="hljs-number">99</span>), Student(<span class="hljs-string">'Bob'</span>, <span class="hljs-number">88</span>), Student(<span class="hljs-string">'Alice'</span>, <span class="hljs-number">77</span>)]
    print(sorted(L,key=functools.cmp_to_key(__cmp__)))
</code></pre>
<ul>
<li>请修改 Student 的 <strong>cmp</strong> 方法，让它按照分数从高到底排序，分数相同的按名字排序。</li>
</ul>
<pre class="hljs"><code>    <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(object)</span>:</span>

        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, score)</span>:</span>
            self.name = name
            self.score = score

        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span><span class="hljs-params">(self)</span>:</span>
            <span class="hljs-keyword">return</span> <span class="hljs-string">'(%s: %s)'</span> % (self.name, self.score)

        __repr__ = __str__

        <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__cmp__</span><span class="hljs-params">(self, s)</span>:</span>
            <span class="hljs-keyword">if</span> <span class="hljs-keyword">False</span> == isinstance(s, Student):
                <span class="hljs-keyword">return</span> <span class="hljs-number">-1</span>
            <span class="hljs-keyword">return</span> -cmp(self.score, s.score) <span class="hljs-keyword">or</span> cmp(self.name, s.name)

    L = [Student(<span class="hljs-string">'Tim'</span>, <span class="hljs-number">99</span>), Student(<span class="hljs-string">'Bob'</span>, <span class="hljs-number">88</span>), Student(<span class="hljs-string">'Alice'</span>, <span class="hljs-number">99</span>)]
    <span class="hljs-keyword">print</span> sorted(L)
</code></pre>
</li>
<li>
<p>__len__</p>
<ul>
<li>
<p>如果一个类表现得像一个list，要获取有多少个元素，就得用 len() 函数。</p>
</li>
<li>
<p>要让 len() 函数工作正常，类必须提供一个特殊方法__len__()，它返回元素的个数。</p>
</li>
<li>
<p>例如，我们写一个 Students 类，把名字传进去：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Students</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, *args)</span>:</span>
        self.names = args
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__len__</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> len(self.names)
</code></pre>
</li>
<li>
<p>只要正确实现了__len__()方法，就可以用len()函数返回Students实例的“长度”：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>ss = Students(<span class="hljs-string">'Bob'</span>, <span class="hljs-string">'Alice'</span>, <span class="hljs-string">'Tim'</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">print</span> len(ss)
<span class="hljs-number">3</span>
</code></pre>
</li>
<li>
<p>斐波那契数列是由 0, 1, 1, 2, 3, 5, 8...构成。</p>
<ul>
<li>请编写一个Fib类，Fib(10)表示数列的前10个元素，print Fib(10) 可以打印出数列的前 10 个元素，
len(Fib(10))可以正确返回数列的个数10。</li>
<li>需要根据num计算出斐波那契数列的前N个元素。</li>
<li>参考代码:<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Fib</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, num)</span>:</span>
        a, b, L = <span class="hljs-number">0</span>, <span class="hljs-number">1</span>, []
        <span class="hljs-keyword">for</span> n <span class="hljs-keyword">in</span> range(num):
            L.append(a)
            a, b = b, a + b
        self.numbers = L

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> str(self.numbers)

    __repr__ = __str__

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__len__</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> len(self.numbers)

f = Fib(<span class="hljs-number">10</span>)
<span class="hljs-keyword">print</span> f
<span class="hljs-keyword">print</span> len(f)

</code></pre>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>数***算</h1>
<ul>
<li>Python 提供的基本数据类型 int、float 可以做整数和浮点的四则运算以及乘方等运算。</li>
</ul>
<p>但是，四则运算不局限于int和float，还可以是有理数、矩阵等。</p>
<p>要表示有理数，可以用一个Rational类来表示分数：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Rational</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, p, q)</span>:</span>
        self.p = p
        self.q = q
</code></pre>
<ul>
<li>p、q 都是整数，表示有理数 p/q。</li>
</ul>
<br/>
<ul>
<li>
<p>如果要让Rational进行+-*/运算，需要正确实现</p>
</li>
<li>
<p>加法运算 + 调用__add__</p>
</li>
<li>
<p>减法运算 - 调用__sub__</p>
</li>
<li>
<p>乘法运算 * 调用__mul__</p>
</li>
<li>
<p>除法运算 / 调用__div__</p>
</li>
<li>
<p>如果运算结果是 6/8，在显示的时候需要归约到最简形式3/4。</p>
<ul>
<li>参考代码:<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">gcd</span><span class="hljs-params">(a, b)</span>:</span>
    <span class="hljs-keyword">if</span> b == <span class="hljs-number">0</span>:
        <span class="hljs-keyword">return</span> a
    <span class="hljs-keyword">return</span> gcd(b, a % b)

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Rational</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, p, q)</span>:</span>
        self.p = p
        self.q = q
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__add__</span><span class="hljs-params">(self, r)</span>:</span>
        <span class="hljs-keyword">return</span> Rational(self.p * r.q + self.q * r.p, self.q * r.q)
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__sub__</span><span class="hljs-params">(self, r)</span>:</span>
        <span class="hljs-keyword">return</span> Rational(self.p * r.q - self.q * r.p, self.q * r.q)
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__mul__</span><span class="hljs-params">(self, r)</span>:</span>
        <span class="hljs-keyword">return</span> Rational(self.p * r.p, self.q * r.q)
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__div__</span><span class="hljs-params">(self, r)</span>:</span>
        <span class="hljs-keyword">return</span> Rational(self.p * r.q, self.q * r.p)
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span><span class="hljs-params">(self)</span>:</span>
        g = gcd(self.p, self.q)
        <span class="hljs-keyword">return</span> <span class="hljs-string">'%s/%s'</span> % (self.p / g, self.q / g)
    __repr__ = __str__

r1 = Rational(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>)
r2 = Rational(<span class="hljs-number">1</span>, <span class="hljs-number">4</span>)
<span class="hljs-keyword">print</span> r1 + r2
<span class="hljs-keyword">print</span> r1 - r2
<span class="hljs-keyword">print</span> r1 * r2
<span class="hljs-keyword">print</span> r1 / r2

<span class="hljs-number">3</span>/<span class="hljs-number">4</span>
<span class="hljs-number">1</span>/<span class="hljs-number">4</span>
<span class="hljs-number">1</span>/<span class="hljs-number">8</span>
<span class="hljs-number">2</span>/<span class="hljs-number">1</span>
</code></pre>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>类型转换</h1>
<ul>
<li>Rational类实现了有理数运算，但是，如果要把结果转为 int 或 float 怎么办？
<ul>
<li>考察整数和浮点数的转换：<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>int(<span class="hljs-number">12.34</span>)
<span class="hljs-number">12</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>float(<span class="hljs-number">12</span>)
<span class="hljs-number">12.0</span>
</code></pre>
</li>
<li>如果要把 Rational 转为 int，应该使用：<pre class="hljs"><code>r = Rational(<span class="hljs-number">12</span>, <span class="hljs-number">5</span>)
n = int(r)
</code></pre>
</li>
<li>要让int()函数正常工作，只需要实现特殊方法__int__():<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Rational</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, p, q)</span>:</span>
        self.p = p
        self.q = q
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__int__</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> self.p // self.q

结果如下：

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">print</span> int(Rational(<span class="hljs-number">7</span>, <span class="hljs-number">2</span>))
<span class="hljs-number">3</span>
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">print</span> int(Rational(<span class="hljs-number">1</span>, <span class="hljs-number">3</span>))
<span class="hljs-number">0</span>
</code></pre>
</li>
<li>同理，要让float()函数正常工作，只需要实现特殊方法__float__()。<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__float__</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> <span class="hljs-number">1.0</span>*self.p/self.q
</code></pre>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>@property</h1>
<ul>
<li>
<p>考察Student类：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, score)</span>:</span>
        self.name = name
        self.score = score
</code></pre>
</li>
<li>
<p>当我们想要修改一个 Student 的 scroe 属性时，可以这么写：</p>
<pre class="hljs"><code>s = Student(<span class="hljs-string">'Bob'</span>, <span class="hljs-number">59</span>)
s.score = <span class="hljs-number">60</span>
</code></pre>
</li>
<li>
<p>但是也可以这么写：</p>
<pre class="hljs"><code>s.score = <span class="hljs-number">1000</span>
</code></pre>
<p>显然，直接给属性赋值无法检查分数的有效性。</p>
<ul>
<li>如果利用两个方法：<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, score)</span>:</span>
        self.name = name
        self.__score = score
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_score</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-keyword">return</span> self.__score
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">set_score</span><span class="hljs-params">(self, score)</span>:</span>
        <span class="hljs-keyword">if</span> score &lt; <span class="hljs-number">0</span> <span class="hljs-keyword">or</span> score &gt; <span class="hljs-number">100</span>:
            <span class="hljs-keyword">raise</span> ValueError(<span class="hljs-string">'invalid score'</span>)<span class="hljs-comment">#########</span>
        self.__score = score
</code></pre>
</li>
</ul>
<p>这样一来，s.set_score(1000) 就会抛异常。</p>
</li>
<li>
<p>但是写 s.get_score() 和 s.set_score() 没有直接写 s.score 来得直接。</p>
</li>
<li>
<p>有没有两全其美的方法？----有。</p>
</li>
<li>
<p>因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，
可以用装饰器函数把 get/set 方法“装饰”成属性调用：</p>
<pre class="hljs"><code> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(object)</span>:</span>
     <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, score)</span>:</span>
         self.name = name
         self.__score = score
<span class="hljs-meta">     @property</span>
     <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">score</span><span class="hljs-params">(self)</span>:</span>
         <span class="hljs-keyword">return</span> self.__score
<span class="hljs-meta">     @score.setter</span>
     <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">score</span><span class="hljs-params">(self, score)</span>:</span>
         <span class="hljs-keyword">if</span> score &lt; <span class="hljs-number">0</span> <span class="hljs-keyword">or</span> score &gt; <span class="hljs-number">100</span>:
             <span class="hljs-keyword">raise</span> ValueError(<span class="hljs-string">'invalid score'</span>)<span class="hljs-comment">####</span>
         self.__score = score
</code></pre>
<ul>
<li>
<p>注意: <font color="yellow">第一个score(self)是get方法，用@property装饰，
第二个score(self, score)是set方法，用@score.setter装饰，
@score.setter是前一个@property装饰后的副产品（有get就得有set），也就是score的判断语句。</font></p>
</li>
<li>
<p>现在，就可以像使用属性一样设置score了（即不用get_score和set_score,也可以对输入的score进行判断）：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>s = Student(<span class="hljs-string">'Bob'</span>, <span class="hljs-number">59</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>s.score = <span class="hljs-number">60</span>
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">print</span> s.score
<span class="hljs-number">60</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>s.score = <span class="hljs-number">1000</span>
Traceback (most recent call last):
  ...
ValueError: invalid score
</code></pre>
</li>
<li>
<p>说明对 score 赋值实际调用的是 set方法。</p>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>__slots__</h1>
<ul>
<li>
<p>由于Python是动态语言，任何实例在运行期都可以动态地添加属性。</p>
</li>
<li>
<p>如果要限制添加的属性，例如，Student类只允许添加 name、gender和score 这3个属性，
就可以利用Python的一个特殊的__slots__来实现。</p>
</li>
<li>
<p>顾名思义，__slots__是指一个类允许的属性列表：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">(object)</span>:</span>
    __slots__ = (<span class="hljs-string">'name'</span>, <span class="hljs-string">'gender'</span>, <span class="hljs-string">'score'</span>)
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender, score)</span>:</span>
        self.name = name
        self.gender = gender
        self.score = score
</code></pre>
</li>
<li>
<p>现在，对实例进行操作：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>s = Student(<span class="hljs-string">'Bob'</span>, <span class="hljs-string">'male'</span>, <span class="hljs-number">59</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>s.name = <span class="hljs-string">'Tim'</span> <span class="hljs-comment"># OK</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>s.score = <span class="hljs-number">99</span> <span class="hljs-comment"># OK</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>s.grade = <span class="hljs-string">'A'</span>
Traceback (most recent call last):
  ...
AttributeError: <span class="hljs-string">'Student'</span> object has no attribute <span class="hljs-string">'grade'</span>
</code></pre>
</li>
<li>
<p>__slots__的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，
使用__slots__也能节省内存。</p>
</li>
<li>
<p>子类的__slots__只需要包含父类不包含的属性即可。</p>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>__call__</h1>
<ul>
<li>
<p>在Python中，函数其实是一个对象：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>f = abs
<span class="hljs-meta">&gt;&gt;&gt; </span>f.__name__
<span class="hljs-string">'abs'</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>f(<span class="hljs-number">-123</span>)
<span class="hljs-number">123</span>
</code></pre>
</li>
<li>
<p>由于 f 可以被调用，所以，f 被称为可调用对象。</p>
</li>
<li>
<p>所有的函数都是可调用对象。</p>
</li>
<li>
<p>一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。</p>
<ul>
<li>
<p>我们把 Person 类变成一个可调用对象：</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, gender)</span>:</span>
        self.name = name
        self.gender = gender

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__call__</span><span class="hljs-params">(self, friend)</span>:</span>
        <span class="hljs-keyword">print</span> <span class="hljs-string">'My name is %s...'</span> % self.name
        <span class="hljs-keyword">print</span> <span class="hljs-string">'My friend is %s...'</span> % friend
</code></pre>
</li>
<li>
<p>现在可以对 Person 实例直接调用：</p>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>p = Person(<span class="hljs-string">'Bob'</span>, <span class="hljs-string">'male'</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>p(<span class="hljs-string">'Tim'</span>)
My name <span class="hljs-keyword">is</span> Bob...
My friend <span class="hljs-keyword">is</span> Tim...
</code></pre>
</li>
<li>
<p>单看 p('Tim') 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，
对象和函数的区别并不显著</p>
</li>
<li>
<p>改进一下前面定义的斐波那契数列</p>
<pre class="hljs"><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Fib</span><span class="hljs-params">(object)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__call__</span><span class="hljs-params">(self, num)</span>:</span>
        a, b, L = <span class="hljs-number">0</span>, <span class="hljs-number">1</span>, []
        <span class="hljs-keyword">for</span> n <span class="hljs-keyword">in</span> range(num):
            L.append(a)
            a, b = b, a + b
        <span class="hljs-keyword">return</span> L

f = Fib()
<span class="hljs-keyword">print</span> f(<span class="hljs-number">10</span>)
</code></pre>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
<h1>典型错误：</h1>
<ul>
<li>1<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">calc_prod</span><span class="hljs-params">(lst)</span>:</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">g</span><span class="hljs-params">(lst)</span>:</span>
		s=<span class="hljs-number">1</span>
		<span class="hljs-keyword">for</span> n <span class="hljs-keyword">in</span> lst:
			s*=n
		<span class="hljs-keyword">return</span> s
	<span class="hljs-keyword">return</span> g

f = calc_prod([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>])
<span class="hljs-keyword">print</span> (f())
</code></pre>
<ul>
<li>
<p>程序的第二行中的g函数:g(lst)表示创建一个新的lst参数，但是，在程序中并没有传入因此会报错</p>
</li>
<li>
<p>修改：</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">calc_prod</span><span class="hljs-params">(lst)</span>:</span>
	<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">g</span><span class="hljs-params">()</span>:</span>
		s=<span class="hljs-number">1</span>
		<span class="hljs-keyword">for</span> n <span class="hljs-keyword">in</span> lst:
			s*=n
		<span class="hljs-keyword">return</span> s
	<span class="hljs-keyword">return</span> g

f = calc_prod([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>])
<span class="hljs-keyword">print</span> (f())
</code></pre>
</li>
</ul>
</li>
</ul>
<br/>
<br/>
<br/>
<ul>
<li>2
<ul>
<li>希望一次返回3个函数，分别计算1x1,2x2,3x3:</li>
</ul>
<pre class="hljs"><code>    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">count</span><span class="hljs-params">()</span>:</span>
        fs = []
        <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">1</span>, <span class="hljs-number">4</span>):
            <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">()</span>:</span>
                 <span class="hljs-keyword">return</span> i*i
            fs.append(f)
        <span class="hljs-keyword">return</span> fs

    f1, f2, f3 = count()
</code></pre>
<ul>
<li>
<p>你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9</p>
</li>
<li>
<p>原因就是当执行完count()函数后， i 的值就变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：</p>
</li>
</ul>
<pre class="hljs"><code><span class="hljs-meta">&gt;&gt;&gt; </span>f1()
<span class="hljs-number">9</span>     <span class="hljs-comment"># 因为f1现在才被调用，而此时的i=3</span>
</code></pre>
</li>
<li>闭包的特点是返回的函数还引用了外层函数的局部变量，
所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。
<ul>
<li>
<p>修改：</p>
<ul>
<li>考察下面的函数 f:<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">(j)</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">g</span><span class="hljs-params">()</span>:</span>
        <span class="hljs-keyword">return</span> j*j
    <span class="hljs-keyword">return</span> g
</code></pre>
<pre><code>  它可以正确地返回一个闭包g，g所引用的变量j不是循环变量，因此将正常执行。
</code></pre>
</li>
</ul>
</li>
<li>
<p>在count函数的循环内部，如果借助f函数，就可以避免引用循环变量i。</p>
<pre class="hljs"><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">count</span><span class="hljs-params">()</span>:</span>
	fs = []
	<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">1</span>, <span class="hljs-number">4</span>):
		<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">(j)</span>:</span>
<span class="hljs-comment">#------------------------------------------------------------------------------</span>
			<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">g</span><span class="hljs-params">()</span>:</span>
				<span class="hljs-keyword">return</span> j*j
			<span class="hljs-keyword">return</span> g
		k=f(i)
		fs.append(k)<span class="hljs-comment">#如果此处写fs.append(f)的话，则每次调用f时需要传入参数</span>
			    <span class="hljs-comment">#但是fs.append(k)，中的k函数已经是传入值后的f了，例如k=f(1)</span>
<span class="hljs-comment">#-----------------------------------------------------------------------------</span>
	<span class="hljs-keyword">return</span> fs
f1, f2, f3 = count()
</code></pre>
<ul>
<li>当执行完count()函数后， i 的值就变成了3。</li>
<li>f1、f2、f3也没有被调用，但是,程序中的k并不受i的影响，因为k函数已经是传入值后的f了，</li>
<li>例如k=f(1)，k已经确定了</li>
<li>当 f1 被调用时：<pre class="hljs"><code>&gt;&gt;&gt;f1()
<span class="hljs-number">9</span>
</code></pre>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div></body></html>

慕课python3.5学习笔记

布尔值