如何基于指定字符集生成自定义哈希字符串（无需强加密安全性）

Great question! Since you don't need strong cryptographic security, the solution boils down to converting the binary output of a standard hash function into a string using your custom character set—essentially doing a base-N conversion where N is the size of your allowed characters. This is way more flexible than base64, which locks you into its fixed 64-character set.

Let's break it down step by step, with a Python example (the logic translates easily to other languages too):

Step 1: Generate a basic binary hash #

First, start with a standard hash function to get a fixed-size binary digest. Since you don't need strong security, even a fast, older hash like MD5 works perfectly—you could also use SHA-1 or even a simple checksum if you want something lighter. The key is to get the raw binary output, not the hex string.

Step 2: Convert binary to a big integer #

Treat the binary digest as a single large integer. This makes it easy to perform base-N conversion with your custom character set.

Step 3: Custom base-N conversion #

Write a small function to convert that integer into a string using your chosen characters. Each digit in the base-N system maps to a character in your set.

Full Example Code #

import hashlib

def custom_hash(input_str, charset="abcdefghijklmnopqrstuvwxyz0123456789"):
    # Generate a binary hash digest (MD5 used here; swap for any hash you prefer)
    hash_digest = hashlib.md5(input_str.encode()).digest()
    
    # Convert binary digest to a large integer
    hash_int = int.from_bytes(hash_digest, byteorder="big")
    
    base = len(charset)
    # Handle edge case where hash is 0 (avoids empty string)
    if hash_int == 0:
        return charset[0]
    
    result_chars = []
    # Build the string by repeatedly dividing the integer and grabbing remainders
    while hash_int > 0:
        hash_int, remainder = divmod(hash_int, base)
        result_chars.append(charset[remainder])
    
    # Reverse to get the correct order (since we built it from least to most significant digit)
    return ''.join(reversed(result_chars))

# Test it out!
print(custom_hash("Hello World"))  # Outputs a 22-character string using a-z0-9

Key Customization Tips #

• Adjust the character set: Swap the charset parameter for any unique set of characters (e.g., ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 for uppercase, or add symbols if you need them—just make sure no duplicates exist).
• Change the hash function: Replace hashlib.md5 with hashlib.sha1, hashlib.sha256, or even a custom checksum function if you want something simpler.
• Truncate the output: If you don't need the full length, just slice the result (e.g., custom_hash("input")[:10] to get the first 10 characters). Since you don't need cryptographic security, truncation won't cause issues for your use case.
• Handle empty input: The example covers the edge case where the hash integer is 0, but you might want to add extra checks for empty input strings depending on your needs.

Why This Works Better Than Base64 #

Base64 uses a fixed set of 64 characters (A-Za-z0-9+/), which doesn't let you pick exactly the characters you want. This base-N conversion method lets you define any character set you need—perfect for use cases like URL shorteners, custom identifiers, or where you need to avoid specific characters.

内容的提问来源于stack exchange，提问作者Dieter Menne