Creat taisce DjangoLink to this heading#

MemcachedLink to this heading#

Is freastalaí taisce go hiomlán bunaithe ar chuimhne é Memcached__, a forbraíodh ar dtús chun ualaí arda a láimhseáil ag LiveJournal.com agus foinse oscailte ina dhiaidh sin ag Danga Interactive. Úsáideann suíomhanna mar Facebook agus Wikipedia é chun rochtain ar bhunachar sonraí a laghdú agus feidhmíocht an láithreáin a mhéadú go mór.

Ritheann Memcached mar démon agus leithdháiltear méid sonraithe RAM air. Níl le déanamh aige ach comhéadan tapa a sholáthar chun sonraí sa taisce a chur leis, a aisghabháil agus a scriosadh. Stóráiltear na sonraí go léir go díreach i gcuimhne, mar sin níl aon lasbhunachar sonraí nó úsáid chórais chomhad ann.

Tar éis duit Memcached féin a shuiteáil, beidh ort ceangailt Memcached a shuiteáil. Tá roinnt ceangail Python Memcached ar fáil; is iad an dá cheann a thacaíonn Django: pypi: pylibmc agus:pypi: pymemcache.

Chun Memcached a úsáid le Django:

• Socraigh: Socrú: BACKEND `go ``Django.core.cache.backends.memcached.pymemcachecache`<CACHES-BACKEND> nó django.core.cache.backends.memcached.pylibmccache (ag brath ar an gceangailt memcached roghnaithe agat)

• SOC:SET:SETING: LOCATION <CACHES-LOCATION>`go luachanna ``ip: port `, áit is é ip` seoladh IP an daemon Memcached agus port an calafort ar a bhfuil Memcached ag rith, nó go luach unix:path, áit is é path an cosán chuig comhad soicéad Memcached Unix.

Sa sampla seo, tá Memcached ag rith ar chalafort localhost (127.0.0.1) 11211, ag baint úsáide as an cheangailteach ``pymemcache`:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": "127.0.0.1:11211",
    }
}

Sa sampla seo, tá Memcached ar fáil trí chomhad soicéad áitiúil Unix: file: /tmp/memcached.sock ag baint úsáide as an ceangailt pymemcache:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": "unix:/tmp/memcached.sock",
    }
}

Gné den scoth amháin de Memcached is ea a chumas taisce a roinnt thar fhreastalaithe iolracha. Ciallaíonn sé seo gur féidir leat daemons Memcached a reáchtáil ar iliomad meaisíní, agus déileálfaidh an clár leis an ngrúpa meaisíní mar taisce* aonair*, gan gá luachanna taisce a dhúbailt ar gach meaisín. Ch <CACHES-LOCATION>un leas a bhaint as an ngné seo, cuir gach seoladh freastalaí san áireamh in:socrú: `LOCATION `, mar shreang teoranta leath-cholún nó camóg, nó mar liosta.

Sa sampla seo, roinntear an taisce thar chásanna Memcached atá ag rith ar sheoladh IP 172.19.26.240 agus 172.19.26.242, araon ar chalafort 11211:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": [
            "172.19.26.240:11211",
            "172.19.26.242:11211",
        ],
    }
}

Sa sampla seo a leanas, roinntear an taisce thar chásanna Memcached atá ag rith ar na seoltaí IP 172.19.26.240 (calafort 11211), 172.19.26.242 (calafort 11212), agus 172.19.26.244 (calafort 11213):

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": [
            "172.19.26.240:11211",
            "172.19.26.242:11212",
            "172.19.26.244:11213",
        ],
    }
}

