点击Django跳到阅读点

文章目录

• Django
• • windows安装
• 设计模式与模板层
• • MVC
  • MTV
  • • M模型层
    • • 应用
      • • 分布式路由
        • 模板
      • **模型
      • **ORM框架
      • **模型创建
      • Meta类
      • **模型使用
    • T模板层
    • • 模板配置
      • 加载模板
      • 模板变量
      • 模板标签
      • 过滤器
      • 继承
      • 静态文件
• ORM模型CRUD
• • 数据库设置
  • 字段类型
  • 字段选项
  • 关系映射
  • 创建数据
  • • Django Shell
  • 查询操作
  • 更新操作
  • 删除操作
  • F&Q
  • 聚合查询
  • 原生数据库
• 数据库使用
• • 数据库设置
  • 字段类型
  • 字段选项
  • 关系映射
• 入门使用
• • 创建项目
  • pycharm配置
  • 运行项目
  • 创建应用(startapp)
  • 创建view
  • 创建模型(数据库表)
  • 激活模型
• Cookie&Session
• Admin后台
• 函数
• • path()
  • render()
  • HttpResponseRedirect
• 功能
• • URL
  • url反向解析
  • url跳转&页面跳转&传参
  • 请求传参的四种方式
  • Django中的请求
  • Django响应
  • 请求响应
  • setting文件
  • 路由配置
• 基础
• • Django中的请求
  • Django响应
  • http请求
  • HTTP响应
• 项目开发
• • http请求
  • HTTP响应
• 项目开发

Django

下载网站

https://www.python.org/downloads/windows/

Django 是在快节奏的新闻编辑室环境中开发的，所以它旨在使常见的 Web 开发任务变得快速而简单

windows安装

• 在 Windows 上安装 Python 3.8 和 Django3.2.10

• 解压Django到文件夹，在进到解压目录，在cmd中运行python setup.py install

• 等运行完，cmd测试是否成功

• >python
  Python 3.8.7 
  >>> import django
  >>> django.get_version()
  '3.2.10'
  >>>
  

设计模式与模板层

MVC

MVC代表Model-View-Controller (模型-视图-控制器)模式。

