Conversão de base 62

Como você converteria um número inteiro em base 62 (como hexadecimal, mas com estes dígitos: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ').

Tenho tentado encontrar uma boa biblioteca Python para ele, mas todos parecem estar ocupados com a conversão de strings. O módulo Python base64 aceita apenas strings e transforma um único dígito em quatro caracteres. Eu estava procurando por algo semelhante ao que os encurtadores de URL usam.

Não existe um módulo padrão para isso, mas escrevi minhas próprias funções para fazer isso.

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

Observe o fato de que você pode fornecer qualquer alfabeto para usar na codificação e decodificação. Se você deixar o alphabetargumento de fora, obterá o alfabeto de 62 caracteres definido na primeira linha do código e, portanto, a codificação / decodificação de / para a base 62.

Espero que isto ajude.

PS - Para encurtadores de URL, descobri que é melhor deixar alguns caracteres confusos como 0Ol1oI etc. Portanto, uso este alfabeto para minhas necessidades de encurtamento de URL - "23456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"

Diverta-se.

Uma vez escrevi um script para fazer isso também, acho que é bastante elegante :)

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

Exemplo de uso:

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

O fabricante de decodificadores a seguir funciona com qualquer base razoável, tem um loop muito mais organizado e fornece uma mensagem de erro explícita quando encontra um caractere inválido.

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)

Se você está procurando a mais alta eficiência (como django), você vai querer algo como o seguinte. Este código é uma combinação de métodos eficientes de Baishampayan Ghose e WoLpH e 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

Você também pode calcular o seu dicionário com antecedência. (Observação: a codificação com uma string mostra mais eficiência do que com uma lista, mesmo com números muito longos.)

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

Codificou e decodificou 1 milhão de números em menos de 2,5 segundos. (2,2 Ghz i7-2670QM)

Se você usar o framework django, você pode usar o módulo django.utils.baseconv.

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

Além de base62, o baseconv também definiu base2 / base16 / base36 / base56 / base64.

Você provavelmente deseja base64, não base62. Há uma versão compatível com URL dele circulando, então os dois caracteres de preenchimento extras não devem ser um problema.

O processo é bastante simples; considere que base64 representa 6 bits e um byte regular representa 8. Atribua um valor de 000000 a 111111 a cada um dos 64 caracteres escolhidos e coloque os 4 valores juntos para corresponder a um conjunto de 3 bytes base256. Repita para cada conjunto de 3 bytes, preenchendo no final com sua escolha de caractere de preenchimento (0 geralmente é útil).

Se tudo o que você precisa é gerar um ID curto (já que você mencionou encurtadores de URL) em vez de codificar / decodificar algo, este módulo pode ajudar:

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

você pode baixar o módulo zbase62 de pypi

por exemplo

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

Eu me beneficiei muito das postagens de outros aqui. Eu precisava do código python originalmente para um projeto Django, mas desde então eu mudei para node.js, então aqui está uma versão javascript do código (a parte de codificação) que Baishampayan Ghose forneceu.

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"));

Espero que o seguinte snippet possa ajudar.

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)])

Uso para o seu caso:

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

Obviamente, você pode especificar outro alfabeto, consistindo em um número maior ou menor de símbolos, então ele converterá seu número para a base numérica menor ou maior. Por exemplo, fornecer '01' como um alfabeto produzirá uma string que representa o número de entrada como binário.

Você pode embaralhar o alfabeto inicialmente para ter uma representação única dos números. Pode ser útil se você estiver fazendo um serviço de encurtador de URL.

Agora existe uma biblioteca python para isso.

Estou trabalhando em fazer um pacote pip para isso.

Eu recomendo que você use meu bases.py https://github.com/kamijoutouma/bases.py que foi inspirado em 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

consulte https://github.com/kamijoutouma/bases.py#known-basesalphabets para saber quais bases são utilizáveis

Esta é minha solução:

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()

explicação

Em qualquer base, cada número é igual a a1+a2*base**2+a3*base**3...Portanto, o objetivo é encontrar todos os as.

Para cada N=1,2,3...código isola o aN*base**Npor "moduloing" por bpara b=base**(N+1)que corta todo aé maior do que N, e cortando todo o aé de modo que sua série é menor do que Ndiminuindo acada vez que a função é chamada de forma recursiva pela corrente aN*base**N.

Base%(base-1)==1portanto base**p%(base-1)==1e, portanto, q*base^p%(base-1)==qcom apenas uma exceção, quando q==base-1que retorna 0. Para consertar esse caso, ele retorna 0. A função verifica 0desde o início.

vantagens

Neste exemplo, há apenas uma multiplicação (em vez de uma divisão) e algumas operações de módulo, que são todas relativamente rápidas.

Pessoalmente, gosto da solução de Baishampayan, principalmente por despir os personagens confusos.

Para integridade e solução com melhor desempenho, este post mostra uma forma de usar o módulo Python base64.

Escrevi isso há um tempo e funcionou muito bem (negativos e todos incluídos)

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

desculpe pela duração de tudo

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

Aqui está uma maneira recorrente e iterativa de fazer isso. O iterativo é um pouco mais rápido dependendo da contagem de execução.

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

Pitão 3.7.x

Encontrei um github de PhD para alguns algoritmos ao procurar um script base62 existente . Não funcionou para a versão max atual do Python 3 neste momento, então fui em frente e consertei onde necessário e fiz uma pequena refatoração. Eu normalmente não trabalho com Python e sempre usei ad-hoc, então YMMV. Todo o crédito vai para o Dr. Zhihua Lai . Acabei de resolver os problemas desta versão do Python.

Arquivo 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

Arquivo 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])}')

saída de try_base62.py

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

_{^{Como não havia informações de licenciamento no repo, eu enviei um PR para que o autor original pelo menos saiba que outras pessoas estão usando e modificando seu código.}}

Não posso ajudá-lo com uma biblioteca aqui. Eu preferiria usar base64 e apenas adicionar caracteres extras à sua escolha - se possível!

Então você pode usar o módulo base64.

Se isso for realmente impossível:

Você pode fazer isso sozinho (este é um pseudocódigo):

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

com recursão simples

"""
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)

Mais simples de todos.

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"))