python Django知識點總結
python Django知識點總結
1、Django建立項目：
CMD 終端：Django_admin startproject sitename(文件名)
其餘經常使用命令：javascript
其餘經常使用命令： 經過類建立表--python manage.py makemigrations --python manage.py migrate 其餘命令： python manage.py runserver 0.0.0.0 python manage.py stratapp appname python manage.py suncdb python manage.py createsuperuser
2、建立數據庫（ORM）
a.數據庫表的增
增: 在原來models.py文件中添加一個新的類（ORM---類就是表，對象是行） 在Terminal執行：--python manage.py makemigrations --python manage.py migrate 命令更新數據庫
1 這是原來的表 2 class UserINfo(models.Model): 3 nickname = models.CharField(max_length=32) 4 username = models.CharField(max_length=32) 5 password = models.CharField(max_length=32) 6 gender_list=( 7 (1,'男'), 8 (2,'女'), 9 ) 10 gender = models.IntegerField(choices=gender_list) 11 m = models.ManyToManyField('UserINfo') 12 ------------------------------------------------------------------------- 13 這是新增的表 14 class User(models.Model): 15 new_id=models.IntegerField(null=True) 16 new_tabe= models.CharField(max_length=32) 17 new_content =models.CharField(max_length=64) 18 new_root = models.CharField(max_length=32) 19 content = models.ForeignKey('User',null=True,blank=True,related_name='xxx')
b.數據庫表的刪
刪： 在原來建立表的py文件中把不要的表對應的類註釋掉（ORM---類就是表，對象是行） 在Terminal執行：--python manage.py makemigrations --python manage.py migrate 命令更新數據庫
1 這是數據庫的表 2 class GTB(models.Model): 3 g = models.ForeignKey('Boy',null=True) 4 b = models.ForeignKey('Grily',null=True) 5 6 ------------------------------------------------------------- 7 這是刪除數據庫表 8 # class UserInfo(models.Model): 9 # nickname = models.CharField(max_length=32) 10 # username = models.CharField(max_length=32) 11 # password = models.CharField(max_length=32) 12 # gender_list=( 13 # (1,'男'), 14 # (2,'女'), 15 # ) 16 # gender = models.IntegerField(choices=gender_list)
c.數據庫表的改
改： 在原來建立表的py文件中把要進行的表對應的類進行調整（ORM---類就是表，對象是行）
在Terminal執行：--python manage.py makemigrations --python manage.py migrate 命令更新數據庫
1 這是數據庫未進行修改的表 2 class Boy(models.Model): 3 username = models.CharField(max_length=32) 4 nickname = models.CharField(max_length=32) 5 password = models.CharField(max_length=32) 6 7 8 ------------------------------------------------------------ 9 這是要進行更改數據的表 10 class Boy(models.Model): 11 username = models.CharField(max_length=32) 12 name = models.CharField(max_length=32) 13 password = models.CharField(max_length=32)
d.數據庫錶行的增
建立一個url對應的函數，經過瀏覽器訪問這個url觸發相對應的函數 在函數中設置數據庫行的增長命令 在對錶的行進行增長時，參數是建立表時的每列名稱以及對應的參數值 models.Body.objects.create(username='波多愛軍',password=123,sex=1)
1 def index(request): 2 models.Body.objects.create(username='波多愛軍',password=123,sex=1) 3 models.Body.objects.create(username='蒼愛軍',password=123,sex=1) 4 models.Body.objects.create(username='吉澤愛軍',password=123,sex=1) 5 models.Body.objects.create(username='田原愛軍',password=123,sex=1)
e.數據庫錶行的刪
建立一個url對應的函數，經過瀏覽器訪問這個url觸發相對應的函數 在函數中設置數據庫行的刪除命令 在對錶的行進行增長時，參數是建立表時的每列名稱以及對應的參數值 models.Body.objects.delete（username=‘alex’）
1 def index(request): 2 models.Body.objects.delete(username='波多愛軍',password=123,sex=1)
f.數據庫錶行的改
建立一個url對應的函數，經過瀏覽器訪問這個url觸發相對應的函數 在函數中設置數據庫行的修改命令 在對錶的行進行增長時，參數是建立表時的每列名稱以及對應的參數值 models.Body.objects.filter(username='alex).update(username='波多愛軍')
1 def index（request）： 2 models.Body.objects.filter(username='波多愛軍',password=123,sex=1).update(username='波多愛軍',password=233,sex=2)
g.數據庫錶行的查
models.Body.objects.filter(username='alex).all()
1 def gets(request): 2 # models.UserInfo.objects.all() 3 # # 查看所有行的數據 4 5 # models.UserInfo.objects.filter(id=2) 6 # #查看id等於2的哪行數據 7 8 # models.UserInfo.objects.first() 9 # #查看第一個數據 10 11 # models.UserInfo.objects.last() 12 # #查看最後一個數據 13 14 # models.UserInfo.objects.exclude(id=4) 15 # #查看id不等於4的全部內容 16 17 # models.UserInfo.objects.filter(name='seven').count() 18 # #獲取名字等於seven的總數 19 20 # models.UserInfo.objects.get(name='seven') 21 # #獲取名字等於seven的單個對象 22 23 # models.UserInfo.objects.filter(id_gt=1) 24 # #查看id大於1的行內容 25 26 # models.UserInfo.objects.filter(id_lt=2) 27 # #查看id小於2的行內容 28 29 # models.UserInfo.objects.filter(id_gte=1) 30 # #查看id大於等於1的行內容 31 32 # models.UserInfo.objects.filter(id_let=5) 33 # #查看id小於等於5的行內容 34 35 # models.UserInfo.objects.filter(id_lt=10,id_gt=1) 36 # #查看id大於1且id小於10的行內容 37 38 # models.UserInfo.objects.filter(id__in=[11,33,44]) 39 # #查看id在不在列表中 40 41 # models.UserInfo.objects.exclude(id_in=[11,33,44]) 42 # #查看id不在列表中的的數據內容 43 44 # models.UserInfo.objects.filter(pud_date__isnull=True) 45 # #查看pud_date不是爲空 46 47 # models.UserInfo.objects.filter(name__contains='alex') 48 # #查看名字中列中包含alex的數據內容 49 50 # models.UserInfo.objects.exclude(name__icontains='alex') 51 # #查看名字中列中包含alex（大小寫不敏感）的數據內容 52 53 # models.UserInfo.objects.filter(ut_id__range=[1,5]) 54 # #範圍（bettwen end） 55 56 # models.UserInfo.objects.filter(name__startswith='alex') 57 # #查看名字以alex開頭的數據行 58 59 # models.UserInfo.objects.filter(name__istartswith='alex') 60 # #查看名字以alex開頭（大小寫不敏感）的數據行 61 62 # models.UserInfo.objects.filter(name__endswith='egon') 63 # #查看名字以egon結尾的數據行 64 65 # models.UserInfo.objects.filter(name__iendswith='egon') 66 # #查看名字以egon（大小寫不敏感）的數據行 67 68 # models.UserInfo.objects.all().order_by('-id') 69 # #以降序進行排列查看 70 71 # models.UserInfo.objects.all().order_by('id') 72 # #以升序進行排列查看（默認使用升序） 73 74 # models.UserInfo.objects.all()[1:4] 75 # #分頁limit offset 起始位置和結束位置
3、路由系統
一、單一路由對應html
|
1
|
url(r
'^index$'
, views.index),
|
二、基於正則的路由java
|
1
2
|
url(r
'^index/(\d*)'
, views.index),
url(r
'^manage/(?P<name>\w*)/(?P<id>\d*)'
, views.manage),
|
三、添加額外的參數python
|
1
|
url(r
'^manage/(?P<name>\w*)'
, views.manage,{
'id'
:
333
}),
|
四、爲路由映射設置名稱jquery
|
1
2
|
url(r
'^home'
, views.home, name
=
'h1'
),
url(r
'^index/(\d*)'
, views.index, name
=
'h2'
),
|
設置名稱以後，能夠在不一樣的地方調用，如：web
- 模板中使用生成URL {% url 'h2' 2012 %}
- 函數中使用生成URL reverse('h2', args=(2012,)) 路徑:django.urls.reverse
- Model中使用獲取URL 自定義get_absolute_url() 方法
1 class NewType(models.Model): 2 caption = models.CharField(max_length=16) 3 4 5 def get_absolute_url(self): 6 """ 7 爲每一個對象生成一個URL 8 應用：在對象列表中生成查看詳細的URL，使用此方法便可！！！ 9 :return: 10 """ 11 # return '/%s/%s' % (self._meta.db_table, self.id) 12 # 或 13 from django.urls import reverse 14 return reverse('NewType.Detail', kwargs={'nid': self.id})
獲取請求匹配成功的URL信息：request.resolver_matchajax
五、根據app對路由規則進行分類sql
|
1
|
url(r
'^web/'
,include(
'web.urls'
)),
|
六、命名空間數據庫
a. project.urls.pydjango
|
1
2
3
4
5
6
|
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
|
1
2
3
4
5
6
7
|
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
|
1
2
3
|
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請求作一條路由映射，從而是路由系統變得簡潔。
經過反射機制，爲django開發一套動態的路由系統Demo： 點擊下載
4、模板
一、模版的執行
模版的建立過程，對於模版，其實就是讀取模版（其中嵌套着模版標籤），而後將 Model 中獲取的數據插入到模版中，最後將信息返回給用戶。
1 def current_datetime(request): 2 now = datetime.datetime.now() 3 html = "<html><body>It is now %s.</body></html>" % now 4 return HttpResponse(html)
1 from django import template 2 t = template.Template('My name is {{ name }}.') 3 c = template.Context({'name': 'Adrian'}) 4 print t.render(c)
1 import datetime 2 from django import template 3 import DjangoDemo.settings 4 5 now = datetime.datetime.now() 6 fp = open(settings.BASE_DIR+'/templates/Home/Index.html') 7 t = template.Template(fp.read()) 8 fp.close() 9 html = t.render(template.Context({'current_date': now})) 10 return HttpResponse(html
1 from django.template.loader import get_template 2 from django.template import Context 3 from django.http import HttpResponse 4 import datetime 5 6 def current_datetime(request): 7 now = datetime.datetime.now() 8 t = get_template('current_datetime.html') 9 html = t.render(Context({'current_date': now})) 10 return HttpResponse(html)
1 return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))
二、模版語言
模板中也有本身的語言，該語言能夠實現數據展現
- {{ item }}
- {% 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 }}
三、自定義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 = template.Library()
@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 文件名
|
1
|
{
%
load xx
%
}
|
d、使用simple_tag
|
1
2
|
{
%
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',
)
5、F
====F更新時對比以前的內容(在原來的值中更新)====
models.UserInfo.objects.all().update(age=F('age')+1)
1 # from django.db.models import F 2 # models.UserInfo.objects.all().update(age=F('age')+1)
6、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的關係
1 #方法一： 2 # Q(nid__gt=10) 3 # #建立一個Q 4 # Q(nid=8) | Q(nid__gt=10) 5 # #倆個Q是或的關係 6 # Q(nid=8) & Q(nid__gt=10) 7 # #倆個Q是與的關係 8 # Q(nid=8) | Q(nid__gt=10) & Q(nid=7) 9 # #Q8 和 Q7 或 Q10 和 Q7的關係 10 11 #方法二： 12 # from django.db.models import Q 13 # q1=Q() 14 # q1.connector='OR' 15 # q1.children.append(('id_gt',1)) 16 # q1.children.append(('id',10)) 17 # q1.children.append(('id',9)) 18 # 19 # q2=Q() 20 # q2.connector='OR' 21 # q2.children.append(('c1',2)) 22 # q2.children.append(('c1',10)) 23 # q2.children.append(('c1',9)) 24 # 25 # q3=Q() 26 # q3.connector='AND' 27 # q3.children.append(('id',1)) 28 # q3.children.append(('id',2)) 29 # q2.add(q3,'OR') 30 # 31 # con=Q() 32 # con.add(q1,'AND') 33 # con.add(q2,'AND') 34 # 35 # models.UserInfo.objects.filter(con)
7、extra
======================extra是一種擴展方式======================== models.UserInfo.objects.extra(where=['headline=%s'],params=[1,])
def extra(self,select=None,where=None,params=None,tables=None,order_by=None,select_params=None)
where ---------params
select ----------select_params
1 1 # def gets(request): 2 2 # models.UserInfo.objects.extra(where=['headline=%s'],params=[1,]) 3 3 # #where 和 params 配合使用 4 4 # models.UserInfo.objects.extra(where=["foo='a' OR bar='a',baz='a"]) 5 5 # #查詢條件是foo和baz等於a 或者bar和baz等a 6 6 # models.UserInfo.objects.extra(select={'new_id':"select id from tb where id>%s"},select_params=(1,),order_by=['-nid']) 7 7 # #查詢id大於1並以降序排列
8、連表
a.對象連表
1 # models.UserInfo.objects.all() 2 #查看UserIinfo表的全部行 3 # models.UserInfo.objects.filter(id=2) 4 ##查看UserInfo表id等於2的哪一行內容 5 # result = models.UserInfo.objects.all() 6 ##經過此方式返回一個列表中存放的是對象（object） 7 # for row in result: 8 # print(row.name,row.id,row.age,row.ut.title) 9 ##以是對象的方式進行連表
b.字典連表
1 # models.UserInfo.objects.all()
2 ## 查看錶的全部行
3 # models.UserInfo.objects.filter(id=1)
4 ##查看錶的id是1的行
5 # result=models.UserInfo.objects.all().values('id','name','ut__title')
6 ##經過此方式連表返回個列表，列表中存放的是字典對象（dict）
7 # for row in result:
8 # print(row)
c.元組連表
1 # models.UserInfo.objects.all()
2 ## 查看錶的全部行
3 # models.UserInfo.objects.filter(id=2)
4 ##查看錶的id是2的行
5 # result=models.UserInfo.objects.all().values_list('id','name','ut__title')
6 ##經過此方式連表返回個列表，列表中存放的是元組對象（tuple）
7 # for row in result:
8 # print(row)
7、正反向查找
a.對象正向查找
============================對象正向查找=========================
1 result = models.UserInfo.objects.all() 2 for obj in result: 3 print(obj.name,obj.age,obj.ut_id,obj.ut.title) 4 #打印obj對象的名字，對象的年齡，對象的外鍵，ut設置外鍵的列就是至關於ut表對應的主鍵（如今拿到就是ut那個表能夠拿ut對應的一行全部內容） 5 result = models.UserInfo.objects.all().first() 6 ##獲取表中全部的行但只是拿第一個對象，也就是第一行 7 print(result.name,result.age,result.ut)
b.對象反向查找
============================對象反向查找=========================
1 # obj = models.UserType.objects.all().last() 2 # print('用戶類型',obj) 3 # for row in obj.userinfo_set.all(): 4 # print(row.name,row.age)
c.字典正向查找
============================字典正向查找=========================
1 # models.UserInfo.objects.filter(id__gt=7).delete() 2 #v=models.UserInfo.objects.all().values('name','age','ut__title') 3 # print(v)
d.字典反向查找
============================字典反向查找=========================
1 1 # vv = models.UserType.objects.values('title','userinfo__name') 2 2 # print(vv)
e.元組正向查找
============================元組正向查找=========================
1 1 # v3 = models.UserInfo.objects.all().values_list('name','age','ut__title') 2 2 # print(v3)
f.元組反向查找
============================元組反向查找=========================
1 1 # v4 = models.UserType.objects.all().values_list('title','userinfo__name') 2 2 # print(v4)
9、排序
1 # user_list = models.UserInfo.objects.all().order_by('-id')
2 # ##排序默認的升序，order_by（'-id'）是降序
3 # for i in user_list:
4 # print(i.name,i.id)
5 # return HttpResponse('....')
1 ss =models.UserInfo.objects.all().order_by('-id','age').reverse() 2 print(ss.query) 3 ''' 4 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 5 6 ''' 7 8 將設置的排序方式進行反轉，原本id是降序，age是升序，反轉後id 是升序，age是降序
10、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"
'''
11、轉化成sql語句
v = models.UserInfo.objects.values('ut_id').annotate(wws=Count('ut_id')).filter(ut_id__gt=2)
print(v.query)
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"
12、去重
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')
十3、排除某列數據
# ss=models.UserInfo.objects.defer('age','ut_id')
# #映射中排除某列數據
# for i in ss:
# print(i.id)
十4、僅獲取某列數據
# sss=models.UserInfo.objects.all().only('age')
#僅取某列數據
# for i in sss:
# print(i.age)
十5、指定使用某數據庫
models.UserInfo.objects.using('dbx')
指定使用的數據庫，參數爲存放數據中的數據庫名
ss=models.UserInfo.objects.raw('select * from appo1_userinfo')
print(ss)
十6、其餘相關操做
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('....')
十7、cookie
cookie 是一保存在客戶端瀏覽器上的鍵值對 我的理解cookie 工做原理：由於http是短鏈接，無狀態的 用戶經過瀏覽器訪問服務端若是登陸成功，服務端會給客戶端瀏覽器發送一個cookie，下次再來訪問時只要攜帶者cookie就不須要再次進行登陸
一、獲取Cookie：
|
1
2
3
4
5
6
|
request.COOKIES[
'key'
]
request.get_signed_cookie(key, default
=
RAISE_ERROR, salt
=
'', max_age
=
None
)
參數：
default: 默認值
salt: 加密鹽
max_age: 後臺控制過時時間
|
二、設置Cookie：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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獲取（不是絕對，底層抓包能夠獲取到也能夠被覆蓋）
|
三、因爲cookie保存在客戶端的電腦上，因此，JavaScript和jquery也能夠操做cookie。
<script src='/static/js/jquery.cookie.js'></script>
$.cookie("list_pager_num", 30,{ path: '/' });
十8、xss（跨站腳本攻擊）
xss 攻擊：是經過用戶的信任來進行註釋，好比在評論裏寫一堆HTML標籤，成功提交後會保存數據庫中或者本地文件中，當別的用戶在點開查看的時候，以前用戶填寫的評論也會經過字符串發送到瀏覽器，若是在html頁面上設置【|safe】那麼你就成功的被註釋了 他能夠獲取你的相關信息，若是你在html頁面中設置了safe 在HTML也是可及進行關鍵詞判斷，防止被註釋！（Django自己就進行了XSS攻擊防範的）
十9、crsf 跨站假裝請求
我的理解：crsf是防止跨站假裝請求，用戶若是訪問服務端，服務端會發送一端字符串給客戶端瀏覽器，若是在次有請求時服務端會檢測客戶端瀏覽器上有沒有 服務端發送的隨機字符串，若是有就能夠進行訪問，若是沒有就不能進行訪問
1、簡介
django爲用戶實現防止跨站請求僞造的功能，經過中間件 django.middleware.csrf.CsrfViewMiddleware 來完成。而對於django中設置防跨站請求僞造功能有分爲全局和局部。
全局：
中間件 django.middleware.csrf.CsrfViewMiddleware
局部：
- @csrf_protect，爲當前函數強制設置防跨站請求僞造功能，即使settings中沒有設置全局中間件。
- @csrf_exempt，取消當前函數防跨站請求僞造功能，即使settings中設置了全局中間件。
注：from django.views.decorators.csrf import csrf_exempt,csrf_protect
2、應用
一、普通表單
veiw中設置返回值：
return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))
或者
return render(request, 'xxx.html', data)
html中設置Token:
{% csrf_token %}
二、Ajax
對於傳統的form，能夠經過表單的方式將token再次發送到服務端，而對於ajax的話，使用以下方式。
view.py
from django.template.context import RequestContext
# Create your views here.
def test(request):
if request.method == 'POST':
print request.POST
return HttpResponse('ok')
return render_to_response('app01/test.html',context_instance=RequestContext(request))
text.html
<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title></title>
</head>
<body>
{% csrf_token %}
<input type="button" onclick="Do();" value="Do it"/>
<script src="/static/plugin/jquery/jquery-1.8.0.js"></script>
<script src="/static/plugin/jquery/jquery.cookie.js"></script>
<script type="text/javascript">
var csrftoken = $.cookie('csrftoken');
function csrfSafeMethod(method) {
// these HTTP methods do not require CSRF protection
return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
}
$.ajaxSetup({
beforeSend: function(xhr, settings) {
if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
xhr.setRequestHeader("X-CSRFToken", csrftoken);
}
}
});
function Do(){
$.ajax({
url:"/app01/test/",
data:{id:1},
type:'POST',
success:function(data){
console.log(data);
}
});
}
</script>
</body>
</html>
二10、session
|
1
2
3
4
|
Session是什麼？
Session 是保存在服務端的數據
Cookie是什麼？
Cookie是保存在客戶端瀏覽器上的鍵值對
|
Session我的理解
|
1
2
3
4
5
|
我的Session理解說明：
Session就是在存再服務端的數據，每次有人來訪問網頁Session會檢測用戶是否帶Session發送的隨機字符串，若是有隨機字符串Session就本身會查看本身以字典形式保存在內存的數據，字典鍵就是Session生成的隨機字符串，字典的值就是用戶的信息。
總體總結：
Session是依賴於Cookie的一種會話保持，Session會向第一次成功訪問的用戶發送一個隨機的字符串，以便之後用戶登陸能夠準確的定位到用戶是誰，用戶的相關信息。
須要注意一點，每一個用戶之間都是獨立的字典，不會出現用戶信息混亂情況，使用Session的好處，用戶查看不到敏感信息
|
|
1
2
3
4
5
6
|
我的Cookie理解說明：
Cookie是存在客戶端瀏覽器上的鍵值對
Cookie的能夠用於用戶登陸驗證，投票
總體總結：
Cookie會向第一次成功登錄頁面的用戶發送一個鍵值對，若是下次登錄服務端會檢測用戶是否攜帶Cookie若是攜帶就能夠直接進行訪問不須要再進用戶驗證。
Cookie能夠設置過時時間 和哪些用戶能夠進行訪問
|
Session 保存在服務端的數據（本質是鍵值對）
配置文件中能夠指定存儲位置
數據庫 Session
Django默認支持Session，而且默認是將Session數據存儲在數據庫中，即：django_session 表中。
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.db' # 引擎（默認）
SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在瀏覽器上時的key，即：sessionid＝隨機字符串（默認）
SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路徑（默認）
SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名（默認）
SESSION_COOKIE_SECURE = False # 是否Https傳輸cookie（默認）
SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http傳輸（默認）
SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）（默認）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否關閉瀏覽器使得Session過時（默認）
SESSION_SAVE_EVERY_REQUEST = False # 是否每次請求都保存Session，默認修改以後才保存（默認）
b. 使用
def index(request):
# 獲取、設置、刪除Session中數據
request.session['k1']
request.session.get('k1',None)
request.session['k1'] = 123
request.session.setdefault('k1',123) # 存在則不設置
del request.session['k1']
# 全部 鍵、值、鍵值對
request.session.keys()
request.session.values()
request.session.items()
request.session.iterkeys()
request.session.itervalues()
request.session.iteritems()
# 用戶session的隨機字符串
request.session.session_key
# 將全部Session失效日期小於當前日期的數據刪除
request.session.clear_expired()
# 檢查 用戶session的隨機字符串 在數據庫中是否
request.session.exists("session_key")
# 刪除當前用戶的全部Session數據
request.session.delete("session_key")
request.session.set_expiry(value)
* 若是value是個整數，session會在些秒數後失效。
* 若是value是個datatime或timedelta，session就會在這個時間後失效。
* 若是value是0,用戶關閉瀏覽器session就會失效。
* 若是value是None,session會依賴全局session失效策略。
緩存Session
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.cache' # 引擎
SESSION_CACHE_ALIAS = 'default' # 使用的緩存別名（默認內存緩存，也能夠是memcache），此處別名依賴緩存的設置
SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在瀏覽器上時的key，即：sessionid＝隨機字符串
SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路徑
SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名
SESSION_COOKIE_SECURE = False # 是否Https傳輸cookie
SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http傳輸
SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否關閉瀏覽器使得Session過時
SESSION_SAVE_EVERY_REQUEST = False # 是否每次請求都保存Session，默認修改以後才保存
b. 使用
同上
文件Session
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎
SESSION_FILE_PATH = None # 緩存文件路徑，若是爲None，則使用tempfile模塊獲取一個臨時地址tempfile.gettempdir() # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T
SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在瀏覽器上時的key，即：sessionid＝隨機字符串
SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路徑
SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名
SESSION_COOKIE_SECURE = False # 是否Https傳輸cookie
SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http傳輸
SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否關閉瀏覽器使得Session過時
SESSION_SAVE_EVERY_REQUEST = False # 是否每次請求都保存Session，默認修改以後才保存
b. 使用
同上
緩存+數據庫Session
數據庫用於作持久化，緩存用於提升效率
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db' # 引擎
b. 使用
同上
緩衝+數據庫 先是去數據庫中查找，沒有就去數據庫中查找
Cookie 中存放Session
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies' # 引擎
b. 使用
同上
這樣的存放方式 至關於沒有使用Session
Session 用戶驗證
1 1 def login(func): 2 2 def wrap(request, *args, **kwargs): 3 3 # 若是未登錄，跳轉到指定頁面 4 4 if request.path == '/test/': 5 5 return redirect('http://www.baidu.com') 6 6 return func(request, *args, **kwargs) 7 7 return wrap
二11、分頁
1、Django內置分頁
1 from django.shortcuts import render 2 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger 3 4 L = [] 5 for i in range(999): 6 L.append(i) 7 8 def index(request): 9 current_page = request.GET.get('p') 10 11 paginator = Paginator(L, 10) 12 # per_page: 每頁顯示條目數量 13 # count: 數據總個數 14 # num_pages:總頁數 15 # page_range:總頁數的索引範圍，如: (1,10),(1,200) 16 # page: page對象 17 try: 18 posts = paginator.page(current_page) 19 # has_next 是否有下一頁 20 # next_page_number 下一頁頁碼 21 # has_previous 是否有上一頁 22 # previous_page_number 上一頁頁碼 23 # object_list 分頁以後的數據列表 24 # number 當前頁 25 # paginator paginator對象 26 except PageNotAnInteger: 27 posts = paginator.page(1) 28 except EmptyPage: 29 posts = paginator.page(paginator.num_pages) 30 return render(request, 'index.html', {'posts': posts})
1 <!DOCTYPE html> 2 <html> 3 <head lang="en"> 4 <meta charset="UTF-8"> 5 <title></title> 6 </head> 7 <body> 8 <ul> 9 {% for item in posts %} 10 <li>{{ item }}</li> 11 {% endfor %} 12 </ul> 13 14 <div class="pagination"> 15 <span class="step-links"> 16 {% if posts.has_previous %} 17 <a href="?p={{ posts.previous_page_number }}">Previous</a> 18 {% endif %} 19 <span class="current"> 20 Page {{ posts.number }} of {{ posts.paginator.num_pages }}. 21 </span> 22 {% if posts.has_next %} 23 <a href="?p={{ posts.next_page_number }}">Next</a> 24 {% endif %} 25 </span> 26 27 </div> 28 </body> 29 </html>
1 from django.shortcuts import render 2 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger 3 4 5 class CustomPaginator(Paginator): 6 def __init__(self, current_page, max_pager_num, *args, **kwargs): 7 """ 8 :param current_page: 當前頁 9 :param max_pager_num:最多顯示的頁碼個數 10 :param args: 11 :param kwargs: 12 :return: 13 """ 14 self.current_page = int(current_page) 15 self.max_pager_num = max_pager_num 16 super(CustomPaginator, self).__init__(*args, **kwargs) 17 18 def page_num_range(self): 19 # 當前頁面 20 # self.current_page 21 # 總頁數 22 # self.num_pages 23 # 最多顯示的頁碼個數 24 # self.max_pager_num 25 print(1) 26 if self.num_pages < self.max_pager_num: 27 return range(1, self.num_pages + 1) 28 print(2) 29 part = int(self.max_pager_num / 2) 30 if self.current_page - part < 1: 31 return range(1, self.max_pager_num + 1) 32 print(3) 33 if self.current_page + part > self.num_pages: 34 return range(self.num_pages + 1 - self.max_pager_num, self.num_pages + 1) 35 print(4) 36 return range(self.current_page - part, self.current_page + part + 1) 37 38 39 L = [] 40 for i in range(999): 41 L.append(i) 42 43 def index(request): 44 current_page = request.GET.get('p') 45 paginator = CustomPaginator(current_page, 11, L, 10) 46 # per_page: 每頁顯示條目數量 47 # count: 數據總個數 48 # num_pages:總頁數 49 # page_range:總頁數的索引範圍，如: (1,10),(1,200) 50 # page: page對象 51 try: 52 posts = paginator.page(current_page) 53 # has_next 是否有下一頁 54 # next_page_number 下一頁頁碼 55 # has_previous 是否有上一頁 56 # previous_page_number 上一頁頁碼 57 # object_list 分頁以後的數據列表 58 # number 當前頁 59 # paginator paginator對象 60 except PageNotAnInteger: 61 posts = paginator.page(1) 62 except EmptyPage: 63 posts = paginator.page(paginator.num_pages) 64 65 return render(request, 'index.html', {'posts': posts})
1 <!DOCTYPE html> 2 <html> 3 <head lang="en"> 4 <meta charset="UTF-8"> 5 <title></title> 6 </head> 7 <body> 8 9 <ul> 10 {% for item in posts %} 11 <li>{{ item }}</li> 12 {% endfor %} 13 </ul> 14 15 <div class="pagination"> 16 <span class="step-links"> 17 {% if posts.has_previous %} 18 <a href="?p={{ posts.previous_page_number }}">Previous</a> 19 {% endif %} 20 21 {% for i in posts.paginator.page_num_range %} 22 <a href="?p={{ i }}">{{ i }}</a> 23 {% endfor %} 24 25 {% if posts.has_next %} 26 <a href="?p={{ posts.next_page_number }}">Next</a> 27 {% endif %} 28 </span> 29 30 <span class="current"> 31 Page {{ posts.number }} of {{ posts.paginator.num_pages }}. 32 </span> 33 34 </div> 35 </body> 36 </html>
2、自定義分頁
分頁功能在每一個網站都是必要的，對於分頁來講，其實就是根據用戶的輸入計算出應該在數據庫表中的起始位置。
一、設定每頁顯示數據條數
二、用戶輸入頁碼（第一頁、第二頁...）
三、根據設定的每頁顯示條數和當前頁碼，計算出須要取數據表的起始位置
四、在數據表中根據起始位置取值，頁面上輸出數據
需求又來了，須要在頁面上顯示分頁的頁面。如：［上一頁］［1］［2］［3］［4］［5］［下一頁］
一、設定每頁顯示數據條數
二、用戶輸入頁碼（第一頁、第二頁...）
三、設定顯示多少頁號
四、獲取當前數據總條數
五、根據設定顯示多少頁號和數據總條數計算出，總頁數
六、根據設定的每頁顯示條數和當前頁碼，計算出須要取數據表的起始位置
七、在數據表中根據起始位置取值，頁面上輸出數據
八、輸出分頁html，如：［上一頁］［1］［2］［3］［4］［5］［下一頁］
1 ##============================================django自定義分頁不能對頁數進行限定============================ 2 3 # class PageInfo(object): 4 # 5 # def __init__(self,current_page,per_page,all_count,show_page=11): 6 # try: 7 # self.current_page = int(current_page) 8 # except Exception as e: 9 # self.current_page=1 10 # self.per_page=per_page 11 # self.all_count=all_count 12 # a,b =divmod(all_count,per_page) 13 # if b: 14 # a = a+1 15 # self.all_pager = a 16 # self.show_page=show_page 17 # 18 # def start(self): 19 # return (self.current_page -1)* self.per_page 20 # 21 # def end(self): 22 # return self.current_page * self.per_page 23 # 24 # def pager(self): 25 # # v='<a href="/custom.html?page=1">1</a>' 26 # # return v 27 # page_list=[] 28 # half=(self.show_page-1)/2 29 # begin=self.current_page - half 30 # stop=self.current_page +half +1 31 # for i in range(int(begin),int(stop)): 32 # if self.current_page == i: 33 # temp="<a style='display:inline-block;padding:5px;margin:5px;background-color:red' href='/custom.html?page=%s'>%s</a>"%(i,i,) 34 # else: 35 # temp = "<a style='display:inline-block;padding:5px;margin:5px;' href='/custom.html?page=%s'>%s</a>" % ( 36 # i, i,) 37 # page_list.append(temp) 38 # 39 # return ''.join(page_list) 40 # def custom(request): 41 # #表示用戶當前想要訪問的頁碼 42 # all_count = models.UserInfo.objects.all().count() 43 # #每頁顯示的個數 44 # page_info=PageInfo(request.GET.get('page'),10,all_count) 45 # user_list = models.UserInfo.objects.all()[page_info.start():page_info.end()] 46 # return render(request,'custom.html',{'user_list':user_list,'page_info':page_info})
1 from django.core.paginator import Paginator,Page 2 class PageInfo(object): 3 4 def __init__(self,current_page,per_page,all_count,show_page=11): 5 ##類的變量參數 6 try: 7 #捕捉異常 8 self.current_page = int(current_page) 9 #若是能正常轉換成整型就賦值給self.current_page 10 except Exception as e: 11 #不能正常轉換成整型就賦值成數字1 12 self.current_page=1 13 #設置多少條數據分爲一個一頁 14 self.per_page=per_page 15 #獲取數據庫中全部的數據能分爲多少頁 16 self.all_count=all_count 17 #進行分頁計算（數據庫總數/多少天數據進行分頁）能除開等到結果就像是（12,0）把12賦值給a，把0賦值給b 18 a,b =divmod(all_count,per_page) 19 #若是b爲真 20 if b: 21 #a 等於a+1 22 a = a+1 23 #求出總共要分的頁數賦值給self.all_pager 24 self.all_pager = a 25 #把傳入的show_page值賦值給self.show_page 26 self.show_page=show_page 27 28 def start(self): 29 #定義函數 設定起始位 30 return (self.current_page -1)* self.per_page 31 #返回當前頁數減1 乘每頁多少數據 32 def end(self): 33 # 定義函數 設定中止位 34 return self.current_page * self.per_page 35 # 返回當前頁數減乘每頁多少數據 36 def pager(self): 37 #定義函數 38 # v='<a href="/custom.html?page=1">1</a>' 39 # return v 40 page_list=[] 41 #建立列表 42 half=(self.show_page-1)/2 43 #獲取頁碼的中間值 44 if self.all_pager < self.show_page: 45 #若是數據庫的數小於設定的頁碼數 46 begin=1 47 #起始位設定爲1 48 stop=self.all_pager+1 49 #中止爲設定爲數據庫的數加上1（由於切片是顧頭不顧尾） 50 else: 51 #不然 52 if self.current_page <= half: 53 #若是當前頁碼小於等於頁碼中間值 54 begin=1 55 #起始位設定爲1 56 stop=self.show_page+1 57 #中止位設定爲頁碼數加1（由於切片是顧頭不顧尾） 58 else: 59 #不然 60 if self.current_page + half > self.all_pager: 61 #若是當前頁碼加上中間的頁碼大於數據庫的總頁碼數 62 begin=self.all_pager-10 63 #起始值設定爲數據庫總數減10 64 stop=self.all_pager+1 65 #中止值設定爲數據庫總數加1（由於切片是顧頭不顧尾） 66 else: 67 #不然 68 begin=self.current_page-half 69 #起始位設定爲當前頁碼減中間頁碼 70 stop=self.current_page+half+1 71 #中止位設定爲當前頁碼加中間頁碼加1（由於切片是顧頭不顧尾） 72 if self.current_page==self.all_pager: 73 up = "<li><a href='#'>下一頁</a></li>" 74 else: 75 up = "<li><a href='/custom.html?page=%s'>下一頁</a></li>" % (self.current_page+1) 76 page_list.append(up) 77 for i in range(int(begin),int(stop)): 78 #進行循環範圍是（起始位，中止位） 79 if self.current_page == i: 80 #若是當前頁碼等於循環的i時 81 temp="<li class='active'><a href='/custom.html?page=%s'>%s</a></li>"%(i,i,) 82 #自定義一個a標籤設置簡單樣式 並添加背景顏色做爲當前頁碼標識 83 else: 84 #不然 85 temp = "<li><a href='/custom.html?page=%s'>%s</a></li>" % ( 86 i, i,) 87 #自定義一個a標籤設置簡單樣式 88 page_list.append(temp) 89 #把每循環的a標籤都添加到page_list列表中 90 if self.current_page==1: 91 nex = "<li><a href='#'>上一頁</a></li>" 92 else: 93 nex = "<li><a href='/custom.html?page=%s'>上一頁</a></li>" % (self.current_page-1) 94 page_list.append(nex) 95 return ''.join(page_list) 96 #把列擺中的內容進行拼接（由於返回的是字符串） 97 # def custom(request): 98 # #從數據庫中獲取全部數據 99 # all_count = models.UserInfo.objects.all().count() 100 # #實例化一個對象並進行傳值 101 # page_info=PageInfo(request.GET.get('page'),10,all_count) 102 # #從數據庫中獲取數據設置起始和結束位置 103 # user_list = models.UserInfo.objects.all()[page_info.start():page_info.end()] 104 # #返回到HTML標籤中並傳入參數 105 # return render(request,'custom.html',{'user_list':user_list,'page_info':page_info}) 106 107 ##==================================================總結================================================================= 108 ''' 109 1.獲取到數據中最大的頁碼數 110 2.設定一頁顯示多少數據 111 3.在用數據庫總數除以要顯示的內容數量（若是餘數不等於零須要多添加一頁） 112 4.設定一頁中顯示多少頁碼按鈕 113 5.獲取一頁頁碼中中間的頁碼數 114 6.判斷數據庫的頁碼是否是小於設定一頁中顯示頁碼按鈕的數（若是小於就重寫中止值，不小於就往下判斷） 115 7.判斷當前頁碼數小於等於設定頁碼的中間值（重寫起始值爲1） 116 8.當前頁碼值不小於等於頁碼的中間值（重寫起始值爲中間值-5，結束值+6，由於切片是顧頭不顧尾） 117 9.判斷當前頁碼加上中間頁碼數是否是大於數據庫總數（大於重寫起始值爲數據庫總數-10，結束值爲數據庫總數+1，由於切片是顧頭不顧尾） 118 10.經過python向HTML頁面中傳一個函數名，在HTML中函數名.方法執行（不能加括號執行） 119 11.|safe 代表是安全參數能夠正常渲染 120 12.判斷當前頁碼數是否是等於1（若是等於1不執行上一步按鈕） 121 13.判斷當前頁碼數是否是等於數據庫總數（若是等於不執行下一步按鈕） 122 '''
二12、自關聯
一、自關聯，經過名字大概就知道是一張表要關聯它本身自己，若是按照之前學的知識創表時確定不能成功，這就要運用到今天新學的知識點。
related_name
二、想一想，我們之前關聯表時都是在建立一個關係表裏邊設置外鍵，自關聯也同樣。
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 這樣就至關於給他們設置了別名，數據庫就不會分不清誰是誰的關聯
三、重點來了，表已經創好了，數據也存在怎麼查看相關聯的信息啊？
1 def indexs(request): 2 tt= models.UserInfo.objects.filter(id=2).first() 3 print(tt) 4 # 獲取Boy表中id等於2的obj對象（Boy的obj對象） 5 xx =tt.grily.all() 6 # 獲取UTU表中的全部和Boy對象相關的全部對象 7 print(xx) 8 for i in xx: 9 print(i.g.nickname) 10 # 循環獲取UTU對象g外鍵對應的名稱 11 return HttpResponse('ok')
1 def indexss(request): 2 tt=models.UserINfo.objects.filter(id=2).first() 3 xx = tt.userinfo_set.all() 4 ## 反向查看關係自關聯的表 5 for i in xx: 6 print(i.nickname) 7 return HttpResponse('ok')
四、咱們在經過ManyToManyField自動建立一個自關聯的關係表。
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')
1 def indexsz(request): 2 tt = models.UserINfo.objects.filter(id=2).first() 3 # 正向查看自關聯表的內容 4 xx =tt.m.all() 5 # 獲取到和UserINfo相關的UserINfo對象 6 for i in xx: 7 print(i.nickname) 8 return HttpResponse('ok')
1 def indexs(request): 2 tt =models.UserINfo.objects.filter(id=2).first() 3 ss=tt.userinfo_set.all() 4 print(ss) 5 for i in ss: 6 print(i.nickname)
Fk（外鍵關聯）
外鍵關聯就是表（自己）設置一個外鍵，這個外鍵要關聯的列是這個表（自己）的自增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')
1 def indexss(request): 2 xx =models.User.objects.filter(id=1).first() 3 xs =models.User.objects.filter(id=2).first() 4 tt =xx.xxx.all() 5 ts =xs.xxx.all() 6 for i in tt: 7 print(i.new_content) 8 for i in ts: 9 print(i.new_content) 10 return HttpResponse('ok')
相關文章
- 1. django - 總結 - cnblog 知識點
- 2. Django知識點總結
- 3. Django ORM 知識點總結
- 4. django - 總結 - CRM - 知識點
- 5. Django知識總結
- 6. 關於Django查詢知識點總結
- 7. 八月22日，django知識點總結：
- 8. python知識點總結
- 9. 2.python知識點總結
- 10. Python小知識點總結
- 更多相關文章...
- • SQLite - Python - SQLite教程
- • Docker 安裝 Python - Docker教程
- • 算法總結-雙指針
- • 算法總結-回溯法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Duang!超快Wi-Fi來襲
- 2. 機器學習-補充03 神經網絡之**函數(Activation Function)
- 3. git上開源maven項目部署 多module maven項目（多module maven+redis+tomcat+mysql）後臺部署流程學習記錄
- 4. ecliple-tomcat部署maven項目方式之一
- 5. eclipse新導入的項目經常可以看到「XX cannot be resolved to a type」的報錯信息
- 6. Spark RDD的依賴於DAG的工作原理
- 7. VMware安裝CentOS-8教程詳解
- 8. YDOOK：Java 項目 Spring 項目導入基本四大 jar 包 導入依賴，怎樣在 IDEA 的項目結構中導入 jar 包 導入依賴
- 9. 簡單方法使得putty（windows10上）可以免密登錄樹莓派
- 10. idea怎麼用本地maven
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. django - 總結 - cnblog 知識點
- 2. Django知識點總結
- 3. Django ORM 知識點總結
- 4. django - 總結 - CRM - 知識點
- 5. Django知識總結
- 6. 關於Django查詢知識點總結
- 7. 八月22日，django知識點總結：
- 8. python知識點總結
- 9. 2.python知識點總結
- 10. Python小知識點總結