我有一个元类:

class MyMeta(type):
    def __init__(cls, name, bases, dct):
        # Do something
        ...

        return super(MyMeta, cls).__init__(cls, name, bases, dct)

和一个班级:

class MyClass(object):
    __metaclass__ = MyMeta

当我使用这些时,我收到以下错误:

TypeError: Error when calling the metaclass bases
    type.__init__() takes 1 or 3 arguments

问题是什么？为什么type.__init__()要采用精确可变数量的参数？

根据文件,object是所有新式班级的基础.

而AFAIK,所谓的新式课程,只是通过继承获得一些新的东西object,对吧？

我认为object继承type或使用type它__metaclass__,但object.__bases__没有给我任何东西,所以它object来自哪个剂量,它和它之间的关系是什么type？

阅读本文时：Python 中的元类是什么？，我正在学习使用__new__以下代码段：-

class a(object):
    pass

a.__new__(int,'abcdef',(int,),{})

调用__new__using可能存在一些问题a.。但是，我收到以下错误，我不明白其含义：-

TypeError: object.__new__(int) is not safe, use int.__new__()

如果与 的用法有关__new__，我可以通过阅读一些书籍来修改。但是，有人可以解释为什么会出现这条消息：

object.__new__(int) is not safe, use int.__new__()

当前状态

我有一个抽象的基类,它以numpy数组的形式托管数据,知道如何处理这些数据,哪些可以解释matplotlib如何绘制它.为了容纳不同类型的数据,它有许多子类,如下所示:

class PlotData():
    """Base Class"""
    subclasslist = []

    @classmethod
    def register(cls):
        super().subclasslist.append(cls)

    def __new__(self, initdata, *args, **kwargs):
        for subclass in subclasslist:
            try:
                subclass.__test__(initdata)
            except AssertionError:
                continue
            else:
                break
        else:
            raise TypeError("Initdata does not fit any known subclass")
        return subclass(initdata, *args, **kwargs)

class Plot3D(PlotData):
    """Subclass for 3d-plotting data"""
    def __test__(initdata):
        assert Data_is_the_right_kind

class Plot_XY(PlotData):
    """Subclass for for plotting X-Y relations of data"""
    def __test__(initdata):
        assert Data_is_the_right_kind

问题

现在,问题是如何将类引用引入子类列表.起初我想在类体中调用super().register(),但我无法获得对类本身的引用,这就是我想要存储在列表中的内容.一个小小的搜索已经产生了两种可能的解决方案,我想知道最好的解决方案是什么.

解决方案1

在每个类定义后添加一个调用,如下所示:

class Plot_XY(PlotData):
    """Subclass for for plotting X-Y relations of data""" …

因此，我已经看到有关此错误的类似问题，它们似乎都与存在ManyToMany关系的用例有关。但是，即使我的模型没有M2M关系，我也遇到了这个问题，所以我想问一下为什么会这样。

这是我的模型：

class Course(models.Model):
    name = models.CharField(max_length=64)
    credit = models.IntegerField
    notes = models.CharField(max_length=128)
    resources = models.TextField
    description = models.TextField
    topic = models.CharField(max_length=128)

每当我创建这个模型的一个新实例，我得到TypeError的credit，resources和description领域。

我将其实例化为：

c = Course(
    name='some name',
    credit='8',
    notes='N/A',
    resources='no resources',
    description='N/A',
    topic='some topic'
)

但是，如果我将受影响的字段更改为models.IntegerField(max_length=8)和models.TextField(max_length=8)，则错误消失了。

为什么会这样？我的印象是该max_length参数是可选的TextField；我什至不知道在上下文中这意味着什么IntegerField。有人可以解释这种行为和/或我在做什么错吗？

我正在使用Flask构建一个非常小的单页动态网站.我想在不使用类的情况下跨函数共享变量及其值的列表.

我查看了Flask的View类,但是我觉得我的应用程序不够大,也不够复杂,无法使用Flask实现我的项目的基于类的版本.如果我正确说明我也将失去使用route装饰器的能力,并且必须使用其代理功能add_url_rule.

这也会迫使我将我的代码重构为这样的东西:

from flask.views import View
class ShowUsers(View):

def dispatch_request(self):
    users = User.query.all()
    return render_template('users.html', objects=users)

app.add_url_rule('/users/', view_func=ShowUsers.as_view('show_users'))

对于变量共享,我想到了两种技术.

1. x = ""
   
   def foo():
       global x
       x = request.form["fizz"]
   
   def bar():
       # do something with x (readable)
       print(x)
   
   def baz():
       return someMadeupFunction(x)
   

   Run Code Online (Sandbox Code Playgroud)

2. def foo():
       x = request.form["fizz"]
       qux(someValue)
   
   def qux(i):
       menu = {
       key0: bar,
       key1: baz,
       }
       menu[i](x)
   
   def bar(x):
       # do something with x (readable)
       print(x)
   
   def baz(x):
       return someMadeupFunction(x)
   

   Run Code Online (Sandbox Code Playgroud)

实例是从类创建的对象。类也是对象，但从元类创建。函数是对象，方法是对象，文件是对象，Python 中的一切都是对象。

那么元类也是对象吗？如果是，元类属于什么类？

我完全理解在这个例子中传递的是什么self.我对它如何被传递到self内部非常困惑.有人可以帮我理解吗？

class Cars:

    def __init__(self, model, engine, doors):

        self.model = model
        self.engine = engine
        self.doors = doors

tesla = Cars('Model S', 'Electric', 'Four door')
ford = Cars('Mustang', 'v8', 'Two door')

说我有

class A:
    # Some code

然后，我想创建一个抽象类B的A，这本身就是混凝土。我是否应该为此目的使用多重继承？如果是这样，我应该ABC先导入，如

class B(ABC, A):
    @abstractmethod
    def some_method():
        pass

，或者我应该最后导入它，例如

class B(A, ABC):
    @abstractmethod
    def some_method():
        pass

假设我有一个像这样的 C++ 枚举：

enum class Kind {Kind1 = 1, Kind2, Kind3};

要使用 Pybind11 将此枚举绑定到 Python 枚举中，我正在执行以下操作：

py::enum_<Kind>(py_module, "Kind")
   .value("Kind1", Kind::Kind1)
   .value("Kind2", Kind::Kind2)
   .value("Kind3", Kind::Kind3)
   .def("__len__", 
      [](Kind p) {
         return 3;
      });

编译代码后，如果我询问枚举的长度，我将收到此错误：

>>> len(Kind)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'pybind11_type' has no len()

我有什么想法可以解决它吗？

编辑1：我在 Visual Studio 2019 (C++17) 上使用 Pybind11 版本 2.10.1。

编辑 2：我希望具有与 Python 枚举中相同的行为：

>>> from enum import Enum
>>> class Kind(Enum):
...    kind1 = …