26面向?qū)ο?_類方法-靜態(tài)方法-訪問(wèn)控制-猴子補(bǔ)丁

?

目錄

面向?qū)ο笕兀?/span>... 3

類對(duì)象及類屬性：... 4

實(shí)例化：... 6

instance實(shí)例對(duì)象：... 10

裝飾一個(gè)類：... 13

類方法、靜態(tài)方法：... 14

訪問(wèn)控制：... 16

猴子補(bǔ)丁：... 19

?

?

?

面向?qū)ο?/span>

?

語(yǔ)言的分類：

面向機(jī)器：

抽象成機(jī)器的指令，機(jī)器容易理解；

代表：匯編語(yǔ)言；

?

面向過(guò)程：

流程式，第1步，第2步...；

問(wèn)題規(guī)模小，可以步驟化，按部就班處理；

代表：C語(yǔ)言；

?

面向?qū)ο螅?/span>

隨著計(jì)算機(jī)需要解決的問(wèn)題的規(guī)模擴(kuò)大，情況越來(lái)越復(fù)雜，需要很多人、很多部門協(xié)作，面向過(guò)程編程不太適合了；

代表：C++、java、python；

?

什么是面向?qū)ο螅?/span>

一種認(rèn)識(shí)世界，分析世界的方法論，將萬(wàn)事萬(wàn)物抽象為類；

?

class類，是抽象的概念，是萬(wàn)事萬(wàn)物的抽象，是一類事物的共同特征的集合；

用計(jì)算機(jī)語(yǔ)言來(lái)描述類，就是屬性和方法的集合；

?

instance實(shí)例，或，object對(duì)象，是類的具象，是一個(gè)實(shí)體；

對(duì)于我們每個(gè)人這個(gè)個(gè)體，都是抽象概念人類的不同的實(shí)體；

例：

你吃魚：

你，就是對(duì)象；

魚，也是對(duì)象；

吃，就是動(dòng)作；

你是具體的人，是具體的對(duì)象，你屬于人類，人類是個(gè)抽象的概念，是無(wú)數(shù)具體的個(gè)體的抽象；

魚也是具體的對(duì)象，就是你吃的這一條具體的魚，這條魚屬于魚類，是無(wú)數(shù)的魚抽象出來(lái)的概念；

?

注：

數(shù)據(jù)<-->屬性；

動(dòng)作<-->方法；

屬性和方法的集合體；

python中函數(shù)和方法要加以區(qū)分；

屬性也決定著方法的多少，有一些方法是為內(nèi)部屬性作操作的，有一些方法是對(duì)外的；

項(xiàng)目有多復(fù)雜，數(shù)據(jù)結(jié)構(gòu)就有多復(fù)雜；

類是數(shù)據(jù)和動(dòng)作，即屬性和方法的集合；

抽象？（數(shù)據(jù)和動(dòng)作的集合）；

具象？

吃，是動(dòng)作，是操作，也是方法，這個(gè)吃是你的動(dòng)作，也就是人類具有的方法；如果反過(guò)來(lái)，魚吃人，吃就是魚類的動(dòng)作了；

吃，這個(gè)動(dòng)作，很多動(dòng)物都具有，人類和魚類都屬于動(dòng)物類，而動(dòng)物類是抽象的概念，是動(dòng)物都有吃的動(dòng)作，但吃法不同而已；

你駕駛車，這個(gè)車是車類的具體的對(duì)象（實(shí)例），駕駛這個(gè)動(dòng)作是魚類不具有的，是人類具有的方法；

?

屬性，是對(duì)象狀態(tài)的抽象，用數(shù)據(jù)結(jié)構(gòu)來(lái)描述；

操作（方法），是對(duì)象行為的抽象，用操作名和實(shí)現(xiàn)該操作的方法來(lái)描述；

?

每個(gè)人都有名字、身高、體重等信息，這些信息是個(gè)人的屬性，但這些信息不能保存在人類中，因?yàn)槿祟愂浅橄蟮母拍?，不能保留具體的值；

而人類的實(shí)例，是具體的人，他可以存儲(chǔ)這些具體的屬性，而且不同人有不同的屬性；

?

哲學(xué)：

一切皆對(duì)象；

對(duì)象是數(shù)據(jù)（屬性）和操作（方法）的封裝；

對(duì)象是獨(dú)立的，但對(duì)象之間可相互作用；

目前，面向?qū)ο笫亲罱咏祟愓J(rèn)知的編程范式；

