Úsáideacha DjangoLink to this heading#

django.utils.cacheLink to this heading#

Tá feidhmeanna cúntóra sa mhodúl seo chun caismú HTTP a rialú. Déanann sé amhlaidh trí cheannteideal freagraí Vary a bhainistiú. Cuimsíonn sé feidhmeanna chun ceanntásc na rudaí freagartha a phaisteáil go díreach agus maisitheoirí a athraíonn feidhmeanna chun an ceannteideal sin a dhéanamh iad féin.

Le haghaidh faisnéise faoin gceannteideal Vary, féach:rfc: 9110 #section -12.5.5.

Go bunúsach, sainmhíníonn an ceannteideal HTTP Vary cé na ceannteidil ba chóir do taisce a chur san áireamh agus a eochair taisce á thógáil. Ní mór d'iarratais leis an gcosán céanna ach ábhar ceanntásc difriúil do cheanntásca a ainmnítear in Vary eochracha taisce éagsúla a fháil chun ábhar mícheart a sheachadadh a

Mar shampla, :doc: bheadh ar mheánghearraí idirnáisiúnaíochta idirdhealú a dhéanamh ar chaisce</topics/i18n/index> anna leis an gceannteideal ``Accept-Teanga ``.

patch_cache_control(response, **kwargs)Link to this definition#

Paiseann an fheidhm seo an ceannteideal ``Cache-Control ``trí gach argóint eochairfhocal a chur leis. Is é seo a leanas an claochlú:

• Déantar gach ainm paraiméadar eochairfhocal a chasadh go litreacha beaga, agus déantar béim a thiontú go hiphens.

• Más luach paraiméadar True (go díreach True, ní fíor-luach amháin), ní chuirtear ach ainm an pharaiméadair leis an gceannteideal.

• Cuirtear na paraiméadair eile go léir lena luach, tar éis ``str () ``a chur i bhfeidhm air.

get_max_age(response)Link to this definition#

Tugann sé an t-aois uasta ar ais ón gceannteideal Cache-Control freagra mar shláimhir (nó None mura bhfuarthas é nó mura raibh sé ina slámhshláir).

patch_response_headers(response, cache_timeout=None)Link to this definition#

Cuireann sé roinnt ceanntála úsáideacha leis an réad HttpResponse a thugtar:

• ``Deireadh ``

• ``Rialú Cache ``

Ní chuirtear gach ceannteideal leis ach mura bhfuil sé socraithe cheana féin.

Tá cache_timeout i soicindí. Úsáidtear an socrú: SETTING: CACHE_MIDDLEWARE_SECONDS de réir réamhshocraithe.

add_never_cache_headers(response)Link to this definition#

Cuireann ceanntásc Expires leis an dáta/am reatha.

Cuireann sé ceannteideal Cache-Control: max-age = 0, no-cache, no-store, must-athbhailíniú, príobháideach le freagra chun a léiriú nár chóir leathanach a chosc riamh.

Ní chuirtear gach ceannteideal leis ach mura bhfuil sé socraithe cheana féin.

patch_vary_headers(response, newheaders)Link to this definition#

Cuireann (nó nuashonraíonn sé) an ceannteideal Vary sa réad HttpResponse a thugtar. Is liosta d'ainmneacha ceanntásc is ea newheaders ar chóir a bheith i Vary. Má tá réiltín i gceanntásca, ansin beidh réiltín amháin *' comhdhéanta de cheanntásc Vary, de réir: rfc: 9110 #section -12.5.5. Seachas sin, ní bhaintear ceanntásca atá ann cheana i Vary.

get_cache_key(request, key_prefix=None, method='GET', cache=None)Link to this definition#

Tugann eochair taisce ar ais bunaithe ar an gcosán iarratais. Is féidir é a úsáid i gcéim an iarratais toisc go dtarraingíonn sé liosta na gceanntásca le cur san áireamh ón gclárlann cosáin domhanda agus úsáideann sé iad siúd chun eochair taisce a thógáil chun seiceáil ina choinne.

Mura bhfuil aon cheannliosta stóráilte ann, ní mór an leathanach a atógáil, mar sin filleann an fheidhm seo ``None ``.

learn_cache_key(request, response, cache_timeout=None, key_prefix=None, cache=None)Link to this definition#

Foghlaimíonn sé cad iad na ceanntásca atá le cur san áireamh do chosán iarratais éigin ón réad freagartha Stórálann sé na ceannteidil sin i gclárlann cosáin domhanda ionas go mbeidh a fhios ag rochtain níos déanaí ar an gcosán sin cad iad na ceanntásca atá le cur san áireamh gan an réad Ainmnítear na ceanntásca i gceanntásc Vary den fhreagra, ach ba mhaith linn giniúint freagartha a chosc.

Stóráiltear liosta na gceanntásca atá le húsáid le haghaidh giniúint eochair taisce sa taisce céanna leis na leathanaigh féin. Má thugann an taisce roinnt sonraí as an taisce, ciallaíonn sé seo go gcaithfimid an freagra a thógáil uair amháin chun teacht ar an gceannteideal Vary agus mar sin ag liosta na gceanntásc le húsáid don eochair taisce.

django.utils.dateparseLink to this heading#

Tá na hairíonna seo a leanas ag na feidhmeanna atá sainmhínithe sa mhodúl seo

