Django 总结（超级实用！！！）

一．什么是web框架？

框架，即framework，特指为解决一个开放性问题而设计的具有一定约束性的支撑结构，使用框架可以帮你快速开发特定的系统，简单地说，就是你用别人搭建好的舞台来做表演。

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

from wsgiref.simple_server import make_server

def f1(req):
    print(req)
    print(req["QUERY_STRING"])
    f1=open("index1.html","rb")
    data1=f1.read()
    return [data1]

def f2(req):
    f2=open("index2.html","rb")
    data2=f2.read()
    return [data2]

import time

def f3(req):        #模版以及数据库
    f3=open("index3.html","rb")
    data3=f3.read()
    times=time.strftime("%Y-%m-%d %X", time.localtime())
    data3=str(data3,"utf8").replace("!time!",str(times))
    return [data3.encode("utf8")]


def routers():
    urlpatterns = (
        ('/yuan',f1),
        ('/alex',f2),
        ("/cur_time",f3)
    )
    return urlpatterns


def application(environ, start_response):
# environ封装收到的内容
# start_response 定义发出的内容
    print(environ['PATH_INFO'])
    path=environ['PATH_INFO']
    start_response('200 OK', [('Content-Type', 'text/html')])


    urlpatterns = routers()
    func = None
    for item in urlpatterns:
        if item[0] == path:
            func = item[1]
            break
    if func:
        return func(environ)
    else:
        return ["
404
".encode("utf8")]

httpd = make_server('', 8518, application)

print('Serving HTTP on port 8084...')

# 开始监听HTTP请求:
httpd.serve_forever()

二． MVC和MTV模式

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

• 模型负责业务对象与数据库的对象(ORM)；
• 视图负责与用户的交互(页面)；
• 控制器©接受用户的输入调用模型和视图完成用户的请求（逻辑函数）。

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

• Model(模型)：负责业务对象与数据库的对象(ORM)
• Template(模版)：负责如何把页面展示给用户
• View(视图)：负责业务逻辑，并在适当的时候调用Model和Template
• 此外，Django还有一个url分发器，它的作用是将一个个URL的页面请求分发给不同的view处理，view再调用相应的Model和Template
  

三．django的流程和命令行工具

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

    #1  创建project
        django-admin startproject mysite

	#2  创建APP              
		python mannage.py startapp  app_name
		django-admin startapp app_name


    #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  使用模版
       render(req,"index.html")   

    #6  启动项目
       python manage.py runserver  127.0.0.1:8090
 
    #7  连接数据库，操作数据
       model.py
        生成同步数据库的脚本：python manage.py makemigrations  
		同步数据库:  python manage.py migrate 
        清空数据库： python manage.py  flush
         注意：在开发过程中，数据库同步误操作之后，难免会遇到后面不能同步成功的情况，解决这个问题的一个简单粗暴方法是把migrations目录下的脚本（除__init__.py之外）全部删掉，再把数据库删掉之后创建一个新的数据库，数据库同步操作再重新做一遍。

	#8  查询某个命令的详细信息
        django-admin.py  help  startapp
			admin 是Django 自带的一个后台数据库管理系统。

四. Django的配置文件(settings)

静态文件设置:

4.1 概述：

静态文件交由Web服务器处理，Django本身不处理静态文件。

4.2 MEDIA_ROOT和MEDIA_URL

4.3 STATIC_ROOT和STATIC_URL、

STATIC主要指的是如css,js,images这样文件，在settings里面可以配置STATIC_ROOT和STATIC_URL.

STATIC_URL = '/static/'               #引用名
STATICFILES_DIRS = (
            os.path.join(BASE_DIR,"statics")  #实际名 ,即实际文件夹的名字
        )

五.Django URL (路由系统)

URL配置(URLconf)就像Django 所支撑网站的目录。它的本质是URL模式以及要为该URL模式调用的视图函数之间的映射表；你就是以这种方式告诉Django，对于这个URL调用这段代码，对于那个URL调用那段代码。

urlpatterns = [
    url(正则表达式, views视图函数，参数，别名),
]
参数说明：
一个正则表达式字符串
一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串
可选的要传递给视图函数的默认参数（字典形式）
一个可选的name参数

5.1 Named groups

import re

ret=re.search('(?P\d{3})/(?P\w{3})','weeew34ttt123/ooo')

print(ret.group())   # 123/ooo
print(ret.group('id'))     # 123
print(ret.group('name'))    # ooo

说明：(?P\d{3})
(?P<命名>\正则表达式)

5.2 url映射分发

from django.conf.urls import include, url

urlpatterns = [
   path('admin/', admin.site.urls),
   path('blog/', include('blog.urls')),
]

六. Django Views（视图函数）

http请求中产生两个核心对象：
http请求：HttpRequest对象
http响应：HttpResponse对象

所在位置：django.http

6.1 HttpRequest对象的属性和方法：

属性：

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

方法：

get_full_path() 比如：http://127.0.0.1:8000/index33/?name=123 ,req.get_full_path()得到的结果就是/index33/?name=123
req.path:/index33

6.2 HttpResponse对象：
对于HttpRequest对象来说，是由django自动创建的，但是，HttpResponse对象就必须我们自己创建。每个view请求处理方法必须返回一个HttpResponse对象。
render()（推荐） render_to_response() 页面渲染；
redirect(“路径”) 页面跳转，可以是网页路径，或者程序路径；
locals()： 可以直接将函数中所有的变量传给模板；

七．Template（模板语言）基础

7.1模版的组成

HTML代码＋逻辑控制代码

7.2逻辑控制代码的组成

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

语法格式： {{var_name}}

Template和Context对象：

t = Template('Hello, {{ name }}')
for name in ('John', 'Julie', 'Pat'):
    print t.render(Context({'name': name}))

由此可见 ，模板对象可以重复使用。

def current_time(req):
    now=datetime.datetime.now()
    return render(req, 'current_datetime.html', {'current_date':now})

深度变量的查找（万能的句点号）：
在 Django 模板中遍历复杂数据结构（list、dictionary和自定义的对象）的关键是句点字符 (.)。

# 首先，句点可用于访问列表索引，例如：
>>> 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.'

# 用于任意的对象。
>>> 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.'

变量的过滤器(filter)的使用：
语法格式： {{obj|filter:param}}

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='跳转'
{% autoescape off %}
  {{ value6 }}
{% endautoescape %}

{{ value6|safe }}
  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'

7.2.2 标签(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开始计数，第一次循环设为03，forloop.revcounter4，forloop.revcounter05，forloop.first当第一次循环时值为True，在特别情况下很有用：

{%csrf_token%}：csrf_token标签：
用于生成csrf_token的标签，用于防治跨站攻击验证（主要是提交From表单时）。 其实，这里是会生成一个input标签，和其他表单标签一起提交给后台的。用于验证。

{% url %}: 引用路由配置的地址：

          
          
          {%csrf_token%}

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

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

{% verbatim %}: 禁止render

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

{% load %}: 加载标签库

7.2.3 自定义filter和simple_tag

a. 在app中创建templatetags模块(必须的)
b. 创建任意 .py 文件，如：my_tags.py
c. 在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py ：{% load my_tags %}
d. 使用simple_tag和filter（如何调用）
e. 在settings中的INSTALLED_APPS配置当前app，不然django无法找到自定义的simple_tag.

filter 最多传两个参数。
simple_tag 可以传多个参数，不能用于 if 和 for 语句。

7.2.4 extend模板继承

在整个网站中，如何减少共用页面区域（比如站点导航）所引起的重复和冗余代码？
答： 模板继承 。
本质上来说，模板继承就是先构造一个基础框架模板，而后在其子模板中对它所包含站点公用部分和定义块进行重载。

父模板base.html部分：

        //block1


    
My helpful timestamp site
    {% block content %}{% endblock %}      //block2
    {% block footer %}                  ////block3
    
Thanks for visiting my site.
    {% endblock %}

子1模板部分：

{% extends "base.html" %}
{% block title %}The current time{% endblock %}
{% block content %}
It is now {{ current_date }}
{% endblock %}

子2模板部分：

{% extends "base.html" %} 
{% block title %}Future time{% endblock %}
{% block content %}
In {{ hour_offset }} hour(s), it will be {{ next_time }}
{% endblock %}

以下是使用模板继承的一些诀窍：
<1>如果在模板中使用 {% extends %} ，必须保证其放在最上面。 否则，模板继承将不起作用。

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

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

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

八．Models

8.1数据库的配置

8.1.1 django默认支持sqlite，mysql, oracle,postgresql数据库。

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

8.1.2 mysql驱动程序

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

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

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

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

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', 
        'NAME': 'books',    #你的数据库名称
        'USER': 'root',   #你的数据库用户名
        'PASSWORD': '', #你的数据库密码
        'HOST': '',  #你的数据库主机，留空默认为localhost
        'PORT': '3306', #你的数据库端口
    }
}

因为django默认你导入的驱动是MySQLdb，可是MySQLdb对于py3有很大问题，所以我们需要的驱动是PyMySQL。
所以，我们只需要找到项目名文件下的__init__,在里面写入：

import pymysql
pymysql.install_as_MySQLdb()