相关疑难解决方法(0)

我有一个类有两个类方法(使用classmethod()函数)来获取和设置本质上是一个静态变量.我尝试使用property()函数,但它会导致错误.我能够在解释器中使用以下内容重现错误:

class Foo(object):
    _var = 5
    @classmethod
    def getvar(cls):
        return cls._var
    @classmethod
    def setvar(cls, value):
        cls._var = value
    var = property(getvar, setvar)

我可以演示类方法,但它们不能作为属性:

>>> f = Foo()
>>> f.getvar()
5
>>> f.setvar(4)
>>> f.getvar()
4
>>> f.var
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: 'classmethod' object is not callable
>>> f.var=5
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: 'classmethod' object is not callable

是否可以将property()函数与classmethod修饰函数一起使用？

定义无参数异常:

class MyException(Exception):
    pass

提出时,之间有什么区别:

raise MyException

和

raise MyException()

在尝试时,我找不到 - 它只是一个重载的语法？

在下面的代码中,我创建了一个基本抽象类Base.我希望所有继承的类都Base提供name属性,所以我创建了这个属性@abstractmethod.

然后我创建了一个Base名为的子类Base_1,它旨在提供一些功能,但仍然是抽象的.没有name属性Base_1,但是python会在没有错误的情况下实现该类的对象.如何创建抽象属性？

from abc import ABCMeta, abstractmethod
class Base(object):
    __metaclass__ = ABCMeta
    def __init__(self, strDirConfig):
        self.strDirConfig = strDirConfig

    @abstractmethod
    def _doStuff(self, signals):
        pass

    @property    
    @abstractmethod
    def name(self):
        #this property will be supplied by the inheriting classes
        #individually
        pass


class Base_1(Base):
    __metaclass__ = ABCMeta
    # this class does not provide the name property, should raise an error
    def __init__(self, strDirConfig):
        super(Base_1, self).__init__(strDirConfig)

    def _doStuff(self, signals): …

定义抽象实例属性的最佳实践是什么,而不是属性？

我想写一些类似的东西:

class AbstractFoo(metaclass=ABCMeta):

    @property
    @abstractmethod
    def bar(self):
        pass

class Foo(AbstractFoo):

    def __init__(self):
        self.bar = 3

代替:

class Foo(AbstractFoo):

    def __init__(self):
        self._bar = 3

    @property
    def bar(self):
        return self._bar

    @bar.setter
    def setbar(self, bar):
        self._bar = bar

    @bar.deleter
    def delbar(self):
        del self._bar

属性很方便,但对于不需要计算的简单属性,它们是一种过度杀伤.这对于将由用户进行子类化和实现的抽象类尤其重要(我不想强迫某人@property在他刚写入self.foo = foo时使用__init__).

Python问题中的抽象属性建议仅作为使用的答案,@property并且@abstractmethod:它不回答我的问题.

抽象类属性的ActiveState配方AbstractAttribute可能是正确的方法,但我不确定.它也只适用于类属性而不适用于实例属性.

在Python 2.x中,当您想要将方法标记为抽象时,您可以像这样定义它:

class Base:
    def foo(self):
        raise NotImplementedError("Subclasses should implement this!")

然后,如果您忘记覆盖它,您会收到一个很好的提醒异常.是否有相同的方法将字段标记为抽象？或者在类docstring中说明它你能做什么？

起初我以为我可以将字段设置为NotImplemented,但是当我查看它的实际内容(丰富的比较)时,它似乎是侮辱性的.

我想创建一个具有abc.ABCMeta元类的类,并且与Python 2.7和Python 3.5兼容.到目前为止,我只能在2.7或3.5上成功实现这一点 - 但从不同时在两个版本上.有人可以帮我一把吗？

Python 2.7:

