blocks|key|1002100|text|您可以引入一个新函数来执行从dict到dataclass的给定转换：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1002101|import+inspect
from+dataclasses+import+dataclass

@dataclass
class+Req:
++++id:+int
++++description:+str

def+from_dict_to_dataclass(cls,+data):
++++return+cls(
++++++++**{
++++++++++++key:+(data[key]+if+val.default+==+val.empty+else+data.get(key,+val.default))
++++++++++++for+key,+val+in+inspect.signature(Req).parameters.items()
++++++++}
++++)

from_dict_to_dataclass(Req,+{"id":+123,+"description":+"hello",+"data_a":+""})
#+Output:+Req(id=123,+description='hello')|code-block|syntax|javascript|1002102|注意，需要if+val.default+==+val.empty条件来检查数据集是否有默认值集。如果这是真的，那么在构造数据块时，我们应该考虑给定的值。|offset|length|style|CODE|1002103|entityMap^0|0|0|5|R|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can possibly introduce a new function that will perform the given conversion from dict to dataclass:
<pre><code>import inspect
from dataclasses import dataclass

@dataclass
class Req:
 id: int
 description: str

def from_dict_to_dataclass(cls, data):
 return cls(
 **{
 key: (data[key] if val.default == val.empty else data.get(key, val.default))
 for key, val in inspect.signature(Req).parameters.items()
 }
 )

from_dict_to_dataclass(Req, {&quot;id&quot;: 123, &quot;description&quot;: &quot;hello&quot;, &quot;data_a&quot;: &quot;&quot;})
# Output: Req(id=123, description='hello')
</code></pre>
Note, <code>if val.default == val.empty</code> condition is needed in order to check if your dataclass has a default value set. If it's true then we should take the given value into consideration when constructing a dataclass.

blocks|key|1993431|text|解决这一问题的方法是截取数据集的数据集并筛选出不被识别的字段。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1993432|from+dataclasses+import+dataclass,+fields

@dataclass
class+Req1:
++++id:+int
++++description:+str


@dataclass
class+Req2:
++++id:+int
++++description:+str

++++def+__init__(self,+**kwargs):
++++++++for+key,+value+in+kwargs.items():
++++++++++++if+key+in+REQ2_FIELD_NAMES:
++++++++++++++++setattr(self,+key,+value)

#+To+not+re-evaluate+the+field+names+for+each+and+every+creation+of+Req2,+list+them+here.
REQ2_FIELD_NAMES+=+{field.name+for+field+in+fields(Req2)}

data+=+{
++++"id":+1,
++++"description":+"some",
++++"data_a":+None,
}

try:
++++print("Call+for+Req1:",+Req1(**data))
except+Exception+as+error:
++++print("Call+for+Req1:",+error)

try:
++++print("Call+for+Req2:",+Req2(**data))
except+Exception+as+error:
++++print("Call+for+Req2:",+error)|code-block|syntax|javascript|1993433|输出：|1993434|Call+for+Req1:+__init__()+got+an+unexpected+keyword+argument+'data_a'
Call+for+Req2:+Req2(id=1,+description='some')|1993435|有关问题：|1993436|如何忽略传递给数据类的额外参数？|unordered-list-item|1993437|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/dataclasses.html|1|2|https://stackoverflow.com/questions/54678337/how-does-one-ignore-extra-arguments-passed-to-a-data-class^0|C|3|0|G|3|1|0|0|0|0|0|0|G|2|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]|$A|16|B|17|1|18]]|C|$]]|$1|D|3|E|5|F|7|19|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1A|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1B|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1C|8|@]|9|@]|C|$]]|$1|O|3|P|5|Q|7|1D|8|@]|9|@$A|1E|B|1F|1|1G]]|C|$]]|$1|R|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]|Z|$5|U|V|W|C|$X|Y]]|10|$5|U|V|W|C|$X|11]]]]

A workaround to this is by intercepting the <code>__init__</code> of the <a href="https://docs.python.org/3/library/dataclasses.html" rel="nofollow noreferrer">dataclass</a> and filter out the fields that are not recognized.
<pre><code>from dataclasses import dataclass, fields

@dataclass
class Req1:
 id: int
 description: str


