djangodocs

Django 6.1
Gaeilge
Documentation contents

Rudaí iarratais agus freagartha

Forbhreathnú tapa

Úsáideann Django rudaí iarratais agus freagartha chun stát a rith tríd an gcóras.

Nuair a iarrtar leathanach, cruthaíonn Django réad: class: HttpRequest ina bhfuil meiteashonraí faoin iarratas. Ansin luchtaíonn Django an dearcadh cuí, ag rith an:class: HttpRequest mar an chéad argóint chuig an bhfeidhm amharc. Tá gach radharc freagrach as réad: class: HttpResponse a thabhairt ar ais.

Míníonn an doiciméad seo na APIs le haghaidh rudaí: class: HttpRequest agus:class: HttpResponse, atá sainmhínithe sa mhodúl:mod: django.http.

HttpRequest rudaí

class HttpRequest

tréithe

Ba chóir gach tréith a mheas go léite amháin, mura luaitear a mhalairt.

HttpRequest.scheme

Sreang a léiríonn scéim an iarratais (http nó https` de ghnáth).

HttpRequest.body

An comhlacht iarratais amh-HTTP mar bytestring. Tá sé seo úsáideach chun sonraí a phróiseáil ar bhealaí éagsúla ná foirmeacha traidisiúnta HTML: íomhánna dénártha, ualach pá XML srl Chun sonraí foirme traidisiúnta a phróiseáil, bain úsáid as: attr: HttpRequest.post.

Is féidir leat léamh freisin ó HttpRequest` ag baint úsáide as comhéadan cosúil le comhad le:meth: HttpRequest.read nó:meth: HttpRequest.readline. Tabharfar RawPostDataException a rochtain ar an tréith ``corp ``*tar éis * an iarraidh a léamh le ceachtar de na modhanna srutha I/O seo.

HttpRequest.path

Sreang a léiríonn an cosán iomlán chuig an leathanach iarrtha, gan an scéim, an fearann nó an teaghrán fiosrúcháin san áireamh.

Sampla: ” /ceol/banda/the_beatles/"

HttpRequest.path_info

Faoi roinnt cumraíochtaí freastalaí gréasáin, roinntear an chuid den URL tar éis an ainm óstach i gcuid réimír script agus i gcuid faisnéise cosáin. Tá an chuid faisnéise cosáin den chosán sa tréith path_info` i gcónaí, is cuma cén freastalaí gréasáin atá á úsáid. Ag baint úsáide as seo in ionad:attr: ~httpRequest.path is féidir le do chód a dhéanamh níos éasca bogadh idir freastalaithe tástála agus imscartha.

Mar shampla, má tá an WSGiscriptalias d'iarratas socraithe go ” /minfo", ansin d'fhéadfadh path a bheith``” /minfo/music/bands/the_beatles/"`` agus path_info` a bheadh ” /music/bands/the_beatles/".

HttpRequest.method

Sreang a léiríonn an modh HTTP a úsáidtear san iarratas. Ráthaítear go mbeidh sé seo uachtaracha. Mar shampla:

Code
if request.method == "GET":
    do_something()
elif request.method == "POST":
    do_something_else()
HttpRequest.encoding

Sreang a léiríonn an t-ionchódú reatha a úsáidtear chun sonraí aighneachta foirme a dhíchódú (nó None, rud a chiallaíonn an socrú: DEFAULT_CHARSET a úsáidtear an socrú: DEFAULT_CHARSET). Féadfaidh tú scríobh chuig an tréith seo chun an t-ionchódú a úsáidtear a athrú agus tú ag rochtain ar shonraí Úsáidfidh aon rochtain tréithe ina dhiaidh sin (mar shampla léamh ó:attr: GET nó: attr: POST `) an luach ``encoding` nua. Úsáideach má tá a fhios agat nach bhfuil na sonraí foirme san ionchódú: setting: DEFAULT_CHARSET.

HttpRequest.content_type

Sreang a léiríonn cineál MIME an iarratais, a pháirsítear ón gceannteideal CONTENT_TYPE.

HttpRequest.content_params

Foclóir de pharaiméadair eochair/luacha atá san áireamh sa cheanntásc CONTENT_TYPE.

HttpRequest.GET

Rud cosúil le foclóir ina bhfuil gach paraiméadar HTTP GET a thugtar. Féach an doiciméadúint:class: QueryDict thíos.

HttpRequest.POST

Rud cosúil le foclóir ina bhfuil gach paraiméadar HTTP POST a thugtar, ar choinníoll go bhfuil sonraí foirme san iarratas. Féach an doiciméadach:class: QueryDict thíos. Más gá duit rochtain a fháil ar shonraí amha nó neamh-fhoirme a chuirtear san iarratas, rochtain a fháil air seo tríd an tréith: attr: `HttpRequest.body `ina ionad.

Is féidir go bhféadfadh iarratas teacht isteach trí POST le foclóir folamh POST ``- má iarrtar foirm tríd an modh POST HTTP ach nach bhfuil sonraí foirme san áireamh ann. Dá bhrí sin, níor chóir duit `if request.post a úsáid chun seiceáil maidir le húsáid an modh POST; ina ionad sin, bain úsáid as if request.method == “POST" (féach: attr: HttpRequest.method).

Ní chuimsíonn POST `` `` `` `` `` `` `` `` `` `` `` ` Féach: attr: COMHAID.

HttpRequest.COOKIES

Foclóir ina bhfuil na fianáin go léir. Is teaghráin iad eochracha agus luachanna.

HttpRequest.FILES

Rud cosúil le foclóir ina bhfuil gach comhad uaslódáilte. <input type="file" name="">Is é gach eochair i FILES` an ainm ``` ón ```` `` . Is é gach luach i `FILES` ná: aicme: ~django.core.files.uploadedfile.uploadedfile.

Féach: doc: /topics/files le haghaidh tuilleadh faisnéise.

Ní bheidh sonraí i FILES ach amháin má bhí POST an modh iarratais agus má bhí enctype="multipart/form-data" ag an <form> a chuir post chuig an iarraidh. Seachas sin, is réad bán cosúil le foclóir é FILES`.

HttpRequest.META

Foclóir ina bhfuil gach ceanntásc HTTP atá ar fáil. Braitheann ceanntála atá ar fáil ar an gcliant agus ar an bhfreastalaí, ach seo roinnt samplaí:

  • CONTENT_LENGTH - Fad an chomhlachta iarratais (mar shreang).

  • CONTENT_TYPE - Cineál MIME an chomhlachta iarratais.

  • HTTP_ACCEPT - Cineálacha ábhair inghlactha don fhreagra.

  • HTTP_ACCEPT_ENCODING - Ionchódaithe inghlactha don fhreagra.

  • HTTP_ACCEPT_LANGUAGE -- Teangacha inghlactha don fhreagra.

  • HTTP_HOST - An ceannteideal Óstach HTTP a sheol an cliant.

  • HTTP_REFERER - An leathanach tagartha, más ann.

  • HTTP_USER_AGENT -- Sreang gníomhaire úsáideora an chliaint.

  • QUERY_STRING - An teaghrán fiosrúcháin, mar shreang aonair (neamhpháirseáilte).

  • REMOTE_ADDR - Seoladh IP an chliaint.

  • REMOTE_HOST - Ainm óstach an chliaint.

  • REMOTE_USER - An t-úsáideoir a fhíordheimhnigh an fhreastalaí gréasáin, más ann.

  • REQUEST_METHOD -- Sreang mar "GET" nó "POST".

  • SERVER_NAME - Ainm óstach an fhreastalaí.

  • SERVER_PORT - Calafort an fhreastalaí (mar shreang).

Seachas CONTENT_LENGTH agus CONTENT_TYPE`, mar a thugtar thuas, déantar aon cheannteidil HTTP san iarratas a thiontú go heochracha META` trí gach carachtar a thiontú go uachchlóir, béim a chur in ionad aon bhreitheanna agus réimír HTTP_` a chur leis an ainm. Mar sin, mar shampla, déanfaí ceanntásc ar a dtugtar X-Bender a mhapáil leis an eochair META HTTP_X_BENDER.

Tabhair faoi deara go mbaineann: djadmin: runserver gach ceannteideal le béim san ainm, ionas nach bhfeicfidh tú iad i META`. Cuireann sé seo cosc ar cheannteanntáil bunaithe ar dhébhríocht idir béim agus scaoileanna araon ag normalú le béim i n-athróga timpeallachta WSGI. Meaitseálann sé le hiompar freastalaithe gréasáin cosúil le Nginx agus Apache 2.4+.

HttpRequest.headers is a simpler way to access all HTTP-prefixed headers, plus CONTENT_LENGTH and CONTENT_TYPE.

HttpRequest.headers

Rud cás-neamh-íogair, cosúil le dict a sholáthraíonn rochtain ar gach ceannteideal réamhshocraithe HTTP (móide Content-Fad ``agus ``Content-Type) ón iarratas.

Déantar ainm gach ceanntásc a stíliú le teidil cásáil (m.sh. ``Gníomhaire Usáideora ``) nuair a thaispeántar é. Is féidir leat rochtain a fháil ar cheanntásca go mí-íogair:

Python console
>>> request.headers
{'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6', ...)}

>>> "User-Agent" in request.headers
True
>>> "user-agent" in request.headers
True

>>> request.headers["User-Agent"]
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)
>>> request.headers["user-agent"]
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)

>>> request.headers.get("User-Agent")
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)
>>> request.headers.get("user-agent")
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)

Le húsáid i dteimpléid Django, mar shampla, is féidir ceanntásca a fheiceáil suas freisin ag baint úsáide as béim in ionad hiphens:

Django template
{{ request.headers.user_agent }}
HttpRequest.resolver_match

Sampla de:class: ~django.urls.resolverMatch a léiríonn an URL réitithe. Ní shocraítear an tréith seo ach tar éis réiteach URL a dhéanamh, rud a chiallaíonn go bhfuil sé ar fáil i ngach radharc ach ní i lár a fhorghníomhaítear sula ndéantar réiteach URL (is féidir leat é a úsáid in:meth: process_view áfach).

HttpRequest.multipart_parser_class

The class used to parse multipart/form-data request data. By default, this is django.http.multipartparser.MultiPartParser.

You can set this attribute to use a custom multipart parser, either via middleware or directly in views:

Code
from django.http.multipartparser import MultiPartParser


class CustomMultiPartParser(MultiPartParser):
    def parse(self):
        post = QueryDict(mutable=True)
        files = MultiValueDict()
        # Custom processing logic here
        return post, files


# In middleware or view:
request.multipart_parser_class = CustomMultiPartParser

Tréithe socraithe de réir cód iarratais

Ní shocraíonn Django na tréithe seo féin ach úsáideann sé iad má shocraíonn d'fheidhmchlár iad.

HttpRequest.current_app

The url template tag will use its value as the current_app argument to reverse().

HttpRequest.urlconf

Úsáidfear é seo mar an URLConf fréimhe don iarratas reatha, ag cur thar an socrú: setting: ROOT_URLCONF. Féach: ref: how django-processes-a-request le haghaidh sonraí.

Is féidir urlconf a shocrú go None chun aon athruithe a rinne middleware roimhe seo a chur ar ais agus filleadh ar an: setting: ROOT_URLCONF a úsáid.

HttpRequest.exception_reporter_filter

Úsáidfear é seo in ionad:setting: DEFAULT_EXCEPTION_REPORTER_FILTER don iarratas reatha. Féach: Ref: `custom-earror-reports `le haghaidh sonraí.

HttpRequest.exception_reporter_class

Úsáidfear é seo in ionad:setting: DEFAULT_EXCEPTION_REPORTER don iarratas reatha. Féach: Ref: `custom-earror-reports `le haghaidh sonraí.

Tréithe arna leagan síos ag middleware

Socraíonn cuid de na middleware atá san áireamh in aipeanna contrib Django tréithe ar an iarratas. Mura bhfeiceann tú an tréith ar iarratas, bí cinnte go bhfuil an rang lár-earraí cuí liostaithe in:setting: MIDDLEWARE.

HttpRequest.session

Ón:class: ~django.contrib.sessions.middleware.sessionMiddleware: Rud inléite agus inscríofa, cosúil le foclóir a léiríonn an seisiún reatha.

HttpRequest.site

From the CurrentSiteMiddleware: An instance of Site or RequestSite as returned by get_current_site() representing the current site.

HttpRequest.user

Ón:class: ~django.contrib.auth.middleware.AuthenticationMiddleware: Sampla de:setting: AUTH_USER_MODEL a léiríonn an t-úsáideoir logáilte isteach faoi láthair. Mura bhfuil an t-úsáideoir logáilte isteach faoi láthair, socraítear user ar shampla de:class: ~django.contrib.auth.models.anonymousUser. Is féidir leat iad a insint óna chéile la:attr: ~django.contrib.auth.models.user.is_Authenticated, mar sin:

Code
if request.user.is_authenticated:
    ...  # Do something for logged-in users.
else:
    ...  # Do something for anonymous users.

The auser() can be used to access the user in async contexts.

Modhanna

HttpRequest.auser()

Ón:aicme: ~django.contrib.auth.middleware.AuthenticationMiddleware: Coroutine. Tugann sé sampla de:setting: AUTH_USER_MODEL a léiríonn an t-úsáideoir atá logáilte isteach faoi láthair. Mura bhfuil an t-úsáideoir logáilte isteach faoi láthair, cuirfidh auser sampla de:class: ~django.contrib.auth.models.anonymousUser ar ais. Tá sé seo cosúil leis an tréith: attr: user ach oibríonn sé i gcomhthéacsanna async.

HttpRequest.get_host()

Filleann sé óstach tionscnaimh an iarratais ag baint úsáide as faisnéis ó na ceannteidil HTTP_X_FORWARDED_HOST (ife:setting: USE_X_FORWARDED_HOST cumasaithe) agus HTTP_HOST`, san ord sin. Mura soláthraíonn siad luach, úsáideann an modh teaglaim de SERVER_NAME agus SERVER_PORT mar a mionsonraítear in:pep: 3333.

Sampla: "127.0.0. 1:8000 “

<1035>Ardaíonn sé django.core.exceptions.disallowedHost mura bhfuil an t-óstach in:setting: ALLOWED_HOSTS nó go bhfuil an t-ainm fearainn neamhbhailí de réir: rfc: 1034/:rfc: 1035.

HttpRequest.get_port()

Tugann calafort tionscnaimh an iarratais ar ais ag baint úsáide as faisnéis ó na hathróga HTTP_X_FORWARDED_PORT` (ife:setting: USE_X_FORWARDED_PORT cumasaithe) agus SERVER_PORT META athróga, san ord sin.

HttpRequest.get_full_path()

Tugann sé an path ar ais, móide teaghrán ceisteanna curtha leis, más infheidhme.

Sampla: ” /minfo/music/banna/the_beatles/? print=true"

HttpRequest.get_full_path_info()

Cosúil le: Meth: get_full_path, ach úsáideann sé: attr: path_info in ionad:attr: path.

Sampla: ” /ceol/banda/the_beatles/? print=true"

HttpRequest.build_absolute_uri(location=None)

Tugann sé an fhoirm iomlán URI de ``suíomh ``ar ais. Mura gcuirtear aon suíomh ar fáil, socraítear an suíomh go ``request.get_full_path () ``.

Más URI iomlán é an suíomh cheana féin, ní athrófar é. Seachas sin tógtar an URI iomlán ag baint úsáide as na hathróga freastalaí atá ar fáil san iarratas seo. Mar shampla:

Python console
>>> request.build_absolute_uri()
'https://example.com/music/bands/the_beatles/?print=true'
>>> request.build_absolute_uri("/bands/")
'https://example.com/bands/'
>>> request.build_absolute_uri("https://example2.com/bands/")
'https://example2.com/bands/'

Tugann luach fianán ar ais do fhianán sínithe, nó ardaíonn sé eisceacht django.core.signing.badsignature mura bhfuil an síniú bailí a thuilleadh. Má sholáthraíonn tú an argóint réamhshocraithe cuirfear an t-eisceacht faoi chois agus cuirfear an luach réamhshocraithe sin ar ais ina ionad sin.

The optional salt argument can be used to put the cookie into a separate signature namespace. If supplied, the max_age argument will be checked against the signed timestamp attached to the cookie value to ensure the cookie is not older than max_age seconds.

Cookies signed by older Django versions are accepted by default for backwards compatibility. Set SIGNED_COOKIE_LEGACY_SALT_FALLBACK to False to reject them.

Mar shampla:

Python console
>>> request.get_signed_cookie("name")
'Tony'
>>> request.get_signed_cookie("name", salt="name-salt")
'Tony' # assuming cookie was set using the same salt
>>> request.get_signed_cookie("nonexistent-cookie")
KeyError: 'nonexistent-cookie'
>>> request.get_signed_cookie("nonexistent-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

Féach: doc: `síniú cripteagrafach' le haghaidh tuilleadh faisnéise. </topics/signing>

HttpRequest.is_secure()

Tugann sé ar ais True má tá an t-iarratas slán; is é sin, má rinneadh é le HTTPS.

HttpRequest.get_preferred_type(media_types)

Returns the preferred mime type from media_types, based on the Accept header, or None if the client does not accept any of the provided types.

Assuming the client sends an Accept header of text/html,application/json;q=0.8:

Python console
>>> request.get_preferred_type(["text/html", "application/json"])
"text/html"
>>> request.get_preferred_type(["application/json", "text/plain"])
"application/json"
>>> request.get_preferred_type(["application/xml", "text/plain"])
None

If the mime type includes parameters, these are also considered when determining the preferred media type. For example, with an Accept header of text/vcard;version=3.0,text/html;q=0.5, the return value of request.get_preferred_type() depends on the available media types:

Python console
>>> request.get_preferred_type(
...     [
...         "text/vcard; version=4.0",
...         "text/vcard; version=3.0",
...         "text/vcard",
...         "text/directory",
...     ]
... )
"text/vcard; version=3.0"
>>> request.get_preferred_type(
...     [
...         "text/vcard; version=4.0",
...         "text/html",
...     ]
... )
"text/html"
>>> request.get_preferred_type(
...     [
...         "text/vcard; version=4.0",
...         "text/vcard",
...         "text/directory",
...     ]
... )
None

(For further details on how content negotiation is performed, see RFC 9110 Section 12.5.1.)

Most browsers send Accept: */* by default, meaning they don't have a preference, in which case the first item in media_types would be returned.

Setting an explicit Accept header in API requests can be useful for returning a different content type for those consumers only. See Sampla idirbheartaíochta ábhair for an example of returning different content based on the Accept header.

HttpRequest.accepts(mime_type)

Returns True if the request's Accept header matches the mime_type argument:

Python console
>>> request.accepts("text/html")
True

Most browsers send Accept: */* by default, so this would return True for all content types.

See Sampla idirbheartaíochta ábhair for an example of using accepts() to return different content based on the Accept header.

HttpRequest.read(size=None)
HttpRequest.readline()
HttpRequest.readlines()
HttpRequest.__iter__()

Modhanna a chur i bhfeidhm comhéadan cosúil le comhad chun léamh ó shampla HttpRequest`. Fágann sé seo gur féidir iarratas atá ag teacht isteach a ithe ar bhealach sruthú. Is é cás úsáide coitianta ná ualach mór XML a phróiseáil le parser athraitheach gan crann XML iomlán a thógáil i gcuimhne.

Mar gheall ar an gcomhéadan caighdeánach seo, is féidir sampla HttpRequest a chur ar aghaidh go díreach chuig parser XML amsúil:class: ~xml.etree.elementTree.ElementTree:

Code
import xml.etree.ElementTree as ET

for element in ET.iterparse(request):
    process(element)

Rud Querydict

class QueryDict

I réad:class: HttpRequest, is cásanna de Django.http.QueryDict` iad tréithe: ~HttpRequest.Get agus:attr: ~HttpRequest.post `, aicme cosúil le foclóir saincheaptha chun déileáil le luachanna iolracha don eochair chéanna. Tá sé seo riachtanach toisc go dtéann roinnt eilimintí foirme HTML, go háiri <select multiple>the ``, luachanna iolracha don eochair chéanna.

Beidh na QueryDict`s ag Request.Post` agus Request.Get inathraithe nuair a bhíonn rochtain orthu i ngnáthtimthriall iarrata/freagartha. Chun leagan inathraithe a fháil ní mór duit: meth: Querydict.copy a úsáid.

Modhanna

QueryDict implements all the standard dictionary methods because it's a subclass of dictionary. Exceptions are outlined here:

QueryDict.__init__(query_string=None, mutable=False, encoding=None)

Cuireann sé réad Querydict bunaithe ar query_string.

Python console
>>> QueryDict("a=1&a=2&c=3")
<QueryDict: {'a': ['1', '2'], 'c': ['3']}>

Mura gcuirtear query_string isteach, beidh an Querydict` mar thoradh air folamh (ní bheidh aon eochracha ná luachanna aige).

Beidh an chuid is mó de Querydict a thagann leat, agus go háirithe iad siúd ag Request.Post agus Request.Get, neathraithe. Má tá ceann á dhéanamh agat féin, is féidir leat é a dhéanamh inathraithe trí mutable=True a chur chuig a ``__init__ () ``.

Déanfar teaghráin chun eochracha agus luachanna a shocrú a thiontú ó encoding go str`. Mura bhfuil encoding socraithe, déanann sé réamhshocraithe:setting: DEFAULT_CHARSET.

classmethod QueryDict.fromkeys(iterable, value='', mutable=False, encoding=None)

Cruthaíonn sé QueryDict nua le heochracha ó iterable agus gach luach atá comhionann le luach. Mar shampla:

Python console
>>> QueryDict.fromkeys(["a", "a", "b"], value="val")
<QueryDict: {'a': ['val', 'val'], 'b': ['val']}>
QueryDict.__getitem__(key)

Returns the last value for the given key; or an empty list ([]) if the key exists but has no values. Raises django.utils.datastructures.MultiValueDictKeyError if the key does not exist. (This is a subclass of Python's standard KeyError, so you can stick to catching KeyError.)

Python console
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.__getitem__("a")
'3'
>>> q.__setitem__("b", [])
>>> q.__getitem__("b")
[]
QueryDict.__setitem__(key, value)

Socraíonn an eochair a thugtar go [luach] (liosta a bhfuil a ghné aonair luach). Tabhair faoi deara nach féidir é seo, mar fheidhmeanna foclóra eile a bhfuil fo-iarsmaí acu, a ghlaoch ach ar Querydict` athraithe (mar shampla ceann a cruthaíodh via: meth: Querydict.copy).

QueryDict.__contains__(key)

Tugann sé ar ais True má tá an eochair tugtha socraithe. Ligeann sé seo duit, m.sh., if “foo” in request.get` a dhéanamh.

QueryDict.get(key, default=None)

Úsáideann sé an loighic chéanna amha:meth: __getitem__, le crúca chun luach réamhshocraithe a thabhairt ar ais mura bhfuil an eochair ann.

QueryDict.setdefault(key, default=None)

Cosúil le: Meth: dict.setdefault, ach amháin go n-úsáideann sé: meth: __setitem__ go hinmheánach.

QueryDict.update(other_dict)

Tógann sé Querydict nó foclóir. Cosúil le: Meth: dict.update, seachas aigh* cuireann sé leis na míreanna foclóra reatha seachas iad a chur in ionad. Mar shampla:

Python console
>>> q = QueryDict("a=1", mutable=True)
>>> q.update({"a": "2"})
>>> q.getlist("a")
['1', '2']
>>> q["a"]  # returns the last
'2'
QueryDict.items()

Cosúil le: Meth: dict.items, ach amháin go n-úsáideann sé seo an loighic luach deiridh céanna mar: meth: __getitem__ agus filleann sé réad athraitheora in ionad réad amharc. Mar shampla:

Python console
>>> q = QueryDict("a=1&a=2&a=3")
>>> list(q.items())
[('a', '3')]
QueryDict.values()

Cosúil le: Meth: dict.values, ach amháin go n-úsáideann sé seo an loighic luach deiridh céanna mar: meth: __getitem__ agus filleann sé athraitheoir in ionad réad amharc. Mar shampla:

Python console
>>> q = QueryDict("a=1&a=2&a=3")
>>> list(q.values())
['3']

Ina theannta sin, tá na modhanna seo a leanas ag Querydict:

QueryDict.copy()

Tugann cóip den réad ar ais ag baint úsáid:func: copy.deepcopy. Beidh an cóip seo inathraithe fiú mura raibh an bunaidh.

QueryDict.getlist(key, default=None)

Tugann liosta de na sonraí ar ais leis an eochair iarrtha. Tugann liosta folamh ar ais mura bhfuil an eochair ann agus is é réamhshocraithe None. Ráthaítear liosta a thabhairt ar ais mura bhfuil liosta an luach réamhshocraithe a chuirtear ar fáil.

QueryDict.setlist(key, list_)

Socraíonn an eochair a thugtar go list_ (gan cosúil: meth: __setitem__).

QueryDict.appendlist(key, item)

Cuireann sé mír leis an liosta inmheánach a bhaineann leis an eochair.

QueryDict.setlistdefault(key, default_list=None)

Cosúil le: Meth: setdefault, ach amháin go dtógann sé liosta luachanna in ionad luach amháin.

QueryDict.lists()

Like items(), except it includes all values, as a list, for each member of the dictionary. For example:

Python console
>>> q = QueryDict("a=1&a=2&a=3")
>>> q.lists()
[('a', ['1', '2', '3'])]
QueryDict.pop(key)

Tugann liosta luachanna ar ais don eochair a thugtar agus baineann sé iad ón bhfoclóir. Ardaíonn sé Keyerror mura bhfuil an eochair ann. Mar shampla:

Python console
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.pop("a")
['1', '2', '3']
QueryDict.popitem()

Baineann sé ball treallach den fhoclóir (ós rud é nach bhfuil aon choincheap ordaithe ann), agus tugann sé tuple dhá luach ina bhfuil an eochair agus liosta de na luachanna go léir don eochair. Ardaíonn sé Keyerror nuair a ghairtear ar fhoclóir folamh. Mar shampla:

Python console
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.popitem()
('a', ['1', '2', '3'])
QueryDict.dict()

Tugann sé ionadaíocht dict ar Querydict ar ais. I gcás gach péire (eochair, liosta) i QueryDict`, beidh (eochair, mír) ag dict, áit a bhfuil mír eilimint amháin den liosta, ag baint úsáide as an loighic chéanna amha:meth: QueryDict. __getitem__:

Python console
>>> q = QueryDict("a=1&a=3&a=5")
>>> q.dict()
{'a': '5'}
QueryDict.urlencode(safe=None)

Filleann sreang de na sonraí i bhformáid sreangán fiosrúcháin. Mar shampla:

Python console
>>> q = QueryDict("a=2&b=3&b=5")
>>> q.urlencode()
'a=2&b=3&b=5'

Úsáid an paraiméadar sábháilte chun carachtair nach dteastaíonn ionchódú uathu a rith. Mar shampla:

Python console
>>> q = QueryDict(mutable=True)
>>> q["next"] = "/a&b/"
>>> q.urlencode(safe="/")
'next=/a%26b/'

HttpResponse rudaí

class HttpResponse

I gcodarsnacht le:class: rudaí HttpRequest, a chruthaíonn Django go huathoibríoch, :class: Is iad rudaí HttpResponse freagracht ort. Tá gach radharc a scríobhann tú freagrach as: class: HttpResponse a chur ar aghaidh, a dhaonrú agus a thabhairt ar ais.

Tá an rang:class: HttpResponse ina gcónaí sa mhodúl:mod: django.http.

Úsáid

Steaghráin a rith

Is é an úsáid tipiciúil ná ábhar an leathanaigh, mar shreang, bytestring, nó:class: memoryview, a chur chuig an tógálaí:class: HttpResponse:

Python console
>>> 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(b"Bytestrings are also accepted.")
>>> response = HttpResponse(memoryview(b"Memoryview as well."))

Ach más mian leat ábhar a chur le chéile, is féidir leat ``freagra ``a úsáid mar réad cosúil le comhad:

Python console
>>> response = HttpResponse()
>>> response.write("<p>Here's the text of the web page.</p>")
>>> response.write("<p>Here's another paragraph.</p>")

Athraitheoirí a rith

Faoi dheireadh, is féidir leat HttpResponse` a chur ar athraitheoir seachas teaghráin. Itheoidh HttpResponse an t-athraitheoir láithreach, stóráilfidh sé a ábhar mar shreang, agus caitheann sé é. Dúntar rudaí le modh ``close () ``mar shampla comhaid agus gineadóirí láithreach.

Más gá duit an freagra a shruthú ón iterator chuig an gcliant, ní mór duit an rang:class: StreamInghttPresponse a úsáid ina ionad.

Réimsí ceanntásc a shoc

Chun réimse ceanntásc a shocrú nó a bhaint i do fhreagra, bain úsáid:attr: HttpResponse.headers:

Python console
>>> response = HttpResponse()
>>> response.headers["Age"] = 120
>>> del response.headers["Age"]

Is féidir leat ceanntásca a ionramháil freisin trí do fhreagra a chóireáil mar fhoclóir:

Python console
>>> response = HttpResponse()
>>> response["Age"] = 120
>>> del response["Age"]

Cuireann sé seo seachfhálaí chuig HttpResponse.Headers`, agus is é an comhéadan bunaidh a thairgeann HttpResponse`.

Nuair a bhíonn an comhéadan seo á úsáid agat, murab ionann agus foclóir, ní ardaíonn del Keyerror` mura bhfuil an réimse ceannteideal ann.

Is féidir leat ceanntásca a shocrú freisin ar instantiation:

Python console
>>> response = HttpResponse(headers={"Age": 120})

Chun na réimsí ceanntásc Cache-Control agus Vary a shocrú, moltar na modhanna: func: ~django.utils.cache.patch_cache_control agus:func: ~django.utils.cache.patch_vary_headers a úsáid ó:mod: django.utils.cache, ós rud é gur féidir luachanna iolracha, scartha le camóg a bheith ag na réimsí seo. Cinntíonn na modhanna “paiste” nach mbaintear luachanna eile, m.sh. a chuireann meán-earraí leis.

Ní féidir línte nua a bheith i réimsí ceanntásc HTTP. Ardóidh iarracht réimse ceanntásc ina bhfuil carachtar líne nua (CR nó LF) a shocrú BadHeaderROR

Ag rá leis an mbrabhsálaí an freagra a chaitheamh mar cheangaltán comhad

Chun a rá don bhrabhsálaí caitheamh leis an bhfreagra mar cheangaltán comhad, socraigh na ceannteidil Content-Type agus ``Content-Disposition`. Mar shampla, seo mar a d'fhéadfá scarbhileog Microsoft Excel a thabhairt ar ais:

Python console
>>> response = HttpResponse(
...     my_data,
...     headers={
...         "Content-Type": "application/vnd.ms-excel",
...         "Content-Disposition": 'attachment; filename="foo.xls"',
...     },
... )

Níl aon rud Django-sonrach faoin gceannteideal ``Content-Disposition`, ach is furasta dearmad a dhéanamh ar an gcomhréir, mar sin tá sé curtha san áireamh anseo.

tréithe

HttpResponse.content

Bytestring a léiríonn an t-ábhar, ionchódaithe ó shreang más gá.

HttpResponse.text

A string representation of HttpResponse.content, decoded using the response's HttpResponse.charset (defaulting to UTF-8 if empty).

HttpResponse.cookies

A http.cookies.SimpleCookie object holding the cookies included in the response.

HttpResponse.headers

Rud cás-neamhíogair, cosúil le dict a sholáthraíonn comhéadan do gach ceannteideal HTTP ar an bhfreagra, seachas ceannteideal Set-Cookie. Féach: Ref: socruithe ceanncheadr-fields agus:attr: HttpResponse.cookies.

HttpResponse.charset

Sreang a léiríonn an tacar charta ina ndéanfar an freagra a ionchódú. Mura dtugtar é ag am institiúcháin HttpResponse, bainfear as content_type` é agus mura n-éireoidh leis sin, úsáidfear an socrú:setting: DEFAULT_CHARSET.

HttpResponse.status_code

<9110 #section -15>An: RFC: Cód stádais HTTP don fhreagra.

Unless:attr: Socraítear réasúna_phrase go sainráite, modhnófar luach `status_code lasmuigh den tógálaí luach réas_phrase a mhodhnú freisin.

HttpResponse.reason_phrase

An frása chúis HTTP don fhreagra. <9110 #section -15.1>Úsáideann sé na frásaí cúis réamhshocraithe: rfc: `HTTP caighdeán' s.

Mura bhfuil sé socraithe go sainráite, socraítear réas_phrase ag luach: attr: status_code.

HttpResponse.streaming

Tá sé seo i gcónaí bréag.

Tá an tréith seo ann ionas gur féidir le middleware freagraí sruthú a chaitheamh go difriúil ó fhreagairtí rialta

HttpResponse.closed

Fíor má tá an freagra dúnta.

Modhanna

HttpResponse.__init__(content=b'', content_type=None, status=200, reason=None, charset=None, headers=None)

Cuireann sé réad HttpResponse leis an ábhar leathanaigh, an cineál ábhair agus na ceannteidil a thugtar.

Is minic gurb é content ná iterator, bytestring, :class: memoryview, nó teaghrán. Déanfar cineálacha eile a thiontú go bytestring tríd a n-ionadaíocht teaghrán a ionchódú. Ba chóir d'athraitheoirí teaghráin nó bytestrings a thabhairt ar ais agus déanfar iad sin a cheangal le chéile chun ábhar an fhreagra a fhoirmiú.

Is é content_type an cineál MIME a chomhlánann go roghnach ag ionchódú tacar carachtair agus úsáidtear é chun an ceannteideal HTTP Content-Type a líonadh. Mura sonraítear é, cruthaítear é le 'text/html' agus socruithe: DEFAULT_CHARSET agus socruithe: DEFAULT_CHARSET`, de réir réamhshocraithe: ``"text/html; charset = utf-8".

status is the HTTP status code for the response. You can use Python's http.HTTPStatus for meaningful aliases, such as HTTPStatus.NO_CONTENT.

Is é réas an frása freagartha HTTP. Mura gcuirtear ar fáil, úsáidfear abairt réamhshocraithe.

Is é charset an charset ina ndéanfar an freagra a ionchódú. Mura dtugtar é bainfear as content_type`, agus mura n-éiríonn leis sin, úsáidfear an socrú: setting: DEFAULT_CHARSET.

Is é headers a: aicme: dict ceannteidil HTTP don fhreagra.

HttpResponse.__setitem__(header, value)

Socraíonn an t-ainm ceanntásc tugtha don luach tugtha. Ba chóir go mbeadh ceannteannair agus luach` araon teaghráin.

HttpResponse.__delitem__(header)

Scriosann sé an ceanntásc leis an ainm tugtha. Teipeann sé go ciúin mura bhfuil an ceanntásc ann. Cás-neamh-íogair.

HttpResponse.__getitem__(header)

Tugann sé an luach don ainm ceanntásc tugtha ar ais. Cás-neamh-íogair.

HttpResponse.get(header, alternate=None)

Tugann sé an luach don cheanntásc a thugtar, nó malart mura bhfuil an ceannteideal ann.

HttpResponse.has_header(header)

Tugann sé “True`` nó False` bunaithe ar sheiceáil cás-neamh-íogair do cheanntásc leis an ainm tugtha.

HttpResponse.items()

Gníomhartha cosúil:meth: dict.items do cheanntásca HTTP ar an bhfreagra.

HttpResponse.setdefault(header, value)

Socraíonn sé ceanntásc mura bhfuil sé socraithe cheana féin.

Socraíonn fianán. Tá na paraiméadair mar an gcéanna le réad fianáin: class: ~http.cookies.morsel sa leabharlann caighdeánach Python.

  • Ba chóir go mbeadh max_age a:class: ~datetime.timedelta réad, líon sláireach soicind, nó None (réamhshocraithe) más chóir go mairfeadh an fianán ach chomh fada agus seisiún brabhsálaí an chliaint. Mura sonraítear ```deigh', ríomhfar é.

  • Ba chóir go mbeadh expires ina shreang sa fhormáid "Wdy, DD-mon-yy HH:MM:SS GMT"` nó réad ``datetime.datetime i UTC. Más réad datetime é scaipe, ríomhfar an max_age.

  • Úsáid domain más mian leat fianán tras-fearainn a shocrú. Mar shampla, socraíonn domain="example.com" fianán atá inléite ag na fearainn www.example.com, blog.example.com, srl. Seachas sin, ní bheidh fianán inléite ach ag an bhfearann a shocraigh é.

  • Úsáid secure=true mura dteastaíonn uait nach seolfar an fianán chuig an bhfreastalaí ach nuair a dhéantar iarratas leis an scéim https.

  • Úsáid HttpOnly=True` más mian leat JavaScript taobh an chliaint a chosc ó rochtain a bheith agat ar an bhfianán.

    Is bratach é HTTPOnly atá san áireamh i gceannteideal freagartha Set-Cookie HTTP. Tá sé mar chuid den <6265 #section -4.1.2.6> chaighdeán:rfc: RFC 6265 le haghaidh fianáin agus féadann sé a bheith ina bhealach úsáideach chun an baol go bhfaighidh script taobh an chliaint rochtain ar na sonraí cosanta fianán a mhaolú.

  • Úsáid sameSite='strict' nó sameSite='Lax' chun a rá don bhrabhsálaí gan an fianán seo a sheoladh agus iarratas tras-bhunús á dhéanamh agat. Ní thacaíonn gach brabhsálaí le SameSite, mar sin ní athsholáthar é ar chosaint CSRF Django, ach beart cosanta domhain é.

    Úsáid sameSite='none' (teaghrán) chun a rá go sainráite go seoltar an fianán seo le gach iarratas ar an láithreán céanna agus tras-láithreán.

Like set_cookie(), but cryptographic signing the cookie before setting it. Use in conjunction with HttpRequest.get_signed_cookie(). You can use the optional salt argument to put the cookie into a separate signature namespace, but you will need to remember to pass it to the corresponding HttpRequest.get_signed_cookie() call.

Scriosann sé an fianán leis an eochair a thugtar. Teipeann sé go ciúin mura bhfuil an eochair ann.

Mar gheall ar an mbealach a oibríonn fianáin, ba chóir go mbeadh path` agus domain na luachanna céanna a d'úsáid tú i set_cookie () - ar shlí eile ní fhéadfar an fianán a scriosadh.

HttpResponse.close()

This method is called at the end of the request directly by the WSGI or ASGI server.

HttpResponse.write(content)

Déanann an modh seo réad cosúil le comhad mar shampla an:class: HttpResponse.

HttpResponse.flush()

Déanann an modh seo réad cosúil le comhad mar shampla an:class: HttpResponse.

HttpResponse.tell()

Déanann an modh seo réad cosúil le comhad mar shampla an:class: HttpResponse.

HttpResponse.getvalue()

Tugann luach: attr: HttpResponse.content ar ais. Déanann an modh seo réad cosúil le sruth mar shampla an:class: HttpResponse.

HttpResponse.readable()

I gcónaí Bréag. Déanann an modh seo réad cosúil le sruth mar shampla an:class: HttpResponse.

HttpResponse.seekable()

I gcónaí Bréag. Déanann an modh seo réad cosúil le sruth mar shampla an:class: HttpResponse.

HttpResponse.writable()

“Fíor” i gcónaí. Déanann an modh seo réad cosúil le sruth mar shampla an:class: HttpResponse.

HttpResponse.writelines(lines)

Scríobhann liosta línte don fhreagra. Ní chuirtear deighilteoirí líne leis. Déanann an modh seo réad cosúil le sruth mar shampla an:class: HttpResponse.

Fo-aicmí HttpResponse`

Cuimsíonn Django roinnt fo-aicmí HttpResponse a láimhseálann cineálacha éagsúla freagraí HTTP. Cosúil le HttpResponse`, tá na fo-aicmí seo ina gcónaí in:mod: django.http.

class HttpResponseRedirect

The first argument to the constructor is required -- the path to redirect to. This can be a fully qualified URL (e.g. 'https://www.yahoo.com/search/'), an absolute path with no domain (e.g. '/search/'), or even a relative path (e.g. 'search/'). In that last case, the client browser will reconstruct the full URL itself according to the current path.

The constructor accepts an optional preserve_request keyword argument that defaults to False, producing a response with a 302 status code. If preserve_request is True, the status code will be 307 instead.

The constructor accepts an optional max_length keyword argument to override the maximum allowed length for the redirect URL. You can set it to None to disable the length check.

See HttpResponse for other optional constructor arguments.

url

Léiríonn an tréith léite amháin seo an URL a atreoróidh an freagra chuig (comhionann leis an gceannteideal freagartha ``Suíomh ``).

class HttpResponsePermanentRedirect

Like HttpResponseRedirect, but it returns a permanent redirect (HTTP status code 301) instead of a "found" redirect (status code 302). When preserve_request=True, the response's status code is 308.

class HttpResponseNotModified

Ní ghlacann an tógálaí aon argóintí agus níor cheart aon ábhar a chur leis an bhfreagra seo. Úsáid é seo chun a ainmniú nár modhnaíodh leathanach ó iarratas deireanach an úsáideora (cód stádais 304).

class HttpResponseBadRequest

Gníomhaíonn sé díreach cosúil:class: HttpResponse ach úsáideann sé cód stádais 400.

class HttpResponseNotFound

Gníomhaíonn sé díreach cosúil:class: HttpResponse ach úsáideann sé cód stádais 404.

class HttpResponseForbidden

Gníomhaíonn sé díreach cosúil:class: HttpResponse ach úsáideann sé cód stádais 403.

class HttpResponseNotAllowed

Cosúil le: class: HttpResponse, ach úsáideann sé cód stádais 405. Teastaíonn an chéad argóint don tógálaí: liosta de na modhanna ceadaithe (m.sh. ['GET', 'POST']).

class HttpResponseGone

Gníomhaíonn sé díreach cosúil:class: HttpResponse ach úsáideann sé cód stádais 410.

class HttpResponseServerError

Gníomhaíonn sé díreach cosúil:class: HttpResponse ach úsáideann sé cód stádais 500.

Ranganna freagartha saincheaptha

If you find yourself needing a response class that Django doesn't provide, you can create it with the help of http.HTTPStatus. For example:

Code
from http import HTTPStatus
from django.http import HttpResponse


class HttpResponseNoContent(HttpResponse):
    status_code = HTTPStatus.NO_CONTENT

JSONResponse rudaí

class JsonResponse(data, encoder=DjangoJSONEncoder, safe=True, json_dumps_params=None, **kwargs)

An:class: fo-aicme HttpResponse a chabhraíonn le freagra ionchódaithe JSON a chruthú. Oidhreacht aige an chuid is mó d'iompar óna sáraicme le lánúin difríochtaí:

Tá a cheanntásc réamhshocraithe Content-Type socraithe ag:mimetype: application/json.

Ba chóir go mbeadh an chéad pharaiméadar, sonraí ``, mar shampla ``dict. Má tá an paraiméadar sábháilte ``socraithe go ``False (féach thíos) is féidir é a bheith ar aon réad inserializable JSON.

Úsáidfear an encoder, atá réamhshocraithe to:class: django.core.serializers.json.djangojsonEncoder, chun na sonraí a shraitheadh. Féach: Ref: `JSON sraitheoireacht <serialization-formats-json>`le haghaidh tuilleadh sonraí faoin sraitheoir seo.

Tá an paraiméadar boolean sábháilte ``réamhshocraithe go ``True. Má tá sé socraithe go False, is féidir aon rud a chur ar aghaidh le haghaidh sraitheadh (ar shlí eile ní cheadaítear ach cásanna dict). Má tá sábháilte True agus má chuirtear réad neamh-dict ar aghaidh mar an chéad argóint, ardófar a:exc: TypeError.

Is foclóir argóintí eochairfhocal é an paraiméadar json_dumps_params le dul chuig an nglao ``json.dumps () ``a úsáidtear chun an freagra a ghiniúint.

Úsáid

D'fhéadfadh cuma a bheith ar úsáid tipiciúil:

Python console
>>> from django.http import JsonResponse
>>> response = JsonResponse({"foo": "bar"})
>>> response.content
b'{"foo": "bar"}'

Rud neamh-fhoclóra a shraitheadh

D'fhonn rudaí seachas dict` a shraitheadh ní mór duit an paraiméadar sábháilte a shocrú go False:

Python console
>>> response = JsonResponse([1, 2, 3], safe=False)

Gan dul ar safe=False, ardófar a:exc: TypeError.

Tabhair faoi deara go bhfuil API bunaithe ar rudaí dict níos leathnaithe, níos solúbtha, agus go ndéanann sé níos éasca comhoiriúnacht ar aghaidh a choinneáil. Dá bhrí sin, ba cheart duit rudaí neamh-dict a sheachaint i bhfreagra ionchódaithe JSON.

An t-ionchódóir JSON réamhshocraithe a

Más gá duit rang ionchódóra JSON difriúil a úsáid is féidir leat an paraiméadar ``encoder` a chur ar aghaidh chuig an modh tógálaí:

Python console
>>> response = JsonResponse(data, encoder=MyJSONEncoder)

Streaminghttpreresponse rudaí

class StreamingHttpResponse

Úsáidtear an rang:class: StreamInghttPresponse chun freagra a shruthlú ó Django chuig an mbrabhsálaí.

Úsáid shamplach de:class: StreamInghttPresponse faoi WSGI is ea ábhar a shruthlú nuair a thógfadh an freagra rófhada nó úsáideadh an iomarca cuimhne. <streaming-csv-files>Mar shampla, tá sé úsáideach le haghaidh: ref: `comhaid mhóra CSV a ghiniúint `.

Tá breithnithe feidhmíochta ann agus é seo á dhéanamh agat, áfach. Tá Django, faoi WSGI, deartha le haghaidh iarratais ghearrshaoil. Ceanglóidh freagraí sruthú próiseas oibrithe ar feadh tréimhse iomlán na freagartha. D'fhéadfadh droch-fheidhmíocht a bheith mar thoradh air seo

Go ginearálta, déanfá tascanna daor lasmuigh den timthriall iarrata-freagartha, seachas dul i ngleic le freagra sruthaithe.

Agus tú ag freastalú faoi ASGI, áfach, ní gá a: class: StreamInghttPrésponse stop a chur ar iarratais eile a sheirbheáil agus iad ag fanacht le I/O. Osclaíonn sé seo an fhéidearthacht iarratais fadré ar ábhar sruthú agus patrúin a chur i bhfeidhm mar vótaíocht fhada, agus imeachtaí a sheoltar ó fhreastalaí.

Fiú amháin faoi nóta ASGI, níor cheart: StreamInghttPresponse a úsáid ach amháin i gcásanna ina bhfuil sé riachtanach go hiomlán nach ndéantar an t-ábhar iomlán a athrú sula n-aistrítear na sonraí chuig an gcliant. Toisc nach féidir rochtain a fháil ar an ábhar, ní féidir le go leor middleware feidhmiú de ghnáth. Mar shampla ní féidir na ceannteidil Etag agus Content-Length a ghiniúint le haghaidh freagraí sruthú.

Ní fo-aicme de:class: HttpResponse é an:class: HttpResponse, toisc go bhfuil API beagán difriúil aige. Mar sin féin, tá sé beagnach comhionann, leis na difríochtaí suntasacha seo a leanas:

  • Ba chóir athraitheoir a thabhairt dó a thugann bytestrings, :class: memoryview, nó teaghráin mar ábhar. Agus tú ag freastal faoi WSGI, ba chóir go mbeadh sé seo ina athraitheoir sioncronaithe. Agus tú ag freastal faoi ASGI, ba chóir go mbeadh sé ina athraitheoir async.

  • Ní féidir leat rochtain a fháil ar a ábhar, ach amháin tríd an réad freagartha féin a athrá. Níor chóir go dtarlódh sé seo ach nuair a chuirtear an freagra ar ais chuig an gcliant: níor cheart duit an freagra a athrú duit féin.

    Faoi WSGI déanfar an freagra a athdhéanamh go sioncrónach. Faoi ASGI déanfar an freagra a athrá go asincrónach. (Sin é an fáth go gcaithfidh an cineál iterator an prótacal atá á úsáid agat a mheaitseáil.)

    Chun timpiste a sheachaint, déanfar cineál athraitheora mícheart a mhapáil leis an gcineál ceart le linn athraithe, agus ardófar rabhadh, ach chun é seo a dhéanamh caithfear an t-athraitheoir a ithe go hiomlán, rud a sháraíonn an cuspóir a: class: StreamInghttPresponse a úsáid ar chor ar bith.

  • Níl aon tréith ``ábhar ``aige. Ina áit sin, tá a: attr: ~StreamInghttPresponse.streaming_content tréith aige. Is féidir é seo a úsáid i lár earraí chun an freagra a fhilleadh in-athrá, ach níor cheart é a ithe.

  • It has no text attribute, as it would require iterating the response object.

  • Ní féidir leat na modhanna réad cosúil le comhad tell () ``nó `scríobh () a úsáid. Má dhéantar é sin, beidh eisceacht ann.

Tá an bunaicme: Class: HttpResponseBase coitianta idir: aicme: HttpResponse agus:class: StreamInghttPresponse.

tréithe

StreamingHttpResponse.streaming_content

Athraitheoir ar an ábhar freagartha, ionchódaithe bytestring de réir: attr: HttpResponse.charSet.

StreamingHttpResponse.status_code

<9110 #section -15>An: RFC: Cód stádais HTTP don fhreagra.

Unless:attr: Socraítear réasúna_phrase go sainráite, modhnófar luach `status_code lasmuigh den tógálaí luach réas_phrase a mhodhnú freisin.

StreamingHttpResponse.reason_phrase

An frása chúis HTTP don fhreagra. <9110 #section -15.1>Úsáideann sé na frásaí cúis réamhshocraithe: rfc: `HTTP caighdeán' s.

Mura bhfuil sé socraithe go sainráite, socraítear réas_phrase ag luach: attr: status_code.

StreamingHttpResponse.streaming

Tá sé seo i gcónaí ``Fíor`.

StreamingHttpResponse.is_async

Boolean a léiríonn an bhfuil: attr: StreamInghttPresponse.streaming_content is iterator asincrónach nó nach bhfuil.

Tá sé seo úsáideach do mheánearraí a theastaíonn uathu fillte:attr: StreamInghttPresponse.streaming_content.

Dícheangail láimhseáil

Má dhícheanglaíonn an cliant le linn freagra sruthú, cuirfidh Django an coroutine atá ag láimhseáil an freagra ar ceal. Más mian leat acmhainní a ghlanadh de láimh, is féidir leat é sin a dhéanamh tríd an Asyncio.CancelleDerror` a ghabháil:

Code
async def streaming_response():
    try:
        # Do some work here
        async for chunk in my_streaming_iterator():
            yield chunk
    except asyncio.CancelledError:
        # Handle disconnect
        ...
        raise


async def my_streaming_view(request):
    return StreamingHttpResponse(streaming_response())

Ní thaispeánann an sampla seo ach conas dícheangal cliant a láimhseáil agus an freagra ag sruthú. <async-handling-disconnect>Má dhéanann tú oibríochtaí fadtéarmacha i do thuairim sula bhfilleann tú an réad StreaminghttPresponse ar ais, ansin b'fhéidir gur mhaith leat freis:ref: `dícheangail a láimhseáil sa radharc `féin.

Rudaí FileResponse

class FileResponse(open_file, as_attachment=False, filename='', **kwargs)

FileResponse is a subclass of StreamingHttpResponse optimized for binary files. It uses wsgi.file_wrapper if provided by the wsgi server, otherwise it streams the file out in small chunks.

Má tá as_attachment=True, socraítear an ceannteideal Content-Disposition` go ``attachment, a iarrann ar an mbrabhsálaí an comhad a thairiscint don úsáideoir mar íoslódáil. Seachas sin, ní shocrófar ceanntásc Content-Disposition` le luach ``inline (réamhshocraithe an bhrabhsálaí) ach amháin má tá ainm comhaid ar fáil.

Mura bhfuil ainm ag open_file nó mura bhfuil ainm open_file` oiriúnach, tabhair ainm comhaid saincheaptha ag baint úsáide as an paraiméadar file. Tabhair faoi deara má chuireann tú réad cosúil le comhad cosúil le IO.Bytesio, is é do chúram search () ``é sula ndéantar é a chur chuig `FileResponse.

Socraítear an ceannteideal Content-Length go huathoibríoch nuair is féidir é a thuairisciú ó ábhar open_file.

Socraítear an ceannteideal Content-Type go huathoibríoch nuair is féidir é a thuairisciú ón ainm comhad ``, nó ainm `open_file.

Glacann FileResponse le haon rud cosúil le comhad le hábhar dénártha, mar shampla comhad oscailte i mód dénártha mar sin:

Python console
>>> from django.http import FileResponse
>>> response = FileResponse(open("myfile.png", "rb"))

Dúnfar an comhad go huathoibríoch, mar sin ná oscail é le bainisteoir comhthéacs.

Modhanna

FileResponse.set_headers(open_file)

Glaofar an modh seo go huathoibríoch le linn an tionscnamh freagartha agus socraítear ceannteidil éagsúla (Content-Fad ``, `Content-Type, agus`` Content-Disposition ) ag brath ar ``oscailte_comhad.

Aicme HttpResponseBase

class HttpResponseBase

Tá an rang:class: HttpResponseBase coitianta do gach freagra Django. Níor chóir é a úsáid chun freagraí a chruthú go díreach, ach d'fhéadfadh sé a bheith úsáideach chun cineál-sheiceáil.

View as Markdown Edit this page on GitHub Official version