Python进阶

函数式编程

 1. 函数和函数式不同，就像计算和计算机不同一样
    变量可以指向函数：
    f=abs
    f(-20)=20
    且函数名本身就是指向函数的变量：
    abs=len
    abs(-10) 报错
    abs([1,2,3])=3此时abs为len函数计算list的长度
 2. 高阶函数：能接受函数作为参数的函数
    def and(x,y,f):
        return f(x)+f(y)
    and(-5,8,abs)=13   此时and函数可以看做高阶函数

 3. map()函数

    def f(x):
        return x*x
    print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
    输出结果：
    [1, 4, 9, 10, 25, 36, 49, 64, 81]

    map()函数不改变原有的 list，而是返回一个新的 list。
    利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。 
    由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。

    假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则，请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list：
输入：['adam', 'LISA', 'barT']
输出：['Adam', 'Lisa', 'Bart']

def format_name(s):
    c=s.lower()
    l=len(c)
    if l>0:
        s=c[0].upper()+c[1:l]
    else:
        s=c[0].upper()
    return s
print map(format_name,['adam', 'LISA', 'barT'])意map()函数是每次对s中的一个元素依次进行函数运算，而不是对整个s进行操作
//既def format_name（s）函数中的s分别是‘adam’、‘LIST’、‘barT'而不是整个LIST “s”  

 4. reduce（）函数
    reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。
例如，编写一个f函数，接收x和y，返回x和y的和：
def f(x, y):
    return x + y
调用 reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：
先计算头两个元素：f(1, 3)，结果为4；
再把结果和第3个元素计算：f(4, 5)，结果为9；
再把结果和第4个元素计算：f(9, 7)，结果为16；
再把结果和第5个元素计算：f(16, 9)，结果为25；
由于没有更多的元素了，计算结束，返回结果25。
上述计算实际上是对 list 的所有元素求和。reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：
reduce(f, [1, 3, 5, 7, 9], 100)
结果将变为125，因为第一轮计算是：
计算初始值和第一个元素：f(100, 1)，结果为101。

 5. filter()函数
  （1） filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：
def is_odd(x):
    return x % 2 == 1
然后，利用filter()过滤掉偶数：
filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
结果：[1, 7, 9, 17]

（2）利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：
def is_not_empty(s):
    return s and len(s.strip()) > 0
filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])
结果：['test', 'str', 'END']
注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。
当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下：
a = '     123'
a.strip()
结果： '123'
a='\t\t123\r\n'
a.strip()
结果：'123'


（3）请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

import math
def is_sqr(x):
    return math.sqrt(x)%1==0

print filter(is_sqr, range(1, 101))

 6. 自定义函数sorted()
   (1) Python内置的 sorted()函数可对list进行排序：
>>>sorted([36, 5, 12, 9, 21])
[5, 9, 12, 21, 36]

   (2)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]
   (3)sorted()也可以对字符串进行排序，字符串默认按照ASCII大小来比较：
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']
'Zoo'排在'about'之前是因为'Z'的ASCII码比'a'小。
   (4)对字符串排序时，有时候忽略大小写排序更符合习惯。请利用sorted()高阶函数，实现忽略大小写排序的算法。
输入：['bob', 'about', 'Zoo', 'Credit']
输出：['about', 'bob', 'Credit', 'Zoo']
 def cmp_ignore_case(s1, s2):
    if s1.lower()>s2.lower():
        return 1
    if s1.lower()<s2.lower():
        return -1
    return 0

 print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)   

 7. 返回函数
    Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数
   （1）定义一个函数 f()，我们让它返回一个函数 g，可以这样写：
def f():
    print 'call f()...'
    # 定义函数g:
    def g():
        print 'call g()...'
    # 返回函数g:
    return g
>>> x = f()   # 调用f()
call f()...
>>> x   # 变量x是f()返回的函数：
<function g at 0x1037bf320>
>>> x()   # x指向函数，因此可以调用//注意函数名加上（）才能执行该函数
call g()...   # 调用x()就是执行g()函数定义的代码

   （2）请注意区分返回函数和返回值：
def myabs():
    return abs   # 返回函数
def myabs2(x):
    return abs(x)   # 返回函数调用的结果，返回值是一个数值

   （3）返回函数可以把一些计算延迟执行。如果返回一个函数，就可以“延迟计算”：
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
由于可以返回函数，我们在后续代码里就可以决定到底要不要调用该函数。
   （4）请编写一个函数calc_prod(lst)，它接收一个list，返回一个函数，返回函数可以计算参数的乘积。
   def calc_prod(lst):
    def f(x,y):
        return x*y
    def h():
        return reduce(f,lst)
    return h
f = calc_prod([1, 2, 3, 4])
print f()

 8. decorator-装饰器  极大简化代码，避免代码重写的复杂性
 (1)python函数使用语法简化装饰器调用
 @new_fn                   def f1(x):
 def f1(x):        ---->       return 2*x  
     return 2*x            f1=new_fn(f1)
 (2)编写无参decorator
 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。
 @log函数只能对一个参数的函数有作用
 要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总 是能正常调用：
def log(f):
    def fn(*args, **kw):
        print 'call ' + f.__name__ + '()...'
        return f(*args, **kw)
    return fn

 （3） 计算函数调用的时间可以记录调用前后的当前时间戳，然后计算两个时间戳的差。
    import time

    def performance(f):
        def fn(*args,**kw)://能适应多个参数
            t1=time.time()
            r=f(*args,**kw)
            t2=time.time()
            print 'call %s() in %fs' % (f.__name__, (t2 - t1))//输出的语法和C语言类似，--->（" call %s ()  in %f s",f.__name__,(t2-t1)）
            return r
        return fn

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

    print factorial(10)
（4）上一节的@performance只能打印秒，请给 @performace 增加一个参数，允许传入's'或'ms'：
import time

def performance(unit):
    def fn(f):
        def new_fn(*args,**kw):
            t1=time.time()
            r=f(*args,**kw)
            t2=time.time()
            t=(t2-t1)*1000 if unit=='ms' else (t2-t1)//if else语句的写法
            print 'call %s() in %f%s'%(f.__name__,t,unit)
            return r
        return new_fn
    return fn


@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)
（5） functools，将decorator中的函数属性赋值给原函数
import functools
def log(f):
    @functools.wraps(f)//将函数f的函数名、doc等属性赋值给wrapper函数，避免返回wrapper的属性
    def wrapper(*args, **kw):
        print 'call...'
        return f(*args, **kw)
    return wrapper
（6)偏函数 -functools.partial()

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
其中functools.partial(int,base=2)相当于
def int2(x, base=2):
    return int(x, base)
所以，functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。


sorted这个高阶函数中传入自定义排序函数就可以实现忽略大小写排序。请用functools.partial把这个复杂调用变成一个简单的函数：
import functools

sorted_ignore_case = functools.partial(sorted,cmp=lambda s1,s2: cmp(s1.upper(),s2.upper()))//再次简化，lambda表达式，实现简单的函数功能简化

print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])

面向对象编程

 1. 创建实例属性

 由于python是动态语言，因此可以直接进行属性的赋值而不需要先定义
xiaoming = Person()
xiaoming.name = 'Xiao Ming'
xiaoming.gender = 'Male'
xiaoming.birth = '1990-1-1'
任务：
请创建包含两个 Person 类的实例的 list，并给两个实例的 name 赋值，然后按照 name 进行排序。
代码：
class Person(object):
    pass

p1 = Person()
p1.name = 'Bart'

p2 = Person()
p2.name = 'Adam'

p3 = Person()
p3.name = 'Lisa'

L1 = [p1, p2, p3]
L2 = sorted(L1,lambda x,y: cmp(x.name,y.name))

print L2[0].name
print L2[1].name
print L2[2].name

 2. 初始化实例属性-->__init__()方法:
 __int__（self，） 初始化实例的属性，（同时也具备普通函数的功能,可以在其中进行一些计算和初始化），每执行一次就计算函数内容的运算，函数里面引用类的属性需要带上类名。self相当于php的伪变量，为每个实例自身赋值。
 class Person(object):
    def __init__(self, name, gender, birth):
        self.name = name
        self.gender = gender
        self.birth = birth
__init__() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。
 3. 属性访问限制（私有属性）
 class Person(object):
    def __init__(self, name, score):
        self.name=name
        self.__score=score

p = Person('Bob', 59)

print p.name
print p.__score
__score和_score的区别在于_score可以再子类中使用，相当于c++中的protect，__score不能再子类中使用，相当于private

 4. 创建类的属性
 class Person(object):
    address = 'Earth'
    def __init__(self, name):
        self.name = name
因为类属性是直接绑定在类上的，所以，访问类属性不需要创建实例，就可以直接访问：
print Person.address
# => Earth

