---
title: "Comhaid a bhainistiú"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/topics/files/
canonical: https://djangodocs.dev/ga/6.0/topics/files/
---
# Comhaid a bhainistiú

Déanann an doiciméad seo cur síos ar APIs rochtana comhaid Django do chomhaid mar iad siúd a uaslódálann úsáideoir Tá na APIs leibhéal níos ísle ginearálta go leor gur féidir leat iad a úsáid chun críocha eile. Más mian leat “comhaid statacha” a láimhseáil (JS, CSS, srl.), Féach: doc: /howto/static-files/index .

De réir réamhshocraithe, stóráilíonn Django comhaid go háitiúil, ag baint úsáide as socruithe:: MEDIA\_ROOT agus:setting: MEDIA\_URL. Glacann na samplaí thíos leis go bhfuil na réamhshocruithe seo á úsáid agat.

Mar sin féin, soláthraíonn Django bealaí chun córais stórála comhad \_ saincheaptha a scríobh a ligeann duit cá háit agus conas a stórálann Django comhaid a shaincheapadh go hiomlán. Déanann an dara leath den doiciméad seo cur síos ar conas a oibríonn na córais stórála

## Comhaid a úsáid i samhlacha

Nuair a úsáideann tú a:class: ~django.db.models.filefield nó:class: ~django.db.models.imagefield, soláthraíonn Django sraith APIs is féidir leat a úsáid chun déileáil leis an gcomhad sin.

Smaoinigh ar an tsamhail seo a leanas, ag baint úsáide as an:class: ~django.db.models.imagefield chun grianghraf a stóráil:

```
from django.db import models

class Car(models.Model):
    name = models.CharField(max_length=255)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    photo = models.ImageField(upload_to="cars")
    specs = models.FileField(upload_to="specs")
```

Beidh tréith ```grianghraf ``ag aon shampla ``Car``` is féidir leat a úsáid chun sonraí an ghrianghraf ceangailte a fháil:

```pycon
>>> car = Car.objects.get(name="57 Chevy")
>>> car.photo
<ImageFieldFile: cars/chevy.jpg>
>>> car.photo.name
'cars/chevy.jpg'
>>> car.photo.path
'/media/cars/chevy.jpg'
>>> car.photo.url
'https://media.example.com/cars/chevy.jpg'
```

Is réad “Comhad” é an réad seo - `car.photo` sa sampla -- réad Comhad , rud a chiallaíonn go bhfuil na modhanna agus na tréithe go léir a thuairiscítear thíos aige.

> **Note**
>
> Sábháiltear an comhad mar chuid den tsamhail a shábháil sa bhunachar sonraí, mar sin ní féidir brath ar an ainm comhaid iarbhír a úsáidtear ar dhiosca go dtí go ndéanfar an tsamhail a shábháil.

Mar shampla, is féidir leat ainm an chomhaid a athrú tríd an comhad a shocrú 's:attr: ~django.core.files.name go cosán i gcoibhneas le suíomh stórála an chomhaid (:setting: MEDIA\_ROOT má tá an réamhshocraithe:class: ~django.core.files.storage.fileSystemStorage):

```pycon
>>> import os
>>> from django.conf import settings
>>> initial_path = car.photo.path
>>> car.photo.name = "cars/chevy_ii.jpg"
>>> new_path = os.path.join(settings.MEDIA_ROOT, car.photo.name)
>>> # Move the file on the filesystem
>>> os.rename(initial_path, new_path)
>>> car.save()
>>> car.photo.path
'/media/cars/chevy_ii.jpg'
>>> car.photo.path == new_path
True
```

Chun comhad atá ann cheana a shábháil ar dhiosca chuig a:class: ~Django.db.Models.FileField:

```pycon
>>> from pathlib import Path
>>> from django.core.files import File
>>> path = Path("/some/external/specs.pdf")
>>> car = Car.objects.get(name="57 Chevy")
>>> with path.open(mode="rb") as f:
...     car.specs = File(f, name=path.name)
...     car.save()
...
```

> **Note**
>
> Cé go bhfuil tréithe sonraí neamh-íomhá: Class: ~django.db.models.imagefield ar fáil ar an gcás, mar shampla ```airde ``, `leithead```, agus `size` \`\` \`\` \`\` fiú, ní féidir na sonraí íomhá bunúsacha a úsáid gan an íomhá a athoscailt. Mar shampla:
>
> ```pycon
> >>> from PIL import Image
> >>> car = Car.objects.get(name="57 Chevy")
> >>> car.photo.width
> 191
> >>> car.photo.height
> 287
> >>> image = Image.open(car.photo)
> # Raises ValueError: seek of closed file.
> >>> car.photo.open()
> <ImageFieldFile: cars/chevy.jpg>
> >>> image = Image.open(car.photo)
> >>> image
> <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=191x287 at 0x7F99A94E9048>
> ```

## An réad Comhad \`\`

Go hinmheánach, úsáideann Django sampla a:class: Django.core.files.file aon uair a theastaíonn uaidh comhad a léiriú.

An chuid is mó den am úsáidfidh tú Comhad a thug Django duit (ie comhad atá ceangailte le samhail mar thuas, nó comhad uaslódáilte b'fhéidir).

Más gá duit ```Comhad ``a thógáil duit féin, is é an bealach is éasca ceann a chruthú ag baint úsáide as réad `comhad``` ionsuite Python:

```pycon
>>> from django.core.files import File

# Create a Python file object using open()
>>> f = open("/path/to/hello.world", "w")
>>> myfile = File(f)
```

Anois is féidir leat aon cheann de na tréithe agus na modhanna doiciméadaithe den aicme:class: ~django.core.files.file a úsáid.

