Django（一）

推荐教程：https://code.ziqiangxuetang.com/django/django-tutorial.html

MVC设计模式（Model，View，Controller）

Model：用于封装与应用程序的业务逻辑相关的数据及对数据的处理方法，是Web应用程序中用于处理应用程序的数据逻辑部分，Model通常只提供功能性的接口，通过这些接口可以获取Model的所有功能。

View:负责数据的显示和呈现，View是对用户的直接输出。

Controller:负责从用户端收集用户的输入，可以看成提供View的反向功能，主要处理用户交互。

Django是MVT模式，本质上还是MVC模式

MVT本质上与MVC没什么差别，也是各组件之间为了保持松耦合关系，只是定义上有些许不同。

Model:负责业务对象与数据库（ORM）的对象

View:负责业务逻辑，并在适当的时候调用Model和Template

Template:负责把页面展示给用户

注意:Django中还有一个url分发器（也可以叫做路由），主要用来将一个个URL页面的请求分发给不同的View进行处理，View再调用相应的Model和Template。

1.虚拟环境的安装

    作用：隔离项目运行环境

    安装virtualenvwrapper，详情见环境搭建之virtualenv的安装

2.配置Django项目开发环境

    创建项目虚拟环境: （删除：rmvirtualenv 虚拟环境名称）

       mkvirtualenv --python=/usr/local/python3.5.3/bin/python venv_name

       其中，--python=的是你要使用的python解释器的路径，后面的是虚拟环境的名字

    进入虚拟环境： （退出：deactivate）

        workon 虚拟环境名称

        指定python解释器—>用绝对路径，在编译器中编辑时要指定编辑器的解释器。

    安装XXX依赖包：pip install XXX

        pip freeze: 查看虚拟环境新安装的包

        pip install django==2.2 (== 用来指定需要安装的版本)

3.Django项目

    创建项目：django-admin startproject axf

 

    Django 目录介绍

manage.py:
 是Django用于管理本项目的命令行工具，之后进行站点运行，数据库自动生成等都是通过本文件完成。

axf/__init__.py:
 告诉python该目录是一个python包，暂无内容，后期一些工具的初始化可能会用到

axf/settings.py:
 Django项目的配置文件，默认状态其中定义了本项目引用的组件，项目名，数据库，静态资源等。

axf/urls.py:
 维护项目的URL路由映射，即定义当客户端访问时由哪个模块进行响应。

axf/wsgi.py:
 定义WSGI的接口信息，主要用于服务器集成，通常本文件生成后无需改动。

    启动服务：python manager.py runserver [ip:port] 默认本机8000端口

    生成迁移：python manager.py makemigrations
    执行迁移：python mananger.py migrate

 

    settings中的DataBase模块，可以直接连接操作数据库Sqlite和MySQL

  1 'ENGINE':'django.db.backends.mysql', # 驱动
  2 'NAME':'school', # 数据库名
  3 'USER':'root', # 用户名
  4 'PASSWORD':'123', # 用户密码
  5 'HOST':'127.0.0.1', # 主机
  6 'PORT':'3306', # 端口
  7

    安装sql驱动：pip install pymysql
    安装后还需要在__init__.py中添加初始化代码
        import pymysql
        pymysql.install_as_MySQLdb() # 导入驱动

 

    创建应用：python manager.py startapp XXX（应用名）

    将应用添加到settings.py.INSTALLED_APPS中使应用生效

    应用目录介绍：

__init__.py:
 其中暂无内容，使得app成为一个包

admin.py:
 管理站点模型的声明文件，默认为空

apps.py:
 应用信息定义文件，在其中生成了AppConfig，该类用于定义应用名等数据

models.py:
 添加模型层数据类文件

views.py:
 定义URL相应函数（路由规则）

migrations包:
 自动生成，生辰迁移文件的

tests.py:
 测试代码文件

 

    创建响应函数连接应用路由到项目路由：

首先我们在views.py中建立一个路由响应函数
from django.http import HttpResponse

def welcome(request):
	return HttpResponse('HelloDjango');

接着我们在urls中进行注册
	from App import views
	path('welcome/',views.welcome)

基于模块化的设计，我们通常会在每个app中定义自己的urls

在项目的urls中将app的urls包含进来
	from django.conf.urls import include
 	path('welcome/',include('App.urls'))

 

    模板文件templates：

    客户端显示的实际上是经过处理的模板HTML

模板文件实际上就是我们用HTML写好的页面

