blocks|key|2035952|text|将所有有效组合插入到dictionary+of+tuples中，如果组合不存在，则返回0：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2035953|def+convert_what(numeral_sys_1,+numeral_sys_2):
++++numeral_dict+=+{
++++++++("Hexadecimal",+"Decimal"++++)+:+1,
++++++++("Hexadecimal",+"Binary"+++++)+:+2,
++++++++("Decimal",+++++"Hexadecimal")+:+4,+
++++++++("Decimal",+++++"Binary"+++++)+:+6,
++++++++("Binary",++++++"Hexadecimal")+:+5,
++++++++("Binary",++++++"Decimal"++++)+:+3
++++}
++++return+numeral_dict.get((numeral_sys_1,+numeral_sys_2),+0)|code-block|syntax|javascript|2035954|如果您计划在循环中使用函数，那么最好在函数外部定义字典，这样就不会在每次调用该函数时重新创建它。|2035955|entityMap^0|A|A|O|5|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Insert all the valid combinations to a <code>dictionary</code> of <code>tuple</code>s, and if the combination is not there, return 0:

<pre><code>def convert_what(numeral_sys_1, numeral_sys_2):
 numeral_dict = {
 ("Hexadecimal", "Decimal" ) : 1,
 ("Hexadecimal", "Binary" ) : 2,
 ("Decimal", "Hexadecimal") : 4, 
 ("Decimal", "Binary" ) : 6,
 ("Binary", "Hexadecimal") : 5,
 ("Binary", "Decimal" ) : 3
 }
 return numeral_dict.get((numeral_sys_1, numeral_sys_2), 0)
</code></pre>

If you are planning to use the function in a loop, it may be a better idea to define the dictionary outside the function, so it wouldn't be recreated on every call to the function.

blocks|key|1825327|text|一个想法是使用一个列表并获得结果的索引。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1825328|def+convert_what(numeral_sys_1,+numeral_sys_2):
++++if+numeral_sys_1+==+numeral_sys_2:++++++
++++++++return+0
++++return+["HexadecimalDecimal",+"HexadecimalBinary",+"BinaryDecimal",+"DecimalHexadecimal",+"BinaryHexadecimal",+"DecimalBinary"+].index(numeral_sys_1+%2B+numeral_sys_2)+%2B+1|code-block|syntax|javascript|1825329|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|$]]

An Idea is using a list and get index of result, ie.

<pre><code>def convert_what(numeral_sys_1, numeral_sys_2):
 if numeral_sys_1 == numeral_sys_2: 
 return 0
 return ["HexadecimalDecimal", "HexadecimalBinary", "BinaryDecimal", "DecimalHexadecimal", "BinaryHexadecimal", "DecimalBinary" ].index(numeral_sys_1 + numeral_sys_2) + 1
</code></pre>

blocks|key|1192525|text|如果您确信没有其他值可以设置为numeral_sys_1和numeral_sys_2变量，那么这是最简单和最干净的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1192526|另一方面，如果您有“十六进制”、“十进制”和“二进制”以外的任何其他值，则必须扩展字典及其与可用值的组合。|1192527|这里的逻辑是；如果字典键中的变量元组不等于给定的变量元组，则.get()方法返回"0“。如果给定变量元组匹配字典中的任何键，则返回匹配键的值。|1192528|def+convert_what(numeral_sys_1,+numeral_sys_2):
++++return+{
++++++++("Hexadecimal",+"Decimal")+:+1,+
++++++++("Hexadecimal",+"Binary")+:+2,+
++++++++("Binary",+"Decimal")+:+3,
++++++++("Decimal",+"Hexadecimal")+:+4,
++++++++("Binary",+"Hexadecimal")+:+5,+
++++++++("Decimal",+"Binary")+:+6,+
+++++}.get((numeral_sys_1,+numeral_sys_2),+0)|code-block|syntax|javascript|1192529|也有使用生成器的可能解决方案。看起来要聪明得多，但我认为硬编码字典比使用生成器来满足这一简单要求更快。|1192530|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you are sure there is no other value could have been set to numeral_sys_1 and numeral_sys_2 variables this is the simplest and cleanest solution.

