blocks|key|1152552|text|您可以创建一个新字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152553|fields+=+{fields_map[k]:v+for+k,v+in+fields.items()}|code-block|syntax|javascript|1152554|这里有实例化|offset|length|1152555|如果找不到密钥，可以使用get并将原始密钥作为新键返回：|style|CODE|1152556|fields+=+{fields_map.get(k,+k):v+for+k,v+in+fields.items()}|1152557|entityMap|0|LINK|mutability|MUTABLE|url|https://repl.it/repls/ExpensiveBuoyantSearch|1|https://docs.python.org/3.7/library/stdtypes.html#dict.get^0|0|0|3|3|0|0|C|3|C|3|1|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@$I|13|J|14|1|15]]|A|$]]|$1|K|3|L|5|6|7|16|8|@$I|17|J|18|M|N]]|9|@$I|19|J|1A|1|1B]]|A|$]]|$1|O|3|P|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|T|U|V|A|$W|Z]]]]

You can create a new dictionary:

<pre><code>fields = {fields_map[k]:v for k,v in fields.items()}
</code></pre>

Here you have the <a href="https://repl.it/repls/ExpensiveBuoyantSearch" rel="nofollow noreferrer">live example</a>

In case the key is not found, you can use <a href="https://docs.python.org/3.7/library/stdtypes.html#dict.get" rel="nofollow noreferrer"><code>get</code></a> and return the original key as new key:

<pre><code>fields = {fields_map.get(k, k):v for k,v in fields.items()}
</code></pre>

blocks|key|1365286|text|你可以试着理解力，比如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1365287|{fields_map[k]:v+for+k,v+in+fields.items()}|code-block|syntax|javascript|1365288|我不知道这是否会是最好和最出色的技术。|1365289|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You could try a dict comprehension, something like :

<pre><code>{fields_map[k]:v for k,v in fields.items()}
</code></pre>

I have no clue if it would be the best and most performant technique though.

blocks|key|1365305|text|大多数表现方式是在迭代dict时更改键名(例如，输入验证)，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1365306|def+read_input(fields):
++++fields_map+=+get_account_fields_map()
++++ret+=+{}
++++for+k,+v+in+fields.items():
++++++++ret[fields_map[k]]+=+validate(v)
++++return+ret|code-block|syntax|javascript|1365307|大多数毕多尼克人都不理解：|1365308|fields+=+{fields_map[k]:+v+for+k,+v+in+fields.items()}|1365309|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Most performant way is to change the key names when you are iterating the dict for some other reason (say, input validation), like so:

<pre><code>def read_input(fields):
 fields_map = get_account_fields_map()
 ret = {}
 for k, v in fields.items():
 ret[fields_map[k]] = validate(v)
 return ret
</code></pre>

Most Pythonic is dict comprehension:

<pre><code>fields = {fields_map[k]: v for k, v in fields.items()}
</code></pre>

blocks|key|1365349|text|因此，如果映射关系非常明确，上述所有解决方案都会工作。但是，例如，对于字段是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1365350|fields+=+{
++++'Name':+'Foo',+
++++'Surname':+'Bar',+
++++'Email':+'foo.bar@email.com',+
++++'Privacy':+'true',+
++++'SomeUnmappedFieldKey':+'value'+
}|code-block|syntax|javascript|1365351|只需使用以下命令即可抛出KeyError：|offset|length|style|CODE|1365352|fields+=+{fields_map[k]:v+for+k,+v+in+fields.items()}|1365353|因此，使用@Netwave的跳板后，避免KeyErrors或映射关系与原始dict之间的差异的最全面方法是使用：|1365354|fields+=+{fields_map[k]:v+for+k,+v+in+fields.items()+if+k+in+fields_map}|1365355|这意味着：|1365356|fields+=+{
++++'first_name':+'Foo',+
++++'last_name':+'Bar',+
++++'email':+'foo.bar@email.com',+
++++'remarketing_consent':+'true',+
}|1365357|从@Netwave的建议来看，这一点和我的解决方案有一点细微差别，例如：|1365358|fields+=+{fields_map.get(k,+k):v+for+k,v+in+fields.items()}|1365359|将提供以下内容：|1365360|{
++++'first_name':+'Foo',+
++++'last_name':+'Bar',+
++++'email':+'foo.bar@email.com',+
++++'remarketing_consent':+'true,
++++'SomeUnmappedFieldKey':+value
}|1365361|因此，如果没有映射，一种方法将保留密钥，如果没有映射，则会删除该方法。使用最适合您的用例。|1365362|entityMap^0|0|0|C|8|0|0|1H|0|K|9|11|4|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@$I|1B|J|1C|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1D|8|@$I|1E|J|1F|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1G|8|@$I|1H|J|1I|K|L]|$I|1J|J|1K|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1L|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1P|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|1S|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|17|$]]

