Python进阶

2015.8.5

慕课网Python进阶学习：
 
函数式编程（functional）：
  1.python不是纯函数式编程：允许存在变量
  2.支持高阶函数：函数可作为变量传入
  3.支持闭包：有了闭包就能返回函数
  4.有限度的支持匿名函数
 
高阶函数：能接收函数作为参数的函数。
  1. def add(x,y,f):
  2. return f(x)+f(y)
  3. print add(4,5,abs)
 其中abs是个求值函数
 
map()函数：它接收一个函数f和一个list，通过函数f依次作用在list的每个元素上
  1. def format_name(s):
  2. a=s[:1].upper()+s[1:].lower()
  3. return a
  5. print map(format_name,['adam','LISA','barT'])
reduce()函数：它接收一个函数f和一个list，它传入的函数f必须接收两个参数，对list反复调用f并返回最总结果值。也可接收第三个参数为它的初始值。
  1. def prod(x, y):
  2. return x*y
  3. print reduce(prod,[2,4,5,7,12])
  4. print reduce(prod,[2,4,5,7,12],100)
第一个输出的运算形式：prod(2,4)=8 ;=>prod(8,5)=40;=>.......依次相乘
第二个输出的运算形式：prod(100,2)=200 ;=>prod(200,4)=800;=>.......依次相乘
 
filter()函数：它接收一个函数f和一个list，f对每个元素进行判断，返回true或false，filter()通过判断结果自动过滤不符合条件的元素，返回由符合条件元素组成的新的list
  1. import math
  2. def is_sqr(x):
  3. r=int(math.sqrt(x))
  4. return r*r==x
  5. print filter(is_sqr, range(1,100))
math.sqrt(x)求x的平方根，返回结果是浮点数，int()将其转为int类型
 
sorted()自定义排序函数:接收一个比较函数f和一个list，f接收两个待比较的元素x,y，如果x应该排在y的前面，返回-1，如果x应该排在y的后面返回1，如果x,y相等，返回0
  1. def cmp_ignore_case(s1, s2):
  2. u1=s1.upper()
  3. u2=s2.upper()
  4. if u1<u2:
  5. return-1
  6. if u1==u2:
  7. return0
  8. if u1>u2:
  9. return1
  10. print sorted(['bob','about','Zoo','Credit'],cmp_ignore_case)
从小到大排列，忽略大小写
 
返回函数：
  1. def calc_prod(lst):
  2. def g():
  3. def d(x,y):
  4. return x * y
  5. return reduce(d,lst,1)
  6. return g
  7. f = calc_prod([1,2,3,4])
  8. print f()
闭包：内层函数应用了外层函数的变量，然后返回内层函数的情况称为闭包。注意：返回函数不要引用任何循环变量或者后续会发生编发的变量
  1. def count():
  2. fs =[]
  3. for i in range(1,4):
  4. def f(x):
  5. def g():
  6. return x*x;
  7. return g
  8. r=f(i)
  9. fs.append(r)
  10. return fs
  12. f1, f2, f3 = count()
  13. print f1(), f2(), f3()
匿名函数：lambda      只能有一个表达式，不写return,返回值就是该表达式的结果
  1. print filter(lambda s:s and len(s.strip())>0,['test',None,'','str',' ','END'])
s为匿名函数参数
 
 
2015.8.6
装饰器（decorator）:
极大的简化代码，避免每个函数编写重复性代码
使用@在调用装饰器函数的函数之前
不带参数装饰器
打印日志：@log
def log(f):
def fn(x):
print'call '+ f.__name__ +'()...'
return f(x)
return fn
 
@log
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)
#此处代码如下
factorial=log(
对于参数不是一个的，调用将报错，@log写死了只含有一个参数的返回值，要让@log自适应任何参数的函数可以使用*args和**kw，保证任意个参数都能正常调用
def log(f):
def fn(*args,**kw):
print'call '+ f.__name__ +'()...'
return f(*args,**kw)
return fn
@log
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)
检测性能：@performance
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)
数据库事务：@transaction
URL路由：@post('/register')
 
带参数的装饰器
def log(str):
def log_decorator(f):
def fn(*args,**kw):
print'call [%s] %s()...'%(str,f.__name__)
return f(*args,**kw)
return fn
return log_decorator
 
@log('debug')
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))
#factorial=log(factorial)
print factorial(10)
import time
 
def performance(unit):
def pp(f):
def ff(*a,**k):
t1=time.time()
r=f(*a,**k)
t2=time.time()
print'call %s() in %f%s'%(f.__name__,t2-t1,unit)
return r
return ff
return pp
 