• Glacann siad le teaghráin i bhformáidí dáta/ama ISO 8601 (nó roinnt roghanna dlúth) agus filleann siad rudaí ó na ranganna comhfhreagracha i modúl Python: MOD: datetime.

• Ardaíonn siad: exc: ValueError má tá a n-ionchur formáidithe go maith ach nach dáta nó am bailí é.

• Filleann siad ``None ``mura bhfuil sé formáidithe go maith ar chor ar bith.

• Glacann siad suas le taifeach picosecond in ionchur, ach cuireann siad é a ghearradh go micreasoicind, ós rud é sin a thacaíonn Python le.

parse_date(value)Link to this definition#

Déanann sé teaghrán a pháirseáil agus a: class: datetime.date ar ais.

parse_time(value)Link to this definition#

Déanann sé teaghrán a pháirseáil agus a: class: datetime.time ar ais.

Ní thacaítear le háirithe UTC; má chuireann luach cur síos ar cheann amháin, is é None an toradh.

parse_datetime(value)Link to this definition#

Déanann sé teaghrán a pháirseáil agus a: class: datetime.datetime ar ais.

Tacaítear le hoiriúintí UTC; má chuireann value cur síos ar cheann amháin, is é a: class: datetime.timezone tréith tzinfo an torthaí.

parse_duration(value)Link to this definition#

Déanann sé teaghrán a pháirseáil agus a: class: datetime.timedelta ar ais.

Tá súil ag súil le sonraí san fhormáid "DD HH:MM:SS.uuuuuuu", "DD HH:MM:SS, uuuuuu", nó mar a shonraítear le ISO 8601 (m.sh. P4DT1H15M20S` atá coibhéis le 4 1:15:20 ``) nó formáid eatramh lae-ama PostgreSQL (m.sh. `3 lá 04:05:06).

``django.utils.decorators ``Link to this heading#

method_decorator(decorator, name='')Link to this definition#

Athraíonn maisitheoir feidhme ina mhaisitheoir modh. Is féidir é a úsáid chun modhanna nó ranganna a mhaisiú; sa chás deireanach, is é ainm ``ainm ainm an mhodha atá le maisiú agus tá sé riachtanach.

D'fhéadfadh go mbeadh “maisitheoir” ina liosta nó tiúpla feidhmeanna freisin. Tá siad fillte in ord droim ionas gurb é an t-ordú glaonna an t-ord ina bhfuil na feidhmeanna le feiceáil sa liosta/tuple.

Féach: tagairt: `tuairimí bunaithe ar rang a mhaisiú <decorating-class-based-views>`mar shampla úsáid.

decorator_from_middleware(middleware_class)Link to this definition#

Mar gheall ar rang lár-earraí, filleann sé maisitheoir radharc ar ais. Ligeann sé seo duit feidhmiúlacht middleware a úsáid ar bhonn aghaidh an amharc. Cruthaítear an middleware gan aon pharams a rith.

Glacann sé le middleware atá comhoiriúnach le seanstíl Django 1.9 agus níos luaithe (modhanna mar process_request () `, process_exception ()`, agus ``process_response () ``).

decorator_from_middleware_with_args(middleware_class)Link to this definition#

Cosúil le decorator_from_middleware`, ach filleann feidhm a ghlacann leis na hargóintí atá le cur chuig an middleware_class. Mar shampla, cruthaítear maisitheoir:func: ~django.views.decorators.cache.cache_page ón cacheMiddleware` mar seo:

Code

cache_page = decorator_from_middleware_with_args(CacheMiddleware)


@cache_page(3600)
def my_view(request):
    pass

sync_only_middleware(middleware)Link to this definition#

<async-middleware>Marcaíonn sé meán-earraí mar: ref: `synchronous-only `. (An réamhshocrú i Django, ach tugann sé seo deis duit cruthúnas sa todhchaí má athraíonn an réamhshocrú riamh i scaoileadh amach anseo.)

async_only_middleware(middleware)Link to this definition#

<async-middleware>Marcálann sé meán-earraí mar: ref: `asynchronous-only `. Fillfidh Django é i lúb imeachta asincrónach nuair a ghlaofar air ón gcosán iarratais WSGI.

sync_and_async_middleware(middleware)Link to this definition#

Marcálann sé meán-earraí mar: ref: sync agus async comhoiriúnach <async-middleware>, ceadaíonn sé seo iarratais a thiontú a sheachaint. Ní mór duit braite an cineál iarratais reatha a chur i bhfeidhm chun an maisitheoir seo a úsáid. <async-middleware>Féach: ref: `doiciméadú middleware asincrónach `le haghaidh sonraí.

django.utils.encodingLink to this heading#

smart_str(s, encoding='utf-8', strings_only=False, errors='strict')Link to this definition#

Filleann sé réad str a léiríonn réad treallach s. Déileálann sé le bytestrings ag baint úsáide as an codec encoding.

Má tá strings_only True, ná tiontaigh (roinnt) rudaí neamh-shreangacha.

is_protected_type(obj)Link to this definition#

Faigh amach an bhfuil an t-ábhar réada de chineál cosanta.

Caomhnaítear rudaí de chineálacha cosanta mar atá nuair a chuirtear ar aghaidh chuig ``force_str (strings_only=true) ``.

