精华内容
下载资源
问答
  • 主要介绍了Python 静态方法和类方法,结合实例形式分析了Python类、实例、静态方法等相关概念、原理与使用技巧,需要的朋友可以参考下
  • 类方法和静态方法的区别在于,Python会自动绑定类方法的第一个参数,类方法的第一个参数(通常建议参数名为 cls)会自动绑定到本身;但对于静态方法则不会自动绑定。 使用 @classmethod修饰的方法就是类方法;...

    实际上,Python 完全支持定义类方法,甚至支持定义静态方法。Python 的类方法和静态方法很相似,它们都推荐使用类来调用(其实也可使用对象来调用)。

    类方法和静态方法的区别在于,Python会自动绑定类方法的第一个参数,类方法的第一个参数(通常建议参数名为 cls)会自动绑定到类本身;但对于静态方法则不会自动绑定。

    使用 @classmethod修饰的方法就是类方法;使用@staticmethod修饰的方法就是静态方法。

    下面代码示范了定义类方法和静态方法:

        class Bird:
            # classmethod修饰的方法是类方法
            @classmethod
            def fly (cls):
                print('类方法fly: ', cls)
            # staticmethod修饰的方法是静态方法
            @staticmethod
            def info (p):
                print('静态方法info: ', p)
        # 调用类方法,Bird类会自动绑定到第一个参数
        Bird.fly()  #①
        # 调用静态方法,不会自动绑定,因此程序必须手动绑定第一个参数
        Bird.info('crazyit')
        # 创建Bird对象
        b = Bird()
        # 使用对象调用fly()类方法,其实依然还是使用类调用,
        # 因此第一个参数依然被自动绑定到Bird类
        b.fly()  #②
        # 使用对象调用info()静态方法,其实依然还是使用类调用,
        # 因此程序必须为第一个参数执行绑定
        b.info('fkit')
    

    从上面粗体字代码可以看出,使用@classmethod 修饰的方法是类方法,该类方法定义了一个 cls 参数,该参数会被自动绑定到 Bird 类本身,不管程序是使用类还是对象调用该方法,Python 始终都会将类方法的第一个参数绑定到类本身,如 ① 号、② 号代码的执行效果。

    上面程序还使用@staticmethod定义了一个静态方法,程序同样既可使用类调用静态方法,也可使用对象调用静态方法,不管用哪种方式调用,Python 都不会为静态方法执行自动绑定。

    在使用 Python 编程时,一般不需要使用类方法或静态方法,程序完全可以使用函数来代替类方法或静态方法。但是在特殊的场景(比如使用工厂模式)下,类方法或静态方法也是不错的选择。

    展开全文
  • Python 静态方法和类方法的区别.pdf
  • Python 静态方法和类方法

    千次阅读 2017-06-02 11:33:09
    静态方法我们知道在其他语言中静态方法一般使用static修饰,静态方法的主要特点是不需要new出对象,直接通过类名就可以访问,也可以通过对象访问。...A.staticfunc() # A类方法类方法和静态方法类似,也

    静态方法

    我们知道在其他语言中静态方法一般使用static修饰,静态方法的主要特点是不需要new出对象,直接通过类名就可以访问,也可以通过对象访问。需要使用staticmethod装饰器装饰方法

    举例:

    class A:
        @staticmethod
        def staticfunc():
            print("A")
    A.staticfunc() # A

    类方法

    类方法和静态方法类似,也可以直接通过类名访问,不过要使用classmethod装饰方法,而且参数第一个类本身,为了方便的操作类本身的属性和方法。

    举例:

    class B:
        @classmethod
        def classfunc(cls):
            cls.a = 10
    
    B.classfunc() 
    print(B.a) # 10

    对比

    静态方法和类方法都可以通过类名访问,那直接用静态方法不就好了?举个例子看一下

    class A:
        @staticmethod
        def staticfunc():
            A.a = 10
    A.staticfunc()
    print(A.a)#10
    
    class B:
        @classmethod
        def classfunc(cls):
            cls.b = 20;
    B.classfunc()
    print(B.b)#20

    通过上面的例子我们可以看到静态方法也可以操作类本身,为什么还要在发明一个类方法?上面例子我们观察到,静态方法是通过类名来操作类属性的写死在程序中,而类方法是通过参数来操作类属性的,如果子类继承了使用静态方法的类,那么子类继承的静态方法还是在操作父类,子类需要重新静态方法才能操作子类,类方法如果被继承,那么类参数会传入子类本身。

    展开全文
  • 主要介绍了关于Python静态方法成员的相关资料,文中通过示例代码给大家详细总结了两者在语法使用上的区别,有需要的朋友可以参考借鉴,下面来一起看看吧。
  • 主要介绍了Python实例方法类方法静态方法的区别与作用,结合实例形式分析了Python面向对象程序设计中实例方法类方法静态方法的概念、原理、用法及相关操作技巧,需要的朋友可以参考下
  • 刚接触Python中的面向对象,对于类方法和静态方法难以区分,通过查找知乎、CSDN论坛,废了好大的劲思路才逐渐明朗,所以就总结顺便分享一下。 首先开始编辑代码 # 普通方法类方法静态方法的比较 # 普通方法、...
  • Python进阶之路 静态方法和类方法

    万次阅读 多人点赞 2019-06-18 18:57:00
    Python类包含三种方法:实例方法静态方法和类方法。其中,实例方法在前面的章节已经多次使用了。要想调用实例方法,必须要实例化,然后才可以调用。也就是说,调用实例化方法需要的实例(对象)。而静态方法在...

    静态方法和类方法

    Python类包含三种方法:实例方法、静态方法和类方法。其中,实例方法在前面的章节已经多次使用了。要想调用实例方法,必须要实例化类,然后才可以调用。也就是说,调用实例化方法需要类的实例(对象)。而静态方法在调用时根本不需要类的实例(静态方法不需要self参数),这一点和其他编程语言完全一样。

    类方法的调用方式与静态方法完全一样,所不同的是,类方法与实例方法的定义方式相同,都需要一个self参数,只不过这个self参数的含义不同。对于实例方法来说,这个self参数就代表当前类的实例,可以通过self访问对象中的方法和属性。而类方法的self参数表示类的元数据,也就是类本身,不能通过self参数访问对象中的方法和属性,只能通过这个self参数访问类的静态方法和静态属性。

    定义静态方法需要使用@staticmethod装饰器(decorator),定义类方法需要使用@classmethod装饰器。

    class Myclass:
        # 实例方法
        def instancemethod(self):
            pass
        # 静态方法
        @staticmethod
        def staticmethod():
            pass
        # 类方法
        @classmethod
        def classmethod(self):
            pass
    

    [例 10.9] 本例演示了如何定义实例方法、静态方法和类方法,并演示了如何调用这些方法

    class Myclass:
        # 定义一个静态变量,可以被静态方法和类方法访问
        name = 'Bill'
        def __init__(self):
            print('Myclass的构造方法被调用')
            # 定义实例变量,静态方法和类方法不能访问该变量
            self.value = 20
        # 定义静态方法
        @staticmethod
        def run():
            # 访问Myclass类中的静态变量name
            print('*', Myclass.name, '*')
            print('Myclass的静态方法run被调用')
    
        # 定义类方法
        @classmethod
        # 这里self是类的元数据,不是类的实例
        def do(self):
            print(self)
            # 访问Myclass类中的静态变量name
            print('[', self.name, ']')
            print('调用静态方法run')
            self.run()
            # 在类方法中不能访问实例变量,否则会抛出异常(因为实例变量需要用类的实例访问) print(self.value)
            print('成员方法do被调用')
        # 定义实例方法
        def do1(self):
            print(self.value)
            print('<', self.name, '>')
            print(self)
    # 调用静态方法run
    Myclass.run()
    # 创建Myclass类的实例
    c = Myclass()
    # 通过类的实例也可以调用类方法
    c.do()
    # 通过类访问类的静态变量
    print('Myclass2.name', '=', Myclass.name)
    # 通过类调用类方法
    Myclass.do()
    # 通过类的实例访问实例方法
    c.do1()
    

    输出结果:

    * Bill *
    Myclass的静态方法run被调用
    Myclass的构造方法被调用
    <class '__main__.Myclass'>
    [ Bill ]
    调用静态方法run
    * Bill *
    Myclass的静态方法run被调用
    成员方法do被调用
    Myclass2.name = Bill
    <class '__main__.Myclass'>
    [ Bill ]
    调用静态方法run
    * Bill *
    Myclass的静态方法run被调用
    成员方法do被调用
    20
    < Bill >
    <__main__.Myclass object at 0x10d5bcd30>
    

    从实例方法、静态方法和类方法的调用规则可以得出以下结论:

    通过实例定义的变量只能被实例方法访问,而直接在类中定义的静态变量(如本例的name变量)即可以被实例方法访问,也可以被静态方法和类方法访问。实例方法不能被静态方法和类方法访问,但静态方法和类方法可以被实例方法访问。

    展开全文
  • 何时定义静态方法和类方法:当你的某个函数与其它函数没有任何关系,就可以定义,静态方法和类方法只是为了方便调用,不需要创建实例,直接类名.函数名就可以调用。 静态方法 静态方法所有,可以通过对象来使用...
  • Python静态方法和类方法深度总结

    万次阅读 多人点赞 2017-06-17 22:46:40
    Python静态方法和类方法深度总结

    方法在Python中是如何工作的
    方法就是一个函数,它作为一个类属性而存在,你可以用如下方式来声明、访问一个函数:

    >>> class Pizza(object):
    ...   def __init__(self, size):
    ...     self.size = size
    ...   def get_size(self):
    ...     return self.size
    ...
    >>> Pizza.get_size
    <unbound method Pizza.get_size>

    Python在告诉你,属性get_size是类Pizza的一个未绑定方法。这是什么意思呢?很快我们就会知道答案:

    >>> Pizza.get_size()
    Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
    TypeError: unbound method get_size() must be called with Pizza instance as first argument (got nothing instead)

    我们不能这么调用,因为它还没有绑定到Pizza类的任何实例对象上,它需要一个实例作为第一个参数传递进去(Python2必须是该类的实例,Python3中可以是任何东西),尝试一下:

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

    太棒了,现在用一个实例对象作为它的的第一个参数来调用,整个世界都清静了,如果我说这种调用方式还不是最方便的,你也会这么认为的;没错,现在每次调用这个方法的时候我们都不得不引用这个类,随着代码量的增加,如果忘记了哪个类是我们需要的,会造成程序的混乱,所以长期看来这种方式是行不通的。

    那么Python为我们做了什么呢,它绑定了所有来自类Pizza的方法以及该类的任何一个实例的方法。也就意味着现在属性get_size是Pizza的一个实例对象的绑定方法,这个方法的第一个参数就是该实例本身。

    >>> Pizza(42).get_size
    <bound method Pizza.get_size of <__main__.Pizza object at 0x7f3138827910>>
    >>> Pizza(42).get_size()
    42

    和我们预期的一样,现在不再需要提供任何参数给get_size,因为它已经是绑定的,它的self参数会自动地设置给Pizza实例,下面代码是最好的证明:

    >>> m = Pizza(42).get_size
    >>> m()
    42

    更有甚者,你都没必要使用持有Pizza对象的引用了,因为该方法已经绑定到了这个对象,所以这个方法对它自己来说是已经足够了。
    也许,如果你想知道这个绑定的方法是绑定在哪个对象上,下面这种手段就能得知:

    >>> m = Pizza(42).get_size
    >>> m.__self__
    <__main__.Pizza object at 0x7f3138827910>
    >>> 
    # You could guess, look at this:
    ...
    >>> m == m.__self__.get_size
    True

    显然,该对象仍然有一个引用存在,只要你愿意你还是可以把它找回来。
    在Python3中,依附在类上的函数不再当作是未绑定的方法,而是把它当作一个简单地函数,如果有必要它会绑定到一个对象身上去,原则依然和Python2保持一致,但是模块更简洁:

    >>> class Pizza(object):
    ...   def __init__(self, size):
    ...     self.size = size
    ...   def get_size(self):
    ...     return self.size
    ...
    >>> Pizza.get_size
    <function Pizza.get_size at 0x7f307f984dd0>

    静态方法

    静态方法是一类特殊的方法,有时你可能需要写一个属于这个类的方法,但是这些代码完全不会使用到实例对象本身,例如:

    class Pizza(object):
      @staticmethod
      def mix_ingredients(x, y):
        return x + y
    
      def cook(self):
        return self.mix_ingredients(self.cheese, self.vegetables)

    这个例子中,如果把mix_ingredients作为非静态方法同样可以运行,但是它要提供self参数,而这个参数在方法中根本不会被使用到。这里的@staticmethod装饰器可以给我们带来一些好处:
    Python不再需要为Pizza对象实例初始化一个绑定方法,绑定方法同样是对象,但是创建他们需要成本,而静态方法就可以避免这些。

    >>> Pizza().cook is Pizza().cook
    False
    >>> Pizza().mix_ingredients is Pizza.mix_ingredients
    True
    >>> Pizza().mix_ingredients is Pizza().mix_ingredients
    True
    可读性更好的代码,看到@staticmethod我们就知道这个方法并不需要依赖对象本身的状态。
    可以在子类中被覆盖,如果是把mix_ingredients作为模块的顶层函数,那么继承自Pizza的子类就没法改变pizza的mix_ingredients了如果不覆盖cook的话。
    

    类方法

    什么是类方法呢?类方法不是绑定到对象上,而是绑定在类上的方法。

    >>> class Pizza(object):
    ...   radius = 42
    ...   @classmethod
    ...   def get_radius(cls):
    ...     return cls.radius
    ... 
    >>> 
    >>> Pizza.get_radius
    <bound method type.get_radius of <class '__main__.Pizza'>>
    >>> Pizza().get_radius
    <bound method type.get_radius of <class '__main__.Pizza'>>
    >>> Pizza.get_radius is Pizza().get_radius
    True
    >>> Pizza.get_radius()
    42

    无论你用哪种方式访问这个方法,它总是绑定到了这个类身上,它的第一个参数是这个类本身(记住:类也是对象)。
    什么时候使用这种方法呢?类方法通常在以下两种场景是非常有用的:

    • 工厂方法:它用于创建类的实例,例如一些预处理。如果使用@staticmethod代替,那我们不得不硬编码Pizza类名在函数中,这使得任何继承Pizza的类都不能使用我们这个工厂方法给它自己用。
    class Pizza(object):
      def __init__(self, ingredients):
        self.ingredients = ingredients
    
      @classmethod
      def from_fridge(cls, fridge):
        return cls(fridge.get_cheese() + fridge.get_vegetables())
    • 调用静态类:如果你把一个静态方法拆分成多个静态方法,除非你使用类方法,否则你还是得硬编码类名。使用这种方式声明方法,Pizza类名明永远都不会在被直接引用,继承和方法覆盖都可以完美的工作。
    class Pizza(object):
      def __init__(self, radius, height):
        self.radius = radius
        self.height = height
    
      @staticmethod
      def compute_area(radius):
         return math.pi * (radius ** 2)
    
      @classmethod
      def compute_volume(cls, height, radius):
         return height * cls.compute_area(radius)
    
      def get_volume(self):
        return self.compute_volume(self.height, self.radius)

    抽象方法
    抽象方法是定义在基类中的一种方法,它没有提供任何实现,类似于Java中接口(Interface)里面的方法。
    在Python中实现抽象方法最简单地方式是:

    class Pizza(object):
      def get_radius(self):
        raise NotImplementedError

    任何继承自_Pizza的类必须覆盖实现方法get_radius,否则会抛出异常。
    这种抽象方法的实现有它的弊端,如果你写一个类继承Pizza,但是忘记实现get_radius,异常只有在你真正使用的时候才会抛出来。

    >>> Pizza()
    <__main__.Pizza object at 0x7fb747353d90>
    >>> Pizza().get_radius()
    Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
     File "<stdin>", line 3, in get_radius
    NotImplementedError

    还有一种方式可以让错误更早的触发,使用Python提供的abc模块,对象被初始化之后就可以抛出异常:

    import abc
    
    class BasePizza(object):
      __metaclass__ = abc.ABCMeta
    
      @abc.abstractmethod
      def get_radius(self):
    
    """Method that should do something."""

    使用abc后,当你尝试初始化BasePizza或者任何子类的时候立马就会得到一个TypeError,而无需等到真正调用get_radius的时候才发现异常。

    >>> BasePizza()
    Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
    TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius

    混合静态方法、类方法、抽象方法

    当你开始构建类和继承结构时,混合使用这些装饰器的时候到了,所以这里列出了一些技巧。
    记住,声明一个抽象的方法,不会固定方法的原型,这就意味着虽然你必须实现它,但是我可以用任何参数列表来实现:

    import abc
    
    class BasePizza(object):
      __metaclass__ = abc.ABCMeta
    
      @abc.abstractmethod
      def get_ingredients(self):
    
    """Returns the ingredient list."""
    
    class Calzone(BasePizza):
      def get_ingredients(self, with_egg=False):
        egg = Egg() if with_egg else None
        return self.ingredients + egg

    这样是允许的,因为Calzone满足BasePizza对象所定义的接口需求。同样我们也可以用一个类方法或静态方法来实现:

    import abc
    
    class BasePizza(object):
      __metaclass__ = abc.ABCMeta
    
      @abc.abstractmethod
      def get_ingredients(self):
    
    """Returns the ingredient list."""
    
    class DietPizza(BasePizza):
      @staticmethod
      def get_ingredients():
        return None

    这同样是正确的,因为它遵循抽象类BasePizza设定的契约。事实上get_ingredients方法并不需要知道返回结果是什么,结果是实现细节,不是契约条件。
    因此,你不能强制抽象方法的实现是一个常规方法、或者是类方法还是静态方法,也没什么可争论的。从Python3开始(在Python2中不能如你期待的运行,见issue5867),在abstractmethod方法上面使用@staticmethod和@classmethod装饰器成为可能。

    import abc
    
    class BasePizza(object):
      __metaclass__ = abc.ABCMeta
    
      ingredient = ['cheese']
    
      @classmethod
      @abc.abstractmethod
      def get_ingredients(cls):
    
    """Returns the ingredient list."""
         return cls.ingredients

    别误会了,如果你认为它会强制子类作为一个类方法来实现get_ingredients那你就错了,它仅仅表示你实现的get_ingredients在BasePizza中是一个类方法。
    可以在抽象方法中做代码的实现?没错,Python与Java接口中的方法相反,你可以在抽象方法编写实现代码通过super()来调用它。(译注:在Java8中,接口也提供的默认方法,允许在接口中写方法的实现)

    import abc
    
    class BasePizza(object):
      __metaclass__ = abc.ABCMeta
    
      default_ingredients = ['cheese']
    
      @classmethod
      @abc.abstractmethod
      def get_ingredients(cls):
    
    """Returns the ingredient list."""
         return cls.default_ingredients
    
    class DietPizza(BasePizza):
      def get_ingredients(self):
        return ['egg'] + super(DietPizza, self).get_ingredients()

    这个例子中,你构建的每个pizza都通过继承BasePizza的方式,你不得不覆盖get_ingredients方法,但是能够使用默认机制通过super()来获取ingredient列表。

    展开全文
  • python类的实例方法静态方法和类方法区别及其应用场景 一、先看语法,python 语法中有三种方法,实例方法静态方法类方法。 ps.python中self,cls的区别 普通实例方法,第一个参数需要是self,它表示一...
  • 主要介绍了Python 类方法和实例方法(@classmethod),静态方法(@staticmethod),结合实例形式分析了Python 类方法和实例方法静态方法相关原理、用法及相关操作注意事项,需要的朋友可以参考下
  • 昨天的文章 详解类方法之绑定方法与非绑定方法 中写了方法中的绑定方法和非绑定方法,今天我们继续来学习剩下的「类方法静态方法」。 类方法 & 静态方法 在开始之前,先让我们来看下面一段代码: class ...
  • python3:类方法静态方法和实例方法以及应用场景

    千次阅读 多人点赞 2018-10-20 13:29:52
    1.实例方法 在编程里经常用的是实例方法,直接用实例去调用, 只要 方法里有self 就可以断定是实例方法, 如 def method_name(self,*argc). 先看下边代码如下: class Date: def __init__(self,year,month,day)...
  • 本文主要介绍了python 实例方法类方法和静态方法的相关知识。具有很好的参考价值,下面跟着小编一起来看下吧
  • 主要介绍了Python实例方法类方法静态方法区别详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 实例方法就是的实例能够使用的方法。如下:复制代码 代码如下:class Foo: def __init__(self, name): self.name = name def hi(self): print self.name if __name__ == ‘__main__’: foo01 = Foo(‘letian’...
  • Python中至少有三种比较常见的方法类型,即实例方法类方法静态方法。它们是如何定义的呢?如何调用的呢?它们又有何区别作用呢?且看下文。 首先,这三种方法都定义在中。下面我先简单说一下怎么定义调用...
  • 本文实例讲述了python类方法和静态方法。分享给大家供大家参考。具体分析如下: python没有C++中static关键字,它的静态方法是怎样的呢?还有其它语言中少有的类方法又是神马? python中实现静态方法和类方法都...
  • Python 实例方法类方法和静态方法

    万次阅读 多人点赞 2018-03-30 20:17:19
    Python 中,实例方法(instance method),类方法(class method)与静态方法(static method)经常容易混淆。本文通过代码例子来说明它们的区别。 实例方法 Python 的实例方法用得最多,也最常见。我们先来...
  • 主要介绍了解析python 类方法、对象方法静态方法的的相关资料,帮助大家更好的理解学习python,感兴趣的朋友可以了解下
  • 面相对象程序设计中,类方法和静态方法是经常用到的两个术语。 逻辑上讲:类方法是只能由类名调用;静态方法可以由类名或对象名进行调用。 python staticmethod and classmethod Though classmethod and ...
  • python类方法静态方法和实例方法的作用区别

    千次阅读 多人点赞 2019-02-18 15:08:00
    class A(object): # 构造函数 def __init__(self, title1): self.title = title1 print(self.title) # 实例函数 def foo(self, title2): print(title2) # 静态函数 @staticme...
  • 主要介绍了python 的继承 实例方法.静态方法.类方法的代码解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 220,769
精华内容 88,307
关键字:

python静态方法和类方法

python 订阅