On the other hand, you have to extend the dictionary with its combinations with available values, if you have any other value than "Hexadecimal", "Decimal" and "Binary" 

The logic here is; if variable tuples in dictionary keys are not equal to given variable tuple, .get() method returns "0". If given variable tuple match any key in dictionary thus return value of the matching key.

<pre><code>def convert_what(numeral_sys_1, numeral_sys_2):
 return {
 ("Hexadecimal", "Decimal") : 1, 
 ("Hexadecimal", "Binary") : 2, 
 ("Binary", "Decimal") : 3,
 ("Decimal", "Hexadecimal") : 4,
 ("Binary", "Hexadecimal") : 5, 
 ("Decimal", "Binary") : 6, 
 }.get((numeral_sys_1, numeral_sys_2), 0)
</code></pre>

There is also using generator could be a solution. Looks much smarter, but I think hard codded dictionary would faster than using a generator for this simple requirement.

blocks|key|1192550|text|虽然@Aryerez和@SencerH.的答案有效，但在列出值对时，必须为numeral_sys_2的每个可能值反复写入每个可能的值，从而使数据结构在可能值的数量增加时更难维护。相反，可以使用嵌套的dict代替嵌套的if语句：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1192551|mapping+=+{
++++'Hexadecimal':+{'Decimal':+1,+'Binary':+2},
++++'Binary':+{'Decimal':+3,+'Hexadecimal':+5},
++++'Decimal':+{'Hexadecimal':+4,+'Binary':+6}
}
def+convert_what(numeral_sys_1,+numeral_sys_2):
++++return+mapping.get(numeral_sys_1,+{}).get(numeral_sys_2,+0)|code-block|syntax|javascript|1192552|或者，您可以使用itertools.permutations方法生成映射的值对，其顺序与输入序列的顺序相同：|1192553|mapping+=+dict(zip(permutations(('Hexadecimal',+'Decimal',+'Binary'),+r=2),+(1,+2,+4,+6,+3,+5)))
def+convert_what(numeral_sys_1,+numeral_sys_2):
++++return+mapping.get((numeral_sys_1,+numeral_sys_2),+0)|1192554|entityMap^0|11|D|0|0|8|M|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

While @Aryerez and @SencerH.'s answers work, each possible value of <code>numeral_sys_1</code> has to be repeatedly written for each possible value of <code>numeral_sys_2</code> when listing the value pairs, making the data structure harder to maintain when the number of possible values increases. You can instead use a nested dict in place of your nested if statements instead:

<pre><code>mapping = {
 'Hexadecimal': {'Decimal': 1, 'Binary': 2},
 'Binary': {'Decimal': 3, 'Hexadecimal': 5},
 'Decimal': {'Hexadecimal': 4, 'Binary': 6}
}
def convert_what(numeral_sys_1, numeral_sys_2):
 return mapping.get(numeral_sys_1, {}).get(numeral_sys_2, 0)
</code></pre>

Alternatively, you can generate the pairs of values for the mapping with the <code>itertools.permutations</code> method, the order of which follows that of the input sequence:

<pre><code>mapping = dict(zip(permutations(('Hexadecimal', 'Decimal', 'Binary'), r=2), (1, 2, 4, 6, 3, 5)))
def convert_what(numeral_sys_1, numeral_sys_2):
 return mapping.get((numeral_sys_1, numeral_sys_2), 0)
</code></pre>

blocks|key|1192556|text|通常，我会使用字典解决方案来执行嵌套的if任务。有些特殊情况可能会带来另一种方法。就像这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1192557|def+convert_what(numeral_sys_1,+numeral_sys_2):

++++num+=+['Hexadecimal','Decimal','Binary']
++++tbl+=+[[0,1,2],
+++++++++++[4,0,6],
+++++++++++[5,3,0]]
++++try:
++++++++return+tbl[num.index(numeral_sys_1)][num.index(numeral_sys_2)]
++++except+ValueError:
++++++++return+0|code-block|syntax|javascript|1192558|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|$]]

In general I would run with dictionary solution for nested if task. Some particular cases may bring to another approach. Like this one:

