从零创建一个 Django 项目

1. 预备环境

在开始之前，确保你的开辟环境满足以下要求：

• 安装了 Python (推荐 3.8 或更高版本)。
  
• 安装 pip 包管理工具。
  
• 如果要使用 MySQL 或 PostgreSQL，确保对应的数据库已安装。
  

创建虚拟环境

在项目目录中创建并激活虚拟环境，保证项目依赖隔离：

1. # 创建虚拟环境
2. python -m venv env
4. # 激活虚拟环境
5. # Windows
6. envScriptsactivate
7. # Linux/Mac
8. source env/bin/activate

复制代码

---

2. 安装 Django 和数据库驱动

在激活的虚拟环境中安装 Django：

1. pip install django

复制代码

如果使用 MySQL 或 PostgreSQL，还必要安装相应的驱动：

• MySQL: 安装 mysqlclient:
  
  1. pip install mysqlclient

  复制代码
• PostgreSQL: 安装 psycopg2:
  
  1. pip install psycopg2-binary

  复制代码

如果只是使用 SQLite，Django 默认支持，无需额外安装。

---

3. 创建 Django 项目

使用 django-admin 创建一个新的项目：

1. django-admin startproject myproject

复制代码

项目布局

创建后，项目的根本布局如下：

1. myproject/
2.     manage.py         # 项目管理脚本
3.     myproject/
4.         __init__.py   # 包标识
5.         settings.py   # 项目设置
6.         urls.py       # URL 配置
7.         asgi.py       # ASGI 配置
8.         wsgi.py       # WSGI 配置

复制代码

---

4. 设置数据库

打开 myproject/myproject/settings.py，找到 DATABASES 设置项，根据数据库范例修改设置：
默认的 SQLite 设置

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

复制代码

使用 MySQL

如果你使用 MySQL，修改为：

1. DATABASES = {
2.     'default': {
3.         'ENGINE': 'django.db.backends.mysql',
4.         'NAME': 'your_database_name',
5.         'USER': 'your_database_user',
6.         'PASSWORD': 'your_database_password',
7.         'HOST': 'localhost',  # 数据库主机地址，通常是 localhost
8.         'PORT': '3306',       # MySQL 默认端口
9.     }
10. }

复制代码

使用 PostgreSQL

如果你使用 PostgreSQL，修改为：

1. DATABASES = {
2.     'default': {
3.         'ENGINE': 'django.db.backends.postgresql',
4.         'NAME': 'your_database_name',
5.         'USER': 'your_database_user',
6.         'PASSWORD': 'your_database_password',
7.         'HOST': 'localhost',  # 数据库主机地址，通常是 localhost
8.         'PORT': '5432',       # PostgreSQL 默认端口
9.     }
10. }

复制代码

---

5. 创建 Django 应用

在项目目录中创建一个新的 Django 应用：

1. python manage.py startapp myapp

复制代码

应用布局

创建后，应用的布局如下：

1. myapp/
2.     migrations/         # 数据库迁移文件目录
3.         __init__.py
4.     __init__.py         # 包标识
5.     admin.py            # 管理后台配置
6.     apps.py             # 应用配置
7.     models.py           # 数据模型定义
8.     tests.py            # 单元测试
9.     views.py            # 视图函数

复制代码

---

6. 设置应用

打开 myproject/myproject/settings.py，在 INSTALLED_APPS 中添加你的新应用：

1. INSTALLED_APPS = [
2.     # Django 自带的应用
3.     'django.contrib.admin',
4.     'django.contrib.auth',
5.     'django.contrib.contenttypes',
6.     'django.contrib.sessions',
7.     'django.contrib.messages',
8.     'django.contrib.staticfiles',
10.     # 你的应用
11.     'myapp',
12. ]

复制代码

---

7. 创建模子并生成数据库表

在 myapp/models.py 中定义数据模子。比方：

1. from django.db import models
3. class Lesson(models.Model):
4.     id = models.CharField(max_length=20, primary_key=True)
5.     name = models.CharField(max_length=50)
7.     def __str__(self):
8.         return self.name

复制代码

生成迁徙文件

运行以下命令生成迁徙文件：

