Python 學習第二十三天 django 知識（五）

一，django 的model操作

　　1，字段

 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

    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)
        - 二進制類型

 2，創建數據庫表，元數據可以加入自定義字段

　　（1）自定義表名，在django中生成表名，默認為app的name下划線加上models.py中定義的類名，

　　　　  如果要自定義表名，可用如下方法：

class User(models.Model):
	name = models.CharField(max_length=32,db_index=True)
	pwd = models.CharField(max_length=32,db_index=True)		
	class Meta:
		# 數據庫中生成的表名稱 默認 app名稱 + 下划線 + 類名
		db_table = "tbname"                            #生成表名為tbname的表

 　　（2）創建聯合索引，聯合索引查詢時，支持最左前綴模式，以下面的代碼為例，解釋最左前綴模式

　　　　　select * from user where name="xx" 可命中聯合索引，

　　　　　select * from user where name="xx" and pwd="xx" 可命中聯合索引，

　　　　   select * from user where pwd="xx" 不能命中索引，

class User(models.Model):
	name = models.CharField(max_length=32)
	pwd = models.CharField(max_length=32)		
	class Meta:
		# 數據庫中生成的表名稱 默認 app名稱 + 下划線 + 類名
		db_table = "tb1"

		index_together = [
			("name", 'pwd'),
		]
　　　　　　　　　　unique_together = (("driver","restautant"),)   #聯合唯一索引，組合唯一
　　　　　　　　　 

 　3，數據表中字段類型one-to-one 實際為foreign key並且唯一

　 4，字段參數

    null                數據庫中字段是否可以為空
    db_column           數據庫中字段的列名
    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_112233\d+', message='又錯誤了', code='c2'),
                                    EmailValidator(message='又錯誤了', code='c3'), ]
                            )

 5，操作數據庫表，正反向查找

class UserType(models.Model):
	name = models.CharField(max_length=32)
			
class User(models.Model):
	name = models.CharField(max_length=32)
	pwd = models.CharField(max_length=32)
	ut =  models.ForiegnKey(to="UserType",to_field='id')


# 正向
v = User.objects.all()                     #獲取queryset對象
for item in v:
    item.user
    item.pwd
    item.ut.name
User.objects.all().values('user','ut__name')                 #直接查找，跨表查詢加雙下划線

#反向
v = UserType.objects.all()
for item in v:
    item.name
    item.id
    item.user_set.all()

 models.UserType.objects.all().values('name','user__pwd')   #直接查找

    （1）如果Foriegnkey字段有參數related_name="b",則在反向查找中，user_set為b

　 （2）如果Foriegnkey字段有參數related_query_name="a" 只替代表名，即在查找中item.a_set.all()

6，manytomany 多對多關系表建立

　　（1）django 自動創建第三張關系表

class Blog(models.Model):
    site = models.CharField(max_length=32)

class Tag(models.Model):
    name = models.CharField(max_length=32)
    m = models.ManyToManyField('Blog')

#自動創建第三張表，表名為blog_to_tag，可以利用db_table="name" 來定義第三張表的名字
#可使用如下方法對數據庫表進行操作
#m2m.remove()
#m2m.add()
#m2m.set()
#m2m.clear()
#m2m.filter()

 　　（2）自動義表建立manytomany關系

class Blog(models.Model):
    site = models.CharField(max_length=32)

class Tag(models.Model):
    name = models.CharField(max_length=32)

class B2T(models.Model):
    b = models.ForeignKey('Blog')
    t = models.ForeignKey('tag')

#自己創建多對多關系
#跨表查詢時，需要先跨到B2T表，再通過B2T表查詢另一張表

 　　（3）自定義某個字段的manytomany關系

class Blog(models.Model):
    site = models.CharField(max_length=32)
    m = models.ManyToManyField('Tag'.through='B2T',through_fields=['b','t1'])

class Tag(models.Model):
    name = models.CharField(max_length=32)

class B2T(models.Model):
    b = models.ForeignKey('Blog')
    t1 = models.ForeignKey('tag')
    status = models.Foreignkey()

