Django学习笔记-CSDN博客

功能完善、要素齐全：该有的、可以没有的都有，自带大量常用工具和框架，无须你自定义、组合、增删及修改。
完善的文档：经过十多年的发展和完善，Django有广泛的实践案例和完善的在线文档。开发者遇到问题时可以搜索在线文档寻求解决方案。
强大的数据库访问组件：Django的Model层自带数据库ORM组件，使得开发者无须学习其他数据库访问技术（SQL、pymysql、SQLALchemy等）。
灵活的URL映射：Django使用正则表达式管理URL映射，灵活性高。新版的2.0，进一步提高了URL编写的优雅性。
丰富的Template模板语言：类似jinjia模板语言，不但原生功能丰富，还可以自定义模板标签，并且与其ORM的用法非常相似。
自带后台管理系统admin：只需要通过简单的几行配置和代码就可以实现一个完整的后台数据管理控制平台。
完整的错误信息提示：在开发调试过程中如果出现运行错误或者异常，Django可以提供非常完整的错误信息帮助定位问题。

什么是wsgi？

WSGI是Python在处理HTTP请求时，规定的一种处理方式。当一个HTTP Request过来了，WSGI就是规定这个处理函数来进行处理和返回结果。简单而言，WSGI就是规定了处理函数的输入和输出格式。

django请求的生命周期？

当用户在浏览器中输入url时,浏览器会生成请求头和请求体发给服务端
url经过Django中的wsgi,再经过中间件,最后url到过路由映射表,在路由中一条一条进行匹配
视图函数根据客户端的请求查询相应的数据返回给Django,然后Django把服务端想要的数据做为一个字符串返回给客户端.
客户端浏览器接收到返回的数据,经过渲染后显示给用户.

M 代表模型（Model）：负责业务对象和数据库的关系映射(ORM)。
T 代表模板 (Template)：负责如何把页面展示给用户(html)。
V 代表视图（View）：负责业务逻辑，并在适当时候调用Model和Template

列举django的内置组件？

Admin是对model中对应的数据表进行增删改查提供的组件
model组件：负责操作数据库
form组件：1.生成HTML代码 2.数据有效性校验 3.校验信息返回并展示
ModelForm组件即用于数据库操作,也可用于用户请求的验证

modelform和form组件区别：

模型表单（ModelForm）：

依赖模型数据库，能够自动创建表单字段和验证规则并处理与模型实例的保存和更新

1 自动创建表单字段 2 自动验证规则 3 处理模型的保存和更新

普通表单（Form）：

允许你自由地定义表单字段和验证规则，并处理表单数据的提交

1 自由定义字段和验证规则

2 不处理模型的保存和更新

3 只负责接收和验证表单数据，将数据传递给视图函数

列举django中间件的5个方法？以及django中间件的应用场景？

process_request : 请求进来时,权限认证
process_view : 路由匹配之后,能够得到视图函数
process_exception : 异常时执行
process_template_responseprocess : 模板渲染时执行
.process_response : 请求有响应时执行

简述什么是FBV和CBV？

FBV和CBV本质是一样的，基于函数的视图叫做FBV，基于类的视图叫做CBV

在python中使用CBV的优点：

- 提高了代码的复用性，可以使用面向对象的技术，比如Mixin（多继承）

- 可以用不同的函数针对不同的HTTP方法处理，而不是通过很多if判断，提高代码可读性

django的request对象是在什么时候创建的？

class WSGIHandler(base.BaseHandler):

-------request = self.request_class(environ)

# 请求走到WSGIHandler类的时候，执行cell方法，将environ封装成了request

如何给CBV的程序添加装饰器？

from django.utils.decorators import method_decorator
1、给方法加：
    @method_decorator(check_login)
    def post(self, request):
        ...
2、给dispatch加：
    @method_decorator(check_login)
    def dispatch(self, request, *args, **kwargs):
        ...
3、给类加：
    @method_decorator(check_login, name="get")
    @method_decorator(check_login, name="post")
    class HomeView(View):
        ...

