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

  1. 当请求一个页面时，Django会建立一个包含请求元数据的 HttpRequest 对象。 当Django 加载对应的视图时，HttpRequest 对象将作为视图函数的第一个参数。每个视图会返回一个HttpResponse 对象。

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

  1. 返回Query Set对象的方法有： 
  2. * all() 
  3. * filter() 
  4. * exclude() 
  5. * order_by() 
  6. * reverse() 
  7. * dictinct()
  9. 特殊的QuerySet: 
  10. * values() 返回一个可迭代的字典序列 
  11. * values_list() 返回一个可迭代的元祖序列
  13. 返回具体对象的： 
  14. * get() 
  15. * first() 
  16. * last()
  18. 返回布尔值的方法有： 
  19. * existe()
  21. 返回数学的方法有： 
  22. * count( )

33、only和defer的区别？

  1. defer :　映射中排除某列数据
  2. only : 仅取某个列中的数据

34、select_related和prefetch_related的区别？

  1. select_related通过多表join关联查询，一次性获得所有数据，通过降低数据库查询次数来提升性能，但关联表不能太多，因为join操作本来就比较消耗性能
  2. prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系！ 
  3. 都是为了减少SQL查询的数量
  4. title = models.CharField(max_length=32)
  6.   class UserInfo(models.Model):
  7.       name = models.CharField(max_length=32)
  8.       email = models.CharField(max_length=32)
  9.       ut = models.ForeignKey(to='UserType')
  10.       ut = models.ForeignKey(to='UserType')
  11.       ut = models.ForeignKey(to='UserType')
  12.       ut = models.ForeignKey(to='UserType')
  15.   # 1次SQL
  16.   # select * from userinfo
  17.   objs = UserInfo.obejcts.all()
  18.   for item in objs:
  19.       print(item.name)
  21.   # n+1次SQL
  22.   # select * from userinfo
  23.   objs = UserInfo.obejcts.all()
  24.   for item in objs:
  25.       # select * from usertype where id = item.id 
  26.       print(item.name,item.ut.title)
  28.   示例1:        
  29.   .select_related()
  30.       # 1次SQL
  31.       # select * from userinfo inner join usertype on userinfo.ut_id = usertype.id 
  32.       objs = UserInfo.obejcts.all().select_related('ut')
  33.       for item in objs:
  34.           print(item.name,item.ut.title)
  35.   示例2:
  36.   .prefetch_related()
  37.       # select * from userinfo where id <= 8
  38.       # 计算：[1,2]
  39.       # select * from usertype where id in [1,2]
  40.       objs = UserInfo.obejcts.filter(id__lte=8).prefetch_related('ut')
  41.       for obj in objs:
  42.           print(obj.name,obj.ut.title)
  43.   两个函数的作用都是减少查询次数

35、filter和exclude的区别？

  1. filter是查询满足条件的数据 
  2. exclude是查询不满足添加的数据

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

  1. #  1.使用execute执行自定义SQL
  2.   # from django.db import connection, connections
  3.   # cursor = connection.cursor()  # cursor = connections['default'].cursor()
  4.   # cursor.execute("""SELECT * from auth_user where id = %s""", [1])
  5.   # row = cursor.fetchone()
  7. #   2.使用extra方法 
  9.   # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
  10.   #    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
  11.   #    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
  12.   #    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
  13.   #    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
  15. #   3.使用raw方法
  16. #   　　解释：执行原始sql并返回模型
  17. #   　　说明：依赖model多用于查询
  18. #   　　用法：
  19. #   　　　　book = Book.objects.raw("select * from hello_book")
  20. #   　　　　for item in book:
  21. #   　　　　　　print(item.title)

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

  1.  class Router1:
  2.       def allow_migrate(self, db, app_label, model_name=None, **hints):
  3.           """
  4.           All non-auth models end up in this pool.
  5.           """
  6.           if db=='db1' and app_label == 'app02':
  7.               return True
  8.           elif db == 'default' and app_label == 'app01':
  9.               return True
  10.           else:
  11.               return False
  13.           # 如果返回None，那么表示交给后续的router，如果后续没有router，则相当于返回True
  15.       def db_for_read(self, model, **hints):
  16.           """
  17.           Attempts to read auth models go to auth_db.
  18.           """
  19.           if model._meta.app_label == 'app01':
  20.               return 'default'
  21.           else:
  22.               return 'db1'
  24.       def db_for_write(self, model, **hints):
  25.           """
  26.           Attempts to write auth models go to auth_db.
  27.           """
  28.           if model._meta.app_label == 'app01':
  29.               return 'default'
  30.           else:
  31.               return 'db1'

