Django入门

py3study

发布于 2020-02-10 22:40:14

2.1K0

发布于 2020-02-10 22:40:14

文章被收录于专栏：python3python3

一、http协议

http协议即：Hyper Text Transfer Protocol（超文本传输协议），于1990年提出，是用于万维网(World Wide Web)服务器与本地浏览器之间传输超文本的传送协议

1.1 http协议的特性

基于TCP/IP协议之上的应用层协议
基于请求-响应模式 HTTP协议规定，请求从客户端发出，最后服务器端响应该请求并返回。换句话说，肯定是先从客户端开始建立通信的，服务器端在没有接收到请求之前不会发送响应
无状态保存 HTTP是一种不保存状态，即无状态(stateless)协议。HTTP协议自身不对请求和响应之间的通信状态进行保存。也就是说在HTTP这个级别，协议对于发送过的请求或响应都不做持久化处理。
无连接 无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。

二、http请求协议与响应协议

2.1 请求协议

请求格式

请求方式：get与post请求

2.2 响应协议

响应格式

响应状态码
- 状态码的值是当客户端向服务器端发送请求时，返回的请求结果。借助状态码，用户可以知道服务器端是正常处理了请求，还是出错了。状态码如200 OK，以3位数字和字母组成。数字中的第一位指定了响应级别。响应级别有以下5种。

三、MVC与MTV

MVC
- M代表模型（Model）：负责业务对象与数据库的映射
- V代表视图（View）：负责与用户交互（页面）
- C代表控制器（Controller）：接收用户的输入，调用模型和视图完成用户的请求
MTV
- M代表模型(Model)：负责业务对象和数据库的关系映射(ORM)
- T代表模板(Template)：负责如何将页面展示给用户(html)
- V代表视图(View)：负责业务逻辑，并在适当时候调用Model和Template

一般是用户通过浏览器向服务器发送一个请求（request），首先会去访问视图函数，如果不涉及数据的调用（那么这个时候视图函数返回一个模板，也就是你一个网页给用户），视图函数调用模型，模型去数据库查找数据，然后逐级返回，视图函数把返回的数据填充到模板的空格中，最后返回网页给用户

四、Django的基本命令

下载
- cmd命令行：pip3 install django,或可以指定版本号下载：pip3 install django==1.11.9
- 用pycharm进行安装
创建一个django project

django-admin startproject 项目名 　　# windows命令

python manage.py startapp app名　　# Windows命令

启动django项目

python manage.py runserver 8000
python manage.py runserver 127.0.0.1：8000

然后用浏览器去访问127.0.0.1:8000就OK了

五、settings的配置

5.1 静态文件的配置

STATIC_URL = '/static/'

# 创建一个static文件夹
STATICFILES_DIRS = [
　　　　# 将static文件夹拼接到根目录下
　　　　os.path.join(BASE_DIR, 'static'),
　　]

方法一：用static标签函数
{% load static %}
<img src="{% static "images/aa.jpg" %}"/>
或者上面也可这样写
{% load static %}
{% static "images/aa.jpg" as photo %}
<img src="{{ photo }}"/>

方法二：用get_static_prefix标签,它返回的就是/static/
{% load static %}
<img src="{% get_static_prefix %}images/aa.jpg"/>

同样也可以定以为一个易用的变量
{% load static %}
{% get_static_prefix as photo %}

<img src="{{ photo }}images/aa.jpg" />

5.2 模板路径的配置（新建templates文件夹后）

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',
            ],
        },
    },
]

5.3 logging日志的配置（将SQL语句打印到控制台）

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

eg：实现登录功能

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <link rel="stylesheet" href="../static/bootstrap-3.3.7/css/bootstrap.css">
    <link rel="stylesheet" href="../static/css/style.css">
    <title>login</title>
</head>
<body>
<h1>登录</h1>
<div class="col-md-6 col-md-offset-3">
    <form action="/login/" method="post">
        <p>user:<input type="text" name="name" class="form-control"></p>
        <p>password:<input type="password" name="pwd" class="form-control"></p>
        <input type="submit" value="提交">
    </form>
