Python的数据模型,Python数据模型

作者:计算机知识
基本结构
AutoField(Field)
        - int自增列,必须填入参数 primary_key=True

    BigAutoField(AutoField)
        - bigint自增列,必须填入参数 primary_key=True

        注:当model中如果没有自增列,则自动会创建一个列名为id的列
        from django.db import models

        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)

        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)

    SmallIntegerField(IntegerField):
        - 小整数 -32768 ~ 32767

    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整数 0 ~ 32767
    IntegerField(Field)
        - 整数列(有符号的) -2147483648 ~ 2147483647

    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整数 0 ~ 2147483647

    BigIntegerField(IntegerField):
        - 长整型(有符号的) -9223372036854775808 ~ 9223372036854775807

    自定义无符号整数字段

        class UnsignedIntegerField(models.IntegerField):
            def db_type(self, connection):
                return 'integer UNSIGNED'

        PS: 返回值为字段在数据库中的属性,Django字段默认的值为:
            'AutoField': 'integer AUTO_INCREMENT',
            'BigAutoField': 'bigint AUTO_INCREMENT',
            'BinaryField': 'longblob',
            'BooleanField': 'bool',
            'CharField': 'varchar(%(max_length)s)',
            'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
            'DateField': 'date',
            'DateTimeField': 'datetime',
            'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
            'DurationField': 'bigint',
            'FileField': 'varchar(%(max_length)s)',
            'FilePathField': 'varchar(%(max_length)s)',
            'FloatField': 'double precision',
            'IntegerField': 'integer',
            'BigIntegerField': 'bigint',
            'IPAddressField': 'char(15)',
            'GenericIPAddressField': 'char(39)',
            'NullBooleanField': 'bool',
            'OneToOneField': 'integer',
            'PositiveIntegerField': 'integer UNSIGNED',
            'PositiveSmallIntegerField': 'smallint UNSIGNED',
            'SlugField': 'varchar(%(max_length)s)',
            'SmallIntegerField': 'smallint',
            'TextField': 'longtext',
            'TimeField': 'time',
            'UUIDField': 'char(32)',

    BooleanField(Field)
        - 布尔值类型

    NullBooleanField(Field):
        - 可以为空的布尔值

    CharField(Field)
        - 字符类型
        - 必须提供max_length参数, max_length表示字符长度

    TextField(Field)
        - 文本类型

    EmailField(CharField):
        - 字符串类型,Django Admin以及ModelForm中提供验证机制

    IPAddressField(Field)
        - 字符串类型,Django Admin以及ModelForm中提供验证 IPV4 机制

    GenericIPAddressField(Field)
        - 字符串类型,Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数:
            protocol,用于指定Ipv4或Ipv6, 'both',"ipv4","ipv6"
            unpack_ipv4, 如果指定为True,则输入::ffff:192.0.2.1时候,可解析为192.0.2.1,开启刺功能,需要protocol="both"

    URLField(CharField)
        - 字符串类型,Django Admin以及ModelForm中提供验证 URL

    SlugField(CharField)
        - 字符串类型,Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符(减号)

    CommaSeparatedIntegerField(CharField)
        - 字符串类型,格式必须为逗号分割的数字

    UUIDField(Field)
        - 字符串类型,Django Admin以及ModelForm中提供对UUID格式的验证

    FilePathField(Field)
        - 字符串,Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数:
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹

    FileField(Field)
        - 字符串,路径保存在数据库,文件上传到指定目录
        - 参数:
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件,默认django.core.files.storage.FileSystemStorage

    ImageField(FileField)
        - 字符串,路径保存在数据库,文件上传到指定目录
        - 参数:
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件,默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名(字符串)
            height_field=None   上传图片的宽度保存的数据库字段名(字符串)

    DateTimeField(DateField)
        - 日期 时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]

    DurationField(Field)
        - 长整数,时间间隔,数据库中按照bigint存储,ORM中获取的值为datetime.timedelta类型

    FloatField(Field)
        - 浮点型

    DecimalField(Field)
        - 10进制小数
        - 参数:
            max_digits,小数总长度
            decimal_places,小数位长度

    BinaryField(Field)
        - 二进制类型


