Conversion en base 62

Comment convertiriez-vous un entier en base 62 (comme hexadécimal, mais avec ces chiffres: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ').

J'ai essayé de trouver une bonne bibliothèque Python pour cela, mais elles semblent toutes être occupées à convertir des chaînes. Le module Python base64 n'accepte que les chaînes et transforme un seul chiffre en quatre caractères. Je cherchais quelque chose qui ressemble à ce que les raccourcisseurs d'URL utilisent.

Il n'y a pas de module standard pour cela, mais j'ai écrit mes propres fonctions pour y parvenir.

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

Notez le fait que vous pouvez lui donner n'importe quel alphabet à utiliser pour l'encodage et le décodage. Si vous laissez l' alphabetargument de côté, vous obtiendrez l'alphabet de 62 caractères défini sur la première ligne de code, et donc l'encodage / décodage vers / à partir de 62 base.

J'espère que cela t'aides.

PS - Pour les raccourcisseurs d'URL, j'ai trouvé qu'il vaut mieux laisser de côté quelques caractères déroutants comme 0Ol1oI etc. Ainsi j'utilise cet alphabet pour mes besoins de raccourcissement d'URL - "23456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"

S'amuser.

Une fois, j'ai écrit un script pour faire cela aussi, je pense que c'est assez élégant :)

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

Exemple d'utilisation:

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

Le décodeur-fabricant suivant fonctionne avec n'importe quelle base raisonnable, a une boucle beaucoup plus ordonnée et donne un message d'erreur explicite lorsqu'il rencontre un caractère invalide.

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)

Si vous recherchez la plus grande efficacité (comme django), vous voudrez quelque chose comme ce qui suit. Ce code est une combinaison de méthodes efficaces de Baishampayan Ghose et WoLpH et 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

Vous pouvez également calculer votre dictionnaire à l'avance. (Remarque: l'encodage avec une chaîne est plus efficace qu'avec une liste, même avec des nombres très longs.)

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

Encodé et décodé 1 million de nombres en moins de 2,5 secondes. (2,2 GHz i7-2670QM)

Si vous utilisez le framework django, vous pouvez utiliser le module django.utils.baseconv.

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

En plus de base62, baseconv a également défini base2 / base16 / base36 / base56 / base64.

Vous voulez probablement base64, pas base62. Il existe une version compatible URL de celui-ci flottant, donc les deux caractères de remplissage supplémentaires ne devraient pas poser de problème.

Le processus est assez simple; considérez que base64 représente 6 bits et un octet régulier représente 8. Attribuez une valeur de 000000 à 111111 à chacun des 64 caractères choisis, et mettez les 4 valeurs ensemble pour correspondre à un ensemble de 3 base256 octets. Répétez pour chaque ensemble de 3 octets, en remplissant à la fin votre choix de caractère de remplissage (0 est généralement utile).

Si tout ce dont vous avez besoin est de générer un identifiant court (puisque vous mentionnez des raccourcisseurs d'URL) plutôt que d'encoder / décoder quelque chose, ce module peut vous aider:

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

vous pouvez télécharger le module zbase62 depuis pypi

par exemple

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

J'ai beaucoup profité des publications des autres ici. J'avais besoin du code python à l'origine pour un projet Django, mais depuis, je me suis tourné vers node.js, voici donc une version javascript du code (la partie encodage) que Baishampayan Ghose a fourni.

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

J'espère que l'extrait suivant pourra vous aider.

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

Utilisation pour votre cas:

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

Évidemment, vous pouvez spécifier un autre alphabet, composé d'un nombre inférieur ou supérieur de symboles, puis il convertira votre nombre en base numérique inférieure ou supérieure. Par exemple, fournir «01» comme alphabet produira une chaîne représentant le nombre d'entrée sous forme de binaire.

Vous pouvez d'abord mélanger l'alphabet pour avoir votre représentation unique des nombres. Cela peut être utile si vous créez un service de raccourcissement d'URL.

Il existe maintenant une bibliothèque python pour cela.

Je travaille sur la création d'un package pip pour cela.

Je vous recommande d'utiliser mon bases.py https://github.com/kamijoutouma/bases.py qui a été inspiré par 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

reportez-vous à https://github.com/kamijoutouma/bases.py#known-basesalphabets pour connaître les bases utilisables

Voici ma solution:

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

explication

Dans n'importe quelle base, chaque nombre est égal à a1+a2*base**2+a3*base**3...Donc le but est de trouver tous les as.

Pour tout N=1,2,3...le code isole le aN*base**Nen "modulant" par bpour b=base**(N+1)quelles tranches tous les as plus grands que N, et en découpant tous les as pour que leur série soit plus petite qu'en Ndiminuant à achaque fois que la fonction est appelée récursivement par le courant aN*base**N.

Base%(base-1)==1donc base**p%(base-1)==1et donc q*base^p%(base-1)==qà une seule exception, quand q==base-1qui revient 0. Pour résoudre ce cas, il revient 0. La fonction vérifie 0depuis le début.

avantages

Dans cet exemple, il n'y a qu'une seule multiplication (au lieu d'une division) et quelques opérations de module, qui sont toutes relativement rapides.

Personnellement, j'aime la solution de Baishampayan, principalement à cause du décapage des personnages déroutants.

Pour être complet et pour une solution avec de meilleures performances, cet article montre un moyen d'utiliser le module Python base64.

J'ai écrit ceci il y a quelque temps et ça a plutôt bien fonctionné (négatifs et tout inclus)

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

désolé pour la durée de tout ça

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

Voici une façon récurrente et itérative de le faire. L'itératif est un peu plus rapide en fonction du nombre d'exécutions.

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

J'ai trouvé un github de doctorat pour certains algorithmes lors de la recherche d'un script base62 existant . Cela ne fonctionnait pas pour la version max actuelle de Python 3 à ce moment-là, je suis donc allé de l'avant et j'ai corrigé le cas échéant et fait un peu de refactorisation. Je ne travaille généralement pas avec Python et je l'ai toujours utilisé ad hoc donc YMMV. Tout le mérite revient au Dr Zhihua Lai . Je viens de résoudre les problèmes de cette version de Python.

fichier 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

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

sortie de try_base62.py

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

_{^{Puisqu'il n'y avait aucune information de licence dans le repo, j'ai soumis un PR afin que l'auteur original sache au moins que d'autres personnes utilisent et modifient leur code.}}

Désolé, je ne peux pas vous aider avec une bibliothèque ici. Je préférerais utiliser base64 et simplement ajouter des caractères supplémentaires à votre choix - si possible!

Ensuite, vous pouvez utiliser le module base64.

Si ce n'est vraiment, vraiment pas possible:

Vous pouvez le faire vous-même de cette façon (c'est un pseudo-code):

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

avec récursion simple

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

Le plus simple jamais.

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