当前位置:   article > 正文

Django 入门教程

Django 入门教程

1. Django简介

基本介绍

Django 是一个由 Python 编写的一个开放源代码的 Web 应用框架。

MVC 与 MVT 模型

MVC 模型

MVC 模式(Model–view–controller)是软件工程中的一种软件架构模式,把软件系统分为三个基本部分:模型(Model)、视图(View)和控制器(Controller)。
MVC 以一种插件式的、松耦合的方式连接在一起。

  • 模型(M)- 编写程序应有的功能,负责业务对象与数据库的映射(ORM)。
  • 视图(V)- 图形界面,负责与用户的交互(页面)。
  • 控制器(C)- 负责转发请求,对请求进行处理。

MTV 模型

Django 的 MTV 模式本质上和 MVC 是一样的,也是为了各组件间保持松耦合关系,只是定义上有些许不同,Django 的 MTV 分别是指:

  • M 表示模型(Model):编写程序应有的功能,负责业务对象与数据库的映射(ORM)。
  • T 表示模板 (Template):负责如何把页面(html)展示给用户。
  • V 表示视图(View):负责业务逻辑,并在适当时候调用 Model和 Template。
    除了以上三层之外,还需要一个 URL 分发器,它的作用是将一个个 URL 的页面请求分发给不同的 View 处理,View 再调用相应的 Model 和 Template,MTV 的响应模式如下所示:
    在这里插入图片描述
    解析
    用户通过浏览器向我们的服务器发起一个请求(request),这个请求会去访问视图函数:
    a.如果不涉及到数据调用,那么这个时候视图函数直接返回一个模板也就是一个网页给用户。
    b.如果涉及到数据调用,那么视图函数调用模型,模型去数据库查找数据,然后逐级返回。

2. 创建项目

创建第一个项目

django-admin startproject My_Project
  • 1

创建完成后我们可以查看下项目的目录结构:

$ cd My_Project/ #项目的容器。
$ tree
.
|-- My_Project
|   |-- __init__.py 
|   |-- asgi.py #一个 ASGI 兼容的 Web 服务器的入口,以便运行你的项目。
|   |-- settings.py #该 Django 项目的设置/配置。
|   |-- urls.py #一个 WSGI 兼容的 Web 服务器的入口,以便运行你的项目。
|   `-- wsgi.py #一个 WSGI 兼容的 Web 服务器的入口,以便运行你的项目。
`-- manage.py #一个实用的命令行工具,可让你以各种方式与该 Django 项目进行交互。

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

WSGI (Web Server Gateway Interface) 是一个 Python 规范,它定义了 Web 服务器和 Python Web 应用程序之间通信的方式。
ASGI (Asynchronous Server Gateway Interface) 是一个新的 Python 规范,它扩展了 WSGI 规范,支持异步操作。
 
WSGI 的主要作用是:

  • 定义 Web 服务器和 Python Web 应用程序之间通信的标准: WSGI 规范定义了服务器环境变量、应用程序对象和 WSGI 协议,这使得不同的 Web 服务器和 Python Web 应用程序可以相互兼容。
  • 简化 Web 应用程序的开发: 通过使用 WSGI 规范,Web 应用程序开发人员可以专注于编写应用程序逻辑,而无需担心服务器端代码。
  • 提高 Web 应用程序的性能: WSGI 规范支持多线程和多进程,这可以提高 Web 应用程序的性能。

 
ASGI 的主要作用是:

  • 支持异步操作: ASGI 规范支持异步操作,例如数据库查询和网络请求。这可以提高 Web 应用程序的性能,因为异步操作可以并发执行。
  • 提高 Web 应用程序的扩展性: ASGI 规范支持多进程和多线程,这可以提高 Web 应用程序的扩展性。

创建第一个app

1. 使用startapp命令

python manage.py startapp my_app
  • 1

2. 在 settings.py 中注册应用

在你的 Django 项目的 settings.py 文件中,将 my_app 添加到 INSTALLED_APPS 列表中:

INSTALLED_APPS = [
    # ... 其他应用
    'my_app',
]
  • 1
  • 2
  • 3
  • 4

3. 运行迁移

在创建应用后,需要运行数据库迁移以创建数据库表:

python manage.py makemigrations
python manage.py migrate
  • 1
  • 2
my_app/
├── __init__.py
├── admin.py #用于注册模型的管理界面
├── apps.py #用于配置应用的元数据
├── migrations/ #用于存储数据库迁移文件
│   └── __init__.py
├── models.py #models.py 文件是定义模型的地方。每个模型都对应一个数据库表。
├── tests.py #编写测试用例
└── views.py #这个文件用于编写视图函数。视图函数处理用户请求并返回响应。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

启动服务器

python3 manage.py runserver 0.0.0.0:8000
  • 1

在浏览器输入你服务器的 ip(这里我们输入本机 IP 地址: 127.0.0.1:8000) 及端口号,如果正常启动,输出结果如下:
在这里插入图片描述

视图和URL配置

在view.py文件中写响应

#My_Project/myapp/views.py:
from django.http import HttpResponse
 
def hello(request):
    return HttpResponse("Hello world ! ")
  • 1
  • 2
  • 3
  • 4
  • 5

接着,绑定 URL 与视图函数。打开 urls.py 文件,删除原来代码,将以下代码复制粘贴到 urls.py 文件中:

#My_Project/myapp/urls.py:
from django.urls import path
 
from . import views
 
urlpatterns = [
    path("", views.hello, name="hello"),
]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

完成后,启动 Django 开发服务器,并在浏览器访问打开浏览器并访问:
在这里插入图片描述

Path()/re_path()函数区别

1. 简介

pathre_path 都是 Django 中的 URL 路由函数,用于将 URL 模式与视图函数进行关联。

  • path 函数用于匹配精确的 URL 路径。
  • re_path 函数用于匹配正则表达式。

2. 语法

from django.urls import path, re_path

urlpatterns = [
    path('articles/<int:year>/', views.article_list),
    re_path(r'^articles/(?P<year>[0-9]{4})/$', views.article_list),
]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

3. 区别

  • 匹配方式: path 函数用于匹配精确的 URL 路径,而 re_path 函数用于匹配正则表达式。
  • 性能: path 函数的性能比 re_path 函数更高,因为 path 函数不需要编译正则表达式。
  • 灵活性: re_path 函数比 path 函数更灵活,因为它可以匹配更复杂的 URL 模式。

4. 举例

  • 精确匹配: 以下代码将匹配 URL 路径 /articles/2023/
path('articles/<int:year>/', views.article_list)
  • 1
  • 正则表达式匹配: 以下代码将匹配 URL 路径 /articles/2023//articles/2024/
re_path(r'^articles/(?P<year>[0-9]{4})/$', views.article_list)
  • 1

3. Django 模板

在 my_app 目录底下创建 templates 目录并建立 runoob.html文件,整个目录结构如下

My_Project/
├── manage.py
├── my_app/
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── migrations/
│   │   └── __init__.py
│   ├── models.py
│   ├── tests.py
│   ├── views.py
│   └── templates/
│       └── runoo.bhtml
├── db.sqlite3
└── My_Project/
    ├── __init__.py
    ├── asgi.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

runoob.html 文件代码如下:

<h1>{{ hello }}</h1>
  • 1

接下来我们需要向Django说明模板文件的路径,修改HelloWorld/settings.py,修改 TEMPLATES 中的 DIRS 为 [os.path.join(BASE_DIR, ‘templates’)],如下所示:

...
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],       # 修改位置
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]
...
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

我们现在修改 views.py,增加一个新的对象,用于向模板提交数据:

from django.shortcuts import render
 
def runoob(request):
    context          = {}
    context['hello'] = 'Hello World!'
    return render(request, 'runoob.html', context)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

urls.py文件修改为:

from django.urls import path
 
from . import views
 
urlpatterns = [
    path('runoob/', views.runoob),
]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

