精华内容
下载资源
问答
  • 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

    展开全文
  • python中的实例方法、静态方法类方法变量和实例变量浅析
    这篇文章主要介绍了python中的实例方法、静态方法、类方法、类变量和实例变量浅析。。。
    
    一、实例方法

    实例方法就是类的实例能够使用的方法。如下:

    class Foo:
        def __init__(self, name):
            self.name = name
        def hi(self):
            print self.name
    
    if __name__ == '__main__':
        f = Foo('python')
        f.hi()
        print type(f)
        print type(Foo)
        print id(f)
        print id(Foo)
    运行结果为:
    python
    <type 'instance'>
    <type 'classobj'>
    45491424
    8351224
    可以看到,Foo的type为classobj(类对象,python中定义的类本身也是对象),f的type为instance(实例)。
    而hi()是实例方法,所以f.hi()会输出'python'。实例方法的第一个参数默认为self,代指调用该方法的当前实例。
    self不是一个关键字,而是约定的写法。__init__()是生成实例时默认(自动)调用的实例方法。
    也可以将Foo的定义改为以下形式,运行依然正确:

    class Foo:
        def __init__(this, name): #第一个参数写成self,是一种约定的(习惯上的)写法,并不是必须的。写成this也可以。
            this.name = name
        def hi(here): #第一个参数写成self,是一种约定的(习惯上的)写法,并不是必须的。写成here(或其他)也可以。
            print here.name
    
    if __name__ == '__main__':
        f = Foo('python')
        f.hi()
        print type(f)
        print type(Foo)
        print id(f)
        print id(Foo)
    内置函数id用来查看对象的标识符,下面是其doc内容:

    >>> print id.__doc__
    id(object) -> integer
    
    Return the identity of an object.  This is guaranteed to be unique among
    simultaneously existing objects.  (Hint: it's the object's memory address.)
    >>>
    二、静态方法
    静态方法是一种普通函数,就位于类定义的命名空间中,它不会对任何实例类型进行操作。
    使用装饰器@staticmethod定义静态方法。类对象和实例都可以调用静态方法:

    class Foo:
        def __init__(self, name):
            self.name = name
        def hi(self):
            print self.name
        #静态方法属于类,所有实例可以共享
        #静态方法可以(在没有生成实例的时候)通过类名直接调用,因此没有self参数
        @staticmethod
        def add(a, b):
            print a + b
    
    if __name__ == '__main__':
        Foo.add(1, 2)#通过类名直接调用静态方法
        f=Foo('python')
        f.hi()
        f.add(1,2)   #通过实例调用静态方法
    运行结果如下:
    3
    python
    3
    注意,很多编程语言不允许实例调用静态方法。python可以!!!
    三、类方法
    类方法是将类本身作为对象进行操作的方法。类方法使用@classmethod装饰器定义,其第一个参数是类,约定写为cls。
    类对象和实例都可以调用类方法:
    class Foo:
        name = 'python!'#类属性,可以通过类名直接访问
        #使用@classmethod装饰器定义类方法,其第一个参数是类,约定写为cls
        @classmethod
        def hi(cls, x):
            print cls.name * x
    
    if __name__ == '__main__':
        f=Foo()
        f.hi(2)   #通过实例调用类方法
        Foo.hi(3) #通过类名调用类方法
    运行结果如下:
    python!python!
    python!python!python!
    注意,很多其他的编程语言不允许实例调用类方法。python可以!!!
    四、super
    super用来执行父类中的函数,例如:

    class Foo(object):
        def hi(self):
            print 'hi,Foo'
    
    class Foo2(Foo):
        def hi(self):
            super(Foo2,self).hi()
            print 'hi,Foo2'
    
    if __name__ == '__main__':
        f2 = Foo2()
        f2.hi()
    运行结果:
    hi,Foo
    hi,Foo2
    注意,Foo类必须继承某个类(并且这个继承链开始于object类!!!),如果改成下面的形式,就会报错:

    class Foo: #此处应该继承object类
        def hi(self):
            print 'hi,Foo'
    
    class Foo2(Foo):
        def hi(self):
            super(Foo2, self).hi() #通过super来调用父类中的方法,要求继承链开始于object类,否则报错:TypeError
    
    if __name__ == '__main__':
        f2 = Foo2()
        f2.hi()
    五、类变量和实例变量
    类变量定义在类的定义之后,实例变量则是以为self.开头。例如:

    class Foo(object):
        val = 0 #类变量
        def __init__(self):
            self.val = 1 #实例变量
    
    if __name__ == '__main__':
        f= Foo()
        print f.val    # 1
        print Foo.val  # 0
    实例也能够访问类变量,如下:

    class Foo(object):
        val = 0 #类变量。当实例自己没有val变量,却硬要访问val时,实际上访问的是类的val变量
        def __init__(self):#生成实例时,实例自身并没有val变量
            pass
    if __name__ == '__main__':
        f = Foo()
        print f.val   # 0  访问的实际上是类的val变量
        print Foo.val # 0
    另外,可以通过以下方式访问类变量:

    class Foo(object):
        val = 3 #类变量
        def __init__(self,x):
            print 'Foo.__init__ is called!'
            self.val=x
    if __name__ == '__main__':
        f = Foo(10)
        print f.__class__     #查看实例f所属的类
        print f.__class__.val #查看类变量val
        print Foo.val         #查看类变量val
    运行结果:
    Foo.__init__ is called!
    <class '__main__.Foo'>
    3
    3
    还可以这样访问类变量:

    class Foo(object):
        val = 3 #类变量,可以通过类名直接访问
        def __init__(self):
            pass
        #定义类方法,可以通过类名直接调用
        @classmethod
        def echo(cls):
            print cls.val
    if __name__ == '__main__':
        Foo.echo()  # 3
    六、如何调用父类的构造函数
    子类(派生类)并不会自动调用父类(基类)的__init__方法,例如:
    class Foo(object):
        def __init__(self):
            self.val = 1
    
    class Foo2(Foo):
        def __init__(self):
            print self.val #报错 AttributeError: 'Foo2' object has no attribute 'val'
    
    if __name__ == '__main__':
        f2 = Foo2()
    调用父类的init方法有两种,第一种:

    class Foo(object):#也可以不继承object
        def __init__(self):
            self.val = 1
    
    class Foo2(Foo):
        def __init__(self):
            Foo.__init__(self)#通过该方法调用父类的__init__方法,并不要求继承链开始于object类
            print self.val
    
    if __name__ == '__main__':
        f2 = Foo2()
    第二种:

    class Foo(object):#继承链必须开始于object类(新式类)
        def __init__(self):
            self.val = 1
    
    class Foo2(Foo):
        def __init__(self):
            super(Foo2,self).__init__()#通过super调用父类的方法,要求继承链必须开始于object类
            print self.val
    
    if __name__ == '__main__':
        f2 = Foo2()
    上述两种方法的运行结果均为:1


     原文链接:http://www.jb51.net/article/49402.htm


    展开全文
  • 第7.14节 Python类中的实例方法详析

    千次阅读 多人点赞 2019-06-16 19:30:32
    第7.14节 Python类中的实例方法详析 一、 实例方法的定义 在本章前面章节已经介绍了实例方法实例方法的定义有三种方式: 1. 体中定义实例方法 第一种方式很简单,就是在体中定义,所有在中定义的方法...

    第7.14节 Python类中的实例方法详析

    一、    实例方法的定义
    在本章前面章节已经介绍了类的实例方法,实例方法的定义有三种方式:
    1.    类体中定义实例方法
    第一种方式很简单,就是在类体中定义,所有在类中定义的方法默认是实例方法。定义实例方法与定义函数基本相同,只是Python要求实例方法的第一个形参必须为self,也就是实例对象本身,因此实例方法至少应该有一个self参数。关于self的说明,请大家参考老猿前面的章节7.5 揭开Python类中self的面纱。如下例子:

    class MethodTest():
        def method1(self):print("in method1")

    2.    在类体外将一个函数直接赋值给一个对象实例
    Python 是动态语言,允许为对象动态增加方法,相关步骤如下:
    1)    按照实例方法定义形式在类体外定义一个函数,函数需要将self作为第一个参数;
    2)    使用“实例对象名.方法名=函数”方式在实例中增加方法。
    老猿认为,这种动态定义实例方法,本质上就是动态增加实例变量,只是这个实例变量比较特殊,是个函数类型,对应的赋值也是一个函数。因此上述方法定义的实例方法,与类体中定义的方法还是有差别的,对这种方法Python 不会将实例对象自动绑定到方法的第一个参数,即使将第一个参数命名为 self 也没有用。
    3.    在类体外将一个函数绑定到对象实例
    这种方法与第二种方法本质上是一致的,只是能解决调用时无法自动将实例对象作为第一个实参处理的问题。具体绑定方法如下:
    1)    按照实例方法定义形式在类体外定义一个函数,函数需要将self作为第一个参数;
    2)    使用“实例对象名.方法名 = MethodType(函数, 对象)” 方式在实例中增加方法。
    其中MethodType是从Python的types模块import进来的,通过MethodType可以将函数与实例对象的某个方法进行绑定,调用时就无需再传递实例对象到第一个参数。

    上述第二种和第三种方法都是动态方法,绑定的“实例对象名.方法名”可以是一个已经存在的实例方法,也可以是新定义的一个属性方法,如果是一个已经存在的实例方法,新绑定的函数将替换原实例的方法。

    二、    实例方法的使用
    1.    实例方法可以在类体的实例方法内调用,此时调用方使用“self.方法”方式调用,并在调用传递实参时不需要使用self。请看如下类的定义和调用:

    class MethodTest():
        def method1(self):print("in method1")
        def method2(self):
            print("in method2")
            self.method1()

    上述代码中method2调用了方法method1,使用self方式调用。
    2.    在类体外面调用类体内直接定义的实例方法,直接用“实例名.方法名”方式调用,对于类体内定义的实例方法传实参时无需传递self形参对应的实参,由Python在编译时自动添加实例对象作为第一个实参。请看上面的类定义实例对象后调用method2:

    m1=MethodTest()
    m1.method2()

    上述样例代码执行截图:

    注意:在类外调用实例方法时,无需也不能传递self的实参,由Python解释器自动为其在后面执行时添加。如果定义的方法没有以类方法的方式定义,也没有在方法定义时将self作为第一个形参,编译时并不会报错,但调用该实例方法时会有运行时错误,因为Python会强行绑定实例对象作为第一个参数,因此调用者的实参与定义的形参是一样时,此时会多出一个实参self,导致执行时报参数个数不对的错误。
    3.    在类体外面调用通过函数直接赋值定义的实例方法时,其调用方式与类体内定义的模式不同,要求第一个实参必须是调用的对象本身;
    以上面的类MethodTest为例,如果要增加一个method3的实例方法,其代码如下:

    def dynamicmethond(self):print("in DynamicMethond")
    m1.method3=dynamicmethond

    这样m1这个实例就增加了一个method3方法,调用代码如下:
    m1.method3(m1)  #注意必须在第一个参数将实例自身传递进去

    4.    在类体外面调用通过MethodType绑定的实例方法时,其调用方式与类体内定义的模式相同,第一个形参self对应的实参无需传值,由Python自动添加对应的实例对象;
    以上面的类MethodTest为例,如果要增加一个method4的实例方法进行绑定,其代码如下:

    def dynamicmethond(self):print("in DynamicMethond")
    m1.method4= MethodType(dynamicmethond,m1)

    这样m1这个实例就增加了一个method4方法,且实现了方法与实例的绑定,调用代码如下:

    m1.method4()

    三、    构造方法
    之所以单独介绍构造方法,是因为构造方法是一个特殊的实例方法,具体特殊性包括如下:
    1.    Python的构造方法对所有自定义类名字都固定为__init__,且第一个参数必须为self;
    2.    可以允许开发者没有在类中定义构造方法,此时Python 会自动为该类定义一个只包含一个 self 参数的默认的构造方法;
    3.    构造方法如果有多个形参,除了第一个参数必须是self外,其他参数都是创建实例时在类名后面的括号中给出,也就构造方法的参数就是创建实例时传入的参数,也必须是创建实例时传入;
    4.    构造方法是每个实例定义时自动执行;
    5.    在子类重写构造方法时,必须调用超类(继承的类)的构造方法,否则可能无法正确地初始化对象。
    1)    Python3中所有类都继承于object类,构造函数的重写不用考虑object类的情况,即无需调用object类的构造函数;
    2)    在构造方法中调用父类的构造方法时,可以使用“父类.类名.__init__(self,其他参数)”的方式调用;
    3)    在构造方法中调用父类的构造方法时,可以使用“super().__init__ (参数)”的方式调用,注意此时的参数中不能传递self参数。但这种情况如果存在多个超类时,执行的是第一个超类的构造方法,其实参必须按照第一个超类构造方法的形参来传递,其他超类的构造方法必须通过“父类.类名.__init__(self,其他参数)”的方式调用。
    理解了这几点,结合其他语言的构造方法,就理解了Python的构造方法。

    四、    本节相关代码的完整执行截屏

    本节结合案例详细介绍了实例方法的定义和使用方法,需要注意,动态定义实例方法只影响单个实例自身,对其他实例没有影响。老猿认为动态定义实例方法的使用范围比较有限,如果可能尽量使用类体定义实例方法,仅在特定场景(如动态扩展功能)下使用动态实例方法。
    老猿Python(https://blog.csdn.net/LaoYuanPython)系列文章用于逐步介绍老猿学习Python后总结的学习经验,这些经验有助于没有接触过Python的程序员可以很容易地进入Python的世界。
    欢迎大家批评指正,谢谢大家关注!

    展开全文
  • 主要介绍了Python实例方法类方法、静态方法的区别与作用,结合实例形式分析了Python面向对象程序设计中实例方法类方法、静态方法的概念、原理、用法及相关操作技巧,需要的朋友可以参考下
  • 怀着万分的羞耻悲愤之情写下这篇博客。下午考了一套笔试,编程题怎么也通不过,代码逻辑应该是没有问题的,由于不允许使用本地IDE没报错信息一直没发现问题所在。 刚刚把代码再写了一遍,我做题时候用的是python...
  • 实例方法类方法,静态方法及普通方法的调用方法区别 结论 1. instance创建时包含隐藏参数self,cls.因此调用时对四种method皆可直接调用; 2. class创建时包含隐藏参数cls.无self. 因此调用instance_method时需要...
  • 我们知道在python里面可以定义三种类型的方法: class A(object): # 实例方法  def foo(self,x): print "executing foo(%s,%s)"%(self,x) # 类方法 @classmethod def class_foo(cls,x): print "executi
  • Python-对象方法和类实例对象方法

    千次阅读 2018-06-05 13:33:26
    自己总结python类对象方法和类实例对象方法,其判断的方法是: (1)首先看方法定义是否引用了self,带了self,肯定为实例对象方法。 (2)其次,看是否带参数,如果不带参数,肯定是对象方法。 (3)除了...
  • python类方法实例方法,静态方法的作用区别 Python中至少有三种比较常见的方法类型,即实例方法类方法、静态方法。它们是如何定义的呢?如何调用的呢?它们又有何区别作用呢?且看下文。 首先,这三种...
  • Python类变量和实例变量区别

    万次阅读 2014-03-11 14:43:13
    深入理解python类实例变量和类变量 Python变量的本质:被赋值 1 普通python变量(非类相关变量)很容易理解,在被赋值后即变量存在,可读可写 2 Python类的变量(变量和实例对象变量)以某种方式在某地方被赋值...
  • Python——类和实例

    千次阅读 2018-08-22 23:44:05
    Python中,定义是通过class关键字。 语法格式如下: class ClassName(object):  &lt;statement-1&gt;  .  &lt;statement-N&gt; class后面紧接着是类名,类名通常是大写开头的单词,紧...
  • python实例方法和销毁方法

    千次阅读 2020-08-07 09:09:10
    实例方法是在 实例化的时候调用的,而销毁方法是在实例对象删除之后调用的 >>> class c: def __init__(self): print("我是实例方法,我被调用了") def __del__(self): print("我是销毁方法,...
  • classmethod类方法 1) 在python中.类方法 @classmethod 是一个函数...2) 普通对象方法至少需要一个self参数,代表对象实例3)类方法变量cls传入,从而可以用cls做一些相关的处理。并且有子类继承时,调用该...
  • Python-实例方法静态方法类方法对比总结

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

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

    万次阅读 多人点赞 2018-07-03 10:45:22
    定义 class Person(): pass 创建实例 xiaoming = Person() xiaohong = Person() 实例属性 xiaoming = Person() xiaoming.name = xiaoming xiaoming.age = 24 xiaoming.sex = man xiaohong = Person() ...
  • Python类调用实例方法

    千次阅读 2019-07-08 11:29:56
    前面讲过,在 Python体中定义的方法默认都是实例方法,也示范了通过对象来调用实例方法。 但要提醒大家的是,Python在很大程度上是一个命名空间,当程序在体中定义变量、方法时,与前面介绍的定义...
  • python类对象和实例对象

    千次阅读 2019-04-22 15:00:56
    对象支持两种操作:属性引用和实例化。 属性引用 使用 Python 中所有属性引用所使用的标准语法: obj.name。 有效的属性名称是对象被创建时存在于命名空间中的所有名称。 因此,如果定义是这样的: """A ...
  • Python实例方法之间的关系

    千次阅读 多人点赞 2016-10-14 11:19:56
    的功能有一个更为通俗的名字就是方法,在Python中,方法定义在的定义中,但是只能被实例所调用,调用一个方法的最终途径必须是这样的:(1)定义类和类中的方法(2)创建一个实例或者说将类实例化(3)最后用这...
  • python类变量在继承中取值方法如下: 1,如果一个变量的名字在当前中没有,将搜索父类直到被引用的变量名被找到,多继承时会按照继承顺序依次找,如果一直到最顶级都没有找到,会引发一个 AttributeError 异常 。 ...
  • 从简,不浪费时间,直接用例子讲解: ... def kkk(self,x): #实例方法类和实例都能访问 print(self,x) @classmethod #加上这句后 classKkk就成为了类方法类和实例都可以访问, def classKkk(cls,x):
  • python 定义和实例化使用

    千次阅读 2017-11-13 08:09:55
    单方面的记录一下简单的python类对象创建和实例化 0x00代码 # coding=utf-8 class Student(object): #构造函数 def __init__(self, _name, _age): #self 类似this指针 # self.name 定义属性 self.name...
  • 实例方法顾名思义就是实例对象调用的方法,是最普遍最常用的中的方法: class animal(object): def __init__(self): pass def talk(self): print(&amp;quot;in animal talk&amp;quot;) dog=animal...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 561,909
精华内容 224,763
关键字:

python类方法和实例方法

python 订阅