在python的类语法中,可以出现三种方法,具体如下:

  (1)实例方法

    1)第一个参数必须是实例本身,一般使用【self】表示。

    2)在实例方法中,可以通过【self】来操作实例属性,【类名】来操作类属性。

    3)实例方法只能通过实例对象去调用,尽管也可以通过类名间接调用【类名.方法名(self, ...)】,但此时仍然需要传入self对象。

  (2)类方法

    1)使用【@classmethod】修饰函数,且第一个参数必须是类本身,一般使用【cls】表示。

    2)在类方法中,可以使用【cls=类名】来操作类属性,但是不能操作实例属性(self对象中存储的变量)。

    3)类方法可以通过实例对象或者类对象调用。

  (3)静态方法

    1)使用【@staticmethod】修饰函数,不需要使用任何参数表示。与普通函数一样,只是将该方法放到了类中实现而已。

    2)使用方式与类方法一样,参考类方法中的 2)、3)。(注:静态方法只能通过【类名】去操作类属性;)

案例1:实例方法、类方法、静态方法使用

class Foo(object):
"""类三种方法语法形式"""
count = 0 # 统计实例对象的数量
class_method_count = 0 # 统计类方法的调用次数 # 实例方法
def __init__(self, name):
self.name = name
Foo.count += 1 # 实例方法
def instance_method(self):
print("是类{}的实例方法,只能被实例对象调用".format(Foo))
print("产生了一个<{}>实例,共有<{}>个实例对象".format(self.name, Foo.count)) # 类方法
@classmethod
def class_method(cls):
print("是类{}的类方法,可以被实例对象、类对象调用".format(cls))
cls.__static_method_test()
cls.class_method_count += 1 # 静态方法
@staticmethod
def static_method():
print("是类{}的静态方法,可以被实例对象、类对象调用".format(Foo))
print("+++以下内容为类方法class_method()的运行结果:")
Foo.class_method() @staticmethod
def __static_method_test():
print("调用了静态方法 static_method_test()") print("--"*20 + "实例方法测试" + "--"*20)
obj1 = Foo("dog")
obj1.instance_method() # <=> Foo.instance_method(obj1) print("--"*20 + "类方法测试" + "--"*20)
obj1.class_method()
print("--"*20)
Foo.class_method() print("--"*20 + "静态方法测试" + "--" * 20)
obj1.static_method()
print("--"*20)
Foo.static_method() """
运行结果:
----------------------------------------实例方法测试----------------------------------------
是类<class '__main__.Foo'>的实例方法,只能被实例对象调用
产生了一个<dog>实例,共有<1>个实例对象
----------------------------------------类方法测试----------------------------------------
是类<class '__main__.Foo'>的类方法,可以被实例对象、类对象调用
调用了静态方法 static_method_test()
----------------------------------------
是类<class '__main__.Foo'>的类方法,可以被实例对象、类对象调用
调用了静态方法 static_method_test()
----------------------------------------静态方法测试----------------------------------------
是类<class '__main__.Foo'>的静态方法,可以被实例对象、类对象调用
+++以下内容为类方法class_method()的运行结果:
是类<class '__main__.Foo'>的类方法,可以被实例对象、类对象调用
调用了静态方法 static_method_test()
----------------------------------------
是类<class '__main__.Foo'>的静态方法,可以被实例对象、类对象调用
+++以下内容为类方法class_method()的运行结果:
是类<class '__main__.Foo'>的类方法,可以被实例对象、类对象调用
调用了静态方法 static_method_test()
"""

  从案例1中得到,类方法与静态方法可以相互调用,但是静态方法只能用【类名】表示,而类方法用【cls】就比较方便了。

案例2:实例方法、类方法、静态方法在继承中(子类重写父类中的方法)的使用

