Python将元组转换为整数

是否有任何函数可以将元组转换为整数

例如：

input = (1, 3, 7)

output = 137

---

只是另一种方法

>>> sum(n*10**i for (i,n) in enumerate(input[::-1]))
137

还有一个

>>> int(str(input).translate(None,'(,) '))
137

---

虽然将其转换为字符串然后再转换为int可以工作，但这是一种有点粗俗的方法。我们拥有制作数字所需的所有信息，即：

• 数字
• 数字的位置

由于我们有这些信息，我们可以通过计算每个位置的每个单位的值，然后乘以该位置的数字来计算数字。然后我们把结果加在一起，得到我们的数字。这可以在一行中完成，如下所示：

test = (1, 2, 3)
sum((10**pos)*val for pos, val in enumerate(reversed(test)))

让我们来分析一下：

>>> list(enumerate(reversed(test)))
[(0, 3), (1, 2), (2, 1)]

那么，如果我们把它乘以：

>>> list((10**pos)*val for pos, val in enumerate(reversed(test)))
[3, 20, 100]

所以我们求和得到123

编辑：关于速度的注释：

python -m timeit "int(''.join(map(str,(1,2,3))))"
100000 loops, best of 3: 2.7 usec per loop

python -m timeit 'sum((10**pos)*val for pos, val in enumerate(reversed((1,2,3))))'
100000 loops, best of 3: 2.29 usec per loop

python -m timeit -s 'from functools import reduce' 'reduce(lambda rst, d: rst * 10 + d, (1, 2, 3))'
1000000 loops, best of 3: 0.598 usec per loop

所以，如果你要保持速度，就要做到这一点。我觉得更容易理解的东西让我心烦意乱。我总是觉得lambdas有点难看，但总的来说，我认为它仍然是更可读的方法

编辑2：使用非常大的元组：

长度20：

python -m timeit -s "x=tuple(list(range(1,10))*2)" "int(''.join(map(str, x)))"
100000 loops, best of 3: 5.45 usec per loop

python -m timeit -s "x=tuple(list(range(1,10))*2)" "sum((10**pos)*val for pos, val in enumerate(reversed(x)))" 
100000 loops, best of 3: 11.7 usec per loop

python -m timeit -s "x=tuple(list(range(1,10))*2)" -s 'from functools import reduce' 'reduce(lambda rst, d: rst * 10 + d, x)'
100000 loops, best of 3: 4.18 usec per loop

长度100：

python -m timeit -s "x=tuple(list(range(1,10))*10)" "int(''.join(map(str, x)))"
100000 loops, best of 3: 18.6 usec per loop

python -m timeit -s "x=tuple(list(range(1,10))*10)" "sum((10**pos)*val for pos, val in enumerate(reversed(x)))"
10000 loops, best of 3: 72.9 usec per loop

python -m timeit -s "x=tuple(list(range(1,10))*10)" -s 'from functools import reduce' 'reduce(lambda rst, d: rst * 10 + d, x)'
10000 loops, best of 3: 25.6 usec per loop

---

在这里，我们看到最快的方法实际上是字符串操作-然而，现实情况是，您不太可能在10位数范围之外使用此方法-其中

reduce（）

方法在速度方面仍然占主导地位。我还认为string方法很粗糙，读者不太清楚，这通常比速度更重要。

这不会将整数转换为字符串并将其合并：

>>> sum([(10 ** i) * input[len(input)-i-1] for i in range(len(input))])
123

这是一行中的for循环。

如何：

In [19]: filter(set('0123456789').__contains__,str((1,2,3)))
Out[19]: '123'

我相信这是最简单的解决办法

一个非常快速的解决方案是：

plus=ord("0").__add__ # separate out for readability; bound functions are partially-applied functions
int(str(bytearray(map(plus,x)))) #str is necessary

这与下一个最快的解决方案相比有何优势：

$ python -m timeit -s 'x=tuple(list(range(1,10))*10)' 'plus=ord("0").__add__;int(str(bytearray(map(plus,x))))'
10000 loops, best of 3: 47.7 usec per loop

$ python -m timeit -s "x=tuple(list(range(1,10))*10)" "int(''.join(map(str, x)))"
10000 loops, best of 3: 59 usec per loop

bytearray

解决方案确实是Python 2中最快的解决方案

按照Python 3中的同一行可以做到：

>>> plus = ord("0").__add__
>>> int(bytes(map(plus, x)))

