Django的开始

一 浏览器相关知识

　http：只有依赖一回，属于短链接，不会报错客户端的信息。

　浏览器相当于一个客户端，客户端的链接

　服务端：socket服务端，起服务监听客户端的请求。

import socket
sk=socket.socket()
sk.bind(('192.168.11.38',8888))
sk.listen(5)

def index():
    with open('轮播网页.html',encoding='utf-8')as f:
        ret=f.read()
        return ret
def login():
    with open('login.html',encoding='utf-8')as f:
        ret=f.read()
    import pymysql
    conn=pymysql.connect(
        host='127.0.0.1',
        port=3306,
        user='root',
        passwd='0410',
        db='day46'
    )
    cursor=conn.cursor()
    cursor.execute('select * from user')
    user_list=cursor.fetchall()
    cursor.close()
    conn.close()
    res=''
    for i in user_list:
        res += '''
        <tr>
            <td>{}</td>
            <td>{}</td>
            <td>{}</td>
        </tr>
        '''.format(i[0], i[1], i[2])
    tables= ret.replace('@@xx@@',res)
    return tables

def info():
    return "这是个人信息"

info_index=[
    ('/login/',login),
    ('/index/',index),
    ('/info/',info)
]
while True:
    conn,addr=sk.accept()
    print(addr)
    data=conn.recv(8096)
    data3=str(data,encoding='utf-8')
    data1=data3.split('\r\n\r\n')[0]
    print('*'*50)
    print(data1)
    data2=data1.split('\r\n')[0].split(' ')[1]
    print(data2)
    ingo_name=None
    for i in info_index:
        if data2==i[0]:
            ingo_name=i[1]
            break
    if ingo_name:
        response=ingo_name()
    else:
        response='404'

    conn.send(b'HTTP/1.1 200 0k\r\nContent-Type:text/html;charset=utf-8\r\n\r\n')
    conn.send(response.encode('utf-8'))
    conn.close()

二 框架的介绍

　tornado：模版都是人家写好的，我们只管拿来使用。

　Django：服务端可以自己写，其他的模版都是别人写好的。

　flask：服务端和模版渲染都是自己写的，函数的功能都是别人写好了的。

　所有的web框架叫做web应用服务器。

三 django的安装和使用

　安装：pip install django。

　创建项目：django-admin startproject 项目名

　手动创建：

　查看参数：django-admin。

　开启项目：python manage.py runserver

　使用命令创建app：atsrtapp app名

　　配置文件的INSTALLED_APPS添加：'rbac.apps.RbacConfig',

　响应格式：

　　{

　　"接收到的想要"：回复

。。。。。

　　}

　相关文件夹：

　　manage.py：所有django命令，所有的django项目相关的都是基于manage这个文件实现的。

　　settings.py：配置文件，客户端可以直接访问这里面的一些文件

　　urls.py：函数功能，url内部给函数自动传入了一个参数，就是request参数。

　　　如果想要获取到url里面的内容，使用正则表达式里面的分组，将要获取的内容括起来，然后会被当作实参传入到函数功能里面去。

url配置：
	   注意：url：匹配的是url的路径部分
       import re
       re.findall("^articls/2004/$","articls/2004/asdsa")

	无名分组：
       # url(r'^articls/(\d{4})/(\d{2})$', views.archive3,),  # archive2(request,2000,11)	     

    有名分组：
      # url(r'^articls/(?P<y>\d{4})/(?P<m>\d{2})$', views.archive4,), # archive2(request,y=2000,m=11)

　　blog分发：将一个大的urls文件进行分组，分成多个小的urls文件，然后再在大的urls文件里面调用这些小的urls文件。

小urls文件
from django.conf.urls import url, include
from django.contrib import admin
from app01 import views

urlpatterns = [
    url(r'^articls/2004/$', views.archive, ),  # 完全匹配 #  archive(request)
    url(r'^articls/(?P<y>\d{4})/(?P<m>\d{2})$', views.archive4, ),  # archive2(request,y=2000,m=11)
]

大urls文件
from django.conf.urls import url,include
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^index/', views.index),
    url(r'^login.html/', views.login,name="laogou"), # login(request)
    url(r'^foo/', views.foo), # login(request)

    ##############路由分发####################

    url(r'^app01/', include('app01.urls')) ,  # /app01/articls/2004

]

　　wsgi.py ：socketserver相关，wsgi文件和django结合使用的，django是没有服务端的，而wsgi文件为django提供了一个服务端。

　　　wsgi文件是一种协议，是web网关接口，分别有两种：wsgiref和uwsgi。

　　　　wsgiref是可以实现基本的，大多数用来调试的。

　　　　uwsgi是用于企业的。

　　　　wsgi导入的文件是：

from django.core.wsgi import get_wsgi_application

　　app文件：project　　：主要用于业务的分类，是整个项目下的一个程序

　　　主站，app：专门处理相关的业务，启动app的web命令：

python manage.py startapp web

　　　后台管理 app：启动app的backend命令：

python manage.py startapp backend

　　models文件：主要是写web应用相关的内容。

四 使用

　views视图分为两大块：一个是请求对象，另一个是响应对象。

　　请求对象request：代表所有请求的内容

　　　request.method：获取请求，请求的方法具体是什么

　　　request.POST.get('***')：以什么途径发送的请求

　　　request.GET.get（‘***’）：从url中获取具体的什么数据或者内容，在后端函数里面需要使用GET

　　　request.POST.getlist：同时可以获取多个值，所有的值都是在一个列表里面

　　　request.encoding：请求的格式

　　　request.path 和request.info：请求路径的内容，没有数据内容

