_creation_counter = 0

    default_error_messages = {

        'required': _('This field is required.'),

        'null': _('This field may not be null.')

    }

    default_validators = []     #默认验证器初始化为空list

    default_empty_html = empty

    initial = None

    # 在构造函数中，给出了各种定义参数，由子类继承，在实例化时传参，来控制这个字段的各种属性

    # read_only，表明只用于序列化输出

    # write_only， 表明只用于反序列化输入，比如密码

    # required， 表明在反序列化时必须输入

    # default， 反序列化时使用的默认值

    # initial

    # source，

    # label， 用于HTML展示API页面时，显示的字段名称

    # help_text， 用于HTML展示API页面时，显示的字段帮助提示信息

    # style

    # error_messages， 包含错误编号与错误信息的字典

    # validators， 该字段使用的验证器

    # allow_null, 表明该字段是否允许传入None，默认False

    def __init__(self, read_only=False, write_only=False,

                 required=None, default=empty, initial=empty, source=None,

                 label=None, help_text=None, style=None,

                 error_messages=None, validators=None, allow_null=False):

        self._creation_counter = Field._creation_counter

        Field._creation_counter += 1

        # If `required` is unset, then use `True` unless a default is provided.

        if required is None:

            required = default is empty and not read_only

        # Some combinations of keyword arguments do not make sense.

        # 断言一些没有意义的参数组合

        assert not (read_only and write_only), NOT_READ_ONLY_WRITE_ONLY

        assert not (read_only and required), NOT_READ_ONLY_REQUIRED

        assert not (required and default is not empty), NOT_REQUIRED_DEFAULT

        assert not (read_only and self.__class__ == Field), USE_READONLYFIELD

        # 将传入的参数赋值给实例（属性初始化）

        self.read_only = read_only

        self.write_only = write_only

        self.required = required

        self.default = default

        self.source = source

        self.initial = self.initial if (initial is empty) else initial

        self.label = label

        self.help_text = help_text

        self.style = {} if style is None else style

        self.allow_null = allow_null

        if self.default_empty_html is not empty:

            if default is not empty:

                self.default_empty_html = default

        if validators is not None:

            self.validators = list(validators)

        # These are set up by `.bind()` when the field is added to a serializer.

        self.field_name = None

        self.parent = None

        # Collect default error message from self and parent classes

        messages = {}

        for cls in reversed(self.__class__.__mro__):

            messages.update(getattr(cls, 'default_error_messages', {}))

        messages.update(error_messages or {})

        self.error_messages = messages

    # .validators is a lazily loaded property, that gets its default

    # value from `get_validators`.

    # validators属性设置

    @property

    def validators(self):

        if not hasattr(self, '_validators'):

            self._validators = self.get_validators()

        return self._validators

    @validators.setter

    def validators(self, validators):

        self._validators = validators

    def get_validators(self):

        return list(self.default_validators)

class IntegerField(Field):

    default_error_messages = {

        'invalid': _('A valid integer is required.'),

        'max_value': _('Ensure this value is less than or equal to {max_value}.'),

        'min_value': _('Ensure this value is greater than or equal to {min_value}.'),

        'max_string_length': _('String value too large.')

    }

    MAX_STRING_LENGTH = 1000  # Guard against malicious string inputs.

    re_decimal = re.compile(r'\.0*\s*$')  # allow e.g. '1.0' as an int, but not '1.2'

    def __init__(self, **kwargs):

        # 从变长传参里找max_value，min_value，给到实例，默认为None

        #继承父类的其他属性（相当于父类属性是通用，这里的属性是子类独有的）

        self.max_value = kwargs.pop('max_value', None)

        self.min_value = kwargs.pop('min_value', None)

        super().__init__(**kwargs)

        # 如果传参max_value，先拼接error message，然后在validators属性里添加一个验证器元素。

        if self.max_value is not None:

            message = lazy_format(self.error_messages['max_value'], max_value=self.max_value)

            self.validators.append(

                MaxValueValidator(self.max_value, message=message))

        if self.min_value is not None:

            message = lazy_format(self.error_messages['min_value'], min_value=self.min_value)

            self.validators.append(

                MinValueValidator(self.min_value, message=message))

    def to_internal_value(self, data):

        if isinstance(data, str) and len(data) > self.MAX_STRING_LENGTH:

            self.fail('max_string_length')

        try:

            data = int(self.re_decimal.sub('', str(data)))

        except (ValueError, TypeError):

            self.fail('invalid')

        return data

    def to_representation(self, value):

        return int(value)

class CharField(Field):

    default_error_messages = {

        'invalid': _('Not a valid string.'),

        'blank': _('This field may not be blank.'),

        'max_length': _('Ensure this field has no more than {max_length} characters.'),

        'min_length': _('Ensure this field has at least {min_length} characters.'),

    }

    initial = ''

    def __init__(self, **kwargs):

        self.allow_blank = kwargs.pop('allow_blank', False)

        self.trim_whitespace = kwargs.pop('trim_whitespace', True)

        self.max_length = kwargs.pop('max_length', None)

        self.min_length = kwargs.pop('min_length', None)

        super().__init__(**kwargs)

        if self.max_length is not None:

            message = lazy_format(self.error_messages['max_length'], max_length=self.max_length)

            self.validators.append(

                MaxLengthValidator(self.max_length, message=message))

        if self.min_length is not None:

            message = lazy_format(self.error_messages['min_length'], min_length=self.min_length)

            self.validators.append(

                MinLengthValidator(self.min_length, message=message))

        # ProhibitNullCharactersValidator is None on Django < 2.0

        if ProhibitNullCharactersValidator is not None:

            self.validators.append(ProhibitNullCharactersValidator())

    def run_validation(self, data=empty):

        # Test for the empty string here so that it does not get validated,

        # and so that subclasses do not need to handle it explicitly

        # inside the `to_internal_value()` method.

        if data == '' or (self.trim_whitespace and str(data).strip() == ''):

            if not self.allow_blank:

                self.fail('blank')

            return ''

        return super().run_validation(data)

    # 将int，float转为为str

    def to_internal_value(self, data):

        # We're lenient with allowing basic numerics to be coerced into strings,

        # but other types should fail. Eg. unclear if booleans should represent as `true` or `True`,

        # and composites such as lists are likely user error.

        if isinstance(data, bool) or not isinstance(data, (str, int, float,)):

            self.fail('invalid')

        value = str(data)

        return value.strip() if self.trim_whitespace else value

    def to_representation(self, value):

        return str(value)