学习 Python Django_pythondjango教程

学习 Django

1. 初识Django命令

(1). 基本命令

(2). 数据库相关命令

2. 初识Django项目

(1). 创建项目

django-admin startproject 项目名字
1

(2). 启动项目

python manage.py runserver
1

3. 初识Django应用

(1). Django应用

一个Django项目包含一组配置和若干个Django应用

一个Django项目就是一个基于Django的Web应用

一个Django应用就是一个可重用的Python软件包

每个应用可以自己管理模型、视图、模板、路由和静态文件等

应用可以重复包含

(2). 创建应用

python manage.py startapp 应用名称
1

(3). 应用目录

4. Django视图

使用Django视图编写 hello world 函数

1). 在Django应用的views.py文件中创建视图函数

首先要导入模块

from django.http import HttpResponse


def helloWorld (request):
    return HttpResponse('hello world')

1
2
3
4
5
6

2). 应用层面的路由配置: 在Django应用的urls.py文件中 配置路由绑定试图函数和url

这是配置应用层面的路由

import 应用名称.views

from django.urls import path


urlpatterns = [
    # 配置应用路由
    path('hello_world', 应用名称.views.helloWorld),
]
1
2
3
4
5
6
7
8
9

3). 项目层面的路由配置: 在Django项目的urls.py文件中 配置路由绑定试图函数和url

这是配置项目层面的路由

urlpatterns = [
    ...
    # 配置项目
    path('映射url/', include('应用名称.urls'))
    ...
]
1
2
3
4
5
6

4). 将应用添加到Django配置文件中

INSTALLED_APPS = [
    ...
    '应用名称.apps.XXXConfig',
]
1
2
3
4

4. Django模型层

1. 什么是模型层

位于Django视图层和数据库之间, 用于将Python对象和数据库表之间的转换

模型层作用:

• 屏蔽不同数据库之间的差异
• 让开发者更加专注于业务逻辑的开发
• 提供了很多便捷的工具有利于开发

2. 模型层数据库配置

在Django项目的setting.py文件中

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}
1
2
3
4
5
6

修改成mysql数据库

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': '数据库名称',
        'USER': '用户名',
        'PASSWORD': '密码',
        'HOST': '',
        'PORT': '端口号'
    }
}
1
2
3
4
5
6
7
8
9
10
'
运行
运行

3. 模型层例子

(1). 模型层定义字段

自增类型

二进制和布尔类型

整数类型

字符和文本类型

时间类型

浮点类型

其他类型

关系类型

(2). 字段参数

所有字段共有参数

个别字段参数

关系型字段参数

models.CASCADED 级联删除

models.PROTECT 需要先删除关联数据, 才可以删除当前数据

models.SET_NULL 关联数据置空 null = True, blank = True

models.SET_DEFAULT 关联字段值为默认值

models.SET_NOTHING 啥也不做

models.SET() 传递一个值或一个函数的返回值

自关联

一个数据库中的字段关联另一个数据库中的某一字段

地址表中, 地址的字段关联地址

from django.db import models

class AddressInfo(models.Model):
    address = models.CharField(max_length=200, null=True, blank=True, verbose_name="地址")
    pid = models.ForeignKey('self', null=True, blank=True, verbose_name="自关联")
    # pid = models.ForeignKey('AddressInfo', null=True, blank=True, verbose_name="自关联")

    def __str__(self):
        return self.address

1
2
3
4
5
6
7
8
9
10

(3). 设计博客模型层

在Django应用的models.py文件中定义模型

from django.db import models


class Article(models.Model):
    # 文章Id
    articleId = models.AutoField(primary_key=True)
    # 文章标题
    title = models.TextField()
    # 文章摘要
    briefContent = models.TextField()
    # 文章内容
    content = models.TextField()
    # 文章发布日期
    publishDate = models.DateTimeField(auto_now=True)

    # admin中显示
    def __str__(self) :
        return self.title
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

(4). 模型迁移

python manage.py makemigrations

生成数据库要执行的内容到migrations文件夹下

python manage.py migrate

