Thousand Separators in Django Admin for DecimalField

You've observed correct behavior. The Django Admin intentionally displays raw, unformatted values in form fields because they are meant for editing. The USE_THOUSAND_SEPARATOR setting primarily affects how numbers are displayed in read-only contexts (like your custom view), but not in form inputs where users need to edit the raw data.

Why This Happens

The Django Admin uses HTML <input> elements for editing, and browsers expect numeric inputs without formatting characters like commas. This is why:

1. Your custom view shows formatted numbers (with commas) because it's displaying the value in a read-only context
2. The Admin shows unformatted numbers because it's presenting an editable field

Possible Solutions

1. Custom Admin Form Field Rendering

You can create a custom widget or form field that displays the formatted value but handles the conversion back to a raw number on submission:

PYTHONCopied
from django import forms
from django.contrib import admin
from .models import City

class FormattedDecimalField(forms.DecimalField):
    def widget_attrs(self, widget):
        attrs = super().widget_attrs(widget)
        attrs['class'] = 'formatted-decimal'
        return attrs

class CityAdminForm(forms.ModelForm):
    inhabitants = FormattedDecimalField(
        max_digits=19,
        decimal_places=2,
        required=False
    )
    
    class Meta:
        model = City
        fields = '__all__'

class CityAdmin(admin.ModelAdmin):
    form = CityAdminForm
    
    class Media:
        js = ('js/formatted_decimal.js',)

admin.site.register(City, CityAdmin)

Then create a JavaScript file (formatted_decimal.js) to handle the formatting:

JAVASCRIPTCopied
document.addEventListener('DOMContentLoaded', function() {
    // Format the decimal fields on page load
    const fields = document.querySelectorAll('.formatted-decimal');
    
    fields.forEach(function(field) {
        // Store the original value for form submission
        const originalValue = field.value;
        field.dataset.originalValue = originalValue;
        
        // Display formatted value
        if (originalValue) {
            field.value = parseFloat(originalValue).toLocaleString();
        }
        
        // Convert back to raw value on form submission
        field.form.addEventListener('submit', function() {
            field.value = field.dataset.originalValue;
        });
        
        // Update original value when field changes
        field.addEventListener('change', function() {
            // Remove any commas before storing
            field.dataset.originalValue = field.value.replace(/,/g, '');
            // Re-format the display value
            field.value = parseFloat(field.dataset.originalValue).toLocaleString();
        });
    });
});

2. Use a Read-Only Field in Admin List View

If you only need the formatting in the list view (not the edit form), you can add a custom method to your model and use it in the admin:

PYTHONCopied
class City(models.Model):
    # Your existing model code...
    
    def formatted_inhabitants(self):
        if self.inhabitants is None:
            return None
        return f"{self.inhabitants:,}"
    formatted_inhabitants.short_description = "Inhabitants"

class CityAdmin(admin.ModelAdmin):
    list_display = ('name', 'country', 'formatted_inhabitants')
    # Keep the original field for editing
    fields = ('name', 'country', 'inhabitants')

3. Custom Admin Template

You could also override the admin template for this specific model to handle the formatting and parsing.

Conclusion

The Django Admin's behavior is intentional for form fields, as it needs to work with raw data for proper validation and saving. The most practical approach is to either:

1. Use a custom read-only field for display purposes in list views
2. Implement a JavaScript solution that handles the formatting and parsing correctly

The JavaScript approach is more complex but provides the best user experience if you need formatted numbers in edit forms.