Chuyển đổi cơ sở 62

Làm cách nào bạn chuyển đổi một số nguyên sang cơ số 62 (như hệ thập lục phân, nhưng với các chữ số sau: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ').

Tôi đã cố gắng tìm một thư viện Python tốt cho nó, nhưng dường như tất cả chúng đều bận rộn với việc chuyển đổi các chuỗi. Mô-đun base64 của Python chỉ chấp nhận các chuỗi và biến một chữ số duy nhất thành bốn ký tự. Tôi đang tìm kiếm thứ gì đó tương tự như những gì trình rút ngắn URL sử dụng.

Không có mô-đun tiêu chuẩn nào cho việc này, nhưng tôi đã viết các chức năng của riêng mình để đạt được điều đó.

BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

def encode(num, alphabet):
    """Encode a positive number into Base X and return the string.

    Arguments:
    - `num`: The number to encode
    - `alphabet`: The alphabet to use for encoding
    """
    if num == 0:
        return alphabet[0]
    arr = []
    arr_append = arr.append  # Extract bound-method for faster access.
    _divmod = divmod  # Access to locals is faster.
    base = len(alphabet)
    while num:
        num, rem = _divmod(num, base)
        arr_append(alphabet[rem])
    arr.reverse()
    return ''.join(arr)

def decode(string, alphabet=BASE62):
    """Decode a Base X encoded string into the number

    Arguments:
    - `string`: The encoded string
    - `alphabet`: The alphabet to use for decoding
    """
    base = len(alphabet)
    strlen = len(string)
    num = 0

    idx = 0
    for char in string:
        power = (strlen - (idx + 1))
        num += alphabet.index(char) * (base ** power)
        idx += 1

    return num

Lưu ý thực tế là bạn có thể cung cấp cho nó bất kỳ bảng chữ cái nào để sử dụng để mã hóa và giải mã. Nếu bạn bỏ qua alphabetđối số, bạn sẽ nhận được bảng chữ cái 62 ký tự được xác định trên dòng mã đầu tiên và do đó mã hóa / giải mã thành / từ cơ sở 62.

Hi vọng điêu nay co ich.

Tái bút - Đối với trình rút ngắn URL, tôi nhận thấy rằng tốt hơn nên bỏ đi một vài ký tự khó hiểu như 0Ol1oI, v.v. Vì vậy, tôi sử dụng bảng chữ cái này cho nhu cầu rút ngắn URL của mình - "23456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"

Chúc vui vẻ.

Tôi đã từng viết một kịch bản để làm điều này, tôi nghĩ nó khá thanh lịch :)

import string
# Remove the `_@` below for base62, now it has 64 characters
BASE_LIST = string.digits + string.letters + '_@'
BASE_DICT = dict((c, i) for i, c in enumerate(BASE_LIST))

def base_decode(string, reverse_base=BASE_DICT):
    length = len(reverse_base)
    ret = 0
    for i, c in enumerate(string[::-1]):
        ret += (length ** i) * reverse_base[c]

    return ret

def base_encode(integer, base=BASE_LIST):
    if integer == 0:
        return base[0]

    length = len(base)
    ret = ''
    while integer != 0:
        ret = base[integer % length] + ret
        integer /= length

    return ret

Ví dụ sử dụng:

for i in range(100):                                    
    print i, base_decode(base_encode(i)), base_encode(i)

Trình tạo bộ giải mã sau hoạt động với bất kỳ cơ sở hợp lý nào, có vòng lặp gọn gàng hơn nhiều và đưa ra thông báo lỗi rõ ràng khi nó gặp ký tự không hợp lệ.

def base_n_decoder(alphabet):
    """Return a decoder for a base-n encoded string
    Argument:
    - `alphabet`: The alphabet used for encoding
    """
    base = len(alphabet)
    char_value = dict(((c, v) for v, c in enumerate(alphabet)))
    def f(string):
        num = 0
        try:
            for char in string:
                num = num * base + char_value[char]
        except KeyError:
            raise ValueError('Unexpected character %r' % char)
        return num
    return f

if __name__ == "__main__":
    func = base_n_decoder('0123456789abcdef')
    for test in ('0', 'f', '2020', 'ffff', 'abqdef'):
        print test
        print func(test)

Nếu bạn đang tìm kiếm hiệu quả cao nhất (như django), bạn sẽ muốn những thứ như sau. Mã này là sự kết hợp của các phương pháp hiệu quả từ Baishampayan Ghose, WoLpH và John Machin.

