重点章节。

需要搞清楚每个函数之间互相嵌套的关系。

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

注意reduce的用法

调用f()之后,x会被赋予f()的值,但是x不指向函数的情况下(即不是x())是无法调用第二层函数的

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

def format_name(s):

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

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

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

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum
    像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

sorted只需要一个list作为参数，可以添加函数改变它的判断值

在例题中把所有list中的元素大写（小写），然后直接copy参数的返回值

s.strip()这个函数的作用是用来判断字符是否为NONE以及是否为空格。

filter可以判断并留下布尔值为TRUE的元素并组成新的LIST

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

当rm为空时，默认删除空白符.

例题中的r = int(math.sqrt(x))用来限制r为整数的平方根

注意filter的返回值

记住map只需要传入一个参数，reduce需要多个参数

注意在案例答案中直接使用的方式：

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

其实可以免去第一行，因为map是独自引用各个参数

任务

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

reduce()接收的函数f需要两个参数，并返回一个结果，以便继续进行下一轮计算。

def prod(x, y):                                 def f(x,y)

    return x * y                                   return x*y

print reduce(prod, [2, 4, 5, 7, 12])

先定义能计算乘积的函数，再将此函数返回。

参考代码:

def calc_prod(lst):

    def lazy_prod():

        def f(x, y):

            return x * y

        return reduce(f, lst, 1)

    return lazy_prod

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

print f()

因此，如果我们要实现倒序排序，只需要编写一个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']

• ?不会了怎么办

• 对于比较函数cmp_ignore_case(s1, s2)，要忽略大小写比较，就是先把两个字符串都变成大写（或者都变成小写），再比较。

  参考代码:

  def cmp_ignore_case(s1, s2):
      u1 = s1.upper()
      u2 = s2.upper()
      if u1 < u2:
          return -1
      if u1 > u2:
          return 1
      return 0
  print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

class Person(object):

    def __init__(self, name, gender, birth, **kw):

        self.name = name

        self.gender = gender

        self.birth = birth

        for k,v in kw.iteritems():

            setattr(self, k, v)

xiaoming = Person('Xiao Ming', 'Male', '1990-1-1', job='Student')

print xiaoming.name

print xiaoming.job

使用了迭代器

1.辗转相除法

两数取余，小着与余数再相余，直至余数为零，此时的被余数为最大公约数。

2.更相减损法

两者相减，小者与差数再相减，直至差数为零，此时被减数为最大公约数。

3.穷举法

取较大者为i，两者同时取i的余数，若余数不同时等于零，则i-1，再次取余，直至余数为1。此时的i为最大公约数

类可以多态（方法调用将作用在 x 的实际类型上，方法可以重名但是依然可以根据实际类型正确输出结果）

调用方法（ 如例中s.whoAmI()）总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。

子类属性和方法比父类多，所以子不是父

父类属性和方法全部继承给了子类，所以父判断是子

子类与子类之间互不相同