• M 模型层(Model),主要用于对数据库层的封装
• V 视图层(View),用于向用户展示结果 (WHAT + HOW )
• C 控制(Controller ,用于处理请求、获取数据、返回结果(重要)

MTV

核心逻辑代码跳到V中

MTV代表Model-Template-View(模型-模板-视图)模式。

• M 模型层(Model)负责与数据库交互
• T 模板层(Template)负责呈现内容到浏览器(HOW)
• V 视图层(View）是核心，负责接收请求、获取数据、返回结果(WHAT)

M模型层

应用

应用在Django项目中是一个独立的业务模块,

可以包含自己的路由,视图,模板,模型

• 创建应用文件夹
  • python manage.py startapp name
• 安装此应用
  • settings.py配置INSTALLED_APPS = [name , … , …]

├─name ''' 小MTV结构 '''
│  │  admin.py	#管理
│  │  apps.py
│  │  models.py	#数据库相关
│  │  tests.py
│  │  views.py	#视图逻辑
│  │  __init__.py
│  │
│  └─migrations  #数据库
│          __init__.py

分布式路由

Django中，

主路由配置文件(urls.py)可以不处理用户具体路由，

主路由配置文件的可以做请求的分发(分布式请求处理)。

具体的请求可以由各自的应用来进行处理

创建应用内的URLS
1 主路由中调用include函数，用于
	将当前路由转到各个应用的路由配置文件的urlpatterns进行分布式处理
    include('app名字.url模块名')
    例如：
       path('music/',include(music.urls)),
    
2 setting中添加应用（就是添加目录）
	例如：
    INSTALLED_APPS = [
    'django.contrib.staticfiles',
    'music',]	#否则目录下的模板可能找不到 	
		
3 配置应用内urls.py
	from . import views
	urlpatterns = [
  	  path('admin/', admin.site.urls),
  	  path('index',views.index_view)
	]              

模板

应用内部可以配置模板目录

• 应用下手动创建templates文件夹
• settings.py中开启应用模板功能
  • TEMPLATE 配置项中的'APP_DIRS'值为True 即可
• 应用下templates和外层templates都存在时，django得查找模板规则
  • 1．优先查找外层templates目录下的模板
  • 2．按INSTALLED_APPS配置下的应用顺序逐层查找

TEMPLATES = [
    {  'APP_DIRS': True, }]

**模型

模型层,与数据库交互

什么是模型？

模型是一个Python类，它是由django.db.models.Model派生出的子类。

• 一个模型类代表数据库中的一张数据表
• 模型类中每一个类属性都代表数据库中的一个字段。
• 模型是数据交互的接口，是表示和操作数据库的方法和方式

**ORM框架

ORM (Object Relational Mapping)即对象关系映射，

它是―种程序技术，

它允许你使用类和对象对数据库进行操作,从而避免通过SQL语句操作数据库

• 建立模型类和表之间的对应关系，允许通过面向对象的方式来操作数据库。
• 根据设计的模型类生成数据库中的表格。
• 通过简单的配置就可以进行数据库的切换。

优点:
只需要面向对象编程，不需要面向数据库编写代码.
对数据库的操作都转化成对类属性和方法的操作.
不用编写各种数据库的sql语句.
实现了数据模型与数据库的解耦,屏蔽了不同数据库操作上的差异.
不在关注用的是mysql、oracle...等数据库的内部细节.
简单的配置就可以轻松更换数据库.而不需要修改代码

缺点:
对于复杂业务，使用成本较高
根据对象的操作转换成SQL语句,根据查询的结果转化成对象，在映射过程中有性能损失.

映射关系

ORM	DB
类	数据表
对象	数据行
属性	字段

**模型创建

class模型类名(mode1s.Mode1) :
字段名= models.字段类型(字段选项)

1.创建app
	python manage.py startapp bookstore
    
2.写模型models.py
'''from django.db import models
class Book(models.Model):
    title = models.charFie1d("书名",max_length=50,default=' ')
    price = models.DecimalFie1d('定价',max_digits=7,decimal_places=2,defau1t=0.0)
    '''
    
3.数据库迁移
Django同步对模型所做更改（添加字段，删除模型等）到数据库模式的方式

(1)生成迁移文件-执行
#		python manage.py makemigrations
将应用下的models.py文件生成一个中间文件,并保存在migrations文件夹中

(2)执行迁移脚本程序-执行
#		python manage.py migrate
执行迁移程序实现迁移。将每个应用下的migrations目录中的中间文件同步回数据库

#会生成很多表

Meta类

使用内部 Meta类来给模型赋予属性，

Meta类下有很多内建的类性，可对模型类做一些控制

class Book(models.Model):
    ...
    ...
    class Meta:
        db_table='name?'
        ...

**模型使用

修改表结构在models.py中修改

任何关于表结构的修改，务必在对应模型类上修改

修改后

python manage.py makemigrations
python manage.py migrate

T模板层

- 1.模板是可以根据字典数据动态变化的html网页
- 2.模板可以根据视图中传递的字典数据动态生成相应的HTML网页。

模板配置

1.创建模板文件夹<项目名>/templates

2.在settings.py 中 TEMPLATES配置项

如果编译器找不到模板

• - BACKEND:指定模板的引擎
    - 接受视图，调用视图的实现，默认系统自带
    
  - DIRS:模板的搜索目录
    - 添加上自己创建的模板目录(可以是一个或多个)
    
  - APP_DIRS∶是否要在应用中的templates 文件夹中搜索模板文件
  
  - OPTIONS∶有关模板的选项
  
  配置项中需要修改部分
  设置DIRS 
  - 'DIRS'": [os.path.join(BASE_DIR, 'templates')],
  

加载模板

#template_view

from django.template import loader
#1.通过1oader加载模板‘
t = loader. get_template("模板文件名") #如test.html
# 2.将t转换成HTML字符串
html = t.render(字典数据)
# 3.用响应对象将转换的字符串内容返回给浏览器
return HttpResponse(htm1)

'''
from django.shortcuts import render
return render(request,"test.html",dict)
#请求，网页，字典
'''

#templates/test.html
<--		 可以用{{变量名}}来引用模板传入的字典值     /-->
<!DOCTYPE html>
<html lang="zh-Hans">
<head> </head>
<body>
		<h1> 这是模板 </h1>
</body>
</html>

模板变量

def mode_view(request):
    dict={
        "fruit":"apple",
        "value":'10'
    }
    return render(request,"test1.html",dict)
传递类型
str int list tuple dict func odj
{{name}}#(变量名)
{{name.index}}
{{name.key}}
{{name.方法}}
{{函数名}}

模板标签

作用

• 将一些服务器端的功能嵌入到模板中，例如流程控制等

标签语法
if标签
{% if 表达式1  %}
.。。
{% elif 表达式2  %}
。。。
{% else 表达式3  %}
...
{% endif %}

for标签
{% for name in list %}
		{{name}}
		
		{% endfor %}

过滤器

• 定义:在变量输出时对变量的值进行处理
• 作用:可以通过使用过滤器来改变变量的输出显示
• 语法∶{{ 变量|过滤器1:‘参数值1’|过滤器2:参数值2’…].}}

继承

模板继承可以使父模板的内容重用,子模板直接继承父模板的全部内容并可以覆盖父模板中相应的块

#语法–父模板中:
定义父模板中的块 block标签标识出哪些在子模块中是允许被修改的
block标签:在父模板中定义，可以在子模板中覆盖
block标签外的不能改
    
#语法–子模板中:
继承模板extends标签(写在模板文件的第一行)
例如{%extends 'base.html'%}

子模板重写父模板中的内容块

###  block标签  ###
{% block block_name %}
子模板块用来覆盖父模板中 block_name块的内容
{% endblock block_name %}

静态文件

• 静态文件配置 settings.py中

配置静态文件的访问路径【该配置默认存在】

#通过哪个url地址找静态文件
 STATIC_URL = '/static/'
 
说明:
指定访问静态文件时是需要通过/static/xxx
或http://127.0.0.1:8000/static/xxx
[xxx表示具体的静态资源位置]

#配置静态文件的存储路径STATICFILES DIRS
STATICFILES_DIRS保存的是静态文件在服务器端的存储位置

STATICFILES_DIRS = (
os.path.join(BASE_DIR，"static"),
)

模板中访问静态文件
- img标签为例

1．<img src=" /static/image/django2.jpg" width="200px"height="200px">

<img src="http://127.0.0.1:8000/static/image/django2.jpg">

2．通过{%static %}标签访问静态文件
加载static - 
#放最上
{% load static %}
使用静态资源– {% static '静态资源路径'%}

样例
<img src="{% static 'images/lena.jpg'%}">
<body style="background-image: url({% static 'img/index.png' %});background-size: cover">

ORM模型CRUD

基本操作包括增删改查操作，即(CRUD操作)
CRUD是指在做计算处理时的增加(Create)、读取查询(Read)、更新(Update)和删除(Delete)
ORM CRUD核心—>模型类.管理器对象(model.object. )

每个继承自models.Model的模型类，都会有一个objects对象被同样继承下来。

这个对象叫管理器对象,数据库的增删改查可以通过模型的管理器实现

数据库设置

打开 mysite/settings.py 。这是个包含了 Django 项目设置的 Python 模块。

• 使用 SQLite 以外的数据库，请确认在使用前已经创建了数据库。
• 还要确保该数据库用户具有 “create database” 权限。

Django配置数据库有两种方法

方法一：直接在settings.py文件中添加数据库配置信息

DATABASES = {
    # 方法一
    'default': {
        'ENGINE': 'django.db.backends.mysql',   # 数据库引擎
        'NAME': 'mysite',                       # 数据库名称
        'USER': 'xiaohong',                      # 数据库登录用户名
        'PASSWORD': 'xiaohong',                # 密码
        'HOST': '127.0.0.1',                # 数据库主机IP
        'PORT': 3306,                           # 数据库端口号
    }
}

`'django.db.backends.sqlite3'`
`'django.db.backends.postgresql'`
`'django.db.backends.mysql'`
`'django.db.backends.oracle'`

直接使用出错误

django.core.exceptions.ImproperlyConfigured: Error loading MySQLdb module.
Did you install mysqlclient?

安装包

pip install pymysql

要在settings.py文件所在包中的__init__.py中导入pymysql

import pymysql
pymysql.install_as_MySQLdb()

如何使用见·模型使用

方法二：将数据库配置信息存到一个文件中，在settings.py文件中将其引入。(推荐)

新建数据库配置文件my.cnf(名字随意选择)

[client]
database = blog
user = blog
password = blog
host =127.0.0.1
port = 3306
default-character-set = utf8

在settings.py文件中引入my.cnf文件

DATABASES = {
    # 方法二：
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'OPTIONS': {
            'read_default_file': 'utils/dbs/my.cnf',
        },
    }
}

字段类型

BooleanField()
	数据库类型:tinyint(1)	--	编程语言中:使用true或False来表示值
	在数据库中:使用1或0来表示具体的值
        
CharField()
数据库类型:varchar
注意:必须要指定max_length参数值

DateField()
	数据库类型:date		表示日期√参数:
	 auto_now:每次保存对象时，自动设置该字段为当前时间(取值:True/False)
     acto_now_add:当对象第一次被创建时自动设置当前时间(取值:True/False)
     default:设置当前时间(取值:字符串格式时间如: '2019-6-1')。
以上三个参数只能多选一
    
DateTimeField()
数据库类型:datetime(6)		表示日期和时间参数同DateField

FloatField()
数据库类型:double
编程语言中和数据库中都使用小数表示值

DecimalField()
	数据库类型:decimal(x,y)
	编程语言中:使用小数表示该列的值√在数据库中:使用小数
	参数:
		max_digits:位数总数，包括小数点后的位数。该值必须大于等于decimal_places.
		decimal_places:小数点后的数字数量

EmailField()
	数据库类型:varchar
	编程语言和数据库中使用字符串
    
IntegerField()
	数据库类型:int
	编程语言和数据库中使用整数

lmageField()
	数据库类型varchar(100)
	作用:在数据库中为了保存图片的路径
    编程语言和数据库中使用字符串

TextField()
	数据库类型:longtext
	作用:表示不定长的字符数据

字段选项

字段选项,指定创建的列的额外的信息

• 允许出现多个字段选项,多个选项之间使用,隔开

primary_key
	如果设置为True,表示该列为主键,如果指定一个字段为主键，则此数库表不会创建id字段

blank (与null不同)
	设置为True时，字段可以为空。设置为False时，字段是必须填写的