#只生成3張表，並且可通過m字段進行manytomany操作，但不能有add(),remove(),set()操作
#因為在B2T中可以自定義出多個字段，且through_fields中只包含部分字段，
#只能做查詢操作

 7，多表關系以及參數

 ForeignKey(ForeignObject) # ForeignObject(RelatedField)
        to,                         # 要進行關聯的表名
        to_field=None,              # 要關聯的表中的字段名稱
        on_delete=None,             # 當刪除關聯表中的數據時，當前表與其關聯的行的行為
                                        - models.CASCADE，刪除關聯數據，與之關聯也刪除
                                        - models.DO_NOTHING，刪除關聯數據，引發錯誤IntegrityError
                                        - models.PROTECT，刪除關聯數據，引發錯誤ProtectedError
                                        - models.SET_NULL，刪除關聯數據，與之關聯的值設置為null（前提FK字段需要設置為可空）
                                        - models.SET_DEFAULT，刪除關聯數據，與之關聯的值設置為默認值（前提FK字段需要設置默認值）
                                        - models.SET，刪除關聯數據，
                                                      a. 與之關聯的值設置為指定值，設置：models.SET(值)
                                                      b. 與之關聯的值設置為可執行對象的返回值，設置：models.SET(可執行對象)

                                                        def func():
                                                            return 10

                                                        class MyModel(models.Model):
                                                            user = models.ForeignKey(
                                                                to="User",
                                                                to_field="id"
                                                                on_delete=models.SET(func),)
        related_name=None,          # 反向操作時，使用的字段名，用於代替 【表名_set】 如： obj.表名_set.all()
        related_query_name=None,    # 反向操作時，使用的連接前綴，用於替換【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
        limit_choices_to=None,      # 在Admin或ModelForm中顯示關聯數據時，提供的條件：
                                    # 如：
                                            - limit_choices_to={'nid__gt': 5}
                                            - limit_choices_to=lambda : {'nid__gt': 5}

                                            from django.db.models import Q
                                            - limit_choices_to=Q(nid__gt=10)
                                            - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                            - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
        db_constraint=True          # 是否在數據庫中創建外鍵約束
        parent_link=False           # 在Admin中是否顯示關聯數據


    OneToOneField(ForeignKey)
        to,                         # 要進行關聯的表名
        to_field=None               # 要關聯的表中的字段名稱
        on_delete=None,             # 當刪除關聯表中的數據時，當前表與其關聯的行的行為

                                    ###### 對於一對一 ######
                                    # 1. 一對一其實就是 一對多 + 唯一索引
                                    # 2.當兩個類之間有繼承關系時，默認會創建一個一對一字段
                                    # 如下會在A表中額外增加一個c_ptr_id列且唯一：
                                            class C(models.Model):
                                                nid = models.AutoField(primary_key=True)
                                                part = models.CharField(max_length=12)

                                            class A(C):
                                                id = models.AutoField(primary_key=True)
                                                code = models.CharField(max_length=1)

    ManyToManyField(RelatedField)
        to,                         # 要進行關聯的表名
        related_name=None,          # 反向操作時，使用的字段名，用於代替 【表名_set】 如： obj.表名_set.all()
        related_query_name=None,    # 反向操作時，使用的連接前綴，用於替換【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
        limit_choices_to=None,      # 在Admin或ModelForm中顯示關聯數據時，提供的條件：
                                    # 如：
                                            - limit_choices_to={'nid__gt': 5}
                                            - limit_choices_to=lambda : {'nid__gt': 5}

                                            from django.db.models import Q
                                            - limit_choices_to=Q(nid__gt=10)
                                            - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                            - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
        symmetrical=None,           # 僅用於多對多自關聯時，symmetrical用於指定內部是否創建反向操作的字段
                                    # 做如下操作時，不同的symmetrical會有不同的可選字段
                                        models.BB.objects.filter(...)

                                        # 可選字段有：code, id, m1
                                            class BB(models.Model):

                                            code = models.CharField(max_length=12)
                                            m1 = models.ManyToManyField('self',symmetrical=True)

                                        # 可選字段有: bb, code, id, m1
                                            class BB(models.Model):

                                            code = models.CharField(max_length=12)
                                            m1 = models.ManyToManyField('self',symmetrical=False)

        through=None,               # 自定義第三張表時，使用字段用於指定關系表
        through_fields=None,        # 自定義第三張表時，使用字段用於指定關系表中那些字段做多對多關系表
                                        from django.db import models

                                        class Person(models.Model):
                                            name = models.CharField(max_length=50)

                                        class Group(models.Model):
                                            name = models.CharField(max_length=128)
                                            members = models.ManyToManyField(
                                                Person,
                                                through='Membership',
                                                through_fields=('group', 'person'),
                                            )

                                        class Membership(models.Model):
                                            group = models.ForeignKey(Group, on_delete=models.CASCADE)
                                            person = models.ForeignKey(Person, on_delete=models.CASCADE)
                                            inviter = models.ForeignKey(
                                                Person,
                                                on_delete=models.CASCADE,
                                                related_name="membership_invites",
                                            )
                                            invite_reason = models.CharField(max_length=64)
        db_constraint=True,         # 是否在數據庫中創建外鍵約束
        db_table=None,              # 默認創建第三張表時，數據庫中表的名稱

 8，ORM查詢數據效率

