Conversione in base 62

Come convertiresti un numero intero in base 62 (come esadecimale, ma con queste cifre: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ').

Ho cercato di trovare una buona libreria Python per questo, ma sembrano tutti occupati con la conversione di stringhe. Il modulo Python base64 accetta solo stringhe e trasforma una singola cifra in quattro caratteri. Stavo cercando qualcosa di simile a quello che usano gli accorciatori di URL.

Non esiste un modulo standard per questo, ma ho scritto le mie funzioni per ottenerlo.

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

Nota il fatto che puoi dargli qualsiasi alfabeto da usare per la codifica e la decodifica. Se tralasci l' alphabetargomento, otterrai l'alfabeto di 62 caratteri definito sulla prima riga di codice, e quindi la codifica / decodifica dalla / alla 62 base.

Spero che questo ti aiuti.

PS - Per gli accorciatori di URL, ho scoperto che è meglio tralasciare alcuni caratteri confusi come 0Ol1oI ecc. Quindi uso questo alfabeto per le mie esigenze di accorciamento degli URL - "23456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"

Divertiti.

Una volta ho scritto una sceneggiatura anche per questo, penso che sia abbastanza 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

Utilizzo di esempio:

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

Il seguente decoder-maker funziona con qualsiasi base ragionevole, ha un ciclo molto più ordinato e fornisce un messaggio di errore esplicito quando incontra un carattere non valido.

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 stai cercando la massima efficienza (come django), ti consigliamo qualcosa come il seguente. Questo codice è una combinazione di metodi efficienti di Baishampayan Ghose, 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

Puoi anche calcolare il tuo dizionario in anticipo. (Nota: la codifica con una stringa mostra una maggiore efficienza rispetto a un elenco, anche con numeri molto lunghi.)

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

1 milione di numeri codificati e decodificati in meno di 2,5 secondi. (2.2 Ghz i7-2670QM)

Se usi il framework django, puoi usare il modulo django.utils.baseconv.

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

Oltre a base62, baseconv ha definito anche base2 / base16 / base36 / base56 / base64.

Probabilmente vuoi base64, non base62. C'è una versione compatibile con l'URL che fluttua in giro, quindi i due caratteri di riempimento extra non dovrebbero essere un problema.

Il processo è abbastanza semplice; si consideri che base64 rappresenta 6 bit e un byte regolare rappresenta 8. Assegnare un valore da 000000 a 111111 a ciascuno dei 64 caratteri scelti e unire i 4 valori insieme per far corrispondere un set di 3 base256 byte. Ripeti per ogni set di 3 byte, riempiendo alla fine con la tua scelta di caratteri di riempimento (0 è generalmente utile).

Se tutto ciò di cui hai bisogno è generare un ID breve (dal momento che menzioni accorciatori di URL) piuttosto che codificare / decodificare qualcosa, questo modulo potrebbe aiutare:

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

puoi scaricare il modulo zbase62 da pypi

per esempio

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

Ho tratto grandi benefici dai post degli altri qui. Inizialmente avevo bisogno del codice python per un progetto Django, ma da allora sono passato a node.js, quindi ecco una versione javascript del codice (la parte di codifica) fornita da Baishampayan Ghose.

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

Spero che il seguente frammento possa aiutare.

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

Utilizzo per il tuo caso:

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

Ovviamente, puoi specificare un altro alfabeto, composto da un numero maggiore o minore di simboli, quindi convertirà il tuo numero nella base numerica minore o maggiore. Ad esempio, se si specifica "01" come alfabeto, verrà emessa una stringa che rappresenta il numero di input come binario.

Puoi mescolare l'alfabeto inizialmente per avere la tua rappresentazione unica dei numeri. Può essere utile se stai creando un servizio di abbreviazione di URL.

Ora c'è una libreria Python per questo.

Sto lavorando alla creazione di un pacchetto pip per questo.

Ti consiglio di usare il mio bases.py https://github.com/kamijoutouma/bases.py che è stato ispirato da 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

fare riferimento a https://github.com/kamijoutouma/bases.py#known-basesalphabets per sapere quali basi sono utilizzabili

Ecco la mia soluzione:

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

spiegazione

In qualsiasi base ogni numero è uguale a a1+a2*base**2+a3*base**3...Quindi l'obiettivo è trovare tutte le as.

Per ogni N=1,2,3...il codice isola il aN*base**N"modulo" bper b=base**(N+1)cui divide tutti gli as più grandi di Ne affetta tutti gli as in modo che il loro numero di serie sia minore di Ndecrescente aogni volta che la funzione viene chiamata ricorsivamente dalla corrente aN*base**N.

Base%(base-1)==1quindi base**p%(base-1)==1e quindi q*base^p%(base-1)==qcon una sola eccezione, quando q==base-1che ritorna 0. Per risolvere quel caso, ritorna 0. La funzione controlla 0dall'inizio.

vantaggi

In questo esempio c'è solo una moltiplicazione (invece di una divisione) e alcune operazioni di modulo, che sono tutte relativamente veloci.

Personalmente mi piace la soluzione di Baishampayan, soprattutto per aver messo a nudo i personaggi confusi.

Per completezza e soluzione con prestazioni migliori, questo post mostra un modo per utilizzare il modulo Python base64.

L'ho scritto tempo fa e ha funzionato abbastanza bene (negativi e tutto incluso)

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

mi dispiace per la durata di tutto questo

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

Ecco un modo ricorrente e iterativo per farlo. Quello iterativo è un po 'più veloce a seconda del conteggio dell'esecuzione.

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

Pitone 3.7.x

Ho trovato un GitHub di dottorato per alcuni algoritmi durante la ricerca di uno script base62 esistente . Non funzionava per l'attuale versione max di Python 3 in questo momento, quindi sono andato avanti e ho risolto dove necessario e ho fatto un piccolo refactoring. Di solito non lavoro con Python e l'ho sempre usato ad hoc, quindi YMMV. Tutto il merito va al Dr. Zhihua Lai . Ho appena risolto i problemi per questa versione di Python.

file 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

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

uscita di try_base62.py

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

_{^{Poiché non c'erano informazioni sulla licenza nel repository, ho inviato un PR in modo che l'autore originale sappia almeno che altre persone stanno usando e modificando il loro codice.}}

Mi spiace, non posso aiutarti con una libreria qui. Preferirei usare base64 e aggiungere solo caratteri extra a tua scelta, se possibile!

Quindi puoi usare il modulo base64.

Se questo è davvero, davvero non possibile:

Puoi farlo da solo in questo modo (questo è pseudo-codice):

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

con semplice ricorsione

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

Il più semplice in assoluto.

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