在项目文件夹下创建模板文件夹templates
在工程目录的需要注册
    settings中的TEMPLATES中的DIRS中添加
	os.path.join(BASE_DIR,'templates')
在模板文件夹中创建模板文件 XXX.html

在views中去加载渲染模板
1.from django.template import loader
	template = loader.get_template('xxx')
	return HttpResponse(template.render())

2 return render(request,'xxx') #我喜欢这种

 

    模型介绍model：

    以学生班级为例，定义两个模型结构

from django.db import models
# 定义年级
class Grade（models.Model）:
	g_name = models.CharField(max_length=10)
    	g_date = models.DateTimeField()
    	g_girlnum = models.IntegerField()
    	g_boynum = models.IntegerField()
    	isDelete = models.BooleanField()

# 定义学生
class Students(models.Model):
    	s_name = models.CharField(max_length=20)
    	s_gender = models.BooleanField(default=True)
    	s_age = models.IntegerField()
    	s_info = models.CharField(max_length=20)
    	isDelete = models.BooleanField(default=False)
    	# 关联外键>>理解原理需要学习数据库
    	s_grade = models.ForeignKey(Grade)

    上面在settings中设置了MySQL的连接参数，这里就可以迁移数据到MySQL数据库

    生成迁移文件：python manager.py makemigrations
    执行迁移操作：python mananger.py migrate

 

测试数据模型：

插入数据：
    {
    # 实例化对象：
        对象=类名； grade_one = Grade()
    # 对象属性赋值：
        对象.属性=值；grade_one.g_girlnum = 55
        .........
    对象.save()
    }

查询:
    查询所有数据：类名.objects.all();Grade.objects.all()
    根据id查询一条数据：Grade.objects.get(pk=id)
    根据条件筛选：Grade.objects.filter(条件)

修改数据：
    {
    # 查询要修改的对象：
        对象=类名.objects.查询方法；
        grade_one = Grade.objects.get(pk=id)

    # 对象属性赋值：
        对象.属性=值；grade_one.g_girlnum = 55
        .........
        对象.save()
    }

删除数据：
    {
   # 查询要删除的对象：
        对象=类名.objects.查询方法；
        grade_one = Grade.objects.get(pk=id)

        对象.delete()
        grade_one.delete()
    }

    创建班级数据：

在App.views中

# 导入包:
from App.models import *
from django.utils import timezone
from datetime import *

# 创建插入班级数据的函数：
def add_grade(request):
    grade_one = Grade()
    grade_one.g_name = 'python9102'
    grade_one.g_date = datetime(year=9102, month=7, day=28)
    grade_one.g_girlnum = 55
    grade_one.g_boynum = 6
    grade_one.save()
    return HttpResponse('add OK')

    创建学生数据：

在views中创建插入学生数据的函数：

def add_student(request):
    stu = Students()
    stu.s_name = 'rook'
    stu.s_age = 18
    stu.s_gender = True
    stu.s_info = '学渣2'
    stu.s_grade = Grade.objects.get(pk=2)
    stu.save()
    return HttpResponse('add {} OK'.format(stu.s_name))

Django中获得关联对象集合:

    获取班级中的所有学生
    对象名.关联的类名小写_set.all()   
    grade_one.student_set.all()
---------------------------------------------------------------------------

数据从数据库到客户端的常用流程：

    客户端访问→路由urls↓

    urls根据规则调取views中对应方法↓

    views中的方法从models中取得数据↓

    views将数据渲染进templates中的对应的模型↓

    将渲染好的模板返回给客户端。。。点击查看模型图

Django模板语法：

views中传参：
def 函数名(request):

    XXX。。。处理逻辑。。。

    data = {
        key：value，
        。。。。。。
    }
    return render(request, '模板相对templates的路径', context=data)

模板语法：
直接取值用{{ key }}接受views函数中传过来的context的值
表达式：{% for XX in key %}。。。等多种表达式
	处理逻辑。。。
       {% endfor %}

反向解析语法：{ % url 'name' 'p1' 'p2' %}?=
’get请求方式‘，'p1'和 'p2'是数据

将接收到的数据当成普通字符串处理还是当成HTML代码来渲染
渲染成html:
{{ code|safe}}

{% autoescape off%}
	code
{% endautoescape %}

不想渲染
{% autoescape on%}
	code
{% endautoescape %}

某些恶意网站包含链接，表单，按钮，Js利用登陆用户在浏览器中的认证信息，进行非法操作，攻击服务，破坏数据

