今天對python普通方法、類方法及靜態方法的知識進行了學習，還是感覺函數間內部的邏輯不是很懂，鬱悶啊，難道看的時候分心咯，醉了。知識點都能看懂，但是換個調用方式就又變的迷糊了：
class Fruit： #定義一個類
def init(self): #類的構造函數，用於初始化類的內部狀態，爲類的屬性設置默認值
self.name=name #定義name屬性
self.color=color #定義color屬性
def grow（self）： #定義一個函數，爲類的函數，稱爲方法；它至少有一個參數self
print（‘Fruit grow’）
if name==”main” #當程序作爲主程序運行
fruit=Fruit() #實例化：創建一個對象，創建了一個Fruit對象
fruit，grow() #對象調用grow（）方法
class Fruit:
price=0 #定義一個類屬性
def init(self): #構造函數
self.color=”red” #實例屬性，以self爲前綴
zone=”China” #局部變量，不以self爲前綴
if name==”main“:
print(Fruit.price) #使用類名調用類變量 0
apple=Fruit() #實例化apple
print(apple.color) #打印apple實例的顏色 red
Fruit.price=Fruit.price+10 #將類變量+10
print(“apple’s price:”,+str(apple.price)) #打印apple實例的price 10
banana=Fruit() #實例化banana
print(“banana’s price:”+str(banana.price)) #打印banana實例的price 10
class Fruit:
price=0 #類變量
def init(self): #構造函數
self.__color=”red” #定義一個私有屬性，類的外部不能直接訪問
def getColor(self): #類方法
print(self.__color) #打印出私有變量
@staticmenthod #使用修飾器靜態方法
def getPrice(): #定義一個類方法
print(Fruit.price) #打印類變量
def __getPrice(): #定義私有函數，不能被模塊外的類或者方法調用
Fruit.price=Fruit.price+10 #類變量+10
print(Fruit.price)
count=staticmenthod(__getPrice) #定義靜態方法
if name==”main“:
apple=Fruit() #實例化apple
apple.getColor() #使用實例私有變量， red；因爲創建了對象apple，所以靜態屬性price執行一次
Fruit.count() #使用列名直接調用靜態方法 10
banana=Fruit() #實例化 創建banana對象，所以靜態屬性第三次執行
Fruit.count() #實例調用靜態方法 20
Fruit.getPrice() # 20
object_name = outclass_name.inclass_name()
object_name.method()
第二種：先對外部類進行實例化，然後再實例化內部類，最後調用內部類的方法
out_name = outclass_name()
in_name = out_name.inclass_name()
in_name.method()
class Fruit:
def init(self, color):
self.__color = color
print( self.__color)
def getColor(self):
print( self.__color)
def setColor(self, color):
self.__color = color
print(self.__color)
if name == ‘main‘:
color = ‘red’
fruit = Fruit(color) #red
fruit.getColor() #red
fruit.setColor(‘blue’) #blue
在類裏面定義的函數就是方法,類方法需要@ classmethod 修飾並且有個隱藏參數 cls,實例方法必須有個參數 self, 靜態方法必須有 @staticmethod修飾,類和實例都可以訪問靜態方法,實例可以訪問實例方法也可以訪問類方法,類可以訪問類方法也可以訪問實例方法,訪問實例方法必須要帶參數 self, 可以理解爲類其實也是一個實例,類訪問實例方法不帶參數會報錯的
--coding:utf-8--
metaclass = type
class Tst:
name = ‘tst’
data = ‘this is data’
# 普通方法
def normalMethod(self,name):
print self.data,self.name
# 類方法，可以訪問類屬性
@classmethod
def classMethod(cls,name):
print cls.data,name
#靜態方法，不可訪問類屬性
@staticmethod
def staticMethod(name):
print name
tst = Tst()
tst.data = ‘this is new’
tst.normalMethod(‘x’)
tst.staticMethod(‘x’)
tst.classMethod(‘x’)
三種方法都可以通過實例來調用，但是靜態方法和類方法無法訪問實例屬性，所以更改了tst.data僅對普通方法起了作用
普通方法不能通過類名調用，但是靜態方法和類方法是可以的
error普通方法必須通過實例調用
Tst.normalMethod(‘name’)
Tst.classMethod(‘name’)
Tst.staticMethod(‘name’)
結果
this is data name
name
普通方法,可以通過self訪問實例屬性
def normalMethod(self,data)
1
類方法,可以通過cls訪問類屬性
@classmethod
def classMethod(cls,data)
1
2
靜態方法,不可以訪問,通過傳值的方式
@staticmethod
def staticMethod(data)
Python：類屬性，實例屬性，私有屬性與靜態方法，類方法，實例方法
屬性分爲實例屬性與類屬性
方法分爲普通方法，類方法，靜態方法
一：屬性：
儘量把需要用戶傳入的屬性作爲實例屬性，而把同類都一樣的屬性作爲類屬性。實例屬性在每創造一個實例時都會初始化一遍，不同的實例的實例屬性可能不同，不同實例的類屬性都相同。從而減少內存。
1：實例屬性：
最好在init(self,…)中初始化
內部調用時都需要加上self.
外部調用時用instancename.propertyname
2:類屬性：
在init()外初始化
在內部用classname.類屬性名調用
外部既可以用classname.類屬性名又可以用instancename.類屬性名來調用
3：私有屬性：
1）：單下劃線_開頭：只是告訴別人這是私有屬性，外部依然可以訪問更改
2）：雙下劃線__開頭：外部不可通過instancename.propertyname來訪問或者更改
實際將其轉化爲了_classname__propertyname
二：方法
1：普通類方法：
def fun_name(self,…):
pass
外部用實例調用
2：靜態方法：@staticmethod
不能訪問實例屬性！！！ 參數不能傳入self！！！
與類相關但是不依賴類與實例的方法！！
3:類方法：@classmethod
不能訪問實例屬性！！！ 參數必須傳入cls！！！
必須傳入cls參數（即代表了此類對象—–區別——self代表實例對象），並且用此來調用類屬性：cls.類屬性名
*靜態方法與類方法都可以通過類或者實例來調用。其兩個的特點都是不能夠調用實例屬性
類變量定義在類的定義之後，實例變量則是以爲self.開頭。例如：
class Foo(object):
val = 0
def init(self):
self.val = 1
if name == ‘main‘:
foo = Foo()
print foo.val
print Foo.val
報錯：
class Foo(object):
def init(self):
self.val = 1
class Foo2(Foo):
def init(self):
print self.val
if name == ‘main‘:
foo2 = Foo2()
調用父類的init方法有兩種，第一種：
class Foo(object):
def init(self):
self.val = 1
class Foo2(Foo):
def init(self):
Foo.init(self)
print self.val
if name == ‘main‘:
foo2 = Foo2()
class Foo(object):
def init(self):
self.val = 1
class Foo2(Foo):
def init(self):
super(Foo2,self).init()
print self.val
if name == ‘main‘:
foo2 = Foo2()