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修飾的特性

二、異常處理

把一個錯誤頁面轉換成一個友好的界面展示給用戶