　　　request.get_full_path：请求路径的内容，还有数据的内容

def archive(request):
    print(request.path)  # /app01/articls/2004/
    print(request.path_info)  # /app01/articls/2004/
    print(request.get_full_path())  # /app01/articls/2004/?a=1

　　　request.is_ajax：判断这次的请求是不是ajax请求

　　　还有request.COOKICS；request.session；request.path等

　　　　GET:

		URL: 127.0.0.1:8000/class_list/?name=alex&age=18

		request.GET.get("name")
		request.GET.get("age")	

	POST：

		<form class="form-horizontal" action="/add_class/" method="post">
			<div class="form-group">
				<label for="inputclassname" class="col-sm-2 control-label">班级名称</label>
				<div class="col-sm-10">
					<input name="class_name" type="text" class="form-control" id="inputclassname" placeholder="班级名称">
				</div>
			</div>
			<div class="form-group">
				<div class="col-sm-offset-2 col-sm-10">
					<button type="submit" class="btn btn-default">提交</button>
				</div>
			</div>
		</form>

　request.body：所有的请求数据都会在这里面。

from django.shortcuts import render,HttpResponse

# Create your views here.

def login(request):
    if request.is_ajax():
        print(request.body) # b'{"user":"alex","pwd":"123"}'
        # b'user=alex&pwd=123&csrfmiddlewaretoken=PCLE4jNWOmLcmd5LiY1qrwTWQZLpZdSktwwwPswNKg7DhblKO6X1fBDkB05yoNMm'
        print(request.POST) # {'user': ['alex'], 'pwd': ['123'], 'csrfmiddlewaretoken': ['PCLE4jNWOmLcmd5LiY1qrwTWQZLpZdSktwwwPswNKg7DhblKO6X1fBDkB05yoNMm']}
        print(request.GET)  # {}

        # user=request.POST.get("user")
        # pwd=request.POST.get("pwd")
        #
        # print(user,pwd)
        # print("=======")
        # import json
        # s=request.body.decode("utf8")
        # d=json.loads(s)
        # print(d.get("user"))
        # print(d.get("pwd"))
        return HttpResponse("OK")

    return render(request,"index.html")

def reg(request):
    if request.is_ajax():
        print(request.POST,"=======")

        return HttpResponse("OK")

    return render(request,"reg.html")

　request.FILES：文件上传的地方接收到的是一个文件对象，也就是一个文件句柄，直接.name就是文件名字。

from django.shortcuts import render,HttpResponse

# Create your views here.

def index(request):

    # #print(request.body)
    # print(request.POST) # <QueryDict: {'csrfmiddlewaretoken': ['2Fq1vmv59yRSUxDwlkym3qmk5bNpfdHLGzbTgveW5sdjPvTvRsuXRv6IQc7yENBN'], 'user': ['yuan'], 'cFile': ['day76.txt']}>
    # print(request.FILES)
    #
    # file_obj=request.FILES.get("cFile")
    # name=file_obj.name
    # print(name)  # day76.txt
    # import os
    #
    # from filePut import settings
    # path=os.path.join(settings.BASE_DIR,"app01","static",name)
    # with open(path,"wb") as f_write:
    #     for line in file_obj:
    #         f_write.write(line)

    return render(request,"index.html")

def indexAjax(request):
    print(request.body)
    print(request.POST)
    print(request.GET)

    # print(request.POST)
    # print(request.FILES)
    # file_obj=request.FILES.get("cFile")
    # name=file_obj.name
    # print(name)  # day76.txt
    # import os
    #
    # from filePut import settings
    # path=os.path.join(settings.BASE_DIR,"app01","static",name)
    # with open(path,"wb") as f_write:
    #     for line in file_obj:
    #         f_write.write(line)

    return HttpResponse("")

　新手三件套：

　　导入：from django.shortcuts import

　　　HttpResponse：http的响应，里面只能够方字符串

　　　render：渲染，一次请求一次响应。每请求一次就会被渲染。

　　　　render（request, 'html文件'）

　　　　render（request,"html文件",{"替换的内容":值})

　　　　render（request,"html文件",locals())   ：局部的变量都可以在HTML文件里面使用

　　　redirect：跳转页面，重定向这一次请求，重定向时，需要多发送一次请求。

			以登录为例：
			    第一次请求：
			        请求url： http://127.0.0.1:8000/login.html/      GET     无请求数据
					login.html/-------> views.login------>login()
					响应到一个login.html页面

				第二次请求：
                     请求url： http://127.0.0.1:8000/login.html/     POST    有请求数据  {"user":"alex","pwd":"123"}
  					 login.html/-------> views.login------>login()
					 响应的return redirect("/index/")到浏览器，通知浏览器再发送请求："/index/"

					 请求url： http://127.0.0.1:8000/index/       get请求   没有数据
					 index/ --->url(r'^index/', views.index),---->index()

					 响应一个index.html

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

def mysql():
    import pymysql
    user_dic = {}
    conn=pymysql.connect(host="127.0.0.1", port=3306, user="root", passwd="0410", db="day43", charset="utf8")
    cursor=conn.cursor()
    cursor.execute('select name,password from user')
    user_list = cursor.fetchall()
    cursor.close()
    conn.close()
    for user in user_list:
        user_dic[user[0]]=user[1]
    return user_dic

