16 . PythonWeb框架之Django

# M 代表模型（Model）： 负责业务对象和数据库的关系映射(ORM)。
# T 代表模板 (Template)：负责如何把页面展示给用户(html)。
# V 代表视图（View）：   负责业务逻辑，并在适当时候调用Model和Template。

# 1. 主流、活跃程序:  
# 从GitHub的数据来看，Django的开发非常活跃,迭代速度也非常快  
  
# 2. 是否可以满足需求:  
# Django以要素齐全、工具丰富、框架庞大著称,基本上别的框架有的他有，别的框架没有的他也有，  
# 如果Django满足不了需求，那么别的框架同时也一样.  
  
# 3. 时效性:  
# Django有很长的开发喝实践过程，或早或晚的文档、教程、帮助、博客等等非常多，资料更新速度也很快.  
  
# 4. 入门友好程度  
# 一个框架能否流行起来，对新手入门友好非常关键.Django在这一点做的非常好.  

# 熟悉Python语言  
# 对前端的HTMLCSSJavaScript比较熟悉  
# 对网络基础，比如HTTP、TCP/IP等比较熟悉  
# 熟悉数据库、缓存、消息队列等技术的使用场景和使用方法  
# 日常能使用Linux或Mac系统工作(Windows标配)  
# 有性能优化经验，能快速定位问题  
# 除此之外,还要对业务有深刻理解，能够写出可维护性足够高的代码，当然，以上都是对经验丰富的开发者而言,  
# 对于新手刚入门者，我们朝着这个目标努力学习就好  
# 下面是基于Python的Web开发技术栈  
# 1、web应用
# 运行在浏览器上的应用

# 2、c/s b/s 架构
# client/server：客户端服务器架构，C++
# brower/server：浏览器服务器架构，Java、Python
# 底层均是基于socket

# 3、Python Web框架
# a.socket b.页面路由 c.模板渲染
# Django 	a用的wsgiref b自己写的 c自己写的 功能全面
# Flask 	a用的第三方 b自己写的 c自己写的 小而轻
# Tornado   a自己写的 b自己写的 c自己写的 支持高并发

demo1
	-- index.html
	-- server.py

import socket
# 利用socket建立服务器对象
server = socket.socket()
# 设置ip和端口
server.bind(('127.0.0.1', 8001))
# 设置监听
server.listen(5)
print('服务器设置成功')
print('浏览器访问：http://127.0.0.1:8001')
while True:
    # 阻塞等待客户端数据
    client, address = server.accept()
    # 接收数据
    data = client.recv(1024)
    print('接收到数据: ', data)
    # 返回数据
    client.send(b'Normal Socket Web')
    # 关闭连接(必须关闭每一次连接)
    client.close()  

# 请求发来的数据
b'GET / HTTP/1.1rn
Host: 127.0.0.1:8001rn
Connection: keep-alivern
Upgrade-Insecure-Requests: 1rn
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36rn
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8rn
Accept-Encoding: gzip, deflate, brrn
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8rn
Cookie: csrftoken=szfYLDVuqvRhlveNpNE2rp1GYOcI5x7mRNfvkRWTMRNRwWxXMZWOhL1MqknYJ7jg; sessionid=3pphvmw2icub0bea7nn02u6wev17k4uwrn
rn'

# HTTP（HyperText Transport Protocol）是超文本传输协议
# 基于TCP/IP协议基础上的应用层协议，底层实现仍为socket
# 基于请求-响应模式：通信一定是从客户端开始，服务器端接收到客户端一定会做出对应响应
# 无状态：协议不对任何一次通信状态和任何数据做保存
# 无连接：一次连接只完成一次请求-响应，请求-响应完毕后会立即断开连接

# 一次http操作称之为一个事务，工作过程可分为四步
# 1.客户端与服务端建立连接
# 2.客户端发生一个http协议指定格式的请求
# 3.服务器端接收请求后，响应一个http协议指定格式的响应
# 4.客户端将服务器的响应显示展现给用户

POST / HTTP/1.1rn
Host: 127.0.0.1:8001rn
Connection: keep-alivern
Upgrade-Insecure-Requests: 1rn
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36rn
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8rn
Accept-Encoding: gzip, deflate, brrn
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8rn
rn
usr=abc&pwd=123

# 响应行  响应头  响应体
HTTP/1.1 200 OKrn
Content-type:text/htmlrn
rn
Login Success

# 字符串
client.send(b'HTTP/1.1 200 OKrn')
client.send(b'rn')
client.send(b'Normal Socket Web')
# html代码，请求头要设置支持html代码
client.send(b'HTTP/1.1 200 OKrn')
client.send(b'Content-type:text/htmlrn')
client.send(b'rn')
client.send(b'<h1>Normal Socket Web</h1>')
# html文件（同级目录建立一个index.html页面）
client.send(b'HTTP/1.1 200 OKrn')
client.send(b'Content-type:text/htmlrn')
client.send(b'rn')
# 利用文件方式读取页面
with open('index.html', 'rb') as f:
    dt = f.read()
client.send(dt)

# 分析接收到的数据
data = client.recv(1024)
# 保证接收到的数据作为字符串进行以下处理
data = str(data, encoding='utf-8')
# 拆分出地址位
route = data.split('rn')[0].split(' ')[1]
# 匹配地址，做出不同的响应
if route == '/index':
    with open('index.html', 'rb') as f:
    	dt = f.read()
elif route == '/login':  # 新建login页面
    with open('login.html', 'rb') as f:
    	dt = f.read()
else:
    dt = b'404'
client.send(dt)

# 1打头：消息通知
# 2打头：请求成功
# 3打头：重定向
# 4打头：客户端错误
# 5打头：服务器端错误

part2
	-- favicon.ico
	-- index.html
	-- manage.py=

import socket
import pymysql
# 响应头
RESP_HEADER = b'HTTP/1.1 200 OKrnContent-type:text/htmlrnrn'

# 请求处理
def index():
    # 以字节方式读取文件
    with open('index.html', 'rb') as f:
        dt = f.read()
    return dt
def ico():
    with open(favicon.jpeg, 'rb') as f:
        dt = f.read()
    return dt
def user():
    # 数据库操作
    conn = pymysql.connect(host='127.0.0.1', port=3306, db='django', user='root', password='root')
    cur = conn.cursor(pymysql.cursors.DictCursor)
    cur.execute('select * from user')
    users = cur.fetchall()
    print(users)
    users = '''%d:%s
    %d:%s''' % (users[0]['id'], users[0]['name'], users[1]['id'], users[1]['name'])
    return users.encode('utf-8')

# 设置路由
urls = {
    # 请求路径与请求处理函数一一对应
    '/index': index,
    favicon.jpeg: ico,
    '/user': user
}

# 设置socket
def serve(host, port):
    server = socket.socket()
    server.bind((host, port))
    print('start:http://' + host + ':' + str(port))
    server.listen(5)
    while True:
        sock, addr = server.accept()
        data = sock.recv(1024)
        data = str(data, encoding='utf-8')
        print(data)
        route = data.split('rn')[0].split(' ')[1]

        resp = b'404'
        if route in urls:
            resp = urls[route]()

        sock.send(RESP_HEADER)
        sock.send(resp)
        sock.close()

# 启服务
if __name__ == '__main__':
    serve('127.0.0.1', 8002)

03_proj
	-- template
		-- index.html
		-- user.html
	favicon.ico
	start.py
	urls.py
	views.py

<h1>{{ name }}</h1>

<table border="1">
    <tr>
        <th>id</th>
        <th>name</th>
        <th>password</th>
    </tr>
    {% for user in users%}
    <tr>
        <td>{{user.id}}</td>
        <td>{{user.name}}</td>
        <td>{{user.password}}</td>
    </tr>
    {% endfor %}
</table>

from wsgiref.simple_server import make_server
from urls import urls


def app(env, response):
    print(env)
    # 设置响应头
    response("200 OK", [('Content-type', 'text/html')])
    route = env['PATH_INFO']
    print(route)
    data = urls['error']()
    if route in urls:
        data = urls[route]()
    # 返回二进制响应体
    return [data]


if __name__ == '__main__':
    server = make_server('127.0.0.1', 8003, app)
    print('start:http://127.0.0.1:8003')
    server.serve_forever()

from views import *
urls = {
    '/index': index,
    '/favicon.ico': ico,
    '/user': user,
    'error': error
}

import pymysql
# 利用jinja2来渲染模板，将后台数据传给前台
from jinja2 import Template

def index():
    with open('templates/index.html', 'r') as f:
        dt = f.read()
    tem = Template(dt)
    resp = tem.render(name='主页')
    return resp.encode('utf-8')

def ico():
    with open('favicon.ico', 'rb') as f:
        dt = f.read()
    return dt

def user():
    # 数据库操作
    conn = pymysql.connect(host='127.0.0.1', port=3306, db='django', user='root', password='root')
    cur = conn.cursor(pymysql.cursors.DictCursor)
    cur.execute('select * from user')
    users = cur.fetchall()
    print(users)

    with open('templates/user.html', 'r') as f:
        dt = f.read()
    tem = Template(dt)
    resp = tem.render(users=users)

    return resp.encode('utf-8')

def error():
    return b'404'

urlpatterns = [  
 url(r'^$', views.index),  
 url(r'^([0-9]+)/$', views.best),  
]  
  
# 注意:  
# 该urlpatterns对象的列表url()功能，在Python中，使用方括号定义列表,项目以逗号分隔，  
# 并可能有一个可选的逗号，例如:[item1,item2,item3,].  
  
# 该模式的奇怪的语法称为正则表达式  
  
# 第二个参数url()是当模式匹配时，将被调用的另一个函数,符号views.index表示该函数被调用,  
# index()并且可以在被调用的模块中找到views(即在一个名为views.py的文件中.)  

## filename：views.py（Django视图函数）  
  
从django.http导入HttpResponse  
  
def index（request）：  
 ＃Get HttpRequest-request参数  
 ＃使用请求中的信息执行操作。  
 ＃Return HttpResponse  
 return HttpResponse（'你好，Django！'）  
  
# 注意:  
# Python模块是函数的'库'，存储在单独的文件中，我们可能想在我们的代码块中使用他们，  
# 在这里我们只从django.http模块导入了HttpResponse对象，使我们可以在视图中使用它:  
  
# from django.http import HttpResponse  
# 还有其他方法可以从模块导入一些或所有对象.  
  
# 如上所示,使用def关键字声明函数,在函数名称后面的括号列出命名参数: 整行以冒号结尾，  
# 注意下一行是否都进行了缩进,缩进很重要，因为他指定代码行在该特定块内(强制缩进是Python的一个关键特征)，  
# 也是Python代码很容易阅读的一个原因).  
  
# 视图通常存储在一个名为views.py的文件中  

# filename: models.py  
  
from django.db import models   
  
class Team(models.Model):   
 team_name = models.CharField(max_length=40)   
  
 TEAM_LEVELS = (  
 ('U09', 'Under 09s'),  
 ('U10', 'Under 10s'),  
 ('U11', 'Under 11s'),  
 ...  #list other team levels  
 )  
 team_level = models.CharField(max_length=3,choices=TEAM_LEVELS,default='U11')  
  
# 注意:  
# Python支持'面向对象编程',这是一种编程风格，我们将代码组织到对象中，  
# 其中包括用于对该对象进行操作的相关数据和功能,对象也可以从其他对象继承/扩展/派生,  
# 允许相关对象之间的共同行为被共享，在Python中，我们使用关键字Class定义对象的‘蓝图’,  
# 我们可以根据类中的模型创建类型的多个特定实例.  
  
# 例如,我们有个Team类，它来自于Model类，这意味着他是一个模型，并且将包含模型的所有方法,  
# 但是我们也可以给他自己的专门功能，在我们的模型中，我们定义了数据库需要存储我们的数据字段,  
# 给出他们的具体名称，Django使用这些定义(包括字段名称)来创建底层数据库.  

## filename: views.py  
  
from django.shortcuts import render  
from .models import Team   
  
def index(request):  
 list_teams = Team.objects.filter(team_level__exact="U09")  
 context = {'youngest_teams': list_teams}  
 return render(request, '/best/index.html', context)  

## filename: best/templates/best/index.html  
  
<!DOCTYPE html>  
<html lang="en">  
<body>  
  
 {% if youngest_teams %}  
 <ul>  
 {% for team in youngest_teams %}  
 <li>{{ team.team_name }}</li>  
 {% endfor %}  
 </ul>  
{% else %}  
 <p>No teams are available.</p>  
{% endif %}  
  
</body>  
</html>  

# 表单: HTML表单用于收集用户数据以便在服务器上进行处理,Django简化了表单创建，验证和处理.  
  
# 用户身份验证和权限: Django包含了一个强大的用户身份验证和权限系统，该系统已经构建了安全性.  
  
# 缓存: 与提供静态内容相比，动态创建内容需要更大的计算强度(也更缓慢),DJango提供灵活的缓存，  
# 以便你可以存储所有或部分的页面，如无必要，不会重新呈现网页.  
  
