entityMap|blocks|key|3i502|text|您可能需要base64，而不是base62。它有一个与URL兼容的版本，所以额外的两个填充字符应该不是问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|98lot|这个过程相当简单；假设base64表示6位，一个常规字节表示8。为所选的64个字符中的每个字符分配一个从000000到111111的值，然后将这4个值放在一起以匹配一组3个base256字节。对每组3个字节重复上述步骤，在末尾填充您选择的填充字符(0通常很有用)。^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

You probably want base64, not base62. There's an URL-compatible version of it floating around, so the extra two filler characters shouldn't be a problem.

The process is fairly simple; consider that base64 represents 6 bits and a regular byte represents 8. Assign a value from 000000 to 111111 to each of the 64 characters chosen, and put the 4 values together to match a set of 3 base256 bytes. Repeat for each set of 3 bytes, padding at the end with your choice of padding character (0 is generally useful).

entityMap|blocks|key|64gft|text|对不起，我不能在这里帮你建图书馆。我更喜欢使用base64，如果可能的话，只需要添加额外的字符就可以了！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ak39o|然后，您可以使用base64模块。|9e0hf|如果这真的，真的是不可能的：|4br9c|你可以这样做(这是伪代码)：^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|I|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|J|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|K|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|L|9|@]|A|@]|B|$]]]]

Sorry, I can't help you with a library here. I would prefer using base64 and just adding to extra characters to your choice -- if possible!

Then you can use the base64 module.

If this is really, really not possible:

You can do it yourself this way (this is pseudo-code):

<pre><code>base62vals = []
myBase = 62
while num &gt; 0:
 reminder = num % myBase
 num = num / myBase
 base62vals.insert(0, reminder)
</code></pre>

entityMap|blocks|key|7s0mn|text|这方面没有标准的模块，但我已经编写了自己的函数来实现这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|f7ch6|请注意，您可以为其提供用于编码和解码的任何字母表。如果省略alphabet参数，您将获得在第一行代码中定义的62个字符的字母表，从而对62+base进行编码/解码。|offset|length|style|CODE|f8s3t|希望这能有所帮助。|815u1|PS+-对于网址缩写程序，我发现最好是省略一些容易混淆的字符，如0Ol1oI等。因此，我使用这个字母表来满足我的网址缩短需求--+"23456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"|p343|玩得开心。^0|0|T|8|0|0|1T|1M|0^^$0|$]|1|@$2|3|4|5|6|7|8|O|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|P|9|@$E|Q|F|R|G|H]]|A|@]|B|$]]|$2|I|4|J|6|7|8|S|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|T|9|@$E|U|F|V|G|H]]|A|@]|B|$]]|$2|M|4|N|6|7|8|W|9|@]|A|@]|B|$]]]]

There is no standard module for this, but I have written my own functions to achieve that.
<pre class="lang-py prettyprint-override"><code>BASE62 = &quot;0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;

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

 Arguments:
 - `num`: The number to encode
 - `alphabet`: The alphabet to use for encoding
 &quot;&quot;&quot;
 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):
 &quot;&quot;&quot;Decode a Base X encoded string into the number

 Arguments:
 - `string`: The encoded string
 - `alphabet`: The alphabet to use for decoding
 &quot;&quot;&quot;
 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
</code></pre>
Notice the fact that you can give it any alphabet to use for encoding and decoding. If you leave the <code>alphabet</code> argument out, you are going to get the 62 character alphabet defined on the first line of code, and hence encoding/decoding to/from 62 base.
Hope this helps.
PS - For URL shorteners, I have found that it's better to leave out a few confusing characters like 0Ol1oI etc. Thus I use this alphabet for my URL shortening needs - <code>&quot;23456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ&quot;</code>
Have fun.

entityMap|blocks|key|4ngce|text|你可以从pypi下载zbase62模块|type|unstyled|depth|inlineStyleRanges|entityRanges|data|d41qu|例如^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

you can download zbase62 module from <a href="http://pypi.python.org/pypi/zbase62" rel="nofollow noreferrer">pypi</a>

eg 

<pre><code>&gt;&gt;&gt; import zbase62
&gt;&gt;&gt; zbase62.b2a("abcd")
'1mZPsa'
</code></pre>

entityMap|blocks|key|fsmjp|text|就我个人而言，我喜欢Baishampayan的解决方案，主要是因为去掉了令人困惑的字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|8dccn|为了完整性，以及更好的性能解决方案，这篇文章展示了一种使用Python+base64模块的方法。^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