1. python manage.py makemigrations

复制代码

Django 会检测到模子更改并生成迁徙文件，比方：

1. Migrations for 'myapp':
2.   myapp/migrations/0001_initial.py
3.     - Create model Lesson

复制代码

应用迁徙文件

运行以下命令将迁徙文件应用到数据库，生成表布局：

1. python manage.py migrate

复制代码

生成并应用迁徙文件的目的

• 将模子定义和数据库表布局同步，确保模子中的字段和属性能够在数据库中对应为实际的表和列；
  

迁徙文件的作用

• 迁徙文件是 Django 提供的一种机制，用于跟踪和记录数据模子的变化，然后将这些变化应用到数据库中。
  
• **作用1：**将模子转换为数据库表； （在 models.py 中定义的模子只是 Python 的类，它们形貌了表的布局（如字段、范例、束缚等），但它们并不会自动创建数据库中的实际表。）
  
  
  
  • 迁徙文件将这些模子转化为一组可以执行的指令（SQL 语句），以在数据库中创建实际的表。
    
  
  
• 举例： 在models.py中定义
  from django.db import models
  class User(models.Model):
  id = models.AutoField(primary_key=True)
  username = models.CharField(max_length=100)
  email = models.EmailField()
  
• 迁徙文件会生成相应的SQL语句；
  CREATE TABLE user (
  id INT AUTO_INCREMENT PRIMARY KEY,
  username VARCHAR(100) NOT NULL,
  email VARCHAR(254) NOT NULL
  );
  
• **作用2：**跟踪和管理模子的变更； （当你对 models.py 中的模子做出修改（如新增字段、修改字段范例、删除字段等）时，Django 会通过迁徙文件记录这些变化。）应用迁徙文件后，Django 会将这些更改同步到数据库中，而不会丢失现有数据。
  
• 举例：假设你为User模子添加了一个新的字段age
  age = models.IntegerField(default=18)
  
• 生成迁徙文件以后，Django会创建一个指令来添加字段；
  ALTER TABLE user ADD COLUMN age INT NOT NULL DEFAULT 18;
  
• **作用3：**管理多开辟者协作中的数据库一致性； （在多人开辟时，每个开辟者可能对模子进行不同的更改，通过迁徙文件可以记录这些更改，并在团队中共享。迁徙文件以增量的形式记录每次更改，确保所有开辟者和环境中的数据库表布局保持一致。）
  

8. 运行开辟服务器

使用以下命令启动 Django 开辟服务器：

1. python manage.py runserver

复制代码

打开欣赏器访问 http://127.0.0.1:8000/ 以查看项目是否正常运行。

---

9. 添加管理后台支持

如果必要通过 Django 的管理后台管理数据库，可以为模子添加管理支持。
注册模子

打开 myapp/admin.py，注册模子：

1. from django.contrib import admin
2. from .models import Lesson
4. admin.site.register(Lesson)

复制代码

创建超级用户

运行以下命令创建管理员账户：

1. python manage.py createsuperuser

复制代码

按照提示输入用户名、邮箱和暗码。
访问管理后台

启动开辟服务器后，访问 http://127.0.0.1:8000/admin，使用管理员账户登录即可管理数据库中的数据。

---

10. 测试操作数据库

可以通过 manage.py shell 交互式操作数据库：

1. python manage.py shell

复制代码

在交互环境中：

1. from myapp.models import Lesson
3. # 创建记录
4. lesson = Lesson.objects.create(id='1', name='Django Basics')
6. # 查询记录
7. lesson = Lesson.objects.get(id='1')
8. print(lesson.name)
10. # 更新记录
11. lesson.name = 'Advanced Django'
12. lesson.save()
14. # 删除记录
15. lesson.delete()

复制代码

---

总结

通过以上步骤，你可以从零创建一个 Django 项目，并设置数据库支持。核心流程包罗：

• 安装 Django 和数据库驱动。
  
• 设置数据库毗连。
  
• 创建应用和模子。
  
• 生成并应用迁徙文件。
  
• 运行开辟服务器并使用 Django 提供的管理后台。
  

项目布局解读

env文件夹