38、F和Q的作用?

  1. F：操作数据表中的某列值，F( )允许Django在未实际链接数据的情况下具有对数据库字段的值的引用，不用获取对象放在内存中再对字段进行操作，直接执行原生产sql语句操作。
  3. 通常情况下我们在更新数据时需要先从数据库里将原数据取出后方在内存里，然后编辑某些属性，最后提交
  5. Q：对对象进行复杂查询，并支持&（and）,|（or），~（not）操作符。
  6.  F:
  7.   Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
  8.   修改操作也可以使用F函数,比如将每一本书的价格提高30元
  10.   例:把所有书名后面加上(第一版)
  11.       from django.db.models.functions import Concat
  12.       from django.db.models import Value
  13.       models.Book.objects.all().update(title=Concat(F("title"), Value("("), Value("第一版"), Value(")")))
  14.   Q:
  15.   Q(条件1) | Q(条件2) 或
  16.   Q(条件1) & Q(条件2) 且
  17.   Q(条件1) & ~Q(条件2) 非

39、values和values_list的区别？

  1. values方法可以获取number字段的字典列表。
  2. values_list可以获取number的元组列表。
  3. values_list方法加个参数flat=True可以获取number的值列表。

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

  1. def bulk_create(self, objs, batch_size=None):
  2.         # 批量插入
  3.         # batch_size表示一次插入的个数
  4.         objs = [
  5.             models.DDD(name='r11'),
  6.             models.DDD(name='r22')
  7.         ]
  8.         models.DDD.objects.bulk_create(objs, 10)

41、django的Form和ModeForm的作用？

  1. - 作用：
  2.       - 对用户请求数据格式进行校验
  3.       - 自动生成HTML标签
  4.   - 区别：
  5.       - Form，字段需要自己手写。
  6.           class Form(Form):
  7.               xx = fields.CharField(.)
  8.               xx = fields.CharField(.)
  9.               xx = fields.CharField(.)
  10.               xx = fields.CharField(.)
  11.       - ModelForm，可以通过Meta进行定义
  12.           class MForm(ModelForm):
  13.               class Meta:
  14.                   fields = "__all__"
  15.                   model = UserInfo                            
  16.   - 应用：只要是客户端向服务端发送表单数据时，都可以进行使用，如：用户登录注册

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

  1. 方式一:重写构造方法，在构造方法中重新去数据库获取值
  2.   class UserForm(Form):
  3.       name = fields.CharField(label='用户名',max_length=32)
  4.       email = fields.EmailField(label='邮箱')
  5.       ut_id = fields.ChoiceField(
  6.           # choices=[(1,'二B用户'),(2,'山炮用户')]
  7.           choices=[]
  8.       )
  10.       def __init__(self,*args,**kwargs):
  11.           super(UserForm,self).__init__(*args,**kwargs)
  13.           self.fields['ut_id'].choices = models.UserType.objects.all().values_list('id','title')
  14.   方式二: ModelChoiceField字段
  15.   from django.forms import Form
  16.   from django.forms import fields
  17.   from django.forms.models import ModelChoiceField
  18.   class UserForm(Form):
  19.       name = fields.CharField(label='用户名',max_length=32)
  20.       email = fields.EmailField(label='邮箱')
  21.       ut_id = ModelChoiceField(queryset=models.UserType.objects.all())    
  23.   依赖：
  24.       class UserType(models.Model):
  25.           title = models.CharField(max_length=32)
  27.           def __str__(self):
  28.               return self.title

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

  1. on_delete有CASCADE、PROTECT、SET_NULL、SET_DEFAULT、SET()五个可选择的值
  2. CASCADE：此值设置，是级联删除。
  4. PROTECT：此值设置，是会报完整性错误。
  6. SET_NULL：此值设置，会把外键设置为null，前提是允许为null。
  8. SET_DEFAULT：此值设置，会把设置为外键的默认值。
  10. SET()：此值设置，会调用外面的值，可以是一个函数。

