标签: instance-methods

我可以将Python方法同时定义为静态和实例吗？就像是:

class C(object):
    @staticmethod
    def a(self, arg1):
        if self:
            blah
        blah

所以我可以用它们来调用它:

C.a(arg1)
C().a(arg1)

目的是能够运行两组逻辑.如果作为实例方法访问,它将使用实例变量并执行操作.如果作为静态方法访问,它将不会.

我想在我的一个类中为实例方法添加一个属性.我尝试了这个问题给出的答案,但这个答案只适用于函数 - 据我所知.

举个例子,我希望能够做到这样的事情:

class foo(object):
    ...
    def bar(self):
        self.bar.counter += 1
        return self.bar.counter
    bar.counter = 1
    ...

但是,当我调用foo().bar()时,我得到:

AttributeError: 'instancemethod' object has no attribute 'counter'

我这样做的目的是试图强调'counter'变量是bar()方法的本地变量,并且还避免使用另一个属性混乱我的类名称空间.有没有办法做到这一点？有更多的pythonic方式吗？

在Rails中发送邮件时,通常可以执行以下操作:

UserMailer.password_reset(user).deliver

但如果我们看一下,UserMailer我们可以看到:

def password_reset(user) # not self.password_reset
  # ...
end

请注意,方法名称不带前缀self.看一下,看起来你需要首先实例化对象,如下所示.Rails如何做到这一点？

UserMailer.new.password_reset(user).deliver

DTO是否可以接受基于DTO数据返回派生值的实例方法？或者DTO应该是纯数据容器而没有其他方法(除了getter/setter)？

我的纯粹主义者说,商业逻辑很容易融入这种方法.但是,如果(例如)跨应用程序层共享DTO,则可能存在在DTO上具有此类方法的论据.

你对此有何看法？有没有可以接受的情况,或者应该避免这种事情？为什么/为什么不呢？

对此非常新,所以我希望我的标题中的术语正确.

我试图找出如何创建将执行以下操作的实例方法:

- 返回身份证号码.

- 由于每个对象是从类构造函数(实例化？)创建的,因此会为其分配唯一的整数ID号.第一个ID号是1,并且当实例化新对象时,将分配连续的数字.

我能够找到上面做的类/静态方法的例子但是我无法弄清楚如何用实例方法做到这一点.我的尝试如下:

class Coordinates
{
    private int iD = 0;
    private float xCoordinate;
    private float yCoordinate;

    public Coordinates()
    {
        //Asks for input and assigns it to the two variables below
        Scanner keyboard = new Scanner(System.in);
        System.out.println("Please enter the X Coordinate followed by the return key");
        xCoordinate = keyboard.nextDouble();
        System.out.println("Please enter the Y Coordinate followed by the return key");
        yCoordinate = keyboard.nextDouble();

        iD++;
    }

    public getiD()
    {
        return iD;
    }

}

我的主要方法如下:

public class …

我正在为我正在玩的一些简单的验证内容创建一些流畅的界面.我注意到的一件事是我创建了很多不同的对象.

例如,鉴于以下陈述:

Check.Assertion.ForValue.That(value, "value").IsNotNull() : void

Check.Assertion.ForArgument.That(value, "value").IsNotNull() : void

Validate.Assertion.ForDate.That("Test").IsNotNull() : bool

Validate.Assertion.ForNumeric.That("Test").IsNotNull() : bool

每个'.' (接受最后一个)我正在新建一个对象.如果我在这里没有使用流畅的界面,我会使用静态方法.

我想知道的是,如果有人知道在使用这些实例对象(注意它们是非常小的对象)时会注意到性能上的任何真正差异,就像使用静态方法一样.

干杯安东尼

我希望能够这样做:

class A(object):
    @staticandinstancemethod
    def B(self=None, x, y):
        print self is None and "static" or "instance"

A.B(1,2)
A().B(1,2)

这似乎是一个应该有一个简单解决方案的问题,但我无法想到或找到一个.

实例方法不能在Python 2或Python 3中自动腌制.

我需要使用Python 3 挑选实例方法,并将Steven Bethard的示例代码移植到Python 3:

import copyreg
import types

def _pickle_method(method):
    func_name = method.__func__.__name__
    obj = method.__self__
    cls = method.__self__.__class__
    return _unpickle_method, (func_name, obj, cls)

def _unpickle_method(func_name, obj, cls):
    for cls in cls.mro():
        try:
            func = cls.__dict__[func_name]
        except KeyError:
            pass
        else:
            break
    return func.__get__(obj, cls)

copyreg.pickle(types.MethodType, _pickle_method, _unpickle_method)

这种方法是否适用于酸洗实例方法？或者有些事情可怕的错误？我用一些模拟类测试了它,一切似乎都有效.

如果什么都不会出错,为什么Python 3中的标准pickle实例方法不可能？

鉴于一类A我只是可以添加一个instancemethod a通过

def a(self):
    pass

A.a = a

但是,如果我尝试添加另一个类B的instancemethod b,即A.b = B.b调用的尝试A().b()产生一个

TypeError:b()必须使用B实例作为第一个参数调用unbound方法(没有任何东西)

(虽然B().b()很好).确实存在差异

A.a -> <unbound method A.a>
A.b -> <unbound method B.b>  # should be A.b, not B.b

所以,

• 如何解决这个问题？
• 为什么会这样？它似乎不直观,但通常Guido有一些很好的理由......

奇怪的是,这在Python3中不再失败......

最近，我一直在研究 Python 的类实例化过程，以真正了解创建类实例时幕后发生的情况。但是，在玩测试代码时，我遇到了一些我不明白的事情。

考虑这个虚拟类

class Foo():

    def test(self):
        print("I'm using test()")

通常，如果我想使用Foo.test 实例方法，我会创建一个实例Foo并显式调用它，如下所示，

foo_inst = Foo()
foo_inst.test()
>>>> I'm using test()

但是，我发现这样调用最终会得到相同的结果，

Foo.test(Foo)
>>>> I'm using test()

这里我实际上并没有创建实例，但我仍然在访问 的Foo实例方法。为什么以及如何在 Python 环境中工作？我的意思self是通常指类的当前实例，但在这种情况下，从技术上讲我并没有创建类实例。

print(Foo()) #This is a Foo object
>>>><__main__.Foo object at ...>
print(Foo) #This is not
>>>> <class '__main__.Foo'>