Django入门

最新推荐文章于 2024-05-22 16:48:23 发布

置顶钟哥哥实在帅

最新推荐文章于 2024-05-22 16:48:23 发布

阅读量2k

点赞数

分类专栏：个人文章标签： django python 后端

本文链接：https://blog.csdn.net/weixin_39540280/article/details/122421066

版权

个人专栏收录该内容

51 篇文章 2 订阅

订阅专栏

1. Django的框架模式 - MTV

        M： Model层模型层，负责数据库的建模以及CRUD操作

        T： Templates层模板层，用于处理用户显示的内容，如HTML

        V： Views层视图层，处理与用户交互的部分操作，从模型中提取数据

MVC: Model（同M） Views(同T) Controllers（处理与用户交互的部分内容，从模型中获取数据，再交给视图层，再显示给用户

2. Django的使用

1. Django的介绍

        网站： https://www.djangoproject.com

2. Django的安装

        1. 在线安装

            sudo pip3 install django

        2. 离线安装

            1. 解压 tar -xvf Django-*tar.gz

            2. 安装 sudo python3 setup.py install

3. 使用django

        1. 创建django项目

            django-admin startproject 项目名

        2. 启动服务，用于访问

            使用manage.py 文件启动服务

            python3 manage.py runserver

        3. 访问网站

            启动服务成功后，在浏览器中，通过一下地址访问127.0.0.1:8000

3. Django项目结构介绍

1. manage.py

        负责执行django中各项操作文件，如：启动服务、创建管理员、创建应用、数据库的同步操作

2. 主目录（名称与项目名称相同）

__init__.py

         项目初始化文件，每当服务器启动的时候，都会自动执行

urls.py

        项目的基础url（路由）配置文件

wsgi

            应用服务器配置文件

settings.py

        项目的主设置文件如下：

            1. BASE_DIR 获取当前项目的根目录路径

            2. DEBUG：调试模式

                开发过程：推荐使用True

                上线运行：推荐使用False

            3. ALLOWED_HOSTS

                设置允许访问本项目的地址列表

                如果不设置的话，只有本机能访问

                推荐写'*',表示任何地址都允许访问该项目（局域网）

                运行服务器得用0.0.0.0：端口号

            4. INSTALLED_APPS

                指定已安装的应用，如果有自定义应用的话，需要在此位置进行注册

            5. MIDDLEWARE

                指定注册的中间件

            6. ROOT_URLCONF

                指定项目的基础路由配置文件

            7. TEMPLATES ：指定模板的信息

            8. DATABASES：指定数据库的信息

          9. LANGUAGE_CODE：指定当前网站的语言，如果要使用中文则可以修改为 zh-Hans

            10. TIME_ZONE 指定时区，如果指定中国时区，则可以修改为 Asia/Shanghai

urls.py

         默认是在主目录中，主路由配置文件，会包含最基本的地址映射。每个请求到达之后，都会由由url.py的URL_PATTERNS列表的url进行匹配url()函数匹配之后，可能将请求转交给其他的urls.py或视图（views）去处理

        url函数的语法： url(regex,views,kwargs=None,name=None)

                regex：正则表达式，匹配请求的url

                views：视图处理函数或其他的urls.py

                kwargs：字典，用来向views传参，没有参数则可以省略

                name：字符串,给url()起别名，主要在模板中使用

4. Django应用

什么是应用

        应用就是网站中一个独立程序模块

在settings.py中进行注册

        在INSTALLED_APPS中进行注册：

                NSTALLED_APPS = [

                        'django.contrib.admin',

                        ……，

                        'news']

应用的结构组成

migrations 目录：存放数据库中间文件（日志文件）

__init__.py：应用的初始化文件

admin.py：应用的后台管理配置文件

apps.py：应用的属性配置文件

models.py：模型文件，同数据库有关

tests.py：测试模块，基本没用

views.py：定义视图的文件

5. Django的Templates

1. 什么是模板

        模板就是要动态给用户呈现的网页内容

        其实就是一个网页 - 前后端结合的一个网页