列举django orm 中所有的方法（QuerySet对象的所有方法）

<1> all(): 查询所有结果
<2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象。获取不到返回None
<3> get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个。如果符合筛选条件的对象超过一个或者没有都会抛出错误。
<4> exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
<5> order_by(*field): 对查询结果排序
<6> reverse(): 对查询结果反向排序
<8> count(): 返回数据库中匹配查询(QuerySet)的对象数量。
<9> first(): 返回第一条记录
<10> last(): 返回最后一条记录
<11> exists(): 如果QuerySet包含数据，就返回True，否则返回False
<12> values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系 model的实例化对象，而是一个可迭代的字典序列
<13> values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
<14> distinct(): 从返回结果中剔除重复纪录

列举django orm中三种能写sql语句的方法

1.使用execute执行自定义的SQL 直接执行SQL语句（类似于pymysql的用法） # 更高灵活度的方式执行原生SQL语句
from django.db import connection

cursor = connection.cursor() 
cursor.execute("SELECT DATE_FORMAT(create_time, '%Y-%m') FROM blog_article;") 
ret = cursor.fetchall() 
print(ret)
2.使用extra方法：queryset.extra(select={"key": "原生的SQL语句"})

3.使用raw方法 1.执行原始sql并返回模型 2.依赖model多用于查询

values和values_list的区别？

values : queryset类型的列表中是字典
values_list : queryset类型的列表中是元组

如何使用django orm批量创建数据？

objs=[models.Book(title="图书{}".format(i+15)) for i in range(100)] models.Book.objects.bulk_create(objs)

django的Form组件中,若字段包含choices参数，请使用两种方式实现数据源实时更新

1.重写构造函数

def__init__(self, *args, **kwargs):
     super().__init__(*args, **kwargs)
     self.fields["city"].widget.choices = models.City.objects.all().values_list("id", "name")

2.利用ModelChoiceField字段,参数为queryset对象

authors = form_model.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())
//多选

django的Model中的ForeignKey字段中的on_delete参数有什么作用？

删除关联表中的数据时,当前表与其关联的field的操作
django2.0之后，表与表之间关联的时候,必须要写on_delete参数,否则会报异常

jango的模板中自定义filter和simple_tag的区别？

自定义filter：{{ 参数1|filter函数名:参数2 }}

可以与if标签来连用
自定义时需要写两个形参

1. 在app01下创建一个叫templatetags的Python包
2. 在templatetags的文件夹下创建py文件  myfilters
3. 在py文件中写代码
    from django import template
    register = template.Library()
    
    @register.filter
    def add_sb(value,arg='aaa'):
        return "{}_sb_{}".formart(value,arg)
        
    @register.filter(name='sb')
    def add_sb(value,arg='aaa'):
        return "{}_sb_{}".formart(value,arg)     
4. 使用自定义filter
    {% load myfilters %}
    {{ name|add_sb:'xxx'}}
    {{ name|sb:'xxx'}}

simple_tag:{% simple_tag函数名参数1 参数2 %}
可以传多个参数,没有限制
不能与if标签来连用

例子：自定义simpletag
    创建
        1 、在app01中创建一个名字是templatetags的包，
        2、在包中创建一个py文件
        3、在py文件中导入
              from django import template
              register = template.Library()
        4、写函数
              @register.simple_tag(name="plus")
              def plus(a,b,c):
                  return '{}+{}+{}'.format(a,b,c)
        5、加装饰器@register.simple_tag(name="plus")
  使用
      1、导入
            {% load mytag %}
      2、使用
           {% plus 1 2 3 %}

Django本身提供了runserver，为什么不能用来部署？(runserver与uWSGI的区别)

1.runserver方法是调试 Django 时经常用到的运行方式，它是Django自带的

2.uWSGI是一个Web服务器，它实现了WSGI协议、uwsgi、http 等协议。注意uwsgi是一种通信协议，而uWSGI是实现uwsgi协议和WSGI协议的 Web 服务器。uWSGI具有超快的性能、低内存占用和多app管理等优点，并且搭配着Nginx就是一个生产环境了，能够将用户访问请求与应用 app 隔离开，实现真正的部署。相比来讲，支持的并发量更高，方便管理多进程，发挥多核的优势，提升性能

