Django从入门到精通：First [Django版本.Python面向对象.Web基础.创建Django项目]

文章目录

Django初学者指南
- [1 Django简介](#1 Django简介)
- - [1.1 Django的历史](#1.1 Django的历史)
  - [1.2 使用Django的知名网站](#1.2 使用Django的知名网站)
  - [1.4 Django的主要特点](#1.4 Django的主要特点)
  - [1.5 Django的工作原理](#1.5 Django的工作原理)
- [2 Django 版本选择](#2 Django 版本选择)
- - [2.1 Django 支持的 Python 版本](#2.1 Django 支持的 Python 版本)
  - [2.2 Django 版本](#2.2 Django 版本)
- [3 Django 开发 Web 程序](#3 Django 开发 Web 程序)
- - [3.1 Python知识点](#3.1 Python知识点)
  - - [3.1.1 Python 函数](#3.1.1 Python 函数)
    - [3.1.2 Python 面向对象](#3.1.2 Python 面向对象)
  - [3.2 Web 基础知识](#3.2 Web 基础知识)
  - [3.3 安装Django](#3.3 安装Django)
  - [3.4 创建Django项目](#3.4 创建Django项目)
  - - [3.4.1 用命令行创建Django项目](#3.4.1 用命令行创建Django项目)
    - [3.4.2 用PyCharm创建Django项目](#3.4.2 用PyCharm创建Django项目)
- [4 Django 部分常用参数、插件](#4 Django 部分常用参数、插件)
- - [4.1 path() 视图函数](#4.1 path() 视图函数)
  - [4.2 models.py模型参数](#4.2 models.py模型参数)
  - [4.3 模板插件、技术](#4.3 模板插件、技术)
  - - [4.3.1 Bootstrap](#4.3.1 Bootstrap)
    - [4.3.2 jQuery](#4.3.2 jQuery)
    - [4.3.2 AJAX](#4.3.2 AJAX)
- 小结

Django初学者指南

欢迎进入Django的世界！如果你对开发数据库驱动的网站感兴趣，Django是一个非常有用的框架。在这篇博文中，我们将介绍Django的基础知识，包括它的历史、特点、如何开始学习，以及一些使用Django的知名网站。

1 Django简介

Django 是一个用于构建 Web 应用程序的高级 Python Web 框架。

Django 提供了一套强大的工具和约定，处理了Web开发中的许多繁琐事务，使得开发者可以专注于编写网站独特的业务逻辑部分，快速构建功能齐全且易于维护的网站。

Django 遵守 BSD 版权，初次发布于 2005 年 7 月, 并于 2008 年 9 月发布了第一个正式版本 1.0 。

Django 采用了 MVT 的软件设计模式，即模型（Model），视图（View）和模板（Template）。

1.1 Django的历史

Django诞生于2003年，最初是为了满足新闻网站的需求而开发的。

2005年7月21日，Django被公开发布，并在BSD许可证下提供。

如今，Django已经发展成为一个由全球社区支持的成熟框架。

Django框架的历史始于2003年秋，当时位于劳伦斯《日报世界》报社的网络程序员Adrian Holovaty和Simon Willison开始使用Python构建应用程序。在Django开发的早期，Jacob Kaplan-Moss被聘请加入，这是在Simon Willison的实习结束前不久。

Django最初是为了满足新闻网站的需求而开发的，它的目标是简化复杂、数据库驱动网站的创建。Django强调组件的可重用性和"插件化"，以及少量代码、低耦合、快速开发和不重复自己（DRY）的原则。

2005年7月21日，Django被公开发布，并在BSD许可证下提供。框架的命名是为了纪念吉他手Django Reinhardt，Adrian Holovaty是一位罗姆人爵士吉他演奏者，他的音乐部分地启发了Reinhardt。

到了2008年6月，宣布新成立的Django软件基金会（DSF）将在未来维护Django。DSF是在美国成立的一个独立组织，是一个501©(3)非营利组织。

如今，Django已经发展成为一个由全球社区支持的成熟框架，它的最新稳定版本是5.0.6，于2024年5月7日发布1。Django继续是许多开发者和公司构建现代Web应用程序的首选框架。

1.2 使用Django的知名网站

国外网站：

Instagram：一个流行的社交媒体平台，专注于图片和视频的分享。
Pinterest：一个允许用户发现新想法和灵感的平台。
Disqus：一个广泛使用的博客评论托管服务。
Mozilla：火狐浏览器的帮助页面。
NASA：美国国家航空航天局官方网站的某些部分是由Django开发的。
The Washington Post：一家有影响力的新闻机构，其网站使用Django来处理大量的视图和流量。

国内网站：

豆瓣：一个提供电影、书籍、音乐等文化商品综合信息、用户评论及推荐服务的网站。
知乎：一个中文问答网站，用户可以在上面提出问题、分享知识、经验和见解。

这些网站的成功运营证明了Django作为一个Web框架的可靠性和高效性。

Django的设计哲学、安全性和快速开发的特点使其成为许多开发者和公司的首选框架。

1.4 Django的主要特点

完整性：提供几乎所有开发者可能想要的功能"开箱即用"。
多功能性：Django可以（也已经）被用来构建几乎任何类型的网站。
安全性：Django对待安全问题的态度：致力于帮助开发者避免常见的安全错误，提供一个旨在自动保护网站的框架。
快速开发：Django旨在帮助开发者从概念到完成尽可能快地开发应用程序。
可扩展性：适用于流量最繁忙的网站。
DRY原则：强调组件的可重用性，遵循不要重复自己的原则。

Django 处理了Web开发中的许多繁琐事务，比如: 用户认证、数据库连接、CRUD（创建、读取、更新、删除）操作、URL路由、表单处理和安全性等，这样开发者就可以专注于编写使网站独特的业务逻辑部分，而不需要重新发明轮子。

Django遵循"包含电池"的理念，提供了几乎所有开发者可能想要的功能"开箱即用"。因为你需要的一切都是框架的一部分，所以它们可以无缝协同工作，遵循一致的设计原则，并且拥有广泛且最新的官方文档。

1.5 Django的工作原理

Django遵循MVT（模型-视图-模板）架构：

模型（Model）：定义程序的数据结构。即开发者想要展示的数据，通常是来自数据库的数据。
视图（View）：处理HTTP请求，从模型中获取数据，传递给模板。它是一个处理HTTP请求的函数或方法，它导入相关的模型，并决定发送哪些数据到模板，然后返回最终结果。
模板（Template）：定义如何显示数据。它是一个描述结果应该如何表示的文件。模板通常是HTML文件，包含网页布局，以及如何显示数据的逻辑。

如果你对创建数据库驱动的网站感兴趣，Django是一个非常有用的框架。

它的ORM（对象关系映射）技术使得与数据库的交流变得更加简单，无需编写复杂的SQL语句。Django还强调组件的可重用性，遵循DRY（不要重复自己）的原则。

2 Django 版本选择

确定你要使用的 Django 版本。

Django 是 BSD 许可下的开源版本。建议使用最新版本的 Python 3.x 。

2.1 Django 支持的 Python 版本

因为新版本的 Python 通常会更快，拥有更多特性，而且有更好的支持，推荐使用 Python 3 的最新版本。
使用旧版本的 Django 不会损失任何东西，但你不能利用新版本的 Python 的改进和优化。

与 Django 一起使用的第三方应用程序可以自由设置自己的版本要求。

Django 版本对应的 Python 版本：

Django 版本	Python 版本
1.8	2.7、3.2（until the end of 2016）、3.3、3.4、3.5
1.9、1.10	2.7、3.4、3.5
1.11	2.7、3.4、3.5、3.6、3.7（added in 1.11.17）
2.0	3.4, 3.5, 3.6, 3.7
2.1	3.5, 3.6, 3.7
2.2	3.5、3.6、3.7、3.8 (added in 2.2.8)、3.9 (added in 2.2.17)
3.1	3.6、3.7、3.8、3.9（added in 3.1.3）
3.2	3.6、3.7、3.8、3.9、3.10（added in 3.2.9）
4.0	3.8、3.9、3.10
4.1	3.8、3.9、3.10、3.11（added in 4.1.3）
4.2	3.8、3.9、3.10、3.11、3.12（added in 4.2.8）
5.0	3.10、3.11、3.12
5.1	3.10、3.11、3.12
5.2	3.10、3.11、3.12、3.13

2.2 Django 版本

通常情况下，如果在生产环境中使用代码，应该使用稳定版本。
Django 项目大约每八个月发布一个完整的稳定版本，并在其间发布错误修复更新。

这些稳定版本包含我们向后兼容性保证所覆盖的 API；如果你针对稳定版本编写代码，在下一个官方版本发布时升级应该不会有任何问题。

功能版本（AB、A.B+1 等）大约每八个月发布一次。这些版本将包含新功能、对现有功能的改进等。

补丁版本（ABC 等）将根据需要发布，以修复错误和/或安全问题。这些版本将与相关功能版本 100% 兼容，除非出于安全原因或为了防止数据丢失而无法兼容。因此，"我应该升级到最新补丁版本吗？"的答案永远是"是"。

某些功能版本将被指定为长期支持 (LTS) 版本。这些版本将在保证的一段时间内（通常为三年）应用安全和数据丢失修复。

发布系列	最新发布	主流支持终止	延长支持结束
5.0	5.0.6	2024 年 8 月	2025 年 4 月
4.2 长期支持版本	4.2.13	2023 年 12 月 4 日	2026 年 4 月

未来版本路线图

发布系列	发布日期	主流支持终止	延长支持结束
6.1	2026 年 8 月	2027 年 4 月	2027 年 12 月
6.0	2025 年 12 月	2026 年 8 月	2027 年 4 月
5.2 长期支持版本	2025 年 4 月	2025 年 12 月	2028 年 4 月
5.1	2024 年 8 月	2025 年 4 月	2025 年 12 月

3 Django 开发 Web 程序

开始使用 Django 前你需要了解一些基础的 Web 知识及 Python 基础知识。

Python知识点：函数、面向对象。

前端开发：Web 基础、HTML、CSS、JavaScript 。

3.1 Python知识点

函数、面向对象

3.1.1 Python 函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。Python已经提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个自己的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串---用于存放函数说明。
函数内容以冒号 : 起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

语法：

py 复制代码

# Python 定义函数使用 def 关键字，一般格式如下：
def 函数名（参数列表）:
    函数体
# 默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

函数调用

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

参数传递

在 python 中，类型属于对象，对象有不同类型的区分，变量是没有类型的。

参数

以下是调用函数时可使用的正式参数类型：

必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
默认参数
调用函数时，如果没有传递参数，则会使用默认参数。

不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

py 复制代码

  # 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
  def functionname([formal_args,] *var_args_tuple ):
 		# 函数_文档字符串
 		function_suite
 		return [expression]
 		
  # 加了两个星号 ** 的参数会以字典的形式导入。
 	def functionname([formal_args,] **var_args_dict ):
 		# 函数_文档字符串
 		function_suite
 		return [expression]

3.1.2 Python 面向对象

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。

面向对象 的一些 基本特征:

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：

类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

类定义

语法格式如下：

py 复制代码

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

类对象

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。

类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

py 复制代码

#!/usr/bin/python3
 
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('runoob',10,30)
p.speak()

执行以上程序输出结果为：runoob 说: 我 10 岁。

继承

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示:

py 复制代码

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:
class DerivedClassName(modname.BaseClassName):

多继承

Python同样有限的支持多继承形式。多继承的类定义形如下例:

py 复制代码

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找父类中是否包含方法。

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法

类属性与方法

类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs 。

类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。

类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用，不能在类的外部调用。self.__private_methods。

类的专有方法：

__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方

3.2 Web 基础知识

web框架底层

网络通信
如下图所示：4 台电脑组成了局域网，可以进行通信。

通常个人写的程序，想要让别人访问的话需要将程序部署在云服务器上，部署前需要去云平台租用服务器（含公网IP），常见的云服务器有：阿里云、华为云、腾讯云、亚马逊云等。让网络中可以互相通信的双发收发数据。

我们自己写时，通过socket模块可以实现网络上的两端进行通信。

我的电脑 [服务端]

py 复制代码

import socket

# 1.监听本机的IP和端口
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('192.168.10.3', 8001))  # 我自己的电脑IP（通过ip可以找到电脑, 通过端口可以找到我的程序），端口8001

# 2.让多少人等待
sock.listen(5)

while True:
    # 3.等待连接请求的申请，有人来连接（阻塞）
    conn, addr = sock.accept()

    # 4.连接成功后立即发送
    conn.sendall("欢迎使用xx系统".encode("utf-8"))

    # 5.断开连接
    conn.close()

# 6.停止服务端程序
sock.close()

# 绑定本机ip和程序（端口） 然后让其他人来连接 连接了就获取con和add 然后发送消息

朋友A的电脑（同一个局域网）[客户端]

py 复制代码

import socket

# 1. 向指定IP发送连接请求
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('192.168.10.3', 8001))

# 2. 接收你发的消息
message = client.recv(1024)  ##recvive  接受发送的消息
print(message.decode("utf-8"))

# 3.断开连接
client.close()

朋友B的电脑 [客户端]

py 复制代码

import socket

# 1. 向指定IP发送连接请求
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('192.168.10.3', 8001))

# 2. 接收你发的消息
message = client.recv(1024)
print(message.decode("utf-8"))

# 3.断开连接
client.close()

常见软件架构

bs架构

py 复制代码

浏览器：充当客户端
服务器：网站

cs架构，开发应用程序，例如：QQ、Pycharm、网易云音乐（安装在电脑上的软件）

py 复制代码

客户端：安装在电脑上的软件。 网易云音乐
服务端：网易服务器

对于程序员来说：

网站，只需要写服务端程序。

py 复制代码

基于django开发的本质就是网站（web应用）
电脑上浏览器本质上是socket实现网络通信。（浏览器本身就已经写好了）

软件，客户端 + 服务端。

手撸web框架(手写简单web构建网站，不使用django、flask等)

py 复制代码

import socket

# 1.监听本机的IP和端口
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('192.168.0.6', 9000))  # 我自己的电脑IP，端口8001

# 2.让多少人等待
sock.listen(5)

while True:
    # 3.等待连接请求的申请，有人来连接（阻塞） -> 登录浏览器来连接我
    conn, addr = sock.accept()

    # 4.收到浏览器发送的消息
    buf = conn.recv(2048)
    print(buf)

    # 5.给浏览器返回数据
    conn.send(b"HTTP/1.1 200 OK\r\n\r\n")
    conn.send(b"Hello, World")

    # 6.断开连接
    conn.close()

# 6.停止服务端程序
sock.close()

知识点：浏览器再与服务端的网站进行通信时，多了几个规则。

服务端：网站

客户端：浏览器

创建连接
发送数据，固定格式

py 复制代码

# 请求头首行
GET /xxx/xxx/?name=xxx&age=111 HTTP/1.1\r\n

# 请求头（浏览器等相关信息）
Host: 192.168.0.6:9000\r\n
Connection: keep-alive\r\n
Upgrade-Insecure-Requests: 1\r\n
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\r\n
Accept-Encoding: gzip, deflate\r\n
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,zh-TW;q=0.7\r\n\r\n'

py 复制代码

# 请求头首行
POST /xxx/xxx/ HTTP/1.1\r\n

# 请求头
Host: 192.168.0.6:9000\r\n
Connection: keep-alive\r\n
Upgrade-Insecure-Requests: 1\r\n
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\r\n
Accept-Encoding: gzip, deflate\r\n
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,zh-TW;q=0.7\r\n\r\n（\r\n\r\n表示后面为请求体）
# 请求体
username=wupeiqi&password=123

py 复制代码

浏览器本质上发送请求时，包含请求头和请求体。
- GET请求
	- 只有请求头 + 没有请求体
	- 请求头之间用 \r\n
	- 请求头和请求体之间用 \r\n\r\n

- POST请求
	- 只有请求头 + 有请求体
	- 请求头之间用 \r\n
	- 请求头和请求体之间用 \r\n\r\n

一次请求和响应后，断开连接。客服端发送数据服务器返回数据（登陆失败）断开连接。
http协议

py 复制代码

http协议特点：无状态的短连接。 
http的应用：浏览器向服务端发送请求，就是按照http协议来的。
- 请求头+请求体 ；请求头和请求体之间用 \r\n\r\n ；请求头之间用 \r\n
- 一次请求和一次响应后，断开连接。  -> 短连接。  ->无状态如何体现？（朋友B发送	给服务端 服务端知道是朋友B了，说欢迎朋友B 然后连接断开，然后朋友B又连接 服务器更之前一样不知道是谁 所以后面得用cookie来解决）
- 后期记住 请求头+cookie
（具体就是朋友B发送给服务端 服务端知道是朋友B了，并给了一个凭证一起发送回去给朋友B，让朋友B把这个凭证存在浏览器文件，下次朋友B在发送数据给服务器，就会带着这个凭证，服务器收到凭证就知道是朋友B）就是服务器给客户端一个令牌 下次客户端带着令牌来

GET请求和POST的唯一区别就是POST有请求体，用来传输数据。当然，GET也能传输数据，用 get /xxx/xxx/?name=xxx&age=111

3.3 安装Django

在安装 Django 前，确保系统需要已经安装了 Python 的开发环境。

如果你还没有安装 Python，请先从 Python 官网下载并安装所需版本的 Python。

Django 安装很简单，使用包管理工具pip安装Django：

bash 复制代码

# 安装最新版Django
pip install django
# 安装指定版Django4.1
pip install django==4.1

通过以下命令可以查看已安装的版本：

# python 版本
python -V

# Django 版本
python -m django --version

3.4 创建Django项目

3.4.1 用命令行创建Django项目

创建一个新的Django项目 mysite2：

bash 复制代码

django-admin startproject mysite2

创建完成后项目的目录结构：

bash 复制代码

.
|-- mysite2
|   |-- __init__.py		# 一个空文件，告诉 Python 该目录是一个 Python 包
|   |-- asgi.py			# 一个 ASGI 兼容的 Web 服务器的入口，以便运行你的项目
|   |-- settings.py		# 该 Django 项目的设置/配置
|   |-- urls.py			# 该 Django 项目的 URL 声明; 一份由 Django 驱动的网站"目录"
|   `-- wsgi.py			# 一个 WSGI 兼容的 Web 服务器的入口，以便运行你的项目
`-- manage.py			# 一个实用的命令行工具，可让你以各种方式与该 Django 项目进行交互

运行开发服务器

启动Django的开发服务器：

bash 复制代码

cd myproject
python manage.py runserver

创建Django应用

创建一个新的Django应用：

bash 复制代码

python manage.py startapp app01

现在整个目录结构如下：

.
|-- mysite2			   # 项目的容器
|   |-- __init__.py
|   |-- __init__.pyc			
|   |-- settings.py			
|   |-- settings.pyc			
|   |-- urls.py				    # url 配置
|   |-- urls.pyc			
|   |-- views.py			    # 添加的视图文件
|   |-- views.pyc			# 编译后的视图文件
|   |-- wsgi.py			
|   `-- wsgi.pyc			
`-- manage.py

接着，理解模型、视图、模板等基本概念后，就可以开始实践构建你的项目了。

3.4.2 用PyCharm创建Django项目

推荐使用PyCharm创建Django项目

创建Django项目

PyCharm 主页面点击左上角 File -> newProject -> Django

注意：

命令行，创建的项目是标准的。
PyCharm，在标准的基础上默认给咱们加了点东西。
- 创建了一个templates目录【删除这个templates文件夹，然后在app01文件夹下新建一个templates文件夹】
- settings.py中【删除如图所示的内容】
  
  默认项目的文件介绍：
  
  mysite2
  ├── manage.py 【项目的管理，启动项目、创建app、数据管理】【不要动】【常常用】
  └── mysite
  ├── init.py
  ├── settings.py 【项目配置】【常常修改】
  ├── urls.py 【URL和函数的对应关系】【常常修改】
  ├── asgi.py 【接收网络请求】【不要动】
  └── wsgi.py 【接收网络请求】【不要动】

创建app

bash 复制代码

python3.9 manage.py startapp app01

- 项目
	- app，用户管理	【表结构、函数、HTML模板、CSS】
	- app，订单管理	【表结构、函数、HTML模板、CSS】
	- app，后台管理	【表结构、函数、HTML模板、CSS】
	- app，网站   	【表结构、函数、HTML模板、CSS】
	- app，API    	【表结构、函数、HTML模板、CSS】
	..
	
注意：一般情况下，用不到多app，这里项目下创建1个app即可。

现在整个目录结构如下：

├── app01
│   ├── __init__.py
│   ├── admin.py         【固定，不用动】django默认提供了admin后台管理。
│   ├── apps.py          【固定，不用动】app启动类
│   ├── migrations       【固定，不用动】数据库变更记录
│   │   └── __init__.py
│   ├── models.py        【**重要**】，对数据库操作。
│   ├── tests.py         【固定，不用动】单元测试
│   └── views.py         【**重要**】，函数。
├── manage.py
└── mysite2
    ├── __init__.py
    ├── asgi.py
    ├── settings.py
    ├── urls.py          【URL->函数】
    └── wsgi.py

快速上手

确保app已注册【settings.py】
编写URL和视图函数对应关系【urls.py】
编写视图函数【views.py】
启动django项目
- 命令行启动
```
python manage.py runserver 
```
- Pycharm启动

接着，理解模型、视图、模板等基本概念后，就可以开始实践构建你的项目了。

4 Django 部分常用参数、插件

4.1 path() 视图函数

path() 可以接收四个参数，分别是两个必选参数：route、view 和两个可选参数：kwargs、name。

py 复制代码

# 语法格式：
path(route, view, kwargs=None, name=None)

# 参数
route： 字符串，定义 URL 的路径部分。可以包含变量，例如 <int:my_variable>，以从 URL 中捕获参数并将其传递给视图函数。
view： 视图函数，处理与给定路由匹配的请求。可以是一个函数或一个基于类的视图。
kwargs（可选）： 一个字典，包含传递给视图函数的额外关键字参数。
name（可选）： 为 URL 路由指定一个唯一的名称，以便在代码的其他地方引用它。这对于在模板中生成 URL 或在代码中进行重定向等操作非常有用。

4.2 models.py模型参数

字段类型

在Django的models.py文件中，可以使用多种字段来定义模型的属性和表的字段。以下是一些常用的字段类型：

py 复制代码

# 字段
CharField：用于存储字符数据，指定max_length参数来设置最大长度。
IntegerField：用于存储整数数据。
FloatField：用于存储浮点数数据。
BooleanField：用于存储布尔值。
DateField：用于存储日期。
DateTimeField：用于存储日期和时间。
TextField：用于存储长文本数据。
EmailField：用于存储电子邮件地址。
URLField：用于存储URL地址。
ForeignKey：用于建立外键关联。
ManyToManyField：用于建立多对多关联。
除了上述字段类型之外，还有其他更多的字段类型可供选择，如FileField、ImageField、UUIDField等。每个字段类型都有一些特定的参数和选项，可以根据需要进行配置。

字段的类型中的属性

在Django的模型中，字段可以使用不同的属性来定义其行为和特性。以下是一些常见的模型字段属性：

py 复制代码

# 属性参数
null：指定字段是否允许为NULL值。默认为False，即字段不能为空。
blank：指定字段是否可以为空白。默认为False，即字段不能为空白。
default：指定字段的默认值。可以是一个具体的值或一个可调用对象（如函数）。
choices：指定字段的可选值列表。可以是一个包含元组的列表，每个元组包含两个值：选项的实际值和显示值。
primary_key：指定字段是否为主键。默认情况下，Django会自动为每个模型添加一个自增的主键字段（id），但你也可以将其他字段指定为主键。
unique：指定字段的值是否必须是唯一的。默认为False。
db_index：指定是否为字段创建数据库索引。默认为False。
editable：指定字段是否可编辑。默认为True。如果设置为False，字段将不会出现在模型表单中。
verbose_name：指定字段的人类可读的名称。用于在后台管理界面和表单中显示。
help_text：为字段提供帮助文本，用于在后台管理界面和表单中显示。
auto_now：指定字段在每次保存模型时是否自动更新为当前日期和时间。
auto_now_add：指定字段在模型对象第一次保存时自动设置为当前日期和时间，之后不再更新。
related_name：指定反向关系的名称。用于在关联模型中访问关联对象。
on_delete：指定当关联对象被删除时，该字段的行为。常见的选项包括CASCADE（级联删除关联对象）、PROTECT（阻止删除）、SET_NULL（设置为NULL值）等。
这只是一些常见的模型字段属性，Django还提供了更多的属性和选项，可以根据实际需求选择合适的属性来定义模型字段的行为。

如：在Django的models.CharField中，除了max_length字段之外，还有一些其他可选参数可以用来定义CharField的行为和属性。

以下是models.CharField中常用的一些字段：

py 复制代码

blank：布尔值，指定字段是否可以为空。默认为False，即不能为空。如果设置为True，则允许为空。
null：布尔值，指定字段是否可以为NULL。默认为False，即不允许为NULL。如果设置为True，则允许为NULL。
default：指定字段的默认值。可以是一个具体的值，也可以是一个可调用对象（如函数或方法）。默认值将在创建新对象时使用，如果没有提供其他值。
choices：一个可选的选择列表，用于限制字段的有效值。可以是一个列表或元组的组合，每个元素都是一个包含两个元素的元组，第一个元素是实际存储的值，第二个元素是显示给用户的标签。例如：choices=[('M', 'Male'), ('F', 'Female')]。
verbose_name：字段的人类可读名称。如果未提供，Django将根据字段名称自动生成一个。
help_text：字段的帮助文本，用于提供关于字段用途和输入格式的描述。
validators：一个可选的验证器列表，用于验证字段的值。验证器可以是内置的Django验证器，也可以是自定义的验证器函数。
unique：布尔值，指定字段的值是否必须是唯一的。默认为False，即允许重复值。如果设置为True，则要求字段的值是唯一的。
error_messages：一个字典，用于自定义字段的错误消息。可以定义各种错误消息，如blank（字段为空时的错误消息）、null（字段为NULL时的错误消息）等。

以上是models.CharField中常用的一些字段。根据具体的需求，可以使用这些字段来定义和配置CharField的行为和属性。

模型之间的关联关系

在Django中，模型之间可以通过不同类型的关系进行关联。

以下是常见的模型关系类型：

py 复制代码

一对一关系（One-to-One Relationship）：一个模型实例与另一个模型实例之间有且仅有一个关联关系。例如，一个人只能有一个身份证号，一个身份证号也只能对应一个人。在Django中，可以使用OneToOneField来定义一对一关系。

一对多关系（One-to-Many Relationship）：一个模型实例与多个另一个模型实例之间存在关联关系。例如，一个作者可以写多本书，但一本书只能有一个作者。在Django中，可以使用ForeignKey来定义一对多关系。

多对多关系（Many-to-Many Relationship）：多个模型实例之间存在多对多关联关系。例如，一个学生可以参加多个课程，一个课程也可以有多个学生。在Django中，可以使用ManyToManyField来定义多对多关系。

多态关系（Polymorphic Relationship）：一个模型实例可以同时关联多个不同模型实例。例如，一个评论可以同时关联一篇文章和一个视频。在Django中，可以使用第三方库（如django-polymorphic）来实现多态关系。

自引用关系（Self-Referential Relationship）：一个模型实例可以与同一模型的其他实例之间存在关联关系。例如，一个员工可以有一个上级领导，这个上级领导也是一个员工。在Django中，可以使用ForeignKey来定义自引用关系。

以上是常见的模型关系类型，在实际开发中可能还会遇到其他类型的关系。Django提供了丰富的关系字段和管理方法，可以轻松地处理模型之间的关联关系。

model中 class Meta设置

在Django的模型中，class Meta是一个内部类，用于定义模型的元数据（metadata）。元数据是关于模型的额外信息，用于控制模型的行为和特性。
class Meta可以包含以下属性：

py 复制代码

# class Meta 属性参数

db_table：指定模型在数据库中对应的表名。

ordering：指定模型的默认排序方式。可以是一个包含字段名的列表，也可以是一个字符串。

verbose_name：指定模型的人类可读的名称。用于在后台管理界面显示。

verbose_name_plural：指定模型的复数形式的人类可读名称。

unique_together：指定模型的字段组合必须是唯一的。可以是一个包含字段名的元组或列表。

indexes：指定模型的数据库索引。可以是一个包含models.Index对象的列表。

constraints：指定模型的数据库约束。可以是一个包含models.CheckConstraint、models.UniqueConstraint或models.ForeignKeyConstraint对象的列表。

default_related_name：指定模型的反向关系的默认名称。用于在关联模型中访问关联对象。

abstract：指定模型是否为抽象模型。抽象模型不能直接实例化，只能被其他模型继承。

app_label：指定模型所属的应用程序的名称。

db_tablespace：指定模型在数据库中的表空间。

managed：指定是否由Django自动管理模型的数据库表。默认为True，表示由Django自动创建和维护表结构。

通过定义class Meta，可以对模型进行更精细的控制和配置。这些元数据属性可以影响模型的数据库表结构、后台管理界面的显示、查询结果的排序等。

model中的 def str(self)设置

在Django的模型中，def __str__(self)是一个特殊的方法，用于定义模型对象的字符串表示形式。该方法在模型对象被打印、显示在后台管理界面或其他上下文中时被调用，用于返回一个可读的字符串表示。

通常情况下，def __str__(self)方法会返回模型对象的某个字段的值，以便更好地表示该对象。例如，如果模型有一个名为name的字段，可以在def __str__(self)方法中返回该字段的值，如下所示：

py 复制代码

class MyModel(models.Model):
    name = models.CharField(max_length=100)
    # other fields...

    def __str__(self):
        return self.name

在这个例子中，def __str__(self)方法返回模型对象的name字段的值。当该模型对象被打印或显示时，将以该值作为字符串表示。

通过定义def __str__(self)方法，可以自定义模型对象的字符串表示形式，以便更好地展示和识别模型对象。这对于调试和开发过程中的可读性非常有用。

4.3 模板插件、技术

4.3.1 Bootstrap

Bootstrap

来自 Twitter，是目前最受欢迎的前端框架。

Bootstrap 是基于 HTML、CSS、JAVASCRIPT 的，它简洁灵活，使得 Web 开发更加快捷。

Bootstrap 是由 Twitter 的 Mark Otto 和 Jacob Thornton 开发的。Bootstrap 是 2011 年八月在 GitHub 上发布的开源产品。

在开始使用之前，确保你已具备 HTML 、 CSS 和 JavaScript 的基础知识。

Bootstrap 的特点：

移动设备优先：自 Bootstrap 3 起，框架包含了贯穿于整个库的移动设备优先的样式。
浏览器支持：所有的主流浏览器都支持 Bootstrap。
容易上手：只要您具备 HTML 和 CSS 的基础知识，您就可以开始学习 Bootstrap。
响应式设计：Bootstrap 的响应式 CSS 能够自适应于台式机、平板电脑和手机。
为后端开发人员创建接口提供了一个简洁统一的解决方案。
包含了功能强大的内置组件，易于定制。
还提供了基于 Web 的定制。
Bootstrap是开源的。

Bootstrap 包的内容：

基本结构：Bootstrap 提供了一个带有网格系统、链接样式、背景的基本结构。
CSS：Bootstrap 自带以下特性：全局的 CSS 设置、定义基本的 HTML 元素样式、可扩展的 class，以及一个先进的网格系统。
组件：Bootstrap 包含了十几个可重用的组件，用于创建图像、下拉菜单、导航、警告框、弹出框等等。
JavaScript 插件：Bootstrap 包含了十几个自定义的 jQuery 插件。您可以直接包含所有的插件，也可以逐个包含这些插件。
定制：您可以定制 Bootstrap 的组件、LESS 变量和 jQuery 插件来得到您自己的版本。

4.3.2 jQuery

jQuery

是一个 JavaScript 库。

jQuery 极大地简化了 JavaScript 编程。

jQuery 库可以通过一行简单的标记被添加到网页中。

jQuery 是一个轻量级的"写的少，做的多"的 JavaScript 库。

jQuery 库包含以下功能：

HTML 元素选取
HTML 元素操作
CSS 操作
HTML 事件函数
JavaScript 特效和动画
HTML DOM 遍历和修改
AJAX
Utilities

4.3.2 AJAX

AJAX

是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。

AJAX 不是新的编程语言，而是一种使用现有标准的新方法。

AJAX 最大的优点是在不重新加载整个页面的情况下，可以与服务器交换数据并更新部分网页内容。

AJAX 不需要任何浏览器插件，但需要用户允许 JavaScript 在浏览器上执行。

XMLHttpRequest 只是实现 Ajax 的一种方式。

AJAX = 异步 JavaScript 和 XML。

AJAX 是一种用于创建快速动态网页的技术。

通过在后台与服务器进行少量数据交换，AJAX 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。

传统的网页（不使用 AJAX）如果需要更新内容，必需重载整个网页面。

有很多使用 AJAX 的应用程序案例：新浪微博、Google 地图、开心网等等。

AJAX 应用：

AJAX是基于现有的Internet标准，并且联合使用它们

XMLHttpRequest 对象 (异步的与服务器交换数据)。运用 XHTML+CSS 来表达资讯。
JavaScript/DOM (信息显示/交互)。运用 JavaScript 操作 DOM（Document Object Model）来执行动态效果。
CSS (给数据定义样式)。
XML (作为转换数据的格式)。运用 XML 和 XSLT 操作资料，运用 XMLHttpRequest 或新的 Fetch API 与网页服务器进行异步资料交换。

注意，AJAX 与 Flash、Silverlight 和 Java Applet 等 RIA 技术是有区分的，AJAX应用程序与浏览器和平台无关！

AJAX 工作原理：

小结

Django 处理了Web开发中的许多繁琐事务，比如: 用户认证、数据库连接、CRUD（创建、读取、更新、删除）操作、URL路由、表单处理和安全性等，这样开发者就可以专注于编写使网站独特的业务逻辑部分，而不需要重新发明轮子。

Django 遵循"包含电池"的理念，提供了几乎所有开发者可能想要的功能"开箱即用"。

Django 的ORM（对象关系映射）技术使得与数据库的交流变得更加简单，无需编写复杂的SQL语句。Django还强调组件的可重用性，遵循DRY（不要重复自己）的原则。

Django 是一个强大的框架，适合那些希望快速开发安全、可维护的网站的开发者。如果你对创建数据库驱动的网站感兴趣，Django是一个非常有用的框架。

END -

本文摘编自《速学Django：Web开发从入门到进阶》，经出版方授权发布。

推荐语:

为满足广大Python编程学习者的实际需求，本书作者十多年来致力于推动Python编程基础教学，始终专注于产品原型设计、Django前端开发、Python程序设计。

本书是一本适合Django开发快速入门的图书。

本书配合实际操作的案例，清晰明了地讲解了使用Django进行Web项目开发时所涉及的常用知识点，包括框架配置、路由配置、模型、视图、模板、表单、中间件、上下文处理器、代码测试、网站缓存和网站部署等内容。

摘编图书参考：《速学Django：Web开发从入门到进阶》