2. 模板的设置

        在settings.py中TEMPLATES变量

            1. BACKEND: 指定模板的搜索引擎，不用动

            2. DIRS：指定模板所存放目录们， DIRS = ['index.temp']    index目录下的temp目录是模板存放位置，如果DIRS为空的话，那么django会自动到每个应用中去搜索一个叫templates的目录来作为模板的管理目录。

                推荐：DIRS内容保持为空和在每个应用中都创建一个templates目录

            3. APP_DIRS

                True: 首先从dirs中指定的目录中查找模板，如果没有找到的话，再搜索templates目录

3. 模板的加载方式

使用loader获取模板，并通过HttpResponse进行响应

        from django.template import loader

            1. 通过loader加载模板

                t = loader.get_template('模板名称')

            2. 通过t对象，将模板渲染成字符串

                html = t.render()

            3. 通过HttpResponse将html响应给客户端

                return HttpResponse(html)

使用render直接加载模板并返回

        from django.shortcuts import render

        return render(request, '模板名称', 要传给模板变量字典形式)

4 模板的语法

变量

        作用：允许将后端的数据传递给模板，在模板中，会根据变量的值进行显示

在django中允许传递给模板做变量的数据类型

        数字，字符串，列表，元素，字典，函数，对象

变量的语法

        1. loader

                dic = {

                    '变量名1'：'值1'，

                    '变量名2'：'值2'，

                }

                t = loader.get_template('xxx.html')

                return HttpResponse(t.render(dic))

                在模板中显示变量： {{变量名}}

        2. 标签

                1. 什么是标签

                    允许将服务器端的一些功能嵌入模板中

                2. 语法

                    {% 标签内容 %}

                3、常用标签

                        1、for

                                {% for 变量 in 列表|元组|字典 %}

                                {% endfor %}

                                允许使用 for 提供的内置变量 - forloop

                                1、forloop.counter：记录当前循环的次数，从1开始

                                2、forloop.first：是否是第一次循环(第一项)

                                3、forloop.last：是否是最后一次循环(最后一项)

                        2、if

                                1、{% if 条件 %} 满足条件运行的内容 {% endif %}

条件中允许使用比较运算符(>,<,>=,<=,==,!=)，逻辑运算符(not,and,or)

                                注意：and 和 or 不能同时出现

                                2、{% if 条件 %}满足条件运行的内容{% else %}不满足条件运行的内容{% endif %}

3、{% if 条件1 %}满足条件1运行的内容{% elif 条件2 %}满足条件2运行的内容{% elif 条件3 %}满足条件3运行的内容{% else %}以上条件都不满足的时候运行的内容{% endif %}

        3、过滤器

                1、作用：过滤数据，在显示变量的数据之前，允许对数据进行筛选或改变

                2、语法： {{变量|过滤器:参数}}

                3、简单的过滤器

                        1、{{value|upper}} 将value变为大写字符

                        2、{{value|lower}} 将value编写小写字符

                        3、{{value|add:num}} 将num累加到value之后

                        4、{{value|floatformat:n}} 将value四舍五入到n位小数

                        5、{{value|truncatechars:n}} 将字符串截取到n位(包含...)

6. 模型 Model

什么是模型

        模型，是根据数据库中数据表的结构来创建出来的class。每一张表到编程语言中就是一个class,表中的每一个列，到编程语言中就是class的一个属性。并且在模型中还可以完成对数据的CRUD操作

创建和使用模型 - ORM【对象关系映射（object Relational Mapping）】

        三大特征：

            1. 数据表到类(class)的映射

                将数据表自动生成一个class类，同时也允许将一个class类自动生成数据库中的一张表

            2. 数据类型的映射

                允许将表中的字段的数据类型自动映射成编程语言中对应的数据类型，也允许将编程语言的数据类型自动映射成表中的字段的数据类型

            3. 关系映射

                在编程语言中允许将表与表之间的关系映射处理，表与表之间的关系也可以自动映射到编程语言的class中，数据库表中的关联关系：一对一，一对多，多对多

        优点：

                1. 提高了开发的效率，能够自动完成表到对象的映射

                2. 不用SQL编码，也能够完成对数据的CRUD操作，可以省略庞大的数据访问层

