python笔记

1.map(f,list) 
2.reduce(f,list) 
3.filter(f,list)
4.sorted(list,cmp)
如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0
5.返回函数
6.像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：
7.匿名函数
通过对比可以看出，匿名函数 lambda x: x * x 实际上就是：

def f(x):
return x * x
关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。
8.decoder
Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。
使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。
9.复制原始信息@functools.wraps(f)
import functools
def log(f):
@functools.wraps(f)
def wrapper(*args, **kw):
print 'call...'
return f(*args, **kw)
return wrapper
10.Python偏函数
当一个函数有很多参数时，调用者就需要提供多个参数。如果减少参数个数，就可以简化调用者的负担。
def int2(x, base=2):
return int(x, base)
11.导入模块
import math
12.动态导入
try:
import json
except ImportError:
import simplejson
13. 2中导入3的方法
要在Python 2.7中引入3.x的除法规则，导入__future__的division：

>>> from __future__ import division
>>> print 10 / 3
3.3333333333333335
14.创建实例
15.创建实例，添加属性
16.初始化
def __init__
17.私有属性
Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问。看例子：
18.类属性
class Person(object):
address = 'Earth'
def __init__(self, name):
self.name = name
19.属性同名
可见，当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。
20.实例方法
实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的：

class Person(object):

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

def get_name(self):
return self.__name
21.静态方法，
22.继承
class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score
23.判断类型
isinstance(s, Person)
24.多态，重写
类具有继承关系，并且子类类型可以向上转型看做父类类型，如果我们从 Person 派生出 Student和Teacher ，并都写了一个 whoAmI() 方法：
25.多重继承
class A(object):
def __init__(self, a):
print 'init A...'
self.a = a

class B(A):
def __init__(self, a):
super(B, self).__init__(a)
print 'init B...'

class C(A):
def __init__(self, a):
super(C, self).__init__(a)
print 'init C...'

class D(B, C):
def __init__(self, a):
super(D, self).__init__(a)
print 'init D...'
26.获取对象信息
首先可以用 type() 函数获取变量的类型，它返回一个 Type 对象：

>>> type(123)
<type 'int'>
>>> s = Student('Bob', 'Male', 88)
>>> type(s)
<class '__main__.Student'>
27.__str__()和__repr__()
因为 Python 定义了__str__()和__repr__()两种方法，__str__()用于显示给用户，而__repr__()用于显示给开发人员。
28. __cmp__()：实例对象的对比方法
29.__len__
30.有理数
>>> r1 = Rational(1, 3)
>>> r2 = Rational(1, 2)
>>> print r1 + r2
5/6
31. get set 方法
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
32.只允许添加的属性
顾名思义，__slots__是指一个类允许的属性列表：
33. 类编程可调用对象
由于 f 可以被调用，所以，f 被称为可调用对象。
所有的函数都是可调用对象。
一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。
-============
decorator

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

return r
return fn

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

print factorial(10)


--三层的包装
import time

def performance(unit):
def perform2(f):
def wrapprr(*args, **kw):
t1=time.time();
r=f(*args, **kw)
t2=time.time();
time3 = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)
print 'call %s() in %f %s' % (f.__name__, time3, unit)
return r
return wrapprr
return perform2

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

print factorial(10)

--- @functools.wraps(f)

from math import log
from logging import log as logger

--遍历变量参数
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')
print p.age
print p.course