@dataclass
class Req2:
 id: int
 description: str

 def __init__(self, **kwargs):
 for key, value in kwargs.items():
 if key in REQ2_FIELD_NAMES:
 setattr(self, key, value)

# To not re-evaluate the field names for each and every creation of Req2, list them here.
REQ2_FIELD_NAMES = {field.name for field in fields(Req2)}

data = {
 &quot;id&quot;: 1,
 &quot;description&quot;: &quot;some&quot;,
 &quot;data_a&quot;: None,
}

try:
 print(&quot;Call for Req1:&quot;, Req1(**data))
except Exception as error:
 print(&quot;Call for Req1:&quot;, error)

try:
 print(&quot;Call for Req2:&quot;, Req2(**data))
except Exception as error:
 print(&quot;Call for Req2:&quot;, error)
</code></pre>
Output:
<pre><code>Call for Req1: __init__() got an unexpected keyword argument 'data_a'
Call for Req2: Req2(id=1, description='some')
</code></pre>
Related question:
<ul>
<li><a href="https://stackoverflow.com/questions/54678337/how-does-one-ignore-extra-arguments-passed-to-a-data-class">How does one ignore extra arguments passed to a data class?</a></li>
</ul>

blocks|key|1993464|text|这里有一个可以用于任何类的解决方案。它只需过滤输入字典，就可以排除不是init==True类的字段名的键。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1993465|from+dataclasses+import+dataclass,+fields

@dataclass
class+Req:
++++id:+int
++++description:+str

def+classFromArgs(className,+argDict):
++++fieldSet+=+{f.name+for+f+in+fields(className)+if+f.init}
++++filteredArgDict+=+{k+:+v+for+k,+v+in+argDict.items()+if+k+in+fieldSet}
++++return+className(**filteredArgDict)

data+=+{"id":+123,+"description":+"hello",+"data_a":+""}
req+=+classFromArgs(Req,+data)
print(req)|code-block|syntax|javascript|1993466|输出：|1993467|Req(id=123,+description='hello')|1993468|UPDATE：上面的策略有一个变化，它创建了一个实用工具类，为使用它的每个数据集缓存dataclasses.fields+(这是由@rv.kvetch对同一数据集的多次调用表示对dataclasses.fields重复处理的性能关注)。|BOLD|1993469|from+dataclasses+import+dataclass,+fields

class+DataClassUnpack:
++++classFieldCache+=+{}

++++@classmethod
++++def+instantiate(cls,+classToInstantiate,+argDict):
++++++++if+classToInstantiate+not+in+cls.classFieldCache:
++++++++++++cls.classFieldCache[classToInstantiate]+=+{f.name+for+f+in+fields(classToInstantiate)+if+f.init}

++++++++fieldSet+=+cls.classFieldCache[classToInstantiate]
++++++++filteredArgDict+=+{k+:+v+for+k,+v+in+argDict.items()+if+k+in+fieldSet}
++++++++return+classToInstantiate(**filteredArgDict)

@dataclass
class+Req:
++++id:+int
++++description:+str
req+=+DataClassUnpack.instantiate(Req,+{"id":+123,+"description":+"hello",+"data_a":+""})
print(req)
req+=+DataClassUnpack.instantiate(Req,+{"id":+456,+"description":+"goodbye",+"data_a":+"my",+"data_b":+"friend"})
print(req)

@dataclass
class+Req2:
++++id:+int
++++description:+str
++++data_a:+str
req2+=+DataClassUnpack.instantiate(Req2,+{"id":+123,+"description":+"hello",+"data_a":+"world"})
print(req2)

print("\nHere's+a+peek+at+the+internals+of+DataClassUnpack:")
print(DataClassUnpack.classFieldCache)|1993470|1993471|Req(id=123,+description='hello')
Req(id=456,+description='goodbye')
Req2(id=123,+description='hello',+data_a='world')

Here's+a+peek+at+the+internals+of+DataClassUnpack:
{<class+'__main__.Req'>:+{'description',+'id'},+<class+'__main__.Req2'>:+{'description',+'data_a',+'id'}}|1993472|entityMap^0|Z|A|0|0|0|0|0|6|16|I|2H|I|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|Q]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|R|3|S|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|T|3|L|5|6|7|1C|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|X|$]]