Personally I like the solution from Baishampayan, mostly because of stripping the confusing characters.

For completeness, and solution with better performance, <a href="http://fi.am/entry/urlsafe-base64-encodingdecoding-in-two-lines/" rel="nofollow noreferrer">this post</a> shows a way to use the Python base64 module.

entityMap|blocks|key|9l5jj|text|下面的解码器生成器与任何合理的基础一起工作，具有更整洁的循环，并在遇到无效字符时给出明确的错误消息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

The following decoder-maker works with any reasonable base, has a much tidier loop, and gives an explicit error message when it meets an invalid character.

<pre><code>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)
</code></pre>

entityMap|blocks|key|6n57q|text|我曾经写过一个脚本来做这件事，我认为它很优雅:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|d2008|示例用法：^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

I once wrote a script to do this aswell, I think it's quite elegant :)

<pre><code>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
</code></pre>

Example usage:

<pre><code>for i in range(100): 
 print i, base_decode(base_encode(i)), base_encode(i)
</code></pre>

entityMap|blocks|key|d1b0v|text|如果您所需要的只是生成一个短ID+(因为您提到了URL缩写)，而不是编码/解码某些东西，那么这个模块可能会有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|7eu35|https://github.com/stochastic-technologies/shortuuid/^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

If all you need is to generate a short ID (since you mention URL shorteners) rather than encode/decode something, this module might help:

<a href="https://github.com/stochastic-technologies/shortuuid/" rel="nofollow">https://github.com/stochastic-technologies/shortuuid/</a>

entityMap|blocks|key|6njil|text|我在这里从其他人的帖子中获益良多。我最初需要在Django项目中使用python代码，但从那时起我转向了node.js，所以这里是Baishampayan+Ghose提供的代码的javascript版本(编码部分)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

I have benefited greatly from others' posts here. I needed the python code originally for a Django project, but since then I have turned to node.js, so here's a javascript version of the code (the encoding part) that Baishampayan Ghose provided.

<pre><code>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"));
</code></pre>

entityMap|blocks|key|ddeuq|text|我前段时间写了这篇文章，它运行得很好(包括底片和所有的底片)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|35ooj|很抱歉这一切的篇幅太长了^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

I wrote this a while back and it's worked pretty well (negatives and all included)

<pre><code>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 &lt; 2:
 base = 2
 if base &gt; 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 &lt; 0:
 final = "-"
 number = abs(number)
 while base**loc &lt;= number:
 loc = loc + 1
 for x in range(loc-1,-1,-1):
 for y in range(base-1,-1,-1):
 if y*(base**x) &lt;= 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 &lt; 2:
 base = 2
 if base &gt; 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) &gt; 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
</code></pre>

sorry about the length of it all

entityMap|blocks|key|3hphs|text|如果您正在寻找最高的效率(如django)，您将需要如下内容。这段代码是Baishampayan+Ghose和WoLpH以及John+Machin的有效方法的组合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|40vc4|你可能还想提前计算一下你的字典。(注意:使用字符串编码比使用列表编码效率更高，即使是非常长的数字也是如此。)|ep45f|在不到2.5秒的时间内对100万个数字进行编码和解码。(2.2+i7-2670QM)^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|G|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|H|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|I|9|@]|A|@]|B|$]]]]

If you're looking for the highest efficiency (like django), you'll want something like the following. This code is a combination of efficient methods from Baishampayan Ghose and WoLpH and John Machin.

<pre><code># 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
</code></pre>

You may want to also calculate your dictionary in advance. (Note: Encoding with a string shows more efficiency than with a list, even with very long numbers.)

<pre><code>&gt;&gt;&gt; timeit.timeit("for i in xrange(1000000): base.base_decode(base.base_encode(i))", setup="import base", number=1)
2.3302059173583984
</code></pre>

Encoded and decoded 1 million numbers in under 2.5 seconds. (2.2Ghz i7-2670QM)

entityMap|blocks|key|32af7|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|-4|5|6|7|B|8|@]|9|@]|A|$]]]]

<pre><code>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
</code></pre>

entityMap|blocks|key|1mu74|text|我希望下面的代码片段能有所帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|6drt5|案例的用法：|2vr0p|显然，您可以指定另一个字母表，由较少或较大数量的符号组成，然后它会将您的数字转换为较小或较大的数字基数。例如，提供'01‘作为字母表将输出以二进制形式表示输入数字的字符串。|31j3m|你可以先把字母打乱，然后用你自己独特的数字表示法。如果你正在做URL缩短服务，它会很有帮助。^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|I|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|J|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|K|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|L|9|@]|A|@]|B|$]]]]

