欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Django ORM查詢操作方式

 更新時間：2023年10月19日 09:18:23   作者：一個兩個四個三  
Django提供了一套非常方便的類似SqlAlchemy ORM的通過對象調(diào)用的方式操作數(shù)據(jù)庫表的ORM框架,,本文給大家詳細介紹Django ORM查詢操作方式,感興趣的朋友一起看看吧

Django提供了一套非常方便的類似SqlAlchemy ORM的通過對象調(diào)用的方式操作數(shù)據(jù)庫表的ORM框架。

Django ORM操作主要分為以下幾類：

  • 增：向表內(nèi)插入一條數(shù)據(jù)
  • 刪：刪除表內(nèi)數(shù)據(jù)（物理刪除）
  • 改：update操作更新某條數(shù)據(jù)
  • 查：基本的表查詢（包括多表、跨表、子查詢、聯(lián)表查詢）

其中比較復雜的是表查詢。下面分類講解這幾種操作方式。

1 增 – 向表內(nèi)插入一條數(shù)據(jù)

關(guān)于新增記錄的操作這里分為兩種方式:

第一種方式，通過模型對象的save()方法：

userObj=User()
userObj.username= request.data.get('username')
# userObj.password= make_password(request.POST.get('password'),None,'pbkdf2_sha256')  # 創(chuàng)建django密碼，第三個參數(shù)為加密算法
userObj.set_password(request.data.get('password'))  # 創(chuàng)建django密碼，第三個參數(shù)為加密算法
userObj.name= request.data.get('name')
userObj.phone= request.data.get('phone')
userObj.email= request.data.get('email')
userObj.create_name= request.data.get('create_name')
userObj.update_name= request.data.get('update_name')
userObj.is_superuser= 0
print(userObj.username)
print('username %s' % (userObj.username))
print('password %s' % (userObj.password))
userObj.save()

這種方式先創(chuàng)建一個模型對象，賦值，最后調(diào)用模型的 .save()方法的方式向數(shù)據(jù)庫插入一條數(shù)據(jù)。

第二種方式，通過objects.create的方式直接新增，類似一種縮略的方式，比較簡單

res = models.User.objects.create(username='admin',make_password='123456',register_time=datetime.datetime.now())
print(res)

2 刪 – 刪除表內(nèi)數(shù)據(jù)（物理刪除）

django刪除表數(shù)據(jù)是通過.delete()方法，舉例：

如果我們只刪除 user表 主鍵為1的記錄： ret = models.User.objects.get(pk=1).delete()
上述是只刪一條記錄，刪除多條記錄類似： ret = models.User.objects.filter(pk__gt=1).delete()

這樣我們可以批量刪除user表中主鍵值大于1的其他所有記錄。

需要提醒的是，這種方式屬于物理刪除，刪除后不可恢復，如需邏輯刪除，參考下面 update的方式。

3 改 – update操作更新某條數(shù)據(jù)

django ORM 的改操作，這里分為三種方式。我們先按單記錄的更新講解，批量更新類似：

第一種，指定更新字段更新：

ret = models.User.objects.get(pk=1).update(username='admin',password='123456')

第二種，通過 Json 更新：

object = {'username':'admin','password':'123456'}
ret = models.User.objects.get(pk=1).update(**object)

第三種，類似增操作，直接通過.save()方法更新整條記錄

userObj=User()
userObj.id= request.data.get('id')
userObj.username= request.data.get('username')
# userObj.password= make_password(request.POST.get('password'),None,'pbkdf2_sha256')  # 創(chuàng)建django密碼，第三個參數(shù)為加密算法
userObj.set_password(request.data.get('password'))  # 創(chuàng)建django密碼，第三個參數(shù)為加密算法
userObj.name= request.data.get('name')
userObj.phone= request.data.get('phone')
userObj.email= request.data.get('email')
userObj.create_name= request.data.get('create_name')
userObj.update_name= request.data.get('update_name')
userObj.is_superuser= 0
print(userObj.username)
print('username %s' % (userObj.username))
print('password %s' % (userObj.password))
userObj.save()

這種方式不太建議用，需要注意數(shù)據(jù)的完整性。

4 查 – 基本的表查詢（包括多表、跨表、子查詢、聯(lián)表查詢）

4.1 基本查詢

