Django框架入门_django 前端框架

Django框架入门

为什么用框架？使用框架的优势有哪些？

封装----大量的功能封装，简化了开发任务

简化----把相对复杂的功能进行封装后做到简化

优化----直白的说是大咖帮你把很多Py代码优化了，进一步提升了效率

漏洞----弥补了已知的网站传输漏洞，比如sql注入

管理----框架以模块划分，负责不同的功能，清晰易于管理

使用Django框架的优势

1.简便、快捷的开发数据库驱动的网站。它强调代码复用，多个组件可以很方便的以"插件"形式服务于整个框架。

2.Django具有很强的可扩展性。Django框架有许多功能强大的第三方插件，可以方便用户开发出自己的工具包。

3.强调快速开发和 DRY ( Do Not Repeat Yourself )原则。

Django框架的特点

Django 是一款重量级框架, 内部架构使用的是 MVT 设计模式.

对比 Flask 框架，Django 原生提供了众多的功能组件，让开发更简便快速。

关于网站框架的MVC结构

1.什么是MVC？

M = Model 俗称模型，其实就是控制你的数据库表结构的东西

V = View 俗称视图，其实就是负责具体前端输出的内容，比如：颜色、文字、表单等等

C = Controller 俗称控制器，其实就是具体负责实现的功能，比如：加减乘除、增删改写等等

2.什么是router和渲染template?

2.1 router 路由

简单粗暴的说，路由就是用户访问的地址（如：www.baidu.com）通过router映射到控制器（Controller）的功能，这个功能包含很多，如渲染某个页面（模板）等

2.2 渲染模板（template）

简单来说，就是用户看到的页面，即为view视图层

注意：Django也是一个MVC框架。但是在Django中，控制器接受用户输入的部分由框架自行处理，所以 Django 里更关注的是模型（Model）、模板(Template)和视图（Views），称为 MTV模式其内部对应关系如下：

标准MVC中：

Model ------> 模型。管理应用程序的状态（通常存储到数据库中），并约束改变状态的行为（或者叫做“业务规则”）。

View ------> 视图。负责把数据格式化后呈现给用户。

Controller -------> 控制器。接受外部用户的操作，根据操作访问模型获取数据，并调用“视图”显示这些数据。控制器是将“模型”和“视图”隔离，并成为二者之间的联系纽带。

Django的MVC：

Model ----> 模型。即数据存取层。 该层处理与数据相关的所有事务： 如何存取、如何验证有效性、包含哪些行为以及数据之间的关系等。

Tempalte ------> 视图。即表现层。 该层处理与表现相关的决定： 如何在页面或其他类型文档中进行显示。

View -----> 控制器。即业务逻辑层。 该层包含存取模型及调取恰当模板的相关逻辑。 你可以把它看作模型与模板之间的桥梁。

Django框架的MVC流程

基本流程：

创建Django项目的流程

1.确定项目需求和功能：首先，需要明确自己要开发的项目的需求和功能，包括数据模型、视图、模板等

2.安装Django：使用pip安装Django。

3.创建Django项目：通过运行django-admin startproject projectName命令来创建Django项目。 其中，projectName为创建的项目名称。

4.创建应用程序：使用python manage.py startapp appName命令创建应用程序。 其中，appName为创建应用程序的名称。注意需先进入到创建的Django项目文件中。

django中的一个app就是项目里面的一个应用的意思，一个项目可以包含多个app,一个app通常就是一个相对独立的模块，实现相对独立的功能，如管理员设计在mgr模块中，销售员设计在sales模块中。

这一步会自动创建django项目的设置文件、初始化文件、路由配置文件、服务器代理设置文件以及主程序文件以及应用程序相关的文件。如，创建一个名为 weibo_test的django项目。其中的first为创建的app应用程序。

5.编写模型：定义模型类，表示数据库中的数据表。

6.编写视图：编写视图函数来处理用户的请求。

7.编写模板：编写HTML模板文件，将数据渲染到模板中。

8.创建URL：创建URL模式来匹配用户请求。

9.运行项目：使用python manage.py runserver命令启动Django开发服务器。

