django

Bertha 。 2021-12-01 13:22 221阅读 0赞

**django目录层级说明：**

manage.py--一个命令行工具，可以使我们用多种方式对Django项目进行设置  
　　project  
　　　　\_\_init\_\_.py--一个空文件，他告诉Python这个是一个包  
　　　　setting.py--配置文件  
　　　　urls.py--项目的url声明  
　　　　wsgi.py--项目与wsgi兼容的web服务器入口  
**基本操作：**  
　　设计表结构：  
　　　　班级表  
　　　　　　表明(grade)，字段\[班级名称(gname)，成立时间(gdate)，学生总数(gnum)，是否删除(isdelete)\]，  
　　　　学生表  
　　　　　　表明(student)，字段\[姓名(sname)，性别(sgender)，年龄(sage)，所属班级(sgrate)，是否删除\](isdelete)  
　　配置数据库：--Django默认使用sqlite数据库  
　　　在settings.py通过DATABASE选项进行数据库配置

DATABASES = \{  
　　　　　　'default': \{  
　　　　　　'ENGINE': 'django.db.backends.mysql',  
　　　　　　'NAME': 'baseName',  
　　　　　　'USER':'root',  
　　　　　　'PASSWORD':'123123',  
　　　　　　'HOST':'localhost',  
　　　　　　'PORT':'3306',  
　　　　　　\}  
　　　　\}  
　　配置mysql  
　　　　在\_\_init\_\_.py中写入  
　　　　　　import pymysql  
　　　　　　pymysql.install\_as\_MySQLdb()  
　　创建项目：

django-admin startproject proName  
　　创建应用：在一个项目中可以创建多个应用，每个应用进行一种业务处理  
　　　　cd my\_projectName  
　　　　python manage.py startapp appName  
　　　　目录说明：  
　　　　　　admin.py--站点配置  
　　　　　　models.py--模型  
　　　　　　views.py--视图  
　　激活应用：  
　　　　在settings.py文件中，将app应用加入到INSTALLED\_APPS中  
  
　　定义模型：  
　　　　有一个数据表，就对应有一个模型  
　　　　在models.py文件中定义模型  
　　　　　　from django.db import models  
　　　　　　模型类继承models.Model类  
　　　　　　class Grades(models.Model):  
　　　　　　　　gname = models.CharField(max\_length=20)  
　　　　　　　　gdate = models.DateTimeField()  
　　　　　　　　gnum = models.IntegerField()  
　　　　　　　　isdelete = models.models.BooleanField()  
　　　　　　class Students(models.Model):  
　　　　　　　　sname = models.CharField(max\_length=20)  
　　　　　　　　sgender = models..models.BooleanField()  
　　　　　　　　sage = models.IntegerField()  
　　　　　　　　\#关联外键  
　　　　　　　　sgrade = models.ForeignKey('Grades',on\_delete=models.)  
　　　　　　　　isdelete = models.models.BooleanField()  
　　　　　　　说明：不需要定义主键，主键会在生成时自动添加  
  
　　　　生成数据表：  
　　　　　　生成迁移文件  
　　　　　　执行<python manage.py makemigrations>  
　　　　　　执行迁移  
　　　　　　<python manage.py migrate>

测试数据操作：  
　　　　　　进入到python\_shell环境--执行<python manage.py shell>  
　　　　　　引入包：  
　　　　　　　　from myApp.modesl import Grades,Students  
　　　　　　　　from django.utils import timezone  
　　　　　　　　frome datetime import \*  
　　　　　　查询所有数据(类名.objects.all())：  
　　　　　　　　<Grades.objects.all()>  
  
　　　　　　添加数据：-本质：创建一个类的属性--创建对象  
　　　　　　　　<grade = Grades()  
　　　　　　　　grade.gname = 'python'  
　　　　　　　　....>  
　　　　　　　　<grade.save()>  
　　　　　　查看某个对象：  
　　　　　　　　Grades.objects.get(pk=1)  
  
