如何通过__dict__分配新的类属性？
在Python中，__dict__是一个特殊的属性，它用于存储对象的属性和方法。要通过__dict__分配新的类属性，您可以将属性添加到类的__dict__属性中。以下是一个示例：
class MyClass:
def __init__(self, name, age):
self.name = name
self.age = age
def assign_attribute(self, key, value):
self.__dict__[key] = value
# 创建一个MyClass的实例
my_instance = MyClass("Alice", 30)
# 通过assign_attribute方法，将新属性添加到my_instance的__dict__中
my_instance.assign_attribute("city", "New York")
# 输出my_instance的__dict__属性，以查看新添加的属性
print(my_instance.__dict__)输出：
{'name': 'Alice', 'age': 30, 'city': 'New York'}在这个示例中，我们定义了一个名为MyClass的类，该类具有name和age属性。我们还定义了一个名为assign_attribute的方法，该方法接受一个键和一个值作为参数，并将它们添加到对象的__dict__属性中。
然后，我们创建了一个MyClass的实例，并使用assign_attribute方法将新属性添加到实例的__dict__中。最后，我们输出实例的__dict__属性，以查看新添加的属性。
相关·内容
>>> a = object()
>>> a.x = 5
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'object' object has no attribute 'x'
>>> b = lambda:0
>>> b.x = 5
>>> b.x
5
为什么object类的实例没有一个__dict__
浏览 4提问于2016-11-28得票数 10
回答已采纳
根据Python2.7.12的文档：
如果__setattr__()想要为一个实例属性赋值，它不应该简单地执行self.name = value --这将导致对自身的递归调用。相反，它应该在实例属性的字典中插入值，例如self.__dict__[name] = value。用于新样式类的object.__setattr__(self, name, value).，而不是访问实例字典，它应该调用同名的基类方法，例如， 。
但是，下列代码的工作方式与人们所期望的一样：
class Class(object):
def __setattr__(self, name, val):
浏览 2提问于2016-07-31得票数 0
回答已采纳
我有一个类分数，它的init创建实例变量self.num = num和self.denom=denom
def __init__(self,num=0,denom=1):
assert isinstance(num, int), "Numerator and denominator must be an integer"
assert isinstance(denom, int), "Numerator and denominator must be an integer"
assert denom !=
浏览 2提问于2021-10-20得票数 0
回答已采纳
来自
注意，定制Python实例的__dict__属性是一个；实例本身没有该属性，而是提供它的类(因此返回type(instance).__dict__['__dict__'].__get__(instance) )。object.__dict__可能存在，但object.__dict__['__dict__']不存在。
为什么自定义Python类实例的__dict__属性是类的描述符，而不是实例的实际属性？
浏览 0提问于2017-10-05得票数 4
回答已采纳
我想要创建一个类，它的行为类似于numpy数组，但是拥有额外的方法/属性，并且一直在读取和不完全理解numpy子类ndarray的。在那个网页上有一个例子
import numpy as np
class RealisticInfoArray(np.ndarray):
def __new__(cls, input_array, info=None):
# Input array is an already formed ndarray instance
# We first cast to be our class type
obj
浏览 3提问于2021-11-12得票数 2
回答已采纳
我是一个完整的Python新手，所以我的问题似乎很愚蠢。我看到了在Python中为对象属性赋值的两种方法：
使用__dict__
class A(object):
def __init__(self,a,b):
self.__dict__['a'] = a
self.__dict__['b'] = b
无__dict__
class A(object):
def __init__(self,a,b):
self.a = a
self.b = b
有谁能解释一下有什么区别吗？
浏览 4提问于2013-08-05得票数 1
回答已采纳
为什么可以为Python中的每个类实例动态定义一个新属性，只要它不是object类型的
class NewStyle(object):
pass
class OldStyle:
pass
a = object()
# This line raises AttributeError
a.foo = 1
# All of these work fine
a = Exception()
a.foo = 1
a = OldStyle()
a.foo = 1
a = NewStyle()
a.foo = 1
在Python 3中，这种行为似乎是相同的。
浏览 3提问于2014-09-03得票数 0
回答已采纳
3回答
首先是密码，
#Python 2.7
>>>class A(object):
pass
>>>a1 = A()
>>>a2 = A()
>>>A.__dict__
dict_proxy({'__dict__': <attribute '__dict__' of 'A' objects>, '__module__': '__main__', '__weakref__': <attribute
浏览 3提问于2012-05-08得票数 3
在以下简单的Python代码中：
>>> class C:
... class_level_var = 5
...
>>> C.__dict__
mappingproxy({'__module__': '__main__', 'class_level_var': 5, '__dict__': <attribute '__dict__' of
'C' objects>, '__weakref__': <attribute '
浏览 0提问于2021-02-06得票数 0
为什么这段代码是为我运行的？
class Foo():
__slots__ = []
def __init__(self):
self.should_not_work = "or does it?"
print "This code does not run,",self.should_not_work
Foo()
我认为插槽是一种限制。我正在运行Python2.6.6。
浏览 6提问于2011-02-01得票数 6
回答已采纳
2回答
当我运行这段代码时：
a = '1'
vars()['a'] = '2'
print a
我得到以下输出：
2
但是当我运行这段代码时：
def bar():
a = '1'
vars()['a'] = '2'
print a
bar()
我得到以下输出：
1
现在我的问题是为什么会发生这种情况，以及如何使第二种情况给出与第一种情况相同的解决方案。
编辑：
我真的找不到解决方案，但我找到了一个小技巧……尽管我不想使用exec：
def bar():
a = "
浏览 0提问于2012-04-24得票数 3
>>> class A(object): pass
...
>>> A.__dict__
<dictproxy object at 0x173ef30>
>>> A.__dict__.__dict__
Traceback (most recent call last):
File "<string>", line 1, in <fragment>
AttributeError: 'dictproxy' object has no attribute '__di
浏览 40提问于2011-02-03得票数 101
回答已采纳
希望避免出现这种情况：
>>> class Point:
x = 0
y = 0
>>> a = Point()
>>> a.X = 4 #whoops, typo creates new attribute capital x
我创建了以下对象作为超类使用：
class StrictObject(object):
def __setattr__(self, item, value):
if item in dir(self):
object.__setattr__(self, item, v
浏览 3提问于2012-03-10得票数 15
回答已采纳
我不明白Python中“静态”类数据是如何工作的。我试图复制我在Java中经常使用的模式，在那里我创建了一个中央的faux-数据库类，并将它的实例提供给任何需要它的类。
然而，这里是我迷上Python的地方，似乎每当我尝试访问“静态”变量时，我都会创建一个实例级别1。这很让人困惑。
下面是代码：
import csv
class Database(object):
data = list()
def __init__(self):
pass
def connect(self, location=None):
path = '
浏览 7提问于2013-01-15得票数 1
回答已采纳
我想访问类中的属性，这样我就可以动态地更改它们。
我在这个网站上看到的答案表明，类的__dict__将提供这一点，就像我尝试使用以下代码一样：
class Item:
def __init__(self):
self.name = ''
self.description = ''
self.weight = ''
self.volume = ''
print(Item.__dict__)
{'__module__': '__main
浏览 0提问于2019-04-08得票数 1
如果我像这样创建一个类实例
class MyClass(object):
pass
x = MyClass()
然后，我可以将x上的属性设置为：
x.myAttr = 1或x.__setattr__('myAttr', 1)
但是，如果我做了一个
d = {}
我不能在上面设置属性。例如，如果我这样做
d.__setattr__('myAttr', 1)
我得到了错误“'dict‘对象没有属性'myAttr’”--如果我尝试相同的情况
d.myAttr = 1
我注意到，在x.myAttr =1的情况下，实际发生的情况是
x.__dict
浏览 5提问于2012-06-05得票数 6
2回答
可以通过dir(someObject)或someObject.__dict__获得对象的所有可迭代属性。如何获得不可迭代的属性？某些库，例如Reqest，返回具有不可迭代属性的对象。
浏览 4提问于2013-10-29得票数 0
回答已采纳
我对python有个问题。
我有一个自定义__getattr__的类
class ChoiceNumToName(object):
def __init__(self, django_choice_tuple):
self.ods_choice_tuple = django_choice_tuple
self.choice_data = {}
self.choice_point = -1
for choice_value, choice_name in django_choice_tuple:
se
浏览 0提问于2017-11-15得票数 7
class Foo:
bar = 1
......etc.
我知道在创建实例时，bar是在__init__之前创建的，我想知道在为Foo创建实例时创建bar属性是否是第一件事。此外，在创建任何实例之前，该条是否已经存在于内存中？
浏览 10提问于2013-09-25得票数 3
回答已采纳
3回答
我想知道为什么类__dict__是mappingproxy，而实例__dict__只是一个普通的dict
>>> class A:
... pass
>>> a = A()
>>> type(a.__dict__)
<class 'dict'>
>>> type(A.__dict__)
<class 'mappingproxy'>
浏览 1提问于2015-09-22得票数 96
回答已采纳
2回答
类型的__dict__是一个只读的dictproxy对象。我想知道它的目的是什么。它仅仅是为了“不允许修改内置类型”吗？我找到了一种能绕着它走的方法。我知道修改内置类型不是个好主意。但我正在尝试修改Cython的cdef class。
我想知道这样修改__dict__ of cdef class有什么危险吗？
以下是代码：
import gc
gc.get_referents(float.__dict__)[0]["square"] = lambda self: self*self
(3.14).square()
浏览 11提问于2014-08-22得票数 25
我一直在处理多处理和C++扩展，我不太了解__getstate_manages_dict__函数(我知道如何使用它，但我不太确定它是如何工作的)。说：
Boost.Python扩展类的作者可能提供一个__getstate__方法，而不考虑在Python中使用他的类作为基类的可能性。很可能，需要对派生类实例的dict进行筛选，以便正确恢复实例。*用户直接将项添加到实例的__dict__中。同样，需要对实例的__dict__进行腌制。为了提醒用户注意这个非常不明显的问题，我们提供了一个安全防护装置。如果定义了__getstate__，且实例的__dict__不是空的，则Boost.Python将
浏览 7提问于2020-07-22得票数 0
回答已采纳
1回答
以声明方式设置类__name__
、、、、
为什么不能以声明方式覆盖类名，例如使用不是有效标识符的类名？
>>> class Potato:
... __name__ = 'not Potato'
...
>>> Potato.__name__ # doesn't stick
'Potato'
>>> Potato().__name__ # .. but it's in the dict
'not Potato'
我想，也许这只是在类定义块完成后被覆盖的一种情况。但这似乎不是真的，因为名称是可写的，
浏览 0提问于2018-04-11得票数 12
回答已采纳
我想知道为什么可以为自定义类型的实例创建新属性(“新”表示“未在类体中定义”)，但不能为内置类型创建新属性(“新”表示“未在类体中定义”)，例如object本身。
代码示例：
>>> class SomeClass(object):
... pass
...
>>> sc = SomeClass()
>>> sc.name = "AAA"
>>> sc.name
'AAA'
>>> obj = object()
>>> obj.name = &#
浏览 0提问于2010-07-31得票数 10
回答已采纳
假设我有一个Python类，它包含在构造函数中创建的属性和使用property装饰器创建的计算属性的混合：
class Example:
def __init__(self):
self.foo = 1
@property
def bar(self):
return 2
def baz(self, x):
return x * x
我想要生成一个包含这两种属性的字典，但是没有其他的。然而，如果我做了vars(Example())，我只能得到foo。如果我做了dir(Example())，我会得到foo和bar
浏览 4提问于2017-05-17得票数 1
回答已采纳
因此，假设我想编写自己的类，重写__getattribute__函数。每当有人调用未定义的属性时，我都希望它生成一个随机int。
X = GetAttribute()
print(X.predefined_attribute) # "First attribute"
X.attr2 = "Hi"
print(X.attr2) # "Hi"
print(X.attr3) # random int
显然，我不能写这样的东西，因为它会导致递归。
class GetAttribute(object):
def __init__(self):
浏览 10提问于2017-05-31得票数 1
回答已采纳
1回答
我正试图向一个带有装饰器的类中注入一个混合器。当代码运行时，类不再具有、dict、属性，尽管dir(实例)表示它有一个属性。我不知道财产在哪里消失。是否有一种方法可以获得、dict、或其他方法来查找实例的属性？
def testDecorator(cls):
return type(cls.__name__, (Mixin,) + cls.__bases__, dict(cls.__dict__))
class Mixin:
pass
@testDecorator
class dummyClass:
def __init__(self):
浏览 0提问于2017-12-27得票数 1
回答已采纳
下面的代码按排序顺序列出了一个名为“A”的类的属性：
>>> class A():
def __init__(self, i):
self.at = i
>>> sorted(vars(A))
['__dict__', '__doc__', '__init__', '__module__', '__weakref__']
现在，打印键值，'__dict__'的结果是：-
>>> vars(A)['
浏览 3提问于2020-07-03得票数 5
回答已采纳
在python中，如何在不显式调用对象属性的情况下访问它们？然后打印那些属性？
例如：
class MyClass:
def __init__(self):
self.prop1 = None
self.prop2 = 10
def print_properties(self):
# Print the property name and value
example_a = MyClass()
example_a.print_properties()
期望产出：
prop1: None
prop2: 10
不同于：，因为有人指出，不建议访问
浏览 0提问于2018-04-17得票数 0
回答已采纳
(用Python shell编写)
>>> o = object()
>>> o.test = 1
Traceback (most recent call last):
File "<pyshell#45>", line 1, in <module>
o.test = 1
AttributeError: 'object' object has no attribute 'test'
>>> class test1:
pass
>>&g
浏览 0提问于2009-08-16得票数 66
回答已采纳
3回答
我在一个函数上测试预定义的dict属性，我得到了一个意想不到的结果。考虑以下代码：
>>> def func():
x = 7
a = 0
print(func.__dict__)
>>> func()
{}
毕竟，我确实在函数的命名空间中定义了两个变量。那么为什么这些名称没有出现在函数的dict属性中呢？
浏览 2提问于2020-08-20得票数 0
回答已采纳
我看到了这个Borg Singleton模式代码，但是我无法理解我添加到单例对象中的新成员是如何被附加到__shared_state = {}字典中的。
这是单例代码
class Borg(object):
_shared_state = {}
def __new__(cls,*args,**kwargs):
obj = super(Borg,cls).__new__(cls,*args,**kwargs)
obj.__dict__ = cls._shared_state
return obj
class Child(Borg
浏览 4提问于2017-07-25得票数 6
回答已采纳
是否可以创建既没有__slots__也没有__dict__的python对象
浏览 7提问于2018-08-13得票数 1
我的问题很简单，我有：
class upperstr(str):
def __new__(cls, arg):
return str.__new__(cls, str(arg).upper())
为什么，如果我的__new__()方法直接使用不可变类型(str)的实例，那么我的新类型(upperstr)的实例是可变的？
>>> s = str("text")
>>> "__dict__" in dir(s)
False
>>> s = upperstr("text")
浏览 0提问于2011-11-26得票数 1
回答已采纳
我将这样一个简单的类定义如下：
>>> class myclass(object):
name = "google"
我正在创建一个实例来调用name属性
>>> a = myclass()
>>> a.name
'google'
也直接从类本身调用它。
>>> myclass.name
'google'
到目前为止(因为我有C#和Java的背景)，我将调用myclass.name静态调用，从实例调用静态成员是可以的。
但是我观察到的是，直到我用另一个值设置a.nam
浏览 4提问于2011-11-14得票数 0
回答已采纳
来自
object没有__dict__，因此不能将任意属性分配给object类的实例。
为什么"object没有__dict__"？对我来说很管用
>>> object.__dict__
mappingproxy({'__repr__': <slot wrapper '__repr__' of 'object' objects>, '__hash__': <slot wrapper '__hash__' of 'object' object
浏览 1提问于2017-07-03得票数 3
回答已采纳
我知道wraps具有如下属性：
但是我想知道如何使用assigned和updated参数，有人有例子吗？
浏览 2提问于2015-04-29得票数 8
我有以下课程：
class TestClass(object):
def __init__(self, **kwargs):
for key, value in kwargs.items(): #items return list of dict
setattr(self, key, value)
典型用途：
obj = MessageItem(**{"testkey1":"tval1", "tkey2":"tval2", "tkey3":"tval3"})
在不知道属性名称
浏览 2提问于2017-08-28得票数 5
在我正在开发的游戏中，我遇到了一个棘手的问题。我正在使用Pygame来开发它。我碰巧是那些从不使用默认__dict__对象变量的开发人员之一；我总是定义__slots__来阐明对象可以拥有的变量(我有一个类方法，它读取插槽以确定配置文件中所需的变量)。
无论如何，我刚刚意识到这种努力在我的一些类中是行不通的；尽管它们显式地定义了它们的__slots__，但它们仍然有一个__dict__变量，并且可以分配任意的属性。我认为这是因为他们继承了pygame.sprite.Sprite，它有一个__dict__。如果是这种情况，我如何禁止创建此字典？(我认为应该明确定义__slots__ )，或者我可
浏览 1提问于2011-06-11得票数 5
回答已采纳
最近我学习了Python，但是我有一个关于__slots__的问题。在我看来，它是为了限制Class中的参数，但也是为了限制Class中的方法？
例如：
from types import MethodType
Class Student(object):
__slots__=('name','age')
当我运行代码时：
def set_age(self,age):
self.age=age
stu=Student()
stu.set_age=MethodType(set_age,stu,Student)
print stu.age
An erro
浏览 0提问于2015-01-21得票数 1
1回答
包装函数隐藏其属性？
、、、、
这是我上一个问题的延续。
如果我已经包装了一个函数，以便它使用下面的装饰符来记录调用它的时间：
def keep_count(f):
@wraps(f)
def wrapped_f(*args, **kwargs):
f(*args, **kwargs)
wrapped_f.count += 1
wrapped_f.count = 0
return wrapped_f
然后我想再用别的东西来包装它：
def decorator2(fn):
@wraps(fn)
def fn_wrapper(*args, **kwa
浏览 2提问于2015-01-14得票数 3
回答已采纳
假设我有一个A类：
class A(object):
def __init__(self, x):
self.x = x
def __str__(self):
return self.x
我使用sys.getsizeof来查看A的实例占用了多少字节：
>>> sys.getsizeof(A(1))
64
>>> sys.getsizeof(A('a'))
64
>>> sys.getsizeof(A('aaa'))
64
如上面的实验所示，无论self.x是什
浏览 0提问于2010-10-31得票数 9
回答已采纳
4回答
假设我有一个包含__slots__的类
class A:
__slots__ = ['x']
a = A()
a.x = 1 # works fine
a.y = 1 # AttributeError (as expected)
现在我要更改A的__slots__。
A.__slots__.append('y')
print(A.__slots__) # ['x', 'y']
b = A()
b.x = 1 # OK
b.y = 1 # AttributeError (why?)
b是在A的__slo
浏览 0提问于2015-01-13得票数 9
>>> dir(classAInstance.objectTInstance.__dict__)
['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__',
'__ge__', '__getattribute__', '__getitem__', '__gt__'
浏览 1提问于2012-03-04得票数 1
回答已采纳
如果类实例不存在，我必须为它设置属性。我正在使用下面的代码来实现这个目标：
class O(object):
pass
o = O()
if not hasattr(o, 'some_attr'):
setattr(o, 'some_attr', None)
print o.some_attr
是否有更好的方法来执行这样的行动？
浏览 4提问于2016-02-05得票数 2
回答已采纳
3回答
Python 3.4.0a1
Windows 8.1
类创建的类：
class Bank(object):
bankrupt = False
命令输入空闲__main__，其结果如下：
>>> a = Bank()
>>> b = Bank()
>>> a.bankrupt
False
>>> b.bankrupt
False
>>> b.bankrupt = True
>>> b.bankrupt
True
>>> a.bankrupt
False
预
浏览 7提问于2014-06-30得票数 2
回答已采纳
1回答
返回属性名和类型值的切分
、、、
NewType=type('nt',(object,),{'x':'hello'})
n=NewType()
n.x
'hello'
如何从n中获得dict {'x':'hello'}？
尝试失败：n.__bases__, n.__dir__, n.__dict__
浏览 4提问于2014-04-23得票数 1
回答已采纳
当我从名称元组继承一个类时，为什么__dict__是空的？下面是准备显示的最小代码。您可以看到x.__dict__是空的，但是z.__dict__有这个信息。
from collections import namedtuple
Person = namedtuple('Person', 'name age')
class Student(Person):
def print(self):
print(self.name)
x = Student("Tom",25)
class Employee:
def _
浏览 8提问于2021-02-03得票数 1
回答已采纳
2回答
如果之前有人问过这个问题，很抱歉。在类的__init__方法中没有定义属性的情况下，是否可以在Python中动态创建类。
例如，使用这个类
class Person(object):
def __init__(self):
...
我可以在初始化期间动态地放入属性，如下所示：
person = Person(name='Joe')
并像这样访问它：
person.name
>>> Joe
谢谢
浏览 2提问于2011-03-01得票数 5
回答已采纳
1回答
可能重复：
In [67]: obj = object()
In [68]: obj.x = 42
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
/home/user/<ipython-input-68-0203a27904ca> in <module>()
----> 1 obj.x = 4
浏览 2提问于2012-07-22得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
