In the Django framework, custom model field validation can be implemented in the following ways:

• Using the clean() method:
  Define a clean() method in the model to validate the model’s fields. This method is automatically called when invoking the full_clean() method and is commonly used in form validation.

  1 2 3 4 5 6 7 8

  from django.core.exceptions import ValidationError class MyModel(models.Model): my_field = models.CharField(max_length=100) def clean(self): if 'bad_value' in self.my_field: raise ValidationError('my_field cannot contain "bad_value"')

• Using the clean_<fieldname>() method:
  For validating specific fields, you can define a method prefixed with clean_ followed by the field name.

  1 2 3 4 5 6

  class MyModel(models.Model): my_field = models.CharField(max_length=100) def clean_my_field(self): if 'bad_value' in self.my_field: raise ValidationError('my_field cannot contain "bad_value"')

• Using the validators parameter:
  When defining a field, you can add custom validators through the validators parameter.

  1 2 3 4 5 6 7 8

  from django.core.validators import RegexValidator def my_custom_validator(value): if 'bad_value' in value: raise ValidationError('Value cannot contain "bad_value"') class MyModel(models.Model): my_field = models.CharField(max_length=100, validators=[my_custom_validator])

• Using the override method:
  If you need to perform validation when saving the model, you can override the save() method.

  1 2 3 4 5 6 7

  class MyModel(models.Model): my_field = models.CharField(max_length=100) def save(self, *args, **kwargs): if 'bad_value' in self.my_field: raise ValidationError('my_field cannot contain "bad_value"') super().save(*args, **kwargs)

• Using signals:
  Use Django signals, such as pre_save or post_save, to perform validation before or after saving the model.

  1 2 3 4 5 6 7

  from django.db.models.signals import pre_save from django.dispatch import receiver @receiver(pre_save, sender=MyModel) def my_model_pre_save(sender, instance, **kwargs): if 'bad_value' in instance.my_field: raise ValidationError('my_field cannot contain "bad_value"')

These are several common methods for custom field validation in Django models. Choose the appropriate method based on your specific requirements.

In Django, model data validation can be performed through several methods:

• Field Options: Django model fields provide numerous options for validating input data types and formats. For example, CharField has a max_length option to ensure strings don’t exceed specified lengths, while EmailField automatically validates email address formats.

• Clean Methods: You can define a clean method in your model for custom validation. This method is called before the model instance is saved (save). Within the clean method, you can implement custom validation logic and raise ValidationError when validation fails.

• Form Validation: Django’s form system (forms) offers another validation approach. Using ModelForm, you can automatically generate a form class that binds model fields and validation logic together. You can also add additional validation methods in the form class, such as clean_fieldname methods, to validate specific field data.

• Model Signals: Django provides signals like pre_save and post_save, where you can implement validation logic in their processors.

• Custom Validators: Django 1.9 and above supports custom validators. These can be attached to model fields or used as model-level validators.

• Overriding Save Method: By overriding the model’s save method, you can perform additional validation before data is saved.

• Using full_clean Method: Django model instances have a full_clean method that calls all field cleaning methods and the model’s clean method, enabling manual triggering of the complete validation process.

Through these mechanisms, Django provides a robust framework for ensuring data integrity and accuracy in your applications.