def login(request):
    if request.method=='GET':
        return render(request,'登陆界面.html')
    else:
        user_dic=mysql()
        for user in user_dic:
            if request.POST.get('user')==user and request.POST.get('passwd')==user_dic[user] and request.POST.get('pwd')==user_dic[user]:
                return redirect('http://www.xiaohuar.com/hua/')
            elif request.POST.get('user')==user and request.POST.get('passwd')==user_dic[user] and request.POST.get('pwd')!=user_dic[user]:
                return render(request, '登陆界面.html', {'error_msg': '密码输入不一致'})
        else:
            return render(request,'登陆界面.html',{'error_msg':'用户名和密码错误'})

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

　http就是基于一次请求一次响应的。

　模版语言：

　　格式1：

　　　{% for i in **%}

　　　　{{x}}

　　　{% endfor %}

　　格式2：

　　　{{ 变量名 }}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .c1 {
            width: 100%;
            height: 50px;
            background-color:#DDDDDD;
            opacity: 0.3;
        }

        .c4{
            width:80%;
            height:50px;
            background-color:#DDDDDD;
            margin-left: 10%;
        }

        .c7{
            width: 100px;
            height: 50px;
            float:left;
        }

        .c8{
            width: 80px;
            height: 50px;
            float:right;
        }

        .c9{
            width: 120px;
            height: 50px;
            float:right;
        }

        .c10{
            width: 80px;
            height: 50px;
            float:right;
        }

        .c11{
            width: 80px;
            height: 50px;
            float:right;
        }

         .c12{
             width: 50px;
             height: 50px;
             float:right;
        }

        .s1{
            line-height:50px;
            text-align: center;
            color:#1F1E1E;
        }

        .c2{
            width:100%;
            height: 60px;
            background-color: #ffffff;
            margin-top: 20px;
        }

        .c5{
            width: 80%;
            height: 60px;
            background-color: #FFFFFF;
            margin-left: 10%;
        }
        .c3{
            width:100%;
            height:auto;

        }

        .c6{
            width: 80%;
            height: auto;
            margin-left: 10%;
        }

        .d1{
            width: 500px;
            height: 400px;
            float: left;
            margin-top: 50px;
        }

        .d3{
            width: 500px;
            height: 50px;
            margin-top:60px;
        }

        .s2{
            font-weight:600;
            font-size:30px;
            color: #2e2e2e;
            line-height:50px;
            margin-left: 70px;

        }

        .p1{
            margin-left: 120px;
        }

        .p2{
            margin-left: 104px;
        }

        .i2{
            margin-left: 15px;
        }

        .s3{
            color:red;
        }

        .p4{
            margin-left: 150px;
        }

        .s4{
            color:#0000CC;
        }

        .i3{
            font-size: 14px;
        }

        .p5{
            margin-left: 200px;
        }

        .i5{
            font-size: 10px;
             background-color:red;
        }

        .d2{
            width: 314px;
            height:400px;
            float: right;
            margin-top: 50px;
        }

        .p6{
            margin-left:30px;
        }

        .p7{
            margin-top: 50px;
        }

    </style>
</head>
<body>

<div class="c1">
    <div class="c4">
        <div class="c7"><span class="s1">*收藏网址</span></div>
        <div class="c8"><span class="s1">客户服务</span></div>
        <div class="c9"><span class="s1">VIP会员俱乐部</span></div>
        <div class="c10"><span class="s1">我的订单</span></div>
        <div class="c11"><span class="s1">免费注册</span></div>
        <div class="c12"><span class="s1">登陆</span></div>
    </div>
</div>
<div class="c2">
    <div class="c5"><img src="111.png" alt="悟空"></div>
</div>
<div class="c3">
    <div class="c6">
        <div class="d1">
            <div class="d3"><span class="s2">注册新用户</span></div>
            <form action="/login/" method="post">
                <p class="p1"><span class="s3">*</span>用户名：<input type="text" name="user" class="i2"></p>
                <p class="p1"><span class="s3">*</span>手机号：<input type="text" name="phone" class="i2"></p>
                <p class="p2"><span class="s3">*</span>登陆密码：<input type="password" name="passwd" class="i2"></p>
                <p class="p2"><span class="s3">*</span>确认密码：<input type="password" name="pwd" class="i2"></p>
                <p class="p4"><input type="checkbox" name="ppp"><span class="i3">我已阅读并同意</span><span class="s4 i3">《用户注册协议》</span> </p>
                <p class="p5"><input type="submit" value="开始登录" class="i5"></p>
                {{ error_msg }}
            </form>
        </div>
        <div class="d2">
            <p class="p6 p7"><img src="222.png" alt="悟天" width='250px' height="200px"></p>
        </div>
    </div>
</div>
</body>
</html>

　empty：for循环为空的时候需要执行的任务

        {% for teacher in  teacher_list %}
		要做的事儿
	{% empty %}
		要做的事儿
	{% endfor %}

　if判断语句：

　　{% if 条件语句 %}

　　　　执行语句

　　{% else  %}

　　　　执行语句

　　{% endif %}

      {% if student.class_id == class.id %}
           <option selected value="{{ class.id }}">{{ class.cname }}</option>
      {% else %}
           <option value="{{ class.id }}">{{ class.cname }}</option>
      {% endif %}

　识别标签：{{ 变量名|safe}}

{{ page_html|safe }}

　{% csrf_token %}：中间件

　{% url  '别名'  %}：调用别名，在urls文件中，name的值就是别名。

url(r'^login.html/', views.login,name="Login"), # login(request)
    in template:
        action="{% url 'Login' %}"
	<a href='{% url 'Login' %}'>click</a>

　with模板：将深查找赋值一个变量

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

　csrf_token：如果是post的请求需要处理，防跨域。

　　在form标签里面使用：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<form action="/login.html/" method="post">
    {% csrf_token %}
    <p>姓名：<input type="text" name="user"></p>
    <p>密码：<input type="password" name="pwd"></p>
    <input type="submit">