# 管理网站: 当你使用基本骨架创建应用时，就已经默认包含了一个Django管理站点，它十分轻松创建了一个管理页面，  
# 使网站管理员能够创建、编辑和查看站点中的任何数据模型.  
  
# 序列化数据:  Django可以轻松的将数据序列化，并支持XML或JSON格式，  
# 这会有助于创建一个Web服务(Web服务指数据纯粹为其他应用程序或站点所用，  
# 并不会在自己的站点中显示),或是有助于创建一个由客户端代码处理和呈现所有数据的网站  

tree mvc_demo/   
mvc_demo/   
├── Controller   
│   ├── account.py   
│   └── __pycache__   
│       └── account.cpython-36.pyc   
├── Model   
├── Socket_Demo11.py   
└── View   
 └── index.html   

cat mvc_demo/Controller/account.py   
#!/usr/bin/env python3   
#-*- coding:utf-8 -*-   
# 2020/1/17 10:38   
    
def handle_index():   
 import time   
 v = str(time.time())   
 f = open('View/index.html',mode='rb')   
 data=f.read()   
 f.close()   
 data = data.replace(b'@u',v.encode('utf-8'))   
 return [data,]   
    
def handle_date():   
 return ['<h1>Hello,Date!</h1>'.encode('utf-8'), ]   

cat mvc_demo/View/index.html   
<!DOCTYPE html>   
<html lang="en">   
<head>   
 <meta charset="UTF-8">   
 <title>Title</title>   
</head>   
<body>   
 <h1>INDEX @u</h1>   
</body>   
</html>   

cat mvc_demo/Socket_Demo11.py   
from wsgiref.simple_server import make_server   
from Controller import account   
    
URL_DICT = {   
 "/index": account.handle_index,   
 "/date":  account.handle_date,   
}   
def RunServer(environ, start_response):   
 # environ 封装了客户端发来的所有数据   
 # start_response 封装要返回用户的数据，响应头、状态码   
 start_response('200 OK', [('Content-Type', 'text/html')])   
 current_url = environ['PATH_INFO']   
 func = None   
 if current_url in URL_DICT:   
 func = URL_DICT[current_url]   
 if func:   
 return func()   
 else:   
 return ['<h1>404</h1>'.encode('utf-8')]   
    
if __name__ == '__main__':   
 httpd = make_server('', 8001, RunServer)   
 print("Serving HTTP on port 8000...")   
 httpd.serve_forever()   

cd mvc_demo/   
python3 Socket_Demo11.py   
Serving HTTP on port 8000...   
127.0.0.1 - - [17/Jan/2020 11:13:10] "GET /index HTTP/1.1" 200 161   
    
curl localhost:8001/index   
<!DOCTYPE html>   
<html lang="en">   
<head>   
 <meta charset="UTF-8">   
 <title>Title</title>   
</head>   
<body>   
 <h1>INDEX 1579230790.0229425</h1>   
</body>   
</html>   
# MVC   
# Model			View			Controller   
# 数据库			模板文件		业务处理   
    
# MTV   
# Model			Template		View   
# 数据库			模板文件		业务处理   

# 用户请求 ----> URL对应关系(匹配)  ---->  视图函数 ----> 返回用户字符串
# 用户请求 ----->URL对应关系(匹配)  ----> 视图函数 ----> 打开一个HTML文件，读取内容

# 1.浏览器发送请求
# 2.wsgi服务器接收到请求，将请求解析交给Django
# 3.Django中间件过滤请求信息，交给路由匹配，如果匹配成功
# 4.路由完成业务逻辑的分发，到指定app下views中指定的视图函数,可以去数据库里面取数据,
# 5.视图函数完成具体的业务逻辑，和模板渲染,返回字符串响应结果
# 6.将处理结果通过服务器返回给浏览器

# 安装：pip3 install django==2.2
# 查看版本号：django-admin --version
# 新建项目：1.前往目标目录  2.django-admin startproject proj_name

# 项目目录，包含项目最基本的一些配置
# 项目名：
   |--项目同名文件夹
	|---- __init__.py  模块的配置文件
	|---- settings.py  配置总文件
	|---- urls.py      url配置文件，主路由
	|---- wsgi.py      (web server gateway interface)，
# 服务器网关接口，python应用与web服务器直接通信的接口
# templates：模板文件夹，存放html文件的(页面)，支持使用Django模板语言(DTL)，也可以使用第三方(jinja2)
# manage.py：项目管理器，与项目交互的命令行工具集的入口，查看支持的所有命令python3 manage.py

# __init__.py
# admin.py：应用的后台管理系统配置
# apps.py：django 1.9后，本应用的相关配置
# models.py：数据模型模块，使用ORM框架，类似于MVC模式下的Model层
# tests.py：自动化测试模块，可以写自动化测试脚本
# views.py：执行相应的逻辑代码模块

django-admin startproject mysite  
  
tree  mysite/  
mysite/  
├── manage.py  
└── mysite  
 ├── __init__.py  
 ├── settings.py  
 ├── urls.py  
 └── wsgi.py  
  
  
# 各文件和目录解释:  
# 外层的mysite/目录与Django无关，只是你项目的容器，可以任意重命名,[工程名称]  
# manage.py:  一个命令行工具,用于与Django进行不同方式的交互脚本,非常重要  
# 内部的mysite/目录是真正的项目文件包裹目录，他的名字是你引用内部文件的包名，例如: mysite.urls.  
  
# mysite/__init__.py: 一个定义包的空文件  
# mysite/setting.py: 项目的主配置文件，非常重要.  
# mysite/urls.py: 路有文件，所有的任务都是从这里开始分配，相当于Django驱动站点的内容表格，非常重要.  
# mysite/wsgi.py:  一个基于WSGI的web服务器进入点，提供底层的网络通信功能，通常不用关心，  
# 但是上线时候不要使用wsgi，使用uwsgi，通常再配合nginx。  
  
python3 manage.py startapp cmdb  
tree cmdb/  
cmdb/  
├── admin.py  
├── apps.py  
├── __init__.py  
├── migrations  
│   └── __init__.py  
├── models.py  
├── tests.py  
└── views.py  
# app  
# migrations:   数据修改表结构  
# admin:	Django为我们提供的后台管理  
# apps: 	配置当前app  
# models: ORM写指定的类，通过命令创建数据库结构  
# test:	单元测试  
# views:	业务逻辑代码  

# 安装pymysql
sudo wget https://bootstrap.pypa.io/get-pip.py  --no-check-certificate
sudo python get-pip.py 
sudo pip install pymysql
sudo pip3 install pymysql

# 数据库
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME':'youmen_db',
        'USER':'root',
        'PASSWORD':'ZHOUjian.20',
        'HOST':'116.196.83.113',
        'PORT':'3306',
    }
}

# 新建一个与templates同级文件夹,配置文件添加
STATICFILES_DIRS=os.path.join(BASE_DIR,'static'),
# 静态文件检索的文件夹

# 语言和时区
LANGUAGE_CODE = 'zh-hans' 
TIME_ZONE = 'Asia/Shanghai'  #
USE_I18N = True   #internationalization  国际化 支持多语言
USE_L10N = True	  #本地化，比如农历
USE_TZ = True

#修改： 配置文件：
ALLOWED_HOSTS = ['*']  #允许所有访问
ALLOWED_HOSTS = ['192,168,0.114','127.0.0.1']  #列表为了防止黑客入侵，只允许列表中的ip地址访问 
#表示此Django站点可以投放的主机/域名的字符串列表。这是防止HTTP主机头部攻击的安全措施



# (如果需要调用js,css文件可以配置一下settings.py，html文件就可以调用static里面的css,js文件了)
STATICFILES_DIRS = (
os.path.join(BASE_DIR, 'static'),
)

# 终端： python3 manage.py runserver 127.0.0.1:8801
python manage.py runserver                # 启动
python manage.py runserver 0.0.0.0:8080   #启动改变端口号和外部访问：
python manage.py  makemigrations   		  # 生成迁移文件
python manage.py migrate		   		  # 执行迁移，存到数据库
django-admin startapp xxx          		  # 新建一个app 

from django.contrib import admin
from django.urls import path
urlpatterns = [
    url('admin/',admin.site.urls),
]

from django.db import models

# Create your models here.
class UserType(models.Model):
    name = models.CharField(max_length=32)

class UserInfo(models.Model):
    username=models.CharField(max_length=32)
    pwd=models.CharField(max_length=32)
    email=models.CharField(max_length=32)
    user_type=models.ForeignKey(UserType,on_delete=models.CASCADE)

from django.contrib import admin
# Register your models here.
from cmdb import models
admin.site.register(models.UserInfo)

# 先将之前models.py文件的表创建出来**
python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser
Username (leave blank to use 'you-men'): youmen
Email address: youmen@163.com
Password:
Password (again):

"login"  --> 函数名
# Example
from django.conf.urls import url
from django.contrib import admin
from cmdb import views

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

# app下views.py
# 获取用户请求的发来数据
# def func(request):
# 	request.method GET / POST
# 	http://127.0.0.1:8000/home?pid=123&name=nginx
# 	request.GET.get('',None)	# 获取用户请求发来的数据
# 	request.POST.get('',None)
#	request.FILES.get('files')	# 此处files对应<input type="file" name="files" />
# 	checkbox等多选内容(值)
# 	request.POST.getlist()

# GET获取数据     POST: 提交数据

# 返回用户数据
# return HttpResponse('字符串')
# return render(request,"HTTP模板的路径")
# return redirect('url路径')   # return redirect('/login')  # 此处/代指前面的地址.
# Example
from django.shortcuts import render
from django.shortcuts import HttpResponse
from django.shortcuts import redirect

# Create your views here.
from django.shortcuts import HttpResponse

def login(request):
    # 包含用户提交的所有信息
    # 获取用户提交方法
    # print(request.method)
    error_msg = ""
    if request.method == "POST":
        # 用户通过POST提交过来的数据通过request.GET.get('',None)获取
        user = request.POST.get('user',None)
        pwd = request.POST.get('pwd',None)
        if user == 'root' and pwd == '123':
            # 去跳转到
            return redirect(home);
        else:
            error_msg = "用户名或密码错误"
            # 用户密码不匹配
    return render(request,'login.html',{'error_msg':error_msg})

USER_LIST = [
    {'username':'alex','email': 'Tom','gender':'男'},
    {'username':'alex','email': 'Tom','gender':'男'},
    {'username':'alex','email': 'Tom','gender':'男'},
]
# for index in range(20):
#     temp = {'username':'alex' + str(index) ,'email': 'Tom','gender':'男'}
#     USER_LIST.append(temp)
def home(request):
    if request.method == "POST":
        # 获取用户提交的数据 POST请求中
        u = request.POST.get('username')
        e = request.POST.get('email')
        g = request.POST.get('gender')
        temp = {'username':u, "email":e,'gender':g}
        USER_LIST.append(temp)
    return render(request,'home.html',{'user_list': USER_LIST})

# def home(request):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body style="margin: 0;">
    <div style="height: 48px; background: #dddddd;"></div>
    <div>
        <div>
            <form action="/home" method="post">
                <input type="text" name="username" placeholder="用户名"/>
                <input type="text" name="email" placeholder="邮箱"/>
                <input type="text" name="gender" placeholder="性别" />
                <input type="submit" value="添加" />
            </form>
        </div>
        <table>
            {% for row in user_list %}
            <tr>
                <td>{{ row.username }}</td>
                <td>{{ row.email }}</td>
                <td>{{ row.gender }}</td>
            </tr>
            {% endfor %}
        </table>
    </div>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" href="/static/commons.css">
</head>
    <style>
        .label{
            width: 80px;
            text-align: right;
            display: inline-block;
        }
    </style>
<body>
    <form action="/login" method="post">
        <p>
            <label for="username">用户名:</label>
            <input id="user" name="user" type="text">
        </p>

        <p>
            <label for="password">密码:</label>
            <input id="pwd" name="pwd" type="password">
            <input type="submit"  value="提交">
            <span style="color: red;">{{ error_msg }}</span>
        </p>
    </form>
    <script src="/static/jquery.min.js"></script>

</body>
</html>

from django.shortcuts import render,HttpResponse,redirect
import os
# Create your views here.
def index(request):
    return HttpResponse('index')

error_masg = ""
def registered(request):
    if request.method == "GET":
        print(request.method)
        return render(request,'registered.html')
    elif request.method == "POST":
        obj = request.FILES.get('files')
        print(obj,type(obj),obj.name)
        file_path = os.path.join('upload',obj.name)
        f = open(file_path,mode='wb')
        for i in obj.chunks():
            f.write(i)
        f.close()
        return render(request,'registered.html')