</div>
</body>
</html>

templates----login.html

from django.shortcuts import render, HttpResponse
import pymysql
from login import models


# Create your views here.
def login(request):
    # print('login')
    if request.method == 'GET':
        return render(request, 'login.html')
    elif request.method == 'POST':
        print(request.POST)
        # 从POST拿到name和pwd
        name = request.POST.get('name')
        pwd = request.POST.get('pwd')

        # 一、用 pymysql 连接数据库
        conn = pymysql.connect(host='127.0.0.1', port=3306, db='user_info', user='root', password='95500')
        cur = conn.cursor()
        cur.execute('select * from user where name = %s and passwoed = %s', [name, pwd])
        user = cur.fetchone()

        # 二、通过 orm 用 pycharm 连接数据库
        # user = models.User.objects.filter(name=name,pwd=pwd).first()
        if user:
            return HttpResponse('successful')
        else:
            return HttpResponse('wrong')

# 为了避免程序报错，在settings里找到MIDDLEWARE将中间的第四行注释掉

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',
]

六、python中连接MySQL

import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', db='test', password=95500)
# connect --> __init__.py(Connect) --> connections.py(Connection的__init__方法)
'''
def __init__(self, host=None, user=None, password="",
                 database=None, port=0, unix_socket=None,
                 charset='', sql_mode=None,
                 read_default_file=None, conv=None, use_unicode=None,
                 client_flag=0, cursorclass=Cursor, init_command=None,
                 connect_timeout=10, ssl=None, read_default_group=None,
                 compress=None, named_pipe=None,
                 autocommit=False, db=None, passwd=None, local_infile=False,
                 max_allowed_packet=16*1024*1024, defer_connect=False,
                 auth_plugin_map=None, read_timeout=None, write_timeout=None,
                 bind_address=None, binary_prefix=False, program_name=None,
                 server_public_key=None):
'''
# pymysql.cursors.DictCursor 拿到的是字典类型
cour = conn.cursor(pymysql.cursors.DictCursor)
# 要查询的SQL语句
cour.execute('select * from user')
dic = cour.fetchall()
# dic = cour.fetchone()
print(dic)

七、orm

orm：即对象关系映射(object relational mapping)

orm的使用：

连接mysql需要在settings里对DATABASES进行配置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'HOST': '127.0.0.1',
        'PORT': 3306,
        'USER': 'root',
        'PASSWORD': '95500',
        'NAME': 'user_info', # 需要自己手动创建数据库
    }
}

注意：Django的orm不会自动创建数据库，但可以创建数据表和字段

在你的app目录下的__init__.py里写上：

import pymysql

# 替换为pymysql
pymysql.install_as_MySQLdb()

然后在models里创建一个类，继承models.Model

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

# 创建字段
class User(models.Model):
    # 自增int类型
    id = models.AutoField(primary_key=True)

    # name,pwd 是一个 varcher 类型,长度为32
    name = models.CharField(max_length=32)
    pwd = models.CharField(max_length=32)

数据库的迁移操作，在cmd中输入以下命令

python3 manage.py makemigrations   ---- # 会在migrations文件夹下自动生成0001_initial.py目录，记录数据库的变化

python3 manage.py migrate          ---- # 将变化同步到数据库中

其中带有 app名_类名 的就是我们所创建的表，eg：login_user

八、orm操作数据库

name = models.CharField(max_length=32, [default=''])
# 需要注意的是，后来添加的字段需要手动添加默认值
# 方法1. models.py中创建字段时直接在后面添加一个默认值，default='值'
# 方法2. 在输入数据迁移的第一个命令时，选择1，然后键入一个str类型的值

id = models.AutoField(primary_key=True)

# 删除时可直接删除掉该字段，或注释，如：
# name = models.CharField(max_length=32)

name = models.CharField(max_length=32)

