---
title: "Sonraí Unicode"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/ref/unicode/
canonical: https://djangodocs.dev/ga/6.1/ref/unicode/
---
# Sonraí Unicode

Tacaíonn Django le sonraí Unicode i ngach áit.

Insíonn an doiciméad seo duit cad is gá duit a bheith ar an eolas má tá tú ag scríobh feidhmchláir a úsáideann sonraí nó teimpléid atá ionchódaithe i rud éigin eile seachas ASCII.

## An bunachar sonraí a chruthú

Déan cinnte go bhfuil do bhunachar sonraí cumraithe chun a bheith in ann sonraí sreangán treallach a stóráil De ghnáth, ciallaíonn sé seo ionchódú UTF-8 nó UTF-16 a thabhairt dó. Má úsáideann tú ionchódú níos sriantacha - mar shampla, latin1 (iso8859-1) - ní bheidh tú in ann carachtair áirithe a stóráil sa bhunachar sonraí, agus caillfear faisnéis.

- Úsáideoirí MySQL, féach ar an lámhleabhar MySQL \_ le haghaidh sonraí maidir le conas ionchódú tacar carachtair bunachar sonraí a shocrú nó a athrú.
- Úsáideoirí PostgreSQL, féach ar an lámhleabhar PostgreSQL \_ le haghaidh sonraí maidir le bunachair sonraí a chruthú leis an ionchódú ceart.
- Úsáideoirí Oracle, féach ar an [lámhleabhar Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/nlspg/index.html) le haghaidh sonraí maidir le conas ionchódú tacar carachtar bunachar sonraí a shocrú ([alt 2](https://docs.oracle.com/en/database/oracle/oracle-database/21/nlspg/character-set-migration.html)) nó a athrú ([alt 11](https://docs.oracle.com/en/database/oracle/oracle-database/21/nlspg/choosing-character-set.html)).
- Úsáideoirí SQLite, níl aon rud is gá duit a dhéanamh. Úsáideann SQLite UTF-8 i gcónaí le haghaidh ionchódú inmheánach.

Tiontaíonn cúltaca bunachar sonraí go léir Django teaghráin go huathoibríoch ina ionchódú cuí chun labhairt leis an mbunachar sonraí. Déanann siad teaghráin a aisghabhadh ón mbunachar sonraí a thiontú go huathoi Ní gá duit fiú a rá le Django cén ionchódú a úsáideann do bhunachar sonraí: déantar é sin a láimhseáil go trédhearcach.

Le haghaidh tuilleadh, féach an chuid “An API bunachar sonraí” thíos.

## Láimhseáil teaghrán gin

Aon uair a úsáideann tú teaghráin le Django - m.sh. i lorg bunachar sonraí, rindreáil teimpléad nó áit ar bith eile - tá dhá rogha agat chun na teaghráin sin a ionchódú. Is féidir leat gnáthteaghráin nó bytestrings a úsáid (ag tosú le 'b').

> **Warning**
>
> Ní iompraíonn bytestring aon fhaisnéis leis faoina ionchódú. Ar an gcúis sin, caithfimid toimhde a dhéanamh, agus glacann Django leis go bhfuil gach bytestrings i UTF-8.
>
> Má chuireann tú sreang chuig Django atá ionchódaithe i bhformáid éigin eile, rachaidh rudaí mícheart ar bhealaí suimiúla. De ghnáth, ardóidh Django `UnicodeDecodeError` ag pointe éigin.

Mura n-úsáideann do chód ach sonraí ASCII, tá sé sábháilte do ghnáthshreangáin a úsáid, agus iad a chur timpeall ar uacht, toisc gur fo-thacar de UTF-8 é ASCII.

Ná bíodh a mhealladh ag smaoineamh má tá do socrú: setting: DEFAULT\_CHARSET socraithe ar rud éigin seachas `utf-8'` is féidir leat an t-ionchódú eile sin a úsáid i do theagraí bytestrings! :setting: Ní bhaineann DEFAULT\_CHARSET ach leis na teaghráin a ghintear mar thoradh ar rindreáil teimpléid (agus ríomhphost). Glacfaidh Django le hionchódú UTF-8 i gcónaí le haghaidh bytestrings inmheánacha. Is é an chúis leis seo ná nach bhfuil an socrú: setting: DEFAULT\_CHARSET faoi do smacht i ndáiríre (más tusa an forbróir feidhmchláir). Tá sé faoi smacht an duine atá ag suiteáil agus ag úsáid d'iarratas - agus má roghnaíonn an duine sin suíomh difriúil, caithfidh do chód leanúint ar aghaidh ag obair. Mar sin, ní féidir leis brath ar an suíomh sin.

I bhformhór na gcásanna nuair a bhíonn Django ag déileáil le teaghráin, tiontóidh sé iad go teaghráin sula ndéanfaidh sé aon rud eile. Mar sin, mar riail ghinearálta, má théann tú i mbytestring, bí réidh le sreang a fháil ar ais sa toradh.

### Teagáin aistrithe

Seachas teaghráin agus bytestrings, tá tríú cineál réad cosúil le sreanga ann a d'fhéadfá teacht ar aghaidh agus Django á úsáid agat. Tugann gnéithe idirnáisiúnaithe an chreat coincheap “aistriúcháin leisciúil” isteach - sreang atá marcáilte mar aistrithe ach nach gcinntear a thoradh aistriúcháin iarbhír go dtí go n-úsáidtear an réad i sreang. Tá an ghné seo úsáideach i gcásanna nach bhfuil an láithreán aistriúcháin ar eolas go dtí go n-úsáidtear an sreang, cé go bhféadfadh gur cruthaíodh an teaghrán ar dtús nuair a allmhairíodh an cód den chéad uair.

De ghnáth, ní bheidh ort a bheith buartha faoi aistriúcháin leisciúla. Bí ar an eolas má scrúdaíonn tú réad agus maíonn sé gur `django.utils.functional é. __proxy__` réad, is aistriúchán leisciúil é. Ag glaoch ar str () leis an aistriúchán leisciúil mar gheobhaidh an argóint teaghrán sa réigiún reatha.

Le haghaidh tuilleadh sonraí faoi rudaí aistriúcháin leisciúil, féach ar an doiciméadach:doc: \</topics/i18n/index\> idirnáisiúnaíon.

### feidhmeanna fóntais úsáideacha

Toisc go dtagann roinnt oibríochtaí teaghráin suas arís agus arís eile, seolann Django le cúpla feidhm úsáideach ar chóir go mbeadh sé níos éasca oibriú le rudaí sreangán agus bytestring.

#### Feidhmeanna tiontú

Tá cúpla feidhm sa mhodúl `django.utils.encoding` atá áisiúil chun tiontú anall agus anall idir teaghráin agus bytestrings.

- ```smart_str (s, encoding='utf-8', strings_only=false, errors='strict') ``athraíonn a ionchur go sreang. Sonraíonn an paraiméadar ``ionchód``` an ionchódú ionchuir. (Mar shampla, úsáideann Django é seo go hinmheánach agus sonraí ionchuir foirme á bpróiseáil, nach bhféadfadh a bheith ionchódaithe UTF-8.) Mar thoradh ar an bparaiméadar strings\_only, má tá sé socraithe go True, ní thiontófar uimhreacha Python, booleans agus `None` go sreang (coinníonn siad a gcineálacha bunaidh). Glacann an paraiméadar ```earráidí ``aon cheann de na luachanna a nglacann feidhm ``str ()``` Python lena láimhseáil earráide.
- ```force_str (s, encoding='utf-8', strings_only=false, errors='strict') ``comhionann le ``smart_str ()``` i mbeagnach gach cás. Is é an difríocht nuair is é an chéad argóint a: ref: aistriúchán leisciúil \<lazy-translations\>\`sampla. Cé go gcaomhnóidh \`\`smart\_str () \`\`aistriúcháin leisciúla, cuireann \`\`force\_str ()\` iallach ar na rudaí sin chuig teaghrán (is cúis leis an aistriúchán tarlú). De ghnáth, beidh tú ag iarraidh smart\_str () a úsáid. Mar sin féin, tá force\_str () úsáideach i gclibeanna teimpléad agus scagairí a bhfuil teaghrán aige go hiomlán\* le bheith ag obair leo, ní amháin rud is féidir a thiontú go sreang.
- Tá ```smart_bytes (s, encoding='utf-8', strings_only=false, errors='strict') ``go bunúsach a mhalairt de ``smart_str ()```. Cuireann sé iallach ar an gcéad argóint chuig bytestring. Tá an t-iompar céanna ag an bparaiméadar `strings_only` agus le haghaidh ```smart_str () ``agus ``force_str ()```. Is séimeantaic beagán difriúil é seo ó fheidhm 'str () tógáilte Python, ach tá an difríocht ag teastáil i gcúpla áit laistigh de inmheánacha Django.

De ghnáth, ní bheidh ort ach force\_str () a úsáid. Glaoigh air chomh luath agus is féidir ar aon sonraí ionchuir a d'fhéadfadh a bheith ina shreang nó ina mbeagán, agus as sin ar aghaidh, is féidir leat an toradh a chóireáil mar shreang i gcónaí.

#### Láimhseáil URI agus IRI

Caithfidh creataí gréasáin déileáil le URLanna (ar cineál IRI iad). Riachtanas amháin a bhaineann le URLanna ná go ndéantar iad a ionchódú ag baint úsáide as carachtair ASCII amháin. \<3986\>Mar sin féin, i \<3987\>dtimpeallacht idirnáisiúnta, b'fhéidir go mbeidh ort URL a thógáil ó an:rfc: IRI \`-- go han-scaoilte, a:rfc: \`URI a d'fhéadfadh carachtair Unicode a bheith ann. Úsáid na feidhmeanna seo chun IRI a lua agus a thiontú go URI:

- The [`django.utils.encoding.iri_to_uri()`](/ga/6.1/ref/utils/#django.utils.encoding.iri_to_uri) function, which implements the
  conversion from IRI to URI as required by [**RFC 3987 Section 3.1**](https://datatracker.ietf.org/doc/html/rfc3987.html#section-3.1).
- Feidhmeanna:func: urllib.parse.quote agus:func: urllib.parse.quote\_plus ó leabharlann caighdeánach Python.

Tá cuspóirí beagán difriúil ag an dá ghrúpa feidhmeanna seo, agus tá sé tábhachtach iad a choinneáil díreach. De ghnáth, úsáidfeá quote () ar na codanna aonair den chosán IRI nó URI ionas go ndéantar aon charachtair áirithe mar '&' nó '% 'a ionchódú i gceart. Ansin, cuireann tú iri\_to\_uri () i bhfeidhm ar an IRI iomlán agus athraíonn sé aon charachtair neamh-ASCII go dtí na luachanna cearta ionchódaithe.

> **Note**
>
> Go teicniúil, níl sé ceart a rá go gcuireann iri\_to\_uri () an algartam iomlán i bhfeidhm i sonraíocht IRI. Ní dhéanann sé (fós) an chuid ionchódú ainm fearainn idirnáisiúnta den algartam.

Ní athróidh an fheidhm iri\_to\_uri () carachtair ASCII a cheadaítear ar shlí eile i URL. Mar sin, mar shampla, ní ionchódaítear an carachtar '%' a thuilleadh nuair a chuirtear ar aghaidh chuig iri\_to\_uri () . Ciallaíonn sé seo gur féidir leat URL iomlán a chur chuig an bhfeidhm seo agus ní chuirfidh sé praiseach ar an sreang fiosrúcháin nó aon rud mar sin.

D'fhéadfadh sampla rudaí a shoiléiriú anseo:

```pycon
>>> from urllib.parse import quote
>>> from django.utils.encoding import iri_to_uri
>>> quote("Paris & Orléans")
'Paris%20%26%20Orl%C3%A9ans'
>>> iri_to_uri("/favorites/François/%s" % quote("Paris & Orléans"))
'/favorites/Fran%C3%A7ois/Paris%20%26%20Orl%C3%A9ans'
```

Má fhéachann tú go cúramach, is féidir leat a fheiceáil nár luadh dúbailte an chuid a ghinigh le ```quote () ``sa dara sampla nuair a cuireadh chuig `iri_to_uri ()```. Is gné an-tábhachtach agus úsáideach é seo. Ciallaíonn sé gur féidir leat do IRI a thógáil gan a bheith buartha faoi an bhfuil carachtair neamh-ASCII ann agus ansin, ag an deireadh, glaoch ar iri\_to\_uri () ar an toradh.

Similarly, Django provides [`django.utils.encoding.uri_to_iri()`](/ga/6.1/ref/utils/#django.utils.encoding.uri_to_iri) which
implements the conversion from URI to IRI as per [**RFC 3987 Section 3.2**](https://datatracker.ietf.org/doc/html/rfc3987.html#section-3.2).

Sampla chun a thaispeáint:

```pycon
>>> from django.utils.encoding import uri_to_iri
>>> uri_to_iri("/%E2%99%A5%E2%99%A5/?utf8=%E2%9C%93")
'/♥♥/?utf8=✓'
>>> uri_to_iri("%A9hello%3Fworld")
'%A9hello%3Fworld'
```

Sa chéad shampla, ní luaitear na carachtair UTF-8. Sa dara ceann, fanann na hinchódaithe céatadáin gan athrú toisc go bhfuil siad lasmuigh den raon bailí UTF-8 nó go léiríonn siad carachtar forchoimeádta.

Tá feidhmeanna ```iri_to_uri () ``agus ``uri_to_iri ()``` idempotent, rud a chiallaíonn go bhfuil an méid seo a leanas fíor i gcónaí:

```
iri_to_uri(iri_to_uri(some_string)) == iri_to_uri(some_string)
uri_to_iri(uri_to_iri(some_string)) == uri_to_iri(some_string)
```

Mar sin is féidir leat glaoch go sábháilte air arís agus arís eile ar an URI/IRI céanna gan fadhbanna luachana dúbailte a chur i mbaol.

## Samhla

Toisc go gcuirtear gach teaghráin ar ais ón mbunachar sonraí mar rudaí str, beidh luachanna Unicode i réimsí samhail atá bunaithe ar charachtar (CharField, TextField, URLField, srl.) Nuair a aisghabhann Django sonraí ón mbunachar sonraí. Is é seo\* i gcónaí\* an cás, fiú dá bhféadfadh na sonraí oiriúnach i mbytestring ASCII.

Is féidir leat dul isteach i mbytestrings agus tú ag cruthú samhail nó ag daonrú réimse, agus déanfaidh Django é a thiontú go teaghráin nuair is gá dó.

### Ag tabhairt aire i get\_absolute\_url () \`\`

Ní féidir ach carachtair ASCII a bheith ag URLanna. Má tá URL á thógáil agat ó phíosaí sonraí a d'fhéadfadh a bheith neamh-ASCII, bí cúramach na torthaí a ionchódú ar bhealach atá oiriúnach do URL. Láimhseálann an fheidhm: Func: ~django.urls.reverse é seo duit go huathoibríoch.

Má tá URL á thógáil agat de láimh (ie, *ní* ag baint úsáide as an bhfeidhm ```reverse () `), beidh ort aire a thabhairt don ionchódú tú féin. Sa chás seo, bain úsáid as na feidhmeanna ``iri_to_uri () ``agus ``quote ()``` a doiciméadaíodh [thuas](#id1). Mar shampla:

```
from urllib.parse import quote
from django.utils.encoding import iri_to_uri

def get_absolute_url(self):
    url = "/person/%s/?x=0&y=0" % quote(self.location)
    return iri_to_uri(url)
```

Tugann an fheidhm seo URL ionchódaithe i gceart fiú má tá `self.location` rud cosúil le “Thug Jack cuairt ar Pháras & Orléans”. (Go deimhin, níl an glao iri\_to\_uri () riachtanach go docht sa sampla thuas, toisc go mbainfí na carachtair neamh-ASCII go léir agus iad ag lua sa chéad líne.)

## Teimpléid

Úsáid teaghráin agus teimpléid á chruthú de láimh:

```
from django.template import Template

t2 = Template("This is a string template.")
```

But the common case is to read templates from the filesystem. If your template
files are not stored with a UTF-8 encoding, adjust the [`TEMPLATES`](/ga/6.1/ref/settings/#std-setting-TEMPLATES)
setting. The built-in [`django`](/ga/6.1/topics/templates/#module-django.template.backends.django) backend
provides the `'file_charset'` option to change the encoding used to read
files from disk.

Rialaíonn an socrú: SETTING: DEFAULT\_CHARSET ionchódú teimpléid rindreáilte. Tá sé seo socraithe go UTF-8 de réir réamhshocraithe.

### Clibeanna teimpléad agus scagair

Cúpla leid le cuimhneamh agus do chlibeanna agus scagairí teimpléad féin á scríobh:

- Cuir teaghráin ar ais i gcónaí ó mhodh render () chlib teimpléad agus ó scagairí teimpléad.
- Úsáid ```force_str () ``i rogha ``smart_str ()``` sna háiteanna seo. Tarlaíonn rindreáil clibeanna agus glaonna scagaire de réir mar a bhíonn an teimpléad á léiriú, mar sin níl aon bhuntáiste ann tiontú rudaí aistriúcháin leisciúil a chur siar ina teaghráin. Tá sé níos éasca oibriú amháin le teaghráin ag an bpointe sin.

## Comhaid

Má tá sé ar intinn agat ligean d'úsáideoirí comhaid a uaslódáil, ní mór duit a chinntiú go bhfuil an timpeallacht a úsáidtear chun Django a reáchtáil cumraithe chun oibriú le hainmneacha comhaid nach Mura bhfuil do thimpeallacht cumraithe i gceart, beidh eisceachtaí UnicodeEncodeError agat agus tú ag sábháil comhaid le hainmneacha comhaid nó ábhar ina bhfuil carachtair neamh-ASCII.

Athraíonn tacaíocht chórais chomhaid d'ainmneacha comhaid UTF-8 agus d'fhéadfadh sé go mbraitheann sé ar an gcomhshaol. Seiceáil do chumraíocht reatha i bhlaosc idirghníomhach Python trí rith:

```
import sys

sys.getfilesystemencoding()
```

Ba chóir go n-aschur sé seo “UTF-8".

Tá an t-athróg comhshaoil LANG freagrach as an ionchódú a bhfuil súil leis a shocrú ar ardáin Unix. Téigh i gcomhairle leis na cáipéisíocht do do chóras oibriúcháin agus do fhreastalaí feidhmchláir chun an comhréir agus an suíomh cuí Féach na:doc: /howto/deployment/wsgi/modwsgi le haghaidh samplaí.

I do thimpeallacht forbartha, b'fhéidir go mbeidh ort socrú a chur le do `~.bashrc` atá cosúil le:

```shell
export LANG="en_US.UTF-8"
```

## Foirm aighneacht

Is réimse deacair é aighneacht foirme HTML. Níl aon ráthaíocht ann go mbeidh faisnéis ionchódú san aighneacht, rud a chiallaíonn go bhféadfadh go mbeadh ar an gcreat tuairim a dhéanamh ar ionchódú sonraí curtha isteach.

Glacann Django cur chuige “leisciúil” maidir le sonraí foirme a dhíchódú. Ní dhíchódaítear na sonraí i réad HttpRequest\` ach nuair a rochtaíonn tú air. Déanta na fírinne, ní dhíchódaítear an chuid is mó de na sonraí ar chor ar bith. Níl aon díchódú i bhfeidhm orthu ach na struchtúir sonraí HttpRequest.get\` agus ```HttpRequest.post ``. Tabharfaidh an dá réimse sin a gcuid baill ar ais mar shonraí Unicode. Tugann gach tréithe agus modh eile ``HttpRequest``` sonraí ar ais go díreach mar a chuir an cliant isteach iad.

De réir réamhshocraithe, úsáidtear an socrú: setting: DEFAULT\_CHARSET mar an ionchódú glactha le haghaidh sonraí foirme. Más gá duit é seo a athrú le haghaidh foirm áirithe, is féidir leat an tréith `encoding` a shocrú ar shampla HttpRequest\`. Mar shampla:

```
def some_view(request):
    # We know that the data must be encoded as KOI8-R (for some reason).
    request.encoding = "koi8-r"
    ...
```

Is féidir leat an t-ionchódú a athrú fiú tar éis duit rochtain a fháil ar `Request.get` nó `request.post`, agus úsáidfidh gach rochtain ina dhiaidh sin an t-ionchódú nua.

Ní chaithfidh mórchuid na bhforbróirí a bheith buartha faoi ionchódú foirme a athrú, ach is gné úsáideach é seo d'iarratais a labhraíonn le córais oidhreachta nach féidir leat a n-ionchódú a rialú.

Ní dhíchódálann Django sonraí uaslódála comhad, toisc go ndéileálfar leis na sonraí sin de ghnáth mar bhailiúcháin béite, seachas teaghráin. Athródh aon díchódú uathoibríoch ann brí sruth na mbetaí.