---
title: "Lokalisering av format"
version: 5.2
locale: sv
source: https://docs.djangoproject.com/sv/5.2/topics/i18n/formatting/
canonical: https://djangodocs.dev/sv/5.2/topics/i18n/formatting/
---
# Lokalisering av format

## Översikt

Djangos formateringssystem kan visa datum, tider och siffror i mallar med hjälp av det format som anges för den aktuella [locale](/sv/5.2/topics/i18n/#term-locale-name). Det hanterar också lokaliserad inmatning i formulär.

Två användare som får tillgång till samma innehåll kan se datum, tider och siffror formaterade på olika sätt, beroende på formaten för deras aktuella plats.

> **Note**
>
> För att aktivera talformatering med tusentalsavgränsare måste du ange [`USE_THOUSAND_SEPARATOR = True`](/sv/5.2/ref/settings/#std-setting-USE_THOUSAND_SEPARATOR) i din inställningsfil. Alternativt kan du använda [`intcomma`](/sv/5.2/ref/contrib/humanize/#std-templatefilter-intcomma) för att formatera siffror i din mall.

> **Note**
>
> Det finns en relaterad [`USE_I18N`](/sv/5.2/ref/settings/#std-setting-USE_I18N)-inställning som styr om Django ska aktivera översättning. Se [Översättning](/sv/5.2/topics/i18n/translation/) för mer information.

## Lokalanpassad inmatning i formulär

När formatering är aktiverat kan Django använda lokala format när datum, tider och siffror analyseras i formulär. Det innebär att den försöker olika format för olika lokala när den gissar det format som används av användaren när han eller hon matar in data i formulär.

> **Note**
>
> Django använder andra format för att visa data än de som används för att analysera data. Framför allt kan formaten för att analysera datum inte använda `%a` (förkortat veckodagsnamn), `%A` (fullständigt veckodagsnamn), `%b` (förkortat månadsnamn), `%B` (fullständigt månadsnamn) eller `%p` (AM/PM).

För att aktivera ett formulärfält för att lokalisera in- och utdata använder du dess `localize`-argument:

```
class CashRegisterForm(forms.Form):
    product = forms.CharField()
    revenue = forms.DecimalField(max_digits=4, decimal_places=2, localize=True)
```

## Styrning av lokalisering i mallar

Django försöker använda ett lokalspecifikt format när det skriver ut ett värde i en mall.

Det är dock inte alltid lämpligt att använda lokaliserade värden - om du t.ex. skriver ut JavaScript eller XML som är utformat för att vara maskinläsbart vill du alltid använda icke-lokaliserade värden. Du kanske också vill använda lokalisering i utvalda mallar i stället för att använda lokalisering överallt.

För att möjliggöra en fin kontroll över användningen av lokalisering tillhandahåller Django mallbiblioteket `l10n` som innehåller följande taggar och filter.

### Malltaggar

#### `lokalisera`

Aktiverar eller inaktiverar lokalisering av mallvariabler i det block som ingår.

För att aktivera eller avaktivera lokalisering för ett mallblock, använd:

```html+django
{% load l10n %}

{% localize on %}
    {{ value }}
{% endlocalize %}

{% localize off %}
    {{ value }}
{% endlocalize %}
```

När lokalisering är inaktiverad tillämpas formaten [lokaliseringsinställningar](/sv/5.2/ref/settings/#settings-l10n).

Se [`localize`](#std-templatefilter-localize) och [`unlocalize`](#std-templatefilter-unlocalize) för mallfilter som gör samma sak per variabel.

### Mallfilter

#### `lokalisera`

Tvingar fram lokalisering av ett enda värde.

Till exempel:

```html+django
{% load l10n %}

{{ value|localize }}
```

För att inaktivera lokalisering för ett enskilt värde, använd [`unlocalize`](#std-templatefilter-unlocalize). För att kontrollera lokalisering över en stor del av en mall, använd [`localize`](#std-templatetag-localize) malltagg.

#### `avlokalisera`

Tvingar ett enskilt värde att skrivas ut utan lokalisering.

Till exempel:

```html+django
{% load l10n %}

{{ value|unlocalize }}
```

För att tvinga fram lokalisering av ett enda värde, använd [`localize`](#std-templatefilter-localize). För att kontrollera lokalisering över en stor del av en mall, använd [`localize`](#std-templatetag-localize) malltagg.

Returnerar en strängrepresentation för tal (`int`, `float` eller `Decimal`) med [lokaliseringsinställningar](/sv/5.2/ref/settings/#settings-l10n)-formaten tillämpade.

## Skapa anpassade formatfiler

Django tillhandahåller formatdefinitioner för många lokala språk, men ibland kanske du vill skapa dina egna, eftersom det inte finns någon formatfil för ditt lokala språk, eller för att du vill skriva över några av värdena.

Om du vill använda anpassade format måste du först ange sökvägen där formatfilerna ska placeras.  Det gör du genom att ställa in [`FORMAT_MODULE_PATH`](/sv/5.2/ref/settings/#std-setting-FORMAT_MODULE_PATH) till det paket där formatfilerna ska finnas, till exempel:

```
FORMAT_MODULE_PATH = [
    "mysite.formats",
    "some_app.formats",
]
```

Filerna placeras inte direkt i den här katalogen utan i en katalog med samma namn som den lokala, och måste ha namnet `formats.py`. Var försiktig så att du inte lägger känslig information i dessa filer eftersom värdena inuti kan exponeras om du skickar strängen till `django.utils.formats.get_format()` (används av [`date`](/sv/5.2/ref/templates/builtins/#std-templatefilter-date) mallfilter).

För att anpassa de engelska formaten skulle en struktur som denna behövas:

```text
mysite/
    formats/
        __init__.py
        en/
            __init__.py
            formats.py
```

där `formats.py` innehåller anpassade formatdefinitioner. Till exempel:

```
THOUSAND_SEPARATOR = "\xa0"
```

för att använda ett obrutet mellanslag (Unicode `00A0`) som tusentalsavgränsare, i stället för standardkommat på engelska.

## Begränsningar för de lokala format som tillhandahålls

Vissa lokala språk använder kontextkänsliga format för siffror, vilket Djangos lokaliseringssystem inte kan hantera automatiskt.

### Schweiz (Tyska, franska)

Det schweiziska talformatet varierar traditionellt beroende på sammanhanget. Till exempel kan monetära värden använda en punkt som decimalavgränsare (`Fr. 23,50`), medan mått ofta använder ett komma (`22,5 m`). Djangos lokaliseringssystem stöder inte sådana kontextspecifika variationer automatiskt.

Det lokala formatet som tillhandahålls av Django använder generiska separatorer, ett komma för decimaler och ett mellanslag för tusentalsseparatorer.