django知识点总结

最新推荐文章于 2024-05-02 18:13:09 发布

BigC哥

最新推荐文章于 2024-05-02 18:13:09 发布

阅读量454

点赞数

分类专栏： django

本文链接：https://blog.csdn.net/weixin_43063753/article/details/88950914

版权

django 专栏收录该内容

31 篇文章 3 订阅

订阅专栏

一、django创建项目

CMD 终端：Django_admin startproject sitename(文件名)

通过类创建表   python manage.py makemigrations
                    python manage.py migrate

其他命令：
python manage.py runserver 0.0.0.0
python manage.py stratapp appname     # 创建APP
python manage.py suncdb
python manage.py createsuperuser         # 创建超级用户

二、创建数据库（ORM）

1. 数据库表的增

增:
在原来models.py文件中添加一个新的类（ORM---类就是表，对象是行）
在Terminal执行：--python manage.py makemigrations 
                       --python manage.py migrate 命令更新数据库

# 这是原来的表
class UserINfo(models.Model):
     nickname = models.CharField(max_length=32)
     username = models.CharField(max_length=32)
     password = models.CharField(max_length=32)
     gender_list=(
         (1,'男'),
         (2,'女'),
     )
     gender = models.IntegerField(choices=gender_list)
     m = models.ManyToManyField('UserINfo')
#-------------------------------------------------------------------------
# 这是新增的表
class User(models.Model):
     new_id=models.IntegerField(null=True)
     new_tabe= models.CharField(max_length=32)
     new_content =models.CharField(max_length=64)
     new_root = models.CharField(max_length=32)
     content = models.ForeignKey('User',null=True,blank=True,related_name='xxx')

增示例

2. 数据库表的删

删：
在原来创建表的py文件中把不要的表对应的类注释掉（ORM---类就是表，对象是行）
在Terminal执行：--python manage.py makemigrations
               --python manage.py migrate  命令更新数据库

#这是数据库的表
class GTB(models.Model):
     g = models.ForeignKey('Boy',null=True)
     b = models.ForeignKey('Grily',null=True)

# -------------------------------------------------------------
#这是删除数据库表
# class UserInfo(models.Model):
# nickname = models.CharField(max_length=32)
# username = models.CharField(max_length=32)
# password = models.CharField(max_length=32)
# gender_list=(
# (1,‘男’),
# (2,‘女’),
# )
# gender = models.IntegerField(choices=gender_list)

删示例

3. 数据库表的改

改：
在原来创建表的py文件中把要进行的表对应的类进行调整（ORM---类就是表，对象是行）

在Terminal执行：–python manage.py makemigrations
　　　　　　　　--python manage.py migrate 命令更新数据库

#这是数据库未进行修改的表
class Boy(models.Model):
     username = models.CharField(max_length=32)
     nickname = models.CharField(max_length=32)
     password = models.CharField(max_length=32)

#------------------------------------------------------------
#这是要进行更改数据的表
class Boy(models.Model):
username = models.CharField(max_length=32)
name = models.CharField(max_length=32)
password = models.CharField(max_length=32)

改示例

4. 数据库表中行的增

创建一个url对应的函数，通过浏览器访问这个url触发相对应的函数
在函数中设置数据库行的增加命令
在对表的行进行增加时，参数是创建表时的每列名称以及对应的参数值
models.Body.objects.create(username='波多爱军',password=123,sex=1)

def index(request):
    models.Body.objects.create(username='张三',password=123,sex=1)
    models.Body.objects.create(username='李四',password=123,sex=1)
    models.Body.objects.create(username='王五',password=123,sex=1)
    models.Body.objects.create(username='赵六',password=123,sex=1)

行增加示例

5. 数据库表中行的删

创建一个url对应的函数，通过浏览器访问这个url触发相对应的函数
在函数中设置数据库行的删除命令
在对表的行进行增加时，参数是创建表时的每列名称以及对应的参数值
models.Body.objects.delete（username='lucy'）

def index(request):
    models.Body.objects.delete(username='波多爱军',password=123,sex=1)

行删除示例

6. 数据库表中行的改

创建一个url对应的函数，通过浏览器访问这个url触发相对应的函数
在函数中设置数据库行的修改命令
在对表的行进行增加时，参数是创建表时的每列名称以及对应的参数值
models.Body.objects.filter(username='lucy').update(username='张三')

