python-静态方法staticmethod、类方法classmethod、属性方法property

Python的方法主要有3个,即静态方法(staticmethod),类方法(classmethod)和实例方法


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

def foo(x):

    print "executing foo(%s)"%(x)

 

class A(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

 

a=A()

这个self和cls是对类或者实例的绑定,对于一般的函数来说我们可以这么调用foo(x),这个函数就是最常用的,它的工作跟任何东西(类,实例)无关.对于实例方法,我们知道在类里每次定义方法的时候都需要绑定这个实例,就是foo(self, x),为什么要这么做呢?因为实例方法的调用离不开实例,我们需要把实例自己传给函数,调用的时候是这样的a.foo(x)(其实是foo(a, x)).类方法一样,只不过它传递的是类而不是实例,A.class_foo(x).注意这里的self和cls可以替换别的参数,但是python的约定是这俩,还是不要改的好.

对于静态方法其实和普通的方法一样,不需要对谁进行绑定,唯一的区别是调用的时候需要使用a.static_foo(x)或者A.static_foo(x)来调用.

\ 实例方法 类方法 静态方法
a = A() a.foo(x) a.class_foo(x) a.static_foo(x)
A 不可用 A.class_foo(x) A.static_foo(x)

类的普通方法

class Animal(object):
    def __init__(self,name):
        self.name = name
    def intro(self):
        print(‘there is a %s‘%(self.name))
cat = Animal(‘cat‘)
cat.intro()
  • 静态类方法
class Animal(object):
    def __init__(self,name):
        self.name = name
    @staticmethod
    def intro(self):
        print(‘there is a %s‘%(self.name))
cat = Animal(‘cat‘)
cat.intro()
  • 加上装饰器后运行会报错,原因是方法变为一个普通函数,脱离的与类的关系,不能引用构造函数中的变量了。

使用场景举例:python内置方法os中的方法,可以直接使用的工具包,跟类没关系。


class Animal(object):
    def __init__(self,name):
        self.name = name
    @classmethod
    def intro(self):
        print(‘there is a %s‘%(self.name))
cat = Animal(‘cat‘)
cat.intro()
  • 报错信息

如果换成

class Animal(object):
    name = ‘cat‘
    def __init__(self,name):
        self.name = name
    @classmethod
    def intro(self):
        print(‘there is a %s‘%(self.name))
cat = Animal(‘cat‘)
cat.intro()
  • 可以正常运行。

结论:类方法只能调用类变量,不能调用实例变量



属性方法@property 把一个方法变为(伪装成)类属性。因为类属性的实质是一个类变量,用户可以调用变量就可以修改变量。某些特定场景要限制用户行为,就用到静态方法。 
@property广泛应用在类的定义中,可以让调用者写出简短的代码,同时保证对参数进行必要的检查,这样,程序运行时就减少了出错的可能性。(摘自廖雪峰的博客)

class Animal(object):
    def __init__(self,name):
        self.name = name
    @property
    def intro(self,food):
        print(‘there is a %s eating %s‘%(self.name,food))
cat = Animal(‘cat‘)
cat.intro()
  • 报错:
  • 方法不能正常调用。如果要调用,如下:
cat.intro
  • 是这样的话,方法就没办法单独传入参数。如果要传入参数,如下:
class Animal(object):
    def __init__(self,name):
        self.name = name
    @property
    def intro(self):
        print(‘there is a %s eating %s‘%(self.name,food))
    @intro.setter
    def intro(self,food):
        pass
cat = Animal(‘cat‘)
cat.intro
  • cat.intro还有其他操作getter deleter等等。

一:staticmethod

代码如下:

class Singleton(object):
    instance = None

    def __init__(self):
        raise SyntaxError(‘can not instance, please use get_instance‘)

    @staticmethod
    def get_instance():
        if Singleton.instance is None:
            Singleton.instance = object.__new__(Singleton)
        return Singleton.instance

a = Singleton.get_instance()
b = Singleton.get_instance()
print(‘a id=‘, id(a))
print(‘b id=‘, id(b))

该方法的要点是在__init__抛出异常,禁止通过类来实例化,只能通过静态get_instance函数来获取实例;因为不能通过类来实例化,所以静态get_instance函数中可以通过父类object.__new__来实例化。

二:classmethod

和方法一类似,代码:

class Singleton(object):
    instance = None

    def __init__(self):
        raise SyntaxError(‘can not instance, please use get_instance‘)

    @classmethod
    def get_instance(cls):
        if Singleton.instance is None:
            Singleton.instance = object.__new__(Singleton)
        return Singleton.instance

a = Singleton.get_instance()
b = Singleton.get_instance()
print(‘a id=‘, id(a))
print(‘b id=‘, id(b))

该方法的要点是在__init__抛出异常,禁止通过类来实例化,只能通过静态get_instance函数来获取实例;因为不能通过类来实例化,所以静态get_instance函数中可以通过父类object.__new__来实例化。

三:类属性方法

和方法一类似, 代码:

class Singleton(object):
    instance = None

    def __init__(self):
        raise SyntaxError(‘can not instance, please use get_instance‘)

    def get_instance():
        if Singleton.instance is None:
            Singleton.instance = object.__new__(Singleton)
        return Singleton.instance

a = Singleton.get_instance()
b = Singleton.get_instance()
print(id(a))
print(id(b))

该方法的要点是在__init__抛出异常,禁止通过类来实例化,只能通过静态get_instance函数来获取实例;因为不能通过类来实例化,所以静态get_instance函数中可以通过父类object.__new__来实例化。

四:__new__

常见的方法, 代码如下:

class Singleton(object):
    instance = None

    def __new__(cls, *args, **kw):
        if not cls.instance:
            # cls.instance = object.__new__(cls, *args)
            cls.instance = super(Singleton, cls).__new__(cls, *args, **kw)
        return cls.instance

a = Singleton()
b = Singleton()
print(id(a))
print(id(b))

五:装饰器

代码如下:

def Singleton(cls):
    instances = {}

    def getinstance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return getinstance

@Singleton
class MyClass:
    pass

a = MyClass()
b = MyClass()
c = MyClass()

print(id(a))
print(id(b))
print(id(c))

六:元类

python2版:

class Singleton(type):
    def __init__(cls, name, bases, dct):
        super(Singleton, cls).__init__(name, bases, dct)
        cls.instance = None

    def __call__(cls, *args):
        if cls.instance is None:
            cls.instance = super(Singleton, cls).__call__(*args)
        return cls.instance

class MyClass(object):
    __metaclass__ = Singleton

a = MyClass()
b = MyClass()
c = MyClass()
print(id(a))
print(id(b))
print(id(c))
print(a is b)
print(a is c)

或者:

class Singleton(type):
    def __new__(cls, name, bases, attrs):
        attrs["_instance"] = None
        return super(Singleton, cls).__new__(cls, name, bases, attrs)

    def __call__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instance

class Foo(object):
    __metaclass__ = Singleton

x = Foo()
y = Foo()
print(id(x))
print(id(y))

python3版:

class Singleton(type):
    def __new__(cls, name, bases, attrs):
        attrs[‘instance‘] = None
        return super(Singleton, cls).__new__(cls, name, bases, attrs)

    def __call__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls.instance

class Foo(metaclass=Singleton):
    pass

x = Foo()
y = Foo()
print(id(x))
print(id(y))

七:名字覆盖

代码如下:

class Singleton(object):
    def foo(self):
        print(‘foo‘)

    def __call__(self):
        return self

Singleton = Singleton()

Singleton.foo()

a = Singleton()
b = Singleton()
print(id(a))
print(id(b))

原文地址:https://www.cnblogs.com/klb561/p/9302185.html

时间: 2024-09-28 16:47:59

python-静态方法staticmethod、类方法classmethod、属性方法property的相关文章

Python静态方法、类方法、属性方法

静态方法 使用静态方法以后,相当于把下面的函数和类的关系截断了,它的作用相当于是类下面的一个独立函数,不会自动传入参数self. class people:..... @staticmethod def xxx(): pass 类方法 只能访问类变量,不能访问实例变量. @classmethod class dog: name = "小黑" def __init__(self,name): self.name = name @classmethod def hit(cls): prin

Python的3个方法:静态方法(staticmethod),类方法(classmethod)和实例方法

Python的方法主要有3个,即静态方法(staticmethod),类方法(classmethod)和实例方法,如下: def foo(x): print "executing foo(%s)"%(x) class A(object): def foo(self,x): print "executing foo(%s,%s)"%(self,x) @classmethod def class_foo(cls,x): print "executing cla

Python的程序结构(2) -> 方法/Method -> 静态方法、类方法和属性方法

静态方法.类方法和属性方法 在 Python 中有三种常用的方法装饰器(参考装饰器部分内容),可以使普通的类实例方法变成带有特殊功能的方法,分别是静态方法.类方法和属性方法. 静态方法 / Static Method 在 def 定义之前加上 @staticmethod 进行装饰,便可以使该方法成为静态方法,静态方法无法调用实例属性.静态方法可以通过实例或类进行调用.通常用于无需生成实例或无需共享实例属性的方法中,比如一些纯粹的数学公式计算等场合. 1 class Foo(): 2 @stati

python中静态方法、类方法、属性方法区别

在python中,静态方法.类方法.属性方法,刚接触对于它们之间的区别确实让人疑惑. 类方法(@classmethod) 是一个函数修饰符,表是该函数是一个类方法 类方法第一个参数是cls,而实例方法第一个参数是self(表示该类的一个实例) 类中普通函数至少要一个self参数,代表类对象实例 类方法至少需要一个cls参数,通过cls可以获取到类本身的属性方法等元信息.当有个子类继承时,传入的是子类对象. 对于类方法两种调用方式,类.func(),类实例.func() 静态方法(@staticm

python:静态方法、类方法、属性方法

静态方法:只是名义上归类管理,实际上在静态方法里访问不了类或实例中的任何属性. 例子: class dog(object):----def init(self,name):br/>--------self.name=name[email protected]----def eat(self):--------print("%s is eating" %self.name,"baozi")d=dog("small")d.eat(d) 类方法:

面向对象【day08】:静态方法、类方法、属性方法

本节内容 概述 静态方法 类方法 属性方法 总结 一.概述 前面我们已经讲解了关于类的很多东西,今天讲讲类的另外的特性:静态方法(staticmethod).类方法(classmethod).属性方法(property) 二.静态方法 2.1 定义 说明:在方法名前加上@staticmethod装饰器,表示此方法为静态方法 1 2 3 4 5 6 7 8 class Dog(object):     def __init__(self,name):         self.name = nam

python3学习笔记 静态方法,类方法,属性方法

静态方法@statitmetod 只是名义上归类管理,实际上在静态方法里访问不了类或实例中的任何属性 类方法@classmethed 只能访问类变量,不能访问实例变量 属性方法@property 把一个方法变成一个静态属性 删除 @del.deleter def eat(self): del self.__food 原文地址:https://www.cnblogs.com/zsypython/p/8884792.html

python第三十三天----静态方法、类方法、属性方法

@staticmethod 装饰后,类中的方法转成静态方法 1 class a: 2 3 @staticmethod 4 def b(self): 5 print('') 静态方法不可以访问实例变量或类变量,相当于类中的工具包.如os,  system 等 import的模块一般 @classmethod装饰后,类中的方法转成类方法,类方法和普通方法的区别是, 类方法只能访问类变量,不能访问实例变量 1 class b(object): 2 name='aa' 3 @classmethod 4

Python面向对象静态方法,类方法,属性方法

静态方法(staticmethod名义上归类管理,实际上在静态方法里访问不到类或实例中的静态属性) 1 class days(object): 2 def __init__(self, food): 3 self.food = food 4 5 @staticmethod # 实际和类没有关系 6 def tell(self): 7 print('这里有%s,%s快来' % (self.food, 'name')) 8 9 10 a = days('香蕉') 11 a.tell(a) 类方法(c

Python学习——静态方法、类方法、属性方法

import os # os.system() # os.mkdir() class Dog(object): # name = 'kk' def __init__(self,name): self.name = name # @staticmethod #静态方法,实际上跟类没什么关系了,并且,这个不会主动传self参数的. # @classmethod #类方法,能够调用self参数了,但是不能够调用实例化的变量. @property #静态属性,不能传入参数了,只能自己调用类或者实例里面的