Ogólnie mówiąc, kiedy próbujesz "po prostu uzyskać działający przykład", najlepiej "po prostu zacząć pisać kod". Nie ma tu kodu, który mógłby ci pomóc, więc odpowiedź na to pytanie jest dla nas o wiele bardziej przydatna.

Jeśli chcesz pobrać plik, potrzebujesz czegoś takiego w pliku html:

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

To da ci przycisk Przeglądaj, przycisk wysyłania, aby rozpocząć akcję (Prześlij formularz) i zanotować enctype, aby Django wiedział, że da ci request.FILES

W zobacz gdzie możesz uzyskać dostęp do pliku za pomocą

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

Istnieje ogromna ilość informacji w dokumenty wysyłania plików

Zalecam dokładne przeczytanie strony i po prostu zacznij pisać kod - potem wróć z przykładami i stosuj ślady, gdy nie działa.

Demo

Zobacz github repo , Działa z Django 3

Minimalny przykład przesłania pliku Django

1. Tworzenie projektu django

Uruchom startproject::

$ django-admin.py startproject sample

Teraz tworzony jest folder (sample ).

2. tworzenie aplikacji

Tworzenie aplikacji::

$ cd sample
$ python manage.py startapp uploader

Teraz tworzony jest folder (uploader) z tymi plikami::

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

3. Aktualizacja settings.py

On sample/settings.py add 'uploader' to INSTALLED_APPS and dodaj MEDIA_ROOT i MEDIA_URL, czyli:

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

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

4. Aktualizacja urls.py

W sample/urls.py dodaj::

...<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.UploadView.as_view(), name='fileupload'),
]+ static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

5. Aktualizacja models.py

Update uploader/models.py::

from django.db import models
class Upload(models.Model):
    upload_file = models.FileField()    
    upload_date = models.DateTimeField(auto_now_add =True)

6. Aktualizacja views.py

Update uploader/views.py::

from django.views.generic.edit import CreateView
from django.urls import reverse_lazy
from .models import Upload
class UploadView(CreateView):
    model = Upload
    fields = ['upload_file', ]
    success_url = reverse_lazy('fileupload')
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['documents'] = Upload.objects.all()
        return context

7. tworzenie szablonów

Utwórz folder sample / uploader / templates / uploader

Utwórz plik upload_form.html ie sample/uploader/templates/uploader/upload_form.html::

<div style="padding:40px;margin:40px;border:1px solid #ccc">
    <h1>Django File Upload</h1>
    <form method="post" enctype="multipart/form-data">
      {% csrf_token %}
      {{ form.as_p }}
      <button type="submit">Submit</button>
    </form><hr>
    <ul>
    {% for document in documents %}
        <li>
            <a href="{{ document.upload_file.url }}">{{ document.upload_file.name }}</a>
            <small>({{ document.upload_file.size|filesizeformat }}) - {{document.upload_date}}</small>
        </li>
    {% endfor %}
    </ul>
</div>

8. Syncronize database

Synchronizacja bazy danych i runserver::

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

Wizyta http://localhost:8000/

Muszę powiedzieć, że dokumentacja w django jest myląca. Również dla najprostszego przykładu, dlaczego wymienia się formy? Przykład mam do pracy w views.py jest: -

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()

Plik html wygląda jak poniższy kod, chociaż ten przykład przesyła tylko jeden plik, a kod do zapisania plików obsługuje wiele : -

<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>

Te przykłady nie są moim kodem, zostały wybrane z dwóch innych przykładów, które znalazłem. Jestem początkującym relatywnie django więc jest bardzo prawdopodobne, że brakuje mi jakiś kluczowy punkt.

Ja też miałem podobne wymagania. Większość przykładów w sieci prosi o tworzenie modeli i formularzy, których nie chciałem używać. Oto mój ostatni kod.

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

A w HTML do uploadu napisałem:

{% 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 %}

Poniżej znajduje się HTML, który wyświetla zawartość pliku:

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

Rozszerzenie na Przykład Henry ' ego :

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

Możesz wywołać tę funkcję handle_uploaded_file z widoku z przesłanym obiektem pliku. Spowoduje to zapisanie pliku o unikalnej nazwie (poprzedzonej nazwą oryginalnego przesłanego pliku) w systemie plików i zwróci pełną ścieżkę zapisanego pliku. Możesz zapisać ścieżkę w bazie danych i zrobić coś z plikiem później.

Tutaj może Ci pomóc: Utwórz pole pliku w swoim models.py

Do wgrywania pliku(w Twoim 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)

I użyj tego pola również w szablonie.

Możesz odwoływać się do przykładów serwerów w Fine Uploader, który ma wersję django. https://github.com/FineUploader/server-examples/tree/master/python/django-fine-uploader

Jest bardzo elegancki i co najważniejsze, zapewnia funkcjonalny js lib. Szablon nie jest zawarty w server-examples, ale można znaleźć demo na jego stronie internetowej. Fine Uploader: http://fineuploader.com/demos.html

Django-fine-uploader

Views.py

UploadView wysyła żądanie post i delete do odpowiednich podmiotów obsługujących.

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)

Nie wiem, czy są jakieś wady tego podejścia, ale jeszcze bardziej minimalne, w views.py:

entry = form.save()

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

Spotkałem się z podobnym problemem i rozwiązałem go przez django admin site.

# 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)