精华内容
下载资源
问答
  • python静态方法 Python静态方法 (Python static method) In this quick post, we will learn how to create and use a Python static method. We will also have a look at what advantages and disadvantages ...

    python静态方法

    Python静态方法 (Python static method)

    In this quick post, we will learn how to create and use a Python static method. We will also have a look at what advantages and disadvantages static methods offer as compared to the instance methods. Let’s get started.

    在这篇快速文章中,我们将学习如何创建和使用Python静态方法。 我们还将看看静态方法与实例方法相比有哪些优点和缺点。 让我们开始吧。

    什么是静态方法? (What is a static method?)

    Static methods in Python are extremely similar to python class level methods, the difference being that a static method is bound to a class rather than the objects for that class.

    Python中的静态方法与python类级别的方法极为相似,不同之处在于静态方法绑定到一个类而不是该类的对象。

    This means that a static method can be called without an object for that class. This also means that static methods cannot modify the state of an object as they are not bound to it. Let’s see how we can create static methods in Python.

    这意味着可以在没有该类对象的情况下调用静态方法。 这也意味着静态方法无法修改对象的状态,因为它们没有绑定到对象。 让我们看看如何在Python中创建静态方法。

    创建python静态方法 (Creating python static methods)

    Python Static methods can be created in two ways. Let’s see each of the ways here:

    Python静态方法可以通过两种方式创建。 让我们看看这里的每种方式:

    使用staticmethod() (Using staticmethod())

    Let’s directly jump to sample code snippet on how to use the staticmethod() approach:

    让我们直接跳转到如何使用staticmethod()方法的示例代码片段:

    class Calculator:
    
        def addNumbers(x, y):
            return x + y
    
    # create addNumbers static method
    Calculator.addNumbers = staticmethod(Calculator.addNumbers)
    
    print('Product:', Calculator.addNumbers(15, 110))

    Note that we called the addNumbers we created without an object. When we run this program, here is the output we will get:

    python staticmethod function

    There were no surprises there. This approach is controlled as at each place, it is possible to create a static method out of a class method as well. Let’s see another approach with the same example here.

    请注意,我们在没有对象的情况下调用了我们创建的addNumbers。 当我们运行该程序时,将获得以下输出:

    那里没有惊喜。 这种方法在每个地方都受到控制,因此也可以从类方法中创建静态方法。 让我们在这里查看带有相同示例的另一种方法。

    使用@staticmethod (Using @staticmethod)

    This is a more subtle way of creating a Static method as we do not have to rely on a statement definition of a method being a class method and making it static at each place you make it static.

    这是创建静态方法的一种更微妙的方法,因为我们不必依赖于方法的语句定义,该方法是类方法,并且在使它变为静态的每个位置都使其成为静态。

    Let’s use this annotation in a code snippet:

    让我们在代码片段中使用此注释:

    class Calculator:
    
        # create addNumbers static method
        @staticmethod
        def addNumbers(x, y):
            return x + y
    
    print('Product:', Calculator.addNumbers(15, 110))

    When we run this program, here is the output we will get:

    python static method annotation

    This was actually a much better way to create a static method as the intention of keeping the method static is clear as soon as we create it and mark it with the @staticmethod annotation.

    当我们运行该程序时,将获得以下输出:

    实际上,这是创建静态方法的一种好得多的方法,因为在我们创建静态方法并使用@staticmethod批注对其进行标记后,就保持了静态方法的意图很明确。

    Python静态方法的优点 (Advantages of Python static method)

    Static methods have a very clear use-case. When we need some functionality not w.r.t an Object but w.r.t the complete class, we make a method static. This is pretty much advantageous when we need to create Utility methods as they aren’t tied to an object lifecycle usually.

    静态方法有一个非常明确的用例。 当我们需要某些功能而不是对象,而需要完整的类时,我们可以使方法静态化。 当我们需要创建Utility方法时,这是非常有利的,因为它们通常与对象生命周期无关。

    Finally, note that in a static method, we don’t need the self to be passed as the first argument.

    最后,请注意,在静态方法中,我们不需要将self作为第一个参数传递。

    API Reference: Python Documentation

    API参考: Python文档

    翻译自: https://www.journaldev.com/18722/python-static-method

    python静态方法

    展开全文
  • python 静态方法

    2019-04-03 10:08:18
    在开发时,如果需要在勒种封装...这个时候,可以把这个方法封装成静态方法 语法 @staticmethod def 静态方法名(): pass 实例 class Dog(object): # 不访问实例属性/方法也不访问类属性/方法 @staticmethod...
    在开发时,如果需要在勒种封装一个方法,这个方法:
    1.既不需要访问实例属性或者调用实例方法
    2.也不需要访问类属性或者调用类方法
    这个时候,可以把这个方法封装成静态方法
    
    语法
    
    @staticmethod
    def 静态方法名():
        pass

    实例

    class Dog(object):
        # 不访问实例属性/方法,也不访问类属性/方法
        @staticmethod
        def dark():
            print('wang,wang,wang...')
    # 方法一
    duoduo = Dog()
    duoduo.dark()
    
    # 方法二
    Dog.dark()

     

    展开全文
  • python静态方法

    千次阅读 2019-07-07 17:42:29
    这个标题「静态方法其实暗藏玄机」其实只是该文章的一个知识点。或许有些标题党,但没有关系,我相信有不少人对此并没有深入研究他们,不信我问你三个问题,你看能否答上来。 1、Python2.x和3.x中,函数和方法的...

    朋友们,我是床长! 如需转载请标明出处:http://blog.csdn.net/jiangjunshow

     

    这个标题「静态方法其实暗藏玄机」其实只是该文章的一个知识点。或许有些标题党,但没有关系,我相信有不少人对此并没有深入研究他们,不信我问你三个问题,你看能否答上来。

    1、Python2.x和3.x中,函数和方法的区分有什么不同?

    2、有了类/实例方法和普通函数,为什么还会有静态方法?

    3、Python3.x 中,静态方法有几种写法?

    带着这三个问题,你可以尝试在下文中寻找答案。


    在 Python 2 中的函数和方法的区别,十分清晰,很好分辨。但在 Python3中,我却发现完全又是另一套准则。

    首先先来 Python2 的(以下在 Python2.7中测试通过)

     

     

     

    可以得出结论:

    1、普通函数(未定位在类里),都是函数。

    2、静态方法(@staticmethod),都是函数。

    3、类方法(@classmethod),都是方法。

    4、实例方法(首参数为self且非静态、非类方法的),都是方法。

    你一定想说,类方法和实例方法,是方法没错呀,毕竟名字本身就有方法,普通函数是函数,我也理解呀。那静态方法,为什么不是方法而是函数呢?

    名字只是一个外在的表面称呼,你能说「赵铁男」就一定是汉子吗?

    我的理解是:方法是一种和对象(实例或者类)绑定后的函数。

    类方法的首参是cls,调用时,无需显示传入。实例方法首参是self,调用时,也无需显示传入。

    而静态方法,其实和普通函数没啥区别,唯一的区别就是,他定义的位置被放在了类里,做为类或者实例的一个函数。

    那你肯定又要问了,既然静态方法和普通函数都是一样的,为什么要刻意将它放在类里呢?

    我上面说了,放在类里定义,就可以让它成为类的一个工具函数,这就像你身上随身携带了一把刀,这把刀与你本人并没有什么直接关系,唯一的联系就是这把刀是你的,而你把它带在身上,无论你去到哪里,只要需要,你就可以直接拿出来用上。对比将函数放在类外面,缺点是什么呢?就是当你出门在外(在别的模块里)发现你要用刀的时候,还要特地跑一趟去商店买一把刀(import 这个函数)。

    另外,我觉得静态方法在业务和设计上的意义,会更多一些。

    一般静态方法是做为类或者实例的一个工具函数,比如对变量的做一个合法性的检验,对数据进行序列化反序列化操作等等。

    说完了 Python2 ,再来说说Python3.

    以前我觉得 Python2 对于方法和函数的界线更加清晰,但接触了 Python3,我反而觉得Python3里方法和函数的区分似乎更加合理。

    还是刚刚那段代码,我更改了解释器为Python3.6(以下在 Python3.6中测试通过)

     

     

     

    和Python2的唯一区别是,People.jump 在Python3 中变成了函数。

    这一下颠覆了你刚刚才建立起来的知识体系有木有?

    先别急,我再做个试验,也许你就知道了。

    在 Python2中

    执行People.jump('hello'),会报错说,jump的首参必须为People的实例对象,这可以理解,毕竟jump定义时,第一个参数为self。

     

     

     

    在 Python3中

    你可以发现,这里的jump的首参不再要求是 People 的一个实例,而可以是任意的对象,比如我使用字符串对象,也没有报错。

     

     

     

    也就是说,当你往jump中传入的首参为People的实例时,jump 就是方法,而当你传入的首参不是People的实例对象时,jump就是函数。

    你看,多么灵活呀。

    再总结一下,在Python3中:

    1、普通函数(未定位在类里),都是函数。

    2、静态方法(@staticmethod),都是函数。

    3、类方法(@classmethod),都是方法。

    4、方法和函数区分没有那么明确,而是更加灵活了,一个函数有可能是方法也有可能是函数。

    你肯定又要问了,那这是不是就意味着,Python3 中静态方法,可以不用再使用@staticmethod 装饰了呢,反正Python3都可以识别。

    这是个好问题,是的,可以不用指定,但是最好指定,如果你不指定,你调用这个方法只能通过People.jump,而不能通过 self.jump了,因为首参不是 self,而如果使用@staticmethod 就可以使用self.jump。

    所以说这是一个规范,就像类的私有方法,规范要求外部最好不要调用,但这不是强制要求,不是说外部就不能调用。

    写这篇文章的起源,是前两天有位读者在交流里问到了相关的问题,正好没什么主题可以写,就拿过来做为素材整理一下,也正好没有写过静态方法、类方法的内容,没想到简单的东西,也能写出这么多的内容出来。

    展开全文
  • python静态方法实例

    2020-12-25 16:25:33
    本文实例讲述了python静态方法。分享给大家供大家参考。 具体实现方法如下: 复制代码 代码如下:staticmethod Found at: __builtin__ staticmethod(function) -> method    Convert a function to be a static ...
  • 主要介绍了Python 静态方法和类方法,结合实例形式分析了Python类、实例、静态方法等相关概念、原理与使用技巧,需要的朋友可以参考下
  • Python 静态方法和类方法的区别.pdf
  • Python静态方法和类方法区别?.pdf
  • 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 静态方法 类方法

    万次阅读 2014-08-17 15:22:42
    静态方法和实例方法的区别主要体现在两个方面: 1. 在外部调用静态方法时,可以使用"类名.方法名"的方式,也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说,调用静态方法可以无需创建对象...
  • Python 静态方法和类方法

    千次阅读 2017-06-02 11:33:09
    静态方法我们知道在其他语言中静态方法一般使用static修饰,静态方法的主要特点是不需要new出对象,直接通过类名就可以访问,也可以通过对象访问。需要使用staticmethod装饰器装饰方法 举例:class A: @...
  • Python使用静态方法类似函数工具使用,一般尽量少用静态方法Python静态方法和类成员方法都可以被类或实例访问,两者概念不容易理清,但还是有区别的:1)静态方法无需传入self参数,类成员方法需传入代表本类的...
  • 实际上,Python 完全支持定义类方法,甚至支持定义静态方法Python 的类方法和静态方法很相似,它们都推荐使用类来调用(其实也可使用对象来调用)。 类方法和静态方法的区别在于,Python会自动绑定类方法的第一个...
  • 静态方法的实现大致有以下两种方法:   第一种方式(staticmethod): >>> class Foo:  str = "I'm a static method." def bar():  print Foo.str bar = staticmethod(bar) >>> Foo.bar() I'm a s
  • 静态:staticmethod 类方法:classmethod class Date: #构造函数 def __init__(self, year, month, day): self.year = year self.month = month self.day = day def tomorrow(self): self.day +=
  • 静态方法: @staticmethod def method(): print(&quot;this is a staticmethod&quot;) 静态方法的效果就和一个普通函数一样,可以当做函数来使用,不可以访问类或实例对象属性,但可以传值。 调用方式:...
  • 静态方法 静态方法可以被类和类的实例

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 219,794
精华内容 87,917
关键字:

python静态方法

python 订阅