django模型层

学生注册：
核心：模块化开发
1.新建应用，在终端输入python manage.PY startapp (应用名stu)
migration：迁移文件
admin.py：后台站点的配置信息
models.py：存放模型类，对数据库进行增删改查的
views,py：存放视图函数或者视图类
创建好新的应用后，要手动添加到seting中

什么是迁移文件：由模型类生成的文件，其实就是数据库表的映射文件
创建模型类：在modes.py中
class 表名(models.Mdodel)：
sname=models.CharField(max_length=30)
spwd=models.CharField(max_length=30)

创建好模型类后，映射到数据库中
1：生成迁移文件 在控制台输入 python manage.py makemigration 应用名
2：执行迁移文件 在控制台输入 python manage.py migrate
执行迁移文件后，在模型类型中设置的信息就会映射到数据库中，在数据库中刷新就会出现创建的表
在django中也会生成一个表，右键点击此表再点击As Data Source （第一次要下载驱动文件）然后点击Text Connection（测试是否连接成功） 再点击右下角的apply然后点击ok 就完成了在右边会出现一个database

在控制台 输入：
from 应用名 modles import *
对象1=表名（字段1=’‘，字段2=’‘）
例如：
stu=Student（sname=’zhangsan‘，spwd=’123‘）
这样在右边的database的表中就会更新数据

ORM：对象关系映射，只要开发者操作模型类对象就可以操作数据库，不需要通过sql语句，可以实现跨平台。只要在seting中更改就可以了

注册功能2

显示注册页面，设置访问路径：http://127.0.0.1:8000/stu/register