　　（1）多表關聯查詢，用.all()方法查詢　

users = models.User.objects.all().select_related('ut')
for row in users:
    print(row.user,row.pwd,row.ut_id)
    print(row.tu.name) # 每次循環都會再發起一次SQL請求

 　 （2）多表關聯查詢，用.all().values("name1","name2")，只進行一次查詢，但查詢的字段固定

　  （3）多表關聯查詢，用.all().select_related('name'),可一次性查詢所有數據，但是name字段必須為ForeignKey，獲得的結果可進行對象操作

　  （4）多表關聯查詢，用.filter(id__gt=30).prefetch_related("name")語句，會進行兩步sql 語句（a）類似於select * from users where id>30（b）select * from user_type where id in [1,2] 這里的1,2為假設值

  9，以.all().values("name1","name2") 或者以.all().values_list()獲取的查詢結果不能再繼續進行.操作

  10， ORM操作總結

　（1）基本操作

        # 增
        #
        # models.Tb1.objects.create(c1='xx', c2='oo')  增加一條數據，可以接受字典類型數據 **kwargs

        # obj = models.Tb1(c1='xx', c2='oo')
        # obj.save()

        # 查
        #
        # models.Tb1.objects.get(id=123)         # 獲取單條數據，不存在則報錯（不建議）
        # models.Tb1.objects.all()               # 獲取全部
        # models.Tb1.objects.filter(name='seven') # 獲取指定條件的數據
        # models.Tb1.objects.exclude(name='seven') # 獲取指定條件的數據

        # 刪
        #
        # models.Tb1.objects.filter(name='seven').delete() # 刪除指定條件的數據

        # 改
        # models.Tb1.objects.filter(name='seven').update(gender='0')  # 將指定條件的數據更新，均支持 **kwargs
        # obj = models.Tb1.objects.get(id=1)
        # obj.c1 = '111'
        # obj.save()

 　（2）進階操作

