“Django/docs/2.2.x/ref/files/uploads”的版本间差异

来自菜鸟教程
Django/docs/2.2.x/ref/files/uploads
跳转至:导航、​搜索
(autoload)
 
(Page commit)
 
第1行: 第1行:
 +
{{DISPLAYTITLE:上传文件和上传处理程序 — Django 文档}}
 
<div id="module-django.core.files.uploadedfile" class="section">
 
<div id="module-django.core.files.uploadedfile" class="section">
  
 
<span id="uploaded-files-and-upload-handlers"></span>
 
<span id="uploaded-files-and-upload-handlers"></span>
= Uploaded Files and Upload Handlers =
+
= 上传的文件和上传处理程序 =
  
 
<div id="uploaded-files" class="section">
 
<div id="uploaded-files" class="section">
  
== Uploaded files ==
+
== 上传的文件 ==
  
; ''class'' <code>UploadedFile</code>[[../../_modules/django/core/files/uploadedfile.html#UploadedFile|<span class="viewcode-link">[源代码]</span>]]
+
; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">UploadedFile</span></span>
 
:  
 
:  
  
During file uploads, the actual file data is stored in [[../../request-response#django.http.HttpRequest|<code>request.FILES</code>]]. Each entry in this dictionary is an
+
在文件上传过程中,实际文件数据存储在 [[../../request-response#django.http.HttpRequest|request.FILES]] 中。 这本字典中的每个条目都是一个 <code>UploadedFile</code> 对象(或一个子类)——一个上传文件的简单包装器。 您通常会使用以下方法之一来访问上传的内容:
<code>UploadedFile</code> object (or a subclass) -- a simple wrapper around an uploaded
 
file. You'll usually use one of these methods to access the uploaded content:
 
  
; <code>UploadedFile.</code><code>read</code><span class="sig-paren">(</span><span class="sig-paren">)</span>
+
; <span class="sig-prename descclassname"><span class="pre">UploadedFile.</span></span><span class="sig-name descname"><span class="pre">read</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span>
: Read the entire uploaded data from the file. Be careful with this method: if the uploaded file is huge it can overwhelm your system if you try to read it into memory. You'll probably want to use <code>chunks()</code> instead; see below.
+
: 从文件中读取整个上传的数据。 小心使用这种方法:如果上传的文件很大,如果您尝试将其读入内存,它可能会使您的系统不堪重负。 你可能想用 <code>chunks()</code> 代替; 见下文。
  
; <code>UploadedFile.</code><code>multiple_chunks</code><span class="sig-paren">(</span>''<span class="n">chunk_size</span><span class="o">=</span><span class="default_value">None</span>''<span class="sig-paren">)</span>
+
; <span class="sig-prename descclassname"><span class="pre">UploadedFile.</span></span><span class="sig-name descname"><span class="pre">multiple_chunks</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">chunk_size</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>''<span class="sig-paren">)</span>
: Returns <code>True</code> if the uploaded file is big enough to require reading in multiple chunks. By default this will be any file larger than 2.5 megabytes, but that's configurable; see below.
+
: 如果上传的文件大到需要读取多个块,则返回 <code>True</code>。 默认情况下,这将是大于 2.5 兆字节的任何文件,但这是可配置的; 见下文。
  
 
<dl>
 
<dl>
<dt><code>UploadedFile.</code><code>chunks</code><span class="sig-paren">(</span>''<span class="n">chunk_size</span><span class="o">=</span><span class="default_value">None</span>''<span class="sig-paren">)</span></dt>
+
<dt><span class="sig-prename descclassname"><span class="pre">UploadedFile.</span></span><span class="sig-name descname"><span class="pre">chunks</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">chunk_size</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span>''<span class="sig-paren">)</span></dt>
<dd><p>A generator returning chunks of the file. If <code>multiple_chunks()</code> is
+
<dd><p>返回文件块的生成器。 如果 <code>multiple_chunks()</code> <code>True</code>,则应在循环中使用此方法而不是 <code>read()</code></p>
<code>True</code>, you should use this method in a loop instead of <code>read()</code>.</p>
+
<p>在实践中,最简单的方法通常是一直使用 <code>chunks()</code>。 循环使用 <code>chunks()</code> 而不是使用 <code>read()</code> 可确保大文件不会占用系统内存。</p></dd></dl>
<p>In practice, it's often easiest simply to use <code>chunks()</code> all the time.
 
Looping over <code>chunks()</code> instead of using <code>read()</code> ensures that large
 
files don't overwhelm your system's memory.</p></dd></dl>
 
  
Here are some useful attributes of <code>UploadedFile</code>:
+
以下是 <code>UploadedFile</code> 的一些有用属性:
  
; <code>UploadedFile.</code><code>name</code>
+
; <span class="sig-prename descclassname"><span class="pre">UploadedFile.</span></span><span class="sig-name descname"><span class="pre">name</span></span>
: The name of the uploaded file (e.g. <code>my_file.txt</code>).
+
: 上传文件的名称(例如 <code>my_file.txt</code>)。
  
; <code>UploadedFile.</code><code>size</code>
+
; <span class="sig-prename descclassname"><span class="pre">UploadedFile.</span></span><span class="sig-name descname"><span class="pre">size</span></span>
: The size, in bytes, of the uploaded file.
+
: 上传文件的大小,以字节为单位。
  
; <code>UploadedFile.</code><code>content_type</code>
+
; <span class="sig-prename descclassname"><span class="pre">UploadedFile.</span></span><span class="sig-name descname"><span class="pre">content_type</span></span>
: The content-type header uploaded with the file (e.g. ''text/plain'' or ''application/pdf''). Like any data supplied by the user, you shouldn't trust that the uploaded file is actually this type. You'll still need to validate that the file contains the content that the content-type header claims -- &quot;trust but verify.&quot;
+
: 随文件上传的内容类型标头(例如 ''text/plain'' ''application/pdf'')。 与用户提供的任何数据一样,您不应该相信上传的文件实际上是这种类型。 您仍然需要验证文件是否包含内容类型标头声明的内容 - “信任但验证”。
  
; <code>UploadedFile.</code><code>content_type_extra</code>
+
; <span class="sig-prename descclassname"><span class="pre">UploadedFile.</span></span><span class="sig-name descname"><span class="pre">content_type_extra</span></span>
: A dictionary containing extra parameters passed to the <code>content-type</code> header. This is typically provided by services, such as Google App Engine, that intercept and handle file uploads on your behalf. As a result your handler may not receive the uploaded file content, but instead a URL or other pointer to the file. (see [https://www.ietf.org/rfc/rfc2388.txt RFC 2388] section 5.3).
+
: 包含传递给 <code>content-type</code> 标头的额外参数的字典。 这通常由代表您拦截和处理文件上传的服务(例如 Google App Engine)提供。 因此,您的处理程序可能不会收到上传的文件内容,而是收到文件的 URL 或其他指针。 (参见 [https://www.ietf.org/rfc/rfc2388.txt RFC 2388] 5.3 节)。
  
; <code>UploadedFile.</code><code>charset</code>
+
; <span class="sig-prename descclassname"><span class="pre">UploadedFile.</span></span><span class="sig-name descname"><span class="pre">charset</span></span>
: For ''text/*'' content-types, the character set (i.e. <code>utf8</code>) supplied by the browser. Again, &quot;trust but verify&quot; is the best policy here.
+
: 对于 ''text/*'' 内容类型,字符集(即 <code>utf8</code>) 由浏览器提供。 同样,“信任但验证”是这里的最佳策略。
  
 
<div class="admonition note">
 
<div class="admonition note">
  
注解
+
笔记
  
Like regular Python files, you can read the file line-by-line simply by
+
像普通的 Python 文件一样,你可以通过迭代上传的文件来逐行读取文件:
iterating over the uploaded file:
 
  
 
<div class="highlight-python notranslate">
 
<div class="highlight-python notranslate">
第57行: 第52行:
 
<div class="highlight">
 
<div class="highlight">
  
<pre>for line in uploadedfile:
+
<syntaxhighlight lang="python">for line in uploadedfile:
     do_something_with(line)</pre>
+
     do_something_with(line)</syntaxhighlight>
  
 
</div>
 
</div>
  
 
</div>
 
</div>
Lines are split using [https://www.python.org/dev/peps/pep-0278 universal newlines]. The following are recognized
+
使用 [https://www.python.org/dev/peps/pep-0278 通用换行符] 拆分行。 以下被认为是行尾:Unix 行尾约定 <code>'\n'</code>、Windows 约定 <code>'\r\n'</code> 和旧的 Macintosh 约定 <code>'\r'</code>
as ending a line: the Unix end-of-line convention <code>'\n'</code>, the Windows
 
convention <code>'\r\n'</code>, and the old Macintosh convention <code>'\r'</code>.
 
  
  
 
</div>
 
</div>
Subclasses of <code>UploadedFile</code> include:
+
<code>UploadedFile</code> 的子类包括:
  
; ''class'' <code>TemporaryUploadedFile</code>[[../../_modules/django/core/files/uploadedfile.html#TemporaryUploadedFile|<span class="viewcode-link">[源代码]</span>]]
+
; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">TemporaryUploadedFile</span></span>
: A file uploaded to a temporary location (i.e. stream-to-disk). This class is used by the [[#django.core.files.uploadhandler.TemporaryFileUploadHandler|<code>TemporaryFileUploadHandler</code>]]. In addition to the methods from [[#django.core.files.uploadedfile.UploadedFile|<code>UploadedFile</code>]], it has one additional method:
+
: 上传到临时位置的文件(即 流到磁盘)。 此类由 [[#django.core.files.uploadhandler.TemporaryFileUploadHandler|TemporaryFileUploadHandler]] 使用。 除了 [[#django.core.files.uploadedfile.UploadedFile|UploadedFile]] 中的方法,它还有一个额外的方法:
  
; <code>TemporaryUploadedFile.</code><code>temporary_file_path</code><span class="sig-paren">(</span><span class="sig-paren">)</span>[[../../_modules/django/core/files/uploadedfile.html#TemporaryUploadedFile.temporary_file_path|<span class="viewcode-link">[源代码]</span>]]
+
; <span class="sig-prename descclassname"><span class="pre">TemporaryUploadedFile.</span></span><span class="sig-name descname"><span class="pre">temporary_file_path</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span>
: Returns the full path to the temporary uploaded file.
+
: 返回临时上传文件的完整路径。
  
; ''class'' <code>InMemoryUploadedFile</code>[[../../_modules/django/core/files/uploadedfile.html#InMemoryUploadedFile|<span class="viewcode-link">[源代码]</span>]]
+
; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">InMemoryUploadedFile</span></span>
: A file uploaded into memory (i.e. stream-to-memory). This class is used by the [[#django.core.files.uploadhandler.MemoryFileUploadHandler|<code>MemoryFileUploadHandler</code>]].
+
: 上传到内存中的文件(即 流到内存)。 此类由 [[#django.core.files.uploadhandler.MemoryFileUploadHandler|MemoryFileUploadHandler]] 使用。
  
  
第85行: 第78行:
  
 
<span id="built-in-upload-handlers"></span>
 
<span id="built-in-upload-handlers"></span>
== Built-in upload handlers ==
+
== 内置上传处理程序 ==
  
Together the [[#django.core.files.uploadhandler.MemoryFileUploadHandler|<code>MemoryFileUploadHandler</code>]] and
+
[[#django.core.files.uploadhandler.MemoryFileUploadHandler|MemoryFileUploadHandler]] [[#django.core.files.uploadhandler.TemporaryFileUploadHandler|TemporaryFileUploadHandler]] 一起提供了 Django 的默认文件上传行为,将小文件读入内存,将大文件读入磁盘。 它们位于 <code>django.core.files.uploadhandler</code>
[[#django.core.files.uploadhandler.TemporaryFileUploadHandler|<code>TemporaryFileUploadHandler</code>]] provide Django's default file upload
 
behavior of reading small files into memory and large ones onto disk. They
 
are located in <code>django.core.files.uploadhandler</code>.
 
  
; ''class'' <code>MemoryFileUploadHandler</code>[[../../_modules/django/core/files/uploadhandler.html#MemoryFileUploadHandler|<span class="viewcode-link">[源代码]</span>]]
+
; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">MemoryFileUploadHandler</span></span>
 
:  
 
:  
  
File upload handler to stream uploads into memory (used for small files).
+
文件上传处理程序,将上传的文件以流式传输到内存中(用于小文件)。
  
; ''class'' <code>TemporaryFileUploadHandler</code>[[../../_modules/django/core/files/uploadhandler.html#TemporaryFileUploadHandler|<span class="viewcode-link">[源代码]</span>]]
+
; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">TemporaryFileUploadHandler</span></span>
 
:  
 
:  
  
Upload handler that streams data into a temporary file using
+
使用 [[#django.core.files.uploadedfile.TemporaryUploadedFile|TemporaryUploadedFile]] 将数据流式传输到临时文件的上传处理程序。
[[#django.core.files.uploadedfile.TemporaryUploadedFile|<code>TemporaryUploadedFile</code>]].
 
  
  
第108行: 第97行:
  
 
<span id="custom-upload-handlers"></span>
 
<span id="custom-upload-handlers"></span>
== Writing custom upload handlers ==
+
== 编写自定义上传处理程序 ==
  
; ''class'' <code>FileUploadHandler</code>[[../../_modules/django/core/files/uploadhandler.html#FileUploadHandler|<span class="viewcode-link">[源代码]</span>]]
+
; ''<span class="pre">class</span>'' <span class="sig-name descname"><span class="pre">FileUploadHandler</span></span>
 
:  
 
:  
  
All file upload handlers should be subclasses of
+
所有文件上传处理程序都应该是 <code>django.core.files.uploadhandler.FileUploadHandler</code> 的子类。 您可以在任何地方定义上传处理程序。
<code>django.core.files.uploadhandler.FileUploadHandler</code>. You can define upload
 
handlers wherever you wish.
 
  
 
<div id="required-methods" class="section">
 
<div id="required-methods" class="section">
  
=== Required methods ===
+
=== 必要方法 ===
  
Custom file upload handlers '''must''' define the following methods:
+
自定义文件上传处理程序 '''必须''' 定义以下方法:
  
 
<dl>
 
<dl>
<dt><code>FileUploadHandler.</code><code>receive_data_chunk</code><span class="sig-paren">(</span>''<span class="n">raw_data</span>'', ''<span class="n">start</span>''<span class="sig-paren">)</span>[[../../_modules/django/core/files/uploadhandler.html#FileUploadHandler.receive_data_chunk|<span class="viewcode-link">[源代码]</span>]]</dt>
+
<dt><span class="sig-prename descclassname"><span class="pre">FileUploadHandler.</span></span><span class="sig-name descname"><span class="pre">receive_data_chunk</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">raw_data</span></span>'', ''<span class="n"><span class="pre">start</span></span>''<span class="sig-paren">)</span></dt>
<dd><p>Receives a &quot;chunk&quot; of data from the file upload.</p>
+
<dd><p>从文件上传接收数据“块”。</p>
<p><code>raw_data</code> is a bytestring containing the uploaded data.</p>
+
<p><code>raw_data</code> 是包含上传数据的字节串。</p>
<p><code>start</code> is the position in the file where this <code>raw_data</code> chunk
+
<p><code>start</code> 是文件中这个 <code>raw_data</code> 块开始的位置。</p>
begins.</p>
+
<p>您返回的数据将被输入到后续上传处理程序的 <code>receive_data_chunk</code> 方法中。 这样,一个处理程序可以成为其他处理程序的“过滤器”。</p>
<p>The data you return will get fed into the subsequent upload handlers'
+
<p><code>receive_data_chunk</code> 返回 <code>None</code> 以短路剩余的上传处理程序以获取此块。 如果您自己存储上传的数据并且不希望将来的处理程序存储数据的副本,这将非常有用。</p>
<code>receive_data_chunk</code> methods. In this way, one handler can be a
+
<p>如果您引发 <code>StopUpload</code> <code>SkipFile</code> 异常,上传将中止或文件将被完全跳过。</p></dd></dl>
&quot;filter&quot; for other handlers.</p>
 
<p>Return <code>None</code> from <code>receive_data_chunk</code> to short-circuit remaining
 
upload handlers from getting this chunk. This is useful if you're
 
storing the uploaded data yourself and don't want future handlers to
 
store a copy of the data.</p>
 
<p>If you raise a <code>StopUpload</code> or a <code>SkipFile</code> exception, the upload
 
will abort or the file will be completely skipped.</p></dd></dl>
 
  
 
<dl>
 
<dl>
<dt><code>FileUploadHandler.</code><code>file_complete</code><span class="sig-paren">(</span>''<span class="n">file_size</span>''<span class="sig-paren">)</span>[[../../_modules/django/core/files/uploadhandler.html#FileUploadHandler.file_complete|<span class="viewcode-link">[源代码]</span>]]</dt>
+
<dt><span class="sig-prename descclassname"><span class="pre">FileUploadHandler.</span></span><span class="sig-name descname"><span class="pre">file_complete</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">file_size</span></span>''<span class="sig-paren">)</span></dt>
<dd><p>Called when a file has finished uploading.</p>
+
<dd><p>当文件上传完毕时调用。</p>
<p>The handler should return an <code>UploadedFile</code> object that will be stored
+
<p>处理程序应返回一个 <code>UploadedFile</code> 对象,该对象将存储在 <code>request.FILES</code> 中。 处理程序也可能返回 <code>None</code> 以指示 <code>UploadedFile</code> 对象应该来自后续上传处理程序。</p></dd></dl>
in <code>request.FILES</code>. Handlers may also return <code>None</code> to indicate that
 
the <code>UploadedFile</code> object should come from subsequent upload handlers.</p></dd></dl>
 
  
  
第150行: 第128行:
 
<div id="optional-methods" class="section">
 
<div id="optional-methods" class="section">
  
=== Optional methods ===
+
=== 可选方法 ===
  
Custom upload handlers may also define any of the following optional methods or
+
自定义上传处理程序也可以定义以下任何一个可选方法或属性:
attributes:
 
  
 
<dl>
 
<dl>
<dt><code>FileUploadHandler.</code><code>chunk_size</code></dt>
+
<dt><span class="sig-prename descclassname"><span class="pre">FileUploadHandler.</span></span><span class="sig-name descname"><span class="pre">chunk_size</span></span></dt>
<dd><p>Size, in bytes, of the &quot;chunks&quot; Django should store into memory and feed
+
<dd><p>“块”的大小,以字节为单位,Django 应该存储到内存中并输入处理程序。 也就是说,该属性控制送入 <code>FileUploadHandler.receive_data_chunk</code> 的块的大小。</p>
into the handler. That is, this attribute controls the size of chunks
+
<p>为了获得最佳性能,块大小应可被 <code>4</code> 整除,并且大小不应超过 2 GB(2<sup>31</sup> 字节)。 当多个处理程序提供多个块大小时,Django 将使用任何处理程序定义的最小块大小。</p>
fed into <code>FileUploadHandler.receive_data_chunk</code>.</p>
+
<p>默认为 64*2<sup>10</sup> 字节,或 64 KB。</p></dd></dl>
<p>For maximum performance the chunk sizes should be divisible by <code>4</code> and
 
should not exceed 2 GB (2<sup>31</sup> bytes) in size. When there are
 
multiple chunk sizes provided by multiple handlers, Django will use the
 
smallest chunk size defined by any handler.</p>
 
<p>The default is 64*2<sup>10</sup> bytes, or 64 KB.</p></dd></dl>
 
  
 
<dl>
 
<dl>
<dt><code>FileUploadHandler.</code><code>new_file</code><span class="sig-paren">(</span>''<span class="n">field_name</span>'', ''<span class="n">file_name</span>'', ''<span class="n">content_type</span>'', ''<span class="n">content_length</span>'', ''<span class="n">charset</span>'', ''<span class="n">content_type_extra</span>''<span class="sig-paren">)</span>[[../../_modules/django/core/files/uploadhandler.html#FileUploadHandler.new_file|<span class="viewcode-link">[源代码]</span>]]</dt>
+
<dt><span class="sig-prename descclassname"><span class="pre">FileUploadHandler.</span></span><span class="sig-name descname"><span class="pre">new_file</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">field_name</span></span>'', ''<span class="n"><span class="pre">file_name</span></span>'', ''<span class="n"><span class="pre">content_type</span></span>'', ''<span class="n"><span class="pre">content_length</span></span>'', ''<span class="n"><span class="pre">charset</span></span>'', ''<span class="n"><span class="pre">content_type_extra</span></span>''<span class="sig-paren">)</span></dt>
<dd><p>Callback signaling that a new file upload is starting. This is called
+
<dd><p>新文件上传开始的回调信号。 在将任何数据馈送到任何上传处理程序之前调用此方法。</p>
before any data has been fed to any upload handlers.</p>
+
<p><code>field_name</code> 是文件 <code>&lt;input&gt;</code> 字段的字符串名称。</p>
<p><code>field_name</code> is a string name of the file <code>&lt;input&gt;</code> field.</p>
+
<p><code>file_name</code> 是浏览器提供的文件名。</p>
<p><code>file_name</code> is the filename provided by the browser.</p>
+
<p><code>content_type</code> 是浏览器提供的 MIME 类型 - 例如 <code>'image/jpeg'</code></p>
<p><code>content_type</code> is the MIME type provided by the browser -- E.g.
+
<p><code>content_length</code> 是浏览器给出的图片长度。 有时这不会被提供,而是 <code>None</code></p>
<code>'image/jpeg'</code>.</p>
+
<p><code>charset</code> 是字符集(即 <code>utf8</code>) 由浏览器给出。 像 <code>content_length</code> 一样,有时不会提供。</p>
<p><code>content_length</code> is the length of the image given by the browser.
+
<p><code>content_type_extra</code> 是来自 <code>content-type</code> 头文件的额外信息。 参见 [[#django.core.files.uploadedfile.UploadedFile.content_type_extra|UploadedFile.content_type_extra]]</p>
Sometimes this won't be provided and will be <code>None</code>.</p>
+
<p>此方法可能会引发 <code>StopFutureHandlers</code> 异常以防止将来的处理程序处理此文件。</p></dd></dl>
<p><code>charset</code> is the character set (i.e. <code>utf8</code>) given by the browser.
 
Like <code>content_length</code>, this sometimes won't be provided.</p>
 
<p><code>content_type_extra</code> is extra information about the file from the
 
<code>content-type</code> header. See [[#django.core.files.uploadedfile.UploadedFile.content_type_extra|<code>UploadedFile.content_type_extra</code>]].</p>
 
<p>This method may raise a <code>StopFutureHandlers</code> exception to prevent
 
future handlers from handling this file.</p></dd></dl>
 
  
; <code>FileUploadHandler.</code><code>upload_complete</code><span class="sig-paren">(</span><span class="sig-paren">)</span>[[../../_modules/django/core/files/uploadhandler.html#FileUploadHandler.upload_complete|<span class="viewcode-link">[源代码]</span>]]
+
; <span class="sig-prename descclassname"><span class="pre">FileUploadHandler.</span></span><span class="sig-name descname"><span class="pre">upload_complete</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span>
: Callback signaling that the entire upload (all files) has completed.
+
: 回调信号,表示整个上传(所有文件)已经完成。
  
 
<dl>
 
<dl>
<dt><code>FileUploadHandler.</code><code>handle_raw_input</code><span class="sig-paren">(</span>''<span class="n">input_data</span>'', ''<span class="n">META</span>'', ''<span class="n">content_length</span>'', ''<span class="n">boundary</span>'', ''<span class="n">encoding</span>''<span class="sig-paren">)</span>[[../../_modules/django/core/files/uploadhandler.html#FileUploadHandler.handle_raw_input|<span class="viewcode-link">[源代码]</span>]]</dt>
+
<dt><span class="sig-prename descclassname"><span class="pre">FileUploadHandler.</span></span><span class="sig-name descname"><span class="pre">handle_raw_input</span></span><span class="sig-paren">(</span>''<span class="n"><span class="pre">input_data</span></span>'', ''<span class="n"><span class="pre">META</span></span>'', ''<span class="n"><span class="pre">content_length</span></span>'', ''<span class="n"><span class="pre">boundary</span></span>'', ''<span class="n"><span class="pre">encoding</span></span>''<span class="sig-paren">)</span></dt>
<dd><p>Allows the handler to completely override the parsing of the raw
+
<dd><p>允许处理程序完全覆盖原始 HTTP 输入的解析。</p>
HTTP input.</p>
+
<p><code>input_data</code> 是一个类文件对象,支持 <code>read()</code>-ing。</p>
<p><code>input_data</code> is a file-like object that supports <code>read()</code>-ing.</p>
+
<p><code>META</code> <code>request.META</code> 是同一个对象。</p>
<p><code>META</code> is the same object as <code>request.META</code>.</p>
+
<p><code>content_length</code><code>input_data</code>中数据的长度。 不要从 <code>input_data</code> 读取超过 <code>content_length</code> 个字节。</p>
<p><code>content_length</code> is the length of the data in <code>input_data</code>. Don't
+
<p><code>boundary</code> 是此请求的 MIME 边界。</p>
read more than <code>content_length</code> bytes from <code>input_data</code>.</p>
+
<p><code>encoding</code> 是请求的编码。</p>
<p><code>boundary</code> is the MIME boundary for this request.</p>
+
<p>如果要继续上传处理,则返回 <code>None</code>,如果要直接返回适合请求的新数据结构,则返回 <code>(POST, FILES)</code> 元组。</p></dd></dl>
<p><code>encoding</code> is the encoding of the request.</p>
 
<p>Return <code>None</code> if you want upload handling to continue, or a tuple of
 
<code>(POST, FILES)</code> if you want to return the new data structures suitable
 
for the request directly.</p></dd></dl>
 
  
  
第206行: 第168行:
  
 
</div>
 
</div>
 +
<div class="clearer">
  
[[Category:Django 2.2.x 中文文档]]
+
 
 +
 
 +
</div>
 +
 
 +
[[Category:Django 2.2.x 文档]]

2021年10月31日 (日) 04:05的最新版本

上传的文件和上传处理程序

上传的文件

class UploadedFile

在文件上传过程中,实际文件数据存储在 request.FILES 中。 这本字典中的每个条目都是一个 UploadedFile 对象(或一个子类)——一个上传文件的简单包装器。 您通常会使用以下方法之一来访问上传的内容:

UploadedFile.read()
从文件中读取整个上传的数据。 小心使用这种方法:如果上传的文件很大,如果您尝试将其读入内存,它可能会使您的系统不堪重负。 你可能想用 chunks() 代替; 见下文。
UploadedFile.multiple_chunks(chunk_size=None)
如果上传的文件大到需要读取多个块,则返回 True。 默认情况下,这将是大于 2.5 兆字节的任何文件,但这是可配置的; 见下文。
UploadedFile.chunks(chunk_size=None)

返回文件块的生成器。 如果 multiple_chunks()True,则应在循环中使用此方法而不是 read()

在实践中,最简单的方法通常是一直使用 chunks()。 循环使用 chunks() 而不是使用 read() 可确保大文件不会占用系统内存。

以下是 UploadedFile 的一些有用属性:

UploadedFile.name
上传文件的名称(例如 my_file.txt)。
UploadedFile.size
上传文件的大小,以字节为单位。
UploadedFile.content_type
随文件上传的内容类型标头(例如 text/plainapplication/pdf)。 与用户提供的任何数据一样,您不应该相信上传的文件实际上是这种类型。 您仍然需要验证文件是否包含内容类型标头声明的内容 - “信任但验证”。
UploadedFile.content_type_extra
包含传递给 content-type 标头的额外参数的字典。 这通常由代表您拦截和处理文件上传的服务(例如 Google App Engine)提供。 因此,您的处理程序可能不会收到上传的文件内容,而是收到文件的 URL 或其他指针。 (参见 RFC 2388 第 5.3 节)。
UploadedFile.charset
对于 text/* 内容类型,字符集(即 utf8) 由浏览器提供。 同样,“信任但验证”是这里的最佳策略。

笔记

像普通的 Python 文件一样,你可以通过迭代上传的文件来逐行读取文件:

for line in uploadedfile:
    do_something_with(line)

使用 通用换行符 拆分行。 以下被认为是行尾:Unix 行尾约定 '\n'、Windows 约定 '\r\n' 和旧的 Macintosh 约定 '\r'


UploadedFile 的子类包括:

class TemporaryUploadedFile
上传到临时位置的文件(即 流到磁盘)。 此类由 TemporaryFileUploadHandler 使用。 除了 UploadedFile 中的方法,它还有一个额外的方法:
TemporaryUploadedFile.temporary_file_path()
返回临时上传文件的完整路径。
class InMemoryUploadedFile
上传到内存中的文件(即 流到内存)。 此类由 MemoryFileUploadHandler 使用。


内置上传处理程序

MemoryFileUploadHandlerTemporaryFileUploadHandler 一起提供了 Django 的默认文件上传行为,将小文件读入内存,将大文件读入磁盘。 它们位于 django.core.files.uploadhandler

class MemoryFileUploadHandler

文件上传处理程序,将上传的文件以流式传输到内存中(用于小文件)。

class TemporaryFileUploadHandler

使用 TemporaryUploadedFile 将数据流式传输到临时文件的上传处理程序。


编写自定义上传处理程序

class FileUploadHandler

所有文件上传处理程序都应该是 django.core.files.uploadhandler.FileUploadHandler 的子类。 您可以在任何地方定义上传处理程序。

必要方法

自定义文件上传处理程序 必须 定义以下方法:

FileUploadHandler.receive_data_chunk(raw_data, start)

从文件上传接收数据“块”。

raw_data 是包含上传数据的字节串。

start 是文件中这个 raw_data 块开始的位置。

您返回的数据将被输入到后续上传处理程序的 receive_data_chunk 方法中。 这样,一个处理程序可以成为其他处理程序的“过滤器”。

receive_data_chunk 返回 None 以短路剩余的上传处理程序以获取此块。 如果您自己存储上传的数据并且不希望将来的处理程序存储数据的副本,这将非常有用。

如果您引发 StopUploadSkipFile 异常,上传将中止或文件将被完全跳过。

FileUploadHandler.file_complete(file_size)

当文件上传完毕时调用。

处理程序应返回一个 UploadedFile 对象,该对象将存储在 request.FILES 中。 处理程序也可能返回 None 以指示 UploadedFile 对象应该来自后续上传处理程序。


可选方法

自定义上传处理程序也可以定义以下任何一个可选方法或属性:

FileUploadHandler.chunk_size

“块”的大小,以字节为单位,Django 应该存储到内存中并输入处理程序。 也就是说,该属性控制送入 FileUploadHandler.receive_data_chunk 的块的大小。

为了获得最佳性能,块大小应可被 4 整除,并且大小不应超过 2 GB(231 字节)。 当多个处理程序提供多个块大小时,Django 将使用任何处理程序定义的最小块大小。

默认为 64*210 字节,或 64 KB。

FileUploadHandler.new_file(field_name, file_name, content_type, content_length, charset, content_type_extra)

新文件上传开始的回调信号。 在将任何数据馈送到任何上传处理程序之前调用此方法。

field_name 是文件 <input> 字段的字符串名称。

file_name 是浏览器提供的文件名。

content_type 是浏览器提供的 MIME 类型 - 例如 'image/jpeg'

content_length 是浏览器给出的图片长度。 有时这不会被提供,而是 None

charset 是字符集(即 utf8) 由浏览器给出。 像 content_length 一样,有时不会提供。

content_type_extra 是来自 content-type 头文件的额外信息。 参见 UploadedFile.content_type_extra

此方法可能会引发 StopFutureHandlers 异常以防止将来的处理程序处理此文件。

FileUploadHandler.upload_complete()
回调信号,表示整个上传(所有文件)已经完成。
FileUploadHandler.handle_raw_input(input_data, META, content_length, boundary, encoding)

允许处理程序完全覆盖原始 HTTP 输入的解析。

input_data 是一个类文件对象,支持 read()-ing。

METArequest.META 是同一个对象。

content_lengthinput_data中数据的长度。 不要从 input_data 读取超过 content_length 个字节。

boundary 是此请求的 MIME 边界。

encoding 是请求的编码。

如果要继续上传处理,则返回 None,如果要直接返回适合请求的新数据结构,则返回 (POST, FILES) 元组。