I hope the following snippet could help. 

<pre><code>def num2sym(num, sym, join_symbol=''):
 if num == 0:
 return sym[0]
 if num &lt; 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)])
</code></pre>

Usage for your case:

<pre><code>number = 367891
alphabet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
print num2sym(number, alphabet) # will print '1xHJ'
</code></pre>

Obviously, you can specify another alphabet, consisting of lesser or greater number of symbols, then it will convert your number to the lesser or greater number base. For example, providing '01' as an alphabet will output string representing input number as binary.

You may shuffle the alphabet initially to have your unique representation of the numbers. It can be helpful if you're making URL shortener service.

entityMap|blocks|key|afdl1|text|这里有一种递归和迭代的方法来实现这一点。根据执行次数的不同，迭代式的速度会更快一些。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

Here is an recurive and iterative way to do that. The iterative one is a little faster depending on the count of execution.

<pre><code>def base62_encode_r(dec):
 s = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
 return s[dec] if dec &lt; 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 &gt; 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
</code></pre>

entityMap|blocks|key|73dt|text|现在有了一个python库来解决这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|bja65|我正在为这个做一个pip包。|c4bt3|我推荐你使用我的受bases.js启发的bases.py+https://github.com/kamijoutouma/bases.py|6ohp|有关哪些基础可用，请参阅https://github.com/kamijoutouma/bases.py#known-basesalphabets^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|I|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|J|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|K|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|L|9|@]|A|@]|B|$]]]]

There is now a python library for this.

I'm working on making a pip package for this.

I recommend you use my bases.py <a href="https://github.com/kamijoutouma/bases.py" rel="nofollow">https://github.com/kamijoutouma/bases.py</a> which was inspired by bases.js

<pre><code>from bases import Bases
bases = Bases()

bases.toBase16(200) // =&gt; 'c8'
bases.toBase(200, 16) // =&gt; 'c8'
bases.toBase62(99999) // =&gt; 'q0T'
bases.toBase(200, 62) // =&gt; 'q0T'
bases.toAlphabet(300, 'aAbBcC') // =&gt; 'Abba'

bases.fromBase16('c8') // =&gt; 200
bases.fromBase('c8', 16) // =&gt; 200
bases.fromBase62('q0T') // =&gt; 99999
bases.fromBase('q0T', 62) // =&gt; 99999
bases.fromAlphabet('Abba', 'aAbBcC') // =&gt; 300
</code></pre>

refer to <a href="https://github.com/kamijoutouma/bases.py#known-basesalphabets" rel="nofollow">https://github.com/kamijoutouma/bases.py#known-basesalphabets</a>
for what bases are usable

entityMap|blocks|key|6t41k|text|这是我的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|o90g|解释|b4god|在任何基数中，每个数字都等于a1%2Ba2*base**2%2Ba3*base**3...，所以我们的目标是找到所有的a。|offset|length|style|CODE|6u3sn|对于每个N=1,2,3...，代码隔离aN*base**N的方法是:对b对b=base**(N%2B1)进行“模块化”，将所有的a分成大于N的片，并对所有的a进行分片，以使它们的序列号小于N，方法是在每次由当前<a>aN*base**N递归调用该函数时，通过减少a来减少它们的序列号。|dm5iu|因此Base%25(base-1)==1为base**p%25(base-1)==1，因此为q*base%5Ep%25(base-1)==q，只有一个例外，即返回0的q==base-1。为了解决这种情况，它返回0。该函数从头开始检查0。|7dofu|优势|2erm8|在这个示例中，只有一个乘法(而不是除法)和一些模运算，它们都相对较快。^0|0|0|E|R|1J|1|0|4|A|J|A|Z|1|11|D|1Q|1|1V|1|24|1|2K|1|2W|1|3L|1|0|2|G|J|J|16|K|21|1|23|9|2P|1|30|1|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|S|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|T|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|U|9|@$G|V|H|W|I|J]|$G|X|H|Y|I|J]]|A|@]|B|$]]|$2|K|4|L|6|7|8|Z|9|@$G|10|H|11|I|J]|$G|12|H|13|I|J]|$G|14|H|15|I|J]|$G|16|H|17|I|J]|$G|18|H|19|I|J]|$G|1A|H|1B|I|J]|$G|1C|H|1D|I|J]|$G|1E|H|1F|I|J]|$G|1G|H|1H|I|J]|$G|1I|H|1J|I|J]]|A|@]|B|$]]|$2|M|4|N|6|7|8|1K|9|@$G|1L|H|1M|I|J]|$G|1N|H|1O|I|J]|$G|1P|H|1Q|I|J]|$G|1R|H|1S|I|J]|$G|1T|H|1U|I|J]|$G|1V|H|1W|I|J]|$G|1X|H|1Y|I|J]]|A|@]|B|$]]|$2|O|4|P|6|7|8|1Z|9|@]|A|@]|B|$]]|$2|Q|4|R|6|7|8|20|9|@]|A|@]|B|$]]]]