10.测试项目：使用Django测试框架进行测试。

11.部署项目：将项目部署到生产服务器上。

12.维护项目：对项目进行维护和更新，确保项目的正常运行。

Django框架创建的常见命令

创建项目：django-admin startproject projectName ,其中，projectName为创建项目的名称

创建app(需先进入创建的Django工程目录)： python manage.py appName,其中，appName为创建的app名称

创建数据库表（需先进入创建的Django工程目录）：python manage.py makemigrations

执行数据库表建立（需先进入创建的Django工程目录）：python manage.py migrate

模板渲染嵌入语法：在html可以嵌入后台语言，区分符号：》> {% 命令 %} {{ 变量 }}

注意：所有的命令必须前缀均为python manage.py ,表示执行的所有操作均在manage.py对应的django项目工程下

Django框架的目录简要介绍

Django的使用流程

1.安装Django

pip install django
1

执行命令后，会在安装python的文件中新增两个文件夹：

假设安装的python在c盘的python39文件夹下，则相应的文件路径如下：

c:\python39
    - python.exe
    - Scripts
    	- pip.exe
        - django-admin.exe (新增文件之一) 【工具，帮助创建django项目中的文件和文件夹】
    - Lib
    	- 内置模块
        - site-package
        	- python-docx
            - flask
            - django（新增文件之二）【为django框架的源码，创建django项目时，需引入该文件】
1
2
3
4
5
6
7
8
9
10
11

2.创建项目

2.1 基于终端创建

• 打开终端

• 进入放入项目的文件目录，以D:\Program Files\Python\Code 为例

  cd D:\Programs Files\Python\Code
  1

• 执行命令创建项目

  "C:\python39\Scripts\django-admin.exe" startproject 项目名称
  1

  # 如果c:\python39\Scripts 已加入系统环境变量
  django-admin startproject 项目名称
  1
  2

  # 如：在D:\Program Files\Python\Code文件下创建名为weibo_test的django项目
  django-admin startproject weibo_test
  1
  2

  执行该命令后，会在对应的文件目录中创建weibo_test的文件夹，如图：
  

2.2 基于企业版本的pycharm创建

下图为所截的其他博主图片，使用企业版本的Pycharm创建django项目时，只需选择创建django项目，并指定创建项目的文件路径和解释器版本即可。

两种创建方式的对比：

• 命令行创建的项目是标准的
• pycharm，在标准的基础上默认增加了一些东西
  • 创建了一个templates目录。（用来存放前端界面）
  • settings.py中，在templates配置中，新增了一句话：‘DIRS’:[os.path.join(BASE_DIR,‘templates’)],表示前端的页面默认在文件夹templates中

默认Django项目的文件介绍

weibo_test
	manage.py           [项目的管理，启动项目、创建app、数据管理] [先维持默认即可，不要修改，常用文件]
	weibo_test
		__init__.py
		settings.py     [项目的配置文件，如数据库配置等]     [经常修改的文件]
		urls.py         [url和函数的对应关系]              [经常修改的文件]
		asgi.py         [接收异步的网络请求]               [先维持默认即可，不要修改]
		wsgi.py         [接受同步的网络请求]               [先维持默认即可，不要修改]
1
2
3
4
5
6
7
8

3.创建app

- 项目
	- app,用户管理[表结构、函数、HTML模板、CSS]
	- app,订单管理[表结构、函数、HTML模板、CSS]
	- app,后台管理[表结构、函数、HTML模板、CSS]
	- app,网站   [表结构、函数、HTML模板、CSS]
	- app,API   [表结构、函数、HTML模板、CSS]
	……
注意：我们开发比较简洁，用不到多个app，一般情况下，一个项目下创建1个app即可。
1
2
3
4
5
6
7
8

# 创建app指令
# python manage.py startapp appName 其中appName为app的名称
# 需先进入创建django的项目目录中
# 如创建的django项目为weibo_test文件
cd weibo_test
python manage.py startapp first
1
2
3
4
5
6

对应文件目录解析：

