【Python全栈-后端开发】Django入门基础

一、 什么是web框架？

众所周知，对于所有的Web应用，本质上其实就是一个socket服务端，用户的浏览器其实就是一个socket客户端。

import socket
 
def handle_request(client):
    buf = client.recv(1024)
    client.send("HTTP/1.1 200 OK\r\n\r\n")
    client.send("Hello, Seven")
 
def main():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('localhost',8000))
    sock.listen(5)
 
    while True:
        connection, address = sock.accept()
        handle_request(connection)
        connection.close()
 
if __name__ == '__main__':
    main()

上述通过socket来实现了其本质，而对于真实开发中的python web程序来说，一般会分为两部分：服务器程序和应用程序。服务器程序负责对socket服务器进行封装，并在请求到来时，对请求的各种数据进行整理。应用程序则负责具体的逻辑处理。为了方便应用程序的开发，就出现了众多的Web框架，例如：Django、Flask、web.py 等。不同的框架有不同的开发方式，但是无论如何，开发出的应用程序都要和服务器程序配合，才能为用户提供服务。这样，服务器程序就需要为不同的框架提供不同的支持。这样混乱的局面无论对于服务器还是框架，都是不好的。对服务器来说，需要支持各种不同框架，对框架来说，只有支持它的服务器才能被开发出的应用使用。这时候，标准化就变得尤为重要。我们可以设立一个标准，只要服务器程序支持这个标准，框架也支持这个标准，那么他们就可以配合使用。一旦标准确定，双方各自实现。这样，服务器可以支持更多支持标准的框架，框架也可以使用更多支持标准的服务器。

WSGI（Web Server Gateway Interface）是一种规范，它定义了使用python编写的web app与web server之间接口格式，实现web app与web server间的解耦。

python标准库提供的独立WSGI服务器称为wsgiref。

from wsgiref.simple_server import make_server