创建和配置数据库

        1. 创建数据库（支持中文）

                create database 数据库名 default charset utf8 collate utf8_general_ci;

        2. 配置数据库（Django）

                在settings.py中配置数据库的信息，连接Mysql
DATABASES = {
    'default': {
    'ENGINE': 'django.db.backends.mysql',    # 引擎
    'NAME': 'webdb',    # DB名称
    'USER': 'root',     # 用户名
    'PASSWORD': '*******',  # 密码
    'HOST': '127.0.0.1',    # Host
    'PORT': '3306',   # 端口号
    }
}
# Django中连接mysql的话依赖pymysql，  在主目录中__init__.py
import pymysql
pymysql.install_as_MYSQLdb()
数据库的同步操作

        1. python manage.py makemigrations

作用：将每个应用下的models.py文件生成一个数据库的中间文件，并保存在migrations目录中。

        2. python manage.py migrate

作用：将每个应用下的migrations目录中的中间文件同步到数据库中。

编写models

        1. 注意

            1. Models中的每个class都称为模型类（Model类），实体类（Entry/Entity）

            2. Models中的每个模型类，必须继承自models.Model

        2. 编写模型类
class 类名（models.Model）:

    属性1 = models.字段类型（字段选项）
                1. 字段类型和字段选项

                        1. 字段类型

                            BooleanField()/CharField()/DateField()/DateTimeField()/DecimalField()/EmailField()/integerField()/TextField()/URLField/FloatField()/ImageField()

                        2. 字段选项

                            max_length: 指定数据的最大长度在CharField()必须要设置的选项

                            default: 为当前字段指定默认值

                            null: 指定当前字段是否允许为空，默认值是false

                    2. 数据的版本切换: 把数据库导成类 python manage.pyinspectdb > Models.py

        3. 模型中的CRUD

                1. 通过ORM向DB中增加数据: Entry.objects.create(属性=值,属性=值)
1. create创建
Author.objects.create(name='zsf',age=85)

2、创建一个 Models 对象，通过对象的 save() 完成增加
obj = Author(names='laoshe',age=65)
obj.save()

3、使用字典构建对象，通过 save() 完成增加
dic = {
    '属性1':'值1',
    '属性2':'值2',
}
obj = Entry(**dic)
obj.save()
2. 查询操作（重难点）

                        通过Entry.objects调用查询接口

                        1. 基本查询操作  all()

                            用法： Entry.objects.all()

                            返回： QuerySet

                        2. 查询指定列 values('列1','列2'，……)

                            用法： Entry.objects.values('列1','列2'，……)

                            返回： QuerySet

  ex: Entry.objects.all().values('names', 'age')

                        3. 根据条件查询部分行数据  Entry.objects.filter(参数)

                            1. 使用Entry属性作为查询参数

                                多个参数的话使用','隔开，映射到sql语句上，是使用and来进行关联的

ex： Author.objects.filter(id=1,name='莫言') ==

select * from Author where id =1 and name ='莫言'

                            2. 通过Field Lookup（查询表达式）完成复杂条件构建

                                查询表达式：每个查询表达式都是一个独立的查询条件，可以用在所有的有查询条件的位置处

                                1. __exact 作用：精确查询，等值判断

                                    用法： Entry.objects.filter(属性__exact=值)

                                    ex： Author.objects.filter(id__exact=1) == select * from Author where id = 1

                                2. __contains作用：筛选出属性中包含指定关键字的记录（模糊查询）

                                    ex:

                                        Author.objects.filter(names__contains = 'ao')

                                        select * from Author where names like '%ao%'

                                3. __lt 作用：筛选出属性值小于指定值的记录

                                4. __lte 作用：筛选出属性值小于等于指定值的记录

                                5. __gt, __gte

                                6. __startswith, __endwith

                            3. 查询值返回一条数据get(条件)

                                用法： Entry.objects.get(查询条件/表达式)

                                注意：该函数值适用于返回一条记录时使用

                3. 修改数据

                    1. 通过get()得到要修改的实体对象

                    2. 通过实体对象属性修改属性值

                    3. 再通过实体对象的save()保存回数据库

                4. 删除数据调用实体对象/查询结果集的delete()即可

                        1. 删除单个对象 Author.objects.get(id=1).delete()

                        2. 删除多个对象 Author.objects.all().delete()

