blocks|key|1985636|text|在这种情况下，从一封信翻译到莫尔斯电码相当简单。您只需使用键访问该值，并将每个字符串值连接到另一个字符串。见下文：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1985637|user_input+=+input("Input+english+to+translate+to+morse+code:+")

morse_code_message+=+""
for+i+in+user_input:
++++if+i+in+translation.keys():
+++++++++morse_code_message+%2B=+translation[i]
print(morse_code_message)|code-block|syntax|javascript|1985638|然而，字典并不打算反过来使用。所以莫尔斯对英语将是不同的。您必须搜索字典值。如果您一定要这样做，请参阅this+post。一种简单而廉价的方法就是制作两个翻译表，并使用与英语莫尔斯相同的逻辑。|offset|length|1985639|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/8023306/get-key-by-value-in-dictionary^0|0|0|1F|9|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Translating from a letter to morse code is quite simple in this case. You simply access the value using the key and concatenate each string value to another string. See below:

<pre><code>user_input = input("Input english to translate to morse code: ")

morse_code_message = ""
for i in user_input:
 if i in translation.keys():
 morse_code_message += translation[i]
print(morse_code_message)
</code></pre>

However, dictionaries are not intended to be used the other way around. So morse to english will be different. You will have to search the dictionary values. See <a href="https://stackoverflow.com/questions/8023306/get-key-by-value-in-dictionary">this post</a> if you absolutely must do it this way. A cheap and easy way around this is to just make two translation tables and just use the same logic as is used for english to morse.

blocks|key|686821|text|构建原始dict的反向索引，然后有两个方便的查找。现在你有一个问题，莫尔斯是一个不同的长度与字符。假设morse字符间隙是作为一个空格编写的，您可以通过首先检查输入流的alpha+(pop+1+char)还是morse+(pop多个字符)，一次使用一个令牌。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|686822|注意，做i+in+translation而不是translation.keys()|offset|length|style|CODE|686823|translation+=+{...+your+original+dict+...}
morse_to_alpha+=+{v,k+for+k,v+in+translation.items()}

user_input+=+input("Input+english+or+morse+code+message:\n").upper()

while+user_input:
++++if+user_input[0]+in+translation:
++++++++print(translation.pop(0))
++++elif+user_input[0]+in+'.-':
++++++++try:
+++++++++++++separator+=+user_input.index('+')
++++++++except+ValueError:
+++++++++++++separator+=+len(user_input)
++++++++morse+=+user_input[:separator]
++++++++del+user_input[:separator%2B1]
++++++++print(morse_to_alpha[morse])
++++else:
++++++++print("unkown+symbol")+|code-block|syntax|javascript|686824|entityMap^0|0|4|G|N|I|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Build a reverse index of the original dict and then you have two convenient lookups. Now you have the problem that morse is a different length than characters. Assuming that the morse intercharacter gap is written as a space, you can consume the input stream one token at a time by first checking if its alpha (pop 1 char) or morse (pop multiple chars).

Note, do <code>i in translation</code> not <code>translation.keys()</code>

<pre><code>translation = {... your original dict ...}
morse_to_alpha = {v,k for k,v in translation.items()}

user_input = input("Input english or morse code message:\n").upper()

while user_input:
 if user_input[0] in translation:
 print(translation.pop(0))
 elif user_input[0] in '.-':
 try:
 separator = user_input.index(' ')
 except ValueError:
 separator = len(user_input)
 morse = user_input[:separator]
 del user_input[:separator+1]
 print(morse_to_alpha[morse])
 else:
 print("unkown symbol") 
</code></pre>

blocks|key|1748912|text|您必须检查这是一条莫尔斯消息还是一条“alpha”消息：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1748913|+#+build+a+reversed+dict
translation_from_morse+=+{v:+k+for+k,+v+in+translation.items()}

user_input+=+input("Input+english+or+morse+code+message:\n").upper()

if+user_input[0]+in+".-":
++++print("+".join("".join(translation_from[morse]+for+morse+in+part.split("+"))+for+part+in+user_input+.split("++")))
else:
++++print("+".join(translation_to.get(c,+c)+for+c+in+user_input+))|code-block|syntax|javascript|1748914|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You are going to have to check if it is a Morse message or a 'alpha' message:

<pre><code> # build a reversed dict
translation_from_morse = {v: k for k, v in translation.items()}

user_input = input("Input english or morse code message:\n").upper()

if user_input[0] in ".-":
 print(" ".join("".join(translation_from[morse] for morse in part.split(" ")) for part in user_input .split(" ")))
else:
 print(" ".join(translation_to.get(c, c) for c in user_input ))
</code></pre>

