1. 视图简介

urlpatterns = [
    url(r'^$', views.index, name='index'),  # 正则匹配成功时访问index函数
    url(r'^([0-9]+)/$', views.detail, name='detail'),  # 正则匹配成功时访问detail函数
]

再在项目的 urls.py 中使用 include() 关联对应应用的 urls.py：

urlpatterns = [
    url(r'^admin/', include(admin.site.urls)),
    url(r'^hero_info/', include('hero_book.urls', namespace='hero_info')),  # 关联hero_book包下的urls.py
]

使用 include 可以去除 urlconf 的冗余。

匹配过程

解析 web 请求地址时，先与主 URLconf 匹配，成功后再用剩余的部分与应用中的 URLconf 匹配。如下示例：

请求 http://www.demo.cn/hero_info/1/
匹配部分是 /hero_info/1/
在 settings.py 中与“hero_info/”匹配成功，再用“1/”与 hero_info 应用的 urls 匹配成功

2）URLconf 的编写

url 的正则表达式不需要添加一个前导的反斜杠，如应该写作'hero_info/'，而不应该写作'/hero_info/'。
每个正则表达式前面的 r 表示字符串不转义。
请求的 url 被看做是一个普通的 python 字符串，进行匹配时不包括 get 或 post 请求的参数及域名。

http://www.itcast.cn/python/1/?i=1&p=new  # 只匹配“/python/1/”部分

若要从 url 中捕获一个值，则要使用正则中的分组。
- 优先使用命名参数，如果没有命名参数则使用位置参数。
- 每个捕获的参数都作为一个普通的 python 字符串传递给视图。

url(r'^([0-9]+)/$', views.detail, name='detail')  # 通过位置参数传递给视图
url(r'^(?P<id>[0-9]+)/$', views.detail, name='detail')  # 通过分组名称传递参数给视图函数，本例的参数名称为id

3）namespace 反向解析

在 include 中通过 namespace 定义命名空间，用于反向解析。

URL的反向解析

问题：如果在视图、模板中使用硬编码的链接，在 urlconf 发生改变时，维护是一件非常麻烦的事情。

解决：在做链接时，通过指向 urlconf 的名称，动态生成链接地址。

视图：使用 django.core.urlresolvers.reverse() 函数。
模板：使用 url 模板标签。

3. 视图函数&错误视图

视图本质就是一个函数。在应用目录下默认有 views.py 文件，一般视图都定义在这个文件中。

视图的参数：

一个 HttpRequest 实例
通过正则表达式分组获取的位置参数或关键字参数

如果处理功能过多，可以将函数定义到不同的 py 文件中（但不建议）。示例：

# 新建views1.py
from django.http import HttpResponse

def index(request):
    return HttpResponse("你好")
 
# 在urls.py中修改配置
from . import views1
url(r'^$', views1.index, name='index'),

错误视图

Django 原生自带了几个默认视图用于处理 HTTP 错误。

404 (page not found) 视图

默认的 404 视图将传递一个变量 request_path 给模板，它是导致错误的 url。
如果Django在检测URLconf中的每个正则表达式后没有找到匹配的内容时，将调用 404 视图。
如果在 settings.py 中 DEBUG 设置为 True，那么将永远不会调用 404 视图，而是显示 URLconf。并带有一些调试信息。

1）在 templates 中创建 404.html：

2）编写 404.html：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{{request_path}}
<h1>Oops！该网页不存在..</h1>
</body>
</html>

3）在 settings.py 中修改两个配置：

DEBUG = False  # 取消调试状态
ALLOWED_HOSTS = ['*', ]  # 允许所有主机访问

4）访问不存在的地址：

500 (server error) 视图

默认的 500 视图不会传递变量给 500.html 模板。
同理，如果在 settings.py 中 DEBUG 设置为 True，也将不会调用 505 视图，而是显示 URLconf 并带有一些调试信息。

400 (bad request) 视图

错误来自客户端的操作。例如当用户进行的操作在安全方面可疑时（篡改会话 cookie 等）。

4. HttpRequest 对象