　　　　　　修改数据：  
　　　　　　　　grade.gname=''  
　　　　　　　　grade.save()  
　　　　　　删除：--物理删除，一般不使用  
　　　　　　　　grade.delete()  
　　　　　　关联对象：  
　　　　　　　　获取python班级的所有学生  
　　　　　　　　grade.students\_set.all()  
　　　　　　　　创建学生属于哪个班级  
　　　　　　　　stu = grade.students\_set.create(sname='xiaozhang',sage=11,sgender=1,isdelete=0)  
　　　　　　　　他会直接添加到数据库中  
  
　　　　启动服务器：  
　　　　　　格式--Python manage.py runserver ip:port  
　　　　　　这是一个纯Python写的轻量级web服务器，仅仅在开发环境中使用  
  
　　　　Admin站点管理：  
　　　　　　内容发布  
　　　　　　负责添加、修改、删除内容  
　　　　　　公共访问  
  
　　　　配置Admin应用：  
　　　　　　在setting.py 中 INSTALLED\_APPS添加‘django.contrib.admin’  
　　　　创建管理员用户：  
　　　　　　进入目录  
　　　　　　python manage.py createsuperuser  
　　　　　　-->username  
　　　　　　-->email  
　　　　　　-->password  
　　　　汉化：  
　　　　　　settings.py -->LANGUAGE\_CODE='zh-Hans'  
　　　　　　-->TIME\_ZONE='Asia/Shanghai'  
  
　　　　管理数据表：  
　　　　　　修改admin.py文件  
　　　　　　from .models import Grades,Students

\#注册  
　　　　　　admin.site.register(Grades)  
　　　　　　admin.site.register(Students)  
  
　　　　自定义管理页面：  
　　　　　　列表页属性  
　　　　　　list\_display = \[\]  
　　　　　　list\_filter = \[\]  
　　　　　　search\_fields = \[\]  
　　　　　　list\_per\_page = \[\]

添加、修改页属性  
　　　　　　fields = \[\]-属性的先后顺序  
　　　　　　fieldsets = \[\]--分组  
  
　　　　　　fields与fieldsets不能同时使用  
  
　　　　关联对象：  
　　　　　　在创建一个班级时，可以直接创建几个学生  
　　　　　　class StudentsInfo(admin.TabularInline):  
　　　　　　model = Students  
　　　　　　extra = 2

\#注册  
　　　　　　class GradesAdmin(admin.ModelAdmin):  
　　　　　　\#必须有外键才行  
　　　　　　inlines = \[StudentsInfo\]  
  
　　　　布尔值显示问题  
  
　　　　　　执行动作位置  
　　　　　　actions\_on\_bottom = True  
  
　　　　使用装饰器完成注册  
　　　　　　@admin.register(Students)-替换-  
　　　　　　admin.site.register(Grades,GradesAdmin)  
  
　　　　视图的基本使用  
　　　　　　在Django中，视图对web请求进行的响应  
　　　　　　视图就是一个python函数，在views.py中定义  
　　　　　　定义视图：  
　　　　　　　　from django.http import HttpResponse  
　　　　　　　　\# Create your views here.  
　　　　　　　　def index(request):  
　　　　　　　　return HttpResponse('hahahahahahahahaha')  
　　　　　　配置url  
　　　　　　　　修改project目录下的urls.py文件  
　　　　　　　　在myapp目录下创建urls.py文件  
  
　　　　模板的基本使用：  
　　　　　　概述：模板是HTML页面，可以根据视图中传递过来的数据进行填充  
　　　　　　创建模板：在根目录下创建templates 目录，再创建myapp目录  
　　　　　　配置模板路径：  
　　　　　　修改settings.py文件-TEMPLATES-DIRS:\[os.path.join(BASE\_DIR,'templates')\]  
  
　　　　　　定义班级和学生模板  
　　　　　　　　模板语法：  
　　　　　　　　\{ \{输出值，可以是变量，也可以是对象.属性\}\}  
　　　　　　　　\{%执行代码段%\}  
  
  
　　　　流程梳理：  
　　　　　　创建工程目录 <django-admin startproject proName>  
　　　　　　进入工程目录  
　　　　　　创建项目 <python manage.py startapp myApp>  
　　　　　　激活项目 修改settings.py 中的INSTALL\_APPS  
　　　　　　配置数据库  
　　　　　　修改\_\_ini\_\_.py文件  
　　　　　　修改settings.py文件中的DATABASES  
  