Here's my solution:
<pre><code>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()
</code></pre>
<hr />
<h2>explanation</h2>
In any base every number is equal to <code> a1+a2*base**2+a3*base**3...</code> So the goal is to find all the <code>a</code>s.
For every <code>N=1,2,3...</code> the code isolates the <code>aN*base**N</code> by &quot;moduloing&quot; by <code>b</code> for <code>b=base**(N+1)</code> which slices all <code>a</code>s bigger than <code>N</code>, and slicing all the <code>a</code>s so that their serial is smaller than <code>N</code> by decreasing <code>a</code> everytime the function is called recursively by the current <code>aN*base**N</code>.
<code>Base%(base-1)==1</code> therefore <code>base**p%(base-1)==1</code> and therefore <code>q*base^p%(base-1)==q</code> with only one exception, when <code>q==base-1</code> which returns <code>0</code>. To fix that case it returns <code>0</code>. The function checks for <code>0</code> from the beginning.
<hr />
<h2>advantages</h2>
In this sample there's only one multiplication (instead of a division) and some modulus operations, which are all relatively fast.

entityMap|blocks|key|h4k7|text|如果你使用django框架，你可以使用django.utils.baseconv模块。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|6hpl1|除了base62，baseconv还定义了base2/base16/base36/base56/base64。^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

If you use django framework, you can use django.utils.baseconv module.

<pre><code>&gt;&gt;&gt; from django.utils import baseconv
&gt;&gt;&gt; baseconv.base62.encode(1234567890)
1LY7VK
</code></pre>

In addition to base62, baseconv also defined base2/base16/base36/base56/base64.

entityMap|blocks|key|ef1tn|text|使用简单的递归|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

with simple recursion

