python類方法

『壹』 python 如何調用類的方法

以numpy為例，首先創建一個對象：

In[32]:a=numpp.arange(10)

然後，a就擁有了類的方法，例如求和：

In[33]:a.sum()
Out[33]:45

也可以使用類的方法，將其應用到類的對象上，例如：

In[34]:numpp.sum(a)
Out[34]:45

『貳』 實例方法和類方法的區別 python

有區別的，最主要的區別在於，定義類方法主要是要加一個裝飾器，@classmethod

而實例方法沒有這個裝飾器。這是區別實例方法和類方法的最主要的區別。

在調用上的區別在於，實例方法要先實例化一個對象再調用這個實例化方法，而類方法不需要有類的實例，直接類名.方法名就可以調用。

實例方法至少有一個參數，通常用self，這個參數裡面是這個實例本身。類方法至少有一個參數，通常用cls，這個參數裡面是這個類本身。

實例方法由於有實例，所以實例的屬性對其實可見的，但類方法顯然沒有屬性。

本質上來講，類方法和實例方法沒有本質區別，只不過在調用的時候，實例方法把這個實例本身當做參數傳過去了。

以下是示例代碼，感受一下。

classmyclass:
@classmethod
defclassMethod(cls):
print('classmethod')
print('parameter:%s'%cls)
pass
definstanceMethod(self):
print('instancemethod')
print('parameter:%s'%self)
pass
m=myclass()
m.instanceMethod()#實例來調用實例方法
myclass.classMethod()#類名.方法名調用類方法
myclass.instanceMethod(m)#類名.方法名，並將實例作為參數傳入，和實例調用實例方法一樣

『叄』 python 怎麼結束類和方法體

縮進啊。。。縮進內的是方法內的部分，縮進外的就代表結束了。

deffunction_name(paras):
inner
outter

『肆』 python類方法和靜態方法有什麼用

主要特點就是需要綁定到一個對象上，python解析器會自動把實例自身傳遞給方法，如14行所示，而直接使用InstanceMethod.f1()調用方法是不行的。

class InstanceMethod(object):
def __init__(self, a):
self.a = a
def f1(self):
print 'This is {0}.'.format(self)
def f2(self, a):
print 'Value:{0}'.format(a)
if __name__ == '__main__':
# im = InstanceMethod()
im = InstanceMethod('233')
im.f1()
# im.f2()
im.f2(233)

『伍』 python類中的 方法 屬性分別什麼意思

就比方說有一個類叫做car

這個類的屬性可以有colorsizebrandpriceyear等描述性的東西

這個類的方法可以是runstopforwardbackward等執行性的東西

classcar:
#定義基本屬性
color=''
size=0
brand=''
price=0
year=0

#定義構造方法
def__init__(self):
self.color=color
self.size=size
self.brand=brand
self.price=price
self.year=year
defrun(self):
print("thecarisrunning")
defstop(self):
print("thecarisstop")
defforward(self):
print("thecarisforward")
defbackward(self):
print("thecarisbackward")

#類調用

benz=car('red',1.8T,'Mercedes',400000,2016)
benz.run()
benz.stop()
benz.forward()
benz.backward()

『陸』 python 類方法和靜態方法 實例方法的區別

以前有過類似的問題 可以參考下：

http://www.cnblogs.com/funfunny/p/5892212.html

『柒』 python類方法和靜態方法的區別

面相對象程序設計中，類方法和靜態方法是經常用到的兩個術語。

邏輯上講：類方法是只能由類名調用；靜態方法可以由類名或對象名進行調用。

在C++中，靜態方法與類方法邏輯上是等價的，只有一個概念，不會混淆。

而在python中，方法分為三類實例方法、類方法、靜態方法。代碼如下：

class Test(object):

def InstanceFun(self):

print("InstanceFun");

print(self);

@classmethod

def ClassFun(cls):

print("ClassFun");

print(cls);

@staticmethod

def StaticFun():

print("StaticFun");

t = Test();

t.InstanceFun();＃ 輸出InstanceFun，列印對象內存地址「<__main__.Test object at 0x0293DCF0>」

Test.ClassFun(); # 輸出ClassFun，列印類位置 <class '__main__.Test'>

Test.StaticFun(); # 輸出StaticFun

t.StaticFun(); # 輸出StaticFun

t.ClassFun(); # 輸出ClassFun，列印類位置 <class '__main__.Test'>

Test.InstanceFun(); # 錯誤，TypeError: unbound method
instanceFun() must be called with Test instance as first argument

Test.InstanceFun(t); # 輸出InstanceFun，列印對象內存地址「<__main__.Test object at 0x0293DCF0>」

