Bird's blog

1. Django概述

1. 简介

Django 是用Python开发的一个免费开源的Web框架，可以用于快速搭建高性能，优雅的网站！采用了MVC的框架模式，即模型M，视图V和控制器C，也可以称为MVT模式，模型M，视图V，模板T。这套框架是以比利时的吉普赛爵士吉他手Django Reinhardt来命名的.

MVT (Model-Template-View) —— Django 的实现方式

Django 中采用了 MVT 设计模式，类似于 MVC，但有一些区别：

Model (模型)：与数据库交互，处理数据的创建、读取、更新、删除。
Template (模板)：负责页面渲染，生成最终的 HTML 内容。
View (视图)：Django 的 View 更偏向于控制器的角色，接收请求并决定使用哪个模板和数据。

流程：

用户访问 URL，请求被 Django 的 urls.py 映射到相应的 View。
View 处理业务逻辑，调用 Model 获取数据。
View 将数据传递给 Template。
Template 渲染 HTML，最终返回给用户。

内置功能

功能	说明
Admin 后台	自动生成管理界面，无需手动编写 CRUD 逻辑。
ORM	用 Python 类操作数据库，无需写 SQL。
表单处理	内置表单验证，防止 CSRF 攻击。
用户认证	提供登录、注册、权限管理（`django.contrib.auth`）。
路由系统	URL 映射灵活，支持正则表达式。
缓存机制	支持 Memcached、Redis 等后端。

2. 项目结构

以HelloWorld项目为例:

HelloWorld/                  # 项目根目录
├── manage.py                # 项目管理脚本
├── db.sqlite3               # SQLite 数据库文件
├── templates                # 模板文件
└── HelloWorld/              # 项目配置目录（与项目同名）
    ├── __init__.py          # 包标识文件
    ├── settings.py          # 项目设置
    ├── urls.py              # 主路由配置
    ├── asgi.py              # ASGI 配置
    └── wsgi.py              # WSGI 配置

1.模型层Model

ORM（对象关系映射）：Django 通过 ORM 实现数据库操作，无需编写 SQL 语句。支持多种数据库（如 PostgreSQL、MySQL、SQLite 等）。
模型定义：在 models.py 中定义数据模型，每个模型对应数据库中的一张表，字段对应表的列。
数据库迁移：通过 makemigrations 和 migrate 命令管理数据库结构变更。

步骤:

在项目中创建一个包并新建一个models.py文件。
在settings.py中注册应用

INSTALLED_APPS = [
       # ...
       '包名',  # 添加此行
   ]

在models.py中定义数据模型

   # 示例
   from django.db import models
   class Book(models.Model):
       title = models.CharField(max_length=100)  # 书籍标题
       author = models.CharField(max_length=100)  # 作者
       publication_date = models.DateField()  # 出版日期
       is_published = models.BooleanField(default=False)  # 是否出版
       def __str__(self):
           return self.title  # 用于在后台和调试时显示对象名称

2.视图层View

在 Django 中，视图层（View） 负责处理用户请求并返回响应，是 MVC（在 Django 中称为 MTV）架构的核心组成部分。视图层接收 HTTP 请求，执行必要的业务逻辑（如查询数据库、调用 API），然后返回 HTML 页面或 JSON 数据等响应。

请求处理：视图函数或类接收 HTTP 请求，处理业务逻辑，并返回 HTTP 响应。
路由系统：在 urls.py 中定义 URL 模式与视图的映射关系。
通用视图：Django 提供多种内置通用视图（如 ListView、DetailView 等），简化常见视图开发。

步骤：

在views.py中使用函数或者类的方式来返回一个HttpResponse对象或是render()渲染模板

from django.http import HttpRequest, HttpResponse

def hello_world(request):
    return HttpResponse("Hello, World!")   # 如果想渲染templates中的模板页面使用 return render(request, 'hello.html')