def index（request）：
    models.Body.objects.filter(username='张三',password=123,sex=1).update(username='张三',password=233,sex=2)

行修改示例

7. 数据库表中行的查

models.Body.objects.filter(username='lucy').all()

def gets(request):
#     models.UserInfo.objects.all()
#     # 查看全部行的数据

# models.UserInfo.objects.filter(id=2)
# #查看id等于2的哪行数据

# models.UserInfo.objects.first()
# #查看第一个数据

# models.UserInfo.objects.last()
# #查看最后一个数据

# models.UserInfo.objects.exclude(id=4)
# #查看id不等于4的所有内容

# models.UserInfo.objects.filter(name=‘lisi’).count()
# #获取名字等于lisi的总数

# models.UserInfo.objects.get(name=‘lisi’)
# #获取名字等于lisi的单个对象

# models.UserInfo.objects.filter(id_gt=1)
# #查看id大于1的行内容

# models.UserInfo.objects.filter(id_lt=2)
# #查看id小于2的行内容

# models.UserInfo.objects.filter(id_gte=1)
# #查看id大于等于1的行内容

# models.UserInfo.objects.filter(id_let=5)
# #查看id小于等于5的行内容

# models.UserInfo.objects.filter(id_lt=10,id_gt=1)
# #查看id大于1且id小于10的行内容

# models.UserInfo.objects.filter(id__in=[11,33,44])
# #查看id在不在列表中

# models.UserInfo.objects.exclude(id_in=[11,33,44])
# #查看id不在列表中的的数据内容

# models.UserInfo.objects.filter(pud_date__isnull=True)
# #查看pud_date不是为空

# models.UserInfo.objects.filter(name__contains=‘lisi’)
# #查看名字中列中包含lisi的数据内容

# models.UserInfo.objects.exclude(name__icontains=‘lisi’)
# #查看名字中列中包含lisi（大小写不敏感）的数据内容

# models.UserInfo.objects.filter(ut_id__range=[1,5])
# #范围（bettwen end）

# models.UserInfo.objects.filter(name__startswith=‘lisi’)
# #查看名字以lisi开头的数据行

# models.UserInfo.objects.filter(name__istartswith=‘lisi’)
# #查看名字以lisi开头（大小写不敏感）的数据行

# models.UserInfo.objects.filter(name__endswith=‘lisi’)
# #查看名字以lisi结尾的数据行

# models.UserInfo.objects.filter(name__iendswith=‘lisi’)
# #查看名字以lisi（大小写不敏感）的数据行

# models.UserInfo.objects.all().order_by(’-id’)
# #以降序进行排列查看

# models.UserInfo.objects.all().order_by(‘id’)
# #以升序进行排列查看（默认使用升序）

# models.UserInfo.objects.all()[1:4]
# #分页limit offset 起始位置和结束位置

行查看示例

三、路由系统

1、单一路由对应

url(r'^index$', views.index),

2、基于正则的路由

url(r'^index/(\d*)', views.index),
url(r'^manage/(?P<name>\w*)/(?P<id>\d*)', views.manage),

3、添加额外的参数

url(r'^manage/(?P<name>\w*)', views.manage,{'id':333}),

4、为路由映射设置名称

url(r'^home', views.home, name='h1'),
url(r'^index/(\d*)', views.index, name='h2'),

设置名称之后，可以在不同的地方调用，如：

模板中使用生成URL {% url ‘h2’ 2012 %}
函数中使用生成URL reverse(‘h2’, args=(2012,)) 路径:django.urls.reverse
Model中使用获取URL 自定义get_absolute_url() 方法

class NewType(models.Model):
     caption = models.CharField(max_length=16)
</span><span style="color: #0000ff;">def</span><span style="color: #000000;"> get_absolute_url(self):
     </span><span style="color: #800000;">"""</span><span style="color: #800000;">
     为每个对象生成一个URL
    应用：在对象列表中生成查看详细的URL，使用此方法即可！！！
     :return:
     </span><span style="color: #800000;">"""</span>
     <span style="color: #008000;">#</span><span style="color: #008000;"> return '/%s/%s' % (self._meta.db_table, self.id)</span>
     <span style="color: #008000;">#</span><span style="color: #008000;"> 或</span>
     <span style="color: #0000ff;">from</span> django.urls <span style="color: #0000ff;">import</span><span style="color: #000000;"> reverse
     </span><span style="color: #0000ff;">return</span> reverse(<span style="color: #800000;">'</span><span style="color: #800000;">NewType.Detail</span><span style="color: #800000;">'</span>, kwargs={<span style="color: #800000;">'</span><span style="color: #800000;">nid</span><span style="color: #800000;">'</span>: self.id})</pre>