force_str(s, encoding='utf-8', strings_only=False, errors='strict')Link to this definition#

Cosúil le ``smart_str () ``, ach amháin go ndéantar cásanna leisciúla a réiteach ar teaghráin, seachas a choinneáil mar rudaí leisciúla.

Má tá strings_only True, ná tiontaigh (roinnt) rudaí neamh-shreangacha.

smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict')Link to this definition#

Tugann sé leagan bytestring de réad treallach s, ionchódaithe mar a shonraítear i encoding.

Má tá strings_only True, ná tiontaigh (roinnt) rudaí neamh-shreangacha.

force_bytes(s, encoding='utf-8', strings_only=False, errors='strict')Link to this definition#

Cosúil le smart_bytes, ach amháin go ndéantar cásanna leisciúla a réiteach ar bytestrings, seachas a choinneáil mar rudaí leisciúla.

Má tá strings_only True, ná tiontaigh (roinnt) rudaí neamh-shreangacha.

iri_to_uri(iri)Link to this definition#

Tiontaigh cuid Aitheantóir Acmhainní Idirnáisiúnta (IRI) go cuid URI atá oiriúnach lena áireamh i URL.

Seo an algartam ó chuid 3.1 de:rfc: 3987 #section -3.1, atá beagán simplithe ós rud é go nglactar leis gur sreang é an t-ionchur seachas sruth beot treallach.

Tógann sé IRI (sreang nó UTF-8 bytes) agus filleann sé teaghrán ina bhfuil an toradh ionchódaithe.

uri_to_iri(uri)Link to this definition#

Athraíonn Aitheantóir Acmhainní Aonfhoirmeach ina Aitheantóir Acmhainní Idir

Is algartam é seo ó chuid 3.2 de:rfc: 3987 #section -3.2.

Tógann sé URI i mbeátaí ASCII agus filleann sé teaghrán ina bhfuil an toradh ionchódaithe.

filepath_to_uri(path)Link to this definition#

Tiontaigh cosán córais chomhaid go cuid URI atá oiriúnach le cuimsiú i URL. Glactar leis gurb é an cosán UTF-8 bytes, string, nó a: class: ~pathLib.path.

This method will encode certain characters that would normally be recognized as special characters for URIs. Note that this method does not encode the ' character, as it is a valid character within URIs. See encodeURIComponent() JavaScript function for more details.

Filleann sé teaghrán ASCII ina bhfuil an toradh ionchódaithe.

escape_uri_path(path)Link to this definition#

Éalaíonn sé na carachtair neamhshábháilte ón gcuid cosáin d'Aitheantóir Acmhainní Aonfhoirmeach (URI).

django.utils.feedgeneratorLink to this heading#

Úsáid samplach:

>>> from django.utils import feedgenerator
>>> feed = feedgenerator.Rss201rev2Feed(
...     title="Poynter E-Media Tidbits",
...     link="https://www.poynter.org/tag/e-media-tidbits/",
...     description="A group blog by the sharpest minds in online media/journalism/publishing.",
...     language="en",
... )
>>> feed.add_item(
...     title="Hello",
...     link="https://www.holovaty.com/test/",
...     description="Testing.",
... )
>>> with open("test.rss", "w") as fp:
...     feed.write(fp, "utf-8")
...

Chun roghnú gineadóir a shimpliú bain úsáid as FeedGenerator.defaultFeed atá RSS201Rev2Feed faoi láthair

For definitions of the different versions of RSS, see The myth of RSS compatibility.

get_tag_uri(url, date)Link to this definition#

Cruthaíonn TagUri.

See How to make a good ID in Atom.

django.utils.functionalLink to this heading#

class cached_property(func)Link to this definition#

Cuireann an maisitheoir @cached_property toradh modh le hargóint ``féin` amháin mar mhaoin. Leanfaidh an toradh taisceáilte chomh fada agus a dhéanann an cás, mar sin má chuirtear an cás timpeall agus má ghairmtear an fheidhm ina dhiaidh sin, cuirfear an toradh taisceáilte ar ais.

Smaoinigh ar chás tipiciúil, ina bhféadfadh go mbeadh gá le dearcadh modh samhail a ghlaoch chun ríomh éigin a dhéanamh, sula gcuirtear an t-áis samhail isteach sa chomhthéacs, áit a bhféadfadh an teimpléad an modh a ghairm arís:

Code

# the model
class Person(models.Model):
    def friends(self):
        # expensive computation
        ...
        return friends


# in the view:
if person.friends():
    ...

Agus sa teimpléad bheadh agat:

Django template

{% for friend in person.friends %}

Anseo, glaofar ar cairde () ``faoi dhó. Ós rud é go bhfuil an cás ``pearsa` sa radharc agus an teimpléad mar an gcéanna, is féidir an modh cairde () ``a mhaisiú le @cached_property ``a sheachaint:

Code

from django.utils.functional import cached_property


class Person(models.Model):
    @cached_property
    def friends(self): ...

Tabhair faoi deara toisc gur maoin é an modh anois, i gcód Python caithfear rochtain a fháil go cuí air:

Code

# in the view:
if person.friends:
    ...

Is féidir an luach taisceáilte a chóireáil mar ghnáthtréith den chás:

Code

# clear it, requiring re-computation next time it's called
person.__dict__.pop("friends", None)

# set a value manually, that will persist on the instance until cleared
person.friends = ["Huckleberry Finn", "Tom Sawyer"]

Because of the way the descriptor protocol works, using del (or delattr) on a cached_property that hasn't been accessed raises AttributeError.

Chomh maith le buntáistí feidhmíochta féideartha a thairiscint, is féidir le @cached_property a chinntiú nach n-athróidh luach tréithe gan choinne thar shaol an cháis. D'fhéadfadh sé seo tarlú le modh a bhfuil a ríomh bunaithe ar datetime.now () `, nó má shábháiltear athrú ar an mbunachar sonraí trí phróiseas éigin eile san eatramh gairid idir inghairmithe modh ina dhiaidh sin ar an gcás céanna.

Is féidir leat airíonna taisceáilte modhanna a dhéanamh. Mar shampla, má bhí modh daor ``get_friends () `agat agus má theastaigh uait é a ghlaoch gan an luach taisceáilte a aisghabháil, d'fhéadfá scríobh:

Code

friends = cached_property(get_friends)

Cé go ndéanfaidh ``person.get_friends () ``na cairde a athríomh ar gach glao, leanfaidh luach na maoine a choscáil go dtí go scriosann tú í mar a thuairiscítear thuas:

Code

x = person.friends  # calls first time
y = person.get_friends()  # calls again
z = person.friends  # does not call
x is z  # is True

class classproperty(method=None)Link to this definition#

Similar to @classmethod, the @classproperty decorator converts the result of a method with a single cls argument into a property that can be accessed directly from the class.

keep_lazy(func, *resultclasses)Link to this definition#

Cuireann Django go leor feidhmeanna fóntais ar fáil (go háirithe i django.utils) a ghlacann sreang mar an gcéad argóint agus a dhéanann rud éigin leis an sreang sin. Úsáidtear na feidhmeanna seo ag scagairí teimpléid chomh maith le go díreach i gcód eile.

Má scríobhann tú do chuid feidhmeanna comhchosúla féin agus má dhéileálann tú le haistriúcháin, beidh fadhb agat cad atá le déanamh nuair is réad aistriúcháin leisciúil é an chéad argóint. Níl tú ag iarraidh é a thiontú go sreang láithreach, mar b'fhéidir go bhfuil an fheidhm seo á úsáid agat lasmuigh de radharc (agus dá bhrí sin ní bheidh socrú áitiúil an snáithe reatha ceart).

Maidir le cásanna mar seo, bain úsáid as an maisitheoir ``django.utils.functional.keep_lazy () ``. Athraíonn sé an fheidhm ionas ionas gur* má thugtar air le haistriúchán leisciúil mar cheann dá argóintí, cuirtear moill ar an meastóireacht feidhme go dtí go gcaithfear é a thiontú go sreang.

Mar shampla:

Code

from django.utils.functional import keep_lazy, keep_lazy_text


def fancy_utility_function(s, *args, **kwargs):
    # Do some conversion on string 's'
    ...


fancy_utility_function = keep_lazy(str)(fancy_utility_function)


# Or more succinctly:
@keep_lazy(str)
def fancy_utility_function(s, *args, **kwargs): ...

Tógann an maisitheoir keep_lazy () ``roinnt argóintí breise (``*args) a shonraíonn an cineál/na cineálacha is féidir leis an bhfeidhm bhunaidh a thabhairt ar ais. Cás úsáide coitianta is ea feidhmeanna a bheith agat a thugann téacs ar ais. Chuige seo, is féidir leat an cineál str a chur chuig keep_lazy` (nó bain úsáid as an maisitheoir: func: keep_lazy_text a thuairiscítear sa chéad chuid eile).

Ciallaíonn an maisitheoir seo a úsáid gur féidir leat do fheidhm a scríobh agus glacadh leis gur sreang ceart é an t-ionchur, ansin tacaíocht a chur le haghaidh rudaí aistriúcháin leisciúil ag an deireadh.

keep_lazy_text(func)Link to this definition#

Aicearra le haghaidh ``keep_lazy (str) (func) ``.

Má tá feidhm agat a thugann téacs ar ais agus má theastaíonn uait a bheith in ann argóintí leisciúla a ghlacadh agus tú ag moill ar a meastóireacht, is féidir leat an maisitheoir seo a úsáid:

Code

from django.utils.functional import keep_lazy, keep_lazy_text


# Our previous example was:
@keep_lazy(str)
def fancy_utility_function(s, *args, **kwargs): ...


# Which can be rewritten as:
@keep_lazy_text
def fancy_utility_function(s, *args, **kwargs): ...

django.utils.htmlLink to this heading#

De ghnáth ba chóir duit HTML a thógáil ag baint úsáide as teimpléid Django chun a mheicníocht autoescape a úsáid, ag baint úsáide as na fóntais in:mod: django.utils.safestring nuair is cuí. Soláthraíonn an modúl seo roinnt fóntais leibhéal íseal breise chun HTML a éalú.

escape(text)Link to this definition#

Tugann sé an téacs a thugtar ar ais le ampersandaí, luachana agus lúibíní uillinne ionchódaithe le húsáid i HTML. Cuirtear iallach ar an ionchur ar dtús chuig sreang agus tá: func: ~django.utils.safestring.mark_safe curtha i bhfeidhm ar an aschur.

conditional_escape(text)Link to this definition#