在url.py中将 URL 路径与视图函数绑定

from django.urls import path
from . import views

urlpatterns = [
    path('hello', views.hello_world),  # 访问 /hello/ 时调用 hello_world
]

启动内置服务器进行访问查看效果

python manage.py runserver  # 启动后会显示内置服务器地址http://localhost:8000

3.模板层Template

Django 模板是 Django 框架中用于生成 HTML 页面的组件，它采用 Python 语法和特殊的模板标签，将数据与展示逻辑分离。语法再后文详解，此处仅介绍。

模板语法：简称DTL，HTML 中嵌入 Django 模板标签和过滤器，实现动态内容渲染。
模板继承：通过 extends 和 block 标签实现模板复用，减少代码冗余。
上下文：视图向模板传递数据的机制。

步骤：

在templates.py文件中创建html文件
在views.py视图中进行渲染

2. 模板

在Django框架中，模板是可以帮助开发者快速生成呈现给用户页面的工具。用于编写html代码，还可以嵌入模板代码转换更方便的完成页面开发，再通过在视图中渲染模板，将生成模板的设计实现了业务逻辑视图与显示内容模板的分离，一个视图可以使用任意一个模板，一个模板可以供多个视图使用。当前显示的页面=模板+数据，模板创建在项目的/templates文件中。

1. Django模板语言

Django 模板语言（Django Template Language，DTL）。这种语法主要用于在 HTML 模板里生成动态内容。

Django 模板使用双花括号{{ }}表示变量，使用{% %}表示标签。

变量：借助双花括号来输出变量，示例如下：

   {{ variable_name }}

标签：使用{% %}来执行逻辑操作，比如条件判断和循环，示例如下：

   {% if condition %}
       <p>条件为真</p>
   {% else %}
       <p>条件为假</p>
   {% endif %}

   {% for item in items %}
       <li>{{ item }}</li>
   {% endfor %}

过滤器：通过|对变量进行修改，示例如下：

add：将值的值增加2。使用形式为：{{value | add：“ 2”}}

cut：从给定值中删除所有arg的值。使用形式为：{{value | cut：arg}}

date：格式化时间格式。使用形式为：{{value| date：“ Ymd H：M：S”}}

default：如果value是False，那么输出给定的默认值。使用形式：{{value | default：“ nothing”}}。例如，如果值是“”，那么输出将是nothing

first：返回列表/字符串中的第一个元素。使用形式：{{value | first}}