t.ClassFun(Test); # 錯誤 classFun() takes exactly 1 argument (2 given)

可以看到，在PYTHON中，兩種方法的主要區別在於參數。實例方法隱含的參數為類實例self，而類方法隱含的參數為類本身cls。
靜態方法無隱含參數，主要為了類實例也可以直接調用靜態方法。

所以邏輯上類方法應當只被類調用，實例方法實例調用，靜態方法兩者都能調用。主要區別在於參數傳遞上的區別，實例方法悄悄傳遞的是self引用作為參數，而類方法悄悄傳遞的是cls引用作為參數。

『捌』 python 什麼時候用類方法

用class來聲明一個類，也就是創建了一個類。使用class關鍵字，後面接類的名稱，然後一個冒號
還有兩種寫法，他們都是等價的。
聲明類以後，我們使用__init__函數來重載構造函數，如圖所示，在類中都有一個self參數，他是任何類都有的，代表實例本身，假如我們想要給實例設置一個name屬性，那麼我們用下面的方法來設置。__init__後面的參數都可以在創建實例的時候使用。
當然我們可以任意設置__init__方法的參數個數
通常我們使用__del__函數來重載析構函數，不過如果你沒有在類的聲明中寫這個方法，它也會默認加上去的。所以，通常都不寫。。。
你還可以在類中聲明一個方法，然後在創建實例以後，我們再調用方法。聲明方法如下：
創建實例
創建實例我們用賦值的方式，我們可以直接將參數輸入到類中。然後用p.name來調用類的屬性。

『玖』 python類方法問題

@classmethod
defnew_square(cls,side_length):
returncls(side_length,side_length)

@classmethod表示函數new_square是Rectangle類裡面創建一個成員函數
cls表示調用當前的類名
side_length是函數的一個要傳的參數
returncls(side_length,side_length)表示返回調用Rectangle類的構造函數def__init__(self,width,height)初始化後的類

所以square=Rectangle.new_square(5)表示調用Rectangle類的成員函數new_square,初始化Rectangle類並返回
print(square.calculate_area())表示調用Rectangle類的計算面積函數,並列印輸出
因此5傳給side_length變數,又調用__init__函數為self.width和self.height賦值為5,
調用print(square.calculate_area())列印self.width*self.height=5*5=25

『拾』 python中可以直接用類調用方法嗎

這里先肯定的回答一下：可以

python里方法在類中是作為類的屬性的，在解釋之前，這邊先給個例子

>>>classPizza(object):
...radius=42
...def__init__(self,size=10):
...self.size=size
...defget_size(self):
...returnself.size
...@staticmethod
...defmix_ingredients(x,y):
...returnx+y
...defcook(self):
...returnself.mix_ingredients(self.cheese,self.vegetables)
...@classmethod
...defget_radius(cls):
...returncls.radius
>>>Pizza.get_size
<unboundmethodPizza.get_size>
>>>Pizza.get_size()
Traceback(mostrecentcalllast):
File"<stdin>",line1,in<mole>
TypeError:unboundmethodget_size()(gotnothinginstead)
>>>Pizza.get_size(Pizza(42))
42
>>>Pizza(42).get_size
<boundmethodPizza.get_sizeof<__main__.Pizzaobjectat0x7f3138827910>>
>>>Pizza(42).get_size()
42
>>>m=Pizza(42).get_size
>>>m()
42
>>>m=Pizza(42).get_size
>>>m.__self__
<__main__.Pizzaobjectat0x7f3138827910>
>>>m==m.__self__.get_size
True
>>>Pizza().cookisPizza().cook
False
>>>Pizza().mix_ingredientsisPizza.mix_ingredients
True
>>>Pizza().mix_ingredientsisPizza().mix_ingredients
True
>>>Pizza.get_radius
<boundmethodtype.get_radiusof<class'__main__.Pizza'>>
>>>Pizza().get_radius
<boundmethodtype.get_radiusof<class'__main__.Pizza'>>
>>>Pizza.get_radiusisPizza().get_radius
True
>>>Pizza.get_radius()
42

在上面的例子中可以看出python中類有三種方法，分別是類方法，靜態方法，實例方法。而能讓類只接調用的只有類方法，或通過一些小技巧，類也可以調用實例方法如上面例子中的調用

>>>Pizza.get_size(Pizza(42))
42

這邊順便說明下這三中方法的區別

1類方法的特點是類方法不屬於任何該類的對象，只屬於類本身

2類的靜態方法類似於全局函數，因為靜態方法既沒有實例方法的self參數也沒有類方法的cls參數，誰都可以調用

3.實例方法只屬於實例，是實例化的對象才能調用