Similar to escape(), except that it doesn't operate on pre-escaped strings, so it will not double escape.

format_html(format_string, *args, **kwargs)Link to this definition#

Tá sé seo cosúil le:meth: str.format, ach amháin go bhfuil sé oiriúnach chun blúirí HTML a thógáil suas. Ní éaltar an chéad argóint format_string ach cuirtear gach args agus kwargs eile trí:func: conditional_escape sula gcuirtear ar aghaidh chuig str.format () `. Faoi dheireadh, tá: func: ~django.utils.safestring.mark_safe curtha i bhfeidhm ar an aschur.

Maidir le blúirí beaga HTML a thógáil, is fearr leis an bhfeidhm seo ná idirphallú sreangán ag baint úsáide as %` nó ``str.format () ``go díreach, toisc go mbaineann sé éalú le gach argóint - díreach mar a chuireann an córas teimpléid i bhfeidhm ag éalú de réir réamhshocraithe.

Mar sin, in ionad scríobh:

Code

mark_safe(
    "%s <b>%s</b> %s"
    % (
        some_html,
        escape(some_text),
        escape(some_other_text),
    )
)

Ba chóir duit ina ionad sin a úsáid:

Code

format_html(
    "{} <b>{}</b> {}",
    mark_safe(some_html),
    some_text,
    some_other_text,
)

Tá an buntáiste aige seo nach gá duit iarratas a dhéanamh: func: `éalú `chuig gach argóint agus go mbeidh fabht agus leochaileacht XSS i mbaol má dhéanann tú dearmad ar cheann amháin.

Tabhair faoi deara cé go n-úsáideann an fheidhm seo str.format () ``chun an t-idirghabháil a dhéanamh, ní oibreoidh cuid de na roghanna formáidithe a sholáthraíonn ``str.format () (m.sh. formáidiú uimhir), ós rud é go gcuirtear gach argóint trí:func: func: force_str ar an luachanna.

format_html_join(sep, format_string, args_generator)Link to this definition#

Fillteán de:func: format_html, maidir le cás coitianta grúpa argóintí a chaithfear iad a fhormáidiú ag baint úsáide as an sreang formáide céanna, agus ansin a cheangal ag baint úsáide as sep. Cuirtear sep trí:func: conditional_escape freisin.

args_generator should be an iterator that yields arguments to pass to format_html(), either sequences of positional arguments or mappings of keyword arguments.

For example, tuples can be used for positional arguments:

Code

format_html_join(
    "\n",
    "<li>{} {}</li>",
    ((u.first_name, u.last_name) for u in users),
)

Or dictionaries can be used for keyword arguments:

Code

format_html_join(
    "\n",
    '<li data-id="{id}">{id} {title}</li>',
    ({"id": b.id, "title": b.title} for b in books),
)

json_script(value, element_id=None, encoder=None)Link to this definition#

Éalaíonn sé gach carachtar speisialta HTML/XML lena n-éalaíonn Unicode, mar sin tá an luach sábháilte le húsáid le JavaScript. Fillteann sé an JSON éalaithe i gclib <script>```` freisin. <script>Mura bhfuil an paraiméadar element_id `None ``, tugtar an id rith don chlib ``. Mar shampla:

Python console

>>> json_script({"hello": "world"}, element_id="hello-data")
'<script id="hello-data" type="application/json">{"hello": "world"}</script>'

Ú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.

strip_tags(value)Link to this definition#

Déanann iarracht aon rud atá cosúil le clib HTML a bhaint as an sreang, is é sin aon rud atá laistigh de <>`.

Absolutely NO guarantee is provided about the resulting string being HTML safe. So NEVER mark safe the result of a strip_tags call without escaping it first, for example with escape().

Mar shampla:

Code

strip_tags(value)

Más é luach ” Is slug é <b>Joel</b> “ is é an luach tuai <button>ris</button> ceáin <span>"Is slug</span> é Joel".

Má tá réiteach níos láidre á lorg agat, smaoinigh ar uirlis sláintíochta HTML tríú páirtí a úsáid.

html_safe()Link to this definition#

Cuidíonn an modh ``__html__ () ``ar rang le teimpléid neamh-DJango ranganna a bhrath nach dteastaíonn a n-aschur ag éalú HTML.

Sainmhíníonn an maisitheoir seo an modh __html__ () ``ar an rang maisithe trí ``__str__ () a fhilleadh in:meth: ~django.utils.safestring.mark_safe. Déan cinnte go gcuireann an modh ``__str__ () ``téacs ar ais go deimhin nach dteastaíonn éalú HTML uaidh.

django.utils.httpLink to this heading#

urlencode(query, doseq=False)Link to this definition#

Leagan de fheidhm Python: Func: urllib.parse.urlencode atá in ann oibriú ar multivaluedict agus luachanna neamh-sreang.

http_date(epoch_seconds=None)Link to this definition#

Formáidigh an t-am chun an formáid dáta: rfc: 1123 #section -5.2.14 a mheaitseáil mar a shonraíonn http:RFC: 9110 #section -5.6.7.

