filter(f, list) 可以利用f()剔除掉不符合标准的项

reduce(f, list) f(x,y), 接受两个变量，对list前两个值进行操作，返回值+第三个值进行操作

map(f, list) f(x)对list的每个值进行操作

upper 是将所有的字母都变成大写

lower 是将所有的字母都变成小写

python中接收任意关键字参数的__init__函数

Python内置的开方函数-----sqrt()

• 对is_not_empty(s)函数的解释：考虑的是s的长度大于0的，当s=''时，len(s)=0,则应写 len(s) > 0, 为了排除首尾空字符串或\n\t等情况，即当s=' '时，len(s)=1,而s.strip()是表示删除s字符串中为空的字符，应改写为len(s.strip()) > 0
  

• 其次，当s=None时，len(s)大于0，且s.strip也无法删除，len(s.strip())>0的函数判断不适用于s为None的情况，而 s 不能None；但是当 s>0,当s为None时，s>0为假，且在Python里，编译器把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True，故当

        def is_not_empty(s):

                 return s>0 #只能过滤掉S为None的情况

                 filter(is_not_empty,['test',None,'','str',' ','END'])得到的list是除None其它的都在的list

        最终正确的定义为：

        def is_not_empty(s):

                   return s and len(s.strip()) > 0  

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

• int(x)是对x取整，math.sqrt(x)对x取平方根，返回结果为浮点数
  

python内置的高阶函数reduce()，接收的参数有，一个函数f，一个list，还可以有初始值，但作用为对list中的每一个元素重复函数f()的功能

python内置的高阶函数map()函数，接受一个函数f和一个list，并通过list的每个元素做出f()的操作，得到一个新的list并返回，map()函数不改变原有的list，而是返回一个新的list

def format_name(s)L

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

print map(format_name,['adan','LISA',;barT'])

属性有类属性和实例对象属性，当定义一个类时就有了类属性，当创建一个实例对象时，会拷贝一份类属性给实例对象，即实例对象属性

类属性和实例对象属性都分为私有属性和公有属性

类的私有属性通过类方法调用
类的公有属性通过类方法调用，或者直接 类名.属性

实例对象的私有属性通过实例方法调用，
实例对象的公有属性通过实例方法调用，或者 实例名.属性

私有属性不可以直接被调用，但可以通过方法来调用，包括类方法和实例方法，所以如果要想调用出私有属性的值，定义方法就可以啦

通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。

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

python中返回函数

Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数！

例如，定义一个函数 f()，我们让它返回一个函数 g，可以这样写：

def f():     print 'call f()...'     # 定义函数g:     def g():         print 'call g()...'     # 返回函数g:     return g

仔细观察上面的函数定义，我们在函数 f 内部又定义了一个函数 g。由于函数 g 也是一个对象，函数名 g 就是指向函数 g 的变量，所以，最外层函数 f 可以返回变量 g，也就是函数 g 本身。

调用函数 f，我们会得到 f 返回的一个函数：

>>> x = f()   # 调用f() call f()... >>> x   # 变量x是f()返回的函数： <function g at 0x1037bf320> >>> x()   # x指向函数，因此可以调用 call g()...   # 调用x()就是执行g()函数定义的代码

请注意区分返回函数和返回值：

def myabs():     return abs   # 返回函数 def myabs2(x):     return abs(x)   # 返回函数调用的结果，返回值是一个数值

返回函数可以把一些计算延迟执行。例如，如果定义一个普通的求和函数：

def calc_sum(lst):     return sum(lst)

调用calc_sum()函数时，将立刻计算并得到结果：

>>> calc_sum([1, 2, 3, 4]) 10

但是，如果返回一个函数，就可以“延迟计算”：

def calc_sum(lst):     def lazy_sum():         return sum(lst)     return lazy_sum

# 调用calc_sum()并没有计算出结果，而是返回函数:

>>> f = calc_sum([1, 2, 3, 4]) >>> f <function lazy_sum at 0x1037bfaa0>

# 对返回的函数进行调用时，才计算出结果:

>>> f() 10

由于可以返回函数，我们在后续代码里就可以决定到底要不要调用该函数。

任务

请编写一个函数calc_prod(lst)，它接收一个list，返回一个函数，返回函数可以计算参数的乘积。

def calc_prod(lst):

    def calc_prod_later():

        def prod(x, y):

            return x * y

        return reduce(prod, lst)     

    return calc_prod_later

f = calc_prod([1, 2, 3, 4])

print f()

class Fib(object):

    def __init__(self, num):

        self.fib = [0,1]

        while len(self.fib) < num:

            self.fib.append(self.fib[-2]+self.fib[-1])

    def __len__(self):

        return len(self.fib)

    def __str__(self):

        return str(self.fib)

f = Fib(10)

print f

print len(f)

斐波那契数列是由 0, 1, 1, 2, 3, 5, 8...构成。

while b < 1000:    
    print(b)
    a, b = b, a+b 实现