服务器接收到 http 请求后，会根据报文创建 HttpRequest 对象。
视图函数的第一个参数是 HttpRequest 对象。
在 django.http 模块中定义了 HttpRequest 对象的 API。

属性

下面除非特别说明，属性都是只读的。

path：一个字符串，表示请求的页面的完整路径，不包含域名和端口。
method：一个字符串，表示请求使用的 HTTP 方法，常用值包括：'GET'、'POST'。
encoding：一个字符串，表示提交的数据的编码方式。
- 如果为 None 则表示使用浏览器的默认设置，一般为 utf-8。
- 这个属性是可写的，可以通过修改它来修改访问表单数据时使用的编码，接下来对属性的任何访问将使用新的 encoding 值。
GET：一个类似于字典的对象，包含 get 请求方式的所有参数。
POST：一个类似于字典的对象，包含 post 请求方式的所有参数。
FILES：一个类似于字典的对象，包含所有的上传文件。
COOKIES：一个标准的 python 字典，包含所有的 cookie，键和值都为字符串。
session：一个既可读又可写的类似于字典的对象，表示当前的会话，只有当 Django 启用会话的支持时才可用。

方法

is_ajax()：如果请求是通过 XMLHttpRequest 发起的，则返回 True。

1）QueryDict 对象

QueryDict 对象定义在 django.http.QueryDict。

Request 对象的属性 GET、POST 等都是 QueryDict 类型的对象。

与 python 字典不同，QueryDict 类型的对象用来处理同一个键带有多个值的情况。

方法 get()：根据键获取一个值。如果一个键同时拥有多个值，获取最后一个值。

dict.get('键', default)
或简写为
dict['键']

方法 getlist()：将键的值以列表返回，即可以获取一个键的多个值。

dict.getlist('键', default)

2）GET 属性

GET 属性是 QueryDict 类型的对象，包含了 get 请求方式的所有参数，与 url 请求地址中的参数对应，位于 ? 后面。
参数的格式是键值对，如 key1=value1。多个参数之间则使用 & 连接，如 key1=value1&key2=value2。
键是开发人员定下来的，值是可变的。

范例

views.py：创建 get_test_1() 用于定义链接，get_test_2() 用于接收一键一值，get_test_3() 用于接收一键多值。

 1 def get_test_1(request):
 2     return render(request, "hero_book/get_test_1.html")
 3
 4 def get_test_2(request):
 5     a = request.GET["a"]
 6     b = request.GET["b"]
 7     context = {"a": a, "b": b}
 8     return render(request, "hero_book/get_test_2.html", context)
 9
10 def get_test_3(request):
11     a = request.GET.getlist("a")
12     b = request.GET["b"]
13     context = {"a": a, "b": b}
14     return render(request, "hero_book/get_test_3.html", context)

urls.py：

    url(r'^get_test_1/$', views.get_test_1),
    url(r'^get_test_2/$', views.get_test_2),
    url(r'^get_test_3/$', views.get_test_3),

创建 get_test_1.html：

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8
 9 链接1：一个键传递一个值 <a href="/hero_book/get_test_2/?a=1&b=2">get_test_2</a>
10 <br>
11 链接2：一个键传递多个值 <a href="/hero_book/get_test_3/?a=1&a=2&b=3">get_test_3</a>
12
13 </body>
14 </html>

创建 get_test_2.html：

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8 a: {{ a }} <br>
 9 b: {{ b }}
10 </body>
11 </html>

创建 get_test_3.html：

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8 a: {% for value in a %}
 9 {{ value }}
10 {% endfor %}
11 <br>
12 b: {{ b }}
13 </body>
14 </html>

执行效果：

3）POST 属性

POST 属性是 QueryDict 类型的对象，包含了 post 请求方式的所有参数，与 form 表单中的控件对应。

问：表单中哪些属性会被提交？

控件要有 name 属性，则 name 属性的值为键，value 属性的值为键，构成键值对提交。键是开发人员定下来的，值是可变的。
对于 checkbox 控件，name 属性一样为一组，当控件被选中后会被提交，存在一键多值的情况。

范例

