div標籤和span標籤
div標籤用來定義一個塊級元素，並沒有實際的意義。主要經過CSS樣式爲其賦予不一樣的表現。
span標籤用來定義內聯(行內)元素，並沒有實際的意義。主要經過CSS樣式爲其賦予不一樣的表現。css
塊級元素與行內元素的區別：
所謂塊元素，是以另起一行開始渲染的元素，行內元素則不需另起一行。若是單獨在網頁中插入這兩個元素，不會對頁面產生任何的影響。
這兩個元素是專門爲定義CSS樣式而生的。html
注意：前端
關於標籤嵌套：一般塊級元素能夠包含內聯元素或某些塊級元素，但內聯元素不能包含塊級元素，它只能包含其它內聯元素python
______________________________________________________________________________________jquery
上傳文件git
form表單設置enctype="multipart/form-data"web
views.py中取file_obj用request.FILES.get()ajax
from django.shortcuts import render,HttpResponse
# Create your views here.
def upload(request):
if request.method=='POST':
file_obj=request.FILES.get('file')
print(file_obj)
with open(file_obj.name,'wb') as f:
for line in file_obj:
f.write(line)
return render(request,'upload.html')
views.py
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form method="post" action="upload.html" enctype="multipart/form-data">
{% csrf_token %}
<input type="file" name="file">
<input type="submit" >
</form>
</body>
</html>
upload.html
form組件的做用正則表達式
1.生成html代碼數據庫
2.驗證
3.把驗證的錯誤信息保留在頁面上而且保留原始數據
Form表單的基本實例
from django import forms
from django.core.exceptions import ValidationError
# 定義註冊的form類
class RegForm(forms.Form):
username=forms.CharField(
max_length=16,
label='用戶名：',
error_messages={
'max_length':'最長爲16位',
'required':'不能爲空'
},
# 爲前端利用bootstrap添加東西
widget=forms.widgets.TextInput(
attrs={'class':'form-control','placeholder':'username'},
)
)
password=forms.CharField(
min_length=6,
label='密碼：',
# widget= 用於設置html格式
widget=forms.PasswordInput(
attrs={'class': 'form-control', 'placeholder': 'password'},
# 密碼不消失
# render_value=True
),
error_messages={
'max_length': '最短爲6位',
'required': '不能爲空'
}
)
re_password=forms.CharField(
min_length=6,
label='重複密碼：',
# widget= 用於設置html格式
widget=forms.PasswordInput(
attrs={'class': 'form-control', 'placeholder': 'password'},
),
error_messages = {
'max_length': '最短爲6位',
'required': '不能爲空'
}
)
email=forms.EmailField(
label='郵箱：',
widget=forms.widgets.EmailInput(
attrs={'class': 'form-control', 'placeholder': 'email'},
),
error_messages={
# 格式錯誤
'invalid':'格式錯誤',
'required':'不能爲空'
}
)
# 重寫全局鉤子函數，對確認密碼進行確認
def clean(self):
password=self.cleaned_data.get('password')
re_password=self.cleaned_data.get('re_password')
if password!=re_password:
# 注意須要引入ValidationError
self.add_error('re_password',ValidationError('兩次密碼不一致'))
else:
return self.cleaned_data
forms.py
# 重寫局部鉤子函數，對username是否註冊作校驗,不是實時校驗
def clean_username(self):
username=self.cleaned_data.get('username')
is_exit=models.UserInfo.objects.filter(username=username)
if is_exit:
self.add_error('username',ValidationError('用戶名已存在'))
else:
return username 注意全局鉤子函數返回cleaned_date，局部鉤子函數返回具體值，鉤子函數的名字都是固定的。
視圖函數獲取form_obj，傳到前端（
return render(request, 'app01/reg.html', {'form_obj':form_obj})
）
form_obj=forms.RegForm()
POST方式接受數據以後，
obj=forms.RegForm(request.POST)
obj.is_valid()
obj.cleaned_data
css引入方式
<link rel="stylesheet" href="">
js引入方式
<script src=""></script>
前端Form表單中對form_obj的幾種顯示方式
（有文件上傳是在form表單中加enctype="multipart/form-data"
label標籤中for=「」填入id，能夠實如今點擊label=點擊id的標籤
）
<form novalidate action="/reg/" method="post" class="form-horizontal reg_form" enctype="multipart/form-data">
{% csrf_token %}
{# form_obj的幾種前端顯示方式#}
{# 方式一#}
{# {{ form_obj.username.label }}#}
{# {{ form_obj.username }}#}
{# {{ form_obj.password.label }}#}
{# {{ form_obj.password }}#}
{# 方式二#}
{# {% for item in form_obj %}#}
{# {{ item.label }}#}
{# {{ item }}#}
{# {% endfor %}#}
<div class="form-group">
<label for="{{ form_obj.username.id_for_label }}" class="col-sm-2 control-label">{{ form_obj.username.label }}</label>
<div class="col-sm-10">
{{ form_obj.username }}
<span id="helpBlock2" class="help-block">{{ form_obj.username.errors.0 }}</span>
</div>
</div>
<div class="form-group">
<label for="{{ form_obj.password.id_for_label }}" class="col-sm-2 control-label">{{ form_obj.password.label }}</label>
<div class="col-sm-10">
{{ form_obj.password }}
<span id="helpBlock2" class="help-block">{{ form_obj.password.errors.0 }}</span>
</div>
</div>
<div class="form-group">
<label for="{{ form_obj.re_password.id_for_label }}" class="col-sm-2 control-label">{{ form_obj.re_password.label }}</label>
<div class="col-sm-10">
{{ form_obj.re_password }}
<span id="helpBlock2" class="help-block">{{ form_obj.re_password.errors.0 }}</span>
</div>
</div>
<div class="form-group">
<label for="{{ form_obj.email.id_for_label }}" class="col-sm-2 control-label">{{ form_obj.email.label }}</label>
<div class="col-sm-10">
{{ form_obj.email }}
<span id="helpBlock2" class="help-block">{{ form_obj.email.errors.0 }}</span>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">頭像</label>
<div class="col-sm-10">
<label for="avatar_id">
<img src="/static/default_avatar/default_avatar.jpg" id="avatar_img" width="50px" height="50px">
</label>
<input type="file" name="avatar" id="avatar_id" style="display: none;">
</div>
</div>
<div class="form-group">
<div class="col-sm-offset-2 col-sm-10">
<button type="submit" class="btn btn-default">註冊</button>
</div>
</div>
</form >
reg.html
經過js代碼實現對頭像的預覽
<script>
{#經過js代碼實現選中頭像前端能夠有顯示#}
{#找到頭像input標籤綁定chang事件#}
$('#avatar_id').change(function () {
{#建立一個讀取文件的對象#}
alert('123')
var fileReader=new FileReader();
{#當前選中的頭像文件 this指的是當前input框#}
console.log(this.files[0]);
{#讀取選中的文件，這裏的讀取須要時間#}
fileReader.readAsDataURL(this.files[0]);
{#等到上一步讀取完成,才能把圖片加載出來在前端img標籤中#}
console.log(fileReader.result)
fileReader.onload=function () {
$('#avatar_img').attr('src',fileReader.result)
}
})
</script>
reg.html
ajax的優缺點：
優勢：
- AJAX使用Javascript技術向服務器發送異步請求；
- AJAX無須刷新整個頁面；
- 由於服務器響應內容再也不是整個頁面，而是頁面中的局部，因此AJAX性能高；
缺點：
- AJAX並不適合全部場景，不少時候仍是要使用同步交互；
- AJAX雖然提升了用戶體驗，但無形中向服務器發送的請求次數增多了，致使服務器壓力增大；
- 由於AJAX是在瀏覽器中使用Javascript技術完成的，因此還須要處理瀏覽器兼容性問題；
同步是指：發送方發出數據後，等接收方發回響應之後才發下一個數據包的通信方式。
異步是指：發送方發出數據後，不等接收方發回響應，接着發送下個數據包的通信方式。
同步通訊方式與異步通訊的概念
同步通訊方式要求通訊雙方以相同的時鐘頻率進行，並且準確協調，經過共享一個單個時鐘或定時脈衝源保證發送方和接收方的準確同步，效率較高；
異步通訊方式不要求雙方同步，收發方可採用各自的時鐘源，雙方遵循異步的通訊協議，以字符爲數據傳輸單位，發送方傳送字符的時間間隔不肯定，發送效率比同步傳送效率低。
ajax提交是data中須要添加csrf信息
csrfmiddlewaretoken:$("[name='csrfmiddlewaretoken']").val(),
ajax基本實例:
$.ajax({
url:'/reg/',
type:'post',
{#利用ajax傳文件必須加如下兩個#}
processData:false,
contentType:false,
data:{},
success:function (data) {
{#數據提交成功返回data#}
if (data.status){
{#有錯誤展現錯誤信息#}
console.log(data.msg);
{#將錯誤信息填寫到頁面上#}
}
else {
}
}
})
js
經過ajax上傳文件須要
processData:false, 告訴jquery不要處理個人數據
contentType:false, 告訴jquery不要設置content類型
而且
{#傳遞文件須要把數據加入FormData中，data:{}處直接data:formData#}
var formData=new FormData();
formData.append('username',$('#id_username').val());
formData.append('csrfmiddlewaretoken',$('[name="csrfmiddlewaretoken"]').val());
{#$('#avatar_id')多是一個jQuery對象#}
{#$('#avatar_id')[0]是input框#}
{#$('#avatar_id')[0].files是一個Filelist#}
{#$('#avatar_id')[0].files[0]是一個File#}
formData.append('avatar',$('#avatar_id')[0].files[0]);
jquery中each循環
$.each(（對象）,function (k（對象中的鍵）,v（對象中的值）) {
{#經過找id的方式找到input標籤，在找到其下的span標籤添加錯誤信息#}
$('#id_'+k).next('span').text(v[0])
})
JS知識
.next() 下一個標籤
.next(‘span’).text()下一個span標籤添加文本
獲取焦點事件，就是鼠標點到的地方觸發的函數
$('form input').focus(function () {
})
$('form input').blur(function () {
當失去焦點時觸發的函數
})
$('').change(function () {
當發生改變時觸發的函數
})
js實現頁面跳轉
location.href=url
from django.http import JsonResponse
返回一個json數據，適合用ajax返回success中的數據
return JsonResponse()
實現實時檢測用戶名是否存在
{#當失去焦點時，檢測數據庫用戶名是否已被註冊#}
$('#id_username').blur(function () {
$.ajax({
{#專門處理此問題函數#}
url:'check_username_exit',
type: 'get',
data: {
username:$('#id_username').val(),
},
success:function (data) {
if(data.status){
{#將錯誤信息添加到input標籤下的span標籤#}
$('#id_username').next('span').text(data.msg)
}
}
})
})
js
# 專門處理檢查用戶名是否已被註冊
def check_username_exit(requesnt):
ret={'status':0,'msg':''}
username=requesnt.GET.get('username')
r=models.UserInfo.objects.filter(username=username)
if r:
ret['status']=1
ret['msg']='用戶名已存在'
return JsonResponse(ret)
views.py
加到form表單中把自動補全關閉autocomplete="off"
鉤子函數實現爲form組件添加額外的校驗，分爲全局鉤子和局部鉤子函數
from django.core.exceptions import ValidationError
# 必須寫在form類中
# 重寫全局鉤子函數，對確認密碼進行確認
def clean(self):
password=self.cleaned_data.get('password')
re_password=self.cleaned_data.get('re_password')
if password!=re_password:
# 注意須要引入ValidationError
self.add_error('re_password',ValidationError('兩次密碼不一致'))
else:
return self.cleaned_data
# 重寫局部鉤子函數，對username是否註冊作校驗,不是實時校驗
def clean_username(self):
username=self.cleaned_data.get('username')
is_exit=models.UserInfo.objects.filter(username=username)
if is_exit:
self.add_error('username',ValidationError('用戶名已存在'))
else:
return username
forms.py
中間件的五種方法：
process_request
process_view
process_exception
process_template_response
process_response
web請求的部分執行流程：
wsgi（從用戶過來的）解析的信息，走中間件的process_request,而後走urls.py,走process_view，而後views.py,若是須要走process_exception,process_template_response,最後必定會走process_response。
中間件版的登陸驗證：
from django.contrib import admin
from django.urls import path,re_path
from app01 import views
urlpatterns = [
path('admin/', admin.site.urls),
re_path(r'^index/$', views.index),
re_path(r'^login/$', views.login, name='login'),
]
urls.py
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'middleware.middlewares.AuthMD',
]
settings.py
須要在根目錄建middleware目錄
from django.utils.deprecation import MiddlewareMixin
class AuthMD(MiddlewareMixin):
white_list = ['/login/', ] # 白名單
balck_list = ['/black/', ] # 黑名單
def process_request(self, request):
from django.shortcuts import redirect, HttpResponse
next_url = request.path_info
print(request.path_info, request.get_full_path())
if next_url in self.white_list or request.session.get("user"):
return
elif next_url in self.balck_list:
return HttpResponse('This is an illegal URL')
else:
return redirect("/login/?next={}".format(next_url))
middlewares
from django.shortcuts import render,HttpResponse,redirect
# Create your views here.
def index(request):
return HttpResponse('this is index')
def home(request):
return HttpResponse('this is home')
def login(request):
if request.method == "POST":
user = request.POST.get("user")
pwd = request.POST.get("pwd")
if user =='zw' and pwd == '123456':
# 設置session
request.session["user"] = user
# 獲取跳到登錄頁面以前的URL
next_url = request.GET.get("next")
# 若是有，就跳轉回登錄以前的URL
if next_url:
return redirect(next_url)
# 不然默認跳轉到index頁面
else:
return redirect("/index/")
return render(request, "login.html")
views.py
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="x-ua-compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>登陸頁面</title>
</head>
<body>
<form action="{% url 'login' %}" method="post">
{% csrf_token %}
<p>
<label for="user">用戶名：</label>
<input type="text" name="user" id="user">
</p>
<p>
<label for="pwd">密 碼：</label>
<input type="text" name="pwd" id="pwd">
</p>
<input type="submit" value="登陸">
</form>
</body>
</html>
login.html
bootstrap中的媒體對象就像博客首頁每一篇文章的一塊地方。
如下是py文件用django環境的方法，ORM基於對象的查詢和基於queryset的查詢
# 如下是py文件用django環境的方法
from django.db import connection
import os
if __name__=='__main__':
# 從manage.py中複製出來的
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Blog_2.settings")
# 啓動django
import django
django.setup()
# 這裏引入models不能再主函數外邊引入不知道爲何
from app01 import models
# 基於對象的查詢 SQL：子查詢
a=models.Article.objects.first()
a.user.avatar
# 查看執行的全部SQL語句，加上[-1]指最後一條
print(connection.queries[-1])
print(a.user.avatar)
# 基於queryset的查詢,SQL:join連表查詢
# .filter()和.all()都是基於queryset的查詢
b=models.Article.objects.filter(pk=1)
b.values('user__avatar')
print(b.values('user__avatar'))
print(connection.queries[-1])
# .values_list()輸出queryset[(),()]元組裏是數據庫數據
# .values()輸出queryset[{},{}]字典裏是數據庫數據
c=models.Article.objects.all()
print(c.values_list())
print(c.values())
View Code
# 查看ORM語句執行的全部SQL語句，加上[-1]指最後一條
from django.db import connection
print(connection.queries[-1])
在settings.py中設置能夠輸出所有的SQL語句
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
View Code
在django 中用戶只能看到static中的文件，經過設置爲用戶打開一個media。前端能夠經過拼接從而達到顯示上傳頭像的目的。
# 用戶是無權訪問/static/以外的路徑的，因此須要開一個，
# django用戶上傳的都叫media文件
MEDIA_URL='/media/'
MEDIA_ROOT=os.path.join(BASE_DIR,'media')
# 還須要在urls.py裏寫url
settings.py
from django.views.static import serve
from django.conf import settings
re_path(r'^media/(?P<path>.*)$',serve,{"document_root":settings.MEDIA_ROOT}),
urls.py
ORM foreign key 基於對象的查詢和基於queryset的查詢（正反向）。
manytomany基於對象查詢方法和foreign key 相同。onetoone基於對象反向查詢時只寫小寫表名，不用加_set。
#Article有對Classification的外鍵
# 基於對象的
# 正向
a = models.Article.objects.first()
# print(a.classification.blog)
# 反向
b=models.Classification.objects.first()
# print(b)
# print(b.article_set.all())
# print(type(b.article_set))
# print(type(b.article_set.all()))
# 基於queryset
# 正向
c=models.Article.objects.filter(pk=1).values('classification__title')
print(c)
# 反向
d=models.Classification.objects.filter(pk=1).values('article__title')
print(d)
for i in d:
print(i['article__title'])
test.py
ORM分組和聚合查詢
聚合：
aggregate()是QuerySet 的一個終止子句，意思是說，它返回一個包含一些鍵值對的字典。 鍵的名稱是聚合值的標識符，值是計算出來的聚合值。鍵的名稱是按照字段和聚合函數的名稱自動生成出來的.
from django.db.models import Avg, Sum, Max, Min, Count
>>> from django.db.models import Avg, Sum, Max, Min, Count
>>> models.Book.objects.all().aggregate(Avg("price"))
{'price__avg': 13.233333}
本身指定一個名稱
>>> models.Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 13.233333}
查詢多個值
>>> models.Book.objects.all().aggregate(Avg("price"), Max("price"), Min("price"))
{'price__avg': 13.233333, 'price__max': Decimal('19.90'), 'price__min': Decimal('9.90')}
分組：
annotate是ORM中的分組，關鍵字前面內容是按照什麼分組，關鍵字前面values()括號中填的是分組的字段，最後的values()中是須要顯示的內容。
總之：1.annotate前面內容是按照什麼分組
2.最後values()是須要顯示的內容。
建議對應原生SQL看看。
執行原生SQL：
from django.db import connection, connections
cursor = connection.cursor() # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
ret = cursor.fetchone()
View Code
extra構造額外的查詢條件或者映射，如：子查詢
按照月份給文章分類：
create_time_format_list=models.Article.objects.filter(user=user_obj).extra(
select={'create_time_format':'date_format(create_time,"%%Y-%%m")'}
).values('create_time_format').annotate(c=Count('nid')).values('create_time_format','c')
注意：create_time_format是一個變量
select date_format(create_time,"%Y-%m") from app01_article;實現對creat_tiem的格式化
extra中添加就是將日期格式化的語句。
路由系統中
re_path(r'(\w+)/article/(\d+)', views.article_detial),
(\w+)(\d+)加的括號就是參數，須要在視圖函數中接受
ORM模版語言：
母版中添加
{% block main_body %}
{% endblock %}
子板添加
{% extends 母版所在html文件%}
{%block main_body%}
子板語句
{%endblock%}
自定義標籤：
1.在app下建立python package 名字必須爲templatetags
2.其下建立xx.py, xx爲標籤名，app必須被註冊
from django import template
register=template.Library()
# 自定義tag 標籤
@register.inclusion_tag('left_menu.html')#這裏的html文件能夠嵌入標籤的地方
#@register.simple_tag
def get_left_menu(arg):
return {
}#通常都是字典，對於inclusion_tag
3.在html中用標籤
{%load xx %} xx爲標籤名
{%get_left_menu arg%}
render渲染：不管是html，css，js都認爲是字符串，把{{}}{%%}替換中的
內容進行替換，在js中須要注意替換時可能找不到(就是未定義變量)
須要加雙引號。
json: 是一種標準的格式。
python JSON(格式固定)
dict objects {"":""}
list,tuple array []
str string ""
int,float number
True true
False false
None null
全部json格式的數據本質都是json字符串，如objects類型'{"name":"aa"}'(注意外邊必須是單引號，裏面必須是雙引號,纔算是json字符串)，
array類型'["x",2]'，string類型'"abc"'(總之就是在外邊加單引號),全部符合json字符串的均可以進行反序列化成須要的語言格式。
js中：JSON.stringify()和JSON.parse()用來序列化和還原JavaScript對象。
python中：json.dumps()和json.loads()用來序列化和反序列化。
ajax請求後端返回的幾乎都是字典。
若是把js寫成一個文件，而後引入，注意模板語言不能進行渲染js文件，因此須要把js文件中須要的值存在一個地方，而後再取出來，例如：在html頁面多加一個<div id="info" style="display: none" article_obj_nid="{{ article_obj.nid }}" ></div>(自定義屬性)，在js文件中var article_id=$('#info').attr('article_obj_nid');
JS知識：
.attr()取到的是屬性。
.hasClass('xx')若是有xx屬性就返回true，不然返回false。
.text()取尖括號之間的值,也能夠進行設置。
.val()取的是框裏輸入的內容，也能夠設置。
parseInt()轉換類型爲int。
設置延時，將digg_tips的值設置爲空，在1s以後：
setTimeout(function () {
$('#digg_tips').text('')
},1000);
F和Q操做：
from django.db.models import F，Q
在查詢的時候有時須要用數據庫自己的字段，須要用到F
給Article表的讚的數量增長一
models.Article.objects.filter(pk=article_id).update(up_like_count=F('up_like_count')+1)
filter()中的操做都是進行AND，若是須要OR就要用Q操做
示例1： 查詢做者名是a或b的
models.Book.objects.filter(Q(authors__name="a")|Q(authors__name="b"))
你能夠組合& 和| 操做符以及使用括號進行分組來編寫任意複雜的Q 對象。同時，Q 對象可使用~ 操做符取反，這容許組合正常的查詢和取反(NOT) 查詢。
示例：查詢做者名字是a而且不是2018年出版的書的書名。
>>> models.Book.objects.filter(Q(author__name="a") & ~Q(publish_date__year=2018)).values_list("title")
查詢函數能夠混合使用Q 對象和關鍵字參數。全部提供給查詢函數的參數（關鍵字參數或Q 對象）都將"AND」在一塊兒。可是，若是出現Q 對象，它必須位於全部關鍵字參數的前面。
例如：查詢出版年份是2017或2018，書名中帶a的全部書。 >>> models.Book.objects.filter(Q(publish_date__year=2018) | Q(publish_date__year=2017), title__icontains="a")
模板語言顯示多少樓，從1開始
#{{ forloop.counter }}樓
html中的空格
 
前端日期格式化
{{create_time|date:'Y-m-d H-i'}}
python 中datetime類常見：
datetime.datetime.now()
datetime.date
date.time
JS字符處理
根據字符取索引
.indexOf();
根據索引取字符
.charAt(3)
切片 包括前面不包括後面
.slice(1,5)
var 定義變量時，子做用域中加var是局部變量，不加是全局變量。
$('[name='xxx']') 應該算是屬性選擇器。
ajax添加評論是經過字符拼接html代碼，而後append到指定地方。
評論樹：後端把全部本篇文章評論傳給前端，在前端構建評論樹。Jsonrespoonse若是返回的不是字典須要設置safe=False
<script>
var article_nid = $('#info').attr('article_obj_nid');
$.ajax({
url: 'blog/comment_tree/' + article_nid + '/',
type: 'GET',
success: function (data) {
$.each(data,function (k,comment) {
{#構建comment_item代碼塊#}
var s='<div class="comment_item" my_id='+comment.nid+' parent_comment_id='+comment.parent_comment_id+'> <span>'+comment.content+'</span> </div>'
{#若是是子評論#}
if(comment.parent_comment_id){
var parent_comment_id=comment.parent_comment_id
{#找到父評論，添加進父評論#}
$('[my_id='+parent_comment_id+']').append(s)
}
{#根評論，直接添加#}
else{
$('.comment_tree ').append(s)
}
})
}
})
</script>
js
def comment_tree(request,article_nid):
comment_list=models.comment.objects.filter(article=article_nid).values()
comment_list=list(comment_list)
# print(comment_list)
return JsonResponse(comment_list,safe=False)
views.py
富文本編輯器kindeditor，須要下載引入
# 文章上傳圖片
def article_updown_pic(request):
# 獲取文件句柄，文件名能夠經過print（request.POST）看出
import os,json
from Blog_2 import settings
img_obj=request.FILES.get('imgFile')
# 經過路徑拼接，把文件（圖片）寫到對應位置。由於是全部人都能看，因此放到media中
path = os.path.join(settings.MEDIA_ROOT, 'article_add_img',img_obj.name )
print(img_obj)
print(type(img_obj))
with open(path,'wb') as f:
for i in img_obj:
f.write(i)
# 這裏返回是爲了讓圖片成功在textarea框裏預覽
ret={
# 這裏的參數不知道在哪找的
'error':0,
'url':'/media/article_add_img/'+img_obj.name,
}
return HttpResponse(json.dumps(ret))
views.py
部分js代碼 處理上傳文件（圖片）
<script>
KindEditor.ready(function(K) {
{#textarea的id#}
window.editor = K.create('#article_content',{
{#相關文檔中發送文件的url和發送的額外參數#}
uploadJson:'/article_updown_pic/',
extraFileUploadParams:{
csrfmiddlewaretoken:$("[name='csrfmiddlewaretoken']").val(),
},
});
});
</script>
js
beautifulsoup實現對desc的提取和過濾非法的標籤
from bs4 import BeautifulSoup
bs=BeautifulSoup(字符串,'html.parser')
desc=bs.text[:150]+'...'（把html代碼中的標籤去掉，只要文字,取前150個字符，最後加...）
過濾非法標籤,如script標籤。
find_all()是找到全部標籤，也能夠直接加標籤名參數，是找到對應標籤。
for tag in bs.find_all():
if tag.name in ['script，...']:
刪除在 ['script，...']中的標籤
tag.decompose()
left join和inner join的區別：
left join(左聯接) 返回包括左表中的全部記錄和右表中聯結字段相等的記錄
right join(右聯接) 返回包括右表中的全部記錄和左表中聯結字段相等的記錄
inner join(等值鏈接) 只返回兩個表中聯結字段相等的行
什麼是url
協議:// IP:端口/路徑？路徑參數
***Xadmin
路由分發 視圖函數部分換成 ([路由語句],None,None)
re_path(r'^test/',([
re_path(r'^test1$',test1),
],None,None)),
路徑訪問test/test1 才能正常訪問到
路由分發中的^和$,限定必須以什麼開頭和結尾。
經過查看源碼模仿admin自定義對錶的增刪改查url設計
"""xadmin_12_9 URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/2.0/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path,re_path
from django.shortcuts import HttpResponse,render
def test1(request):
return HttpResponse('test1')
def show_view(request):
return HttpResponse('show_view')
def edit_view(request,id):
return HttpResponse('edit_view')
def add_view(request):
return HttpResponse('add_view')
def delete_view(request,id):
return HttpResponse('delete_view')
def func_2():
lst=[]
lst.append(re_path(r'^$',show_view))
lst.append(re_path(r'^add$',add_view))
lst.append(re_path(r'^(\d+)/edit$',edit_view))
lst.append(re_path(r'^(\d+)/delete$',delete_view))
return lst
def func():
lst=[]
# 查看源碼知道admin.site.register(Book，book_admin)註冊的類都存在_registry這個字典中
# self._registry[model] = admin_class(model, self)
# 字典的鍵爲類，如Book,值爲book_admin對象，若不傳，默認爲ModelAdmin對象
for model,admin_class_obj in admin.site._registry.items():
app_name=model._meta.app_label #類對應的app名
model_name=model._meta.model_name #類對應的小寫表名
lst.append(re_path(r'^%s/%s/'%(app_name,model_name), (func_2(),None,None)),)
return lst
urlpatterns = [
re_path(r'^test/',([
re_path(r'^test1',test1),
],None,None)),
path('admin/', admin.site.urls),
re_path(r'^xadmin/', (func(),None,None)),
]
urls.py
django啓動時，會把settings.py中INSTALLED_APP中導入的所有執行一次，發現執行'app01.apps.App01Config'的父類AppConfig，中含有ready方法，在子類中重寫在django啓動時就會運行，經過模仿admin得知autodiscover_modules('Xadmin')自動執行每個app的Xadmin。
在類中，@property是屬性，定義時像方法，使用時像字段，不三不四。
換個角度看問題，換一種編程思想，有時候能方便不少。
HTML:
table標籤
<table>
<thead>
<tr>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td></td>
</tr>
</tbody>
</table>
from django.utils.safestring import mark_safe
使django不作處理，展現a標籤
return mark_safe('<a href="%s">編輯</a>'%(reverse('edit',args=(obj.pk,))))
對model的操做：
model._meta.model_name 類名小寫
model._meta.app_label 所在app的名字
model._meta.get_field(字段名).verbose_name 取字段的vervose_name
model._meta.get_field(字段名)這部分就是獲得某個model（表）的字段對象。
url反向解析
url(r'^home', views.home, name='h1'),
url(r'^home/(\d*)', views.index, name='h2'),
模板中使用生成URL {% url 'h2' 2012 %}
函數中使用生成URL reverse('h2', args=(2012,)) 路徑:django.urls.reverse
Model中使用獲取URL 自定義get_absolute_url() 方法
python 字典items()函數以列表返回可遍歷的(鍵值)元組數組。通常用在for循環中。
ManyToMany實例：
class Tag(models.Model):
'''標籤表'''
nid = models.AutoField(primary_key=True)
title = models.CharField(max_length=32)
blog = models.ForeignKey(to='Blog', to_field='nid',on_delete=models.DO_NOTHING)
def __str__(self):
return self.title
class Meta:
verbose_name = '標籤'
verbose_name_plural = verbose_name
class Article(models.Model):
'''文章表'''
nid = models.AutoField(primary_key=True)
user = models.ForeignKey(to='UserInfo', to_field='nid',on_delete=models.DO_NOTHING)
title = models.CharField(max_length=32)
desc = models.CharField(max_length=256)
create_time = models.DateTimeField(auto_now_add=True)
classification = models.ForeignKey(to='Classification', to_field='nid',null=True,blank=True,on_delete=models.DO_NOTHING)
comment_count=models.IntegerField(default=0,verbose_name='評論數')
up_like_count=models.IntegerField(default=0,verbose_name='點贊數')
down_like_count=models.IntegerField(default=0,verbose_name='踩數')
tags=models.ManyToManyField(
# 和那張表進行關聯
to='Tag',
# 中間表
through='Article_to_Tags',
# 關聯方向是 article ->tag
through_fields=('article','tag'),
)
def __str__(self):
return self.title
class Meta:
verbose_name = '文章'
verbose_name_plural = verbose_name
class Article_to_Tags(models.Model):
'''文章-標籤表'''
nid=models.AutoField(primary_key=True)
article=models.ForeignKey(to='Article',to_field='nid',on_delete=models.DO_NOTHING)
tag=models.ForeignKey(to='Tag',to_field='nid',on_delete=models.DO_NOTHING)
class Meta:
verbose_name = '文章-標籤'
verbose_name_plural = verbose_name
def __str__(self):
return '%s-%s'%(self.article,self.tag)
models.py
dir()顯示相關信息時，當顯示的是對象時，對象的屬性和方法都會顯示，方法只顯示方法名。
a標籤添加get參數<a href="?page=..&o=.."></a>
三元運算
>>> a=10
>>> b=4
>>> c=a if a>b else b
>>> c
10
js的娛樂：
document.body.contentEditable=true;
queryset排序：
queryset.order_by('字段') -字段表示倒序
若是request.GET.get('字段‘)
是None，能夠設置一個默認值，request.GET.get('字段','默認值')
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)
ORM一些進階操做：如filter(qq__contains='')
# 獲取個數
#
# 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等於十一、2二、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)
View Code
python 動態構造類(構造類的特殊方法)：
type(name, bases, dict) 返回一個新的type對象. 基本上是 class 語句的動態形式.
參數: name , 字符串, 制定要構造類的名字, 賦給新對象的 __name__ 屬性;
bases，一個tuple，指定類的父類，賦給新對象的__bases__ 屬性;
dict， 字典類型，類中的成員，賦給新對象的__dict__ 屬性
例如：
>>> class X(object):
... a = 1
...
>>> X = type('X', (object,), dict(a=1)
通常狀況上面的X就和後面類名X同樣（習慣上，也比較方便）
在類中要知道__new__方法是在__init__方法以前執行的。
子類執行父類方法有兩種方式
super(子類名，self).父類的方法名()
父類名.父類中的方法(self,....)
在ModelForm中，
ModelForm類直接在前端顯示是空的標籤
ModelForm類(instance=model對象)， 如：.objects.get(nid=obj_nid) ，就會顯示對象有的信息在標籤裏。
ModelForm類(request.POST,instance=model對象)
form_obj=ModelForm類(request.POST,instance=model對象)
form_obj.save()就實現對當前對象數據的更新。
form_objform_obj=ModelForm類(request.POST)
form_obj.save()實現從新建立一行數據。
\r 表示將光標的位置回退到本行的開頭位置
\b 表示將光標的位置回退一位
有時候須要多試試：
就像m2m字段，能夠models.表的類.m2m字段.rel.model.all() 獲取對應m2m表的全部記錄
form_obj.instance.m2m字段.all() 得到當前記錄m2m字段已有的記錄。
form表單中onsubmit=""是當提交表單時觸發
<form method="post" onsubmit="return selected_data();">
的，要加上return ，對應函數應該返回True，才能正常提交表單。(暫時不作深究)
*arg和**kwargs
*arg表示任意多個無名參數，類型爲tuple;
# *容許你傳入0個或任意個參數，這些可變參數在函數調用時自動組裝爲一個tuple。
**kwargs表示關鍵字參數，爲dict
# **,關鍵字參數容許你傳入0個或任意個含參數名的參數,這些關鍵字參數在函數內部自動組裝爲一個dict。例如函數名(a=1,b=2)
<i> 標籤顯示斜體文本效果。
<i> 標籤和基於內容的樣式標籤 <em>相似。它告訴瀏覽器將包含其中的文本以斜體字（italic）或者傾斜（oblique）字體顯示。若是這種斜體字對該瀏覽器不可用的話，可使用高亮、反白或加下劃線等樣式。
定位（position）
static
static 默認值，無定位，不能看成絕對定位的參照物，而且設置標籤對象的left、top等值是不起做用的的。
relative（相對定位）
相對定位是相對於該元素在文檔流中的原始位置，即以本身原始位置爲參照物。有趣的是，即便設定了元素的相對定位以及偏移值，元素還佔有着原來的位置，即佔據文檔流空間。對象遵循正常文檔流，但將依據top，right，bottom，left等屬性在正常文檔流中偏移位置。而其層疊經過z-index屬性定義。
注意：position：relative的一個主要用法：方便絕對定位元素找到參照物。
absolute（絕對定位）
定義：設置爲絕對定位的元素框從文檔流徹底刪除，並相對於最近的已定位祖先元素定位，若是元素沒有已定位的祖先元素，那麼它的位置相對於最初的包含塊（即body元素）。元素原先在正常文檔流中所佔的空間會關閉，就好像該元素原來不存在同樣。元素定位後生成一個塊級框，而不論原來它在正常流中生成何種類型的框。
重點：若是父級設置了position屬性，例如position:relative;，那麼子元素就會以父級的左上角爲原始點進行定位。這樣能很好的解決自適應網站的標籤偏離問題，即父級爲自適應的，那我子元素就設置position:absolute;父元素設置position:relative;，而後Top、Right、Bottom、Left用百分比寬度表示。
另外，對象脫離正常文檔流，使用top，right，bottom，left等屬性進行絕對定位。而其層疊經過z-index屬性定義。
反射的四個函數
又由於在Python中一切皆爲對象，因此把反射理解爲從對象中動態的獲取成員。
關於反射, 其實一共有4個函數:
- hasattr(obj, str) 判斷obj中是否包含str成員
- getattr(obj,str) 從obj中獲取str成員。
- setattr(obj, str, value) 把obj中的str成員設置成value。這⾥的value能夠是值，也能夠是函數或者⽅法。
- delattr(obj, str) 把obj中的str成員刪除掉。
CSRF設置的裝飾器
from django.views.decorators.csrf import csrf_protect,csrf_exempt
某個函數設置CSRF 免除CSRF
from django.utils.decorators import method_decorator
CBV設置前兩個裝飾器，不能直接在方法加裝飾器，須要在類前面加
@method_decorator(裝飾器名，name=dispatch)
WSGI是Web服務器網關接口。它是一個規範，描述了Web服務器如何與Web應用程序通訊，以及如何將Web應用程序連接在一塊兒以處理一個請求。
django中設置緩存
from django.core.cache import cache
cache.set(k,v,30) 設置鍵值對，和存儲在緩存中的秒數。
cache.get(k) 取到對應的值
string.ascii_letters是'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
string.digits是'0123456789'
在編寫form的鉤子函數時，self就是form生成的HTML代碼，能夠self.instance獲得傳進去的實例化對象。
<pre></pre>數據庫中存儲的什麼樣，前端顯示就是什麼樣。
判斷路徑是否存在用os.path.exist()
os.makedirs(path,exist_ok=True) exist_ok=True 不存在就建立，存在不會拋異常。
從request.FILES中得到的真實的文件。這個字典的每一個輸入都是一個UploadedFile對象——一個上傳以後的文件的簡單的包裝。
你一般會使用下面的幾個方法來訪問被上傳的內容：
UploadedFile.read（）：從文件中讀取整個上傳的數據。當心整個方法：若是這個文件很大，你把它讀到內存中會弄慢你的系統。你能夠想要使用chunks（）來代替，看下面；
UploadedFile.chunks()：若是上傳的文件足夠大須要分塊就返回真。默認的這個值是2.5M，固然這個值是能夠調節的。
例如：
with open('{}\{}'.format(enroll_data_dir,file_obj.name),'wb') as f:
for chunk in file_obj.chunks():
f.write(chunk)
django中批量建立，不用每次建立一個都想數據庫提交。
objs_list=[xxx(**kwargs),xxx(**kwargs),xxx(**kwargs),] 表名(所需參數)
models.xxx.objects.bulk_create(objs_list)
得到GET提交的字典形式request.GET.dict()
django ORM中對日期字段過濾須要傳入的是datetime.datetime類型
import datetime
對時間的加減操做
datetime.datetime.now() + datetime.timedelta(hours=-hour,minutes=-minute,seconds=-second,days=-7)
pycharm 修改端口
run->edit configurations ->有端口配置
.values() 以字典形式返回queryset，括號裏還能夠經過字段跨表查詢，括號裏用__是跨表查詢，用_是字段查詢。(對多個queryset對象進行的。)
.distinct()對queryset進行去重。
css去除邊上的空白
django ORM中的DateField和DateTimeField的區別：
DateField 日期字段，日期格式 YYYY-MM-DD，至關於Python中的datetime.date()實例。
DateTimeField 日期時間字段，格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，至關於Python中datetime.datetime()實例。
django路由中的分組命名匹配
分組命名匹配的正則表達式組來捕獲URL中的值並以關鍵字參數形式傳遞給視圖。 在Python的正則表達式中，分組命名正則表達式組的語法是(?P<name>pattern)，其中name是組的名稱，pattern是要匹配的模式。
例子：
url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
捕獲的值做爲關鍵字參數而不是位置參數傳遞給視圖函數。 例如，針對url /articles/2017/12/至關於按如下方式調用視圖函數：
views.month_archive(request, year="2017", month="12")
ORM中關於文件的字段：
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 上傳圖片的寬度保存的數據庫字段名（字符串）
請求方法
經常使用的請求方法有get(查詢),post(添加),put(更新),delete(刪除),patch(局部更新)
對於put和patch的一點區別：
patch方法用來更新局部資源，這句話咱們該如何理解？
假設咱們有一個UserInfo，裏面有userId， userName， userGender等10個字段。可你的編輯功能由於需求，在某個特別的頁面裏只能修改userName，這時候的更新怎麼作？
人們一般(爲徒省事)把一個包含了修改後userName的完整userInfo對象傳給後端，作完整更新。但仔細想一想，這種作法感受有點二，並且真心浪費帶寬(純技術上講，你不關心帶寬那是你土豪)。
因而patch誕生，只傳一個userName到指定資源去，表示該請求是一個局部更新，後端僅更新接收到的字段。
而put雖然也是更新資源，但要求前端提供的必定是一個完整的資源對象，理論上說，若是你用了put，但卻沒有提供完整的UserInfo，那麼缺了的那些字段應該被清空
補充:
最後再補充一句，restful只是標準，標準的意思是若是在你們都依此行事的話，溝通成本會很低，開發效率就高。但並不是強制(也沒人強制得了)，因此你說在你的程序裏把方法名從put改爲patch沒有任何影響，那是天然，由於你的後端程序並無按照標準對兩個方法作不一樣處理，她的表現天然是同樣的。
補充一下，PATCH 與 PUT 屬性上的一個重要區別還在於：PUT 是冪等的，而 PATCH 不是冪等的。
冪等是一個數學和計算機學概念，在計算機範疇內表示一個操做執行任意次對系統的影響跟一次是相同。
在HTTP/1.1規範中冪等性的定義是:
Methods can also have the property of "idempotence" in that (aside from error or expiration issues) the side-effects of N > 0 identical requests is the same as for a single request.
如：POST 方法不是冪等的，若反覆執行屢次對應的每一次都會建立一個新資源。若是請求超時，則須要回答這一問題：資源是否已經在服務端建立了？可否再重試一次或檢查資源列表？而對於冪等方法不存在這一個問題，咱們能夠放心地屢次請求。 來自https://segmentfault.com/q/1010000005685904
OrderedDict
使用dict時，Key是無序的。在對dict作迭代時，咱們沒法肯定Key的順序。
若是要保持Key的順序，能夠用OrderedDict：
>>> from collections import OrderedDict >>> d = dict([('a', 1), ('b', 2), ('c', 3)]) >>> d
注意，OrderedDict的Key會按照插入的順序排列，不是Key自己排序。
templates順序問題
django中render渲染頁面，先去項目templates下面匹配，而後按照app註冊順序去其下的templates下匹配，匹配不到就報錯。同理templatetags也是如此，因此要避免視圖名稱重複這個問題，通常在template下在建立一個python package，起名是app名(不會重複)，視圖就不會找錯了。
django的settings.py中
APPEND_SLASH 默認爲True，會在url後面自動加/。
當客戶端發送請求，當url前面均可以匹配到，後面缺乏一個/，服務端會給客戶端發一個重定向，重定向的地址後面自動加/，客戶端自動訪問加/的地址。
靜態文件路徑設置
#靜態文件的前綴 STATIC_URL = '/static/'
#靜態文件的路徑 STATICFILES_DIRS = ( os.path.join(BASE_DIR, "common_static"),
#app共有的靜態文件，好比：jqurey.js '/path/to/others/static/',#其餘靜態文件的路徑 )
CRM
js中對象[]的添加元素 對象.push()
.val()不只能夠獲取值還能夠設置值。
外部訪問 django
開開啓django時，使用0.0.0.0:xxxx，做爲ip和端口例如： python manage.py runserver 0.0.0.0:9000 而後在settings裏修改ALLOWED_HOSTS = []， 改成ALLOWED_HOSTS = ['*',]，注意不要漏掉「，」。
Auth模塊
from django.contrib import auth
auth.authenticate(username=,password=)
利用sshpass進行主機鏈接（輸入明文密碼，不用進行交互）
'sshpass -p {password} ssh {username}@{ip} -o StrictHostKeyChecking=no'
chmod變動文件或目錄的權限
chown變動文件或目錄的擁有者或所屬羣組
強制調用類的私有字段：_類名__字段名
Q查詢的其餘方式：
con=Q()
con.connector='OR'
for i in search_fields:
con.children.append(('%s__contains'%i,search_content))
#能夠把con看成查詢條件直接加進filter()中
View Code
ORM中對時間字段進行過濾
filter({'date__gt': datetime.datetime(2019, 4, 28, 0, 0, 0, 636064)}) 注意時間類型
對該類型時間的增減 下面是今天零點的時間
time_difference=datetime.datetime.now()+datetime.timedelta(hours=-hour,minutes=-minute,seconds=-second)
prop()獲取checkbox的屬性，也能夠設置屬性