复习单列，sql orm
不管用什么都是基于httpRespone
url控制器，
Django框架的设计模式借鉴了MVC框架的思想，也是分成三部分，来降低各个部分之间的耦合性。
MTV
templates view models
Model(模型)：负责业务对象与数据库的对象(ORM)
Template(模版)：负责如何把页面展示给用户
View(视图)：负责业务逻辑，并在适当的时候调用Model和Template
此外，Django还有一个urls分发器，它的作用是将一个个URL的页面请求分发给不同的view处理，view再调用相应的Model和Template
2,AJAX
----------------contentType 上传文件指定False（编码格式）
3 forms 组件 局部钩子，全局钩子
4，cookie，session，
Session
1. 浏览器请求来了之后，服务端给你分配一个序号（口令）
2. 浏览器收到响应之后，把得到的口令保存在 cookie
3. 浏览器携带着刚才得到的口令，再次发送请求
4. 服务端拿到口令，去后端根据口令找对应的数据（大字典
session 依赖cookie 。cookie保存在浏览器，session保存在服务端
session好处，客服端只有cookie的值，没有用户的信息
request.sesion["name"]="egon"（走的流程）
生成随机字符串
看中间件：
只是在内存中间，没有更新到数据库，如果没有return
5，用户认证组件
6，中间件：应用场景：限制访问的频率
wsgiref 代替web服务器部署（把一堆字符串解析--》request（中间件））
浏览器只解析，html css js（页面看到的东西不一定是服务器发来的）如果不加safe
request发请求怎么到服务器？
点击确定就
‘’
post/index HTTP/1.1
''''''''
请求体里面怎么放name，password？
服务器怎么解？
必须按照一种格式解 （form有3种格式）
Json
form-data
application/x-www-form-urlencoded（默认）
……所以我们在请求头告诉服务器用什么编码 content-Type=默认按这种解（form表单）
Name=yuan&pwd=123
Ajax 和form表单一样的格式
如果用ajax发json格式 contentType
要保证contentType 和内容换成一致
下面一种是json格式
不能骗浏览器，ajax里面要改成这样
后端收到的为空，为什么？
query对象里面有没有关键request.post只解析application/x-www-form-urlencoded
只是不解析
request.body 可以拿到所有原信息
所以我们序列化
补充：
https://www.cnblogs.com/yuanchenqi/articles/9070966.html
https://www.cnblogs.com/yuanchenqi/articles/8323452.html
‘’
admin管理工具
list_display = ["title","price","publishDate"]（列表时，定制显示的列。）
list_filter = ["publish","authors"] （列表时，定制右侧快速筛选。）
search_fields=["price","title"] （列表时，模糊搜索的功能）
search_field：添加搜索框
https://www.cnblogs.com/yuanchenqi/articles/8323452.html 其他详见
admin源码解析
单例模式
单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。
在 Python 中，我们可以用多种方法来实现单例模式：
- 使用模块
- 使用 __new__
- 使用装饰器（decorator）
- 使用元类（metaclass）
（1）使用 __new__
为了使类只能出现一个实例，我们可以使用 __new__ 来控制实例的创建过程，代码如下：
class Singleton(object):
_instance = None
def __new__(cls, *args, **kw):
if not cls._instance:
cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)
return cls._instance
class MyClass(Singleton):
a = 1
在上面的代码中，我们将类的实例和一个类变量 _instance 关联起来，如果 cls._instance 为 None 则创建实例，否则直接返回 cls._instance。
执行情况如下：
>>> one = MyClass()
>>> two = MyClass()
>>> one == two
True
>>> one is two
True
>>> id(one), id(two)
(4303862608, 4303862608)
（2）使用模块
其实，Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做：
# mysingleton.py
class My_Singleton(object):
def foo(self):
pass
my_singleton = My_Singleton()
将上面的代码保存在文件 mysingleton.py 中，然后这样使用：
from mysingleton import my_singleton
my_singleton.foo()
一个类只有一个实例对象
只要有一个类，每一个类对象不一样，只有实例化对象地址才是一样的
类的继承
class Base(object):
def __init__(self,val):
self.val = val
def func(self):
self.test()
print(self.val)
def test(self):
print("Base.test")
class Foo(Base):
def test(self):
print("FOO.test")
# def func(self):
# print(self.val,666)
#有就执行自己的，没有就执行父类的
class Bar(object):
def __init__(self):
self._register = {}
def regiter(self,a,b=None):
if not b:
b=Base
self._register[a] = b(a) #函数，类，对象
obj = Bar() #实例化就会去执行它自己的__init__方法，并获取到一个对象b,b就可以调用里面的属性和方法了
obj.regiter(1,Foo)
obj.regiter(2)
print(obj._register) #{1: <__main__.Foo object at 0x0000000002213160>, 2: <__main__.Base object at 0x0000000002213198>}
#obj._register[1] == Foo(1)
obj._register[1].func() #Foo的对象 打印结果：FOO.test 1
obj._register[2].func() #Base的对象 打印结果：Base.test 2
单例模式：单例模式是一个设计模式，就是单个实例共用一个对象
s1.py
class Foo(object):
def test(self):
print("123")
v = Foo()
#v是Foo的实例
s2.py
from s1 import v as v1
print(v1,id(v1)) #<s1.Foo object at 0x0000000002221710> 35788560
from s1 import v as v2
print(v1,id(v2)) #<s1.Foo object at 0x0000000002221710> 35788560
# 两个的内存地址是一样的
# 文件加载的时候，第一次导入后，再次导入时不会再重新加载。
举例二：
class Singleton:
def __new__(cls, *args, **kw):
'''__new__是一个构造方法，self就是他构造的'''
if not hasattr(cls, '_instance'):
orig = super(Singleton, cls)
cls._instance = orig.__new__(cls, *args, **kw)
return cls._instance
one = Singleton()
two = Singleton()
print(one,two) #他们两个的地址一样
# print(id(one),id(two))
one.name = 'alex'
print(two.name)
来自 <http://www.cnblogs.com/haiyan123/p/8034430.html>
admin执行流程
admin
1 使用
2 源码
（1）启动
执行每一个app下的admin.py 文件
autodiscover_modules('admin', register_to=site)
（2）注册
class AdminSite(object):
def __init__(self, name='admin'):
self._registry = {}
def register(self, model_or_iterable, admin_class=None, **options):
if not admin_class:
admin_class = ModelAdmin # 配置类
self._registry[model] = admin_class(model, self)
# {Book:BookConfig(Book),Publish:ModelAdmin(Publish)}
site=AdminSite()
##########
class BookConfig(ModelAdmin):
list_display=["",]
admin.site.register(Book,BookConfig)
admin.site.register(Publish)
{
<class 'django.contrib.auth.models.Group'>: <django.contrib.auth.admin.GroupAdmin object at 0x00000256B97EF9E8>,
<class 'django.contrib.auth.models.User'>: <django.contrib.auth.admin.UserAdmin object at 0x00000256B9825438>,
<class 'app01.models.Book'>: <app01.admin.BookConfig object at 0x00000256B983C080>,
<class 'app01.models.Publish'>: <app01.admin.PublishConfig object at 0x00000256B983C128>
}