需要了解如下方法的使用：

  • all() 查詢所有數(shù)據(jù)
  • filter() 帶有過濾條件的查詢 where
  • get() 獲取單條，查詢不到會報錯
  • first() 取queryset里第一條記錄
  • last() 取queryset里最后一條記錄
  • values() 指定要獲取的字段
models.User.objects.filter(pk=1).values('username','phone')
# 返回 <QuerySet [{'username': 'admin', 'phone': '176****'}]>

values_list() 列表套元祖

 models.User.objects.filter(pk=1).values_list('username','phone')
# 返回 <QuerySet [('admin','176***')]>

distinct() 去重

ret = models.User.objects.filter(pk=1).distinct()

需要注意，這里去重是針對整條數(shù)據(jù)的去重，主鍵不一樣也不會去重

order_by() 排序

ret = models.User.objects.order_by('username')# 默認升序
ret = models.User.objects.order_by('-username')# 降序

reverse() 反轉(zhuǎn)，前提已排序

ret = models.User.objects.order_by('username').reverse()# 默認升序
ret = models.User.objects.order_by('-username').reverse()# 降序

count() 當前查詢條件的記錄數(shù)

ret = models.User.objects.filter(pk=1).count()

exclude() 排除 ，相當于查詢條件不等于

ret = models.User.objects.exclude(pk=1)

exists() 記錄是否存在，不太實用，不過多講

4.2 雙下劃線查詢條件

django不支持 類似：>=,<=等查詢判斷方式，但提供了一套很好用的方法：

  • __gt <=> 大于:
  • ret = models.User.objects.filter(id__gt=1)#查詢id>1的記錄
  • __lt <=> 小于: ret = models.User.objects.filter(id__lt=1)#查詢id<1的記錄
  • __gte <=> 大于等于: ret = models.User.objects.filter(id__gte=1)#查詢id>=1的記錄
  • __lte <=> 小于等于: ret = models.User.objects.filter(id__lte=1)#查詢id<=1的記錄
  • __in <=> 條件是否歸屬所給的選擇: ret = models.User.objects.filter(id__in=[1,2])#查詢id=1或id=2的記錄
  • __range <=> 范圍: ret = models.User.objects.filter(id__range=[1,3])#查詢1<=id<=3的記錄
  • __contains <=> 模糊查詢 ,區(qū)分大小寫: ret = models.User.objects.filter(username__contains='a')#查詢 username like '%a%'的記錄
  • __icontains <=> 模糊查詢 ,不區(qū)分大小寫: ret = models.User.objects.filter(username__icontains='a')#查詢 username like '%a%'的記錄
  • __startswith <=> 模糊查詢 ,指定內(nèi)容開始: ret = models.User.objects.filter(username__icontains='a')#查詢 username like 'a%'的記錄
  • __endswith <=> 模糊查詢 ,指定內(nèi)容結(jié)束: ret = models.User.objects.filter(username__icontains='a')#查詢 username like '%a'的記錄

注意：__contains、__icontains、__startswith、__endswith這些模糊查詢性能很低，生產(chǎn)環(huán)境不建議使用。

4.3 邏輯查詢：or、and、not

涉及概念：Django的Q對象

4.3.1 Q對象

Q對象實例化后能夠增加各個條件之間的關(guān)系，而且這種寫法用在你不知道用戶到底傳入了多少個參數(shù)的時候很方便。

比如默認情況下filter()里面每個字段的連接都是&，我們使用Q對象通常都是讓它變成|，來進行查詢 。

from django.db.models import Q
query = Q()
q1 = Q()
q1.connector = "AND"  # 連接的條件是AND 代表就是& 
q1.children.append(("email", "280773872@qq.com")) # email代表的是數(shù)據(jù)庫的字段
q1.children.append(("password", "666"))
 # 等同于：email="280773872@qq.com" & password="666"
q2 = Q()
q2.connector = "AND"  # 同樣q2對象連接條件也是AND 
q2.children.append(("username", "fe_cow")) # 同樣數(shù)據(jù)庫里username字段
q2.children.append(("password", "fe_cow666"))
 # 等同于：username="fe_cow" & password="fe_cow666"
query.add(q1, "OR") 
query.add(q2, "OR")
 # query目前里面的符合條件結(jié)果就是: （email="280773872@qq.com" & password="666"） |  （username="fe_cow" & password="fe_cow666"）
userinfo_obj = models.UserInfo.objects.filter(query).first()