# 文件上传功能需要在from标签注明enctype="multipart/form-data"

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/registered" method="POST"  enctype="multipart/form-data">
        <p>
            <input type="text" name="user" placeholder="用户名">
        </p>

        <p>
            <input type="password" name="pwd" placeholder="密码" />
        </p>
        <p>
            男: <input type="radio" name="gender" value="1" />
            女: <input type="radio" name="gender" value="2" />
            张扬: <input type="radio" name="gender" value="3" />
        </p>
        <p>
            男: <input type="checkbox" name="favor" value="11" />
            女: <input type="checkbox" name="favor" value="22" />
            张扬: <input type="checkbox" name="favor" value="33" />
        </p>
        <p>
            <select name="area" multiple>
                <option  value="sh">上海</option>
                <option  value="bj">北京</option>
                <option  value="tj">天津</option>
                <option  value="gz">广州</option>
            </select>
        </p>
        <p>
            <input type="file" name="files">
        </p>
        <input type="submit" value="提交">
    </form>
</body>
</html>

from django.conf.urls import url
#循环urlpatterns，找到对应的函数执行,匹配上一个路径就找到对应的函数执行，就不再往下循环了，并给函数传一个参数request，和wsgiref的environ类似，就是请求信息的所有内容
urlpatterns = [
     url(正则表达式, views视图函数，参数，别名),
]

# 参数说明
# 正则表达式: 一个正则表达式字符串
# views视图函数: 一个可调用对象,通常为一个视图函数或一个指定视图函数路径的字符串

# 参数: 可选的要传递给视图函数的默认参数(字典形式)

# 别名: 一个可选的name参数

from django.urls import path

urlpatterns = [
    path('articles/2003/', views.special_case_2003),
    path('articles/<int:year>/', views.year_archive),
    path('articles/<int:year>/<int:month>/', views.month_archive),
    path('articles/<int:year>/<int:month>/<slug:slug>/', views.article_detail),
]

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    # url(r'^admin/', admin.site.urls),
    url(r'^index/', views.login),

    # 无名分组 (给应用视图函数传递位置参数)
    url(r'books/(d{4})/', views.year_books),  # 完全匹配
    url(r'^books/(d{4})/(d{2})/', views.year_mouth_books),
    url(r'^books/(d{4})/(d{2})/(d{2})', views.year_mouth_day_books),
]    

# 1. urlpatterns中的元素按照书写顺序从上往下逐一匹配正则表达式，一旦匹配成功则不再继续。
# 2. 若要从URL中捕获一个值，只需要在它周围放置一对圆括号（分组匹配）。
# 3. 不需要添加一个前导的反斜杠（也就是写在正则最前面的那个/），因为每个URL 都有。例如，应该是^books而不是 ^/books。
# 4. 每个正则表达式前面的'r' 是可选的但是建议加上。
# 5. ^books&  以什么结尾，以什么开头，严格限制路径。


# 是否开启URL访问地址后面没有/跳转至带有/的路径的配置项
APPEND_SLASH=True

from django.conf.urls import url
from app01 import views

urlpatterns = [
        url(r'^blog/$', views.blog),
]

# 访问 http://www.example.com/blog 时，默认将网址自动转换为 http://www.example/com/blog/ 。

# 如果在settings.py中设置了 APPEND_SLASH=False，此时我们再请求 http://www.example.com/blog 时就会提示找不到页面。

# 注意：无名分组传递给views函数的为位置参数。

from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
#某年的，(?P<year>[0-9]{4})这是命名参数（正则命名匹配还记得吗？），
# 那么函数year_archive(request,year)，形参名称必须是year这个名字。
# 而且注意如果你这个正则后面没有写$符号，即便是输入了月份路径，也会被它拦截下拉，因为它的正则也能匹配上
    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
    #某年某月的
    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$', views.article_detail), 
    # 某年某月某日的
]

# 这个实现与前面的示例完全相同，只有一个细微的差别：捕获的值作为关键字参数而不是位置参数传递给视图函数

def year_article(request, year=2000):
    print(year)
    return HttpResponse(f'出版年限：{year}')


def year_mouth_article(request, year, mouth):
    print(year, mouth)
    return HttpResponse(f'出版年限：{year},出版月份：{mouth}')

def year_mouth_day_article(request, year, mouth, day):
    print(year, mouth, day)
    return HttpResponse(f'出版年限：{year},出版月份：{mouth},出版天数：{day}')

url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),

# urls.py中
from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^blog/$', views.page),
    url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
]

# views.py中，可以为num指定默认值
def page(request, num="1"):
    pass

from django.conf.urls import url,include
from app01 import views

urlpatterns = [
    # 首页
    url(r'^$',views.base),
    url('^app01/',include('app01.urls')),
]

from django.conf.urls import url
from app01 import views

urlpatterns = [
    url('^login/',views.login),
]

from django.shortcuts import render
from django.shortcuts import redirect

def login(request):
    return render(request,'login1.html')


def base(request):
    return render(request,'base.html')

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^blog/(?P<year>[0-9]{4})/$', views.year_archive, {'foo': 'bar'}),
    
# 注意，这就像一个命名分组一样，你的函数里面的必须有一个形参，形参必须叫做foo才行，如果是命名分组的url，那么foo参数写在函数的哪个位置都行，如果不是命名分组，那么都是将这个形参写在参数的最后。
]

from django.http import HttpResponse
import datetime

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

# path_info		返回用户访问url,不包括域名
# method		请求中使用的HTTP方法的字符串表示,全大写表示
# GET			包含所有HTTP GET参数的类字典对象
# POST			包含所有HTTP POST参数的类字典对象
# body			请求体,byte类型 request.POST的数据就是从body里面提取到的

def upload(request):
    """
    保存上传文件前，数据需要存放在某个位置。默认当上传文件小于2.5M时，django会将上传文件的全部内容读进内存。从内存读取一次，写磁盘一次。
    但当上传文件很大时，django会把上传文件写到临时文件中，然后存放到系统临时文件夹中。
    :param request: 
    :return: 
    """
    if request.method == "POST":
        # 从请求的FILES中获取上传文件的文件名，file为页面上type=files类型input的name属性值
        filename = request.FILES["file"].name
        # 在项目目录下新建一个文件
        with open(filename, "wb") as f:
            # 从上传的文件对象中一点一点读
            for chunk in request.FILES["file"].chunks():
                # 写入本地文件
                f.write(chunk)
        return HttpResponse("上传OK")

1.HttpRequest.get_host()
　　根据从HTTP_X_FORWARDED_HOST（如果打开 USE_X_FORWARDED_HOST，默认为False）和 HTTP_HOST 头部信息返回请求的原始主机。
   如果这两个头部没有提供相应的值，则使用SERVER_NAME 和SERVER_PORT，在PEP 3333 中有详细描述。

　　USE_X_FORWARDED_HOST：一个布尔值，用于指定是否优先使用 X-Forwarded-Host 首部，仅在代理设置了该首部的情况下，才可以被使用。
　　例如："127.0.0.1:8000"
　　注意：当主机位于多个代理后面时，get_host() 方法将会失败。除非使用中间件重写代理的首部。

2.HttpRequest.get_full_path()
　　返回 path，如果可以将加上查询字符串。
　　例如："/music/bands/the_beatles/?print=true"
 

3.HttpRequest.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)

　　返回签名过的Cookie 对应的值，如果签名不再合法则返回django.core.signing.BadSignature。

　　如果提供 default 参数，将不会引发异常并返回 default 的值。

　　可选参数salt 可以用来对安全密钥强力攻击提供额外的保护。max_age 参数用于检查Cookie 对应的时间戳以确保Cookie 的时间不会超过max_age 秒。

        >>> request.get_signed_cookie('name')
        'Tony'
        >>> request.get_signed_cookie('name', salt='name-salt')
        'Tony' # 假设在设置cookie的时候使用的是相同的salt
        >>> request.get_signed_cookie('non-existing-cookie')
        ...
        KeyError: 'non-existing-cookie'    # 没有相应的键时触发异常
        >>> request.get_signed_cookie('non-existing-cookie', False)
        False
        >>> request.get_signed_cookie('cookie-that-was-tampered-with')
        ...
        BadSignature: ...    
        >>> request.get_signed_cookie('name', max_age=60)
        ...
        SignatureExpired: Signature age 1677.3839159 > 60 seconds
        >>> request.get_signed_cookie('name', False, max_age=60)
        False

4.HttpRequest.is_secure()
　　如果请求时是安全的，则返回True；即请求通是过 HTTPS 发起的。

5.HttpRequest.is_ajax()

　　如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'。

　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。

　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cache middleware， 
   你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存。

from django.shortcuts import render,HttpResponse,redirect

# Create your views here.

def index(request):
    print(request.method) #请求方式
    print(request.path)   #请求路径，不带参数的
    print(request.POST)   #post请求数据  字典格式
    print(request.GET)    #get的请求数据  字典格式
    print(request.META)   #请求头信息,将来用到哪个咱们再说哪个
    print(request.get_full_path())   #获取请求路径带参数的，/index/?a=1
    print(request.is_ajax())   #判断是不是ajax发送的请求，True和False
    '''
        Django一定最后会响应一个HttpResponse的示例对象
        三种形式：
HttpResponse('字符串') 最简单

render(页面)   最重要
                2.1 两个功能
                    -- 读取文件字符串
                    -- 嵌入变量(模板渲染) html里面：{{ name }} ， {'name':'太白'}作为render的第三个参数，想写多个变量{'name':'太白','hobby':['篮球','羽毛球']....}

redirect() 重定向  最难理解,某个网站搬家了，网址变了，访问原来的网址就重定向到一个新网址，就叫做重定向，网站自己做的重定向，你访问还是访问的你之前的，
你自己啥也不用做，浏览器发送请求，然后服务端响应，然后服务端告诉浏览器，你直接跳转到另外一个网址上，那么浏览器又自动发送了另外一个请求，发送到服务端，
服务端返回一个页面，包含两次请求，登陆成功后跳转到网站的首页，网站首页的网址和你login登陆页面的网址是不用的。
                
    '''

    return render(request,'index.html',{'name':'太白'})
    # return HttpResponse('ok')

from django.http import HttpResponse
response = HttpResponse("Here's the text of the Web page.")
response = HttpResponse("Text only, please.", content_type="text/plain")

response = HttpResponse()
response['Content-Type'] = 'text/html; charset=UTF-8'
del response['Content-Type']

# 属性
# HttpResponse.content;		响应内容
# HttpResponse.charset;		响应内容的编码
# HttpResponse.status_code; 响应的状态码

HttpResponse()
render()
redirect()

from django.shortcuts import render

def my_view(request):
    # 视图的代码写在这里
    return render(request, 'myapp/index.html', {'foo': 'bar'})

# 上面的代码等同于
from django.http import HttpResponse
from django.template import loader

def my_view(request):
    # 视图代码写在这里
    t = loader.get_template('myapp/index.html')
    c = {'foo': 'bar'}
    return HttpResponse(t.render(c, request))

# 1. 一个模型：将调用模型的get_absolute_url() 函数
# 2.一个视图，可以带有参数：将使用urlresolvers.reverse 来反向解析名称
# 3.一个绝对的或相对的URL，将原封不动的作为重定向的位置。
# 默认返回一个临时的重定向；传递permanent=True 可以返回一个永久的重定向。

# 将调用ORM对象的get_absolute_url()方法来获取重定向的URL;

from django.shortcuts import redirect
 
def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object)

# views 示例
def my_view(request):
    ...
    return redirect('home')

def home(request):
　　return HttpResponse('跳转成功！')
 
# urls示例：
urlpatterns = [
    url(r'home/', views.home, name='home'),  # 起别名，这样以后无论url如何变化，访问home直接可以映射到home函数
]

def my_view(request):
    ...
    return redirect('/index')

def my_view(request):
    ...
    return redirect('http://example.com/')

# 301和302的区别。

# 301和302状态码都表示重定向，就是说浏览器在拿到服务器返回的这个状态码后会自动跳转到一个新的URL地址，这个地址可以从响应的Location首部中获取
# （用户看到的效果就是他输入的地址A瞬间变成了另一个地址B）——这是它们的共同点。

# 他们的不同在于。301表示旧地址A的资源已经被永久地移除了（这个资源不可访问了），搜索引擎在抓取新内容的同时也将旧的网址交换为重定向之后的网址；

# 302表示旧地址A的资源还在（仍然可以访问），这个重定向只是临时地从旧地址A跳转到地址B，搜索引擎会抓取新的内容而保存旧的网址。 SEO302好于301

 

# 重定向原因：
#（1）网站调整（如改变网页目录结构）；
#（2）网页被移到一个新地址；
#（3）网页扩展名改变(如应用需要把.php改成.Html或.shtml)。
#  这种情况下，如果不做重定向，则用户收藏夹或搜索引擎数据库中旧地址只能让访问客户得到一个404页面错误信息，访问流量白白丧失；再者某些注册了多个域名的
# 网站，也需要通过重定向让访问这些域名的用户自动跳转到主站点等。

# 简单来说就是：
# 响应状态码：301，为临时重定向，旧地址的资源仍然可以访问。 
# 响应状态码：302，为永久重定向，旧地址的资源已经被永久移除了，这个资源不可访问了。 
# 对普通用户来说是没什么区别的，它主要面向的是搜索引擎的机器人。
# A页面临时重定向到B页面，那搜索引擎收录的就是A页面。
# A页面永久重定向到B页面，那搜索引擎收录的就是B页面。