View Code

获取请求匹配成功的URL信息：request.resolver_match

5、根据app对路由规则进行分类

url(r'^web/',include('web.urls')),

6、命名空间

a. project.urls.py

from django.conf.urls import url,include

urlpatterns = [
url(r’^a/’, include(‘app01.urls’, namespace=‘author-polls’)),
url(r’^b/’, include(‘app01.urls’, namespace=‘publisher-polls’)),
]

b. app01.urls.py

from django.conf.urls import url
from app01 import views

app_name = ‘app01’
urlpatterns = [
url(r’^(?P<pk>\d+)/$’, views.detail, name=‘detail’)
]

c. app01.views.py

def detail(request, pk):
    print(request.resolver_match)
    return HttpResponse(pk)

以上定义带命名空间的url之后，使用name生成URL时候，应该如下：

v = reverse(‘app01:detail’, kwargs={‘pk’:11})
{% url ‘app01:detail’ pk=12 pp=99 %}
django中的路由系统和其他语言的框架有所不同，在django中每一个请求的url都要有一条路由映射，这样才能将请求交给对一个的view中的函数去处理。其他大部分的Web框架则是对一类的url请求做一条路由映射，从而是路由系统变得简洁。

四、模板

1、模板的执行

模版的创建过程，对于模版，其实就是读取模版（其中嵌套着模版标签），然后将 Model 中获取的数据插入到模版中，最后将信息返回给用户。

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

from django import template
t = template.Template('My name is {{ name }}.')
c = template.Context({'name': 'Adrian'})
print t.render(c)

import datetime
from django import template
import DjangoDemo.settings

now = datetime.datetime.now()
fp = open(settings.BASE_DIR+’/templates/Home/Index.html’)
t = template.Template(fp.read())
fp.close()
html = t.render(template.Context({‘current_date’: now}))
return HttpResponse(html）

from django.template.loader import get_template
from django.template import Context
from django.http import HttpResponse
import datetime

def current_datetime(request):
now = datetime.datetime.now()
t = get_template(‘current_datetime.html’)
html = t.render(Context({‘current_date’: now}))
return HttpResponse(html)

return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))

2、模板语言

模板中也有自己的语言，该语言可以实现数据展示

{% for item in item_list %} <a>{{ item }}</a> {% endfor %}
　　forloop.counter
　　forloop.first
　　forloop.last

{% if ordered_warranty %} {% else %} {% endif %}

母板：{% block title %}{% endblock %}
子板：{% extends "base.html" %}
　　　{% block title %}{% endblock %}

帮助方法：
{{ item.event_start|date:"Y-m-d H:i:s"}}
{{ bio|truncatewords:"30" }}
{{ my_list|first|upper }}
{{ name|lower }}

3、自定义simple_tag

a、在app中创建templatetags模块

b、创建任意 .py 文件，如：xx.py

#!/usr/bin/env python
#coding:utf-8
from django import template
from django.utils.safestring import mark_safe

@register.simple_tag
def my_simple_time(v1,v2,v3):
return v1 + v2 + v3

@register.simple_tag
def my_input(id,arg):
result = “<input type=‘text’ id=’%s’ class=’%s’ />” %(id,arg,)
return mark_safe(result)

c、在使用自定义simple_tag的html文件中导入之前创建的 xx.py 文件名

{% load xx %}

d、使用simple_tag

{% my_simple_time 1 2 3%}
{% my_input 'id_username' 'hide'%}

e、在settings中配置当前app，不然django无法找到自定义的simple_tag

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01',
)

View Code

五、F

from django.db.models import F

models.UserInfo.objects.all().update(age=F('age')+1)

六、Q

====Q用于构造复杂查询条件====
# Q(nid__gt=10)
# #创建一个Q
# Q(nid=8) | Q(nid__gt=10)
# #俩个Q是或的关系
# Q(nid=8) & Q(nid__gt=10)
# #俩个Q是与的关系
# Q(nid=8) | Q(nid__gt=10) & Q(nid=7)
# #Q8 和 Q7 或 Q10 和 Q7的关系

