在 Python 中使用“str”是处理数字的正确习语

Question

我了解在 Python 中处理数字的数字的一种方法是将数字转换为字符串，然后使用字符串方法将生成的“数字”分割成“数字”组。例如，假设我有一个测试素数的函数prime，我可以用

确认整数n既是左又是右truncatable prime

all(prime(int(str(n)[:-i])) and prime(int(str(n)[i:])) for i in range(1, len(str(n))))

此方法首先将 n 转换为字符串以便对其进行切片，然后将该切片转换回整数以便检查其素数。也许这是我使用静态类型语言的历史，或者是一些模糊的认为字符串“昂贵”的想法，或者是包含用于类似操作的内置功能的语言的经验（例如 Mathematica 的 IntegerDigits 和 FromDigits）；但我想知道这是否是执行此类任务的正确方法。

在字符串和数字之间来回转换是否是在 Python 中访问数字的正确（甚至是唯一）方法。有没有更有效的方法？

Answer 1

在您的示例代码中，您可以使用divmod 而不是对数字进行字符串切片。 divmod(x, y) 返回元组 x//y, x%y，对于 y 的值，10**i 正是您想要的数字的左右部分。这不一定更 Pythonic，尽管它可能会更快一些。

sn = str(n)
all(prime(int(sn[:i])) and prime(int(sn[i:])) for i in range(1, len(sn))) # original
all(all(map(prime, divmod(n, 10**i))) for i in range(1, len(sn))) # variant using divmod

我认为对于更一般的数字运算，使用str 可能非常明智，因为对数字基数的幂进行大量数学运算可能比直接对字符串中的数字进行运算更难理解。

编写要读取的代码，除非它对性能非常敏感。

Answer 2

Python 的原生整数以 2 的幂为基数存储，因此将它们转换为十进制表示法或从十进制表示法转换需要真正的工作。在许多需要频繁访问非常大整数的十进制数字的“谜题”;-) 问题中，使用decimal 模块可以改变世界。它以 10 的幂为基数存储值，因此“转换”到/从十进制数字是微不足道的费用。

>>> import decimal
>>> x = decimal.Decimal('1e20') - 1
>>> x
Decimal('99999999999999999999')
>>> x.as_tuple().digits
(9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9)

这需要与位数成线性关系的时间。将本机整数转换为十进制所需的时间是位数的二次方。

不过，我可以在这里猜测您的具体应用，但使用 divmod() 确实是最好的方法。

Answer 3

这个怎么样？

def digits(n):
    if n == 0:
        yield 0
    else:
        while n:
            yield n % 10
            n //= 10

for digit in digits(123):
    # do something with digit

这应该比您展示的示例更方便和更有效。

编辑：我想再添加两件事。

0) 您可以根据需要扩展该技术。假设您要测试右截断素数。假设你有一个函数is_prime()：

def right_trunc_int_values(n):
    if n == 0:
        yield 0
    else:
        while n:
            yield n
            n //= 10

assert(all(is_prime(n) for n in right_trunc_int_values(317))

1) 为了解决方便使用数字的一般问题，您也许可以使用decimal 模块。我会更多地研究这个。但与此同时，您可以使用我的digits() 函数来制作可索引的数字列表：

d = list(digits(123))
print(d[2])  # prints 2

编辑：将一系列数字转换为整数值非常容易。

def int_from_digits(digits):
    result = 0
    found_a_digit = False
    for digit in reversed(digits):
        result = result * 10 + digit
    return result 

def is_right_trunc_prime(n):
    d = list(digits(n))
    return all(is_prime(int_from_digits(d[:i]) for i in range(len(d), -1, -1)))

# example from question of left and right truncatable check
d = list(digits(n))
all(prime(int_from_digits(d[:-i])) and prime(int_from_digits(d[i:])) for i in range(1, len(d)))

Answer 4

这一直是我的方法，而且效果很好，尽管我从未对速度进行过太多测试。它在需要迭代数字的排列/组合时特别有效，因为您可以使用 itertools 包中的函数构建此类字符串。

当然还有其他方法涉及不太直接的数学运算，但除非速度绝对至关重要，否则我觉得字符串方法是最 Pythonic 的。

---

例如，这里是一种更数学的方法，其中 a 和 b 从右侧开始索引（即个位为 0，十位为 1，等等）：

def getSubdigits(n, a, b):
    n %= 10 ** a
    n //= 10 ** b
    return n

要使用与字符串切片相同的索引，您需要先找到总位数，函数变为：

def getSubdigits2(n, a, b):
    l = int(math.ceil(math.log10(n)))
    n %= 10 ** (l - a)
    n //= 10 ** (l - b)
    return n

和字符串切片等效：

def subDigits3(n, a, b):
    return int(str(n)[a:n])

这是计时结果：

• subDigits: 0.293327726114
• subDigits2: 0.850861833337
• subDigits3: 0.990543234267

我从该结果中得出的结论是，除非您真的关心速度，否则切片方法很好，在这种情况下，您需要使用第一种方法并考虑另一个方向的索引。

Answer 5

在没有str() 和切片的情况下测试左截断素数：

def is_prime(n):
    if n < 2:
        return False
    elif n == 2:
        return True
    elif n % 2 == 0:
        return False
    return all(n % x for x in xrange(3,int(pow(n,0.5))+1,2))

def is_left_truncatable_prime(n):
    largest_power_of_ten = 1
    while largest_power_of_ten < n:
        largest_power_of_ten *= 10
    while True:
        largest_power_of_ten /= 10 # Use // in Python 3
        if is_prime(n):
            n %= largest_power_of_ten
            if n == 0:
                return True
        else:
            return False

print is_left_truncatable_prime(167) # True
print is_left_truncatable_prime(173) # True
print is_left_truncatable_prime(171) # False

我没有对此进行广泛的测试，如果有任何错误，请见谅。如果有，请告诉我，我会修复它们。

编辑：稍微修正一下代码。