字段

  null                数据库中字段是否可以为空
    db_column           数据库中字段的列名
    db_tablespace
    default             数据库中字段的默认值
    primary_key         数据库中字段是否为主键
    db_index            数据库中字段是否可以建立索引
    unique              数据库中字段是否可以建立唯一索引
    unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
    unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
    unique_for_year     数据库中字段【年】部分是否可以建立唯一索引

    verbose_name        Admin中显示的字段名称
    blank               Admin中是否允许用户输入为空
    editable            Admin中是否可以编辑
    help_text           Admin中该字段的提示信息
    choices             Admin中显示选择框的内容,用不变动的数据放在内存中从而避免跨表操作
                        如:gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)

    error_messages      自定义错误信息(字典类型),从而定制想要显示的错误信息;
                        字典健:null, blank, invalid, invalid_choice, unique, and unique_for_date
                        如:{'null': "不能为空.", 'invalid': '格式错误'}

    validators          自定义错误验证(列表类型),从而定制想要的验证规则
                        from django.core.validators import RegexValidator
                        from django.core.validators import EmailValidator,URLValidator,DecimalValidator,
                        MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
                        如:
                            test = models.CharField(
                                max_length=32,
                                error_messages={
                                    'c1': '优先错信息1',
                                    'c2': '优先错信息2',
                                    'c3': '优先错信息3',
                                },
                                validators=[
                                    RegexValidator(regex='root_d ', message='错误了', code='c1'),
                                    RegexValidator(regex='root_112233d ', message='又错误了', code='c2'),
                                    EmailValidator(message='又错误了', code='c3'), ]
                            )

 Meta参数

一.一 1摞Python风格的叶子

那壹节介绍了__len____getitem__那八个法力方法

import collections
from random import choice

Card = collections.namedtuple('Card', ['rank', 'suit'])

class FrenchDeck:
    ranks = [str(n) for n in range(2, 11)]   list('JQKA')
    suits = 'spades diamonds clubs hearts'.split()

    def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suits for rank in self.ranks] 

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, position):
        return self._cards[position]

此间先利用了collections.namedtuple构建了多个简约的卡德类来代表一张卡片。

beer_card = Card('7', 'diamonds')
print(beer_card)
#outputs: 
Card(rank='7', suit='diamonds')

根据__getitem__格局完成的功用

print(deck[0])
print(deck[-1])
#outputs:
Card(rank='2', suit='spades')
Card(rank='A', suit='hearts')

#随机从序列中选取
print(choice(deck))
print(choice(deck))
#outputs:
Card(rank='10', suit='hearts')
Card(rank='8', suit='diamonds')

这里在类的个中,实际上是在操作_card那些列表,所以也扶助分割操作。

print(deck[:3])
outputs:[Card(rank='2', suit='spades'), Card(rank='3', suit='spades'), Card(rank='4', suit='spades')]

print(deck[12::13])
outputs:[Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'), Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]

根据__getitem__办法那么些类就形成可迭代的类了。

for card in deck:
    print(card)
outputs:
Card(rank='2', suit='spades')
Card(rank='3', suit='spades')
...
Card(rank='K', suit='hearts')
Card(rank='A', suit='hearts')

反向迭代

for card in reversed(deck):
    print(card)
outputs:
Card(rank='A', suit='hearts')
Card(rank='K', suit='hearts')
...
Card(rank='3', suit='spades')
Card(rank='2', suit='spades')

此处对品种实行权重赋值,就可以对牌举行排序。

suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)

def spades_high(card):
    rank_value = FrenchDeck.ranks.index(card.rank)
    return rank_value * len(suit_values)   suit_values[card.suit]

deck = FrenchDeck()

for card in sorted(deck, key=spades_high):
    print(card)
outputs:
Card(rank='2', suit='clubs')
Card(rank='2', suit='diamonds')
...
Card(rank='A', suit='hearts')
Card(rank='A', suit='spades')

壹摞Python风格的叶子

 1 from collections import namedtuple
 2 from random import choice
 3 
 4 #命名元祖
 5 Card = namedtuple('Card', ['rank', 'suit'])
 6 
 7 
 8 class FrenchDeck:
 9     ranks = [str(n) for n in range(2, 11)]   list('JQKA')