• 概念；env 文件夹是一个 虚拟环境 的文件夹。
  
• 什么是虚拟环境？【虚拟环境是 Python 提供的一种工具，用于隔离项目的依赖。它允许你在每个项目中独立安装 Python 包，而不会干扰全局 Python 环境或其他项目的依赖。】
  
• 为什么必要虚拟环境？
  
  
  
  • 依赖隔离：每个项目可能必要不同版本的库，如果不使用虚拟环境，可能会导致版本辩论。
    
  • 防止污染全局环境：全局环境中的库安装可能会影响其他项目的正常运行。
    
  
  
• env文件夹的作用
  
  
  
  • 环境隔离：当你激活虚拟环境时，所有安装的依赖包（如 Django）都被存储在 env 文件夹中。
    
  • 存储依赖包：比方，你安装的 Django 和 MySQL 驱动等依赖，都会存储在 env/Lib/site-packages 下。
    
  
  
• 激活虚拟环境（window）
  envScriptsactivate
  
• 激活虚拟环境（Linux/Mac）
  source env/bin/activate
  
• 关闭虚拟环境
  deactivate
  

项目目录布局以及Django项目开辟留意点

1. myproject/
2.     manage.py
3.     myproject/
4.         __init__.py
5.         settings.py
6.         urls.py
7.         asgi.py
8.         wsgi.py
9.     myapp/
10.         migrations/
11.         __init__.py
12.         admin.py
13.         apps.py
14.         models.py
15.         tests.py
16.         views.py

复制代码

manage.py

• 概念；manage.py 是 Django 项目的入口点。它是一个命令行工具，允许你管理项目（如运行开辟服务器、数据库迁徙等）。常见的命令包罗：
  
• 启动开辟服务器
  python manage.py runserver
  
  
• 创建数据库迁徙
  python manage.py makemigrations
  
  python manage.py migrate
  
  
• 创建超级用户
  python manage.py createsuperuser
  
  

myproject/（同名的文件夹）

• 概念；这个文件夹是Django项目的设置文件夹，它的名字和项目名一致
  
• settings.py：项目的核心设置文件，包罗数据库设置、已安装的应用、静态文件路径等。
  
• urls.py：项目的 URL 路由设置文件，用于将 URL 路径映射到对应的视图函数。
  
• asgi.py：ASGI（异步服务器网关接口）设置，用于支持异步请求处理。
  
• wsgi.py：WSGI（Web服务器网关接口）设置，用于部署 Django 项目到生产环境。
  

myapp（创建的应用目录）

• myapp/ 是你创建的应用目录。Django 项目可以包罗多个应用，每个应用负责不同的功能模块。
  
• 各文件的作用
  
  
  
  • models.py：定义数据模子（数据库表布局）。
    
  • views.py：处理用户的请求，并返反响应。
    
  • admin.py：设置管理后台（Django admin）。
    
  • apps.py：管理应用的设置信息。
    
  • migrations/：存储数据库迁徙文件，用于跟踪模子的变化。
    
  • tests.py：定义测试用例，用于自动化测试。
    
  • init: 标识这是一个Python包； （文件夹可以被 Python 识别为模块）
    
  
  

为什么 myproject 文件夹下有一个和项目同名的文件夹？

• 这是Django项目默认的目录布局
  
  
  
  • 最外层的 myproject/ 是项目的根目录，存放项目入口点 manage.py 和其他项目相关的文件。
    
  • 内层的 myproject/ 是项目的 设置文件夹，存放项目的设置（如 settings.py、urls.py 等）。
    
  
  
• 如许计划的目的
  
  
  
  • Django 如许计划的原因是为了方便管理项目的全局文件和应用文件。分开这两层布局，可以更清晰地区分项目的设置文件和其他文件。
    
  
  

修改项目名称会影响哪些地方？

• 如果你必要修改项目名称，内层文件夹（myproject）中的设置文件必要同步更新。比方：
  
  
  
  • asgi.py 和 wsgi.py 中引用的模块路径必要修改。
    
  • 项目运行时的模块路径也必要更新。
    
  
  

怎样添加更多的应用到项目中？

• Django 支持模块化的开辟，可以为项目添加多个应用，每个应用负责不同的功能。
  