Glacann sé le huimhir phointe snámh a chuirtear in iúl i soicindí ón tréimhse in UTC - mar shampla an líon a chuirtear amach ag time.time () `. Má tá sé socraithe ar ``None, réamhshocraithe go dtí an t-am reatha.

Aischuir sreang san fhormáid Wdy, DD Mon YYYY HH:MM: SS GMT.

content_disposition_header(as_attachment, filename)Link to this definition#

Tógann sé luach ceanntásc HTTP Content-Disposition ón ainm comhad ``tugtar mar a shonraítear ar:rfc: `6266`. Tugann ``None má tá as_attachment False agus ainm comhaid ```None, seachas sin filleann sé sreang atá oiriúnach don cheannteideal HTTP Content-Disposition.

base36_to_int(s)Link to this definition#

Athraíonn sé sreang bonn 36 go sláimhir.

int_to_base36(i)Link to this definition#

Athraíonn sé sláimhir dhearfach go bun-sreang 36.

urlsafe_base64_encode(s)Link to this definition#

Ionchódaíonn bytestring chuig teaghrán base64 le húsáid in URLanna, ag scriosadh aon chomharthaí comhionanna rianacha.

urlsafe_base64_decode(s)Link to this definition#

Déan teaghrán ionchódaithe base64 a dhíchódú, ag cur siar aon chomharthaí comhionannacha a d'fhéadfadh a bheith bainte amach.

django.utils.module_loadingLink to this heading#

Feidhmeanna chun oibriú le modúil Python.

import_string(dotted_path)Link to this definition#

Ionmhairíonn cosán modúl poncanach agus cuireann sé an tréith/rang ainmnithe leis an ainm deireanach sa chosán ar ais. Ardaíonn sé ``allmhaireacht ``má theip ar an allmhairiú. Mar shampla:

Code

from django.utils.module_loading import import_string

ValidationError = import_string("django.core.exceptions.ValidationError")

atá coibhéiseach le:

Code

from django.core.exceptions import ValidationError

django.utils.safestringLink to this heading#

Feidhmeanna agus ranganna chun oibriú le “teaghráin sábháilte”: teaghráin is féidir a thaispeáint go sábháilte gan éalú breise i HTML. Ciallaíonn rud éigin a mharcáil mar “teaghrán sábháilte” go bhfuil táirgeoir an teaghráin tar éis carachtair a iompú cheana féin nár cheart ag an inneall HTML (m.sh. '<') iad a léirmhíniú sna heintitis iomchuí.

class SafeStringLink to this definition#

Fo-aicme str` atá marcáilte go sonrach mar “sábháilte” (ní gá éalú breise) chun críocha aschuir HTML.

mark_safe(s)Link to this definition#

Marcáil sreang go sainráite mar shábháilte chun críocha aschuir (HTML). Is féidir an réad a chuirtear ar ais a úsáid i ngach áit a bhfuil sreang oiriúnach.

Is féidir é a ghlaoch arís agus arís eile ar shreang amháin.

Is féidir é a úsáid freisin mar mhaisitheoir.

Chun blúirí HTML a thógáil, ba chóir duit de ghnáth a bheith ag baint úsáidea:func: django.utils.html.format_html ina ionad.

Beidh sreang marcáilte sábháilte neamhshábháilte arís Mar shampla:

Python console

>>> mystr = "<b>Hello World</b>   "
>>> mystr = mark_safe(mystr)
>>> type(mystr)
<class 'django.utils.safestring.SafeString'>

>>> mystr = mystr.strip()  # removing whitespace
>>> type(mystr)
<type 'str'>

django.utils.textLink to this heading#

format_lazy(format_string, *args, **kwargs)Link to this definition#

Leagan de:meth: str.format nuair a bhíonn rudaí leisciúla ag format_string, args`, agus/nó kwargs. Is é an chéad argóint an sreang atá le formáidiú. Mar shampla:

Code

from django.utils.text import format_lazy
from django.utils.translation import pgettext_lazy

urlpatterns = [
    path(
        format_lazy("{person}/<int:pk>/", person=pgettext_lazy("URL", "person")),
        PersonDetailView.as_view(),
    ),
]

Ligeann an sampla seo d'aistritheoirí cuid den URL a aistriú. Má aistrítear “duine” go “persona”, meaitneoidh an abairt rialta persona/ (? P<pk>\ d+) /$, m.sh. persona/5/.

slugify(value, allow_unicode=False)Link to this definition#

Athraíonn sé sreang go slug URL trí:

1. Ag tiontú go ASCII más é allow_unicode False` (an réamhshocraithe).

2. Ag tiontú go litreacha beaga.

3. Carachtair nach alfaiméireacha, béim, braithíní nó spás bán iad a bhaint.

4. Aon spás bán nó sraitheanna arís agus arís agus arís eile a chur in ionad stiúir aonair.

5. Spás bán tosaigh agus rianúcháin a bhaint, sraitheanna agus béim a bhaint.

Mar shampla:

Python console

>>> slugify(" Joel is a slug ")
'joel-is-a-slug'

Más mian leat carachtair Unicode a cheadú, pas allow_unicode=true. Mar shampla:

Python console

>>> slugify("你好 World", allow_unicode=True)
'你好-world'

``django.utils.timezone ``Link to this heading#

get_fixed_timezone(offset)Link to this definition#

Tugann a: class: ~datetime.tzinfo sampla a léiríonn crios ama le fritháireamh seasta ó UTC.

Is é offset a:class: datetime.timedelta nó líon sláireach nóiméad. Úsáid luachanna dearfacha do chriosanna ama thoir ó UTC agus luachanna diúltacha siar de UTC.

get_default_timezone()Link to this definition#

<default-current-time-zone>Tugann a:class: ~datetime.tzinfo sampla a léiríonn an:ref: `crios ama réamhshocraithe `.

get_default_timezone_name()Link to this definition#

<default-current-time-zone>Tugann ainm an: ref: `crios ama réamhshocraithe `ar ais.

get_current_timezone()Link to this definition#

<default-current-time-zone>Tuairisceann a:class: ~datetime.tzinfo sampla a léiríonn an:ref: `crios ama reatha `.

get_current_timezone_name()Link to this definition#

<default-current-time-zone>Tugann ainm an: ref: `crios ama reatha `ar ais.

activate(timezone)Link to this definition#

<default-current-time-zone>Socraíonn an: ref: crios ama reatha `. Caithfidh an argóint `timezone` a bheith ina shampla de a:class: ~datetime.tzinfo fo-aicme nó ainm crios ama.

