Python：如何从类变量访问class .__ dict__？

Question

我需要定义一个名为“ class”的类变量。 我想直接在类名称空间而不是在类方法中执行此操作。 显然，我不能直接说：

class MyClass(object):
    a = 1
    b = 2
    class = 3

所以，我想做类似的事情：

class MyClass(object):
    a = 1
    b = 2
    self.__dict__["class"] = 3

其中“ self ”应替换为对该类的引用。 那么，如何从类名称空间引用一个类呢？

---

注意：这个问题看似人为，但这是出于实际目标。

实际上， MyClass是Django REST框架的序列化程序，我需要在其上定义“类”字段，因为该REST端点必须遵循某种协议。

有一个为Serializers定义的元类，它在类创建时调用__new__() ，而__new__()聚集在类上定义的所有字段，并使用它们填充字段注册表。 因此，我必须在创建class之前定义变量class 。 另请参阅： Django REST Framework：如何使字段的详细名称与其字段名称不同？

Answer 1

您可以这样做：

class MyClass(object):
    a = 1
    b = 2
    vars()['class'] = 3

但是，由于class是保留关键字，因此您必须使用getattr和setattr访问变量，以便class仍然是字符串。

>>> m = MyClass()
>>> getattr(m, 'class')
3

Answer 2

您可以从type创建您的类，并将属性class添加到类字典中：

>>> MyClass = type('MyClass', (), {'class': 3, 'a':1, 'b':2})
>>> getattr(MyClass, 'class')
3

您不能直接使用点引用访问名称class ，而需要使用getattr ：

>>> MyClass.class
  File "<stdin>", line 1
    MyClass.class
                ^
SyntaxError: invalid syntax

FWIW，您可以像常规方式那样定义类方法，然后稍后将它们绑定到类。

警告 ：虽然可以使用，但我自己不会使用这种技巧，因为关键字class太多了，无法篡改。

Answer 3

您无需命名属性class ，这会导致各种问题。 您可以命名属性class_ ，但仍然可以将其从名为class的源属性中提取出来，并作为class呈现给JSON。

您可以通过重写序列化器的元类来实现。 这是一个serializers.py文件的示例（模型和类在很大程度上是从教程中直接获取的）。

主要魔术是元类的这一部分

# Remap fields (to use class instead of class_)
fields_ = []
for name, field in fields:
    if name.endswith('_'):
        name = name.rstrip('_')
    fields_.append((name, field))

这需要你在一个下划线（即结束串定义的任何字段field_ ），当它结合了删除名称中使用下划线Fields ，并设置_declared_fields在串行属性。

from collections import OrderedDict

from rest_framework import serializers
from rest_framework.fields import Field
from snippets.models import Snippet, LANGUAGE_CHOICES, STYLE_CHOICES

class MyMeta(serializers.SerializerMetaclass):

    @classmethod
    def _get_declared_fields(cls, bases, attrs):
        fields = [(field_name, attrs.pop(field_name))
                  for field_name, obj in list(attrs.items())
                  if isinstance(obj, Field)]
        fields.sort(key=lambda x: x[1]._creation_counter)

        # If this class is subclassing another Serializer, add that Serializer's
        # fields.  Note that we loop over the bases in *reverse*. This is necessary
        # in order to maintain the correct order of fields.
        for base in reversed(bases):
            if hasattr(base, '_declared_fields'):
                fields = list(base._declared_fields.items()) + fields

        # Remap fields (to use class instead of class_)
        fields_ = []
        for name, field in fields:
            if name.endswith('_'):
                name = name.rstrip('_')
            fields_.append((name, field))

        return OrderedDict(fields_)


class SnippetSerializer(serializers.Serializer):

    __metaclass__ = MyMeta

    pk = serializers.IntegerField(read_only=True)
    title = serializers.CharField(required=False, allow_blank=True, max_length=100)
    class_ = serializers.CharField(source='klass', label='class', default='blah')

    def create(self, validated_data):
        """
        Create and return a new `Snippet` instance, given the validated data.
        """
        return Snippet.objects.create(**validated_data)

    def update(self, instance, validated_data):
        """
        Update and return an existing `Snippet` instance, given the validated data.
        """
        instance.title = validated_data.get('title', instance.title)
        instance.class_ = validated_data.get('class', instance.class_)
        instance.save()
        return instance

这是供参考的models.py文件（django不允许字段名称以下划线结尾）

from django.db import models

class Snippet(models.Model):
    title = models.CharField(max_length=100, blank=True, default='')
    klass = models.CharField(max_length=100, default='yo')

这是从Django shell看起来的样子

$ python manage.py shell

>>> from snippets.models import Snippet
>>> from snippets.serializers import SnippetSerializer
>>> from rest_framework.renderers import JSONRenderer
>>> from rest_framework.parsers import JSONParser
>>> snippet = Snippet(title='test')
>>> snippet.save()
>>> serializer = SnippetSerializer(snippet)
>>> serializer.data
{'title': u'test', 'pk': 6, 'class': u'yo'}

Answer 4

创建类时无法做到这一点-从技术上讲该对象尚不存在。

您可以考虑：

class MyClass(object):
    a = 1
    b = 2

# class is already created
MyClass.__dict__["class"] = 3

但是MyClass.__dict__不是字典，而是dictproxy和'dictproxy' object does not support item assignment ，因此会TypeError 。

Answer 5

完成类定义后，立即使用“''setattr''''设置类属性。 当然，超出定义。 传递'''MyClass'''作为参数，它将创建您的类的属性。

成员的Dict不应该使用，尤其是在修改对象时。 实际上，几乎不需要它。 人们通常打算做的大多数事情（尽管不是全部）最好由'''setattr'''和'''getattr'''完成。

最后，正如那些回答的人所注意到的那样，您实际上并不需要一个名为“''class''''的字段，但这是另一个故事，与您的原始问题不同。