def RunServer(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return '
Hello, web!
'

if __name__ == '__main__':
    httpd = make_server('', 8000, RunServer)
    print "Serving HTTP on port 8000..."
    httpd.serve_forever()

自定义Web框架

通过python标准库提供的wsgiref模块开发一个自己的Web框架

#!/usr/bin/env python
#coding:utf-8
from wsgiref.simple_server import make_server

def index():
    return 'index'

def login():
    return 'login'

def routers():
    
    urlpatterns = (
        ('/index/',index),
        ('/login/',login),
    )
    
    return urlpatterns

def RunServer(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    url = environ['PATH_INFO']
    urlpatterns = routers()
    func = None
    for item in urlpatterns:
        if item[0] == url:
            func = item[1]
            break 
    if func:
        return func()
    else:
        return '404 not found'
    
if __name__ == '__main__':
    httpd = make_server('', 8000, RunServer)
    print "Serving HTTP on port 8000..."
    httpd.serve_forever()

二、MVC和MTV模式

MVC：Model、View、Controller

MTV：Model、Template、View

著名的MVC模式：所谓MVC就是把web应用分为模型(M),控制器(C),视图(V)三层；他们之间以一种插件似的，松耦合的方式连接在一起。

模型负责业务对象与数据库的对象(ORM) ， 视图负责与用户的交互(页面)，控制器(C)接受用户的输入调用模型和视图完成用户的请求。

              
Django的MTV模式本质上与MVC模式没有什么差别，也是各组件之间为了保持松耦合关系，只是定义上有些许不同，Django的MTV分别代表：

       Model(模型)：负责业务对象与数据库的对象(ORM)

      Template(模版)：负责如何把页面展示给用户

       View(视图)：负责业务逻辑，并在适当的时候调用Model和Template

       此外，Django还有一个url分发器，它的作用是将一个个URL的页面请求分发给不同的view处理，view再调用相应的Model和Template

三、Django的流程和命令行工具

Django项目的实现流程：

Django
    #安装： pip3 install django
          添加环境变量

    #1  在cmd命令行中创建project
django-admin startproject [项目名]

       django-admin startproject mysite

       ---mysite
          ---settings.py
          ---url.py
          ---wsgi.py
       ---- manage.py(启动文件)  

    #2  创建APP 
python manage.py startapp [app名字]      
       python manage.py startapp app01

    #3  settings配置
       TEMPLATES
　　
#配置静态文件路径
       STATICFILES_DIRS=(
            os.path.join(BASE_DIR,"statics"),　　　　#一定要加逗号，不然会报错
        )

       STATIC_URL = '/static/' 　　#别名（由于原名更改导致后续更改麻烦，以后一般使用别名，）
       #  我们只能用 STATIC_URL，但STATIC_URL会按着你的STATICFILES_DIRS去找#4  根据需求设计代码
           url.py
           view.py

    #5  使用模版渲染HTML界面
       render(request,"index.html")   

    #6  启动项目（pycharm 的terminal中）
       python manage.py runserver  【127.0.0.1:8000】  #后面【】部分可以不填，默认是127.0.0.1:8000

    #7  连接数据库，操作数据
       model.py

django的cmd命令行工具：

django-admin.py  是Django的一个用于管理任务的命令行工具，manage.py是对django-admin.py的简单包装,每一个Django Project里都会有一个manage.py。

<1> 创建一个django工程 : django-admin.py startproject mysite

        当前目录下会生成mysite的工程，目录结构如下：

        

  • manage.py ----- Django项目里面的工具，通过它可以调用django shell和数据库等。
  • settings.py ---- 包含了项目的默认设置，包括数据库信息，调试标志以及其他一些工作的变量。
  • urls.py ----- 负责把URL模式映射到应用程序。

<2>在mysite目录下创建APP应用 blog: python manage.py startapp blog

        

<3>启动django项目：python manage.py runserver [8080]   #默认是8000端口

<4>生成同步数据库的迁移脚本文件：python manage.py makemigrations  

将生成的迁移脚本文件映射到数据库:  python manage.py migrate   

注意：在开发过程中，数据库同步误操作之后，难免会遇到后面不能同步成功的情况，解决这个问题的一个简单粗暴方法是把migrations目录下

                的脚本（除__init__.py之外）全部删掉，再把数据库删掉之后创建一个新的数据库，数据库同步操作再重新做一遍。            

<5>当我们访问后台管理员：http://127.0.0.1:8080/admin/时，会出现：

所以我们需要为进入这个项目的后台创建超级管理员：python manage.py createsuperuser，设置好用户名和密码后便可登录啦！

注意： 修改密码：python manage.py changepassword [用户名]

当忘记用户名或密码时：

在shell模式下（Python manage.py shell）
---------------------------------------------------找回用户名

from django.contrib.auth.models import User #引入管理员密码存放的数据库

user=User.objects.filter()     #查找该数据库里有哪些用户

print(user)    #, ]>

-----------------------------------------------------修改密码（方法一）

user = User.objects.get(username='admin') #获取名称为admin的用户

user.set_password('123456') #设置密码

user.save()  # 报错user对象

-----------------------------------------------------修改密码（方法二）
退出shell模式，在Terminal中

Python manage.py changepassword [用户名]

<6>清空数据库（慎用！！！）：python manage.py  flush

<7>查询某个命令的详细信息： django-admin.py  help  startapp

       admin 是Django 自带的一个后台数据库管理系统。

<8>启动Django与数据库交互模式：python manage.py  shell

     这个命令和直接运行 python 进入 shell 的区别是：你可以在这个 shell 里面调用当前项目的 models.py 中的 API，对于操作数据，还有一些小测试非常方便。

<9> 终端上输入python manage.py 可以看到详细的列表，在忘记子名称的时候特别有用。

四、项目文件夹下(settings.py)全局配置

1. 静态文件staticfiles设置:

一、概述：

     #静态文件交由Web服务器处理，Django本身不处理静态文件。简单的处理逻辑如下(以nginx为例)：

     #          URI请求-----> 按照Web服务器里面的配置规则先处理，以nginx为例，主要求配置在nginx.
                             #conf里的location

                         |---------->如果是静态文件，则由nginx直接处理

                         |---------->如果不是则交由Django处理，Django根据urls.py里面的规则进行匹配

    # 以上是部署到Web服务器后的处理方式，为了便于开发，Django提供了在开发环境的对静态文件的处理机制，方法是这样：

    #1、在INSTALLED_APPS里面加入'django.contrib.staticfiles',

    #2、在urls.py里面加入
       if settings.DEBUG:  
           urlpatterns += patterns('', url(r'^media/(?P.*)$', 
           'django.views.static.serve', {'document_root': settings.MEDIA_ROOT }),   
            url(r'^static/(?P.*)$',
          'django.views.static.serve',{'document_root':settings.STATIC_ROOT}), )  

    # 3、这样就可以在开发阶段直接使用静态文件了。

二、MEDIA_ROOT和MEDIA_URL

        #而静态文件的处理又包括STATIC和MEDIA两类，这往往容易混淆，在Django里面是这样定义的：

        #MEDIA:指用户上传的文件，比如在Model里面的FileFIeld，ImageField上传的文件。如果你定义

        #MEDIA_ROOT=c:\temp\media，那么File=models.FileField(upload_to="abc/")＃，上传的文件就会被保存到c:\temp\media\abc  
        #eg：
            class blog(models.Model):  
                   Title=models.charField(max_length=64)  
                   Photo=models.ImageField(upload_to="photo") 
        #     上传的图片就上传到c:\temp\media\photo，而在模板中要显示该文件，则在这样写
        #在settings里面设置的MEDIA_ROOT必须是本地路径的绝对路径，一般是这样写:
                 BASE_DIR= os.path.abspath(os.path.dirname(__file__))  
                 MEDIA_ROOT=os.path.join(BASE_DIR,'media/').replace('\\','/') 

        #MEDIA_URL是指从浏览器访问时的地址前缀，举个例子：
            MEDIA_ROOT=c:\temp\media\photo  
            MEDIA_URL="/data/"
        #在开发阶段,media的处理由django处理：

        #    访问http://localhost/data/abc/a.png就是访问c:\temp\media\photo\abc\a.png

        #    在模板里面这样写

        #    在部署阶段最大的不同在于你必须让web服务器来处理media文件，因此你必须在web服务器中配置，
        #  以便能让web服务器能访问media文件
        #    以nginx为例，可以在nginx.conf里面这样：

                 location ~/media/{
                       root/temp/
                       break;
                    }

        #    具体可以参考如何在nginx部署django的资料。

三、STATIC_ROOT和STATIC_URL、
    STATIC主要指的是如css,js,images这样文件，在settings里面可以配置STATIC_ROOT和STATIC_URL,
    配置方式与MEDIA_ROOT是一样的，但是要注意

    #STATIC文件一般保存在以下位置：

    #1、STATIC_ROOT：在settings里面设置，一般用来放一些公共的js,css,images等。

    #2、app的static文件夹，在每个app所在文夹均可以建立一个static文件夹，然后当运行collectstatic时，
    #    Django会遍历INSTALL_APPS里面所有app的static文件夹，将里面所有的文件复制到STATIC_ROOT。因此，
    #   如果你要建立可复用的app，那么你要将该app所需要的静态文件放在static文件夹中。

    # 也就是说一个项目引用了很多app，那么这个项目所需要的css,images等静态文件是分散在各个app的static文件的，比
    #  较典型的是admin应用。当你要发布时，需要将这些分散的static文件收集到一个地方就是STATIC_ROOT。

    #3、STATIC文件还可以配置STATICFILES_DIRS，指定额外的静态文件存储位置。
    #  STATIC_URL的含义与MEDIA_URL类似。

    # ----------------------------------------------------------------------------
    #注意1:为了后端的更改不会影响前端的引入，避免造成前端大量修改，所有一般静态文件夹都使用别名
        STATIC_URL = '/static/'               #别名
        STATICFILES_DIRS = (
            os.path.join(BASE_DIR,"statics")  #实际名 ,即实际文件夹的名字
        )

        #django对引用名和实际名进行映射,引用时,只能按照引用名来,不能按实际名去找
        #   #--error－－不能直接用，必须用STATIC_URL = '/static/':
        #

    #注意2：(statics文件夹写在不同的app下,静态文件的调用):
        STATIC_URL = '/static/'    #别名

        STATICFILES_DIRS=(
            ('hello',os.path.join(BASE_DIR,"app01","statics")) ,
        )

        #

    #注意3: 在模板文件html中 载入静态文件路径
        STATIC_URL = '/static/'
        {% load staticfiles %}  #注意：Django3 版本 {% load static %}
       #

2. 配置编码：

首先需要配置的是文字编码格式，django默认的编码是英文格式，我们把它改成中文格式，需要修改下面几个变量的值。

LANGUAGE_CODE = 'zh-hans' # zh-hans为中文编码

TIME_ZONE = 'Asia/Shanghai' # 国际时区改成中国时区

USE_I18N = True

USE_L10N = True

USE_TZ = False

3. 配置数据库：

然后还需要配置数据库信息，django默认使用的是sqlite数据库，我们修改为mysql数据库。找到DATABASES节点，修改为如下代码。

其中，NAME为数据库名，USER为mysql的用户名，PASSWORD为密码，HOSY为127.0.0.1，PORT为3306

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'video',
        'USER': 'root',
        'PASSWORD': '123456',
        'HOST':'127.0.0.1',
        'PORT':'3306',
    }
}