@performance('ms')
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))
 
print factorial(10)
由于decorator会改造函数，便会改变函数的__name__,__doc__等其他属性，所以就需要将原函数属性复制到新函数中使用functools自动化完成这个复制任务
import functools
def log(f):
#@functools.wraps(f)
def wrapper(*args,**kw):
print'call...'
return f(*args,**kw)
return wrapper
@log
def ff():
return1
print ff.__name__
此时输出wrapper    若加上@functools.wraps(f) 输出ff
import time, functools
 
def performance(unit):
def pp(f):
@functools.wraps(f)
def ff(*rags,**k):
t1=time.time()
r=f(*rags,**k)
t2=time.time()
print'call %s in %f%s'%(f.__name__,t2-t1,unit)
return r
return ff
return pp
 
@performance('ms')
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)
print factorial.__name__
偏函数：
functools.partial可以将一个参数多的函数变为一个参数少的函数，少的函数需要在创建是指定默认值
import functools
 
sorted_ignore_case = functools.partial(sorted,cmp=lambda s1,s2:cmp(s1.upper(),s2.upper()))
 
print sorted_ignore_case(['bob','about','Zoo','Credit'])
cmp(x,y)函数为对比函数 x>y返回1 x=y返回0 x<y 返回-1
 
模块和包：
包便是文件夹，.py文件便是模块，包中必须要有__init__.py文件，包的每层目录中都需要有
用import引用其他模块的函数等
将同名模块放入不同的包中
#test.py
import p1.unit
print p1.unit.f(2,1)
os.path模块提供了is.dir()和isfile()函数，判断指定目录和文件是否存在
import os.path
 
print os.path.isdir(r'/data/webroot/resource/python')
print os.path.isfile(r'/data/webroot/resource/python/test.txt')
动态导入模块（动态引入需要在直接引入之前）：
同样实现stringIO的功能，但是CStringIO模块部分是用c写的，所以CStringIO要比StringIO运行要快。
try:
from cStringIO importStringIO
exceptImportError:
fromStringIOimportStringIO
try:
import json
exceptImportError:
import simplejson as json
 
print json.dumps({'python':2.7})
使用import...as...动态导入不同名称的模块
 
使用__future__
python新版本会引入新的功能，但是，实际上这些功能再上一个老版本中已经存在，要试用某些新特性，就可以通过导入__future__模块的某些功能来实现。
from __future__ import division#若不引入，print 10/3输出3，引入输出3.3333333
import p1.hello
 
print10/3
print p1.hello.factorial(10)
from __future__ import unicode_literals
 
s = b'am I an unicode?'
print isinstance(s, unicode)
在现在的版本中，字符串同意为unicode不需要加u前缀，而str 必须加b前缀
 
安装第三方模块
工具：easy_install   pip（官方推荐，内置到python2.7.9）
确保python版本为python2.7.9以上版本，在命令提示符下使用pip install web.py（web.py为第三方模块）
 
面向对象编程
classPerson(object):
pass
类名首字母大写，object为该类继承的类
classPerson(object):
def __init__(self,name):#构造函数
self.name=name
 
xiaoming =Person('xiaoming')
xiaohong =Person('xiaohong')
 