import abc
class SomeAbstractClass(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def do_something(self):
        pass

Python 3.5:

import abc
class SomeAbstractClass(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def do_something(self):
        pass

测试

如果我们使用合适版本的Python解释器(Python 2.7 - >示例1,Python 3.5 - >示例2)运行以下测试,则它在以下两种情况下都会成功:

import unittest
class SomeAbstractClassTestCase(unittest.TestCase):
    def test_do_something_raises_exception(self):
        with self.assertRaises(TypeError) as error:
            processor = SomeAbstractClass()
        msg = str(error.exception)
        expected_msg = "Can't instantiate abstract class SomeAbstractClass with abstract methods do_something"
        self.assertEqual(msg, expected_msg)

问题

在使用Python 3.5运行测试时,预期的行为不会发生(TypeError在实例化时不会引发SomeAbstractClass):

======================================================================
FAIL: test_do_something_raises_exception (__main__.SomeAbstractClassTestCase)
----------------------------------------------------------------------
Traceback …

我想有一个抽象类，它强制每个派生类在其__init__方法中设置某些属性。

我已经看了几个不能完全解决我问题的问题，特别是在这里或这里。这看起来很有希望，但我无法使其正常运行。

我假设我想要的结果可能类似于以下伪代码：

from abc import ABCMeta, abstractmethod


class Quadrature(object, metaclass=ABCMeta):

    @someMagicKeyword            #<==== This is what I want, but can't get working
    xyz

    @someMagicKeyword            #<==== This is what I want, but can't get working
    weights


    @abstractmethod
    def __init__(self, order):
        pass


    def someStupidFunctionDefinedHere(self, n):
        return self.xyz+self.weights+n



class QuadratureWhichWorks(Quadrature):
    # This shall work because we initialize xyz and weights in __init__
    def __init__(self,order):
        self.xyz = 123
        self.weights = 456

class QuadratureWhichShallNotWork(Quadrature):
    # …

我真正想做的是这样的事情：

class X(metaclass=abc.ABCMeta):
    @abc.abstractAttribute # this doesn't exist
    var = [1,2]

class Y(X):
    var = X.var + [3,4]

这将强制 的任何子类X实现静态var属性。

但是没有办法将静态属性定义为抽象的。

尝试使用@abc.abstractmethod，结合属性，我可以接近：

class X(metaclass=abc.ABCMeta):
    @property
    @abc.abstractmethod
    def var(self):
        return [1,2]

class Y(X):
    @property
    def var(self):
        return super().var + [3,4]

y=Y(); y.var给人[1,2,3,4]的期望。

但目标是创建静态属性/属性，而不是实例属性/属性。

创建为@staticmethod 时：

class X(metaclass=abc.ABCMeta):
    @property
    @staticmethod
    @abc.abstractmethod
    def var():
        return [1,2]

class Y(X):
    @property
    @staticmethod
    def var():
        return X.var + [3,4]

...然后y=Y(); y.var给TypeError 'staticmethod' object is not callable …

我有一组子类,应该都定义一个x应该评估为True或False 的属性.为了在忘记在子类中设置此值时捕获错误,我想在其超类中将其设置为真值评估导致错误的值.Python有这种行为的内置值吗？我有点期望NotImplemented这种行为,但它的评估结果是True.

我可以将其设置为numpy.array([0, 0])在那里if x:提高ValueError,但感觉不对.同样,我可以定义自己的类来__bool__引发异常.但是否有适合此目的的内置价值？

其他替代方案是设置属性(抽象与否)或根本不定义(所以我们得到AttributeError).

(我正在使用Python 3.4,以防万一)

我尝试在泛型类上调用类方法：

from typing import List, Union, TypeVar, Generic
from enum import IntEnum

class Gender(IntEnum):
    MALE = 1
    FEMALE = 2
    DIVERS = 3


T = TypeVar('T')

class EnumAggregate(Generic[T]):
    def __init__(self, value: Union[int, str, List[T]]) -> None:
        if value == '':
            raise ValueError(f'Parameter "value" cannot be empty!')

        if isinstance(value, list):
            self._value = ''.join([str(x.value) for x in value])
        else:
            self._value = str(value)

    def __contains__(self, item: T) -> bool:
        return item in self.to_list

    @property
    def to_list(self) -> List[T]:
        return [T(int(character)) for character in …