函数式变成：支持高阶函数（接受函数为参数的函数），支持闭包

1.python把函数作为参数

import math

def add(x, y, f):

return f(x) + f(y)

print add(25, 9, math.sqrt) //这里引用的，math函数库里的求平方根函数sqrt()

2.python中map()函数 //这里引用了高阶函数map(f,list)会把list中的每个值赋给函数f进行输出

首字母大写，后面的小写

def format_name(s):

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

return str1

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

3.python中reduce()函数:还可以接收第三个至作为初值

对list中的值进行积的运算，reduce每次只能送进两个参数

def prod(x, y):

return x*y

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

4.python中filter()函数：filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list

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

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

import math

def is_sqr(x):

return math.sqrt(x)%1 == 0 //这里不用isinstance的原因：math.sqrt()函数求的值都为float型

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

5.python中自定义排序函数sorted()

def cmp_ignore_case(s1, s2):

s1=s1.lower()

s2=s2.lower()

if s1 < s2: //可以用cmp(s1.lower(),s2.lower())代替

return -1

if s1 > s2:

return 1

if s1 == s2:

return 0

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

6.python中返回函数

它接收一个list，返回一个函数，返回函数可以计算参数的乘积。

def calc_prod(lst):

def prod(x,y):

return x * y

def lazy_prod():

return reduce(prod,lst)

return lazy_prod

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

print f()

7.python中闭包：像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）

def count():

fs = []

for i in range(1, 4):

def f():

return i*i

fs.append(f)

return fs

f1, f2, f3 = count()

print f1(),f2(),f3() //这里输出的是9,9,9，因为上面的i是变量，最后一次输出为3

*************************

def count():

fs = []

for i in range(1, 4):

def f(j): //这个函数的作用就是把变量变成定值

def g():

return j**2

return g

r = f(i)

fs.append(r)

return fs

f1, f2, f3 = count()

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

8.python中匿名函数lambda

lambda s:s and len(s.strip()) > 0相当于：

def is_not_empty(s):

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

---------------------------------------

print filter(lambda s:s and len(s.strip()) > 0, ['test', None, '', 'str', ' ', 'END'])

9.python中编写无参数decorator

如果模块是被导入，__name__的值为模块名字

如果模块是被直接执行，__name__的值为’__main__’

返回执行函数的时间差：

import time

def performance(f):

def fn(*args):

t1 = time.time()

r = f(*args)

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)

10.python中编写带参数decorator

import time

def performance(unit):

def performance_decorator(f):

def wrapper(*args):

t1 = time.time()

r = f(*args)

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 performance_decorator

@performance('ms')

def factorial(n):

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

print factorial(10)

11.python完善decorator之functools

import time, functools

def performance(unit):

def per_decorator(f):

@functools.wraps(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 per_decorator

@performance('ms')

def factorial(n):

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

print factorial.__name__

12.python中偏函数---functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。

import functools

sorted_ignore_case = functools.partial(sorted,cmp = lambda s1,s2:cmp(s1.lower(),s2.lower()))

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

******************************

包，模块：包就是文件夹，模块就是文件

每个包都有一个_init_文件

******************************

13.包，模块的引入

import os

import os.path

from os import path

from os.path import isdir, isfile

14.python中动态导入模块

有的时候，两个不同的模块提供了相同的功能，比如 StringIO 和 cStringIO 都提供了StringIO这个功能。

StringIO 是纯Python代码编写的，而 cStringIO 部分函数是 C 写的，因此 cStringIO 运行速度更快。

利用ImportError错误，我们经常在Python中动态导入模块：

try:

from cStringIO import StringIO

except ImportError:

from StringIO import StringIO

try 的作用是捕获错误，并在捕获到指定错误时执行 except 语句。

15.python之使用__future__

from __future__ import unicode_literals

s = 'am I an unicode?'

t = b'am I an str?'

print isinstance(s, unicode)

print isinstance(t,str)

**********************面向对象编程***************************

16.python之定义类并创建实例

class Person(object):

pass

xiaoming = Person()

xiaohong = Person()

print xiaoming

print xiaohong

print xiaoming == xiaohong

17.python中创建实例属性

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 p1,p2: cmp(p1.name,p2.name))

print L2[0].name

print L2[1].name

print L2[2].name

18.python中初始化实例属性__init__

class Person(object):

def __init__(self,name,sex,birthday,**kw): //init可以用别的变量代替，但是默认是self

self.name = name

self.sex = sex

self.birthday = birthday

for k,v in kw.iteritems():

setattr(self,k,v) //相当于self.k = v

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

print xiaoming.name

print xiaoming.job

19.python中访问限制

ython对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问

class Person(object):

def __init__(self, name, score):

self.name = name

self.__score = score

p = Person('Bob', 59)

print p.name

try: //以"__xxx__"定义的属性在Python的类中被称为特殊属性

print p.__score //以单下划线开头的属性"_xxx"虽然也可以被外部访问，但是，按照习惯，他们不应该被外部访问。

except:

print 'attributeError'

20.python中创建类属性

class Person(object):

count = 0

def __init__(self,name): //这里count属于类的属性，不重置，初始化函数会重置并给类的属性+1

self.name = name

Person.count += 1

p1 = Person('xiaoming')

print Person.count

p2 = Person('xiaohong')

print Person.count

21.python中类属性和实例属性名字冲突怎么办

当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。

class Person(object):

__count = 0

def __init__(self, name):

self.name = name

Person.__count += 1

print Person.__count

p1 = Person("xiaoming")

p2 = Person("xiaohong")

try:

print Person.count

except:

print 'Error'

22.python中定义实例方法

# -*- coding: utf-8 -*-

class Person(object):

"""docstring for Person"""

def __init__(self, name,grade):

self.__name = name

self.__grade = grade

def get_grade(self):

if self.__grade > 75:

return u'A-优秀'

if self.__grade >60:

return u'B-及格'

return u'C-不及格'

p1 = Person('Bob', 90)

print p1.get_grade()

p2 = Person('Alice', 65)

print p2.get_grade()

p3 = Person('Tim', 48)

print p3.get_grade()

23.python中方法也是属性

p1.get_grade

调用的是函数，而

p1.get_grade()

则调用的是这个函返回的结果，即：方法调用。

函数调用不需要传入 self，但是方法调用需要传入 self。（self可省）

class Person(object):

def __init__(self, name, score):

self.name = name

self.score = score

self.get_grade = lambda: 'A'

//lambda相当于def get_grade():

// return 'A'

p1 = Person('Bob', 90)

print p1.get_grade

print p1.get_grade()

----------------------------------

# -*- coding: utf-8 -*-

#给一个实例绑定一个方法

import types

def fn_get_grade(self):

if self.grade >= 90:

return 'a'

elif self.grade >= 60:

return 'b'

else:

return 'c'

class Person(object):

"""docstring for Person"""

def __init__(self, name,grade):

self.name = name

self.grade = grade

p1 = Person('xiaoming',61)

p2 = Person('xiaohong',33)

p3 = Person('zhangsan',91)

try:

print p1.get_grade

except:

print 'error'

p1.get_grade = types.MethodType(fn_get_grade,p1,Person) //types.MethodType() 把一个函数变为一个方法：

print p1.get_grade()

24.python中定义类方法

在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。

方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。

class Person(object):

__count = -1

@classmethod

def how_many(cls):

cls.__count += 1

return cls.count

def __init__(self,name):

self.name = name

print Person.how_many()

p1 = Person('Bob')

print Person.how_many()

25.python中继承一个类

class Person(object):

"""docstring for

"""

def __init__(self, name,gender):

self.name = name

self.gender = gender

class Teacher(Person):

"""docstring for Teacher"""

def __init__(self,name,gender,course):

super(Teacher, self).__init__(name,gender)

self.course = course

p1 = Teacher('Alice','female','English')

print p1.name

print p1.course

26.pytho判断类型:

print isinstance(t,Person)

print isinstance(t,Student)

print isinstance(t,Teacher)

print isinstance(t,object)

27.python中多态：s 是Student类型，它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法，但调用 s.whoAmI()总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。

class Person(object):

def __init__(self, name, gender):

self.name = name

self.gender = gender

def whoAmI(self):

return 'I am a Person, my name is %s' % self.name

class Student(Person):

def __init__(self, name, gender, score):

super(Student, self).__init__(name, gender)

self.score = score

def whoAmI(self):

return 'I am a Student, my name is %s' % self.name

class Teacher(Person):

def __init__(self, name, gender, course):

super(Teacher, self).__init__(name, gender)

self.course = course

def whoAmI(self):

return 'I am a Teacher, my name is %s' % self.name

在一个函数中，如果我们接收一个变量 x，则无论该 x 是 Person、Student还是 Teacher，都可以正确打印出结果：

def who_am_i(x):

print x.whoAmI()

p = Person('Tim', 'Male')

s = Student('Bob', 'Male', 88)

t = Teacher('Alice', 'Female', 'English')

who_am_i(p)

who_am_i(s)

who_am_i(t)

运行结果：

I am a Person, my name is Tim

I am a Student, my name is Bob

I am a Teacher, my name is Alice

28.python中多重继承

除了从一个父类继承外，Python允许从多个父类继承，称为多重继承。

多重继承的继承链就不是一棵树了，它像这样：

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

看下图:

         ---

        | A |

         ---

         / \

       /    \

     ---   ---

    | B | | C |

    ---    ---

     \        /

      \     /

       \ /

       ---

      | D |

       ---

29.python中获取对象信息

a = 123

print type(a)

输出为：

