首先需要python的环境，这里就不赘述了
具体可以参考：https://blog.csdn.net/Leo_csdn_/article/details/88552724
linux下用pip安装django：pip install django
安装完成后，
运行如下命令创建工程：
django-admin startproject blogproject
进入工程所在目录 ，会发现多了一个 blogproject\ 的目录，其内部的文件结构如下
blogproject\
manage.py
blogproject\
__init__.py
settings.py
urls.py
wsgi.py
最顶层的 blogproject\ 目录是我们刚刚指定的工程目录。blogproject\ 目录下面有一个 manage.py 文件，manage 是管理的意思，顾名思义 manage.py 就是 Django 为我们生成的管理这个项目的 Python 脚本文件，以后用到时会再次介绍。与 manage.py 同级的还有一个 blogproject\ 的目录，这里面存放了一些 Django 的配置文件，例如 settings.py、urls.py 等等，以后用到时会详细介绍。
网站需要运行在一个 Web 服务器上，Django 已经为我们提供了一个用于本地开发的 Web 服务器。在命令行工具里进入到 manage.py 所在目录，即最外层的 blogproject\ 目录下。运行 python manage.py runserver 命令就可以在本机上开启一个 Web 服务器：
[xxxxx]$ python manage.py runserver
Performing system checks...
System check identified no issues (0 silenced).
You have 13 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.
December 21, 2016 - 20:23:07
Django version 1.10.4, using settings 'blogproject.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.
看到这样的信息表明我们的服务器开启成功。
在浏览器输入 http://127.0.0.1:8000/ ，看到如下的页面提示信息：
It worked! Django 工作了！
Django 默认的语言是英语，所以显示给我们的欢迎页面是英文的。我们在 Django 的配置文件里稍作修改，让它支持中文。用任何一个文本编辑器打开 settings.py 文件，找到如下的两行代码：
## 其它配置代码...
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
## 其它配置代码...
把 LANGUAGE_CODE 的值改为 zh-hans，TIME_ZONE 的值改为 Asia/Shanghai：
blogproject/blogproject/settings.py
## 其它配置代码...
# 把英文改为中文
LANGUAGE_CODE = 'zh-hans'
# 把国际时区改为中国时区
TIME_ZONE = 'Asia/Shanghai'
## 其它配置代码...
保存更改后关闭 settings.py 文件。
再次运行开发服务器，并在浏览器打开 http://127.0.0.1:8000/，可以看到 Django 已经支持中文了。
建立博客应用
现在就来创建我们的 Django 博客应用，我把它命名为 blog。进入到 manage.py 文件所在的目录下，运行 python manage.py startapp blog 命令即可建立一个 blog 应用。
可以看到多了一个 blog\ 的目录，该目录下面的文件结构如下：
blog\
__init__.py
admin.py
apps.py
migrations\
__init__.py
models.py
tests.py
views.py
打开 blogproject\ 目录下的 settings.py 文件，找到 INSTALLED_APPS 设置项，将 blog 应用添加进去。
blogproject/blogproject/settings.py
## 其他配置项...
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'blog', # 注册 blog 应用
]
## 其他配置项...
编写博客模型代码
博客最主要的功能就是展示我们写的文章，它需要从某个地方获取博客文章数据才能把文章展示出来，通常来说这个地方就是数据库。我们把写好的文章永久地保存在数据库里，当用户访问我们的博客时，Django 就去数据库里把这些数据取出来展现给用户。
Django 把数据库的语法转换成了 Python 的语法形式，我们只要写 Python 代码就可以了，Django 会把 Python 代码翻译成对应的数据库操作语言。
进入blog目录下编辑models.py文件
blog/models.py
from django.db import models
from django.contrib.auth.models import User
class Category(models.Model):
"""
Django 要求模型必须继承 models.Model 类。
Category 只需要一个简单的分类名 name 就可以了。
CharField 指定了分类名 name 的数据类型，CharField 是字符型，
CharField 的 max_length 参数指定其最大长度，超过这个长度的分类名就不能被存入数据库。
当然 Django 还为我们提供了多种其它的数据类型，如日期时间类型 DateTimeField、整数类型 IntegerField 等等。
Django 内置的全部类型可查看文档：
https://docs.djangoproject.com/en/1.10/ref/models/fields/#field-types
"""
name = models.CharField(max_length=100)
class Tag(models.Model):
"""
标签 Tag 也比较简单，和 Category 一样。
再次强调一定要继承 models.Model 类！
"""
name = models.CharField(max_length=100)
class Post(models.Model):
"""
文章的数据库表稍微复杂一点，主要是涉及的字段更多。
"""
# 文章标题
title = models.CharField(max_length=70)
# 文章正文，我们使用了 TextField。
# 存储比较短的字符串可以使用 CharField，但对于文章的正文来说可能会是一大段文本，因此使用 TextField 来存储大段文本。
body = models.TextField()
# 这两个列分别表示文章的创建时间和最后一次修改时间，存储时间的字段用 DateTimeField 类型。
created_time = models.DateTimeField()
modified_time = models.DateTimeField()
# 文章摘要，可以没有文章摘要，但默认情况下 CharField 要求我们必须存入数据，否则就会报错。
# 指定 CharField 的 blank=True 参数值后就可以允许空值了。
excerpt = models.CharField(max_length=200, blank=True)
# 这是分类与标签，分类与标签的模型我们已经定义在上面。
# 我们在这里把文章对应的数据库表和分类、标签对应的数据库表关联了起来，但是关联形式稍微有点不同。
# 我们规定一篇文章只能对应一个分类，但是一个分类下可以有多篇文章，所以我们使用的是 ForeignKey，即一对多的关联关系。
# 而对于标签来说，一篇文章可以有多个标签，同一个标签下也可能有多篇文章，所以我们使用 ManyToManyField，表明这是多对多的关联关系。
# 同时我们规定文章可以没有标签，因此为标签 tags 指定了 blank=True。
# 如果你对 ForeignKey、ManyToManyField 不了解，请看教程中的解释，亦可参考官方文档：
# https://docs.djangoproject.com/en/1.10/topics/db/models/#relationships
category = models.ForeignKey(Category)
tags = models.ManyToManyField(Tag, blank=True)
# 文章作者，这里 User 是从 django.contrib.auth.models 导入的。
# django.contrib.auth 是 Django 内置的应用，专门用于处理网站用户的注册、登录等流程，User 是 Django 为我们已经写好的用户模型。
# 这里我们通过 ForeignKey 把文章和 User 关联了起来。
# 因为我们规定一篇文章只能有一个作者，而一个作者可能会写多篇文章，因此这是一对多的关联关系，和 Category 类似。
author = models.ForeignKey(User)
迁移数据库
切换到 manage.py 文件所在的目录下，分别运行 python manage.py makemigrations 和 python manage.py migrate 命令：
[xxxxx]$ python manage.py makemigrations
Migrations for 'blog':
blog\migrations\0001_initial.py:
- Create model Category
- Create model Post
- Create model Tag
- Add field tags to post
[xxxxx]$ python manage.py migrate
Operations to perform:
Apply all migrations: admin, auth, blog, contenttypes, sessions
Running migrations:
Applying contenttypes.0001_initial... OK
Applying auth.0001_initial... OK
Applying admin.0001_initial... OK
Applying admin.0002_logentry_remove_auto_add... OK
Applying contenttypes.0002_remove_content_type_name... OK
Applying auth.0002_alter_permission_name_max_length... OK
Applying auth.0003_alter_user_email_max_length... OK
Applying auth.0004_alter_user_username_opts... OK
Applying auth.0005_alter_user_last_login_null... OK
Applying auth.0006_require_contenttypes_0002... OK
Applying auth.0007_alter_validators_add_error_messages... OK
Applying auth.0008_alter_user_username_max_length... OK
Applying blog.0001_initial... OK
Applying sessions.0001_initial... OK
用 Django 的方式操作数据库
存数据
先在命令行中来探索一下这些函数，感受一下如何用 Django 的方式来操作数据库。在 manage.py 所在目录下运行 python manage.py shell 命令：
[xxxxx]$ python manage.py shell
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:18:55) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>>
这打开了一个交互式命令行。
首先我们来创建一个分类和一个标签：
>>> from blog.models import Category, Tag, Post
>>> c = Category(name='category test')
>>> c.save()
>>> t = Tag(name='tag test')
>>> t.save()
首先导入 3 个之前写好的模型类，然后实例化了一个 Category 类和一个 Tag 类，为他们的属性 name 赋了值。为了让 Django 把这些数据保存进数据库，调用实例的 save 方法即可。
再创建一篇文章试试，但创建文章之前，我们需要先创建一个 User，用于指定文章的作者。创建 User 的命令 Django 已经帮我们写好了，依然是通过 manage.py 来运行。首先按住 Ctrl + c 退出命令交互栏（一次退不出就连续多按几次），运行 python manage.py createsuperuser 命令并根据提示创建用户：
[xxxxx]$ python manage.py createsuperuser
Username (leave blank to use 'zmrenwu@163.com'): myuser
Email address: a@aa.com
Password:
Password (again):
Superuser created successfully.
运行 python manage.py createsuperuser 开始创建用户，之后会提示你输入用户名、邮箱、密码和确认密码，按照提示输入即可。最后出现 Superuser created successfully. 说明用户创建成功了。
再次运行 python manage.py shell 进入 Python 命令交互栏，开始创建文章：
>>> from blog.models import Category, Tag, Post
>>> from django.utils import timezone
>>> from django.contrib.auth.models import User
>>> user = User.objects.get(username='myuser')
>>> c = Category.objects.get(name='category test')
>>> p = Post(title='title test', body='body test', created_time=timezone.now(), modified_time=timezone.now(), category=c, author=user)
>>> p.save()
取数据
数据已经存入数据库了，现在要把它们取出来看看：
>>> Category.objects.all()
<QuerySet [<Category: Category object>]>
>>> Tag.objects.all()
<QuerySet [<Tag: Tag object>]>
>>> Post.objects.all()
<QuerySet [<Post: Post object>]>
>>>
objects 是我们的模型管理器，它为我们提供一系列从数据库中取数据方法，这里我们使用了 all 方法，表示我们要把对应的数据全部取出来。可以看到 all 方法都返回了数据，这些数据应该是我们之前存进去的，但是显示的字符串有点奇怪，无法看出究竟是不是我们之前存入的数据。为了让显示出来的数据更加人性化一点，我们为 3 个模型分别增加一个 __str__ 方法：
blog/models.py
from django.utils.six import python_2_unicode_compatible
# python_2_unicode_compatible 装饰器用于兼容 Python2
@python_2_unicode_compatible
class Category(models.Model):
...
def __str__(self):
return self.name
@python_2_unicode_compatible
class Tag(models.Model):
...
def __str__(self):
return self.name
@python_2_unicode_compatible
class Post(models.Model):
...
def __str__(self):
return self.title
先按 Ctrl + c 退出 Shell，再重新运行 python manage.py shell 进入 Shell。
>>> from blog.models import Category, Tag, Post
>>> Category.objects.all()
<QuerySet [<Category: category test>]>
>>> Tag.objects.all()
<QuerySet [<Tag: tag test>]>
>>> Post.objects.all()
<QuerySet [<Post: title test>]>
>>> Post.objects.get(title='title test')
<Post: title test>
改数据
尝试修改数据：
>>> c = Category.objects.get(name='category test')
>>> c.name = 'category test new'
>>> c.save()
>>> Category.objects.all()
<QuerySet [<Category: test category new>]>
删数据
删除掉数据：
>>> p = Post.objects.get(title='title test')
>>> p
<Post: title test>
>>> p.delete()
(1, {'blog.Post_tags': 0, 'blog.Post': 1})
>>> Post.objects.all()
<QuerySet []>
Django 博客首页视图
绑定 URL 与视图函数
首先在 blog 应用的目录下创建一个 urls.py 文件，在 blog\urls.py 中写入这些代码：
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.index, name='index'),
]
我们首先从 django.conf.urls 导入了 url 函数，又从当前目录下导入了 views 模块。然后我们把网址和处理函数的关系写在了 urlpatterns 列表里。
绑定关系的写法是把网址和对应的处理函数作为参数传给 url 函数（第一个参数是网址，第二个参数是处理函数），另外我们还传递了另外一个参数 name，这个参数的值将作为处理函数 index 的别名，这在以后会用到。
注意这里我们的网址是用正则表达式写的，Django 会用这个正则表达式去匹配用户实际输入的网址，如果匹配成功，就会调用其后面的视图函数做相应的处理。
比如说我们本地开发服务器的域名是 http://127.0.0.1:8000，那么当用户输入网址 http://127.0.0.1:8000 后，Django 首先会把协议 http、域名 127.0.0.1 和端口号 8000 去掉，此时只剩下一个空字符串，而 r'^$' 的模式正是匹配一个空字符串（这个正则表达式的意思是以空字符串开头且以空字符串结尾），于是二者匹配，Django 便会调用其对应的 views.index 函数。
注意：在项目根目录的 blogproject\ 目录下（即 settings.py 所在的目录），原本就有一个 urls.py 文件，这是整个工程项目的 URL 配置文件。而我们这里新建了一个 urls.py 文件，且位于 blog 应用下。这个文件将用于 blog 应用相关的 URL 配置。不要把两个文件搞混了。
配置项目 URL
把 blog 应用下的 urls.py 文件包含到 blogproject\urls.py 里去，修改成如下的形式：
from django.conf.urls import url, include
from django.contrib import admin
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'', include('blog.urls')),
]
运行结果
运行 python manage.py runserver 打开开发服务器，在浏览器输入开发服务器的地址 http://127.0.0.1:8000/，可以看到 Django 返回的内容了。
欢迎访问我的博客首页！
使用 Django 模板系统
首先在我们的项目根目录（即 manage.py 文件所在目录）下建立一个名为 templates 的文件夹，用来存放我们的模板。然后在 templates\ 目录下建立一个名为 blog 的文件夹，用来存放和 blog 应用相关的模板
在 templates\blog 目录下建立一个名为 index.html 的文件,在文件里写入下面的代码：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>{{ title }}</title>
</head>
<body>
<h1>{{ welcome }}</h1>
</body>
</html>
这是一个标准的 HTML 文档，只是里面有两个比较奇怪的地方：{{ title }}，{{ welcome }}。这是 Django 规定的语法。用 {{ }} 包起来的变量叫做模板变量。Django 在渲染这个模板的时候会根据我们传递给模板的变量替换掉这些变量。最终在模板中显示的将会是我们传递的值。
模板写好了，还得告诉 Django 去哪里找模板，在 settings.py 文件里设置一下模板文件所在的路径。
在 settings.py 找到 TEMPLATES 选项，它的内容是这样的：
blogproject/settings.py
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',
],
},
},
]
其中 DIRS 就是设置模板的路径，在 [] 中写入 os.path.join(BASE_DIR, 'templates')，即像下面这样：
TEMPLATES = [
{
...
'DIRS': [os.path.join(BASE_DIR, 'templates')],
...
},
]
视图函数可以改一下了：
from django.http import HttpResponse
from django.shortcuts import render
def index(request):
return render(request, 'blog/index.html', context={
'title': '我的博客首页',
'welcome': '欢迎访问我的博客首页'
})
这里我们不再是直接把字符串传给 HttpResponse 了，而是调用 Django 提供的 render 函数。这个函数根据我们传入的参数来构造 HttpResponse。
在 Django Admin 后台发布文章
创建 Admin 后台管理员账户
在前面的步骤中已经创建过一个管理员账户了，如果没有执行，则利用python manage.py createsuperuser命令新建一个
在 Admin 后台注册模型
注册非常简单，只需要在 blog\admin.py 中加入下面的代码：
from django.contrib import admin
from .models import Post, Category, Tag
admin.site.register(Post)
admin.site.register(Category)
admin.site.register(Tag)
运行开发服务器，访问 http://127.0.0.1:8000/admin/ ，就进入了到了Django Admin 后台登录页面，输入刚才创建的管理员账户密码就可以登录到后台了。
可以看到我们刚才注册的三个模型了，点击 Posts 后面的增加按钮，将进入添加 Post 的页面，也就是新增博客文章。然后在相关的地方输入一些测试用的内容，增加完后点击保存，这样文章就添加完毕了，你也可以多添加几篇看看效果。注意每篇文章必须有一个分类，在添加文章时你可以选择已有分类。如果数据库中还没有分类，在选择分类时点击 Category 后面的 + 按钮新增一个分类即可。
定制 Admin 后台
在 admin post 列表页面，我们只看到了文章的标题，但是我们希望它显示更加详细的信息，这需要我们来定制 Admin 了，在 admin.py 添加如下代码：
from django.contrib import admin
from .models import Post, Category, Tag
class PostAdmin(admin.ModelAdmin):
list_display = ['title', 'created_time', 'modified_time', 'category', 'author']
# 把新增的 PostAdmin 也注册进来
admin.site.register(Post, PostAdmin)
admin.site.register(Category)
admin.site.register(Tag)
参考文章：https://www.zmrenwu.com/post/2/
相关网站
bootstarp：http://www.runoob.com/bootstrap/bootstrap-tutorial.html
来源：CSDN
作者：Just_like_fire
链接：https://blog.csdn.net/Leo_csdn_/article/details/88552097