- first
	- __init__.py
    - admin.py                [固定，不用动] django默认提供了admin后台管理
    - apps.py                 [固定，不用动] app启动类
    - migrations              [固定，不用动] 数据库变更记录
    	- __init__.py
    - models.py               [**重要**] 对数据库操作
    - tests.py                [固定，不用动] 单元测试
    - views.py                [**重要**] 函数
- manage.py
- weibo_test
	- __init__.py
    - asgi.py
    - settings.py
    - urls.py                 [url --> 函数]
    - wsgi.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.快速上手

• ① 确保app已注册 【在settings.py文件中编写】
  • 怎么注册？
  • 在settings.py文件中的INSTALLED_APPS列表中添加内容为app项目文件中的apps.py中的主类名文件

• ② 编写URL和视图函数对应关系 【在urls.py文件中编写】

• ③ 编写视图函数 【在views.py文件中编写】

• ④ 启动django项目

  • 终端指令：

    python manage.py runserver
    1

  • pycharm启动：

执行结果：

后续再添加一个页面时，本质上就是url和函数的映射关系。如url和函数的一一对应关系：

4.1 templates模板

编写网站项目时，当需要将返回的数据用前端页面（html）显示时，需要使用render函数。如：

# 注意：若在settings.py文件中的TEMPLATES列表元素中设置了 
# 'DIRS':[os.path.join(BASE_DIR,'templates')]
# 则会默认再项目文件的根目录下找templates文件中的user_list.html
# 去first目录下的templates目录寻找user_list.html
# 当需要将数据返回至html文件中，需要使用render函数，且render函数默认有一个名为request的参数
# 根据app的注册顺序，逐一去他们的templates目录中找指定网页
# 查找顺序：
# 1.优先去项目根目录的templates中寻找【需要提前配置，不配置无效】
# 2.根据app的注册顺序，在每个app下的templates目录中寻找
1
2
3
4
5
6
7
8
9

4.2 引入静态文件

• 直接引入：

# 如引入一个图片
<img src='/static/img/1.jpg'>
1
2

• django引入：

{% load static %} //需写在页面的顶部
<link rel="stylesheet" href="{% static 'img/1.jpg' %}">
1
2

如：

{% load static %}
		<link rel="stylesheet" type="text/css" href="{% static 'admin/component/pear/css/pear.css' %}">
        <link rel="stylesheet" type="text/css" href="{% static 'admin/admin/css/loader.css' %}"/>
        <link rel="stylesheet" type="text/css" href="{% static 'admin/admin/css/admin.css' %}"/>
1
2
3
4

django引入静态文件的好处：

• 方便后期修改维护。若后期的静态文件名改名为statics，不是默认的static，则可在settings.py文件中设置修改static静态资源路径名即可。

4.3 模板语法

本质上是将后端返回的数据进行渲染显示在前端界面上进行前后端交互。

• 普通字符串：直接将数据返回给页面，页面可直接读取

# 如
view.py:
    def index(request):
        name = '张三'
        return render(request,'index.html',{'n1':name})
urls.py:
    # 导入views文件
    from first import views
    path('index/',views.index)
templates下的index.html:
    <h1> {{ n1 }} </h1>
    
页面显示结果：张三
1
2
3
4
5
6
7
8
9
10
11
12
13

• 列表元素类型：通过数组下标调用显示数据,下标从0开始

# 如
view.py:
    def index(request):
        name = ['张三','李四','王五']
        return render(request,'index.html',{'n1':name})
urls.py:
    # 导入views文件
    from first import views
    path('index/',views.index)
templates下的index.html:
    <h1> {{ n1 }} </h1>
    {{ n1.0 }} {{ n1.1 }} {{ n1.2 }}
页面显示结果：['张三','李四','王五'] 张三 李四 王五
1
2
3
4
5
6
7
8
9
10
11
12
13

• 字典数据类型：通过键值对的形式调用显示数据，即key和value

# 如：
view.py:
    def index(request):
        user_info = {"name":"李四","salary":100000,"role":"CTO"}
        return render(request,'index.html',{'n1':user_info})
urls.py:
    # 导入views文件
    from first import views
    path('index/',views.index)
