标签: abc

我用 abc 包实现了抽象类。下面的程序显示没有问题。

有没有办法让它失败，因为抽象MyMethod确实有一个参数，a但类中的“MyMethod”的实现Derivative没有？所以我不仅要指定接口类中的方法，还要指定Base这些方法的参数。

import abc

#Abstract class
class Base(object):
    __metaclass__  = abc.ABCMeta

    @abc.abstractmethod
    def MyMethod(self, a):
        'MyMethod prints a'


class Derivative(Base)

    def MyMethod(self):
        print 'MyMethod'

我有这样的功能

def print_stuff(items):
    if isinstance(items, (str, bytes)):
        items = (items,)
    for item in items:
        print (item)

可以这样称呼：

In [37]: print_stuff(('a', 'b'))
a
b

In [38]: print_stuff('a')
a

我不喜欢做，isinstance (items, (str, bytes))我更愿意做isinstance(item, (collections.abc.MAGIC))

其中MAGIC是所有序列对象的ABC，可以包含其他序列对象，例如

• 元组
• 清单
• numpy.array
• 一些用户定义的矢量类，等等

但不是：

• 力量
• 个字节
• 一些用户定义的UTF-16的str类，等等

恐怕这是不可能的，tuple并且str具有相同的7个ABC ：(

In [49]: [v for k, v in vars(collections.abc).items()
    ...:                                   if inspect.isclass(v) and issubclass(tuple, v) ]
Out[49]:
[collections.abc.Hashable,
 collections.abc.Iterable,
 collections.abc.Reversible,
 collections.abc.Sized,
 collections.abc.Container,
 collections.abc.Collection,
 collections.abc.Sequence]

In [50]: [v for k, v in …

我想在使用带有abc库的抽象类时提取 python 类名。不幸的是，我收到了 class name ABCMeta。

import abc

class A(abc.ABC)
    pass

class B(A)
    pass

print(A.__class__.__name__)  # output: 'ABCMeta'
print(B.__class__.__name__)  # output: 'ABCMeta'
print(str(A))  # output: "<class '__main__.A'>"
print(str(B))  # output: "<class '__main__.B'>"

我希望我应该收到如下输出

print(A.__class__.__name__)  # output: 'A'
print(B.__class__.__name__)  # output: 'B'

在str(A)和str(B)似乎让我假设类的名字可以从什么地方提取打印的类名。但尽管如此，我对str用来解析和获取类名不感兴趣。

假设我们有一个 Python 类，它使用abc模块来定义一个抽象属性：

import abc

class A(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractproperty
    def test_attribute(self):
        raise NotImplementedError

现在让我们考虑通过添加新方法 ( )B来定义子类，并通过实现最初在 中声明的抽象方法来定义子类：Atest_method()CBA

class B(A):

    def test_method(self):
        pass

class C(B):

    def test_attribute(self):
        # Implement abstract attribute
        pass

假设我想保持B抽象（不可实例化），我是否应该test_attribute在 中重新定义抽象属性 ( ) 和元类赋值B？或者继承它们就足够了A（如上面的代码）？

我知道Python允许我不重新定义抽象方法，从而从父类继承它们。从理论软件工程的角度来看，这是正确的吗？

我这么问是因为如果我没记错的话，其他语言（例如Java）不允许继承抽象方法而不将它们重新实现为抽象......

是否可以使用户定义的类型成为Python中内置类型的虚拟子类？我希望我的类被视为 的子类int，但是我不想像这样直接继承：

class MyInt(int):
    '''Do some stuff kind of like an int, but not exactly'''
    pass

从那时起，我的类实际上变得不可变，无论我是否愿意。例如，不可能使用像__iadd__和 这样的方法__isub__，因为int无法修改自身。我可以继承numbers.Integral，但是当有人打电话时isinstance(myIntObj, int)或者issubclass(MyInt, int)会得到答复False。据我所知，具有 ABCMeta 元类的类可以使用该方法register将类注册为不真正从它们继承的虚拟基类。有没有办法用内置类型来做到这一点？就像是：

registerAsParent(int, MyInt)

我环顾四周（无论是在 python 文档中还是在网上），但还没有找到任何接近我正在寻找的东西。我所要求的完全不可能吗？

我有一个抽象基类，并且每个后代都应该具有某些属性（类型为 str、int 等），因此在基类中记录这些属性是有意义的。在 Python 3.6+ 中记录这些属性的推荐格式是什么？

我想编写抽象类，强制继承类在我的抽象类中实现所有方法和属性。

另外，我想对我的抽象属性使用 setter 和 getter，以使我的代码整洁并看起来很好

但是，当前的实现：

import abc


class Component(metaclass=abc.ABCMeta):

    @property
    @abc.abstractmethod
    def status(self):
        pass

    @property
    @status.setter
    @abc.abstractmethod
    def status(self, value):
        pass

确实强制继承类为我的抽象属性 getter 实现 getter，但不强制创建属性设置器（这正是我想要的）

我怎样才能在不失去应用进一步提到的方法的所有好处的情况下实现这种行为（也就是编写新方法并在我的抽象类 setter 中执行它们）？

我有一个抽象基类，Animal：

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def move(self):
        raise NotImplementedError()

    @abc.abstractmethod
    def eat(self):
        raise NotImplementedError()

现在我有另一个 abc 只实现了这些方法之一：

class Bird(Animal):
    def move(self):
        print("fly")

另一个实现缺失方法的类：

class Eagle(Bird):
    def eat(self):
        print("eagle eats")

但是 PyCharm 抱怨Bird它“必须实现所有抽象方法”，而我故意希望它保持抽象。

我错过了什么，还是这是一个错误？如果这只是一个错误，我可以以某种方式忽略警告#noqa吗（类似于）？

即使一个类是从 继承的ABC，看起来它仍然可以被实例化，除非它包含抽象方法。

有了下面的代码，防止Identifier创建对象的最佳方法是什么：Identifier(['get', 'Name'])？

from abc import ABC
from typing import List
from dataclasses import dataclass

@dataclass
class Identifier(ABC):
    sub_tokens: List[str]

    @staticmethod
    def from_sub_tokens(sub_tokens):
        return SimpleIdentifier(sub_tokens) if len(sub_tokens) == 1 else CompoundIdentifier(sub_tokens)


@dataclass
class SimpleIdentifier(Identifier):
    pass


@dataclass
class CompoundIdentifier(Identifier):
    pass

如果这个问题已经得到回答，我提前道歉。这看起来很基本，但是，由于某种原因我找不到答案。

干杯，赫利卜。

我见过两种在python. 有什么区别，分别有哪些使用场景？

from abc import ABCMeta, abstractmethod
class AbstactClass(metaclass = ABCMeta):

和

from abc import ABC, abstractmethod
class AbstractClass2(ABC):