# 直接修改需要的字段即可，如：
names = models.CharField(max_length=64)

用orm实现对用户信息的操作

from django.shortcuts import render, redirect
from firstapp.models import *


# Create your views here.
def check(request):
    if request.method == 'GET':
        info = Info.objects.all()
        return render(request, 'check.html', {'user_info': info})


def delete_info(request):
    if request.method == 'GET':
        id = request.GET.get('id')
        Info.objects.filter(id=id).delete()
        return redirect('/check/')


def update_info(request):
    if request.method == 'GET':
        id = request.GET.get('id')
        res = Info.objects.filter(id=id).first()
        return render(request, 'update_info.html', {'user': res})

    if request.method == 'POST':
        id = request.GET.get('id')
        name = request.POST.get('name')
        password = request.POST.get('password')
        address = request.POST.get('address')

        Info.objects.filter(id=id).update(name=name, password=password, address=address)
        return redirect('/check/')


def add_info(request):
    if request.method == 'GET':
        return render(request, 'add_info.html')

    if request.method == 'POST':
        name = request.POST.get('name')
        password = request.POST.get('password')
        address = request.POST.get('address')
        Info.objects.create(name=name, password=password, address=address)
        return redirect('/check/')

user（项目名）\firstapp（app名）\views.py

from django.db import models


# Create your models here.
class Info(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=64)
    password = models.CharField(max_length=64)
    address = models.CharField(max_length=64)

user\firstapp\models.py

import pymysql
pymysql.install_as_MySQLdb()

user\firstapp\__init__.py

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>add_info</title>
</head>
<body>
<form action="" method="post">
    <p>name:<input type="text" name="name"></p>
    <p>passwd:<input type="password" name="password"></p>
    <p>address:<input type="text" name="address"></p>
    <p><input type="submit" value="提交"></p>
</form>
</body>
</html>

user\templates\add_info.html

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <title>check</title>
    <link rel="stylesheet" href="../static/bootstrap-3.3.7/css/bootstrap.css">
</head>
<body>
<table border="2" class="col-md-4 col-md-offset-4">
    <thead>
    <tr>
        <th>id</th>
        <th>name</th>
        <th>password</th>
        <th>address</th>
        <th>操作</th>
        <th>编辑</th>
    </tr>
    </thead>
    <tbody>
        {% for user in user_info %}
        <tr>
        <td>{{ user.id }}</td>
        <td>{{ user.name }}</td>
        <td>{{ user.password }}</td>
        <td>{{ user.address }}</td>
        <td><a href="/delete_info/?id={{ user.id }}">delete</a></td>
        <td><a href="/update_info/?id={{ user.id }}">update</a></td>
        </tr>
        {% endfor %}
    </tbody>
</table>
<button><a href="/add_info/">add</a></button>
</body>
</html>

user\templates\check.html

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <title>update</title>
</head>
<body>
<form action="/update_info/?id={{ user.id }}" method="post">
    <p>name:<input type="text" name="name" value="{{ user.name }}"></p>
    <p>passwd:<input type="text" name="password" value="{{ user.password }}"></p>
    <p>address:<input type="text" name="address" value="{{ user.address }}"></p>
    <p><input type="submit" value="提交"></p>
</form>
</body>
</html>

user\templates\update_info.html

"""
Django settings for user project.

Generated by 'django-admin startproject' using Django 1.11.9.

For more information on this file, see
https://docs.djangoproject.com/en/1.11/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.11/ref/settings/
"""

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 = 'm&6g#c(w#9cbv*sh04**-cda^(=*oc51k9%0xm#gkay)1a2hz)'

# 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',
    'firstapp.apps.FirstappConfig',
]

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 = 'user.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 = 'user.wsgi.application'


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

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


# 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, 'static')
]

user\user\settings.py