44、django中csrf的实现机制？

  1. Django预防CSRF攻击的方法是在用户提交的表单中加入一个csrftoken的隐含值，这个值和服务器中保存的csrftoken的值相同，这样做的原理如下:
  3. 1、在用户访问django的可信站点时，django反馈给用户的表单中有一个隐含字段csrftoken，这个值是在服务器端随机生成的，每一次提交表单都会生成不同的值
  5. 2、当用户提交django的表单时，服务器校验这个表单的csrftoken是否和自己保存的一致，来判断用户的合法性
  7. 3、当用户被csrf攻击从其他站点发送精心编制的攻击请求时，由于其他站点不可能知道隐藏的csrftoken字段的信息这样在服务器端就会校验失败，攻击被成功防御
  9. 具体配置如下：
  11. template中添加{%csrf_token%}标签

44、django中csrf的实现机制？

  1. Django预防CSRF攻击的方法是在用户提交的表单中加入一个csrftoken的隐含值，这个值和服务器中保存的csrftoken的值相同，这样做的原理如下:
  3. 1、在用户访问django的可信站点时，django反馈给用户的表单中有一个隐含字段csrftoken，这个值是在服务器端随机生成的，每一次提交表单都会生成不同的值
  5. 2、当用户提交django的表单时，服务器校验这个表单的csrftoken是否和自己保存的一致，来判断用户的合法性
  7. 3、当用户被csrf攻击从其他站点发送精心编制的攻击请求时，由于其他站点不可能知道隐藏的csrftoken字段的信息这样在服务器端就会校验失败，攻击被成功防御
  9. 具体配置如下：
  11. template中添加{%csrf_token%}标签

45、django如何实现websocket？
https://www.cnblogs.com/huguodong/p/6611602.html

46、基于django使用ajax发送post请求时，都可以使用哪种方法携带csrf token？

  1. 方法一：
  2. <script>
  3.   $(".eq").on("click",function () {
  4.         $.ajax({
  5.             url:"/eq/",
  6.             type:"POST",
  7.             data:{
  8.                 csrfmiddlewaretoken:{{ csrf_token }}, //必须写在模板中，才会被渲染
  9.                 a:$(".a").val(),
  10.                 b:$(".b").val()
  11.             },
  12.             success:function (data) {
  14.               $(".c").html(data);
  15.             }
  16.         })
  17.     })
  18. </script>
  19. 方法二：
  20. //模板页面中必须要有 {% csrf_token %}
  21. <script>
  22.     $(".eq").on("click",function () {
  23.         $.ajax({
  24.             url:"/eq/",
  25.             type:"POST",
  26.             data:{
  27.                 csrfmiddlewaretoken:$("input:first").val(),
  28.                 a:$(".a").val(),
  29.                 b:$(".b").val()
  30.             },
  31.             success:function (data) {
  33.               $(".c").html(data);
  34.             }
  35.         })
  36.     })
  37. </script>
  38. 方法三：
  39. <script src="/static/jquery.cookie.js"></script> //必须先引入它
  40. <script>
  41.     $("#btn").on("click",function () {
  42.      $.ajax({
  43.         url:"/lianxi/",
  44.         type:"POST",
  45.         headers:{"X-CSRFToken":$.cookie('csrftoken')},
  46.         data:$("#f1").serialize()
  47.     }
  48.     )
  49.     })
  51. </script>