templates下的index.html:
    <h1> {{ n1 }} </h1> 
    {{ n1.name }}
    {{ n1.salary }}
    {{ n1.role }}
    <ul>
    	{% for item in n1.keys %}
    	<li> {{ item }} </li>
    </ul>
    <ul>
    	{% for item in n1.values %}
    	<li> {{ item }} </li>
    </ul>
页面显示结果：{"name":"李四","salary":100000,"role":"CTO"}
            name
            salary
            role
            李四
            100000
            CTO
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

• 列表元素为字典的数据类型：通过字典的键值对的名称调用显示数据，即字典中对应的键和值

# 如：
view.py:
    def index(request):
        user_info = [
            {"name":"李四","salary":100000,"role":"CTO"},
            {"name":"张三","salary":100000,"role":"CTO"},
        ]
        return render(request,'index.html',{'n1':user_info})
urls.py:
    # 导入views文件
    from first import views
    path('index/',views.index)
templates下的index.html:
    <h1> {{ n1 }} </h1> 
    {{ n1.0.name }}
    {{ n1.0.salary }}
    {{ n1.0.role }}
    <ul>
        {% for item in n1 %}
        <li> {{ item.name }} {{ item.salary }} </li>
        {% endfor %}
    </ul>
页面显示结果：[{"name":"李四","salary":100000,"role":"CTO"},{"name":"张三","salary":100000,"role":"CTO"}]
			李四 100000 CTO 
            李四 100000
            张三 100000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

视图函数的render内部（数据渲染过程）：

1.读取含有模板语法的html文件

2.内部进行渲染（模板语法执行并替换数据）

最终得到，只包含HTML标签的字符串

3.将渲染（替换）完成的字符串返还给用户浏览器

如：

案例

通过爬取联通新闻数据，并将数据显示在前端页面上

5.请求和响应

app->views.py
# 请求和响应数据
def something(request):
    # request是一个对象，封装了用户发送过来的所用请求相关数据
    # 1.获取请求方式
    print(request.method)
    # 2.在url上传递值(get方式)
    print(request.GET)
    # 3.在请求体中传递数据（post方式）
    print(request.POST)
    # 4.【响应】将字符串内容返回给请求者
    # return HttpResponse('返回内容')
    # 5.【响应】读取HTML的内容 + 数据渲染（替换）---> 生成新的字符串返回给用户浏览器
    # return render(request,'something.html',{"title":"来了"})
    # 6.【响应】让浏览器重定向到其他的页面
    return redirect('https://www.baidu.com')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

关于重定向

用户发起请求，后台设置返回的页面为其他页面，此时涉及到重定向，浏览器处理重定向的流程如下：

① 用户发起请求 —> ② 浏览器设置返回为其他页面 ----> ③ 浏览器将返回的其他页面的url返回给用户对应的服务器 ----> ④ 用户对应的服务器请求该页面 -----> ⑤ 用户对应的服务器将请求到的页面数据返回给用户浏览器

注意：当使用django实现简单用户登录或其他功能时，出现403错误时，只需在登陆页面或其他实现功能的前端页面中的form表单加入 {% csrf_token %}即可。

原因：django框架有个默认的验证机制，即csrf_token,若页面是从本地发起请求并回到本地页面时，服务器会通过验证传输过来的数据是否包含csrf_token数据，若包含，则可顺利跳转页面；若不包含，可能会出现403错误。

6.数据库操作

MySQL + pymysql

import pymysql
# 1.连接mysql
conn = pymysql.connect(host="127.0.0.1",port=3306,user='root',password='root123',charset='utf8',db='unicom')
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
# 2.发送指令
cursor.execute("insert into admin(username,password,mobile)")
values('sky','qew123','13245542545')
conn.commit()
# 3.关闭
cursor.close()
conn.close()
1
2
3
4
5
6
7
8
9
10
11

Django开发数据库更为简单，内部提供了ORM框架

Django开发数据库操作

6.1 安装第三方模块

# 建议使用mysqlclient,当前最新版本的django的数据库开发操作中，pymysql有些操作无法执行
# 最新版本的django中开发支持了mysqlclient的相关开发
pip install mysqlclient 
1
2
3