views.py：定义视图 post_test_1 用于填写 form 表单；定义视图 post_test_2 获取表单的键值。

 1 def post_test_1(request):
 2     return render(request, "hero_book/post_test_1.html")
 3
 4 def post_test_2(request):
 5     uname=request.POST['uname']
 6     upwd=request.POST['upwd']
 7     ugender=request.POST['ugender']
 8     uhobby=request.POST.getlist('uhobby')
 9     context={'uname': uname, 'upwd': upwd, 'ugender': ugender, 'uhobby': uhobby}
10     return render(request, "hero_book/post_test_2.html", context)

注意：使用表单提交时，先注释掉 settings.py 中的中间件 crsf。

urls.py：

    url(r'^post_test_1/$', views.post_test_1),
    url(r'^post_test_2/$', views.post_test_2),

创建模板 post_test_1.html，用于填写并提交 form 表单：

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8 <form method="post" action="/hero_book/post_test_2/">
 9     姓名：<input type="text" name="uname"/><br>
10     密码：<input type="password" name="upwd"/><br>
11     性别：<input type="radio" name="ugender" value="1"/>男
12     <input type="radio" name="ugender" value="0"/>女<br>
13     爱好：<input type="checkbox" name="uhobby" value="胸口碎大石"/>胸口碎大石
14     <input type="checkbox" name="uhobby" value="喝酒"/>喝酒
15     <input type="checkbox" name="uhobby" value="爬山"/>爬山<br>
16     <input type="submit" value="提交"/>
17 </form>
18 </body>
19 </html>

创建模板 post_test_2.html，用于输出表单的值：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
用户名：{{ uname }}<br>
密码：{{ upwd }}<br>
性别：{{ ugender }}<br>
爱好：{% for hobby in uhobby %}
{{ hobby }}
{% endfor %}
</body>
</html>

执行效果：

5. HttpResponse 对象

在 django.http 模块中定义了 HttpResponse 对象的 API。
HttpRequest 对象由 Django 自动创建，HttpResponse 对象由程序员创建。

示例 1：不调用模板，直接返回数据

from django.http import HttpResponse
 
def index(request):
    return HttpResponse('你好')

示例 2：调用模板

from django.http import HttpResponse
from django.template import RequestContext, loader
 
def index(request):
    t1 = loader.get_template('polls/index.html')  # 加载模板
    context = RequestContext(request, {'h1': 'hello'})  # 渲染模板（填充数据）
    return HttpResponse(t1.render(context))  # 返回一个渲染后的 HttpResponse 对象

示例 3：简写函数 render

render(request, template_name[, context])：结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。

request：该 request 用于生成 response。
template_name：要使用的模板的完整名称。
context：添加到模板上下文的一个字典，视图将在渲染模板之前调用它。

from django.shortcuts import render
 
def index(request):
    return render(request, 'booktest/index.html', {'h1': 'hello'})

属性

content：表示返回的内容，字符串类型。
charset：表示 response 采用的编码字符集，字符串类型。
status_code：响应的 HTTP 响应状态码。
content-type：指定输出的 MIME 类型。

方法

init()：实例化 HttpResponse 对象。
write(content)：以文件的方式写。
flush()：以文件的方式输出缓存区。
set_cookie(key, value='', max_age=None, expires=None)：设置 cookie。
- key、value：都是字符串类型。
- max_age：是一个整数，表示在指定秒数后过期。
- expires：是一个 datetime 或 timedelta 对象，会话将在这个指定的日期/时间过期，注意 datetime 和 timedelta 值只有在使用 PickleSerializer 时才可序列化。
- max_age 与 expires 二选一。
- 如果不指定过期时间，则两个星期后过期。
delete_cookie(key)：删除指定 key 的 Cookie，如果 key 不存在则什么也不发生。

1）设置 Cookie

 1 def index(request):
 2     response = HttpResponse()
 3     # 用户已有cookie则读取
 4     if "username" in request.COOKIES:
 5         response.write("已有 cookie: %s" % request.COOKIES["username"])
 6         return response
 7     # 对首次访问的用户设置cookie
 8     response.set_cookie("username", "xiaoming", None, datetime(2030, 1, 1))
 9     response.write("初始化 cookie 成功")
