Généralement parlant quand vous essayez de 'juste obtenir un exemple de travail' il est préférable de 'juste commencer à écrire du code'. Il n'y a pas de code ici pour vous aider, donc répondre à la question nous fait beaucoup plus de travail.

si vous voulez récupérer un fichier, vous avez besoin de quelque chose comme ça dans un fichier html quelque part:

<form method="post" enctype="multipart/form-data">
    <input type="file" name="myfile" />
    <input type="submit" name="submit" value="Upload" />
</form>

qui vous donnera le bouton browse, un bouton upload pour lancer l'action (soumettre le formulaire) et noter l'enctype so Django sait vous donner request.FILES

dans une vue quelque part, vous pouvez accéder au fichier avec

def myview(request):
    request.FILES['myfile'] # this is my file

Il ya une énorme quantité d'informations dans le fichier upload docs

je vous recommande de lire attentivement la page et il suffit de commencer à écrire le code - puis revenir avec des exemples et empiler des traces quand il ne fonctionne pas.

Démo

mise à Jour de Akseli Palén la réponse de . voir le GitHub repo , œuvres avec Django 2

Un minimum de Django upload de fichier exemple

1. Créer un projet django

Exécuter startproject::

$ django-admin.py startproject sample

maintenant un dossier ( échantillon ) est créé::

sample/
  manage.py
  sample/
    __init__.py
    settings.py
    urls.py
    wsgi.py 

2. créer une application

créer une application::

$ cd sample
$ python manage.py startapp uploader

Maintenant un dossier( uploader ) avec ces fichiers sont créés::

uploader/
  __init__.py
  admin.py
  app.py
  models.py
  tests.py
  views.py
  migrations/
    __init__.py

3. Mise à jour settings.py

sur sample/settings.py ajouter 'uploader.apps.UploaderConfig' à INSTALLED_APPS et ajouter MEDIA_ROOT et MEDIA_URL , c'est-à-dire:

INSTALLED_APPS = [
    ...<other apps>...
    'uploader.apps.UploaderConfig',
]

MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'

4. Mise à jour urls.py

dans sample/urls.py ajouter::

...<other imports>...
from django.conf import settings
from django.conf.urls.static import static
from uploader import views as uploader_views

urlpatterns = [
    ...<other url patterns>...
    path('', uploader_views.home, name='imageupload'),
]+ static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

5. Mise à jour models.py

mise à jour uploader/models.py ::

from django.db import models
from django.forms import ModelForm

class Upload(models.Model):
    pic = models.FileField(upload_to="images/")    
    upload_date=models.DateTimeField(auto_now_add =True)

# FileUpload form class.
class UploadForm(ModelForm):
    class Meta:
        model = Upload
        fields = ('pic',)

6. Mise à jour views.py

mise à jour uploader/views.py ::

from django.shortcuts import render
from uploader.models import UploadForm,Upload
from django.http import HttpResponseRedirect
from django.urls import reverse
# Create your views here.
def home(request):
    if request.method=="POST":
        img = UploadForm(request.POST, request.FILES)       
        if img.is_valid():
            img.save()  
            return HttpResponseRedirect(reverse('imageupload'))
    else:
        img=UploadForm()
    images=Upload.objects.all().order_by('-upload_date')
    return render(request,'home.html',{'form':img,'images':images})

7. créer des modèles

Créer un dossier modèles dans le dossier uploader , puis créez un fichier maison.html , c'est à dire sample/uploader/templates/home.html ::

<div style="padding:40px;margin:40px;border:1px solid #ccc">
    <h1>picture</h1>
    <form action="#" method="post" enctype="multipart/form-data">
        {% csrf_token %} {{form}} 
        <input type="submit" value="Upload" />
    </form>
    {% for img in images %}
        {{forloop.counter}}.<a href="{{ img.pic.url }}">{{ img.pic.name }}</a>
        ({{img.upload_date}})<hr />
    {% endfor %}
</div>

8. Synchroniser la base de données

Synchroniser la base de données et runserver::

$ python manage.py makemigrations
$ python manage.py migrate
$ python manage.py runserver

visit http://localhost.com:8000

je dois dire que je trouve la documentation à django confuse. Aussi pour l'exemple le plus simple pourquoi sont des formes d'être mentionné? L'exemple que j'ai eu à travailler dans le views.py est :-

for key, file in request.FILES.items():
    path = file.name
    dest = open(path, 'w')
    if file.multiple_chunks:
        for c in file.chunks():
            dest.write(c)
    else:
        dest.write(file.read())
    dest.close()

le fichier html ressemble au code ci-dessous, bien que cet exemple ne télécharge qu'un fichier et que le code pour enregistrer les fichiers en gère beaucoup: -

<form action="/upload_file/" method="post" enctype="multipart/form-data">{% csrf_token %}
<label for="file">Filename:</label>
<input type="file" name="file" id="file" />
<br />
<input type="submit" name="submit" value="Submit" />
</form>

ces exemples ne sont pas mon code, ils ont été tirés de deux autres exemples que j'ai trouvés. Je suis un parent débutant à django donc il est très probable que je manque un point clé.

s'Étendant sur de Henry exemple :

import tempfile
import shutil

FILE_UPLOAD_DIR = '/home/imran/uploads'

