相关疑难解决方法(0)

我正在使用一个接受类作为输入的ORM,我需要能够为它提供一些动态生成的类.目前,我正在做这样一个人为的例子:

def make_cls(_param):
   def Cls(object):
       param = _param
   return Cls

A, B = map(make_cls, ['A', 'B'])

print A().foo
print B().foo

虽然这样可以正常工作,但感觉有点偏差:例如,两个类都<class '__main__.Cls'>在repl上打印.虽然名称问题不是什么大问题(我想我可以通过设置解决它__name__),但我想知道是否还有其他我不知道的事情.所以我的问题是:有没有更好的方法来动态创建类或者我的示例已经很好了？

我想在类创建时自动运行一些可以调用其他类方法的代码.我没有在类声明本身中找到这样做的方法,并最终创建一个@classmethod被调用__clsinit__并在类声明后立即从定义范围调用它.是否有一个我可以定义的方法,以便在创建类对象后自动调用它？

class Singleton(type):
    def __init__(self, *args, **kwargs):
        print 'calling __init__ of Singleton class', self
        print 'args: ', args
        print 'kwargs: ', kwargs
        super(Singleton, self).__init__(*args, **kwargs)
        self.__instance = None
    def __call__(self, *args, **kwargs):
        print 'running __call__ of Singleton', self
        print 'args: ', args
        print 'kwargs: ', kwargs, '\n\n'
        if self.__instance is None:
            self.__instance = super(Singleton, self).__call__(*args, **kwargs)
        return self.__instance

class A(object):
    __metaclass__ = Singleton
    def __init__(self,a):
        print 'in __init__ of A:  ', self
        self.a = a
        print 'self.a: ', self.a

a=A(10)
b=A(20) …

使用python manage.py shell在django项目根目录下打开python shell,并观察以下内容:

>>> class A(object): pass #checking type of user-defined class
...
>>> type(A)
<type 'type'>
>>> class B(A): pass #checking type of child class
>>> type(B)
<type 'type'>
>>> from collections import OrderedDict #checking type of imported class
>>> type(OrderedDict)
<type 'type'>

现在看看这个:

>>> from my_project.models import MyModel
>>> type(MyModel)
<class 'django.db.models.base.ModelClass'>

有人可以解释一下这里发生了什么吗？Django模型明确定义为models.py中的类:

class MyModel(models.Model):
  pass

那么为什么它们在进口时不属于"类型"？Django是通过一些黑色魔法改变模型类型的,还是我只是遗漏了一些明显的东西？

这是一个尝试创建装饰器的玩具示例,该装饰器允许声明属性名称,这些属性名称应该是标准__subclasshook__和__instancecheck__模式中"接口检查"的必要部分.

当我装饰这个Foo类时,它似乎按预期工作.我创建了一个Bar与之无关的类,Foo但它具有所需的属性,并且它正确地满足isinstance(instance_of_bar, Foo) == True.

但是作为另一个例子,我创建了一个dict扩充的子类,以便key可以使用getattr语法访问这些值(例如dict,d['a']可以替换d.a为可获得相同结果的where ).在这种情况下,属性只是实例属性,因此__instancecheck__应该工作.

这是代码.请注意,鉴于具有Bar工作实例的示例,将__subclasshook__函数"monkeypatch"选择到Foo类(具有元类)中的选择正常.因此,似乎不必直接在元类的类定义中定义函数.

#Using Python 2.7.3

import abc
def interface(*attributes):
    def decorator(Base):

        def checker(Other):
            return all(hasattr(Other, a) for a in attributes)

        def __subclasshook__(cls, Other):
            if checker(Other):
                return True
            return NotImplemented

        def __instancecheck__(cls, Other):
            return checker(Other)

        Base.__subclasshook__ = classmethod(__subclasshook__)
        Base.__instancecheck__ = classmethod(__instancecheck__) …

我有一个父类和一个继承的子类，我想知道如何访问父类中的子类变量..

我试过这个，但失败了 -

class Parent(object):
    def __init__(self):
        print x

class Child(Parent):
    x = 1;            

x = Child();

错误：-

NameError: global name 'x' is not defined

这个问题与我们继承表单类并声明一些类变量的 Django 表单有关。

例如：-

我的表格看起来像这样

from django import forms

class EmployeeForm(forms.Form):
      fname = forms.CharField(max_length=100)
      lname = forms.CharField(max_length=100)

我相信表单字段被视为类变量并以某种方式传递给父类..

我想__init__.py通过以下方式为我的包的文件中的另一个函数分配另一个函数:

llen = len
len = lambda x: llen(x) - 1

它工作正常,但只在__init__.py文件中.如何让它影响我的包中的其他模块？

我是python的新手。我试图使用 super() 方法访问子类中的父类变量，但它抛出错误“无参数”。使用类名访问类变量有效，但我想知道是否可以使用 super() 方法访问它们。

class Parent(object):
        __props__ = (
            ('a', str, 'a var'),
            ('b', int, 'b var')
        )

        def __init__(self):
            self.test = 'foo'

class Child(Parent):
    __props__ = super().__props__ + (
        ('c', str, 'foo'),
    ) # Parent.__props__


    def __init__(self):
        super().__init__()

错误：

    __props__ = super().__props__ + (
RuntimeError: super(): no arguments

我知道标题可能有点混乱，所以让我举个例子。假设您有一个基类Base，它旨在被子类化以创建更复杂的对象。但是您还有一些可选功能，您不需要每个子类都需要这些功能，因此您将它放在一个二级类中OptionalStuffA，该二级类始终打算与基类一起进行子类化。你也应该让那个次要类成为 的子类Base吗？

这当然是唯一相关，如果你有一个以上的OptionalStuff班，你想给他们以不同的方式结合起来，否则你不需要子类均Base和OptionalStuffA（，只是有OptionalStuffA成为的一个子类Base，所以你只需要在子类OptionalStuffA）。我Base知道如果从Base.

下面是一个示例场景。我还将QObject该类作为“第三方”令牌类放入该类，其功能对于其中一个辅助类工作是必需的。我在哪里子类化它？下面的例子显示了我到目前为止是如何做到的，但我怀疑这是要走的路。

from PyQt5.QtCore import QObject

class Base:
    def __init__(self):
        self._basic_stuff = None

    def reset(self):
        self._basic_stuff = None


class OptionalStuffA:
    def __init__(self):
        super().__init__()
        self._optional_stuff_a = None

    def reset(self):
        if hasattr(super(), 'reset'):
            super().reset()
        self._optional_stuff_a = None

    def do_stuff_that_only_works_if_my_children_also_inherited_from_Base(self):
        self._basic_stuff = not None


class OptionalStuffB:
    def __init__(self):
        super().__init__()
        self._optional_stuff_b = None

    def reset(self):
        if hasattr(super(), 'reset'): …

使用继承自Base类的SQLAlchemy对象,我可以将参数传递给类,而不是在构造函数中定义的变量:

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, Sequence('user_id_seq'), primary_key=True)
    name = Column(String(50))
    fullname = Column(String(50))
    password = Column(String(12))

    def __repr__(self):
        return "<User(name='%s', fullname='%s', password='%s')>" % (
                                self.name, self.fullname, self.password)

ed_user = User(name='ed', fullname='Ed Jones', password='edspassword')

当然,如果我尝试将这样的参数传递给另一个类,以同样的方式设置类变量我会收到错误:

In [1]: class MyClass(object):
   ...:     i = 2
   ...:     

In [2]: instance = MyClass(i=9)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-6d3ec8445b00> in <module>()
----> 1 instance = MyClass(i=9)

TypeError: object.__new__() takes no …