相关疑难解决方法(0)

我的测试框架目前基于一个测试运行器实用程序,它本身来自Eclipse pydev python test-runner.我正在转向使用Nose,它具有我的自定义测试运行器的许多功能,但似乎是更好的质量代码.

我的测试套件包括许多以前从未运行过的抽象测试类.标准的python testrunner(和我的自定义的)只运行了unittest.TestCase和unittest.TestSuite的实例.

我注意到,因为我切换到Nose,它运行的任何东西都以名称"test"开头,这很烦人...因为我们用于test-mixins的命名约定看起来像是Nose的测试类.以前这些从未作为测试运行,因为它们不是TestCase或TestSuite的实例.

显然,我可以重命名方法,从名称中排除"test"这个词......这需要一段时间,因为测试框架非常大,并且有很多继承.另一方面,如果有一种方法可以让Nose只看到TestCases和TestSuites是可运行的......那就没有别的了.

可以这样做吗？

我感兴趣的是,是否有一种方法可以无误地反省Python实例,__dict__尽管程序员可能会遇到任何障碍,因为这样可以帮助我调试非预期的引用循环和悬空资源(如打开文件)等问题.

一个更简单的例子是:dict如果程序员隐藏keys()在自己的类后面,我怎么能看到子类的键？解决dict keys()方法是手动调用方法而不是让继承调用子类的方法版本:

# Simple example of getting to the real info
# about an instance

class KeyHidingDict(dict):
    def keys(self):
        return []  # there are no keys here!

khd = KeyHidingDict(a=1, b=2, c=3)
khd.keys()       # drat, returns []
dict.keys(khd)   # aha! returns ['a', 'b', 'c']

现在我的实际问题是,__dict__无论程序员可能做了什么来隐藏它,我怎么能看到一个实例呢？如果他们设置了一个__dict__类变量,那么它似乎会影响__dict__从该类继承的任何对象的实际内容:

# My actual question

class DunderDictHider(object):
    __dict__ = {'fake': 'dict'}

ddh = DunderDictHider()
ddh.a = 1
ddh.b = 2
print …

我已经完成了这个:Python中的元类是什么？

但是,任何人都可以更具体地解释什么时候我应该使用元类概念,什么时候它非常方便？

假设我有一个类如下:

 class Book(object):
    CATEGORIES = ['programming','literature','physics']
    def _get_book_name(self,book):
        return book['title']
    def _get_category(self, book):
        for cat in self.CATEGORIES:
            if book['title'].find(cat) > -1:
                return cat  
        return "Other"


if __name__ == '__main__':
    b = Book()
    dummy_book = {'title':'Python Guide of Programming', 'status':'available'}
    print b._get_category(dummy_book)

对于这堂课.

在哪种情况下我应该使用元类,为什么它有用？

提前致谢.

在SQLAlchemy ORM教程中,给出以下代码作为将映射到表的类的示例:

>>> from sqlalchemy import Column, Integer, String
>>> class User(Base):
...     __tablename__ = 'users'
...
...     id = Column(Integer, primary_key=True)
...     name = Column(String)
...     fullname = Column(String)
...     password = Column(String)
...
...     def __init__(self, name, fullname, password):
...         self.name = name
...         self.fullname = fullname
...         self.password = password
...
...     def __repr__(self):
...        return "<User('%s','%s', '%s')>" % (self.name, self.fullname, self.password)

如果name,fullname并且password在__init__实例化类时由方法中的用户设置,那么将它们声明为Column对象(即作为类变量)是什么意思？我不明白SQLAlchemy如何以及何时能够使用这些信息 - 它是通过 …

我真的不明白基础元类是如何工作的(又名type).有没有人知道它的功能的纯python模拟？

python文档经常为C级代码执行此操作,这些代码很难用英语完全描述(例如,请参阅解释__getattribute__),但不适用于type.

我知道怎么开始.由于定义type使用类型的子类的行为有点像说"类型工作方式类型工作",我定义了一个鸭类型元类.它有些功能,但还不够.

class MetaClassDuck(object):
    @classmethod
    def __new__(self, mcs, name, bases, attrs):
        """Create a new class object."""
        newcls = super(MetaClassDuck, self).__new__(mcs)
        newcls.__dict__.update(attrs)
        newcls.__name__ = name
        newcls.__bases__ = bases
        return newcls

    def __call__(cls, *args, **kwargs):
        """Calling a class results in an object instance."""
        ###########################################################
        # Fill in the blank:
        # I don't see a way to implement this without type.__new__
        ###########################################################
        return newobj

class MyClass(object):
    __metaclass__ = MetaClassDuck

    one = 1
    _two …

我在拿起Django的同时学习Python.我熟悉许多其他语言.

在下面的代码片段中,x是类的类变量Foo.

class Foo(object):
    x = 9000

鉴于之前的声明,以下工作正常.

print Foo.x

Django框架允许您通过定义Python类来创建模型.它使用Python类中的不同类变量创建字段.

class Question(models.Model):
    question_text = models.CharField(max_length=200)

为什么以下代码段:

#!/usr/bin/env
import os, django
os.environ['DJANGO_SETTINGS_MODULE'] = 'mysite.settings'
django.setup()
from polls.models import Question, Choice
print Question.question_text

抛出以下错误:

AttributeError: type object 'Question' has no attribute 'question_text'

据我所知,我的Question类有一个静态成员定义:Question.question_text.

我正在阅读http://blog.thedigitalcatonline.com/blog/2014/09/01/python-3-oop-part-5-metaclasses/#.Vv1T7zG1XGA,其中包含:

因为在Python中一切都是对象,所以一切都是类的实例,甚至是类.好吧,type是实例化的类来获取类.所以请记住:object是每个对象的基础,type是每个类型的类.听起来令人费解？这不是你的错,不用担心.然而,只是为了让你完成整理,这就是Python的基础

>>> type(object)
<class 'type'>
>>> type.__bases__
(<class 'object'>,)

我无法理解这一点,任何人都可以用不同的方式解释这种关系,以使其更清晰吗？

基于我有限的 Python 知识，Metaclass 是另一个类。在下面的例子中，我只是在构建一个元类。在这里，我重载了该__new__方法。我的期望是在类声明的末尾，当type.__new__() 被调用时它将被委托给MyMeta.__new__(). 但这永远不会发生。

print('Building MetaOne')

class MyMeta(type):
      def __new__(meta, classname, supers, classdict):
          print('In MyMeta:', classname)

      def myfunc(self):
          print ('In myfunc')

这里距MyMeta的__new__()我没有看到打印。

但相反，如果我现在使用MyMeta类作为另一个类的元类，例如：

print('Building Another class')
class Super(metaclass = MyMeta):
      def myfunc(self):
          print ('In Super myfunc')

在这门课结束时，我看到 MyMeta__new__被调用了。

有人可以帮助我理解为什么会发生这种情况吗？

我有一个只有类方法的类。它是一种 Pythonic 的命名空间方式吗？如果没有，将相似类型的方法分组的最佳方法是什么？

class OnlyClassMethods(object):
    @classmethod
    def method_1(cls):
        pass

    @classmethod
    def method_2(cls):
        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 = …