<pre><code>def convert_what(numeral_sys_1, numeral_sys_2):

 num = ['Hexadecimal','Decimal','Binary']
 tbl = [[0,1,2],
 [4,0,6],
 [5,3,0]]
 try:
 return tbl[num.index(numeral_sys_1)][num.index(numeral_sys_2)]
 except ValueError:
 return 0
</code></pre>

blocks|key|1192593|text|不如这样吧：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1192594|def+convert_what(numeral_sys_1,+numeral_sys_2):
++++src+=+numeral_sys_1,+numeral_sys_2
++++if+src+==+"Hexadecimal",+"Decimal":
++++++++return+1
++++if+src+==+"Hexadecimal",+"Binary"
++++++++return+2
++++#+You+get+the+gist....+
++++if+src+==+"Decimal",+"Binary":
++++++++return+6
++++return+0+|code-block|syntax|javascript|1192595|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|$]]

How about something like:

<pre><code>def convert_what(numeral_sys_1, numeral_sys_2):
 src = numeral_sys_1, numeral_sys_2
 if src == "Hexadecimal", "Decimal":
 return 1
 if src == "Hexadecimal", "Binary"
 return 2
 # You get the gist.... 
 if src == "Decimal", "Binary":
 return 6
 return 0 
</code></pre>

blocks|key|2036148|text|在我看来，这个convert_what函数本身并不是非常质子化的。我猜调用此代码的代码也有一堆if语句，并根据convert_what()的返回值进行转换。我建议你这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2036149|第一步，为每一个组合创建一个函数：|2036150|def+hex_dec(inp):
++++return+1234++#+todo+implement
#+do+the+same+for+hex_bin,+bin_dec,+dec_hex,+bin_hex,+dec_bin|code-block|syntax|javascript|2036151|第二步，将函数对象放入dict中。注意，函数名后面没有()，因为我们希望存储函数对象，而不是调用它：|2036152|converter_funcs+=+{
++++("Hexadecimal",+"Decimal"):+hex_dec,
++++("Hexadecimal",+"Binary"):+hex_bin,
++++("Binary",+"Decimal"):+bin_dec,
++++("Decimal",+"Hexadecimal"):+dec_hex,
++++("Binary",+"Hexadecimal"):+bin_hex,
++++("Decimal",+"Binary"):+dec_bin,
}|2036153|第三步也是最后一步，实现一个转换函数。if语句检查两个系统是否相同。然后，我们从我们的dict中得到正确的函数，并称之为：|2036154|def+convert(input_number,+from_sys,+to_sys):
++++if+from_sys+==+to_sys:
++++++++return+input_number
++++func+=+converter_funcs[(from_sys,+to_sys)]
++++return+func(input_number)|2036155|entityMap^0|7|C|1J|E|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|15|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

In my opinion, this <code>convert_what</code> function itself is not very pythonic. I guess the code which calls this code has a bunch of if statements too and does the converting depending on the return value of <code>convert_what()</code>. I suggest something like this:

First step, make one function for every combination:

<pre><code>def hex_dec(inp):
 return 1234 # todo implement
# do the same for hex_bin, bin_dec, dec_hex, bin_hex, dec_bin
</code></pre>

Second step, put the function objects in a dict. Note that there are no () after the function names, because we want to store the function object and not call it yet:

<pre><code>converter_funcs = {
 ("Hexadecimal", "Decimal"): hex_dec,
 ("Hexadecimal", "Binary"): hex_bin,
 ("Binary", "Decimal"): bin_dec,
 ("Decimal", "Hexadecimal"): dec_hex,
 ("Binary", "Hexadecimal"): bin_hex,
 ("Decimal", "Binary"): dec_bin,
}
</code></pre>

Third and last step, implement a convert function. The if statement checks if both systems are the same. Then, we get the right function from our dict and call it:

<pre><code>def convert(input_number, from_sys, to_sys):
 if from_sys == to_sys:
 return input_number
 func = converter_funcs[(from_sys, to_sys)]
 return func(input_number)
</code></pre>