# Edit this list of characters as desired.
BASE_ALPH = tuple("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
BASE_DICT = dict((c, v) for v, c in enumerate(BASE_ALPH))
BASE_LEN = len(BASE_ALPH)

def base_decode(string):
    num = 0
    for char in string:
        num = num * BASE_LEN + BASE_DICT[char]
    return num

def base_encode(num):
    if not num:
        return BASE_ALPH[0]

    encoding = ""
    while num:
        num, rem = divmod(num, BASE_LEN)
        encoding = BASE_ALPH[rem] + encoding
    return encoding

Bạn cũng có thể muốn tính toán trước từ điển của mình. (Lưu ý: Mã hóa bằng một chuỗi cho thấy hiệu quả hơn với một danh sách, ngay cả với các số rất dài.)

>>> timeit.timeit("for i in xrange(1000000): base.base_decode(base.base_encode(i))", setup="import base", number=1)
2.3302059173583984

Mã hóa và giải mã 1 triệu số trong thời gian dưới 2,5 giây. (2.2Ghz i7-2670QM)

Nếu bạn sử dụng khung công tác django, bạn có thể sử dụng mô-đun django.utils.baseconv.

>>> from django.utils import baseconv
>>> baseconv.base62.encode(1234567890)
1LY7VK

Ngoài base62, baseconv cũng định nghĩa base2 / base16 / base36 / base56 / base64.

Bạn có thể muốn base64, không base62. Có một phiên bản tương thích với URL của nó nổi xung quanh, vì vậy hai ký tự điền thêm không phải là vấn đề.

Quá trình này khá đơn giản; coi rằng base64 đại diện cho 6 bit và một byte thông thường đại diện cho 8. Gán một giá trị từ 000000 đến 111111 cho từng ký tự trong số 64 ký tự đã chọn và đặt 4 giá trị lại với nhau để khớp với bộ 3 base256 byte. Lặp lại cho mỗi bộ 3 byte, đệm ở cuối với sự lựa chọn của ký tự đệm (0 thường hữu ích).

Nếu tất cả những gì bạn cần là tạo một ID ngắn (vì bạn đề cập đến trình rút gọn URL) thay vì mã hóa / giải mã thứ gì đó, thì mô-đun này có thể giúp:

https://github.com/stochastic-technologies/shortuuid/

bạn có thể tải xuống mô-đun zbase62 từ pypi

ví dụ

>>> import zbase62
>>> zbase62.b2a("abcd")
'1mZPsa'

Tôi đã được hưởng lợi rất nhiều từ những bài viết của người khác ở đây. Ban đầu tôi cần mã python cho dự án Django, nhưng kể từ đó tôi đã chuyển sang node.js, vì vậy đây là phiên bản mã javascript (phần mã hóa) mà Baishampayan Ghose đã cung cấp.

var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

function base62_encode(n, alpha) {
  var num = n || 0;
  var alphabet = alpha || ALPHABET;

  if (num == 0) return alphabet[0];
  var arr = [];
  var base = alphabet.length;

  while(num) {
    rem = num % base;
    num = (num - rem)/base;
    arr.push(alphabet.substring(rem,rem+1));
  }

  return arr.reverse().join('');
}

console.log(base62_encode(2390687438976, "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ"));

Tôi hy vọng đoạn mã sau đây có thể giúp ích.

def num2sym(num, sym, join_symbol=''):
    if num == 0:
        return sym[0]
    if num < 0 or type(num) not in (int, long):
        raise ValueError('num must be positive integer')

    l = len(sym)  # target number base
    r = []
    div = num
    while div != 0: # base conversion
        div, mod = divmod(div, l)
        r.append(sym[mod])

    return join_symbol.join([x for x in reversed(r)])

Cách sử dụng cho trường hợp của bạn:

number = 367891
alphabet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
print num2sym(number, alphabet)  # will print '1xHJ'

Rõ ràng, bạn có thể chỉ định một bảng chữ cái khác, bao gồm số lượng ký hiệu ít hơn hoặc lớn hơn, sau đó nó sẽ chuyển đổi số của bạn thành cơ số nhỏ hơn hoặc lớn hơn. Ví dụ: cung cấp '01' dưới dạng bảng chữ cái sẽ xuất ra chuỗi đại diện cho số đầu vào dưới dạng nhị phân.

Ban đầu, bạn có thể xáo trộn bảng chữ cái để có cách biểu diễn các con số duy nhất. Nó có thể hữu ích nếu bạn đang sử dụng dịch vụ rút ngắn URL.

Hiện có một thư viện python cho việc này.

Tôi đang làm việc để tạo một gói pip cho việc này.

Tôi khuyên bạn nên sử dụng base.py https://github.com/kamijoutouma/bases.py được lấy cảm hứng từ base.js của tôi

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

tham khảo https://github.com/kamijoutouma/bases.py#known-basesalphabets để biết những cơ sở nào có thể sử dụng được

Đây là giải pháp của tôi:

def base62(a):
    baseit = (lambda a=a, b=62: (not a) and '0' or
        baseit(a-a%b, b*62) + '0123456789abcdefghijklmnopqrstuvwxyz'
                              'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[a%b%61 or -1*bool(a%b)])
    return baseit()

giải trình

Trong bất kỳ cơ số nào, mọi số đều bằng a1+a2*base**2+a3*base**3...Vì vậy mục tiêu là tìm tất cả các as.

Đối với mỗi N=1,2,3...mã phân lập các aN*base**Nbằng "moduloing" bởi bvì b=base**(N+1)đó lát tất cả alà lớn hơn N, và cắt tất cả các as để nối tiếp của họ là nhỏ hơn Nbằng cách giảm amọi chức năng được gọi là đệ quy bằng dòng điện aN*base**N.

Base%(base-1)==1do đó base**p%(base-1)==1và do đó q*base^p%(base-1)==qchỉ với một ngoại lệ, khi q==base-1nào trả về 0. Để khắc phục trường hợp đó nó trả về 0. Chức năng kiểm tra 0ngay từ đầu.

lợi thế

Trong mẫu này chỉ có một phép nhân (thay vì phép chia) và một số phép toán mô đun, tất cả đều tương đối nhanh.

Cá nhân tôi thích giải pháp từ Baishampayan, chủ yếu là vì loại bỏ các ký tự khó hiểu.

Để có tính hoàn chỉnh và giải pháp có hiệu suất tốt hơn, bài đăng này chỉ ra cách sử dụng mô-đun Python base64.

Tôi đã viết bài này một thời gian và nó hoạt động khá tốt (âm bản và tất cả được bao gồm)

def code(number,base):
    try:
        int(number),int(base)
    except ValueError:
        raise ValueError('code(number,base): number and base must be in base10')
    else:
        number,base = int(number),int(base)
    if base < 2:
        base = 2
    if base > 62:
        base = 62
    numbers = [0,1,2,3,4,5,6,7,8,9,"a","b","c","d","e","f","g","h","i","j",
               "k","l","m","n","o","p","q","r","s","t","u","v","w","x","y",
               "z","A","B","C","D","E","F","G","H","I","J","K","L","M","N",
               "O","P","Q","R","S","T","U","V","W","X","Y","Z"]
    final = ""
    loc = 0
    if number < 0:
        final = "-"
        number = abs(number)
    while base**loc <= number:
        loc = loc + 1
    for x in range(loc-1,-1,-1):
        for y in range(base-1,-1,-1):
            if y*(base**x) <= number:
                final = "{}{}".format(final,numbers[y])
                number = number - y*(base**x)
                break
    return final

def decode(number,base):
    try:
        int(base)
    except ValueError:
        raise ValueError('decode(value,base): base must be in base10')
    else:
        base = int(base)
    number = str(number)
    if base < 2:
        base = 2
    if base > 62:
        base = 62
    numbers = ["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f",
               "g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v",
               "w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L",
               "M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]
    final = 0
    if number.startswith("-"):
        neg = True
        number = list(number)
        del(number[0])
        temp = number
        number = ""
        for x in temp:
            number = "{}{}".format(number,x)
    else:
        neg = False
    loc = len(number)-1
    number = str(number)
    for x in number:
        if numbers.index(x) > base:
            raise ValueError('{} is out of base{} range'.format(x,str(base)))
        final = final+(numbers.index(x)*(base**loc))
        loc = loc - 1
    if neg:
        return -final
    else:
        return final

xin lỗi về độ dài của tất cả

BASE_LIST = tuple("23456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz")
BASE_DICT = dict((c, v) for v, c in enumerate(BASE_LIST))
BASE_LEN = len(BASE_LIST)

def nice_decode(str):
    num = 0
    for char in str[::-1]:
        num = num * BASE_LEN + BASE_DICT[char]
    return num

def nice_encode(num):
    if not num:
        return BASE_LIST[0]

    encoding = ""
    while num:
        num, rem = divmod(num, BASE_LEN)
        encoding += BASE_LIST[rem]
    return encoding

Đây là một cách khôi phục và lặp lại để làm điều đó. Quá trình lặp lại nhanh hơn một chút tùy thuộc vào số lần thực thi.

def base62_encode_r(dec):
    s = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    return s[dec] if dec < 62 else base62_encode_r(dec / 62) + s[dec % 62]
print base62_encode_r(2347878234)

def base62_encode_i(dec):
    s = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    ret = ''
    while dec > 0:
        ret = s[dec % 62] + ret
        dec /= 62
    return ret
print base62_encode_i(2347878234)

def base62_decode_r(b62):
    s = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    if len(b62) == 1:
        return s.index(b62)
    x = base62_decode_r(b62[:-1]) * 62 + s.index(b62[-1:]) % 62
    return x
print base62_decode_r("2yTsnM")

def base62_decode_i(b62):
    s = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    ret = 0
    for i in xrange(len(b62)-1,-1,-1):
        ret = ret + s.index(b62[i]) * (62**(len(b62)-i-1))
    return ret
print base62_decode_i("2yTsnM")

if __name__ == '__main__':
    import timeit
    print(timeit.timeit(stmt="base62_encode_r(2347878234)", setup="from __main__ import base62_encode_r", number=100000))
    print(timeit.timeit(stmt="base62_encode_i(2347878234)", setup="from __main__ import base62_encode_i", number=100000))
    print(timeit.timeit(stmt="base62_decode_r('2yTsnM')", setup="from __main__ import base62_decode_r", number=100000))
    print(timeit.timeit(stmt="base62_decode_i('2yTsnM')", setup="from __main__ import base62_decode_i", number=100000))

0.270266867033
0.260915645986
0.344734796766
0.311662500262

Python 3.7.x

Tôi đã tìm thấy github của tiến sĩ cho một số thuật toán khi tìm kiếm tập lệnh base62 hiện có . Nó không hoạt động với phiên bản tối đa hiện tại của Python 3 tại thời điểm này vì vậy tôi đã tiếp tục và sửa khi cần thiết và thực hiện một chút cấu trúc lại. Tôi không thường làm việc với Python và luôn sử dụng nó một cách đặc biệt nên YMMV. Tất cả tín dụng thuộc về Tiến sĩ Zhihua Lai . Tôi vừa mới làm việc với phiên bản Python này.

tập tin base62.py

#modified from Dr. Zhihua Lai's original on GitHub
from math import floor
base = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
b = 62;
def toBase10(b62: str) -> int:
    limit = len(b62)
    res = 0
    for i in range(limit):
        res = b * res + base.find(b62[i])
    return res
def toBase62(b10: int) -> str:
    if b <= 0 or b > 62:
        return 0
    r = b10 % b
    res = base[r];
    q = floor(b10 / b)
    while q:
        r = q % b
        q = floor(q / b)
        res = base[int(r)] + res
    return res

tập tin try_base62.py

import base62
print("Base10 ==> Base62")
for i in range(999):
    print(f'{i} => {base62.toBase62(i)}')
base62_samples = ["gud", "GA", "mE", "lo", "lz", "OMFGWTFLMFAOENCODING"]
print("Base62 ==> Base10")
for i in range(len(base62_samples)):
    print(f'{base62_samples[i]} => {base62.toBase10(base62_samples[i])}')

đầu ra của try_base62.py

Base10 ==> Base62
0 => 0
[...]
998 => g6
Base62 ==> Base10
gud => 63377
GA => 2640
mE => 1404
lo => 1326
lz => 1337
OMFGWTFLMFAOENCODING => 577002768656147353068189971419611424

_{^{Vì không có thông tin cấp phép trong repo, tôi đã gửi một bài PR để tác giả gốc ít nhất cũng biết những người khác đang sử dụng và sửa đổi mã của họ.}}

Xin lỗi, tôi không thể giúp bạn với thư viện ở đây. Tôi thích sử dụng base64 hơn và chỉ cần thêm các ký tự bổ sung vào lựa chọn của bạn - nếu có thể!

Sau đó, bạn có thể sử dụng mô-đun base64.

Nếu điều này thực sự, thực sự không thể:

Bạn có thể tự làm theo cách này (đây là mã giả):

base62vals = []
myBase = 62
while num > 0:
   reminder = num % myBase
   num = num / myBase
   base62vals.insert(0, reminder)

với đệ quy đơn giản

"""
This module contains functions to transform a number to string and vice-versa
"""
BASE = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
LEN_BASE = len(BASE)


def encode(num):
    """
    This function encodes the given number into alpha numeric string
    """

    if num < LEN_BASE:
        return BASE[num]

    return BASE[num % LEN_BASE] + encode(num//LEN_BASE)


def decode_recursive(string, index):
    """
    recursive util function for decode
    """

    if not string or index >= len(string):
        return 0

    return (BASE.index(string[index]) * LEN_BASE ** index) + decode_recursive(string, index + 1)


def decode(string):
    """
    This function decodes given string to number
    """

    return decode_recursive(string, 0)

Đơn giản nhất từ ​​trước đến nay.

BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
def encode_base62(num):
    s = ""
    while num>0:
      num,r = divmod(num,62)
      s = BASE62[r]+s
    return s


def decode_base62(num):
   x,s = 1,0
   for i in range(len(num)-1,-1,-1):
      s = int(BASE62.index(num[i])) *x + s
      x*=62
   return s

print(encode_base62(123))
print(decode_base62("1Z"))