93django_view

 

目录

客户端传参的几种方式：... 1

服务器端view中，获取url路径传递的参数：... 2

服务器端view中，获取query string参数：... 2

服务器端view中，获取请求体数据：... 2

获取Form Data()键值对：... 3

获取非表单类型None-Form Data，如json类型：... 3

获取请求头数据：... 4

服务器端view中，响应：... 5

服务器端view中，cookie|session：... 6

cookie：... 6

session：... 7

view：... 8

返回404：... 9

自定义错误view：... 9

render() 9

redirect() 10

get_object_or_404() 10

get_list_or_404() 11

decorator：... 12

HttpRequest()、HttpResponse() 12

send_mail() 13

导出csv：... 14

上传文件：... 14

下载文件：... 15

 

 

 

客户端传参的几种方式：

1、通过URL路径传递，如http://ip:port/news/1/2，两个参数，新闻类型id和页码；

2、通过query string传递，如http://ip:port/news?category=1&page=2；

3、通过body请求体传递，又可根据数据格式分为k-v对、form数据、非form数据（json|xml）；

4、通过http header传递；

 

 

服务器端view中，获取url路径传递的参数：

解决：

在配置URL时，用正则匹配url中的参数；

用py的正则分组，可以对组命名（命名参数-关键字参数），也可不命名（未命名参数-位置参数）；

匹配成功后，django会自动匹配成功的值，作为方法的参数传递到视图函数中；

 

例1（未命名参数-位置参数）：

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

 

def news(request, a, b):

         return HttpResponse('news: {} {}'.format(a,b))

 

例2（命名参数-关键字参数）：

url(r'^news/(?P<category>\d+)/(?P<page>\d+)$', user.views.news),

 