<CACHES-OPTIONS>De réir réamhshocraithe, socraíonn an cúltaca PymemCacheCache` na roghanna seo a leanas (is féidir leat iad a shárú i d:setting: `OPTIONS `):

"OPTIONS": {
    "allow_unicode_keys": True,
    "default_noreply": False,
    "serde": pymemcache.serde.pickle_serde,
}

Pointe deiridh faoi Memcached ná go bhfuil míbhuntáiste ag taiscáil cuimhne bunaithe: toisc go stóráiltear na sonraí taisceáilte i gcuimhne, caillfear na sonraí má thimpíonn do fhreastalaí. Is léir nach bhfuil cuimhne beartaithe le haghaidh stórála sonraí buan, mar sin ná bí ag brath ar chaching cuimhne mar an t-aon stóráil sonraí atá agat. Gan amhras, níor cheart aon cheann de na cúltaca caching Django a úsáid le haghaidh stórála buan - tá sé beartaithe go léir a bheith ina réitigh le haghaidh taiscéála, ní stóráil - ach cuirimid é seo in iúl anseo toisc go bhfuil caching bunaithe ar chuimhne go háirithe sealadach.

RedisLink to this heading#

Is bunachar sonraí in-chuimhne é Redis__ is féidir a úsáid le haghaidh taiscála. Chun tús a chur beidh freastalaí Redis ag teastáil uait ag rith go háitiúil nó ar mheaisín iargúlta.

Tar éis duit an freastalaí Redis a bhunú, beidh ort ceangail Python a shuiteáil do Redis. :pypi: Is é `redis-py <redis>`an ceangailt a thacaíonn Django go dúchasach. <hiredis>Moltar an pacáiste: pypi: `hiredis-py `a shuiteáil freisin.

Chun Redis a úsáid mar do chúltaca taisce le Django:

• <CACHES-BACKEND>Socraigh: socrú: BACKEND `go ``Django.Core.Cache.Backends.Redis.RedisCache `.

• Set LOCATION to the URL pointing to your Redis instance, using the appropriate scheme. See the redis-py docs for details on the available schemes.

Mar shampla, má tá Redis ag rith ar chalafort localhost (127.0.0.1) 6379:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
    }
}

Is minic a chosnaítear freastalaithe Redis le fíordheimhniú. D'fhonn ainm úsáideora agus pasfhocal a sholáthar, cuir iad sa SUÍOMH` mar aon leis an URL:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://username:password@127.0.0.1:6379",
    }
}

Má tá iolracha freastalaithe Redis curtha ar bun agat sa mhodh macasamhail, is féidir leat na freastalaithe a shonrú mar shreang teoranta leath-cholún nó camóg, nó mar liosta. Agus freastalaithe iolracha á úsáid agat, déantar oibríochtaí scríofa ar an gcéad fhreastalaí (ceannaire) Déantar oibríochtaí léite ar na freastalaithe eile (macasamhail) a roghnaítear go randamach:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": [
            "redis://127.0.0.1:6379",  # leader
            "redis://127.0.0.1:6378",  # read-replica 1
            "redis://127.0.0.1:6377",  # read-replica 2
        ],
    }
}

Cacháil bunachar sonraíLink to this heading#

Is féidir le Django a chuid sonraí taiscéadaithe a stóráil i do bhunachar sonraí. Oibríonn sé seo is fearr má tá freastalaí bunachar sonraí tapa, innéacsaithe go maith agat.

Chun tábla bunachar sonraí a úsáid mar do chúltaca taisce:

• <CACHES-BACKEND>Socraigh: socrú: BACKEND `go ``Django.core.cache.backends.db.databaseCache `

• Socraigh: socrú: LOCATION <CACHES-LOCATION>`go ``tablename`, ainm an tábla bunachar sonraí. Is féidir leis an ainm seo a bheith cibé rud is mian leat, fad is ainm tábla bailí é nach bhfuil á úsáid cheana féin i do bhunachar sonraí.

Sa sampla seo, is é my_cache_table` ainm an tábla taisce:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.db.DatabaseCache",
        "LOCATION": "my_cache_table",
    }
}

Murab ionann agus cúltaca taisce eile, ní thacaíonn taisce an bhunachar sonraí le cur isteach in éag go huathoibríoch ag leibhéal an bhunachar sonraí. Ina áit sin, déantar iontrálacha taisce in éag a scriosadh gach uair a thugtar add () ``, `set (), nó ``touch () ``.

python manage.py createcachetable

class CacheRouter:
    """A router to control all database cache operations"""

    def db_for_read(self, model, **hints):
        "All cache read operations go to the replica"
        if model._meta.app_label == "django_cache":
            return "cache_replica"
        return None

    def db_for_write(self, model, **hints):
        "All cache write operations go to primary"
        if model._meta.app_label == "django_cache":
            return "cache_primary"
        return None

    def allow_migrate(self, db, app_label, model_name=None, **hints):
        "Only install the cache model on primary"
        if app_label == "django_cache":
            return db == "cache_primary"
        return None

Caching chórais comhaidLink to this heading#

