Python Day23

admin流程之启动

单例模式

单例：只允许一个类实例化出一个对象

使用 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  

egon=Animal()
alex=Animal()
wupeiqi=Animal()

print(id(egon))
print(id(alex))
print(id(wupeiqi))
#三者完全相同

在上面的代码中，我们将类的实例和一个类变量 _instance 关联起来，
如果 cls._instance 为 None 则创建实例，否则直接返回 cls._instance。

使用模块

其实，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()

启动

（settings---->installapp------>admin）

        def autodiscover():autodiscover_modules('admin', register_to=site)

admin流程之注册

admin.site : 单例对象

class AdminSite():
    def __init__(self, name='admin'):
        self._registry = {} 

 #model就是表对象（Book），admin_class就是表的配置类（BookConfig）   
    def register(self, model, admin_class=None, **options):
            if not admin_class:
                #配置类
                    admin_class = ModelAdmin

            self._registry[model] = admin_class(model, self)

site=AdminSite()

admin.site.register(Book,BookConfig)
admin.site.register(Book)    #  site._registry:{Book:ModelAdmin(Book)}
admin.site.register(Publish) #  site._registry:{Book:ModelAdmin(Book),Publish:ModelAdmin(Publish)}

#site._registry:{模型类:该模型类的配置类对象,........}

知识点：url分发扩展

url()方法的扩展应用

from django.shortcuts import HttpResponse
    url(r'^index/', index), # 一旦匹配成功， index(request)

        urlpatterns = [
            url(r'^admin/', admin.site.urls),

            url(r'^yuan/', ([
                    url(r'^test01/', ([
                                url(r'^test1_1/', test01),
                                url(r'^test1_2/', test01),
                                    ],None,None)),
                    url(r'^test02/', test02),
                    url(r'^test03/', test03),
                            ],None,None)),
        ] 

格式，元祖里面是一个列表+None+None

admin流程之设计url

admin中：

扫描二维码关注公众号，回复： 1595814 查看本文章

from app01 import models

admin.site.register(models.Book)
admin.site.register(models.Publish)
admin.site.register(models.Author)

urls.py中：

from django.conf.urls import url
from django.contrib import admin
from django.shortcuts import render, HttpResponse, redirect

def list_view(request):
    return HttpResponse("list_view")

def change(request, id):
    return HttpResponse("change")

def delete(request, id):
    return HttpResponse("delete")

def add(request):
    return HttpResponse("add")

def get_urls2():
    temp = [
        url("^add/$", add),
        url("^$", list_view),
        url("^(\d+)/change/$", change),
        url("^(\d+)/delete/$", delete)
    ]

    return temp

def get_urls():
    temp = []

    print("_registry==>", admin.site._registry.items())
    #{Book:ModelAdmin(Book),....}
    #(<class 'app01.models.Book'>, <django.contrib.admin.options.ModelAdmin object at 0x00000234441F99B0>)
    #Django启动会先加载settings，因此_registry中有值
    for model, model_class_obj in admin.site._registry.items():

        app_name = model._meta.app_label
        #model._meta.app_label可以获取当前model所在app的名字
        model_name = model._meta.model_name
        #model._meta.model_name可以获得当前model的名称字符串

        #用stark+app的名字+模型表的名字
        #举例：http://127.0.0.1:8000/stark/app01/book/02/change/
        temp.append(url(r"%s/%s/" % (app_name, model_name), (get_urls2(), None, None)))

    return temp

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    # [
    #    url(r'^test01/', test01),
    #    url(r'^test02/', test02),
    #                 ]
    url(r"^stark",(get_urls(),None,None))
]

最终url示例:

^stark auth/group/
^stark auth/user/
^stark app01/book/ ^add/$
^stark app01/book/ ^$
^stark app01/book/ ^(\d+)/change/$
^stark app01/book/ ^(\d+)/delete/$
^stark app01/publish/
^stark app01/author/

知识点回顾

函数和实例方法的区别

class Animal():

    def running(self):
        print("running...")

#从实例对象调
alex = Animal()
#alex会作为self参数传进去
alex.running()
#结果：
#running...

#当做函数调，必须传个参数
Animal.running(123)
#结果：
#running...

合并列表

temp = []
temp.append(1)

l = [2, 3, 4]
temp.extend(l)
print(temp)
#结果：
[1, 2, 3, 4]