47、django中如何实现orm表中添加数据时创建一条日志记录。

  1. 在settings.py中添加：
  2. LOGGING = {
  3.     'disable_existing_loggers': False,
  4.     'version': 1,
  5.     'handlers': {
  6.         'console': {
  7.             # logging handler that outputs log messages to terminal
  8.             'class': 'logging.StreamHandler',
  9.             'level': 'DEBUG', # message level to be written to console
  10.         },
  11.     },
  12.     'loggers': {
  13.         '': {
  14.             # this sets root level logger to log debug and higher level
  15.             # logs to console. All other loggers inherit settings from
  16.             # root level logger.
  17.             'handlers': ['console'],
  18.             'level': 'DEBUG',
  19.             'propagate': False, # this tells logger to send logging message
  20.                                 # to its parent (will send if set to True)
  21.         },
  22.         'django.db': {
  23.             # # django also has database level logging
  24.             'handlers': ['console'],
  25.             'level': 'DEBUG',
  26.             'propagate': False,
  27.         },
  28.     },
  29. }

48、django缓存如何设置？

  1.       三种粒度缓存
  2.    1 中间件级别
  3.        'django.middleware.cache.UpdateCacheMiddleware',
  4.        'django.middleware.cache.FetchFromCacheMiddleware',
  5.         CACHE_MIDDLEWARE_SECONDS=10
  7.    2 视图级别
  9.       from django.views.decorators.cache import cache_page
  10.       @cache_page(15)
  11.       def index(request):
  12.           import time
  13.           t=time.time()
  14.           return render(request,"index.html",locals())
  17.    3 局部缓存
  18.       {% load cache %}
  19.           ...
  20.           ...
  21.       {% cache 15 "time_cache" %}
  22.       <h3>缓存时间:{{ t }}</h3>
  23.       {% endcache %}