null
	如果设置为True,表示该列值允许为空。
	默认为False,如果此选项为False，建议加入default选项来设置默认值

default
	设置所在列的默认值,如果字段选项null=False建议添加此项

db_index
	如果设置为True,表示为该列增加索引

unique
	如果设置为True,表示该字段在数据库中的值必须是唯一(不能重复出现的)

db_column
	指定列的名称,如果不指定的话则采用属性名作为列名

verbose_name
	设置此字段在admin界面上的显示名称
	
#创建一个属性,表示用户名称,长度30个字符,必须是唯一的,不能为空,添加索引

name = models.charField(max_length=30，unique=True,nu77=False，db_index=True)

关系映射

在关系型数据库中，通常不会把所有数据都放在同一张表中，不易于扩展，

常见关系映射有:

表关系

一对一映射
	OneToOneField(类名, on_delete=xxx)
class B(mode1 .Mode1) :
	属性= models.oneTooneFie1d(类A,on_delete=??)
    怎么删除
	1.models.CASCADF级联删除。
    	Django模拟SQL约束ON DELETECASCADE的行为，并删除包含ForeignKey的对象。
	2.models.PROTECT 抛出ProtectedError 以阻止被引用对象的删除;
    	[等同于mysql默认的RESTRICT]
	3.SET_NULL设置ForeignKey null;
    	需要指定null=True
	4.SET_DEFAULT 将ForeignKey设置为其默认值;
    	必须设置ForeignKey的默认值。
#创建数据
    有外键的模型类
	wife1 = Wife.objects.create(name='王夫人', author=author1)
    #关联王老师obj
	wife1 = Wife.objects.create(name='王夫人';author_id=1)
    # 关联王老师对应主键值