10     suits = 'spades diamonds clubs hearts'.split()
11 
12     def __init__(self):
13         self._cards = [Card(rank, suit) for suit in self.suits for rank in self.ranks]
14 
15     def __len__(self):
16         return len(self._cards)
17 
18     #变为可迭代的对象
19     def __getitem__(self, position):
20         return self._cards[position]
21 
22 deck = FrenchDeck()
23 #扑克牌的张数
24 print('扑克牌的长度:', len(deck))
25 
26 #随机选择扑克牌
27 print('随机选择的扑克牌:', choice(deck))
28 
29 #选择扑克牌最上面的三张牌
30 print('扑克牌上最上面的三张牌:', deck[:3])
31 
32 #选择大老A
33 print('先选择第一张A', deck[12])
34 
35 #每一个花色有12张牌,可以通过步长来获取
36 print('取所有的大老A:', deck[12::13])
37 
38 #判断成员关系
39 print(Card('Q', 'hearts') in deck)
40 print(Card('7', 'beasts') in deck)
41 
42 #反向输出结果
43 for card in reversed(deck):
44     print(card)

以上代码实行的结果为:

扑克牌的长度: 52
随机选择的扑克牌: Card(rank='J', suit='clubs')
扑克牌上最上面的三张牌: [Card(rank='2', suit='spades'), Card(rank='3', suit='spades'), Card(rank='4', suit='spades')]
先选择第一张A Card(rank='A', suit='spades')
取所有的大老A: [Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'), Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]
True
False
Card(rank='A', suit='hearts')
Card(rank='K', suit='hearts')
Card(rank='Q', suit='hearts')
Card(rank='J', suit='hearts')
Card(rank='10', suit='hearts')
Card(rank='9', suit='hearts')
Card(rank='8', suit='hearts')
Card(rank='7', suit='hearts')
.......................
.......................

  那么排序呢?大家遵照常规,用点数来推断扑克牌的大大小小,二细微、A最大;同期还要加上对项目标决断,黑桃最大、红桃次之、方块再度、红绿梅最小。下边正是依据那个规则来给扑克牌排序的函数,春梅2 的轻重是 0,黑桃 A 是 5一:

 1 #牌颜色的权重
 2 suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)
 3 
 4 def spades_high(card):
 5     #获取2.....A的索引的值
 6     rank_value = FrenchDeck.ranks.index(card.rank)
 7     return rank_value * len(suit_values)   suit_values[card.suit]
 8 
 9 for card in sorted(deck, key=spades_high):
10     print(card)

上述代码执行的结果为:

Card(rank='2', suit='clubs')
Card(rank='2', suit='diamonds')
Card(rank='2', suit='hearts')
... (46 cards ommitted)
Card(rank='A', suit='diamonds')
Card(rank='A', suit='hearts')
Card(rank='A', suit='spades')

 

Python数据模型


明白好Python的数据模型才是当真精晓了Python那门语言

  • Python数据模型其实就是指标模型,书中对数据模型的表明是 数据模型是对Python框架的描述,标准了Python自己构建立模型块的接口,数据模型体现了Python的安顿性思想,明白好就会写出Pythonic代码。
  • 看似于平时应用的 len(something)幕后调用的是something.__len__方法,obj[key]骨子里调用的是obj.__getitem__亚洲必赢788.net,格局等等,那几个方法正是创设Python数据模型的主要,它们称为特种措施(魔术点子或双下方法)。

Pythonic纸牌


那是书中对于Python特殊措施的代码示例

import collections
from random import choice

# namedtuple用来构建只有少数属性但是没有方法的对象
# 访问其中的属性,可以像元组那样使用索引,也可以像一般对象那样使用点操作符(.)
Card = collections.namedtuple('Card', ['rank', 'suit'])

class FrenchDeck:
  ranks = [str(i) for i in range(2, 11)]   list('JQKA')
  suits = 'spades diamonds clubs hearts'.split()

  def __init__(self):
      self._cards = [Card(rank, suit) for suit in self.suits for rank in self.ranks]

  def __len__(self):
      return len(self._cards)

  # 可以利用索引查找元素,而且使得它的对象可迭代
  def __getitem__(self, pos):
      return self._cards[pos]

  def __repr__(self):
      return 