5. F()操作  在执行操作中，获取某列的值时使用
F('列名')
from django.db.models import F
Author.objects.all().update(age=F('age') + 10)
6. Q()操作在查询条件中，可以完成或（or）的操作.如果只是为了完成and操作的话，那么直接filter逗号隔开就行
from django.db.models import Q
# Q(表达式) | Q(表达式)
# ex: 查询Author实体中，id为6或者大于等于70的人的信息
Author.objects.filter(Q(id=6)|Q(age__gte=70))
# 等效于 select * from index_author where id=6 or age>=70
7. 原生的数据库操作方法
1. 查询 函数：raw(sql)
   语法：Entry.objects.raw(sql)
2. 增删改
    with connection.cursor() as cursor:
        sql = 'delete from author'
        cursor.execute(sql)
        return HttpResponse('……')/return HttpResponseRedirect('……')
        4. 模型中关系映射

                1. 一对一映射

                        1. 什么是一对一  A表中的一条记录只能与B表中的一条记录相关联

                             数据库中的实现：

                             A表：设置主键

B表：增加一列，并引用自A表的主键，还得增加一个唯一约束（unique）

                        2. 语法

                            在关联的两个类的任何一个类中增加：

                            属性 = models.OneToOneField(Entry)

                        3. 查询

                          正向查询：通过wife找author

                           1. 获取id为1的Wife信息

                                wife = Wife.objects.get(id=1)

2. 通过wife的关联属性author来找Author

                                author = wife.author

反向查询：通过author找wife

1. 获取id为1的author

                            author = Author.objects.get(id=1)

2. 通过object到wife找Wife

                            wife = author.wife

wife是Django通过OneToOneField在Author中默认增加的一个隐式属性

            2. 一对多映射(1:M)

                1. 什么是一对多

                        A表中的一条数据同B表中的任意多条数据关联

                        B表中的一条数据只能同A表中的一条数据关联

                        如：出版社同图书

                2. 在数据库中的体现

                        通过外键（Foreign Key）来体现一对多

                        在"多"表中增加外键对"一"表的主键进行引用。主键外键只是加入一个外键，在添加数据时候检测防止出错

                3. Django中语法

                        使用外键（Foreign Key）

                        在“多”的实体中，增加：属性 = models.ForeignKey(Entry)

                4. 查询

                        Book(多) 和Publisher(一)

                        1. 正向查询 - 通过Book查询Publisher

                                book = Book.objects.get(id__exact = 1)

                                publisher = book.publisher

                        2. 反向查询 - 通过Publisher查询Book

                                Django会在1的实体中增加关联对象_set属性用于查询多的数据

                                在Publisher中增加book_set属性(隐式属性)

                                publisher = Publisher.objects.get(id=1)

                                books = publisher.book_set.all()

            3. 多对多映射

                1. 什么是多对多

                        A表中的一条数据可以与B表中多条数据匹配

                        B表中的一条数据可以与A表中多条数据匹配

                2. 在数据库中的体现

                        必须创建第三张表，关联涉及到的两张表的数据

                3. django中语法

                        允许在任何一个实体中增加操作：entry = models.ManyToManyField(Entry)

                4. 查询

                        1. 正向查询 - 通过Author查询所有的Book

                                author = Author.objects.get(id=1)

                                books = author.book.all()

                                通过关联属性.all()查询所有对应数据

                        2. 反向查询 - 通过Book查询所有的Author

                                Django中，会在Book实体中增加一个隐式属性author_set

                                book = Book.objects.get(id=1)

                                authors = book.author_set.all()

5. 自定义查询对象 - objects (封装继承多态)

                1. 声明类EntryManager,继承自models.Manager，在EntryManager中添加自定义函数

                        class EntryManager(models.Manager):

                            def 函数名(self, 自定义参数列表)：

                                ……

                                return ……

                2. 使用EntryManager覆盖models类中的objects

                        class Entry(models.Model):

                            objects = EntryManager()

7. 使用后台管理models

1. 创建超级管理员



  2. 基本管理

        1. 在应用中admin.py中注册要管理的实体类
from .models import *
admin.site.register(Entry)
2. 修改models.py处理显示内容

1. 在models.py中为各个class追加
def __str__(self):
    return self.name
2. 通过Model类的内部类Meta定义每个类的展现形式
class Author(models.Model):
    ……
    class Meta:
        1. db_table 指定该实体类对应到的表的名称
        2. verbose_name 定义当前实体类在后台管理的列表页中的名称（单数形式） 更改model在后台的名称
        3. verbose_name_plural 效果同上，是复数形式
        4. ordering 实体数据列表的排序规则，取值是一个列表，默认按升序排序，降序则需要手动添加 负号
3. 高级管理

        1. 在admin.py中创建高级管理类

                1. 定义EntryAdmin,继承自admin.ModelAdmin

class AuthorAdmin(admin.ModelAdmin):

        pass

                2. 注册高级管理类

                        admin.site.register(Entry, EntryAdmin)

        2. 定制高级管理信息

                1. list_display

                        作用：指定在列表页中能够显示的字段们

                        取值：由属性名称组成的元组或列表

                        ex: list_display = ['name','age','email']

                    2. list_display_links

                        作用：指定在列表页中能够链接到详情页的字段们

                        取值：由属性名称组成的元组或列表.取值必须要出现在list_display上

                        ex: list_display_links = ['email']

                    3. list_editable

                        作用：指定在列表页中就允许被编辑的字段们。不用点入详情页就可以更改元素的参数。

                        注意：取值不能出现在list_display_link。但必须出现在list_display中

ex: list_editable = ['age']

                    4. search_fields

                        作用：添加允许被搜索的字段们

                        取值：由属性名称组成的元组或列表

                        搜索框，只要在搜索框内有任意一样符合搜索框中元素的值都会保存下来

                    5. list_filter（类别，时间作为过滤器是最好的。数据重复性越大越适用）

                        作用：在列表的右侧作为过滤器实现快速筛选

                        取值：由属性名称组成的元组或列表

                    6. date_hierarchy

                        作用：在列表页的顶端增加一个时间选择

                        取值必须是DateField 或者 DateTimeField的值

                    7. field

                        作用：指定在详情页(添加页)中显示的字段们以及排列的顺序，按列表顺序进行排列

                    8. fieldsets（不能同feild共存，只能存在一项）

                        作用：在详情页(添加页)中，对字段们进行分组显示。--选择分组对object进行添加

                        语法： filedsets = (

                                        ('分组名称', {'feilds':['name', 'age'],'classes':('collapse',)}), # 分组1

                                        () # 分组2

                                    )

8. 转发和重定向

1. 转发(不推荐进行使用)

        return 其他视图函数(request)

2. 重定向

        1. 什么是重定向

                重新向新的地址发送请求（服务器端）

        2. 语法
from django.http import HttpResponseRedirect
return HttpResponseRedirect(url)

9. HttpRequest

1. Http协议

        1. 请求（request）

            1. 请求起始行

            2. 请求消息头

            3. 请求主体（POST PUT）

        2. 响应（response）

            1. 响应起始行协议版本/版本号响应状态码原因短句

            2. 响应消息头

            3. 响应主体

2. HttpRequest

        1. 什么是HttpRequest

            HttpRequest，在Django中是对请求对象的封装体现，它封装了请求过程中所有信息。在Django中，HttpRequest被化身成了request

        2. HttpRequest中的主要内容

            1. request.scheme: 请求协议

            2. request.body: 请求主体

            3. request.path: 请求路径

            4. request.get_host(): 请求主机/域名

            5. request.method: 请求方法

            6. request.GET ： GET请求方式提交的数据

            7. request.POST: POST请求方式提交的数据

            8. request.COOKIES: cookies中的数据