配置好数据库之后，还需要在 videoproject/videoproject/__init__.py 安装mysql驱动，只需要写入代码：

import pymysql
pymysql.install_as_MySQLdb()

views.py操作数据库的日志 --->控制台打印SQL语句

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

五、Django URL (路由系统)

Django1.0版本路由分发 使用url，Django2.0 使用 path/re_path

from django.conf.urls import url
urlpatterns = [
    url(正则表达式, views视图函数，参数，别名),
]

参数说明：

  • 一个正则表达式字符串
  • 一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串
  • 可选的要传递给视图函数的默认参数（字典形式）
  • 一个可选的name参数
  • 可以两个url对应一个views视图函数（注意：逻辑不能乱）

5.1 一些基本的urls.py配置:

url系统:  urls.py
           1>. 导入 from django.conf.urls import url
           2>. 基本格式:
　　　　　　　　　　　#Django1.0版本写法
                     urlpatterns = [
                        url(正则表达式, views视图函数，参数，别名),
                     ]
　　　　　　　　　　　　　#Django2.0 以上版本　使用re.path()　　　　　　　　　　　　　
           url分类:
               3>. 无命名分组:
                   url(r'^article/(\d{4})/(\d{2})',views.article),       # 无命名分组，注意article视图函数要传2个参数
               
               4>. 有命名分组:
                   url(r'^article/(?P\d{4})/(?P\d{2})',views.article),  # 有命名分组, views.py中视图函数article一定要按命名要求传参
               
               5>. 别名:更改项目文件夹名称时，还可以通过别名找到，不至于大量修改前端引用地址
                   1>>. 供前端表单使用，不会将前端url写死
                        url(r'^register/', views.register, name='reg')   # 别名
                   2>>. 通过模板动态调用
                        

                   3>>. 模板中传参
                         {% url 'reg' param1 param2 %}                 # 无名分组传参 r'^all/(\d+)'
                         {% url 'reg' name=para1 %}                    # 有命名分组传参 r'^all/(?\d+)'
                   4>>. 在view中传参
                         reverse('reg',args=(1,))                      # 无命名分组
                         reverse('reg',kwargs={'name':1})              # 有命名分组       
                   
           urls分流（将路由分发到app01中的urls.py）:  
               1>. DjangoWeb项目urls.py中为主系统
                   urlpatterns = [
                        path('admin/', admin.site.urls),
                        path('blog/', include('blog.urls'))   # 通过include('blog.urls') 导入
                   ]
               2. 具体app01中(如blog)urls.py 为分系统
                   urlpatterns = [
                    url(r'userInfo/',views.userInfo),
                    url(r'^article/(\d{4})/(\d{2})',views.article),       # 无命名分组
                    url(r'^article/(?P\d{4})/(?P\d{2})',views.article),  # 有命名分组
                    url(r'^register/', views.register, name='reg')   # 别名
                   ]
               
               # 浏览器访问时:
                  # http://127.0.0.1:8080/blog/register/

注意：django1.0和Django2.0---url和path/re_path的区别

pycharm创建Django2.0项目时默认导入的是path模块,
path模块路径不能是正则表达式，路径是正则时需要使用re_path
from django.urls import path

urlpatterns = [
    re_path(r'^hello/$',views.hello),
    re_path(r'^admin/$', admin.site.urls),
    re_path(r'^time/$', current_datetime),

    re_path(r'^time/plus/(\d{1,2})/$',hours_ahead),

]
#django1.0版本 导入url
from django.conf.urls import url 

urlpatterns = [
    url(r'^hello/$',views.hello),
    url(r'^admin/$', admin.site.urls),
    url(r'^time/$', current_datetime),

    url(r'^time/plus/(\d{1,2})/$',hours_ahead),

]

参考：Django的路由系统|URL配置、正则表达式、分组命名、命名空间、命名URL反向解析

六、Views.py（视图函数* * * * *）

http请求中产生两个核心对象：

        http请求：HttpRequest对象

        http响应：HttpResponse对象

所在位置：django.http

之前我们用到的参数request就是HttpRequest    检测方法：isinstance(request,HttpRequest)

1. HttpRequest对象的属性(path method GET POST COOKIES FILES等等)和方法(req.get_full_path())：

# path：       请求页面的全路径，不包括域名
#
# method：     请求中使用的HTTP方法的字符串表示。全大写表示。例如
#
#                    if  req.method=="GET":
#
#                              do_something()
#
#                    elseif req.method=="POST":
#
#                              do_something_else()
#
# GET:         包含所有HTTP GET参数的类字典对象
#
# POST：       包含所有HTTP POST参数的类字典对象
#
#              服务器收到空的POST请求的情况也是可能发生的，也就是说，表单form通过
#              HTTP POST方法提交请求，但是表单中可能没有数据，因此不能使用
#              if req.POST来判断是否使用了HTTP POST 方法；应该使用  if req.method=="POST"
#
# COOKIES:     包含所有cookies的标准Python字典对象；keys和values都是字符串。
#
# FILES：      包含所有上传文件的类字典对象；FILES中的每一个Key都是标签中name属性的值，
               FILES中的每一个value同时也是一个标准的python字典对象，包含下面三个Keys：
#
#             filename：      上传文件名，用字符串表示
#             content_type:   上传文件的Content Type
#             content：       上传文件的原始内容
#
#
# user：       是一个django.contrib.auth.models.User对象，代表当前登陆的用户。如果访问用户当前
#              没有登陆，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。你
#              可以通过user的is_authenticated()方法来辨别用户是否登陆：
#              if req.user.is_authenticated();只有激活Django中的AuthenticationMiddleware
#              时该属性才可用
#
# session：    唯一可读写的属性，代表当前会话的字典对象；自己有激活Django中的session支持时该属性才可用。

#方法
get_full_path(),   比如：http://127.0.0.1:8000/index33/?name=xiong&pwd=123456 ,req.get_full_path()得到的结果就是/index33/?name=xiong&pwd=123456
req.path           /index33

注意一个常用方法：request.POST.getlist('')

2. HttpResponse对象：

对于HttpRequest对象来说，是由django自动创建的，但是HttpResponse对象就必须我们自己创建。每个view请求处理方法必须返回一个HttpResponse对象。

HttpResponse类在django.http.HttpResponse  对象上扩展的常用方法：

页面渲染：         render(request,'index.html',{"name":name})（推荐）    render_to_response('index.html',{'name':name}),         
页面跳转：         redirect("路径")  #redirect('/login/')
locals()：        可以直接将函数中所有的变量传给模板

render 和 redirect的区别