任务：
请给 Person 类添加一个类属性 count，每创建一个实例，count 属性就加 1，这样就可以统计出一共创建了多少个 Person 的实例
代码：
class Person(object):
    count=0;
    def __init__(self,name):
        self.name=name
        Person.count=Person.count+1

p1 = Person('Bob')
print Person.count

p2 = Person('Alice')
print Person.count

 5. 实例属性和类属性
class Person(object):
    address = 'Earth'
//类属性
    def __init__(self, name):
        self.name = name
p1 = Person('Bob')
p2 = Person('Alice')
p1.address = 'China'
//实例属性
print p1.address
print p2.address 
两者不相同，p1的address属性为China,p2的arth实例属性的优先级高于类属性

 6. 定义实例方法
实例的方法就是在类中定义的函数，它的第一个参数永远是 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)其实也可看做是一个特殊的实例方法。
任务：
请给 Person 类增加一个私有属性 __score，表示分数，再增加一个实例方法 get_grade()，能根据 __score 的值分别返回 A-优秀, B-及格, C-不及格三档。
代码：
# -*- coding: utf-8 -*- 
class Person(object):

    def __init__(self, name, score):
        self.name=name
        self.__score=score

    def get_grade(self):
        if  self.__score>=80:
            return 'A-优秀'
        elif self.__score>=60:
            return 'B'
        else:
            return 'C'

p1 = Person('Bob', 90)
p2 = Person('Alice', 65)
p3 = Person('Tim', 48)

print p1.get_grade()
print p2.get_grade()
print p3.get_grade()

 7. 方法也是属性
class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
        self.get_grade = lambda: 'A'

p1 = Person('Bob', 90)
print p1.get_grade//输出方法的位置
print p1.get_grade()

 8. 定义类方法(实例方法和类方法的区别)
要在class中定义类方法，需要这么写：
class Person(object):
    count = 0
    @classmethod
    def how_many(cls):
        return cls.count
    def __init__(self, name):
        self.name = name
        Person.count = Person.count + 1

print Person.how_many()
p1 = Person('Bob')
print Person.how_many()
通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。
因为是在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。任务：
如果将类属性 count 改为私有属性__count，则外部无法读取__score，但可以通过一个类方法获取，请编写类方法获得__count值。
代码：
class Person(object):

    __count = 0

    @classmethod//注意加上classmethod注解
    def how_many(cls)://cls参数相当于类本（classs）
        return cls.__count

    def __init__(self,name):
        self.name=name
        Person.__count=Person.__count+1

print Person.how_many()

p1 = Person('Bob')

print Person.how_many()

类的继承

 1. 继承一个类：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
定义Student类时，只需要把额外的属性加上
class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
一定要用 super(Student, self).__init__(name, gender) 去初始化父类，否则，继承自 Person 的 Student 将没有 name 和 gender。
函数super(Student, self)将返回当前类继承的父类，即 Person ，然后调用__init__()方法，注意self参数已在super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）。

 2. 多态
.........
 3. 获取对象的属性（getattr(),setattr()方法）
>>> s = Student('Bob', 'Male', 88)//Student为某个类
>>> getattr(s, 'name')  # 获取name属性
'Bob'

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

>>> s.name
'Adam'
任务：
对于Person类的定义：
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
希望除了 name和gender 外，可以提供任意额外的关键字参数，并绑定到实例，请修改 Person 的 __init__()定 义，完成该功能。
代码：
class Person(object):

    def __init__(self, name, gender, **kw):
        self.name=name
        self.gender=gender
        for k,v in kw.iteritems():
            setattr(self,k,v)

p = Person('Bob', 'Male', age=18, course='Python')//age、course为多余的参数
print p.age
print p.course

定制类

 1. __str__和__repr__
 __str__相当于JAVA中的toString方法
任务：
请修改 Student 的 __cmp__ 方法，让它按照分数从高到底排序，分数相同的按名字排序。
代码：
class Student(object):

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

    def __str__(self):
        return '(%s: %s)' % (self.name, self.score)//输出属性

    __repr__ = __str__//必须加上，不然输出的是开发人员看的字符

    def __cmp__(self, s):
        if self.score>s.score:
            return -1
        elif self.score<s.score:
            return 1
        else:
            if self.name>s.name:
                return 1
            elif self.name<s.name:
                return -1
            else:
                return 0
            return 0

L = [Student('Tim', 99), Student('Bob', 88), Student('Alice', 99)]
print sorted(L)

 2. __len__
 如果一个类表现得像一个list，要获取有多少个元素，就得用 len() 函数。