def handle_uploaded_file(source):
    fd, filepath = tempfile.mkstemp(prefix=source.name, dir=FILE_UPLOAD_DIR)
    with open(filepath, 'wb') as dest:
        shutil.copyfileobj(source, dest)
    return filepath

vous pouvez appeler cette fonction handle_uploaded_file de votre point de vue avec l'objet fichier téléchargé. Cela permettra de sauvegarder le fichier avec un nom unique (préfixé avec le nom du fichier d'origine téléchargé) dans le système de fichiers et de retourner le chemin complet du fichier sauvegardé. Vous pouvez enregistrer le chemin dans la base de données, et faire quelque chose avec le fichier plus tard.

j'avais également l'exigence similaire. La plupart des exemples sur net demandent de créer des modèles et des formes que je ne voulais pas utiliser. Voici mon code final.

if request.method == 'POST':
    file1 = request.FILES['file']
    contentOfFile = file1.read()
    if file1:
        return render(request, 'blogapp/Statistics.html', {'file': file1, 'contentOfFile': contentOfFile})

et en HTML pour télécharger j'ai écrit:

{% block content %}
    <h1>File content</h1>
    <form action="{% url 'blogapp:uploadComplete'%}" method="post" enctype="multipart/form-data">
         {% csrf_token %}
        <input id="uploadbutton" type="file" value="Browse" name="file" accept="text/csv" />
        <input type="submit" value="Upload" />
    </form>
    {% endblock %}

suit le HTML qui affiche le contenu du fichier:

{% block content %}
    <h3>File uploaded successfully</h3>
    {{file.name}}
    </br>content = {{contentOfFile}}
{% endblock %}

ici, il peut vous aider: créer un champ fichier dans votre models.py

pour télécharger le fichier(dans votre admin.py):

def save_model(self, request, obj, form, change):
    url = "http://img.youtube.com/vi/%s/hqdefault.jpg" %(obj.video)
    url = str(url)

    if url:
        temp_img = NamedTemporaryFile(delete=True)
        temp_img.write(urllib2.urlopen(url).read())
        temp_img.flush()
        filename_img = urlparse(url).path.split('/')[-1]
        obj.image.save(filename_img,File(temp_img)

et utilisez ce champ dans votre modèle.

vous pouvez vous référer à des exemples de serveur dans Fin Uploader, qui a la version django. https://github.com/FineUploader/server-examples/tree/master/python/django-fine-uploader

c'est très élégant et le plus important de tous, il offre featured js lib. Template n'est pas inclus dans server-examples, mais vous pouvez trouver demo sur son site web. Uploader fin: http://fineuploader.com/demos.html

django-fine-uploader

views.py

UploadView les dépêches de la poste et supprimer la demande pour les différents gestionnaires.

class UploadView(View):

    @csrf_exempt
    def dispatch(self, *args, **kwargs):
        return super(UploadView, self).dispatch(*args, **kwargs)

    def post(self, request, *args, **kwargs):
        """A POST request. Validate the form and then handle the upload
        based ont the POSTed data. Does not handle extra parameters yet.
        """
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            handle_upload(request.FILES['qqfile'], form.cleaned_data)
            return make_response(content=json.dumps({ 'success': True }))
        else:
            return make_response(status=400,
                content=json.dumps({
                    'success': False,
                    'error': '%s' % repr(form.errors)
                }))

    def delete(self, request, *args, **kwargs):
        """A DELETE request. If found, deletes a file with the corresponding
        UUID from the server's filesystem.
        """
        qquuid = kwargs.get('qquuid', '')
        if qquuid:
            try:
                handle_deleted_file(qquuid)
                return make_response(content=json.dumps({ 'success': True }))
            except Exception, e:
                return make_response(status=400,
                    content=json.dumps({
                        'success': False,
                        'error': '%s' % repr(e)
                    }))
        return make_response(status=404,
            content=json.dumps({
                'success': False,
                'error': 'File not present'
            }))

forms.py

class UploadFileForm(forms.Form):

    """ This form represents a basic request from Fine Uploader.
    The required fields will **always** be sent, the other fields are optional
    based on your setup.
    Edit this if you want to add custom parameters in the body of the POST
    request.
    """
    qqfile = forms.FileField()
    qquuid = forms.CharField()
    qqfilename = forms.CharField()
    qqpartindex = forms.IntegerField(required=False)
    qqchunksize = forms.IntegerField(required=False)
    qqpartbyteoffset = forms.IntegerField(required=False)
    qqtotalfilesize = forms.IntegerField(required=False)
    qqtotalparts = forms.IntegerField(required=False)

pas sûr s'il y a des inconvénients à cette approche, mais encore plus minime, en views.py:

entry = form.save()

# save uploaded file
if request.FILES['myfile']:
    entry.myfile.save(request.FILES['myfile']._name, request.FILES['myfile'], True)

j'ai fait face au même problème, et résolu par le site admin django.

# models
class Document(models.Model):
    docfile = models.FileField(upload_to='documents/Temp/%Y/%m/%d')

    def doc_name(self):
        return self.docfile.name.split('/')[-1] # only the name, not full path

# admin
from myapp.models import Document
class DocumentAdmin(admin.ModelAdmin):
    list_display = ('doc_name',)
admin.site.register(Document, DocumentAdmin)