在表单中添加
{% csrf_token %}

在settings中的中间件MIDDLEWARE中配置打开
    'django.middleware.csrf.CsrfViewMiddleware',

extends 继承，写在开头位置
    {% extends  '父模板路径' %}

关键字block:
    {% block XXX%}
          code
    {% endblock %}

include:加载模板进行渲染
    格式{% include '模板文件' %}

参考文档：菜鸟教程||博客园-郭楷丰 详细图文随笔||CSDN参考博客

 

Django模型：

Django的model应用的是ORM模式

    ORM 全拼Object-Relation Mapping（对象关系映射）；

定义表信息：
class Meta：
    db_table = xxx 定义数据表名，推荐使用小写字母
    ordering =[]
 升序ordering['id']，降序ordering['-id']

过滤条件：
all()：返回所有数据
filter()：返回符合条件的数据
exclude()：过滤掉符合条件的数据
order_by()：排序
values()：一条数据就是一个字典，返回一个列表
get()：返回一个满足条件的对象，没有或多个会抛异常
first()：返回查询集中的第一个对象
last()：返回查询集中的最后一个对象
count()：返回当前查询集中的对象个数
exists()：判断查询集中是否有数据，有返回True
可以连用

在模型类中增加类方法去创建对象：
@classmethoddef
create(cls,name,age):
    自定义创建对象的方法。。。

比较运算：
语法:属性名称__比较运算符=值
外键:属性名_id
Student.objects.all()[0:5]；取前5个，下标不能是负数
filter(sname__contains='%')；sname中包含%，开头加i不区分大小写
startswith,endswith：以values开头或结尾，开头加i不区分大小写
isnull,isnotnull：是否为空(sname__isnull=False)
filter(pk__in=[2,4,6,8])；是否包含在范围内
gt,gte,lt,lte：大于，大于等于，小于小于等于

处理时间序列：
filter(lasttime__year=2017)
filter(pub_date__gt=date(1990,1,1))；导入datetime.date

跨关系查询:
模型类名__属性名__比较运算符，实际上就是处理的数据库中的join
grade = Grade.objects.filter(student__scontend__contains='楚人美')
描述中带有'楚人美'这三个字的数据属于哪个班级

聚合函数：
使用aggregate()函数返回聚合函数的值
Avg：平均值
Count：数量
Max：最大
Min：最小
Sum：求和
Student.objects().aggregate(Max('sage'))

F对象：
可以使用模型的A属性与B属性进行比较
grades = Grade.objects.filter(ggirlnum__gt=F('gboynum') )
F对象支持算数运算
grades = Grade.objects.filter(ggirlnum__gt=F('gboynum') +10 )

Q对象：
过滤器的方法中的关键参数，常用于组合条件
年龄小于25
Student.objects.filter(Q(sage__lt=25))
Q对象语法支持  | (or), & (and), ~(取反)
年龄大于等25
Student.objects.filter(~Q(sage__lt=25))
filter(Q(readcount__gt=20) | Q(id__lt=3))

Django模型对应关系有：
1:1（一对一）
1：N（一对多）
M:N（多对多）
常见的几种数据关系，django都提供了很好的支持

1 ： 1
使用models.OneToOneField()进行关联
class Card(models.Model):
	person = models.OneToOneField(Person，on_delete='CASCADE')

绑定卡与人的一对一关系
默认情况下，当人被删除的情况下，与人绑定的卡就也删除了
可以使用on_delete进行调整
on_delete：
	models.CASCADE：默认值
	models.PROTECT：保护模式
	models.SET_NULL：置空模式
	models.SET_DEFAULT：置默认值
	models.SET()；删除的时候重新动态指向一个实体
访问对应元素：person.pcard

1 ： N
使用models.ForeignKey关联
删除时同 1 : 1
获取对应元素  grade.student_set

M : N
使用models.
删除会删除指定对象和关系表中的关系映射
获取对应元素Goods和Buyer
	goods. buyer_set
	buyer. bgoods
买家添加buyer.bgoods.add
买家清空buyer.bgoods.clear
买家移除buyer.bgoods.remove

模型继承：
在models中添加Meta，指定是否抽象，然后进行继承
class Animal(models.Model):
	xxx
	class Meta:
		abstract = True/False

class Dog(Animal):
	xxx

模型关系参考：https://blog.csdn.net/duus_nabolun/article/details/83107276