10     return response

2）子类 HttpResponseRedirect

重定向，服务器端跳转。
构造函数的第一个参数用来指定重定向的地址。
简写：from django.shortcuts import redirect

1 def redirect_test_1(request):
2     return HttpResponseRedirect("/hero_book/redirect_test_2/")
3
4 def redirect_test_2(request):
5     return render(request, "hero_book/redirect_test_2.html")

访问 http://127.0.0.1:8000/hero_book/redirect_test_1，结果如下：

3）子类 JsonResponse

返回 json 数据，一般用于异步请求。
帮助用户创建 JSON 编码的响应。
_init _(data)：参数 data 是字典对象。
JsonResponse 的默认 Content-Type 为 application/json。

from django.http import JsonResponse
 
def index2(requeset):
    return JsonResponse({'list': 'abc'})

4）异常处理：返回 404

得到对象或返回 404

get_object_or_404(klass, *args, **kwargs)
通过模型管理器或查询集调用 get() 方法，如果没找到对象，不引发模型的 DoesNotExist 异常，而是引发 Http404 异常。
klass：获取对象的模型类、Manager 对象或 QuerySet 对象。
**kwargs：查询的参数，格式应该可以被 get() 和 filter() 接受。
如果找到多个对象将引发 MultipleObjectsReturned 异常。

from django.shortcuts import *
 
def detail(request, id):
    try:
        book = get_object_or_404(BookInfo, pk=id)
    except BookInfo.MultipleObjectsReturned:
        book = None
    return render(request, 'booktest/detail.html', {'book': book})
 
#将settings.py中的DEBUG改为False
#将请求地址输入2和100查看效果

得到列表或返回 404

get_list_or_404(klass, *args, **kwargs)
klass：获取列表的一个 Model、Manager 或 QuerySet 实例。
**kwargs：查寻的参数，格式应该可以被 get() 和 filter() 接受。

from django.shortcuts import *
 
def index(request):
    # list = get_list_or_404(BookInfo, pk__lt=1)
    list = get_list_or_404(BookInfo, pk__lt=6)
    return render(request, 'booktest/index.html', {'list': list})
 
# 将settings.py中的DEBUG改为False

6. 状态保持：Session

http 协议是无状态的：每次请求都是一次新的请求，不会记得之前通信的状态。而实现状态保持的方式一般是在客户端或服务器端存储与会话有关的数据。

客户端与服务器端的一次通信，就是一次会话。存储方式包括 cookie、session，会话一般指 session 对象。

使用 cookie，所有数据存储在客户端，注意不要存储敏感信息。
推荐使用 sesison 方式，所有数据存储在服务器端，并自动在客户端 cookie 中存储 session_id。

状态保持的目的是在一段时间内跟踪请求者的状态，可以实现跨页面访问当前请求者的数据。注意：不同的请求者之间不会共享这个数据，会话与请求者一一对应。

启用 session

使用 django-admin startproject 创建项目时已默认启用。在 settings.py 文件中：

# INSTALLED_APPS列表中添加：
'django.contrib.sessions',
 
# MIDDLEWARE_CLASSES列表中添加：
'django.contrib.sessions.middleware.SessionMiddleware',

禁用会话：删除/注释上面指定的两个值，禁用会话将节省一些性能消耗。

使用 session

启用会话后，每个 HttpRequest 对象将具有一个 session 属性，它是一个 QueryDict 对象。其方法如下：

get(key, default=None)：根据键获取会话的值。
clear()：清除所有会话。
flush()：删除当前的会话数据并删除会话的 cookie。
del request.session['member_id']：删除会话。

范例：用户登录

views.py：

 1 # 主页
 2 def index(request):
 3     user_name = request.session.get("session_name")  # 没有则返回默认的None
 4     return render(request, "hero_book/index.html", {"user_name": user_name})
 5
 6 # 登录页
 7 def login(request):
 8     return render(request, "hero_book/login.html")
 9
10 # 登录页提交表单
11 def login_handler(request):
12     request.session["session_name"] = request.POST["myname"]
13     return redirect("/hero_book/")  # 重定向主页
14
15 # 退出登录
16 def logout(request):
17     # del request.session["session_name"]
18     # request.session.clear()
19     request.session.flush()
20     return redirect("/hero_book/")  # 重定向主页

urls.py：

    url(r'^$', views.index),
    url(r"^login/", views.login),
    url(r"^login_handler/", views.login_handler),
    url(r"^logout/", views.logout),

index.html：

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8 你好！{{ user_name }}
 9 <hr/>
10 <a href="/hero_book/login/">登录</a>
11 <hr/>
12 <a href="/hero_book/logout/">退出</a>
13 </body>
14 </html>

login.html：

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>登录</title>
 6 </head>
 7 <body>
 8 <form method="post" action="/hero_book/login_handler/">
 9     请输入用户名：<input type="text" name="myname"/>
10     <input type="submit" value="登录"/>
11 </form>
12 </body>
13 </html>

会话过期时间

set_expiry(value)：设置会话的超时时间。

如果没有指定，则两个星期后过期。
如果 value 是一个整数，会话将在 value 秒没有活动后过期。
如果 value 是一个 timedelta 对象，会话将在当前时间加上这个指定的日期/时间过期。
如果 value 为 0，那么用户会话的 cookie 将在用户的浏览器关闭时过期。
如果 value 为 None，那么会话永不过期。

def login_handle(request):
    request.session['uname'] = request.POST['uname']
    # request.session.set_expiry(10)
    # request.session.set_expiry(timedelta(days=5))
    # request.session.set_expiry(0)
    # request.session.set_expiry(None)

存储 session

会话的存储方式，可以在 settings.py 的 SESSION_ENGINE 项中指定。

基于数据库的会话：这是 Django 默认的会话存储方式，需要添加 django.contrib.sessions 到的 INSTALLED_APPS 设置中，运行 manage.py migrate 后会在数据库中安装会话表，可显示指定为：

SESSION_ENGINE = 'django.contrib.sessions.backends.db'

基于缓存的会话：只存在本地内在中，如果丢失则不能找回，比数据库的方式读写更快。

SESSION_ENGINE = 'django.contrib.sessions.backends.cache'

可以将缓存和数据库同时使用：优先从本地缓存中获取，如果没有则从数据库中获取。

SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'

使用 Redis 缓存 session

Session 还支持文件、纯 cookie、Memcached、Redis 等方式存储。

安装 Django 与 Redis 的交互包：

pip install django-redis-sessions

修改 settings.py 中的配置，增加如下项：

SESSION_ENGINE = 'redis_sessions.session'
SESSION_REDIS_HOST = 'localhost'  # redis服务器IP
SESSION_REDIS_PORT = 6379  # redis 默认端口
SESSION_REDIS_DB = 0
SESSION_REDIS_PASSWORD = ''
SESSION_REDIS_PREFIX = 'session'

管理 Redis 的命令：

启动：sudo redis-server /etc/redis/redis.conf
停止：sudo redis-server stop
重启：sudo redis-server restart
redis-cli：使用客户端连接服务器
keys *：查看所有的键
get name：获取指定键的值
del name：删除指定名称的键

Django 视图（View）的更多相关文章