blocks|key|1192618|text|这是通过开关用大多数其他语言的语句来完成的.在python中，我使用一个简单的函数和表达式字典。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1192619|代码：|offset|length|style|BOLD|1192620|def+convert_what(numeral_sys_1,+numeral_sys_2):
++++myExpressions+=+{"Hexadecimal"+:+{"Decimal"+:+1,+"Binary"+:+2},
++++++++++++++++++++"Decimal"+:+{"Hexadecimal"+:+4,+"Binary"+:+6},+
++++++++++++++++++++"Binary"+:+{"Hexadecimal"+:+5,+"Decimal"+:+3}}
++++return+(myExpressions.get(numeral_sys_1,+{})).get(numeral_sys_2,+0)|code-block|syntax|javascript|1192621|输出：|1192622|>+convert_what("Hexadecimal",+"Decimal")
>+1
>+convert_what("Binary",+"Binary")
>+0
>+convert_what("Invalid",+"Hexadecimal")
>+0|1192623|entityMap^0|0|0|3|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

This is done by switch-case statements in most of other languages. In python, I use a simple function with an expression dictionary.

Code:

<pre class="lang-py prettyprint-override"><code>def convert_what(numeral_sys_1, numeral_sys_2):
 myExpressions = {"Hexadecimal" : {"Decimal" : 1, "Binary" : 2},
 "Decimal" : {"Hexadecimal" : 4, "Binary" : 6}, 
 "Binary" : {"Hexadecimal" : 5, "Decimal" : 3}}
 return (myExpressions.get(numeral_sys_1, {})).get(numeral_sys_2, 0)
</code></pre>

Output:

<pre><code>&gt; convert_what("Hexadecimal", "Decimal")
&gt; 1
&gt; convert_what("Binary", "Binary")
&gt; 0
&gt; convert_what("Invalid", "Hexadecimal")
&gt; 0
</code></pre>

blocks|key|2036177|text|使用嵌套列表的另一种方法。希望能帮上忙！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2036178|def+convert_what(numeral_sys_1,+numeral_sys_2):

++++l1+=+[["Hexadecimal","Decimal"],["Hexadecimal","Binary"],
++++++++++++["Decimal","Hexadecimal"],["Decimal","Binary"],
++++++++++++["Binary","Hexadecimal"],["Binary","Decimal"]]

++++return+l1.index([numeral_sys_1,+numeral_sys_2])+%2B+1+if+[numeral_sys_1,numeral_sys_2]+in+l1+else+0|code-block|syntax|javascript|2036179|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|$]]

An alternative way using nested list. Hope it helps!!

<pre><code>def convert_what(numeral_sys_1, numeral_sys_2):

 l1 = [["Hexadecimal","Decimal"],["Hexadecimal","Binary"],
 ["Decimal","Hexadecimal"],["Decimal","Binary"],
 ["Binary","Hexadecimal"],["Binary","Decimal"]]

 return l1.index([numeral_sys_1, numeral_sys_2]) + 1 if [numeral_sys_1,numeral_sys_2] in l1 else 0
</code></pre>

blocks|key|2036197|text|我喜欢让代码保持干燥：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2036198|def+convert_what_2(numeral_sys_1,+numeral_sys_2):
++++num_sys+=+["Hexadecimal",+"Decimal",+"Binary"]
++++r_value+=+{0:+{1:+1,+2:+2},
+++++++++++++++1:+{0:+4,+2:+6},
+++++++++++++++2:+{0:+5,+1:+3}+}
++++try:
++++++++value+=+r_value[num_sys.index(numeral_sys_1)][num_sys.index(numeral_sys_2)]
++++except+KeyError:+#+Catches+when+they+are+equal+or+undefined
++++++++value+=+0
++++return+value|code-block|syntax|javascript|2036199|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|$]]

I like to keep code dry:

<pre><code>def convert_what_2(numeral_sys_1, numeral_sys_2):
 num_sys = ["Hexadecimal", "Decimal", "Binary"]
 r_value = {0: {1: 1, 2: 2},
 1: {0: 4, 2: 6},
 2: {0: 5, 1: 3} }
 try:
 value = r_value[num_sys.index(numeral_sys_1)][num_sys.index(numeral_sys_2)]
 except KeyError: # Catches when they are equal or undefined
 value = 0
 return value