# 獲取個數
        #
        # models.Tb1.objects.filter(name='seven').count()

        # 大於，小於
        #
        # models.Tb1.objects.filter(id__gt=1)              # 獲取id大於1的值
        # models.Tb1.objects.filter(id__gte=1)              # 獲取id大於等於1的值
        # models.Tb1.objects.filter(id__lt=10)             # 獲取id小於10的值
        # models.Tb1.objects.filter(id__lte=10)             # 獲取id小於10的值
        # models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 獲取id大於1 且 小於10的值

        # in
        #
        # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 獲取id等於11、22、33的數據
        # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

        # isnull
        # Entry.objects.filter(pub_date__isnull=True)

        # contains
        #
        # models.Tb1.objects.filter(name__contains="ven")
        # models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
        # models.Tb1.objects.exclude(name__icontains="ven")

        # range
        #
        # models.Tb1.objects.filter(id__range=[1, 2])   # 范圍bettwen and

        # 其他類似
        #
        # startswith，istartswith, endswith, iendswith,

        # order by
        #
        # models.Tb1.objects.filter(name='seven').order_by('id')    # asc
        # models.Tb1.objects.filter(name='seven').order_by('-id')   # desc

        # group by
        #
        # from django.db.models import Count, Min, Max, Sum
        # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
        # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

        # limit 、offset
        #
        # models.Tb1.objects.all()[10:20]

        # regex正則匹配，iregex 不區分大小寫
        #
        # Entry.objects.get(title__regex=r'^(An?|The) +')
        # Entry.objects.get(title__iregex=r'^(an?|the) +')

        # date
        #
        # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
        # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

        # year
        #
        # Entry.objects.filter(pub_date__year=2005)
        # Entry.objects.filter(pub_date__year__gte=2005)

        # month
        #
        # Entry.objects.filter(pub_date__month=12)
        # Entry.objects.filter(pub_date__month__gte=6)

        # day
        #
        # Entry.objects.filter(pub_date__day=3)
        # Entry.objects.filter(pub_date__day__gte=3)

        # week_day
        #
        # Entry.objects.filter(pub_date__week_day=2)
        # Entry.objects.filter(pub_date__week_day__gte=2)

        # hour
        #
        # Event.objects.filter(timestamp__hour=23)
        # Event.objects.filter(time__hour=5)
        # Event.objects.filter(timestamp__hour__gte=12)

        # minute
        #
        # Event.objects.filter(timestamp__minute=29)
        # Event.objects.filter(time__minute=46)
        # Event.objects.filter(timestamp__minute__gte=29)

        # second
        #
        # Event.objects.filter(timestamp__second=31)
        # Event.objects.filter(time__second=2)
        # Event.objects.filter(timestamp__second__gte=31)

 　（3）高級操作

        # extra
        #
        # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
        #    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
        #    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
        #    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
        #    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

        # F
        #
        # from django.db.models import F
        # models.Tb1.objects.update(num=F('num')+1)


        # Q
        #
        # 方式一：
        # Q(nid__gt=10)
        # Q(nid=8) | Q(nid__gt=10)
        # Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')

        # 方式二：
        # con = Q()
        # q1 = Q()
        # q1.connector = 'OR'
        # q1.children.append(('id', 1))
        # q1.children.append(('id', 10))
        # q1.children.append(('id', 9))
        # q2 = Q()
        # q2.connector = 'OR'
        # q2.children.append(('c1', 1))
        # q2.children.append(('c1', 10))
        # q2.children.append(('c1', 9))
        # con.add(q1, 'AND')
        # con.add(q2, 'AND')
        #
        # models.Tb1.objects.filter(con)


        # 執行原生SQL
        #
        # from django.db import connection, connections
        # cursor = connection.cursor()  # cursor = connections['default'].cursor()
        # cursor.execute("""SELECT * from auth_user where id = %s""", [1])
        # row = cursor.fetchone()

 　（4）其它操作

##################################################################
# PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
##################################################################

def all(self)
    # 獲取所有的數據對象

def filter(self, *args, **kwargs)
    # 條件查詢
    # 條件可以是：參數，字典，Q

def exclude(self, *args, **kwargs)
    # 條件查詢
    # 條件可以是：參數，字典，Q

def select_related(self, *fields)
     性能相關：表之間進行join連表操作，一次性獲取關聯的數據。
     model.tb.objects.all().select_related()
     model.tb.objects.all().select_related('外鍵字段')
     model.tb.objects.all().select_related('外鍵字段__外鍵字段')

def prefetch_related(self, *lookups)
    性能相關：多表連表操作時速度會慢，使用其執行多次SQL查詢在Python代碼中實現連表操作。
            # 獲取所有用戶表
            # 獲取用戶類型表where id in (用戶表中的查到的所有用戶ID)
            models.UserInfo.objects.prefetch_related('外鍵字段')



            from django.db.models import Count, Case, When, IntegerField
            Article.objects.annotate(
                numviews=Count(Case(
                    When(readership__what_time__lt=treshold, then=1),
                    output_field=CharField(),
                ))
            )

            students = Student.objects.all().annotate(num_excused_absences=models.Sum(
                models.Case(
                    models.When(absence__type='Excused', then=1),
                default=0,
                output_field=models.IntegerField()
            )))

def annotate(self, *args, **kwargs)
    # 用於實現聚合group by查詢

    from django.db.models import Count, Avg, Max, Min, Sum

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
    # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
    # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
    # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

def distinct(self, *field_names)
    # 用於distinct去重
    models.UserInfo.objects.values('nid').distinct()
    # select distinct nid from userinfo

    注：只有在PostgreSQL中才能使用distinct進行去重

def order_by(self, *field_names)
    # 用於排序
    models.UserInfo.objects.all().order_by('-id','age')

def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    # 構造額外的查詢條件或者映射，如：子查詢

    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

 def reverse(self):
    # 倒序
    models.UserInfo.objects.all().order_by('-nid').reverse()
    # 注：如果存在order_by，reverse則是倒序，如果多個排序則一一倒序


 def defer(self, *fields):
    models.UserInfo.objects.defer('username','id')
    或
    models.UserInfo.objects.filter(...).defer('username','id')
    #映射中排除某列數據

 def only(self, *fields):
    #僅取某個表中的數據
     models.UserInfo.objects.only('username','id')
     或
     models.UserInfo.objects.filter(...).only('username','id')

 def using(self, alias):
     指定使用的數據庫，參數為別名（setting中的設置）