Django数据查询时返回的是QuerySet对象；参考：Django ORM之QuerySet

自定义管理器参考：django之ORM介绍与基本使用↓↓

参考文档：菜鸟教程||django之ORM介绍与基本用法||django之ORM查询操作

 

Django-views：

Django中views模块是控制中心，几乎多有逻辑代码都在这个模块编写

HTTP请求中的两个核心对象：

    HttpRequest：请求对象

    HttpResponse：返回对象

Django在接收到http的请求后，会将请求生成一个WSGIRequest对象，并且作为参数传递给views函数的（request）参数，这个对象上包含着客户端上传的各种信息

视图函数处理完相关的逻辑后，也需要返回一个HttpResponseBase对象或者他的子类对象给浏览器。用的最多的子类对象是HttpResponse

WSGIResquest对象常用的属性和方法：（request）

常用属性：
path：请求的完整路径，不包含域名和参数
method：请求的HTTP方法（GET或POST）
GET：GET参数的类字典对象
POST：POST参数的类字典对象
FILES：上传文件的信息
COOKIES：字典对象，key和value都是字符串
session：字典对象，key和value都是字符串
META：所有客户端发来的header信息

常用方法：
is_secure()；是否采用Https协议
is_ajax()；是否采用ajax
get_host；服务器的域名，+[端口号]
get_full_path；返回完整的path，包括参数
get_raw_url()；获取完整url，(http://127.0.0.1:8000/index/)

QueryDict对象：（类字典对象）
get()；获取指定key的值，没有则返回None
getlist()；key有多个值时使用，返回一个列表

HttpResponse对象常用的属性和方法：

content：返回的内容
status_code：返回的http状态码
write()；写入数据到content中
set_cookie：设置cookie
delete-cookie：删除cookie
content_type：返回数据的MIME类型默认text/html
　　浏览器器会根据这个来显示数据常用的有：
　　text/html:（默认的，HTML文件）
　　text/plain:（纯文本）
　　text/css:（css文件）
　　text/javascript:（js文件）
　　multipart/form-data:（文件提交）
　　application/json:（json传输）
　　application/xml:(xml文件)

参考文档：https://www.cnblogs.com/dxnui119/p/10434274.html

 

Django中cookie的使用：

# 设置cookie，从服务器返回的response中设置
response  = redirect(path)；重定向到某个指定的路径下
response.set_cookie(key,value,max_age=0)
# 直接设置cookie的值和value
# max_age是过期时间，0是默认，None是永久，接上数字是具体时间，用s做单位
#如：response.set_cookie('name',person.name,max_age=3600)

# 获取cookie，从客户端请求中获得
name = request.COOKIE.get('name')
response = render(request,'home.index',contex=({'name':name})
return response

# 清除cookie，从response清除
response = redirect('namespace:name')
response.delete_cookie('name')

Django中session的使用：

# 设置session
#在setting中注册
# INSTALLED_APPS：
	'django.contrib.sessions'
# MIDDLEWARE:
	'django.contrib.sessions.middleware.SessionMiddleware'
#默认是加上的，在request中设置session
request.session['name'] = person.name
request.session.set_expiry(60) # 设置过期时间，单位是s

# 获取session，也是从request中获取
name = request.session.get('name')

# 删除session，在response中删除
response.delete_cookie('sessionid') # 在客户端删除session
del request.session['name'] # 在服务器端删除session
request.session.flush() # 直接清除两端的session

Django中token的使用：

# 设置token，首先需要建立有关token字段的表格，在response中设置
person.token = create_token() # create_token 是创造token的函数
response.set_cookie('token',person.token)

# 获取token，在request中获取token
person.token = request.COOKIE.get('token')

# 清除token，在response中清除
response.delete_cookie('token')

进行md5加密
import hashlib
def create_hash(password)
    md5 = hashlib.md5()
    md5.update(password.encode('utf-8'))
    return md5.hexdigest()

uuid创建token
import uuid
token = str(uuid.uuid5(uuid.uuid4() ,'token'))

urls：

带参数的url：可以指定参数类型

版本2.：path('marke/<int:typeid>/<childcid>/', views.market, name='market),

版本1.：url(r'^news/(?P<year>\d{4})/(?P<month>\d+)$',views.getNews)

验证码：

一般使用第三方包：Pillow

安装：pip install Pillow
核心：Image,ImageDraw,ImageFont

绘制流程：
import random
from PIL import Image, ImageDraw, ImageFont, ImageFilter

_letter_cases = "abcdefghjkmnpqrstuwxy"  # 小写字母，去除可能干扰的i，l，o，v,z
_upper_cases = _letter_cases.upper()  # 大写字母
_numbers = ''.join(map(str, range(3, 10)))  # 数字
init_chars = ''.join((_letter_cases, _upper_cases, _numbers))

def create_validate_code(size=(120, 30),
                         chars=init_chars,
                         img_type="GIF",
                         mode="RGB",
                         bg_color=(255, 255, 255),
                         fg_color=(0, 0, 255),
                         font_size=18,
                         font_type="Monaco.ttf", # 字体路径
                         length=4, # 验证码长度
                         draw_lines=True,
                         n_line=(1, 2),
                         draw_points=True,
                         point_chance = 2):
    '''
    @todo: 生成验证码图片
    @param size: 图片的大小，格式（宽，高），默认为(120, 30)
    @param chars: 允许的字符集合，格式字符串
    @param img_type: 图片保存的格式，默认为GIF，可选的为GIF，JPEG，PNG
    @param mode: 图片模式，默认为RGB
    @param bg_color: 背景颜色，默认为白色
    @param fg_color: 前景色，验证码字符颜色，默认为蓝色#0000FF
    @param font_size: 验证码字体大小
    @param font_type: 验证码字体，默认为 ae_AlArabiya.ttf
    @param length: 验证码字符个数
    @param draw_lines: 是否划干扰线
    @param n_lines: 干扰线的条数范围，格式元组，默认为(1, 2)，只有draw_lines为True时有效
    @param draw_points: 是否画干扰点
    @param point_chance: 干扰点出现的概率，大小范围[0, 100]
    @return: [0]: PIL Image实例
    @return: [1]: 验证码图片中的字符串
    '''

    width, height = size # 宽， 高
    img = Image.new(mode, size, bg_color) # 创建图形
    draw = ImageDraw.Draw(img) # 创建画笔

    def get_chars():
        '''生成给定长度的字符串，返回列表格式'''
        return random.sample(chars, length)

    def create_lines():
        '''绘制干扰线'''
        line_num = random.randint(*n_line) # 干扰线条数

        for i in range(line_num):
            # 起始点
            begin = (random.randint(0, size[0]), random.randint(0, size[1]))
            #结束点
            end = (random.randint(0, size[0]), random.randint(0, size[1]))
            draw.line([begin, end], fill=(0, 0, 0))

    def create_points():
        '''绘制干扰点'''
        chance = min(100, max(0, int(point_chance))) # 大小限制在[0, 100]

        for w in range(width):
            for h in range(height):
                tmp = random.randint(0, 100)
                if tmp > 100 - chance:
                    draw.point((w, h), fill=(0, 0, 0))

    def create_strs():
        '''绘制验证码字符'''
        c_chars = get_chars()
        strs = ' %s ' % ' '.join(c_chars) # 每个字符前后以空格隔开

        font = ImageFont.truetype(font_type, font_size)
        font_width, font_height = font.getsize(strs)

        draw.text(((width - font_width) / 3, (height - font_height) / 3),
                    strs, font=font, fill=fg_color)

        return ''.join(c_chars)

    if draw_lines:
        create_lines()
    if draw_points:
        create_points()
    strs = create_strs()

    # 图形扭曲参数
    params = [1 - float(random.randint(1, 2)) / 100,
              0,
              0,
              0,
              1 - float(random.randint(1, 10)) / 100,
              float(random.randint(1, 2)) / 500,
              0.001,
              float(random.randint(1, 2)) / 500
              ]
    img = img.transform(size, Image.PERSPECTIVE, params) # 创建扭曲

    img = img.filter(ImageFilter.EDGE_ENHANCE_MORE) # 滤镜，边界加强（阈值更大）

    return img, strs

在views中调用：
import io
from django.shortcuts import HttpResponse
from backend.utils import CheckCode

def check_code(request):
    """
    获取验证码
    :param request:
    :return:
    """
    stream = io.BytesIO()
    # 创建随机字符 code
    # 创建一张图片格式的字符串，将随机字符串写到图片上
    img, code = CheckCode.create_validate_code()
    img.save(stream, "PNG")
    # 将字符串形式的验证码放在Session中
    request.session["CheckCode"] = code
    return HttpResponse(stream.getvalue())

 

富文本：

用处大约有两种
    1. 在后台管理中使用
    2. 在页面中使用，通常用来作博客