如何将任意基数的整数转换为字符串？
https://stackoverflow.com/questions/2267362
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
Python 允许通过给定基数的字符串轻松创建整数
int(str, base).
我想执行相反的操作： 从整数创建字符串, ， IE我想要一些功能 int2base(num, base), ，这样：
int(int2base(x, b), b) == x
函数名称/参数顺序并不重要。
对于任何数字 x 和基地 b 那 int() 会接受。
这是一个很容易编写的函数：事实上，这比在这个问题中描述它更容易。但是，我觉得我一定错过了一些东西。
我知道这些功能 bin, oct, hex, ，但由于以下几个原因我无法使用它们：
这些函数在旧版本的 Python 上不可用，我需要与 (2.2) 兼容
我想要一个通用的解决方案，可以针对不同的基础以相同的方式调用
我想允许 2、8、16 以外的碱基
有关的
解决方案
如果您需要与旧版 Python 兼容，您可以使用 gmpy （它确实包括一个快速、完全通用的整数到字符串转换函数，并且可以为此类古老版本构建——您可能需要尝试较旧的版本，因为最近的版本尚未针对古老的 Python 和 GMP 版本进行过测试，仅有点最近的），或者，为了降低速度但更方便，使用 Python 代码 - 例如，最简单的：
import string
digs = string.digits + string.ascii_letters
def int2base(x, base):
if x < 0:
sign = -1
elif x == 0:
return digs[0]
else:
sign = 1
x *= sign
digits = []
while x:
digits.append(digs[int(x % base)])
x = int(x / base)
if sign < 0:
digits.append('-')
digits.reverse()
return ''.join(digits)
其他提示
令人惊讶的是，人们只给出了转换为小基数（小于英文字母的长度）的解决方案。没有尝试给出一个可以转换为从 2 到无穷大的任意基数的解决方案。
所以这是一个超级简单的解决方案：
def numberToBase(n, b):
if n == 0:
return [0]
digits = []
while n:
digits.append(int(n % b))
n //= b
return digits[::-1]
所以如果你需要将一些超级大的数字转换为基数 577,
numberToBase(67854 ** 15 - 102, 577), ，会给你一个正确的解决方案：[4, 473, 131, 96, 431, 285, 524, 486, 28, 23, 16, 82, 292, 538, 149, 25, 41, 483, 100, 517, 131, 28, 0, 435, 197, 264, 455],
您稍后可以将其转换为您想要的任何基础
def baseN(num,b,numerals="0123456789abcdefghijklmnopqrstuvwxyz"):
return ((num == 0) and numerals[0]) or (baseN(num // b, b, numerals).lstrip(numerals[0]) + numerals[num % b])
参考：http://code.activestate.com/recipes/65212/
请注意，这可能会导致
RuntimeError: maximum recursion depth exceeded in cmp
对于非常大的整数。
"{0:b}".format(100) # bin: 1100100
"{0:x}".format(100) # hex: 64
"{0:o}".format(100) # oct: 144
很好的答案！我想我的问题的答案是“不”，我并没有错过一些明显的解决方案。这是我将使用的函数，它浓缩了答案中表达的好想法。
- 允许调用者提供的字符映射（允许 base64 编码）
- 检查负数和零
- 将复数映射为字符串元组
def int2base(x,b,alphabet='0123456789abcdefghijklmnopqrstuvwxyz'): 'convert an integer to its string representation in a given base' if b<2 or b>len(alphabet): if b==64: # assume base64 rather than raise error alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" else: raise AssertionError("int2base base out of range") if isinstance(x,complex): # return a tuple return ( int2base(x.real,b,alphabet) , int2base(x.imag,b,alphabet) ) if x<=0: if x==0: return alphabet[0] else: return '-' + int2base(-x,b,alphabet) # else x is non-negative real rets='' while x>0: x,idx = divmod(x,b) rets = alphabet[idx] + rets return rets
Python 没有用于以任意基数打印整数的内置函数。如果您愿意，您必须自己编写。
你可以使用 baseconv.py 来自我的项目： https://github.com/semente/python-baseconv
使用示例：
>>> from baseconv import BaseConverter
>>> base20 = BaseConverter('0123456789abcdefghij')
>>> base20.encode(1234)
'31e'
>>> base20.decode('31e')
'1234'
>>> base20.encode(-1234)
'-31e'
>>> base20.decode('-31e')
'-1234'
>>> base11 = BaseConverter('0123456789-', sign='$')
>>> base11.encode('$1234')
'$-22'
>>> base11.decode('$-22')
'$1234'
有一些 bultin 转换器，例如 baseconv.base2, baseconv.base16 和 baseconv.base64.
递归
我会 简化 这 得票最多的答案 到：
BS="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def to_base(n, b):
return "0" if not n else to_base(n//b, b).lstrip("0") + BS[n%b]
对于同样的建议 RuntimeError: maximum recursion depth exceeded in cmp 对于非常大的整数和负数。（你可以使用sys.setrecursionlimit(new_limit))
迭代
到 避免递归问题:
BS="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def to_base(s, b):
res = ""
while s:
res+=BS[s%b]
s//= b
return res[::-1] or "0"
>>> numpy.base_repr(10, base=3)
'101'
http://code.activestate.com/recipes/65212/
def base10toN(num,n):
"""Change a to a base-n number.
Up to base-36 is supported without special notation."""
num_rep={10:'a',
11:'b',
12:'c',
13:'d',
14:'e',
15:'f',
16:'g',
17:'h',
18:'i',
19:'j',
20:'k',
21:'l',
22:'m',
23:'n',
24:'o',
25:'p',
26:'q',
27:'r',
28:'s',
29:'t',
30:'u',
31:'v',
32:'w',
33:'x',
34:'y',
35:'z'}
new_num_string=''
current=num
while current!=0:
remainder=current%n
if 36>remainder>9:
remainder_string=num_rep[remainder]
elif remainder>=36:
remainder_string='('+str(remainder)+')'
else:
remainder_string=str(remainder)
new_num_string=remainder_string+new_num_string
current=current/n
return new_num_string
这是同一链接中的另一篇文章
def baseconvert(n, base):
"""convert positive decimal integer n to equivalent in another base (2-36)"""
digits = "0123456789abcdefghijklmnopqrstuvwxyz"
try:
n = int(n)
base = int(base)
except:
return ""
if n < 0 or base < 2 or base > 36:
return ""
s = ""
while 1:
r = n % base
s = digits[r] + s
n = n / base
if n == 0:
break
return s
我为此制作了一个 pip 包。
我建议你使用我的bases.py https://github.com/kamijoutouma/bases.py 其灵感来自于bases.js
from bases import Bases
bases = Bases()
bases.toBase16(200) // => 'c8'
bases.toBase(200, 16) // => 'c8'
bases.toBase62(99999) // => 'q0T'
bases.toBase(200, 62) // => 'q0T'
bases.toAlphabet(300, 'aAbBcC') // => 'Abba'
bases.fromBase16('c8') // => 200
bases.fromBase('c8', 16) // => 200
bases.fromBase62('q0T') // => 99999
bases.fromBase('q0T', 62) // => 99999
bases.fromAlphabet('Abba', 'aAbBcC') // => 300
参考 https://github.com/kamijoutouma/bases.py#known-basesalphabets哪些碱基可用
def base(decimal ,base) :
list = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
other_base = ""
while decimal != 0 :
other_base = list[decimal % base] + other_base
decimal = decimal / base
if other_base == "":
other_base = "0"
return other_base
print base(31 ,16)
输出：
「1F」
>>> import string
>>> def int2base(integer, base):
if not integer: return '0'
sign = 1 if integer > 0 else -1
alphanum = string.digits + string.ascii_lowercase
nums = alphanum[:base]
res = ''
integer *= sign
while integer:
integer, mod = divmod(integer, base)
res += nums[mod]
return ('' if sign == 1 else '-') + res[::-1]
>>> int2base(-15645, 23)
'-16d5'
>>> int2base(213, 21)
'a3'
对于那些感兴趣的人来说，这是一个递归解决方案。当然，这不适用于负二进制值。您需要实现二进制补码。
def generateBase36Alphabet():
return ''.join([str(i) for i in range(10)]+[chr(i+65) for i in range(26)])
def generateAlphabet(base):
return generateBase36Alphabet()[:base]
def intToStr(n, base, alphabet):
def toStr(n, base, alphabet):
return alphabet[n] if n < base else toStr(n//base,base,alphabet) + alphabet[n%base]
return ('-' if n < 0 else '') + toStr(abs(n), base, alphabet)
print('{} -> {}'.format(-31, intToStr(-31, 16, generateAlphabet(16)))) # -31 -> -1F
def int2base(a, base, numerals="0123456789abcdefghijklmnopqrstuvwxyz"):
baseit = lambda a=a, b=base: (not a) and numerals[0] or baseit(a-a%b,b*base)+numerals[a%b%(base-1) or (a%b) and (base-1)]
return baseit()
解释
在任何基数中每个数字都等于 a1+a2*base**2+a3*base**3... “任务”是找到所有的a。
对于每一个N=1,2,3... 该代码隔离了 aN*base**N 通过 b 的“模制” b=base**(N+1) 对所有大于 N 的 a 进行切片，并通过每次当前调用 func 时减少 a 来切片其序列小于 N 的所有 a 。 aN*base**N .
Base%(base-1)==1 因此 base**p%(base-1)==1 并且因此 q*base^p%(base-1)==q 只有一个例外，当 q=base-1 时返回 0。为了解决这个问题，以防它返回 0，func 从一开始就检查它是否为 0。
优点
在这个示例中，只有一次乘法（而不是除法）和一些相对需要少量时间的 moudulueses。
num = input("number")
power = 0
num = int(num)
while num > 10:
num = num / 10
power += 1
print(str(round(num, 2)) + "^" + str(power))
def base_changer(number,base):
buff=97+abs(base-10)
dic={};buff2='';buff3=10
for i in range(97,buff+1):
dic[buff3]=chr(i)
buff3+=1
while(number>=base):
mod=int(number%base)
number=int(number//base)
if (mod) in dic.keys():
buff2+=dic[mod]
continue
buff2+=str(mod)
if (number) in dic.keys():
buff2+=dic[number]
else:
buff2+=str(number)
return buff2[::-1]
def dec_to_radix(input, to_radix=2, power=None):
if not isinstance(input, int):
raise TypeError('Not an integer!')
elif power is None:
power = 1
if input == 0:
return 0
else:
remainder = input % to_radix**power
digit = str(int(remainder/to_radix**(power-1)))
return int(str(dec_to_radix(input-remainder, to_radix, power+1)) + digit)
def radix_to_dec(input, from_radix):
if not isinstance(input, int):
raise TypeError('Not an integer!')
return sum(int(digit)*(from_radix**power) for power, digit in enumerate(str(input)[::-1]))
def radix_to_radix(input, from_radix=10, to_radix=2, power=None):
dec = radix_to_dec(input, from_radix)
return dec_to_radix(dec, to_radix, power)
另一个简短的（在我看来更容易理解）：
def int_to_str(n, b, symbols='0123456789abcdefghijklmnopqrstuvwxyz'):
return (int_to_str(n/b, b, symbols) if n >= b else "") + symbols[n%b]
并通过适当的异常处理：
def int_to_str(n, b, symbols='0123456789abcdefghijklmnopqrstuvwxyz'):
try:
return (int_to_str(n/b, b) if n >= b else "") + symbols[n%b]
except IndexError:
raise ValueError(
"The symbols provided are not enough to represent this number in "
"this base")
另一种解决方案适用于基数 2 到 10，需要修改为更高的基数：
def n2b(n, b):
if n == 0:
return 0
d = []
while n:
d.append(int(n % b))
n /= b
return ''.join(map(str,d[::-1]))
例子：
n2b(10,2) => '10100'
int(n2b(10,2),2) => 10
这是处理有符号整数和自定义数字的递归版本。
import string
def base_convert(x, base, digits=None):
"""Convert integer `x` from base 10 to base `base` using `digits` characters as digits.
If `digits` is omitted, it will use decimal digits + lowercase letters + uppercase letters.
"""
digits = digits or (string.digits + string.ascii_letters)
assert 2 <= base <= len(digits), "Unsupported base: {}".format(base)
if x == 0:
return digits[0]
sign = '-' if x < 0 else ''
x = abs(x)
first_digits = base_convert(x // base, base, digits).lstrip(digits[0])
return sign + first_digits + digits[x % base]
字符串并不是表示数字的唯一选择：您可以使用整数列表来表示每个数字的顺序。这些可以很容易地转换为字符串。
没有一个答案拒绝基数 < 2；大多数都会运行得很慢或者因堆栈溢出而崩溃 很大 数字（例如 56789 ** 43210）。为了避免此类失败，请像这样快速减少：
def n_to_base(n, b):
if b < 2: raise # invalid base
if abs(n) < b: return [n]
ret = [y for d in n_to_base(n, b*b) for y in divmod(d, b)]
return ret[1:] if ret[0] == 0 else ret # remove leading zeros
def base_to_n(v, b):
h = len(v) // 2
if h == 0: return v[0]
return base_to_n(v[:-h], b) * (b**h) + base_to_n(v[-h:], b)
assert ''.join(['0123456789'[x] for x in n_to_base(56789**43210,10)])==str(56789**43210)
速度快， n_to_base 相当于 str 对于大数字（在我的机器上大约 0.3 秒），但是如果你比较 hex 你可能会感到惊讶（在我的机器上大约 0.3 毫秒，或者快 1000 倍）。原因是因为大整数以 256（字节）为基数存储在内存中。每个字节都可以简单地转换为两个字符的十六进制字符串。这种对齐仅发生在 2 的幂的基数上，这就是为什么 2,8 和 16（以及 base64、ascii、utf16、utf32）有特殊情况的原因。
考虑十进制字符串的最后一位数字。它与形成其整数的字节序列有何关系？让我们标记字节 s[i] 和 s[0] 是最不重要的（小端）。那么最后一位数字是 sum([s[i]*(256**i) % 10 for i in range(n)]). 。好吧，碰巧 256**i 以 6 结尾，因为 i > 0 (6*6=36)，所以最后一位数字是 (s[0]*5 + sum(s)*6)%10. 。由此可见，最后一位数字取决于所有字节的总和。这种非局部属性使得转换为十进制更加困难。
def baseConverter(x, b):
s = ""
d = string.printable.upper()
while x > 0:
s += d[x%b]
x = x / b
return s[::-1]
我在这里没有看到任何浮点转换器。我总是错过三位数的分组。
去做：
- 科学表达中的数字 (n.nnnnnn*10**(exp) - 这 '10' 是 self.baseDigits[1::-1]/self.to_string(len (self.baseDigits))
-from_string-函数。
-base 1 -> 罗马数字？
-带有角的复合体的repr
所以这是我的解决方案：
DIGITS = "0123456789abcdefghijklmnopqrstuvwxyz"
# note that the order of the digits is reversed for digits before the point
NO_GROUPING = lambda g: g
concat = "".join
concat_backwards = lambda g: concat(e for e in reversed(list(g)))
def grouping(length = 3, char = '_'):
def yieldor(digits):
i = 0
for d in digits:
if i == length:
yield char
i = 0
yield d
i+=1
return yieldor
class Converter:
def __init__(self, baseDigits: (int, str), beforePoint = NO_GROUPING, afterPoint = NO_GROUPING, decimalPoint = '.', digitPrecision = 16, trimZeros = True):
if isinstance(baseDigits, int):
baseDigits = DIGITS[:baseDigits]
self.baseDigits = baseDigits
self.beforePoint = beforePoint
self.afterPoint = afterPoint
self.decimalPoint = decimalPoint
self.digitPrecision = digitPrecision
self.trimZeros = trimZeros
def to_string(self, number: (int, float, complex)) -> str:
if isinstance(number, complex):
if number.imag == 0:
return self.to_string(number.real)
if number.real == 0:
return self.to_string(number.imag) + 'j'
return "({}+{}j)".format(self.to_string(number.real), self.to_string (number.imag))
if number < 0:
return '-' + self.to_string(-number)
digitCount = len(self.baseDigits)
if isinstance(number, float):
# round correctly
precError=digitCount**-self.digitPrecision
number+=0.5*precError
if self.trimZeros:
def yieldor(n):
p = precError
for i in range(self.digitPrecision):
if n <= p:
return
p *= digitCount
n *= digitCount
digit = int(n)
n -= digit
yield self.baseDigits[digit]
else:
def yieldor(n):
for i in range(self.digitPrecision):
n *= digitCount
digit = int(n)
n -= digit
yield self.baseDigits[digit]
a = concat(self.afterPoint(yieldor(number%1)))
return (
self.to_string(int(number)) + (a and self.decimalPoint + a)
)
else: #is int
if not number: return self.baseDigits[0]
def yieldor(n):
while n:
n, digit = divmod(n, digitCount)
yield self.baseDigits[digit]
return concat_backwards(self.beforePoint(yieldor(number)))
# some tests:
if __name__ == "__main__":
def conv_test(num, digits, *argv, **kwv):
print(num, "->", digits if isinstance(digits, int) else "{} ({})".format(len(digits), digits), Converter(digits, *argv, **kwv).to_string(num))
conv_test(True, "ft")
conv_test(123, 12, grouping(2))
conv_test(-0xf00d, 16)
conv_test(1000, True<<True, grouping(4))
conv_test(1_000_000, "0+-", beforePoint = grouping(2, '|'))
conv_test(1.5, 10)
conv_test(0.999999999, 10, digitPrecision = 8)
conv_test(-0.1, 10)
import math
conv_test(math.pi, 10, afterPoint = grouping(5, ' '))
conv_test(0.123456789, 10, digitPrecision = 6)
grSpc = grouping(1, ' ')
conv_test(math.e, ["off", "on"], grSpc, grSpc, " dot ", digitPrecision = 7)
conv_test(1 + 1.5j, 10)
conv_test(50j, 10)
conv_test(10.01, '-<>')
# and generate some brainfuck-code here:
conv_test(1701**42, '+-<>,.][', digitPrecision = 32)
def bn(x,b,ab="0123456789abcdefghijklmnopqrstuvwxyz..."
a = ""
while (x>0):
x,r = divmod(x,n)
a += ab[r]
return a[::-1]
bn(2**100, 36)
输出：
3ewfdnca0n6ld1ggvfgg
要转换为任何基数，逆也很容易。
