精华内容
下载资源
问答
  • 实例方法

    千次阅读 2018-08-29 08:03:02
    实例方法(method) 实例方法 * 语法: class 类名(继承列表): def 实例方法名(self, 形参名1,形参名2,....): '方法文档字符串' 语句块 作用: 用于描述一个对象的行为,让此类型的全部对象都拥有相同...

    实例方法(method)

    实例方法
    * 语法:

    class 类名(继承列表):
        def 实例方法名(self, 形参名1,形参名2,....):
            '方法文档字符串'
            语句块
    • 作用:
      用于描述一个对象的行为,让此类型的全部对象都拥有相同的行为
      *说明:
      实例方法的是指是函数,是定义在类内的函数
      实例方法至少有一个形参,第一个形参用来绑定调用这个方法的实例,一般命名’self’

    • 实例方法的调用语句:
      实例.实例方法名(调用传参)

      类名.实例方法名(实例.调用传参)
      实例见:

    # 此实例示意实例方法的定义和调用
    class Dog:
        '''创建一个Dog类, 此类用于描述一种
        小狗的行为和属性'''
    
        def eat(self, food):
            '''此方法用来描述狗吃东西的行为'''
            print('id为', id(self), '的小狗正在吃', food)
    
        def sleep(self, hour):
            '''此方法用来描述小狗睡觉的行为'''
            print('小狗睡了', hour, '小时')
    
        def play(self, obj):
            '''此方法描述小狗玩东西的行为'''
            print('小狗在玩', obj)
    
    
    # print(Dog)
    dog1 = Dog()  # 这是创建Dog类的一个实例,对象
    dog1.eat('骨头')
    dog1.sleep(1)
    dog1.play('ball')
    
    dog2 = Dog()  # 这是创建Dog类的第二个对象,第二只狗
    dog2.eat('狗粮')
    dog2.sleep(3)
    dog2.play('飞盘')
    展开全文
  • Python 实例方法、类方法和静态方法

    万次阅读 多人点赞 2018-03-30 20:17:19
    在 Python 中,实例方法(instance method),类方法(class method)与静态方法(static method)经常容易混淆。本文通过代码例子来说明它们的区别。 实例方法 Python 的实例方法用得最多,也最常见。我们先来...

    在 Python 中,实例方法(instance method),类方法(class method)与静态方法(static method)经常容易混淆。本文通过代码例子来说明它们的区别。

    实例方法

    Python 的实例方法用得最多,也最常见。我们先来看 Python 的实例方法。

    class Kls(object):
        def __init__(self, data):
            self.data = data
    
        def printd(self):
            print(self.data)
    
    
    ik1 = Kls('leo')
    ik2 = Kls('lee')
    
    ik1.printd()
    ik2.printd()

    输出:

    leo
    lee

    上述例子中,printd为一个实例方法。实例方法第一个参数为self,当使用ik1.printd()调用实例方法时,实例ik1会传递给self参数,这样self参数就可以引用当前正在调用实例方法的实例。利用实例方法的这个特性,上述代码正确输出了两个实例的成员数据。

    类方法

    Python 的类方法采用装饰器@classmethod来定义,我们直接看例子。

    class Kls(object):
        num_inst = 0
    
        def __init__(self):
            Kls.num_inst = Kls.num_inst + 1
    
        @classmethod
        def get_no_of_instance(cls):
            return cls.num_inst
    
    
    ik1 = Kls()
    ik2 = Kls()
    
    print ik1.get_no_of_instance()
    print Kls.get_no_of_instance()

    输出:

    2
    2

    在上述例子中,我们需要统计类Kls实例的个数,因此定义了一个类变量num_inst来存放实例个数。通过装饰器@classmethod的使用,方法get_no_of_instance被定义成一个类方法。在调用类方法时,Python 会将类(class Kls)传递给cls,这样在get_no_of_instance内部就可以引用类变量num_inst
    由于在调用类方法时,只需要将类型本身传递给类方法,因此,既可以通过类也可以通过实例来调用类方法。

    静态方法

    在开发中,我们常常需要定义一些方法,这些方法跟类有关,但在实现时并不需要引用类或者实例,例如,设置环境变量,修改另一个类的变量,等。这个时候,我们可以使用静态方法。
    Python 使用装饰器@staticmethod来定义一个静态方法。

    IND = 'ON'
    
    
    class Kls(object):
        def __init__(self, data):
            self.data = data
    
        @staticmethod
        def checkind():
            return IND == 'ON'
    
        def do_reset(self):
            if self.checkind():
                print('Reset done for: %s' % self.data)
    
        def set_db(self):
            if self.checkind():
                print('DB connection made for: %s' % self.data)
    
    
    ik1 = Kls(24)
    ik1.do_reset()
    ik1.set_db()

    输出:

    Reset done for: 24
    DB connection made for: 24

    在代码中,我们定义了一个全局变量IND,由于IND跟类Kls相关,所以我们将方法checkind放置在类Kls中定义。方法checkind只需检查IND的值,而不需要引用类或者实例,因此,我们将方法checkind定义为静态方法。
    对于静态方法,Python 并不需要传递类或者实例,因此,既可以使用类也可以使用实例来调用静态方法。

    实例方法,类方法与静态方法的区别

    我们用代码说明实例方法,类方法,静态方法的区别。注意下述代码中方法fooclass_foostatic_foo的定义以及使用。

    class Kls(object):
        def foo(self, x):
            print('executing foo(%s,%s)' % (self, x))
    
        @classmethod
        def class_foo(cls,x):
            print('executing class_foo(%s,%s)' % (cls,x))
    
        @staticmethod
        def static_foo(x):
            print('executing static_foo(%s)' % x)
    
    
    ik = Kls()
    
    # 实例方法
    ik.foo(1)
    print(ik.foo)
    print('==========================================')
    
    # 类方法
    ik.class_foo(1)
    Kls.class_foo(1)
    print(ik.class_foo)
    print('==========================================')
    
    # 静态方法
    ik.static_foo(1)
    Kls.static_foo('hi')
    print(ik.static_foo)

    输出:

    executing foo(<__main__.Kls object at 0x0551E190>,1)
    <bound method Kls.foo of <__main__.Kls object at 0x0551E190>>
    ==========================================
    executing class_foo(<class '__main__.Kls'>,1)
    executing class_foo(<class '__main__.Kls'>,1)
    <bound method type.class_foo of <class '__main__.Kls'>>
    ==========================================
    executing static_foo(1)
    executing static_foo(hi)
    <function static_foo at 0x055238B0>

    对于实例方法,调用时会把实例ik作为第一个参数传递给self参数。因此,调用ik.foo(1)时输出了实例ik的地址。

    对于类方法,调用时会把类Kls作为第一个参数传递给cls参数。因此,调用ik.class_foo(1)时输出了Kls类型信息。
    前面提到,可以通过类也可以通过实例来调用类方法,在上述代码中,我们再一次进行了验证。

    对于静态方法,调用时并不需要传递类或者实例。其实,静态方法很像我们在类外定义的函数,只不过静态方法可以通过类或者实例来调用而已。

    值得注意的是,在上述例子中,foo只是个函数,但当调用ik.foo的时候我们得到的是一个已经跟实例ik绑定的函数。调用foo时需要两个参数,但调用ik.foo时只需要一个参数。fooik进行了绑定,因此,当我们打印ik.foo时,会看到以下输出:

    <bound method Kls.foo of <__main__.Kls object at 0x0551E190>>

    当调用ik.class_foo时,由于class_foo是类方法,因此,class_fooKls进行了绑定(而不是跟ik绑定)。当我们打印ik.class_foo时,输出:

    <bound method type.class_foo of <class '__main__.Kls'>>

    当调用ik.static_foo时,静态方法并不会与类或者实例绑定,因此,打印ik.static_foo(或者Kls.static_foo)时输出:

    <function static_foo at 0x055238B0>

    概括来说,是否与类或者实例进行绑定,这就是实例方法,类方法,静态方法的区别。

    参考资料

    1. https://www.pythoncentral.io/difference-between-staticmethod-and-classmethod-in-python/
    2. https://taizilongxu.gitbooks.io/stackoverflow-about-python/content/14/README.html
    3. https://kuanghy.github.io/2015/12/19/python-variable
    4. https://stackoverflow.com/questions/136097/what-is-the-difference-between-staticmethod-and-classmethod-in-python
    展开全文
  • python类的实例方法、静态方法和类方法区别及其应用场景 一、先看语法,python 类语法中有三种方法,实例方法,静态方法,类方法。 ps.python中self,cls的区别 普通实例方法,第一个参数需要是self,它表示一...

    python类的实例方法、静态方法和类方法区别及其应用场景

    一、先看语法,python 类语法中有三种方法,实例方法,静态方法,类方法。

     

    ps.python中self,cls的区别

    普通实例方法,第一个参数需要是self,它表示一个具体的实例本身。
    如果用了staticmethod,那么就可以无视这个self,而将这个方法当成一个普通的函数使用。
    而对于classmethod,它的第一个参数不是self,是cls,它表示这个类本身。

    # coding:utf-8
    class Foo(object):
        """类三种方法语法形式"""
    
        def instance_method(self):
            print("是类{}的实例方法,只能被实例对象调用".format(Foo))
    
        @staticmethod
        def static_method():
            print("是静态方法")
    
        @classmethod
        def class_method(cls):
            print("是类方法")
    
    foo = Foo()
    foo.instance_method()
    foo.static_method()
    foo.class_method()
    print('----------------')
    Foo.static_method()
    Foo.class_method()

    运行结果如下

    是类<class '__main__.Foo'>的实例方法,只能被实例对象调用
    是静态方法
    是类方法
    ----------------
    是静态方法
    是类方法

    说明:

    实例方法只能被实例对象调用,静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法),可以被类或类的实例对象调用。

    实例方法,第一个参数必须要默认传实例对象,一般习惯用self。
    静态方法,参数没有要求。

    类方法,第一个参数必须要默认传类,一般习惯用cls。

    二、静态方法、类方法使用区别或者说使用场景

     

    1、类方法用在模拟java定义多个构造函数的情况。

     由于python类中只能有一个初始化方法,不能按照不同的情况初始化类。

    参考django https://docs.djangoproject.com/en/1.9/ref/models/instances/ 请看下面的代码。

    # coding:utf-8
    class Book(object):
    
        def __init__(self, title):
            self.title = title
    
        @classmethod
        def class_method_create(cls, title):
            book = cls(title=title)
            return book
    
        @staticmethod
        def static_method_create(title):
            book= Book(title)
            return book
    
    book1 = Book("use instance_method_create book instance")
    book2 = Book.class_method_create("use class_method_create book instance")
    book3 = Book.static_method_create("use static_method_create book instance")
    print(book1.title)
    print(book2.title)
    print(book3.title)

    结果:

    use instance_method_create book instance
    use class_method_create book instance
    use static_method_create book instance
    
    Process finished with exit code 0

    特别说明,静态方法也可以实现上面功能,当静态方法每次都要写上类的名字,不方便。

    2、类中静态方法方法调用静态方法和类方法调用静态方法例子。
    下面的代码,静态方法调用另一个静态方法,如果改用类方法调用静态方法,可以让cls代替类,

    让代码看起来精简一些。也防止类名修改了,不用在类定义中修改原来的类名。

    # coding:utf-8
    class Foo(object):
        X = 1
        Y = 2
    
        @staticmethod
        def averag(*mixes):
            return sum(mixes) / len(mixes)
    
        @staticmethod
        def static_method():  # 在静态方法中调用静态方法
            print "在静态方法中调用静态方法"
            return Foo.averag(Foo.X, Foo.Y)
    
        @classmethod
        def class_method(cls):  # 在类方法中使用静态方法
            print "在类方法中使用静态方法"
            return cls.averag(cls.X, cls.Y)
    
    foo = Foo()
    print(foo.static_method())
    print(foo.class_method())

    结果:

    在静态方法中调用静态方法
    1
    在类方法中使用静态方法
    1

    3、继承类中的区别 

    从下面代码可以看出,如果子类继承父类的方法,子类覆盖了父类的静态方法,
    子类的实例继承了父类的static_method静态方法,调用该方法,还是调用的父类的方法和类属性。

    子类的实例继承了父类的class_method类方法,调用该方法,调用的是子类的方法和子类的类属性。

    # coding:utf-8
    class Foo(object):
        X = 1
        Y = 14
    
        @staticmethod
        def averag(*mixes):  # "父类中的静态方法"
            return sum(mixes) / len(mixes)
    
        @staticmethod
        def static_method():  # "父类中的静态方法"
            print "父类中的静态方法"
            return Foo.averag(Foo.X, Foo.Y)
    
        @classmethod
        def class_method(cls):  # 父类中的类方法
            print "父类中的类方法"
            return cls.averag(cls.X, cls.Y)
    
    
    class Son(Foo):
        X = 3
        Y = 5
    
        @staticmethod
        def averag(*mixes):  # "子类中重载了父类的静态方法"
            print "子类中重载了父类的静态方法"
            print "666 ",mixes
            return sum(mixes) / 3
    
    p = Son()
    print "result of p.averag(1,5)"
    print (p.averag(1,5))
    print "result of p.static_method()"
    print(p.static_method())
    print "result of p.class_method()"
    print(p.class_method())

    结果如下:

    result of p.averag(1,5)
    子类中重载了父类的静态方法
    666  (1, 5)
    2
    result of p.static_method()
    父类中的静态方法
    7
    result of p.class_method()
    父类中的类方法
    子类中重载了父类的静态方法
    666  (3, 5)
    2

    Process finished with exit code 0

    参考网址:https://zhuanlan.zhihu.com/p/21101992

    展开全文
  • 实例方法、类方法、构造方法

    千次阅读 多人点赞 2019-11-19 14:11:00
    Java中类的方法分为类方法(用static修饰,也叫静态方法)和实例方法(没有用static修饰,也叫非静态方法) 实例方法,就是一般的方法 类方法,有static修饰符,典型的主函数 构造方法,没有返回值(就是连void都没有...

    Java中类的方法分为类方法(用static修饰,也叫静态方法)和实例方法(没有用static修饰,也叫非静态方法)
    实例方法,就是一般的方法
    类方法,有static修饰符,典型的主函数
    构造方法,没有返回值(就是连void都没有),方法名与类名一样

    public static void myMethod();//类方法
    public void myMethod2();//实例方法
    public Test(){}//构造方法,没有返回值,方法名与类名一样
    

    实例方法与类方法的区别:

    1、类方法是属于整个类,而不属于某个对象。
    2、类方法只能访问类成员变量,不能访问实例变量,而实例方法可以访问类成员变量和实例变量。
    3、在类方法中不能使用super、this关键字。
    4、类方法的调用可以通过类名.类方法和对象.类方法,而实例方法只能通过对象.实例方法访问。
    5、类方法只能访问类方法,而实例方法可以访问类方法和实例方法。
    6、类方法不能被覆盖,实例方法可以被覆盖。
    
    1. 构造方法—构造方法负责对象的初始化工作,为实例变量赋予合适的初始值。必须满足以下的语法规则:
    1、方法名与类名相同;
    2、不要返回类型(例如return、void等);
    3、不能被static、final、native、abstract和synchronized修饰,不能被子类继承
    

    1.1. 默认构造方法—默认构造方法时没有参数的构造方法,分为

    a.隐含的默认构造方法:public ClassName(){}
    b.程序显示定义默认构造方法:public Employee(){this("无名氏");}
    

    1.2. 重载构造方法—通过new创建一个对象后,在不同的条件下,对象可能会有不同的初始化行为,可以通过重载构造方法来表达对象的初始化行为。具体参考this关键字的用法。
    1.3. 子类调用父类的构造方法—父类的构造方法不能被子类调用,可以通过super语句调用父类的构造方法。例如:
    在这里插入图片描述
    用super调用父类的构造方法必须遵守以下规则:

    1. 子类的构造方法中不能直接通过父类的方法名调用父类的构造方法,使用super语句;
    2. 加入在子类的构造方法中有super语句,它必须作为构造方法的第一条语句(同this语句);
    

    1.4. 构造方法的作用域

    1、当前类的其他构造方法通过this语句调用;
    2、当前类的子类的构造方法通过super语句调用;
    3、在程序中通过new语句调用。
    

    1.5. 构造方法的private访问级别— 构造方法为private级别时,意味着只能在当前类中访问它:当前类的其他构造方法中可以通过this语句调用,此外还可以在当前类的成员方法中使用new调用。
    以下场合中,可以把类的所有构造方法声明为private:

    1、这个类中仅仅包含一些供其他程序调用的静态方法,没有任何实例方法。
    2、禁止这个类被继承。声明为private后,如果定义了它的子类,子类的方法中无法调用父类的任何构造方法。
    3、类需要把构造自身实例的细节封装起来,不允许其他程序通过new语句创建这个类的实例。提供静态方法。
    
    展开全文
  • Python-实例方法静态方法类方法对比总结

    千次阅读 多人点赞 2018-12-19 14:49:18
    实例方法需要将类实例化后才可以调用,如果使用类直接调用实例方法,需要显示地将实例对象作为参数传入。 **直接用类调用实例方法代码**: class ClassA(): def funcA(self): print('Hello world') #...
  • iOS 类方法与实例方法

    万次阅读 2016-11-08 08:44:46
    静态方法在程序开始时生成内存,实例方法在程序运行中生成内存, 所以静态方法可以直接调用,实例方法要先成生实例,通过实例调用方法,静态速度很快,但是多了会占内存。 静态内存是连续的,因为是在程序开始时就生成...
  • 实例方法、类方法、静态方法

    千次阅读 2020-05-23 15:16:01
    实例方法、静态方法和类方法 示例方法:第一个参数为self,必须实例化之后才能调用的方法 类方法:使用@classmethod进行装饰,第一个参数为cls,可以被类调用,也可以被实例调用。 静态方法:使用@staticmethod进行...
  • Python进阶(十一)-定义实例方法

    万次阅读 2017-03-17 17:09:09
    Python进阶(十一)-定义实例方法  一个实例的私有属性就是以__开头的属性,无法被外部访问。那这些属性定义有什么用?   虽然私有属性无法从外部访问,但是,从类的内部是可以访问的。除了可以定义实例的属性外...
  • java 类方法和实例方法 调用关系

    万次阅读 多人点赞 2018-04-20 23:49:55
    java 类方法和实例方法 1. 类方法 也可称静态方法,使用static修饰的类中方法; 2.实例方法 非静态方法,没有用static修饰的方法。 3.测试案例 public class Test { private int a = 5; private ...
  • Java 基础之实例方法,实例变量,类方法,类变量

    千次阅读 多人点赞 2019-05-18 09:08:17
    实例变量(instance variable) ...实例方法(instance method) 实例方法:或叫成员方法(member method)。供实例用的方法,必须要先有实例,才能通过此实例调用实例方法。 类变量(class variable) 类...
  • 使用对象调用实例方法时,Python会自动绑定方法的第一个参数(通常建议将该参数命名为self)。 根据第一个参数出现位置的不同,第一个参数所绑定的对象略有不同。 —在构造方法中引用该构造方法正在初始化的对象 ...
  • 实例方法(对象方法):不用修饰符static声明的方法为实例方法。 误区: 1.静态方法常驻内存,实例方法不是,所以静态方法效率高但占内存 事实上,方法都是一样的,在加载时机和占用内存上,静态方法和实例方法...
  • C++ 类方法和实例方法辨析

    千次阅读 2017-05-08 10:05:05
    首先明确定义: 类方法:即静态方法(静态成员函数),指的是类中被...但是类方法不能调用实例方法,只能调用其他类方法(非绝对,也可以使用传引用的方法让类方法调用实例方法) 性质2:当类文件加载到内存,实例方
  • Swift 类方法和实例方法

    千次阅读 2015-08-27 14:35:50
    Swift 类方法和实例方法
  • js中实例方法、静态方法和原型方法详解

    千次阅读 多人点赞 2019-05-24 10:57:47
    实例方法 构造函数中this上添加的成员,在Cat构造方法里面,定义在this中的变量和方法,只有实例才能访问到:如this.name,this.move,this.eat这些都是实例拥有,无法通过Cat直接调用。 function Cat(name){ this....
  • 类方法和实例方法区别

    千次阅读 2019-06-15 09:13:50
    Objective-C里面既有实例方法也类方法。类方法(Class Method) 有时被称为工厂方法(Factory Method)或者方便方法(Convenience method)。工厂方法的称谓明显和一般意义上的工厂方法不同,从本质上来说,类方法可以独立...
  • java中实例方法 静态方法 实例变量 静态变量之间的关系问题 静态变量可以方法静态方法 实例变量可以访问静态方法 实例变量可以访问实例方法 以上说法对么
  • 静态方法与实例方法的区别

    千次阅读 2018-12-21 10:27:36
    静态方法与实例方法的区别 1、静态方法属于整个类所有,因此调用它不需要实例化,可以直接调用(类.静态方法())。实例方法必须先实例化,创建一个对象,才能进行调用(对象.实例方法())。 2、静态方法只能访问...
  • #定义一个类a ... #定义一个实例方法,并给与返回值 def A(self): p = self.height return p #定义另一个实例方法,该方法需要方法A中的返回值,则在方法B中这样调用 def B(self): print(a.A(self))
  • C#静态方法和实例方法

    千次阅读 2018-10-13 16:40:44
    1.静态方法: 用修饰符static声明的方法; 注意:(1)不管用类创没创建对象,类的静态方法都可以使用;...注意:实例方法可以使用该方法所在类的所有静态成员和实例成员。 使用格式: 对象名.实例方法名  ...
  • js 对象方法(实例方法) 类方法 原型方法 function Animal() { //实例属性 this.name = name || 'Animal'; //实例方法 this.sleep = function () { console.log(this.name + "正在睡觉") } this....
  • python3:类方法,静态方法和实例方法以及应用场景

    千次阅读 多人点赞 2018-10-20 13:29:52
    1.实例方法 在编程里经常用的是实例方法,直接用实例去调用, 只要 方法里有self 就可以断定是实例方法, 如 def method_name(self,*argc). 先看下边代码如下: class Date: def __init__(self,year,month,day)...
  • java 类方法和实例方法

    万次阅读 多人点赞 2018-03-13 22:55:50
    类方法 用static修饰的方法。 由于类方法是属于整个类的,所以类方法的方法体中不能有与类的对象有关的内容。 即类方法体有如下限制:...实例方法 当一个类创建了一个对象后,这个对象就可以调用该类的方法(...
  • iOS 类方法与实例方法总结

    万次阅读 2017-02-16 11:07:49
    所以静态方法可以直接调用,实例方法要先成生实例,通过实例调用方法,静态速度很快,但是多了会占内存。 静态内存是连续的,因为是在程序开始时就生成了,而实例申请的是离散的空间,所以当然没有静态方法快, 而且...
  • C#中的静态方法与实例方法

    千次阅读 2018-10-18 22:26:37
    一、静态成员,实例成员 在C#中,通俗的讲,用static修饰**的成员我们称之为静态成员,没有经过static修饰的我们称之为...二、静态方法与实例方法 在C#中,用static修饰的方法我们称之为静态方法,没有经过static修...
  • 静态方法和实例方法联系与区别

    千次阅读 2017-01-11 15:24:11
    静态方法与实例方法联系与区别
  • Python实例方法、静态方法与类方法

    千次阅读 2018-09-17 10:07:26
    Python 实例方法、类方法、静态方法的区别与作用 转载自:https://www.cnblogs.com/wcwnina/p/8644892.html Python中至少有三种比较常见的方法类型,即实例方法,类方法、静态方法。它们...
  • Java中的实例方法和类方法

    千次阅读 多人点赞 2019-02-18 17:24:40
    如同类的成员变量有实例变量和类变量两种一样,类的方法也有两种:实例方法和类方法。在方法定义时,冠以修饰字static的方法称为类方法,没有冠以static修饰字的方法是实例方法。 1.类D定义了一个实例方法,两个类...
  • # 实例方法:实例方法可以通过类对象和实例对象来调用,可以访问类属性和类方法,不能访问普通方法和实例属性,可以访问静态方法 # 静态方法:静态方法可以通过类对象和实例对象来调用,可以访问类属性,不...
  • js静态方法和实例方法

    千次阅读 2018-09-04 23:28:35
    实例方法就是定义在 构造函数原型(prototype)上的方法; 面试的时候很多面试官会问:数组有哪些方法。那么我们就拿数组的方法来举例。 静态方法: Array的新方法from/of都是。在控制台输入 Object....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,308,299
精华内容 1,323,319
关键字:

实例方法