</code></pre>

blocks|key|1192683|text|使用其他答案提供的一些技术，并将它们结合起来：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1192684|def+convert(key1,+key2):
++++keys+=+["Hexadecimal",+"Decimal",+"Binary"]
++++combinations+=+{(0,+1):+1,+(0,+2):+2,+(1,+0):+4,+(1,+2):+6,+(2,+0):+5,+(2,+1):+3}+#+use+keys+indexes+to+map+to+combinations
++++try:
++++++++return+combinations[(keys.index(key1),+keys.index(key2))]
++++except+(KeyError,+ValueError):+#+if+value+is+not+in+list,+return+as+0
++++++++return+0|code-block|syntax|javascript|1192685|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|$]]

Using some techniques that the other answers provide and combine them:

<pre><code>def convert(key1, key2):
 keys = ["Hexadecimal", "Decimal", "Binary"]
 combinations = {(0, 1): 1, (0, 2): 2, (1, 0): 4, (1, 2): 6, (2, 0): 5, (2, 1): 3} # use keys indexes to map to combinations
 try:
 return combinations[(keys.index(key1), keys.index(key2))]
 except (KeyError, ValueError): # if value is not in list, return as 0
 return 0
</code></pre>

blocks|key|1825612|text|虽然不确定这种方法是否更快，但也可以使用numpy来完成：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1825613|conditions+=+[
++++("Hexadecimal",+"Decimal"),+("Hexadecimal",+"Binary"),
++++("Binary",+"Decimal"),+("Decimal",+"Hexadecimal"),+("Binary",+"Hexadecimal"),+("Decimal",+"Binary")]
choices+=+[1,2,3,4,5,6]|code-block|syntax|javascript|1825614|并可用作：|1825615|+np.select(conditions,+choices,+default=0)|1825616|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|$]]

Although not sure if this approach is faster, but could be done using numpy as well: 

<pre><code>conditions = [
 ("Hexadecimal", "Decimal"), ("Hexadecimal", "Binary"),
 ("Binary", "Decimal"), ("Decimal", "Hexadecimal"), ("Binary", "Hexadecimal"), ("Decimal", "Binary")]
choices = [1,2,3,4,5,6]
</code></pre>

and can be used as : 

<pre><code> np.select(conditions, choices, default=0)
</code></pre>

blocks|key|2036317|text|正如萨达普所说，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2036318|在我看来，这个convert_what函数本身并不是非常质子化的。我猜调用此代码的代码也有一堆if语句，并根据convert_what()的返回值进行转换。我建议你这样做：|blockquote|offset|length|style|CODE|2036319|如果您正在为整数实现基本转换，那么您可能正在经历一个常见的表示：int。对于每对碱基都不需要一个单独的函数，而且所涉及的两个基甚至不需要相互了解。|2036320|输入|2036321|创建从数字系统名称到其基的映射：|2036322|BINARY+=+"Binary"
DECIMAL+=+"Decimal"
HEXADECIMAL+=+"Hexadecimal"

