La Base de 62 conversion

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=BASE62):
    """Encode a positive number in Base X

    Arguments:
    - `num`: The number to encode
    - `alphabet`: The alphabet to use for encoding
    """
    if num == 0:
        return alphabet[0]
    arr = []
    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 encoding
    """
    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

Avis le fait que vous pouvez lui donner tout l'alphabet à utiliser pour l'encodage et le décodage. Si vous laissez le alphabet argument, vous allez obtenir de l'62 caractères de l'alphabet définies sur la première ligne de code, et donc de l'encodage/décodage/à partir de 62 de la base.

Espère que cette aide.

PS - Pour les raccourcisseurs d'URL, j'ai trouvé qu'il est préférable de laisser un peu de confusion des personnages comme 0Ol1oI etc. J'ai donc utiliser cet alphabet pour mon raccourcissement d'URL besoins "23456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"

Avoir du plaisir.

La suite du décodeur maker est compatible avec la toute base raisonnable, est beaucoup plus propre de la boucle, et donne un message d'erreur explicite quand il rencontre un caractère non valide.

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)

Vous voulez probablement base64, pas base62. Il y a une URL de la version de compatible avec flottant autour, de sorte que les deux caractères de remplissage ne devrait pas être un problème.

Le processus est assez simple; considère que base64 représente 6 bits et d'octets, ne représente que 8. Affecter une valeur à partir de 000000 à 111111 pour chacun des 64 caractères choisis, et mettre les 4 valeurs pour correspondre à un ensemble de 3 base256 octets. Répétez l'opération pour chaque ensemble de 3 octets, rembourrage à la fin avec votre choix de rembourrage personnage (0 est généralement utile).

vous pouvez télécharger zbase62 module de pypi

par exemple

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

J'espère que le fragment de code suivant pourrait 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)])

D'utilisation pour votre cas:

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

Évidemment, vous pouvez spécifier un autre alphabet, composé de plus ou moins grand nombre de symboles, puis il vous permet de convertir votre numéro de téléphone sur le plus ou moins grand nombre de la base. Par exemple, '01', comme un alphabet de sortie de chaîne de caractères représentant le numéro d'entrée binaire.

Vous pouvez shuffle l'alphabet d'abord avoir votre unique de représentation des nombres. Il peut être utile si vous faites le raccourcisseur d'URL de service.

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

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

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

J'ai écrit ce un temps, et c'est assez bien travaillé (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 longueur de tout

Voici un recurive et de façon itérative pour le faire. L'itératif est un peu plus rapide en fonction sur le compte de l'exécution.

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

Désolé, je ne peux pas vous aider avec une bibliothèque ici. Je préfère utiliser base64 et juste en ajoutant à des caractères supplémentaires pour votre choix, si possible!

Ensuite, vous pouvez utiliser le base64 module.

Si c'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)