from django.shortcuts import render,HttpResponse
from django.views import View  # 从django.views模块中引用View类

class Login(View):
    """
    自己定义get post方法，方法名不能变。这样只要访问此url，get请求自动执行get方法，post请求自动执行post方法，与我们写的FBV 
if request.method == 'GET' or 'POST' 一样。
    """
    def get(self, request):
        return render(request, 'login.html')

    def post(self, request):
        username = request.POST.get('username')
        password = request.POST.get('password')
        if username.strip() == 'taibai' and password.strip() == '123':
            return HttpResponse('登录成功')

        return render(request, 'login.html')

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^login/', views.Login.as_view()),
    # 引用views函数重的Login类，然后调用父类的as_view()方法
]

# CBV传参，和FBV类似，有名分组，无名分组
# url写法：无名分组的
# url(r'^cv/(d{2})/', views.Myd.as_view(),name='cv'),
# url(r'^cv/(?P<n>d{2})/', views.Myd.as_view(name='xxx'),name='cv'),
# 如果想给类的name属性赋值，前提你的Myd类里面必须有name属性（类属性，
# 定义init方法来接受属性行不通，但是可以自行研究一下，看看如何行通，意义不大），
# 并且之前类里面的name属性的值会被覆盖掉

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" rel="stylesheet">


</head>
<body>
<h1>你好 欢迎来到plus会所，请先登录</h1>

<form action="" method="post">
    <input type="text" name="username">
    <p></p>
    <input type="text" name="password">
    <p></p>
    <input type="submit">
</form>

</body>
</html>

def wrapper(func):

    def inner(*args,**kwargs):
        print('请求来了！')
        ret = func(*args,**kwargs)
        print('请求走了！')
        return ret
    return inner

@wrapper
def home(request):
    print('执行home函数')
    return render(request, 'home.html')

def wrapper(func):

    def inner(*args,**kwargs):
        print('请求来了！')
        ret = func(*args,**kwargs)
        print('请求走了！')
        return ret
    return inner


class Login(View):

    @wrapper
    def get(self, request):
        print('get 方法')
        return render(request, 'login.html')

    def post(self, request):

        username = request.POST.get('username')
        password = request.POST.get('password')

        if username.strip() == 'taibai' and password.strip() == '123':
            return HttpResponse('登录成功')

        return render(request, 'login.html')

'''
执行流程：
请求来了！
执行home函数
请求走了！
'''

from django.utils.decorators import method_decorator
def wrapper(func):

    def inner(*args,**kwargs):
        print('请求来了！')
        ret = func(*args,**kwargs)
        print('请求走了！')
        return ret
    return inner


class Login(View):

    @method_decorator(wrapper)
    def get(self, request):
        print('get 方法')
        return render(request, 'login.html')

    def post(self, request):

        username = request.POST.get('username')
        password = request.POST.get('password')

        if username.strip() == 'taibai' and password.strip() == '123':
            return HttpResponse('登录成功')

        return render(request, 'login.html')

class Login(View):
   
    @wrapper
    def dispatch(self, request, *args, **kwargs):
        ret = super().dispatch(request, *args, **kwargs)
        return ret    

# 注意csrf-token装饰器的特殊性，在CBV模式下它只能加在dispatch上面(后面再说)
# 下面这是csrf_token的装饰器：
#　@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置csrfToken全局中间件。
# @csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。
# 注意：from django.views.decorators.csrf import csrf_exempt,csrf_protect

from django.conf.urls import url,include
from app01 import views

urlpatterns = [
    # 首页
    url(r'^$',views.base),
    url('^app01/',include('app01.urls')),
]

# Django_Demo1/app01/urls.py  (第二个app应用的urls.py)
from django.conf.urls import url
from app01 import views

urlpatterns = [
    url('^login/',views.login),
]

from django.shortcuts import render
from django.shortcuts import redirect


def login(request):
    name = "幽梦"
    age = 20
    name_list = ['幽梦', 'flying', ]
    dic = {'幽梦': 18, 'flying': 21}
    return render(request, 'login1.html', {'name': name, 'age': age, 'name_list': name_list, 'dic_class': dic})

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .c1 {
            height: 48px;
            background: #dddddd;
            text-align: center
        }
    </style>
</head>
<body style="margin: 0;">
<div class="c1">欢迎来到You-Men博客</div>

<ul>
    <li>{{ name }}</li>
    <li>{{ age }}</li>
    <li>{{ name_list }}</li>
    <li>{{ dic_class }}</li>
</ul>
</body>
</html>

# 字典查询(Dictionary lookup)
# 属性或方法查询(Attribute or method lookup)
# 数字索引查询(Numeric index lookup)

from django.shortcuts import render
from django.shortcuts import redirect


def home(request):
    name = "幽梦"
    age = 20
    name_list = ['幽梦', 'flying', '红玫瑰','紫玫瑰','白玫瑰']
    dic = {'幽梦': 18, 'flying': 21,"黄玫瑰":22}
    return render(request, 'home.html', locals())


def base(request):
    return render(request, 'base.html')

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .c1 {
            height: 48px;
            background: #dddddd;
            text-align: center
        }
    </style>
</head>
<body style="margin: 0;">
<div class="c1">欢迎来到You-Men博客</div>

<ul>
    <li>{{ name }}</li>
    <li>{{ age }}</li>
    <li>{{ name_list.2 }}</li>
    <li>{{ dic.黄玫瑰 }}</li>
</ul>
</body>
</html>

# 过滤器的语法:  {{ value | filter_name:参数 }}
# 使用管道符"|"来应用过滤器
# 例如: {{ name|lower }}会将name变量应用lower过滤器之后再显示他的值,lower在这里的作用就是将文本全部都变为小写.

# 注意事项:
# 1. 过滤器支持"链式"操作,即一个过滤器的输出作为另一个过滤器的输入.
# 2. 过滤器可以接受参数,例如: {{ ss|truncatewords:30 }},这将显示ss的前三十个词
# 3. 过滤器参数包含空格的话,必须用引号包裹起来,比如使用逗号和空格去连接一个一个列表中的元素, 如{{ list|join:',' }}
# 4. '|'左右没有空格!没有空格 ! 没有空格
# Django的模板语言中提供了大约六十个内置过滤器

views:
a = ''  # 没有变量a或者变量a为空


html：  # 显示啥也没有
{{ value|default:"啥也没有"}}

views：
name_list = ['幽梦', 'flying', '红玫瑰','紫玫瑰','白玫瑰']
return render(request, 'home.html', { 'name_list':name_list})

html：
{{ name_list|length }}  # 显示为5

views：
value = 1048576

html：
{{ value|filesizeformat }}  # 显示为1.0MB

views：
name_list = ['王阔', '天琪', '傻强', '志晨', '健身哥']
s = '太白金星讲师'

html：
{{ name_list|slice:'1:3' }}  # ['天琪', '傻强']
{{ s|slice:'1::2' }}  # '白星师'

# views
time = datetime.datetime.now()
return render(request, 'home.html', { 'time':time })    
    

# html    
<li>{{ time|date:"Y-m-d H:i:s" }}</li>

# views：
describe = '1999年3月，马云正式辞去公职，后来被称为18罗汉的马云团队回到杭州，凑够50万元人民币'

# html：
{{ describe|truncatechars:9 }}  # 1999年3...

# 截断9个字符，三个点也算三个字符
# 我们浏览网页可以经常看到一个链接下面有一段注释,然后就是...

views:
words = 'i love you my country china'

html:
{{ words|truncatewords:3 }}  # i love you...

views:
words = 'i love you my country china'

html:
{{ words|cut:3 }}  # iloveyou

views:
name_list = ['王阔', '天琪', '傻强', '志晨', '健身哥']
dic = {'name':'太白','age': 18}
tu = (1, 2, 3)

html:
<li>{{ name_list|join:'_'}}</li>
<li>{{ dic|join:','}}</li>
<li>{{ tu|join:'+'}}</li>
'''
王阔_天琪_傻强_志晨_健身哥
name,age
1+2+3
'''

views:
  year_12 = datetime.datetime.now().replace(year=2012, month=6, day=28)
  year_18 = datetime.datetime.now().replace(year=2018, month=3, day=1)

html:
 <li>{{ year_12|timesince:year_18}}</li>

'''
5 years, 8 months
'''
# 如果year_18不写,默认就是距现在的时间段

{{ conference_date|timeuntil:from_date }}

# 前端页面
<ul>
    <li>{{ name_list.0 }}</li>
    <li>{{ name_list.1 }}</li>
    <li>{{ name_list.2 }}</li>
    <li>{{ name_list.3 }}</li>
</ul>

{% for 变量 in render的可迭代对象 %}
        {{ 变量 }}
{% endfor %}

# 例如：
{% for foo in name_list %}
        {{ foo }}
{% endfor %}

import datetime
from django.shortcuts import render
from django.shortcuts import redirect

def home(request):
    name = "幽梦"
    age = 20
    size = 2342314
    time = datetime.datetime.now()
    name_list = ['幽梦', 'flying', '红玫瑰','紫玫瑰','白玫瑰']
    dic = {'幽梦': 18, 'flying': 21,"黄玫瑰":22}
    return render(request, 'home.html', { 'name_list':name_list })

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .c1 {
            height: 48px;
            background: #dddddd;
            text-align: center
        }
    </style>
</head>
<body style="margin: 0;">
<div class="c1">欢迎来到You-Men博客</div>

<li>{{ name }}</li>
<li>{{ age }}</li>
<ul>
    {% for i in name_list %}
        <li>{{ i }}</li>
    {% endfor %}
</ul>
<li>{{ dic }}</li>
</body>
</html>

<ul>
    {% for foo in name_list %}
        <li>{{ foo }}</li>
    {% endfor %}
</ul>

{% for foo in name_list reversed %}
        <li>{{ foo }}</li>
{% endfor %}

<ul>

    {% for key,value in dic.items %}
        <li>{{ key }}: {{ value }}</li>
    {% endfor %}

    {% for key in dic.keys %}
        <li>{{ key }}</li>
    {% endfor %}

    {% for value in dic %}
        <li>{{ value }}</li>
    {% endfor %}

</ul>

forloop.counter            # 当前循环的索引值(从1开始)，forloop是循环器，通过点来使用功能
forloop.counter0           # 当前循环的索引值（从0开始）
forloop.revcounter         # 当前循环的倒序索引值（从1开始）
forloop.revcounter0        # 当前循环的倒序索引值（从0开始）
forloop.first              # 当前循环是不是第一次循环（布尔值）
forloop.last               # 当前循环是不是最后一次循环（布尔值）
forloop.parentloop         # 本层循环的外层循环的对象，再通过上面的几个属性来显示外层循环的计数等


<ul>
    {% for foo in name_list %}

        <li>{{ forloop.counter }} {{ foo }}</li>
    {% endfor %}

    {% for foo in name_list %}
        {{ forloop.counter0 }}
        <li>{{ foo }}</li>
    {% endfor %}
    
    {% for foo in name_list %}
    <li>{{ forloop.revcounter }} {{ foo }}</li>
 	{% endfor %}

	{% for foo in name_list %}
        <li>{{ forloop.first }} {{ foo }}</li>
	{% endfor %}
</ul>

<ul>        
    {% for foo in aaa %}
        <li>{{ foo }}</li>
    {% empty %}
        <li>查询的内容啥也没有</li>
    {% endfor %}

    {% for foo in value %}
        <li>{{ foo }}</li>
    {% empty %}
        <li>查询的内容啥也没有</li>
     {% endfor %}
</ul>

{% if 条件 %}
    结果  <!--不满足条件，不会生成这个标签-->
{% elif 条件 %}
    结果
{% else %}  <!--也是在if标签结构里面的-->
    结果
{% endif %}

{% if dic.age > 18 %}
    <p>可以干点儿该做的事儿了～</p>
{% elif dic.age < 18 %}
    <p>小孩子，懂什么</p>
{% else %}
    <p> 风华正茂的年龄～</p>
{% endif %}

% if name_list|length > 4 %}
    <p>列表元素超过4个</p>
{% else %}
    <p>列表元素太少！</p>
{% endif %}

{% with total=business.employees.count %}
    {{ total }} <!--只能在with语句体内用-->
{% endwith %}

{% with business.employees.count as total %}
    {{ total }}
{% endwith %}

{% for foo in name_list %}
    {% if forloop.first %}
        {{ foo }}
    {% else %}
        <p>只有第一次循环打印</p>
    {% endif %}
{% endfor %}

