python面向對象

##**語言的分類**
– 面向機器:匯編語言
– 面向過程:c語言
– 面向對象：C++ Java Python

##**面向對象**
– 類class
– 類是抽象的概念，萬事萬物的抽象，是一類事物的共同特征集合。
– 對象instance object
– 對象是類的具象，是一個實體
– 人這樣的個體，就是人類的不同實體
– 屬性
– 對象狀態的抽象，用數據結構描述
– 操作
– 它是對象行為的抽象，用操作名和實現該操作的方法來描述
– 哲學
– 一切皆對象；對象是數據和操作的封裝；對象是獨立的，但是對象之間可以相互作用
– 目前oop是最接近人類認知的編程范式

##**面向對象的三要素**
– 封裝
– 組裝：將數據和操作組裝到一起
– 隱藏數據：對外只暴露一些接口，通過接口訪問對象。
– 繼承
– 多復用，繼承來的就不用自己來寫
– 多繼承少修改，OCP，使用繼承來改變，來體現個性
– 多態
– 面向對象編程是最靈活的地方，動態綁定

##**python的類**
– 定義
– class ClassName:
– (1) 必須使用class關鍵字 (2) 類名大駝峰 (3) 類定義完后，產生類對象，綁定到了ClassName上
###**舉例**
class MyClass:
”’A example class”’
x = ‘abc’
def foo(self):
return ‘My Class’
print(MyClass.x)
print(MyClass.foo)
print(MyClass.__doc__)

##**類對象及類屬性**
– 類對象 類的定義就會生成一個類對象
– 類的屬性，類定義中的變量和類中定義的方法都是類的屬性
– 類變量，x是類MyClass的變量
– foo是method方法對象，不是普通的函數對象function，它必須至少有個一參數，且第一個參數必須是self。
– **self指代當前實例本身** a = MyClass() 就是實例化

##__init__方法
– MyClass()實際上調用的是__init__(self)方法，可以不定義，如果沒有定義會在實例化后隱式調用
– 作用：對實例進行初始化
– __init__() 方法不能有返回值，也就是只能是None
###舉例
案例1
class MyClass:
def __init__(self):
print(‘init’)
a = MyClass() #實例化
案例2
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def showage(self):
print(‘{} is {}’.format(self.name,self.age))
tom = Person(‘Tom’,20)
jerry = Person(‘jerry’,25)
print(tom.name,jerry.age)
jerry.age += 1
print(jerry.age) # 26
jerry.showage()

##**實例對象instance**
– 類實例化后一定會獲得一個對象，就是實例對象。
– 實例變量是每一個實例自己的變量，是自己獨有的；類變量是類的變量，是類的所有實例共享的屬性和方法
– __name__ 對象名 __class__ 對象的類型 __dict__ 對象的屬性的字典 __qualname__ 類的限定名
– 類屬性保存在__dict__中，同樣，實例也有__dict__中，如果從實例訪問類的屬性，就需要借助__class__找到所屬的類

##**裝飾一個類**
– 之所以能夠裝飾，本質上是為類對象動態的添加了一個屬性，而Person這個標識符指向這個類對象
###實例
def logger(name):
def wrapper(cls):
cls.NAME = name
return cls
return wrapper

@logger(‘MAGE’) #@wrapper –> Human = wrapper(Human)
class Human:
print(‘123’)
print(Human.NAME)

##**類方法和靜態方法**
– 類除了普通方法都可以調用，普通方法需要對象的實例作為第一參數
– 實例可以調用所有類中定義的方法(包括類方法、靜態方法)，普通方法傳入實例自身，靜態方法和類方法需要找到實例的類
class Person:
def normal_method():
print(‘normal’)
Person.normal_method() # normal
Person().normal_method() # 報錯因為Person()給了一個參數給normal_method但是，這個函數并不需要參數

類方法
class Person:
@classmethod #在類定義中用它裝飾器修飾的方法
def class_method(cls): #cls 代表傳上來的類
print(‘class={0.__name__} ({0})’.format(cls))
cls.HEIGHT = 170

@staticmethod #靜態方法很少用
def static_methd():
print(Person.HEIGHT)

Person.class_method()
Person.static_method()
print(Person.__dict__)

##**訪問控制**
– 私有屬性，屬性在外部可以訪問，或者說可見，就可以直接繞過方法，直接修改這個屬性
– 私有屬性使用雙下劃線開頭的屬性名，就是私有屬性
– 私有變量的本質：類定義的時候，使用雙下劃線，Python解釋器會將其改名，轉換為_類名__變量名。
##
class Person:
def __init__(self,name,age=18):
self.name = name
self.__age = age
def growup(self,i=1):
if i>0 and i<150:
self.__age += i

##**保護變量**
– 使用 _方法名，這只是開發者共同的約定，看見這種變量，就如同私有變量，不要直接使用

##**私有方法**
– 與私有變量一樣，使用單雙下劃線命名的方法
– 單下劃線的方法只是開發者之間的約定，解釋器不做任何改變
– 雙下劃線的方法，是私有方法，解釋器會改變，改名策略和私有變量相同
– 方法變量都在__dict__中可以找到
###舉例
class Person:
def __init__(self,name,age=18):
self.name = name
self._age = age

def _getname(self):
return self.name

def __getage(self):
return self._age

tom = Person(‘Tom’)
print(tom._getname())

print(tom._Person__getage())
print(tom.__class__.__dict__)
print(tom.__dict__)

##補丁
#test1
from test2 import Person
from test3 import get_score

def change():
Person.get_score = get_score
print(Person().get_score())
change()
print(Person().get_score())
#test2
class Person:
def get_score(self):

ret = {‘eng’:68,’his’:78,’math’:98}
return ret
#test3
def get_score(self):
return dict(eng=88,his=99,math=100)

##**屬性裝飾器**
– 把實例的屬性保護起來，不讓外部直接訪問，外部使用getter讀取屬性和setter方法設置屬性
– property裝飾器
– 后面跟的函數名就是以后的屬性名。他就是getter。這個必須有，有了它至少只讀屬性
– setter裝飾器
– 與屬性名同名，且接收2個參數，第一個是self，第二個是將要賦值的值，有了它，屬性可寫
– deleter裝飾器
– 可以控制是否刪除屬性。很少用
– property必須在前，setter、deleter裝飾器在后。
– property裝飾器能通過簡單的方式，把對方法的操作變成對屬性的訪問，并起到了一定隱藏效果
###舉例
法一：
class Person:
def __init__(self,name,age=18):
self.name = name
self.__age = age
@property #property把age作為屬性名，不是方法了
def age(self):
return self.__age

@age.setter #設置年齡
def age(self,age):
self.__age = age

@age.delter #刪除
def age(self):
#del self.__age
print(‘del’)
tom = Person(‘Tom’)
print(tom.age)
tom.age = 20
print(tom.age)
del tom.age #刪除tom.age屬性
法二：
class Person:
def __init__(self,name,age=18):
self.name = name
self.__age = age

def getage(self):
return self.__age

def setage(self,age):
self.__age = age

def delage(self):
del self.__age

age = property(getage,setage,delage,’age property’)

##**對象的銷毀**
– 類中定義__del__方法，稱為析構函數(方法)
– 作用：銷毀類的實例的時候調用，以釋放占用的資源
– python已經實現了垃圾回收機制，這個方法不能確定何時執行。有必要時，使用del語句刪除實例。
###舉例
class Person:
def __init__(self,name,age=18):
self.name = name
self.__age = age

def __del__(self):
print(‘delete {}’.format(self.name))
tom = Person(‘Tom’)
del tom