length：返回值的长度。使用形式：{{value | length}}

  {{ value|date:"Y-m-d" }}  {# 格式化日期 #}
  {{ text|truncatewords:30 }}  {# 截断文本 #}

注释：用{# #}添加注释，示例如下：

{# 这是一条注释 #}

模板继承：能够创建基础模板和子模板，示例如下：

{# base.html #}
<body>
{% block content %}
{% endblock %}
</body>

{# child.html #}
{% extends "base.html" %}
{% block content %}
<p>这是子模板的内容</p>
{% endblock %}

3. 模型

Django 模型是与数据库交互的核心组件，采用 ORM（对象关系映射）机制，让你可以使用 Python 代码而非 SQL 语句来操作数据库。每个模型对应数据库中的一张表，字段对应表中的列。

模型是有关数据的唯一确定的信息源。它包含要存储数据的基本字段和行为。通常，每个模型都映射到单个数据库表。

每一个模型是django.db.models.Model的子类
每一个模型属性代表数据表的一个字段。
Django提供了自动生成的数据库访问API，使用模型操作数据库很方便

示例：

定义一个Person模型，其中包含了first_name和last_name字段

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

此操作会创建一个数据库名为Person的表：

CREATE TABLE myapp_person (
    "id" serial NOT NULL PRIMARY KEY,
    "first_name" varchar(30) NOT NULL,
    "last_name" varchar(30) NOT NULL
);

1. 定义模型

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

from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

class Product(models.Model):
    name = models.CharField(max_length=200)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    description = models.TextField(blank=True)
    category = models.ForeignKey(Category, on_delete=models.CASCADE, related_name='products')
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

2. 字段类型

Django 提供多种字段类型：

CharField：短文本字段（必须指定max_length）
TextField：长文本字段
IntegerField：整数
DecimalField：十进制数（需指定max_digits和decimal_places）
BooleanField：布尔值
DateField/DateTimeField：日期 / 日期时间（auto_now_add自动设置创建时间，auto_now自动更新时间）
ForeignKey：外键关联
ManyToManyField：多对多关联
OneToOneField：一对一关联

3. 模型关系

外键（ForeignKey）：定义多对一关系

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

多对多（ManyToManyField）：定义多对多关系

class Tag(models.Model):
    name = models.CharField(max_length=50)

class Article(models.Model):
    title = models.CharField(max_length=200)
    tags = models.ManyToManyField(Tag)

一对一（OneToOneField）：定义一对一关系

class User(models.Model):
    username = models.CharField(max_length=100)

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()

3. 模型方法

可以为模型添加自定义方法：

from django.db import models
from django.urls import reverse

class Product(models.Model):
    name = models.CharField(max_length=200)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    discount_percentage = models.IntegerField(default=0)

    def get_discounted_price(self):
        return self.price * (1 - self.discount_percentage / 100)

    def get_absolute_url(self):
        return reverse('product_detail', args=[str(self.id)])

4. 数据库迁移

定义模型后，需要创建并应用迁移：

# 创建迁移文件
python manage.py makemigrations

# 应用迁移到数据库
python manage.py migrate

在修改模型后同样需要进行数据库的迁移

5. 查询集（QuerySets）

Django 提供强大的查询 API：

# 获取所有产品
products = Product.objects.all()

# 过滤查询
active_products = Product.objects.filter(is_active=True)
expensive_products = Product.objects.filter(price__gt=100)  # 价格大于100

# 获取单个对象
product = Product.objects.get(id=1)

# 排序
products_by_price = Product.objects.order_by('price')  # 升序
products_by_price_desc = Product.objects.order_by('-price')  # 降序

# 链式查询
discounted_products = Product.objects.filter(
    is_active=True
).order_by('-discount_percentage')

# 聚合查询
from django.db.models import Avg, Sum, Count
average_price = Product.objects.aggregate(Avg('price'))
total_products = Product.objects.count()

6. 关联查询

通过关联字段查询相关对象：

# 获取某个分类下的所有产品
category = Category.objects.get(name='Electronics')
products = category.products.all()

# 反向查询
product = Product.objects.get(name='Laptop')
category = product.category

# 跨关联查询
electronics_products = Product.objects.filter(category__name='Electronics')

7. 模型元数据（Meta）

可以通过Meta类自定义模型行为：

class Product(models.Model):
    # 字段定义...

    class Meta:
        db_table = 'table_name'  # 表名设为table_name
        verbose_name = '产品' # 设置模型的人类可读名称（用于管理界面等）
        verbose_name_plural = '产品列表' # 设置模型的人类可读名称（用于管理界面等）
        ordering = ['-created_at'] # 指定模型对象的默认排序方式
        unique_together = ('name', 'category') # 设置多字段联合唯一约束

8. 模型继承

Django 支持三种继承方式：

抽象基类（不创建表，仅用于复用代码）

class TimeStampedModel(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True

class Product(TimeStampedModel):
    # 继承created_at和updated_at字段
    name = models.CharField(max_length=200)

多表继承（每个模型都创建表）

class Vehicle(models.Model):
    brand = models.CharField(max_length=100)

class Car(Vehicle):
    doors = models.IntegerField()

代理模型（不创建新表，仅改变查询行为）

class Person(models.Model):
    name = models.CharField(max_length=100)

class OrderedPerson(Person):
    class Meta:
        proxy = True
        ordering = ['name']

4. 视图

Django 视图是处理 Web 请求并返回响应的 Python 函数或类。它们是 MVC（实际上是 MTV - 模型、模板、视图）架构的核心组件，负责处理业务逻辑。视图在项目中的views.py文件中创建。

1. 函数视图（Function-Based Views）

这是最简单的视图类型，本质上是 Python 函数：

from django.http import HttpResponse

def hello_world(request):
    return HttpResponse("Hello, World!")

在 Django 中，HttpResponse是处理视图返回的基本响应对象，它负责将服务器处理结果返回给客户端。其构造为：

HttpResponse(
    content=b'', 
    content_type=None, 
    status=200, 
    reason=None, 
    charset=None
)

content
类型：字符串或字节
描述：响应的内容主体
示例：

# 字符串内容（自动编码为UTF-8）
HttpResponse("Hello, World!")

# 字节内容
HttpResponse(b"Binary data\x00\x01")

content_type
类型：字符串
描述：响应的 MIME 类型（默认：text/html; charset=utf-8）
示例：

# 纯文本响应
HttpResponse("Plain text", content_type="text/plain")

# JSON响应
HttpResponse(json.dumps({'key': 'value'}), content_type="application/json")

status
类型：整数
描述：HTTP 状态码（默认：200）
示例：

# 404 Not Found
HttpResponse("Page not found", status=404)

# 201 Created
HttpResponse("Resource created", status=201)

reason
类型：字符串
描述：状态码的文本描述（默认：Django 自动设置）
示例：

# 自定义状态描述
HttpResponse("Unauthorized", status=401, reason="Invalid credentials")

charset
类型：字符串
描述：字符编码（默认：从content_type中提取，或使用settings.DEFAULT_CHARSET）
示例：

# 指定GBK编码
HttpResponse("中文内容", content_type="text/plain", charset="gbk")

Django 提供了多种HttpResponse的子类：

HttpResponseRedirect：302 重定向
HttpResponsePermanentRedirect：301 永久重定向
HttpResponseNotAllowed：405 方法不允许
HttpResponseNotFound：404 未找到
HttpResponseForbidden：403 禁止访问
HttpResponseServerError：500 服务器错误
JsonResponse：JSON 格式响应
StreamingHttpResponse：流式响应

更复杂的例子可能会处理不同 HTTP 方法：

from django.http import HttpResponse, JsonResponse

def user_list(request):
    if request.method == 'GET':
        # 返回用户列表逻辑
        users = [{'name': 'Alice'}, {'name': 'Bob'}]
        return JsonResponse(users, safe=False)
    elif request.method == 'POST':
        # 创建新用户逻辑
        data = request.POST
        # 处理数据并保存到数据库
        return HttpResponse("User created", status=201)

2. 类视图（Class-Based Views）

类视图提供了更结构化的方式来组织代码，支持继承和复用：

from django.views import View
from django.http import HttpResponse

class HelloWorldView(View):
    def get(self, request):
        return HttpResponse("Hello from Class View!")

使用基于类的通用视图（Generic Views）可以进一步简化常见任务：

from django.views.generic import ListView
from .models import User

class UserListView(ListView):
    model = User
    template_name = 'user_list.html'
    context_object_name = 'users'

3. URL 配置

视图需要通过 URL 模式映射才能被访问：

# urls.py
from django.urls import path
from .views import hello_world, UserListView

urlpatterns = [
    path('hello/', hello_world),
    path('users/', UserListView.as_view()),
]

4. 处理表单

视图通常需要处理用户提交的表单：

from django.shortcuts import render, redirect
from .forms import ContactForm

def contact_view(request):
    if request.method == 'POST':
        form = ContactForm(request.POST)
        if form.is_valid():
            # 处理表单数据
            form.save()
            return redirect('success')
    else:
        form = ContactForm()
    return render(request, 'contact.html', {'form': form})

5. 使用模板

视图可以渲染 HTML 模板：

from django.shortcuts import render

def home_view(request):
    context = {
        'title': 'Welcome to my site',
        'items': ['apple', 'banana', 'cherry']
    }
    return render(request, 'home.html', context)

对应的模板文件 home.html 可能是：

<!DOCTYPE html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ title }}</h1>
    <ul>
        {% for item in items %}
            <li>{{ item }}</li>
        {% endfor %}
    </ul>
</body>
</html>

在 Django 中，render() 是一个常用的快捷函数，用于将模板与上下文数据结合并返回 HTTP 响应。它简化了手动创建 HttpResponse 和加载模板的过程。

render(
    request,            # 当前请求对象（用于传递上下文数据和会话信息）
    template_name,      # 模板文件的名称或路径（如 'home.html' 或 'pages/home.html'）
    context=None,       # 递给模板的上下文数据（字典类型）
    content_type=None,  # 响应的 MIME 类型（默认：'text/html'）
    status=None,        # HTTP 状态码（默认：200）
    using=None          # 指定使用的模板引擎（多引擎配置时使用）
)

6. 中间件与视图装饰器

可以使用装饰器来增强视图功能：

from django.contrib.auth.decorators import login_required

@login_required
def protected_view(request):
    return HttpResponse("This page requires authentication")

5. setting文件配置

在 Django 中，settings.py 文件是项目的核心配置文件，用于定义项目的各种配置选项，包括数据库连接、中间件、应用程序、静态文件路径等。下面介绍 Django 中 settings.py 的主要配置项和使用方法。

1. 基础配置

首先，让我们看一下 Django 项目中 settings.py 文件的基础结构和常用配置项：

# 项目名称/settings.py

# 导入必要的模块
import os
from pathlib import Path

# 项目路径设置
BASE_DIR = Path(__file__).resolve().parent.parent

# 安全密钥 - 生产环境中应从环境变量获取
SECRET_KEY = 'your-secret-key-here'

# 调试模式 - 生产环境应设置为 False
DEBUG = True

# 允许访问的域名
ALLOWED_HOSTS = []

# 应用列表 - 添加你的应用
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # 添加你的应用
    'myapp',
]

# 中间件配置
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

# URL 配置
ROOT_URLCONF = 'project_name.urls'

# 模板配置
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        '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',
            ],
        },
    },
]