So all of the above solutions would work, if a mapping relationship was very much definied. However, for the case where, for example, fields was:

<pre><code>fields = {
 'Name': 'Foo', 
 'Surname': 'Bar', 
 'Email': 'foo.bar@email.com', 
 'Privacy': 'true', 
 'SomeUnmappedFieldKey': 'value' 
}
</code></pre>

Would throw a <code>KeyError</code> just by using:

<code>fields = {fields_map[k]:v for k, v in fields.items()}</code>

Having used the springboard by @Netwave, therefore it looks like the most comprehensize way to avoid <code>KeyErrors</code> or discrepancies between the mapping relation and the original <code>dict</code> would be to use:

<pre><code>fields = {fields_map[k]:v for k, v in fields.items() if k in fields_map}
</code></pre>

Which gives:

<pre><code>fields = {
 'first_name': 'Foo', 
 'last_name': 'Bar', 
 'email': 'foo.bar@email.com', 
 'remarketing_consent': 'true', 
}
</code></pre>

From @Netwave 's suggestion, there is a slight nuance with this and my solution, such that:

<pre><code>fields = {fields_map.get(k, k):v for k,v in fields.items()}
</code></pre>

Would give the following:

<pre><code>{
 'first_name': 'Foo', 
 'last_name': 'Bar', 
 'email': 'foo.bar@email.com', 
 'remarketing_consent': 'true,
 'SomeUnmappedFieldKey': value
}
</code></pre>

So one method retains the key if there is no mapping, and one drops it if it is not in the mapping. Use whichever is best for your use case.

I'm wondering, let's say I have the following data structure:

<pre><code>fields = {'Name': 'Foo', 'Surname': 'Bar', 'Email': 'foo.bar@email.com', 'Privacy': 'true'}
</code></pre>

I also have the following mapping relationship function:

<pre><code>def get_account_fields_map():
 return {
 'Name': 'first_name',
 'Surname': 'last_name',
 'Email': 'email',
 'Privacy': 'remarketing_consent'
 }

fields_map = get_account_fields_map()
</code></pre>

What would be the best and most performant technique, to rename the keys of <code>fields</code> dictionary using the <code>fields_map</code>?

I'm thinking it may need a combination of:

<pre><code>_dict[new_key] = __dict.pop(old_key)
</code></pre>

And the <code>map()</code> function, and some sort of apply function which translates they keys? Not sure...any suggestions would be appreciated.

N.B. I also know that one of the field values is 'true'...I'm using an XML SOAP API. XD

Edit: N.B. Also, I would need to handle if <code>fields</code> had a key value pair which didn't have a mapping in the <code>fields_map</code>...for this case, I am happy to drop that key - value pair from the dict...

Dictionary key manipulation using a mapping relation

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想知道，假设我有以下数据结构：fields = {'Name': 'Foo', 'Surname': 'Bar', 'Email': 'foo.bar@email.com', 'Privacy': 'true'}我还具有以下映射关系函数：def get_account_fields_map():    return ...

问使用映射关系进行字典密钥操作
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用映射关系进行字典密钥操作EN