filter()過濾器的方法中關(guān)鍵字參數(shù)查詢，會合并為And(),需要進行or查詢，使用Q()對象，Q對象django.db.models.Q用于封裝一組關(guān)鍵字參數(shù)，這些關(guān)鍵字參數(shù)與比較運算符中的相同。

Q對象可以使用&(and)、|(or)操作符組合起來，當操作符應(yīng)用在兩個Q對象時，會產(chǎn)生一個新的Q對象。

list.filter(pk__lt=6).filter(bcomment__gt=10) 
list.filter(Q(pk__lt=6) | Q(bcomment__gt=10))
  • 使用~操作符在Q對象前表示取反: list.filter(~Q(pk__lt=6))
  • 可以使用&|~結(jié)合括號進行分組，構(gòu)造出復雜的Q對象

4.3.2 or、and、not

import os
import django
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'salary.settings')
django.setup(set_prefix=False)
from employee.models import Employees  # 這一行必須在`os.environ.setdefault`之后，先把配置、環(huán)境變量準備好后才能import
from django.db.models import Q
# emps = Employees.objects.all()  # 懶查詢，只有后面對查詢結(jié)構(gòu)有引用時，才會驅(qū)動真正的查詢
# print(emps)  # 查詢集
mgr = Employees.objects
# AND查詢： 五種方式
x = mgr.filter(pk__gt=10005, pk__lt=10010)
print(x)
y = mgr.filter(pk__gt=10005).filter(pk__lt=10010)
print(y)
z = mgr.filter(pk__gt=10005) & mgr.filter(pk__lt=10010)
print(z)
# Django的Q對象
xx = mgr.filter(Q(pk__gt=10005) & Q(pk__lt=10010))
yy = mgr.filter(Q(pk__gt=10005), Q(pk__lt=10010))
# OR查詢: 三種方式
x = mgr.filter(pk__in=[10005, 10010])
print(x)
y = mgr.filter(pk=10005) | mgr.filter(pk=10010)
print(y)
z = mgr.filter(Q(pk=10005) | Q(pk=10010))
# NOT查詢：
x = mgr.exclude(pk=10005)
print(x)
y = mgr.filter(~(Q(pk__gt=10005) & Q(pk__lt=10010)))
print(y)

4.3.3 集合查詢

# 聚合
from django.db.models import Max, Min, Count, Sum, Avg
x = mgr.filter(pk__gt=10008).count()  # 將所有數(shù)據(jù)看做一行出結(jié)構(gòu)
print(x)  # 單值
# aggregate聚合函數(shù)：出統(tǒng)計函數(shù)的結(jié)果，返回字典，默認key命名為`字段名_聚合函數(shù)名`
y = mgr.filter(pk__gt=10008).aggregate(Count("pk"), Max("pk"), Min("pk"), sm_pk=Sum('pk'), avg_pk=Avg('pk'))  # 可以給聚合查詢結(jié)果起別名
print(y)
# 結(jié)果：{'sm_pk': 120174, 'avg_pk': 10014.5, 'pk__count': 12, 'pk__max': 10020, 'pk__min': 10009}
# annotate聚合函數(shù)：這個聚合函數(shù)會分組，沒有指定分組使用pk分組，行行分組。返回結(jié)果集
z = mgr.filter(pk__gt=10013).annotate(Count("pk"), Max("pk"), Min("pk"), sm_pk=Sum('pk'), avg_pk=Avg('pk'))
print(z)
xx = mgr.filter(pk__gt=10013).values('gender').annotate(c=Count("pk")).values("c")  # 第一個values控制分組，第二個values控制投影
print(xx)

4.4 多表查詢

4.4.1 一對多查詢

  • Django不支持聯(lián)合主鍵，只支持單一主鍵，這一點和sqlalchemy不一樣
  • Django不支持在Model中聲明編碼格式，這一點和sqlalchemy不一樣，只能在setting.py的DATABASES注冊中添加選項
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'test',
        'USER': 'root',
        'PASSWORD': 'cli*963.',
        'HOST': '127.0.0.1',
        'PORT': '3306',
    },
    'OPTIONS': {
        'charset': 'utf8mb4',
    }
}

一對多模型構(gòu)造：
員工表 – 工資表是一對多的關(guān)系。由于django不支持聯(lián)合主鍵，需改造工資表。增加自增的id列，并設(shè)為主鍵，刪除其他主鍵和外鍵。