##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
##################################################

def raw(self, raw_query, params=None, translations=None, using=None):
    # 執行原生SQL，獲取的結果為對象
    models.UserInfo.objects.raw('select * from userinfo')

    # 如果SQL是其他表時，必須將名字設置為當前UserInfo對象的主鍵列名
    models.UserInfo.objects.raw('select id as nid from 其他表')

    # 為原生SQL設置參數
    models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])

    # 將獲取的到列名轉換為指定列名
    name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
    Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)

    # 指定數據庫
    models.UserInfo.objects.raw('select * from userinfo', using="default")

    ################### 原生SQL ###################
    from django.db import connection, connections
    cursor = connection.cursor()  # cursor = connections['default'].cursor()
    cursor.execute("""SELECT * from auth_user where id = %s""", [1])
    row = cursor.fetchone() # fetchall()/fetchmany(..)


def values(self, *fields):
    # 獲取每行數據為字典格式

def values_list(self, *fields, **kwargs):
    # 獲取每行數據為元祖

def dates(self, field_name, kind, order='ASC'):
    # 根據時間進行某一部分進行去重查找並截取指定內容
    # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
    # order只能是："ASC"  "DESC"
    # 並獲取轉換后的時間
        - year : 年-01-01
        - month: 年-月-01
        - day  : 年-月-日

    models.DatePlus.objects.dates('ctime','day','DESC')

def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
    # 根據時間進行某一部分進行去重查找並截取指定內容，將時間轉換為指定時區時間
    # kind只能是 "year", "month", "day", "hour", "minute", "second"
    # order只能是："ASC"  "DESC"
    # tzinfo時區對象
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))

    """
    pip3 install pytz
    import pytz
    pytz.all_timezones
    pytz.timezone(‘Asia/Shanghai’)
    """

def none(self):
    # 空QuerySet對象


####################################
# METHODS THAT DO DATABASE QUERIES #
####################################

def aggregate(self, *args, **kwargs):
   # 聚合函數，獲取字典類型聚合結果，加上distinct=True參數，會對查詢的結果進行去重
   from django.db.models import Count, Avg, Max, Min, Sum
   result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
   ===> {'k': 3, 'n': 4}

def count(self):
   # 獲取個數

def get(self, *args, **kwargs):
   # 獲取單個對象

def create(self, **kwargs):
   # 創建對象

def bulk_create(self, objs, batch_size=None):
    # 批量插入
    # batch_size表示一次插入的個數，
    objs = [
        models.DDD(name='r11'),
        models.DDD(name='r22')
    ]
    models.DDD.objects.bulk_create(objs, 10) #10代表每次寫入多少個數據

def get_or_create(self, defaults=None, **kwargs):
    # 如果存在，則獲取，否則，創建
    # defaults 指定創建時，其他字段的值
    obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2})

def update_or_create(self, defaults=None, **kwargs):
    # 如果存在，則更新，否則，創建
    # defaults 指定創建時或更新時的其他字段
    obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1})

def first(self):
   # 獲取第一個

def last(self):
   # 獲取最后一個

def in_bulk(self, id_list=None):
   # 根據主鍵ID進行查找
   id_list = [11,21,31]
   models.DDD.objects.in_bulk(id_list)

def delete(self):
   # 刪除

def update(self, **kwargs):
    # 更新

def exists(self):
   # 是否有結果

 　11，對表中的數據進行聚合

 from django.db.models import Count, Avg, Max, Min, Sum
 result = models.UserInfo.objects.aggregate(n=Count('nid'))

#對userinfor的表中進行聚合，類似於select count(nid) from userinfo as n;
#count,sum,avg等用法一樣

 二，Form 表單驗證

      Form 一般有兩個用途，（1）做驗證（2）生成html標簽，當用新URL方式提交的時候，因為Form 可以保留上一次提交的數據

　　（1）Form表單中生成select標簽，select中的內容從數據庫中獲取

          a) form.py中的代碼

from django import forms
from django.forms import fields
from django.forms import widgets