Déanann an cúltaca comhad-bhunaithe gach luach taisce a shraitheadh agus a stóráil mar chomhad ar leithligh. <CACHES-LOCATION>Chun an tacar cúltaca seo a úsáid: socrú: BACKEND `go ``<CACHES-BACKEND>"django.core.cache.backends.fileBasedCache"` agus:setting: LOCATION chuig eolaire oiriúnach. Mar shampla, chun sonraí taisceáilte a stóráil i /var/tmp/django_cache, bain úsáid as an socrú seo:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "/var/tmp/django_cache",
    }
}

Má tá tú ar Windows, cuir an litir tiomána ag tús an chosáin, mar seo:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "c:/foo/bar",
    }
}

Ba chóir go mbeadh an cosán eolaire iomlán - is é sin, ba chóir go dtosódh sé ag fréamh do chóras comhaid. Is cuma an gcuireann tú slash ag deireadh an shocraithe.

Déan cinnte go bhfuil an eolaire a luaitear ag an socrú seo ann agus go bhfuil sé inléite agus inscríofa, nó gur féidir le húsáideoir an chórais faoina ritheann do fhreastalaí gréasáin é a chruthú. Ag leanúint leis an sampla thuas, má ritheann do fhreastalaí mar an úsáideoir apache, déan cinnte go bhfuil an eolaire /var/tmp/django_cache ann agus go bhfuil sé inléite agus inscríofa ag an úsáideoir apache, nó gur féidir leis an úsáideoir apache é a chruthú.

Cacháil cuimhne áitiúilLink to this heading#

Is é seo an taisce réamhshocraithe mura sonraítear ceann eile i do chomhad socruithe. Más mian leat na buntáistí luais a bhaineann le caching in-chuimhne ach nach bhfuil an cumas agat Memcached a reáchtáil, smaoinigh ar an gcúltaca taisce cuimhne áitiúil. Tá an taisce seo in aghaidh an phróisis (féach thíos) agus sábháilte ó snáithe. <CACHES-BACKEND>Chun é a úsáid, socraí:setting: BACKEND `go `"django.core.cache.backends.locmem.locmemcache"``. Mar shampla:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
        "LOCATION": "unique-snowflake",
    }
}

Úsáidtear an cache:setting: LOCATION <CACHES-LOCATION>`chun siopaí cuimhne aonair a aithint. Mura bhfuil ach taisce ``locmem` amháin agat, is féidir leat an:setting: `LOCATION `a fhágáil<CACHES-LOCATION>; áfach, má tá níos mó ná taisce cuimhne áitiúil amháin agat, beidh ort ainm a shannadh do cheann acu ar a laghad d'fhonn iad a choinneáil ar leithligh.

Úsáideann an taisce straitéis díothaithe is lú a úsáidtear le déanaí (LRU).

Tabhair faoi deara go mbeidh a shampla taisce príobháideach féin ag gach próiseas, rud a chiallaíonn nach féidir aon chaching trasphróisis a dhéanamh. Ciallaíonn sé seo freisin nach bhfuil an taisce cuimhne áitiúil go háirithe éifeachtach ó chuimhne, mar sin is dócha nach rogha maith é do thimpeallachtaí táirgeachta. Tá sé go deas le haghaidh forbartha.

Caching dummy (le haghaidh forbartha)Link to this heading#

Faoi dheireadh, tagann Django le taisce “dummy” nach ndéanann taisce i ndáiríre - ní chuireann sé ach an comhéadan taisce i bhfeidhm gan aon rud a dhéanamh.

Tá sé seo úsáideach má tá suíomh táirgeachta agat a úsáideann taiscáil tromshaothair in áiteanna éagsúla ach timpeallacht forbarta/tástála nach dteastaíonn uait taisce a dhéanamh agus nach dteastaíonn uait do chód a athrú go speisialta an dara ceann. <CACHES-BACKEND>Chun caching dummy a ghníomhachtú, socraí:setting: `BACKEND `mar sin:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.dummy.DummyCache",
    }
}

Úsáid cúltaca taisce saincheapthaLink to this heading#

Cé go gcuimsíonn Django tacaíocht do roinnt cúltaca taisce lasmuigh den bhosca, uaireanta b'fhéidir gur mhaith leat cúltaca taisce saincheaptha a úsáid. Chun cúltaca taisce seachtrach a úsáid le Django, bain úsáid as an gcosán allmhairithe Python mar an:setting: BACKEND `den socrú: `CACHES<CACHES-BACKEND>, mar shampla:

CACHES = {
    "default": {
        "BACKEND": "path.to.backend",
    }
}

Má tá do chúlcheann féin á thógáil agat, is féidir leat na cúltaca caighdeánacha taisce a úsáid mar chur i bhfeidhm tagartha. Gheobhaidh tú an cód san eolaire: source: django/core/cache/backends/ foinse Django.

Nóta: Gan cúis an-láidir, mar óstach nach dtacaíonn leo, ba chóir duit cloí leis na cúltaca taisce atá san áireamh le Django. Rinneadh tástáil mhaith orthu agus tá siad doiciméadaithe go maith.

Argóintí taisceLink to this heading#

Is féidir argóintí breise a thabhairt do gach cúltaca taisce chun iompar taisce a rialú. Cuirtear na hargóintí seo ar fáil mar eochracha breise sa socrú: socrú: CACHES. Is iad seo a leanas argóintí bailí:

• TIMEOUT: The default timeout, in seconds, to use for the cache. This argument defaults to 300 seconds (5 minutes). You can set TIMEOUT to None so that, by default, cache keys never expire. A value of 0 causes keys to immediately expire (effectively "don't cache").

• OPTIONS: Any options that should be passed to the cache backend. The list of valid options will vary with each backend, and cache backends backed by a third-party library will pass their options directly to the underlying cache library.

  Déanfaidh cúltaca taisce a chuireann a straitéis díothaithe féin i bhfeidhm (ie, na cúltaca locmem, córas comhad ``agus ``bunachar sonraí) onóir na roghanna seo a leanas:

  • MAX_ENTRIES: An líon uasta na n-iontrálacha a cheadaítear sa taisce sula scriostar seanluachanna. Tá an argóint seo réamhshocraithe go 300.

  • CULL_FREQUENCY: An codán na n-iontrálacha a dhíothaítear nuair a shroichtear MAX_ENTRIES. Is é an cóimheas iarbhír ná 1/CULL_FREQUENCY, mar sin socraigh CULL_FREQUENCY go 2 chun leath na n-iontrálacha a scriosadh nuair a shroichtear MAX_ENTRIES ``. Ba chóir go mbeadh an argóint seo ina shláimhir agus réamhshocraithe go ``3.

    Ciallaíonn luach 0 do CULL_FREQUENCY` go ndéanfar an taisce iomlán a dumpáil nuair a shroichfear MAX_ENTRIES. Ar roinnt cúltaca (``bunachar sonraí ``go háirithe) déanann sé seo go gcaithfeach* i bhfad níos gasta ar chostas níos mó caitheamh taisce.

  Cuireann cúltaca Memcached agus Redis ábhar: socrú: `OPTIONS <CACHES-OPTIONS>`mar argóintí eochairfhocal chuig tógálaí na gcliant, rud a cheadaíonn rialú níos airde ar iompar cliant. Mar shampla úsáid, féach thíos.

• KEY_PREFIX: A string that will be automatically included (prepended by default) to all cache keys used by the Django server.

  Féach na:ref: `cáipéisíocht taiscéala <cache_key_prefixing>`le haghaidh tuilleadh faisnéise.

• VERSION: The default version number for cache keys generated by the Django server.

  Féach na:ref: `cáipéisíocht taiscéala <cache_versioning>`le haghaidh tuilleadh faisnéise.

• KEY_FUNCTION A string containing a dotted path to a function that defines how to compose a prefix, version and key into a final cache key.

  Féach na:ref: `cáipéisíocht taiscéala <cache_key_transformation>`le haghaidh tuilleadh faisnéise.

Sa sampla seo, tá cúltaca córas comhaid á chumrú le haon ama 60 soicind, agus cumas uasta 1000 mír:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "/var/tmp/django_cache",
        "TIMEOUT": 60,
        "OPTIONS": {"MAX_ENTRIES": 1000},
    }
}

Seo cumraíocht shampla le haghaidh cúltaca bunaithe ar pylibmc a chumasaíonn an prótacal dénártha, fíordheimhniú SASL, agus an modh iompraíochta ketama:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyLibMCCache",
        "LOCATION": "127.0.0.1:11211",
        "OPTIONS": {
            "binary": True,
            "username": "user",
            "password": "pass",
            "behaviors": {
                "ketama": True,
            },
        },
    }
}

Seo cumraíocht shamplach le haghaidh cúltaca bunaithe ar pymemcache a chuireann ar chumas comhdhlúthú cliant (a d'fhéadfadh feidhmíocht a fheabhsú trí chliaint a choinneáil ceangailte), déileálann sé le hearráidí memcache/líonra mar chailleann taisce, agus socraíonn an bratach TCP_NODELAY ar soicéad an nasc:

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": "127.0.0.1:11211",
        "OPTIONS": {
            "no_delay": True,
            "ignore_exc": True,
            "max_pool_size": 4,
            "use_pooling": True,
        },
    }
}

Seo cumraíocht shampla le haghaidh cúltaca bunaithe ar redis a roghnaíonn bunachar sonraí `10 (de réir réamhshocraithe loingíonn Redis le 16 bhunachar sonraí loighciúla), agus a leagann saincheaptha rang linn nasc (Redis.connectionPool úsáidtear de réir réamhshocraithe):

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "db": "10",
            "pool_class": "redis.BlockingConnectionPool",
        },
    }
}