　　　　　　创建模型类 在项目目录下的models.py中添加类  
　　　　　　生成迁移文件 <python manage.py makemigrations>  
　　　　　　执行迁移 <python manage.py migrate>  
　　　　　　配置站点：  
　　　　　　　　创建模板目录、项目模板目录--templates  
　　　　　　在settings.py文件中创建模板路径：os.path.join(BASE\_DIR,'templates')  
　　　　　　在project下修改urls.py  
　　　　　　在项目目录(myApp)下创建urls.py  
  
  
  
　　　　模型：models.py  
　　　　　　django对各种数据库提供了很好的支持，Django为这些数据库提供了统一的api，可以根据不同的业务需求选择不同的数据库  
　　　　　　配置数据库  
　　　　　　project下的\_\_init\_\_() 文件中修改  
　　　　　　　　import pymysql  
　　　　　　　　pymysql.install\_as\_MySQLdb  
　　　　　　修改settings.py文件；  
  
　　　　开发流程：  
　　　　　　配置数据库  
　　　　　　定义模型类  
　　　　　　生成迁移文件  
　　　　　　执行迁移  
　　　　　　使用模型类进行crud操作  
　　ORM  
　　　　对象-关系-映射  
　　　　根据对象的类型生成表结构；将对象列表的操作转换为sql语句；将sql语句查询到的结果转换为对象列表  
　　　　极大的减轻了开发人员的工作量；不需要面对因数据库的变更而修改代码  
　　　　定义模型：  
　　　　　　模型、属性、表、字段间的关系  
　　　　　　一个模型类在数据库中对应一张表，在模型类中定义的属性，对应该模型对应表中的一个字段  
　　　　定义属性  
　　　　　　概述：  
　　　　　　Django根据属性的类型确定一下信息  
　　　　　　当前选择的数据库支持字段的类型  
　　　　　　渲染管理表单时使用的默认HTML空间  
　　　　　　在管理站点最低限度的验证  
　　　　　　Django会为表增加自动增长的主键列，每个模型只能有一个主键列，如果使用选项设置某属性为主键列后，则Django不会再生成默认的主键列  
　　　　属性命名限制  
　　　　　　不能是python的关键字  
　　　　　　有与Django的查询方式，不用需使用连续的下划线  
　　　　库  
　　　　　　定义属性时，需要字段类型，字段类型被定义在Django.db.models.fields目录下，为了方便使用，被导入到Django.db.models中  
  