执行migrations文件夹下的文件, 并将过程记录到django_migrations数据表中(该表是django自动生成的)

python manage.py makemigrations

python manage.py migrate 
1
2
3

(5). 注册模型到admin

在应用的admin.py文件中配置

from django.contrib import admin

from .models import Article

admin.site.register(Article)

1
2
3
4
5
6

(6). 模型迁出

将数据库转成models

python manage.py inspectdb > models.py
1

模型类代码会出现在models.py文件中

(7). 模型删除

1). 删除models.py文件中的模型类代码

2). 删除模型类在migrations文件夹下的对应文件

3). 删除django_migrations表中的记录

4). 删除模型类对应的数据表

4. 初识 Django Shell

1. 什么是 Django Shell

Python Shell是用于交互式的Python编程

Django Shell是用于交互式的Django项目环境

2. 为什么使用 Django Shell

1. 临时性操作使用Django Shell更加方便
2. 小范围Debug更简单，不需要运行整个项目来测试

3. 使用 Django Shell

(1). 进入 Django Shell

python manage.py shell
1

(2). 使用Django Shell导入数据

新建文章

from testapp1.models import Article
a = Article()
a.title = 'Test Django Shell'
a.brief_content = 'Mzy'
a.content = 'Test new Article'
# 存储数据库
a.save()
# 取出全部数据
articles = Article.objects.all()
article = articles[0]
1
2
3
4
5
6
7
8
9
10

5. 初识 Django Admin

(1). 什么是 Django Admin

Django框架的后台管理工具

可以读取定义的模型元数据, 提供强大的管理使用页面

(2). 为什么使用 Django Admin

1. 方便添加数据
2. 管理页面

(3). 使用 Django Shell

1). 创建管理员用户

python manage.py createsuperuser
1

2). 登录进入管理系统

访问admin

6. 初识 Django 模板系统

模板系统的表现形式是文本

1. 基本语法

2. 使用模板系统

在应用的views.py文件写视图

使用render返回html页面, 默认去应用的templates文件夹里找

def getIndexPage(request):
    articles = Article.objects.all()
    return render(request, 'index.html', {
        # 左边是模板变量, 右边是把值赋予的变量
        'articles': articles
    })
1
2
3
4
5
6
'
运行
运行

在应用的urls.py文件配置路由

urlpatterns = [
    # 配置应用路由
    path('hello_world', testapp1.views.helloWorld),
    path('getArticle', testapp1.views.getArticle),
    path('index', testapp1.views.getIndexPage),
    path('detail', testapp1.views.getDetailPage),
]
1
2
3
4
5
6
7

3. 获取url路径参数

urlpatterns = [
    path('detail/<int:articleId>', testapp1.views.getDetailPage)
]
1
2
3

def getDetailPage(request, articleId):
    articles = Article.objects.all()
    article = None
    for i in articles:
        if i.articleId == articleId:
            article = i
            break
    return render(request, 'detail.html', {
        'article': article
    })
1
2
3
4
5
6
7
8
9
10
'
运行
运行

6. 初识 Django ORM

(1). ORM

Object Relational Mapping

(2). 配置数据库

setting.py文件中配置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'PythonTest',
        'USER': 'root',
        'PASSWORD': 'xxx',
        'HOST': 'xxx',
        'PORT': 'xxx'
    }
}
1
2
3
4
5
6
7
8
9
10
'
运行
运行

安装mysqlclient

pip install mysqlclient
1

安装PyMySQL

pip install PyMySQL
1

(3). 元数据

from django.db import models

class AddressInfo(models.Model):
    address = models.CharField(max_length=200, null=True, blank=True, verbose_name="地址")
    pid = models.ForeignKey('self', null=True, blank=True, verbose_name="自关联")
    # pid = models.ForeignKey('AddressInfo', null=True, blank=True, verbose_name="自关联")

    def __str__(self):
        return self.address
    
    class Meta:
        # 设置表名
        db_table = 'address'
        # 设置排序字段
        ordering = [
            'pid'
        ]
        # 设置表备注
        verbose_name = '地址信息'
        verbose_name_plural = verbose_name
        # 指定数据表是不是抽象的, 抽象的不生成数据表, 只用来继承
        abstract = False
        # 设置权限
        permissions = (
            ('权限', '说明'),
        )
        # 是否按照Django管理模式管理该表
        managed = True
        # 联合约束
        unique_together = (
            (), ()
        )
        # 设置模型类所属应用
        app_label = 'testapp1'
        # 定义数据库表空间
        db_tablespace = ''
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