if __name__ == '__main__':
  deck = FrenchDeck()
  print(len(deck))

    # 打印第一张、最后一张、最上面三张、花色是A的扑克牌
  print(deck[0], deck[-1], deck[:3], deck[12::13], sep='n')

  # 随机选择一个元素
  print(choice(deck))

  # 打印每一张牌,打印数字,打印花色
  for card in deck:
      print(card, card[0], card.suit)
  
  # 扑克牌排序
  suit_values = dict(spades = 3, hearts = 2, diamonds = 1, clubs = 0)
  def spades_high(card):
      rank_value = FrenchDeck.ranks.index(card.rank)
      return len(suit_values) * rank_value   suit_values[card.suit]
  for card in sorted(deck, key=spades_high):
      print(card)

能够看到只有那几个特别措施就让对象的操作特别简便,特别是概念了__getitem__办法就足以兑现指标的迭代切片操作,这几个示例不仅仅展现了Python面向对象的风格,也是反映出Python的为主语言特(如迭代和切成丝)

自定义2维向量


关于运算符的非凡措施

from math import hypot    # 两个数平方和开方

class Vector():
  def __init__(self, x=0, y=0):
      self.x = x
      self.y = y

  def __repr__(self):     # 字符串表示形式
      return 'Vector(%r, %r)' % (self.x, self.y)

  def __abs__(self):
      return hypot(self.x, self.y)

  def __bool__(self):
      return bool(abs(self))
      # OR return bool(self.x or self.y)

  def __add__(self, other):
      return Vector(self.x   other.x, self.y   other.y)

  def __mul__(self, scalar):
      return Vector(self.x * scalar, self.y * scalar)

那边透过__add____mul__办法分别完毕了自定义二维向量的对于

  • 和 * 算数运算符的施用,同一时间__abs__落到实处了向量的模,__bool__达成决断向量是还是不是为零向量。

独特措施一览


书中提交的例外措施列表

  1. 与运算符非亲非故的特别规措施
字符串/字节序列表示形式 : __repr__、__str__、__format__、__bytes__
数值转换 : __abs__、__bool__、__complex__、__int__、__float__、__hash__、__index__
集合模拟 : __len__、__getitem__、__setitem__、__delitem__、__contains__
迭代枚举 : __iter__、__reversed__、__next__
可调用模拟 : __call__
上下文管理 : __enter__、__exit__
实例创建和销毁 : __new__、__init__、__del__
属性管理 : __getattr__、__getattribute__、__setattr__、__delattr__、__dir__
属性描述符 : __get__、__set__、__delete__
类相关的服务 : __prepare__、__instancecheck__、__subclasscheck__
  1. Python的数据模型,Python数据模型。与运算符有关的非正规措施
一元运算符 : __neg__  - 、__pos__    、__abs__  abs()
比较运算符 : __lt__  < 、__le__  <= 、__eq__  == 、__ne__  != 、__gt__  > 、__ge__  >=
算术运算符 : __add__    、__sub__  - 、__mul__  * 、__truediv__  / 、__floordiv__  // 、__mod__  % 、__divmod__  divmod() 、__pow__  ** 、__round__  round()
反向算术运算符 : __radd__、__rsub__、__rmul__、__rtruediv__、__rfloordiv__、__rmod__、__rdivmod__、__rpow__
增量赋值算术运算符 : __iadd__、__isub__、__imul__、__itruediv__、__ifloordiv__、__imod__、__ipow__
位运算符 : __invert__  ~ 、__lshift__  << 、__rshift__  >> 、__and__  & 、__or__  : 、__xor__  ^
反向位运算符 : __rlshift__、__rrshift__、__rand__、__ror__、__rxor__
增量赋值位运算符 : __ilshift__、__irshift__、__iand__、__ior__、__ixor__

小结