　　　　使用方式：  
　　　　　　导入 from django.db import models  
　　　　　　通过models.field 创建字段类型的对象，复制给属性  
　　　　逻辑删除---  
　　　　字段类型：  
　　　　　　autoField  
　　　　　　　　一个根据实际ID自动增长的IntegrField。通常不指定，如果不指定，一个主键字段将自动添加到模型中  
　　　　　　　　CharField(max\_length)  
　　　　　　　　字符串，默认的表单样式是TextInput  
　　　　　　TextField  
　　　　　　　　文本字段，一般不超过4000，默认的表单控件是Textarea  
　　　　　　IntegerField 整数  
　　　　　　　　DecimalField(max\_digits,None,decimal\_places None)  
　　　　　　　　使用python的decimal实例表示的十进制浮点数  
　　　　参数说明：  
　　　　　　DecimalField.max\_digits  
　　　　　　　　位数总数  
　　　　　　decimal\_places  
　　　　　　　　小数点后的数字位数  
　　　　　　FloatField  
　　　　　　　　用python的float实例来表示的浮点数  
　　　　　　BooleanField  
　　　　　　　　true/false  
　　　　　　NullBooleanField  
　　　　　　DateField()  
　　　　　　TimeFeild()  
　　　　　　DateTimeField()  
　　　　　　FileField  
　　　　　　　　一个文件上传字段  
　　　　　　ImageField  
　　　　　　　　继承了FileField，但会校验，必须是图片  
　　　　字段选项：  
　　　　　　null--  
　　　　　　blanke--允许空白  
　　　　　　db\_colum--字段名，  
　　　　　　db\_index 创建索引  
　　　　　　default  
　　　　　　primary\_key 主键  
　　　　　　unique 唯一约束  
　　　　关系：  
　　　　分类  
　　　　　　foreignKey-一对多，将字段定义在多的端  
　　　　　　ManyToManyField:多对多，定义在两端  
　　　　　　OneToOne 一对一，任意一段  
　　　　用一对多  
　　　　　　格式：  
　　　　　　对象.模型类小写\_set  
　　　　实例：  
　　　　　　grade.students\_set  
　　　　创建模型类：  
　　　　　　元选项：  
　　　　　　在模型类中定义Meta类，用于设置信息  
　　　　　　class Meta:  
　　　　　　db\_table=''--定义数据表名，推荐小写字母，如果不写，数据表名默认为项目名\_类名  
　　　　　　ordering=\[\]--对象的默认排序字段，获取对象的列表时使用  
　　　　　　ordering=\['id\]--升序  
　　　　　　ordering=\['-id'\]--降序  
　　　　　　注意：排序会增加数据库的开销  
　　　　模型成员：  
　　　　　　类属性  
　　　　　　　　objects--Manager类型的对象，与数据库进行交互  
　　　　　　　　当定义模型类时没指定管理器，则Django为模型创建一个模型为objects的管理器  
　　　　自定义管理器：  
　　　　　　stuObj = models.Manager()  
　　　　　　当自定义模型管理器，objects就不存在了  
　　　　　　自定义管理器Manager类  
　　　　　　模型管理器是Django的模型进行与数据库交互的接口，一个模型可以有多个模型管理器  
　　　　　　作用：向管理器类中添加额外的方法  
　　　　修改管理器返回的原始查询集  
　　　　　　重写get\_queryset()方法  
　　　　　　class StudentsManager(models.Manager):  
　　　　　　　　def get\_queryset(self):  
　　　　　　　　　　return super(StudentsManager,self).get\_queryset().filter(isDelete=False)  
　　　　创建对象  
　　　　　　向数据库中添加数据  
　　　　　　当创建对象时，Django不会对数据库进行读写操作，当调用save()方法时才与数据库进行交互，将对象保存到数据库中  
　　　　　　\_\_init\_\_()已经在基类(model.Model)中使用，在自定义的模型中无法使用  
　　　　方法：  
　　　　　　在模型类中添加一个类方法  
　　　　　　@classmethod  
　　　　　　def createStudetn(cls):  
　　　　在自定义管理器中添加一个方法  
　　　　数据查询：  
　　　　　　查询集-表示从数据库中获取的对象的集合  
　　　　　　查询集可以有多个过滤器  
　　　　　　过滤器就是一个函数，基于所给的参数限制查询机结果  
　　　　　　从sql角度来说，查询机与select语句等价，过滤器就像where条件  
  
　　　　　　查询集：  
　　　　　　　　在管理器上调用过滤器方法返回查询集  
　　　　　　　　查询集经过过滤器筛选后返回新的查询集，所以可以写成链式调用  
　　　　　　　　惰性执行--在创建查询集不会带来任何数据库的访问，直到调用数据时，才会访问数据  
　　　　　　　　直接访问数据的情况：  
　　　　　　　　　　迭代  
　　　　　　　　　　序列化  
　　　　　　　　　　与if合用  
　　　　　　　　　　返回查询集的方法称为过滤器  
　　　　　　　　　　all() --  
　　　　　　　　　　filter()--返回符合条件的数据  
　　　　　　　　　　filter(键=值)  
　　　　　　　　　　filter(键=值，键=值)  
　　　　　　　　　　filter(键=值),filter(键=值)  
　　　　　　　　　　exclude() --过滤符合条件的数据  
　　　　　　　　　　order\_by()--排序  
　　　　　　　　　　values()--一条数据就是一个字典，多个数据就返回一个列表  
　　　　返回单个数据  
　　　　　　get ()--返回一个满足条件的对象  
　　　　　　　　如果没有找到符合条件的对象，模型类会引发模型类.doesNotExists异常  
　　　　　　　　如果找到多条，也会引发一个异常模型类.MultipleObjectReturned  
　　　　　　count()-- 返回当前查询集中的对象个数  
　　　　　　first()--返回查询集中的第一个数据  
　　　　　　last()--最后一个  
　　　　　　exists()--判断查询集是否有数据，如果有，则True  
　　　　限制查询集：  
　　　　　　查询集返回列表，可以使用返回下表的方法进行限制，相当limit  
　　　　　　Studetns.objects.all()\[0:5\]  
　　　　　　注意：下标不能为负数  
  
　　　　查询集的缓存：  
　　　　　　每个查询集都包含一个缓存，来最小化的对数据库访问  
　　　　　　在新建的查询集中，缓存首次为空，第一次对查询集求值，会发生数据缓存，Django会将查询出来的数据进行缓存，并返回查询结果。以后的查询直接使用缓存  
　　　　字段查询：  
　　　　　　概述 :实现了sql语句中的where语句，作为方法filter(),exclude(),get()的参数  
  
  
　　　　属性名称\_\_运算符=值  
　　　　　　age\_\_> = 20  
　　　　外键  
　　　　　　属性名\_id  
　　　　转义：类似sql 中的like语句  
　　　　　　filter(sname\_\_contains=%)  
　　　　比较运算符  
　　　　　　exact--判断，大小写敏感  
　　　　　　filter(isDelete=False)  
　　　　　　contians--是否包含，大小写敏感  
　　　　　　Students.objects.filter(sname\_\_contains='张')  
　　　　　　startswith,endwith 以--开头或结尾  
　　　　　　Students.objects.filter(sname\_\_startsWith='张')  
　　　　　　以上四个在前面加上一个i，表示不区分大小写（icontians....)