1，在跟路由中配置子路url（r’^stu/‘,include(‘应用名.urls’)）其中，include是加载的意思，目的是在根路由中加载子路由
2，在应用中创建python文件，名字就叫urls，执行的时候，先匹配根路由，然后在加载子路由，最后拼接，然后在urls中设置如下
from django.conf urls import url
import views
urlpatterns=[
url(r’^register/$’，views.register）
设置完成后alt+回车键，会 自动在views中创建register函数如下：

def register（requst）：
函数的功能主要是显示页面
return render（requst，‘register.html’）

然后在templates中创建html文件，文件名字就叫做register页面如下
。。。
。。。

{%csrf_token%}

姓名：

密码：

&emsp；：

3,配置路由在子路由中添加路由
url(r’^register/${}^{\prime }，views.register）url(r^{\prime r}egister/$’，views.do_register）同样alt+回车在views中创建处理注册请求页面如下
def register（requst）：
return render（requst，‘register.html’）

def do_register（requwst）：
1获取请求参数
sname=request.POST.get(‘sname’,’’)
spwd=request.POST.get(‘spwd’,’’)
2判断不能为空
if sname and spwd：
将数据插入到数据库中
stu=Student（sname=sname,spwd=spwd）
stu.save()
return HttpResponse(‘注册成功’)
return HttpResponse(‘注册失败’)

分析注册功能的执行过程
1，第一步，查看文档，查看项目架构，了解访问路径，建立应用，更改seting，创建模型类，创建牵引文件，执行牵引文件，在跟路由添加子路由，在应用中创建子路路由，在子路由中创建视图函数，响应html页面，创建html文件设置用户名，密码登陆等信息，在form表单中设置action（根路由/子路由），最后响应注册页面，需在urls中添加响应注册页面的子路由（action后面的子路由），然后获取请求信息，判断不为空，最后http返回注册侧是否成功 （先去根路由匹配，再去子路由中匹配）

注意：凡是需要响应的页面，全部都要添加子路由

m：模型层
v：视图层
t：模板层

admin后台站点完成注册操作
1，设置好迁移文件，执行迁移文件
2，在网页的地址栏输入admin/点击回车,会显示一个用户名和密码的html
3，在命令行输入 createsuperuser（创建超级用户）回车，输入用户名按回车，输入email回车，输入密码回车，就创建成功了，在进入后台站点
4，在seting中设置语言（LANGUAGE_COODE）改成’zh-Hans‘，把TIME_ZONE（时区）改成’Asia/Shanghai‘就变成中文了
5，进入admin.py文件中创建模型类如下：
from djiango.contrib import admin
from 应用文件.models import 表名
admin.site.register(表名)
然后进入models.py文件中重写__str__方法如下(作用是改变对象的输出)：
def str(self):
return self.name
6，在后台站点可以手动添加信息

查看所有学生的信息
1，在子路由列表中添加子路由
2，创建视图函数如下：
def StuList（request）：
stus=Student.object.all()
print(stus)
return render(request,‘stus.html’,{‘students’:stus})
3，创建stus.html如下：

{%for student in students%}

        <tr>
          <td>{{student.id}}<td>
          <td>{{student.sname}}<td>
          <td>{{student.spwd}}<td> 
        <tr>
    {%end for%}

编号		姓名		密码

影片展示
*1，把爬取的html拉取到数据库中，在pycharm中创建新的应用，更改seting文件，创建逆向模型类（在控制台输入 python manage.py insceptdb>应用名>models.py命令）完成此操作数据库中的表都会逆向生成在models.py文件中，然后留取自己想要的（其他删除掉）

2，显示影片页面：请求路径需要明确，get请求方式，配置路由，现在根路由中添加url（‘r^请求路径’，include（‘应用名.urls’））,然后在应用名下创建urls.py文件，配置子路由
from django.conf urls import url
import views
urlpatterns[url(r’^$’,views.showmovie)]
然后alt+回车创建页面展示的函数如下
from 应用名.nodels import Tmovie
def showmovie（request）：
1，查询表中的数据
movielist=Tmovie.object.all()
return fender(request,‘movie.html’,{‘movies’:movielist})

然后在templates中创建movie.html然后把之前准备好的素材复制到html中，只留下一组li标签然后进行循环{%for movie in movies%}然后把li标签中的文本改成{{t_movie.name}}同样的更改把影片描述改成{{t_movie.count}}，把图片信息改成{{t_movie.image}}就完成了

数据库原生分页语句：select * from 表名 limit 0，10；第一页显示10个
select * from 表名 limit 10，10；第二页显示10个

- # List item

---

分页原理： a[start:end]
设定：
num：当前页码 size：每页显示页码数 start end
1 2 0 2
2 2 2 4
3 2 4 6
n s （n-1）s ns

django 分页
0，获取当前的页码数 num=request.GET.get(‘num’,1)
num=int(num)

1，在根路由加载子路由，在应用中新建子路由，加载视图，定义展示的视图函数（获取所有信息例如：tmovies=TMovie.object.all().order_by(‘id’)表示的获取所有的页面信息然后进行排序(默认是升序)）

然后创建django分页对象 page_obj=Paginator（tmovies，12） 参数表示的是所有的信息和要每页要展示的信息

2，获取当前页的数据 per_page_list=page_obj.page（num)
per_page_list.next_page_num()表示的显示下一页的方法（django的自带函数）
per_page_list.previous_page_num()表示的上一页的方法大（也是django自带的方法）
在html中直接写 per_page_list.previous_page_num表示的上一页的方法大（也是django自带的方法）
在HTML这种直接写 per_page_list.next_page_num表示的显示下一页的方法（django的自带函数）
注意：在html中方法后面不加括号

3,return render(request,‘moviehtml’,{‘movies’:per_page_list})

字符数：6922 字数：410段落数：234
django.md

4,创建movies.html
要在html中判断是否有上一页和下一页，{% if moves.has_previous%}
上一页
{%end if %}
同理判断是否存在下一页

模型类：什么事模型类，模型类主要的作用是对数据库的曾删改查（crud）

模型类中的属性：表示数据库中的字段名

模型类中的属性对象：表示的是字段类型

模型类中的属性对象参数：表示的是字段的约束

模型类的定义方式： from django.db import models

模型类的查询语句:

查询全部数 例如：Tmovie.objects.aoll()

条件查询 例如：Tmovie.filter(name=‘流浪地球’)

获取表中的总记录：Tmovie.object.count()

以什么开始 例如 Tmovie.filter(name__startwith=‘n’)

以什么结束 例如 Tmovie.filter(name__endwith=‘n’)

不区分大小写 例如 Tmovie.filter(name__iendwith=‘N’)

包含 且不分大小写 例如 Tmovie.filter(name__icontains=‘N’)

返回多条记录 例如 Tmovie.objects.all()[4:6] 切片操作 从第四条读取两条啊记录

精确查找 例如 movie.filter(name__exact=‘流浪地球’) 等价于 Tmovie.filter(name=‘流浪地球’)

单表的增删改操作

增加数据 例如：Student.object.create(snaame=‘zs’,spwd=‘123’)

也可以创建对象的形式添加数据 例如：stu=Student（snaame=‘zs’,spwd=‘123’） stu.save（）也可以完成数据的增加操作

数据的删除：例如 Student.objects.get(id=‘4’).delect() 根据主键查询删后进行删除操作

批量删除 Student.object.filter(sname___startwith=‘z’).delete()删除以‘z’开头的sname

单表的修改：在模型类中，在控制台先创建对象，例如stu=Student（）.object.get(id=2)
stu.name=‘lisi’
stu.save()

另外一种修改方法是在控制台输入Studennt.object.filter(id=2).updata()也会完成修改的操作

创建后太站点，在admin.py文件中，输入admin.site。registrer（post）然后导包，在控制太输入createsuperuser

回车，在输入用户名，用户email，用户密码

在模型类中，常用的字段类型
CharField max_length （输入框）

TextField（文本框）

DataField（日期）

DataTimeField（日期加时间）

BooleanField（真假）

Integer（整数）

PositiveIntegerField（正整数）

一对一的对应关系OneToOneField类型，例如sno=models.OneToOneField(Student,primary_key=True)

一对多的关系

class Clazz(models.Model)

cno=models.AutoField(max_length=30）
cname=models.CharFIeld(max_length=30)

def __str__(self):
    return self.cname(在python3中的用法)

class Student(models.Model)

sno=models.AutoField(max_length=30）
sname=models.CharFIeld(max_length=30)
cls=models.Foreignkey(Clazz,on_delete=models.CASCADE)
def __str__(self):
    return self.sname(在python3中的用法)

这里班级是一，学生是多，所以学生表要设置关于班级的外键

多对多的关系

创建班级表
class Clazz（models.Model）:
cno=models.AutoField(primary_key=Ture)
cname=models.CharField(max_length=30)
def str(self):
return self.sname(在python3中的用法)

创建课程表
class Course（models.Model）:
courseid=models.AutoField(primary_key=Ture)
coursename=models.CharField(max_length=30)
def str(self):
return self.sname(在python3中的用法)

创建学生表

class Stuent(models.Model):
sno=models.AutoField(primary_key=Ture)
sname=models.CharField(max_length=30)
cls=models.Foreignkey(Clazz)设置外键
course=models.ManyToManyField(Course)

def __str__(self):
    return self.sname(在python3中的用法)

接口：

1硬件接口：比如usb接口

2软件接口：函数（）别人封装好的特定功能的函数供我们调用，需要传什么参数，返回什么值

模型类中的管理器，每个模型类都有一个默认的管理器对象objects

我们可以自定义管理器：
class CustoManage（models.Manager）:
def all(self):
##调用父类

• List item

的方法，然后过滤父类的方法,下面表示的是cno小于4的方法
return super(CustoManage,self).all().filter(cno__lt=‘4’)

自定义管理器方法之后，要赋给一个对象，然后在进行调用例如查看cno小于4的方法如下：

1首先把方法赋给变量
object= CustoManage（）

2 实例调用
clas.object.all()
这样就可以展示出clss里面cno小于4的数据

很多时候我们删除数据后还想恢复数据，那就用到了模型类里面的重写delete方法，例如：

class Student(models.Model):
sname=models.Charfield(max_length=30)
isdelets=models.Booleanfield(default=Ture)

def delete(self,using=none,keep_parents=False)
    self.isdelete=Ture

在删除某个对象之后，调用delete方法，例如，Student.objects.filter(isdelete=False)就会恢复之前删除的数据

去重，模型类名.objects.values(‘需要去重的字段名’).distinct（）

分组聚合函数与查询 模型类.objects.values(‘字段名进行分组’).annotate(a=avg(’’)这里需要别名)

例如获取每个班级的人数：Student.objects.values(‘cls’).annotate(c=count(’*’))

输出结果是QuerySet[{‘cls’:1,‘c’:2}]表示的是班级1，学生有有两个

子查询例如：
查询所有班级里面的最高成绩（逻辑是先获取每个班级的最高成绩，在进行分组，然后获取里面的最大值）
Student.objects.values(‘cls’).annotate(s=Sum(‘score’)).aggregate(m=Max(‘s’))

关联查询，等值连接查询（建议多表查询时使用正向查询） 例如：
Student.object.values(‘cls__cname’)查询结果如下
<QuerySet{‘cls__name’:‘Bpython’}>

原生查询1例如：
连接数据库
from django.db import connection
获取游标
cursor=connection.cursor()
执行数据库操作
cursor.execute(‘select cname from Student__clazz’)
通过fetchall（）获取数据
datas=cursor.fetchall（）
遍历datas获取所有数据
for da in datas：
print（da）
最后关闭cursor
cursor.close（）

原生查询2例如

模型类名.objects.raw(‘包含主键的SQL语句’)

Q查询F查询例如
from Student.models import *
from django.db.models import Q,F
Stu.object.filter(Q(sno=1))&Q(sanme=‘zhangsan’)

事物的原子性
事物的原子性指的的是：一件事物没成功，另外一件事物 也不会成功，具有一致性

具体操作如下：

from django.db.transaction import atomic
sname=models.CharField(max_length=30,unique=Ture)
cls=models.ForeignKey(Clazz,delete=models.CASCADE,relate_name=‘students’)
course=models.ManyToManyField(course)

@atomic
def save(self,force_insert=False,force_updata=False,using=none,updata_fiels=none):
获取班级对象
try:
self.cls=Clazz.object.get(cname=self.cname)
except Clazz.DoseNotExist:
self.cls=Clazz.object.create(cname=self.cname)
进行判断
1/0
super(Students,self).save(self,force_insert=False,force_updata=False,using=none,updata_fiels=none)

def__str__(self):
    return self.name(这里是python的用法)

运行结果：由于1/0为False 所以。无法添加到数据库，如果没有@atomic函数，在class班级表中会存入数据，但是有了@atomic，数据具有原子性，所以，每个表中都不会存入数据