数据模型是Python风格的反映,特殊情势又是数据模型营造的重中之重,通过兑现特殊措施,自定义的数据类型可以像内置类型同样随意。特殊格局这么多,当然是遇则熟然而疏,不供给去记住全体,当须要利用的时候自然就认知它了。

  app_lael

      app_label那几个选项只在一种情景下使用,就是你的模子类不在暗许的应用程序包下的models.py文件中,那时候你须要钦命你那些模型类是那多少个应用程序的。比方您在其他地点写了二个模型类,而这些模型类是属于myapp的,那么您那是内需钦命为:app_label='myapp'

1.二 怎么样行使特别格局

破例格局不能够动用my_object.__len__()这种艺术调用,在成立一个自定义的类的靶卯时,Python会自动调用那么些格局,所以在Python调用这个十分措施时,一般是隐式的。
比方调用__len__时CPython会直接重临PyVarObject里的ob_size属性。
还有for i in x:迭代时,背后用的是iter(x),在函数内部是1个极度措施__iter__()
还只怕有注意不要自个儿无论的丰盛特殊格局。

何以行使极其格局

 

 

宪章数值类型

应用特殊措施,能够让自定义对象通过加号“ ”(或是其他运算符)进行演算

们来贯彻贰个二维向量(vector)类,这里的向量即是欧几里得几何中常用的定义,常在数学和情理中应用的丰裕

亚洲必赢788.net 1

四个二维向量加法的例子,Vector(贰,4)

  • Vextor(2,1) =Vector(4,5)

3个轻巧的2维向量类

 1 from math import hypot
 2 
 3 
 4 class Vector:
 5 
 6     def __init__(self, x=0, y=0):
 7         self.x = x
 8         self.y = y
 9 
10     def __repr__(self):
11         return 'Vector({!r}, {!r})'.format(self.x, self.y)
12 
13     def __abs__(self):
14         return hypot(self.x, self.y)
15 
16     def __bool__(self):
17         return bool(abs(self))
18 
19     def __add__(self, other):
20         x = self.x   other.x
21         y = self.y   other.y
22         return Vector(x, y)
23 
24     def __mul__(self, scalar):
25         return Vector(self.x * scalar, self.y * scalar)
26 
27 
28 v1 = Vector(2, 4)
29 v2 = Vector(2, 1)
30 
31 #向量v1   v2的结果
32 print('v1   v2的和:', v1 v2)
33 
34 #向量v abs的结果
35 v = Vector(3, 4)
36 print('v abs的结果:', abs(v))
37 
38 #向量的惩罚
39 print('v 的标量乘法abs的结果:', abs(v * 3))

上述代码试行的结果为:

v1   v2的和: Vector(4, 5)
v abs的结果: 5.0
v 的标量乘法abs的结果: 15.0

 

