Django is a fully featured Python web framework that can be used to build complex web applications. In this tutorial, you’ll jump in and learn Django by example. You’ll follow the steps to create a fully functioning web application and, along the way, learn some of the most important features of the framework and how they work together
In later posts in this series, you’ll see how to build more complex websites using even more of Django’s features than you’ll cover in this tutorial
By the end of this tutorial, you will be able to
- Understand what Django is and why it’s a great web framework
- Understand the architecture of a Django site and how it compares with other frameworks
- Set up a new Django project and app
- Build a Personal Portfolio Website with Django
Free Bonus. that shows you tips and tricks as well as common pitfalls to avoid when building Python + Django web applications
Why You Should Learn Django
There are endless web development frameworks out there, so why should you learn Django over any of the others? First of all, it’s written in Python, one of the most readable and beginner-friendly programming languages out there
Note. Hướng dẫn này giả định kiến thức trung cấp về ngôn ngữ Python. Nếu bạn là người mới lập trình với Python, hãy xem một số hướng dẫn dành cho người mới bắt đầu của chúng tôi hoặc khóa học giới thiệu
Lý do thứ hai bạn nên học Django là phạm vi tính năng của nó. Nếu bạn cần xây dựng một trang web, bạn không cần phải dựa vào bất kỳ thư viện hoặc gói bên ngoài nào nếu bạn chọn Django. Điều này có nghĩa là bạn không cần học cách sử dụng bất kỳ thứ gì khác và cú pháp liền mạch vì bạn chỉ sử dụng một khung
Ngoài ra còn có một lợi ích bổ sung là bạn không cần phải lo lắng rằng việc cập nhật một thư viện hoặc khung sẽ khiến những thư viện hoặc khung khác mà bạn đã cài đặt trở nên vô dụng
Nếu bạn thấy mình cần thêm các tính năng bổ sung, có nhiều thư viện bên ngoài mà bạn có thể sử dụng để nâng cao trang web của mình
Một trong những điều tuyệt vời về khung Django là tài liệu chuyên sâu của nó. Nó có tài liệu chi tiết về mọi khía cạnh của Django và cũng có các ví dụ tuyệt vời và thậm chí là hướng dẫn để bạn bắt đầu
Ngoài ra còn có một cộng đồng tuyệt vời gồm các nhà phát triển Django, vì vậy nếu bạn gặp khó khăn, hầu như luôn có cách để tiến lên bằng cách kiểm tra tài liệu hoặc hỏi cộng đồng
Django là một khung ứng dụng web cấp cao với vô số tính năng. Thật tuyệt vời cho bất kỳ ai mới phát triển web nhờ tài liệu tuyệt vời của nó và đặc biệt nếu bạn cũng quen thuộc với Python
Loại bỏ các quảng cáoCấu trúc của một trang web Django
Trang web Django bao gồm một dự án duy nhất được chia thành các ứng dụng riêng biệt. Ý tưởng là mỗi ứng dụng xử lý một chức năng độc lập mà trang web cần thực hiện. Ví dụ, hãy tưởng tượng một ứng dụng như Instagram. Có một số chức năng khác nhau cần được thực hiện
- quản lý người dùng. Đăng nhập, đăng xuất, đăng ký, v.v.
- The image feed. Uploading, editing, and displaying images
- Private messaging. Private messages between users and notifications
These are each separate pieces of functionality, so if this were a Django site, then each piece of functionality should be a different Django app inside a single Django project
The Django project holds some configurations that apply to the project as a whole, such as project settings, URLs, shared templates and static files. Each application can have its own database and has its own functions to control how the data is displayed to the user in HTML templates
Each application also has its own URLs as well as its own HTML templates and static files, such as JavaScript and CSS
Django apps are structured so that there is a separation of logic. It supports the Model-View-Controller Pattern, which is the architecture on which most web frameworks are built. The basic principle is that in each application there are three separate files that handle the three main pieces of logic separately
- Model defines the data structure. This is usually a database and is the base layer to an application
- View displays some or all of the data to the user with HTML and CSS
- Controller handles how the database and the view interact
If you want to learn more about the MVC pattern, then check out Model-View-Controller [MVC] Explained – With Legos
In Django, the architecture is slightly different. Although based upon the MVC pattern, Django handles the controller part itself. There’s no need to define how the database and views interact. It’s all done for you
The pattern Django utilizes is called the Model-View-Template [MVT] pattern. The view and template in the MVT pattern make up the view in the MVC pattern. All you need to do is add some URL configurations to map the views to, and Django handles the rest
A Django site starts off as a project and is built up with a number of applications that each handle separate functionality. Each app follows the Model-View-Template pattern. Now that you’re familiar with the structure of a Django site, let’s have a look at what you’re going to build
What You’re Going to Build
Before you get started with any web development project, it’s a good idea to come up with a plan of what you’re going to build. In this tutorial, we are going to build an application with the following features
A fully functioning blog. If you’re looking to demonstrate your coding ability, a blog is a great way to do that. In this application, you will be able to create, update, and delete blog posts. Posts will have categories that can be used to sort them. Finally, users will be able to leave comments on posts
A portfolio of your work. You can showcase previous web development projects here. You’ll build a gallery style page with clickable links to projects that you’ve completed
Note. Before you get started, you can pull down the source code and follow along with the tutorial
If you prefer to follow along by writing the code yourself, don’t worry. I’ve referenced the relevant parts of the source code throughout so you can refer back to it
We won’t be using any external Python libraries in this tutorial. One of the great things about Django is that it has so many features that you don’t need to rely on external libraries. However, we will add Bootstrap 4 styling in the templates
By building these two apps, you’ll learn the basics of Django models, view functions, forms, templates, and the Django admin page. With knowledge of these features, you’ll be able to go away and build loads more applications. You’ll also have the tools to learn even more and build sophisticated Django sites
Hello, World
Now that you know the structure of a Django application, and what you are about to build, we’re going to go through the process of creating an application in Django. You’ll extend this later into your personal portfolio application
Loại bỏ các quảng cáoSet Up Your Development Environment
Whenever you are starting a new web development project, it’s a good idea to first set up your development environment. Create a new directory for your project to live in, and
$ django-admin startproject personal_portfolio
$ mkdir rp-portfolio
$ cd rp-portfolio
Khi bạn đã ở trong thư mục chính, bạn nên tạo một môi trường ảo để quản lý các phụ thuộc. There are many different ways to set up virtual environments, but here you’re going to use
$ django-admin startproject personal_portfolio
$ python3 -m venv venv
This command will create a folder
$ django-admin startproject personal_portfolio
$ source venv/bin/activate
Note. If you’re not using bash shell, you might need to use a to activate your virtual environment. For example, on windows you need this command
C:\> venv\Scripts\activate.bat
You’ll know that your virtual environment has been activated, because your console prompt in the terminal will change. It should look something like this
[venv] $
Note. Your virtual environment directory doesn’t have to be called
$ django-admin startproject personal_portfolio
$ django-admin startproject personal_portfolio
$ django-admin startproject personal_portfolio
$ django-admin startproject personal_portfolio
Then, when activating your virtual environment, replace
$ django-admin startproject personal_portfolio
$ django-admin startproject personal_portfolio
rp-portfolio/
│
├── personal_portfolio/
│ ├── personal_portfolio/
│ │ ├── __init__.py
│ │ ├── settings.py
│ │ ├── urls.py
│ │ └── wsgi.py
│ │
│ └── manage.py
│
└── venv/
Now that you’ve created a virtual environment, it’s time to install Django. You can do this using
rp-portfolio/
│
├── personal_portfolio/
│ ├── personal_portfolio/
│ │ ├── __init__.py
│ │ ├── settings.py
│ │ ├── urls.py
│ │ └── wsgi.py
│ │
│ └── manage.py
│
└── venv/
[venv] $ pip install Django
Once you’ve set up the virtual environment and installed Django, you can now dive in to creating the application
Create a Django Project
As you saw in the previous section, a Django web application is made up of a project and its constituent apps. Making sure you’re in the
rp-portfolio/
│
├── personal_portfolio/
│ ├── personal_portfolio/
│ │ ├── __init__.py
│ │ ├── settings.py
│ │ ├── urls.py
│ │ └── wsgi.py
│ │
│ └── manage.py
│
└── venv/
$ django-admin startproject personal_portfolio
Thao tác này sẽ tạo một thư mục mới
rp-portfolio/
│
├── personal_portfolio/
│ ├── personal_portfolio/
│ │ ├── __init__.py
│ │ ├── settings.py
│ │ ├── urls.py
│ │ └── wsgi.py
│ │
│ └── manage.py
│
└── venv/
$ django-admin startproject personal_portfolio
rp-portfolio/
│
├── personal_portfolio/
│ ├── personal_portfolio/
│ │ ├── __init__.py
│ │ ├── settings.py
│ │ ├── urls.py
│ │ └── wsgi.py
│ │
│ └── manage.py
│
└── venv/
rp-portfolio/
│
├── personal_portfolio/
│ ├── personal_portfolio/
│ │ ├── __init__.py
│ │ ├── settings.py
│ │ ├── urls.py
│ │ └── wsgi.py
│ │
│ └── manage.py
│
└── venv/
rp-portfolio/
│
├── personal_portfolio/
│ ├── personal_portfolio/
│ │ ├── __init__.py
│ │ ├── settings.py
│ │ ├── urls.py
│ │ └── wsgi.py
│ │
│ └── manage.py
│
└── venv/
Hầu hết công việc bạn làm sẽ nằm trong thư mục
rp-portfolio/
│
├── personal_portfolio/
│ ├── personal_portfolio/
│ │ ├── __init__.py
│ │ ├── settings.py
│ │ ├── urls.py
│ │ └── wsgi.py
│ │
│ └── manage.py
│
└── venv/
$ django-admin startproject personal_portfolio
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
Bạn nên kết thúc với một cái gì đó như thế này
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
Khi cấu trúc tệp của bạn được thiết lập, bây giờ bạn có thể khởi động máy chủ và kiểm tra xem thiết lập của bạn đã thành công chưa. Trong bảng điều khiển, hãy chạy lệnh sau
$ python3 -m venv venv
Sau đó, trong trình duyệt của bạn, hãy truy cập vào
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
Xin chúc mừng, bạn đã tạo một trang web Django. Mã nguồn cho phần này của hướng dẫn có thể được tìm thấy trên GitHub. Bước tiếp theo là tạo ứng dụng để bạn có thể thêm chế độ xem và chức năng cho trang web của mình
Loại bỏ các quảng cáoTạo một ứng dụng Django
Đối với phần hướng dẫn này, chúng ta sẽ tạo một ứng dụng có tên là
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
To create the app, run the following command
$ python3 -m venv venv
Thao tác này sẽ tạo một thư mục khác có tên là
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
4 yêu cầu Python coi thư mục là một gói Python$ mv personal_portfolio/manage.py ./ $ mv personal_portfolio/personal_portfolio/* personal_portfolio $ rm -r personal_portfolio/personal_portfolio/
5 chứa cài đặt cho các trang quản trị Django$ mv personal_portfolio/manage.py ./ $ mv personal_portfolio/personal_portfolio/* personal_portfolio $ rm -r personal_portfolio/personal_portfolio/
6 chứa các cài đặt cho cấu hình ứng dụng$ mv personal_portfolio/manage.py ./ $ mv personal_portfolio/personal_portfolio/* personal_portfolio $ rm -r personal_portfolio/personal_portfolio/
7 chứa một loạt các lớp mà ORM của Django chuyển đổi thành các bảng cơ sở dữ liệu$ mv personal_portfolio/manage.py ./ $ mv personal_portfolio/personal_portfolio/* personal_portfolio $ rm -r personal_portfolio/personal_portfolio/
8 chứa các lớp kiểm tra$ mv personal_portfolio/manage.py ./ $ mv personal_portfolio/personal_portfolio/* personal_portfolio $ rm -r personal_portfolio/personal_portfolio/
9 chứa các hàm và lớp xử lý dữ liệu nào được hiển thị trong các mẫu HTML$ mv personal_portfolio/manage.py ./ $ mv personal_portfolio/personal_portfolio/* personal_portfolio $ rm -r personal_portfolio/personal_portfolio/
Khi bạn đã tạo ứng dụng, bạn cần cài đặt nó trong dự án của mình. Trong
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ python3 -m venv venv
Dòng mã đó có nghĩa là dự án của bạn hiện biết rằng ứng dụng bạn vừa tạo đã tồn tại. Bước tiếp theo là tạo chế độ xem để bạn có thể hiển thị nội dung nào đó cho người dùng
Tạo một Chế độ xem
Chế độ xem trong Django là tập hợp các hàm hoặc lớp bên trong tệp
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
Điều hướng đến tệp
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ python3 -m venv venv
Trong đoạn mã này, bạn đã định nghĩa một hàm xem có tên là
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
Hàm xem nhận một đối số,
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ python3 -m venv venv
$ python3 -m venv venv
Bây giờ bạn đã tạo chức năng xem, bạn cần tạo mẫu HTML để hiển thị cho người dùng.
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ python3 -m venv venv
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ python3 -m venv venv
Thêm các dòng HTML sau vào tệp của bạn
$ python3 -m venv venv
Bây giờ bạn đã tạo một hàm để xử lý các dạng xem và mẫu của mình để hiển thị cho người dùng. Bước cuối cùng là kết nối các URL của bạn để bạn có thể truy cập trang bạn vừa tạo. Dự án của bạn có một mô-đun có tên là
$ python3 -m venv venv
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ python3 -m venv venv
$ python3 -m venv venv
Điều này tìm kiếm một mô-đun có tên là
$ python3 -m venv venv
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ python3 -m venv venv
$ python3 -m venv venv
Bên trong mô-đun này, chúng ta cần nhập đối tượng đường dẫn cũng như mô-đun
$ python3 -m venv venv
$ python3 -m venv venv
Bây giờ, khi bạn khởi động lại máy chủ và truy cập vào
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
Xin chúc mừng, một lần nữa. Bạn đã tạo ứng dụng Django đầu tiên của mình và kết nối nó với dự án của bạn. Đừng quên kiểm tra mã nguồn của phần này và phần trước. Vấn đề duy nhất bây giờ là nó trông không đẹp lắm. Trong phần tiếp theo, chúng tôi sẽ thêm các kiểu bootstrap vào dự án của bạn để làm cho nó đẹp hơn
Loại bỏ các quảng cáoThêm Bootstrap vào ứng dụng của bạn
Nếu bạn không thêm bất kỳ kiểu dáng nào, thì ứng dụng bạn tạo sẽ trông không đẹp lắm. Thay vì đi sâu vào tạo kiểu CSS với hướng dẫn này, chúng tôi sẽ chỉ giới thiệu cách thêm kiểu bootstrap vào dự án của bạn. Điều này sẽ cho phép chúng tôi cải thiện giao diện của trang web mà không cần nỗ lực quá nhiều
Trước khi bắt đầu với các kiểu Bootstrap, chúng tôi sẽ tạo một mẫu cơ sở mà chúng tôi có thể nhập vào từng chế độ xem tiếp theo. Mẫu này là nơi sau đó chúng tôi sẽ thêm nhập kiểu Bootstrap
Tạo một thư mục khác có tên là
$ python3 -m venv venv
rp-portfolio/
│
├── personal_portfolio/
│ ├── personal_portfolio/
│ │ ├── __init__.py
│ │ ├── settings.py
│ │ ├── urls.py
│ │ └── wsgi.py
│ │
│ └── manage.py
│
└── venv/
$ python3 -m venv venv
$ python3 -m venv venv
Chúng tôi tạo thư mục mẫu bổ sung này để lưu trữ các mẫu HTML sẽ được sử dụng trong mọi ứng dụng Django trong dự án. Như bạn đã thấy trước đây, mỗi dự án Django có thể bao gồm nhiều ứng dụng xử lý logic riêng biệt và mỗi ứng dụng chứa thư mục
$ python3 -m venv venv
Cấu trúc ứng dụng này hoạt động tốt đối với logic mặt sau, nhưng chúng tôi muốn toàn bộ trang web của mình trông nhất quán ở mặt trước. Thay vì phải nhập các kiểu Bootstrap vào mọi ứng dụng, chúng tôi có thể tạo một mẫu hoặc bộ mẫu được chia sẻ bởi tất cả các ứng dụng. Miễn là Django biết tìm kiếm các mẫu trong thư mục dùng chung mới này, nó có thể lưu rất nhiều kiểu lặp lại
Bên trong tệp mới này [
$ python3 -m venv venv
$ source venv/bin/activate
Bây giờ, trong
$ python3 -m venv venv
$ source venv/bin/activate
Điều xảy ra ở đây là bất kỳ HTML nào bên trong khối
$ python3 -m venv venv
$ python3 -m venv venv
Để cài đặt Bootstrap trong ứng dụng của bạn, bạn sẽ sử dụng. Đây là một cách thực sự đơn giản để cài đặt Bootstrap, chỉ cần thêm một vài dòng mã vào
$ python3 -m venv venv
Tất cả các mẫu trong tương lai mà chúng tôi tạo sẽ mở rộng
$ python3 -m venv venv
Trước khi chúng tôi có thể thấy ứng dụng theo phong cách mới của mình, chúng tôi cần thông báo cho dự án Django của mình rằng
$ python3 -m venv venv
$ python3 -m venv venv
$ python3 -m venv venv
$ python3 -m venv venv
$ source venv/bin/activate
Bây giờ, khi bạn truy cập vào
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
Bất cứ khi nào bạn muốn tạo mẫu hoặc nhập tập lệnh mà bạn định sử dụng trong tất cả các ứng dụng Django của mình bên trong một dự án, bạn có thể thêm chúng vào thư mục cấp dự án này và mở rộng chúng bên trong các mẫu ứng dụng của bạn
Thêm mẫu là giai đoạn cuối cùng để xây dựng Hello, World của bạn. trang Django. Bạn đã tìm hiểu cách thức hoạt động của công cụ tạo khuôn mẫu Django và cách tạo các mẫu cấp dự án có thể được chia sẻ bởi tất cả các ứng dụng bên trong dự án Django của bạn
In this section, you learned how to create a simple Hello, World. Trang web Django bằng cách tạo một dự án với một ứng dụng duy nhất. Trong phần tiếp theo, bạn sẽ tạo một ứng dụng khác để giới thiệu các dự án phát triển web và bạn sẽ tìm hiểu tất cả về các mô hình trong Django
Mã nguồn cho phần này có thể được tìm thấy trên GitHub
Loại bỏ các quảng cáoGiới thiệu dự án của bạn
Bất kỳ nhà phát triển web nào muốn tạo danh mục đầu tư đều cần một cách để thể hiện các dự án mà họ đã thực hiện. Đó là những gì bạn sẽ xây dựng bây giờ. Bạn sẽ tạo một ứng dụng Django khác có tên là
$ python3 -m venv venv
Trước khi chúng tôi xây dựng ứng dụng
$ python3 -m venv venv
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ python3 -m venv venv
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ python3 -m venv venv
$ source venv/bin/activate
Cuối cùng, bạn cần xóa đường dẫn URL được tạo trong
$ python3 -m venv venv
$ source venv/bin/activate
Bây giờ bạn đã xóa ứng dụng
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ python3 -m venv venv
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ source venv/bin/activate
Thao tác này sẽ tạo một thư mục có tên
$ python3 -m venv venv
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ python3 -m venv venv
$ source venv/bin/activate
Kiểm tra mã nguồn cho phần này trên GitHub. Chúng tôi sẽ không lo lắng về các URL cho ứng dụng này. Thay vào đó, chúng tôi sẽ tập trung vào việc xây dựng một mô hình
$ python3 -m venv venv
ứng dụng dự án. người mẫu
Nếu bạn muốn lưu trữ dữ liệu để hiển thị trên một trang web, thì bạn sẽ cần một cơ sở dữ liệu. Thông thường, nếu bạn muốn tạo cơ sở dữ liệu với các bảng và cột trong các bảng đó, bạn sẽ cần sử dụng SQL để quản lý cơ sở dữ liệu. Nhưng khi bạn sử dụng Django, bạn không cần phải học một ngôn ngữ mới vì nó đã được tích hợp sẵn Trình ánh xạ quan hệ đối tượng [ORM]
ORM là một chương trình cho phép bạn tạo các lớp tương ứng với các bảng cơ sở dữ liệu. Các thuộc tính của lớp tương ứng với các cột và các thể hiện của các lớp tương ứng với các hàng trong cơ sở dữ liệu. Vì vậy, thay vì học một ngôn ngữ hoàn toàn mới để tạo cơ sở dữ liệu và các bảng của nó, chúng ta chỉ cần viết một số lớp Python
Khi bạn đang sử dụng ORM, các lớp bạn xây dựng đại diện cho các bảng cơ sở dữ liệu được gọi là các mô hình. Ở Django, chúng sống trong mô-đun
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
Trong ứng dụng dự án của bạn, bạn sẽ chỉ cần một bảng để lưu trữ các dự án khác nhau mà bạn sẽ hiển thị cho người dùng. Điều đó có nghĩa là bạn sẽ chỉ cần tạo một mô hình trong
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
Mô hình bạn sẽ tạo sẽ được gọi là
$ python3 -m venv venv
49 sẽ là một trường chuỗi ngắn chứa tên dự án của bạn$ python3 -m venv venv
50 sẽ là trường chuỗi lớn hơn để chứa đoạn văn bản dài hơn$ python3 -m venv venv
51 sẽ là một trường chuỗi, nhưng nội dung của nó sẽ bị giới hạn ở một số lựa chọn được chọn$ python3 -m venv venv
52 sẽ là trường hình ảnh chứa đường dẫn tệp nơi hình ảnh được lưu trữ$ python3 -m venv venv
Để tạo mô hình này, chúng tôi sẽ tạo một lớp mới trong
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ source venv/bin/activate
Các mô hình Django đi kèm với nhiều loại trường mô hình tích hợp. Chúng tôi chỉ sử dụng ba trong mô hình này.
$ python3 -m venv venv
$ python3 -m venv venv
$ python3 -m venv venv
$ python3 -m venv venv
Bây giờ chúng ta đã tạo xong lớp
$ python3 -m venv venv
Để bắt đầu quá trình tạo cơ sở dữ liệu của chúng tôi, chúng tôi cần tạo một di chuyển. Di chuyển là một tệp chứa lớp
$ python3 -m venv venv
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ source venv/bin/activate
Bạn sẽ thấy rằng một tệp
$ python3 -m venv venv
Bây giờ bạn đã tạo một tệp di chuyển, bạn cần áp dụng các thao tác di chuyển được nêu trong tệp di chuyển và tạo cơ sở dữ liệu của bạn bằng cách sử dụng lệnh
$ python3 -m venv venv
$ source venv/bin/activate
Ghi chú. Khi chạy cả hai lệnh
$ python3 -m venv venv
$ python3 -m venv venv
$ python3 -m venv venv
$ python3 -m venv venv
Nếu bạn chạy
$ python3 -m venv venv
$ python3 -m venv venv
$ python3 -m venv venv
Bạn cũng sẽ thấy rằng một tệp có tên
$ python3 -m venv venv
Để tạo các thể hiện của lớp
$ python3 -m venv venv
C:\> venv\Scripts\activate.bat
Khi bạn đã truy cập trình bao, bạn sẽ nhận thấy rằng dấu nhắc lệnh sẽ thay đổi từ
$ python3 -m venv venv
$ python3 -m venv venv
>>>
C:\> venv\Scripts\activate.bat
We’re first going to create a new project with the following attributes
74.$ python3 -m venv venv
75$ python3 -m venv venv
50.$ python3 -m venv venv
77$ python3 -m venv venv
51.$ python3 -m venv venv
79$ python3 -m venv venv
52.$ python3 -m venv venv
81$ python3 -m venv venv
Để làm điều này, chúng ta tạo một thể hiện của lớp Project trong Django shell
>>>
C:\> venv\Scripts\activate.bat
Điều này tạo ra một mục mới trong bảng dự án của bạn và lưu nó vào cơ sở dữ liệu. Bây giờ bạn đã tạo một dự án mà bạn có thể hiển thị trên trang danh mục đầu tư của mình
Bước cuối cùng trong phần này là tạo thêm hai dự án mẫu
>>>
C:\> venv\Scripts\activate.bat
Làm tốt lắm vì đã đi đến cuối phần này. Bây giờ bạn đã biết cách tạo các mô hình trong Django và xây dựng các tệp di chuyển để bạn có thể dịch các lớp mô hình này thành các bảng cơ sở dữ liệu. Bạn cũng đã sử dụng trình bao Django để tạo ba phiên bản của lớp mô hình của mình
Trong phần tiếp theo, chúng tôi sẽ lấy ba dự án bạn đã tạo này và tạo chức năng xem để hiển thị chúng cho người dùng trên trang web. Bạn có thể tìm mã nguồn cho phần hướng dẫn này trên GitHub
Loại bỏ các quảng cáoứng dụng dự án. Lượt xem
Bây giờ bạn đã tạo các dự án để hiển thị trên trang danh mục đầu tư của mình, bạn sẽ cần tạo các chức năng xem để gửi dữ liệu từ cơ sở dữ liệu đến các mẫu HTML
Trong ứng dụng
$ python3 -m venv venv
- Chế độ xem chỉ mục hiển thị một đoạn thông tin về từng dự án
- Chế độ xem chi tiết hiển thị thêm thông tin về một chủ đề cụ thể
Hãy bắt đầu với chế độ xem chỉ mục, vì logic đơn giản hơn một chút. Bên trong
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ python3 -m venv venv
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ python3 -m venv venv
$ python3 -m venv venv
$ python3 -m venv venv
C:\> venv\Scripts\activate.bat
Có khá nhiều thứ đang diễn ra trong khối mã này, vì vậy hãy chia nhỏ nó ra
Trong dòng 5, bạn thực hiện một truy vấn. Truy vấn chỉ đơn giản là một lệnh cho phép bạn tạo, truy xuất, cập nhật hoặc xóa đối tượng [hoặc hàng] trong cơ sở dữ liệu của mình. Trong trường hợp này, bạn đang truy xuất tất cả các đối tượng trong bảng
$ python3 -m venv venv
Truy vấn cơ sở dữ liệu trả về một tập hợp tất cả các đối tượng khớp với truy vấn, được gọi là Bộ truy vấn. Trong trường hợp này, bạn muốn có tất cả các đối tượng trong bảng, vì vậy nó sẽ trả về một tập hợp tất cả các dự án
Trong dòng 6 của khối mã trên, chúng tôi định nghĩa một từ điển
$ python3 -m venv venv
$ python3 -m venv venv
Ở dòng 9,
$ python3 -m venv venv
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ python3 -m venv venv
$ python3 -m venv venv
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ python3 -m venv venv
Chúng tôi cũng kết xuất một mẫu có tên
$ python3 -m venv venv
Tiếp theo, bạn sẽ cần tạo hàm xem
$ python3 -m venv venv
Mặt khác, logic là tương tự
C:\> venv\Scripts\activate.bat
Trong dòng 14, chúng tôi thực hiện một truy vấn khác. Truy vấn này truy xuất dự án với khóa chính,
$ source venv/bin/activate
$ python3 -m venv venv
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ source venv/bin/activate
Khi các chức năng xem của bạn được tạo, chúng tôi cần kết nối chúng với các URL. Chúng tôi sẽ bắt đầu bằng cách tạo một tệp
$ source venv/bin/activate
C:\> venv\Scripts\activate.bat
Trong dòng 5, chúng tôi kết nối URL gốc của ứng dụng với chế độ xem
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
Giá trị
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
Với những cái hiện đã được thiết lập, chúng tôi cần nối các URL này với các URL của dự án. Trong
$ python3 -m venv venv
C:\> venv\Scripts\activate.bat
Dòng mã này bao gồm tất cả các URL trong ứng dụng dự án nhưng có nghĩa là chúng được truy cập khi có tiền tố là
$ source venv/bin/activate
16. Trang chỉ mục dự án$ source venv/bin/activate
17. The detail view for the project with$ source venv/bin/activate
18$ source venv/bin/activate
Các URL này vẫn không hoạt động bình thường vì chúng tôi không có bất kỳ mẫu HTML nào. Nhưng các chế độ xem và logic của chúng tôi đang hoạt động nên tất cả những gì còn lại phải làm là tạo các mẫu đó. Nếu bạn muốn kiểm tra mã của mình, hãy xem mã nguồn của phần này
Loại bỏ các quảng cáoứng dụng dự án. mẫu
Phù. Bạn sắp hoàn thành với ứng dụng này. Bước cuối cùng của chúng tôi là tạo hai mẫu
- Mẫu
05$ source venv/bin/activate - Mẫu
06$ source venv/bin/activate
Vì chúng tôi đã thêm các kiểu Bootstrap vào ứng dụng của mình, chúng tôi có thể sử dụng một số thành phần được tạo kiểu sẵn để làm cho chế độ xem đẹp mắt. Hãy bắt đầu với mẫu
$ source venv/bin/activate
Đối với mẫu
$ source venv/bin/activate
Chúng tôi không muốn phải tạo 100 thẻ Bootstrap khác nhau và mã hóa cứng tất cả thông tin cho từng dự án. Thay vào đó, chúng tôi sẽ sử dụng một tính năng của công cụ mẫu Django. cho các vòng lặp
Sử dụng tính năng này, bạn sẽ có thể lặp lại tất cả các dự án và tạo thẻ cho từng dự án. Cú pháp vòng lặp for trong công cụ mẫu Django như sau
C:\> venv\Scripts\activate.bat
Bây giờ bạn đã biết cách thức hoạt động của vòng lặp for, bạn có thể thêm đoạn mã sau vào tệp có tên
$ source venv/bin/activate
C:\> venv\Scripts\activate.bat
Có rất nhiều Bootstrap HTML ở đây, đây không phải là trọng tâm của hướng dẫn này. Vui lòng sao chép và dán và xem tài liệu Bootstrap nếu bạn muốn tìm hiểu thêm. Thay vì tập trung vào Bootstrap, có một số điều cần làm nổi bật trong khối mã này
Trong dòng 1, chúng tôi mở rộng
$ python3 -m venv venv
$ python3 -m venv venv
Ở dòng 2, chúng tôi bao gồm thẻ
$ source venv/bin/activate
$ python3 -m venv venv
Django tự động đăng ký các tệp tĩnh được lưu trữ trong thư mục có tên
$ source venv/bin/activate
$ source venv/bin/activate
Khi tải các tệp tĩnh, Django tìm trong thư mục
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
Ở dòng 6, chúng ta bắt đầu vòng lặp for, lặp qua tất cả các dự án được đưa vào bởi từ điển
$ python3 -m venv venv
Bên trong vòng lặp for này, chúng ta có thể truy cập từng dự án riêng lẻ. Để truy cập các thuộc tính của dự án, bạn có thể sử dụng ký hiệu dấu chấm bên trong dấu ngoặc nhọn kép. Ví dụ: để truy cập tiêu đề của dự án, bạn sử dụng
$ source venv/bin/activate
Trên dòng 9, chúng tôi bao gồm hình ảnh dự án của chúng tôi. Bên trong thuộc tính
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
Điểm cuối cùng mà chúng ta cần làm nổi bật là liên kết trên dòng 13. Đây là liên kết đến trang
$ source venv/bin/activate
[venv] $
Trong trường hợp này, chúng tôi đang truy cập một đường dẫn URL có tên
$ source venv/bin/activate
$ source venv/bin/activate
Với tất cả những thứ đó, nếu bạn khởi động máy chủ Django và truy cập vào
$ source venv/bin/activate
Với mẫu
$ python3 -m venv venv
$ source venv/bin/activate
[venv] $
Mã trong mẫu này có chức năng giống như từng thẻ dự án trong mẫu
$ python3 -m venv venv
Nếu bạn truy cập
$ source venv/bin/activate
Trong phần này, bạn đã học cách sử dụng các mô hình, dạng xem và mẫu để tạo một ứng dụng hoạt động đầy đủ cho dự án danh mục đầu tư cá nhân của mình. Kiểm tra mã nguồn cho phần này trên GitHub
Trong phần tiếp theo, bạn sẽ xây dựng một blog hoạt động đầy đủ cho trang web của mình và bạn cũng sẽ tìm hiểu về trang quản trị Django và các biểu mẫu
Loại bỏ các quảng cáoChia sẻ kiến thức của bạn với một blog
Blog là một bổ sung tuyệt vời cho bất kỳ trang web danh mục đầu tư cá nhân nào. Cho dù bạn cập nhật nó hàng tháng hay hàng tuần, đó là một nơi tuyệt vời để chia sẻ kiến thức của bạn khi bạn học. Trong phần này, bạn sẽ xây dựng một blog hoạt động đầy đủ cho phép bạn thực hiện các tác vụ sau
- Tạo, cập nhật và xóa bài đăng trên blog
- Hiển thị bài đăng cho người dùng dưới dạng chế độ xem chỉ mục hoặc chế độ xem chi tiết
- Chỉ định danh mục cho bài viết
- Cho phép người dùng bình luận về bài viết
You’ll also learn how to use the Django Admin interface, which is where you’ll create, update, and delete posts and categories as necessary
Trước khi bạn bắt đầu xây dựng chức năng của phần này trên trang web của mình, hãy tạo một ứng dụng Django mới có tên là
$ source venv/bin/activate
$ python3 -m venv venv
[venv] $
Bạn có thể bắt đầu cảm thấy quen thuộc vì đây là lần thứ ba bạn làm việc này. Đừng quên thêm
$ source venv/bin/activate
rp-portfolio/
│
├── personal_portfolio/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── venv/
│
└── manage.py
$ source venv/bin/activate
[venv] $
Tạm dừng việc kết nối các URL. Như với ứng dụng
$ python3 -m venv venv
ứng dụng blog. người mẫu
Tệp
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ python3 -m venv venv
Bạn sẽ cần ba bảng cơ sở dữ liệu riêng biệt cho blog
56$ source venv/bin/activate
57$ source venv/bin/activate
58$ source venv/bin/activate
Các bảng này cần phải được liên kết với nhau. Điều này được thực hiện dễ dàng hơn vì các mô hình Django đi kèm với các trường dành riêng cho mục đích này
Dưới đây là mã cho các mẫu
$ source venv/bin/activate
$ source venv/bin/activate
[venv] $
Mô hình
$ source venv/bin/activate
$ python3 -m venv venv
Các trường
$ python3 -m venv venv
$ source venv/bin/activate
$ source venv/bin/activate
$ python3 -m venv venv
$ python3 -m venv venv
$ python3 -m venv venv
$ python3 -m venv venv
Hai trường tiếp theo,
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
Ở dòng 9,
$ source venv/bin/activate
$ source venv/bin/activate
Ở dòng 10,
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
Trường cuối cùng trên mô hình bài đăng là thú vị nhất. Chúng tôi muốn liên kết các mô hình của mình cho các danh mục và bài đăng theo cách mà nhiều danh mục có thể được chỉ định cho nhiều bài đăng. May mắn thay, Django giúp chúng tôi làm điều này dễ dàng hơn bằng cách cung cấp loại trường
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
Mô hình thứ ba và cũng là mô hình cuối cùng mà chúng ta cần thêm vào là
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
Bạn sẽ thấy nó hoạt động như thế nào sau khi chúng ta định nghĩa lớp
$ source venv/bin/activate
[venv] $
Ba trường đầu tiên trên mô hình này sẽ trông quen thuộc. Có một trường
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
Ở dòng 20, chúng ta sử dụng một trường quan hệ khác, trường
$ source venv/bin/activate
$ source venv/bin/activate
Trường
$ source venv/bin/activate
$ source venv/bin/activate
C:\> venv\Scripts\activate.bat
Sau khi bạn đã tạo các mô hình, bạn có thể tạo các tệp di chuyển bằng
$ python3 -m venv venv
[venv] $
Bước cuối cùng là di chuyển các bảng. Lần này, không thêm cờ dành riêng cho ứng dụng. Sau này, bạn sẽ cần mô hình
C:\> venv\Scripts\activate.bat
[venv] $
Bây giờ bạn đã tạo các mô hình, chúng ta có thể bắt đầu thêm một số bài đăng và danh mục. Bạn sẽ không làm điều này từ dòng lệnh như bạn đã làm với các dự án, vì việc gõ toàn bộ bài đăng trên blog vào dòng lệnh sẽ rất khó chịu.
Thay vào đó, bạn sẽ học cách sử dụng Quản trị viên Django, điều này sẽ cho phép bạn tạo các phiên bản của các lớp mô hình của mình trong một giao diện web đẹp mắt
Đừng quên rằng bạn có thể kiểm tra mã nguồn của phần này trên GitHub trước khi chuyển sang phần tiếp theo
Loại bỏ các quảng cáoứng dụng blog. Quản trị viên Django
Quản trị viên Django là một công cụ tuyệt vời và là một trong những lợi ích tuyệt vời khi sử dụng Django. Vì bạn là người duy nhất sẽ viết các bài đăng trên blog và tạo danh mục nên không cần phải tạo giao diện người dùng để làm như vậy
Mặt khác, bạn không muốn phải viết các bài đăng trên blog trong dòng lệnh. This is where the admin comes in. Nó cho phép bạn tạo, cập nhật và xóa các thể hiện của các lớp mô hình của bạn và cung cấp một giao diện đẹp mắt để thực hiện việc đó
Trước khi bạn có thể truy cập quản trị viên, bạn cần thêm mình làm siêu người dùng. Đây là lý do tại sao, trong phần trước, bạn đã áp dụng di chuyển cho toàn dự án thay vì chỉ cho ứng dụng. Django đi kèm với các mô hình người dùng tích hợp và hệ thống quản lý người dùng cho phép bạn đăng nhập vào quản trị viên
Để bắt đầu, bạn có thể tự thêm mình làm siêu người dùng bằng lệnh sau
[venv] $
Sau đó, bạn sẽ được nhắc nhập tên người dùng theo sau là địa chỉ email và mật khẩu của bạn. Khi bạn đã nhập các chi tiết cần thiết, bạn sẽ được thông báo rằng siêu người dùng đã được tạo. Đừng lo lắng nếu bạn mắc lỗi vì bạn có thể bắt đầu lại
[venv] $
Điều hướng đến
C:\> venv\Scripts\activate.bat
Các mô hình Người dùng và Nhóm sẽ xuất hiện, nhưng bạn sẽ nhận thấy rằng không có tham chiếu nào đến các mô hình mà bạn đã tự tạo. Đó là bởi vì bạn cần đăng ký chúng trong quản trị viên
Trong thư mục
$ source venv/bin/activate
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
[venv] $ pip install Django
Dòng 2 bạn import các model muốn đăng ký vào trang quản trị
Ghi chú. Chúng tôi không thêm nhận xét cho quản trị viên. Đó là bởi vì bạn thường không cần phải tự chỉnh sửa hoặc tạo nhận xét
Nếu bạn muốn thêm một tính năng kiểm duyệt bình luận, hãy tiếp tục và thêm cả mô hình Bình luận. Các bước thực hiện hoàn toàn giống nhau
Ở dòng 4 và dòng 7, bạn định nghĩa các lớp trống
C:\> venv\Scripts\activate.bat
C:\> venv\Scripts\activate.bat
Hai dòng cuối cùng là quan trọng nhất. Chúng đăng ký các mô hình với các lớp quản trị. Nếu bây giờ bạn truy cập vào
C:\> venv\Scripts\activate.bat
$ source venv/bin/activate
$ source venv/bin/activate
Nếu bạn nhấp vào Bài đăng hoặc Danh mục, bạn sẽ có thể thêm phiên bản mới của cả hai mô hình. Tôi muốn thêm văn bản của các bài đăng trên blog giả bằng cách sử dụng văn bản giả lorem ipsum
Tạo một vài bài đăng giả mạo và gán cho chúng các danh mục giả mạo trước khi chuyển sang phần tiếp theo. Bằng cách đó, bạn sẽ có các bài đăng mà bạn có thể xem khi chúng tôi tạo mẫu của mình
Đừng quên kiểm tra mã nguồn của phần này trước khi chuyển sang xây dựng chế độ xem cho ứng dụng của chúng ta
Loại bỏ các quảng cáoứng dụng blog. Lượt xem
Bạn sẽ cần tạo ba chức năng xem trong tệp
$ mv personal_portfolio/manage.py ./
$ mv personal_portfolio/personal_portfolio/* personal_portfolio
$ rm -r personal_portfolio/personal_portfolio/
$ source venv/bin/activate
15 sẽ hiển thị danh sách tất cả các bài đăng của bạnC:\> venv\Scripts\activate.bat
16 sẽ hiển thị toàn bộ bài đăng cũng như các bình luận và một biểu mẫu cho phép người dùng tạo bình luận mớiC:\> venv\Scripts\activate.bat
17 sẽ tương tự nhưC:\> venv\Scripts\activate.bat
15, nhưng các bài đăng được xem sẽ chỉ thuộc một danh mục cụ thể do người dùng chọnC:\> venv\Scripts\activate.bat
Chức năng xem đơn giản nhất để bắt đầu là
C:\> venv\Scripts\activate.bat
$ python3 -m venv venv
C:\> venv\Scripts\activate.bat
$ source venv/bin/activate
[venv] $ pip install Django
Ở dòng 2, bạn nhập các mô hình
$ source venv/bin/activate
$ source venv/bin/activate
C:\> venv\Scripts\activate.bat
Cuối cùng, bạn xác định từ điển
$ python3 -m venv venv
Tiếp theo, bạn có thể bắt đầu tạo chế độ xem
C:\> venv\Scripts\activate.bat
$ source venv/bin/activate
[venv] $ pip install Django
Trên dòng 14, bạn đã sử dụng một. Đối số của bộ lọc cho Django biết những điều kiện cần phải đáp ứng để truy xuất một đối tượng. Trong trường hợp này, chúng tôi chỉ muốn các bài đăng có danh mục chứa danh mục có tên tương ứng với tên được cung cấp trong đối số của chức năng xem. Một lần nữa, bạn đang sử dụng
C:\> venv\Scripts\activate.bat
Sau đó, chúng tôi thêm các bài đăng này và danh mục vào từ điển
$ python3 -m venv venv
Chức năng xem cuối cùng để thêm là
C:\> venv\Scripts\activate.bat
$ python3 -m venv venv
$ python3 -m venv venv
[venv] $ pip install Django
Hàm xem lấy giá trị
$ source venv/bin/activate
$ source venv/bin/activate
Trên dòng 23, chúng tôi truy xuất lại tất cả các nhận xét được chỉ định cho bài đăng đã cho bằng bộ lọc Django
Cuối cùng, thêm cả
C:\> venv\Scripts\activate.bat
C:\> venv\Scripts\activate.bat
$ python3 -m venv venv
Để thêm biểu mẫu vào trang, bạn cần tạo một tệp khác trong thư mục
$ source venv/bin/activate
C:\> venv\Scripts\activate.bat
Đối với biểu mẫu này, các trường duy nhất bạn cần là
$ source venv/bin/activate
$ python3 -m venv venv
$ source venv/bin/activate
$ python3 -m venv venv
Ghi chú. Nếu
$ python3 -m venv venv
$ python3 -m venv venv
C:\> venv\Scripts\activate.bat
C:\> venv\Scripts\activate.bat
[venv] $ pip install Django
Bạn cũng sẽ nhận thấy một đối số
C:\> venv\Scripts\activate.bat
$ source venv/bin/activate
C:\> venv\Scripts\activate.bat
$ source venv/bin/activate
C:\> venv\Scripts\activate.bat
Các vật dụng này cũng nhận một đối số
C:\> venv\Scripts\activate.bat
Khi một biểu mẫu được đăng, một yêu cầu
$ python3 -m venv venv
$ python3 -m venv venv
C:\> venv\Scripts\activate.bat
Khi bạn đã tạo nhận xét từ biểu mẫu, bạn sẽ cần lưu nó bằng cách sử dụng
C:\> venv\Scripts\activate.bat
[venv] $ pip install Django
Trên dòng 24, chúng tôi tạo một thể hiện của lớp biểu mẫu của chúng tôi. Đừng quên nhập biểu mẫu của bạn vào đầu tệp
[venv] $ pip install Django
Sau đó, chúng tôi tiếp tục kiểm tra xem đã nhận được yêu cầu
$ python3 -m venv venv
Biểu mẫu sau đó được xác thực bằng cách sử dụng
C:\> venv\Scripts\activate.bat
$ source venv/bin/activate
C:\> venv\Scripts\activate.bat
Các khóa của từ điển tương ứng với các trường biểu mẫu, vì vậy bạn có thể truy cập tác giả bằng cách sử dụng
C:\> venv\Scripts\activate.bat
Ghi chú. Vòng đời của việc gửi biểu mẫu có thể hơi phức tạp, vì vậy đây là sơ lược về cách thức hoạt động của nó
- Khi người dùng truy cập trang có chứa biểu mẫu, họ sẽ gửi yêu cầu
00 đến máy chủ. Trong trường hợp này, không có dữ liệu nào được nhập vào biểu mẫu, vì vậy chúng tôi chỉ muốn hiển thị biểu mẫu và hiển thị nó$ python3 -m venv venv - Khi người dùng nhập thông tin và nhấp vào nút Gửi, một yêu cầu
01, chứa dữ liệu được gửi cùng với biểu mẫu, sẽ được gửi đến máy chủ. Tại thời điểm này, dữ liệu phải được xử lý và hai điều có thể xảy ra$ python3 -m venv venv- Biểu mẫu hợp lệ và người dùng được chuyển hướng đến trang tiếp theo
- Biểu mẫu không hợp lệ và biểu mẫu trống một lần nữa được hiển thị. Người dùng quay lại bước 1 và quá trình lặp lại
Mô-đun biểu mẫu Django sẽ xuất ra một số lỗi mà bạn có thể hiển thị cho người dùng. Điều này nằm ngoài phạm vi của hướng dẫn này, nhưng bạn có thể đọc thêm trong tài liệu Django
Ở dòng 33, lưu nhận xét và tiếp tục thêm
C:\> venv\Scripts\activate.bat
$ python3 -m venv venv
Bước cuối cùng trước khi bạn tạo các mẫu và thực sự thấy blog này hoạt động là kết nối các URL. Bạn sẽ cần tạo một tệp
$ python3 -m venv venv
C:\> venv\Scripts\activate.bat
[venv] $ pip install Django
Khi đã có các URL dành riêng cho blog, bạn cần thêm chúng vào cấu hình URL của dự án trong
$ python3 -m venv venv
C:\> venv\Scripts\activate.bat
[venv] $ pip install Django
Với thiết lập này, tất cả các URL của blog sẽ có tiền tố là
C:\> venv\Scripts\activate.bat
73. mục lục blogC:\> venv\Scripts\activate.bat
74. Chế độ xem chi tiết blog của blog vớiC:\> venv\Scripts\activate.bat
75C:\> venv\Scripts\activate.bat
76. Chế độ xem chỉ mục blog của tất cả các bài đăng có danh mụcC:\> venv\Scripts\activate.bat
77C:\> venv\Scripts\activate.bat
Các URL này vẫn chưa hoạt động vì bạn vẫn cần tạo các mẫu
Trong phần này, bạn đã tạo tất cả các chế độ xem cho ứng dụng blog của mình. Bạn đã học cách sử dụng bộ lọc khi thực hiện truy vấn và cách tạo biểu mẫu Django. Sẽ không lâu nữa cho đến khi bạn có thể thấy ứng dụng blog của mình hoạt động
Như mọi khi, đừng quên rằng bạn có thể xem mã nguồn của phần này trên GitHub
Blog App. mẫu
Phần cuối cùng của ứng dụng blog của chúng tôi là các mẫu. Đến cuối phần này, bạn sẽ tạo được một blog đầy đủ chức năng
Bạn sẽ nhận thấy có một số yếu tố bootstrap được bao gồm trong các mẫu để làm cho giao diện đẹp hơn. Đây không phải là trọng tâm của hướng dẫn nên tôi đã lướt qua những gì họ làm nhưng hãy xem tài liệu Bootstrap để tìm hiểu thêm
Mẫu đầu tiên bạn sẽ tạo là dành cho chỉ mục blog trong một tệp mới
C:\> venv\Scripts\activate.bat
Bạn sẽ sử dụng vòng lặp for để lặp qua tất cả các bài đăng. Đối với mỗi bài đăng, bạn sẽ hiển thị tiêu đề và một đoạn nội dung. Như mọi khi, bạn sẽ mở rộng mẫu cơ sở
C:\> venv\Scripts\activate.bat
[venv] $ pip install Django
Ở dòng 7, chúng ta có tiêu đề bài viết, là một siêu liên kết. Liên kết là một liên kết Django nơi chúng tôi đang trỏ đến URL có tên
C:\> venv\Scripts\activate.bat
$ source venv/bin/activate
Bên dưới tiêu đề, chúng tôi sẽ hiển thị thuộc tính
$ source venv/bin/activate
Ở dòng 17, chúng tôi sử dụng bộ lọc mẫu để cắt bỏ nội dung bài đăng ở 400 ký tự để chỉ mục blog dễ đọc hơn
Khi đã có, bạn sẽ có thể truy cập trang này bằng cách truy cập
C:\> venv\Scripts\activate.bat
Tiếp theo, tạo một tệp HTML khác
C:\> venv\Scripts\activate.bat
C:\> venv\Scripts\activate.bat
C:\> venv\Scripts\activate.bat
C:\> venv\Scripts\activate.bat
C:\> venv\Scripts\activate.bat
$ django-admin startproject personal_portfolio
Hầu hết mẫu này giống với mẫu trước đó. Sự khác biệt duy nhất là ở dòng 4, nơi chúng tôi sử dụng bộ lọc mẫu Django khác. Điều này áp dụng chữ cái đầu cho chuỗi và làm cho các từ bắt đầu bằng ký tự viết hoa
Sau khi hoàn thành mẫu đó, bạn sẽ có thể truy cập chế độ xem danh mục của mình. Nếu bạn đã xác định danh mục có tên là
C:\> venv\Scripts\activate.bat
C:\> venv\Scripts\activate.bat
The last template to create is the
C:\> venv\Scripts\activate.bat
Giữa tiêu đề và nội dung của bài đăng, bạn sẽ hiển thị ngày bài đăng được tạo và bất kỳ danh mục nào. Bên dưới đó, bạn sẽ bao gồm một biểu mẫu nhận xét để người dùng có thể thêm nhận xét mới. Dưới đây, sẽ có một danh sách các bình luận đã được để lại
$ django-admin startproject personal_portfolio
The first few lines of the template in which we display the post title, date, and categories is the same logic as for the previous templates. This time, when rendering the post body, use a template filter. This tag registers line breaks as new paragraphs, so the body doesn’t appear as one long block of text
Underneath the post, on line 16, you’ll display your form. The form action points to the URL path of the page to which you’re sending the
$ python3 -m venv venv
C:\> venv\Scripts\activate.bat
To get the bootstrap styling on the author and body fields, you need to add the
C:\> venv\Scripts\activate.bat
Because Django renders the inputs for you when you include
C:\> venv\Scripts\activate.bat
C:\> venv\Scripts\activate.bat
Underneath the form, there’s another for loop that loops over all the comments on the given post. The comments,
$ source venv/bin/activate
$ source venv/bin/activate
$ source venv/bin/activate
Once that template is in place, you should be able to visit
C:\> venv\Scripts\activate.bat
You should also be able to access the post detail pages by clicking on their title in the
C:\> venv\Scripts\activate.bat
The final finishing touch is to add a link to the
C:\> venv\Scripts\activate.bat
$ python3 -m venv venv
$ python3 -m venv venv
With that now in place, your personal portfolio site is complete, and you’ve created your first Django site. The final version of the source code containing all the features can be found on GitHub, so check it out. Click around the site a bit to see all the functionality and try leaving some comments on your posts
You may find a few things here and there that you think need polishing. Go ahead and tidy them up. The best way to learn more about this web framework is through practice, so try to extend this project and make it even better. If you’re not sure where to start, I’ve left a few ideas for you in the conclusion below
Conclusion
Congratulations, you’ve reached the end of the tutorial. We’ve covered a lot, so make sure to keep practicing and building. The more you build the easier it will become and the less you’ll have to refer back to this article or the documentation. You’ll be building sophisticated web applications in no time
In this tutorial you’ve seen
- How to create Django projects and apps
- How to add web pages with views and templates
- How to get user input with forms
- How to hook your views and templates up with URL configurations
- How to add data to your site using relational databases with Django’s Object Relational Mapper
- How to use the Django Admin to manage your models
In addition, you’ve learned about the MVT structure of Django web applications and why Django is such a good choice for web development
If you want to learn more about Django, do check out the documentation and make sure to check out Part 2 of this series
Get Started With Django Part 2. Django User Management »
Mark as Completed
Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding. Get Started With Django. Build a Portfolio App
🐍 Thủ thuật Python 💌
Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Hủy đăng ký bất cứ lúc nào. Curated by the Real Python team
Send Me Python Tricks »
About Jasmine Finer
Jasmine is a Django developer, based in London
» More about JasmineEach tutorial at Real Python is created by a team of developers so that it meets our high quality standards. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là
Aldren
Jim
Joanna
Master Real-World Python Skills With Unlimited Access to Real Python
Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas
Level Up Your Python Skills »
Master Real-World Python Skills
Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia
Level Up Your Python Skills »
What Do You Think?
Rate this article
Tweet Share Share EmailWhat’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know
Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi