导读：很多朋友问到关于django网页怎么分成四块的相关问题，本文首席CTO笔记就来为大家做个详细解答，供大家参考，希望对大家有所帮助！一起来看看吧！
如何写第一个属于自己的Web页面（Django）
上期（超实用搭建个人开发Web网页的软件及配置基础）已经详细的介绍了基于Django+MySQL+PyCharm组合配置的Web开发的基础架构。这期带读者跟着作者写第一个属于自己的Web页面，同时跟作者同一个局域网的其它用户也可以访问。
首先输入python manage.py startapp myFamilyWeb (表示创建一个自己的Web页面项目)，如图1。
生成的myFamilyWeb里的目录结构里的含义如下：
外层的_init_.py文件标识myFamilyWeb是一个Python包。
admin.py 用于将Model定义注册到管理后台，是Django Admin 应用的配置文件。
apps.py用于应用程序本身的配置。
migrations目录用于存储models.py文件中Model的定义及修改。
migrations/_init_.py文件标识migrations是一个Python包。
models.py用于定义应用中所需要的数据表。
tests.py文件用于编写当前应用程序的单元测试。
views.py文件用于编写应用程序的视图。
以上的介绍都是myFamilyWeb应用的全部内容，后续需要做的就是填充对应的service逻辑对外提供服务。如果就这么启动，就会发现如图2一样访问不了。
想要实现访问自己第一个Web页面（myFamilyWeb），第一步是设置路由和在views.py增加一个可以访问的函数（图3-图6）。
配置模板和html（图7-图13）
配置写好了第一个最简单的Web页面，启动服务器。。。（图14）
在开发者电脑上的浏览器访问 （图15）
（配置防火墙端口）（图16）
设置允许多个主机访问 （图17）
在终端输入ipconfig
回车找到IPv4 的地址：192.168.0.102 （图18）
python manage.py runserver 0.0.0.0:8000 （这次启动的时候在后面添加0.0.0.0:8000）。
然后本地网络中的其它计算机就可以在浏览器中访问你的 IP 地址了， （这个网址只能同一个局域网的主机可以访问）
之后就是好好去学习如何写html文件了。。。
如何创建一个Django网站
本文演示如何创建一个简单的 django 网站，使用的 django 版本为1.7。
1. 创建项目
运行下面命令就可以创建一个 django 项目，项目名称叫 mysite ：
$ django-admin.py startproject mysite
创建后的项目目录如下：
mysite
├── manage.py
└── mysite
├── __init__.py
├── settings.py
├── urls.py
└── wsgi.py
1 directory, 5 files
说明：
__init__.py ：让 Python 把该目录当成一个开发包 (即一组模块)所需的文件。 这是一个空文件，一般你不需要修改它。
manage.py ：一种命令行工具，允许你以多种方式与该 Django 项目进行交互。 键入python manage.py help，看一下它能做什么。 你应当不需要编辑这个文件；在这个目录下生成它纯是为了方便。
settings.py ：该 Django 项目的设置或配置。
urls.py：Django项目的URL路由设置。目前，它是空的。
wsgi.py：WSGI web 应用服务器的配置文件。更多细节，查看 How to deploy with WSGI
接下来，你可以修改 settings.py 文件，例如：修改 LANGUAGE_CODE、设置时区 TIME_ZONE
SITE_ID = 1
LANGUAGE_CODE = 'zh_CN'
TIME_ZONE = 'Asia/Shanghai'
USE_TZ = True
上面开启了 [Time zone]() 特性，需要安装 pytz：
$ sudo pip install pytz
2. 运行项目
在运行项目之前，我们需要创建数据库和表结构，这里我使用的默认数据库：
$ python manage.py migrate
Operations to perform:
Apply all migrations: admin, contenttypes, auth, sessions
Running migrations:
Applying contenttypes.0001_initial... OK
Applying auth.0001_initial... OK
Applying admin.0001_initial... OK
Applying sessions.0001_initial... OK
然后启动服务：
$ python manage.py runserver
你会看到下面的输出：
Performing system checks...
System check identified no issues (0 silenced).
January 28, 2015 - 02:08:33
Django version 1.7.1, using settings 'mysite.settings'
Starting development server at
Quit the server with CONTROL-C.
这将会在端口8000启动一个本地服务器, 并且只能从你的这台电脑连接和访问。 既然服务器已经运行起来了，现在用网页浏览器访问 。你应该可以看到一个令人赏心悦目的淡蓝色 Django 欢迎页面它开始工作了。
你也可以指定启动端口:
$ python manage.py runserver 8080
以及指定 ip：
$ python manage.py runserver 0.0.0.0:8000
3. 创建 app
前面创建了一个项目并且成功运行，现在来创建一个 app，一个 app 相当于项目的一个子模块。
在项目目录下创建一个 app：
$ python manage.py startapp polls
如果操作成功，你会在 mysite 文件夹下看到已经多了一个叫 polls 的文件夹，目录结构如下：
polls
├── __init__.py
├── admin.py
├── migrations
│ └── __init__.py
├── models.py
├── tests.py
└── views.py
1 directory, 6 files
4. 创建模型
每一个 Django Model 都继承自 django.db.models.Model
在 Model 当中每一个属性 attribute 都代表一个 database field
通过 Django Model API 可以执行数据库的增删改查, 而不需要写一些数据库的查询语句
打开 polls 文件夹下的 models.py 文件。创建两个模型：
import datetime
from django.db import models
from django.utils import timezone
class Question(models.Model):
question_text = models.CharField(max_length=200)
pub_date = models.DateTimeField('date published')
def was_published_recently(self):
return self.pub_date = timezone.now() - datetime.timedelta(days=1)
class Choice(models.Model):
question = models.ForeignKey(Question)
choice_text = models.CharField(max_length=200)
votes = models.IntegerField(default=0)
然后在 mysite/settings.py 中修改 INSTALLED_APPS 添加 polls：
INSTALLED_APPS = (
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'polls',
)
在添加了新的 app 之后，我们需要运行下面命令告诉 Django 你的模型做了改变，需要迁移数据库：
$ python manage.py makemigrations polls
你会看到下面的输出日志：
Migrations for 'polls':
0001_initial.py:
- Create model Choice
- Create model Question
- Add field question to choice
你可以从 polls/migrations/0001_initial.py 查看迁移语句。
运行下面语句，你可以查看迁移的 sql 语句：
$ python manage.py sqlmigrate polls 0001
输出结果：
BEGIN;
CREATE TABLE "polls_choice" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "choice_text" varchar(200) NOT NULL, "votes" integer NOT NULL);
CREATE TABLE "polls_question" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "question_text" varchar(200) NOT NULL, "pub_date" datetime NOT NULL);
CREATE TABLE "polls_choice__new" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "choice_text" varchar(200) NOT NULL, "votes" integer NOT NULL, "question_id" integer NOT NULL REFERENCES "polls_question" ("id"));
INSERT INTO "polls_choice__new" ("choice_text", "votes", "id") SELECT "choice_text", "votes", "id" FROM "polls_choice";
DROP TABLE "polls_choice";
ALTER TABLE "polls_choice__new" RENAME TO "polls_choice";
CREATE INDEX polls_choice_7aa0f6ee ON "polls_choice" ("question_id");
COMMIT;
你可以运行下面命令，来检查数据库是否有问题：
$ python manage.py check
再次运行下面的命令，来创建新添加的模型：
$ python manage.py migrate
Operations to perform:
Apply all migrations: admin, contenttypes, polls, auth, sessions
Running migrations:
Applying polls.0001_initial... OK
总结一下，当修改一个模型时，需要做以下几个步骤：
修改 models.py 文件
运行 python manage.py makemigrations 创建迁移语句
运行 python manage.py migrate，将模型的改变迁移到数据库中
你可以阅读 django-admin.py documentation，查看更多 manage.py 的用法。
创建了模型之后，我们可以通过 Django 提供的 API 来做测试。运行下面命令可以进入到 python shell 的交互模式：
$ python manage.py shell
下面是一些测试：
from polls.models import Question, Choice # Import the model classes we just wrote.
# No questions are in the system yet.
Question.objects.all()
[]
# Create a new Question.
# Support for time zones is enabled in the default settings file, so
# Django expects a datetime with tzinfo for pub_date. Use timezone.now()
# instead of datetime.datetime.now() and it will do the right thing.
from django.utils import timezone
q = Question(question_text="What's new?", pub_date=timezone.now())
# Save the object into the database. You have to call save() explicitly.
q.save()
# Now it has an ID. Note that this might say "1L" instead of "1", depending
# on which database you're using. That's no biggie; it just means your
# database backend prefers to return integers as Python long integer
# objects.
q.id
1
# Access model field values via Python attributes.
q.question_text
"What's new?"
q.pub_date
datetime.datetime(2012, 2, 26, 13, 0, 0, 775217, tzinfo=UTC)
# Change values by changing the attributes, then calling save().
q.question_text = "What's up?"
q.save()
# objects.all() displays all the questions in the database.
Question.objects.all()
[Question: Question object]
打印所有的 Question 时，输出的结果是 [Question: Question object]，我们可以修改模型类，使其输出更为易懂的描述。修改模型类：
from django.db import models
class Question(models.Model):
# ...
def __str__(self): # __unicode__ on Python 2
return self.question_text
class Choice(models.Model):
# ...
def __str__(self): # __unicode__ on Python 2
return self.choice_text
接下来继续测试：
from polls.models import Question, Choice
# Make sure our __str__() addition worked.
Question.objects.all()
[Question: What's up?]
# Django provides a rich database lookup API that's entirely driven by
# keyword arguments.
Question.objects.filter(id=1)
[Question: What's up?]
Question.objects.filter(question_text__startswith='What')
[Question: What's up?]
# Get the question that was published this year.
from django.utils import timezone
current_year = timezone.now().year
Question.objects.get(pub_date__year=current_year)
Question: What's up?
# Request an ID that doesn't exist, this will raise an exception.
Question.objects.get(id=2)
Traceback (most recent call last):
...
DoesNotExist: Question matching query does not exist.
# Lookup by a primary key is the most common case, so Django provides a
# shortcut for primary-key exact lookups.
# The following is identical to Question.objects.get(id=1).
Question.objects.get(pk=1)
Question: What's up?
# Make sure our custom method worked.
q = Question.objects.get(pk=1)
# Give the Question a couple of Choices. The create call constructs a new
# Choice object, does the INSERT statement, adds the choice to the set
# of available choices and returns the new Choice object. Django creates
# a set to hold the "other side" of a ForeignKey relation
# (e.g. a question's choice) which can be accessed via the API.
q = Question.objects.get(pk=1)
# Display any choices from the related object set -- none so far.
q.choice_set.all()
[]
# Create three choices.
q.choice_set.create(choice_text='Not much', votes=0)
Choice: Not much
q.choice_set.create(choice_text='The sky', votes=0)
Choice: The sky
c = q.choice_set.create(choice_text='Just hacking again', votes=0)
# Choice objects have API access to their related Question objects.
c.question
Question: What's up?
# And vice versa: Question objects get access to Choice objects.
q.choice_set.all()
[Choice: Not much, Choice: The sky, Choice: Just hacking again]
q.choice_set.count()
3
# The API automatically follows relationships as far as you need.
# Use double underscores to separate relationships.
# This works as many levels deep as you want; there's no limit.
# Find all Choices for any question whose pub_date is in this year
# (reusing the 'current_year' variable we created above).
Choice.objects.filter(question__pub_date__year=current_year)
[Choice: Not much, Choice: The sky, Choice: Just hacking again]
# Let's delete one of the choices. Use delete() for that.
c = q.choice_set.filter(choice_text__startswith='Just hacking')
c.delete()
上面这部分测试，涉及到 django orm 相关的知识，详细说明可以参考 Django中的ORM。
5. 管理 admin
Django有一个优秀的特性, 内置了Django admin后台管理界面, 方便管理者进行添加和删除网站的内容.
新建的项目系统已经为我们设置好了后台管理功能，见 mysite/settings.py：
INSTALLED_APPS = (
'django.contrib.admin', #默认添加后台管理功能
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'mysite',
)
同时也已经添加了进入后台管理的 url, 可以在 mysite/urls.py 中查看：
url(r'^admin/', include(admin.site.urls)), #可以使用设置好的url进入网站后台
接下来我们需要创建一个管理用户来登录 admin 后台管理界面：
$ python manage.py createsuperuser
Username (leave blank to use 'june'): admin
Email address:
Password:
Password (again):
Superuser created successfully.
总结
最后，来看项目目录结构：
mysite
├── db.sqlite3
├── manage.py
├── mysite
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ ├── wsgi.py
├── polls
│ ├── __init__.py
│ ├── admin.py
│ ├── migrations
│ │ ├── 0001_initial.py
│ │ ├── __init__.py
│ ├── models.py
│ ├── templates
│ │ └── polls
│ │ ├── detail.html
│ │ ├── index.html
│ │ └── results.html
│ ├── tests.py
│ ├── urls.py
│ ├── views.py
└── templates
└── admin
└── base_site.htm
通过上面的介绍，对 django 的安装、运行以及如何创建视 图和模型有了一个清晰的认识，接下来就可以深入的学习 django 的自动化测试、持久化、中间件、国 际 化等知识。
Nginx+Python 怎么搞才好
介绍NGINX和Python如何配合使用
Python以易用，有趣而出名，它让软件开发变得简单，据说运行性能也高于其他脚本语言（PHP最新版本PHP 7的性能好像可以与Python一较高下）
每一个人都希望自己的网站或应用可以运行得更快。但是每一个网站在大流量和流量激增时都容易遇到性能问题，甚至当机，业务繁忙时，这种情况会更加糟糕。其实无论流量是稳定增长，还是陡峭增长，所有网站都面临性能和当机的困扰。
NGINX和NGINX插件的出现就是为了解决这个问题。他们通过三种不同的方式来改善网站性能：
1、web服务 – 最初开发NGINX是为了解决 C10K 问题 – 可以轻松支撑10,000或更多的并发连接。使用NGINX为你的Python应用提供web服务，可以让你的网站运行更快，即便在小流量的情况下也有效果。当你的用户成千上万时，确定无疑，它可以提供更高的性能，更少的崩溃，以及更少的当机时间。你也可以使用NGINX提供静态文件缓存或者微缓存服务，一个独立的NGINX反向代理也是很好的选择（见下一段）。
2、反向代理– 你可以在应用服务的前端用NGINX做反向代理。NGINX接收Web请求并分发到你的应用服务。这个“怪招”可以让你的网站运行得更快，减少当机，消费更少的服务资源，而且可以提高安全性。你也可以在反向代理服务器上缓存静态资源（非常高效），添加静态内容的微缓存，以减少应用自身的负载，等等。
3、为多个应用服务提供动态均衡 – 通过布署反向代理服务。通过多应用服务并行运行和NGINX或者NGINX插件来做流量负载均衡。通过这种布署，根据流量需要，增长稳定性和运行时间需要，你可以很轻松地在线扩展网站性能。如果你需要让给定用户的会话在同一个服务上，你只需要配置负载均衡以支持会话持久化。
不管是为你的Python应用提供网站服务，还是做反向代理服务，还是做负载均衡，或者三者都用，NGINX和NGINX插件都会给你带来优势。
这是本系列（由两部分组成）中的第一篇文章，将会介绍五个提升Python应用性能的技巧，包括如何使用NGINX或NGINX插件提供web服务，如何实现静态文件的缓存，如何为动态内容做微缓存。在第二部分，我们将介绍如果用NGINX或NGINX插件提供反向代理服务，以及如何为多个应用服务提供负载均衡。
技巧 1– 定位Python性能瓶颈
有两种截然不同的情况会让你的Python应用遇到性能问题– 第一，每天有海量用户；第二，高负载。大部分网站长都不需要担心性能问题，因为他们的负载很小，根据我们的拙见，他们应该努力降低响应时间。将响应时间控制在毫秒级是一个非常困难且不被关注的工作。但可以让我们的用户体验更好，业绩更优秀。
但是这篇博文和剩下的第二部分，将关注每个人都确实关注的场景：当网站繁忙时可能会出现的性能问题，如性能大幅下降和当机。还有黑客模拟大量用户攻击造成的流量激增，同时提高网站性能也是处理攻击的重要步骤。
像Apache HTTP Server这样的系统会为每个用户分配一定数量的内存，随着用户的不断增加，物理内存不堪重负。服务器开始使用磁盘的交换分区，性能直线下降，性能问题和当机接踵而至。这篇博文中所介绍的迁移到NGINX，有助于解决这一问题。
Python特别容易出现内存相关的性能问题，因为与其他脚本语言相比，Python通常是使用更多的内存来执行任务（所以执行速度快）。所以在相同条件下，与用其他语言写的应用相比，你的Python应用更容易在少量用户的情况下而“绊倒”。
优化你的应用对解决问题会有所帮助，但要解决流量相关的性能问题，这通常不是最好最快的方式。这篇博文及剩下的第二部分，将介绍一种最好并且最快的方式。在实施这些措施之后，再采取一切方法优化你的应用，或者使用微服务架构重写。
技巧 2 – 选择单服务或者微服务布署
小网站在单个服务器上就可以运行得很好。大的网站需要多个服务器。但如果你处于中间地带–或者你的网站从一个小网站变成一个大网站– 你可以做一些有趣的选择。
如果你使用单机布署，大流量和浏览激增会给你带来很大的风险。你的扩展手段非常有限，无外乎优化你的应用，把web服务切换到NGINX,使用一个更大更快的服务器，或者使用内容分发网络（CDN）。所有这些可选项的实施都耗时耗钱，而且在实施过程中还有引入bug的风险。
另外一个很显然的风险是单机布署存在单点故障问题 – 很多问题可以导致你的站点挂掉，而且没有快速简单的解决方案。
使用NGINX做为应用的代理服务
如果你把服务切换成NGINX并且使用单机布署，你可以自由地选择使用开源的NGINX或者NGINX插件。NGINX包括企业级支持和一些扩展功能。像实时活动监测这样的扩展功能是支持单机布署的。如果做为反向代理，采用分布式布署，你可以使用其他NGINX插件，如负载均衡和会话持久化。
有很多事情都要考虑周详，除非你确定你的网站在未来很长时间内都是一个小网站，不需要关心当机问题，否则，你要明白，单机布署存在很多风险。分布式布署比较易于扩展 – 单点故障可以通过工程解决，性能可以按需调整，可以快速扩充服务器能力。
技巧 3 – 使用NGINX替换你的Web服务
在Web时代的早期，Apache就是web服务的同义词。但NGINX自2000年出现以来，迅速流行开来；现在已经是排名第一的web服务，被1,000, 10,000多个网站和世界上最繁忙的100,000多个网站使用。
NGINX最初是为了解决C10K问题而开发 – 在给定内存预算下支持10,000+并发。其他web服务需要为每个连接分配内存块，所以他们会耗尽物理内存，当数以千记的用户在同一时间访问一个网站，它会变慢甚至崩溃。NGINX处理器可以单独处理一个请求，也可以优雅地扩展，同时处理多个用户。（这可以很好地解决额外问题，后面会详述。）
一个高层NGINX架构图如下所示。
NGINX 架构, 选自开源应用架构第二卷
在上图，一个Python应用服务被布署在后端的应用服务块中，如图所示，它通过FastCGI被访问。NGINX不“知道”怎么运行Python,所以它需要一个网关连结需要的环境。FastCGI是一个被PHP，Pyhton和其他语言广泛使用的接口。
但是，连结Python和NGINX的流行方案是网络服务网关接口(WSGI)。WSGI工作在多线程和多进程环境下，所以他兼容本文所提到的所有布署选项。
如果你将web服务迁移到NGINX，这里有一些有用的软件：
Configuring gunicorn – “Green Unicorn”是一个流行的WSGI服务，配合NGINX使用。
Configuring uWSGI – 另一个流行的WSGI服务,配合NGINX使用. uWSGI包含NGINX指令支持。
Using uWSGI, NGINX, and Django – 一个流行的Python web框架。
下面的代码片断将向你展示如何配置NGINX和uWSGI – 这个案例中的工程使用Python框架Django。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
http
{
...
upstream
django {
server
127.0.0.1:29000;
}
server
{
listen
80;
server_name
myapp.example.com;
root
/var/www/myapp/html;
location
/ {
index
index.html;
}
location
/static/
{
alias
/var/django/projects/myapp/static/;
}
location
/main {
include
/etc/nginx/uwsgi_params;
uwsgi_pass
django;
uwsgi_param
Host $host;
uwsgi_param
X-Real-IP $remote_addr;
uwsgi_param
X-Forwarded-For $proxy_add_x_forwarded_for;
uwsgi_param
X-Forwarded-Proto $http_x_forwarded_proto;
}
}
}
技巧 4 – 实现静态文件缓存
缓存静态内容包括：为不经常变更的文件保存副本 – 不经常是指数小时或者永远 – 副本保存在其他位置而不是应用服务中。典型的静态内容是网页中经常用到的JPEG图片。
缓存静态文件是提升应用性能的常用手段，经常被用到：
1、用户浏览器
2、互联网提供商 – 从公司网络到互联网提供商(ISP)
3、web服务, 也就是本文所讲的
在web服务端实现静态文件缓存有两个好处：
1、为用户提供快速服务 – NGINX 专门为静态文件缓存做过优化，对静态内容请求的处理比应用服务要快。
2、减少应用服务负载– 应用服务不需要处理已经缓存的静态文件，已经由web服务接管。
缓存静态文件在单服务器上也可以很好的实现，但底层硬件资源仍然是由web服务和应用服务所共享。如果web服务要处理频率的静态文件访问 – 甚至是海量 – 应用服务可以使用的硬件资源就会变少，一些功能可能就会变慢。
如果要支持浏览器缓存，需要正确设置静态文件的头部信息。如HTTPCache Control（特别是它的max age设置），Expires，和Entity标记。如果想深入了解，参见NGINX Plus的管理员指南：使用NGINX为uWSGI和Django提供应用网关
下面的NGINX配置代码用来缓存静态文件，包括JPEG文件，GIF文件，PNG文件，MP4文件，Powerpoint文件，和一些其他文件，请把替换成你自己的网址。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
server
{
#
substitute your web server's URL for
""
server_name
;
root
/var/www/example.com/htdocs;
index
index.php;
access_log
/var/log/nginx/example.com.access.log;
error_log
/var/log/nginx/example.com.error.log;
location
/ {
try_files
$uri $uri/ /index.php?$args;
}
location
~ \.php$ {
try_files
$uri =404;
include
fastcgi_params;
#
substitute the socket, or address and port, of your Python server
fastcgi_pass
unix:/var/run/php5-fpm.sock;
#fastcgi_pass
127.0.0.1:9000;
}
location
~* .(ogg|ogv|svg|svgz|eot|otf|woff|mp4|ttf|css|rss|atom|js|jpg
|jpeg|gif|png|ico|zip|tgz|gz|rar|bz2|doc|xls|exe|ppt|tar|mid
|midi|wav|bmp|rtf)$
{
expires
max;
log_not_found
off;
access_log
off;
}
}
技巧 5 – 实现微服务
微缓存可以很明显的大幅提升Python， PHP和一些其他语言开发的应用服务性能，根据是否适合缓存，可以把网页分成三类：
静态文件 – 这类文件适合缓存，见技巧4所述。
动态，非个性化页面 – 因为它们需要刷新，这些文件通常不适合做缓存。例如未登录前的电商用户所看到的页面（见下一点） – 可用商品和推荐相似商品经常要发生改变，所以必须生成新页面。但是，如果有另外一个用户，在10毫秒之后发送同样请求，将前一用户看到的网页缓存并发送给后一用户就变得合情合理。
动态，个性化页面 –这些不适合缓存，因为它们是针对具体用户的，同一个用户不希望两次看到同一个个性化页面。例如一个电商用户登录后的页面不应该展示给另外一个用户。
静态文件和非个化性动态内容可以缓存
微缓存适用于上面提到的第二类页面–动态，非个性化页面。“微”是指很短的时间。如果你的网站在一秒内要多次生成同一个页面，如果你把这个页面只缓存一秒，并不影响该页面的刷新。但这个短暂的缓存可以极大的降低应用服务的负载，特别是流量较大时。将原来在一个缓存区间内，同一内容生成10，或者20，甚至100次，调整为只生成一次并缓存，为其他用户提供缓存内容。
这个效果是很神奇的。一个服务如果一秒钟要处理大量请求会变得很慢，但如果只处理一个请求，就会变得很快。（包括任何个性化页面）。我们自己的Owen Garrett有一篇博客对微服务的优势做了详情介绍，里面还有配置代码。主要要修改的地方是把代理缓存过期时间设为一秒，只需要几行配置代码就可以搞定。
1
2
3
4
5
6
proxy_cache_path
/tmp/cache keys_zone=cache:10m levels=1:2
inactive=600s max_size=100m;
server
{
proxy_cache
cache;
proxy_cache_valid
200
1s;
...
}
更多配置样例，参见Tyler Hicks Wright关于Python和uWSGI如何使用NGINX的博客。
总结
在第一部分，我们回顾了一下在单机环境下提高Python应用性能的解决方案，还有缓存的使用，在单机情况下缓存可以应用于反向代理服务器或者独立缓存服务（缓存比独立服务性能更好）。在下一部分，我们将会介绍分布式环境下的性能提升方案。
如果你想在应用中使用更多的NGINX Plus特性，如实时事件监测，在线修改配置，你可以马上开通30天免费试用，或者联系我们，可以获得一个真实例子。
django框架中html页面怎么排版？
在数据库中存储的文件为HTML的text格式，如下
只需要在前端模板文件里使用{% autoescape off %}就可以了
结语：以上就是首席CTO笔记为大家介绍的关于django网页怎么分成四块的全部内容了，希望对大家有所帮助，如果你还想了解更多这方面的信息，记得收藏关注本站。