Django视图View
1.什么是Django的视图函数一个视图函数(或者一个类),简称视图是python的一个简单的函数,他是接受web请求并且处理逻辑进而返回响应响应可以是一张网页的HTML内容,一个重定向 ...
Django学习笔记之Django视图View
一个视图函数(类),简称视图,是一个简单的Python 函数(类),它接受Web请求并且返回Web响应. 响应可以是一张网页的HTML内容,一个重定向,一个404错误,一个XML文档,或者一张图片. ...
django 视图view
视图里一般是函数和类,需要返回响应. 试图分为2种:2. CBV(class base view) FBV(function base view) from django.views import V ...
9.11 Django视图 view和路由
2018-9-11 16:34:16 2018-9-11 19:00:24 越努力,.越幸运! Django框架参考: https://www.cnblogs.com/liwenzhou/p/8296 ...
[diango]理解django视图工作原理
前言:正确理解django视图view,模型model,模板的概念及其之间的关联关系,才能快速学习并上手使用django制作网页本文主要讲解自己在学习django后对视图view的理解在进入正文之 ...
Django的View(视图)和路由系统
一.Django的View(视图) 1.介绍一个视图函数(类),简称视图,是一个简单的Python 函数(类),它接受Web请求并且返回Web响应. 响应可以是一张网页的HTML内容,一个重定向,一 ...
Django的View（视图）
Django的View(视图) 一个视图函数(类),简称视图,是一个简单的Python 函数(类),它接受Web请求并且返回Web响应. 响应可以是一张网页的HTML内容,一个重定向,一个404错误, ...
python3开发进阶-Django视图（View）的常见用法
阅读目录简述Django的View(视图) CBV和FBV Request对象和Response对象 Django组件(render,redirect)详解一.简述Django的View(视图) ...
Django 框架篇(四) : 视图(view)详解以及路由系统(url)
|--Django的View(视图) |-- CBV和FBV: |-- 给视图增加装饰器: |-- request对象: |-- response对象: |-- Django的路由系统(url): | ...
Django 2.0 学习(03)：Django视图和URL(下)
接上篇博文,继续分析Django基本流程. 编写第一个(view)视图函数 1.打开文件polls/views.py,输入下面的Python代码: from django.http import Ht ...

随机推荐

LayUI之数据表格扩展
1.点击一行选中以下代码需要在表格渲染完成时加载. 1)当单击表格行时,把单选按钮设为选中状态 //当单击表格行时,把单选按钮设为选中状态 $(document).on("click&q ...
在 Svelte 中使用 CSS-in-JS
你即便不需要,但你可以. 注意:原文发表于2018-12-26,随着框架不断演进,部分内容可能已不适用. CSS 是任何 Web 应用程序的核心部分. 宽泛而论,如果一个 UI 框架没有内置向组件添加 ...
SpringBoot(十):SpringBoot的简单事务管理
SpringBoot集成Mybatis之后,进行事务管理.SpringBoot使用事务非常简单,底层依然采用的是Spring本身提供的事务. 1.在入口类中使用注解@EnableTransaction ...
JUnit5学习之七：参数化测试(Parameterized Tests)进阶
欢迎访问我的GitHub https://github.com/zq2599/blog_demos 内容:所有原创文章分类汇总及配套源码,涉及Java.Docker.Kubernetes.DevOPS ...
【知识点】 gcc和g++的联系和区别
目前(2020-09)GCC 编译器已经更新至 10.2版本,其功能也由最初仅能编译 C 语言,扩增至可以编译多种编程语言,其中就包括 C++ . 除此之外,当下的 GCC 编译器还支持编译 Go.O ...
selenium之元素定位的方法（二）
XPath定位是XML Path的缩写,称为XML路径语言,是在XML文档中查找信息的一种语言,可用来再XML文档中对元素和属性进行搜索.XPath使用路径表达式来选取XML文档中的节点或节点集. X ...
CCF(压缩编码)：动态规划+平行四边形优化
压缩编码 201612-4 一开始看这题还以为是哈夫曼编码的题目,结果是哈夫曼题目的变形. 哈夫曼编码是每次合并任意两堆石子,而这里的题目是合并相邻的两堆石子,而且这里的合并花费是合并两堆石子加上所有 ...
CentOS7 下 MySQL 5.7.23 & XtraBackup 24 做数据备份（1）——安装软件
在两台机子上同时操作下面的步骤首先安装MySQL,从官网下载相对应版本的RPM包 mysql-community-client-5.7.23-1.el7.x86_64.rpm mysql-commu ...
.Net Core 处理跨域问题Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Origin' header is present on the requested resource
网页请求报错: Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Or ...
Java 面向对象 01
面向对象·一级面向对象思想概述 * A:面向过程思想概述 * 第一步 * 第二步 * B:面向对象思想概述 * 找对象(第一步,第二步) * C:举例 * 买煎饼果子 ...

Django 视图（View）

1. 视图简介

2. URLconf