Here's a solution that can be used generically for any class. It simply filters the input dictionary to exclude keys that aren't field names of the class with <code>init==True</code>:
<pre class="lang-py prettyprint-override"><code>from dataclasses import dataclass, fields

@dataclass
class Req:
 id: int
 description: str

def classFromArgs(className, argDict):
 fieldSet = {f.name for f in fields(className) if f.init}
 filteredArgDict = {k : v for k, v in argDict.items() if k in fieldSet}
 return className(**filteredArgDict)

data = {&quot;id&quot;: 123, &quot;description&quot;: &quot;hello&quot;, &quot;data_a&quot;: &quot;&quot;}
req = classFromArgs(Req, data)
print(req)
</code></pre>
Output:
<pre><code>Req(id=123, description='hello')
</code></pre>
UPDATE: Here's a variation on the strategy above which creates a utility class that caches <code>dataclasses.fields</code> for each dataclass that uses it (prompted by a comment by @rv.kvetch expressing performance concerns around duplicate processing of <code>dataclasses.fields</code> by multiple invocations for the same dataclass).
<pre class="lang-py prettyprint-override"><code>from dataclasses import dataclass, fields

class DataClassUnpack:
 classFieldCache = {}

 @classmethod
 def instantiate(cls, classToInstantiate, argDict):
 if classToInstantiate not in cls.classFieldCache:
 cls.classFieldCache[classToInstantiate] = {f.name for f in fields(classToInstantiate) if f.init}

 fieldSet = cls.classFieldCache[classToInstantiate]
 filteredArgDict = {k : v for k, v in argDict.items() if k in fieldSet}
 return classToInstantiate(**filteredArgDict)

@dataclass
class Req:
 id: int
 description: str
req = DataClassUnpack.instantiate(Req, {&quot;id&quot;: 123, &quot;description&quot;: &quot;hello&quot;, &quot;data_a&quot;: &quot;&quot;})
print(req)
req = DataClassUnpack.instantiate(Req, {&quot;id&quot;: 456, &quot;description&quot;: &quot;goodbye&quot;, &quot;data_a&quot;: &quot;my&quot;, &quot;data_b&quot;: &quot;friend&quot;})
print(req)

@dataclass
class Req2:
 id: int
 description: str
 data_a: str
req2 = DataClassUnpack.instantiate(Req2, {&quot;id&quot;: 123, &quot;description&quot;: &quot;hello&quot;, &quot;data_a&quot;: &quot;world&quot;})
print(req2)

print(&quot;\nHere's a peek at the internals of DataClassUnpack:&quot;)
print(DataClassUnpack.classFieldCache)
</code></pre>
Output:
<pre><code>Req(id=123, description='hello')
Req(id=456, description='goodbye')
Req2(id=123, description='hello', data_a='world')

Here's a peek at the internals of DataClassUnpack:
{&lt;class '__main__.Req'&gt;: {'description', 'id'}, &lt;class '__main__.Req2'&gt;: {'description', 'data_a', 'id'}}
</code></pre>

Let's say I want to initialize the below dataclass
<pre class="lang-py prettyprint-override"><code>from dataclasses import dataclass

@dataclass
class Req:
 id: int
 description: str
</code></pre>
I can of course do it in the following way:
<pre class="lang-py prettyprint-override"><code>data = make_request() # gives me a dict with id and description as well as some other keys.
 # {&quot;id&quot;: 123, &quot;description&quot;: &quot;hello&quot;, &quot;data_a&quot;: &quot;&quot;, ...}
req = Req(data[&quot;id&quot;], data[&quot;description&quot;])
</code></pre>
But, is it possible for me to do it with dictionary unpacking, given that the keys I need is always a subset of the dictionary?
<pre class="lang-py prettyprint-override"><code>req = Req(**data) # TypeError: __init__() got an unexpected keyword argument 'data_a'
</code></pre>

Initialize Python dataclass from dictionary

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

假设我想初始化以下数据集from dataclasses import dataclass@dataclassclass Req:    id: int    description: str我当然可以这样做：data = make_request() # gives me a dict with id and des...

问从字典中初始化Python数据集
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从字典中初始化Python数据集EN