# WSGI 应用配置
WSGI_APPLICATION = 'project_name.wsgi.application'

# 数据库配置 - 默认使用 SQLite
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

# 密码验证
AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]

# 国际化配置
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_TZ = True

# 静态文件配置
STATIC_URL = '/static/'

# 默认主键类型
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

2. 关键配置项详解

SECRET_KEY：
用于 Django 的加密签名，必须保密。
生产环境中应从环境变量或配置文件中获取，避免硬编码。
DEBUG：
调试模式开关，生产环境必须设置为 False。
设为 True 时，Django 会显示详细的错误页面，但存在安全风险。
ALLOWED_HOSTS：
指定允许访问的域名或 IP 地址。
生产环境中应设置为你的域名或服务器 IP。
DATABASES：
数据库连接配置，默认使用 SQLite。
生产环境中通常使用 PostgreSQL、MySQL 等数据库：

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'your_database',
'USER': 'your_username',
'PASSWORD': 'your_password',
'HOST': 'localhost',
'PORT': '5432',
}
}

不同的数据库的配置略有不同，下面是一些常用数据库配置：

SQLite（默认配置）

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',  # 数据库文件路径
}
}

特点：

无需单独的数据库服务器，适合开发和小型项目
文件型数据库，存储在单个文件中
不适合高并发生产环境

PostgreSQL

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'mydatabase',      # 数据库名
'USER': 'mydatabaseuser',  # 用户名
'PASSWORD': 'mypassword',  # 密码
'HOST': 'localhost',       # 主机
'PORT': '5432',            # 端口
}
}

安装依赖：

pip install psycopg2-binary  # PostgreSQL 驱动

特点：

功能强大的开源数据库，支持高级特性
适合复杂查询和需要事务支持的场景
生产环境的首选之一

MySQL

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'mydatabase',
'USER': 'mydatabaseuser',
'PASSWORD': 'mypassword',
'HOST': 'localhost',
'PORT': '3306',
'OPTIONS': {
'charset': 'utf8mb4',  # 支持 emoji 字符
},
}
}

安装依赖：

pip install mysqlclient  # MySQL 驱动

特点：

流行的开源数据库，性能优秀
适合大多数 Web 应用
需要注意字符集设置（推荐使用 utf8mb4）

Oracle

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.oracle',
'NAME': 'mydatabase',       # ORACLE_SID 或 TNS 名称
'USER': 'mydatabaseuser',
'PASSWORD': 'mypassword',
'HOST': 'localhost',
'PORT': '1521',
}
}

安装依赖：

pip install cx_Oracle  # Oracle 驱动

INSTALLED_APPS：
注册项目中使用的应用程序。
添加自定义应用或第三方应用时需要在此处注册。
MIDDLEWARE：
中间件是处理请求和响应的钩子系统。
可以添加自定义中间件或调整现有中间件的顺序。
STATICFILES_DIRS 和 STATIC_ROOT：
静态文件配置，用于部署时收集静态文件：

