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

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

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

a = '     123'

a.strip()

结果： '123'

a='\t\t123\r\n'

a.strip()

结果：'123'

同名的变量再不同py文件中互不影响，模块名即同名的模块放入不同的包中；在文件系统中，包就是文件夹，模块就是.py文件，包可以有多级；区分包和普通目录，每层包下必须有一个_init_.py文件

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义。lambda的主体是一个表达式

由于decorator返回的新函数函数名已经不是'f2'，而是@log内部定义的'wrapper'。decorator还改变了函数的__doc__等其它属性。Python内置的functools可以用来自动化把原函数的一些属性复制到新函数中

demo

@简化装饰器调用

装饰器地作用

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

求a与b的最大公约数

s[0].upper()+s[1:].lower()首字母大写其余小写

class Fib(object):

    def __init__(self, num):
        a,b,L = 0,1,[]
        for n in  range(num):
            L.append(a)
            a,b = b,a+b
        self.numbers = L
           

    def __str__(self):
        return str(self.numbers)
       
    __repr__ = __str__
   
    def __len__(self):
        return len(self.numbers)

f = Fib(10)
print f
print len(f)

斐波那契数列

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

我们在 class 中定义的实例方法其实也是属性，它实际上是一个函数对象：
class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def get_grade(self):
        return 'A'

p1 = Person('Bob', 90)
print p1.get_grade
# => <bound method Person.get_grade of <__main__.Person object at 0x109e58510>>
print p1.get_grade()
# => A
也就是说，p1.get_grade 返回的是一个函数对象，但这个函数是一个绑定到实例的函数，
p1.get_grade() 才是方法调用。
因为方法也是一个属性，所以，它也可以动态地添加到实例上，只是需要用 
types.MethodType() 把一个函数变为一个方法：
import types
def fn_get_grade(self):
    if self.score >= 80:
        return 'A'
    if self.score >= 60:
        return 'B'
    return 'C'

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

p1 = Person('Bob', 90)p1.get_grade = types.MethodType(fn_get_grade, p1, Person)print p1.get_grade()# => Ap2 = Person('Alice', 65)
print p2.get_grade()# ERROR: AttributeError: 'Person' object has no attribute 'get_grade'
# 因为p2实例并没有绑定get_grade
给一个实例动态添加方法并不常见，直接在class中定义要更直观。

虽然私有属性无法从外部访问，但是，从类的内部是可以访问的。除了可以定义实例的属性外，还可以定义实例的方法。

实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的：

class Person(object):

    def __init__(self, name):
        self.__name = name

    def get_name(self):
        return self.__name

get_name(self) 就是一个实例方法，它的第一个参数是self。__init__(self, name)其实也可看做是一个特殊的实例方法。

调用实例方法必须在实例上调用：

p1 = Person('Bob')
print p1.get_name()  # self不需要显式传入# => Bob

在实例方法内部，可以访问所有实例属性，这样，如果外部需要访问私有属性，可以通过方法调用获得，这种数据封装的形式除了能保护内部数据一致性外，还可以简化外部调用的难度。

访问 p1.address 时，优先查找实例属性，返回'China'。

访问 p2.address 时，p2没有实例属性address，但是有类属性address，因此返回'Earth'。

可见，当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。

当我们把 p1 的 address 实例属性删除后，访问 p1.address 就又返回类属性的值 'Earth'了：

del p1.address
print p1.address# => Earth

可见，千万不要在实例上修改类属性，它实际上并没有修改类属性，而是给实例绑定了一个实例属性。