어떤베이스의 정수를 문자열로 변환 하는가?
https://stackoverflow.com/questions/2267362
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
Python은 주어진베이스를 통해 정수를 쉽게 만들 수 있습니다.
int(str, base).
역을 수행하고 싶습니다 : 정수에서 문자열 생성, 즉 나는 어떤 기능을 원한다 int2base(num, base),
int(int2base(x, b), b) == x
함수 이름/인수 순서는 중요하지 않습니다.
모든 숫자에 대해 x 그리고베이스 b 저것 int() 받아 들일 것입니다.
이것은 쓰기 쉬운 기능입니다. 실제로이 질문에서 설명하는 것보다 쉽습니다. 그러나 나는 무언가를 놓치고 있어야한다고 생각합니다.
나는 기능에 대해 알고 있습니다 bin, oct, hex, 그러나 몇 가지 이유로 사용할 수 없습니다.
이러한 기능은 이전 버전의 Python에서 사용할 수 없습니다. (2.2)와의 호환성이 필요합니다.
나는 다른베이스와 동일한 방식으로 호출 될 수있는 일반적인 솔루션을 원합니다.
2, 8, 16 이외의 기지를 허용하고 싶습니다.
관련된
해결책
고대 버전의 파이썬과의 호환성이 필요한 경우 사용할 수 있습니다. gmpy (빠르고 완전히 일반적인 Int-String 전환 기능이 포함되어 있으며 그러한 고대 버전을 위해 구축 할 수 있습니다. 최근 릴리스가 유서 깊은 파이썬 및 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])
ref :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 인코딩 허용)
- 음수와 0을 확인합니다
- 복소수를 문자열의 튜플에 맵핑합니다
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 패키지를 만들었다.
내베이스를 사용하는 것이 좋습니다 https://github.com/kamijoutouma/bases.py Base.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어떤 기지가 사용할 수 있는지
편집 : PIP 링크 https://pypi.python.org/pypi/bases.py/0.2.2
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'
관심있는 사람들을위한 재귀 솔루션. 물론 이것은 음의 이진 값으로 작동하지 않습니다. 2의 보완을 구현해야합니다.
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에 의해 "mouduling"에 의해 b=base**(N+1) 모든 a가 n보다 더 큰 슬라이스하고, 전류에 의해 func를 호출 할 때마다 A를 줄임으로써 직렬이 N보다 작다는 모든 A를 슬라이싱합니다. aN*base**N .
Base%(Base-1) == 1은 기본 ** P%(Base-1) == 1에 대해 q*base^p%(Base-1) == q에서 q = base-1만으로 하나의 예외만으로. 0을 반환하려면 0을 반환 할 경우 0을 반환합니다.
장점
이 샘플에는 분할 대신 하나의 곱셈과 소량의 시간이 걸리는 일부 moudulues 만 있습니다.
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)
또 다른 짧은 것 (그리고 IMO를 이해하기 쉬운) :
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.3ms 또는 1000 배 더 빠릅니다). 그 이유는 큰 정수가 기본 256 (바이트)에 메모리에 저장되기 때문입니다. 각 바이트는 단순히 2 자 육각 문자열로 변환 할 수 있습니다. 이 정렬은 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> 0 (6*6 = 36)의 경우 6으로 끝납니다. (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]
나는 여기에서 플로트의 변환기를 보지 못했습니다. 그리고 나는 항상 3 자리 숫자에 대한 그룹화를 놓쳤다.
할 것:
과학적 표현의 -인민 (n.nnnnnn*10**(exp) - '10' ~이다 self.baseDigits[1::-1]/self.to_string(len (self.baseDigits))
-from_string-function.
-Base 1-> 로마 숫자?
-Agles와의 복잡한 재림
그래서 여기 내 해결책이 있습니다.
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
모든베이스로 변환하려면 역도 쉽습니다.