#方法一：
# Q(nid__gt=10)
# #创建一个Q
# Q(nid=8) | Q(nid__gt=10)
# #俩个Q是或的关系
# Q(nid=8) & Q(nid__gt=10)
# #俩个Q是与的关系
# Q(nid=8) | Q(nid__gt=10) & Q(nid=7)
# #Q8 和 Q7 或 Q10 和 Q7的关系

#方法二：
# from django.db.models import Q
# q1=Q()
# q1.connector=‘OR’
# q1.children.append((‘id_gt’,1))
# q1.children.append((‘id’,10))
# q1.children.append((‘id’,9))

# q2=Q()
# q2.connector=‘OR’
# q2.children.append((‘c1’,2))
# q2.children.append((‘c1’,10))
# q2.children.append((‘c1’,9))

# q3=Q()
# q3.connector=‘AND’
# q3.children.append((‘id’,1))
# q3.children.append((‘id’,2))
# q2.add(q3,‘OR’)

# con=Q()
# con.add(q1,‘AND’)
# con.add(q2,‘AND’)

# models.UserInfo.objects.filter(con)

Q演示

七、extra

======================extra是一种扩展方式========================
models.UserInfo.objects.extra(where=['headline=%s'],params=[1,])<br><br>

def extra(self,select=None,where=None,params=None,tables=None,order_by=None,select_params=None)
    where ---------params
    select ----------select_params

# def gets(request):
#     models.UserInfo.objects.extra(where=['headline=%s'],params=[1,])
#     #where 和 params 配合使用
#     models.UserInfo.objects.extra(where=["foo='a' OR bar='a',baz='a"])
#     #查询条件是foo和baz等于a   或者bar和baz等a
 #     models.UserInfo.objects.extra(select={'new_id':"select id from tb where id>%s"},select_params=(1,),order_by=['-nid'])
#     #查询id大于1并以降序排列

extra 演示

八、连表

1、对象连表

# models.UserInfo.objects.all()
#查看UserIinfo表的所有行
# models.UserInfo.objects.filter(id=2)
##查看UserInfo表id等于2的哪一行内容
# result = models.UserInfo.objects.all()
##通过此方式返回一个列表中存放的是对象（object）
# for row in result:
#     print(row.name,row.id,row.age,row.ut.title)
##以是对象的方式进行连表

2、字典连表

# models.UserInfo.objects.all()
## 查看表的所有行
# models.UserInfo.objects.filter(id=1)
##查看表的id是1的行
# result=models.UserInfo.objects.all().values('id','name','ut__title')
##通过此方式连表返回个列表，列表中存放的是字典对象（dict）
# for row in result:
#     print(row)

3、元组连表

# models.UserInfo.objects.all()
## 查看表的所有行
# models.UserInfo.objects.filter(id=2)
##查看表的id是2的行
# result=models.UserInfo.objects.all().values_list('id','name','ut__title')
##通过此方式连表返回个列表，列表中存放的是元组对象（tuple）
# for row in result:
#     print(row)

九、正反向查找

result = models.UserInfo.objects.all()
    for obj in result:
          print(obj.name,obj.age,obj.ut_id,obj.ut.title)
        #打印obj对象的名字，对象的年龄，对象的外键，ut设置外键的列就是相当于ut表对应的主键（现在拿到就是ut那个表可以拿ut对应的一行所有内容）
     result = models.UserInfo.objects.all().first()
      ##获取表中所有的行但只是拿第一个对象，也就是第一行
      print(result.name,result.age,result.ut)

对象正向查找

# obj = models.UserType.objects.all().last()
# print('用户类型',obj)
# for row in obj.userinfo_set.all():
#     print(row.name,row.age)

对象反向查找

# models.UserInfo.objects.filter(id__gt=7).delete()
#v=models.UserInfo.objects.all().values('name','age','ut__title')
# print(v)

字典正向查找

# vv = models.UserType.objects.values('title','userinfo__name')
# print(vv)

字典反向查找

# v3 = models.UserInfo.objects.all().values_list('name','age','ut__title')
# print(v3)

元组正向查找

# v4 = models.UserType.objects.all().values_list('title','userinfo__name')
# print(v4)

元组反向查找

十、排序

# user_list = models.UserInfo.objects.all().order_by('-id')
# ##排序默认的升序，order_by（'-id'）是降序
# for i in user_list:
#     print(i.name,i.id)
# return HttpResponse('....')