?

UML，unified modeling language，統(tǒng)一建模語(yǔ)言；

?

?

?

面向?qū)ο笕兀?/span>

1、封裝：

組裝：將數(shù)據(jù)和操作組裝到一起；

隱藏?cái)?shù)據(jù)：對(duì)外只暴露一些接口，通過(guò)接口訪問(wèn)對(duì)象；（如駕駛員使用汽車，不需要了解汽車的構(gòu)造細(xì)節(jié)，只需要知道使用什么部件怎么駕駛就行，踩了油門就能跑，可以不了解背后的機(jī)動(dòng)原理）；

?

encapsulation封裝：

面向?qū)ο蟮娜刂唬?/span>

將數(shù)據(jù)和操作組織到類中，即屬性和方法；

將數(shù)據(jù)隱藏起來(lái)，給使用者提供操作，使用者通過(guò)操作就可獲取或修改數(shù)據(jù)，getter，setter；

通過(guò)訪問(wèn)控制，暴露適當(dāng)?shù)臄?shù)據(jù)和操作給用戶，該隱藏的隱藏起來(lái)，保護(hù)成員或私有成員；

?

?

2、繼承：

多復(fù)用，繼承是為了復(fù)用，繼承來(lái)的就不需要自己寫了；

多繼承少修改，ocp，open-closed-principle開閉原則，使用繼承來(lái)改變，來(lái)體現(xiàn)個(gè)性；

多繼承慎用，問(wèn)題失控，計(jì)算機(jī)所用技術(shù)，簡(jiǎn)單就是美的；

?

注：

函數(shù)復(fù)用，如yield from；

?

3、多態(tài)：