(4). 实战建表

讲师信息表 课程信息表 学生信息表 助教信息表

助教和讲师是一对一

课程和讲师是多对一

学生信息和课程是多对多

讲师和课程 讲师是父表, 课程是子表

课程和学生 课程是父表, 学生是子表

讲师和助教 讲师是父表, 助教是子表

1). 讲师表

from django.db import models

class Teacher(models.Model):
    # 昵称
    nickname = models.CharField(
        max_length = 30,
        primary_key = True,
        db_index = True,
        verbose_name = "昵称"
    )
    # 个性签名
    introduction = models.TextField(
        default = "这位同学很懒, 木有签名~",
        verbose_name = "个性签名"
    )
    # 粉丝数
    fans = models.PositiveIntegerField(
        default = 0,
        verbose_name = "粉丝数"
    )
    # 用户创建时间
    createTime = models.DateTimeField(
        auto_now_add = True,
        verbose_name = "创建时间"
    )
    # 用户信息修改时间
    updateTime = models.DateTimeField(
        auto_now = True,
        verbose_name = "修改时间"
    )

    class Meta:
        verbose_name = "讲师信息表"
        verbose_name_plural = verbose_name
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

2). 课程表

from django.db import models

class Course(models.Model):
    """课程信息表"""
    # 课程名
    title = models.CharField(
        max_length = 100,
        primary_key = True,
        db_index = True,
        verbose_name = "课程名"
    )
    # 课程类型
    type = models.CharField(
        choices = (
            (1, "实战课"), (2, "免费课"), (3, "其他")
        ),
        max_length = 1,
        default = 0,
        verbose_name = "课程类型"
    )
    # 价格
    price = models.PositiveIntegerField(
        verbose_name = "价格"
    )
    # 销量
    volume = models.PositiveBigIntegerField(
        verbose_name = "销量"
    )
    # 上线时间
    createTime = models.DateTimeField(
        auto_now_add = True,
        verbose_name = "上线时间"
    )
    # 更新时间
    updateTime = models.DateTimeField(
        auto_now = True,
        verbose_name = "更新时间"
    )
    
        # 设置外键关联
    teacher = models.ForeignKey(
        Teacher, 
        # 删除级联
        on_delete = models.CASCADE, 
        null = True,
        blank = True,
        verbose_name = "课程讲师"
    )

    class Meta:
        verbose_name = "课程信息表"
        verbose_name_plural = verbose_name

    def __str__(self):
        return f"{self.get_type_display()}-{self.title}"
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

get_XXX_display()函数获取字段

例如, 如果如下类型字段存储的是1, 使用该函数后, 获得1所对应的值, 这里字段使用choice是数据库枚举类型

    type = models.CharField(
        choices = (
            (1, "实战课"), (2, "免费课"), (3, "其他")
        ),
        max_length = 1,
        default = 0,
        verbose_name = "课程类型"
    )
1
2
3
4
5
6
7
8

F运算符即format函数简化版, 3.6版本新加入的

原版

>>> a = "{}-{}"
>>> a.format("1", "2")
'1-2'
1
2
3

简化版

>>> a = 1
>>> b = 2
>>> c = f"{a}-{b}"
print(c)
1-2
1
2
3
4
5

f"{self.get_type_display()}-{self.title}"

相当于

"{}-{}".format(self.get_type_display(), self.title)

3). 学生信息表

from django.db import models