class Foo(object):
X = 1
Y = 14 @staticmethod
def average(*mixes):
print("父类中的静态方法 average(*mixes)")
print("*****", mixes)
return sum(mixes) / len(mixes) @staticmethod
def static_method():
print("父类中的静态方法 static_method()")
return Foo.average(Foo.X, Foo.Y) # 注:因为这儿已经限定了只允许调用父类中的average() @classmethod
def class_method(cls): # 父类中的类方法
print("父类中的类方法 class_method(cls)")
return cls.average(cls.X, cls.Y) # 注:若用子类对象调用该函数,此时的cls==Son,故调用子类重写后的average() class Son(Foo):
@staticmethod
def average(*mixes): # "子类中重载了父类的静态方法"
print("子类中重载了父类的静态方法 average(*mixes)")
print("*****", mixes)
return sum(mixes) / len(mixes) print(Son.average(1, 2, 3), "\n" + "---" * 20)
print(Son.class_method(), "\n" + "---" * 20)
print(Son.static_method(), "\n" + "---" * 20) """
运行结果:
------------------------------------------------------------
子类中重载了父类的静态方法 average(*mixes)
***** (1, 2, 3)
2.0
------------------------------------------------------------
父类中的类方法 class_method(cls)
子类中重载了父类的静态方法 average(*mixes)
***** (1, 14)
7.5
------------------------------------------------------------
父类中的静态方法 static_method()
父类中的静态方法 average(*mixes)
***** (1, 14)
7.5
------------------------------------------------------------
"""

  从案例2中得到,子类对象调用父类中的 类方法 class_method(cls) 时,由于【cls】此时为【Son】,故会执行子类中的类方法、静态方法、静态属性;进一步推断出,类方法中【cls】取决于类方法的调用者,只有发生类方法调用后才能知道执行结果。而父类中静态方法 static_method()只能调用父类中类方法、静态方法、静态属性,与静态方法的调用者无关;进一步推断,静态方法可以提前预知程序的执行结果,如执行当前类中的某个类方法或静态方法。

  对案例2做一个多态测试,添加代码如下:

def test_polymorphic(foo):
"""
多态测试
:param foo: 父类对象
:return: None
"""
print(f.average(1, 2, 3)) f = Foo()
test_polymorphic(f) print("----"*10)
f = Son() # 会触发多态
test_polymorphic(f) """
父类中的静态方法 average(*mixes)
***** (1, 2, 3)
2.0
----------------------------------------
子类中重载了父类的静态方法 average(*mixes)
***** (1, 2, 3)
2.0
"""

  继续做多态测试,添加代码如下:

def test_polymorphic(foo):
"""
多态测试
:param foo: 父类对象
:return: None
"""
print(f.class_method()) f = Foo()
test_polymorphic(f) print("----"*10)
f = Son() # 会触发多态
test_polymorphic(f) """
父类中的类方法 class_method(cls)
父类中的静态方法 average(*mixes)
***** (1, 14)
7.5
----------------------------------------
父类中的类方法 class_method(cls)
子类中重载了父类的静态方法 average(*mixes)
***** (1, 14)
7.5
"""

案例3:使用类方法或静态方法初始化类(可以自定义类的初始方式)

class Book(object):
def __init__(self, title):
self.__title = title @classmethod
def object_create_by_class_method(cls, title_list):
"""
使用生产器实例化多个对象
:param title_list: 每个对象的初始化参数,List
:return:迭代器,每个实例化对象
"""
for title in title_list:
yield cls(title=title) @staticmethod
def object_create_by_static_method(title_list): # 功能与类方法一样
for title in title_list:
yield Book(title=title) @property
def title(self):
return self.__title @title.setter
def title(self, value):
if not isinstance(value, str):
raise TypeError('%s must be str' % value)
self.__title = value @title.deleter
def title(self):
del self.__title
# raise TypeError('Can not delete') books = ["Chinese", "mathematics", "English"]
g_books = Book.object_create_by_class_method(books)
print(g_books) # <generator object Book.object_create_by_class_method at 0x000001FB72AFEEC8> print(g_books.__next__().title) # 查看书的title -- Chinese
print(g_books.__next__().title) # 查看书的title -- mathematics book = g_books.__next__() # 得到一个实例化对象 print(book.title) # 查看书的title -- English
print(book.__dict__) # {'_Book__title': 'English'} book.title = "英语" # 修改属性
print(book.title) # 查看书的title -- 英语
print(book.__dict__) # {'_Book__title': '英语'} del book.title # 删除属性
print(book.__dict__) # {}

  从案例3中得到,使用类方法或者静态方法可以自定义类的初始化方式,本案例中实现的功能是使用生产器批量创建多个对象。同时,案列中使用了【property】属性,property的作用相当于执行了某个函数,并获得该函数的返回值;其使用方式有3种,分别为【@property --- get】、【@函数名.setter --- set】、【@函数名.deleter --- del】,后二种必须在第一种使用的情况下才能使用,在表现形式上就是通过实例化对象间接访问属性。

  最后,我们对案例3做微小改变,来看看实例方法、类方法、静态方法与类、对象之间的关系,代码如下:

class Book(object):
@classmethod
def object_create_by_class_method(cls):
pass @staticmethod
def object_create_by_static_method():
pass def instance_method(self):
pass book = Book()
print(book.instance_method) # 方法(绑定到对象:发生调用时,将【实例对象=self】自动作为第一个参数传入实例方法中)
print(book.object_create_by_class_method) # 方法(绑定到类:发生调用时,将【类=cls】自动作为第一个参数传入类方法中)
print(book.object_create_by_static_method) # 普通函数(非绑定:发生调用时,不需要传入任何参数,如self,cls) print(Book.instance_method) # 普通函数(非绑定,因为实例方法就存储在类的命名空间中)
print(Book.object_create_by_class_method) # 绑定到类
print(Book.object_create_by_static_method) # 普通函数(非绑定)
"""
<bound method Book.instance_method of <__main__.Book object at 0x000002481CEDE988>>
<bound method Book.object_create_by_class_method of <class '__main__.Book'>>
<function Book.object_create_by_static_method at 0x000002481D12C828> <function Book.instance_method at 0x000002481D12C8B8>
<bound method Book.object_create_by_class_method of <class '__main__.Book'>>
<function Book.object_create_by_static_method at 0x000002481D12C828>
"""

  可以发现,

    1)类中的实例方法都绑定了实例对象,故建议使用实例对象调用实例方法;

    2)类中的类方法都绑定了类,故建议使用类对象调用类方法,即使使用实例对象调用类方法,仍然自动将【类名】作为第一个参数传入类方法。

    3)而对于静态方法而言,无论使用实例对象或者类对象调用其方法都不会自动进行参数传递,故不做限制。

    4)若能用类解决的问题,就将类中的方法定义为类方法,这样可以避免实例化对象的开销。

绑定与非绑定的参考链接:

https://www.cnblogs.com/MrYang161/p/11431725.html

http://cda.pinggu.org/view/23514.html