49、django的缓存能使用redis吗？如果可以的话，如何配置？

  1.   pip install django-redis  
  2.   apt-get install redis-server
  4.   然后在settings.py 里面添加CACHES = {
  5.   'default': {
  6.       'BACKEND': 'redis_cache.cache.RedisCache',
  7.       'LOCATION': '127.0.0.1:6379',
  8.       "OPTIONS": {
  9.           "CLIENT_CLASS": "redis_cache.client.DefaultClient",
  10.       },
  11.   }
  12. 在类中引用
  13. conn = get_redis_connection("default")

50、django路由系统中name的作用？

  1. name 可以用于在 templates, models, views ……中得到对应的网址，相当于“给网址取了个小名”，只要这个名字不变，网址变了也能通过名字获取到。

51、django的模板中filter和simple_tag的区别？

  1. simple_tag 
  2. 　　-参数任意，但是不能作为if条件判断的条件 
  3. filter 
  4. 　　-参数最多只能有两个，但是可以作为if条件判断的条件。

52、django-debug-toolbar的作用？

  1. django_debug_toolbar 是django的第三方工具包，给django扩展了调试功能。 
  2. 包括查看执行的sql语句，db查询次数，request，headers，调试概览等。

53、django中如何实现单元测试？

  1. https://blog.csdn.net/weixin_39198406/article/details/78821677
  2. 对于每一个测试方法都会将setUp()和tearDown()方法执行一遍
  3. 会单独新建一个测试数据库来进行数据库的操作方面的测试，默认在测试完成后销毁。
  4. 在测试方法中对数据库进行增删操作，最后都会被清除。也就是说，在test_add中插入的数据，在test_add测试结束后插入的数据会被清除。
  5. django单元测试时为了模拟生产环境，会修改settings中的变量，例如, 把DEBUG变量修改为True, 把ALLOWED_HOSTS修改为[*]。

https://blog.csdn.net/weixin_39198406/article/details/78821677
53、django中如何实现单元测试？

  1. 对于每一个测试方法都会将setUp()和tearDown()方法执行一遍
  2. 会单独新建一个测试数据库来进行数据库的操作方面的测试，默认在测试完成后销毁。
  3. 在测试方法中对数据库进行增删操作，最后都会被清除。也就是说，在test_add中插入的数据，在test_add测试结束后插入的数据会被清除。
  4. django单元测试时为了模拟生产环境，会修改settings中的变量，例如, 把DEBUG变量修改为True, 把ALLOWED_HOSTS修改为[*]。

https://www.jianshu.com/p/34267dd79ad6
54、解释orm中 db first 和 code first的含义？

  1. datebase first就是代表数据库优先，那么前提就是先创建数据库。 
  2. model first就是代表model优先，那么前提也就是先创建model，然后根据model自动建立数据库。

55、django中如何根据数据库表生成model中的类？

https://jingyan.baidu.com/article/4ae03de3e513d23eff9e6bb7.html

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

  1. ORM框架：
  3. 　　对象关系映射，通过创建一个类，这个类与数据库的表相对应！类的对象代指数据库中的一行数据。
  5. 简述ORM原理：
  7. 　　让用户不再写SQL语句，而是通过类以及对象的方式，和其内部提供的方法，进行数据库操作！把用户输入的类或对象转换成SQL语句，转换之后通过pymysql执行完成数据库的操作。
  9. ORM的优缺点：
  11. 优点： 
  12. * 提高开发效率，降低开发成本 
  13. * 使开发更加对象化 
  14. * 可移植 
  15. * 可以很方便地引入数据缓存之类的附加功能
  17. 缺点： 
  18. * 在处理多表联查、where条件复杂之类的查询时，ORM的语法会变得复杂。就需要写入原生SQL。

57、简述MVC和MTV

  1. MVC： 模型 视图 控制器 
  2. MTV： 模型 模板 视图

58、django的contenttype组件的作用？

  1.  contenttype是django的一个组件（app），为我们找到django程序中所有app中的所有表并添加到记录中。
  3.         可以使用他再加上表中的两个字段实现：一张表和N张表创建FK关系。
  4.             - 字段：表名称
  5.             - 字段：数据行ID

59、谈谈你对restfull 规范的认识？

  1. - restful其实就是一套编写接口的协议，协议规定如何编写以及如何设置返回值、状态码等信息。
  2.     - 最显著的特点：
  3.         restful: 给用户一个url，根据method不同在后端做不同的处理，比如：post 创建数据、get获取数据、put和patch修改数据、delete删除数据。
  4.         no rest: 给调用者很多url，每个url代表一个功能，比如：add_user/delte_user/edit_user/
  5.     - 当然，还有协议其他的，比如：
  6.         - 版本，来控制让程序有多个版本共存的情况，版本可以放在 url、请求头（accept/自定义）、GET参数
  7.         - 状态码，200/300/400/500
  8.         - url中尽量使用名词，restful也可以称为“面向资源编程”
  9.         - api标示：
  10.             api.YueNet.com
  11.             www.YueNet.com/api/
  12.   -------------------------------------------------
  13.     - https
  14.     - 域名 
  15.         - api.twiss.com
  16.         - www.twiss.com/api
  17.     - 版本：
  18.         - www.twiss.com/api/v1
  20.     - URL资源，名词
  21.         - www.twiss.com/api/v1/student
  23.     - 请求方式：
  24.         - GET/POST/PUT/DELETE/PATCH/OPTIONS/HEADERS/TRACE
  25.     - 返回值：
  26.         - www.twiss.com/api/v1/student/    -> 结果集
  27.         - www.twiss.com/api/v1/student/1/  -> 单个对象
  28.     - URL添加条件
  29.         - www.twiss.com/api/v1/student？page=11&size=9
  30.     - 状态码：  
  31.         - 200
  32.         - 300
  33.             - 301
  34.             - 302
  35.         - 400
  36.             - 403
  37.             - 404
  38.         - 500
  39.     - 错误信息
  40.         {
  41.             code:1000,
  42.             meg:'xxxx'
  43.         }
  44.     - hyperlink
  45.         {
  46.             id：1
  47.             name: ‘xiangl’,
  48.             type: http://www.xxx.com/api/v1/type/1/
  49.         }

60、接口的幂等性是什么意思？

  1.  一个接口通过首先进行1次访问，然后对该接口进行N次相同访问的时候，对访问对象不造成影响，那么就认为接口具有幂等性。
  2.   比如：
  3.       GET，  第一次获取数据、第二次也是获取结果，幂等。
  4.       POST， 第一次新增数据，第二次也会再次新增，非幂等。
  5.       PUT，  第一次更新数据，第二次不会再次更新，幂等。
  6.       PATCH，第一次更新数据，第二次可能再次更新，非幂等。
  7.       DELTE，第一次删除数据，第二次不会再次删除，幂等。