• 创建新的应用；使用startapp命令创建新应用；比方
  python manage.py startapp blog
  
• 
  
  • 注册应用；将新应用注册到项目的 INSTALLED_APPS 中：
    
  settings.py
  
  INSTALLED_APPS = [
  # 默认应用
  ‘django.contrib.admin’,
  ‘django.contrib.auth’,
  ‘django.contrib.contenttypes’,
  ‘django.contrib.sessions’,
  ‘django.contrib.messages’,
  ‘django.contrib.staticfiles’,
  
  1. # 你的自定义应用
  2. 'myapp',
  3. 'blog',

  复制代码
  ]
  
  
• 
  
  • 添加URL路由；为新应用设置URL，比方，在新应用blog中创建urls.py
    
  blog/urls.py
  
  from django.urls import path
  from . import views
  urlpatterns = [
  path(‘’, views.index, name=‘index’), # 主页
  ]
  
  
• 
  
  • 在项目的urls.py中包罗这个应用的URL；
    
  myproject/urls.py
  
  from django.contrib import admin
  from django.urls import path, include
  urlpatterns = [
  path(‘admin/’, admin.site.urls),
  path(‘blog/’, include(‘blog.urls’)), # 包罗 blog 的路由
  ]
  
  

项目布局总结

• env 文件夹：是虚拟环境的文件夹，用于隔离项目依赖。
  
• 项目布局：
  
  
  
  • 外层 myproject/ 是根目录，存放入口文件（如 manage.py）。
    
  • 内层 myproject/ 是项目的设置文件夹，存放 settings.py 等设置。
    
  • myapp/ 是一个应用目录，你可以创建多个应用，每个应用负责不同的功能模块。
    
  
  
• 模块化开辟：
  
  
  
  • Django 项目可以包罗多个应用，通过 startapp 命令创建新应用，并通过 INSTALLED_APPS 注册到项目中。
    
  
  

编辑数据库时，是否必要书写models.py文件

1. 使用models.py的场景

• 在大多数环境下，推荐通过models.py 文件来定义和操作数据库，这是 Django 的核心功能之一。
  
• 优点
  
  
  
  • **ORM提供抽象层；**通过Django的ORM（对象关系映射），你可以直接使用Python类和方法操作数据库，而无需手写SQL；
    
  • **数据变更自动管理:**通过迁徙（migrations）功能，可以轻松跟踪和管理数据库布局的变更。
    
  • 代码可维护性强： models.py 中的类定义直接对应数据库表，代码更直观、更易维护。
    
  • **跨数据库支持：**通过 Django 的 ORM，同一套代码可以适配不同的数据库（如 SQLite、MySQL、PostgreSQL）。
    
  
  

2. 直接操作数据库的场景（无需models.py）

场景1：已有数据库表；

• 如果你的项目必要操作一个已有的数据库（非 Django 管理的表），你可以直接通过 SQL 或第三方库操作它，而不定义模子。
  
• 也可以使用Django的inspectdb功能自动生成模子；
  

场景2：复杂SQL查询

• 如果某些操作难以通过 ORM 实现（比方复杂的联表查询、多级嵌套查询等），可以直接使用 SQL 查询。
  

场景3：一次性脚本或数据迁徙

• 如果只是临时操作数据库（如迁徙数据、批量更新等），可以直接运行原生 SQL，而不必要定义模子。
  

使用Django操作数据库（编写接口）

• 目的：想要获取my_db_01数据库下的users表中的所有用户数据；
  

步骤1：在myproject文件夹下的settings.py文件中设置数据库信息

1. DATABASES = {
2.     'default': {
3.         'ENGINE': 'django.db.backends.mysql',  # 使用 MySQL 驱动
4.         'NAME': 'my_db_01',                   # 数据库名
5.         'USER': 'your_mysql_username',        # MySQL 用户名
6.         'PASSWORD': 'your_mysql_password',    # MySQL 密码
7.         'HOST': 'localhost',                  # 数据库主机，通常是 localhost
8.         'PORT': '3306',                       # MySQL 默认端口
9.     }
10. }

复制代码