from django.db import models
# Create your models here.
class Employees(models.Model):
    """
    CREATE TABLE `employees` (
      `emp_no` int(11) NOT NULL,
      `birth_date` date NOT NULL,
      `first_name` varchar(14) NOT NULL,
      `last_name` varchar(16) NOT NULL,
      `gender` enum('M','F') NOT NULL,
      `hire_date` date NOT NULL,
      PRIMARY KEY (`emp_no`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci;
    """
    class Meta:  # 數(shù)據(jù)庫表名，固定的，Django就是這樣定義，一個Meta類
        db_table = "employees"  # 表名
    emp_no = models.IntegerField(primary_key=True, null=False)
    birth_date = models.DateField(null=False)
    first_name = models.CharField(max_length=14, null=False)
    last_name = models.CharField(null=False, max_length=16)
    gender = models.SmallIntegerField(null=False)
    hire_date = models.DateField(null=False)
    # 在多端添加了外鍵屬性后，主端的（Employees）類屬性字典__dict__中會自動增加一個默認名稱為Salaries_set的屬性。
    # 如果外鍵聲明的參數(shù)中使用了related_name=***，則這個屬性的名稱變?yōu)閞elated_name指定的值
    # 序列化
    filed = '__all__'
    depth = 1
    def __repr__(self):
        return "<Employee: {} {} {}>".format(self.emp_no, self.first_name, self.last_name)
    @property
    def full_name(self):
        return "full name:{}-{}".format(self.first_name, self.last_name)
    __str__ = __repr__
class Salaries(models.Model):
    """
    CREATE TABLE `salaries` (
      `emp_no` int(11) NOT NULL,
      `salary` int(11) NOT NULL,
      `from_date` date NOT NULL,
      `to_date` date NOT NULL,
      `id` int(11) NOT NULL AUTO_INCREMENT,
      PRIMARY KEY (`id`) USING BTREE,
      KEY `emp_no` (`emp_no`),
      CONSTRAINT `salaries_ibfk_1` FOREIGN KEY (`emp_no`) REFERENCES `employees` (`emp_no`) ON DELETE CASCADE
    ) ENGINE=InnoDB AUTO_INCREMENT=41 DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci;
    """
    class Meta:
        db_table = "salaries"
    # 一對多的多端，被引用的主表中的字段名emp_no，在多端(從表)的類屬性字典__dict__中保存的key值為emp_no_id，實際上對應(yīng)了主表emp_no在數(shù)據(jù)庫中的值。
    # 多端查詢這個被引用的外鍵值時，也是拿著emp_no_id去主表中查的，此時會報key emp_no_id不存在異常。這種情況只需在外鍵聲明的參數(shù)中使用db_column='emp_no'指定key值。
    emp_no = models.ForeignKey('Employees', models.CASCADE, db_column='emp_no')
    # emp_no = models.ForeignKey('Employees', models.CASCADE, db_column='emp_no', related_name="salaries")  # 使用related_name
    salary = models.IntegerField(null=False)
    from_date = models.DateField(null=False)
    to_date = models.DateField(null=False)
    id = models.AutoField(primary_key=True)  # 自增
    def __repr__(self):
        return "<Salaries: {} {}>".format(self.emp_no_id, self.salary)
    __str__ = __repr__

如上示例，在Salaries Model模型類中，創(chuàng)建ForeignKey外鍵。創(chuàng)建外鍵后:

  • 一對多的多端：多端這里就是Salaries定義的表。在這里，多端（從表）引用的主表的主鍵對應(yīng)的字段名為emp_no。
  • 多端Salaries的類屬性字典__dict__中會自動增加一個屬性，命名規(guī)則為被引用的字段名_id，這里就是emp_no_id，
  • 對應(yīng)主表在數(shù)據(jù)庫中emp_no字段的值。在多端查詢時，由于拿著emp_no_id去主表中查，而主表中的key為emp_no，
  • 導致報key emp_no_id不存在錯誤時，這種情況需在外鍵聲明中加上db_column="emp_no"就可以了，
  • 表示不要用Django自動命名的emp_no_id去查，而是用指定的key值去主表中查。
  • 一對多的一端：多端加了外鍵屬性后，主表類屬性字典__dict__中會自動增加salaries_set屬性，命名規(guī)則默認為多端表名_set。