总结: render和redirect的区别:
#render(request,'studentInfo.html',locals())
直接找到Templates文件夹下的studentInfo.html模板文件
将本地所有变量locals() 通过模板语言语法在后台渲染成HTML文件

#redirect("/login/")
跳转到urls.py在urlpatterns匹配路径，然后进入views.py视图函数 login函数处理

练习：

-----------------------------------------day49/urls
url(r'blog/',include('blog.urls')),
url('login/', views.login),
-----------------------------------------day49/blog/urls
#注册界面
url("register",views.register,name="reg")

----------------------------------------views.py
def register(request):
	# print("部分路径：",request.path)
	# print("全路径：",request.get_full_path())

	if request.method == "POST":
		if request.POST.get("userName") == "xiong":
			return redirect("/login/")  # 输入userName是 xiong 跳转到login界面
		else:
			redirect("http://www.baidu.com")
	else:
		# 开始进来的时候是get请求 返回html渲染界面，之后form表单是以POST提交
		return render(request, "register.html")


def login(request):
    if request.GET.get("username") == "xiong" and request.GET.get("pwd") == "123456":
        return redirect("https://www.cnblogs.com")

----------------------------------------------------template/register.html



    
    {% load static %}      {# 使用别名 需要载入静态文件 #}
    Title



学生注册界面



{#以post方式提交,action="/register/" 是以当前页面的ip+port放在前面一起发过去即：172.0.0.1:8080/register/#}
{##}

    
姓名

    
年龄

    
爱好篮球
            足球
            乒乓球
    

    
提交






----------------------------------------------------template/login.html



    
    登录界面
    {% load static %}




    
用户名: 

    
密码:

七、Template模板（* * * * *） 

模板系统的介绍

你可能已经注意到我们在例子视图中返回文本的方式有点特别。 也就是说，HTML被直接硬编码在 Python代码之中。

def current_datetime(request):
    now = datetime.datetime.now()
    html = "It is now %s." % now
    return HttpResponse(html)

这种写法将HTML和python代码糅合在一起维护起来特别困难，也带来了问题

尽管这种技术便于解释视图是如何工作的，但直接将HTML硬编码到你的视图里却并不是一个好主意。 让我们来看一下为什么：

对页面设计进行的任何改变都必须对 Python 代码进行相应的修改。 站点设计的修改往往比底层 Python 代码的修改要频繁得多，因此如果可以在不进行 Python 代码修改的情况下变更设计，那将会方便得多。

Python 代码编写和 HTML 设计是两项不同的工作，大多数专业的网站开发环境都将他们分配给不同的人员（甚至不同部门）来完成。 设计者和HTML/CSS的编码人员不应该被要求去编辑Python的代码来完成他们的工作。

程序员编写 Python代码和设计人员制作模板两项工作同时进行的效率是最高的，远胜于让一个人等待另一个人完成对某个既包含 Python又包含 HTML 的文件的编辑工作。

基于这些原因，将页面的设计和Python的代码分离开会更干净简洁更容易维护。 我们可以使用 Django的 模板系统 (Template System)来实现这种模式，这就是本章要具体讨论的问题。

模版的组成

组成：HTML代码＋逻辑控制代码

逻辑控制代码的组成

1  变量（使用双大括号来引用变量）：

语法格式：       {{var_name}}

Template（模板）和Context（上下文）对象

>>> python manange.py shell  (进入该django项目的环境)
>>> from django.template import Context, Template
>>> t = Template('My name is {{ name }}.')
>>> c = Context({'name': 'Stephane'})
>>> t.render(c)
'My name is Stephane.'

# 同一模板，多个上下文，一旦有了模板对象，你就可以通过它渲染多个context，无论何时我们都可以
# 像这样使用同一模板源渲染多个context，只进行 一次模板创建然后多次调用render()方法渲染会
# 更为高效：
# Low(创建了3个相同的模板)
for name in ('John', 'Julie', 'Pat'):
    t = Template('Hello, {{ name }}')
    print t.render(Context({'name': name}))

# Good（推荐--创建了1个模板 用了3次）
t = Template('Hello, {{ name }}')
for name in ('John', 'Julie', 'Pat'):
    print t.render(Context({'name': name}))

 Django 模板解析非常快捷。 大部分的解析工作都是在后台通过对简短正则表达式一次性调用来完成。

这和基于 XML 的模板引擎形成鲜明对比，那些引擎承担了 XML 解析器的开销，且往往比 Django 模板渲染引擎要慢上几个数量级。

from django.shortcuts import render,HttpResponse
from django.template.loader import get_template #记得导入
# Create your views here.


import datetime
from django.template import Template,Context

# def current_time(req):
    #原始的视图函数
    # now=datetime.datetime.now()
    # html="现在时刻：
%s.
" %now
    # return HttpResponse(html)



# def current_time(req):

      #django模板修改的视图函数
#     now=datetime.datetime.now()
#     t=Template('现在时刻是:
{{current_date}}
')
      #t=get_template('current_datetime.html')
#     c=Context({'current_date':now})
#     html=t.render(c)
#     return HttpResponse(html)

#另一种写法(推荐)

def current_time(req):

    now=datetime.datetime.now()

    return render(req, 'current_datetime.html', {'current_date':now})

推荐方式

1、深度变量的查找（万能的句点号）

在到目前为止的例子中，我们通过 context 传递的简单参数值主要是字符串，然而，模板系统能够非常简洁地处理更加复杂的数据结构，例如list、dictionary和自定义的对象。

在 Django 模板中遍历复杂数据结构（字符串、列表、字典、类等）的关键是句点字符 (.)。

#最好是用几个例子来说明一下。
# 首先，句点可用于访问列表索引，例如：

>>> from django.template import Template, Context
>>> t = Template('Item 2 is {{ items.2 }}.')
>>> c = Context({'items': ['apples', 'bananas', 'carrots']})
>>> t.render(c)
'Item 2 is carrots.'

#假设你要向模板传递一个 Python 字典。 要通过字典键访问该字典的值，可使用一个句点：
>>> from django.template import Template, Context
>>> person = {'name': 'Sally', 'age': '43'}
>>> t = Template('{{ person.name }} is {{ person.age }} years old.')
>>> c = Context({'person': person})
>>> t.render(c)
'Sally is 43 years old.'

#同样，也可以通过句点来访问对象的属性。 比方说， Python 的 datetime.date 对象有
#year 、 month 和 day 几个属性，你同样可以在模板中使用句点来访问这些属性：

>>> from django.template import Template, Context
>>> import datetime
>>> d = datetime.date(1993, 5, 2)
>>> d.year
>>> d.month
>>> d.day
>>> t = Template('The month is {{ date.month }} and the year is {{ date.year }}.')
>>> c = Context({'date': d})
>>> t.render(c)
'The month is 5 and the year is 1993.'

# 这个例子使用了一个自定义的类，演示了通过实例变量加一点(dots)来访问它的属性，这个方法适
# 用于任意的对象。
>>> from django.template import Template, Context
>>> class Person(object):
...     def __init__(self, first_name, last_name):
...         self.first_name, self.last_name = first_name, last_name
>>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.')
>>> c = Context({'person': Person('John', 'Smith')})
>>> t.render(c)
'Hello, John Smith.'

# 点语法也可以用来引用对象的方法。 例如，每个 Python 字符串都有 upper() 和 isdigit()
# 方法，你在模板中可以使用同样的句点语法来调用它们：
>>> from django.template import Template, Context
>>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}')
>>> t.render(Context({'var': 'hello'}))
'hello -- HELLO -- False'
>>> t.render(Context({'var': '123'}))
'123 -- 123 -- True'

# 注意这里调用方法时并* 没有* 使用圆括号 而且也无法给该方法传递参数；你只能调用不需参数的
# 方法。

2、变量过滤器(filter)的使用

变量过滤器主要是处理后端views.py中函数传递给模板HTML的参数

Django内置的一些过滤方法

   # 1  add          ：   给变量加上相应的值
   # 2  addslashes   :    给变量中的引号前加上斜线
   # 3  capfirst     :    首字母大写
   # 4  cut          ：   从字符串中移除指定的字符
   # 5  date         ：   格式化日期字符串
   # 6  default      ：   如果值是False,就替换成设置的默认值，否则就是用本来的值
   # 7  default_if_none:  如果值是None，就替换成设置的默认值，否则就使用本来的值
# 1  add          ：   给变量加上相应的值
   #
   # 2  addslashes   :    给变量中的引号前加上斜线
   #
   # 3  capfirst     :    首字母大写
   #
   # 4  cut          ：   从字符串中移除指定的字符
   #
   # 5  date         ：   格式化日期字符串
   #
   # 6  default      ：   如果值是False,就替换成设置的默认值，否则就是用本来的值
   #
   # 7  default_if_none:  如果值是None，就替换成设置的默认值，否则就使用本来的值

#实例:

#value1="aBcDe"
{{ value1|upper }}


#value2=5
{{ value2|add:3 }}


#value3='he  llo wo r ld'
{{ value3|cut:' ' }}


#import datetime
#value4=datetime.datetime.now()
{{ value4|date:'Y-m-d' }}


#value5=[]
{{ value5|default:'空的' }}


#value6='跳转'

{{ value6 }}

{% autoescape off %}
  {{ value6 }}
{% endautoescape %}

{{ value6|safe }}


{{ value6|striptags }}

#value7='1234'
{{ value7|filesizeformat }}

{{ value7|first }}

{{ value7|length }}

{{ value7|slice:":-1" }}


#value8='http://www.baidu.com/?a=1&b=3'
{{ value8|urlencode }}

    value9='hello I am yuan'
语法示例

实例演练：

--------------------------------------------------views
from django.shortcuts import render,HttpResponse
import datetime,time
# Create your views here.

class Animal():
    def __init__(self,nation,color):
        self.nation = nation
        self.color = color


def show_time(request):
    t = datetime.datetime.now()
    str1 = "hel lo wo r ld !"
    # 把变量渲染到html中(缺点：前端后端没有分开，python杂糅到HTML中 后续维护困难)
    # return HttpResponse("it is now %s."%(t))

    list1 = ['成龙','李小龙','甄子丹']
    dict1 = {'name':'李明','sex':'男','age':'25'}
    myClass = Animal("china",'yellow')
    list2 = []
    alink = "click!"
    str2 = "12a3bc4d"

    myurl = "https://i.cnblogs.com/PostDone.aspx?postid=10488757&actiontip=发布草稿成功"

    return render(request,"show_time.html",locals())


------------------------------------------------------template/.html


"en">

    "UTF-8">
    Title


    
time is: {{ t }}

    
str1 is: {{ str1 }}

    
list's list[0] is: {{ list1.0 }}

    
list's list1[1] is: {{ list1.1 }}

    
dict's name is: {{ dict1.name }}

    
dict's age is: {{ dict1.age }}

    
dict's sex is: {{ dict1.sex }}

    
从类中取值: {{ myClass.nation }}

    
从类中取值: {{ myClass.color }}


{#－－－－－－变量的过滤器(filter)的使用#}
    
李明的真实年龄：{{ dict1.age|add:10}}

    
字符串的首字母大写：{{ myClass.nation|capfirst}}

    
字符串中移除指定的字符--移除空格：{{ str1|cut:" "}}

    
格式化日期时间：{{ t|date:"Y-m-d H:i:s"}}
      {# 2019-03-08 13:35:32 #}
    
如果值是False,就替换成设置的默认值，否则就是用本来的值：{{ list2|default:"[空列表]" }}

{#后端发给浏览器的HTML格式文本为了安全起见，默认为文本 不是以HTML格式渲染的，若想要HTML渲染---> obj|safe#}
    
指定浏览器以HTML格式渲染,不加safe默认是文本：{{ alink }}

    
指定浏览器以HTML格式渲染：{{ alink|safe }}

{#与上面的效果相同，都是保证浏览器以html格式渲染    #}
    {% autoescape off %}
      {{ alink }}
    {% endautoescape %}

{#对字符串进行操作#}

字符串二进制大小：{{ str2|filesizeformat }}


字符串：{{ str2|first }}


字符串长度：{{ str2|length }}


字符串切片：{{ str2|slice:":-1" }}


{# 对url进行urlencode编码 #}

urlencode编码：{{ myurl|urlencode }}
变量的过滤器--演练

启用安全机制 ---将字符串渲染为html标签

视图函数传递给模板的是字符串，如果要想浏览器将字符串渲染为html标签，需要启用安全机制：　

#方法1
{{str1|safe}}

#方法2
{% autoescape off %}
  {{ value6 }}
{% endautoescape %}

3、标签(tag)的使用（使用 大括号和百分号的组合 来表示使用tag）

语法格式：　　{% tags %}

－－－－－－{% if %} 的使用 

{% if %}标签计算一个变量值，如果是“true”，即它存在、不为空并且不是false的boolean值,系统则会显示{% if %}和{% endif %}间的所有内容

{% if num >= 100 and 8 %}

    {% if num > 200 %}
        
num大于200

    {% else %}
        
num大于100小于200

    {% endif %}

{% elif num < 100%}
    
num小于100


{% else %}
    
num等于100


{% endif %}



{% if %} 标签接受and，or或者not来测试多个变量值或者否定一个给定的变量
{% if %} 标签不允许同一标签里同时出现and和or，否则逻辑容易产生歧义，例如下面的标签是不合法的：

{% if obj1 and obj2 or obj3 %}

－－－－－－{% for %}的使用

{% for %}标签允许你按顺序遍历一个序列中的各个元素,每次循环模板系统都会渲染{% for %}和{% endfor %}之间的所有内容

    
{% for obj in list %}
    
  • {{ obj.name }}
    • 
{% endfor %}




#在标签里添加reversed来反序循环列表：

    {% for obj in list reversed %}
    ...
    {% endfor %}

#{% for %}标签可以嵌套：

    {% for country in countries %}
        
{{ country.name }}

        
    
         {% for city in country.city_list %}
            
  • {{ city }}
    • 
         {% endfor %}
        

    {% endfor %}


#系统不支持中断循环，系统也不支持continue语句，{% for %}标签内置了一个forloop模板变量，
#这个变量含有一些属性可以提供给你一些关于循环的信息

1，forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1:

    {% for item in todo_list %}
        
{{ forloop.counter }}: {{ item }}

    {% endfor %}
2，forloop.counter0 类似于forloop.counter，但它是从0开始计数，第一次循环设为0
3，forloop.revcounter
4，forloop.revcounter0
5，forloop.first当第一次循环时值为True，在特别情况下很有用：

    
    {% for object in objects %}   
         {% if forloop.first %}
  • class="first">{% else %}
  • {% endif %}   
         {{ object }}   
        
    •   
    {% endfor %}  
    
# 富有魔力的forloop变量只能在循环中得到，当模板解析器到达{% endfor %}时forloop就消失了
# 如果你的模板context已经包含一个叫forloop的变量，Django会用{% for %}标签替代它
# Django会在for标签的块中覆盖你定义的forloop变量的值
# 在其他非循环的地方，你的forloop变量仍然可用


#{% empty %}

{{li }}
      {%  for i in li %}
          
  • {{ forloop.counter0 }}----{{ i }}
    • 
      {% empty %}
          
  • this is empty!
    • 
      {% endfor %}

#         [11, 22, 33, 44, 55]
#            0----11
#            1----22
#            2----33
#            3----44
#            4----55

    {% if %}和{% for %}的实例练习：

    --------------------------------------------views
class Animal():
    def __init__(self,nation,color):
        self.nation = nation
        self.color = color


def show_time(request):
    t = datetime.datetime.now()
    str1 = "hel lo wo r ld !"
    # 把变量渲染到html中(缺点：前端后端没有分开，python杂糅到HTML中 后续维护困难)
    # return HttpResponse("it is now %s."%(t))

    list1 = ['成龙','爱因斯坦','李白','刘欢']
    dict1 = {'name':'李明','sex':'男','age': 25}
    myClass = Animal("china",'yellow')
    list2 = []
    list3 = ['actor','scientist','poem','singer']
    alink = "click!"
    str2 = "12a3bc4d"

    myurl = "https://i.cnblogs.com/PostDone.aspx?postid=10488757&actiontip=发布草稿成功"

    return render(request,"show_time.html",locals())

---------------------------------------------template/.html
{#标签(tag)的使用（使用大括号和百分比的组合来表示使用tag）#}
{% if dict1.age > 20 %}
    {% if dict1.age < 40  %}
        
    {{ dict1.name }}的年龄为20~40
    
    {% elif dict1.age < 60 %}
        
    李明的年龄为40~60
    
    {% else %}
        
    李明的年龄大于60岁
    
    {% endif %}
{% elif dict1.age > 10 %}
    
    李明的年龄为10~20
    
{% else %}
    
    李明的年龄为{{ dict1.age }}
    
{% endif %}

{#{% for %}的使用#}
{% for f1 in list1 %}
    {{ f1 }}
    {% for f3 in list3 %}
        
    {% endfor %}
    
    {{ f3 }} |
    
    
{% endfor %}

{# forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1:#}
{% for item in list1 %}
    
    {{ forloop.counter }}:{{ item }}
    
    
    {{ forloop.revcounter0 }}:{{ item }}
    
    
    
{% endfor %}

{#{% empty %}#}
{% for item in list2 %}
    
    {{ forloop.counter0 }}:{{ item }}
    
{% empty %}
    
    这个列表是空的！
    
{% endfor %}

    －－－－－－{%csrf_token%}：csrf_token标签

    用于生成csrf_token的标签，用于防治跨站攻击验证。注意如果你在view的index里用的是render_to_response方法，不会生效

         其实，这里是会生成一个input标签，和其他表单标签一起提交给后台的。

    －－－－－－{% url  'reg'  %}    :引用路由配置的地址 或 别名

    "{% url "bieming"%}" >
          "text">
          "submit"value="提交">
          {%csrf_token%}

    －－－－－－{% with %}   :用更简单的变量名替代复杂的变量名

    {% with total=fhjsaldfhjsdfhlasdfhljsdal %} {{ total }} {% endwith %}

    －－－－－－{% verbatim %}: 禁止render，渲染出来的内容就是 {{ hello }}

    {% verbatim %}
         {{ hello }}
{% endverbatim %}

    －－－－－－{% load %}: 加载标签库   如{% load static %}

    4、自定义filter和simple_tag（* * * *）

    a、在app文件夹下创建templatetags模块

    b、创建任意 .py 文件，如：my_tags.py

    from django import template
from django.utils.safestring import mark_safe

register = template.Library()   #register的名字是固定的,不可改变


@register.filter
def filter_multi(v1,v2):
    return  v1 * v2


@register.simple_tag
def simple_tag_multi(v1,v2):
    return  v1 * v2


@register.simple_tag
def my_input(id,arg):
    result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
    return mark_safe(result)

    c、在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py ：{% load my_tags %}

    d、使用simple_tag和filter

    -------------------------------.html
{% load xxx %}   #首行
    
    
 # num=12
{{ num|filter_multi:2 }} #24

{{ num|filter_multi:"[22,333,4444]" }}


{% simple_tag_multi 2 5 %}    #参数不限,但不能放在if for语句中
{% simple_tag_multi num 5 %}

    e、注意：在settings中的INSTALLED_APPS配置当前app，不然django无法找到自定义的simple_tag.

    自定义filter和自定义标签各有优缺点：

    1、自定义filter 只能传一个参数，而自定义标签 可以传多个参数

    2、filter可以用在if 等控制语句后，simple_tag不可以

    {% if num|filter_multi:30 > 100 %}
    {{ num|filter_multi:30 }}
{% endif %}

    5、include引入模板和extends模板继承

    －－－－－－include (引入)

       

    主模板　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　include引入的模板

    --->下图是从浏览器输入url 到后台程序的响应过程:

    －－－－－－extends 模板继承

    以下是使用模板继承使用方法：

    <1>如果在模板中使用 {% extends %} ，必须保证其为模板中的第一个模板标记。 否则，模板继承将不起作用。

 <2>一般来说，基础模板中的 {% block %} 标签越多越好。 记住，子模板不必定义父模板中所有的代码块，因此
    你可以用合理的缺省值对一些代码块进行填充，然后只对子模板所需的代码块进行（重）定义。 俗话说，钩子越
    多越好。

 <3>如果发觉自己在多个模板之间拷贝代码，你应该考虑将该代码段放置到父模板的某个 {% block %} 中。
    如果你需要访问父模板中的块的内容，使用 {{ block.super }}这个标签吧，这一个魔法变量将会表现出父模
    板中的内容。 如果只想在上级代码块基础上添加内容，而不是全部重载，该变量就显得非常有用了。

 <4>不允许在同一个模板中定义多个同名的 {% block %} 。 存在这样的限制是因为block 标签的工作方式是双向的。
    也就是说，block 标签不仅挖了一个要填的坑，也定义了在父模板中这个坑所填充的内容。如果模板中出现了两个
    相同名称的 {% block %} 标签，父模板将无从得知要使用哪个块的内容。

    实例练习：

    代码：

    -----------------------------------------------------urls
from django.contrib import admin
from django.conf.urls import url
from app01 import views

urlpatterns = [
    url('admin/', admin.site.urls),
    url('base/', views.backend),
    url('student/', views.student),
    url('teacher/', views.teacher),
    url('course/', views.course),
    url('classes/', views.classes),
]

------------------------------------------------------views
from django.shortcuts import render

# Create your views here.
def backend(request):
    return render(request,"base.html")

def student(request):
    student_list = ['唐僧','悟空','悟能','悟净']

    return render(request,"student.html",locals())

def teacher(request):
    teachers_list = ['如来','观音','弥勒','菩提']
    return render(request,"teacher.html",locals())

def course(request):
    course_list = ['语文','数学','英语','科学']
    return render(request,"course.html",locals())

def classes(request):
    classes_list = ['三年一班','四年二班','五年三班','六年一班']
    return render(request,"classes.html",locals())

--------------------------------------------------------template/.html
--------------------------------------base.html
DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页title>
    <style>
        *{margin: 0;
        padding: 0;
        }
        a{text-decoration: none}
        .head-box{
            width: 100%;
            height: 80px;
            background-color: cadetblue;
            font-size: 26px;
            font-weight: 700;
            text-align: center;
            line-height: 80px;
        }
        .left-box{
            display: inline-block;
            float: left;
            width: 25%;
            min-height: 800px;
            background-color: darkgray;
        }
        .left-box div{
            width: 100%;
            height: 100px;
            text-align: center;
            line-height: 80px;
            font-size: 30px;
            font-weight: 500;
            {#border: 1px solid darkred;#}
        }
        .content-box{
            display: inline-block;
            float: right;
            width: 75%;
            min-height: 800px;
            font-size: 50px;
            font-weight: 700;
            color: darkred;
            text-align: center;

        }
        .footer-box{
            float: left;
            width: 100%;
            height: 120px;
            text-align: center;
            line-height: 120px;
            background-color: lightgreen;
        }
    style>
head>
<body>
<div class="outer">
    <div class="head-box">校务信息管理系统div>
    <div class="left-box">
        <div class="student manage"><a href="/student/">学生信息a>div>
        <hr>
        <div class="teacher manage"><a href="/teacher/">老师信息a>div>
        <hr>
        <div class="course manage"><a href="/course/">课程信息a>div>
        <hr>
        <div class="classes manage"><a href="/classes">班级信息a>div>
    div>
    <div class="content-box">

        {% block content %}  {# 块随便取个名字 但必须唯一 #}
            <h5>欢迎来到校务管理系统首页！h5>
        {% endblock %}

    div>
    <div class="footer-box">底部栏div>
div>
body>
html>

------------------------------------------student.html
{% extends "base.html" %}

{% block content %}
    {% for item in student_list %}
        <h5>学生：{{ item }}h5>
    {% endfor %}
{% endblock %}

-------------------------------------------teacher.html
{% extends "base.html" %}

{% block content %}
    {% for item in teachers_list %}
        <h5>教师：{{ item }}h5>
    {% endfor %}
{% endblock %}

-------------------------------------------course.html
{% extends "base.html" %}

{% block content %}
    {% for item in course_list %}
        <h5>课程：{{ item }}h5>
    {% endfor %}
{% endblock %}

------------------------------------------classes.html
{% extends "base.html" %}

{% block content %}
    {% for item in classes_list %}
        <h5>班级：{{ item }}h5>
    {% endfor %}
{% endblock %}

    八、Models.py --- 操作数据库

    1. 数据库的配置

    （1）django默认支持sqlite，mysql, oracle,postgresql数据库。

         <1> sqlite

                django默认使用sqlite的数据库，默认自带sqlite的数据库驱动 , 引擎名称：django.db.backends.sqlite3

         <2> mysql

                引擎名称：django.db.backends.mysql

    （2）mysql驱动程序

    •    MySQLdb(mysql python)
    •    mysqlclient
    •    MySQL
    •    PyMySQL(纯python的mysql驱动程序)

    （3）在django的项目中会默认使用sqlite数据库，在settings里有如下设置：

         

    如果我们想要将数据库更改为mysql，需要修改如下：

        

     在settings.py中修改DATABASE配置

    DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql', 

        'NAME': 'books',    #你的数据库名称

        'USER': 'root',   #你的数据库用户名

        'PASSWORD': '', #你的数据库密码

        'HOST': '', #你的数据库主机，留空默认为localhost

        'PORT': '3306', #你的数据库端口

    }

}

    注意：

    NAME即数据库的名字，在mysql连接前该数据库必须已经创建，而上面的sqlite数据库下的db.sqlite3则是项目自动创建

USER和PASSWORD分别是数据库的用户名和密码。

设置完后，再启动我们的Django项目前，我们需要激活我们的mysql。

然后，启动项目，会报错：no module named MySQLdb

这是因为django默认你导入的驱动是MySQLdb，可是MySQLdb对于py3有很大问题，所以我们需要的驱动是PyMySQL

所以，我们只需要找到项目名文件下的__init__,在里面写入：

import pymysql
pymysql.install_as_MySQLdb()

问题解决！

    （4）Django连接MySQL出错

    错误一：No module named 'MySQLdb'

    错误二：django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.13 or newer is required; you have 0.9.3.

    Django连接MySQL出错
错误一：No module named 'MySQLdb'

原因：python3连接MySQL不能再使用mysqldb，取而代之的是pymysql。

解决方法：在python的MySQL包中，即路径：C:\Users\adong\AppData\Local\Programs\Python\Python36\Lib\site-packages\Django-2.0.3-py3.6.egg\django\db\backends\mysql

下的__init__.py文件中加入：

import pymysql

pymysql.install_as_MySQLdb()

 
错误二：django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.3 or newer is required; you have 0.7.11.None

原因：在解决了错误一以后出现了此错误。

解决方法：在python的MySQL包中，即路径：C:\Users\Administrator\AppData\Local\Programs\Python\Python36\Lib\site-packages\Django-2.2.4-py3.6.egg\django\db\backends\mysql

下的 base.py 文件中，注释掉一下两行代码：

if version < (1, 3, 3):
     raise ImproperlyConfigured("mysqlclient 1.3.3 or newer is required; you have %s" % Database.__version__)

    九、ORM---Django用于操作数据库的语言

    ORM---Object Relation Mapping(对象关系映射)

    用于实现面向对象编程语言里不同类型系统的数据之间的转换，换言之，就是用面向对象的方式去操作数据库的创建表以及增删改查等操作。

    ORM相对于原生SQL语句的优点：

    　　　 1、 ORM使得我们的通用数据库交互变得简单易行，而且完全不用考虑SQL语句。快速开发，由此而来。

                2、 可以避免一些新手程序猿写sql语句带来的性能问题。

    　　　 3 、便于搬家迁移，换数据库之后 ORM调用的语法相似 换个sql接口就可以了

    比如 我们查询User表中的所有字段:

                新手可能会用select ＊ from  auth_user，这样会因为多了一个匹配动作而影响效率的。

    ORM相对于原生SQL语句的缺点：

    　　　 1、  性能有所牺牲。不过现在的各种ORM框架都在尝试各种方法，比如缓存，延迟加载登来减轻这个问题。效果很显著。

                2、  对于个别复杂查询，ORM仍然力不从心。为了解决这个问题，ORM一般也支持写原生的sql语句。

                3、  通过QuerySet的query属性查询对应操作的sql语句

    author_obj=models.Author.objects.filter(id=2)
print(author_obj.query)

    下面要开始学习Django ORM语法了，为了更好的理解，我们来做一个基本的 书籍/作者/出版商 数据库结构。 这是一个众所周知的例子，很多SQL有关的书籍也常用这个举例。

    1. 数据库表 的创建：

    实例：我们来假定下面这些概念，字段和关系

    作者模型：一个作者有姓名。

    作者详细模型：把作者的详情放到详情表，包含性别，email地址和出生日期，作者详情模型和作者模型之间是一对一的关系（one－to－one）（类似于每个人和他的身份证之间的关系），

    在大多数情况下我们没有必要将他们拆分成两张表，这里只是引出一对一的概念。

    出版商模型：出版商有名称，地址，所在城市，省，国家和网站。

    书籍模型：书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系（many－to－many），一本书只应该由一个出版商出版，

    所以出版商和书籍是一对多关联关系（one－to－many），也被称作外键。

    from django.db import models
#出版社
class Publisher(models.Model):
    name = models.CharField(max_length=30, verbose_name="名称")
    address = models.CharField("地址", max_length=50)
    city = models.CharField('城市',max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()
 
    class Meta:
        verbose_name = '出版商'
        verbose_name_plural = verbose_name
 
    def __str__(self):
        return self.name
 
#作者
class Author(models.Model):
    name = models.CharField(max_length=30)
    def __str__(self):
        return self.name
 
#作者详细信息
class AuthorDetail(models.Model):
    sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))
    email = models.EmailField()
    address = models.CharField(max_length=50)
    birthday = models.DateField()
    author = models.OneToOneField(Author)
 
#书籍
class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
    def __str__(self):
        return self.title

    注意1：记得在settings里的INSTALLED_APPS中加入'app01',然后再同步数据库。

    注意2: publisher = models.ForeignKey("Publisher")　　　　#出版社和书籍之间是一对多的关系（一个出版社能出版多本书，一本书只能由一个出版社出版）

    注意3：（注意要将外键写在‘多’的一方）。Django支持通用的数据关系：一对一，一对多和多对多。

    分析代码：

    <1>  每个数据模型都是django.db.models.Model的子类，它的父类Model包含了所有必要的和数据库交互的方法。并提供了一个简介漂亮的定义数据库字段的语法。

    <2>  每个模型相当于单个数据库表（多对多关系例外，会多生成一张关系表），每个属性也是这个表中的字段。属性名就是字段名，它的类型（例如CharField）相当于数据库的字段类型（例如varchar）。

    大家可以留意下其它的类型都和数据库里的什么字段对应。

    <3>  模型之间的三种关系：一对一，一对多，多对多。

    　　一对一：实质就是在主外键（author_id就是foreign key）的关系基础上，给外键加了一个UNIQUE＝True的属性；

    　　一对多：就是主外键关系；（foreign key）

    　　多对多：(ManyToManyField) 自动创建第三张表(当然我们也可以自己创建第三张表：两个foreign key)

    注意：

    MySQL数据库实际上提供的只有一对多Foreign key，一对一是在Foreign key的基础上添加Unique约束，

    多对多是再创建第三张表 它在与另外两张表建立一对多Foreign key约束

    一对多

    区分模型字段和Field参数

    <4>  模型常用的字段

    <1> CharField
        #字符串字段, 用于较短的字符串.
        #CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数.

<2> IntegerField
       #用于保存一个整数.

<3> FloatField
        # 一个浮点数. 必须 提供两个参数:
        #
        # 参数                 描述
        # max_digits        总位数(不包括小数点和符号)
        # decimal_places    小数位数
                # 举例来说, 要保存最大值为 999 (小数点后保存2位),你要这样定义字段:
                #
                # models.FloatField(..., max_digits=5, decimal_places=2)
                # 要保存最大值一百万(小数点后保存10位)的话,你要这样定义:
                #
                # models.FloatField(..., max_digits=19, decimal_places=10)
                # admin 用一个文本框()表示该字段保存的数据.

<4> AutoField
        # 一个 IntegerField, 添加记录时它会自动增长. 你通常不需要直接使用这个字段; 
        # 自定义一个主键：my_id=models.AutoField(primary_key=True)
        # 如果你不指定主键的话,系统会自动添加一个主键字段到你的 model.

<5> BooleanField
        # A true/false field. admin 用 checkbox 来表示此类字段.

<6> TextField
        # 一个容量很大的文本字段.
        # admin 用一个