基于Django开发Python应用：创建输入框并实现历史购买记录查询及纠错

Got it, let's tackle that name spelling error problem you're dealing with—this is such a common pain point with user input, but there are several practical ways to smooth this out in your setup. Here are my go-to solutions:

1. Fuzzy Matching with Similarity Algorithms #

Instead of relying on exact name matches, use string similarity scores to find close matches. Two great tools for this are:

Option A: Python's fuzzywuzzy Library #

This library calculates how similar two strings are (using Levenshtein distance under the hood). It's easy to integrate with your Django models:

First install it:

pip install fuzzywuzzy python-Levenshtein

Then use it in your view to find matching names:

from fuzzywuzzy import fuzz
from myapp.models import PurchaseRecord

def get_purchase_history(request):
    input_name = request.POST.get('name', '').strip()
    input_address = request.POST.get('address', '').strip()

    # Get all unique customer names from your DB
    all_customer_names = PurchaseRecord.objects.values_list('customer_name', flat=True).distinct()
    
    # Filter names with a similarity score above 80 (adjust this threshold as needed)
    matching_names = []
    for name in all_customer_names:
        if fuzz.partial_ratio(input_name.lower(), name.lower()) >= 80:
            matching_names.append(name)
    
    # Fetch records for matching names + address (add address filter if needed)
    records = PurchaseRecord.objects.filter(
        customer_name__in=matching_names,
        customer_address__icontains=input_address
    )
    
    # Pass records to your template
    return render(request, 'purchase_history.html', {'records': records})

Option B: MariaDB Built-in Functions #

If you want to offload some work to the database, use MariaDB's SOUNDEX or LIKE with wildcards. SOUNDEX converts strings to phonetic codes, so similar-sounding names match:

-- Example query (you can run this via Django's raw SQL or ORM)
SELECT * FROM purchase_records 
WHERE SOUNDEX(customer_name) = SOUNDEX(%s)
AND customer_address LIKE %s;

In Django's ORM, you can use annotate and Func to leverage SOUNDEX:

from django.db.models import Func, Value, F
from myapp.models import PurchaseRecord

def get_matching_records(input_name, input_address):
    records = PurchaseRecord.objects.annotate(
        input_soundex=Func(Value(input_name), function='SOUNDEX'),
        name_soundex=Func('customer_name', function='SOUNDEX')
    ).filter(
        name_soundex=F('input_soundex'),
        customer_address__icontains=input_address
    )
    return records

2. Add Real-Time Name Autocomplete #

Give users suggestions as they type to prevent misspellings in the first place. Here's a quick way to implement this:

Backend (Django View) #

Create an endpoint that returns name suggestions based on partial input:

from django.http import JsonResponse
from myapp.models import PurchaseRecord

def name_suggestions(request):
    query = request.GET.get('q', '').lower()
    if not query:
        return JsonResponse({'suggestions': []})
    
    # Get top 5 matching names (adjust limit as needed)
    suggestions = PurchaseRecord.objects.filter(
        customer_name__icontains=query
    ).values_list('customer_name', flat=True).distinct()[:5]
    
    return JsonResponse({'suggestions': list(suggestions)})

Frontend (JavaScript) #

Add a listener to your name input field to fetch suggestions and display them:

<!-- In your template -->
<input type="text" id="name-input" name="name" placeholder="Enter your name">
<div id="name-suggestions"></div>

<script>
const nameInput = document.getElementById('name-input');
const suggestionsDiv = document.getElementById('name-suggestions');

nameInput.addEventListener('input', async () => {
    const query = nameInput.value.trim();
    if (!query) {
        suggestionsDiv.innerHTML = '';
        return;
    }
    
    const response = await fetch(`/name-suggestions/?q=${encodeURIComponent(query)}`);
    const data = await response.json();
    
    // Render suggestions
    suggestionsDiv.innerHTML = data.suggestions.map(name => 
        `<div class="suggestion-item" onclick="selectName('${name}')">${name}</div>`
    ).join('');
});

function selectName(name) {
    nameInput.value = name;
    suggestionsDiv.innerHTML = '';
}
</script>

3. Add a "Did You Mean?" Prompt #

If no exact matches are found, show users the closest similar name and ask if they meant that. For example:

def get_purchase_history(request):
    input_name = request.POST.get('name', '').strip()
    input_address = request.POST.get('address', '').strip()
    
    # First try exact match
    exact_records = PurchaseRecord.objects.filter(
        customer_name__iexact=input_name,
        customer_address__icontains=input_address
    )
    
    if exact_records.exists():
        return render(request, 'purchase_history.html', {'records': exact_records})
    
    # If no exact match, find closest name
    all_names = PurchaseRecord.objects.values_list('customer_name', flat=True).distinct()
    closest_match = None
    highest_score = 0
    
    for name in all_names:
        score = fuzz.ratio(input_name.lower(), name.lower())
        if score > highest_score and score >= 70:
            highest_score = score
            closest_match = name
    
    if closest_match:
        # Pass the suggestion to the template
        return render(request, 'purchase_history.html', {
            'suggested_name': closest_match,
            'input_name': input_name,
            'input_address': input_address
        })
    
    # No matches found at all
    return render(request, 'purchase_history.html', {'no_results': True})

Then in your template:

{% if suggested_name %}
    <p>Did you mean <strong>{{ suggested_name }}</strong>? <a href="?name={{ suggested_name }}&address={{ input_address }}">Click here to view records</a></p>
{% elif no_results %}
    <p>No purchase records found for your input.</p>
{% endif %}

Key Notes to Keep in Mind #

• Performance: If you have a large dataset, caching unique customer names or using MariaDB's full-text indexes can speed up similarity checks.
• Threshold Tuning: Adjust the similarity score thresholds (like 80 in fuzzywuzzy) based on your user base—test with common misspellings your users might make.
• Address Matching: Don't forget to apply similar logic to addresses if users often misspell those too!

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