django 就是一个后端的框架，每一个URL都对应一个处理函数，对应关系存储在 urls 文件中，而处理函数放在 所建立的 APP 下的 views 文件内。
现在我建立的项目文件名称为 mysite，app 为 blog，
在 mysite/blog 下建立一个static，用来存放 html 文件中要导入 js，image，jquery 等静态文件，放入一个 jquery 库，
# setting 配置文件最后添加
STATIC_URL = '/static/' // 别名，指代下面的 static
STATICFILES_DIRS=(
os.path.join(BASE_DIR, 'blog' 'static'),
)
templates 存放html文件，html 中引入 jquery 文件，就需要在 html 中引入下面的
{% load staticfiles %}
<script src="{% static 'jquery-3.3.1.min.js' %}"></script>
# 在浏览器端可以看到渲染之后的结果：
<script src="/static/jquery-3.3.1.min.js"></script>
# 跟一般引入没有差别
也可以用下面的来引入 jquery
<script src="/static/jquery-3.3.1.min.js"></script>
blog 下的 urls 文件，这个文件的作用就是来存放 URL 与处理函数的关系
from django.contrib import admin
from django.urls import path
from blog import views
urlpatterns = [
path('admin/', admin.site.urls),
path('show_time/', views.show_time), //添加这一条
]
blog 下的 views 文件，存放处理函数
from django.shortcuts import render
import time
def show_time(request):
# return HttpResponse("hello")
return render(request,"index.html",{"t":time.ctime()}) //返回一个时间
redirect 重定向，在函数的末尾返回一个重定向的网址，也就是使得django 返回执行 login URL 对应的函数
return redirect("/login")
redirect 和 render 有什么的差别呢，用 render 代替 redirect 时，URL 不会有变化，所以刷新之后还是会跳转到原来的网址，
（浏览器根本就不知道你现在的render后的网址，因为这个网页是服务器发给浏览器的，而不是浏览器用URL去请求的）
用 render 返回时还必须带上login返回的参数，也就是 login 函数有的参数用 render 返回也必须要有，那就写重复代码了
return render(request, "login.html")
Template 模版，组成：HTML代码＋逻辑控制代码
用 context 渲染 template 模版
在模版中，如果要调用从 context 中传入的变量（变量不管是list，dict，class对象，日期，等之类的都可以），需要用 dots 来调用值。
变量的过滤器 | （filter）
标签：{% tags %}
if，endif 结尾
{% if a > 200 %}
<p style="color: red;">
{% else %}
<p>
{% endif %}
libai</p>
for
# 在 views 定义 test = [234,'works']
<p> test: {{ test.0 | add:10 }} </p>
<p> test: {{ test.1 | upper }} </p>
{% for foo in test %}
<p>{{ forloop.counter }} : {{ foo }}</p>
{% endfor %}
输出结果：
1 : 234
2 : works
extend 继承模版，可以减少大量 html 的重复代码，建立一个 base.html 作为模版，在其他需要用到的html中直接引入即可，只修改需要改动的地方。
sqlite 数据库，
pycharm 默认连接的是sqlite数据库
# 在 setting 中可以看到默认的 databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# 在models文件中添加，创建一张表，
class Book(models.Model):
name = models.CharField(max_length=20)
price = models.IntegerField()
pub_data = models.DateField()
在命令行中输入terminal中 ：python manage.py makemigrations 创建表
python manage.py migrate
创建成功之后就可以在 pycharm 中连接 sqlite 数据库了
连接上后就可以在视图窗口中修改数据库的数据了
遇到报错：no such table: django_session
解决：生成默认表格就找得到了
笔记
model（数据库模型）------ORM-----
表与表之间的关系（两张表）
一对多
多对多
一对一
ORM------object relation mapping
python的类
class emp（）：
id=。。。
name=。。。 《======》 表
salary=。。。
e=emp（）
e.id
--------------------
单表操作
表记录的添加
方式一：
Book()
b=Book(name="python基础",price=99,author="yuan",pub_date="2017-12-12")
b.save()
方式二：
Book.objects.create()
Book.objects.create(name="老男孩linux",price=78,author="oldboy",pub_date="2016-12-12")
表记录的修改
方式一：
b=Book.objects.get(author="oldboy")
b.price=120
b.save()
方式二：
#update是QuerySet
Book.objects.filter(author="yuan").update(price=999)
表记录的删除：
Book.objects.filter(author="oldboy").delete()
表记录的查询（重点）：
book_list = Book.objects.filter(id=2)
book_list=Book.objects.exclude(author="yuan").values("name","price")
book_list=Book.objects.all()
book_list = Book.objects.all()[::2]
book_list = Book.objects.all()[::-1]
#first，last,get取到的是一个实例对象，并非一个QuerySet的集合对象
book_list = Book.objects.first()
book_list = Book.objects.last()
book_list = Book.objects.get(id=2)#只能取出一条记录时才不报错
ret1=Book.objects.filter(author="oldboy").values("name") #只取出字段为name的值
ret2=Book.objects.filter(author="yuan").values_list("name","price")
book_list= Book.objects.all().values("name").distinct()
book_count= Book.objects.all().values("name").distinct().count()
模糊查询 双下划线__
book_list=Book.objects.filter(name__icontains="P").values_list("name","price")
book_list=Book.objects.filter(id__gt=5).values_list("name","price")
多表操作（一对多）：
#添加记录
#publish_id=2
Book.objects.create(name="linux运维",price=77,pub_date="2017-12-12",publish_id=2)
#publish=object
Book.objects.create(name="GO",price=23,pub_date="2017-05-12",publish=publish_obj)
#查询记录（通过对象）
正向查询：
book_obj=Book.objects.get(name="python")
pub_obj=book_obj.publish----》书籍对象对应的出版社对象
pub_obj.name
反向查询：
pub_obj = Publish.objects.filter(name="人民出版社")[0]
pub_obj.book_set.all().values("name","price")
#查询记录（filter values 双下划线__）
#人民出版社出版过的书籍与价格
ret=Book.objects.filter(publish__name="人民出版社").values("name","price")
#python这本书出版社的名字
ret2=Publish.objects.filter(book__name="python").values("name")
#python这本书出版社的名字
ret3=Book.objects.filter(name="python").values("publish__name")
#北京的出版社出版书的名字
ret4=Book.objects.filter(publish__city="北京").values("name")
#2017年上半年出版过书的出版社的名字
ret5=Book.objects.filter(pub_date__lt="2017-07-01",pub_date__gt="2017-01-01").values("publish__name")
多表操作（多对多）：
创建多对多的关系 author= models.ManyToManyField("Author")（推荐）
书籍对象它的所有关联作者 obj=book_obj.authors.all()
绑定多对多的关系 obj.add(*QuerySet)
obj.remove(author_obj)
如果想向第三张表插入值的方式绑定关系： 手动创建第三张表
# class Book_Author(models.Model):
# book=models.ForeignKey("Book")
# author=models.ForeignKey("Author")
Book_Author.objects.create(book_id=2,author_id=3)
掌握：通过 filter values (双下换线)进行多对多的关联查询（形式和一对多）
复习
1.Cookie操作
- 客户端本地存储的键值对，每次请求浏览器都会带上cookie去访问
- 确认身份
2.Session操作
- 保存在服务器端的键值对，客户端会获得一个sessionid来标识，获取数据
3.URL路由
- /index -> views.函数
4.MTV
5.View中返回方式
- HttpResponse("内容")
- render(request,'模版路径',{ })
- redirect('URL')
6.启动
python manage.py runserver
7.创建project
django-admin startproject [project名称]
python manage.py startapp [app名称]
8.URL中有别名
[
('/index/(\d+)', func, name='xxoo')
]
9.setting.py 配置
STATICFILES_DIRS=(
os.path.join(BASE_DIR,'static'),
)
10.模版
{{ 变量 }}
{% for, if, %}
views.py
def func(request):
return render(request, 'index.html',{'arg':[1,2,4,5,6]})
index.html
{{ arg.2 }} 取第三个元素
11.数据库连接修改MySQL
默认：MySQLDB
python 3 要修改成pymysql
12.模版继承
block
extends
一个模版可以被多个子模版继承
13.request参数
- request.method
- request.GET
- request.POST.get
- request.POST.getlist('hobby')
14.外键
15.操作数据表
python manage.py makemigrations
python manage.py migrate
16.在html中使用别名指代静态文件路径
17.路由分发
18.数据操作
models.Tb.objects.all().delete()
models.Tb.objects.filter(条件).delete()
19.外键的添加
calss A(models.Model): 部门表
name = c.CharField(max_length=16,null=True,blank=True)
//black是admin里是否允许输入为空
class B():
title = c
fk = FK(A)
models.B.object.create(
title = '1',
fk = models.A.object.get(id=1)
)
models.B.object.create(
title = '1',
fk_id = 1
)
20.外键关联删除
21.URL匹配
[
('/index/(?P<nid>\d+)'),func
]
views.py
def func(request,nid):
pass
22.ORM
-Models中操作
- shell操作
对象 = models.Tb.object.get(id=1)
[对象,] = models.Tb.object.filter(id=1)
23.CSRF
24.自定义标签
25.XSS攻击
views.py
def func(request,nid):
return render(request,'x.html',{'k1':'v1','k2':'<h1>v2</h1>'})
x.html
{{ k1 }}
{{ k2 }}
页面输出：
v1
<h1>v2</h1>
{{ k1 }}
{{ k2|safe }}
页面输出：
v1
v2(加大加粗)
26.obj = models.Tb.objects.get(id=1)
obj.name = '新名称'
obj.save()
models.Tb.objects.filter(id=1).update(name="新名称")
27.多表查询 双下划线跨表查询
28.URL，namespace
30.迭代器
31.数据传递中，来回的都是字符串
django 的请求生命周期
也就是用户从URL访问服务器后发生的一系列事件，
request.GET 就是在请求头中的URL中获取数据，转成字典形式
request.POST 把请求体中的字符串转换成字典
urls.py 文件的正则匹配，要加$完整匹配
-请求响应Http
1.发送Http请求
2.服务器接收，根据请求头中的URL在路由关系表中进行匹配（从上到下）
3.匹配成功后，执行指定的views函数
URL -》 函数 ==》 FBV
URL -》 类 ==》 CBV
视图函数可以用function，也可以用类方法来接收，使用类，就要继承django为我们提供的父类，URL路由导航也要有所更改
#urls.py 中
path('CBV/', views.CBV.as_view()),
#views.py 中
from django.views import View
class CBV(View): // 继承 View 后，method为GET就会自动调用get方法，post类似
def get(self,request):
根据请求头中的 request.method 进行自动执行
return HttpResponse("CBV.get")
def post(self,request):
return HttpResponse("CBV.post")
在父类 View 中封装了dispatch方法，URL路由传递过来的URL和method首先会传到dispatch中，
用反射找到我们自定制的方法并执行。
用类方法来处理URL路由过来的事件，事件传递过来首先触发的是dispatch方法，可以在此处对 get 和 post 做日志记录等
from django.views import View
class CBV(View):
def dispatch(self, request, *args, **kwargs):
print('dispatch....')
ret = super(CBV,self).dispatch(request, *args, **kwargs)
return ret
def get(self,request):
return HttpResponse("CBV.get")
def post(self,request):
return HttpResponse("CBV.post")
上面的get和post方法在返回过程中，可以添加响应头，返回给客户端
def post(self,request):
ret = HttpResponse("CBV.post")
ret['c1'] = 'v2'
ret.set_cookie('c2', 'v2')
return ret
添加外键时报错：TypeError: init() missing 1 required positional argument: 'on_delete'
解决：cs = models.ForeignKey("Classes",on_delete=models.CASCADE)
要加上 on_delete 属性
在 filter， value， 条件中，外键如果要跨表查询，必须把 . 改为 __，可以跨多张表查询
# cs 为外键
# models.Student.objects.filter(cs.id = nid).delete() 这样不行，必须改为
models.Student.objects.filter(cs__id = nid).delete()
django 练习的一个在页面上对数据库的操作，文件太多，不好全发上来，只记录一些重要的，
# models.py 表格文件
from django.db import models
# Create your models here.
class Classes(models.Model):
title = models.CharField(max_length=32)
m = models.ManyToManyField("Teacher")
class Teacher(models.Model):
name = models.CharField(max_length=32)
class Student(models.Model):
username = models.CharField(max_length=32)
age = models.IntegerField()
gender = models.NullBooleanField()
cs = models.ForeignKey("Classes",on_delete=models.CASCADE)
下面是 classes 表的操作
# views 文件下的 Classes.py
from django.shortcuts import render,HttpResponse,redirect
from app01 import models
def get_classes(request): # 获取表格数据
class_list = models.Classes.objects.all()
for c in class_list:
print(c.m.all())
return render(request, "classes.html", {"class":class_list})
def add_classes(request): # 添加数据
if request.method == "POST":
title = request.POST.get("title")
print("title: ",title)
if title:
models.Classes.objects.create(title=title, )
back = "添加成功，你添加的字段为：" + '"'+ title + '"'
else:
back = "添加失败，你提交的是空字段。"
return render(request, "add_classes.html",{"back":back})
else:
return render(request, "add_classes.html")
def del_classes(request): # 删除数据
if request.method == "GET":
nid = request.GET.get("nid")
# print("---------------------------",nid)
# title = models.Classes.objects.filter(id=nid).values("title")[0]["title"]
# print("title: ", title)
models.Classes.objects.filter(id=nid).delete()
# back = "删除 " + nid + "," + title + " 成功。"
# return HttpResponse(back)
return redirect("/classes.html")
def edit_classes(request): # 编辑数据
if request.method == "GET":
nid = request.GET.get('nid')
data_list = models.Classes.objects.filter(id=nid)[0]
return render(request, "edit_classes.html", {"back":data_list})
elif request.method == "POST":
title = request.POST.get("title")
nid = request.POST.get("nid")
print("title: ", title)
print("nid: ", nid)
models.Classes.objects.filter(id=nid).update(title=title)
return redirect("/classes.html")
else:
return redirect("/classes.html")
def set_teachers(request): # 设置
if request.method == "GET":
nid = request.GET.get("nid")
teachers_list = models.Teacher.objects.all().values("id","name")
select_teachers = models.Classes.objects.filter(id=nid).values_list("m","m__name")
print(select_teachers)
select_teachers_id = list(zip(*select_teachers))[0]
print(select_teachers_id)
return render(request,"set_teachers.html",
{
"teachers_list":teachers_list,
"select_teachers_id":select_teachers_id,
"nid":nid
})
elif request.method == "POST":
teachers_list = request.POST.getlist("teachers_list")
nid = request.POST.get("nid")
print("------------------",teachers_list)
print(nid)
ret = models.Classes.objects.filter(id=nid)[0]
ret.m.set(teachers_list)
return redirect("/classes.html")
else:
return redirect("/classes.html")
def set_class(request): # 相对应的students 表的 ajax 删除
if request.method == "GET":
nid = request.GET.get("nid")
classes_list = models.Classes.objects.all()
cs = models.Student.objects.filter(id=nid).values("id","cs_id")
print(classes_list)
print(cs)
return render(request,"set_teachers.html",{
"nid":nid,
"classes_list":classes_list,
"cs":cs
})
与其相对应的 classes.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
.table{
margin-top: 50px;
margin-left: 50px;
color: red;
}
a{
text-decoration: none;
}
.add{
margin-left: 50px;
margin-top: 50px;
margin-bottom: -20px;
}
.classes{
float: left;
}
</style>
</head>
<body>
<div class="add">
<a href="/add_classes.html">添加</a>
</div>
<div class="classes">
<table border="1px" cellpadding="15px" cellspacing="4px" class="table">
<thead>
<tr>
<th>id</th>
<th>班级名称</th>
<th>老师</th>
<th colspan="4">操作</th>
</tr>
</thead>
<tbody>
{% for foo in class %}
<tr>
<th>{{ foo.id }}</th>
<th>{{ foo.title }}</th>
<th>
{% for i in foo.m.all.values %}
<span>{{ i.name }}</span>
{% endfor %}
</th>
<th><a href="/del_classes.html/?nid={{ foo.id }}">删除</a></th>
<th><a href="/edit_classes.html/?nid={{ foo.id }}">修改</a></th>
<th><a href="/set_teachers.html/?nid={{ foo.id }}">分配老师</a></th>
<th><a href="/set_class.html/?nid={{ foo.id }}">分配班级</a></th>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</body>
</html>
效果图
students.py 学生表操作
# views 下的 students.py 文件
from django.shortcuts import render,redirect,HttpResponse
from app01 import models
def get_students(request):
data_list = models.Student.objects.all()
return render(request, "students.html",{'students':data_list})
def add_student(request):
if request.method == "GET":
cs_list = models.Classes.objects.all().values("title","id")
return render(request, "add_students.html", {"cs_list":cs_list})
elif request.method == "POST":
username = request.POST.get("username")
age = request.POST.get('age')
gender = request.POST.get('gender')
cs= request.POST.get('cs')
models.Student.objects.create(username=username,age=age,gender=gender,cs_id=cs)
return redirect("/students.html")
else:
return redirect("/students.html")
def del_students(request):
if request.method == "GET":
nid = request.GET.get('nid')
models.Student.objects.filter(id=nid).delete()
return redirect("/students.html")
def edit_students(request):
if request.method == "GET":
nid = request.GET.get("nid")
data_dic = models.Student.objects.filter(id=nid)[0]
class_dic = models.Classes.objects.all().values("title","id")
print(class_dic)
return render(request, "edit_students.html",{"data_dic":data_dic,"class_dic":class_dic})
elif request.method == "POST":
nid = request.POST.get("nid")
username = request.POST.get("useranme")
gender = request.POST.get("gender")
age = request.POST.get("age")
cs = request.POST.get("cs")
models.Student.objects.filter(id=nid).update(
username=username,
gender=gender,
age=age,
cs_id=cs
)
return redirect("/students.html")
else:
return redirect("/students.html")
students.html 文件，包含了 ajax
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
.table{
margin-top: 50px;
margin-left: 50px;
color: red;
}
a{
text-decoration: none;
}
.add{
margin-left: 50px;
margin-top: 50px;
margin-bottom: -20px;
}
.classes{
float: left;
}
</style>
</head>
<body>
<div class="add">
<a href="/add_students.html">添加</a>
</div>
<div class="classes">
<table border="1px" cellpadding="15px" cellspacing="4px" class="table">
<thead>
<tr>
<th>id</th>
<th>姓名</th>
<th>年龄</th>
<th>性别</th>
<th>班级</th>
<th colspan="3">操作</th>
</tr>
</thead>
<tbody>
{% for foo in students %}
<tr nid="{{ foo.id }}">
<th>{{ foo.id }}</th>
<th>{{ foo.username }}</th>
<th>{{ foo.age }}</th>
{% if foo.gender %}
<th>男</th>
{% else %}
<th>女</th>
{% endif %}
<th>{{ foo.cs.title }}</th>
<th><a href="/del_students.html/?nid={{ foo.id }}">删除</a></th>
<th><a onclick="ajax_del(this)">Ajax删除</a></th>
<th><a href="/edit_students.html/?nid={{ foo.id }}">修改</a></th>
</tr>
{% endfor %}
</tbody>
</table>
</div>
<script src="/static/jquery-3.3.1.min.js"></script>
<script>
function ajax_del(that) {
var nid = $(that).parent().parent().attr("nid");
$.ajax({
url: "/ajax_del.html",
type: "get",
data : {"nid":nid},
success:function (arg) {
if (arg == "successful"){
console.log(arg);
$(that).parent().parent().remove()
}else{
alert(arg);
}
}
})
}
</script>
</body>
</html>
setting 设置静态文件路径，设置MySQL数据库，static 和 打印 数据库 操作的日志
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'books', #你的数据库名称
'USER': 'root', #你的数据库用户名
'PASSWORD': '89828', #你的数据库密码
'HOST': '', #你的数据库主机，留空默认为localhost
'PORT': '3306', #你的数据库端口
}
}
STATIC_URL = '/static/'
STATICFILES_DIRS = (
os.path.join(BASE_DIR, 'static'),
)
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
基本就上传这么多了，剩下的就打包到百度云上去了，方便日后查找。
链接：https://pan.baidu.com/s/1-ARhbM8BtT_Ac59sTo1oNw 密码：h5vz
笔记：
from django.db import models
班级：
id name
1 3班
2 6班
class School:
name = models.CharField(max_length=32)
class Classes(models.Model):
"""
班级表,男
"""
titile = models.CharField(max_length=32)
# m = models.ManyToManyField('Teachers') # 多对多
# sch = models.ForeignKey(School)
老师：
id title
1 Alex
2 老妖
3 瞎驴
4 Eric
class Teachers(models.Model):
"""
老师表，女
"""
name = models.CharField (max_length=32)
学生
id username age gender cs_id
1 东北 18 男 1
2 东北1 118 男 2
2 东北1 118 男 1
class Student(models.Model):
"""
学生表
"""
username = models.CharField(max_length=32)
age = models.IntegerField()
gender = models.BooleanField()
cs = models.ForeignKey(Classes) #
示例：
- 所有学生的姓名以及其所在班级名称,QuerySet,也就是列表类型
stu_list = Student.objects.all()
select * from tb;
[obj,obj,obj,obj] 拿到的是对象，对象 obj.name 就可以访问属性
stu_list = Student.objects.all().values("id",'username')
select id,username from tb;
[{"id":1,'username':'xx'},{id:'',username:''}] value 拿到的是列表内封装的字典
stu_list = Student.objects.all().values_list("id",'username')
[(1,'root'), (2,'alex')] value_list 拿到的是列表内封装的元组
stu_list = Student.objects.all().values('username',"cs__name") cs__name 跨表查询
for row in stu_list:
print(row['username'],row['cs__name']) 遍历 stu_list ,记住，row为字典
stu_list = Student.objects.all().values('username',"cs__titile",“cs__fk__name”)
- 找到3班的所有学生
Student.objects.filter(cs__name='3班')
obj = Classes.objects.filter(name='3班').first()
1. 类代表数据库表
2. 类的对象代指数据库的一行记录
3. FK字段代指关联表中的一行数据（类的对象）
4.
- 正向：fk字段 (*****能用正向就用正向)
- 反向：小写类名_set(默认) ==> related_name='ssss'
假设存在两张表class和student，student的外键fk关联class表，cs = models.ForeignKey(Classes)
那么从cs就可以直接指向class表的某个数据，反过来，从class表也可以指向student表，
所得出的list为student下同一个指定老师的集合，通过obj.student_set.all() ,obj 为所选择的某个class对象
也可以更改默认反向默认查找字段，在 cs = models.ForeignKey(Class,related_name="ssss")
5. 谁是主表？就全部列出其数据
models.Student.objects.all().values('username', 'cs__titile') 列出所有学生的数据，包括班级
models.Classes.objects.all().values('titile', 'ssss__username') 列出所有班级的数据，
values 列出来的数据不为对象，为值
4. M2M字段，自动生成第三张表；依赖关联表对第三张表间接操作
Classes 添加 m = manytomany字段，关联Student
obj.m.all() 列出关联学生的所有老师
obj.m.add(3) 添加
obj.m.set([1,2]) 设置，不为1,2的删除
在student表中的对象也可以关联
obj.classes_set.all() 等
对话框添加，删除，修改：
添加：
Ajax偷偷向后台发请求：
1. 下载引入jQuery
2.
$.ajax({
url: '/add_classes.html',
type: 'POST',
data: {'username':'root','password': '123'},
success:function(arg){
// 回调函数，arg是服务端返回的数据
// window.location.reload(); JS 主动刷新页面
}
})
ajax补充：data: $("#fm").serialize()
yuan 老师的博客：
Http 协议：http://www.cnblogs.com/yuanchenqi/articles/6000358.html
django : http://www.cnblogs.com/yuanchenqi/articles/6083427.html
网友评论