</form>

</body>
</html>

　　在ajax里面使用：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.js"></script>
</head>
<body>

{% csrf_token %}
<p>姓名：<input type="text" id="user"></p>
<p>密码：<input type="password" id="pwd"></p>
<button>click</button><span class="error"></span>
<script>
     $("button").on("click",function () {

         $.ajax({
             url:"/foo/",
             type:"POST",
             data:{
                 user:$("#user").val(),
                 pwd:$("#pwd").val(),
                 csrfmiddlewaretoken:$("[name='csrfmiddlewaretoken']").val()
             },
             success:function (data) {
                 console.log(data);
                 console.log(typeof data);
                 console.log(JSON.parse(data));
                 var data=JSON.parse(data);
                 if (data.user){
                     location.href="/index/"  // 跳转到首页
                 }
                 else {
                     $(".error").html(data.error_msg).css("color","red");
                     setTimeout(function () {
                         $(".error").html("")
                     },2000)

                 }

             }
         })
     })
</script>
</body>
</html>

　slock.super：在block模板内部使用，添加新的内容，并不会覆盖原来的内容。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{% block con1 %}
 <p>con11111</p>
{% endblock %}

{% block con_li%}
    <ul>
    <li>111</li>
    <li>222</li>
    <li>333</li>
    </ul>
{% endblock %}

</body>
</html>

{% extends 'app01/base.html' %}

{% block con_li %}
   {{ block.super }}

{% endblock %}

　　注意：如果在子文件中不使用slock.super模板，就会将父文件中的文本覆盖。

　settings文件的配置：

　　添加路径：

			TEMPLATES = [
				{
					'BACKEND': 'django.template.backends.django.DjangoTemplates',
					'DIRS': [],   # 在这里进行设置
					'APP_DIRS': True,
					'OPTIONS': {
						'context_processors': [
							'django.template.context_processors.debug',
							'django.template.context_processors.request',
							'django.contrib.auth.context_processors.auth',
							'django.contrib.messages.context_processors.messages',
						],
					},
				},
			]

　　注释内容：

			2. 中间件需要注释一个
			MIDDLEWARE = [
			'django.middleware.security.SecurityMiddleware',
			'django.contrib.sessions.middleware.SessionMiddleware',
			'django.middleware.common.CommonMiddleware',
			# 'django.middleware.csrf.CsrfViewMiddleware',
			'django.contrib.auth.middleware.AuthenticationMiddleware',
			'django.contrib.messages.middleware.MessageMiddleware',
			'django.middleware.clickjacking.XFrameOptionsMiddleware',
		]

　　静态文件设置：

			STATIC_URL = '/static/'
			STATICFILES_DIRS = (
				os.path.join(BASE_DIR, "ss"),  # 静态文件存放位置

			)

import os

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '#vofy$6d=w^aoa0kk#8jhtc3mno9o)eil^8-a^u=)cana=9zq^'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'bigJob.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'bigJob.wsgi.application'

# Database
# https://docs.djangoproject.com/en/1.11/ref/settings/#databases

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

# Password validation
# https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]

# Internationalization
# https://docs.djangoproject.com/en/1.11/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.11/howto/static-files/

STATIC_URL = '/static/'
STATICFILES_DIRS=(os.path.join(BASE_DIR,'css'),)
IEMPLATE_DIRS=(os.path.join(BASE_DIR,'templates'),)

　提交数据格式类似于：

		{
			“class_name”： ”全栈7期“
		}

		request.POST.get("“class_name”：")

　select默认选中
　　在对应的option上加selected

　检验数据有效性：form组件（django自带），自动判断输入的是否为空

　模态框版form提交：因为模态框里面的提交按钮是放在form表单外面的，需要使用JS代码去建立关联
　　$("#modal-submit").on("click", function () {
　　　　$("#myModal form").submit();
　　});

　检验状态显示颜色：has-error，如果检验出来就会是红色

$('#setclassname+span').text(dataobj.status).parent().parent().addClass('has-error')

$(document).ready(function () {
    $('.my-menu-item').on('click', 'a', function () {
            $(this).toggleClass('active');
            var $spanEle = $(this).find('span');
            if ($spanEle.removeClass('glyphicon-menu-left')) {
                $spanEle.removeClass('glyphicon-menu-left').addClass('glyphicon-menu-down');
            } else {
                $spanEle.removeClass('glyphicon-menu-down').addClass('glyphicon-menu-left');
            }
        });
        $('#modal-submit').on('click', function () {
            // {#            $('#mymodal from').submit();#}
            var className = $('#inputclassname2').val();
            $.ajax({
                url: '/modal_add_class/',
                type: 'post',
                data: {'classname': className},
                success: function (data) {
                    if (data === 'OK') {
                        // {#                        if (data.length!=0 ){#}
                        // {#                            var classData=JOSN.parse(data);#}
                        // {#                            var newTr=document.cueateElement('tr');#}
                        // {#                            $(newTr).append('<td>'+classData['id']+'</id>');#}
                        // {#                            $(newTr).append('<td>'+classData['name']+'</id>');#}
                        // {#                            $('td:last').clone().appendTo($(newTr));#}
                        // {#                            $(newTr).appendTo('tbody');#}
                        location.href = '/class_list/';
                    } else {
                        $('#error-msg').text(data).parent().parent().addClass('has-error')
                    }
                }
            })
        })

    $('table').on('click','.set_class_list',function () {
        $('#set_mymodal').modal('show');
        var $td=$(this).parent().parent().children();
        var class_id=$($td[0]).text();
        var class_name=$($td[1]).text();

        $('#setclassid').val(class_id);
        $('#setclassname').val(class_name)
    });
    $('#set-modal-submit').on('click',function () {
        var classid=$('#setclassid').val();
        var classname=$('#setclassname').val();
        $.ajax({
            url:"/modal_set_class/",
            type:'post',
            data:{'classid':classid, 'classname':classname},
            success:function(data){
                var dataobj=JSON.parse(data);
                console.log(dataobj.status);
                if (dataobj.status==='OK'){
                    location.reload()
                }else{
                    $('#setclassname+span').text(dataobj.status).parent().parent().addClass('has-error')
                }
            }
        });
    })
});