blocks|key|686905|text|要将文本翻译为morse，只需将字符串中的字符map为translation字典中的相应值：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|686906|>>>+msg+=+"HELLO+WORLD"
>>>+morse+=+'+'.join(map(translation.get,+msg))
>>>+morse
'....+.+.-..+.-..+---++++.--+---+.-.+.-..+-..'|code-block|syntax|javascript|686907|请注意，我用空格分隔代码，否则将几乎不可能将消息解码回来，因为某些序列可能在不同的字符组合中产生。对于返回的翻译，您必须首先逆字典；然后通过空间split+morse消息，并从逆字典中获得值。|686908|>>>+trans_back+=+{v:+k+for+k,+v+in+translation.items()}
>>>+''.join(map(trans_back.get,+morse.split()))
'HELLOWORLD'|686909|不过，请注意，这删除了空间。要解决这个问题，您可以使用与空间不同的符号来分离morse代码序列。或者使用这个稍微复杂一些的版本--使用re.split在一个空间中拆分--只有当这个空格没有后面，或者前面没有另一个空格：|686910|>>>+''.join(map(trans_back.get,+re.split("(?<!+)+%7C+(?!+)",+morse)))
'HELLO+WORLD'|686911|为了决定用哪种方式翻译，即原始文本是莫尔斯还是纯文本，只需检查字符串的第一个字符或所有字符是否在translation字典中，或者它们是否是有效的莫尔斯符号：|686912|if+all(c+in+translation+for+c+in+msg):
++++#+translate+to+morse
elif+all(c+in+".-+"+for+c+in+msg):
++++#+translate+back
else:
++++#+don't+know+what+to+do|686913|注释：这个答案是在dict中的所有条目添加尾随空格之前发布的。|BOLD|686914|entityMap^0|N|3|R|B|0|0|20|5|0|0|1V|8|0|0|1C|B|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|U|3|V|5|H|7|1I|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|1J|8|@$9|1K|A|1L|B|Y]]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|10|$]]

For translating text to morse, just <code>map</code> the characters of the string to the corresponding value from the <code>translation</code> dictionary:

<pre><code>&gt;&gt;&gt; msg = "HELLO WORLD"
&gt;&gt;&gt; morse = ' '.join(map(translation.get, msg))
&gt;&gt;&gt; morse
'.... . .-.. .-.. --- .-- --- .-. .-.. -..'
</code></pre>

Note that I separated the codes with spaces, otherwise it will be nearly impossible to decode the message back, as some sequences could yield in different combinations of characters. For the translation back, you first have to inverse the dictionary; then <code>split</code> the morse message by space and get the value from the inverse dictionary.

<pre><code>&gt;&gt;&gt; trans_back = {v: k for k, v in translation.items()}
&gt;&gt;&gt; ''.join(map(trans_back.get, morse.split()))
'HELLOWORLD'
</code></pre>

Note that this removed the space, though. To fix this, you could use a different symbol than space to separate the morse code sequences.
Or use this slightly more complicated version using <code>re.split</code> to split at a space, only if that space is not followed, or not preceded by another space:

<pre><code>&gt;&gt;&gt; ''.join(map(trans_back.get, re.split("(?&lt;! ) | (?! )", morse)))
'HELLO WORLD'
</code></pre>

For deciding which way to translate, i.e. whether the original text is morse or plain-text, you could just check whether either the first, or all of the characters of the string are in the <code>translation</code> dictionary, or whether they are valid morse symbols:

<pre><code>if all(c in translation for c in msg):
 # translate to morse
elif all(c in ".- " for c in msg):
 # translate back
else:
 # don't know what to do
</code></pre>

<hr>

Note: This answer was posted before trailing spaces were added to all the entries in the dict.

I have a dictionary where the <code>key</code> is a letter in the alphabet and it’s <code>value</code> is its corresponding Morse code letter (e.g. <code>”A”: “.-“</code>). I also have a user input where the user I puts there message. Once they press enter, it checks each input letter to see if it is in Morse code or an English letter by seeing if it is in the value or key. After that, I want it to then print its corresponding letter (e.g. if it found that “.-“, “A” would be printed). How would I do this? 

Here is my code so far:

<pre><code>translation = {
"A": ".-",
"B": "-...",
"C": "-.-.",
"D": "-..",
"E": ".",
"F": "..-.",
"G": "--.",
"H": "....",
"I": "..",
"J": ".---",
"K": "-.-",
"L": ".-..",
"M": "--",
"N": "-.",
"O": "---",
"P": ".--.",
"Q": "--.-",
"R": ".-.",
"S": "...",
"T": "-",
"U": "..-",
"V": "...-",
"W": ".--",
"X": "-..-",
"Y": "-.--",
"Z": "--..",
" ": " "
}

user_input = input("Input english or morse code message:\n").upper()

for i in user_input:
 if i in translation.keys(): 
 print(translation.values()) 
 if i in translation.values():
 print(translation.keys())
</code></pre>

Using dictionary and printing out value when matched key and vise-versa

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有一本字典，key是字母表中的字母，value是对应的莫尔斯电码(例如”A”: “.-“)。我也有一个用户输入，在那里，我把用户的信息。一旦他们按enter，它就会检查每个输入字母是用Morse代码还是英文字母，看看它是在值还是键中。在此之后，我希望它再打印其相应的字母(例如，如果它发现“.-”，“A”将被打印)。我...

问使用字典，匹配键时打印出值，反之亦然。
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用字典，匹配键时打印出值，反之亦然。EN