deactivate()Link to this definition#

<default-current-time-zone>Díshuitear an:ref: `crios ama reatha `.

override(timezone)Link to this definition#

This is a Python context manager that sets the current time zone on entry with activate(), and restores the previously active time zone on exit. If the timezone argument is None, the current time zone is unset on entry with deactivate() instead.

Tá override inúsáidte mar mhaisitheoir feidhme freisin.

localtime(value=None, timezone=None)Link to this definition#

<default-current-time-zone>Athraíonn sé aware:class: ~datetime.datetime go crios ama difriúil, de réir réamhshocraithe an:ref: `crios ama reatha `.

Nuair a fhágtar ``luach ``, réamhshocraithe aith:func: ano.

Ní oibríonn an fheidhm seo ar amanna dáta naif; úsáid: func: make_aware ina ionad.

localdate(value=None, timezone=None)Link to this definition#

<default-current-time-zone>Úsáid:Func: localtime chun aware:class: ~datetime.datetime a thiontú go a:meth: ~datetime.datetime.date i gcrios ama difriúil, de réir réamhshocraithe an:ref: `crios ama reatha `.

Nuair a fhágtar ``luach ``, réamhshocraithe aith:func: ano.

Ní oibríonn an fheidhm seo ar amanna dáta naif.

now()Link to this definition#

Tuairisceáin a: class: ~datetime.datetime a léiríonn an pointe reatha in am. Braitheann an méid a chuirtear ar ais go díreach ar luach de:setting: USE_TZ:

• Más rud é: Setting: False USE_TZ, is é seo a: ref: naive dáta-am <naive_vs_aware_datetimes>(ie dáta-am gan crios ama gaolmhar) a léiríonn an t-am reatha i gcrios ama áitiúil an chórais.

• <naive_vs_aware_datetimes>Más rud é: Setting: USE_TZ True, beidh sé seo an:ref: aware `dáta-am a léiríonn an t-am reatha i UTC. Tabhair faoi deara go bhfillfidh: func: `ano amanna i gcónaí i UTC beag beann ar luach an:setting: TIME_ZONE; is féidir leat:func: localtime a úsáid chun an t-am a fháil sa chrios ama reatha.

is_aware(value)Link to this definition#

Tugann sé ar ais Fíor má tá luach` ar an eolas, Fréag má tá sé naif. Glacann an fheidhm seo leis gurb é luach a:class: ~datetime.datetime.

is_naive(value)Link to this definition#

Tugann sé ar ais True má tá luach` naif, Fréag má tá sé ar an eolas aige. Glacann an fheidhm seo leis gurb é luach a:class: ~datetime.datetime.

make_aware(value, timezone=None)Link to this definition#

Filleann sé aware:class: ~datetime.datetime a léiríonn an pointe céanna in am le value i timezone`, agus value` ina naive:class: ~datetime.datetime. <default-current-time-zone>Má tá timezone socraithe go None, réamhshocraíonn sé go dtí an:ref: `crios ama reatha `.

make_naive(value, timezone=None)Link to this definition#

Tugann naive:class: ~datetime.datetime ar ais a léiríonn i timezone an pointe céanna in am le value, agus lua` atá ina aware:class: ~datetime.datetime. <default-current-time-zone>Má tá timezone socraithe go None, réamhshocraíonn sé go dtí an:ref: `crios ama reatha `.

django.utils.translationLink to this heading#

Le haghaidh plé iomlán maidir le húsáid na nithe seo a leanas féach na:doc: doiciméadú aistriúcháin </topics/i18n/translation>.

gettext(message)Link to this definition#

Aistríonn ``teachtaireacht ``agus cuireann sé ar ais mar shreang é.

pgettext(context, message)Link to this definition#

Aistríonn teachtaireacht ``mar gheall ar an `comhthéacs agus cuireann sé ar ais mar shreang é.

Le haghaidh tuilleadh faisnéise, féach:ref: contextual-markers.

gettext_lazy(message)Link to this definition#

pgettext_lazy(context, message)Link to this definition#

Mar an gcéanna leis na leaganacha neamh-leisciúla thuas, ach ag baint úsáide as forghní

<lazy-translations>Féach:ref: `doiciméadú aistriúcháin leisciúil `.

gettext_noop(message)Link to this definition#

