@语法装饰器

lambda

https://www.cnblogs.com/zhangzhuozheng/p/8053045.html

args kwargs

https://blog.csdn.net/zjuxsl/article/details/79437563

闭包

https://blog.csdn.net/u010339879/article/details/80301651

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

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

reduce不太懂

类方法：在定义类方法之前添加语句：“@classmethod”，则该类方法将被绑定到该类上；类方法的第一个参数将传入类本身，通常将此参数名命名为“cls”，“cls.属性名”相当于“类名.属性名”。

因为是在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。

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()        # 0
p1 = Person('Bob')
print Person.how_many()        # 1

在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

因为方法也是一个属性，所以，它也可以动态地添加到实例上，只是需要用 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
        # self.get_grade = lambda: 'A'

p1 = Person('Bob', 90)
p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
print p1.get_grade()
# => A
p2 = Person('Alice', 65)
print p2.get_grade()
# ERROR: AttributeError: 'Person' object has no attribute 'get_grade'
# 因为p2实例并没有绑定get_grade

直接把 lambda 函数赋值给 self.get_grade 和绑定方法有所不同，函数调用不需要传入 self，但是方法调用需要传入 self。

实例方法：第一个参数固定为self，后续参数和普通函数参数相同。

class Person(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
    def get_grade(self):
        return self.__score

p1 = Person('p1', 80)
print p1.get_grade()        # 80

类属性、实例属性：通过实例修改与某个类属性同名的属性时，修改的是实例的属性，而非同名的类属性。

import time

def performance(unit):

    def perf_decorator(f):

        def wrapper(*args, **kw):

            t1 = time.time()

            r = f(*args, **kw)

            t2 = time.time()

            t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)

            print 'call %s() in %f %s' % (f.__name__, t, unit)

            return r

        return wrapper

    return perf_decorator

@performance('ms')

def factorial(n):

    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

@performance('')

def factorial(n):

    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

def count():

    fs = []

    for i in range(1, 4):

        def f():

            for j in range(1,len(fs)+1)

            return j * j

        fs.append(f)

    return fs

f1, f2, f3 = count()

print f1(), f2(), f3()

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

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

a = '     123'
a.strip()

类属性：可以被直接访问，且对于该类所创建的所有实例而言，访问的都是同一个类属性。

class Person(object):
    count = 0
    def __init__(self, name):
        Person.Count = Person.Count + 1
        self.name = name

p1 = Person('p1')
print Person.Count        # 1
p2 = Person('p2')
print p2.Count        # 2

限制属性访问权：

__attr：无法被外部访问。

__attr__：特殊属性，可以被外部访问。

_attr：可以被外部访问。但按照习惯，不应该被外部访问。

__init__()：初始化实例的属性。在类中定义此方法并为每个属性赋值，当创建实例时，此方法自动被调用并为实例添加属性。第一个参数必须是self（或其它名字），后续参数自由指定，相应地，创建实例时必须提供除self以外的参数。

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')

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]

高阶函数：能够接收函数作为参数的函数