Taisce in aghaidh an amharc a shonrú sa URLConfLink to this heading#

Tá sé crua-chódaithe ag na samplaí sa chuid roimhe seo go bhfuil an dearcadh a stóráil, toisc go n-athraíonn cache_page an fheidhm my_view atá i bhfeidhm. Déanann an cur chuige seo do thuairim leis an gcóras taisce, nach bhfuil oiriúnach ar chúiseanna éagsúla. Mar shampla, b'fhéidir gur mhaith leat na feidhmeanna amharc a athúsáid ar shuíomh eile gan taisce, nó b'fhéidir gur mhaith leat na tuairimí a dháileadh ar dhaoine a d'fhéadfadh a bheith ag iarraidh iad a úsáid gan iad a chosc. Is é an réiteach ar na fadhbanna seo ná an taisce in aghaidh an amharc a shonrú sa URLConf seachas in aice leis na feidhmeanna amharc féin.

Is féidir leat é sin a dhéanamh tríd an bhfeidhm amharc a fhilleadh le cache_page` nuair a thagann tú tagairt dó sa URLConf. Seo an sean-URLConf ó níos luaithe:

urlpatterns = [
    path("foo/<int:code>/", my_view),
]

Seo an rud céanna, le my_view fillte i cache_page:

from django.views.decorators.cache import cache_page

urlpatterns = [
    path("foo/<int:code>/", cache_page(60 * 15)(my_view)),
]

Rochtain a fháil ar an taisceLink to this heading#

django.core.cache.cachesLink to this definition#

Is féidir leat rochtain a fháil ar na táscáin atá cumraithe sa socrú:: CACHES trí réad cosúil le dict: django.core.cache.caches. Tabharfaidh iarratais arís agus arís eile ar an alias céanna sa snáithe céanna ar ais an réad céanna.

Python console

>>> from django.core.cache import caches
>>> cache1 = caches["myalias"]
>>> cache2 = caches["myalias"]
>>> cache1 is cache2
True

Mura bhfuil an eochair ainmnithe ann, ardófar InvalidCacheBackendError.

Chun sábháilteacht snáithe a sholáthar, cuirfear sampla difriúil den chúltaca taisce ar ais do gach snáithe.

django.core.cache.cacheLink to this definition#

Mar aicearra, tá an taisce réamhshocraithe ar fáil mar django.core.cache.cache:

Python console

>>> from django.core.cache import cache

Tá an réad seo comhionann le ``caches ['réamhshocraithe'] ``.

Úsáid bunúsachLink to this heading#

Is é an comhéadan bunúsach:

cache.set(key, value, timeout=DEFAULT_TIMEOUT, version=None)Link to this definition#

>>> cache.set("my_key", "hello, world!", 30)

cache.get(key, default=None, version=None)Link to this definition#

>>> cache.get("my_key")
'hello, world!'

Ba chóir go mbeadh eochair ina str`, agus is féidir luach a bheith ina aon rud Python inpictilte.