print xiaoming.name
print xiaohong.name
print xiaoming.name==xiaohong.name
classPerson(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
python关键字参数和可变参数
python关键字参数用**kw表示，在调用时可以默认赋值且可以为任意个的参数
可变参数用*args表示，在调用时可以是任意个的参数
def foo1(arg1,arg2,*arg,**keywords):
print"arg1 parameters is ",arg1
print"arg2 parameters is ",arg2
print"Arbitrary parameter is ", arg
print"keywords parameter is ",keywords
 
foo1(1,2,3,4,5,6,k1=1,k2=2,k3=3)
构造函数初始化，参数是可以为关键字参数或可变参数
classPerson(object):
def __init__(self,name,sex,bor,*args,**kw):
self.name=name
self.sex=sex
self.bor=bor
for k,v in kw.iteritems():
setattr(self,k,v)
for c in args:
setattr(self,c)
 
xiaoming =Person('Xiao Ming','Male','1990-1-1', job='Student',job2='sty')
 
print xiaoming.name
print xiaoming.job
print xiaoming.job2
访问限制：
设置某属性为外部无法访问用双下划线开头 __
classPerson(object):
def __init__(self, name, score):
self.name=name
self.__score=score
 
p =Person('Bob',59)
 
print p.name
print p.__score
创建类属性（不同于实例属性）
classPerson(object):
count=0
def __init__(self,name):
Person.count=Person.count+1
self.name=name
 
p1 =Person('Bob')
printPerson.count
 
p2 =Person('Alice')
printPerson.count
 
p3 =Person('Tim')
printPerson.count
当实例属性和类属性重名时，实例属性优先级高，实例中是不能修改类属性的
classPerson(object):
 
__count =0
count=0
 
def __init__(self, name):
Person.__count=Person.__count+1
self.name=name
 
p1 =Person('Bob')
p2 =Person('Alice')
 
printPerson.__count
printPerson.count
定义实例函数
#-*- coding:utf-8 -*-
classPerson(object):
 
def __init__(self, name, score):
self.__score=score
self.name=name
 
def get_grade(self):
if self.__score>=80:
return'优秀'
if self.__score>=60:
return'及格'
if self.__score<60:
return'不及格'
 
p1 =Person('Bob',90)
p2 =Person('Alice',65)
p3 =Person('Tim',48)
 
print p1.get_grade()
print p2.get_grade()
print p3.get_grade()
最上面那句是为了使其支持中文编码
 
方法也可以看出是属性，可以将方法动态的添加到实例上，只是需要使用types.MethodType()将一个函数变为一个方法
import types
def fn_get_grade(self):
if self.score >=80:
return'A'
if self.score >=60:
return'B'
return'C'
 
classPerson(object):
def __init__(self, name, score):
self.name = name
self.score = score
 
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
 
classPerson(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()
定义类方法，和属性相似，方法也分实例方法和类方法
classPerson(object):
count=0
@classmethod
def howMany(cls):
return cls.count
def __init__(self,name):
self.name=name
Person.count=Person.count+1
printPerson.howMany()
p1=Person('xiaoming')
printPerson.howMany()
classPerson(object):
 
__count =0
 
def __init__(self,name):
Person.__count=Person.__count+1
self.name=name
@classmethod
def how_many(cls):
return cls.__count
 
printPerson.how_many()
 
p1 =Person('Bob')
 
printPerson.how_many()
继承
classPerson(object):
count=0
@classmethod
def howMany(cls):
return cls.count
def __init__(self,name,gender):
self.name=name
Person.count=Person.count+1
 
classStudent(Person):
def __init__(self,name,gender,school,score):
super(Student,self).__init__(name,gender)
self.school=school
self.score=score
printPerson.howMany()
p1=Person('xiaoming','m')
s1=Student('n','s','d',11)
 
print s1.name
 
printPerson.howMany()
isinstance(s,type)函数，检测s是否是type类型，可用于判断属性是否是int、str等类型
classPerson(object):
 
def __init__(self, name, gender):
self.name = name
self.gender = gender
 
classStudent(Person):
 
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score
 
classTeacher(Person):
 
def __init__(self, name, gender, course):
super(Teacher, self).__init__(name, gender)
self.course = course
 
t =Teacher('Alice','Female','English')
 
print isinstance(t,Person)
print isinstance(t,Student)
print isinstance(t,Teacher)
print isinstance(t,object)
多态
classPerson(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
 
classStudent(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
 
classTeacher(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
 
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)
其中调用whoAmI函数时，先找该对象的方法，没有再向其父类找
 
python提供了open()方法来打开一个磁盘文件，并返回File对象，File对象有一个read()方法可以读取文件内容
任何含有read()方法的函数都可以称为 File-like-object 都可以直接将其对象传给json.load()
import json
classStudents(object):
def read(self):
return r'["Tim", "Bob", "Alice"]'
s =Students()
print json.load(s)
多重继承  从多个父类继承，称为多重继承
在多重继承中，父类的父类的__init__方法只会被调用一次
Python的网络服务器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer
服务器运行模式有多进程ForkingMixin和多线程ThreadingMixin
classPerson(object):
pass
 
classStudent(Person):
pass
 
classTeacher(Person):
pass
 
classSkillMixin(object):
pass
 
classBasketballMixin(SkillMixin):
def skill(self):
return'basketball'
 
classFootballMixin(SkillMixin):
def skill(self):
return'football'
 
classBStudent(BasketballMixin,Student):
pass
 
classFTeacher(FootballMixin,Teacher):
pass
 
s =BStudent()
print s.skill()
 
t =FTeacher()
print t.skill()
获取对象信息
 
type(x)获取对象x的类型 dir(x)获取对象x的所有属性信息。
若知道一个属性名称，要获取或设置对象的属性，就需要用到getattr()和serattr()
  1. #-*- coding:utf-8 -*-
  2. classPerson(object):
  3. def __init__(self, name, gender):
  4. self.name = name
  5. self.gender = gender
  7. classStudent(Person):
  8. def __init__(self, name, gender, score):
  9. super(Student, self).__init__(name, gender)
  10. self.score = score
  11. def whoAmI(self):
  12. return'I am a Student, my name is %s'% self.name
  14. s =Student('Bob','Male',88)
  15. print type(s)
  16. print getattr(s,'name')
  17. print getattr(s,'age',20)#不存在age值则返回默认值20
  18. setattr(s,'name','Adam')
  19. print dir(s)
 
 
2015.8.7
特殊方法（魔术方法）
特殊方法定义的class中，不需要直接调用，Python的某些函数或操作符会调用对应的特殊方法
#-*- coding:utf-8 -*-
classPerson(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
 
s =Person('Bob','Male')
print s
print s.__str__()#输出结果同上__str__()便是一个特殊方法，用于显示给用户
print s.__rpr__()#用于显示给开发人员
特殊方法也可以重写
classPerson(object):
 
def __init__(self, name, gender):
self.name = name
self.gender = gender
 
classStudent(Person):
 
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('Bob','male',88)
print s
__cmp__()方法
对于int，str等内置数据类型排序是，python的sorted()安装默认额比较函数cmp排序，但是对一组Student类的实例排序是就必须提供我们自己的特殊方法__cmp__()
classStudent(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:
return0
else:
return1
 
L =[Student('Tim',99),Student('Bob',88),Student('Alice',99)]
print sorted(L)
__len__()方法
如果类的实例想要使用len()方法必须实现__len__()方法
classFib(object):
 
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)
__repr__=__str__
 
def __len__(self):
return len(self.numbers)
 
f =Fib(10)
print f
print len(f)
数学运算
有理数：有理数是一个整数a和一个非零整数b的比，例如3/8
def gcd(a,b):#处理有理数归约
if b==0:
return a
return gcd(b,a%b)
classRational(object):
def __init__(self, p, q):
self.p = p
self.q = q
 
def __add__(self, r):
returnRational(self.p * r.q + self.q * r.p, self.q * r.q)
 
def __sub__(self, r):
returnRational(self.p*r.q-self.q*r.p,self.q*r.q)
 
def __mul__(self, r):
returnRational(self.p*r.p,self.q*r.q)
 
def __div__(self, r):
returnRational(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
类型转换
classRational(object):
def __init__(self, p, q):
self.p = p
self.q = q
 
def __int__(self):
return self.p // self.q
 
def __float__(self):
return float(self.p)/self.q
 
print float(Rational(7,2))
print float(Rational(1,3))
@property装饰器
classStudent(object):
 
def __init__(self, name, score):
self.name = name
self.__score = score
 
@property #如get方法
def score(self):
return self.__score
 
@score.setter #如set方法
def score(self, score):
if score <0or score >100:
raiseValueError('invalid score')
self.__score = score
 
@property
def grade(self):
if self.score<60:
return'C'
if self.score<80:
return'B'
return'A'
 
s =Student('Bob',59)
print s.grade
 
s.score =60
print s.grade
 
s.score =99
print s.grade
__slots__方法控制类属性如下
classStudent(object):
__slots__ =('name','gender','score')
def __init__(self, name, gender, score):
self.name = name
self.gender = gender
self.score = score
s =Student('Bob','male',59)
s.name ='Tim'# OK
s.score =99# OK
s.grade ='A'
在__slots__中只定义了三个属性，所以会导致s.grade不能正常运行，只有在__slots__中定义了的属性才能够运行
classPerson(object):
 
__slots__ =('name','gender')
 
def __init__(self, name, gender):
self.name = name
self.gender = gender
 
classStudent(Person):
 
__slots__ =('score',)#当只有一个属性是，之后需要加个，
 
def __init__(self,name,gender,score):
super(Student,self).__init__(name,gender)
self.name=name
self.gender=gender
self.score=score
 
s =Student('Bob','male',59)
s.name ='Tim'
s.score =99
print s.score
__call__   将一个实例编程一个可调用对象，即时将一个实例变为一个可调用函数
classPerson(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
p=Person('bob','man')
p('tim')
classFib(object):
def __call__(self,num):
a,b,L=0,1,[]
for n in range(num):
L.append(a)
a,b=b,a+b
return L
 
f =Fib()
print f(10)
 



posted on 2017-05-09 11:40  轻浮不韪  阅读(182)  评论(0)    收藏  举报

博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3