因为一个数最大的因数是其本身，即 x / 1 = x，再次就是它的一半。

所以通过反复比较a，b两个数，当a除以b余数为0时，即找到了它们之间的最大公约数。

比如：gcd(25,15)=>gcd(15,10)=>gcd(10,5)=>gcd(5,0)，返回的a值5就是结果。

再如：gcd(15,25)=>gcd(25,15)=>gcd(15,10)=>gcd(10,5)=>gcd(5,0)

for k, v in kw.iteritems():

            setattr(self, k, v)

**kw，本质是个dict对象，for in 通过dict的iteritems迭代器循环中会读取出key 和 value ，key是dict的key，value则是对应值

每层函数的参数都是不同的，第一层函数的参数是传入要打印的字符串，第二层函数的参数是原函数，第三层函数的参数是原函数的参数；定义两层的话，应该就只能打印固定的字符串了?

s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。

当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下：

a = '     123'
a.strip()

结果： '123'

a='\t\t123\r\n'
a.strip()

结果：'123'

计算平方根可以用函数：

>>> math.sqrt(2)
1.4142...

所有的函数都是可调用对象。

一定要用 super(Student, self).__init__(name, gender) 去初始化父类

如果一个属性由双下划线开头(__)，该属性就无法被外部访问

def format_name(s):

    return s[0].upper()+s[1:].lower()

print map(format_name, ['adam', 'LISA', 'barT'])

计算平方根

math.sqrt(2)

Python 3.x已经改进了整数的除法运算，“/”除将得到浮点数，“//”除才仍是整数：

>>> 10 / 3
3.3333333333333335
>>> 10 // 3
3

要在Python 2.7中引入3.x的除法规则，导入__future__的division：

>>> from __future__ import division
>>> print 10 / 3
3.3333333333333335

当新版本的一个特性与旧版本不兼容时，该特性将会在旧版本中添加到__future__中，以便旧的代码能在旧版本中测试新特性。

利用ImportError错误，我们经常在Python中动态导入模块：

try:
    from cStringIO import StringIO
except ImportError:
    from StringIO import StringIO

上述代码先尝试从cStringIO导入，如果失败了（比如cStringIO没有被安装），再尝试从StringIO导入。这样，如果cStringIO模块存在，则我们将获得更快的运行速度，如果cStringIO不存在，则顶多代码运行速度会变慢，但不会影响代码的正常执行。

try 的作用是捕获错误，并在捕获到指定错误时执行 except 语句。

如果遇到名字冲突怎么办？比如math模块有一个log函数，logging模块也有一个log函数，如果同时使用，如何解决名字冲突？

如果使用import导入模块名，由于必须通过模块名引用函数名，因此不存在冲突：

import math, logging
print math.log(10)   # 调用的是math的log函数logging.log(10, 'something')   # 调用的是logging的log函数

如果使用 from...import 导入 log 函数，势必引起冲突。这时，可以给函数起个“别名”来避免冲突：

from math import log
from logging import log as logger   # logging的log现在变成了loggerprint log(10)   # 调用的是math的loglogger(10, 'import from logging')   # 调用的是logging的log

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

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

使用匿名函数，可以不必定义函数名，直接创建一个函数对象，很多时候可以简化代码：

>>> sorted([1, 3, 9, 5, 0], lambda x,y: -cmp(x,y))
[9, 5, 3, 1, 0]

返回函数的时候，也可以返回匿名函数：

>>> myabs = lambda x: -x if x < 0 else x 
>>> myabs(-1)
1
>>> myabs(1)
1

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：

# 希望一次返回3个函数，分别计算1x1,2x2,3x3:def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9（请自己动手验证）。

原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：

>>> f1()
9     # 因为f1现在才计算i*i，但现在i的值已经变为3

因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。