ss =models.UserInfo.objects.all().order_by('-id','age').reverse()
print(ss.query)
'''
 SELECT "appo1_userinfo"."id", "appo1_userinfo"."name", "appo1_userinfo"."age", "appo1_userinfo"."ut_id" FROM "appo1_userinfo" ORDER BY "appo1_userinfo"."id" ASC, "appo1_userinfo"."age" DESC

‘’’

# 将设置的排序方式进行反转，本来id是降序，age是升序，反转后id 是升序，age是降序

排序演示

十一、annotate(组合)

def annotate(self,*args,**kwargs):
    #用于实现聚合group by查询
    from django.db.models import Count,Avg,Max,Min,Sum
     v = models.UserInfo.objects.values('ut_id').annotate(wsa=Count('ut_id'))
    print(v.query)
'''
SELECT "appo1_userinfo"."ut_id", COUNT("appo1_userinfo"."ut_id") AS "uid" FROM "appo1_userinfo" GROUP BY "appo1_userinfo"."ut_id"

‘’’

十二、转化成sql语句

v = models.UserInfo.objects.values('ut_id').annotate(wws=Count('ut_id')).filter(ut_id__gt=2)
 print(v.query)
<br>SELECT "appo1_userinfo"."ut_id", COUNT("appo1_userinfo"."ut_id") AS "wws" FROM "appo1_userinfo" WHERE "appo1_userinfo"."ut_id" > 2 GROUP BY "appo1_userinfo"."ut_id"

十三、去重

v= models.UserInfo.objects.values('ut_id').distinct()
#进行去重
 print(v.query)

‘’’
SELECT DISTINCT “appo1_userinfo”.“ut_id” FROM “appo1_userinfo”
‘’’

#注:只有在PostgresSQL中才能使用distinct进行去重
#如果是PostgresSQL
# models.UserInfo.objects.distinct(‘nid’)

十四、排除某列数据

# ss=models.UserInfo.objects.defer('age','ut_id')
# #映射中排除某列数据
# for i in ss:
#     print(i.id)

十五、仅获取某列数据

# sss=models.UserInfo.objects.all().only('age')
#仅取某列数据
# for i in sss:
#     print(i.age)

十六、指定使用某数据库

models.UserInfo.objects.using('dbx')
指定使用的数据库，参数为存放数据中的数据库名
ss=models.UserInfo.objects.raw('select * from appo1_userinfo')
print(ss)

十七、其它相关操作

1  models.UserInfo.objects.dates('ctime','day','DESC')
 2 根据时间进行某一部分进行去查找并截取指定内容 (参数 表行   时间格式  排方式)
 3 kind  只能是 year（年） month（年-月）day（年-月-日）
 4 order 只能是 ASC DESC   (排序方式)
 5 并获取转换后的时间
 6  year   年 01 01
 7 month  年 月 01
 8  day    年 月 日
 9 models.UserInfo.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