python 类中方法总结 --- 实例方法、类方法、静态方法的更多相关文章

  1. python类中方法加单下划线、双下划线、前后双下滑线的区别

    首先看一段代码: class Foo(): def __init__(self): print "__init__ method" def public_method(self): ...

  2. Python 类中方法的内部变量,命名加&#39;self.&#39;变成 self.xxx 和不加直接 xxx 的区别

    先看两个类的方法: >>> class nc(): def __init__(self): self.name ='tester' #name变量加self >>> ...

  3. python类中方法__str__()和__repr__()简单粗暴总结

    在交互式模式下,类中同时实现__str__()和__repr__()方法: 直接输入实例名称显示repr返回的类容: 用print打印实例名称显示str返回的内容: >>> clas ...

  4. 孤荷凌寒自学python第二十四天python类中隐藏的私有方法探秘

    孤荷凌寒自学python第二十四天python类中隐藏的私有方法探秘 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) 今天发现了python的类中隐藏着一些特殊的私有方法. 这些私有方法不管我 ...

  5. 关于在C#中对类中的隐藏基类方法和重写方法的理解

    最近在学习C#,在C#中的类看到重写和隐藏基类的方法这些概念.才开始感觉自己不是很理解这些概念.也区分不开这些概念.通过自己的查找资料和练习后.慢慢的理解了类中的隐藏和重写这个概念.在C#中只有在基类 ...

  6. python类及其方法

    python类及其方法 一.介绍 在 Python 中,面向对象编程主要有两个主题,就是类和类实例类与实例:类与实例相互关联着:类是对象的定义,而实例是"真正的实物",它存放了类中 ...

  7. Java学习笔记(七)——获取类中方法的信息,java的LinkedList

    [前面的话] 在实际项目中学习知识总是最快和最有效的,既能够较好的掌握知识,又能够做出点东西,还是简单的知识总结,最近一直在总结笔记,写的东西还是比较水,希望慢慢可以写出一些干货. 学习过程中的小知识 ...

  8. Python类中super()和__init__()的关系

    Python类中super()和__init__()的关系 1.单继承时super()和__init__()实现的功能是类似的 class Base(object): def __init__(sel ...

  9. Python类中的self到底是干啥的

    Python类中的self到底是干啥的 Python编写类的时候,每个函数参数第一个参数都是self,一开始我不管它到底是干嘛的,只知道必须要写上.后来对Python渐渐熟悉了一点,再回头看self的 ...

  10. 【转】python类中super()和__init__()的区别

    [转]python类中super()和__init__()的区别 单继承时super()和__init__()实现的功能是类似的 class Base(object): def __init__(se ...

随机推荐

  1. greenplum如何激活,同步,删除standby和恢复原始master

    在Master失效时,同步程序会停止,Standby可以被在本机被激活,激活Standby时,同步日志被用来恢复Master最后一次事务成功提交时的状态.在激活Standby时还可以指定一个新的Sta ...

  2. iOS - Swift SingleClass 单例类

    前言 单例对象能够被整个程序所操作.对于一个单例类,无论初始化单例对象多少次,也只能有一个单例对象存在,并且该对象是全局的,能够被整个系统访问到. 单例类的创建 1.1 单例类的创建 1 单例类的创建 ...

  3. wordpress主题制作结构文件

    下面是WordPress主题文件层次结构,它会告诉你:当WordPress显示特定的页面类型时,会使用哪个模板文件呢?只有了解了以下主题层次结构,你才能知道你的WordPress主题到底需要写哪些文件 ...

  4. zoj 2165

    很简单的DFS搜索水题,递归理解深了很easy的!打了一遍就ac了 #include<stdio.h> ][]; ,n,m; void DFS(int x,int y) { ; ;i< ...

  5. 原生js版分页插件

    之前我在自己的博客里发表了一篇用angularJs自定义指令实现的分页插件,今天简单改造了一下,改成了原生JavaScript版本的分页插件,可以自定义一些简单配置,特此记录下来.如有不足之处,欢迎指 ...

  6. HDU [P1704] Rank

    传递闭包裸题 但是本题的Floyd一定要优化,不然会T cpp #include <iostream> #include <cstdio> #include <cstri ...

  7. hdu 5120(2014北京—求圆相交)

    题意:求环的相交面积 思路: 通过画图可知,面积= 大圆相交面积 - 大小圆相交面积*2 + 小小圆相交面积  再通过圆相交模板计算即可 #include <iostream> #incl ...

  8. 【转】Fundebug上线微信小游戏错误监控!支持自动截屏!

    摘要: Fundebug竭诚为你的小游戏保驾护航. 想必大家都玩过"跳一跳"吧?刷排行榜的感觉是不是很好啊!还有"知乎答题王"呢,在智力上碾压老铁简直太棒了! ...

  9. [Codeforces896C] Willem, Chtholly and Seniorious (ODT-珂朵莉树)

    无聊学了一下珂朵莉树 珂朵莉树好哇,是可以维护区间x次方和查询的高效数据结构. 思想大致就是一个暴力(相对而言)的树形数据结构 lxl毒瘤太强了,发明了ODT算法(Old Driver Tree老司机 ...

  10. Moo University - Financial Aid [POJ2010] [堆]

    题意: 在C头牛里选N头牛,每头牛需要花掉一定经费ai才能得到一定得bi分,在不超过经费F的情况下,使得N头牛的得分中位数最大.(1 <= N <= 19,999,奇数) (N <= ...