字符串表示方式

  Python 有叁个内置的函数叫 repr,它能把叁个对象用字符串的款型表达出来以便辨认,那就是“字符串代表形式”。repr 就是通过 __repr__本条奇异格局来获取叁个指标的字符串表示方式的。如若未有落实__repr__,当大家在调整台里打字与印刷3个向量的实例时,获得的字符串恐怕会是 <Vector object at 0x10e100070>。 

  交互式调控台和调节和测试程序(debugger)用 repr 函数来获得字符串表示方式;在老的接纳 % 符号的字符串格式中,这么些函数再次回到的结果用来代表 %r 所代表的对象;一样,str.format 函数所用到的新星字符串格式化语法( repr(),才把 !r 字段造成字符串。

  __repr__ 所重临的字符串应该标准、无歧义,并且尽量发挥出什么用代码成立出那些被打字与印刷的对象。因而这里运用了近乎调用对象构造器的表明方式(举例Vector(三, 四) 正是个例证)

  __repr__ 和 __str__ 的不同在于,后者是在 str() 函数被利用,或是在用 print 函数打字与印刷二个目的的时候才被调用的,并且它回到的字符串对终极用户更友善。假让你只想实现那七个奇特格局中的一个,__repr__ 是越来越好的挑选,因为假使3个指标未有 __str__ 函数,而 Python 又必要调用它的时候,解释器会用 __repr__ 作为代表。

 

算术运算符

  通过 __add__ 和 __mul__,示例向量类带来了 和 * 那三个算术运算符。值得注意的是,那七个章程的重临值都以新创设的向量对象,被操作的多个向量(self 或 other)照旧未有丝毫退换,代码里只是读取了它们的值而已。中缀运算符的为主条件正是不转移操作对象,而是产出2个新的值。

 

自定义的布尔值

  就算Python 里有 bool 类型,但实在任何对象都得以用来须要布尔值的左右文中(举个例子 if 或 while 语句,或然 and、or 和 not 运算符)。为了推断三个值 x 为真依旧为假,Python 会调用 bool(x),那几个函数只好回去 True 或许False。

  默许情状下,大家温馨定义的类的实例总被感到是确实,除非那几个类对 __bool__ 或者 __len__ 函数有投机的贯彻。bool(x) 的骨子里是调x.__bool__() 的结果;如若不存在 __bool__ 方法,那么 bool(x) 会尝试调用 x.__len__()。若再次回到 0,则 bool 会再次来到 False;不然重返True。

  我们对 __bool__ 的兑现很简短,假使1个向量的模是 0,那么就回来False,其余情况则赶回 True。因为 __bool__ 函数的回到类型应该是布尔型,所以大家由此 bool(abs(self)) 把模值形成了布尔值。

  假设想让 Vector.__bool__ 更敏捷,能够运用这种实现:

def __bool__(self):
    return bool(self.x or self.y)

  它不那么易读,却能省掉从 abs 到 __abs__ 到平方再到平方根这一个中级步骤。通过 bool 把重临类型显式调换为布尔值是为着契合__bool__ 对重回值的鲜明,因为 or 运算符恐怕会再次来到 x 或许 y本人的值:若 x 的值等价于真,则 or 重回 x 的值;不然重临 y 的值。

 

特别措施一览

跟运算符无关的非正规措施

类别 方法名
字符串字/字节序列表示形式  __repr__、__str__、__format__、__bytes__
数值转换   __abs__、__bool__、__complex__、__int__、__float__、__hash__、__index__
集合模拟   _len__、__getitem__、__setitem__、__delitem__、__contains__  
迭代枚举  __iter__、__reversed__、__next__ 
可调用模拟   __call__
上下文管理  __enter__、__exit__
实例的创建和销毁   __new__、__init__、__del__
属性管理  __getattr__、__getattribute__、__setattr__、__delattr__、__dir__
属性描述符   __get__、__set__、__delete__ 
跟类相关的服务  __prepare__、__instancecheck__、__subclasscheck__

 

 

 

 

 

 

 

 

 

 

 

 

跟运算符相关的特别措施

类别 方法名
一元运算符  __neg__ -、__pos__ 、__abs__ abs()
众多比较运算符  __lt__ <、__le__ <=、__eq__ ==、__ne__ !=、__gt__ >、__ge__ >=
算数运算符   __add__ 、__sub__ -、__mul__ *、__truediv__ /、__floordiv__ //、__mod__ %、  __divmod__divmod()、__pow__ ** 或pow()、__round__ round()
反向算术运算符  __radd__、__rsub__、__rmul__、__rtruediv__、__rfloordiv__、__rmod__、__rdivmod__
增量赋值算术运算符   __iadd__、__isub__、__imul__、__itruediv__、__ifloordiv__、__imod__、__ipow__
位运算符  __invert__ ~、__lshift__ <<、__rshift__ >>、__and__ &、__or__ |、__xor__ ^ 
反向位运算符  __rlshift__、__rrshift__、__rand__、__rxor__、__ror__
增量赋值为运算符   __ilshift__、__irshift__、__iand__、__ixor__、__ior__ 

 

 

 

 

 

 

 

 

 

  

  db_table

       db_table是用来钦点自定义数据库表名的。Django有一套私下认可的遵照一定规则改造数据模型对应的数据库表名,如若您想行使自定义的表名,就透过这一个天性钦定,比方:table_name='my_owner_table'

      若不提供该参数, Django 会使用 app_label '_' module_name 作为表的名字.

      若你的表的名字是一个 SQL 保留字, 或包涵 Python 变量名不允许的字符--特别是连字符 --不要紧. Django 会自动在处之怡然替你将列名字和表名字用引号引起来.

1.2.一效仿数值类型

本文由bwin必赢发布,转载请注明来源

关键词: 流畅的Python