{% for i in lis %}
     {% for j in i %}
{#         <p>{{ forloop.parentloop }}</p>#}
        <p>{{ forloop.parentloop.counter }} {{ forloop.counter }} {{ j }}</p>
     {% endfor %}
{% endfor %}

# 1. Django的模板语言不支持连续判断,即不支持以下写法:
{% if a > b > c %}
...
{% endif %}

# 2. Django的模板语言中属性的优先级大于方法
def xx(request):
    d = {"a": 1, "b": 2, "c": 3, "items": "100"}
    return render(request, "xx.html", {"data": d})
# 如上，我们在使用render方法渲染一个页面的时候，传的字典d有一个key是items并且还有默认的 d.items() 方法，此时在模板语言中:
{{ data.items }}
# 默认会取d的item key的值

import requests

ret = requests.post('http://127.0.0.1:8000/login/',
                    data={'username': 'taibai', 'password': '123'}
                    )

print(ret.content)
# 如果你保留这这个验证，则通过爬虫是登录不成功的，只能返回你一个forbidden的html页面。

# 如果你将settings那个中间件注释掉，那么就可以成功访问了：

urlpatterns = [
    url(r'^base/', views.base),
    url(r'^menu1/', views.menu1),
    url(r'^menu2/', views.menu2),
    url(r'^menu3/', views.menu3),

]

def base(request):
    return render(request, 'base.html')


def menu1(request):
    return render(request, 'menu1.html')


def menu2(request):
    return render(request, 'menu2.html')


def menu3(request):
    return render(request, 'menu3.html')

base.html:
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>

    <style>

        body{
            margin: 0;
            padding: 0;

        }

        .nav{
            background-color: black;
            color: #eaeaea;
            height: 30px;
            width: 100%;
        }
        .clearfix{
            content: '';
            display: block;
            clear: both;
        }
        .sidebar{
            background-color: #b2b2b2;
            color: #435dff;
            width: 20%;
            height: 1000px;
            float: left;
        }
        .sidebar ul{
            margin: 0;
        }

        .menu{
            width: 80%;
            float: right;

        }

    </style>

</head>

<body>

<div class="nav clearfix">
    <a href="">普通洗浴</a>
    <a href="">盆儿堂</a>
    <a href="">局部护理</a>
    <a href="">关于我们</a>
    <a href="">预约电话</a>
    <input type="text">搜索
</div>

<div class='sidebar'>
    <ul>
        <li><a href="/menu1/">菜单一</a></li>
        <li><a href="/menu2/">菜单二</a></li>
        <li><a href="/menu3/">菜单三</a></li>
    </ul>
</div>

<div class="menu">
    首页
</div>


</body>
</html>


menu1.html：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>

    <style>

        body{
            margin: 0;
            padding: 0;

        }

        .nav{
            background-color: black;
            color: #eaeaea;
            height: 30px;
            width: 100%;
        }
        .clearfix{
            content: '';
            display: block;
            clear: both;
        }
        .sidebar{
            background-color: #b2b2b2;
            color: #435dff;
            width: 20%;
            height: 1000px;
            float: left;
        }
        .sidebar ul{
            margin: 0;
        }

        .menu{
            width: 80%;
            float: right;

        }

    </style>

</head>

<body>

<div class="nav clearfix">
    <a href="">普通洗浴</a>
    <a href="">盆儿堂</a>
    <a href="">局部护理</a>
    <a href="">关于我们</a>
    <a href="">预约电话</a>
    <input type="text">搜索
</div>

<div class='sidebar'>
    <ul>
        <li><a href="/menu1/">菜单一</a></li>
        <li><a href="/menu2/">菜单二</a></li>
        <li><a href="/menu3/">菜单三</a></li>
    </ul>
</div>

<div class="menu">
    菜单一首页
</div>


</body>
</html>

menu2.html:
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>

    <style>

        body{
            margin: 0;
            padding: 0;

        }

        .nav{
            background-color: black;
            color: #eaeaea;
            height: 30px;
            width: 100%;
        }
        .clearfix{
            content: '';
            display: block;
            clear: both;
        }
        .sidebar{
            background-color: #b2b2b2;
            color: #435dff;
            width: 20%;
            height: 1000px;
            float: left;
        }
        .sidebar ul{
            margin: 0;
        }

        .menu{
            width: 80%;
            float: right;

        }

    </style>

</head>

<body>

<div class="nav clearfix">
    <a href="">普通洗浴</a>
    <a href="">盆儿堂</a>
    <a href="">局部护理</a>
    <a href="">关于我们</a>
    <a href="">预约电话</a>
    <input type="text">搜索
</div>

<div class='sidebar'>
    <ul>
        <li><a href="/menu1/">菜单一</a></li>
        <li><a href="/menu2/">菜单二</a></li>
        <li><a href="/menu3/">菜单三</a></li>
    </ul>
</div>

<div class="menu">
    菜单2首页
</div>


</body>
</html>

menu3.html

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>

    <style>

        body{
            margin: 0;
            padding: 0;

        }

        .nav{
            background-color: black;
            color: #eaeaea;
            height: 30px;
            width: 100%;
        }
        .clearfix{
            content: '';
            display: block;
            clear: both;
        }
        .sidebar{
            background-color: #b2b2b2;
            color: #435dff;
            width: 20%;
            height: 1000px;
            float: left;
        }
        .sidebar ul{
            margin: 0;
        }

        .menu{
            width: 80%;
            float: right;

        }

    </style>

</head>

<body>

<div class="nav clearfix">
    <a href="">普通洗浴</a>
    <a href="">盆儿堂</a>
    <a href="">局部护理</a>
    <a href="">关于我们</a>
    <a href="">预约电话</a>
    <input type="text">搜索
</div>

<div class='sidebar'>
    <ul>
        <li><a href="/menu1/">菜单一</a></li>
        <li><a href="/menu2/">菜单二</a></li>
        <li><a href="/menu3/">菜单三</a></li>
    </ul>
</div>

<div class="menu">
    菜单三首页
</div>


</body>
</html>

base menu1 menu2 menu3

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>

    <style>

        body{
            margin: 0;
            padding: 0;

        }

        .nav{
            background-color: black;
            color: #eaeaea;
            height: 30px;
            width: 100%;
        }
        .clearfix{
            content: '';
            display: block;
            clear: both;
        }
        .sidebar{
            background-color: #b2b2b2;
            color: #435dff;
            width: 20%;
            height: 1000px;
            float: left;
        }
        .sidebar ul{
            margin: 0;
        }

        .menu{
            width: 80%;
            float: right;

        }

    </style>

</head>

<body>

<div class="nav clearfix">
    <a href="">普通洗浴</a>
    <a href="">盆儿堂</a>
    <a href="">局部护理</a>
    <a href="">关于我们</a>
    <a href="">预约电话</a>
    <input type="text">搜索
</div>

<div class='sidebar'>
    <ul>
        <li><a href="/menu1/">菜单一</a></li>
        <li><a href="/menu2/">菜单二</a></li>
        <li><a href="/menu3/">菜单三</a></li>
    </ul>
</div>

<div class="menu">

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

{% extends 'master_edition.html' %}

<div class="menu">
    {% block content %}
    {% endblock %}
</div>

{% block content %}
     base页面首页
{% endblock %}

<style>

        body{
            margin: 0;
            padding: 0;

        }

        .nav{
            background-color: black;
            color: #eaeaea;
            height: 30px;
            width: 100%;
        }
        .clearfix{
            content: '';
            display: block;
            clear: both;
        }
        .sidebar{
            background-color: #b2b2b2;
            color: #435dff;
            width: 20%;
            height: 1000px;
            float: left;
        }
        .sidebar ul{
            margin: 0;
        }

        .menu{
            width: 80%;
            float: right;

        }
        {% block nav %}
        {% endblock %}
    </style>

{% block nav %}
    .nav{
    background-color: red;
    }
{% endblock %}

<div class="menu">

    {% block content %}
        <div>这是母版测试页面</div>
    {% endblock %}
</div>

{% block content %}
    {{ block.super }}
     base页面首页
{% endblock %}

{% include 'xx.html' %}

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>

    <style>

        body{
            margin: 0;
            padding: 0;

        }

        .nav{
            background-color: black;
            color: #eaeaea;
            height: 30px;
            width: 100%;
        }
        .clearfix{
            content: '';
            display: block;
            clear: both;
        }

    </style>

</head>

<body>

<div class="nav clearfix">
    <a href="">普通洗浴</a>
    <a href="">盆儿堂</a>
    <a href="">局部护理</a>
    <a href="">关于我们</a>
    <a href="">预约电话</a>
    <input type="text">搜索
</div>



</body>
</html>

urls：
url(r'^component/', views.component),


views：
def component(request):
    return render(request,'component.html')

component页面：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" rel="stylesheet">


</head>
<body>
{% include 'nav.html' %}
<h1>你好，世界！</h1>
<div>我是componet页面</div>


</body>
</html>

# 组件是提供某一完整功能的模块,如: 编辑器组件,QQ空间提供的关注组件等

# 而插件更倾向封闭某一个功能方法的函数

# 这两者的区别在JavaScript里区别很小,组件这个名词用的不多,一般统称插件

#sql中的表                                                      

 #创建表:
     CREATE TABLE employee(                                     
                id INT PRIMARY KEY auto_increment ,                   
                name VARCHAR (20),                                   
                gender BIT default 1,                                 
                birthday DATA ,                                       
                department VARCHAR (20),                             
                salary DECIMAL (8,2) unsigned,                       
              );


  #sql中的表纪录                                                  

  #添加一条表纪录:                                                     
      INSERT employee (name,gender,birthday,salary,department)       
             VALUES   ("alex",1,"1985-12-12",8000,"保洁部");            
  #查询一条表纪录:                                                    
      SELECT * FROM\ employee WHERE age=24;                         

  #更新一条表纪录:                                                     
      UPDATE employee SET birthday="1989-10-24" WHERE id=1;              
  #删除一条表纪录:                                                    
      DELETE FROM employee WHERE name="alex"                             

#python的类
class Employee(models.Model):
     id=models.AutoField(primary_key=True)
     name=models.CharField(max_length=32)
     gender=models.BooleanField()
     birthday=models.DateField()
     department=models.CharField(max_length=32)
     salary=models.DecimalField(max_digits=8,decimal_places=2)


 #python的类对象
      #添加一条表纪录:
          emp=Employee(name="alex",gender=True,birthday="1985-12-12",epartment="保洁部")
          emp.save()
      #查询一条表纪录:
          Employee.objects.filter(age=24)
      #更新一条表纪录:
          Employee.objects.filter(id=1).update(birthday="1989-10-24")
      #删除一条表纪录:
          Employee.objects.filter(name="alex").delete()

grant all privileges on *.* to admin@"%" identified by 'ZHOUjian.21' with grant option;
flush privileges;

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'cmdb',
        'USER': 'admin',
        'PASSWORD': 'ZHOUjian.20',
        'HOST': '121.36.43.223',
        'PORT': '3306',
    }
}

# 使用pymysql注意到__init.py加入以下两行代码
import pymysql
pymysql.install_as_MySQLdb()

注意：NAME即数据库的名字，在mysql连接前该数据库必须已经创建，而上面的sqlite数据库下的db.sqlite3则是项目自动创建 USER和PASSWORD分别是数据库的用户名和密码。设置完后，再启动我们的Django项目前，我们需要激活我们的mysql。接下来，我们要提前先给mysql创建cmdb的数据库

from django.db import models
# Create your models here.


class UserInfo(models.Model):
    """
    下面几个类的属性通过ORM映射就对应成了：
    create table userinfo(
        id int primary key auto_increment,
        name varchar(16),
        age int,
        current_date date)
    """
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    age = models.IntegerField()
    current_date = models.DateField()

python manage.py makemigrations

在执行 python manager.py makemigrations时
Django 会在相应的 app 的migrations文件夹下面生成 一个python脚本文件 
    
在执行 python manager.py migrate 时 Django才会生成数据库表，那么Django是如何生成数据库表的呢?

Django是根据 migrations下面的脚本文件来生成数据表的
    每个migrations文件夹下面有多个脚本，那么django是如何知道该执行那个文件的呢，django有一张django-migrations表，表中记录了已经执行的脚本，那么表中没有的就是还没执行的脚本，则 执行migrate的时候就只执行表中没有记录的那些脚本。
    有时在执行 migrate 的时候如果发现没有生成相应的表，可以看看在 django-migrations表中看看 脚本是否已经执行了，
    可以删除 django-migrations 表中的记录 和 数据库中相应的 表 ， 然后重新 执行

# 终端命令:  django-admin startproject sitename
# IDE创建django程序本质上都是自动那个上述命令

# 其他常用命令
python manage.py runserver 0.0.0.0
python manage.py startapp appname
python manage.py syncdb
python manage.py makemigrations
python manage.py migrate
python manage.py createuperuser

python manage.py startapp cmdb

TEMPLATE_DIRS = (
     'DIRS': [os.path.join(BASE_DIR,'templates')],
    )

STATICFILES_DIRS = (
	os.path.join(BASE_DIR,'static')
)

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

# 每个模型在Django中的存在形式为一个Python类
# 每个模型都是django.db.models.Model的子类
# 模型的每个字段（属性）代表数据表的某一列
# Django将自动为你生成数据库访问API

from django.db import models
# Create your models here.


class UserInfo(models.Model):
    """
    下面几个类的属性通过ORM映射就对应成了：
    create table userinfo(
        id int primary key auto_increment,
        name varchar(16),
        age int,
        current_date date)
    """
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    age = models.IntegerField()
    current_date = models.DateField()


python manage.py migrate
python manage.py makemigrations