3. CSRF 跨站点攻击，只有在post，put的时候有

        解决方案

            1. 在settings.py中。。这种方式不可靠

                删除CsrfViewMiddleWare中间件

            2. 在视图的处理函数上增加装饰器 @csrf_protect (不是特别推荐)

            3. 在模板中<form>下的第一行增加(推荐)

                {% csrf_token %}

4. 地址栏拼参数

        手动拼写参数（Query String）到提交地址的后面

        http://地址/?名称1=值&名称2=值2

10. cookie和session

cookie

        1、什么是cookies

            cookies 是一种数据存储技术，将一段文本保存在客户端(浏览器)的一种技术，并可以长时间保存

        2、cookies的应用场合

            1、保存登录信息

            2、保存搜索关键词

        3、django 中使用 cookies

            1、设置 cookies 的值(将数据保存进客户端)

                语法：

                    响应对象.set_cookie(key,value,expires)

                        key:cookie的名字

                        value:cookie的值

                        expires:cookie的保存时间，以s为单位 60*60*24*365

                1、不使用模板

                    resp = HttpResponse('')

                    resp.set_cookie('uname1','zsf',60)

                    return resp

                2、使用模板

                    resp = render(request,'xxx.html',locals())

                    resp.set_cookie(key,value,expires)

                    return resp

                3、使用重定向

                    resp = HttpResponseRedirect('/xxx/')

                    resp.set_cookie(key,value,expires)

                    return resp

            2、获取 cookies 的值(从客户端中取数据)

                    request.COOKIES

                    封装了当前站点下的所有cookie信息

session

        1、什么是session

            session，实际上就是在服务器上为浏览器开辟一段控件，用于保存相关的信息

        2、在 Django 中使用session

            1、设置 session 的值

                request.session['key'] = 值;

                设置session的过期时间

                request.session.set_expiry(time)

                time 就是以秒为单位的一个时间

            2、获取session的值

                request.session[key] 或 request.session.get(key)

            3、删除 session 的值

                del request.session['key']

        3、在 settings.py中，有关session的设置

            1、SESSION_COOKIE_AGE

                作用：设置sessionID在cookies中的存活时间

                ex:

                    SESSION_COOKIE_AGE=60*10

                    sessionID在cookie中保留10分钟

            2、SESSION_EXPIRE_AT_BROWSER_CLOSE

                作用：设置在浏览器关闭时同时清除服务器上对应的session空间

                ex:

                    SESSION_EXPIRE_AT_BROWSER_CLOSE=True

11. 序列化

方式一

from django.forms.models import model_to_dict
json_list = []
for good in goods:
	json_dict = model_to_dict(good)
	json_list.append(json_dict)

方式二

from django.core import serializers
import json
json_data = serializers.serialize(‘json`, goods)
json_data = json.loads(json_data)

12. 部署参考链接

django项目部署_钟哥哥实在帅的博客-CSDN博客1. 确保django项目能够运行2. 安装nginx(网站服务)安装nginxsudo apt-get install nginx2、启动nginxsudo /etc/init.d/nginx start3、验证打开浏览器,输入：127.0.0.1 显示：Welcome to nginx!3、安装uwsgi1、安装sudo pip3 install uwsgi2、验证(用uwsgi启动django项目)uwsgi --http :8008 --chdir /home/tarenhttps://blog.csdn.net/weixin_39540280/article/details/109429797?spm=1001.2014.3001.5501

钟哥哥实在帅

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Django入门

1. Django的框架模式 - MTVM： Model层模型层，负责数据库的建模以及CRUD操作T： Templates层模板层，用于处理用户显示的内容，如HTMLV： Views层视图层，处理与用户交互的部分操作，从模型中提取数据 MVC:Model（同M） Views(同T) Controllers（处理与用户交互的部分内容，从模型中获取数据，再交给视图层，再显示给用户2. Django的使用1....
复制链接

扫一扫