五 AJAX（Async JavaScript and XML）

　url：发送的路由路径

　type：以什么接口的方式

　data：发送的数据

　success：接收数据成功后执行

　error：介绍数据结束后执行

　contentType：标识的事让服务器直到这次请求的格式。

　　x-www-form-urlencode：将数据拼接成字符串发送过去，这个是默认的

　　json：将数据转成js字符串发送过去，告诉服务器是以一个json格式发送的。

　headers：请求头，需要引用jquery里面的cookie.js文件

　cookie("键")：在ajax中获取cookie的值

　serinlize：将某个表单中的value值一起拼接好了一块发送给服务器端。是一种序列化方法。

　post：ajax封装的一个API，以post接口方式发送，如果是get，就以get方式请求

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.js "></script>
    <script src="https://cdn.bootcss.com/jquery-cookie/1.4.1/jquery.cookie.js"></script>
</head>
<body>

<form id="myForm" action="/reg/" method="post">
    {% csrf_token %}
    <input name="uid" type="hidden" value="1" />
    <input id=user name="username" type="text" value="张三" />
    <input name="password" type="text" value="123456" />
    <select name="grade" id="grade">
        <option value="1">一年级</option>
        <option value="2">二年级</option>
        <option value="3" selected="selected">三年级</option>
        <option value="4">四年级</option>
        <option value="5">五年级</option>
        <option value="6">六年级</option>
    </select>
    <input name="sex" type="radio" checked="checked" value="1" />男
    <input name="sex" type="radio" value="0" />女
    <input name="hobby" type="checkbox" checked="checked" value="1" />游泳
    <input name="hobby" type="checkbox" checked="checked" value="2" />跑步
    <input name="hobby" type="checkbox" value="3" />羽毛球
    <input name="btn" id="btn" type="button" value="点击" />

</form>

<script>
    $("#btn").click(function () {

        $.ajax({
            url:"/reg/",
            type:"POST",
            //data:$("#myForm").serialize(),
            data:$(":checkbox,:radio,#user,[name='csrfmiddlewaretoken']").serialize(),
            success:function (data) {
                console.log(data)
            }

        })

    })
