from django.contrib import admin

from . import models

class zhangsan(admin.ModelAdmin):

    list_display = ('name', 'email')

    list_editable = ('email',)

    search_fields = ["name"]

    date_hierarchy = 'ctime'

admin.site.register(models.UserInfo,zhangsan)

adango admin源码

site = AdminSite()

def register(self, model_or_iterable, admin_class=None, **options):
    if not admin_class:
        admin_class = ModelAdmin
    if isinstance(model_or_iterable, ModelBase):
        model_or_iterable = [model_or_iterable]
    for model in model_or_iterable:
        if model._meta.abstract:
            raise ImproperlyConfigured(
                'The model %s is abstract, so it cannot be registered with admin.' % model.__name__
            )

        if model in self._registry:
            raise AlreadyRegistered('The model %s is already registered' % model.__name__)
        if not model._meta.swapped:
            if options:
                options['__module__'] = __name__
                admin_class = type("%sAdmin" % model.__name__, (admin_class,), options)
            self._registry[model] = admin_class(model, self)

def autodiscover():

    autodiscover_modules('admin', register_to=site)

from django.apps import AppConfig

class App01Config(AppConfig):

    name = 'app01'

    def ready(self):

        from django.utils.module_loading import autodiscover_modules

        autodiscover_modules('xxx')

urlpatterns = [

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

]

admin 路由源码

@property
def urls(self):
    return self.get_urls(), 'admin', self.name

def get_urls(self):
    from django.conf.urls import url, include
    from django.contrib.contenttypes import views as contenttype_views
    def wrap(view, cacheable=False):
        def wrapper(*args, **kwargs):
            return self.admin_view(view, cacheable)(*args, **kwargs)
        wrapper.admin_site = self
        return update_wrapper(wrapper, view)
    urlpatterns = [
        url(r'^$', wrap(self.index), name='index'),
        url(r'^login/$', self.login, name='login'),
        url(r'^logout/$', wrap(self.logout), name='logout'),
        url(r'^password_change/$', wrap(self.password_change, cacheable=True), name='password_change'),
        url(r'^password_change/done/$', wrap(self.password_change_done, cacheable=True),
            name='password_change_done'),
        url(r'^jsi18n/$', wrap(self.i18n_javascript, cacheable=True), name='jsi18n'),
        url(r'^r/(?P<content_type_id>\d+)/(?P<object_id>.+)/$', wrap(contenttype_views.shortcut),
            name='view_on_site'),
    ]
    for model, model_admin in self._registry.items():
        urlpatterns += [
            url(r'^%s/%s/' % (model._meta.app_label, model._meta.model_name), include(model_admin.urls)),
        ]
        if model._meta.app_label not in valid_app_labels:
            valid_app_labels.append(model._meta.app_label)
    if valid_app_labels:
        regex = r'^(?P<app_label>' + '|'.join(valid_app_labels) + ')/$'
        urlpatterns += [
            url(regex, wrap(self.app_index), name='app_list'),
        ]
    return urlpatterns

def include(arg, namespace=None, app_name=None):

    if app_name and not namespace:

        raise ValueError('Must specify a namespace if specifying app_name.')

    if app_name:

        warnings.warn(

            'The app_name argument to django.conf.urls.include() is deprecated. '

            'Set the app_name in the included URLconf instead.',

            RemovedInDjango20Warning, stacklevel=2

        )

    if isinstance(arg, tuple):

        # callable returning a namespace hint

        try:

            urlconf_module, app_name = arg

        except ValueError:

            if namespace:

                raise ImproperlyConfigured(

                    'Cannot override the namespace for a dynamic module that provides a namespace'

                )

            warnings.warn(

                'Passing a 3-tuple to django.conf.urls.include() is deprecated. '

                'Pass a 2-tuple containing the list of patterns and app_name, '

                'and provide the namespace argument to include() instead.',

                RemovedInDjango20Warning, stacklevel=2

            )

            urlconf_module, app_name, namespace = arg

    else:

        # No namespace hint - use manually provided namespace

        urlconf_module = arg

    if isinstance(urlconf_module, six.string_types):

        urlconf_module = import_module(urlconf_module)

    patterns = getattr(urlconf_module, 'urlpatterns', urlconf_module)

    app_name = getattr(urlconf_module, 'app_name', app_name)

    if namespace and not app_name:

        warnings.warn(

            'Specifying a namespace in django.conf.urls.include() without '

            'providing an app_name is deprecated. Set the app_name attribute '

            'in the included module, or pass a 2-tuple containing the list of '

            'patterns and app_name instead.',

            RemovedInDjango20Warning, stacklevel=2

        )

    namespace = namespace or app_name

    # Make sure we can iterate through the patterns (without this, some

    # testcases will break).

    if isinstance(patterns, (list, tuple)):

        for url_pattern in patterns:

            # Test if the LocaleRegexURLResolver is used within the include;

            # this should throw an error since this is not allowed!

            if isinstance(url_pattern, LocaleRegexURLResolver):

                raise ImproperlyConfigured(

                    'Using i18n_patterns in an included URLconf is not allowed.')

    return (urlconf_module, app_name, namespace)

url(r'^app01/', ([

                        url(r'^userinfo/', ([

                                                url(r'^index/', index,name='idx_xxx_f'),

                                                url(r'^test/', test,name='tst'),

                                            ],'x2','x2')),

                     ],'x1','x1')),