"""user URL Configuration

The `urlpatterns` list routes URLs to views. For more information please see:
    https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
    1. Add an import:  from my_app import views
    2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
Class-based views
    1. Add an import:  from other_app.views import Home
    2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
Including another URLconf
    1. Import the include() function: from django.conf.urls import url, include
    2. Add a URL to urlpatterns:  url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin
from firstapp import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^check/', views.check),
    url(r'^delete_info/', views.delete_info),
    url(r'^update_info/', views.update_info),
    url(r'^add_info/', views.add_info),
]

user\user\urls.py

用户信息的增删改查重点

# 1 单表查询所有用户:
    models.User.objects.all()
    # 得到的是 queryset对象(当成列表),列表里面,一个一个的对象[user1,user2]
# 2. render的三个参数
    render(request, 'userlist.html', {'user_list': ret})
# 3 for循环模板: 
    {%for user in user_list %}
        # 要循环的内容    
        {{user.name}}
    {% endfor %}
# 4 get请求携带参数:
    http://127.0.0.1:8000/deleteuser/?id = 1
# 后台取值方法:
    request.GET.get('id')  # 推荐使用该方法
    request.GET['id']
# 5 orm删除记录 
    models.User.objects.filter(id=id).delete()
    # 返回值:影响的行数
# 6 前台post提交的数据取值:
    name = request.POST.get('name')
# 7 orm保存的两种方式:
    #方法1
        user = models.User.objects.create(name=name, password=pwd, address=addr)
    #方法2
        user = models.User(name=name, password=pwd, address=addr)
        user.save()
# 8 orm查询单条数据:
    user = models.User.objects.filter(id=id).first()  # 取出的是第一条数据
# 9 orm的修改 
    models.User.objects.filter(id=id).update(name=name, password=pwd, address=addr)

九、Django的路由控制

9.1 URL配置

其本质就是URL与要为该URL调用的视图函数之间的映射关系

from django.conf.urls import url
from django.contrib import admin
from author import views

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

# 其中 ^author/$ 这个路由对应的就是 views.author 这个函数的内存地址，在浏览器输入该路由，就会响应到这个函数，而通过Django内部就可以调用该函数执行其逻辑代码

'''
url(正则表达式, views视图函数, 参数, 别名)
　　参数：可选，字典形式
　　别名：可选，name=''
'''

9.2 有名分组

无名分组
- 没有命名的正则表达式组，通过()来捕获URL中的值，分组之后,会把分组出来的数据,当位置参数,传到视图函数,所以,视图函数需要定义形参

from django.urls import path,re_path
from app01 import views

urlpatterns = [
    re_path(r'^articles/2003/$', views.special_case_2003),
    re_path(r'^articles/([0-9]{4})/$', views.year_archive),
    re_path(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
    re_path(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
]

有名分组语法

(?P<name>pattern)
# 其中name为组的名称，pattern为匹配的模式
from django.conf.urls import url
from app01 import views

urlpatterns = [
    url(r'^articles/2003/$', views.special_case_2003),
    url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
    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),
]

#捕获到的数据都是str类型
#视图函数里可以指定默认值

url('blog/$', views.blog),
url('blog/?(?P<num>[0-9]{1})', views.blog),
def blog(request,num=1):
    print(num)
    return HttpResponse('ok')

9.3 路由分发

# 总路由的配置
from django.conf.urls import include
url(r'^book/',include('book.urls'))
url(r'^author/',include('author.urls'))
# 注意点：正则后面不能加$符号，不然匹配不到分发之后的路由

# 在book的app的urls里配置路由关系
from django.conf.urls import url
from book import views

urlpatterns = [
    url(r'^book/$', views.book),
    url(r'^delete/$', views.delete_book),
    url(r'^add/$', views.add_book),
]

# 在author的app的urls里配置路由关系
from django.conf.urls import url
from author import views

urlpatterns = [
    url(r'^author/$', views.author),
    url(r'^delete/$', views.delete_author),
    url(r'^update/$', views.update_author),
    url(r'^add/$', views.add_author),
]

View Code

9.4 反向解析

在urls中先命名

# 无参数：
    url('r^book/$', views.add_book, name='add')
# 带参数时：
    # 无名分组
    url(r'^book/([0-9]{4})/([0-9]{2})/$', views.add_book,name='add')
    # 有名分组
    url(r'^book/(?P<year>[0-9]{4})/(?P<mounth>[0-9]{2})/$', views.add_book,name='add')

在模板层

# 无参数
    {% url 'add' %}

# 带参数：
    # 无名分组：
    {% url 'add' 2018 11 %}

    # 有名分组：
    {% url 'add' 2018 11 %} # 位置参数

    # 有名分组：
    {% url 'add' year=2018 month=11 %} # 关键字参数

在视图层

from django.shortcuts import reverse

# 在视图层的函数中
# 无参数时：
    url = reverse('add')
# 带参数时：
    # 无名分组：
    url = reverse('add',args=(2018,11,))
    # 有名分组(位置参数)：
    url = reverse('add',args=(2018,11,))  
    # 有名分组(关键字参数)：
    url = reverse('add',kwargs={'year':2018, 'month':11})

9.5 伪静态

# 路由
url(r'^book/(?P<id>\d+.html)',views.book)
# 访问
http://127.0.0.1:8000/book/1.html

9.6 django 2.x和 1.x 路由层的区别

re_path：跟1.X 的url用法相同(url,re_path分组分出来的数据,是字符串)

path:传的路径一定是准确路径
path 的5个转换器

eg：path('test/<path:year>', views.re_test),

str,   # 匹配除了路径分隔符（/）之外的非空字符串，这是默认的形式
int,   # 匹配正整数，包含0。
slug,  # 匹配字母、数字以及横杠、下划线组成的字符串。
uuid,  # 匹配格式化的uuid，如 075194d3-6885-417e-a8a8-6c931e272f00。
path,  # 匹配任何非空字符串，包含了路径分隔符（/）（不能用？）

自定义转换器

# 1、定义一个类
class MyCon:
    # 写一个正则表达式
    regex = '[0-9]{4}'
    # 匹配出來的数据,会传到这里,retrun回去的,会被视图函数接收
    def to_python(self, value):
        return int(value)
    # 反向解析用的
    def to_url(self, value):
        return '%04d' % value
# 2、导入模块
from django.urls import register_converter
register_converter(MyCon,'yyy')
# 3、使用
path('test/<yyy:year>', views.re_test,name='test')

补充：settings设置

APPEND_SLASH=False
# 为假,不会加反斜杠

十、视图层

补充：return render(request, 'index.html', {'name': user})

可以将第三个参数（字典）写做locals()，它能将当前视图函数的所有变量传到模板中

return render(request, 'index.html', locals())

视图层之HttpRequest对象

request.POST    # 前台Post传过来的数据,包装到POST字典中

request.GET     # 前台浏览器窗口里携带的数据,包装到GET字典中

request.method  # 前台请求的方式

request.body    # post提交的数据,body体的内容,前台会封装成:name=lqz&age=18&sex=1

print(request.path) # 取出请求的路径,取不到数据部分

print(request.get_full_path())  # 取出请求的路径,能取到数据部分
print(request.META)

视图层之HttpResponse对象

# 三件套:
render,HttpResponse,redirect
# render函数:
temp=Template('<h1>{{ user }}</h1>')
con=Context({'user':'lqz'})
ret=temp.render(con)
print(ret)
# return render(request,'index.html')
return HttpResponse(ret)

视图层之JsonResponse对象

# -导入:
from django.http import JsonResponse
# -视图函数中:
def test(request):
    import json
    dic={'name':'lqz','age':18}
    ll = ['name', 'age']
    # 把字典转换成json格式,返回到前台
    return HttpResponse(json.dumps(dic))

    # 把列表转换成json格式,返回到前台
    return HttpResponse(json.dumps(ll))

    # 把字典转换成json格式,返回到前台
    return JsonResponse(dic)

    # 报错,默认不支持列表形式
    return JsonResponse(ll)

    # 支持列表形式
    return JsonResponse(ll,safe=False)

CBV和FBV

CBV：基于类的视图

# -1 路由层
url(r'^test/', views.Test.as_view())
# -2 视图层
from django.views import View
# -写一个类:
class Test(View):
    def get(self, request): #一定要传request对象
        return HttpResponse('get-test')

    def post(self, request):
        return HttpResponse('post-test')

FBV：基于函数的视图

十一、模板层

语法

变量：{{ 变量名 }}
	深度查询，用句点符号
        过滤器
标签：{% %}

注意点：{{变量名}} 相当于print了该变量

11.1 过滤器

语法：{{args1|过滤器名字:args2}}
常用过滤器

# length		统计长度
# default		默认值
{{ l1|default:'12345' }}	# l1为空列表，默认值为12345
{{ 'abcd'|default:'12345' }} # abcd

# slice	切分，可指定步长
{{'abcdefg'|slice:'0:3:2'}}		# aceg

# date	使用date可以指定时间的格式，如：
#views.py中
import datetime
ctim=datetime.datetime.now()

# index.html中
{{ ctim }}	# Nov. 11, 2018, 10:30 a.m.
{{ ctim|date:'Y-m-d' }}	# 2018-11-11
{{ ctim|date }}	# Nov. 11, 2018

# filessizeformat	可以将文件大小转换成KB、MB、GB、TB、PB等，方便计算

# truncatechars	一个参数，最少3位字符，剩余用...代替
{{ 'dafddfafgadfgaasdgadgfadaf'|truncatechars:5 }}	# da...

# truncatewords	一个参数，指定长度，取出的是单词的个数
{{ '我 dfaf ga dfgaas 你 dgf adaf'|truncatewords:3 }}	# 我 dfaf ga...

# safe 	使用safe会将HTML标签解析，不使用则不会解析HTML标签

# add		字符串拼接,加法运算

11.2 标签

语法：{% 标签名 %}
for标签

# views.py
info = [
        {'name': 'jack', 'age': 18},
        {'name': 'bob', 'age': 19},
        {'name': 'peter', 'age': 20},
        {'name': 'zero', 'age': 23}
    ]

遍历每个元素

<table border="1">
    {% for foo in info %}
        <tr>
            <td>{{ foo.name }}</td>
            <td>{{ foo.age }}</td>
        </tr>
    {% endfor %}
</table>

当需要循环显示序号时，可以通过｛｛forloop｝｝

forloop.counter            The current iteration of the loop (1-indexed) 当前循环的索引值（从1开始）
forloop.counter0           The current iteration of the loop (0-indexed) 当前循环的索引值（从0开始）
forloop.revcounter         The number of iterations from the end of the loop (1-indexed) 当前循环的倒序索引值（从1开始）
forloop.revcounter0        The number of iterations from the end of the loop (0-indexed) 当前循环的倒序索引值（从0开始）
forloop.first              True if this is the first time through the loop 当前循环是不是第一次循环（布尔值）
forloop.last               True if this is the last time through the loop 当前循环是不是最后一次循环（布尔值）
forloop.parentloop         本层循环的外层循环

for...empty

for 标签带有一个可选的{% empty %} 从句，以便在给出的组是空的或者没有被找到时，可以有所操作，执行empty之后的语句

{# 循环的对象是空,才会走到empty,而不是对象里面的东西为空 #}
{% for foo in dic %}    {# dic为空字典 #}
    <p>{{ foo }}</p>
    {% empty %}
    傻逼了
{% endfor %}
{# 傻逼了 #}

if标签

{% if %}会对一个变量求值，如果它的值是“True”（存在、不为空、且不是boolean类型的false值），对应的内容块会输出，False时则不会输出

{# num=56 #}

{% if num > 100 or num < 0 %}
    <p>错误</p>
{% elif num > 80 and num < 100 %}
    <p>牛逼</p>
{% elif num > 60 %}
    <p>不错哦</p>
{% else %}
    <p>垃圾</p>
{% endif %}

{# 垃圾 #}

if语句同样支持 and 、or、==、>、<、!=、<=、>=、in、not in、is、is not等逻辑运算判断。

with标签

可以为变量起别名

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}
 
{# 或者可写成 with...as... #}
{% with business.employees.count as total %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

csrf_token标签

{% csrf_token %}

该标签用于跨站请求伪造保护

11.3 自定义标签与过滤器

在app中创建templatetags模块
创建一个py文件，如：my_tag.py
在my_tag.py 中导入 Library

# 第一步,导入template
from django.template import Library

# 第二步,定义一个叫register的变量=Library()
register = Library()


# 第三步
# 自定义过滤器
@register.filter(name='ad')　　# name可以为定义的函数起别名，.filter是规定写法
def str_add(str1, str2):
    # 业务逻辑很复杂
    return str1 + str2


# 自定义标签
@register.simple_tag()
def add_nb(args1, ...):
    return args1 + 'nb'

模板中使用时，先导入自定义的标签或过滤器（注意：都需要重启服务）

{% load mytag %}
{#传多个参数的话可以:'aaa:bb:cc'然后切分开,也可以传列表#}
<p>{{ 'jack'|ad:'nb' }}</p>
{# jacknb #}

<p>{% add_nb 'peter' %}</p>
{# peternb #}

注意点：
过滤器,可以用在if判断中使用
{% if 'lqz'|ad:'nb' %}
    <p>肯定是True</p>
{% endif %}
标签不能用在if判断(会报错)
{#{% if add_nb 'egon' %}#}
{#    #}
{#{% endif %}#}

11.4 自定义 inclusion_tag

在app下创建一个templatetags的python包
在包中创建一个py文件
编辑文件
- from django import template
- register = template.Library()
定义参数
- 可以接受参数，并返回一个字典
函数头上加装饰器
- @register.inclusion_tag('模板页面')
函数将返回的字典交给模板页面渲染
渲染完成之后交给视图然后返回给用户展示

运行结果如下：

十二、模板的导入与继承

模板的导入

在需要导入的HTML文件中用关键字 include 导入预先写好的HTML文件即可

{% include 模板名 %}  如：{% include 'index.html' %}

模板的继承

子模板可以继承（extends）母板的框架，子模板会覆盖掉父模板的内容，也可以重用（supper）母板中的内容

// 写在 {% block 模板名 %}和{% endblock %}之间的才能够被继承
如：base.html（这是个母板）
{% block sidebar %}
    <ul>
        <li><a href="/">Home</a></li>
        <li><a href="/blog/">Blog</a></li>
    </ul>
{% endblock %}

// 继承上面的母板
{% extends "base.html" %}

// 重用母板的内容
{{ block.super }}
如：
{% block sidebar %}
{{ block.super }}   

{% endblock %}

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2019-04-01 ，如有侵权请联系 cloudcommunity@tencent.com 删除

python

html

django

http

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

Django入门

Django入门

一、http协议

1.1 http协议的特性

二、http请求协议与响应协议

2.1 请求协议

2.2 响应协议

三、MVC与MTV

四、Django的基本命令

五、settings的配置

5.1 静态文件的配置

5.2 模板路径的配置（新建templates文件夹后）

5.3 logging日志的配置（将SQL语句打印到控制台）

六、python中连接MySQL

七、orm

八、orm操作数据库

用orm实现对用户信息的操作

用户信息的增删改查重点

九、Django的路由控制

9.1 URL配置

9.2 有名分组

9.3 路由分发

9.4 反向解析

9.5 伪静态

9.6 django 2.x和 1.x 路由层的区别

十、视图层

视图层之HttpRequest对象

视图层之HttpResponse对象

视图层之JsonResponse对象

CBV和FBV

十一、模板层

11.1 过滤器

11.2 标签

11.3 自定义标签与过滤器

11.4 自定义 inclusion_tag

十二、模板的导入与继承

模板的导入

模板的继承

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