isnull,isnotnull--是否为空  
　　　　　　..filter(sname\_\_isnull=False)  
　　　　　　in -- 是否包含  
　　　　　　..filter(pk\_\_in=2,4,6)  
　　　　　　gt--大于  
　　　　　　gte--大于等于  
　　　　　　lt--小于  
　　　　　　lte--小于等于  
　　　　　　..filter(sage\_\_gt=30)  
　　　　　　...  
　　　　　　year  
　　　　　　month  
　　　　　　day  
　　　　　　week\_day  
　　　　　　hour  
　　　　　　minute  
　　　　　　second  
　　　　　　..filter(lastTime\_\_year=2019)  
　　　　跨关联查询：  
　　　　　　处理join查询  
　　　　　　模型类名\_\_属性名\_\_比较运算符  
　　　　　　　　grade = Grades.objects.filter(students\_\_sname\_\_contains='xiaozhang')--查询xiaozhang的班级  
  
　　　　查询快捷--pk--代表主键  
  
　　　　聚合函数  
　　　　　　使用aggregate()函数返回聚合函数的值  
　　　　　　Avg--平均  
　　　　　　Count--  
　　　　　　Max  
　　　　　　Min  
　　　　　　Sum  
　　　　　　from django.db,models import Max  
　　　　　　maxAge = Students.objects.aggregate(Max(sage)  
  
  
　　　　F对象  
　　　　　　可以使用模型的A属性与B属性进行比较  
　　　　　　from django.db,models import F,Q  
　　　　　　Grades.objects.filter(ggirlnum\_\_gt=F('gboynum'))  
　　　　　　支持对象的算术运算  
　　　　　　Grades.objects.filter(ggirlnum\_\_gt=F('gboynum')+20)  
  
　　　　Q对象  
　　　　　　过滤器的方法中的关键字参数，条件为and模式  
　　　　　　进行or查询  
　　　　　　使用Q对象  
　　　　　　Students.objects.filter(Q(pk\_\_lt=3) | Q(sage\_\_gt=50))  
　　　　　　只有一个Q对象，就是用于匹配  
　　　　　　Students.objects.filter(Q(pk\_\_lt=3))--> Students.objects.filter(pk\_\_lt=3)  
  
　　　　　　Students.objects.filter(~Q(pk\_\_lt=3))--取反（非）

出现以下错误：  
File "E:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python37\\lib\\site-packages\\django\\db\\backends\\mysql\\operations.py", line 146, in last\_executed\_query  
query = query.decode(errors='replace')  
AttributeError: 'str' object has no attribute 'decode'  
把该文件下的第。。行的decode改为encode

转载于:https://www.cnblogs.com/35xiaoyi/p/11123236.html