【Django笔记】md文档第6篇：Django视图、Cookie和session状态、模板和过滤器

url(r'^(\d+)/(\d+)/$', views.index),

def index(request, value1, value2):
      # 构造上下文
      context = {'v1':value1, 'v2':value2}
      return render(request, 'Book/index.html', context)

def index(request, value2, value1):
      # 构造上下文
      context = {'v1':value1, 'v2':value2}
      return render(request, 'Book/index.html', context)

get('键',默认值)

getlist('键',默认值)

# /get/?a=1&b=2&a=3
  
  
​
def get(request):
    a = request.GET.get('a')
    b = request.GET.get('b')
    alist = request.GET.getlist('a')
    print(a)  # 3
    print(b)  # 2
    print(alist)  # ['1', '3']
    return HttpResponse('OK')

def post(request):
    a = request.POST.get('a')
    b = request.POST.get('b')
    alist = request.POST.getlist('a')
    print(a)
    print(b)
    print(alist)
    return HttpResponse('OK')

{"a": 1, "b": 2}

import json
​
def post_json(request):
    json_str = request.body
    json_str = json_str.decode()  # python3.6 无需执行此步
    req_data = json.loads(json_str)
    print(req_data['a'])
    print(req_data['b'])
    return HttpResponse('OK')

def get_headers(request):
    print(request.META['CONTENT_TYPE'])
    return HttpResponse('OK')

HttpResponse(content=响应体, content_type=响应体数据类型, status=状态码)

response = HttpResponse()
response['itcast'] = 'Python'  # 自定义响应头Itcast, 值为Python

from django.http import HttpResponse
​
def response(request):
    return HttpResponse('itcast python', status=400)
    或者
    response = HttpResponse('itcast python')
    response.status_code = 400
    response['itcast'] = 'Python'
    return response

from django.http import JsonResponse
​
def response(request):
    return JsonResponse({'city': 'beijing', 'subject': 'python'})

from django.shortcuts import redirect
​
def response(request):
    return redirect('/get_header')

HttpResponse.set_cookie(cookie名, value=cookie值, max_age=cookie有效期)

def cookie(request):
    response = HttpResponse('ok')
    response.set_cookie('itcast1', 'python1')  # 临时cookie
    response.set_cookie('itcast2', 'python2', max_age=3600)  # 有效期一小时
    return response

def cookie(request):
    cookie1 = request.COOKIES.get('itcast1')
    print(cookie1)
    return HttpResponse('OK')

response.delete_cookie('itcast2')

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

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

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

pip install django-redis

CACHES = {
    'default': {
        'BACKEND': 'django_redis.cache.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/1',
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
        }
    }
}
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
SESSION_CACHE_ALIAS = 'default'

sudo vim /etc/redis/redis.conf

sudo service redis-server restart

request.session['键']=值

request.session.get('键',默认值)

request.session.clear()

request.session.flush()

del request.session['键']

request.session.set_expiry(value)

def register(request):
    """处理注册"""
​
    # 请求方法，判断是GET/POST请求
    if request.method == 'GET':
        # 处理GET请求，返回注册页面
        return render(request, 'register.html')
    else:
        # 处理POST请求，实现注册逻辑
        return HttpResponse('这里实现注册逻辑')

from django.views.generic import View
​
class RegisterView(View):
    """类视图：处理注册"""
​
    def get(self, request):
        """处理GET请求，返回注册页面"""
        return render(request, 'register.html')
​
    def post(self, request):
        """处理POST请求，实现注册逻辑"""
        return HttpResponse('这里实现注册逻辑')

urlpatterns = [
    # 视图函数：注册
    # url(r'^register/$', views.register, name='register'),
    # 类视图：注册
    url(r'^register/$', views.RegisterView.as_view(), name='register'),
]

@classonlymethod
    def as_view(cls, **initkwargs):
        """
        Main entry point for a request-response process.
        """
        ...省略代码...
​
        def view(request, *args, **kwargs):
            self = cls(**initkwargs)
            if hasattr(self, 'get') and not hasattr(self, 'head'):
                self.head = self.get
            self.request = request
            self.args = args
            self.kwargs = kwargs
            # 调用dispatch方法，按照不同请求方式调用不同请求方法
            return self.dispatch(request, *args, **kwargs)
​
        ...省略代码...
​
        # 返回真正的函数视图
        return view
​
​
    def dispatch(self, request, *args, **kwargs):
        # Try to dispatch to the right method; if a method doesn't exist,
        # defer to the error handler. Also defer to the error handler if the
        # request method isn't on the approved list.
        if request.method.lower() in self.http_method_names:
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed
        return handler(request, *args, **kwargs)

class CenterView(View):
​
    def get(self,request):
        return HttpResponse("OK")
​
    def post(self,request):
        return HttpResponse("OK")

class CenterView(LoginRequireMixin,View):
​
    def get(self,request):
        return HttpResponse("OK")
​
    def post(self,request):
        return HttpResponse("OK")

def simple_middleware(get_response):
    # 此处编写的代码仅在Django第一次配置和初始化的时候执行一次。
​
    def middleware(request):
        # 此处编写的代码会在每个请求处理视图前被调用。
​
        response = get_response(request)
​
        # 此处编写的代码会在每个请求处理视图之后被调用。
​
        return response
​
    return middleware

def my_middleware(get_response):
    print('init 被调用')
    def middleware(request):
        print('before request 被调用')
        response = get_response(request)
        print('after response 被调用')
        return response
    return 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',
    'book.middleware.my_middleware',  # 添加中间件
]

def middleware(request):
    print('view 视图被调用')
    return HttpResponse('OK')

def my_middleware(get_response):
    print('init 被调用')
    def middleware(request):
        print('before request 被调用')
        response = get_response(request)
        print('after response 被调用')
        return response
    return middleware
​
def my_middleware2(get_response):
    print('init2 被调用')
    def middleware(request):
        print('before request 2 被调用')
        response = get_response(request)
        print('after response 2 被调用')
        return response
    return 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',
    'users.middleware.my_middleware',  # 添加
    'users.middleware.my_middleware2',  # 添加
]

init2 被调用
init 被调用
before request 被调用
before request 2 被调用
view 视图被调用
after response 2 被调用
after response 被调用

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

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

from django.http import HttpResponse
from django.template import loader
​
def index(request):
    # 1.模板
    template=loader.get_template('index.html')
​
    context={'city': '北京'}
    # 2.渲染模板
    return HttpResponse(template.render(context))

from django.shortcuts import render
​
def index(request):
    context={'city': '北京'}
    return render(request,'index.html',context)

def index(request):
    context = {
        'city': '北京',
        'adict': {
            'name': '西游记',
            'author': '吴承恩'
        },
        'alist': [1, 2, 3, 4, 5]
    }
    return render(request, 'index.html', context)

==
!=
<
>
<=
>=

and
or
not

​
​
​
列举几个如下：
​
* **safe**，禁用转义，告诉模板这个变量是安全的，可以解释执行
​
* **length**，长度，返回字符串包含字符的个数，或列表、元组、字典的元素个数。
​
* **default**，默认值，如果变量不存在时则返回默认值。
​
* ```python
data|default:'默认值'