Python初学者咨询：如何由输出反推输入及求双射函数逆的方法

Hey there! Great questions—let's unpack them one by one, since they get to some core ideas about functions and reversibility in Python.

1. Are there built-in methods to reverse-engineer inputs from outputs? #

Short answer: It totally depends on the function and what you're working with. Python doesn't have a universal built-in tool that can take any output and spit out the original input, and for good reason: many functions aren't reversible by default.

For example, take a simple squaring function:

def square(x):
    return x ** 2

If you get an output of 4, it could come from 2 or -2—there's no way a generic tool could know which input you meant. That said, some specific tools or libraries do have reverse methods for their own functions:

• base64.b64decode() reverses base64.b64encode() (since encoding/decoding is a bijective process here)
• math.sqrt() acts as the inverse of squaring non-negative numbers (but it's a specific inverse, not a generic solution)
• Hash functions (like those in hashlib) are intentionally one-way—you can't reverse them at all, no matter what.

2. Reconstructing inputs for bijective functions without writing an inverse #

Since bijective functions are both one-to-one (each input maps to exactly one output) and onto (every output maps to exactly one input), reversing them is theoretically possible. Here are practical ways to skip writing a custom inverse function:

Approach 1: Cache input-output pairs as you go #

If you're the one generating outputs by calling the function, you can store every input-output pair in a dictionary as you run the function. Then, when you need to get the original input from an output, just look it up.

Example with a simple character-shifting bijective function:

# Bijective function: shift each letter forward by 1 (z wraps to a)
def shift_string(input_str):
    def shift_char(c):
        return chr(ord(c) + 1) if c != 'z' else 'a'
    result = ''.join([shift_char(c) for c in input_str.lower()])
    
    # Cache the pairs both ways
    forward_cache[input_str] = result
    reverse_cache[result] = input_str
    return result

# Set up empty caches
forward_cache = {}
reverse_cache = {}

# Use the function
my_output = shift_string("hello")
print(my_output)  # "ifmmp"

# Get the original input without writing an inverse
my_input = reverse_cache[my_output]
print(my_input)  # "hello"

This works perfectly if you're generating the outputs yourself, but it won't help if you get an output that wasn't cached during your forward calls.

Approach 2: Brute-force small input spaces #

If the possible inputs are limited (like small integers or short strings), you can precompute all possible input-output pairs by brute-forcing every input, then look up the output you have.

Example with a simple linear function:

def add_seven(x):
    return x + 7  # Bijective for all integers

# Precompute pairs for a small range of inputs
reverse_map = {}
for x in range(-50, 51):
    output = add_seven(x)
    reverse_map[output] = x

# Look up the input from an output
print(reverse_map[12])  # 5

This is only feasible for small input spaces—you can't brute-force all possible 10-character strings, for example. But it's a quick fix for limited cases.

Approach 3: Use symbolic math for mathematical functions #

If your bijective function is a mathematical one (like linear or affine transformations), you can use a library like sympy to compute the inverse symbolically, no manual coding required.

Example:

import sympy as sp

# Define the function symbolically
x = sp.symbols('x')
f = 2*x - 5  # Bijective linear function

# Solve for x to get the inverse
y = sp.symbols('y')
f_inv = sp.solve(sp.Eq(f, y), x)[0]
print(f_inv)  # (y + 5)/2

# Use the inverse to find the original input
output = 9
original_input = f_inv.subs(y, output)
print(original_input)  # 7

This is ideal for math-based functions, as it lets you generate the inverse programmatically instead of writing it from scratch.

A quick reality check #

Even with bijective functions, there's no "magic" built-in in Python to reverse any arbitrary function. The approach you choose depends on the type of function you're working with, but these methods let you avoid writing a custom inverse function from scratch.

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