再次访问 http://127.0.0.1:8000/runoob,可以看到页面:
在这里插入图片描述

4. Django模型

Django 对各种数据库提供了很好的支持,包括:PostgreSQL、MySQL、SQLite、Oracle。

Django ORM

Django 模型使用自带的 ORM。
对象关系映射(Object Relational Mapping,简称 ORM )用于实现面向对象编程语言里不同类型系统的数据之间的转换。
ORM 在业务逻辑层数据库层之间充当了桥梁的作用。
ORM 是通过使用描述对象和数据库之间的映射的元数据,将程序中的对象自动持久化到数据库中。
在这里插入图片描述

ORM 解析过程:

  • ORM 会将 Python 代码转成为 SQL 语句。
  • SQL 语句通过 pymysql 传送到数据库服务端。
  • 在数据库中执行 SQL 语句并将结果返回。

ORM对应关系表
在这里插入图片描述

数据库配置

创建 MySQL 数据库( ORM 无法操作到数据库级别,只能操作到数据表)语法,例如我们创建一个名为 runoob 数据库,编码指定为 utf8:

create database runoob default charset=utf8; # 防止编码问题,指定为 utf8
  • 1

我们在项目的 settings.py 文件中找到 DATABASES 配置项,将其信息修改为:

DATABASES = { 
    'default': 
    { 
        'ENGINE': 'django.db.backends.mysql',    # 数据库引擎
        'NAME': 'runoob', # 数据库名称
        'HOST': '127.0.0.1', # 数据库地址,本机 ip 地址 127.0.0.1 
        'PORT': 3306, # 端口 
        'USER': 'root',  # 数据库用户名
        'PASSWORD': '123456', # 数据库密码
    }  
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

上面包含数据库名称和用户的信息,它们与 MySQL 中对应数据库和用户的设置相同。Django 根据这一设置,与 MySQL 中相应的数据库和用户连接起来。

接下来,告诉 Django 使用 pymysql 模块连接 mysql 数据库:

# 在与 settings.py 同级目录下的 __init__.py 中引入模块和进行配置 
import pymysql
pymysql.install_as_MySQLdb()
  • 1
  • 2
  • 3

定义模型

修改my_app/models.py:

# models.py
from django.db import models
 
class Test(models.Model):
    name = models.CharField(max_length=20)
  • 1
  • 2
  • 3
  • 4
  • 5

以上的类名代表了数据库表名,且继承了models.Model,类里面的字段代表数据表中的字段(name),数据类型则由CharField(相当于varchar)、DateField(相当于datetime), max_length 参数限定长度。
在命令行中运行:

$ python3 manage.py migrate   # 创建表结构

$ python3 manage.py makemigrations my_app  # 让 Django 知道我们在我们的模型有一些变更
$ python3 manage.py migrate my_app   # 创建表结构
  • 1
  • 2
  • 3
  • 4

注意:尽管我们没有在 models 给表设置主键,但是 Django 会自动添加一个 id 作为主键。

数据库操作

接下来我们在 My_Project 目录中添加 testdb.py 文件(下面介绍),并修改 urls.py:

from django.urls import path
 
from . import views,testdb
 
urlpatterns = [
    path('runoob/', views.runoob),
    path('testdb/', testdb.testdb),
]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

添加数据

添加数据需要先创建对象,然后再执行 save 函数,相当于SQL中的INSERT:

# -*- coding: utf-8 -*-
 
from django.http import HttpResponse
 
from my_app.models import Test
 
# 数据库操作
def testdb(request):
    test1 = Test(name='runoob')
    test1.save()
    return HttpResponse("<p>数据添加成功!</p>")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

访问 http://127.0.0.1:8000/testdb 就可以看到数据添加成功的提示。
在这里插入图片描述

获取数据

# testdb.py
# -*- coding: utf-8 -*-
 
from django.http import HttpResponse
 
from TestModel.models import Test
 
# 数据库操作
def testdb(request):
    # 初始化
    response = ""
    response1 = ""
    
    
    # 通过objects这个模型管理器的all()获得所有数据行,相当于SQL中的SELECT * FROM
    listTest = Test.objects.all()
        
    # filter相当于SQL中的WHERE,可设置条件过滤结果
    response2 = Test.objects.filter(id=1) 
    
    # 获取单个对象
    response3 = Test.objects.get(id=1) 
    
    # 限制返回的数据 相当于 SQL 中的 OFFSET 0 LIMIT 2;
    Test.objects.order_by('name')[0:2]
    
    #数据排序
    Test.objects.order_by("id")
    
    # 上面的方法可以连锁使用
    Test.objects.filter(name="runoob").order_by("id")
    
    # 输出所有数据
    for var in listTest:
        response1 += var.name + " "
    response = response1
    return HttpResponse("<p>" + response + "</p>")
  • 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
  • 36
  • 37

更新数据

修改数据可以使用 save() 或 update():

# -*- coding: utf-8 -*-
 
from django.http import HttpResponse
 
from TestModel.models import Test
 
# 数据库操作
def testdb(request):
    # 修改其中一个id=1的name字段,再save,相当于SQL中的UPDATE
    test1 = Test.objects.get(id=1)
    test1.name = 'Google'
    test1.save()
    
    # 另外一种方式
    #Test.objects.filter(id=1).update(name='Google')
    
    # 修改所有的列
    # Test.objects.all().update(name='Google')
    
    return HttpResponse("<p>修改成功</p>")

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

删除数据

删除数据库中的对象只需调用该对象的delete()方法即可:

# -*- coding: utf-8 -*-
 
from django.http import HttpResponse
 
from TestModel.models import Test
 
# 数据库操作
def testdb(request):
    # 删除id=1的数据
    test1 = Test.objects.get(id=1)
    test1.delete()
    
    # 另外一种方式
    # Test.objects.filter(id=1).delete()
    
    # 删除所有数据
    # Test.objects.all().delete()
    
    return HttpResponse("<p>删除成功</p>")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

5. Django视图

一个视图函数,简称视图,是一个简单的 Python 函数,它接受 Web 请求并且返回 Web 响应。
视图层中有两个重要的对象:请求对象(request)与响应对象(HttpResponse)。

请求对象: HttpRequest 对象(简称 request 对象)

1. Get

取值格式:对象.方法。

get():返回字符串,如果该键对应有多个值,取出该键的最后一个值。

def runoob(request):
    name = request.GET.get("name")
    return HttpResponse('姓名:{}'.format(name)) 
  • 1
  • 2
  • 3

2. Post

def runoob(request):
    name = request.POST.get("name")
    return HttpResponse('姓名:{}'.format(name))
  • 1
  • 2
  • 3

3. method

获取当前请求的方式,数据类型是字符串,且结果为大写。

def runoob(request):
    name = request.method
    print(name)
    return HttpResponse("菜鸟教程")
返回结果
POST
```
##  响应对象:HttpResponse 对象
响应对象主要有三种形式:HttpResponse()、render()、redirect()。

HttpResponse(): 返回文本,参数为字符串,字符串中写文本内容。如果参数为字符串里含有 html 标签,也可以渲染。
```python
def runoob(request):
    # return HttpResponse("菜鸟教程")
    return HttpResponse("<a href='https://www.runoob.com/'>菜鸟教程</a>")
```
render(): 返回文本,第一个参数为 request,第二个参数为字符串(页面名称),第三个参数为字典(可选参数,向页面传递的参数:键为页面参数名,值为views参数名)。
````python
def runoob(request):
    name ="菜鸟教程"
    return render(request,"runoob.html",{"name":name})
```
redirect():重定向,跳转新页面。参数为字符串,字符串中填写页面路径。一般用于 form 表单提交后,跳转到新页面。
```python
def runoob(request):
    return redirect("/index/")
```
  • 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
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/629621
推荐阅读
相关标签
  

闽ICP备14008679号