步骤2：定义users表的范例； （方法一）

• Django中可以操作多个应用，
  
• 打开myapp/models.py，并定义User模子
  from django.db import models
  class User(models.Model):
  id = models.AutoField(primary_key=True) # 自增主键
  username = models.CharField(max_length=45) # 用户名
  password = models.CharField(max_length=45) # 暗码
  status = models.BooleanField(default=True) # 状态 (映射为 TINYINT(1))
  
  1. class Meta:
  2.     db_table = 'users'  # 映射到 MySQL 中的 users 表
  3.     managed = False     # 告诉 Django 不去管理（创建/迁移）此表

  复制代码

步骤3：编写视图获取所有用户信息；

• 在 myapp/views.py 中编写一个视图函数，用于获取 users 表的所有记录
  from django.http import JsonResponse
  from .models import User
  def get_all_users(request):
  try:
  # 查询所有用户
  users = User.objects.all().values(‘id’, ‘username’, ‘password’, ‘status’)
  users_list = list(users) # 转换为列表以便返回 JSON 响应
  return JsonResponse({‘status’: ‘success’, ‘data’: users_list}, safe=False)
  except Exception as e:
  return JsonResponse({‘status’: ‘error’, ‘message’: str(e)}, status=500)
  

步骤4：设置URL路由

• 在myapp/urls.py 中添加路由，让接口与视图函数关联；
  from django.urls import path
  from .views import get_all_users
  urlpatterns = [
  path(‘users/’, get_all_users, name=‘get_all_users’), # 绑定接口到视图函数
  ]
  
• 然后在主项目中的urls.py中包罗myapp路由即可；
  from django.urls import path
  from .views import get_all_users
  urlpatterns = [
  path(‘users/’, get_all_users, name=‘get_all_users’), # 绑定接口到视图函数
  ]
  

步骤5：测试接口（欣赏器/postman都可）

操作数据库的时候为啥没有直接书写SQL代码？

• 使用了Django ORM（对象关系映射，Object-Relational Mapping），它是 Django 提供的一个强大的抽象工具，用于取代直接写 SQL 语句来操作数据库。
  

Django ORM的工作原理；

• 模子与数据库表的映射；
  
  
  
  • 在 models.py 中定义的 User 模子，对应的是数据库中的 users 表。
    
  • **Django会根据模子自动生成SQL语句来增删改查数据库； **
    
  
  
• Django ORM 方法与 SQL 的关系
  
  
  
  • 当你使用 ORM 的方法（如 User.objects.all()）时，Django 会在内部转换成对应的 SQL 查询，并向数据库发送请求。你不必要手动书写 SQL，Django 会为你生成高效的 SQL 查询。
    
  
  
• 比方
  users = User.objects.all().values(‘id’, ‘username’, ‘password’, ‘status’)
  相称于sql
  
  SELECT id, username, password, status FROM users;
  

Django ORM的上风

• 提高开辟效率：通过 Python 代码实现数据库操作，无需手动编写 SQL。
  
• 跨数据库兼容性：同一段代码可以在不同数据库（如 SQLite、MySQL、PostgreSQL）上运行，Django 自动生成对应数据库的 SQL。
  
• 安全性：Django ORM 内部会自动处理一些常见的安全问题，如 SQL 注入。
  

使用raw() 方法来执行自定义SQL；

方法1，

• 如果必要执行更复杂的SQL查询（联表查询、子查询）， 可以使用raw()方法；
  from django.db import connection
  from .models import User
  def get_all_users_raw(request):
  with connection.cursor() as cursor:
  cursor.execute(“SELECT id, username, password, status FROM users”)
  rows = cursor.fetchall()
  users_list = [
  {‘id’: row[0], ‘username’: row[1], ‘password’: row[2], ‘status’: row[3]}
  for row in rows
  ]
  return JsonResponse({‘status’: ‘success’, ‘data’: users_list})
  

方法2；使用raw()和ORM

• 可以结合ORM的raw()方法来直接执行SQL查询；即将SQL语句直接放到raw()中， 具体效果如下：
  users = User.objects.raw(“SELECT id, username, password, status FROM users”)
  for user in users:
  print(user.username)
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。