</script>
<script>
{#    $(":button").click(function () {#}
{##}
{#        $.ajax({#}
{#            url:"/login/",#}
{#            type:"POST",#}
{#            data:JSON.stringify({#}
{#                user:$("#user").val(),#}
{#                pwd:$("#pwd").val()#}
{#                //csrfmiddlewaretoken:$("[name='csrfmiddlewaretoken']").val()#}
{#            })#}
{#            ,  // 'user=alex&pwd=123'#}
{#            //contentType:"application/x-www-form-urlencoded",  // (默认)#}
{#            //headers:{"X-CSRFToken":$("[name='csrfmiddlewaretoken']").val()},#}
{#            headers:{"X-CSRFToken":$.cookie("csrftoken")},#}
{#            contentType:"application/json",#}
{#            success:function (data) {#}
{#                 console.log(data)#}
{#            },#}
{##}
{#        })#}
{#    })#}
</script>
</body>
</html>

　ajax可以在不用刷新页面的情况下也可以提交数据。AJAX是jquery封装好了的。

　页面刷新：location.reload()

location.reload()

　页面跳转：location.href='要跳转的页面'

location.href = '/class_list/';

　模态框使用ajax提交，有返回值，在页面可以直接加载数据。

模态框使用ajax提交，返回值
    在页面直接添加数据

    在后端：

        - HttpResponse("只能放字符串")
           我有一个Python的字典，要返回给前端：
           要把它转换成字符串：
           json.dumps()

    在前端：
        - JSON.parse()      --> 把字符串转换回JS对象
        - JSON.stringify()  --> 把JS对象转换成字符串

        var className = {"items": [1, 2, 3, 4]}
        $.ajax({
              url: "/modal_add_class/",
              type: "post",
              data: {"classname": className},
              success: function (data) {
                 console.log(data);
              }
        }

        $.ajax({
              url: "/modal_add_class/",
              type: "post",
              data: json.stringify({"classname": className}),
              success: function (data) {
                console.log(data);
              }
        }

　项目目录结构：

        - 目录结构
		-mysite
			-mysite
				-urls.py  配置对应关系 URL-->函数
				-settings.py 配置文件
				-wsgi.py  socketserver
				-views.py 自己写的函数统一放到这里
				__init__.py
			-templates  存放模板文件的（html文件）
				-index.html
				-class_list.html
			-static
				-bootstrap
					-css
						-bootstrap.min.css
					-fonts
					-js
				-jQuery.3.2.1.min.js
			-manage.py   管理你Django项目的（有很多命令）
						 python manage.py runserver IP:PORT

　cursor.lastrowoid：pymysql下面的一种方法，操作数据库时，返回他们的ID。

    def run_list(self,sql,args=None):
        self.cursor.executemany(sql, args)
        self.conn.commit()
        ret=self.cursor.lastrowid
        return ret

　AJAX发送数据：

 data：{“name”: "alex", "habit": ["抽烟", "喝酒“, "烫头"]}  这样不行
 data：{“name”: "alex", "habit": JSON.stringify(["抽烟", "喝酒“, "烫头"])} 这样可以

　补充：FormData：组装数据，存放要存放的所有键值对

　　　　form标签下面的enctype：修改请求的格式，

　　　　　　multipart/form-data：上传文件的二进制数据格式，同时支持表单的数据上传。

　　　　ProcessData：让数据是否编码成相对应的编码格式，如果为true，使用contentType进行编码格式，如果为false，就不进行contentType编码处理。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.js "></script>
    <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.js "></script>
</head>
<body>

<form action="/index/" method="post" enctype="multipart/form-data">
     {% csrf_token %}
    <p>姓名： <input type="text" name="user"></p>
    <p>文件： <input type="file" name="cFile"></p>
    <input type="submit">
</form>

<hr>

    {% csrf_token %}
    <p>姓名： <input type="text" id="user"></p>
    <p>文件： <input type="file" id="cFile"></p>
    <input type="button" value="submit">

<script>
    $(":button").click(function () {
        var $formData=new FormData() ;
        $formData.append("user",$("#user").val());
        $formData.append("cFile",$("#cFile")[0].files[0]);

        $.ajax({
            url:"/indexAjax/",
            type:"post",
            data:{
                cf:$("#cFile")[0].files[0]
            },
            contentType:false,
            processData:false,    // 不对数据做预处理，不进行任何编发
            headers:{"X-CSRFToken":$('[name="csrfmiddlewaretoken"]').val()},
            success:function (data) {
                console.log(data)
            }
        })

    })
</script>
</body>
</html>

　django的一些特殊操作：

　　母板的继承：{% extends 'base.html' %}

在母板里面定义block
    - 页面布局的block
    - pasge-css
    - page-js

　　引用小组件：{% include 'nav.html' %}

　django详细信息：http://www.cnblogs.com/liwenzhou/p/7931828.html

六登陆验证

　cookic定义：保存在浏览器的键值对；服务端可以在浏览器上面写cookic，响应头里面会有set-cookic；浏览器每次发送请求都会携带cookic。下次访问时判断cookie状态

　cookic的应用：使用在用户登陆和保存用户登陆的。

　跳转回登陆之前的哪个页面：在url上面加上一个跳转url的装饰器。

　request的其他方法：

　　request.get_full_path：获取请求的url

　　request.COOKIC.get：获取具体的cookic值

　　request.set_cookic:设置cookic的值

　　request.delete_cookic：删除cookic值

　sookic的一些参数：

　　key：键是什么

　　value：值是多少

　　max_age：保存时间，以秒为单位

　　expires：保存到一个具体的时间

　　domain：域名

　　secure=False：加密用的Https

　　httponly-False：js的代码不能够读取cookic，只能够浏览器发请求时携带cookic　

response.set_signed_cookie("login2", "1", max_age=10, salt="PythonFullstackS7")

　设置加盐的cookic：set_signed_cookic，下面的salt后面加上自己要加的哪个盐

response.set_signed_cookie("login2", "1", max_age=10, salt="PythonFullstackS7")

　获取加盐的cookic：get_signed_cookic，下面的salt后吗加上自己要获取的那个cookic盐值。

request.get_signed_cookie("login2", salt="PythonFullstackS7", default=None)

七 js补充

　JSON.stringify：将js对象转成字符串类型

　JSON.parse：将字符串类型转成js对象

data:{'teacher_name':teacherName,'teacher_class_id':JSON.stringify(teacherClassID)},
var dataobj=JSON.parse(data);

八 分页

　建议：每个页面最多显示11个页码

　而django内置的分页只有上一页和下一页：

 from django.shortcuts import render
 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

 L = []
 for i in range(999):
     L.append(i)

 def index(request):
     current_page = request.GET.get('p')

     paginator = Paginator(L, 10)
     # per_page: 每页显示条目数量
     # count:    数据总个数
     # num_pages:总页数
     # page_range:总页数的索引范围，如: (1,10),(1,200)
     # page:     page对象
     try:
         posts = paginator.page(current_page)
         # has_next              是否有下一页
         # next_page_number      下一页页码
         # has_previous          是否有上一页
         # previous_page_number  上一页页码
         # object_list           分页之后的数据列表
         # number                当前页
         # paginator             paginator对象
     except PageNotAnInteger:
         posts = paginator.page(1)
     except EmptyPage:
         posts = paginator.page(paginator.num_pages)
     return render(request, 'index.html', {'posts': posts})

　分页的准备：

　　1. 封装：将一些重用的方法封装到一个类里面去，随时都可以调用

　　2.app程序准备

"""
分页组件使用示例：

    obj = Pagination(request.GET.get('page',1),len(USER_LIST),request.path_info)
    page_user_list = USER_LIST[obj.start:obj.end]
    page_html = obj.page_html()

    return render(request,'index.html',{'users':page_user_list,'page_html':page_html})

"""

class Pagination(object):
    def __init__(self,current_page,all_count,base_url,per_page_num=10,pager_count=11):
        """
        封装分页相关数据
        :param current_page: 当前页
        :param all_count:    数据库中的数据总条数
        :param per_page_num: 每页显示的数据条数
        :param base_url: 分页中显示的URL前缀
        :param pager_count:  最多显示的页码个数
        """

        try:
            current_page = int(current_page)
        except Exception as e:
            current_page = 1
        if current_page <1:
            current_page = 1

        self.current_page = current_page

        self.all_count = all_count
        self.per_page_num = per_page_num

        self.base_url = base_url

        # 总页码
        all_pager, tmp = divmod(all_count, per_page_num)
        if tmp:
            all_pager += 1
        self.all_pager = all_pager

        self.pager_count = pager_count
        self.pager_count_half = int((pager_count - 1) / 2)

    @property
    def start(self):
        return (self.current_page - 1) * self.per_page_num

    @property
    def end(self):
        return self.current_page * self.per_page_num

    def page_html(self):
        # 如果总页码 < 11个：
        if self.all_pager <= self.pager_count:
            pager_start = 1
            pager_end = self.all_pager + 1
        # 总页码  > 11
        else:
            # 当前页如果<=页面上最多显示11/2个页码
            if self.current_page <= self.pager_count_half:
                pager_start = 1
                pager_end = self.pager_count + 1

            # 当前页大于5
            else:
                # 页码翻到最后
                if (self.current_page + self.pager_count_half) > self.all_pager:
                    pager_end = self.all_pager + 1
                    pager_start = self.all_pager - self.pager_count + 1
                else:
                    pager_start = self.current_page - self.pager_count_half
                    pager_end = self.current_page + self.pager_count_half + 1

        page_html_list = []

        first_page = '<li><a href="%s?page=%s">首页</a></li>' % (self.base_url,1,)
        page_html_list.append(first_page)

        if self.current_page <= 1:
            prev_page = '<li><a href="#">上一页</a></li>'
        else:
            prev_page = '<li><a href="%s?page=%s">上一页</a></li>' % (self.base_url,self.current_page - 1,)

        page_html_list.append(prev_page)

        for i in range(pager_start, pager_end):
            if i == self.current_page:
                temp = '<li class="active"><a href="%s?page=%s">%s</a></li>' % (self.base_url,i, i,)
            else:
                temp = '<li><a href="%s?page=%s">%s</a></li>' % (self.base_url,i, i,)
            page_html_list.append(temp)

        if self.current_page >= self.all_pager:
            next_page = '<li><a href="#">下一页</a></li>'
        else:
            next_page = '<li><a href="%s?page=%s">下一页</a></li>' % (self.base_url,self.current_page + 1,)
        page_html_list.append(next_page)

        last_page = '<li><a href="%s?page=%s">尾页</a></li>' % (self.base_url,self.all_pager,)
        page_html_list.append(last_page)

        return ''.join(page_html_list)

　　3 实现分页：数据切片获取；显示出实现的页码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" href="/static/plugins/bootstrap/css/bootstrap.min.css">
</head>
<body>
<div class="container">
    <h1>欢迎登陆：{{ user }}   <a href="/logout/">注销</a></h1>

    <table class="table table-bordered">
        <thead>
        <tr>
            <th>ID</th>
            <th>姓名</th>
            <th>操作</th>
        </tr>
        </thead>
        <tbody>
        {% for item in users %}
            <tr>
                <td>{{ item.id }}</td>
                <td>{{ item.name }}</td>
                <td><a href="/edit/{{ item.id }}/?">编辑</a></td>
            </tr>
        {% endfor %}
        </tbody>
    </table>

    <div style="text-align: center">
        <ul class="pagination">
            {{ page_html|safe }}

        </ul>
    </div>
</div>
</body>
</html>

九 session的介绍

　session的原理：输入用户名后回随机返回给浏览器一个字符串，然后服务端自己页保留一样的字符串，当浏览器在次访问时，服务端回拿着浏览器发过来的字符串和自己保存的字符串进行比较，如果不一致会提示；如果一致，找到相对应的信息，根据用户需求是否返回相对应的内容。

　session就相当于保存在服务端的键值对，而cookic就相当于保存在浏览器上面的键值对。而session是依赖于cookic的。

　操作：　

　　设置值：直接调用session

request.session['username']='用户名'

　　　内部操作：

1 设置set_cookie,返回一组字符串给浏览器。

2 自己报保存一样的字符串，作为键值对的键，然后将相关信息作为值保存为键值对的值。
        sessionkey                  sessiondate
        字符串                          上传保存的记录

　　取值：获取浏览器的用户字符串

request.session.get()

　　　内部操作：

'''
         uuid=request.COOKIE.get("sessionID") # 2134shdc329cbk398asdbk2
         django的session表中做过滤：
         session_user=session.objects.filter(session-key="2134shdc329cbk398asdbk2").first()
         ret=session_user.session_data.get("Is_login") #  {"Is_login":True,"user":"alex"}   

    '''

　　删除：删除具体某一个值

del request.session['想要删除的哪个key']

　　　　　删除整条记录：获取浏览器的随机字符串，在根据字符串去服务端比较并删除对应的记录。

request.session.delect()

　创建和保存session的命令：主要是对数据库的迁移

python manage.py makemigrations
python manage.py migrate

　创建好的session可以存放着任何位置，默认存放在数据库：

# ###################### session 配置信息 ##########################
SESSION_ENGINE = 'django.contrib.sessions.backends.db'  # 引擎（默认）
# SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎  存放在缓存里面
# SESSION_CACHE_ALIAS = 'default' # 表示那台机器？

# SESSION_ENGINE = 'django.contrib.sessions.backends.file'  # 引擎   存放在文件里面
# SESSION_FILE_PATH = None  # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()                                            # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T

# SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎  数据库加缓存

# SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎  加密cookic和Session

SESSION_COOKIE_NAME = "sessionid"  # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
SESSION_COOKIE_PATH = "/"  # Session的cookie保存的路径（默认）
SESSION_COOKIE_DOMAIN = None  # Session的cookie保存的域名（默认）
SESSION_COOKIE_SECURE = False  # 是否Https传输cookie（默认）
SESSION_COOKIE_HTTPONLY = True  # 是否Session的cookie只支持http传输（默认）
SESSION_COOKIE_AGE = 1209600  # Session的cookie失效日期（2周）（默认）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False  # 是否关闭浏览器使得Session过期（默认）

# SESSION_SAVE_EVERY_REQUEST = False  # 是否每次请求都保存Session，默认修改之后才保存（默认）
SESSION_SAVE_EVERY_REQUEST = True  # 是否每次请求都保存Session，默认修改之后才保存（默认）    

　　使用了session以后，用户于用户之间是不会混淆的。

　db.sqlite文件：直接链接到数据库的，将用户的记录可以直接保存

　session和cookic的区别是：

　　session执行的速度慢一些，但是安全性高

　　cookic执行的速度快一些，但是安全性低

　Template：模板对象，实例化处理的就是一个模板对象

　　将页面的设计和Python的代码分离开会更干净简洁更容易维护。 我们可以使用 Django的 模板系统 (Template System)来实现这种模式

def current_time(req):
    # ================================原始的视图函数
    # import datetime
    # now=datetime.datetime.now()
    # html="<html><body>现在时刻：<h1>%s.</h1></body></html>" %now

    # ================================django模板修改的视图函数
    # from django.template import Template,Context
    # now=datetime.datetime.now()
    # t=Template('<html><body>现在时刻是:<h1>{{current_date}}</h1></body></html>')
    # #t=get_template('current_datetime.html')
    # c=Context({'current_date':str(now)})
    # html=t.render(c)
    #
    # return HttpResponse(html)

    #另一种写法(推荐)
    import datetime
    now=datetime.datetime.now()
    return render(req, 'current_datetime.html', {'current_date':str(now)[:19]})

　在调用这些 属性时用大的就是点，如果点方法，内能点没有参数的方法

def index(request):

    import time
    c=time.time()
    '''
      render方法的过渡应用：
      t=Template("<html><body>现在时刻是:<h1>{{current_date}}</h1></body></html>")
      c=Context({"current_date":c})
      html=t.render(c)
      return HttpResponse(html)
    '''

    l=[111,222,333]
    d = {"name": "alex"}
    class Person():
        def __init__(self,name,age):
            self.name=name
            self.age=age
        def dream(self):
            return ("dream.....")

    alex=Person(name="alex",age=34)
    egon=Person(name="egon",age=9000)
    nacha=Person(name="nacha",age=3)

    person_list=[alex,egon,nacha]

    return render(request,"app01/index.html",{"l":l,"d":d,"person_list":person_list})

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>Current time {{ c }}</h1>

<hr>
<p>{{ l.2 }}</p>
<p>{{ d.name}}</p>
<p>{{ person_list.1.name }}</p>
<p>{{ person_list.1.age }}</p>

<hr>
{% for person in person_list %}
       <p>{{ person.name }},{{ person.age }}</p>
{% endfor %}
<hr>
{{ person_list.1.dream }}
</body>
</html>

　Context：上下文对象，实例化出来的是一个上下文对象

十 模板过滤器

　练习：datetime.datetime.now()：当前时，返回的是一个时间对象，每一个时间对象都可以点方法取出对应的值

def index(request):

    import time
    c=time.time()
    '''
      render方法的过渡应用：
      t=Template("<html><body>现在时刻是:<h1>{{current_date}}</h1></body></html>")
      c=Context({"current_date":c})
      html=t.render(c)
      return HttpResponse(html)
    '''
    i=10
    l=[111,222,333]
    d = {"name": "alex"}
    class Person():
        def __init__(self,name,age):
            self.name=name
            self.age=age
        def dream(self):
            return ("dream.....")

    alex=Person(name="alex",age=34)
    egon=Person(name="egon",age=9000)
    nacha=Person(name="nacha",age=3)
    person_list=[alex,egon,nacha]

    import datetime

    t=datetime.datetime.now()
    l2=[]
    fileSize=12341234
    s="hello world"
    content="hello world hello world hello world hello world"
    a="<a href=''>click</a>"
    #return render(request,"app01/index.html",{"l":l,"d":d,"person_list":person_list})
    return render(request,"app01/index.html",locals())

def login(request):
    if request.method=="POST":
        user=request.POST.get("user")
        pwd=request.POST.get("pwd")

        if user=="alex" and pwd=="":
            return redirect("/index/")

    return render(request,"app01/login.html")

def archive(request):
    print(request.path)  # /app01/articls/2004/
    print(request.path_info)  # /app01/articls/2004/
    print(request.get_full_path())  # /app01/articls/2004/?a=1
    # select * from Article where year=2004

    return HttpResponse("")

def archive2(request,year):

    return HttpResponse(year)

　add：假发过滤器，将变量的数值加上后面的数字

<p>{{ i|add:5 }}</p>

　date：日期过滤器

<p>{{ t|date:"Y-m-d H:i" }}</p>

　length：长度过滤器

　default：提示用户信息

<p>{{ l2|default:"没有符合要求的内容" }}</p>

　filesizeformat：文件大小过滤器

<p> 文件大小：{{ fileSize|filesizeformat }}</p>

　slice：切片过滤器

<p>{{ s|slice:"2:" }}</p>

　truncatechars：按照字符截断

　truncatwords：按照单词截断

<p>{{ content|truncatechars:9 }}</p>
<p>{{ content|truncatewords:3 }}</p>