10 128     #根据时间进行某一部分查找并截取指定内容，将时间转换为指定时区时间
11 kind只能是 year month day hour minute second
12 order只能是 ASC DESC  排序方式
13 tzinfo 时区对象
14 models.UserInfo.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))
15 ’''
16  安装 pythz pip3 install pytz
17  import pytz
18  pytz.all_timezones
19 pytz.timezone('Asia/Shanghai')
20  '''
21 def none(self):
22     #空QuesySet
23      pass
24  ss=models.UserInfo.objects.aggregate(k=Count('ut_id',distinct=True),n=Count('id'))
25 {'k': 3, 'n': 7}
26  print(ss)
27  ogj=[
28      models.UserInfo(name='alex'),
29      models.UserInfo(name='egon')
30 
31  ]
32  models.UserInfo.objects.bulk_create(ogj,10)
33 批量插入数据 10代表没次插入数量
34  obj,creted = models.UserInfo.objects.get_or_create(username='roo1',defaults={'email':'11111','u_id':2,'tid':3})
35 先查看如果存在就不执行创建的操作，如果不存在就会创建后边的数据
36  obj,creted = models.UserInfo.objects.update_or_create(username='roo1',defaults={'email':'11111','u_id':2,'tid':3})
37 先查如果存在就不执行更新，如果不存在就会创建后边的数据
38  id=[11,222,333]
39  models.UserInfo.objects.in_bulk(id)
40 根据主键ID进行查找
41  ss = models.UserInfo.objects.exists()
42 #查看是否有结果
43  print(ss)
44 return HttpResponse('....')

View Code

十八、cookie

request.COOKIES['key']
request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
    参数：
        default: 默认值
           salt: 加密盐
        max_age: 后台控制过期时间

1、获取Cookie：

rep = HttpResponse(...) 或 rep ＝ render(request, ...)

rep.set_cookie(key,value,…)
rep.set_signed_cookie(key,value,salt=‘加密盐’,…)
参数：
key, 键
value=’’, 值
max_age=None, 超时时间
expires=None, 超时时间(IE requires expires, so set it if hasn’t been already.)
path=’/’, Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie可以被任何url的页面访问
domain=None, Cookie生效的域名
secure=False, https传输
httponly=False 只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）

2、设置Cookie：

3、由于cookie保存在客户端的电脑上，所以，JavaScript和jquery也可以操作cookie。

<script src='/static/js/jquery.cookie.js'></script>
$.cookie("list_pager_num", 30,{ path: '/' });

十九、xss（跨站脚本攻击）

xss 攻击：是通过用户的信任来进行注释，比如在评论里写一堆HTML标签，成功提交后会保存数据库中或者本地文件中，当别的用户在点开查看的时候，之前用户填写的评论也会通过字符串发送到浏览器，如果在html页面上设置【|safe】那么你就成功的被注释了

他可以获取你的相关信息，如果你在html页面中设置了safe 在HTML也是可及进行关键词判断，防止被注释！（Django本身就进行了XSS攻击防范的）

二十、自关联

class UserInfo(models.Model):
    nickname = models.CharField(max_length=32)
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)
    gender_list=(
        (1,'男'),
        (2,'女'),
    )
    gender = models.IntegerField(choices=gender_list)

class UtU(models.Model):
g=models.ForeignKey(‘UserInfo’,null=True,related_name=‘boy’)
b=models.ForeignKey(‘UserInfo’,null=True,related_name=‘grily’)

重点在于related_name 这样就相当于给他们设置了别名，数据库就不会分不清谁是谁的关联

def indexss(request):
     tt=models.UserINfo.objects.filter(id=2).first()
     xx = tt.userinfo_set.all()
     ## 反向查看关系自关联的表
     for i in xx:
         print(i.nickname)
     return HttpResponse('ok')

正向查看自关联的信息

class UserINfo(models.Model):
    nickname = models.CharField(max_length=32)
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)
    gender_list=(
        (1,'男'),
        (2,'女'),
    )
    gender = models.IntegerField(choices=gender_list)
    m = models.ManyToManyField('UserINfo')

通过ManyToManyField自动创建一个自关联的关系表

def indexsz(request):
     tt = models.UserINfo.objects.filter(id=2).first()
     # 正向查看自关联表的内容
     xx =tt.m.all()
     # 获取到和UserINfo相关的UserINfo对象
     for i in xx:
         print(i.nickname)
     return HttpResponse('ok')

正向查看ManyToManyField自关联的信息

def indexs(request):
     tt =models.UserINfo.objects.filter(id=2).first()
     ss=tt.userinfo_set.all()
     print(ss)
     for i in ss:
         print(i.nickname)

反向查看ManyToManyField自关联的信息

二十一、外键关联

外键关联就是表（本身）设置一个外键，这个外键要关联的列是这个表（本身）的自增id

class User(models.Model):
    new_id=models.IntegerField(null=True)
    new_tabe= models.CharField(max_length=32)
    new_content =models.CharField(max_length=64)
    new_root = models.CharField(max_length=32)
    content = models.ForeignKey('User',null=True,blank=True,related_name='xxx')

def indexss(request):
     xx =models.User.objects.filter(id=1).first()
     xs =models.User.objects.filter(id=2).first()
     tt =xx.xxx.all()
     ts =xs.xxx.all()
     for i in tt:
         print(i.new_content)
     for i in ts:
         print(i.new_content)
     return HttpResponse('ok')

外键关联正向查看

BigC哥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
django知识点总结

一、django创建项目CMD 终端：Django_admin startproject sitename(文件名)通过类创建表 python manage.py makemigrations python manage.py migrate其他命令：python manage.py runserver 0.0.0.0pyth...
复制链接

扫一扫

专栏目录