STATICFILES_DIRS = [
BASE_DIR / "static",
]

STATIC_ROOT = BASE_DIR / "staticfiles"

MEDIA_URL 和 MEDIA_ROOT：
上传文件配置：

MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'

AUTHENTICATION_BACKENDS：
自定义认证后端配置：

AUTHENTICATION_BACKENDS = [
'django.contrib.auth.backends.ModelBackend',
'myapp.backends.CustomAuthBackend',
]

CACHES：
- 缓存配置，例如使用 Redis：

CACHES = {
'default': {
    'BACKEND': 'django_redis.cache.RedisCache',
    'LOCATION': 'redis://127.0.0.1:6379/1',
    'OPTIONS': {
        'CLIENT_CLASS': 'django_redis.client.DefaultClient',
        }
    }
}

3. 多环境配置策略

在实际开发中，通常需要为不同环境（开发、测试、生产）使用不同的配置。以下是几种常见的配置策略：

环境变量：
使用 os.environ.get() 获取环境变量，适用于敏感信息如数据库密码。
配置文件拆分：
创建 settings/ 目录，将配置拆分为 base.py、development.py、production.py 等。
第三方工具：
使用 django-environ 或 python-decouple 管理环境变量和配置。

例如，使用环境变量配置数据库：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.environ.get('DB_NAME', 'default_name'),
        'USER': os.environ.get('DB_USER', 'default_user'),
        'PASSWORD': os.environ.get('DB_PASSWORD', 'default_password'),
        'HOST': os.environ.get('DB_HOST', 'localhost'),
        'PORT': os.environ.get('DB_PORT', '5432'),
    }
}

Django

1. Django概述

1. 简介

2. 项目结构

2. 模板

1. Django模板语言

3. 模型

1. 定义模型

2. 字段类型

3. 模型关系

3. 模型方法

4. 数据库迁移

5. 查询集（QuerySets）

6. 关联查询

7. 模型元数据（Meta）

8. 模型继承

4. 视图

1. 函数视图（Function-Based Views）

2. 类视图（Class-Based Views）

3. URL 配置

4. 处理表单

5. 使用模板

6. 中间件与视图装饰器

5. setting文件配置

1. 基础配置

2. 关键配置项详解

SQLite（默认配置）

PostgreSQL

MySQL

Oracle

3. 多环境配置策略

发表评论

相关推荐

python习题

SciPy

高并发秒杀系统设计实践