Marcálann sé teaghráin le haghaidh aistriúcháin ach ní aistríonn sé iad anois. Is féidir é seo a úsáid chun teaghráin a stóráil in athróga domhanda ar chóir dóibh fanacht sa bhuntheanga (toisc go bhféadfaí iad a úsáid go seachtrach) agus aistrítear iad níos déanaí.

ngettext(singular, plural, number)Link to this definition#

Aistríonn singular agus plural` agus filleann sé an teaghrán cuí bunaithe ar uimhre.

npgettext(context, singular, plural, number)Link to this definition#

Aistríonn singular agus plural` agus filleann sé an teaghrán cuí bunaithe ar uimhre agus an context`.

ngettext_lazy(singular, plural, number)Link to this definition#

npgettext_lazy(context, singular, plural, number)Link to this definition#

Mar an gcéanna leis na leaganacha neamh-leisciúla thuas, ach ag baint úsáide as forghní

<lazy-translations>Féach:ref: `doiciméadú aistriúcháin leisciúil `.

activate(language)Link to this definition#

Faigheann sé an réad aistriúcháin do theanga ar leith agus gníomhaíonn sé é mar réad aistriúcháin reatha don snáithe reatha.

deactivate()Link to this definition#

Díghníomhachtaíonn sé an réad aistriúcháin atá gníomhach faoi láthair ionas go réiteoidh glaonna breise i gcoinne an réad aistriúcháin

deactivate_all()Link to this definition#

Déanann sé an réad aistriúcháin ghníomhach mar shampla ``NullTranslations () ``. Tá sé seo úsáideach nuair is mian linn go mbeadh aistriúcháin moillithe le feiceáil mar an teaghrán bunaidh ar chúis

override(language, deactivate=False)Link to this definition#

Gníomhaíonn bainisteoir comhthéacs Python a úsáide:func: django.utils.translation.activate chun an réad aistriúcháin do theanga ar leith a fháil, é a ghníomhachtú mar réad aistriúcháin don snáithe reatha agus athghníomhachtaíonn sé an teanga ghníomhach roimhe seo ar imeacht. Go roghnach, féadfaidh sé an t-aistriúchán sealadach a dhíghníomhachtú ar imeacht le:func: django.utils.translation.deactivate má tá an argóint deactivate True`. Má chuireann tú None mar argóint teanga, cuirtear cás ``NullTranslations () ``i ngníomh laistigh den chomhthéacs.

Tá override inúsáidte mar mhaisitheoir feidhme freisin.

check_for_language(lang_code)Link to this definition#

Seiceálann sé an bhfuil comhad teanga domhanda ann don chód teanga ar leith (m.sh. 'fr', 'pt_br'). Úsáidtear é seo chun cinneadh a dhéanamh an bhfuil teanga a sholáthraíonn an úsáideoir ar fáil.

lang_code has a maximum accepted length of 500 characters. False is returned if it exceeds this limit, before any language-file lookup.

get_language()Link to this definition#

Returns the currently selected language code. Returns None if translations are temporarily deactivated (by deactivate_all() or when None is passed to override()).

get_language_bidi()Link to this definition#

Tugann leagan amach BiDi teanga roghnaithe:

• False = leagan amach ar chlé go deis

• True = leagan amach ar dheis go clé

get_language_from_request(request, check_path=False)Link to this definition#

Déanann anailís ar an iarratas chun a fháil amach cén teanga a theastaíonn ón úsáideoir a thaispeáint. Ní chuirtear san áireamh ach teangacha atá liostaithe i socruithe. Má iarrann an t-úsáideoir fotheanga ina bhfuil príomhtheanga againn, seolfaimid an phríomhtheanga amach.

Más é check_path True, seiceálann an fheidhm an URL iarrtha ar dtús cibé an dtosaíonn a chosán le cód teanga atá liostaithe sa socrú:setting: LANGUAGES.

get_supported_language_variant(lang_code, strict=False)Link to this definition#

Tugann sé 'lang_code`` ar ais má tá sé sa socrú: setting: LANGUAGES, b'fhéidir leagan níos cineálacha a roghnú. Mar shampla, cuirtear es' ar ais má tá lang_code es-ar' agus `es' in:setting: LANGUAGES ach níl es-ar'.

Tá an fad uasta glactha le 500 carachtar ag lang_code. A: Exc: Ardaítear LookuPerror má sháraíonn lang_code an teorainn seo agus má tá docht ``True, nó mura bhfuil aon leagan cineálach ann agus má tá docht False`.

Más é docht ``False (an réamhshocrú), féadfar leagan tír-shonrach a thabhairt ar ais nuair nach bhfaightear an cód teanga ná a leagan cineálach. Mar shampla, mura bhfuil ach es-co' in:setting: LANGUAGES, cuirtear é sin ar ais do lang_codes cosúil le 'es' agus es-ar'. Ní chuirtear na cluichí sin ar ais má tá strict=True.

Ardaithe:exc: LookuPerror mura bhfaightear aon rud.

to_locale(language)Link to this definition#

Tionann ainm teanga (en-us) ina ainm áitiúil (en_US).

templatize(src)Link to this definition#

Tionann teimpléad Django ina rud a thuigeann xgettext. Déanann sé amhlaidh trí na clibeanna aistriúcháin Django a aistriú go gcaighdeánacha feidhme gettext.