python(4)

一、装饰器
装饰器就是把函数包装一下，为函数添加一些附加功能，装饰器就是一个函数，参数为被包装的函数
比如在函数中增加一个功能，只需要装饰器中增加，然后其他函数去引用就OK
(1)定义装饰器但没引用

代码:
def outer(fun):                #定义装饰器
def wrapper():
fun()
print 'yanzheng'
return wrapper

@outer                    #链接上装饰器
def func1():
print 'func1'

func1()
结果：
func1

(2)定义装饰器并引用

代码:
def outer(fun):             #定义装饰器
def wrapper():
print  '新功能1'    #添加新功能1，写在fun()上边就是在上边
fun()
print  '新功能2'    #添加新功能2，写在fun()下边就是在下边
print 'yanzheng'
return wrapper

@outer                  #链接上装饰器
def func1():
print 'func1'

func1()
结果：
新功能1
func1
新功能2

(3)如果函数中有其他参数

代码：
def outer(fun):
def wrapper(arg):       #如果被装饰的函数中有其他参数的话就在这里加上
print '验证'
fun(arg)        #如果被装饰的函数中有其他参数的话就在这里加上
print 'yanzheng'
return wrapper

@outer
def func1(arg):            #这里有参数
print 'func1',arg

func1('hello')
结果：
验证
func1 hello
yanzheng

二、面向对象
面向对象包括：封装、继承、多态

面向对象术语：类，方法，对象
对象可以访问静态字段、动态字段、静态方法、动态方法
字段分为静态字段和动态字段
动态字段属于对象，通过对象.xx 语句获取属性
静态字段属于类，通过类.xx 语句获取属性
方法分为静态方法和动态方法
对象通过对象.方法名称 语句获取属性
概念：面向对象就是：比如定义一个类叫开车的方法，类里面有方法比如前进，后退，然后把这个类给一个叫奔驰或宝马的对象，这个对象就能调用前进后退这两个方法
（1）

代码：
class Province:  #叫做类
memo =  '中国的23省之一' #叫做静态字段，通过类获取，属于类
def __init__(self,name,shenghui):#叫做类的方法，sefl是必须有的不变，后边的可有可无
self.Name = name #叫做动态字段，用self获取的
self.Shenghui = shenghui
def  sport_meet(self):
self.Name + '污染最严重' #叫做动态方法，可以让对象用
@staticmethod
def  foo():
print '每个省都有省会' #叫做静态方法，括号里为空，上边得加staticmethod这个装饰器，类能访问静态方法

hb = Province('河北','唐山') #hb是对象,河北对应name，唐山对应shenghui，相当于实例化了一个对象a，然后就可以通过a来读取属性了
print hb.Name     #通过hb来读取属性
print hb.Shenghui
print Province.memo  #通过类来获取静态字段的属性
print  hb.memo    #对象可以访问静态字段
print  hb.sports_meet() #对象访问动态方法，因为第一个方法self.Name定义了是河北，这里直接用对象获取动态方法的属性
print  Province.foo                                  #类能访问静态方法
结果:
河北
唐山
中国的23省之一
中国的23省之一
河北省污染最严重
每个省都有省会
(2)静态方法的用途

（2）

代码
class Person():
def __init__(self,name,weight):
self.Name = name
self.Weight =  weight

def talk(self):
print 'xxxxxxx'

def fight(self,value):
if self.Weight>value:
print 'da'
else:
print 'pao'
p1 = Person('n1','190')
p2 = Person('n2','100')
p2.fight(p1.Weight)
结果
pao

（3）
不用创建对象，直接类.xx 就能访问，不用实例化类，直接就能调用类下面的方法

class MsSqlHelper：

@staticmethod
def add(sql):

@staticmethod
def delete(sql):

@staticmethod
def update(sql):

@staticmethod
def  select(sql):

MsSqlHelper.add(sql)
MsSqlHelper.delete(sql)
MsSqlHelper.update(sql)
MsSqlHelper.select(sql)

(4)私有字段
外部无法访问，只有内部可以访问

代码：
class Province:
def __init__(self,parovincename,shenghui,flag):
self.__Thailand = flag               #加__,通过对象.xx不能访问

def show(self):                  #定义一个函数
print self.__Thailand

japan = Province('日本','大阪',True)
japan.show()                        #通过对象.函数来访问
结果：
Ture

(5)私有方法

代码
class Province:
def __init__(self,parovincename,shenghui,person):
self.Person = person
def __aaa(self):                  #外部无法访问
print 'this is zhangsan'
def bbb(self):                   #内部定义一个函数访问
self.__aaa()

japan = Province('日本','大阪','zhangsan')
japan.bbb()                         #下边用对象访问函数
结果
this is zhangsan

构造函数和析构函数
构造函数：init函数，根据类创建对象的时候执行的动作
析构函数：del函数，call方法

代码：
class Foo:
def __call__(sefl):
print  'aaa'

f1 = Foo()
f1()
结果：
aaa

2.类的继承
（1）子继承父类

代码
class father:                     #父类
def __init__(self):
self.fname = 'ffff'
def func(self):
print 'father.func'
class son(father):                  #子类，继承父类
def __init__(self):
self.Sname = 'ssss'
def Bar(self):
print 'son.bar'
a = son()                    #实例化对象a可以访问son这个方法
print  a.Sname                  #通过a来读取属性
a.Bar()                      #通过a来读取属性
a.func()                      #子类已经继承父类，所以通过a可以读取父类中方法的属性
结果
ssss
son.bar
father.func

（2）子继承父类，对父类方法的重写

代码
class father:                  #父类
def Bad(self):
print 'father.抽烟喝酒'

class son(father):               #子类，继承父类
def Bad(self):             #如果要重写方法名称不变
print 'son.抽烟'        #在这里进行重写

a = son()
a.Bad()
结果
son.抽烟

（3）子继承父类，对父类增加但不修改

代码
class father:                 #父类
def Bad(self):
print 'father.抽烟喝酒'

class son(father):               #子类，继承父类
def Bad(self):             #如果要重写方法名称不变
father.Bad(self)         #如果不修改父类就先调用父类的方法
print  'son.烫头'       #在增加一段

a = son()
a.Bad()
father.抽烟喝酒
son.烫头

2.1类的继承,经典类和新式类
(1)子调用父类的构造函数（方法）--》经典类（没object）

代码
class father:                                  #父类
def __init__(self):
self.Fname = 'ffff'
print  'father.__init__'

class son(father):                             #子类，继承父类
def __init__(self):
self.Sname = 'ssss'
print 'son.init'
father.__init__(self)                  #调用父类的构造函数（方法）

a = son()
a.Sname
结果
son.init
father.__init__

（2）子调用父类的构造函数（方法）--》新式类（object）

代码
class father(object):                          #父类
def __init__(self):
self.Fname = 'ffff'
print  'father.__init__'

class son(father):                             #子类，继承父类
def __init__(self):
self.Sname = 'ssss'
print 'son.init'
super(son,self).__init__()             #使用super函数继承父类的object类
a = son()
a.Sname
结果
son.init
father.__init__

3.经典类和新式类的特性

经典类：经典类中的特性全部是可读可写（没有只读的功能）
新式类：新式类中的特性默认都是只读，如果想要设置，那么就需要再创建一个被装饰@xxx.setter修饰的特性
二、异常处理
把一个错误页面转换成一个友好的界面展示给用户

本文出自 “翟军铭python” 博客，请务必保留此出处http://pythonzhai.blog.51cto.com/10391994/1728878