<pre class="lang-py prettyprint-override"><code>"""
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 &lt; 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 &gt;= 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)

</code></pre>

entityMap|blocks|key|27os7|text|Python+3.7.x|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|e115m|在寻找现有的base62脚本时，我发现了一些算法的PhD's+github。它不适用于当前最大版本的Python3，所以我继续在需要的地方进行了修复，并做了一些重构。我通常不使用Python，一直使用它，所以YMMV。所有功劳都归功于赖志华博士。我刚刚解决了这个版本的Python的问题。|b7bg6|文件base62.py|18p8g|文件try_base62.py|bph2m|try_base62.py的输出|egbc4|Base10+==>+Base62|3ln34|0+=>+0|bdfdr|[...]|456a3|998+=>+g6|9flhf|Base62+==>+Base10|2aneg|gud+=>+63377|b31c6|GA+=>+2640|4ppau|mE+=>+1404|bj9dp|lo+=>+1326|f1hkl|lz+=>+1337|2nhoa|OMFGWTFLMFAOENCODING+=>+577002768656147353068189971419611424|fc7lp|6v8iq|因为在repo中没有许可信息，所以我提交了PR，所以原始作者至少知道其他人正在使用和修改他们的代码。^0|7|5|0|0|2|9|0|2|D|0|0|D|0|0|H|0|0|6|0|0|5|0|0|9|0|0|H|0|0|C|0|0|A|0|0|A|0|0|A|0|0|A|0|0|1O|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|1D|9|@$A|1E|B|1F|C|D]]|E|@]|F|$]]|$2|G|4|H|6|7|8|1G|9|@]|E|@]|F|$]]|$2|I|4|J|6|7|8|1H|9|@$A|1I|B|1J|C|D]]|E|@]|F|$]]|$2|K|4|L|6|7|8|1K|9|@$A|1L|B|1M|C|D]]|E|@]|F|$]]|$2|M|4|N|6|7|8|1N|9|@$A|1O|B|1P|C|D]]|E|@]|F|$]]|$2|O|4|P|6|7|8|1Q|9|@$A|1R|B|1S|C|D]]|E|@]|F|$]]|$2|Q|4|R|6|7|8|1T|9|@$A|1U|B|1V|C|D]]|E|@]|F|$]]|$2|S|4|T|6|7|8|1W|9|@$A|1X|B|1Y|C|D]]|E|@]|F|$]]|$2|U|4|V|6|7|8|1Z|9|@$A|20|B|21|C|D]]|E|@]|F|$]]|$2|W|4|X|6|7|8|22|9|@$A|23|B|24|C|D]]|E|@]|F|$]]|$2|Y|4|Z|6|7|8|25|9|@$A|26|B|27|C|D]]|E|@]|F|$]]|$2|10|4|11|6|7|8|28|9|@$A|29|B|2A|C|D]]|E|@]|F|$]]|$2|12|4|13|6|7|8|2B|9|@$A|2C|B|2D|C|D]]|E|@]|F|$]]|$2|14|4|15|6|7|8|2E|9|@$A|2F|B|2G|C|D]]|E|@]|F|$]]|$2|16|4|17|6|7|8|2H|9|@$A|2I|B|2J|C|D]]|E|@]|F|$]]|$2|18|4|19|6|7|8|2K|9|@$A|2L|B|2M|C|D]]|E|@]|F|$]]|$2|1A|4|-4|6|7|8|2N|9|@]|E|@]|F|$]]|$2|1B|4|1C|6|7|8|2O|9|@]|E|@]|F|$]]]]

<h2>Python <code>3.7.x</code></h2>

I found a PhD's github for some algorithms when looking for an <a href="https://github.com/DoctorLai/Algorithms/blob/afa74f27469abb43c64258b119f6c330b9e92b6b/Base62/base62.py" rel="nofollow noreferrer">existing base62 script</a>. It didn't work for the current max-version of Python 3 at this time so I went ahead and fixed where needed and did a little refactoring. I don't usually work with Python and have always used it ad-hoc so YMMV. All credit goes to <a href="https://stackoverflow.com/cv/steakovercooked">Dr. Zhihua Lai</a>. I just worked the kinks out for this version of Python. 

<h3>file <code>base62.py</code></h3>

<pre><code>#modified from Dr. Zhihua Lai's original on GitHub
from math import floor
base = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
b = 62;
def toBase10(b62: str) -&gt; int:
 limit = len(b62)
 res = 0
 for i in range(limit):
 res = b * res + base.find(b62[i])
 return res
def toBase62(b10: int) -&gt; str:
 if b &lt;= 0 or b &gt; 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
</code></pre>

<h3>file <code>try_base62.py</code></h3>

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

<h2>output of <code>try_base62.py</code></h2>

<blockquote>
 <code>Base10 ==&gt; Base62</code> 
 <code>0 =&gt; 0</code> 
 <code>[...]</code> 
 <code>998 =&gt; g6</code> 
 <code>Base62 ==&gt; Base10</code> 
 <code>gud =&gt; 63377</code> 
 <code>GA =&gt; 2640</code> 
 <code>mE =&gt; 1404</code> 
 <code>lo =&gt; 1326</code> 
 <code>lz =&gt; 1337</code> 
 <code>OMFGWTFLMFAOENCODING =&gt; 577002768656147353068189971419611424</code>
</blockquote>

Since there was no licensing info in the repo I did submit a <a href="https://github.com/DoctorLai/Algorithms/pull/1" rel="nofollow noreferrer">PR</a> so the original author at least knows other people are using and modifying their code.

entityMap|blocks|key|4e5ge|text|有史以来最简单的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

Simplest ever.

<pre><code>BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
def encode_base62(num):
 s = ""
 while num&gt;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"))
</code></pre>

entityMap|blocks|key|4sub0|text|适用于Python3+(机器:I7-8565U)的基准测试答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

Benchmarking answers that worked for Python3 (machine: i7-8565U):
<pre><code>&quot;&quot;&quot;
us per enc()+dec() # test

(4.477935791015625, 2, '3Tx16Db2JPSS4ZdQ4dp6oW')
(6.073190927505493, 5, '3Tx16Db2JPSS4ZdQ4dp6oW')
(9.051250696182251, 9, '3Tx16Db2JPSS4ZdQ4dp6oW')
(9.864609956741333, 6, '3Tx16Db2JOOqeo6GCGscmW')
(10.868197917938232, 1, '3Tx16Db2JPSS4ZdQ4dp6oW')
(11.018349647521973, 10, '3Tx16Db2JPSS4ZdQ4dp6oW')
(12.448230504989624, 4, '03Tx16Db2JPSS4ZdQ4dp6oW')
(13.016672611236572, 7, '3Tx16Db2JPSS4ZdQ4dp6oW')
(13.212724447250366, 8, '3Tx16Db2JPSS4ZdQ4dp6oW')
(24.119479656219482, 3, '3tX16dB2jpss4zDq4DP6Ow')
&quot;&quot;&quot;

from time import time

half = 2 ** 127
results = []


def bench(n, enc, dec):
 start = time()
 for i in range(half, half + 1_000_000):
 dec(enc(i))
 end = time()
 results.append(tuple([end - start, n, enc(half + 1234134134134314)]))


BASE62 = &quot;0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;


def encode(num, alphabet=BASE62):
 &quot;&quot;&quot;Encode a positive number into Base X and return the string.

 Arguments:
 - `num`: The number to encode
 - `alphabet`: The alphabet to use for encoding
 &quot;&quot;&quot;
 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):
 &quot;&quot;&quot;Decode a Base X encoded string into the number

 Arguments:
 - `string`: The encoded string
 - `alphabet`: The alphabet to use for decoding
 &quot;&quot;&quot;
 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


bench(1, encode, decode)
###########################################################################################################
# Remove the `_@` below for base62, now it has 64 characters
BASE_ALPH = tuple(BASE62)
BASE_LIST = BASE62
BASE_DICT = dict((c, v) for v, c in enumerate(BASE_ALPH))

###########################################################################################################
BASE_LEN = len(BASE_ALPH)


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


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

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


bench(2, encode, decode)

###########################################################################################################
from django.utils import baseconv

bench(3, baseconv.base62.encode, baseconv.base62.decode)


###########################################################################################################
def encode(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()


bench(4, encode, decode)


###########################################################################################################
def encode(num, sym=BASE62, join_symbol=''):
 if num == 0:
 return sym[0]

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


bench(5, encode, decode)

###########################################################################################################
from math import floor

base = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
b = 62;


def decode(b62: str) -&gt; int:
 limit = len(b62)
 res = 0
 for i in range(limit):
 res = b * res + base.find(b62[i])
 return res


def encode(b10: int) -&gt; str:
 if b &lt;= 0 or b &gt; 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


bench(6, encode, decode)


###########################################################################################################
def encode(dec):
 s = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
 return s[dec] if dec &lt; 62 else encode(dec // 62) + s[int(dec % 62)]


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


bench(7, encode, decode)


def encode(dec):
 s = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
 ret = ''
 while dec &gt; 0:
 ret = s[dec % 62] + ret
 dec //= 62
 return ret


def decode(b62):
 s = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
 ret = 0
 for i in range(len(b62) - 1, -1, -1):
 ret = ret + s.index(b62[i]) * (62 ** (len(b62) - i - 1))
 return ret


bench(8, encode, decode)


###########################################################################################################

def encode(num):
 s = &quot;&quot;
 while num &gt; 0:
 num, r = divmod(num, 62)
 s = BASE62[r] + s
 return s


def decode(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


bench(9, encode, decode)


###########################################################################################################

def encode(number: int, alphabet=BASE62, padding: int = 22) -&gt; str:
 l = len(alphabet)
 res = []
 while number &gt; 0:
 number, rem = divmod(number, l)
 res.append(alphabet[rem])
 if number == 0:
 break
 return &quot;&quot;.join(res)[::-1] # .rjust(padding, &quot;0&quot;)


def decode(digits: str, lookup=BASE_DICT) -&gt; int:
 res = 0
 last = len(digits) - 1
 base = len(lookup)
 for i, d in enumerate(digits):
 res += lookup[d] * pow(base, last - i)
 return res


bench(10, encode, decode)

###########################################################################################################

for row in sorted(results):
 print(row)
</code></pre>

How would you convert an integer to base 62 (like hexadecimal, but with these digits: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ').

I have been trying to find a good Python library for it, but they all seems to be occupied with converting strings. The Python base64 module only accepts strings and turns a single digit into four characters. I was looking for something akin to what URL shorteners use.

Base 62 conversion

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

 如何将整数转换为基数62 (如十六进制，但具有以下数字：'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'). 我一直在尝试为它寻找一个好的Python库，但它们似乎都忙于转换字符串。Python base64模块只接受字符串，并将单个数字...

问基数62转换
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问基数62转换EN