# 表名`myapp_person`由Django自动生成，默认格式为“项目名称+下划线+小写类名”，你可以重写这个规则。
# Django默认自动创建自增主键`id`，当然，你也可以自己指定主键。
# 上面的SQL语句基于`PostgreSQL`语法。

<1> CharField
        字符串字段, 用于较短的字符串.
        CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数.
 
<2> IntegerField
       #用于保存一个整数.
 
<3> DecimalField
        一个浮点数. 必须 提供两个参数:
         
        参数    描述
        max_digits    总位数(不包括小数点和符号)
        decimal_places    小数位数
                举例来说, 要保存最大值为 999 (小数点后保存2位),你要这样定义字段:
                 
                models.DecimalField(..., max_digits=5, decimal_places=2)
                要保存最大值一百万(小数点后保存10位)的话,你要这样定义:
                 
                models.DecimalField(..., max_digits=17, decimal_places=10) #max_digits大于等于17就能存储百万以上的数了
                admin 用一个文本框(<input type="text">)表示该字段保存的数据.
 
<4> AutoField
        一个 IntegerField, 添加记录时它会自动增长. 你通常不需要直接使用这个字段;
        自定义一个主键：my_id=models.AutoField(primary_key=True)
        如果你不指定主键的话,系统会自动添加一个主键字段到你的 model.
 
<5> BooleanField
        A true/false field. admin 用 checkbox 来表示此类字段.
 
<6> TextField
        一个容量很大的文本字段.
        admin 用一个 <textarea> (文本区域)表示该字段数据.(一个多行编辑框).
 
<7> EmailField
        一个带有检查Email合法性的 CharField,不接受 maxlength 参数.
 
<8> DateField
        一个日期字段. 共有下列额外的可选参数:
        Argument    描述
        auto_now    当对象被保存时(更新或者添加都行),自动将该字段的值设置为当前时间.通常用于表示 "last-modified" 时间戳.
        auto_now_add    当对象首次被创建时,自动将该字段的值设置为当前时间.通常用于表示对象创建时间.
        （仅仅在admin中有意义...)
 
<9> DateTimeField
         一个日期时间字段. 类似 DateField 支持同样的附加选项.
 
<10> ImageField
        类似 FileField, 不过要校验上传对象是否是一个合法图片.#它有两个可选参数:height_field和width_field,
        如果提供这两个参数,则图片将按提供的高度和宽度规格保存.    