BASES+=+{
++++BINARY:+2,
++++DECIMAL:+10,
++++HEXADECIMAL:+16,
}|code-block|syntax|javascript|2036323|允许您使用int(text,+BASES[numeral_sys_1])读取输入。|2036324|输出|2036325|创建从数字系统名称到格式说明符的映射|2036326|FORMATTERS+=+{
++++BINARY:+"b",
++++DECIMAL:+"d",
++++HEXADECIMAL:+"x",
}|2036327|允许您用format(n,+FORMATTERS[numeral_sys_2])编写输出。|2036328|示例使用|2036329|def+convert(text,+numeral_sys_1,+numeral_sys_2):
++++n+=+int(text,+BASES[numeral_sys_1])
++++return+format(n,+FORMATTERS[numeral_sys_2])|2036330|如果您需要支持一组与int(x,+base)不同的格式，或者比内置的整数格式支持更多的输出基，则dict也可以通过使值函数变得更加通用。|2036331|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/functions.html#format^0|0|7|C|1J|E|0|W|3|0|0|0|0|5|V|0|0|A|5|0|0|0|4|10|0|0|0|A|C|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1I|8|@$E|1J|F|1K|G|H]|$E|1L|F|1M|G|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|1N|8|@$E|1O|F|1P|G|H]]|9|@]|A|$]]|$1|K|3|L|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1R|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1S|8|@]|9|@]|A|$R|S]]|$1|T|3|U|5|6|7|1T|8|@$E|1U|F|1V|G|H]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1W|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1X|8|@]|9|@$E|1Y|F|1Z|1|20]]|A|$]]|$1|Z|3|10|5|Q|7|21|8|@]|9|@]|A|$R|S]]|$1|11|3|12|5|6|7|22|8|@$E|23|F|24|G|H]]|9|@]|A|$]]|$1|13|3|14|5|6|7|25|8|@]|9|@]|A|$]]|$1|15|3|16|5|Q|7|26|8|@]|9|@]|A|$R|S]]|$1|17|3|18|5|6|7|27|8|@$E|28|F|29|G|H]]|9|@]|A|$]]|$1|19|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]]|1A|$1B|$5|1C|1D|1E|A|$1F|1G]]]]

As @Sadap said,

<blockquote>
 In my opinion, this <code>convert_what</code> function itself is not very pythonic. I guess the code which calls this code has a bunch of if statements too and does the converting depending on the return value of <code>convert_what()</code>. I suggest something like this:
</blockquote>

If you’re implementing base conversion for integers, you’re probably going through a common representation anyway: <code>int</code>. A separate function for each pair of bases isn’t necessary, and the two bases involved don’t even need to know about each other.

<h3>Input</h3>

Create a mapping from the name of a number system to its base:

<pre><code>BINARY = "Binary"
DECIMAL = "Decimal"
HEXADECIMAL = "Hexadecimal"

BASES = {
 BINARY: 2,
 DECIMAL: 10,
 HEXADECIMAL: 16,
}
</code></pre>

allowing you to read inputs with <code>int(text, BASES[numeral_sys_1])</code>.

<h3>Output</h3>

Create a mapping from the name of a number system to a <a href="https://docs.python.org/3/library/functions.html#format" rel="nofollow noreferrer">format specifier</a>:

<pre><code>FORMATTERS = {
 BINARY: "b",
 DECIMAL: "d",
 HEXADECIMAL: "x",
}
</code></pre>

allowing you to write outputs with <code>format(n, FORMATTERS[numeral_sys_2])</code>.

<h3>Example use</h3>

<pre><code>def convert(text, numeral_sys_1, numeral_sys_2):
 n = int(text, BASES[numeral_sys_1])
 return format(n, FORMATTERS[numeral_sys_2])
</code></pre>

Either dict can also be made more general by making the values functions instead, if you need to support a different set of formats than <code>int(x, base)</code>, or more output bases than built-in integer formatting supports.

Is there a more pythonic way to do nested if else statements than this one:

<pre><code>def convert_what(numeral_sys_1, numeral_sys_2):

 if numeral_sys_1 == numeral_sys_2: 
 return 0
 elif numeral_sys_1 == "Hexadecimal":
 if numeral_sys_2 == "Decimal":
 return 1
 elif numeral_sys_2 == "Binary":
 return 2
 elif numeral_sys_1 == "Decimal":
 if numeral_sys_2 == "Hexadecimal":
 return 4
 elif numeral_sys_2 == "Binary":
 return 6
 elif numeral_sys_1 == "Binary":
 if numeral_sys_2 == "Hexadecimal":
 return 5
 elif numeral_sys_2 == "Decimal":
 return 3
 else:
 return 0
</code></pre>

This script is a part of a simple converter.

Is there a better way to write nested if statements in python?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

是否有比这一种更多的节奏式方法来执行嵌套if there语句：def convert_what(numeral_sys_1, numeral_sys_2):    if numeral_sys_1 == numeral_sys_2:              return 0    elif numeral_sys_1...

问有没有更好的方法在python中编写嵌套的if语句？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有更好的方法在python中编写嵌套的if语句？EN