class UserInfo(forms.Form):
    user_type = fields.ChoiceField(
           choices=[]
           widget=widgets.Select
      )
    user_type2 = fields.CharField(widget=widget.Select(choices=[]))  
     def __init__(self,*args,**kwargs):
        super(UserInfoForm,self).__init__(*args,**kwargs)
        self.fields['user_type'].choices = models.UserType.objects.values_list('id','name')
        self.fields['user_type'].widget.choices = models.UserType.objects.values_list('id','name')

 　　　b) html代碼

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
        <p>{{ obj.user }}</p>
        <p>{{ obj.pwd }}</p>
        <p>{{ obj.user_type }}</p>
        <p>{{ obj.user_type2 }}</p>
</body>
</html>

        c) views函數

from app01.forms import  UserInfoForm
    obj = userInfoForm()
    return render(request,'index.html',{'obj':obj})

 　（2）Form結合models生成select標簽

　　 a) Form中代碼

from django import forms
from django.forms import fields
from django.forms import widgets
from django.forms import ModelChoiceField

class UserInfo(forms.Form):
    user_type3 = fields.ChoiceField(
　　　　　 empty_label = "請選擇用戶類型"       
         queryset = models.UserType.objects.all()
         to_field_name = 'name'                 #在html會對option標簽生成value屬性，並且該屬性的值為標簽的內容
      )

      b) models代碼部分,models 中重新定制str

from django.db import models

class UserType(models.Model):
    name = models.CharField(max_length=32)
    
    def __str__(self):
        return self.name

     （3）Form中生成默認值，obj = UserInfoForm({'user':"root"})

　　（4）Form中的鈎子對每個field進行驗證，其實就是調用django保留的clean_"field_name"方法

from django.core.exception import ValidationError

class RegisterForm(forms.Form):
    user = fields.CharField()
    email = fields.EmailField()

    def clean_user(self):                                        #對user字段進行驗證
        c = models.UserInfo.objects.filter(name=self.cleand_data['user']).count()
        if not c:
            return self.cleand_data['user']
        else:
            raise ValidationError("用戶名已經存在",code="xxx")
    def clean_email(self)                                         #對email字段進行驗證
        return self.cleand_data['email']                          #必須要有返回值，否則返回none,頁面沒有數據
    def clean(self):                                               #對整個form進行驗證
        c = models.UerInfo.objects.filter(name = self.cleand_data['user'],pwd=self.cleand_data['pwd'])
        if c
            return self.cleand_data
        else:
            raise ValidationError('用戶名或密碼錯誤'）
     def _post_clean(self):
          pass

 　　（5）form驗證的整個過程1，每一個字段（正則，字段的鈎子）2，clean鈎子，3，__post_clean

　　 （6）錯誤信息返回

　　　　　每個字段的錯誤信息返回，在各個字段中

　　　　　views中 obj.errors{ '__all__':[],    #放整體的錯誤信息

　　　　　　　　　　　　　　　'user':[{'code':'required','message':'xxx'}],     #存放user字段的錯誤信息         

　　　　　　　　　　　　　　　'email':[{'code':'required','message':'xxx'}],    #存放email字段的錯誤信息

　　　　　　　　　　　　　　}

三，django ajax請求序列化

　（1）對於ErrorDict，進行序列化

from django.core.exceptions import ValidationError
class JsonCustomEncoder(json.JSONEncoder): 
					
	def default(self, field): 
					 
		if isinstance(field, ValidationError): 
		    return {'code':field.code,'messages':field.messages}
    
                else:
                    return json.JSONEncoder.default(self,field)
         def login(request):
                if request.method == 'GET':
                    return render(request,'login.html')
                elfi request.method == 'POST':
                    obj = LoginForm(request.POST)
                    if obj.is_valid():
                        pass:
                    else:
                        ret['error'] = obj.errors.as_data()
                result = json.dumps(ret,cls=JsonCustomEncoder)
                return HttpResponse(result)

 　　（2）對於常規的數據進行序列化

#第一種方法
from django.core import serializers
				
v = models.tb.objects.all()
data = serializers.serialize("json", v)
#第二種方法
import json 
from datetime import date 
from datetime import datetime 
class JsonCustomEncoder(json.JSONEncoder): 
					
    def default(self, field): 
					 
        if isinstance(field, datetime): 
	    return field.strftime('%Y-%m-%d %H:%M:%S') 
        elif isinstance(field, date): 
	    return field.strftime('%Y-%m-%d') 
        else: 
	    return json.JSONEncoder.default(self, field) 
   
v = models.tb.objects.values('id','name','ctime')
v = list(v)
v = json.dumps(v,cls=JsonCustomEncoder)