如果在外鍵聲明中增加related_name="Salaries"參數(shù)，則這個自動增加的屬性名則使用related_name指定的值

所以：

  • 從一端向多端查，則使用instance.salaries_set
  • 從多端向一端查，則使用instance.emp_no_id
  • 在多端的__repr__中，為了提高效率不觸發(fā)主表查詢，也應(yīng)該用self.emp_no_id，而不是self.emp_no
print(*Employee.__dict__.items(), sep='\n')  
# 一端，Employees類中多了一個類屬性
#（'salaries_set', <django.db,models.fields.related_descriptors.ReverseManyTooneDescriptor object at 0x000001303FB09838>)
print(*salary._dict_,itemsO), sep='\n')
# 多端，Salaries類中也多了一個類屬性
#('emp_no_id'，<django.db.models.query_utils.DeferredAttribute object at 0x000001303F809828>)
#（'emp_no' <django.db.mode1s.fields.related_ descriptors. ForwardManyTo0neDescriptor object at 0x000001303FB09860>）指向Employees類的一個實例

查詢示例：

import os
import django
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'salary.settings')
django.setup(set_prefix=False)
from employee.models import Employees, Salaries  # 這一行必須在`os.environ.setdefault`之后，先把配置、環(huán)境變量準備好后才能import
print(Employees.__dict__.items())
print('_______________')
print(Salaries.__dict__.items())
print('______________')
emps = Employees.objects
sals = Salaries.objects
# 查詢10004號員工的工資
# 從員工表查詢，這個好，沒有冗余查詢
emp = emps.get(pk=10004)  # 一個Employees對象
print(emp.salaries_set.all())  # 返回一個查詢結(jié)果集
# 從工資表查詢，這個不好，多對一，產(chǎn)生了冗余查詢
sal = sals.filter(emp_no=10004).all()
print(sal)

distinct去重:

# 查詢工資大于5500的員工
_emps = sals.filter(salary__gt=5500).values('emp_no').distinct()
print(_emps)
print(emps.filter(emp_no__in=_emps))  # in子查詢
# print(emps.filter(emp_no__in=[x.get("emp_no") for x in _emps]))  # in列表

raw的使用：
對于非常復雜的sql語句，使用django ORM不好寫了，可以使用raw，直接執(zhí)行sql語句。 例如：

# 查詢工資大于50000的所有員工的姓名
sql = """
SELECT DISTINCT e.* from employees as e
JOIN salaries as s
ON e.emp_no = s.emp_no
WHERE salary > 50000
"""
emgr = Employees.objects  # 管理器
res = emgr.raw(sql)
print(list(res))

更多學習案例請參考資料：
https://juejin.cn/post/6974298891353063431

4.4.2 多對多查詢

多對多查詢有兩種建模方式：

借助第三張表。

例如一個員工可以在多個部門，一個部門有多個員工。這種多對多的關(guān)系，可以增加第三張表"部門-員工表"。這樣多對多模型轉(zhuǎn)換為"多-1-多"的模型：部門表 - 部門&員工表 - 員工表"。最后查詢轉(zhuǎn)為為一對多的查詢。

使用models.ManyToManyField，構(gòu)建多對多模型。

models.ManyToManyField會自動創(chuàng)建第三張表。models.ManyToManyField可以建在兩個模型類中的任意一個。

下面以第二種方式舉例。

多對多模型： 一篇文章可以被多個用戶關(guān)注，一個用戶也可以關(guān)注多篇文章,二者是多對多的關(guān)系
模型構(gòu)建：
定義兩張表：User表（用戶表），Artile表（文章表）。

import datetime
from django.db import models
from django.contrib.auth.models import AbstractUser
from django.contrib.auth.hashers import make_password #密碼加密
class Artile(models.Model):
    """
        title: 標題
        sub_title: 子標題
        content: 內(nèi)容
    """
    def __str__(self):
        return self.title
    title = models.CharField(max_length=250,default='',verbose_name='標題')
    sub_title = models.CharField(max_length=250,default='',verbose_name='子標題')
    content = models.CharField(max_length=2000,default='',blank=True,verbose_name='內(nèi)容')
    # 通過models.DateTimeField與User表建立多對多的關(guān)系,ManyToManyField可以建在兩個模型中的任意一個，自動創(chuàng)建第三張表
    users = models.ManyToManyField(to='User', )
    create_time = models.DateTimeField(default=datetime.datetime.now(),verbose_name='創(chuàng)建時間')
    create_name = models.CharField(max_length=20,verbose_name='創(chuàng)建人')
    update_time = models.DateTimeField(default=datetime.datetime.now(),blank=True,verbose_name='更新時間')
    update_name = models.CharField(max_length=20,verbose_name='更新人',blank=True,)
    is_delete = models.IntegerField(default=0,verbose_name='刪除狀態(tài)',blank=True,) # 邏輯刪除 0 正常 1:刪除
    class Meta:
        verbose_name = "文章"
        verbose_name_plural = verbose_name
        app_label = 'webApi'