Tá an argóint timeout roghnach agus réamhshocraíonn sé ar an argóint timeout den chúltaca cuí sa socrúit:setting: CACHES (mínithe thuas). Is é líon na soicind ba chóir an luach a stóráil sa taisce. Ag dul isteach None le haghaidh timeout, beidh an luach a thaisceadh go deo. Ní dhéanfaidh timeout de 0 a thaisceadh an luach.

Mura bhfuil an réad ann sa taisce, filleann cache.get () ````None:

>>> # Wait 30 seconds for 'my_key' to expire...
>>> cache.get("my_key")
None

Más gá duit a chinneadh an bhfuil an réad sa taisce agus go bhfuil luach litriúil “None” stóráilte agat, bain úsáid as réad sentinel mar réamhshocraithe:

>>> sentinel = object()
>>> cache.get("my_key", sentinel) is sentinel
False
>>> # Wait 30 seconds for 'my_key' to expire...
>>> cache.get("my_key", sentinel) is sentinel
True

Is féidir le cache.get () ``argóint ``default a ghlacadh. Sonraíonn sé seo cén luach atá le filleadh mura bhfuil an réad ann sa taisce:

>>> cache.get("my_key", "has expired")
'has expired'

cache.add(key, value, timeout=DEFAULT_TIMEOUT, version=None)Link to this definition#

Chun eochair a chur leis ach amháin mura bhfuil sé ann cheana féin, bain úsáid as an modh ``add () ``. Tógann sé na paraiméadair chéanna le ``set () ``, ach ní dhéanfaidh sé iarracht an taisce a nuashonrú má tá an eochair a shonraítear i láthair cheana féin:

>>> cache.set("add_key", "Initial value")
>>> cache.add("add_key", "New value")
>>> cache.get("add_key")
'Initial value'

Más gá duit fios a bheith agat an stóráil add () ``luach sa taisce, is féidir leat an luach tuairisceáin a sheiceáil. Tabharfaidh sé ar ais ``True má stóráilíodh an luach, False ar shlí eile.

cache.get_or_set(key, default, timeout=DEFAULT_TIMEOUT, version=None)Link to this definition#

Más mian leat luach eochair a fháil nó luach a shocrú mura bhfuil an eochair sa taisce, tá an modh ``get_or_set () `ann. Tógann sé na paraiméadair chéanna le ``get () ``ach socraítear an réamhshocrú mar an luach taisce nua don eochair sin, seachas a thabhairt ar ais:

>>> cache.get("my_new_key")  # returns None
>>> cache.get_or_set("my_new_key", "my new value", 100)
'my new value'

Is féidir leat aon ghlaoch a chur ar aghaidh mar luach*réamhshocraithe*:

>>> import datetime
>>> cache.get_or_set("some-timestamp-key", datetime.datetime.now)
datetime.datetime(2014, 12, 11, 0, 15, 49, 457920)

cache.get_many(keys, version=None)Link to this definition#

Tá comhéadan ``get_many () ``ann freisin nach mbuaileann an taisce ach uair amháin. Tugann ``get_many () ``foclóir ar ais leis na heochracha go léir a d'iarr tú orthu atá ann i ndáiríre sa taisce (agus níor éag):

>>> cache.set("a", 1)
>>> cache.set("b", 2)
>>> cache.set("c", 3)
>>> cache.get_many(["a", "b", "c"])
{'a': 1, 'b': 2, 'c': 3}

cache.set_many(dict, timeout)Link to this definition#

Chun luachanna iolracha a shocrú níos éifeachtaí, bain úsáid as ``set_many () ``chun foclóir péirí eochairluacha a rith:

>>> cache.set_many({"a": 1, "b": 2, "c": 3})
>>> cache.get_many(["a", "b", "c"])
{'a': 1, 'b': 2, 'c': 3}

Cosúil le cache.set () ``, glacann ``set_many () paraiméadar roghnach timeout.

Ar chúltaca tacaithe (memcached), filleann ``set_many () ``liosta eochracha ar theip orthu a chur isteach.

cache.delete(key, version=None)Link to this definition#

Is féidir leat eochracha a scriosadh go sainráite le ``delete () ``chun an taisce do réad áirithe a ghlanadh:

>>> cache.delete("a")
True

Tugann delete () ``filleadh ``True má scriosadh an eochair go rathúil, False ar shlí eile.

cache.delete_many(keys, version=None)Link to this definition#

Más mian leat dornán eochracha a ghlanadh ag an am céanna, is féidir le ``delete_many () ``liosta eochracha atá le glanadh a ghlanadh:

>>> cache.delete_many(["a", "b", "c"])

cache.clear()Link to this definition#

Faoi dheireadh, más mian leat na heochracha go léir sa taisce a scriosadh, bain úsáid as ``cache.clear () ``. Bí cúramach leis seo; bainfidh ``clear () ``gach ruda ón taisce, ní hamháin na heochracha atá leagtha síos ag d'iarratas:

>>> cache.clear()

cache.touch(key, timeout=DEFAULT_TIMEOUT, version=None)Link to this definition#

Socraíonn ``cache.touch () ``éag nua le haghaidh eochair. Mar shampla, chun eochair a nuashonrú chun dul in éag 10 soicind as seo:

>>> cache.touch("a", 10)
True

Cosúil le modhanna eile, tá an argóint timeout roghnach agus réamhshocraíonn sé ar an rogha TIMEOUT den chúltaca cuí sa socrúit:setting: CACHES.

Filleann touch () ```True má rinneadh teagmháil leis an eochair go rathúil, False ar shlí eile.