Django如何实现websocket？

django实现websocket官方推荐大家使用channels。channels通过升级http协议升级到websocket协议。保证实时通讯。也就是说，我们完全可以用channels实现我们的即时通讯。而不是使用长轮询和计时器方式来保证伪实时通讯。他通过改造django框架，使django既支持http协议又支持websocket协议。

说一下Django，MIDDLEWARES中间件的作用和应用场景？

中间件是介于request与response处理之间的一道处理过程,用于在全局范围内改变Django的输入和输出。

简单的来说中间件是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作

例如：

(1.Django项目中默认启用了csrf保护,每次请求时通过CSRF中间件检查请求中是否有正确#token值

(2.当用户在页面上发送请求时，通过自定义的认证中间件，判断用户是否已经登陆，未登陆就去登陆。

(3.当有用户请求过来时，判断用户是否在白名单或者在黑名单里

django中csrf的实现机制

第一步：django第一次响应来自某个客户端的请求时,后端随机产生一个token值，把这个token保存在SESSION状态中;同时,后端把这个token放到cookie中交给前端页面；

第二步：下次前端需要发起请求（比如发帖）的时候把这个token值加入到请求数据或者头信息中,一起传给后端；Cookies:{csrftoken:xxxxx}

第三步：后端校验前端请求带过来的token和SESSION里的token是否一致；

1.cookie:

cookie是保存在浏览器端的键值对,可以用来做用户认证

2.session：

将用户的会话信息保存在服务端,key值是随机产生的自符串,value值时session的内容

依赖于cookie将每个用户的随机字符串保存到用户浏览器上0

Django中session默认保存在数据库中：django_session表flask,session默认将加密的数据写在用户的cookie中

django orm 中如何设置读写分离？

1.手动读写分离:通过 using(db_name)来指定要使用的数据库

（一）手动读写分离

1. 在使用数据库时，通过.using(db_name)来手动指定要使用的数据库

优点：不需要进行其余的配置，只需要通过.using(db_name)来手动指定要使用的数据库就行。

缺点：在大量的对数据库进行操作之后，此种方法繁琐

from django.shortcuts import HttpResponse
from . import models

def write(request):
    models.Products.objects.using('default').create(prod_name='熊猫公仔', prod_price=12.99)
    return HttpResponse('写入成功')


def read(request):
    obj = models.Products.objects.filter(id=1).using('db2').first()
    return HttpResponse(obj.prod_name)

自动读写分离:

(二）自动读写分离

通过配置数据库路由，来自动实现，这样就不需要每次读写都手动指定数据库了。数据库路由中提供了四个方法。这里这里主要用其中的两个：def db_for_read()决定读操作的数据库，def db_for_write()决定写操作的数据库。

# 新建myrouter.py脚本，定义Router类：
class Router:
    def db_for_read(self, model, **hints):
        return 'db2'

    def db_for_write(self, model, **hints):
        return 'default'

配置Router
在settings.py中指定DATABASE_ROUTERS
DATABASE_ROUTERS = ['myrouter.Router',]

提高读的性能：多配置几个数据库,并在读取时,随机选取。写的时候写到主库

实现app之间的数据库分离：分库分表

使用orm和原生sql的优缺点？

1.orm的开发速度快,操作简单。使开发更加对象化

执行速度慢。处理多表联查等复杂操作时,ORM的语法会变得复杂

2.sql开发速度慢,执行速度快。性能强

谈谈你对restful规范的认识？

首先restful是一种软件架构风格或者说是一种设计风格，并不是标准，它只是提供了一组设计原则和约束条件，主要用于客户端和服务器交互类的软件。

就像设计模式一样，并不是一定要遵循这些原则，而是基于这个风格设计的软件可以更简洁，更有层次

它里面提到了一些规范，例如：

1.restful 提倡面向资源编程,在url接口中尽量要使用名词，不要使用动词

2、在url接口中推荐使用Https协议，让网络接口更加安全Bootstrap中文网？page=3

（Https是Http的安全版，即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL（安全套接层协议））

二者区别： HTTP协议以明文方式发送内容，不提供任何方式的数据加密。HTTP协议不适合传输一些敏感信息，比如：信用卡号、密码等支付信息。https则是具有安全性的ssl加密传输协议。http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。并且https协议需要到ca申请证书。HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，要比http协议安全。

3、在url中可以体现版本号https://v1.bootcss.com/mycss不同的版本可以有不同的接口，使其更加简洁，清晰

4、url中可以体现是否是API接口

5、url中可以添加条件去筛选匹配？page=n

6、可以根据Http不同的method，进行不同的资源操作（5种方法：GET / POST / PUT / DELETE / PATCH）

7、响应式应该设置状态码

8、有返回值，而且格式为统一的json格式

9、返回错误信息返回值携带错误信息

10、返回结果中要提供帮助链接，即API最好做到Hypermedia如果遇到需要跳转的情况携带调转接口的URL

简述Django对http请求的执行流程（初级）

在接受一个Http请求之前的准备,需启动一个支持WSGI网关协议的服务器监听端口等待外界的Http请求，比如Django自带的开发者服务器或者uWSGI服务器。

Django服务器根据WSGI协议指定相应的Handler来处理Http请求。

此时服务器已处于监听状态，可以接受外界的Http请求,当一个http请求到达服务器的时候,Django服务器根据WSGI协议从Http请求中提取出必要的参数组成一个字典（environ）并传入Handler中进行处理。

在Handler中对已经符合WSGI协议标准规定的http请求进行分析，比如加载Django提供的中间件，路由分配，调用路由匹配的视图等。

最后返回一个可以被浏览器解析的符合Http协议的HttpResponse。

django中session的运行机制是什么？（初级）

django的session存储可以利用中间件来实现。

需要在 settings.py 文件中注册APP、设置中间件用于启动。

设置存储模式（数据库/缓存/混合存储）和配置数据库缓存用于存储，生成django_session表单用于读写。

什么是跨域请求，其有哪些方式？跨域请求Django是如何处理的？（初级）

跨域是指一个域下的文档或脚本试图去请求另一个域下的资源。

方式如下：

资源跳转： a链接、重定向、表单提交
资源嵌入： link/script/img/frame/dom等标签，还有样式中background:url()、@font-face()等文件外链
脚本请求： js发起的ajax请求、dom和js对象的跨域操作

使用第三方工具 django-cors-headers 即可彻底解决

注册app
添加中间件
配置运行跨域请求方法

什么是信号量？（初级）

Django包含一个"信号调度程序"，它有助于在框架中的其他位置发生操作时通知分离的应用程序。

简而言之，信号允许某些发送者通知一组接收器已经发生了某些动作

web框架的本质是什么？（初级）

web框架本质是一个socket服务端，用户的浏览器是一个socket客户端。

Django中如何加载初始化数据？（初级）

Django在创建对象时在调用save()方法后，ORM框架会把对象的属性写入到数据库中，实现对数据库的初始化。

通过操作对象，查询数据库，将查询集返回给视图函数，通过模板语言展现在前端页面。

Django中如何加载初始化数据？（初级）

Django在创建对象时在调用save()方法后，ORM框架会把对象的属性写入到数据库中，实现对数据库的初始化。

通过操作对象，查询数据库，将查询集返回给视图函数，通过模板语言展现在前端页面。

Django缓存系统类型有哪些？（初级）

全站缓存，较少使用

MIDDLEWARE_CLASSES = (
    ‘django.middleware.cache.UpdateCacheMiddleware’,  # 第一
    'django.middleware.common.CommonMiddleware',
    ‘django.middleware.cache.FetchFromCacheMiddleware’,  # 最后
)

视图缓存，用户视图函数或视图类中
from django.views.decorators.cache import cache_page import time @cache_page(15) #超时时间为15秒 def index(request): t=time.time() #获取当前时间 return render(request,"index.html",locals())
模板缓存，指缓存不经常变换的模板片段

{% load cache %}
    <h3 style="color: green">不缓存:-----{{ t }}</h3>

{% cache 2 'name' %} # 存的key
    <h3>缓存:-----:{{ t }}</h3>
{% endcache %}

请简述Django下的（内建）缓存机制（初级）

Django根据设置的缓存方式，浏览器第一次请求时，cache会缓存单个变量或整个网页等内容到硬盘或者内存中，同时设置response头部。

当浏览器再次发起请求时，附带f-Modified-Since请求时间到Django。

Django发现f-Modified-Since会先去参数之后，会与缓存中的过期时间相比较，如果缓存时间比较新，则会重新请求数据，并缓存起来然后返回response给客户端。

如果缓存没有过期，则直接从缓存中提取数据，返回给response给客户端。

什么是ASGI，简述WSGI和ASGI的关系与区别？（初级）

ASGI是异步网关协议接口，一个介于网络协议服务和Python应用之间的标准接口，能够处理多种通用的协议类型，包括HTTP，HTTP2和WebSocket。

WSGI是基于HTTP协议模式的，不支持WebSocket，而ASGI的诞生则是为了解决Python常用的WSGI不支持当前Web开发中的一些新的协议标准。

同时，ASGI对于WSGI原有的模式的支持和WebSocket的扩展，即ASGI是WSGI的扩展。

urlpatterns中的name与namespace的区别（初级）

name:给路由起一个别名

namespace:防止多个应用之间的路由重复

Django路由系统中include是干嘛用的？（初级）

include用作路由转发，通常，我们会在每个app里，各自创建一个urls.py路由模块，然后从根路由出发，将app所属的url请求，全部转发到相应的urls.py模块中。

class Meta中的元信息字段有哪些？（初级）

Model类可以通过元信息类设置索引和排序信息
元信息是在Model类中定义一个Meta子类

class Meta中的元信息字段有哪些？（初级）
1. Model类可以通过元信息类设置索引和排序信息
2. 元信息是在Model类中定义一个Meta子类
class Meta:
    # ---常用
    db_table = 'table_name'             # 自定义表名
    index_together = ('tag1', 'tag2')   # 联合索引
    unique_together = ('tag3', 'tag4')  # 联合唯一索引
    verbose_name = 'table_name'         # /admin/中显示的表名称
    verbose_name_plural = verbose_name 
    ordering = 'ordering_tag'           # 排序字段#这个选项是指定，模型的复数形式是什么
    abstract =True

Django模型类关系有哪几种？（初级）

一对一关系：OneToOneField
一对多关系：ForeignKey
多对多关系：ManyToManyField

外键有什么用，什么时候合适使用外键，外键一定需要索引吗？（中级）

程序很难100％保证数据的完整性,而用外键即使在数据库服务器宕机或异常的时候,也能够最大限度的保证数据的一致性和完整性。
如果项目性能要求不高,安全要求高,建议使用外键，如果项目性能要求高,安全自己控制，不用外键，因为外键查询比较慢。
加入外键的主要问题就是影响性能,因此加入索引能加快关联查询的速度。

Primary Key和Unique Key的区别？（中级）

Primary key与Unique Key都是唯一性约束。
Primary key是主键，一个表只能由一个，Unique key是唯一键，一个表可以有多个唯一键字段。
Primary key 必须不能为空，Unique Key 可为空。

当删除一个外键的时候，其关联的表有几种处理方式？（初级）

当删除一个外键的时候，其关联的表有几种处理方式？（初级）
有6种处理方式：
同时删除父表和子表
CASCADE：代表删除联级，父表（少类表）被删除的记录在子表（多类表）中所有字段也会被对应删除，模拟SQL语言中的ON DELETE CASCADE约束，将定义有外键的模型对象同时删除！（该操作为当前Django版本的默认操作！）
阻止删除父表
PROTECT：阻止上面的删除操作，但是弹出ProtectedError异常
子表设置为空
SET_NULL：代表父表（少类表）被删除后子表（多类表）对应的外键字段会设置为null，只有当字段设置了null=True，blank=True时，方可使用该值。
子表设置为默认值
SET_DEFAULT:代表父表（少类表）被删除后子表（多类表）对应的外键字段会设置为默认值。只有当字段设置了default参数时，方可使用。
子表什么都不做
DO_NOTHING：什么也不做，一切看数据库级别的约束
设置为一个传递给SET()的值或者一个回调函数的返回值
SET()：设置为一个传递给SET()的值或者一个回调函数的返回值。注意大小写，用得很少。

如何通过外键，子表查询父表和父表查询子表

#父表和子表关系如下：
from django.db import models
 
class Person(models.Model):
    name = models.CharField(max_length=64)
    age = models.IntegerField()
    tel = models.CharField(max_length=64)
 
    @property
    def all_cars(self):
        '''返回全部信息'''
        return self.cars.all()
 
    @property
    def info(self):
        '''返回部分信息'''
        return '%s %s' % (self.name, self.tel)
 class Car(models.Model):
    owner = models.Foreignkey(Person, related_name='cars')
    name = models.CharField(max_length=64)
    price = models.FloatField()

子表查询父表
car = Car.objects.get(id=1)
# 查询该车的车主
owner = car.owner

父表查询子表
Tom = Person.objects.get(id=1)
# 查询此人有多少车
# 方式一:
# Django默认每个主表对象都有一个外键的属性，可以通过它来查询所有属于主表的子表信息
# 查询方式：主表.子表_set()，返回值为一个queryset对象
Tom.Car_set().all()
# 方式二：
# 通过在外键中设置related_name属性值既可
Tom.cars.all()
# 方式三：
# 通过@property装饰器在model中预定义方法实现
Tom.all_cars

ORM如何取消级联？（初级）

user = models.ForeignKey(User,blank=True,null=True,on_delete=models.SET_NULL)

在父表被删除，null为True的时候就会取消级联。

查询集的2大特性？什么是惰性执行？（中级）

特性：

惰性执行
缓存

惰性执行是指创建查询集不会访问数据库，直到调用数据时，才会访问数据库。

select_related和prefetch_related的区别？


前提：有外键存在时，可以很好的减少数据库请求的次数,提高性能
select_related通过多表join关联查询,一次性获得所有数据,只执行一次SQL查询
prefetch_related分别查询每个表,然后根据它们之间的关系进行处理,执行两次查询
原理：select_related是在外键关联的对象确定只有一个的情况下才能使用，prefetch_related则不管外键关联的对象有几个，全部可以使用，因为它取的是一个集合(多对一时，多的一方外键仅关联一个对象；而多对多时，任何一方外键都关联多个对象)
简单记忆：在关联的外键可能指向多个数据对象时，prefetch_related是唯一选择，而在外键指向的是一个唯一对象时，select_related方法明显要比prefetch_related高效，虽然prefetch_related也能用

在Django中当创建一个查询集的时候，并没有跟数据库发生任何交互，只有在访问Queryset的内容的时候，Django才会真正进行数据库的访问。
而多频率、复杂的数据库查询往往是性能问题最大的根源。
在查询对象集合的时候，把指定的外键对象也一并完整查询加载，避免后续的重复查询。
使用 select_related() 和 prefetch_related() 可以很好的减少数据库请求的次数，从而提高性能。
 select_related适用于一对一字段（OneToOneField）和外键字段（ForeignKey）查询；
 prefetch_related适用多对多字段（ManyToManyField）和一对多字段的查ngi询。

Django中查询Q和F的区别？

Q查询：对数据的多个字段联合查询（常和且或非"& | ~"进行联合使用）

F查询：对数据的不同字段进行比较（常用于比较和更新，对数据进行加减操作）

常用视图响应的方式有哪些？


常用视图响应的方式有4种方式redirect、Response、HttpResponse和JsonResponse
return Response(content=响应体, content_type=响应体数据类型, status=状态码)
return HttpResponse(content=响应体, content_type=响应体数据类型, status=状态码) 
return JsonResponse({‘city’: ‘beijing’, ‘subject’: ‘python’},status=response.status_code)
return redirect(‘/index.html’)

如何提高Django应用程序的性能？（高级）

前端优化

1.减少 http 请求，减少数据库的访问量，比如使用雪碧图。

2.使用浏览器缓存，将一些常用的 css，js，logo 图标，这些静态资源缓存到本地浏览器，通过设置 http 头中的 cache-control 和 expires 的属性，可设定浏览器缓存，缓存时间可以自定义。

3.对 html，css，javascript 文件进行压缩，减少网络的通信量。

后端优化

1.合理的使用缓存技术，对一些常用到的动态数据，比如首页做一个缓存，或者某些常用的数据做个缓存，设置一定得过期时间，这样减少了对数据库的压力，提升网站性能。

2.使用 celery 消息队列，将耗时的操作扔到队列里，让 worker 去监听队列里的任务，实现异步操作，比如发邮件，发短信。

3.就是代码上的一些优化，补充：nginx 部署项目也是项目优化，可以配置合适的配置参数，提升效率，增加并发量。

4.如果太多考虑安全因素，服务器磁盘用固态硬盘读写，远远大于机械硬盘，这个技术现在没有普及，主要是固态硬盘技术上还不是完全成熟，相信以后会大量普及。

django 信号量机制

Django有一个信号调度器(signal dispatcher)，用来帮助解耦的应用获知框架内任何其他地方发生的操作。简单地说，信号允许某些发送器去通知一组接收器某些操作发生了。当许多代码段都可能对同一事件感兴趣时，信号特别有用

django缓存如何设置

CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.dummy.DummyCache',  # 缓存后台使用的引擎
  'TIMEOUT': 300,            # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）
  'OPTIONS':{
   'MAX_ENTRIES': 300,          # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  },
 }
}

django路由系统中name的作用

主要是通过name的值，来查找url地址，可以理解为反射作用。在html模板中使用name来反射url优势就是后期url规则发生改变之后，只需调整urls.py即可，所有的模板文件都不需要修改。

谈一下你对 uWSGI 和 Nginx 的理解

1.定义：

1）uWSGI 是一个 Web 服务器，它实现了 WSGI 协议、uwsgi、http 等协议。（2）Nginx 是一个开源的高性能的 HTTP 服务器和反向代理。Nginx 中HttpUwsgiModule 的作用是与 uWSGI 服务器进行交换。

注意 WSGI / uwsgi / uWSGI 这三个概念的区分。

WSGI 是一种通信协议。 uwsgi 是一种线路协议而不是通信协议，在此常用于在 uWSGI 服务器与其他网络服务器的数据通信。 uWSGI 是实现了 uwsgi 和 WSGI 两种协议的 Web 服务器。

django 开发中数据库做过什么优化

（1）设计表时，尽量少使用外键，因为外键约束会影响插入和删除性能；（2）使用缓存，减少对数据库的访问；（3）在 orm 框架下设置表时，能用 varchar 确定字段长度时，就别用 text；（4）可以给搜索频率高的字段属性，在定义时创建索引；（5）Django orm 框架下的 Querysets 本来就有缓存的；（6）如果一个页面需要多次连接数据库，最好一次性取出所有需要的数据，减少对数据库的查询次数；（7）若页面只需要数据库里某一个两个字段时，可以用 QuerySet.values()；（8）在模板标签里使用 with 标签可以缓存 Qset 的查询结果。

django 如何提升性能（实现高并发）

（1）合理的使用缓存技术，对一些常用到的动态数据，比如首页做一个缓存，或者某些常用的数据做个缓存，设置一定得过期时间，这样减少了对数据库的压力，提升网站性能。（2）使用 celery 消息队列，将耗时的操作扔到队列里，让 worker 去监听队列里的任务，实现异步操作，比如发邮件，发短信。

（3）就是代码上的一些优化，补充：Nginx 部署项目也是项目优化，可以配置合适的配