#查询
	#正向查询:直接通关外键属性查询，则称为正向查询
	wife = wife.objects.get(name='王夫人')
	print(wife.name，'的老公是'，wife.author.name)
	#反向查询-没有外键属性的一方，可以调用反向属性查询到关联的另一方
	反向关联属性为`实例对象.引用类名(小写)，
	-当反向引用不存在时，则会触发异常
	author1 = Author.objects.get(name='王老师')
    author1.wife.name

一对多映射
一对多是表示现实事物间存在的一对多的对应关系。
#一对多需要明确出具体角色，在多表上设置外键
当一个A类对象可以关联多个B类对象时
class A(mode1 . Mode1):一
class B (model.Mode1):
    属性= mode1s.ForeignKey("一"的模型类，on_delete=xx)
#创建数据
from .models import *
pub1= Publisher.objects.create(name='清华')
Book.objects.create(title='C++', publisher=pub1)
Book.objects.create(title='Java', publisher_id=1)
#查询		A：B=1:多
类B obj.外键属性.A属性
类A obj.类B_set.all() 

多对多映射

多对多表达对象之间多对多复杂关系，如:每个人都有不同的学校(小学，初中，高中...),每个学校都有不同的学生...
 mysql中创建多对多需要依赖第三张表来实现
 Django中无需手动创建第三张表,Django自动完成


#语法:在关联的两个类中的任意一个类中,
B 增加属性= models.ManyToManyField(A)

#创建数据
先创建book再关联author
book = Book.objects.create(title= ' python1 ' )

author3 = book.authors.create(name= ' guoxiaonao ' )
book.authors.add(author1)

#正向查询有多对多属性的对象查另一方
通过Book查询对应的所有的Author
此时多对多属性等价于objects
book.authors.a11() ->获取book对应的所有的author的信息
book.authors.filter(age_gt=80) ->获取book对应的作者中年龄大于80岁的作者的信息
#反向查询
通过Author查询对应的所有的Book利用反向属性book_set
author.book_set.all()
author.book_set.filter()

创建数据

创建数据中每一条记录就是创建一个数据对象方案1

1.
MyModel.objects.create(属性1=值1,属性2=值1..)
成功:返回创建好的实体对象
失败:抛出异常
    
2.  创建MyModel 实例对象,并调用save()进行保存
obj = MyMode1(属性=值,属性=值)
obj.属性=值
obj.save()

Django Shell

在Django提供了一个交互式的操作项目叫 Django Shell

它能够在交互模式用项目工程的代码执行相应的操作
利用Django Shell可以代替编写view的代码来进行直接操作

注意:项目代码发生变化时，重新进入Django

shell启动方式:
 python manage.py shell
 
>>> from bookstore.models import Book
>>> b1=Book.objects.create(title='zzl',price='endless')
>>> b2=Book(title="qqq",price="1100")
>>> b2.save()

mysql> select * from bookstore_book;
+----+-------+---------+
| id | title | price   |
+----+-------+---------+
|  1 | zzl   | endless |
|  2 | qqq   |   1100  |
+----+-------+---------+

查询操作

数据库的查询需要使用管理器对象进行
通过MyModel.objects管理器方法调用查询方法

简单查询
	MyModel.objects.all()
		查询全部记录,返回QuerySet查询对象， [obj,obj2...]
   	def __str__(self):
    	 retrun 显示格式
		
        仅仅查询部分字段
        MyModel.objects.values(字段1，字段2...)#使用类属性，实则对数据库字段操作
        返回[{},{}]
        MyModel.objects.values_list(字段1，字段2...)
        返回[(),(),]
        MyModel.objects.values(字段1，字段2...).order_by(字段1，字段2...)
		返回[obj,obj2...]
条件查询
     
#等式查询
MyModel.objects.get(属性=值1，..2，..3)
	查询符合条件的唯一记录，如果不是1条数据，出错
    返回obj
    
MyModel.objects.filter(属性=值1，..2，..3)
	查询符合所有条件的多条记录
    返回[obj,...]
    
MyModel.objects.exclude(属性=值1，..2，..3)
	查询不符合条件的全部记录
    返回[obj,...]
#非等式查询
	查询谓词
    定义:做更灵活的条件查询时需要使用查询谓词
     说明:每一个查询谓词是一个独立的查询功能
        _exact:等值匹配
		_contains :包含指定值
        _startswith : 以XXX开始
		_endswith :以XXX结束
        _gt	:大于
        _gte	:大于等于
        _it	:小于
        _ite	:小于等于
        _in	:	(?_in=[,,])
        _range	:(?_range(a,b))
            
            
MyModel.objects.filter( 属性_contains = 值1，..2，..3)

更新操作

1.查

get(id=?)

2.改

obj.属性=？

3.save()

#批量修改
books = Book.objects.filter(id_gt=3)
books.update(price=O)
#将所有书的零售价定为100元
books = Book.objects.all()

删除操作

1.查找数据对象
2.调用这个数据对象的delete()方法实现删除

try:
	auth = Author.objects.get(id=1)
	auth.delete()
except:
	print(删除失败)

F&Q

F

一个F对象代表数据库中某条记录的字段的信息作用:

通常是对数据库中的字段值在不获取的情况下进行操作-用于类属性(字段)之间的比较。

from django . db .models import F
F('列名')

Book.objects.a11().update(market_price=F( 'market_price ')+10)
互斥执行

Q

在条件中用来实现除and(&)以外的or()或not(~)操作运算符:

&与操作
|或操作
&~非操作

from django. db.mode1s import Q
Q(条件1)|Q(条件2)	# 条件1成立或条件2成立
Q(条件1)&Q(条件2)	#条件1和条件2同时成立
Q(条件1)&~Q(条件2)	#条件1成立且条件2不成立

book.objects.filter(  Q()|Q() )

聚合查询

聚合查询是指对一个数据表中的一个字段的数据进行部分或全部进行统计查询,

查bookstore_book数据表中的全部书的平均价格，

查询所有书的总个数等,都要使用聚合查询

聚合查询分为

• 整表聚合

导入方法: from django.db.models import *
    
    聚合函数: Sum, Avg,Count,Max，Min

语法:MyModel.objects.aggregate(结果变量名=聚合函数('列'))
-返回结果:结果变量名和值组成的字典
格式为:{结果变量名":值}

• 分组聚合

分组聚合是指通过计算查询结果中每一个对象所关联的对象集合，
从而得出总计值(也可以是平均值或总和)，即为查询集的每一项生成聚合。

语法:
- QuerySet.annotate(结果变量名=聚合函数('列'))
返回值:
QuerySet


先分组
bs = Book.objects.values ( ' pub')
bs.annotate(res=Count( 'id' ) )
>>>		<QuerySet [{ 'pub': '清华大学出版社'，'res': 2}，{ 'pub': ‘机械工业出版社

bs.annotate(res=Count( 'id' ) ).filter(res_gt=1)

原生数据库

Django也可以支持直接用sql语句的方式通信数据库

查询:
使用MyModel.objects.raw()进行数据库查询操作查询

语法:
MyModel.objects.raw(sql语句,拼接参数)

返回值:
RawQuerySet集合对象【只支持基础操作，比如循环】

完全跨过模型类操作数据库-查询/更新/删除

1.导入cursor所在的包
from django.db import connection
⒉用创建cursor类的构造函数创建cursor对象，再使用cursor对象，

为保证在出现异常时能释放cursor资源,通常使用with语句进行创建

from django.db import connection
with connection.cursor() as cur:
	cur.execute('执行sQL语句'，'拼接参数')

数据库使用

数据库设置

打开 mysite/settings.py 。这是个包含了 Django 项目设置的 Python 模块。

• 使用 SQLite 以外的数据库，请确认在使用前已经创建了数据库。
• 还要确保该数据库用户具有 “create database” 权限。

Django配置数据库有两种方法

方法一：直接在settings.py文件中添加数据库配置信息

DATABASES = {
    # 方法一
    'default': {
        'ENGINE': 'django.db.backends.mysql',   # 数据库引擎
        'NAME': 'mysite',                       # 数据库名称
        'USER': 'xiaohong',                      # 数据库登录用户名
        'PASSWORD': 'xiaohong',                # 密码
        'HOST': '127.0.0.1',                # 数据库主机IP
        'PORT': 3306,                           # 数据库端口号
    }
}

`'django.db.backends.sqlite3'`
`'django.db.backends.postgresql'`
`'django.db.backends.mysql'`
`'django.db.backends.oracle'`

直接使用出错误

django.core.exceptions.ImproperlyConfigured: Error loading MySQLdb module.
Did you install mysqlclient?

安装包

pip install pymysql

要在settings.py文件所在包中的__init__.py中导入pymysql

import pymysql
pymysql.install_as_MySQLdb()

如何使用见·模型使用

方法二：将数据库配置信息存到一个文件中，在settings.py文件中将其引入。(推荐)

新建数据库配置文件my.cnf(名字随意选择)

[client]
database = blog
user = blog
password = blog
host =127.0.0.1
port = 3306
default-character-set = utf8

在settings.py文件中引入my.cnf文件

DATABASES = {
    # 方法二：
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'OPTIONS': {
            'read_default_file': 'utils/dbs/my.cnf',
        },
    }
}

字段类型

BooleanField()
	数据库类型:tinyint(1)	--	编程语言中:使用true或False来表示值
	在数据库中:使用1或0来表示具体的值
        
CharField()
数据库类型:varchar
注意:必须要指定max_length参数值

DateField()
	数据库类型:date		表示日期√参数:
	 auto_now:每次保存对象时，自动设置该字段为当前时间(取值:True/False)
     acto_now_add:当对象第一次被创建时自动设置当前时间(取值:True/False)
     default:设置当前时间(取值:字符串格式时间如: '2019-6-1')。
以上三个参数只能多选一
    
DateTimeField()
数据库类型:datetime(6)		表示日期和时间参数同DateField

FloatField()
数据库类型:double
编程语言中和数据库中都使用小数表示值

DecimalField()
	数据库类型:decimal(x,y)
	编程语言中:使用小数表示该列的值√在数据库中:使用小数
	参数:
		max_digits:位数总数，包括小数点后的位数。该值必须大于等于decimal_places.
		decimal_places:小数点后的数字数量

EmailField()
	数据库类型:varchar
	编程语言和数据库中使用字符串
    
IntegerField()
	数据库类型:int
	编程语言和数据库中使用整数

lmageField()
	数据库类型varchar(100)
	作用:在数据库中为了保存图片的路径
    编程语言和数据库中使用字符串

TextField()
	数据库类型:longtext
	作用:表示不定长的字符数据

字段选项

字段选项,指定创建的列的额外的信息

• 允许出现多个字段选项,多个选项之间使用,隔开

primary_key
	如果设置为True,表示该列为主键,如果指定一个字段为主键，则此数库表不会创建id字段

blank (与null不同)
	设置为True时，字段可以为空。设置为False时，字段是必须填写的

null
	如果设置为True,表示该列值允许为空。
	默认为False,如果此选项为False，建议加入default选项来设置默认值

default
	设置所在列的默认值,如果字段选项null=False建议添加此项

db_index
	如果设置为True,表示为该列增加索引

unique
	如果设置为True,表示该字段在数据库中的值必须是唯一(不能重复出现的)

db_column
	指定列的名称,如果不指定的话则采用属性名作为列名

verbose_name
	设置此字段在admin界面上的显示名称
	
#创建一个属性,表示用户名称,长度30个字符,必须是唯一的,不能为空,添加索引

name = models.charField(max_length=30，unique=True,nu77=False，db_index=True)

关系映射

在关系型数据库中，通常不会把所有数据都放在同一张表中，不易于扩展，

常见关系映射有:

表关系

一对一映射
	OneToOneField(类名, on_delete=xxx)
class B(mode1 .Mode1) :
	属性= models.oneTooneFie1d(类A,on_delete=??)
    怎么删除
	1.models.CASCADF级联删除。
    	Django模拟SQL约束ON DELETECASCADE的行为，并删除包含ForeignKey的对象。
	2.models.PROTECT 抛出ProtectedError 以阻止被引用对象的删除;
    	[等同于mysql默认的RESTRICT]
	3.SET_NULL设置ForeignKey null;
    	需要指定null=True
	4.SET_DEFAULT 将ForeignKey设置为其默认值;
    	必须设置ForeignKey的默认值。
#创建数据
    有外键的模型类
	wife1 = Wife.objects.create(name='王夫人', author=author1)
    #关联王老师obj
	wife1 = Wife.objects.create(name='王夫人';author_id=1)
    # 关联王老师对应主键值
#查询
	#正向查询:直接通关外键属性查询，则称为正向查询
	wife = wife.objects.get(name='王夫人')
	print(wife.name，'的老公是'，wife.author.name)
	#反向查询-没有外键属性的一方，可以调用反向属性查询到关联的另一方
	反向关联属性为`实例对象.引用类名(小写)，
	-当反向引用不存在时，则会触发异常
	author1 = Author.objects.get(name='王老师')
    author1.wife.name

一对多映射
一对多是表示现实事物间存在的一对多的对应关系。
#一对多需要明确出具体角色，在多表上设置外键
当一个A类对象可以关联多个B类对象时
class A(mode1 . Mode1):一
class B (model.Mode1):
    属性= mode1s.ForeignKey("一"的模型类，on_delete=xx)
#创建数据
from .models import *
pub1= Publisher.objects.create(name='清华')
Book.objects.create(title='C++', publisher=pub1)
Book.objects.create(title='Java', publisher_id=1)
#查询		A：B=1:多
类B obj.外键属性.A属性
类A obj.类B_set.all() 

多对多映射

多对多表达对象之间多对多复杂关系，如:每个人都有不同的学校(小学，初中，高中...),每个学校都有不同的学生...
 mysql中创建多对多需要依赖第三张表来实现
 Django中无需手动创建第三张表,Django自动完成


#语法:在关联的两个类中的任意一个类中,
B 增加属性= models.ManyToManyField(A)

#创建数据
先创建book再关联author
book = Book.objects.create(title= ' python1 ' )

author3 = book.authors.create(name= ' guoxiaonao ' )
book.authors.add(author1)

#正向查询有多对多属性的对象查另一方
通过Book查询对应的所有的Author
此时多对多属性等价于objects
book.authors.a11() ->获取book对应的所有的author的信息
book.authors.filter(age_gt=80) ->获取book对应的作者中年龄大于80岁的作者的信息
#反向查询
通过Author查询对应的所有的Book利用反向属性book_set
author.book_set.all()
author.book_set.filter()

入门使用

创建项目

>django-admin startproject mysite1
#创建的目录结构
'''
mysite1/
    manage.py
    mysite1/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py
        '''

• 最外层的mysite1/根目录只是你项目的容器
• manage.py: 一个让你用各种方式管理 Django 项目的命令行工具。
• 里面一层的mysite1/ 包含你的项目
  • mysite1/init.py：一个空文件，告诉 Python 这个目录应该被认为是一个 Python 包。
  • mysite1/settings.py：Django 项目的配置文件。
  • mysite1/urls.py：Django 项目的 URL 声明，就像网站的“目录”。
  • mysite1/asgi.py：运行在ASGI的Web服务器上的入口。
  • mysite1/wsgi.py：运行在WSGI的Web服务器上的入口。

pycharm配置

• 下载破解版pycharm，支持Django
• file–>setting 设置解释器
  • 添加新的虚拟环境，location在项目文件夹下venv，base interpreter为下载的python3.8
  • 勾选inherit global …这样会带有Django的包
  • 前提是之前已经下载安装了Django

• 设置Django的工程目录。setting.py路径，和 manage.py 路径

​

• 最后在run , configuration新建Django服务，配置站点ip端口等

运行项目

进入外层的mysite目录的话，请切换到此目录，然后运行下面的命令：

$ python manage.py runserver (ip:port)

访问http://127.0.0.1:8000/看到成功界面

//启动了 Django 自带的用于开发的简易服务器，它是一个用纯 Python 编写的轻量级的 Web 服务器。
这个服务器内置在 Django 中是为了让你能快速的开发出想要的的东西，

创建应用(startapp)

项目 VS 应用
项目和应用有什么区别？应用是一个专门做某事的网络应用程序——比如博客系统，或者公共记录的数据库，或者小型的投票程序。项目则是一个网站使用的配置和应用的集合。项目可以包含很多个应用。应用可以被很多个项目使用。

在 Django 中，每个应用都是 Python 包，并且遵循相同的约定。Django 自带一个工具，可以帮助生成应用的基础目录结构

• manage.py同级目录下创建投票应用。这样它就可以作为*模块导入，不是而mysite的子模块。

python manage.py startapp polls

'''这个结构目录包括了投票应用的全部内容。
polls/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py
'''

创建view

进入polls/view.py,写视图

from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world. You're at the polls index.")

这是 Django 中最简单的视图。

• 如果想看见效果，我们需要将一个 URL 映射到它
  • ——这就是我们需要 URLconf 的原因

为了创建 URLconf，在polls目录中新建一个urls.py

在polls/urls.py中，输入如下代码：

from django.urls import path

from . import views

urlpatterns = [
    path('', views.index, name='index'),
]

下一步是要在根 URLconf 文件中指定我们创建的polls.urls模块。

在mysite/urls.py文件的里面urlpatterns插入一个include()

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('polls/', include('polls.urls')),
    path('admin/', admin.site.urls),
]

函数include()允许引用其他 URLconfs。删除 Django 遇到include()时，它会截断与插入匹配的 URL 的部分，将脚本的字符串发送到 URLconf 以供进一步处理。

创建模型(数据库表)

在 Django 里写一个数据库驱动的 Web 应用的第一步是定义模型 - 也就是数据库结构设计和附加的其它元数据

设计哲学

# 一个模型就是单个定义你的数据的信息源。
# 模型中包含了不可缺少的数据区域和你存储数据的行为。
# Django 遵循 DRY 原则。目的就是定义你的数据模型要在一位置上，而且自动从该位置推导一些事情。

来介绍一下迁移 - 举个例子，不像 Ruby On Rails，Django 的迁移代码是由你的模型文件自动生成的，它本质上是个历史记录，Django 可以用它来进行数据库的滚动更新，通过这种方式使其能够和当前的模型匹配。

投票应用中，需要创建两个模型：问题Question和选项Choice。

• Question模型包括问题描述和发布时间。
• Choice模型有两个字段，选项描述和当前得票数。每个选项是一个问题。

编辑polls/models.py文件：

from django.db import models

#每个模型django.db.models.Model有许多类变量，
#   -->它们都表示模型里的一个数据库字段。
class Question(models.Model):
    question_text = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')

#几乎所有字段Field的实例
#字符字段被表示为CharField，
#日期时间字段被表示为DateTimeField。

class Choice(models.Model):
    question = models.ForeignKey(Question, on_delete=models.CASCADE)
    choice_text = models.CharField(max_length=200)
    votes = models.IntegerField(default=0)

# 定义部分Field 类实例需要参数。
# 例如CharField 需要一个max_length 参数。这个参数的用处用于定义数据库结构，也用于验证数据，我们很快就会看到这方面的内容。
# Field 也能够接收若干可选参数；在上面的例子中：我们将votes的default也就是默认值，设为0。

#  我们使用ForeignKey定义了一个关系。
这将告诉 Django，每个Choice对象都关联到一个 Question 对象。Django 支持所有常用的数据库关系：多对一、多对多和一对一。

激活模型

Django 可以通过创建模型的代码：

• 为这个应用创建数据库模式（生成语句）。CREATE TABLE
• 创建可以与Question和Choice对象进行交互的 Python 数据库 API

但是首先要把polls应用安装到我们的项目里。

# 设计哲学

Django 应用是“可插拔”的。你可以在多个项目中使用同一个。除此之外，你还可以发布自己的应用，因为它们并不会被绑定到当前安装的Django 上。

• 为了在我们的工程中包含这个应用，需要我们在配置类INSTALLED_APPS中添加设置。因为PollsConfig类写在文件polls/apps.py中，所以它的路径是'polls.apps.PollsConfig'

site/setting.py