cache.incr(key, delta=1, version=None)Link to this definition#

cache.decr(key, delta=1, version=None)Link to this definition#

Is féidir leat eochair atá ann cheana féin a mhéadú nó a laghdú ag baint úsáide as na modhanna incr () ``nó `decr (), faoi seach. De réir réamhshocraithe, déanfar an luach taisce atá ann cheana a mhéadú nó a laghdú faoi 1. Is féidir luachanna fáis/laghdaithe eile a shonrú trí argóint a sholáthar don ghlao fáis/laghdaithe. Ardófar ValueError má dhéanann tú iarracht eochair taisce nach bhfuil ann a mhéadú nó a laghdú:

>>> cache.set("num", 1)
>>> cache.incr("num")
2
>>> cache.incr("num", 10)
12
>>> cache.decr("num")
11
>>> cache.decr("num", 5)
6

cache.close()Link to this definition#

Is féidir leat an nasc le do taisce a dhúnadh le ``close () ``má chuireann an cúltaca taisce i bhfeidhm.

>>> cache.close()

Réamhshocrú eochair taisceLink to this heading#

Má tá sampla taisce á roinnt agat idir freastalaithe, nó idir do thimpeallachtaí táirgeachta agus forbartha, is féidir go n-úsáidfidh freastalaí eile sonraí a chuimsíonn freastalaí amháin. Má tá formáid na sonraí taisceáilte difriúil idir freastalaithe, d'fhéadfadh fadhbanna an-deacair a dhiagnóisiú a bheith mar thoradh air seo.

Chun é seo a chosc, soláthraíonn Django an cumas na heochracha taisce go léir a úsáideann freastalaí a réamhú <CACHES-KEY_PREFIX>Nuair a shábháiltear eochair taisce áirithe nó a aisghabháil, déanfaidh Django réamh-eochair an taisce go huathoibríoch le luach an socrú taisce: socrú: KEY_PREFIX.

Trí chinntiú go bhfuil difri:setting: `KEY_PREFIX <CACHES-KEY_PREFIX>`ag gach cás Django, is féidir leat a chinntiú nach mbeidh aon imbhuailtí i luachanna taisce.

Leagán taisceLink to this heading#

Nuair a athraíonn tú cód reatha a úsáideann luachanna taiscthe, b'fhéidir go mbeidh ort aon luachanna taiscéadaithe atá ann cheana a ghlanadh. Is é an bealach is éasca le seo a dhéanamh ná an taisce iomlán a shruthlú, ach d'fhéadfadh sé seo go gcaillfear luachanna taisce atá fós bailí agus úsáideach.

Soláthraíonn Django bealach níos fearr chun luachanna taisce aonair a dhíriú. <CACHES-VERSION>Tá aitheantóir leagan ar fud an chórais ag creat taisce Django, sonraithe ag baint úsáide as an socrú taisce: leagan: VERSION. Déantar luach an socraithe seo a chomhcheangal go huathoibríoch leis an réimír taisce agus leis an eochair taisce a sholáthraíonn an úsáideoir chun an eochair taisce de

De réir réamhshocraithe, áireofar leagan eochair taisce réamhshocraithe an láithreáin go huathoibríoch Mar sin féin, tá argóint ``leagan ``sa fheidhmeanna taisce príomha uile, ionas gur féidir leat eochrleagan taisce áirithe a shonrú le socrú nó a fháil. Mar shampla:

>>> # Set version 2 of a cache key
>>> cache.set("my_key", "hello world!", version=2)
>>> # Get the default version (assuming version=1)
>>> cache.get("my_key")
None
>>> # Get version 2 of the same key
>>> cache.get("my_key", version=2)
'hello world!'

Is féidir leagan eochair shonrach a mhéadú agus a shocrú ag baint úsáide as na modhanna incr_version () ``agus `decr_version (). Cuireann sé seo ar chumas eochracha ar leith a chur chuig leagan nua, rud a fhágann gan tionchar ar eochracha eile. Leanúint lenár sampla roimhe seo:

>>> # Increment the version of 'my_key'
>>> cache.incr_version("my_key")
>>> # The default version still isn't available
>>> cache.get("my_key")
None
# Version 2 isn't available, either
>>> cache.get("my_key", version=2)
None
>>> # But version 3 *is* available
>>> cache.get("my_key", version=3)
'hello world!'

Eochair claochlú taisceLink to this heading#

Mar a thuairiscítear sa dá chuid roimhe seo, ní úsáidtear an eochair taisce a sholáthraíonn úsáideoir focal focal - déantar é a chomhcheangal leis an réimír taisce agus an leagan eochair chun eochair taisce deiridh a sholáthar. De réir réamhshocraithe, ceanglaítear na trí chuid ag baint úsáide as colons chun sreang deiridh a tháirgeadh:

def make_key(key, key_prefix, version):
    return "%s:%s:%s" % (key_prefix, version, key)

Más mian leat na codanna a chur le chéile ar bhealaí éagsúla, nó próiseáil eile a chur i bhfeidhm ar an eochair dheiridh (m.sh., díleá hash de na príomhchodanna a thógáil), is féidir leat eochairfheidhm saincheaptha a sholáthar.

Sonraíonn an socrú taisce: `KEY_FUNCTION <CACHES-KEY_FUNCTION>`cosán poncair chuig feidhm a mheaitseann le fréamhshamhail ``make_key () ``thuas. Má chuirtear ar fáil, úsáidfear an eochrfheidhm saincheaptha seo in ionad na feidhme comhcheangailte eochair réamhshocrai

Príomhrabhaidh taisceLink to this heading#

Ní cheadaíonn Memcached, an cúltaca taisce táirgeachta is coitianta a úsáidtear, eochracha taisce níos faide ná 250 carachtar nó ina bhfuil spás bán nó carachtair rialaithe, agus beidh eisceacht ina chúis le heochracha den sórt sin a úsáid. Chun cód taisce iniompartha a spreagadh agus iontas míthaitneamhach a íoslaghdú, eisíonn na cúltaca taisce ionsuite eile rabhadh (django.core.cache.backends.base.cachekeyWarning) má úsáidtear eochair a chuirfeadh earráid ar memcached.

Má tá cúltaca táirgeachta á úsáid agat ar féidir leat glacadh le raon níos leithne eochracha (cúltaca saincheaptha, nó ceann de na cúltaca neamh-mheasta), agus gur mhaith leat an raon níos leithne seo a úsáid gan rabhaidh, is féidir leat CachekeyWarning` a thostú leis an gcód seo sa mhodúl bainistí` de cheann de do:

import warnings

from django.core.cache import CacheKeyWarning

warnings.simplefilter("ignore", CacheKeyWarning)

Más mian leat loighic bailíochtaithe eochair saincheaptha a sholáthar ina ionad sin do cheann de na cúltaca ionsuite, is féidir leat é a fho-aicmiú, díreach an modh validate_key a shárú, agus na treoracha chun cúltaca taisce saincheaptha a úsáid `_ a leanúint. Mar shampla, chun é seo a dhéanamh don chúltaca ``locmem`, cuir an cód seo i modúl:

from django.core.cache.backends.locmem import LocMemCache


class CustomLocMemCache(LocMemCache):
    def validate_key(self, key):
        """Custom validation, raising exceptions or warnings as needed."""
        ...

... agus bain úsáid as an gcosán poncaigh Python chuig an rang seo sa chuid: setting: BACKEND `de do shuíomh: <CACHES-BACKEND>CACHES`.