获取字段对象的中文名

from app01.models import Book
#price是book表中一个字段对象
obj = Book._meta.get_field("price")
obj.verbose_name

结果：

'价格'

没有单独设置verbose_name时，则返回英文名，若想使用中文名则要在models定义verbose_name
例：

class Book(models.Model):
    nid = models.AutoField(primary_key=True, verbose_name="编号")
    title = models.CharField(max_length=32, verbose_name="名称")
    price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name="价格")

总结：自制Admin组件

这里我们叫它Stark

从访问说起：下面的思路是模拟Django原生Admin的写法

url流程

1.urls.py中：

from stark.service.sites import site
urlpatterns = [
    # url(r"^stark",(get_urls(),None,None))
    url(r'^stark/', site.urls)
]

2.site是StarkSite这个类的实例化结果，如下面

site = StarkSite()

3.site调用urls，返回的是get_urls中的temp列表

model的注册

在app01目录下面有stark.py文件
我们在这个文件中对model进行注册
在Django启动的时候会遍历每个app中是否有stark.py文件（settings中设置的），找到后会运行，
因此里面的内容在Django启动时就运行过了

1.site.register(Book) 注册Book表
2.register方法会执行：

self._registry[model] = admin_class(model, self)

3.也就是向_registry = {}这个字典中添加了如上内容
内容简单理解为：{Book:ModelStark(Book)},这里的键Book是model对象
此时_registry = {}中就有了内容

访问，url分发开始

1.循环_registry = {},使用site._registry.items()分别得到表的对象和配置类
2.用表对象得到app的名字和表的名字，由此拼出一级分发
3.二级分发用配置类调用urls2得出
配置类对象是ModelStark(Book)
接下来我们去找ModelStark这个类来看一下

class ModelStark()就是默认的配置类，如果注册表的时候没有自定义配置类则走这里，
同时自定义配置类也要继承ModelStark作为父类
在这个类下面：

class ModelStark():  #配置类
    list_display = ["__str__", ]

    def __init__(self, model, site):
        self.model = model

这个self.model = model是关键，谁调用的它self.model就是那个表对象
如果是Book的话，那么self.model = Book

我们回到urls2

urls2返回值构建了一个return self.get_urls2(), None, None的格式
我们再去找get_urls2()这个函数
get_urls2和urls2都是class ModelStark下面的方法

get_urls2里面负责处理二级分发
这里举例访问到视图函数list_view中

    def list_view(self, request):
        data_list = self.model.objects.all()

此时model是Book，所以可以进行查询

self.model是谁

注：在视图函数中self.model到底是谁？这里是原生Admin组件写法的关键
这要看self是谁，一层一层往上找，最后会找到model_class_obj.urls2
model_class_obj来自于site._registry循环结果中的配置类，配置类是stark.py中注册的一个个模型的配置类
循环到谁就是谁调用urls2，self.model也就是那个对应的模型对象

注：我们无法确定用户访问那个url，因此提前准备好所有url，此时访问book，后面的model就是book，因此可以拿到相应数据

表单数据之多对多字段的处理

方法1 使用函数

在stark.py的BookConfig类中再增加一个函数

class BookConfig(ModelStark):
    def display_atuhors(self, obj=None, is_header=False):

        if is_header:
            return "作者"

        s = []
        for author in obj.authors.all():
            s.append(author.name)
        return ",".join(s)

    list_display = [display_atuhors]

方法2

判断是不是多对多函数

data_list = self.model.objects.all()

for obj in data_list:
    temp = []
    #循环需要显示的字段
    for field in self.list_display:
        #判断这个字段是不是字符串
        if isinstance(field, str):
            try:
                #引入ManyToManyField
                from django.db.models.fields.related import ManyToManyField
                #获取相应名称字段的对象
                field_obj = self.model._meta.get_field(field)  #注意，这里没法找出__str__，因此会报错
                #如果这个对象是多对多
                if isinstance(field_obj, ManyToManyField):
                    l = []
                    #利用反射，循环obj.field.all()
                    for i in getattr(obj, field).all():
                            #把循环结果添加到l列表
                        l.append(str(i)) #l==> ['egon', 'alex']
                    #用逗号把列表里面的元素拼起来 
                    val = ",".join(l)
                except Exception as e:
                    val = getattr(obj, field)
        #添加到temp列表
        temp.append(val)