<type 'int'>

# -*- coding: utf-8 -*-

class Person(object):

def __init__(self, name, gender, **kw): #这里必须用**kw

self.name = name

self.gender = gender

for k,v in kw.iteritems():

setattr(self,k,v) #设置属性值

p = Person('Bob', 'Male', course='Python')

print getattr(p,'age',500) #这里的属性age必须加上单引号，这里的500是当没有age参数是输出的默认值

print p.course

30.python中 __str__和__repr__

class Person(object):

def __init__(self,name,gender):

self.name = name

self.gender = gender

class Student(Person):

"""docstring for Student"""

def __init__(self,name,gender,score):

super(Student, self).__init__(name,gender)

self.score = score

def __str__(self):

return '(Student:%s,%s,%s)' %(self.name,self.gender,self.score)

__repr__ = __str__

s = Student('xiaoming','male',88)

print s

31.实例之sorted()---自定义__cmp__函数

# -*- coding: utf-8 -*-

class Student(object):

"""docstring for Person"""

def __init__(self, name,score):

self.name = name

self.score = score

def __str__(self):

return '(Student:%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:

return cmp(self.name,s.name)

# if self.score == s.score:

# return cmp(self.name, s.name)

# return -cmp( self.score,s.score)

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

print sorted(L)

32.python中 __len__

class Fib(object):

"""docstring for Fib"""

def __init__(self, num):

a,b,L = 0,1,[]

for n in range(num):

L.append(a)

a,b = b,a+b

self.numbers = L

def __str__(self):

return str(self.numbers)

def __len__(self):

return len(self.numbers)

__repr__ = __str__

print Fib(10)

print len(Fib(10))

33.python中数学运算

# -*- encoding: utf-8 -*-

class Rational(object):

"""docstring for Rational"""

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

#下面一段是对分数的约分

if self.p < self.q:

if self.p%2 == 0 and self.q%2 == 0:

return '%s/%s' %(self.p/2, self.q/2)

else:

return '%s/%s' %(self.p, self.q)

else:

if self.p%2 == 0 and self.q%2 == 0:

return '%s/%s' %(self.p/2, self.q/2)

__repr__ = __str__

r1 = Rational(1, 2)

r2 = Rational(1, 4)

print r1 + r2

print r1 - r2

print r1 * r2

print r1 / r2

34.python中类型转换

class Rational(object):

def __init__(self, p, q):

self.p = p

self.q = q

def __int__(self):

return self.p // self.q

def __float__(self):

return self.p * 1.0 / self.q #这里的//是整除，7//2.0 == 3.0,而7/2.0 == 3.5

print float(Rational(7, 2))

print float(Rational(1, 3))

35.python中 @property

---------------

类属性：(r1是一个对象)

print r1.__dict__ ---------->{'q': 2, 'p': 1}

print r1.__dict__['p']---------->1 //输出属性p，即print r1.p

---------------

property将一些代码（get_temperature和set_temperature）附加到成员属性（temperature）的访问入口.任何获取temperature值的代

1

property(fget=None, fset=None, fdel=None, doc=None)

这里，fget是一个获取属性值的函数，fset是一个设置属性值的函数，fdel是一个删除属性的函数，doc是一个字符串（类似于注释）。从函数实现上看，这些函数参数都是可选的。所以，可以按照如下的方式简单的创建一个property对象。

>>> property()

<property object at 0x0000000003239B38>

1

2

>>> property()

<property object at 0x0000000003239B38>

Property对象有三个方法，getter(), setter()和delete()，用来在对象创建后设置fget，fset和fdel。这就意味着，这行代码：temperature = property(get_temperature,set_temperature)可以被分解为：

# make empty property

temperature = property()

# assign fget

temperature = temperature.getter(get_temperature)

# assign fset

temperature = temperature.setter(set_temperature)

************

装饰器详解http://blog.csdn.net/u013696062/article/details/51065406

************

class Student(object):

"""docstring for Student"""

def __init__(self, name, score):

self.name = name

self.__score = score

@property

def score(self):

return self.__core

@score.setter

def score(self,value):

if value < 0 or value > 100:

raise NameError('noinvaild value') #抛出异常，如果使用raise的话，后面的语句不能执行

else:

self.__score = value

@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

36.python中 __slots__：__slots__的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，使用__slots__也能节省内存

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

def __str__(self):

return '%s:%s:%s' %(self.name, self.gender, self.score)

__repr__ = __str__

s = Student('Bob', 'male', 59)

print s

s.name = 'Tim'

s.score = 99

print s.score

36.python中 __call__将类的实例直接当成函数调用

class Fib(object):

"""docstring for Fib"""

def __init__(self):

pass

def __call__(self, num):

a, b, L = 0, 1, []

for x in xrange(num):

L.append(a)

a, b = b, a + b

return L

numbers = Fib()

print numbers(10)