В чем разница между null = True и blank = True в Django?

Вот его ответ простыми словами: -

С помощью null = True мы сообщаем базе данных , что это поле модели может быть NULL, с помощью blank = True мы сообщаем Django , что может быть этим полем модели. ПУСТО

null = True || blank = True || null = True && blank = True

class TestModel(models.Model):
    field1 = models.CharField(max_length=100, null=True)
    field2 = models.CharField(max_length=100, blank=True)   # it's not a correct way
    field3 = models.CharField(max_length=100, null=True, blank=True)

ПОЛЯ БД ДЛЯ: MySQL

CREATE TABLE TestModel (
     `id`        INT(10)        NOT     NULL      AUTO_INCREMENT,

     `field1`    VARCHAR(100)   NULL    DEFAULT   NULL,
     `field2`    VARCHAR(100)   NOT     NULL,
     `field3`    VARCHAR(100)   NULL    DEFAULT   NULL,
)

дело-01: null = True

db:   db   field is accepts null value
form: form field is `required`

NB: DB IS ACCEPTS NULL VALUE, BUT FORM FIELD IS REQUIRED. SO FORM IS 
SUBMITTED WHEN THIS FIELD HAVE SOME VALUE. it's good.

case-02: blank = True

db:   db   field is not accepts null value
form: form field is `optional`

NB: FORM IS VALID WITHOUT ANY VALUE, BUT DB IS NOT ACCEPTS NULL VALUE.
SO THE FORM IS SUBMITTED WITHOUT ANY VALUE THEN BOOM. it's worst.

дело-03: null = True && blank = True

db:   db   field is accepts null value
form: form field is `optional`

NB: HERE FORM FIELD IS OPTIONAL & FORM IS VALID WITHOUT ANY VALUE 
& DB ALSO ACCEPTS NULL VALUE. SO, IT'S BEST TO USE `null=True && blank=True`

:)

blank=True можно задать для любого поля модели, чтобы указать, можно ли оставить это поле пустым при вводе значения в форму. Здесь мы говорим о вводе данных.

null=True, если мы устанавливаем blank=True для поля, это поле модели не получает никакого значения, тогда база данных или Django должны что-то делать с этим полем, когда данные записываются в базу данных. Для любого типа текстового содержимого в базе данных хранится пустая строка, поэтому в базе данных хранится значение. Для других типов полей, таких как поля даты или числа, мы используем специальный тип данных «null». «null» можно использовать, если поле потенциально не имеет значения, но по умолчанию Django не допускает «нулевых» значений. Вот почему вам нужно явно указать null=True.

Допустим, вы установили blank=True для любых нетекстовых полей, но не указали «null = True», Django не будет знать, что хранить, и выдаст ошибку.

Blank=False # this field is required.
Null=False # this field should not be null

Blank=True # this field is optional.
Null=True # Django uses empty string (''), not NULL.

Примечание: Избегайте использования null=True в строковых полях, таких как CharField и TextField и FileField / ImageField.

Ссылка: Django null, Django blank

Нулевое значение связано исключительно с базой данных, а пустое значение связано с проверкой. Если в поле указано blank = True, проверка на сайте администратора Django позволит ввести пустое значение. Если в поле пусто = False, поле будет обязательным

Простой ответ: Null - для таблиц базы данных, а Blank - для Django Forms.

Когда вы устанавливаете null=true, он устанавливает null в вашей базе данных, если поле не заполнено. Если вы установили blank=true, оно не установит никакого значения в поле.

Значение null = True и blank = True в модели также зависит от того, как эти поля были определены в классе формы.

Предположим, вы определили следующий класс:

class Client (models.Model):
    name = models.CharField (max_length=100, blank=True)
    address = models.CharField (max_length=100, blank=False)

Если класс формы был определен следующим образом:

class ClientForm (ModelForm):
    class Meta:
        model = Client
        fields = ['name', 'address']
        widgets = {
            'name': forms.TextInput (attrs = {'class': 'form-control form-control-sm'}),
            'address': forms.TextInput (attrs = {'class': 'form-control form-control-sm'})
        }

Тогда поле 'name' не будет обязательным (из-за пустого = True в модели), а поле 'address' будет обязательным (из-за пустого = False в модели).

Однако, если класс ClientForm был определен следующим образом:

class ClientForm (ModelForm):
    class Meta:
        model = Client
        fields = ['name', 'address']

    name = forms.CharField (
        widget = forms.TextInput (attrs = {'class': 'form-control form-control-sm'}),
    )
    address = forms.CharField (
        widget = forms.TextInput (attrs = {'class': 'form-control form-control-sm'}),
    )

Тогда оба поля ('name' и 'address') будут обязательными, ", поскольку поля, определенные декларативно, остаются как есть" (https://docs.djangoproject.com /en/3.0/topics/forms/modelforms/), т.е. по умолчанию для атрибута 'required' поля формы установлено значение True, и для этого потребуется заполнить поля 'name' и 'address', даже если , в модели это поле пустое = True.

Очень простыми словами ,

Пробел отличается от нуля.

null - это чисто относящееся к базе данных , тогда как пустое значение связано с проверкой (требуется в форме) .

Если null=True, Django выполнит store empty values as NULL in the database. Если в поле указано blank=True, проверка формы будет allow entry of an empty value. Если в поле указано пустое значение = False, поле будет обязательным.

В приведенной ниже таблице показаны основные различия:

+--------------------------------------------------------------------+
| Purpose                  | null=True        | blank = True         |
|--------------------------|------------------|----------------------|
| Field can be empty in DB | Do this          | Unaffected           |
|--------------------------|------------------|----------------------|
| ModelForm(required field)| Unaffected       | field not required   |
|--------------------------|------------------|----------------------|
| Form Validation          | Unaffected       | field not required   |
|--------------------------|------------------|----------------------|
| on_delete=SET_NULL       | Need this        | Unaffected           |
+--------------------------------------------------------------------+

null - по умолчанию False если True, Django сохранит пустое значение в базе данных как null.

пусто - по умолчанию False если true, это поле может быть пустым

еще, перейти https://docs.djangoproject.com/en/3.0/topics/db/models/

null для базы данных, а пустой для проверки полей, которые вы хотите отобразить в пользовательском интерфейсе, например текстовое поле, чтобы получить фамилию человека. Если lastname = models.charfield (blank = true) он не просил пользователя вводить фамилию, поскольку теперь это необязательное поле. Если lastname = models.charfield (null = true) , то это означает, что если это поле не получает никакого значения от пользователя, оно будет сохранено в базе данных как пустая строка "".

Значения по умолчанию для пустых и пустых полей - False.

Null: это связано с базой данных. Определяет, будет ли данный столбец базы данных принимать нулевые значения или нет.

Пусто: это связано с проверкой. Он будет использоваться во время проверки форм при вызове form.is_valid ().

При этом совершенно нормально иметь поле с null = True и blank = False. Это означает, что на уровне базы данных поле может иметь значение NULL, но на уровне приложения это обязательное поле.

Теперь, когда большинство разработчиков ошибаются: определение null = True для строковых полей, таких как CharField и TextField. Избегайте этого. В противном случае у вас будет два возможных значения для «нет данных», а именно: Нет и пустая строка. Наличие двух возможных значений «нет данных» является избыточным. Соглашение Django заключается в использовании пустой строки, а не NULL.

У вас может быть свой ответ, однако до сих пор трудно судить, ставить ли в поле null = True или blank = True или и то, и другое. Я лично считаю, что предоставлять разработчикам так много возможностей бесполезно и сбивать с толку. Пусть обрабатывают нули или пробелы, как хотят.

Я следую за этой таблицей, от Две ложки Django : <22444525646755>

Если вы установите null=True, это позволит установить значение столбца вашей базы данных как NULL. Если вы установите только blank=True, django установит новое значение по умолчанию для столбца, равное "".

Есть одна точка, где null=True будет необходимо даже для CharField или TextField, и это когда в базе данных установлен флаг unique ​​ для столбца. В этом случае вам нужно будет использовать это:

a_unique_string = models.CharField(blank=True, null=True, unique=True)

Предпочтительно пропускать null=True для неуникального CharField или TextField. В противном случае некоторые поля будут установлены как NULL, а другие как "", и вам придется каждый раз проверять значение поля для NULL.

Вот основное различие между null=True и blank=True:

Значение по умолчанию для null и blank равно False. Оба эти значения работают на уровне поля, т.е. хотим ли мы сохранить поле null или blank.

null=True установит значение поля на NULL, т.е. без данных. Это в основном для значения столбца базы данных.

date = models.DateTimeField(null=True)

blank=True определяет, будет ли это поле обязательным в формах. Сюда входят администратор и ваши собственные формы.

title = models.CharField(blank=True) // title can be kept blank. В базе данных будет храниться (""). null=True blank=True Это означает, что поле является необязательным при любых обстоятельствах.

epic = models.ForeignKey(null=True, blank=True)
// The exception is CharFields() and TextFields(), which in Django are never saved as NULL. Blank values a

null = True

Означает, что нет ограничений базы данных для поля, которое нужно заполнить, поэтому у вас может быть объект с нулевым значением для заполненного, который имеет этот параметр.

blank = True

Означает, что в формах django нет ограничений на проверку. поэтому, когда вы заполняете modelForm для этой модели, вы можете оставить поле с этой опцией незаполненным.

Важно понимать, что параметры в определении поля модели Django служат (как минимум) двум целям: определение таблиц базы данных, определение формата по умолчанию и проверка форм модели. (Я говорю «по умолчанию», потому что значения всегда можно переопределить, предоставив настраиваемую форму.) Некоторые параметры влияют на базу данных, некоторые параметры влияют на формы, а некоторые влияют на обе.

Когда дело доходит до null и blank, другие ответы уже ясно дали понять, что первое влияет на определение таблицы базы данных, а второе влияет на проверку модели. Я думаю, что различие можно сделать еще яснее, рассмотрев варианты использования для всех четырех возможных конфигураций:

• null=False, blank=False: это конфигурация по умолчанию и означает, что значение требуется при любых обстоятельствах.

• null=True, blank=True: это означает, что поле является необязательным при любых обстоятельствах. (Однако, как указано ниже, это , а не рекомендуемый способ сделать строковые поля необязательными.)

• null=False, blank=True: это означает, что форма не требует значения, а база данных требует. Для этого есть несколько вариантов использования:

  • Чаще всего используется для необязательных строковых полей. Как отмечалось в документации, идиома Django заключается в использовании пустой строки для указания отсутствующего значения. Если бы также было разрешено NULL, вы бы получили два разных способа указать отсутствующее значение.

  • Другая распространенная ситуация состоит в том, что вы хотите автоматически вычислить одно поле на основе значения другого (например, в вашем методе save()). Вы не хотите, чтобы пользователь предоставлял значение в форме (отсюда blank=True), но вы хотите, чтобы база данных обеспечивала постоянное предоставление значения (null=False).

  • Другое использование - когда вы хотите указать, что ManyToManyField является необязательным. Поскольку это поле реализовано как отдельная таблица, а не как столбец базы данных, значение null не имеет смысла. Однако значение blank будет по-прежнему влиять на формы, контролируя, будет ли проверка успешной при отсутствии отношений.

• null=True, blank=False: это означает, что для формы требуется значение, а для базы данных - нет. Это может быть наиболее редко используемая конфигурация, но для нее есть несколько вариантов использования:

  • Совершенно разумно потребовать от пользователей всегда включать значение, даже если оно на самом деле не требуется вашей бизнес-логикой. В конце концов, формы - это только один из способов добавления и редактирования данных. У вас может быть код, генерирующий данные, который не требует такой же строгой проверки, которая требуется от редактора-человека.

  • Другой вариант использования, который я видел, - это когда у вас есть ForeignKey, для которого вы не хотите разрешать каскадное удаление. То есть при нормальном использовании отношение всегда должно быть (blank=False), но если объект, на который он указывает, оказывается удаленным, вы не хотите, чтобы этот объект также удалялся. В этом случае вы можете использовать null=True и on_delete=models.SET_NULL для реализации простого вида мягкого удаления.

Когда мы сохраняем что-либо в админке Django, происходит двухэтапная проверка: на уровне Django и на уровне базы данных. Мы не можем сохранить текст в числовом поле.

База данных имеет тип данных NULL, это ничего. Когда Django создает столбцы в базе данных, он указывает, что они не могут быть пустыми. И если вы попытаетесь сохранить NULL, вы получите ошибку базы данных.

Также на уровне Django-Admin все поля обязательны по умолчанию, вы не можете сохранить пустое поле, Django выдаст ошибку.

Итак, если вы хотите сохранить пустое поле, вам нужно разрешить его на уровне Django и базы данных. blank = True - разрешит пустое поле в админке null = True - позволит сохранить NULL в столбце базы данных.

Вот пример поля с blank= True и null=True

description = models.TextField(blank=True, null= True)

В этом случае: blank = True: сообщает нашей форме, что можно оставить поле описания пустым

и

null = True: сообщает нашей базе данных, что можно записывать нулевое значение в поле базы данных и не выдавать ошибку.

Просто null=True определяет, что база данных должна принимать значения NULL, с другой стороны, blank=True определяет при проверке формы, что это поле должно принимать пустые значения или нет (если blank=True он принимает форму без значения в этом поле и blank=False [значение по умолчанию] при проверке формы будет отображаться Это обязательное поле ошибка.

null=True/False относится к базе данных

blank=True/False связано с проверкой формы

Как сказано в ссылке на поле модели Django: Ссылка

Параметры поля

Следующие аргументы доступны для всех типов полей. Все это необязательно.

null

Field.null

Если True, Django сохранит в базе данных пустые значения как NULL. По умолчанию False.

Избегайте использования null в строковых полях, таких как CharField и TextField, поскольку пустые строковые значения всегда будут храниться как пустые строки, а не NULL. Если строковое поле имеет null=True, это означает, что у него есть два возможных значения для "нет данных": NULL и пустое нить. В большинстве случаев два возможных значения для "нет данных"; соглашение Django заключается в использовании пустой строки, а не NULL.

Как для строковых, так и для нестроковых полей вам также понадобится установить blank=True, если вы хотите разрешить пустые значения в формах, как параметр null влияет только на хранилище базы данных (см. blank).

Примечание

При использовании серверной части базы данных Oracle значение NULL будет сохранено для обозначения пустой строки независимо от этого атрибута

blank

Field.blank

Если True, поле может быть пустым. По умолчанию: False.

Обратите внимание, что это отличается от null. null чисто связано с базой данных, тогда как blank связано с проверкой. Если поле имеет blank=True, проверка формы позволит ввести пустое значение. Если в поле указано blank=False, поле будет обязательным.

Вот как ORM сопоставляет поля blank и null для Django 1.8

class Test(models.Model):
    charNull        = models.CharField(max_length=10, null=True)
    charBlank       = models.CharField(max_length=10, blank=True)
    charNullBlank   = models.CharField(max_length=10, null=True, blank=True)

    intNull         = models.IntegerField(null=True)
    intBlank        = models.IntegerField(blank=True)
    intNullBlank    = models.IntegerField(null=True, blank=True)

    dateNull        = models.DateTimeField(null=True)
    dateBlank       = models.DateTimeField(blank=True)
    dateNullBlank   = models.DateTimeField(null=True, blank=True)        

Поля базы данных, созданные для PostgreSQL 9.4 :

CREATE TABLE Test (
  id              serial                    NOT NULL,

  "charNull"      character varying(10),
  "charBlank"     character varying(10)     NOT NULL,
  "charNullBlank" character varying(10),

  "intNull"       integer,
  "intBlank"      integer                   NOT NULL,
  "intNullBlank"  integer,

  "dateNull"      timestamp with time zone,
  "dateBlank"     timestamp with time zone  NOT NULL,
  "dateNullBlank" timestamp with time zone,
  CONSTRAINT Test_pkey PRIMARY KEY (id)
)

Поля базы данных, созданные для MySQL 5.6 :

CREATE TABLE Test (
     `id`            INT(11)     NOT  NULL    AUTO_INCREMENT,

     `charNull`      VARCHAR(10) NULL DEFAULT NULL,
     `charBlank`     VARCHAR(10) NOT  NULL,
     `charNullBlank` VARCHAR(10) NULL DEFAULT NULL,

     `intNull`       INT(11)     NULL DEFAULT NULL,
     `intBlank`      INT(11)     NOT  NULL,
     `intNullBlank`  INT(11)     NULL DEFAULT NULL,

     `dateNull`      DATETIME    NULL DEFAULT NULL,
     `dateBlank`     DATETIME    NOT  NULL,
     `dateNullBlank` DATETIME    NULL DEFAULT NULL
)