强制转化为int型: int()而不是（int）

filter(f,L)：利用函数f过滤L中的值生成一个新的list

reduce（f，L，n): f为函数，接收两个参数，第一次参数为list中的1，2项，第二次参数为1，2项通过函数计算出的结果和第3项，以此类推；n为计算的初始值，可省略。

转化为大写字母：s.upper()

转化为小写字母：s.lower()

map(f,L)：将list L通过函数f生成一个新的list

函数中的参数可以指向函数：

def add(x,y,f):

    return f(x)+f(y)

add(-4,5,abs)

python中编写无参数decorator

Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。

使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。

考察一个@log的定义：

def log(f):     
    def fn(x):         
        print 'call ' + f.__name__ + '()...'         
        return f(x)     
    return fn

对于阶乘函数，@log工作得很好：

@log 
def factorial(n):     
    return reduce(lambda x,y: x*y, range(1, n+1)) 
    print factorial(10)

结果：

call factorial()... 
3628800

但是，对于参数不是一个的函数，调用将报错：

@log def add(x, y):     
return x + y print add(1, 2)

结果：

Traceback (most recent call last):   
File "test.py", line 15, in <module>     
print add(1,2) 
TypeError: fn() takes exactly 1 argument (2 given)

因为 add() 函数需要传入两个参数，但是 @log 写死了只含一个参数的返回函数。

要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用：

def log(f):     
def fn(*args, **kw):         
print 'call ' + f.__name__ + '()...'         
return f(*args, **kw)     
return fn

现在，对于任意函数，@log 都能正常工作

@property定义只读属性

@setter定义可读可写属性

@deleter定义可读可写可删除属性

 type() 函数获取变量的类型，它返回一个 Type 对象：

>>> type(123)
<type 'int'>
>>> s = Student('Bob', 'Male', 88)
>>> type(s)
<class '__main__.Student'>

dir() 函数获取变量的所有属性：

>>> dir(123)   # 整数也有很多属性...['__abs__', '__add__', '__and__', '__class__', '__cmp__', ...]

dir()返回的属性是字符串列表，如果已知一个属性名称，要获取或者设置对象的属性，就需要用 getattr() 和 setattr( )函数了：

>>> getattr(s, 'name')  # 获取name属性'Bob'

>>> setattr(s, 'name', 'Adam')  # 设置新的name属性>>> s.name
'Adam'

>>> getattr(s, 'age')  # 获取age属性，但是属性不存在，报错：Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'

>>> getattr(s, 'age', 20)  # 获取age属性，如果属性不存在，就返回默认值20：20

除了从一个父类继承外，Python允许从多个父类继承，称为多重继承

多重继承的目的是从两种继承树中分别选择并继承出子类，以便组合功能使用。

import json
f = open('/path/to/file.json', 'r')
print json.load(f)

读取一个指定文件。

由于Python的动态特性，json.load()并不一定要从一个File对象读取内容。任何对象，只要有read()方法，就称为File-like Object，都可以传给json.load()。

isinstance(p, Person)

isinstance函数可以判断类型，返回值为Ture 和 False

继承父类时如果要继承父类的属性，一定要用 super(Student, self).__init__(name, gender) 去初始化父类

这个现在懂了，估计过几天右忘记了

利用匿名函数简化以下代码：

def is_not_empty(s):
    return s and len(s.strip()) > 0
filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])

参考代码:

print filter(lambda s: s and len(s.strip())>0, ['test', None, '', 'str', '  ', 'END'])

# 希望一次返回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

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

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

python中自定义排序函数

Python内置的 sorted()函数可对list进行排序：

>>>sorted([36, 5, 12, 9, 21])
[5, 9, 12, 21, 36]

但 sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

因此，如果我们要实现倒序排序，只需要编写一个reversed_cmp函数：

def reversed_cmp(x, y):     if x > y:         return -1     if x < y:         return 1     return 0

这样，调用 sorted() 并传入 reversed_cmp 就可以实现倒序排序：

>>> sorted([36, 5, 12, 9, 21], reversed_cmp) [36, 21, 12, 9, 5]

sorted()也可以对字符串进行排序，字符串默认按照ASCII大小来比较：

>>> sorted(['bob', 'about', 'Zoo', 'Credit']) ['Credit', 'Zoo', 'about', 'bob']

'Zoo'排在'about'之前是因为'Z'的ASCII码比'a'小。

任务

对字符串排序时，有时候忽略大小写排序更符合习惯。请利用sorted()高阶函数，实现忽略大小写排序的算法。

输入：['bob', 'about', 'Zoo', 'Credit']
输出：['about', 'bob', 'Credit', 'Zoo']