class User(AbstractUser):
    """
        name: 昵稱
        account: 用戶名
        pwd: 密碼
        phone:手機號
        email:郵箱
        avator:頭像
        group_id:歸屬組
    """
    def __str__(self):
        return self.account
    name = models.CharField(max_length=20,default='',verbose_name='昵稱')
    phone = models.CharField(max_length=20,default='',blank=True,verbose_name='手機號')
    email = models.CharField(max_length=20,default='',blank=True,verbose_name='郵箱')
    avator = models.CharField(max_length=200,default='',blank=True,verbose_name='頭像')
    group_id = models.CharField(max_length=50,default='',blank=True,verbose_name='組')
    create_time = models.DateTimeField(default=datetime.datetime.now(),verbose_name='創(chuàng)建時間')
    create_name = models.CharField(max_length=20,verbose_name='創(chuàng)建人')
    update_time = models.DateTimeField(default=datetime.datetime.now(),blank=True,verbose_name='更新時間')
    update_name = models.CharField(max_length=20,verbose_name='更新人',blank=True,)
    is_delete = models.IntegerField(default=0,verbose_name='刪除狀態(tài)',blank=True,) # 邏輯刪除 0 正常 1:刪除
    # blank=True, 可選字段
    class Meta:
        verbose_name = "用戶"
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.username
    # 明文密碼轉(zhuǎn)加密
    def set_password(self, password):
        print('set_password %s' % (password))
        self.password = make_password(password,'jxy','pbkdf2_sha256')
    # 驗證密碼是否匹配
    def check_password(self, password):
        print('password: %s' % (password))
        print('check_password: %s' % (make_password(password,'jxy','pbkdf2_sha256')))
        print('self.password: %s' % (self.password))
        return self.password == make_password(password,'jxy','pbkdf2_sha256')

添加記錄：
向這張關(guān)系表中添加幾條關(guān)系。比如，我們將 Artile表主鍵為1的一條記錄，添加User表 主鍵為1，2兩條關(guān)系。

user1 = models.User.object.filter(pk=1).first()
user2 = models.User.object.filter(pk=2).first()
artile1 = models.Artile.object.filter(pk=1).first()
artile1.users.add(user1,user2)
# 方法二
userSet = models.User.object.filter(pk__in=[1,2]).all()
artile1.users.add(*userSet)

這樣便在關(guān)系表中創(chuàng)建了 Artile表主鍵為1的記錄與User表主鍵為1，2的兩條關(guān)系。
另外清除關(guān)系綁定用法類似，使用remove替代add:

artile1 = models.Artile.object.filter(pk=1).first()
userSet = models.User.object.filter(pk__in=[1,2]).all()
artile1.users.remove(*userSet) #解綁指定關(guān)系
artile1.users.clear() #清空所有關(guān)系

多對多查詢：

正向查詢，例如查詢Artile表第一條記錄有哪些用戶關(guān)注:

artile1 = models.Artile.object.filter(pk=1).first()
print(artile1.users.all().values('username')) # 打印關(guān)注Artile表第一條記錄的用戶名稱

逆向查詢，例如查詢User表第一條記錄關(guān)注過哪些Artile:

user1 = models.User.object.filter(pk=1).first()
print(user1.artile__set.all().values('title')) # 打印User表第一條記錄關(guān)注的文章名稱

總結(jié)

在開發(fā)中，一般都會采用ORM框架，這樣就可以使用對象操作表了。

Django中，定義表映射的類，繼承自Model類。Model類使用了元編程，改變了元類。使用Field實例作為類屬性來描述字段。使用ForeignKey來定義外鍵約束。

到此這篇關(guān)于Django ORM查詢的文章就介紹到這了,更多相關(guān)Django ORM查詢內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

相關(guān)文章

最新評論