Python3处理字符串和字节的方式与Python2不同，因此为了更好地理解这种情况，我做了一些计时。以下是我在我的机器上得到的结果

使用Python 2.7（）：

使用Python 3.2（）时：

---

自己判断：）

将元组转换为数字的最简单方法是使用字符串格式

input = (1, 3, 7)
output = int('{}{}{}'.format(input[0], input[1], input[2]))

# TEST
print(output) # 137
print(type(output)) # <class 'int'>

input=（1,3,7）
output=int（'{}{}}'。格式（输入[0]，输入[1]，输入[2]））
#试验
打印（输出）#137
打印（输入（输出））#

我刚想发布

求和（10**I*x代表I，x在枚举（x[：-1]））

但现在我不知道这个答案和我的答案不一样吗？@Abhijit这些事情的发展很有趣。我不确定我是否首先发布在这里，但我的答案有很多解释，使用

reversed（）

比

[：-1]

更好，因为它可以更快，阅读更方便。是的，我知道，只是想要一个简短的答案，我想我会坚持正确地做事情，即使它会生成更长的代码，特别是由于

enumerate

和

reversed

有这么长的名称…@jamylak与Python一起使用，该语言的很大一部分目标是可读性和可维护性，因此我总是建议更多地为可读性而工作，而不是为简短而工作，但每个都有自己的名称。值得注意的是，在Python3.x中，

reduce（）

也是+1。我认为这是最具可读性的，也是最快的（参见计时比较）。可以说是最具可读性的，当然是最优雅的，但只有在这种较小的情况下才是最快的。字符串方法是处理大数最快的方法。这里使用的

reduce（）

基本上是多项式分解的一种经典方法，称为。也许更好：

reverse（input）

而不是

input[：：-1]

。到目前为止，这个解决方案是唯一一个能够处理

x=（1,9,10,15）

。不清楚OP是否也要处理它们。@RikPoggi我认为这是一个非常不可能的用例，您实际上不知道这是该用例的正确输出。OP从未指定是否希望x=

（1,9,10,15）

表示

191015

或

15*1+10*10+9*100+1*1000

。根据您处理问题的方式，这两种方法都可以被视为有效。他是在考虑输入一组数字还是一组按基数分割的值？嗯，是的，虽然他没有指定它为数字，但我认为我们可以安全地假设它们是。然而，我不明白你怎么能把

（1,9,10,15）

解释为

15*1+10*10+9*100+1*1000

@Lattyware：不清楚这是否是一个用例。我非常怀疑

x=（1,9,10,15）

应该给出

2015

而不是

191015

，我认为这一切都取决于元组是如何生成的。不管怎样，我在运算，希望得到一些许可。你的元组只有一位整数吗？您是否计划像

x=（1,9,10150）

这样的单元组？如果是，您能指定应该有什么输出吗？请提供更多信息。使用

\uuuu函数\uuuu

不是一个好主意，尤其是当有其他选项可用时，对吗？@0xc0de为什么不

str

永远不会丢失

\uuuu contains

方法，这避免了（python）函数调用和运算符解析开销。请注意，在python 3.x中，第一个示例返回

['1'，'2'，'3']

，而不是

'123'

，无论哪种方式，请求的输出都是int，而不是字符串。关于引用

\uuu add\uu（）

，更好的选择是使用

functools.partial（）

和

operator.add（）

和do

plus=partial（add，ord（“0”）

@Lattyware，以何种方式使用partial更好？至于第一个例子的行为，我想你可以想出如何把它改成int；Python 3只是对语言做了一些奇怪的更改。

>>> plus = ord("0").__add__
>>> int(bytes(map(plus, x)))

int(str(bytearray(map(plus, x))))           8.40 usec/pass
int(bytearray(map(plus, x)).decode())       9.85 usec/pass
int(''.join(map(str, x)))                   11.97 usec/pass
reduce(lambda rst, d: rst * 10 + d, x)      22.34 usec/pass

int(bytes(map(plus, x)))                    7.10 usec/pass
int(bytes(map(plus, x)).decode())           7.80 usec/pass
int(bytearray(map(plus,x)).decode())        7.99 usec/pass
int(''.join(map(str, x)))                   17.46 usec/pass
reduce(lambda rst, d: rst * 10 + d, x)      19.03 usec/pass

input = (1, 3, 7)
output = int('{}{}{}'.format(input[0], input[1], input[2]))

# TEST
print(output) # 137
print(type(output)) # <class 'int'>