INSTALLED_APPS = [
    'polls.apps.PollsConfig',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

site/polls/app.py

from django.apps import AppConfig

class PollsConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'polls'

现在 Django 项目会包含polls 应用程序。运行下面的命令：

$ python manage.py makemigrations polls

Cookie&Session

• 会话

从打开浏览器访问一个网站，到关闭浏览器结束此次访问，称之为一次会话
HTTP协议是无状态的，导致会话状态难以保持

Cookies保存在客户端浏览器上的存储空间

Chrome浏览器通过开发者工具的Application >>Storage >> Cookies查看和操作浏览器端所有的Cookies值
火狐浏览器可能通过开发者工具的存储-> Cookie查看

1.cookies在浏览器上是以键-值对的形式进行存储的，
键和值都是以ASCII字符串的形存储(不能是中文字符串)

2.存储的数据带有生命周期

3.cookies中的数据是按域存储隔离的，不同的域之间无法访问

4.cookies的内部的数据会在每次访问此网址时都会携带到服务器端，如果cookies过大会降低响应速度


服务端响应Cookie设置
HttpResponse.set_cookie(key, value=", max_age=None,expires=None)
- key:cookie的名字
- value:cookie的值
- max_age:cookie存活时间，秒为单位
- expires:具体过期时间
-当不指定max age和expires时,关闭浏览器时此数据失效


resp = HttpResponse( 'set cookies is ok' )
resp.set_cookie( ' uuname ' , 'gxn' ,500)
#添加cookie,修改cookie
#为浏览器添加键为my_var1,值为123，过期时间为1个小时的cookie
responds = HttpResponse("已添加my_var1,值为123")
responds.set_cookie( 'my_var1'，123，3600)
return responds

#删除Cookies
- HttpResponse.delete_cookie(key)
-删除指定的key的Cookie。如果key不存在则什么也不发生
#获取Cookies
-通过request.COOKIES绑定的字典(dict)

#获取客户端的COOKIES数据
value = request.COOKIES.get('cookies名'，'默认值')

Session在服务器上开辟一段空间用于保留浏览器和服务器交互时的重要数据

实现方式

-使用session需要在浏览器客户端启动cookie，且在cookie中存储sessionid
-每个客户端都可以在服务器端有一个独立的Session
-注意:不同的请求者之间不会共享这个数据，与请求者一一对应

配置

settings.py中配置session

1，向INSTALLED_APPS列表中添加:
INSTALLED_APPS = [
#启用sessions应用
'django.contrib.sessions ' ,
]

2，向MIDDLEWARE列表中添加:
MIDDLEWARE = [
#启用session中间件
'django.contrib.sessions.middleware.sessionMiddleware'
]

使用

session对于象是一个类似于字典的SessionStore类型的对象,
可以用类拟于字典的方式进行操作
session 能够存储如字符串，整型，字典，列表等。

1，保存session的值到服务器
request.session['KEY'] = VALUE

2，获取session的值
value = request.session['KEY']
value = request.session.get('KEY',默认值)

3，删除session
del request.session['KEY"]

def set_session( request) :
		request.session [ ' uname' ] = 'wwc'
	return HttpResponse( ' set session is ok')
                    
def get_session( request) :
		value = request.session [ ' uname ' ]
	return HttpResponse( 'session value is %s '%(valuel))

使用

settings.py中相关配置项
1,SESSION_COOKJE_AGE
作用:指定sessionid在cookies中的保存时长(默认是2周)，
    如例如:SESSION_COOKIE_AGE = 60* 60 * 24*7* 2
        
2， SESSION_EXPIRE_AT_BROWSER_CLOSE= True
设置只要浏览器关闭时,session就失效(默认为False)

注意:Django中的session数据存储在数据库中
    ，所以使用session前需要确保已经执行过migrate

    
1, django_session表是单表设计;
且该表数据量持续增持【浏览器故意删掉sessionid&过期数据未删除】
2，可以每晚执行python3 manage.py clearsessions
【该命令可删除已过期的session数据】

Admin后台

django提供了比较完善的后台管理数据库的接口，

可供开发过程中调用和测试使用

django 会搜集所有已注册的模型类，

为这些模型类提拱数据管理界面，供开发者使用

创建后台管理帐号–该账号为管理后台最高权限账号
$ python3 manage.py createsuperuser

函数

path()

函数有path()四个参数，两个必须参数：route和view，两个任选参数：kwargs和name。

• route是一个匹配 URL 的准则（类似正则表达式）。当 Django 响应一个请求时，它会从urlpatterns第一项开始，按顺序排列匹配列表中的项，直到找到匹配项。

这些特征不会匹配 GET 和 POST 参数或域名。例如，URLconf 处理请求请求https://www.example.com/myapp/时，它会尝试匹配myapp/。处理请求https://www.example.com/myapp/?page=3时，也可以尝试匹配myapp/

• 当姜戈找到了一个匹配的模型，就会调用特定的这个视图，并同时调用一个HttpRequest对象第一个参数，被“作为”参数的参数以关键字参数的形式呈现。

• kwargs 任意一个关键字参数可以作为一个字典传递给目标视图函数。

• name 为你的 URL 取名可以让你在 Django 的某个地方唯一的这个地引用它，尤其是在模板中特殊的特性允许你只改一个文件外部地修改某个 URL 模式。

render()

**render()**语法如下：

def render(request, template_name, context=None, content_type=None,
           status=None, using=None)

render 的参数 request 和 template name 是必需参数，其余的参数是可选参数。各个参数说明如下。

• request：浏览器向服务器发送的请求对象，包含用户信息、请求内容和请求方式等。
• template_name：设重模板文件名，用于生成网页内容。
• context：对模板上下文（模板变量）赋值，以字典格式表示，默认情况下是一个空字典。
• content_type：响应内容的数据格式，一般情况下使用默认值即可。
• status：HTTP状态码，默认为200。
• using：设置模板引擎，用于解析模板文件，生成网页内容。

HttpResponseRedirect

Django中提供了HttpResponseRedirect对象实现重定向功能，这个类继承自HttpResponse，被定义在django.http模块中，返回的状态码为302。

功能

URL

绝对地址
http://127.0.0.1:8000/page/12，

相对地址
 '/page/1'
 ‘/’开头的相对地址，
 浏览器会把当前地址栏里的协议，ip和端口加上这个地址，作为最终访问地址，
 
 即如果当前页面地址栏为http://127.0.0.1:8000/page/3;当前相对地址最终结果为http://127.0.0.1:8000 + /page/1

 'page/1’
 没有‘/开头的相对地址，
 浏览器会根据当前url的最后一个/之前的内容加上该相对地址作为最终访问地址，
 
 例如当前地址栏地址为http://127.0.0.1:8000/topic/detail;则该相对地址最终结果为http://127.0.0.1:8000/topic/ + page/1

url反向解析

url反向解析是指在视图或模板中，

用path定义的名称来动态查找或计算出相应的路由

path函数的语法
path(route, views, name="别名")
path(page', views.page_view, name="page_url")
根据path中的`name=`关键字传参给url确定了个唯一确定的名字
在模板或视图中，可以通过这个名字反向推断出此url信息

模板中使用url标签实现地址的反向解析

{% url‘别名’%}
{% url '别名’'参数值1''参数值2’%}
{% ur1 'pagen''400’%}
{% url 'person' age='18' name=' gxn'%}

在视图函数中->可调用django中的reverse方法进行反向解析
from django.urls import reverse
url=reverse('别名'，args=[]，kwargs={})

url跳转&页面跳转&传参

URL跳转

url跳转也表示  调用path函数进行views视图处理

url跳转形式
1.通过html标签链接，表单链接


2.通过redict函数

请求传参的四种方式

• URL路径 （ …/123 ）
• GET请求 (…?a=? )
• 请求体 表单等 (form …)
• 报文头header 里 (cookie)

1.URL

path(r'<int>/<int>',a)

def a(request,item1,item2):
    return HttpResponse()

get

Django中的请求

• 请求在Django中,就是视图函数的第一个参数，即HttpRequest对象
• Django接收到http协议的请求后，会根据请求数据报文创建HttpRequest对象
• HttpRequest对象通过属性描述了请求的所有相关信息

path_info: 	URL字符串
method:		字符串，表示HTTP请求方法，常用值:'GET'、'POST
GET: 		QueryDict查询字典的对象，包含get请求方式的所有数据
POST: 		QueryDict查询字典的对象，包含post请求方式的所有数据
FILES:		类似于字典的对象,包含所有的上传文件信息
COOKIES: 	Python字典，包含所有的cookie，键和值都为字符串
session:	似于字典的对象,表示当前的会话
body:		字符串，请求体的内容(POST或PUT)
scheme:		请求协议('http' /'https')
request.get_full _path()∶	请求的完整路径
request.META:	请求中的元数据(消息头)
				客户端IP地址	-> request.META['REMOTE_ADDR'] :


#在视图函数输出
def test_request ( request) :
	print( ' path info is' , request.path_info)
    print ( ' method is', request.method)
	print ( ' querystring is' , request.GET)
		return HttpResponse( ' test request ok' )

Django响应

构造函数格式:

HttpResponse(content=响应体,content_type=响应体数据类型, status=状态码)
作用:
向客户端浏览器返回响应，同时携带响应体内容

常用的Content-Type如下
>
- 'text/html’(默认的,html文件)
- 'text/plain’(纯文本)
- 'text/css’(css文件)
- 'text/javascript'(js文件)
- 'multipart/form-data’(文件提交)
- 'application/json'(json传输)
- 'application/xml’(xml文件)

请求响应

GET

- 浏览器地址栏中输入URL,回车后
- <a href="地址?参数=值&参数=值">
- form表单中的method为get

POST

客户端通过表单等POST请求将数据传递给服务器端,如:

<form method=' post' action=" /login">
	<input type="text" name="username">
	<input type= 'submit' value='登陆'>
</form>

Django的get,POST请求都在视图函数响应

def test_get_post( request) :
	if request.method == 'GET" :
		#request.GET字典
        request.GET['参数名']
        request.GET.get('参数','默认值')	#无参有默认值，不出错
        request.GET.getlist('参数')	#取所有值		
        
	elif request.method == "'POST' :
		request.POST['参数名']# request.PoST绑定QueryDict
        request.PoST.get('参数名'，'')
		request.POST.getList('参数名')

#取消csrf验证,否则Django将会拒绝客户端发来的POST请求，报403响应
'''
取消csrf 验证
-禁止掉settings.py 中 MIDDLEWARE中的CsrfViewsMiddleWare的中间件
MIDDLEWARE = [
#注释掉 	' django.middleware.csrf.csrfviewMiddleware ',
]
'''
	else:
				pass
	return HttpResponse( '--test get post is ok-- ' )

setting文件

• 编辑 mysite/settings.py 文件前，先设置 TIME_ZONE 为你自己时区。

此外，关注一下文件头部的 INSTALLED_APPS 设置项。这里包括了会在你项目中启用的所有 Django 应用。应用能在多个项目中使用，也可以打包并且发布应用，让别人使用。

通常， INSTALLED_APPS 默认包括了以下 Django 的自带应用：

django.contrib.admin -- 管理员站点， 你很快就会使用它。
django.contrib.auth -- 认证授权系统。
django.contrib.contenttypes -- 内容类型框架。
django.contrib.sessions -- 会话框架。
django.contrib.messages -- 消息框架。
django.contrib.staticfiles -- 管理静态文件的框架。
这些应用被默认启用是为了给常规项目提供方便。

默认开启的某些应用需要至少一个数据表，所以，在使用他们之前需要在数据库中创建一些表。执行以下命令：

$ python manage.py migrate

#这个 migrate 命令检查 INSTALLED_APPS 设置，为其中的每个应用创建需要的数据表，

至于具体会创建什么，这取决于你的 mysite/settings.py 设置文件和每个应用的数据库迁移文件（我们稍后会介绍这个）。这个命令所执行的每个迁移操作都会在终端中显示出来。如果你感兴趣的话，运行你数据库的命令行工具，并输入 \dt （PostgreSQL）、SHOW TABLES; （MariaDB，MySQL）、.schema （SQLite）或者 SELECT TABLE_NAME FROM USER_TABLES; （Oracle）来看看 Django 到底创建了哪些表

路由配置

https://docs.djangoproject.com/zh-hans/3.2/topics/http/urls/

urls.py的urlparttern中配置对应的view函数写在view.py中

1.路由配置- path

• path()函数

  • 导入 from django.urls import path

  • 语法– path(route, views, name=None)

  • 参数:

    • route:字符串类型，匹配的请求路径

    • views:指定路径所对应的视图处理函数的名称

    • name:为地址起别名，在模板中地址反向解析时使用

2.路由配置- path -转换器

#path转换器

1·语法:/<转换器类型:自定义名>
2·作用:若转换器类型匹配到对应类型的数据，则将数据按照关键字传参的方式传递给视图函数
3·例子: path('page/<int:page>', views.xxx)

#把int型变量page 以关键字传参形式 传给视图函数view.XXX
如 path('src/<int:value>',view.test)

view函数
def test(request,value):#加上第二个参数value
	return HttpResponse()

下面的路径在默认情况下是有效的：

• str- 匹配'/'之外的非空字符串。如果表达式内不包含转换，默认匹配字符串。

• int- 匹配0或任何正瞬间。返回一个int。

• slug- 匹配任意由 ASCII 字母数字或连字符和下划线组成的短标签building-your-1st-django-site。

• uuid- 匹配一个格式的 UUID。为了防止多个 URL 映射到一个页面，必须包含破折号并且字符都为小写。例如，075194d3-6885-417e-a8a8-6c931e272f00。返回一个UUID实例。

• path- 匹配非空域，包括路径提示符'/'。它允许你匹配完整的 URL，而不是像str那样匹配 URL 的部分。

注册自定义的路径转换器

为了更复杂的匹配需求，你能定义你自己的路径转换器。

转换是一个类，包含如下内容：

• 字符串形式的regex类属性。
• to_python(self, value)方法，可以选择处理匹配的字符串转换为函数的类型。如果没有转换为给定的值，它应该会引发ValueError。ValueError说明没有匹配成功，因此有另一种 URL 模式匹配成功，否则会向用户发送404响应。
• to_url方法， 转换 Python 类型为字符串用于 URL 中。如果不能转换给定的值，会引起error

例如：

class FourDigitYearConverter:
    regex = '[0-9]{4}'

    def to_python(self, value):
        return int(value)

    def to_url(self, value):
        return '%04d' % value

在 URLconf 中使用register_converter()来注册自定义的转换类：

from django.urls import path, register_converter

from . import converters, views

register_converter(converters.FourDigitYearConverter, 'yyyy')

urlpatterns = [
    path('articles/2003/', views.special_case_2003),
    path('articles/<yyyy:year>/', views.year_archive),
    ...
]

使用正则表达式

如果路径和转换器语法不足以定义您的 URL 模式，您还可以使用正则表达式。为此，请使用 re_path()代替path()。

在 Python 正则表达式中，命名正则表达式组的语法是(?P<name>pattern)，其中name是组的名称和 pattern一些要匹配的模式。

urlpatterns[
	
# 	r'^ 是开头，
#	(?P<name>pattern)为分组匹配，可限制位数等
#	$为结尾          
    re_path(r"^(?P<x>\d{1,2})/( ?P<op>\w+)/( ?P<y>\d[1,2}$)'，views.cal2_view)
            //类似于
    path( '<int:n>/<str:op=/<int:m>', views.cal_view) ,
]

基础

Django中的请求

• 请求在Django中,就是视图函数的第一个参数，即HttpRequest对象
• Django接收到http协议的请求后，会根据请求数据报文创建HttpRequest对象
• HttpRequest对象通过属性描述了请求的所有相关信息

path_info: 	URL字符串
method:		字符串，表示HTTP请求方法，常用值:'GET'、'POST
GET: 		QueryDict查询字典的对象，包含get请求方式的所有数据
POST: 		QueryDict查询字典的对象，包含post请求方式的所有数据
FILES:		类似于字典的对象,包含所有的上传文件信息
COOKIES: 	Python字典，包含所有的cookie，键和值都为字符串
session:	似于字典的对象,表示当前的会话
body:		字符串，请求体的内容(POST或PUT)
scheme:		请求协议('http' /'https')
request.get_full _path()∶	请求的完整路径
request.META:	请求中的元数据(消息头)
				客户端IP地址	-> request.META['REMOTE_ADDR'] :


#在视图函数输出
def test_request ( request) :
	print( ' path info is' , request.path_info)
    print ( ' method is', request.method)
	print ( ' querystring is' , request.GET)
		return HttpResponse( ' test request ok' )

Django响应

构造函数格式:

HttpResponse(content=响应体,content_type=响应体数据类型, status=状态码)
作用:
向客户端浏览器返回响应，同时携带响应体内容

常用的Content-Type如下
>
- 'text/html’(默认的,html文件)
- 'text/plain’(纯文本)
- 'text/css’(css文件)
- 'text/javascript'(js文件)
- 'multipart/form-data’(文件提交)
- 'application/json'(json传输)
- 'application/xml’(xml文件)

http请求

GET,POST最常用

http1.0

• GET

  • 请求指定的页面信息，并返回实体主体

• HEAD （测试）

  • 类似于get请求，只不过返回的响应中没有具体的内容，用于获取报头

• POST

  • 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中，可能会导致新的资源的建立和/或已有资源的修改。

HTTP1.1新增

• PUT (更新数据)

  • 从客户端向服务器传送的数据取代指定的文档的内容。

• DELETE （删除）

  • 请求服务器删除指定的页面。

• CONNECT （代理）

  • HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。

• OPTIONS （协商）

  • 允许客户端查看服务器的性能。

• TRACE （链路测试）

  • 回显服务器收到的请求，主要用于测试或诊断。

HTTP响应

下面是常见的HTTP状态码:

• 200-请求成功
• 301 -永久重定向-资源（网页等）被永久转移到其它URL-
• 302-临时重定向
• 404-请求的资源（网页等)不存在
• 500–内部服务器错误

五大类状态码
1**  	服务器收到请求，需要请求者继续执行操作
2**		成功，操作被成功接收并处理
3** 	重定向，需要进一步的操作以完成请求
4**		客户端错误，请求包含语法错误或无法完成请求
5**		服务器错误，服务器在处理请求的过程中发生了错误

项目开发

• 项目组成员角色
  • 产品/运营经理:负责产品功能细节的把控
  • 开发
    • 前端–负责显示部分内容的开发【多】
    • 后端–负责服务器部分的功能开发【少】
  • 运维–管理linux服务器，组件化配置，安全问题
  • 测试–负责找出产品功能的问题【BUG】
  • 美术-负责产品素材方面得绘制

询字典的对象，包含get请求方式的所有数据
POST: QueryDict查询字典的对象，包含post请求方式的所有数据
FILES: 类似于字典的对象,包含所有的上传文件信息
COOKIES: Python字典，包含所有的cookie，键和值都为字符串
session: 似于字典的对象,表示当前的会话
body: 字符串，请求体的内容(POST或PUT)
scheme: 请求协议(‘http’ /‘https’)
request.get_full _path()∶ 请求的完整路径
request.META: 请求中的元数据(消息头)
客户端IP地址 -> request.META[‘REMOTE_ADDR’] :

#在视图函数输出
def test_request ( request) :
print( ’ path info is’ , request.path_info)
print ( ’ method is’, request.method)
print ( ’ querystring is’ , request.GET)
return HttpResponse( ’ test request ok’ )

## Django响应

构造函数格式:

> HttpResponse(content=响应体,content_type=响应体数据类型, status=状态码)
> 作用:
> 向客户端浏览器返回响应，同时携带响应体内容

```sh
常用的Content-Type如下
>
- 'text/html’(默认的,html文件)
- 'text/plain’(纯文本)
- 'text/css’(css文件)
- 'text/javascript'(js文件)
- 'multipart/form-data’(文件提交)
- 'application/json'(json传输)
- 'application/xml’(xml文件)

[外链图片转存中…(img-YnXkW921-1642079895356)]

http请求

GET,POST最常用

[外链图片转存中…(img-NgqhpSNT-1642079895356)]

[外链图片转存中…(img-HFnux1UU-1642079895357)]

http1.0

• GET

  • 请求指定的页面信息，并返回实体主体

• HEAD （测试）

  • 类似于get请求，只不过返回的响应中没有具体的内容，用于获取报头

• POST

  • 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中，可能会导致新的资源的建立和/或已有资源的修改。

HTTP1.1新增

• PUT (更新数据)

  • 从客户端向服务器传送的数据取代指定的文档的内容。

• DELETE （删除）

  • 请求服务器删除指定的页面。

• CONNECT （代理）

  • HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。

• OPTIONS （协商）

  • 允许客户端查看服务器的性能。

• TRACE （链路测试）

  • 回显服务器收到的请求，主要用于测试或诊断。

HTTP响应

[外链图片转存中…(img-UNX4USQh-1642079895357)]

[外链图片转存中…(img-VvJF5OBc-1642079895358)]

下面是常见的HTTP状态码:

• 200-请求成功
• 301 -永久重定向-资源（网页等）被永久转移到其它URL-
• 302-临时重定向
• 404-请求的资源（网页等)不存在
• 500–内部服务器错误

五大类状态码
1**  	服务器收到请求，需要请求者继续执行操作
2**		成功，操作被成功接收并处理
3** 	重定向，需要进一步的操作以完成请求
4**		客户端错误，请求包含语法错误或无法完成请求
5**		服务器错误，服务器在处理请求的过程中发生了错误

项目开发

• 项目组成员角色
  • 产品/运营经理:负责产品功能细节的把控
  • 开发
    • 前端–负责显示部分内容的开发【多】
    • 后端–负责服务器部分的功能开发【少】
  • 运维–管理linux服务器，组件化配置，安全问题
  • 测试–负责找出产品功能的问题【BUG】
  • 美术-负责产品素材方面得绘制