Bí ar an eolas nach ndúntar comhaid a cruthaíodh ar an mbealach seo go huathoibr Is féidir an cur chuige seo a leanas a úsáid chun comhaid a dhúnadh go huathoibr

```pycon
>>> from django.core.files import File

# Create a Python file object using open() and the with statement
>>> with open("/path/to/hello.world", "w") as f:
...     myfile = File(f)
...     myfile.write("Hello World")
...
>>> myfile.closed
True
>>> f.closed
True
```

Tá sé tábhachtach go háirithe comhaid a dhúnadh agus tú ag teacht ar réimsí comhaid i lúb thar líon mór rudaí. Mura ndúntar comhaid de láimh tar éis rochtain a fháil orthu, d'fhéadfadh an riosca go n-éireoidh amach as tuairiscí comhaid. D'fhéadfadh an earráid seo a leanas a bheith mar thoradh air seo:

```pytb
OSError: [Errno 24] Too many open files
```

## Stóráil comhad

Taobh thiar de na radhairc, déanann Django cinntí faoi conas agus cá háit a stóráil comhaid chuig córas stórála comhaid. Is é seo an réad a thuigeann rudaí cosúil le córais chomhaid, comhad a oscailt agus a léamh, srl.

Is é stóráil comhaid réamhshocraithe Django `` ` ``:class: django.core.files.storage.filesystemStorage```. Mura soláthraíonn tú córas stórála go sainráite san eochair ``réamhshocraithe``` den socrú:setting: STORAGES, is é seo an ceann a úsáidfear.

Féach thíos le haghaidh sonraí faoin gcóras stórála comhaid réamhshocraithe ionsuite, agus féach: doc: /howto/custom-file-storage le haghaidh faisnéise maidir le do chóras stórála comhaid féin a scríobh.

### Rudaí stórála

Cé go mbeidh tú ag iarraidh réad Comhad a úsáid an chuid is mó den am (a thosclaíonn chuig an stóráil cheart don chomhad sin), is féidir leat córais stórála comhaid a úsáid go díreach. Is féidir leat sampla de rang stórála comhaid saincheaptha a chruthú, nó - is minic níos úsáideach - is féidir leat an córas stórála réamhshocraithe domhanda a úsáid:

```pycon
>>> from django.core.files.base import ContentFile
>>> from django.core.files.storage import default_storage

>>> path = default_storage.save("path/to/file", ContentFile(b"new content"))
>>> path
'path/to/file'

>>> default_storage.size(path)
11
>>> default_storage.open(path).read()
b'new content'

>>> default_storage.delete(path)
>>> default_storage.exists(path)
False
```

Féach: doc: /ref/files/storage don API stórála comhaid.

### An rang stórála córas comhaid ionsuite

Seolann Django le aicme a:class: django.core.files.storage.filesystemStorage a chuireann stóráil bhunúsach comhaid chórais comhaid áitiúil i bhfeidhm.

Mar shampla, stóráilfidh an cód seo a leanas comhaid uaslódáilte faoi /meáin/grianghraif is cuma cad é do shuíomh: MEDIA\_ROOT:

```
from django.core.files.storage import FileSystemStorage
from django.db import models

fs = FileSystemStorage(location="/media/photos")

class Car(models.Model):
    ...
    photo = models.ImageField(storage=fs)
```

[Custom storage systems](/ga/6.0/howto/custom-file-storage/) work the same way:
you can pass them in as the `storage` argument to a
[`FileField`](/ga/6.0/ref/models/fields/#django.db.models.FileField).

### Ag baint úsáide as inghlaoch

Is féidir leat glaoch a úsáid mar an paraiméadar: attr: ~django.db.models.filefield.storage le haghaidh: class: ~django.db.models.filefield nó:class: ~django.db.models.imagefield. Ligeann sé seo duit an stóráil a úsáidtear a mhodhnú ag rith, ag roghnú stórásanna éagsúla do thimpeallachtaí éagsúla, mar shampla.

Your callable will be evaluated when your model classes are loaded, and must
return an instance of [`Storage`](/ga/6.0/ref/files/storage/#django.core.files.storage.Storage).

Mar shampla:

```
from django.conf import settings
from django.db import models
from .storages import MyLocalStorage, MyRemoteStorage

def select_storage():
    return MyLocalStorage() if settings.DEBUG else MyRemoteStorage()

class MyModel(models.Model):
    my_file = models.FileField(storage=select_storage)
```

D'fhonn stóráil a shainmhínítear sa socrú: socrú: STORAGES is féidir leat úsáid:data: ~django.core.files.storage.storages:

```
from django.core.files.storage import storages

def select_storage():
    return storages["mystorage"]

class MyModel(models.Model):
    upload = models.FileField(storage=select_storage)
```

Because the callable is evaluated when your model classes are loaded, if you
need to override the [`STORAGES`](/ga/6.0/ref/settings/#std-setting-STORAGES) setting in tests, you should use a
`LazyObject` subclass instead:

```
from django.core.files.storage import storages
from django.utils.functional import LazyObject

class OtherStorage(LazyObject):
    def _setup(self):
        self._wrapped = storages["mystorage"]

my_storage = OtherStorage()

class MyModel(models.Model):
    upload = models.FileField(storage=my_storage)
```

The `LazyObject` delays the evaluation of the storage until it's actually
needed, allowing [`override_settings()`](/ga/6.0/topics/testing/tools/#django.test.override_settings) to take effect:

```
@override_settings(
    STORAGES={
        "mystorage": {
            "BACKEND": "django.core.files.storage.InMemoryStorage",
        }
    }
)
def test_storage():
    model = MyModel()
    assert isinstance(model.upload.storage, InMemoryStorage)
```