6.2 ORM框架

ORM可以帮助开发者做两件事：

• 创建、修改和删除数据库中的表（不用自己写sql语句） 【缺点：无法创建数据库】
• 操作表中的数据（不用写SQL语句）

6.3 创建数据库

create database test DEFAULT CHARSET utf8 COLLATE utf8_general_ci;
1

6.4 django连接数据库

在settings.py中编写：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'test', # 连接的数据库名
        'USER': 'root', # 用户名
        'PASSWORD': 'root123', # 密码
        'HOST': '127.0.0.1',   # 主机的IP地址，localhost也可以
        'PORT': 3306,        # mysql的端口号
    }
}
1
2
3
4
5
6
7
8
9
10

6.5 django操作表

• 创建表

在models.py文件中：

class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    password = models.CharField(max_length=64)
    age = models.IntegerField()
    
    """
    当django程序读取到models.py中定义的类时，以UserInfo类为例
    会在数据库中进行如下操作：
    这里的表名为app项目名称 + '_' + 小写英文字母的类名
    create table first_userinfo(
        id bigint auto_increment primary key, # 这里的id为django框架中的ORM框架自动生成的，且为该表主键
        name varchar(32),
        password varchar(64),
        age int
    )
    """
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

此时，数据库中并未创建first_userinfo表，想同步数据库操作，需在终端执行以下两个操作：

# 注意：执行以下命令时，需保证终端路径在项目的根目录，即含有manage.py的文件中
# 注意：app需要提前注册
python manage.py makemigrations
python manage.py migrate
1
2
3
4

• 修改表或删除表：

注意：每次修改或删除表结构或数据时，均需执行如下命令：

# 注意：执行以下命令时，需保证终端路径在项目的根目录，即含有manage.py的文件中
# 注意：app需要提前注册
python manage.py makemigrations
python manage.py migrate
1
2
3
4

在表中新增列时，由于已存在列中可能已有数据，所以新增列必须要指定新增列对应的数据，方法如下：

• 手动输入一个值

• 设置默认值

  age = models.IntegerField(default=2)
  1

• 设置默认值允许为空

  data = models.IntegerField(null=True,blank=True)
  1

以后再开发中如果想要对表结构进行调整：

• 在models.py文件中操作类即可

• 相关命令：

  python manage.py makemigrations
  python manage.py migrate
  1
  2

  6.6 django操作数据库进行增删改查

# 1.新建数据 
# 本质： insert into first_userinfo(name,password,age) values('张三','123456',17)
# UserInfo.objects.create(name='张三',password='123456',age=17)

# 2.删除数据 
# 本质： delete table first_userinfo where id=3
# 其中的filter为条件筛选，这里意为将first_userinfo表中的id值为3的数据删除
# UserInfo.objects.filter(id=3).delete
# 数据表中的数据全部删除
# UserInfo.objects.all().delete()

# 3.获取数据 
# 3.1 获取符合条件的所有数据
# 本质： 相当于select * from first_userinfo
# 获取first_userinfo表中所有的用户数据
# 这里的data_list 为QuerySet数据类型
# 得到的数据类型：
# <QuerySet [<UserInfo: UserInfo object (1)> <UserInfo: UserInfo object (2)>]>
# data_list = [对象，对象，对象] QuerySet类型
#  data_list = UserInfo.objects.all()
# 获取data_list中的数据
# for obj in data_list:
#   print(obj.id ,obj.name ,obj.password ,obj.age)
# 3.2 获取第一条数据 [对象]
# 注意，即使获取到的数据只有一条，其数据类型均为QuerySet数据类型
# 可通过first()方法直接获取到该数据
# 如：
# obj = UserInfo.objects.filter(id=1).first()
# print(obj.id,obj.name,obj.password,obj.age)

# 4.更新数据
# 将first_userinfo表中的所有用户的密码更改为999
# UserInfo.objects.all().update(password='999')
# 将first_userinfo表中id为2的用户的密码更改为999
# UserInfo.objects.filter(id=2).update(password='999')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35