要让 len() 函数工作正常，类必须提供一个特殊方法__len__()，它返回元素的个数。
任务：
斐波那契数列是由 0, 1, 1, 2, 3, 5, 8...构成。
请编写一个Fib类，Fib(10)表示数列的前10个元素，print Fib(10) 可以打印出数列的前 10 个元素，len(Fib(10))可以正确返回数列的个数10。
代码：


class Fib(object):



    def __init__(self, num):

        L=[0,1]

        for i in range(num-2):

            L.append(L[-1]+L[-2])//添加倒数第一和倒数第二的函数

        self.names=L//将L赋值赋值给实例f新增的names属性，其实就是个中间变量



    def __str__(self):

        return str(self.names)//str() 函数将对象转化为适于人阅读的形式。



    def __len__(self):

        return len(self.names)
f = Fib(10)
print f
print len(f)

 3. 数学运算
任务：
Rational类虽然可以做加法，但无法做减法、乘方和除法，请继续完善Rational类，实现四则运算。
提示：
减法运算：__sub__
乘法运算：__mul__
除法运算：__div__


代码：

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

class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)//递归
    def __sub__(self, r):
        return Rational(self.p * r.q - self.q * r.p, self.q * r.q)//递归
    def __mul__(self, r):
        return Rational(self.p * r.p, self.q * r.q)//递归
    def __div__(self, r):
        return Rational(self.p * r.q, self.q * r.p)
    def __str__(self):
        g = gcd(self.p, self.q)
        return '%s/%s' % (self.p / g, self.q / g)
    __repr__ = __str__

r1 = Rational(1, 2)
r2 = Rational(1, 4)
print r1 + r2
print r1 - r2
print r1 * r2
print r1 / r2

 4. @property
 因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，可以用装饰器函数把 get/set 方法“装饰”成属性调用：
class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.__score = score
    @property//相当于封装他的get方法，可以直接sutdent.score访问
    def score(self):
        return self.__score
    @score.setter//相当于封装他的set方法，可以直接sutdent.score=?进行赋值并判断等操作
    def score(self, score):
        if score < 0 or score > 100:
            raise ValueError('invalid score')
        self.__score = score
注意: 第一个score(self)是get方法，用@property装饰，第二个score(self, score)是set方法，用@score.setter装饰，@score.setter是前一个@property装饰后的副产品。

任务：
如果没有定义set方法，就不能对“属性”赋值，这时，就可以创建一个只读“属性”。
请给Student类加一个grade属性，根据 score 计算 A（>=80）、B、C（<60）。
代码：
class Student(object):

    def __init__(self, name, score):
        self.name = name
        self.__score = score

    @property
    def score(self):
        return self.__score

    @score.setter
    def score(self, score):
        if score < 0 or score > 100:
            raise ValueError('invalid score')
        self.__score = score

    @property 
    def grade(self):
        if self.__score>=80:
            return 'A'
        elif self.__score>=60:
            return 'B'
        else:
            return 'C'

s = Student('Bob', 59)
print s.grade

s.score = 60
print s.grade

s.score = 99
print s.grade

 5. __solts__
__slots__的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，使用__slots__也能节省内存。
任务：
假设Person类通过__slots__定义了name和gender，请在派生类Student中通过__slots__继续添加score的定义，使Student类可以实现name、gender和score 3个属性。
代码：
class Person(object):

    __slots__ = ('name', 'gender')

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

class Student(Person):

    __slots__ = ('name', 'gender','score')

    def __init__(self, name, gender,score):
        super(Student,self).__init__(name,gender)
        self.score=score
s = Student('Bob', 'male', 59)
s.name = 'Tim'
s.score = 99
print s.score

 6. __call__
我们把 Person 类变成一个可调用对象：
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print 'My name is %s...' % self.name
        print 'My friend is %s...' % friend
现在可以对 Person 实例直接调用：
>>> p = Person('Bob', 'male')
>>> p('Tim')//当p实例以函数的形式调用其参数时启用__call__
My name is Bob...
My friend is Tim...
单看 p('Tim') 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著。
任务：
改进一下前面定义的斐波那契数列：
class Fib(object):
    ???
请加一个__call__方法，让调用更简单：
>>> f = Fib()
>>> print f(10)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
代码：
class Fib(object):
    def __call__(self,num):
        L=[0,1]

        for i in range(num-2):

            L.append(L[-1]+L[-2])

        return L


f = Fib()
print f(10)