class Student(models.Model):
    """学生信息表"""
    # 昵称
    nickname = models.CharField(
        max_length = 30,
        primary_key = True,
        db_index = True,
        verbose_name = "昵称"
    )
    # 年龄
    age = models.PositiveSmallIntegerField(
        verbose_name = "年龄"
    )
    # 性别
    gender = models.CharField(
        choices = (
            (1, "男"), (2, "女"), (0, "保密")
        ),
        max_length = 1,
        default = 0,
        verbose_name = "性别"
    )
    # 学习时常
    fans = models.PositiveIntegerField(
        default = 0,
        verbose_name = "学习时常"
    )
    # 用户创建时间
    createTime = models.DateTimeField(
        auto_now_add = True,
        verbose_name = "创建时间"
    )
    # 用户信息修改时间
    updateTime = models.DateTimeField(
        auto_now = True,
        verbose_name = "修改时间"
    )
    
    # 设置外键关联
    course = models.ManyToManyField(
        Course,
        verbose_name = "课程"
    )

    class Meta:
        verbose_name = "学生信息表"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.nickname
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

4). 助教信息表

from django.db import models

class TeacherAssistant(models.Model):
    """助教信息表"""
    # 昵称
    nickname = models.CharField(
        max_length = 30,
        primary_key = True,
        db_index = True,
        verbose_name = "昵称"
    )
    # 爱好
    hobby = models.CharField(
        max_length = 100,
        null = True,
        blank = True,
        verbose_name = "爱好"
    )
    # 用户创建时间
    createTime = models.DateTimeField(
        auto_now_add = True,
        verbose_name = "创建时间"
    )
    # 用户信息修改时间
    updateTime = models.DateTimeField(
        auto_now = True,
        verbose_name = "修改时间"
    )

    # 设置外键关联
    teacher = models.OneToOneField(
        Teacher,
        # 设置当关联的讲师被删除时, 与其关联的助教的讲师字段置为空
        on_delete = models.SET_NULL,
        null = True,
        blank = True,
        verbose_name = "讲师"
    )
    
    class Meta:
        verbose_name = "助教信息表"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.nickname
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
38
39
40
41
42
43
44
45

外键字段写到子表

(5). Models API

使用objects模型类对象管理器进行查询

1). 查询全部数据

使用all()函数, 返回结果为QuerySet

模型类名.objects.all()

    teachers = Teacher.objects.all()
1

2). 根据指定字段的值查询

使用get()函数, 返回结果为该类

模型类名.objects.get()

    teachers = Teacher.objects.get(nickname = '惠')
    teachers = Teacher.objects.get(fans = 54, nickname = '惠')
1
2

函数的参数: 字段名 = 值 可以指定多个字段的值

3). 条件查询

使用filter()函数, 返回结果为QuerySet

模型类名.objects.filter()

    teachers = Teacher.objects.filter(fans__gte = 20)
1

4). 查看查询的sql

print(Teacher.objects.filter(fans__gte = 20).query)
1

5). API

可以使用多个参数

7. Django 请求和响应

(1). 请求

request是一个对象，封装了用户发送过来的所有请求相关数据

1). 获取请求方法

def learnRequest(request):
    method = request.method
    print(method)
    return HttpResponse('hello world')
1
2
3
4
'
运行
运行

2). 获取GET请求的QueryString

发送请求

xxx/xxx?a=123

def learnRequest(request):
    queryString = request.GET
    # 获取a键的值
    print(queryString.get('a'))
    return HttpResponse('hello world')
1
2
3
4
5
'
运行
运行

没有键则返回 None

3). 获取POST请求体

def learnRequest(request):
    body = request.POST
    print(body)
    return HttpResponse('123')
1
2
3
4
'
运行
运行

(2). 响应

使用HttpResponse返回字符串

def learnResponse(request):
    return HttpResponse('123')
1
2
'
运行
运行

使用render()函数, 读取html内容, 渲染(替换)为字符串, 返回给浏览器

def learnResponse(request):
    return render(request, 'index.html', {
        'variable': 'value'
    })
1
2
3
4
'
运行
运行

使用redirect()函数重定向

def learnResponse(request):
    return redirect('https://www.baidu.com')
1
2
'
运行
运行