<11> FileField
     一个文件上传字段.
     要求一个必须有的参数: upload_to, 一个用于保存上载文件的本地文件系统路径. 这个路径必须包含 strftime #formatting,
     该格式将被上载文件的 date/time
     替换(so that uploaded files don't fill up the given directory).
     admin 用一个<input type="file">部件表示该字段保存的数据(一个文件上传部件) .
 
     注意：在一个 model 中使用 FileField 或 ImageField 需要以下步骤:
            （1）在你的 settings 文件中, 定义一个完整路径给 MEDIA_ROOT 以便让 Django在此处保存上传文件.
            (出于性能考虑,这些文件并不保存到数据库.) 定义MEDIA_URL 作为该目录的公共 URL. 要确保该目录对
             WEB服务器用户帐号是可写的.
            （2） 在你的 model 中添加 FileField 或 ImageField, 并确保定义了 upload_to 选项,以告诉 Django
             使用 MEDIA_ROOT 的哪个子目录保存上传文件.你的数据库中要保存的只是文件的路径(相对于 MEDIA_ROOT).
             出于习惯你一定很想使用 Django 提供的 get_<#fieldname>_url 函数.举例来说,如果你的 ImageField
             叫作 mug_shot, 你就可以在模板中以 {{ object.#get_mug_shot_url }} 这样的方式得到图像的绝对路径.
 
<12> URLField
      用于保存 URL. 若 verify_exists 参数为 True (默认), 给定的 URL 会预先检查是否存在( 即URL是否被有效装入且
      没有返回404响应).
      admin 用一个 <input type="text"> 文本框表示该字段保存的数据(一个单行编辑框)
 
<13> NullBooleanField
       类似 BooleanField, 不过允许 NULL 作为其中一个选项. 推荐使用这个字段而不要用 BooleanField 加 null=True 选项
       admin 用一个选择框 <select> (三个可选择的值: "Unknown", "Yes" 和 "No" ) 来表示这种字段数据.
 
<14> SlugField
       "Slug" 是一个报纸术语. slug 是某个东西的小小标记(短签), 只包含字母,数字,下划线和连字符.#它们通常用于URLs
       若你使用 Django 开发版本,你可以指定 maxlength. 若 maxlength 未指定, Django 会使用默认长度: 50.  #在
       以前的 Django 版本,没有任何办法改变50 这个长度.
       这暗示了 db_index=True.
       它接受一个额外的参数: prepopulate_from, which is a list of fields from which to auto-#populate
       the slug, via JavaScript,in the object's admin form: models.SlugField
       (prepopulate_from=("pre_name", "name"))prepopulate_from 不接受 DateTimeFields.
 
<13> XMLField
        一个校验值是否为合法XML的 TextField,必须提供参数: schema_path, 它是一个用来校验文本的 RelaxNG schema #的文件系统路径.
 
<14> FilePathField
        可选项目为某个特定目录下的文件名. 支持三个特殊的参数, 其中第一个是必须提供的.
        参数    描述
        path    必需参数. 一个目录的绝对文件系统路径. FilePathField 据此得到可选项目.
        Example: "/home/images".
        match    可选参数. 一个正则表达式, 作为一个字符串, FilePathField 将使用它过滤文件名. 
        注意这个正则表达式只会应用到 base filename 而不是
        路径全名. Example: "foo.*.txt^", 将匹配文件 foo23.txt 却不匹配 bar.txt 或 foo23.gif.
        recursive可选参数.要么 True 要么 False. 默认值是 False. 是否包括 path 下面的全部子目录.
        这三个参数可以同时使用.
        match 仅应用于 base filename, 而不是路径全名. 那么,这个例子:
        FilePathField(path="/home/images", match="foo.*", recursive=True)
        ...会匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif
 
<15> IPAddressField
        一个字符串形式的 IP 地址, (i.e. "24.124.1.30").
<16> CommaSeparatedIntegerField
        用于存放逗号分隔的整数值. 类似 CharField, 必须要有maxlength参数.

(1)null
 
如果为True，Django 将用NULL 来在数据库中存储空值。 默认值是 False.
 
(1)blank
 
如果为True，该字段允许不填。默认为False。
要注意，这与 null 不同。null纯粹是数据库范畴的，而 blank 是数据验证范畴的。
如果一个字段的blank=True，表单的验证将允许该字段是空值。如果字段的blank=False，该字段就是必填的。

(2)default
 
字段的默认值。可以是一个值或者可调用对象。如果可调用 ，每有新对象被创建它都会被调用，如果你的字段没有设置可以为空，那么将来如果我们后添加一个字段，这个字段就要给一个default值
 
(3)primary_key
 
如果为True，那么这个字段就是模型的主键。如果你没有指定任何一个字段的primary_key=True，
Django 就会自动添加一个IntegerField字段做为主键，所以除非你想覆盖默认的主键行为，
否则没必要设置任何一个字段的primary_key=True。
 
(4)unique
 
如果该值设置为 True, 这个数据字段的值在整张表中必须是唯一的
 
(5)choices
由二元组组成的一个可迭代对象（例如，列表或元组），用来给字段提供选择项。 如果设置了choices ，默认的表单将是一个选择框而不是标准的文本框，<br>而且这个选择框的选项就是choices 中的选项。
(6)db_index
　　如果db_index=True 则代表着为此字段设置数据库索引。

DatetimeField、DateField、TimeField这个三个时间字段，都可以设置如下属性。

(7)auto_now_add
    配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。

(8)auto_now
    配置上auto_now=True，每次更新数据记录的时候会更新该字段，标识这条记录最后一次的修改时间。

'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',

python manage.py startapp app01

# 记得在settings.py注册app01

from django.conf.urls import url,include
urlpatterns = [
    url(r'^cmdb/', include("app01.urls")),
]

from django.conf.urls import url
from app01 import views

urlpatterns = [
    url(r'^login/',views.login),
    url(r'^orm/',views.orm),
]

from django.db import models

from django.db import models

class UserInfo(models.Model):
    name = models.CharField(max_length=16)
    password = models.CharField(max_length=20)

python manage.py makemigrations
python manage.py migrate

from django.shortcuts import render,HttpResponse,redirect
from cmdb import models

def login(request):
    if request.method == "GET":
        return render(request, 'login.html')
    elif request.method == "POST":
        return render(request, 'login.html')
    else:
        return  redirect('/index/')

def orm(request):
    # 增加数据有三种
    # 创建1
    # models.UserInfo.objects.create(name='root',password='123')

    # 创建2
    # obj = models.UserInfo(name='tom',password='456')
    # obj.save()

    # 创建3
    # dic = {'username':'tom','password':'999'}
    # models.UserInfo.objects.create(**dic)

    # 查询所有
    # result = models.UserInfo.objects.all()
    # for row in result:
    #     print(row.id,row.username,row.password)
    # print(result)
    # where(filter)查询
    # result = models.UserInfo.objects.filter(username='root')
    # 如果在'root',后面加上password='123'等同于and条件
    # for row in result:
    #     print(row.id,row.username,row.password)
    # print(result)

    # 删除id=10的行
    # models.UserInfo.objects.filter(id=10).delete()

    # 更新所有
    # models.UserInfo.objects.all().update(password=1314520)
    # return HttpResponse('orm')

    # 更新指定
    models.UserInfo.objects.filter(id=8).update(password='WuNai')
    return HttpResponse('orm')

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/login" method="POST"  enctype="multipart/form-data">
        <p>
            <input type="text" name="user" placeholder="用户名">
        </p>

        <p>
            <input type="password" name="pwd" placeholder="密码" />
        </p>
        <p>
            男: <input type="radio" name="gender" value="1" />
            女: <input type="radio" name="gender" value="2" />
            张扬: <input type="radio" name="gender" value="3" />
        </p>
        <p>
            男: <input type="checkbox" name="favor" value="11" />
            女: <input type="checkbox" name="favor" value="22" />
            张扬: <input type="checkbox" name="favor" value="33" />
        </p>
        <p>
            <select name="area" multiple>
                <option  value="sh">上海</option>
                <option  value="bj">北京</option>
                <option  value="tj">天津</option>
                <option  value="gz">广州</option>
            </select>
        </p>
        <p>
            <input type="file" name="files">
        </p>
        <input type="submit" value="提交">
    </form>
</body>
</html>

python manage.py runserver

# 我们先去module.py定义表结构
class Student(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    age = models.IntegerField()

# 生成记录并创建表结构
python manage.py makemigrations
python manage.py migrate

# 方式一
# 在index函数中操作:
def index(request):
    # 实例化一个对象这就是一条记录
    student_obj = models.Student(
        name='王阔',
        age=18
    )
    # 将此记录增加到数据表中
    student_obj.save()
    return render(request,'index.html')
    
# 方式二
# 我们通过方式1给student表中添加了一条表记录，但是上面那种方法不灵活，接下来我们介绍一种更加灵活的方法。
models.Student.objects.create(
        name='ZHOU',
        age=20
    )
    
new_obj = models.Student.objects.create(
        name='ZHOU',
        age=19
    )
print(new_obj)  # Student object
print(new_obj.name)  # 志远


# 批量创建
# 比如依次插入三十条数据
obj_list = [models.Student(name=f'幽梦{i}', age=20) for i in range(1, 31)]
models.Student.objects.bulk_create(obj_list)


# 更新和增加
# orm还有一种方法是对一条表记录进行更新或者增加的操作,有则更新无则增加,类似于字典的这个操作dic['name']='barry'
models.Student.objects.update_or_create(
        name='乔妹儿1',  # 筛选条件
        defaults={  # 需要更新或者增加的值
            'age': 1000,
        }
)

# 简单的查询
# 1. all()全部取出
# 通过all从orm取出来的是一个QuerySet类型，这里面有很多个Student类的对象也就是model对象，这个QuerySet类似于列表，但是不同与列表，在这里我们知道可以循环遍历取值即可.
all_objs = models.Student.objects.all()
    print(all_objs)  # QuerySet类型 这里面有很多个Student类的对象也就是model对象。
    # 通过遍历可以获取每个对象的name属性
    for i in all_objs:
        print(i.name)
        
# filter(条件)查询
# 通过条件查询获取结果，返回的也是QuerySet类型，如果查询不到内容不会报错，返回一个空的QuerySet集合。
objs = models.Student.objects.filter(age=20)
print(objs)
objs = models.Student.objects.filter(id=2)
print(objs)  # <QuerySet [<Student: 傻强>]>
print(objs[0].id)  # 2 可以通过索引取值

objs = models.Student.objects.filter(name='太白')
print(objs) 


# get(条件)查询
# 这个get比较特殊，它返回的是model对象，通过get条件查询，查询的结果有且只有1个。
# 如果超过一个则报错为：get() returned more than one Student -- it returned 2(有几个显示几个)!
# 如果没有则报错为：Student matching query does not exist.

# obj = models.Student.objects.get(name='太白')  # 报错：Student matching query does not exist.
# obj = models.Student.objects.get(age=20)  # get() returned more than one Student -- it returned 20!
obj = models.Student.objects.get(id=1)
print(obj)  # model对象
# 一般使用get条件查询,前提一要确定你的条件锁定的是一行记录.


# exclude排除
# 通过object对象或者QuerySet集合调用，返回QuserySet集合。
# 下面我们演示了上面说到的链式点操作，可以一直进行点的操作，因为此方法可以QuerySet集合调用，并且返回的还是QuerySet集合。
objs = models.Student.objects.exclude(id=1)
print(objs)

# 排除id为1的行记录，将剩下所有的返回
objs = models.Student.objects.filter(age=20).exclude(name='齐佳乐')
print(objs)  # <QuerySet [<Student: 乔妹儿1>, <Student: 乔妹儿1>, <Student: 健身哥>, <Student: 张雨薇>]>
objs = models.Student.objects.filter(age=20).exclude(name='齐佳乐').exclude(name='健身哥')
print(objs)  # <QuerySet [<Student: 乔妹儿1>, <Student: 乔妹儿1>,  <Student: 张雨薇>]>


# order_by排序
# 通过object对象或者QuerySet集合调用,返回QuserySet集合
# object对象调用
objs = models.Student.objects.order_by('age')  # 通过姓名升序排列
print(objs)

# queryset集合调用
objs = models.Student.objects.all().order_by('age')  # 通过姓名升序排列
print(objs)

# 通过年龄升序排列,相同年龄的按照id降序排列
objs = models.Student.objects.all().order_by('age', '-id')
print(objs)


# reverse反转
# 通过order_by返回的QuerySet集合调用，返回一个QuerySet集合。
objs = models.Student.objects.reverse()
print(objs)  # 这样没有作用，all filter等都没有作用
objs = models.Student.objects.order_by('id').reverse()  # 只能通过order_by返回的QuerySet集合调用
print(objs)


# count计数
# 通过QuerySet集合调用,返回一个元素个数
num = models.Student.objects.all().count()
print(num)  # 12
num = models.Student.objects.filter(age=20).count()
print(num)  # 5


# first返回第一个model对象
# 通过QuerySet集合调用,返回第一个model对象
obj = models.Student.objects.filter(age=20).first()
print(obj)


# last返回最后一个model对象
# 通过QuerySet集合调用，返回最后一个model对象
obj = models.Student.objects.filter(age=20).last()
print(obj)


# exists判断是否存在
# 通过QuerySet集合调用，返回bool值
flag = models.Student.objects.filter(age=25).exists()
print(flag)  # False
# 这里我们要说一句，他的效率是高的，尤其是作为if判断的条件。
# 虽然说你可以通过下面的方式判断，但是如果这个集合一下取出上百万条数据，那么你的效率就很低的，
# 而exists翻译成sql语句是limit=1，也就是说它只看第一个对象存不存在就返回bool值了。
if Queryset集合：
    pass
    
# 我们也可以通过配置settings，每次执行orm语句时都将相应的sql语句展示出来，这样可以查看一下exists().

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

# values_list
# 通过QuerySet集合调用,返回一个QuerySet集合
# 但是这个QuerySet集合比较特殊,这个里面的元素不是model对象,而是元组的形式
query_tuple = models.Student.objects.filter(age=20).values_list()
print(query_tuple)
# <QuerySet [(4, '乔妹儿1', 20), (24, '乔妹儿1', 20), (27, '健身哥', 20), (28, '张雨薇', 20), (32, '齐佳乐', 20)]>
query_tuple = models.Student.objects.filter(age=20).values_list().exclude(name='齐佳乐')
print(query_tuple)
# < QuerySet[(4, '乔妹儿1', 20), (24, '乔妹儿1', 20), (27, '健身哥', 20), (28, '张雨薇', 20)] >
# 还可以指定想获取的字段
query_tuple = models.Student.objects.filter(age=20).values_list('name','age')
print(query_tuple)
# <QuerySet [('乔妹儿1', 20), ('乔妹儿1', 20), ('健身哥', 20), ('张雨薇', 20), ('齐佳乐', 20)]>


# values
# 通过QuerySet集合调用，返回一个QuerySet集合
# 但是这个QuerySet集合比较特殊,这个里面的元素不是model对象,而是字典的形式
query_dict = models.Student.objects.filter(age=19).values()
print(query_dict)  # <QuerySet [{'id': 3, 'name': '志远', 'age': 19}, {'id': 25, 'name': '董伟华', 'age': 19}]>
query_dict = models.Student.objects.filter(age=19).values('name', 'age')
print(query_dict)  # <QuerySet [{'name': '志远', 'age': 19}, {'name': '董伟华', 'age': 19}]>


# distinct去重
# 通过QuerySet集合调用，返回一个QuerySet集合
# 这里要注意一点：无论是all还是filter 你对整个对象去重是没有意义的，只要有一个字段不同，都不是重复的。
query_objs = models.Student.objects.filter(age=20).distinct()
print(query_objs)
# <QuerySet [<Student: id:4 name:乔妹儿1 age:20>, <Student: id:24 name:乔妹儿1 age:20>, <Student: id:27 name:健身哥 age:20>, <Student: id:28 name:张雨薇 age:20>, <Student: id:32 name:齐佳乐 age:20>]>
# 所以这个去重一般都用于values或者values_list
query_objs = models.Student.objects.filter(age=20).values('age').distinct()
print(query_objs) # <QuerySet [{'age': 20}]>




# 基于双下划线的模糊查询
# 我们在使用filter方法时，一直在使用 = 条件，但是没有使用过> < >=等条件，这是因为ORM不支持这种写法，不用着急，我们可以根据另一种写法去实现。
query_objs = models.Student.objects.filter(age__gt=19)  # 大于
query_objs = models.Student.objects.filter(age__gte=19)  # 大于等于
query_objs = models.Student.objects.filter(age__lt=20)  # 小于
query_objs = models.Student.objects.filter(age__lte=20)  # 小于等于
query_objs = models.Student.objects.filter(age__range=[18, 20])  # 范围 左右都包含
query_objs = models.Student.objects.filter(name__contains='xiao')  # 针对字符串类型，内容含有
query_objs = models.Student.objects.filter(name__icontains='xiao')  # 针对字符串类型，内容含有 不区分大小写
query_objs = models.Student.objects.filter(name__startswith='x')  # 匹配以x开头
query_objs = models.Student.objects.filter(name__istartswith='x')  # 匹配以x开头，不区分大小写
query_objs = models.Student.objects.filter(name__endswith='o')  # 匹配以x结尾
query_objs = models.Student.objects.filter(name__iendswith='o')  # 匹配以x结尾，不区分大小写



# 日期
# 日期这个字段查询起来比较特殊，现在我们要重新创建一个表。
class Birthday(models.Model):

    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    date = models.DateField()

    def __str__(self):
        return self.name

# 注意date字段，这个字段要求的是date类型，我们如果存放的是datetime类型也是可以的，只不过只是显示年月日。 
# 接下来我们给表中插入一些数据：
import datetime

    models.Birthday.objects.create(name='太白1', date=datetime.datetime.now())
    models.Birthday.objects.create(name='太白2', date='2000-04-25')
    models.Birthday.objects.create(name='太白3', date='2000-06-25')
    models.Birthday.objects.create(name='太白4', date='2000-08-26')
    models.Birthday.objects.create(name='太白5', date='2000-12-28')
    models.Birthday.objects.create(name='太白6', date='2001-03-26')
    models.Birthday.objects.create(name='太白7', date='2001-08-30')
    models.Birthday.objects.create(name='太白8', date='2003-01-13')
    models.Birthday.objects.create(name='太白9', date='2005-10-01')

# 查询2000年出生的人,这样写就会报错了
query_objs = models.Birthday.objects.filter(date='2000')
 print(query_objs)  
 # "'2000' value has an invalid date format. It must be in YYYY-MM-DD format."]
 
 
 # 查询2000年出生的人
query_objs = models.Birthday.objects.filter(date__year='2000')
print(query_objs)  # <QuerySet [<Birthday: 太白2>, <Birthday: 太白3>, <Birthday: 太白4>, <Birthday: 太白5>]>


# 查询2000年4月出生的人
query_objs = models.Birthday.objects.filter(date__year='2000',date__month='04')
print(query_objs)  # <QuerySet [<Birthday: 太白2>]>


# 查询2000年大于4月小于12月出生的人
query_objs = models.Birthday.objects.filter(date__year='2000', date__month__gt='04',date__month__lt='12')
print(query_objs)  # <QuerySet [<Birthday: 太白3>, <Birthday: 太白4>]>



# 删: 删除行记录
# 从对象性质来区分删除有两种

# 1. 调用model对象删除
# 这样就是删除单条记录
models.Student.objects.get(id=20).delete()


# 2. 调用QuerySet集合删除
# 这样就是批量删除记录,满足条件记录都会被删除
models.Student.objects.filter(age=20).delete()

b = Blog.objects.get(pk=1)
# This will delete the Blog and all of its Entry objects.
b.delete()
# 要注意的是： delete() 方法是 QuerySet 上的方法，但并不适用于 Manager 本身。这是一种保护机制，
# 是为了避免意外地调用 Entry.objects.delete() 方法导致 所有的 记录被误删除。如果你确认要删除所有的对象，那么你必须显式地调用：
Entry.objects.all().delete()

# 如果不想级联删除,可以设置为:
pubHouse = models.ForeignKey(to='Publisher', on_delete=models.SET_NULL, blank=True, null=True)


# 改: 更新行记录
# 更新记录的方法只有一个就是update，此方法只能用于QuerySet集合，model对象是不可以使用的。也就是说update可以进行批量更新的操作，并且他会返回一个更新的行记录数量的返回值。

# 我先增加了一条name一样的行记录 
'''
# models.Student.objects.create(
       name='乔妹儿1',
       age=100    )
'''
count = models.Student.objects.filter(name='乔妹儿1').update(age=20)
print(count)  # 2 更新了2条

# 获取个数
#
# models.Tb1.objects.filter(name='seven').count()

# 大于，小于
# models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
# models.Tb1.objects.filter(id__gte=1)              # 获取id大于等于1的值
# models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
# models.Tb1.objects.filter(id__lte=10)             # 获取id小于10的值
# models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

        # in
# models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
# models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
# isnull
# Entry.objects.filter(pub_date__isnull=True)

# contains
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
# models.Tb1.objects.exclude(name__icontains="ven")

# range
# models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and

# 其他类似
# startswith，istartswith, endswith, iendswith,
# order by
#
# models.Tb1.objects.filter(name='seven').order_by('id')    # asc
# models.Tb1.objects.filter(name='seven').order_by('-id')   # desc

# group by
#
# from django.db.models import Count, Min, Max, Sum
# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

# limit 、offset
# models.Tb1.objects.all()[10:20]

# regex正则匹配，iregex 不区分大小写
# Entry.objects.get(title__regex=r'^(An?|The) +')
# Entry.objects.get(title__iregex=r'^(an?|the) +')

# date
# Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

# year
# Entry.objects.filter(pub_date__year=2005)
# Entry.objects.filter(pub_date__year__gte=2005)

# month
# Entry.objects.filter(pub_date__month=12)
# Entry.objects.filter(pub_date__month__gte=6)

# day
# Entry.objects.filter(pub_date__day=3)
# Entry.objects.filter(pub_date__day__gte=3)

# week_day
# Entry.objects.filter(pub_date__week_day=2)
# Entry.objects.filter(pub_date__week_day__gte=2)

# hour
#
# Event.objects.filter(timestamp__hour=23)
# Event.objects.filter(time__hour=5)
# Event.objects.filter(timestamp__hour__gte=12)

# minute
# Event.objects.filter(timestamp__minute=29)
# Event.objects.filter(time__minute=46)
# Event.objects.filter(timestamp__minute__gte=29)

# second
# Event.objects.filter(timestamp__second=31)
# Event.objects.filter(time__second=2)
# Event.objects.filter(timestamp__second__gte=31)

# extra
#
# extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
# Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
# Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
# Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
# Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])


# from django.db.models import F
# models.Tb1.objects.update(num=F('num')+1)

# Q
# 方式一：
# Q(nid__gt=10)
# Q(nid=8) | Q(nid__gt=10)
# Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
# 方式二：
# con = Q()
# q1 = Q()
# q1.connector = 'OR'
# q1.children.append(('id', 1))
# q1.children.append(('id', 10))
# q1.children.append(('id', 9))
# q2 = Q()
    # q2.connector = 'OR'
    # q2.children.append(('c1', 1))
    # q2.children.append(('c1', 10))
# q2.children.append(('c1', 9))
# con.add(q1, 'AND')
    # con.add(q2, 'AND')

# models.Tb1.objects.filter(con)


# 执行原生SQL
# from django.db import connection, connections
# cursor = connection.cursor()  # cursor = connections['default'].cursor()
# cursor.execute("""SELECT * from auth_user where id = %s""", [1])
# row = cursor.fetchone()

from django.conf.urls import url,include
urlpatterns = [
    url(r'^cmdb/', include("cmdb.urls")),
]

from django.conf.urls import url,include
from cmdb import views
urlpatterns = [
    url(r'^business',views.business),
]

from django.db import models
class Business(models.Model):
    caption = models.CharField(max_length=32)
    code = models.CharField(max_length=32,default='PASS')

class Host(models.Model):
    nid = models.AutoField(primary_key=True)
    hostname = models.CharField(max_length=32,db_index=True)
    ip = models.GenericIPAddressField(protocol="ipv4",db_index=True)
    port = models.IntegerField()
    b = models.ForeignKey(to="Business", to_field='id',on_delete=models.CASCADE,)

from django.shortcuts import render,HttpResponse,redirect
from cmdb import models

def business(request):
    v1 = models.Business.objects.all()
    v2 = models.Business.objects.all().values('id','caption')
    v3 = models.Business.objects.all().values_list('id','caption')
    return render(request, 'business.html', {'v1': v1,'v2': v2, 'v3': v3})

def host(request):
    v4 = models.Host.objects.filter(nid__gt=0)
    for row in v4:
        print(row.nid,row.hostname,row.ip,row.port,row.b_id,row.b.caption,row.b.code,sep="t")
        # print(row.b.fk.name)
    # return HttpResponse('host')
    return render(request,'host.html',{'v4':v4})

# 外键通过`.`进行跨表
# `__`也能跨表

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    <h1>业务线列表(对象)</h1>
    <ul>
        {% for row in v1 %}
            <li>{{ row.id }} - {{ row.caption }} - {{ row.code }}</li>
        {% endfor %}
    </ul>
    <h1>业务线列表（字典）</h1>
    <ul>
        {% for row in v2 %}
            <li>{{ row.id }} - {{ row.caption }}</li>
        {% endfor %}
    </ul>
    <h1>业务线列表（元组）</h1>
    <ul>
        {% for row in v3 %}
            <li>{{ row.0 }} - {{ row.1 }}</li>
        {% endfor %}
    </ul>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>业务线列表(对象)</h1>
<table border="">
    <thead>
    <tr>
        <th>主机名</th>
        <th>IP</th>
        <th>端口</th>
        <th>业务线名称</th>
    </tr>
    </thead>
<tbody>
{% for row in v4 %}
    <tr bid="{{ row.nid }}" bid="{{ row.b_id }}">
        <td>{{ row.hostname }}</td>
        <td>{{ row.ip }}</td>
        <td>{{ row.port }}</td>
        <td>{{ row.b.caption }}</td>
    </tr>
{% endfor %}
</tbody>
</table>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .hide{
            display: none;
        }
        .shade{
            position: fixed;
            top: 0;
            right: 0;
            left: 0;
            bottom: 0;
            background: black;
            opacity: 0.6;
            z-index: 100;
        }
        .add_model{
            position: fixed;
            height: 300px;
            width: 500px;
            top: 100px;
            left: 50%;
            z-index: 111;
            border: 1px solid red;
            background-color: blanchedalmond;
            margin-left: -270px;
        }
    </style>

</head>
<body>
<h1>业务线列表(对象)</h1>
<div>
    <input id="add_host" type="button" value="添加" />
</div>
<table border="1">
    <thead>
    <tr>
        <th>主机名</th>
        <th>IP</th>
        <th>端口</th>
        <th>业务线名称</th>
        <th>序号</th>
    </tr>
    </thead>
<tbody>
{% for row in v4 %}
    <tr bid="{{ row.nid }}",bid="{{ row.b_id }}">
        <td>{{ forloop.counter }}</td>
        <td>{{ row.hostname }}</td>
        <td>{{ row.ip }}</td>
        <td>{{ row.port }}</td>
        <td>{{ row.b.caption }}</td>
    </tr>
{% endfor %}
</tbody>
</table>
<div class="shade hide"></div>
<div class="add_mode hide ">
    <div class="group">
        <input type="text" placeholder="主机名" name="hostname" />
    </div>

    <div class="group">
        <input type="text" placeholder="IP" name="ip" />
    </div>

    <div class="group">
        <input type="text" placeholder="端口" name="port" />
    </div>

    <div class="group">
        <select>业务线一</select>
        <select>业务线二</select>
        <select>业务线三</select>
        <select>业务线四</select>
    </div>

    <input type="submit" value="提交" />
    <input type="submit" value="取消" />
</div>

<script src="/static/jquery-1.12.4.js"></script>
<script>
    $(function () {
        $('#add_host').click(function () {
            $(".shade,.add_model").removeClass('hide');
        })
    })
</script>
</body>
</html>

from django.db import models


class Author(models.Model): #比较常用的信息放到这个表里面
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    age=models.IntegerField()

    # 与AuthorDetail建立一对一的关系，一对一的这个关系字段写在两个表的任意一个表里面都可以
    authorDetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE)
    #就是foreignkey+unique，只不过不需要我们自己来写参数了，并且orm会自动帮你给这个字段名字拼上一个_id，数据库中字段名称为authorDetail_id

class AuthorDetail(models.Model):#不常用的放到这个表里面

    nid = models.AutoField(primary_key=True)
    birthday=models.DateField()
    telephone=models.BigIntegerField()
    addr=models.CharField( max_length=64)

class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    city=models.CharField( max_length=32)
    email=models.EmailField()

# 多对多的表关系，mysql的时候是怎么建立的，是不是手动创建一个第三张表，然后写上两个字段，每个字段外键关联到另外两张多对多关系的表，orm的manytomany自动帮我们创建第三张表，两种方式建立关系都可以，以后的学习我们暂时用orm自动创建的第三张表，因为手动创建的第三张表我们进行orm操作的时候，很多关于多对多关系的表之间的orm语句方法无法使用
#如果你想删除某张表，你只需要将这个表注销掉，然后执行那两个数据库同步指令就可以了，自动就删除了。
class Book(models.Model):

    nid = models.AutoField(primary_key=True)
    title = models.CharField( max_length=32)
    publishDate=models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2)

    # 与Publish建立一对多的关系,外键字段建立在多的一方，字段publish如果是外键字段，那么它自动是int类型
    publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE) #foreignkey里面可以加很多的参数，都是需要咱们学习的，慢慢来，to指向表，to_field指向你关联的字段，不写这个，
    # 默认会自动关联主键字段，on_delete级联删除字段名称不需要写成publish_id，orm在翻译foreignkey的时候会自动给你这个字段拼上一个_id,
    # 这个字段名称在数据库里面就自动变成了publish_id
    # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表，
    # 并且注意一点，你查看book表的时候，你看不到这个字段，因为这个字段就是创建第三张表的意思，不是创建字段的意思，
    # 所以只能说这个book类里面有authors这个字段属性
    authors=models.ManyToManyField(to='Author',)
    # 注意不管是一对多还是多对多，写to这个参数的时候，最后后面的值是个字符串，不然你就需要将你要关联的那个表放到这个表的上面

class UserInfo(models.Model):
    name = models.CharField(max_length=16)
    password = models.CharField(max_length=20)

class Student(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    age = models.IntegerField()

class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")


class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者姓名")


# 自己创建第三张表，分别通过外键关联书和作者
class Author2Book(models.Model):
    author = models.ForeignKey(to="Author")
    book = models.ForeignKey(to="Book")

    class Meta:
        unique_together = ("author", "book")

class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")


# 通过ORM自带的ManyToManyField自动创建第三张表
class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者姓名")
    books = models.ManyToManyField(to="Book", related_name="authors")  #自动生成的第三张表我们是没有办法添加其他字段的

class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")


# 自己创建第三张表，并通过ManyToManyField指定关联
class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者姓名")
    books = models.ManyToManyField(to="Book", through="Author2Book", through_fields=("author", "book"))
    # through_fields接受一个2元组（'field1'，'field2'）：
    # 其中field1是定义ManyToManyField的模型外键的名（author），field2是关联目标模型（book）的外键名。


class Author2Book(models.Model):
    author = models.ForeignKey(to="Author")
    book = models.ForeignKey(to="Book")
    #可以扩展其他的字段了
    class Meta:
        unique_together = ("author", "book")

# 当我们需要在第三张关系表中存储额外的字段时，就要使用第三种方式，第三种方式还是可以使用多对多关联关系操作的接口（all、add、clear等等）

# 当我们使用第一种方式创建多对多关联关系时，就无法使用orm提供的set、add、remove、clear方法来管理多对多的关系了。

to
    设置要关联的表。

to_field
    设置要关联的字段。
    
on_delete
    同ForeignKey字段。

创建一对一关系字段时的一些参数

to
    设置要关联的表

to_field
    设置要关联的表的字段

related_name
    反向操作时，使用的字段名，用于代替原反向查询时的'表名_set'。
related_query_name
    反向查询操作时，使用的连接前缀，用于替换表名。

on_delete
    当删除关联表中的数据时，当前表与其关联的行的行为。

创建一对多关系字段时的一些参数

多对多的参数：
    to
        设置要关联的表

    related_name
        同ForeignKey字段。

    related_query_name
        同ForeignKey字段。
    through
        在使用ManyToManyField字段时，Django将自动生成一张表来管理多对多的关联关系。

        但我们也可以手动创建第三张表来管理多对多关系，此时就需要通过        
    through来指定第三张表的表名。

    through_fields
        设置关联的字段。

    db_table
        默认创建第三张表时，数据库中表的名称。            

创建多对多字段时的一些参数

元信息
    ORM对应的类里面包含另一个Meta类，而Meta类封装了一些数据库的信息。主要字段如下:
class Author2Book(models.Model):
    author = models.ForeignKey(to="Author")
    book = models.ForeignKey(to="Book")
    class Meta:
        unique_together = ("author", "book")

db_table
    ORM在数据库中的表名默认是 app_类名，可以通过db_table可以重写表名。db_table = 'book_model'

index_together
    联合索引。

unique_together
    联合唯一索引。

ordering
    指定默认按什么字段排序。
    ordering = ['pub_date',]
    只有设置了该属性，我们查询到的结果才可以被reverse()，否则是能对排序了的结果进行反转(order_by()方法排序过的数据)

创建表时的一些元信息设置

1.指定字段名： 在定义字段的时候，增加参数db_column=’real_field’； 

2.指定表名： 在model的class中，添加Meta类，在Meta类中指定表名db_table 
# 例如在某个models.py文件中，有一个类叫Info:


class Info(models.Model):  
    ''''' 
            信息统计 
    '''  
    app_id = models.ForeignKey(App)  
    app_name = models.CharField(verbose_name='应用名',  max_length=32, db_column='app_name2')  
  
    class Meta:  
        db_table = 'info'  
        verbose_name = '信息统计'  
        verbose_name_plural = '信息统计'

# 其中db_column指定了对应的字段名，db_table指定了对应的表明； 

# 如果不这样指定，字段名默认为app_name， 而表明默认为app名+类名： [app_name]_info.

# verbose_name指定在admin管理界面中显示中文；verbose_name表示单数形式的显示，verbose_name_plural表示复数形式的显示；中文的单数和复数一般不作区别。

# 创建完这个表，我们自己可以通过navicat工具来看看数据库里面的那些表，出版社这个表里面没有任何的关系字段，
# 这种单表的数据，我们可以先添加几条数据，在进行下面的增删改查的操作。

# 生成表如下：

# 表的名称myapp_modelName，是根据 模型中的元数据自动生成的，也可以覆写为别的名称　　
# id 字段是自动添加的
# 对于外键字段，Django 会在字段名上添加"_id" 来创建数据库中的列名
# 这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。
# 定义好模型之后，你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加models.py所在应用的名称。
# 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL)，你可以赋给它空值 None 。
# 咱们的表里面包含了一对一、一对多、多对多的关系，我们基于这几个表来练习，将来无论有多少张表，都逃脱不了这三个关系，操作起来都是一样的。

on_delete
当删除关联表中的数据时，当前表与其关联的行的行为。

models.CASCADE
删除关联数据，与之关联也删除


models.DO_NOTHING
删除关联数据，引发错误IntegrityError


models.PROTECT
删除关联数据，引发错误ProtectedError


models.SET_NULL
删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）


models.SET_DEFAULT
删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）


models.SET

删除关联数据，
a. 与之关联的值设置为指定值，设置：models.SET(值)
b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)


# ForeignKey的db_contraint参数

关系和约束大家要搞清楚，我不加外键能不能表示两个表之间的关系啊，当然可以

但是我们就不能使用ORM外键相关的方法了，所以我们单纯的将外键换成一个其他字段类型，只是单纯的存着另外一个关联表的主键值是不能使用ORM外键方法的。

#db_constraint=False只加两者的关系，没有强制约束的效果，并且ORM外键相关的接口(方法)还能使用，所以如果将来公司让你建立外键，并且不能有强制的约束关系，那么就可以将这个参数改为False
    customer = models.ForeignKey(verbose_name='关联客户', to='Customer',db_constraint=False)