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.实例方法只属于实例，是实例化的对象才能调用