def news(request, category, page):

         return HttpResponse('news: {} {}'.format(category, page)

 

 

服务器端view中，获取query string参数：

url(r'^news/$', users.views.news)

 

def news(request):

         category = request.GET.get('category')   #query string不区分请求方式（HTTP方法），无论client用GET还是POST请求，都可通过request.GET获取到queyr string

         page = request.GET.get('page')

         return HttpResponse('query string is: {}/{}'.format(category, page))

 

 

服务器端view中，获取请求体数据：

请求体数据格式可以是form类型字符串、json类型字符串、xml类型字符串，要区别对待；

可发送请求体数据的HTPP方法有，POST,PUT,PATCH,DELETE；django对这几种请求方式开启了CSRF安全防护，为方便测试，可将对应的中间件注释，'django.middleware.csrf.CsrfViewMiddleware',；

 

获取Form Data()键值对：

url(r'^news/$', users.views.news)

 

def news(request):

         category = request.POST.get('category')   #request.POST只能用来获取POST方式的请求体表单数据或k-v对数据；如果为非请求提交的请求体数据，或是请求体数据类型为非表单或非k-v对数据，则要通过request.body属性获取，获取到后再自己解析

         page = request.POST.get('page')

         return HttpResponse('form: {} {}'.format(category, page))

 

 

获取非表单类型None-Form Data，如json类型：

url(r'^news/$', users.views.news)

 

def news(request):

         json_str = request.body

         dict_data = json.loads((json_str))   #解析json

         category = dict_data.get('category')

         page = dict_data.get('page')

         return HttpResponse('json: {} {}'.format(category, page))

 

获取请求头数据：

url(r'^news/$', users.views.news)

 

def news(request):

         a = request.META.get('HTTP_A')

         b = request.META.get('HTTP_B')

         return HttpResponse('header: {} {}'.format(category, page))

 

 

 

服务器端view中，响应：

 

视图必须返回一个HttpResponse对象（或其子类），可将要返回的字符串传给HttpResponse对象再返回；

HttpRequest对象由django创建，HttpResponse对象由开发人员创建；

django.http.HttpResponse常用子类：django.http.HttpResponseRedirect（重定向），django.http.JsonResponse（返回json数据）；

django.shortcuts.redirect（不返回具体显示内容给client，让client重新请求返回的地址，获取内容）；

 

 

def news(request):

         json_str = '{"name": "jowin"}'

         return HttpResponse(json_str, content_type='application/json', status=400)

 

def news(request):

         response = HttpResponse('my name is jowin')

         response['name'] = 'jowin'   #响应头设置（可直接将HttpResponse对象当作字典进行响应头键值对的设置）

         return response

 

def news(request):

         return JsonResponse({'name': 'jowin})   #传入py的dict，可自动转为json类型，会自动设置响应头的Content-Type为application/json；另，可传入非dict数据，前提要把safe=False

 

注，django.http.JsonResponse源码：

class JsonResponse(HttpResponse):

    def __init__(self, data, encoder=DjangoJSONEncoder, safe=True,

                 json_dumps_params=None, **kwargs):

        if safe and not isinstance(data, dict):

            raise TypeError(

                'In order to allow non-dict objects to be serialized set the '

                'safe parameter to False.'

            )

        if json_dumps_params is None:

            json_dumps_params = {}

        kwargs.setdefault('content_type', 'application/json')

        data = json.dumps(data, cls=encoder, **json_dumps_params)

        super(JsonResponse, self).__init__(content=data, **kwargs)

 

 

def news(request):

         return redirect('/index')

 

 

 

服务器端view中，cookie|session：

b请求服务器是无状态的，它的每一次请求对于服务器来说都是新的，服务器默认不会保存用户的状态数据，但很多时候，服务器需要保存用户的一些状态数据，如用户是否登录过，用户浏览过哪些商品等，解决：cookie或session；

 

 

cookie：

是由服务器生成的，存储在b端的k-v对数据（通常经过加密）；

在响应请求时，服务器会把生成的cookie数据发给b，b会自动保存（前提b林开启cookie功能）；

b请求s时，会自动上传该s生成的所有cookie；

每个网站只能访问到自己生成的cookie，无法访问其它网站（域）生成的cookie；

 

django中cookie的保存和读取：

保存，通过HttpResponse响应对象的set_cookie方法；

读取，通过HttpRequest请求对象的COOKIES属性（dict）；

 

例：

urlpatterns = [

         url(r'set_cookie$', users.views.set_cookie),

         url(r'^get_cookie$', user.views.get_cookie),

]

 

def set_cookie(request):

         response = HttpResponse('save cookie')

         response.set_cookie('user_id', 10)

         response.set_cookie('user_name', 'jowin')

         return response

 

def get_cookie(request):

         user_id = request.COOKIES.get('user_id')

         user_name = request.COOKIES.get('user_name')

         return HttpResponse('{} {}'.format(user_id, user_name))

 

 

session：

cookie是在b端保存k-v对数据，而session是在s端保存k-v对数据，重要敏感的数据（银行卡号密码等）建议存储在s端，不能通过cookie保存在b端；

session的使用依赖cookie；

 

session数据默认保存在django项目的django_session表中，字段为sessionid（b标识），session_data（k-v对，dict），expire_date（过期时间）；

表中一条记录，保存着一个用户所有的session健值对数据；

sessionid，浏览器标识（用户标识），代表着一个用户，通过sessionid可以找到该用户所有的session键值对数据；

 

django默认开启了session功能，settings.py中INSTALLED_APPS和MIDDLEWARE；

 

>python manage.py makemigrations

>python manage.py migrate   #生成django默认的表

 

django中session的数据操作：

request.session['k'] = v   #保存，request.session属性（django.contrib.sessions.backends.db.SessionStore）

request.session.get('k', default_v)   #读取

del request.session['k']   #删除

request.session.flush()   #删除一条记录

request.session.clear()   #清空字段中的session健值对数据

request.session.set_expiry(value)   #value为整数，则session数据将在value秒没有活动后过期；value为0，则session数据将在用户关闭b时过期；value为None，则session数据将在2周后过期

 

 

 

view：

 

返回404：

from django.http import HttpResponse, HttpResponseNotFound

 

         return HttpResponse('Not found', status=404)

         或

         return HttpResonseNotFound('Not found')

 

注：django.http

 

__all__ = [

    'SimpleCookie', 'parse_cookie', 'HttpRequest', 'QueryDict',

    'RawPostDataException', 'UnreadablePostError',

    'HttpResponse', 'StreamingHttpResponse', 'HttpResponseRedirect',

    'HttpResponsePermanentRedirect', 'HttpResponseNotModified',

    'HttpResponseBadRequest', 'HttpResponseForbidden', 'HttpResponseNotFound',

    'HttpResponseNotAllowed', 'HttpResponseGone', 'HttpResponseServerError',

    'Http404', 'BadHeaderError', 'JsonResponse', 'FileResponse',

]

 

 

自定义错误view：

urls.py

handler400 = 'mysite.views.my_custom_bad_request_view'

handler403 = 'mysite.views.my_custom_permission_denied_view'

handler404 = 'mysite.views.my_custom_page_not_found_view'

handler500 = 'mysite.views.my_custom_error_view'

 

 

render()，from django.shortcuts import render：

def render(request, template_name, context=None, content_type=None, status=None, using=None):

    """

    Returns a HttpResponse whose content is filled with the result of calling

    django.template.loader.render_to_string() with the passed arguments.

    """

    content = loader.render_to_string(template_name, context, request, using=using)

    return HttpResponse(content, content_type, status)

 

另，render_to_response()，老版本1.6用；

 

args:

request,the request object used to generate this response；

template_name，模板名称，可以是列表，会使用先找到的那个（app中的templates/app_name/下存放模板，避免找到其它app的模板）；

 

optional argument:

context，渲染模板的context字典，默认是{}；

content_type，response MIME type，默认用DEFAULT_CONTENT_TYPE；

status,the status code for the response. defaults to 200；

using,the name of a template engine to use for loading the template，指定模板引擎；

 

一般前3个参数必须指定；

 

 

redirect()，from django.shortcuts import redirect

def redirect(to, *args, **kwargs):

    """

    Returns an HttpResponseRedirect to the appropriate URL for the arguments

    passed.

    The arguments could be:

        * A model: the model's `get_absolute_url()` function will be called.

        * A view name, possibly with arguments: `urls.reverse()` will be used

          to reverse-resolve the name.

        * A URL, which will be used as-is for the redirect location.

    By default issues a temporary redirect; pass permanent=True to issue a

    permanent redirect

    """

    if kwargs.pop('permanent', False):

        redirect_class = HttpResponsePermanentRedirect

    else:

        redirect_class = HttpResponseRedirect

 

    return redirect_class(resolve_url(to, *args, **kwargs))

 

例：

return redirect(object)   #object=MyModel.objects.get(..)

return redirect('view_name', foo='bar')

return redirect('/some/url/')

return redirect('https://example.com', permanent=True)   #永久重定向

 

 

get_object_or_404()，from django.shortcuts import get_object_or_404：

 

def get_object_or_404(klass, *args, **kwargs):

    """

    Uses get() to return an object, or raises a Http404 exception if the object

    does not exist.

    klass may be a Model, Manager, or QuerySet object. All other passed

    arguments and keyword arguments are used in the get() query.

    Note: Like with get(), an MultipleObjectsReturned will be raised if more than one

    object is found.

    """

    queryset = _get_queryset(klass)

    try:

        return queryset.get(*args, **kwargs)

    except AttributeError:

        klass__name = klass.__name__ if isinstance(klass, type) else klass.__class__.__name__

        raise ValueError(

            "First argument to get_object_or_404() must be a Model, Manager, "

            "or QuerySet, not '%s'." % klass__name

        )

    except queryset.model.DoesNotExist:

        raise Http404('No %s matches the given query.' % queryset.model._meta.object_name)

 

例：

def detail(request, question_id):

    # try:

    #     question = Question.objects.get(id=question_id)

    # except Question.DoesNotExist:

    #     return HttpResponse('Not Found', status=404)

    question = get_object_or_404(Question, pk=question_id)   #以上4行等价于此行

    return render(request, 'polls/detail.html', {'question': question})

 

 

get_list_or_404()，from django.shortcuts import get_list_or_404：

 

def get_list_or_404(klass, *args, **kwargs):

    """

    Uses filter() to return a list of objects, or raise a Http404 exception if

    the list is empty.

    klass may be a Model, Manager, or QuerySet object. All other passed

    arguments and keyword arguments are used in the filter() query.

    """

    queryset = _get_queryset(klass)

    try:

        obj_list = list(queryset.filter(*args, **kwargs))

    except AttributeError:

        klass__name = klass.__name__ if isinstance(klass, type) else klass.__class__.__name__

        raise ValueError(

            "First argument to get_list_or_404() must be a Model, Manager, or "

            "QuerySet, not '%s'." % klass__name

        )

    if not obj_list:

        raise Http404('No %s matches the given query.' % queryset.model._meta.object_name)

    return obj_list

 

 

reverse()、reverse_lazy()，from django.core.urlresolvers import reverse, reverse_lazy：

 

def reverse(viewname, urlconf=None, args=None, kwargs=None, current_app=None):

 

it is useful for when you need to use a URL reversal before your project's URLconf is loaded.

 

 

decorator：

 

django provides several decorators that can be applied to views to support various HTTP features.

 

from django.views.decorators.http import require_http_methods, require_GET, require_POST, require_safe

 

from django.views.decorators.gzip import gzip_page

 

from django.views.decorators.cache import cache_control, never_cache

 

login_required()

transaction.atomic

 

 

HttpRequest()、HttpResponse()，from django.http import HttpRequest, HttpResponse

 

class HttpRequest(object):

    """A basic HTTP request."""

    # The encoding used in GET/POST dicts. None means use default setting.

    _encoding = None

    _upload_handlers = []

 

    def __init__(self):

        # WARNING: The `WSGIRequest` subclass doesn't call `super`.

        # Any variable assignment made here should also happen in

        # `WSGIRequest.__init__()`.

 

        self.GET = QueryDict(mutable=True)

        self.POST = QueryDict(mutable=True)

        self.COOKIES = {}

        self.META = {}

        self.FILES = MultiValueDict()

 

        self.path = ''

        self.path_info = ''

        self.method = None

        self.resolver_match = None

        self._post_parse_error = False

        self.content_type = None

        self.content_params = None

 

 

class HttpResponse(HttpResponseBase):

    """

    An HTTP response class with a string as content.

    This content that can be read, appended to or replaced.

    """

 

    streaming = False

 

    def __init__(self, content=b'', *args, **kwargs):

        super(HttpResponse, self).__init__(*args, **kwargs)

        # Content is a bytestring. See the `content` property methods.

        self.content = content

 

    @property

    def content(self):

        return b''.join(self._container)

 

 

send_mail()，发送邮件，from django.core.mail import send_mail：

 

def send_mail(subject, message, from_email, recipient_list,

              fail_silently=False, auth_user=None, auth_password=None,

              connection=None, html_message=None):

    """

    Easy wrapper for sending a single message to a recipient list. All members

    of the recipient list will see the other recipients in the 'To' field.

 

    If auth_user is None, the EMAIL_HOST_USER setting is used.

    If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.

 

    Note: The API for this method is frozen. New code wanting to extend the

    functionality should use the EmailMessage class directly.

    """

 

注：

recipient_list是一list；

 

 

导出csv：

import csv

from django.http import HttpResponse

 

def some_view(request):

    # Create the HttpResponse object with the appropriate CSV header.

    response = HttpResponse(content_type='text/csv')

    response['Content-Disposition'] = 'attachment; filename="somefilename.csv"'

   

    writer = csv.writer(response)

    writer.writerow(['First row', 'Foo', 'Bar', 'Baz'])

    writer.writerow(['Second row', 'A', 'B', 'C', '"Testing"', "Here's a quote"])

    return response

 

 

上传文件：

 

from django.shortcuts import render

from django.http import HttpResponse

 

 

 

下载文件：

 

 

 

转载于:https://blog.51cto.com/jowin/2394765