面向?qū)ο缶幊套铎`活的地方，動(dòng)態(tài)綁定；

python運(yùn)行時(shí)才綁定（知道）類型；

?

人類就是封裝；

人類繼承自動(dòng)物類，孩子繼承父母的特征，分為單一繼承、多繼承；

多態(tài)，繼承自動(dòng)物類的人類，貓類的操作“吃”不同；

其它語(yǔ)言的繼承、多態(tài)與python不一樣，僅封裝一樣；

?

在面向?qū)ο笾?，父類、子類通過(guò)繼承聯(lián)系在一起，如果可通過(guò)一套方法，就可實(shí)現(xiàn)不同表現(xiàn)，就是多態(tài)；

一個(gè)類繼承自多個(gè)類，就是多繼承，它將具有多個(gè)類的特征；

?

?

?

python的類：

定義：

class ClassName:

???????? 語(yǔ)句塊

必須使用class關(guān)鍵字；

類名必須用大駝峰（首字母大寫）命名，習(xí)慣，不是語(yǔ)法強(qiáng)制；

類定義完成后，就產(chǎn)生了一個(gè)類對(duì)象，綁定到了ClassName上；

?

注：

區(qū)分：類對(duì)象和類的對(duì)象；

?

例：

class MyClass:

??? '''a example class'''

??? x = 'abc'?? #類屬性，另有對(duì)象屬性（類的實(shí)例的屬性）

??? def foo(self):?? #類屬性foo（單從標(biāo)識(shí)符講，foo是類屬性），同時(shí)也是方法，self必須作為第1個(gè)參數(shù)

??????? print(self.x)

??????? return 'My class'

?

print(MyClass)

print(type(MyClass))

print(MyClass.__name__)

print(MyClass.x)?? #不是內(nèi)存地址，高級(jí)語(yǔ)言對(duì)能簡(jiǎn)化的就簡(jiǎn)化了

print(MyClass.foo)?? #內(nèi)存地址

print(MyClass().foo())

print(MyClass.__doc__)

輸出：

<class '__main__.MyClass'>

<class 'type'>

MyClass

abc

<function MyClass.foo at 0x7f05be5370d0>

abc

My class

a example class

?

?

?

類對(duì)象及類屬性：

類對(duì)象，類的定義就會(huì)生成一個(gè)類對(duì)象；

?

類的標(biāo)識(shí)符：

類的屬性，類中定義的變量和類中定義的方法都是類的屬性；

類變量，上例中x是MyClass的變量；

?

MyClass中，x、foo都是類的屬性，__doc__也是類的屬性；

foo方法是類的屬性，如同吃是人類的方法，但是每一個(gè)具體的人才能吃東西，也就是說(shuō)吃是人類的實(shí)例才能調(diào)用的方法；

foo是method方法對(duì)象，不是普通的function函數(shù)對(duì)象，它必須至少有一個(gè)參數(shù)，且第一個(gè)參數(shù)必須是self（self可換名字），這個(gè)參數(shù)位置就留給了self；

?

self指代當(dāng)前實(shí)例本身，self這個(gè)名字只是一個(gè)慣例，它可以修改，但請(qǐng)不要修改，否則影響代碼的可讀性；

?

注：

inspect中，isfunction()、ismethod()；

?

def bar():

class MyClass:

???????? example = bar?? #語(yǔ)法雖允許，但不要這樣寫，破壞了封裝，不符合編程規(guī)范，方法就寫在類內(nèi)部

?

例：

class MyClass:

??? '''a example class'''

??? x = 'abc'

??? def foo(self):

??????? # print(self.x)

??????? print(self)

??????? # return 'My class'

?

# print(MyClass)

# print(type(MyClass))

# print(MyClass.__name__)

# print(MyClass.x)

# print(MyClass.foo)

print(MyClass().foo())

# print(MyClass.__doc__)

print(MyClass.foo(1))?? #不判斷self的類型，1、None

?

mycls = MyClass()?? #實(shí)例化、初始化

print(mycls.foo())?? #對(duì)象調(diào)用方法，相當(dāng)于悄悄的把mycls放入foo(mycls)中

print(mycls.x)?? #實(shí)例可拿走類屬性

print(mycls.foo)?? #對(duì)象綁定方法

輸出：

<__main__.MyClass object at 0x7f338d4ff438>

None

1

None

<__main__.MyClass object at 0x7f338d4ff438>

None

abc

<bound method MyClass.foo of <__main__.MyClass object at 0x7f338d4ff438>>

?

例：

class MyClass:

??? '''a example class'''

??? x = 'abc'

??? def foo(self):?? #self可改名

??????? # print(self.x)

??????? # print(self)

??????? print(id(self))

??????? # return 'My class'

??????? # return self

?

mycls = MyClass()

print(mycls.foo())

# print(mycls.x)

# print(mycls.foo)

print(id(mycls))

輸出：

140426199077888

None

140426199077888

?

常用：

print(MyClass.x)

mycls = MyClass()

print(mycls.x)

print(mycls.foo())

?

?

?

實(shí)例化：

mycls = MyClass()，

在類對(duì)象名稱后面加()，就調(diào)用類的實(shí)例化方法，完成實(shí)例化；

實(shí)例化，就真正創(chuàng)建一個(gè)該類的對(duì)象（實(shí)例），如人類的實(shí)例tom,jerry；

實(shí)例化后，獲得的實(shí)例，是不同的實(shí)例，即使是使用同樣的參數(shù)實(shí)例化，也得到不一樣的對(duì)象；

python類實(shí)例化后，會(huì)自動(dòng)調(diào)用__init__(self)方法，這個(gè)方法第一個(gè)參數(shù)必須留給self，其它參數(shù)隨意；

?

__init__(self)方法：

MyClass實(shí)際上調(diào)用的是__init__(self)方法，可以不定義，如果沒有定義會(huì)在實(shí)例化后隱式調(diào)用；

作用：對(duì)實(shí)例進(jìn)行初始化；

__init__(self)方法與其它方法不一樣，返回值只能是None，一般不寫返回值，如果寫return只能兩種：return和return None，其它形式一律報(bào)錯(cuò)；

初始化函數(shù)可以多個(gè)參數(shù)，第一個(gè)參數(shù)必須self；

初始化函數(shù)也稱構(gòu)造器，構(gòu)造方法，僅初始化，構(gòu)造實(shí)例是__new__方法；

?

另，__new__(cls,*args,**kwargs)，用于構(gòu)建實(shí)例，極少用，類方法；

?

__init__(self)方法，默認(rèn)的語(yǔ)句是：

def __init__(self):

???????? pass

?

例：

class MyClass:

??? '''this is a example class'''

??? x = 123

??? def __init__(self):

??????? print('init')?? #自定義初始化

?

??? def foo(self):

??????? return 'foo = {}'.format(self.x)

?

a = MyClass()

print(a.foo())

輸出：

init

foo = 123

?

例：

class MyClass:

??? '''this is a example class'''

??? def __init__(self):

??????? print('self in init = {}'.format(id(self)))?? #self就是調(diào)用者，即實(shí)例對(duì)象c

c = MyClass()

print('c = {}'.format(id(c)))

輸出：

self in init = 140190037407448

c = 140190037407448

?

例：

class Person:

??? x = 'abc'

??? def __init__(self,name,age=18):

??????? self.name = name?? #實(shí)例屬性，對(duì)象的屬性

??????? self.age = age

?

??? def showage(self):

??????? print('{} is {}'.format(self.name,self.age))

?

tom = Person('tom')

jerry = Person('jerry',20)

print(tom.name,tom.age)

print(jerry.name,jerry.age)

print(tom.x,jerry.x)

輸出：

tom 18

jerry 20

abc abc

?

例：

class Person:

??? x = 'abc'

??? def __init__(self,name,age=18):

??????? self.name = name

??????? self.age = age

?

??? def showage(self):

??????? print('{} is {}'.format(self.name,self.age))

?

tom = Person('tom')

# jerry = Person('jerry',20)

# print(tom.name,tom.age)

# print(jerry.name,jerry.age)

# print(tom.x,jerry.x)

# print(tom == jerry)

jerry = Person('tom')

print(tom.name,tom.age)

print(jerry.name,jerry.age)

print(tom == jerry)?? #tom和jerry是不同的個(gè)體，盡管初始化時(shí)參數(shù)一樣

print(tom is jerry)

輸出：

tom 18

tom 18

False

False

?

例：

class Person:

??? x = 'abc'

??? def __init__(self,name,age=18):

??????? self.name = name

??????? # self.age = age

??????? self.y = age

?

??? def showage(self,x,y):?? #showage中的形參y和self.y不一樣，self.y是實(shí)例在外部使用時(shí)用的，y是形參

??????? print('{} is {}. {} {}'.format(self.name,self.y,x,y))

??????? self.y = x

??????? Person.x = x?? #類中的所有方法，包括特殊__init__(self)方法，都可對(duì)類屬性或?qū)嵗龑傩赃M(jìn)行修改

?

tom = Person('tom')

jerry = Person('jerry',20)

# print(tom.name,tom.age)

# print(jerry.name,jerry.age)

# print(tom.x,jerry.x)

# print(tom == jerry)

# jerry = Person('tom')

# print(tom.name,tom.age)

# print(jerry.name,jerry.age)

# print(tom == jerry)

# print(tom is jerry)

print(tom.y,jerry.y)

tom.showage(100,'a')

jerry.showage(200,'b')

print(tom.y,jerry.y)

print(Person.x)

print(x)?? #當(dāng)前作用域中沒有x，也說(shuō)明x在Person類中封裝著，要訪問(wèn)x前面要加限定，如Person.x

輸出：

18 20

Traceback (most recent call last):

tom is 18. 100 a

jerry is 20. 200 b

100 200

200

? File "/home/python/magedu/projects/cmdb/example_class_Person.py", line 29, in <module>

??? print(x)

NameError: name 'x' is not defined

?

?

?

instance實(shí)例對(duì)象：

類初始化后一定會(huì)獲得一個(gè)對(duì)象，就是實(shí)例對(duì)象；

tom、jerry就是Person類的實(shí)例；

__init__方法的第一個(gè)參數(shù)self，就是指代某一個(gè)實(shí)例；

類實(shí)例化出一個(gè)實(shí)例對(duì)象，實(shí)例對(duì)象會(huì)綁定方法，調(diào)用方法時(shí)采用jerry.showage()的方式；

在定義showage(self)時(shí)，不能少了self，這個(gè)self就是jerry，python會(huì)把方法的調(diào)用者作為第一個(gè)參數(shù)self的實(shí)參傳入；

self.name就是jerry對(duì)象的name，name是保存在了jerry對(duì)象上，而不是Person類上，所以稱為實(shí)例變量；

?

實(shí)例變量是每一個(gè)實(shí)例自己的變量，是自己獨(dú)有的；

類變量是類的變量，是類的所有實(shí)例共享的屬性和方法；

?

類屬性保存在類的__dict__中；

實(shí)例屬性保存在實(shí)例的__dict__中；

如果從實(shí)例訪問(wèn)類的屬性，需要借助__class__找到所屬的類；

?

特殊屬性：

__name__，對(duì)象名；

__class__，對(duì)象的類型，python3中__class__和type()結(jié)果一樣；

__dict__，對(duì)象的屬性的字典；

__qualname__，類的限定名；

?

總結(jié)：

是類的，也是這個(gè)類所有實(shí)例的，其實(shí)例都可以訪問(wèn)到類中定義的屬性和方法；是類的，就是大家的；

是實(shí)例的，就是這個(gè)實(shí)例自己的，通過(guò)類訪問(wèn)不到；是實(shí)例的，就是個(gè)體的；

類變量，是屬于類的變量，這個(gè)類的所有實(shí)例可以共享這個(gè)變量；

實(shí)例可以動(dòng)態(tài)的給自己添加或刪除一個(gè)屬性，實(shí)例.__dict__['變量名']和實(shí)例.變量名都可訪問(wèn)到；也可動(dòng)態(tài)添加類方法，這些會(huì)破壞封裝，不要這么做，雖語(yǔ)法允許，但從設(shè)計(jì)角度不好；

實(shí)例的變量會(huì)隱藏與其同名的類的變量（遮蓋），或者說(shuō)是覆蓋了類變量；

?

實(shí)例屬性的查找順序：

實(shí)例使用.點(diǎn)來(lái)訪問(wèn)屬性，會(huì)先找自己的__dict__；

如果沒有，然后通過(guò)屬性__class__找到自己的類，再去類的__dict__中找；

如果實(shí)例使用__dict__['變量名']來(lái)訪問(wèn)（直接翻字典），將不會(huì)按照上面的查找順序找變量；

?

一般類變量使用全大寫來(lái)命名；

tom.__class__.__dict__等價(jià)于Person.__dict__；

?

例：

class Person:

??? age = 18?? #類變量，通常是一常量，很少用

??? def __init__(self,name):

??????? self.name = name?? #編程中，大量用的是實(shí)例變量，而不是類變量

?

# tom = Person('tom',20)?? #X

tom = Person('tom')?? #初始化、實(shí)例化

jerry = Person('jerry')

print(tom.name,tom.age)

print(jerry.name,jerry.age)

print(Person.age)

# print(Person.name)?? #X

Person.age = 30?? #在外部修改類屬性

print(tom.age,jerry.age,Person.age)

?

print(Person.__dict__)?? #__weakref__弱引用，用.點(diǎn)查找屬性

print(tom.__dict__)?? #每個(gè)對(duì)象保存著自己的屬性，所有對(duì)象的操作方法是一樣的，無(wú)非是數(shù)據(jù)不一樣（傳入的參數(shù)不一樣）

print(jerry.__dict__)

print(tom.__dict__['name'])

?

print(sorted(Person.__dict__.items()),end='\n')

print(sorted(tom.__dict__.items()),end='\n')

?

# print(tom.__qualname__)?? #某一對(duì)象并不擁有所有特殊屬性

print(tom.__class__.__qualname__,jerry.__class__.__qualname__)

print(isinstance(jerry,tom.__class__))

print(int.__class__)

print(Person.__class__)

print(isinstance(tom,int.__class__))

輸出：

tom 18

jerry 18

18

30 30 30

{'__module__': '__main__', 'age': 30, '__init__': <function Person.__init__ at 0x7f7b63da20d0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

{'name': 'tom'}

{'name': 'jerry'}

tom

[('__dict__', <attribute '__dict__' of 'Person' objects>), ('__doc__', None), ('__init__', <function Person.__init__ at 0x7f7b63da20d0>), ('__module__', '__main__'), ('__weakref__', <attribute '__weakref__' of 'Person' objects>), ('age', 30)]

[('name', 'tom')]

Person Person

True

<class 'type'>

<class 'type'>

False

?

例：

class Person:

??? age = 3

??? height = 170

??? def __init__(self,name,age=18):?? #方法中的第一個(gè)參數(shù)self，表示bound了對(duì)象（實(shí)例）

??????? self.name = name

??????? self.age = age

?

tom = Person('tom')

jerry = Person('jerry',20)

?

Person.age = 30

print(Person.age,tom.age,jerry.age)

print(Person.__dict__,tom.__dict__,jerry.__dict__,sep='\n')

print(Person.height,tom.height,jerry.height)

Person.height += 20

print(Person.height,tom.height,jerry.height)

print(Person.__dict__,tom.__dict__,jerry.__dict__,sep='\n')

?

tom.height = 168

print(Person.height,tom.height,jerry.height)

print(Person.__dict__,tom.__dict__,jerry.__dict__,sep='\n')

?

jerry.height += 20

print(Person.height,tom.height,jerry.height)

print(Person.__dict__,tom.__dict__,jerry.__dict__,sep='\n')

?

Person.weight = 70?? #動(dòng)態(tài)添加（刪除）屬性，靈活之處，也可動(dòng)態(tài)添加方法，這些會(huì)破壞封裝，不要這么做

print(Person.weight,tom.weight,jerry.weight)?? #先找自己的__dict__，找不到再通過(guò)__class__找類中的__dict__，類中也沒有拋異常KeyError

print(tom.__dict__['weight'])?? #X，KeyError

輸出：

30 18 20

{'__module__': '__main__', 'age': 30, 'height': 170, '__init__': <function Person.__init__ at 0x7f9f7aad40d0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

{'name': 'tom', 'age': 18}

{'name': 'jerry', 'age': 20}

170 170 170

190 190 190

{'__module__': '__main__', 'age': 30, 'height': 190, '__init__': <function Person.__init__ at 0x7f9f7aad40d0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

{'name': 'tom', 'age': 18}

{'name': 'jerry', 'age': 20}

190 168 190

{'__module__': '__main__', 'age': 30, 'height': 190, '__init__': <function Person.__init__ at 0x7f9f7aad40d0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

{'name': 'tom', 'age': 18, 'height': 168}

{'name': 'jerry', 'age': 20}

190 168 210

{'__module__': '__main__', 'age': 30, 'height': 190, '__init__': <function Person.__init__ at 0x7f9f7aad40d0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

{'name': 'tom', 'age': 18, 'height': 168}

{'name': 'jerry', 'age': 20, 'height': 210}

70 70 70

Traceback (most recent call last):

? File "/home/python/magedu/projects/cmdb/example_class_var.py", line 29, in <module>

??? print(tom.__dict__['weight'])

KeyError: 'weight'

?

?

?

裝飾一個(gè)類：

不是類裝飾器；

需求：為一個(gè)類通過(guò)裝飾，增加一些類屬性；

用于老項(xiàng)目，不動(dòng)類定義，通過(guò)裝飾器動(dòng)態(tài)的添加類屬性；

?

def setnameproperty(name):

??? def wrapper(cls):

??????? cls.NAME = name

??????? return cls

??? return wrapper

?

@setnameproperty('MYCLASS')? ?#MyClass = setnameproperty('MYCLASS')(MyClass)

class MyClass:

??? pass

?

print(MyClass.__dict__)

輸出：

{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None, 'NAME': 'MYCLASS'}

?

?

?

類方法、靜態(tài)方法：

類方法，用裝飾器@classmethod，在定義時(shí)，第1個(gè)參數(shù)留給類本身，如def clsmtd(cls)，與類bound（類似對(duì)象方法，第1個(gè)參數(shù)self，與實(shí)例bound）；

類中普通方法，def bar()，雖語(yǔ)法允許，不推薦使用，若非要不帶參數(shù)，用靜態(tài)方法替代；

靜態(tài)方法，用裝飾器@staticmethod；

?

python中類方法，相當(dāng)于其它語(yǔ)言的靜態(tài)方法；java、c++中的靜態(tài)方法指的是python中的類方法；

?

類方法，如datetime.datetime(...)創(chuàng)建時(shí)間對(duì)象；

靜態(tài)方法，從概念上歸類管轄，實(shí)際使用可以與類沒有關(guān)系，很少用；

?

__init__()等方法，這些本身都是類的屬性，第一個(gè)參數(shù)必須是self，而self必須指向一個(gè)對(duì)象，即類必須實(shí)例化后，由實(shí)例來(lái)調(diào)用這個(gè)方法；

?

普通方法：

MyClass.bar()，先查看MyClass.__dict__，這個(gè)方法只是被MyClass這個(gè)名詞空間管理的一個(gè)普通的方法，bar是MyClass的一個(gè)屬性而已，由于bar在定義時(shí)沒有指定self，這樣即沒有完成與實(shí)例對(duì)象的綁定，不能用a.bar()或MyClass().bar()調(diào)用，這種雖語(yǔ)法對(duì)，但沒人這么用，禁止這樣定義def bar()；

?

類方法：

在類定義中，用@classmethod裝飾器修飾的方法；

pycharm中，定義時(shí)會(huì)自動(dòng)補(bǔ)全cls參數(shù)，必須至少有一個(gè)參數(shù)，且第一個(gè)參數(shù)留給了cls，cls指代調(diào)用者即對(duì)象自身；

cls這個(gè)標(biāo)識(shí)符可以是任意合法名稱，但是為了易讀，請(qǐng)不要修改；

通過(guò)cls可直接操作類的屬性，無(wú)法通過(guò)cls操作類的實(shí)例；

類方法，類似c++、java中的靜態(tài)方法；

?

靜態(tài)方法：

在類定義中用@staticmethod裝飾器修飾的方法；

調(diào)用時(shí)，不會(huì)隱式的傳入?yún)?shù)；

靜態(tài)方法，只是表明這個(gè)方法屬于類這個(gè)名詞空間，函數(shù)歸在一起，方便組織管理；

?

注：

實(shí)例可調(diào)用類中定義的方法（包括類方法、靜態(tài)方法），靜態(tài)方法和類方法需要找到實(shí)例的類；

實(shí)例不可調(diào)用類中的普通方法，如a.bar()，解釋器會(huì)自動(dòng)將a傳到bar(a)內(nèi)，而bar在定義時(shí)沒有self，即沒有綁定實(shí)例；

?

例：

class MyClass:

??? XXX = 'xxx'

??? def __init__(self):

??????? print('init')

?

??? def foo(self):

??????? print('foo')

?

??? def bar():

??????? print('bar')

?

??? @classmethod

??? def clsmtd(cls):?? #類方法，cls為類本身，或是實(shí)例的類

??????? print('{},xxx={}'.format(cls.__name__,cls.XXX))

?

??? @staticmethod

??? def staticmtd():

??? # def staticmtd(x):

??????? print('static')

?

a = MyClass()

a.foo()

MyClass.bar()?? #V，可以這樣用，bar是在MyClass類下定義的

# a.bar()?? #X，foo和bar都是function，bar中形參沒有self，為類中的普通函數(shù)，這樣調(diào)用會(huì)自動(dòng)把a作為形參傳入到bar(a)會(huì)出錯(cuò)

print(MyClass.__dict__)

?

MyClass.clsmtd()?? #同a.foo()，會(huì)將類本身MyClass傳入clsmtd(MyClass)類方法的第一個(gè)參數(shù)

a.clsmtd()?? #是類的，就是大家的，所以實(shí)例可以用，相當(dāng)于a.__class__.clsmtd()

?

MyClass.staticmtd()?? #V

a.staticmtd()?? #是類的，就是大家的

# a.staticmtd(4)

?

輸出：

init

foo

bar

{'__module__': '__main__', 'XXX': 'xxx', '__init__': <function MyClass.__init__ at 0x7f97c11f30d0>, 'foo': <function MyClass.foo at 0x7f97c11f3158>, 'bar': <function MyClass.bar at 0x7f97c11f3488>, 'clsmtd': <classmethod object at 0x7f97c11f5c18>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None}

MyClass,xxx=xxx

MyClass,xxx=xxx

static

static

?

例：

class Person:

??? @classmethod

??? def cls_method(cls):

??????? print('class = {0.__name__} ({0})'.format(cls))

??????? cls.HEIGHT = 170?? #可操作類的屬性，不能操作實(shí)例的屬性

?

??? @staticmethod

??? def static_method():

??????? print(Person.HEIGHT)

?

Person.cls_method()

print(Person.__dict__)

Person.static_method()

輸出：

class = Person (<class '__main__.Person'>)

{'__module__': '__main__', 'cls_method': <classmethod object at 0x7fdfe7ec4710>, 'static_method': <staticmethod object at 0x7fdfe7ec9400>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None, 'HEIGHT': 170}

170

?

?

?

訪問(wèn)控制：

private，私有屬性，雙下劃線開頭的屬性名；

私有變量的本質(zhì)：類定義的時(shí)候，如果聲明一個(gè)實(shí)例變量使用雙下劃線開頭，python解釋器會(huì)將其改名，轉(zhuǎn)換名稱為_類名__變更名，所以在外部用原來(lái)的名字（__age）訪問(wèn)不到了，但仍可通過(guò)__dict__訪問(wèn)或修改；其它語(yǔ)言不是這樣，是確確實(shí)實(shí)看不到，python中仍然可在外部通過(guò)_Person__age訪問(wèn)或修改；

?

保護(hù)變量：

在變更名前加一個(gè)下劃線，查看__dict__，解釋器不做任何特殊處理，這只是開發(fā)者共同的約定，看見這種變量，就如同私有變量，不要直接使用；

?

私有方法：

雙下劃線開頭的方法，解釋器會(huì)改名，改名策略和私有變量相同，_類名__方法名；

單下劃線的方法，只是開發(fā)者之間的約定，解釋器不作任何改變；

方法變量都在類的__dict__中可找到；

?

私有成員的總結(jié)：

在python中使用_或__來(lái)標(biāo)識(shí)一個(gè)成員被保護(hù)或被私有化隱藏起來(lái)，但是不管使用什么樣的訪問(wèn)控制，都不能真正的阻止用戶修改類的成員，python中沒有絕對(duì)的安全的保護(hù)成員或私有成員；

因此前導(dǎo)的下劃線只是一種警告或提醒，請(qǐng)遵守這個(gè)約定，除非真有必要，不要修改或者使用保護(hù)成員或私有成員；

以上是在類中使用_或__，如果是在函數(shù)中使用則不起作用；

?

public、protect、private，其它語(yǔ)言的訪問(wèn)控制，而python中的訪問(wèn)控制只是假象；

?

例：

class Person:

??? def __init__(self,name,age=18):

??????? self.name = name

??????? self.age = age

?

??? def growup(self,incr):

?????? ?if 0 < incr < 150:?? #控制邏輯

??????????? self.age += incr

?

tom = Person('tom')

tom.growup(20)

tom.age = 160?? #未用私有屬性，會(huì)繞過(guò)控制邏輯，外部可見，外部可定義和修改，越過(guò)我們定義的范圍

print(tom.age)

輸出：

160

?

例：

class Person:

??? def __init__(self,name,age=18):

??????? # self.name = name

??????? self._name = name

??????? # self.age = age

??????? self.__age = age?? #對(duì)象字典中的key表現(xiàn)為_Person__age，自動(dòng)對(duì)應(yīng)的

?

??? def growup(self,incr):

??????? if 0 < incr < 150:

??????????? # self.age += incr

??????????? self.__age += incr

?

??? def getage(self):

??????? return self.__age

?

tom = Person('tom')

tom.growup(2)

# tom.age = 160

# print(tom.age)

# print(tom.__age)?? #X，不能直接訪問(wèn)私有屬性，報(bào)AttributeError: 'Person' object has no attribute '__age'

print(tom.getage())?? #通過(guò)方法訪問(wèn)私有屬性，沒多大用處

?

print(Person.__dict__)

print(tom.__dict__)

?

tom._Person__age = 200?? #破壞封裝

print(tom.getage())

?

tom.__age = 300?? #破壞封裝，重新定義的__age，與對(duì)象字典的_Person__age不是同一個(gè)key，不會(huì)被覆蓋

print(tom.getage())

print(tom.__dict__)

print(tom.__age)

?

輸出：

20

{'__module__': '__main__', '__init__': <function Person.__init__ at 0x7fde68b150d0>, 'growup': <function Person.growup at 0x7fde68b15158>, 'getage': <function Person.getage at 0x7fde68b15488>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

{'_name': 'tom', '_Person__age': 20}

200

200

{'_name': 'tom', '_Person__age': 200, '__age': 300}

300

tom

{'_name': 'tom', '_Person__age': 200, '__age': 300}

?

?

?

猴子補(bǔ)?。?/span>

可通過(guò)修改或者替換類的成員；

使用者調(diào)用的方式?jīng)]有改變，但類提供的功能可能已經(jīng)改變了；

適用于上線后的緊急或臨時(shí)修復(fù)上，一般下次變更時(shí)會(huì)合并到代碼中；

?

monkey patch，猴子補(bǔ)丁，在運(yùn)行時(shí)對(duì)屬性進(jìn)行動(dòng)態(tài)替換；

黑魔法，慎用；

?

類方法中的名字，get*讀，set*寫，慣例；

?

例：

使用monkey patch，替換getscore方法，返回模擬的數(shù)據(jù)；

?

test2.py

class Person:

??? def __init__(self,chinese,english,history):

??????? self.chinese = chinese

??????? self.english = english

??????? self.history = history

?

??? def getscore(self):

??????? return self.chinese,self.english,self.history

?

test3.py

def getscore(self):

??? return dict(chinese=self.chinese,english=self.english,history=self.history)

?

test1.py

from test2 import Person

from test3 import getscore

?

def monkeypatch5Person():

??? Person.getscore = getscore

?

stu1 = Person(80,90,88)

print(stu1.getscore())

?

monkeypatch5Person()

?

stu2 = Person(70,80,90)

print(stu2.getscore())

輸出：

(80, 90, 88)

{'chinese': 70, 'english': 80, 'history': 90}

?

?

?